Como escalar threads de acordo com os núcleos da CPU?

Quero resolver um problema matemático com vários threads em Java. meu problema de matemática pode ser separado em unidades de trabalho, que desejo resolver em vários tópicos.

Não quero ter uma quantidade fixa de threads trabalhando nele, mas sim uma quantidade de threads que corresponda à quantidade de núcleos da CPU. Meu problema é que não consegui encontrar um tutorial fácil na internet para isso. Tudo o que encontrei são exemplos com threads fixos.

Como isso pode ser feito? Você pode fornecer exemplos?

Você pode determinar o número de processos disponíveis para a Java Virtual Machine usando o método estático Runtime, availableProcessors . Depois de determinar o número de processadores disponíveis, crie esse número de threads e divida seu trabalho de acordo.

Atualização : Para esclarecer ainda mais, um Thread é apenas um Objeto em Java, então você pode criá-lo como faria com qualquer outro objeto. Então, digamos que você chame o método acima e descubra que ele retorna 2 processadores. Impressionante. Agora, você pode criar um loop que gera um novo Thread, divide o trabalho para aquele thread e dispara o thread. Aqui estão alguns psuedocódigo para demonstrar o que quero dizer:

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 obter mais informações sobre como criar seu próprio tópico, vá para este tutorial . Além disso, você pode querer dar uma olhada em Thread Pooling para a criação de threads.

Você provavelmente deseja examinar a estrutura java.util.concurrent para essas coisas também. 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
        }
    });

ou

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

Isso é muito mais agradável do que lidar com seus próprios pools de threads, etc.

Opção 1:

newWorkStealingPool deExecutors

public static ExecutorService newWorkStealingPool()

Cria um pool de threads de roubo de trabalho usando todos os processadores disponíveis como seu nível de paralelismo de destino.

Com esta API, você não precisa passar o número de núcleos para ExecutorService.

Implementação desta API de 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);
    }

Opção 2:

API newFixedThreadPool de Executorsou other newXXX constructors, que retornaExecutorService

public static ExecutorService newFixedThreadPool(int nThreads)

substituir nThreads por Runtime.getRuntime().availableProcessors()

Opção 3:

ThreadPoolExecutor

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

passe Runtime.getRuntime().availableProcessors()como parâmetro para maximumPoolSize.

Doug Lea (autor do pacote concorrente) tem este artigo que pode ser relevante: http://gee.cs.oswego.edu/dl/papers/fj.pdf

A estrutura Fork Join foi adicionada ao Java SE 7. Abaixo estão mais algumas referências:

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

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

A forma padrão é o método Runtime.getRuntime (). AvailableProcessors (). Na maioria das CPUs padrão, você retornou a contagem ideal de threads (que não é a contagem real do núcleo da CPU) aqui. Portanto, é isso que você está procurando.

Exemplo:

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

NÃO se esqueça de encerrar o serviço do executor desta forma (ou seu programa não sairá):

service.shutdown();

Aqui está apenas um esboço rápido de como configurar um código MT baseado no futuro (offtopic, para ilustração):

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

Em seguida, você precisa acompanhar quantos resultados espera e recuperá-los assim:

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

Na classe Runtime, existe um método chamado availableProcessors (). Você pode usar isso para descobrir quantas CPUs você tem. Como seu programa é limitado pela CPU, você provavelmente desejaria ter (no máximo) um thread por CPU disponível.