Як масштабувати нитки відповідно до ядер CPU?

Я хочу вирішити математичну задачу з декількома потоками на Java. мою математичну проблему можна розділити на робочі одиниці, які я хочу вирішити в декількох потоках.

Я не хочу мати фіксовану кількість потоків, що працюють над ним, але натомість кількість потоків, що відповідає кількості ядер CPU. Моя проблема полягає в тому, що я не зміг знайти простий підручник в Інтернеті для цього. Я знайшов лише приклади з фіксованими нитками.

Як це можна зробити? Чи можете ви навести приклади?

Ви можете визначити кількість процесів, доступних для віртуальної машини Java, використовуючи статичний метод виконання, доступнийПроцесори . Визначивши кількість доступних процесорів, створіть цю кількість потоків і відповідно розділіть свою роботу.

Оновлення : Для подальшого уточнення, Нитка - це просто Об'єкт на Java, тому ви можете створити її так само, як і будь-який інший об’єкт. Отже, скажімо, що ви викликаєте вищевказаний метод і виявляєте, що він повертає 2 процесора. Дивовижно. Тепер ви можете створити цикл, який генерує нову нитку, і розщеплює роботу для цього потоку та запускає нитку. Ось псуедокод для демонстрації того, що я маю на увазі:

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

Щоб отримати додаткові відомості про створення власної теми, зверніться до цього підручника . Крім того, ви можете поглянути на "Об'єднання ниток" для створення ниток.

Ви, мабуть, хочете подивитися також на java.util.concurrent Framework для цього матеріалу. Щось на зразок:

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

або

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

Це набагато приємніше, ніж справлятися з власними пулами ниток тощо.

Варіант 1:

newWorkStealingPool відExecutors

public static ExecutorService newWorkStealingPool()

Створює пул потоків крадіжок роботи, використовуючи всі доступні процесори як його цільовий рівень паралелізму.

За допомогою цього API вам не потрібно передавати кількість ядер ExecutorService.

Реалізація цього API з 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);
    }

Варіант 2:

newFixedThreadPool API від Executorsабо other newXXX constructors, який повертаєтьсяExecutorService

public static ExecutorService newFixedThreadPool(int nThreads)

замініть nThreads на Runtime.getRuntime().availableProcessors()

Варіант 3:

ThreadPoolExecutor

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

передавати Runtime.getRuntime().availableProcessors()як параметр до maximumPoolSize.

Дог Леа (автор одночасного пакету) має цей документ, який може бути актуальним: http://gee.cs.oswego.edu/dl/papers/fj.pdf

Рамка Fork Join була додана в Java SE 7. Нижче ще кілька посилань:

http://www.ibm.com/developerworks/java/library/j-jtp11137/index.html Стаття Брайана Геца

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

Стандартний спосіб - метод Runtime.getRuntime (). AvailableProcessors (). У більшості стандартних процесорів ви повернете тут оптимальне число потоків (що не є фактичним числом ядер CPU). Тому це те, що ви шукаєте.

Приклад:

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

НЕ забудьте вимкнути послугу виконавця на зразок цієї (або програма не вийде):

service.shutdown();

Ось лише короткий опис, як створити майбутній MT-код (офтопік, для ілюстрації):

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

Тоді вам слід буде відслідковувати кількість результатів, які ви очікуєте, і отримувати їх так:

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

Для класу Runtime існує метод, який називається availableProcessors (). Ви можете використовувати це, щоб визначити, скільки у вас процесорів. Оскільки ваша програма пов'язана з процесором, ви, ймовірно, хочете мати (максимум) один потік на доступний процесор.