Wie skaliere ich Threads nach CPU-Kernen?

Ich möchte ein mathematisches Problem mit mehreren Threads in Java lösen. Mein mathematisches Problem kann in Arbeitseinheiten unterteilt werden, die ich in mehreren Threads gelöst haben möchte.

Ich möchte nicht, dass eine feste Anzahl von Threads daran arbeitet, sondern eine Anzahl von Threads, die der Anzahl der CPU-Kerne entspricht. Mein Problem ist, dass ich dafür kein einfaches Tutorial im Internet finden konnte. Ich habe nur Beispiele mit festen Threads gefunden.

Wie kann das gemacht werden? Können Sie Beispiele nennen?

Sie können die Anzahl der Prozesse bestimmen, die für die Java Virtual Machine verfügbar sind, indem Sie die statische Runtime-Methode availableProcessors verwenden . Wenn Sie die Anzahl der verfügbaren Prozessoren festgelegt haben, erstellen Sie diese Anzahl von Threads und teilen Sie Ihre Arbeit entsprechend auf.

Update : Zur weiteren Verdeutlichung ist ein Thread nur ein Objekt in Java, sodass Sie ihn wie jedes andere Objekt erstellen können. Nehmen wir also an, Sie rufen die obige Methode auf und stellen fest, dass sie 2 Prozessoren zurückgibt. Genial. Jetzt können Sie eine Schleife erstellen, die einen neuen Thread generiert, die Arbeit für diesen Thread aufteilt und den Thread auslöst. Hier ist ein Pseudocode, um zu demonstrieren, was ich meine:

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

Weitere Informationen zum Erstellen eines eigenen Threads finden Sie in diesem Tutorial . Möglicherweise möchten Sie auch Thread-Pooling für die Erstellung der Threads betrachten.

Sie möchten sich wahrscheinlich auch das java.util.concurrent-Framework für dieses Zeug ansehen. Etwas wie:

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

oder

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

Dies ist viel schöner als die Bewältigung Ihrer eigenen Thread-Pools usw.

Option 1:

newWorkStealingPool vonExecutors

public static ExecutorService newWorkStealingPool()

Erstellt einen Thread, der die Arbeit stiehlt, wobei alle verfügbaren Prozessoren als Zielparallelitätsstufe verwendet werden.

Mit dieser API müssen Sie nicht die Anzahl der Kerne übergeben ExecutorService.

Implementierung dieser API aus 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);
    }

Option 2:

newFixedThreadPool API von Executorsoder other newXXX constructors, die zurückgibtExecutorService

public static ExecutorService newFixedThreadPool(int nThreads)

Ersetzen Sie nThreads durch Runtime.getRuntime().availableProcessors()

Option 3:

ThreadPoolExecutor

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

geben Runtime.getRuntime().availableProcessors()als Parameter an maximumPoolSize.

Doug Lea (Autor des gleichzeitigen Pakets) hat dieses Dokument, das möglicherweise relevant ist: http://gee.cs.oswego.edu/dl/papers/fj.pdf

Das Fork Join-Framework wurde zu Java SE 7 hinzugefügt. Nachfolgend einige weitere Referenzen:

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

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

Der Standardweg ist die Methode Runtime.getRuntime (). AvailableProcessors (). Bei den meisten Standard-CPUs haben Sie hier die optimale Thread-Anzahl (die nicht die tatsächliche CPU-Kernanzahl ist) zurückgegeben. Deshalb ist dies das, wonach Sie suchen.

Beispiel:

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

Vergessen Sie NICHT, den Executor-Dienst wie folgt herunterzufahren (sonst wird Ihr Programm nicht beendet):

service.shutdown();

Hier nur eine kurze Übersicht über das Einrichten eines zukunftsbasierten MT-Codes (zur Veranschaulichung offtopic):

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

Dann müssen Sie verfolgen, wie viele Ergebnisse Sie erwarten, und diese wie folgt abrufen:

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

In der Runtime-Klasse gibt es eine Methode namens availableProcessors (). Damit können Sie herausfinden, wie viele CPUs Sie haben. Da Ihr Programm CPU-gebunden ist, möchten Sie wahrscheinlich (höchstens) einen Thread pro verfügbarer CPU haben.