Thread es la columna vertebral de multithreading en java. Multithreading es una característica que permite la ejecución simultánea de dos o más partes del programa para la máxima utilización de la CPU. Cada parte de un programa de este tipo se denomina hilo . Entonces, los hilos son procesos livianos dentro de un proceso.
Un subproceso puede tener varios estados en Java y se encuentra en cualquiera de los siguientes estados en cualquier momento de la ejecución
- Nuevo
- Ejecutable
- Correr
- Esperando/Bloqueado
- Terminado/Muerto
El estado ejecutable de un subproceso es un estado en el que el subproceso está listo para ejecutarse, se dice que está en un estado ejecutable o, en otras palabras, esperando que otros subprocesos (actualmente en ejecución) completen su ejecución y se ejecuten solos. Estado de ejecución de un subproceso en el que se dice que el procesador que se está ejecutando actualmente está en estado de ejecución . Es responsabilidad del programador de subprocesos darle al subproceso tiempo para ejecutarse.
Un programa de subprocesos múltiples asigna una cantidad fija de tiempo a cada subproceso individual. Todos y cada uno de los subprocesos se ejecutan durante un breve período de tiempo y luego se detienen y ceden la CPU a otro subproceso para que otros subprocesos puedan tener la oportunidad de ejecutarse.
Aquí discutiremos las diferencias entre los estados Runnable y Running, ya que la mayoría de los programadores de aprendizaje se confunden en ambos estados. A continuación se proporciona el programa para mejorar la claridad y el funcionamiento interno.
Ejemplo:
Java
// java Program to illustrate Difference between
// Running and Runnable states of Thread
// Importing input output classes
import java.io.*;
// Class 1
// Helper Class (extending main Thread class)
// Defining Thread1
class Thread1 extends Thread {
// run() method for Thread1
public void run()
{
// Display message only when thread1 starts
System.out.println("Thread 1 started ");
// Iterations
for (int i = 101; i < 200; i++)
System.out.print(i + " ");
// Display message only when thread1 ended
System.out.println("\nThread 1 completed");
}
}
// Class 2
// Helper Class (extending main Thread class)
// Defining Thread2
class Thread2 extends Thread {
// run() method for Thread 2
public void run()
{
// Display message only when thread 2 starts
System.out.println("Thread 2 started ");
// Iterations
for (int i = 201; i < 300; i++)
System.out.print(i + " ");
// Display message only when thread 2 ended
System.out.println("\nThread 2 completed");
}
}
// Class 3
// Helper Class (extending main Thread class)
// Defining Thread3
class Thread3 extends Thread {
// run() method for Thread 3
public void run()
{
// Display message only when thread 3 starts
System.out.println("Thread 3 started ");
// Iterations
for (int i = 301; i < 400; i++)
System.out.print(i + " ");
// Display message only when thread 3 starts
System.out.println("\nThread 3 completed");
}
}
// Class 4
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Try block to check for exceptions
try {
// Creating object of each of the threads
// defined
Thread1 thread1 = new Thread1();
Thread2 thread2 = new Thread2();
Thread3 thread3 = new Thread3();
// Instructing thread to start the execution
// using the start() method
thread1.start();
thread2.start();
thread3.start();
}
// Catch block to handle the exceptions
catch (Exception e) {
// Print the line number where exception
// occurred
e.printStackTrace();
}
}
}
Producción:
Hilo 1 inició el
hilo 2 inició el
hilo 3 iniciado
301 302 303 304 305 306 307 308 309 310 311 312 313 314 314 315 316 318 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 381 381 381 381 381 381 381 381 381 381 381 381 381 381 381 381 381 381 381 381 381 38A 38A 381 38A 38A 38A 381 381 38A 381 38A 381 38A 381 38A 381 38A 38A 381 38A 38A 381 38A 3A 38 392 393 394 395 396 397 398 399
Hilo 3 completado
101 102 103 104 201 105 202 106 107 203 108 204 109 205 110 206 111 112 113 114 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 130 131 132 133 134 135 136 137 138 139 149 140 142 144 144 144 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 207 208 209 210 211 211 212 213 214 215 215 219 219 2222222 223 225 225 225 225 225 229 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 261 262 263 265 265 266 267 269 269 270 271 272 274 274 274 274 279 261 261 262 263 264 265 265 267 268 269 270 271 272 274 274 274 274 273 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
Hilo 2 completado
176 177 178 179 180 181 182 183 184 185 185 187 188 189 190 191 193 193 197 197 197 197 198 199
Hilo 1 completado
Nota: La salida del código anterior no es necesariamente la misma cada vez que lo ejecutamos, ya que depende de la CPU (programador de subprocesos) qué subproceso se asigna con el procesador y durante cuánto tiempo.
Salida Explicación:
Para entender esto en el contexto del programa anterior, considere cuando se está imprimiendo la declaración 301 , significa que thread3 está en estado de ejecución, pero cuál es el estado de thread1 y thread2, la respuesta es, mientras tanto, cuando thread3 se está ejecutando en el procesador, thread2 y thread1 están esperando su turno para ser procesados o ejecutados, es decir, actualmente están en estado Runnable (o listos para ejecutarse).
Publicación traducida automáticamente
Artículo escrito por ankitsinghrajput y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA