Haciendo que los hilos funcionen de manera adecuada

Question

Acabo de empezar a aprender los hilos y entender mal cómo funcionan.

Aquí es mi clase:

public class MyThread extends Thread { 
    private static int NUM = 0; 
    private int id; 

    public MyThread() { 
     id = NUM++; 
    } 

    public static void main(String[] args) { 
     for (int i = 0; i < 10; i++) { 
      new MyThread().start(); 
     } 
    } 

    public void run() { 
     System.out.println(id + " started"); 

     try { 
      Process p = Runtime.getRuntime().exec("javac -version"); 
      p.waitFor(); 
     } catch (Exception e) { 
      System.out.println("Call a doc!"); 
     } 

     System.out.println(id + " finished"); 
    } 
} 

/* 
Just a sidenote. 
I am creating new javac process just to slow an application down. 
Simple System.out.println(…) is a way faster. 
*/ 

¿Por qué siempre consigo toda "... comenzó" mensajes en un primer momento y después de eso ... "terminados" mensajes? No importa cuántos hilos he empezado, siempre veo:

0 started 
1 started 
2 started 
3 started 
4 started 
5 started 
6 started 
7 started 
8 started 
9 started 
0 finished 
1 finished 
3 finished 
4 finished 
8 finished 
5 finished 
2 finished 
6 finished 
9 finished 
7 finished 

no es el propósito de las discusiones para paralelizar la ejecución?
Tal vez necesito sincronizar algo? ¿O cometió un error por descuido? O…?
Explique, por favor.

ACTUALIZACIÓN:

¿Por qué no puedo ver, digamos:

0 started 
1 started 
0 finished 
2 started 
1 finished 
2 finished 

Gracias a todos por el tratamiento.

Answer 1

Los hilos son paralelos. De lo contrario, vería cada hilo "terminado" antes de que el siguiente "comenzara"

Una manera simple de ralentizar un hilo es usar Thread.sleep (10 * 1000); para dormir durante 10 segundos (10.000 milisegundos)

EDITAR: una manera simple de ver el intercalado de subprocesos es tener un grupo de subprocesos de tamaño fijo.

ExecutorService pool = Executors.newFixedThreadPool(4); 
for (int i = 0; i < 10; i++) { 
    final int id = i; 
    pool.submit(new Callable<Void>() { 
     public Void call() throws InterruptedException { 
      System.out.println(id + " started"); 
      Thread.sleep(1000); 
      System.out.println(id + " finished"); 
      return null; 
     } 
    }); 
} 

imprime

0 started 
1 started 
2 started 
3 started 
0 finished 
4 started 
1 finished 
5 started 
2 finished 
6 started 
3 finished 
7 started 
4 finished 
8 started 
5 finished 
6 finished 
9 started 
7 finished 
8 finished 
9 finished 

Answer 2

se ve bien. Puede ver en su salida que los hilos se entrelazan. los hilos se están iniciando, cambian de contexto y el planificador los selecciona; puede ver dónde el hilo 8 salta delante del hilo 5, por ejemplo. Si todos los números estuvieran en orden consistentemente, sería extraño, pero parece estar bien.

Use el tiempo de inactividad, como sugiere Peter Lawrey, para que pueda modificar cuánto tiempo tarda cada subproceso más fácilmente. Tal como se muestra en su ejemplo, iniciar un proceso lleva tanto tiempo que parece razonable que todos sus hilos comiencen antes de finalizar.

Answer 3

Si coloca un bucle simple para contar del 1 al 20 en el método run(), puede ver mejor el entrelazado de la ejecución.

Answer 4

Hay una diferencia entre multi-threading and parallel processing ... mira esto ...

Answer 5

Si desea ver una partida "al azar" y terminando es posible que desee añadir un

o similares a los hilos.