¿Cómo escalar subprocesos según los núcleos de la CPU?

Quiero resolver un problema matemático con múltiples subprocesos en Java. mi problema de matemáticas se puede dividir en unidades de trabajo, que quiero haber resuelto en varios hilos.

No quiero tener una cantidad fija de subprocesos trabajando en él, sino una cantidad de subprocesos que coincida con la cantidad de núcleos de CPU. Mi problema es que no pude encontrar un tutorial sencillo en Internet para esto. Todo lo que encontré son ejemplos con hilos fijos.

¿Cómo se puede hacer esto? ¿Puede proporcionar ejemplos?

Puede determinar el número de procesos disponibles para la máquina virtual Java mediante el método de tiempo de ejecución estático, availableProcessors . Una vez que haya determinado la cantidad de procesadores disponibles, cree esa cantidad de subprocesos y divida su trabajo en consecuencia.

Actualización : para aclarar aún más, un hilo es solo un objeto en Java, por lo que puede crearlo como lo haría con cualquier otro objeto. Entonces, digamos que llama al método anterior y encuentra que devuelve 2 procesadores. Increíble. Ahora, puede crear un bucle que genere un nuevo subproceso, y divida el trabajo para ese subproceso y lo dispare. Aquí hay un psuedocode para demostrar lo que quiero decir:

int processors = Runtime.getRuntime().availableProcessors();
for(int i=0; i < processors; i++) {
  Thread yourThread = new AThreadYouCreated();
  // You may need to pass in parameters depending on what work you are doing and how you setup your thread.
  yourThread.start();
}

Para obtener más información sobre cómo crear su propio hilo, diríjase a este tutorial . Además, es posible que desee consultar Thread Pooling para la creación de los hilos.

Probablemente también desee ver el marco java.util.concurrent para estas cosas. Algo como:

ExecutorService e = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
// Do work using something like either
e.execute(new Runnable() {
        public void run() {
            // do one task
        }
    });

o

    Future<String> future = pool.submit(new Callable<String>() {
        public String call() throws Exception {
            return null;
        }
    });
    future.get();  // Will block till result available

Esto es mucho mejor que lidiar con tus propios grupos de subprocesos, etc.

Opción 1:

newWorkStealingPool deExecutors

public static ExecutorService newWorkStealingPool()

Crea un grupo de subprocesos de robo de trabajo utilizando todos los procesadores disponibles como su nivel de paralelismo de destino.

Con esta API, no necesita pasar un número de núcleos a ExecutorService.

Implementación de esta API desde grepcode

/**
     * Creates a work-stealing thread pool using all
     * {@link Runtime#availableProcessors available processors}
     * as its target parallelism level.
     * @return the newly created thread pool
     * @see #newWorkStealingPool(int)
     * @since 1.8
     */
    public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

Opcion 2:

newFixedThreadPool API de Executorso other newXXX constructors, que devuelveExecutorService

public static ExecutorService newFixedThreadPool(int nThreads)

reemplace nThreads con Runtime.getRuntime().availableProcessors()

Opcion 3:

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                      int maximumPoolSize,
                      long keepAliveTime,
                      TimeUnit unit,
                      BlockingQueue<Runnable> workQueue)

pasar Runtime.getRuntime().availableProcessors()como parámetro a maximumPoolSize.

Doug Lea (autor del paquete concurrente) tiene este artículo que puede ser relevante: http://gee.cs.oswego.edu/dl/papers/fj.pdf

El marco Fork Join se ha agregado a Java SE 7. A continuación se muestran algunas referencias más:

http://www.ibm.com/developerworks/java/library/j-jtp11137/index.html Artículo de Brian Goetz

http://www.oracle.com/technetwork/articles/java/fork-join-422606.html

La forma estándar es el método Runtime.getRuntime (). AvailableProcessors (). En la mayoría de las CPU estándar, habrá devuelto aquí el número de subprocesos óptimo (que no es el número real de núcleos de CPU). Por tanto, esto es lo que estás buscando.

Ejemplo:

ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

NO olvide cerrar el servicio ejecutor de esta manera (o su programa no se cerrará):

service.shutdown();

Aquí solo un breve resumen de cómo configurar un código MT basado en el futuro (fuera de tema, para ilustración):

CompletionService<YourCallableImplementor> completionService = 
    new ExecutorCompletionService<YourCallableImplementor>(service);
    ArrayList<Future<YourCallableImplementor>> futures = new ArrayList<Future<YourCallableImplementor>>();
    for (String computeMe : elementsToCompute) {
        futures.add(completionService.submit(new YourCallableImplementor(computeMe)));
    }

Luego, debe realizar un seguimiento de cuántos resultados espera y recuperarlos de esta manera:

try {
  int received = 0;
  while (received < elementsToCompute.size()) {
     Future<YourCallableImplementor> resultFuture = completionService.take(); 
     YourCallableImplementor result = resultFuture.get();
     received++; 
  }
} finally {
  service.shutdown();
}

En la clase Runtime, hay un método llamado availableProcessors (). Puede usar eso para averiguar cuántas CPU tiene. Dado que su programa está vinculado a la CPU, probablemente querrá tener (como máximo) un hilo por CPU disponible.