Jak skalować wątki według rdzeni procesora?

Chcę rozwiązać problem matematyczny z wieloma wątkami w Javie. mój problem matematyczny można podzielić na jednostki pracy, które chcę rozwiązać w kilku wątkach.

Nie chcę, aby pracowała nad nim stała liczba wątków, ale zamiast tego liczba wątków odpowiadająca liczbie rdzeni procesora. Mój problem polega na tym, że nie mogłem znaleźć w internecie prostego poradnika na ten temat. Znalazłem tylko przykłady ze stałymi wątkami.

Jak to zrobić? Czy możesz podać przykłady?

Liczbę procesów dostępnych dla wirtualnej maszyny języka Java można określić za pomocą statycznej metody Runtime, availableProcessors . Po określeniu liczby dostępnych procesorów utwórz odpowiednią liczbę wątków i odpowiednio podziel pracę.

Aktualizacja : Aby jeszcze bardziej wyjaśnić, wątek jest po prostu obiektem w Javie, więc możesz go utworzyć tak, jak każdy inny obiekt. Powiedzmy więc, że wywołujesz powyższą metodę i stwierdzasz, że zwraca ona 2 procesory. Niesamowite. Teraz możesz utworzyć pętlę, która generuje nowy wątek, oddziela pracę dla tego wątku i odpala z wątku. Oto kilka psuedokodów, aby pokazać, o co mi chodzi:

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

Aby uzyskać więcej informacji na temat tworzenia własnego wątku, przejdź do tego samouczka . Możesz również zajrzeć do Puli wątków w celu utworzenia wątków.

Prawdopodobnie zechcesz również przyjrzeć się platformie java.util.concurrent, aby uzyskać takie informacje. Coś jak:

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

lub

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

Jest to o wiele przyjemniejsze niż radzenie sobie z własnymi pulami wątków itp.

Opcja 1:

newWorkStealingPool zExecutors

public static ExecutorService newWorkStealingPool()

Tworzy pulę wątków do kradzieży pracy przy użyciu wszystkich dostępnych procesorów jako docelowego poziomu równoległości.

Dzięki temu interfejsowi API nie musisz przekazywać liczby rdzeni do ExecutorService.

Implementacja tego API z 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);
    }

Opcja 2:

newFixedThreadPool API z Executorslub other newXXX constructors, który zwracaExecutorService

public static ExecutorService newFixedThreadPool(int nThreads)

zamień nThreads na Runtime.getRuntime().availableProcessors()

Opcja 3:

ThreadPoolExecutor

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

przekazać Runtime.getRuntime().availableProcessors()jako parametr do maximumPoolSize.

Doug Lea (autor równoległego pakietu) ma ten artykuł, który może mieć znaczenie: http://gee.cs.oswego.edu/dl/papers/fj.pdf

Środowisko Fork Join zostało dodane do Java SE 7. Poniżej znajduje się kilka innych odniesień:

http://www.ibm.com/developerworks/java/library/j-jtp11137/index.html Artykuł autorstwa Briana Goetza

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

Standardowym sposobem jest metoda Runtime.getRuntime (). AvailableProcessors (). W przypadku większości standardowych procesorów zwróci się tutaj optymalną liczbę wątków (która nie jest rzeczywistą liczbą rdzeni procesora). Dlatego właśnie tego szukasz.

Przykład:

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

NIE zapomnij zamknąć usługi executora w ten sposób (inaczej twój program się nie zakończy):

service.shutdown();

Oto krótki opis, jak skonfigurować przyszły kod MT (offtopic, dla ilustracji):

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

Następnie musisz śledzić liczbę spodziewanych wyników i pobierać je w następujący sposób:

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

W klasie Runtime istnieje metoda o nazwie availableProcessors (). Możesz użyć tego, aby dowiedzieć się, ile masz procesorów. Ponieważ twój program jest związany z procesorem, prawdopodobnie chciałbyś mieć (co najwyżej) jeden wątek na dostępny procesor.