Come ridimensionare i thread in base ai core della CPU?

Voglio risolvere un problema matematico con più thread in Java. il mio problema di matematica può essere suddiviso in unità di lavoro, che voglio risolvere in più thread.

Non voglio avere una quantità fissa di thread che ci lavorano, ma invece una quantità di thread corrispondente alla quantità di core della CPU. Il mio problema è che non sono riuscito a trovare un semplice tutorial su Internet per questo. Tutto quello che ho trovato sono esempi con thread fissi.

Come si può fare? Potete fornire esempi?

È possibile determinare il numero di processi disponibili per Java Virtual Machine utilizzando il metodo Runtime statico, availableProcessors . Dopo aver determinato il numero di processori disponibili, creare quel numero di thread e suddividere il lavoro di conseguenza.

Aggiornamento : per chiarire ulteriormente, un thread è solo un oggetto in Java, quindi puoi crearlo proprio come creeresti qualsiasi altro oggetto. Quindi, diciamo che chiami il metodo sopra e scopri che restituisce 2 processori. Eccezionale. Ora puoi creare un ciclo che genera un nuovo thread e divide il lavoro per quel thread e spegne il thread. Ecco alcuni psuedocodici per dimostrare cosa intendo:

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();
}

Per ulteriori informazioni sulla creazione del tuo thread, vai a questo tutorial . Inoltre, potresti voler esaminare il pool di thread per la creazione dei thread.

Probabilmente vorrai dare un'occhiata al framework java.util.concurrent anche per queste cose. Qualcosa di simile a:

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

Questo è molto più bello che gestire i tuoi pool di thread, ecc.

Opzione 1:

newWorkStealingPool daExecutors

public static ExecutorService newWorkStealingPool()

Crea un pool di thread che ruba il lavoro utilizzando tutti i processori disponibili come livello di parallelismo di destinazione.

Con questa API, non è necessario trasferire il numero di core a ExecutorService.

Implementazione di questa API da 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);
    }

Opzione 2:

newFixedThreadPool API da Executorso other newXXX constructors, che restituisceExecutorService

public static ExecutorService newFixedThreadPool(int nThreads)

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

Opzione 3:

ThreadPoolExecutor

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

passa Runtime.getRuntime().availableProcessors()come parametro a maximumPoolSize.

Doug Lea (autore del pacchetto simultaneo) ha questo documento che potrebbe essere rilevante: http://gee.cs.oswego.edu/dl/papers/fj.pdf

Il framework Fork Join è stato aggiunto a Java SE 7. Di seguito sono riportati alcuni altri riferimenti:

http://www.ibm.com/developerworks/java/library/j-jtp11137/index.html Articolo di Brian Goetz

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

Il modo standard è il metodo Runtime.getRuntime (). AvailableProcessors (). Sulla maggior parte delle CPU standard avrai restituito il numero di thread ottimale (che non è il numero di core della CPU effettivo) qui. Quindi questo è quello che stai cercando.

Esempio:

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

NON dimenticare di chiudere il servizio esecutore in questo modo (o il tuo programma non verrà chiuso):

service.shutdown();

Ecco solo una breve descrizione di come impostare un codice MT basato sul futuro (offtopico, per illustrazione):

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)));
    }

Quindi devi tenere traccia di quanti risultati ti aspetti e recuperarli in questo modo:

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

Nella classe Runtime, c'è un metodo chiamato availableProcessors (). Puoi usarlo per capire quante CPU hai. Poiché il tuo programma è vincolato alla CPU, probabilmente vorrai avere (al massimo) un thread per CPU disponibile.