Bagaimana cara menskalakan utas berdasarkan inti CPU?

Saya ingin memecahkan masalah matematika dengan banyak utas di Jawa. masalah matematika saya dapat dipisahkan menjadi unit kerja, yang ingin saya pecahkan dalam beberapa utas.

Saya tidak ingin memiliki jumlah utas yang tetap yang mengerjakannya, tetapi jumlah utas yang cocok dengan jumlah inti CPU. Masalah saya adalah, saya tidak dapat menemukan tutorial mudah di internet untuk ini. Yang saya temukan adalah contoh dengan utas tetap.

Bagaimana ini bisa dilakukan? Bisakah Anda memberikan contoh?

Anda dapat menentukan jumlah proses yang tersedia untuk Mesin Virtual Java dengan menggunakan metode runtime statis, availableProcessors . Setelah Anda menentukan jumlah prosesor yang tersedia, buat jumlah utas itu dan bagi pekerjaan Anda sesuai dengan itu.

Pembaruan : Untuk memperjelas lebih lanjut, Thread hanyalah sebuah Objek di Java, jadi Anda dapat membuatnya seperti Anda akan membuat objek lain. Jadi, katakanlah Anda memanggil metode di atas dan menemukan bahwa ia mengembalikan 2 prosesor. Hebat. Sekarang, Anda dapat membuat loop yang menghasilkan Thread baru, dan membagi pekerjaan untuk thread tersebut, dan mengaktifkan thread tersebut. Berikut beberapa psuedocode untuk menunjukkan apa yang saya maksud:

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

Untuk informasi lebih lanjut tentang membuat utas Anda sendiri, buka tutorial ini . Juga, Anda mungkin ingin melihat Thread Pooling untuk pembuatan thread.

Anda mungkin ingin melihat framework java.util.concurrent untuk hal ini juga. Sesuatu seperti:

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

atau

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

Ini jauh lebih baik daripada mengatasi kumpulan utas Anda sendiri, dll.

Pilihan 1:

newWorkStealingPool dariExecutors

public static ExecutorService newWorkStealingPool()

Membuat kumpulan utas yang mencuri pekerjaan menggunakan semua prosesor yang tersedia sebagai tingkat paralelisme targetnya.

Dengan API ini, Anda tidak perlu meneruskan jumlah inti ke ExecutorService.

Implementasi API ini dari 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);
    }

Pilihan 2:

newFixedThreadPool API dari Executorsatau other newXXX constructors, yang mengembalikanExecutorService

public static ExecutorService newFixedThreadPool(int nThreads)

ganti nThreads dengan Runtime.getRuntime().availableProcessors()

Opsi 3:

ThreadPoolExecutor

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

lulus Runtime.getRuntime().availableProcessors()sebagai parameter ke maximumPoolSize.

Doug Lea (penulis paket bersamaan) memiliki makalah ini yang mungkin relevan: http://gee.cs.oswego.edu/dl/papers/fj.pdf

Kerangka Fork Join telah ditambahkan ke Java SE 7. Berikut adalah beberapa referensi lainnya:

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

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

Cara standarnya adalah metode Runtime.getRuntime (). AvailableProcessors (). Pada kebanyakan CPU standar, Anda akan mengembalikan jumlah utas optimal (yang bukan jumlah inti CPU sebenarnya) di sini. Oleh karena itu, inilah yang Anda cari.

Contoh:

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

JANGAN lupa untuk mematikan layanan eksekutor seperti ini (atau program Anda tidak akan keluar):

service.shutdown();

Berikut adalah garis besar singkat cara mengatur kode MT berbasis masa depan (offtopic, untuk ilustrasi):

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

Kemudian Anda perlu melacak berapa banyak hasil yang Anda harapkan dan mengambilnya seperti ini:

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

Di kelas Runtime, ada metode yang disebut availableProcessors (). Anda dapat menggunakannya untuk mengetahui berapa banyak CPU yang Anda miliki. Karena program Anda terikat dengan CPU, Anda mungkin ingin memiliki (paling banyak) satu utas per CPU yang tersedia.