Java - Creación de varios hilos con un bucle for

Question

Estoy tratando de crear varios hilos, cuyo número depende de la entrada de la línea de comandos. Sé que extender Thread no es la mejor práctica de OO a menos que estés haciendo una versión especializada de Thread, pero hipotéticamente es este código el que crea el resultado deseado.

class MyThread extends Thread { 

    public MyThread (String s) { 
    super(s); 
    } 

    public void run() { 
    System.out.println("Run: "+ getName()); 
    } 
} 


class TestThread { 
    public static void main (String arg[]) { 

    Scanner input = new Scanner(System.in); 
    System.out.println("Please input the number of Threads you want to create: "); 
    int n = input.nextInt(); 
    System.out.println("You selected " + n + " Threads"); 

    for (int x=0; x<n; x++) 
    { 
     MyThread temp= new MyThread("Thread #" + x); 
     temp.start(); 
     System.out.println("Started Thread:" + x); 
    } 
} 
} 

Answer 1

Sí, se está creando y comenzando n hilos, todo hubiera terminado inmediatamente después de la impresión Run: y su nombre.

Answer 2

Una cosa importante que Java JVM puede crear 20000 hilos a la vez. Creación de 255 hilos en Java

class MyThread1 extends Thread { 
    int k; 
    public MyThread1(int i) { 
      k = i; 
    } 

    @Override 
    public void run() { 
     //Your Code 
     System.out.println("Thread no. "+k); 

    } 
} 
class MainClass { 

    public static void main(String arg[]) throws UnknownHostException { 
     Refresh() ; 
    } 

    public static void Refresh(){ 

     //create 255 Thread using for loop 
     for (int x = 0; x < 256; x++) { 
      // Create Thread class 
      MyThread1 temp = new MyThread1(x); 
       temp.start(); 
      try { 
       temp.join(10); 
      } 
      catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 
     } 
    } 
} 

Answer 3

usted tiene mejores alternativas con el código de ExecutorService

muestra:

import java.util.concurrent.*; 

public class ExecutorTest{ 
    public static void main(String args[]){ 

     int numberOfTasks = Integer.parseInt(args[0]); 
     ExecutorService executor= Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()); 
     try{ 
      for (int i=0; i < numberOfTasks; i++){ 
       executor.execute(new MyRunnable(i));     
      } 
     }catch(Exception err){ 
      err.printStackTrace(); 
     } 
     executor.shutdown(); // once you are done with ExecutorService 
    } 
} 
class MyRunnable implements Runnable{ 
    int id; 
    public MyRunnable(int i){ 
     this.id = i; 
    } 
    public void run(){ 
     try{ 
      System.out.println("Runnable started id:"+id); 
      System.out.println("Run: "+ Thread.currentThread().getName()); 
      System.out.println("Runnable ended id:"+id); 
     }catch(Exception err){ 
      err.printStackTrace(); 
     } 
    } 
} 

de uso:

java ExecutorTest 2 

Runnable started id:0 
Run: pool-1-thread-1 
Runnable ended id:0 
Runnable started id:1 
Run: pool-1-thread-2 
Runnable ended id:1 

Puestos relacionados con: (Las ventajas de utilizar ExecutorService como un reemplazo para el llano Thread)

ExecutorService vs Casual Thread Spawner

How to properly use Java Executor?