Bir dizi iş parçacığının tamamlanması için nasıl beklenir?

Tüm iş parçacıklı sürecin bitmesini beklemenin bir yolu nedir? Örneğin, şöyle diyelim:

public class DoSomethingInAThread implements Runnable{

    public static void main(String[] args) {
        for (int n=0; n<1000; n++) {
            Thread t = new Thread(new DoSomethingInAThread());
            t.start();
        }
        // wait for all threads' run() methods to complete before continuing
    }

    public void run() {
        // do something here
    }


}

Bunu nasıl değiştiririm, böylece main()yöntem, tüm iş parçacıklarının run()yöntemleri çıkana kadar yorumda duraklatılır ? Teşekkürler!

Tüm konuları bir diziye koyarsınız, hepsini başlatırsınız ve sonra bir döngü elde edersiniz

for(i = 0; i < threads.length; i++)
  threads[i].join();

Her bir birleştirme, ilgili iş parçacığı tamamlanana kadar engellenecektir. İleti dizileri, onlara katıldığınızdan farklı bir sırada tamamlanabilir, ancak bu bir sorun değildir: döngüden çıkıldığında, tüm iş parçacıkları tamamlanır.

Tek yönlü bir yapmak olacaktır Listarasında Threadlistesine eklerken, s oluşturabilir ve her iş parçacığı başlatın. Her şey başlatıldığında, listeye geri dönün ve join()her birini arayın . İş parçacığının hangi sırada çalışmayı bitirdiği önemli değil, bilmeniz gereken tek şey, ikinci döngünün çalıştırılması bittiğinde, her iş parçacığının tamamlanmış olacağıdır.

Daha iyi bir yaklaşım, bir ExecutorService ve bununla ilişkili yöntemleri kullanmaktır:

List<Callable> callables = ... // assemble list of Callables here
                               // Like Runnable but can return a value
ExecutorService execSvc = Executors.newCachedThreadPool();
List<Future<?>> results = execSvc.invokeAll(callables);
// Note: You may not care about the return values, in which case don't
//       bother saving them

