зачекайте, поки всі потоки закінчать свою роботу в Java

Я пишу додаток, яке містить 5 потоків, які одночасно отримують деяку інформацію з Інтернету та заповнюють 5 різних полів у буферному класі.
Мені потрібно перевірити дані буфера та зберегти їх у базі даних, коли всі потоки закінчать свою роботу.
Як я можу це зробити (отримувати сповіщення, коли всі потоки закінчать свою роботу)?

Я використовую підхід до використання ExecutorService для управління пулами потоків.

ExecutorService es = Executors.newCachedThreadPool();
for(int i=0;i<5;i++)
    es.execute(new Runnable() { /*  your task */ });
es.shutdown();
boolean finished = es.awaitTermination(1, TimeUnit.MINUTES);
// all tasks have finished or the time has been reached.

Ти можеш join до ниток. Блоки об’єднання, поки потік не завершиться.

for (Thread thread : threads) {
    thread.join();
}

Зверніть увагу, що joinкидає InterruptedException. Вам доведеться вирішити, що робити, якщо це трапиться (наприклад, спробуйте скасувати інші потоки, щоб запобігти непотрібній роботі).

Погляньте на різні рішення.

1. join()API був представлений у ранніх версіях Java. Деякі хороші альтернативи доступні з цим одночасним пакетом з моменту випуску JDK 1.5.

2. ExecutorService # invokeAll ()

   Виконує задані завдання, повертаючи список ф’ючерсів, що мають їхній статус та результати, коли все завершено.

   Зверніться до цього відповідного запитання про SE для прикладу коду:

   Як використовувати invokeAll (), щоб дозволити усьому пулу потоків виконувати своє завдання?

3. CountDownLatch

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

   CountDownLatch инициализируется з заданим кол. Методи await блокуються до тих пір, поки поточний рахунок не досягне нуля через виклики countDown()методу, після чого всі потоки очікування звільняються, а всі наступні виклики await негайно повертаються. Це одноразове явище - підрахунок неможливо скинути. Якщо вам потрібна версія, яка скидає підрахунок, розгляньте можливість використання CyclicBarrier .

   Зверніться до цього питання щодо використання CountDownLatch

   Як чекати, поки нитка породить власну нитку?

4. ForkJoinPool або newWorkStealingPool () у виконавцях

5. Переглядайте всі майбутні об’єкти, створені після поданняExecutorService

Окрім Thread.join()запропонованих іншими, Java 5 представив рамки виконавця. Там ви не працюєте з Threadоб’єктами. Натомість ви подаєте свої Callableабо Runnableпредмети виконавцю. Існує спеціальний виконавець, який призначений для виконання кількох завдань і повернення їх результатів із порядку. Це ExecutorCompletionService:

ExecutorCompletionService executor;
for (..) {
    executor.submit(Executors.callable(yourRunnable));
}

Потім ви можете повторно телефонувати, take()поки не буде більше Future<?>об’єктів для повернення, а це означає, що всі вони завершені.

Інша річ, яка може бути актуальною, залежно від вашого сценарію CyclicBarrier.

Допомога синхронізації, яка дозволяє набору потоків всім очікувати, поки один одного дійде до загальної бар’єрної точки. CyclicBarriers корисні в програмах, що включають партію потоків фіксованого розміру, які час від часу повинні чекати один одного. Бар'єр називається циклічним, оскільки його можна використовувати повторно після випуску потоків очікування.

Іншою можливістю є CountDownLatchоб'єкт, який корисний для простих ситуацій: оскільки ви заздалегідь знаєте кількість потоків, ви ініціалізуєте його відповідним рахунком і передаєте посилання на об'єкт кожному потоку.
Після завершення свого завдання кожен потік викликає, CountDownLatch.countDown()що зменшує внутрішній лічильник. Після запуску всіх інших основний потік повинен зробити CountDownLatch.await()виклик блокування. Він буде випущений, як тільки внутрішній лічильник досягне 0.

Зверніть увагу, що з цим предметом InterruptedExceptionможна також кинути і кузов.

Ти робиш

for (Thread t : new Thread[] { th1, th2, th3, th4, th5 })
    t.join()

Після цього циклу for ви можете бути впевнені, що всі потоки закінчили свої завдання.

Зачекайте / заблокуйте Thread Main, поки деякі інші потоки не завершать свою роботу.

Як вже було @Ravindra babuсказано, цього можна досягти різними способами, але показавши на прикладах.

• java.lang.Thread. join () ^{Оскільки: 1.0}

  public static void joiningThreads() throws InterruptedException {
      Thread t1 = new Thread( new LatchTask(1, null), "T1" );
      Thread t2 = new Thread( new LatchTask(7, null), "T2" );
      Thread t3 = new Thread( new LatchTask(5, null), "T3" );
      Thread t4 = new Thread( new LatchTask(2, null), "T4" );
  
      // Start all the threads
      t1.start();
      t2.start();
      t3.start();
      t4.start();
  
      // Wait till all threads completes
      t1.join();
      t2.join();
      t3.join();
      t4.join();
  }

• java.util.concurrent.CountDownLatch ^{З: 1.5}

  • .countDown() «Зменшує кількість груп засувок.
  • .await() «Методи очікування блокуються, поки поточний рахунок не досягне нуля.

  Якщо ви створили, latchGroupCount = 4тоді вам countDown()слід викликати 4 рази, щоб зробити відлік 0. Отже, це await()звільнить блокуючі потоки.

  public static void latchThreads() throws InterruptedException {
      int latchGroupCount = 4;
      CountDownLatch latch = new CountDownLatch(latchGroupCount);
      Thread t1 = new Thread( new LatchTask(1, latch), "T1" );
      Thread t2 = new Thread( new LatchTask(7, latch), "T2" );
      Thread t3 = new Thread( new LatchTask(5, latch), "T3" );
      Thread t4 = new Thread( new LatchTask(2, latch), "T4" );
  
      t1.start();
      t2.start();
      t3.start();
      t4.start();
  
      //latch.countDown();
  
      latch.await(); // block until latchGroupCount is 0.
  }

Приклад коду потокового класу LatchTask. Для тестування підходу використовують joiningThreads(); і latchThreads();основний метод.

class LatchTask extends Thread {
    CountDownLatch latch;
    int iterations = 10;
    public LatchTask(int iterations, CountDownLatch latch) {
        this.iterations = iterations;
        this.latch = latch;
    }

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName + " : Started Task...");

        for (int i = 0; i < iterations; i++) {
            System.out.println(threadName + " : " + i);
            MainThread_Wait_TillWorkerThreadsComplete.sleep(1);
        }
        System.out.println(threadName + " : Completed Task");
        // countDown() « Decrements the count of the latch group.
        if(latch != null)
            latch.countDown();
    }
}

• CyclicBarriers - допоміжний пристрій для синхронізації, що дозволяє набору потоків всім очікувати, поки один одного дійде до загальної точки бар'єру. Бар'єр називається циклічним, оскільки його можна повторно використовувати після звільнення потоків очікування.

  CyclicBarrier barrier = new CyclicBarrier(3);
  barrier.await();

  Наприклад, зверніться до цього класу Concurrent_ParallelNotifyies .

• Фреймворк виконавця: ми можемо використовувати ExecutorService для створення пулу потоків і відстежуємо хід асинхронних завдань за допомогою Future.

  • submit(Runnable), submit(Callable)які повертають Майбутній об'єкт. За допомогою future.get()функції ми можемо блокувати основний потік, поки робочі потоки не завершать свою роботу.

  • invokeAll(...) - повертає список майбутніх об'єктів, за допомогою яких ви можете отримати результати виконання кожного Callable.

Знайдіть приклад використання інтерфейсів Runnable, Callable with Executor framework.

@Дивитися також

• З’ясувати, що нитка все ще жива?

Зберігайте Thread-об'єкти в деякій колекції (наприклад, у списку або наборі), а потім прокручуйте колекцію після запуску потоків і викликайте join () у Threads.

Для цього можна використовувати метод приєднання Threadf # .

Хоча це не стосується проблеми OP, якщо ви зацікавлені в синхронізації (точніше, rendez-vous) із точно одним потоком, ви можете використовувати Exchanger

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

