Creación de número dinámico de subprocesos simultáneamente

Question

Cada vez que tengo que crear un número variable de subprocesos. Lo hago creando una matriz de Hilos y creando múltiples hilos.

Pero, no entiendo cómo comenzar este n número de subprocesos comportándose como un concepto de subprocesamiento múltiple. Quiero que se ejecuten en paralelo.

Por favor guía si qué hacer en este senario.

Answer 1

psuedocode básica:

create x threads, store them in an array or list; 
for each thread in the list/array 
    call start() on the thread object; 

Answer 2

Pero, no entiendo cómo iniciar estos número n de hilos comportándose como concepto de múltiples subprocesos. Quiero que se ejecuten en paralelo.

Por supuesto que puede crear una matriz de hilos utilizando un bucle:

Thread[] threads = new Thread[NUM_JOBS_TO_CREATE]; 
for (int i = 0; i < threads.length; i++) { 
    threads[i] = new Thread(new Runnable() { 
     public void run() { 
      // some code to run in parallel 
      // this could also be another class that implements Runnable 
     } 
    }); 
    threads[i].start(); 
} 

Esto hará que los hilos se ejecuten en segundo plano en paralelo. Luego puede unirse a ellos más tarde para esperar a que todos los completen antes de continuar.

// wait for the threads running in the background to finish 
for (Thread thread : threads) { 
    thread.join(); 
} 

Pero en lugar de gestionar los hilos usted mismo, yo recomendaría usar la orden interna Java Executors. Hacen todo esto porque son más fáciles de administrar. Una de las ventajas de este método es que separa las tareas de los hilos que las ejecutan. Puede comenzar, por ejemplo, 10 hilos para ejecutar 1000 y 1000 de tareas en paralelo.

He aquí algunos ejemplos de ExecutorService código:

// create a pool of threads, 10 max jobs will execute in parallel 
ExecutorService threadPool = Executors.newFixedThreadPool(10); 
// submit jobs to be executing by the pool 
for (int i = 0; i < NUM_JOBS_TO_CREATE; i++) { 
    threadPool.submit(new Runnable() { 
     public void run() { 
      // some code to run in parallel 
      // this could also be another class that implements Runnable 
     } 
    }); 
} 
// once you've submitted your last job to the service it should be shut down 
threadPool.shutdown(); 
// wait for the threads to finish if necessary 
threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS); 

Para obtener más información, consulte la Java tutorial on the thread executors.

Answer 3

Trate de no crear arreglos de hilos e intente administrarlos, pronto se convertirá en un desastre. Si necesita un grupo de subprocesos para ejecutar tareas, necesita una cola productor-consumidor. Cree uno y páselo (o la instancia del objeto de subprocesamiento que lo contiene como miembro) a los subprocesos a medida que los crea. Los hilos giran en redondo, buscando tareas y ejecutándolas.

La manera más fácil de hacerlo es utilizar un ExecutorService como se detalla en @Gray, (+1).

Para enfatizar, repito, no intente microgestionar hilos en matrices, listas o vectores, iniciándolos, verificando su estado en un ciclo 'jefe/gestión', finalizándolos/abortándolos, destruyéndolos, etc. etc. Es como un Porsche 911: después de gastar una gran cantidad de dinero/tiempo para obtener uno, tendrá algo que parece funcionar bien y luego se romperá repentinamente y lo derribará en un árbol.

Utilice un hilo dedicado para trabajos que se bloqueen durante períodos prolongados, un hilo de rosca para aquellos que se pueden hacer de manera intensa y rápida.

Answer 4

En una clase que necesita ser multihilo me puse en la parte superior de la clase:

private static final ExecutorService executor = Executors.newCachedThreadPool();

& en Java 8+ utilizar una expresión lambda donde necesito algo para funcionar en un nuevo hilo:

executor.submit(() -> { 
     myOtherClass.myFunction(doSomething); 
}); 

con un newCachedThreadPool Java gestionará el número total de hilos de acuerdo con el número de núcleos de CPU en el sistema & detendrá automáticamente después de un período de ina ctividad (60 segundos por defecto).