İşlemciler CPU çekirdeklerine göre nasıl ölçeklenir?

Java'da birden çok iş parçacığı olan matematiksel bir problemi çözmek istiyorum. matematik problemim birkaç iş parçacığında çözmek istediğim çalışma birimlerine ayrılabilir.

Üzerinde çalışan sabit miktarda iş parçacığı olmasını istemiyorum, bunun yerine CPU çekirdeği miktarıyla eşleşen bir iş parçacığı miktarı istiyorum. Benim sorunum, internette bunun için kolay bir eğitim bulamamam. Bulduğum tek şey sabit iş parçacıklı örnekler.

Bu nasıl yapılabilir? Örnek verebilir misiniz?

Sen, statik Süre yöntemini kullanarak Java Virtual Machine mevcut süreçlerin sayısını belirleyebilir availableProcessors . Mevcut işlemci sayısını belirledikten sonra, bu sayıda iş parçacığı oluşturun ve çalışmanızı buna göre bölün.

Güncelleme : Daha fazla açıklığa kavuşturmak gerekirse, bir İş Parçacığı yalnızca Java'da bir Nesnedir, bu nedenle herhangi bir nesneyi oluşturduğunuz gibi onu oluşturabilirsiniz. Öyleyse yukarıdaki yöntemi çağırdığınızı ve 2 işlemci döndürdüğünü görelim. Harika. Şimdi, yeni bir İş Parçacığı oluşturan ve bu iş parçacığı için çalışmayı bölen ve iş parçacığını ateşleyen bir döngü oluşturabilirsiniz. İşte ne demek istediğimi göstermek için bazı psuedocode:

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

Kendi ileti dizinizi oluşturma hakkında daha fazla bilgi için bu eğiticiye gidin . Ayrıca, iş parçacığı oluşturmak için İş Parçacığı Havuzuna bakmak isteyebilirsiniz .

Muhtemelen bu şeyler için java.util.concurrent çerçevesine de bakmak istersiniz. Gibi bir şey:

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

veya

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

Bu, kendi iş parçacığı havuzlarınızla başa çıkmaktan çok daha hoş.

Seçenek 1:

newWorkStealingPool danExecutors

public static ExecutorService newWorkStealingPool()

Hedef paralellik düzeyi olarak tüm kullanılabilir işlemcileri kullanarak bir iş hırsızlığı iş parçacığı havuzu oluşturur.

Bu API ile çekirdek sayısını aktarmanıza gerek yoktur ExecutorService.

Bu API'nin grepcode'dan uygulanması

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

Seçenek 2:

newFixedThreadPool API'si Executorsveya other newXXX constructorsdöndürürExecutorService

public static ExecutorService newFixedThreadPool(int nThreads)

nThreads değiştir Runtime.getRuntime().availableProcessors()

3. Seçenek:

ThreadPoolExecutor

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

geçmesi Runtime.getRuntime().availableProcessors()için parametre olarak maximumPoolSize.

Doug Lea (eşzamanlı paketin yazarı) ilgili olabilecek bu makaleye sahiptir: http://gee.cs.oswego.edu/dl/papers/fj.pdf

Fork Join çerçevesi, Java SE 7'ye eklenmiştir. Aşağıda birkaç referans daha bulunmaktadır:

http://www.ibm.com/developerworks/java/library/j-jtp11137/index.html Brian Goetz'in hazırladığı makale

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

Standart yol, Runtime.getRuntime (). AvailableProcessors () yöntemidir. Çoğu standart CPU'da optimum iş parçacığı sayısını (bu gerçek CPU çekirdek sayısı değildir) burada döndürmüş olacaksınız. Bu nedenle aradığınız şey bu.

Misal:

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

Yürütme hizmetini bu şekilde kapatmayı UNUTMAYIN (aksi takdirde programınız çıkmaz):

service.shutdown();

Geleceğe dayalı bir MT kodunun nasıl kurulacağına dair kısa bir özet burada (örnek olarak konu dışı):

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

O halde, kaç sonuç beklediğinizi takip etmeniz ve bunları aşağıdaki gibi almanız gerekir:

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

Runtime sınıfında, availableProcessors () adında bir yöntem vardır. Bunu kaç CPU'nuz olduğunu bulmak için kullanabilirsiniz. Programınız CPU'ya bağlı olduğundan, mevcut CPU başına (en fazla) bir iş parçacığına sahip olmak isteyebilirsiniz.