Службу виконавця можна використовувати для управління кількома потоками, включаючи стан та завершення. Див. Http://programmingexamples.wikidot.com/executorservice

спробуйте це, буде працювати.

  Thread[] threads = new Thread[10];

  List<Thread> allThreads = new ArrayList<Thread>();

  for(Thread thread : threads){

        if(null != thread){

              if(thread.isAlive()){

                    allThreads.add(thread);

              }

        }

  }

  while(!allThreads.isEmpty()){

        Iterator<Thread> ite = allThreads.iterator();

        while(ite.hasNext()){

              Thread thread = ite.next();

              if(!thread.isAlive()){

                   ite.remove();
              }

        }

   }

У мене була подібна проблема, і я закінчив користуватися Java 8 паралельним потоком.

requestList.parallelStream().forEach(req -> makeRequest(req));

Це надзвичайно просто та читабельно. За лаштунками він використовує пул приєднання форків JVM за замовчуванням, що означає, що він буде чекати закінчення всіх потоків, перш ніж продовжувати. Для мого випадку це було акуратне рішення, оскільки це був єдиний паралельний потік у моїй програмі. Якщо у вас одночасно працює кілька паралельних потоків, прочитайте посилання нижче.

Більше інформації про паралельні потоки тут .

Існуючі відповіді сказали, що може join()кожна нитка.

Але є кілька способів отримати масив / список потоків:

• Додайте нитку до списку при створенні.
• Використовуйте ThreadGroupдля управління потоками.

Наступний код буде використовувати ThreadGruop підхід. Він створює групу спочатку, потім при створенні кожного потоку вказує групу в конструкторі, пізніше може отримати масив потоку черезThreadGroup.enumerate()

Код

SyncBlockLearn.java

import org.testng.Assert;
import org.testng.annotations.Test;

/**
 * synchronized block - learn,
 *
 * @author eric
 * @date Apr 20, 2015 1:37:11 PM
 */
public class SyncBlockLearn {
    private static final int TD_COUNT = 5; // thread count
    private static final int ROUND_PER_THREAD = 100; // round for each thread,
    private static final long INC_DELAY = 10; // delay of each increase,

    // sync block test,
    @Test
    public void syncBlockTest() throws InterruptedException {
        Counter ct = new Counter();
        ThreadGroup tg = new ThreadGroup("runner");

        for (int i = 0; i < TD_COUNT; i++) {
            new Thread(tg, ct, "t-" + i).start();
        }

        Thread[] tArr = new Thread[TD_COUNT];
        tg.enumerate(tArr); // get threads,

        // wait all runner to finish,
        for (Thread t : tArr) {
            t.join();
        }

        System.out.printf("\nfinal count: %d\n", ct.getCount());
        Assert.assertEquals(ct.getCount(), TD_COUNT * ROUND_PER_THREAD);
    }

    static class Counter implements Runnable {
        private final Object lkOn = new Object(); // the object to lock on,
        private int count = 0;

        @Override
        public void run() {
            System.out.printf("[%s] begin\n", Thread.currentThread().getName());

            for (int i = 0; i < ROUND_PER_THREAD; i++) {
                synchronized (lkOn) {
                    System.out.printf("[%s] [%d] inc to: %d\n", Thread.currentThread().getName(), i, ++count);
                }
                try {
                    Thread.sleep(INC_DELAY); // wait a while,
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.printf("[%s] end\n", Thread.currentThread().getName());
        }

        public int getCount() {
            return count;
        }
    }
}

Основний потік буде чекати закінчення всіх потоків у групі.

Я створив невеликий допоміжний метод, щоб зачекати, поки закінчиться кілька ниток:

public static void waitForThreadsToFinish(Thread... threads) {
        try {
            for (Thread thread : threads) {
                thread.join();
            }
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

Використовуйте це у своїй головній темі: while (! Executor.isTerminated ()); Помістіть цей рядок коду після запуску всіх потоків із служби виконавця. Це почне основний потік лише після того, як будуть завершені всі потоки, розпочаті виконавцями. Обов’язково зателефонуйте виконавцю.shutdown (); перед вищезазначеною петлею.