countdownlatch用法

CountDownLatch是Java中一种多线程并发编程工具，它可以让一个线程等待其他多个线程执行完毕后再执行。其用法是：首先创建一个CountDownLatch对象，然后在多个线程中并行执行任务，在最后一个线程执行结束时，调用CountDownLatch的countDown()方法，每次调用会让计数器减1；而等待这些线程的主线程则调用CountDownLatch的await()方法，该方法会使主线程等待直到计数器为0为止，然后主线程继续执行。通过CountDownLatch可以实现多线程的同步和协作。

相关问题

CountDownLatch用法

CountDownLatch是Java中提供的一个同步工具类，它可以用来控制一个或多个线程等待多个线程的操作完成。

CountDownLatch的用法如下：

1. 创建一个CountDownLatch对象，指定需要等待的线程数。

CountDownLatch latch = new CountDownLatch(5);

2. 每个需要等待的线程执行完后调用CountDownLatch的countDown方法减少计数器。

latch.countDown();

3. 等待所有线程执行完毕后，调用CountDownLatch的await方法进行等待。

latch.await();

4. 在所有线程执行完毕后，主线程或其他线程可以继续执行自己的操作。

示例代码：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(5);

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is working...");
                try {
                    // 模拟线程执行时间
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " done");
                latch.countDown();
            }).start();
        }

        System.out.println("Waiting for all threads to finish...");
        latch.await();
        System.out.println("All threads have finished, continue to execute the main thread.");
    }
}

运行结果：

Waiting for all threads to finish...
Thread-0 is working...
Thread-2 is working...
Thread-1 is working...
Thread-3 is working...
Thread-4 is working...
Thread-1 done
Thread-3 done
Thread-0 done
Thread-2 done
Thread-4 done
All threads have finished, continue to execute the main thread.

java countdownlatch用法

CountDownLatch是Java并发包中提供的一种同步工具类，它允许一个或多个线程等待其他线程完成操作后再执行。CountDownLatch内部维护着一个计数器，该计数器被初始化为一个正整数，表示需要等待的操作数量。每调用一次CountDownLatch的countDown()方法，计数器的值减1，当计数器的值减为0时，所有等待该计数器的线程将被唤醒。

下面是CountDownLatch的使用方法：

1. 创建CountDownLatch对象，并指定计数器的值。

CountDownLatch latch = new CountDownLatch(3);

2. 在需要等待的线程中调用await()方法，使线程等待。

try {
    latch.await();
} catch (InterruptedException e) {
    e.printStackTrace();
}

3. 在执行完成的线程中调用countDown()方法，使计数器的值减1。

latch.countDown();

4. 可以在主线程中等待所有线程完成后再执行其他操作。

try {
    latch.await();
    System.out.println("所有线程执行完成");
} catch (InterruptedException e) {
    e.printStackTrace();
}

下面是完整的示例代码：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(3);

        new Thread(() -> {
            System.out.println("线程1执行");
            latch.countDown();
        }).start();

        new Thread(() -> {
            System.out.println("线程2执行");
            latch.countDown();
        }).start();

        new Thread(() -> {
            System.out.println("线程3执行");
            latch.countDown();
        }).start();

        try {
            latch.await();
            System.out.println("所有线程执行完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

注意：CountDownLatch计数器的初始值必须大于0，否则调用await()方法会立即返回。如果计数器的值已经减为0，再调用countDown()方法也不会有任何效果。