Bir ExecutorService (ve Java 5'in eşzamanlılık hizmetlerinden gelen tüm yeni şeyler ) kullanmak inanılmaz derecede esnektir ve yukarıdaki örnek yüzeyi neredeyse hiç çizmez.

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class DoSomethingInAThread implements Runnable
{
   public static void main(String[] args) throws ExecutionException, InterruptedException
   {
      //limit the number of actual threads
      int poolSize = 10;
      ExecutorService service = Executors.newFixedThreadPool(poolSize);
      List<Future<Runnable>> futures = new ArrayList<Future<Runnable>>();

      for (int n = 0; n < 1000; n++)
      {
         Future f = service.submit(new DoSomethingInAThread());
         futures.add(f);
      }

      // wait for all tasks to complete before continuing
      for (Future<Runnable> f : futures)
      {
         f.get();
      }

      //shut down the executor service so that this thread can exit
      service.shutdownNow();
   }

   public void run()
   {
      // do something here
   }
}

Bunun yerine, join()eski bir API olan CountDownLatch'i kullanabilirsiniz . İhtiyaçlarınızı karşılamak için kodunuzu aşağıdaki gibi değiştirdim.

import java.util.concurrent.*;
class DoSomethingInAThread implements Runnable{
    CountDownLatch latch;
    public DoSomethingInAThread(CountDownLatch latch){
        this.latch = latch;
    } 
    public void run() {
        try{
            System.out.println("Do some thing");
            latch.countDown();
        }catch(Exception err){
            err.printStackTrace();
        }
    }
}

public class CountDownLatchDemo {
    public static void main(String[] args) {
        try{
            CountDownLatch latch = new CountDownLatch(1000);
            for (int n=0; n<1000; n++) {
                Thread t = new Thread(new DoSomethingInAThread(latch));
                t.start();
            }
            latch.await();
            System.out.println("In Main thread after completion of 1000 threads");
        }catch(Exception err){
            err.printStackTrace();
        }
    }
}

Açıklama :

1. CountDownLatch Gereksiniminize göre verilen 1000 sayısı ile başlatılmıştır.

2. Her bir çalışan iş parçacığı DoSomethingInAThread , CountDownLatchyapıcıda iletileni azaltır .

3. CountDownLatchDemo await()Sayım sıfır olana kadar ana iş parçacığı . Sayım sıfır olduğunda, çıktıda satırın altına ineceksiniz.

   In Main thread after completion of 1000 threads

Oracle belgeleri sayfasından daha fazla bilgi

public void await()
           throws InterruptedException

İplik kesilmedikçe, mevcut iş parçacığının mandal sıfıra geri sayana kadar beklemesine neden olur.

Diğer seçenekler için ilgili SE sorusuna bakın:

tüm iş parçacıkları java'da çalışmalarını bitirene kadar bekleyin

Thread sınıfından tamamen kaçının ve bunun yerine java.util.concurrent içinde sağlanan daha yüksek soyutlamaları kullanın

ExecutorService sınıfı, yalnızca istediğiniz şeyi yapıyor gibi görünen invokeAll yöntemini sağlar .

Kullanmayı düşünün java.util.concurrent.CountDownLatch. Javadocs örnekler

Martin K'nin önerdiği java.util.concurrent.CountDownLatchgibi bunun için daha iyi bir çözüm gibi görünüyor. Sadece aynısı için bir örnek eklemek

     public class CountDownLatchDemo
{

    public static void main (String[] args)
    {
        int noOfThreads = 5;
        // Declare the count down latch based on the number of threads you need
        // to wait on
        final CountDownLatch executionCompleted = new CountDownLatch(noOfThreads);
        for (int i = 0; i < noOfThreads; i++)
        {
            new Thread()
            {

                @Override
                public void run ()
                {

                    System.out.println("I am executed by :" + Thread.currentThread().getName());
                    try
                    {
                        // Dummy sleep
                        Thread.sleep(3000);
                        // One thread has completed its job
                        executionCompleted.countDown();
                    }
                    catch (InterruptedException e)
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

            }.start();
        }

        try
        {
            // Wait till the count down latch opens.In the given case till five
            // times countDown method is invoked
            executionCompleted.await();
            System.out.println("All over");
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }

}

İhtiyaçlarınıza bağlı olarak, java.util.concurrent paketindeki CountDownLatch ve CyclicBarrier sınıflarını da kontrol etmek isteyebilirsiniz. İş parçacıklarınızın birbirini beklemesini istiyorsanız veya iş parçacıklarınızın yürütme şekli üzerinde daha ayrıntılı denetim istiyorsanız (örneğin, başka bir iş parçacığının bir durum ayarlaması için iç yürütmede beklemek) yararlı olabilirler. Döngünüzde ilerledikçe tek tek başlatmak yerine, tüm iş parçacıklarınızın aynı anda başlaması için sinyal vermek için bir CountDownLatch de kullanabilirsiniz. Standart API belgelerinde bunun bir örneği vardır, ayrıca tüm iş parçacıklarının yürütülmesini tamamlamasını beklemek için başka bir CountDownLatch kullanır.

Konuların bir listesini yaparsanız, her biri için döngü yapabilir ve .join () yapabilirsiniz ve döngünüz, tüm iş parçacıkları olduğunda biter. Yine de denemedim.

http://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#join ()

İlk for döngüsünün içinde iş parçacığı nesnesini oluşturun.

for (int i = 0; i < threads.length; i++) {
     threads[i] = new Thread(new Runnable() {
         public void run() {
             // some code to run in parallel
         }
     });
     threads[i].start();
 }

Ve sonra buradaki herkesin söylediği.

for(i = 0; i < threads.length; i++)
  threads[i].join();

Bunu "ThreadGroup" Nesnesi ve activeCount parametresiyle yapabilirsiniz :

CountDownLatch'e alternatif olarak CyclicBarrier'ı da kullanabilirsiniz, örn.

public class ThreadWaitEx {
    static CyclicBarrier barrier = new CyclicBarrier(100, new Runnable(){
        public void run(){
            System.out.println("clean up job after all tasks are done.");
        }
    });
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Thread t = new Thread(new MyCallable(barrier));
            t.start();
        }       
    }

}    

class MyCallable implements Runnable{
    private CyclicBarrier b = null;
    public MyCallable(CyclicBarrier b){
        this.b = b;
    }
    @Override
    public void run(){
        try {
            //do something
            System.out.println(Thread.currentThread().getName()+" is waiting for barrier after completing his job.");
            b.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }       
}

Bu durumda CyclicBarrier'ı kullanmak için barrier.await () son ifade olmalıdır, yani iş parçacığınızın işi bittiğinde. CyclicBarrier, reset () yöntemi ile tekrar kullanılabilir. Javadocs'tan alıntı yapmak için:

CyclicBarrier, partideki son iş parçacığı geldikten sonra, ancak herhangi bir iş parçacığı serbest bırakılmadan önce engel noktası başına bir kez çalıştırılan isteğe bağlı bir Çalıştırılabilir komutunu destekler. Bu bariyer eylemi, taraflardan herhangi biri devam etmeden önce paylaşılan durumu güncellemek için kullanışlıdır.

join()Bana yardımcı olmadı. Kotlin'deki bu örneğe bakın:

    val timeInMillis = System.currentTimeMillis()
    ThreadUtils.startNewThread(Runnable {
        for (i in 1..5) {
            val t = Thread(Runnable {
                Thread.sleep(50)
                var a = i
                kotlin.io.println(Thread.currentThread().name + "|" + "a=$a")
                Thread.sleep(200)
                for (j in 1..5) {
                    a *= j
                    Thread.sleep(100)
                    kotlin.io.println(Thread.currentThread().name + "|" + "$a*$j=$a")
                }
                kotlin.io.println(Thread.currentThread().name + "|TaskDurationInMillis = " + (System.currentTimeMillis() - timeInMillis))
            })
            t.start()
        }
    })

Sonuç:

Thread-5|a=5
Thread-1|a=1
Thread-3|a=3
Thread-2|a=2
Thread-4|a=4
Thread-2|2*1=2
Thread-3|3*1=3
Thread-1|1*1=1
Thread-5|5*1=5
Thread-4|4*1=4
Thread-1|2*2=2
Thread-5|10*2=10
Thread-3|6*2=6
Thread-4|8*2=8
Thread-2|4*2=4
Thread-3|18*3=18
Thread-1|6*3=6
Thread-5|30*3=30
Thread-2|12*3=12
Thread-4|24*3=24
Thread-4|96*4=96
Thread-2|48*4=48
Thread-5|120*4=120
Thread-1|24*4=24
Thread-3|72*4=72
Thread-5|600*5=600
Thread-4|480*5=480
Thread-3|360*5=360
Thread-1|120*5=120
Thread-2|240*5=240
Thread-1|TaskDurationInMillis = 765
Thread-3|TaskDurationInMillis = 765
Thread-4|TaskDurationInMillis = 765
Thread-5|TaskDurationInMillis = 765
Thread-2|TaskDurationInMillis = 765

Şimdi join()iş parçacıkları için kullanmama izin verin :

    val timeInMillis = System.currentTimeMillis()
    ThreadUtils.startNewThread(Runnable {
        for (i in 1..5) {
            val t = Thread(Runnable {
                Thread.sleep(50)
                var a = i
                kotlin.io.println(Thread.currentThread().name + "|" + "a=$a")
                Thread.sleep(200)
                for (j in 1..5) {
                    a *= j
                    Thread.sleep(100)
                    kotlin.io.println(Thread.currentThread().name + "|" + "$a*$j=$a")
                }
                kotlin.io.println(Thread.currentThread().name + "|TaskDurationInMillis = " + (System.currentTimeMillis() - timeInMillis))
            })
            t.start()
            t.join()
        }
    })

Ve sonuç:

Thread-1|a=1
Thread-1|1*1=1
Thread-1|2*2=2
Thread-1|6*3=6
Thread-1|24*4=24
Thread-1|120*5=120
Thread-1|TaskDurationInMillis = 815
Thread-2|a=2
Thread-2|2*1=2
Thread-2|4*2=4
Thread-2|12*3=12
Thread-2|48*4=48
Thread-2|240*5=240
Thread-2|TaskDurationInMillis = 1568
Thread-3|a=3
Thread-3|3*1=3
Thread-3|6*2=6
Thread-3|18*3=18
Thread-3|72*4=72
Thread-3|360*5=360
Thread-3|TaskDurationInMillis = 2323
Thread-4|a=4
Thread-4|4*1=4
Thread-4|8*2=8
Thread-4|24*3=24
Thread-4|96*4=96
Thread-4|480*5=480
Thread-4|TaskDurationInMillis = 3078
Thread-5|a=5
Thread-5|5*1=5
Thread-5|10*2=10
Thread-5|30*3=30
Thread-5|120*4=120
Thread-5|600*5=600
Thread-5|TaskDurationInMillis = 3833

Kullandığımız zaman açıkça görüldüğü gibi join:

1. İplikler sırayla çalışıyor.
2. İlk örnek 765 Milisaniye, ikinci örnek 3833 Milisaniye sürüyor.

Diğer iş parçacıklarının engellenmesini önlemeye yönelik çözümümüz bir ArrayList oluşturmaktı:

val threads = ArrayList<Thread>()

Şimdi yeni bir iş parçacığı başlatmak istediğimizde, onu en çok ArrayList'e ekleriz:

addThreadToArray(
    ThreadUtils.startNewThread(Runnable {
        ...
    })
)

addThreadToArrayfonksiyon:

@Synchronized
fun addThreadToArray(th: Thread) {
    threads.add(th)
}

startNewThreadfunstion:

fun startNewThread(runnable: Runnable) : Thread {
    val th = Thread(runnable)
    th.isDaemon = false
    th.priority = Thread.MAX_PRIORITY
    th.start()
    return th
}

Konuların tamamlandığını, ihtiyaç duyulan her yerde aşağıdaki gibi kontrol edin:

val notAliveThreads = ArrayList<Thread>()
for (t in threads)
    if (!t.isAlive)
        notAliveThreads.add(t)
threads.removeAll(notAliveThreads)
if (threads.size == 0){
    // The size is 0 -> there is no alive threads.
}