J.U.C工具包之CountDownLatch

技术2020年8月4日

什么是CountDownLatch：

countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。

是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。

例子：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        new CountDownLatchDemo().test();
    }

    private void test() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        new Thread(new Task(countDownLatch), "Thread1").start();
        new Thread(new Task(countDownLatch), "Thread2").start();
        new Thread(new Task(countDownLatch), "Thread3").start();
        countDownLatch.await();
        System.out.println("all thread finished, count is:" + countDownLatch.getCount());

    }

    class Task implements Runnable {
        private CountDownLatch countDownLatch;

        public Task(CountDownLatch coutDownLatch) {
            this.countDownLatch = coutDownLatch;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread:" + Thread.currentThread().getName() + " count");
            countDownLatch.countDown();
        }
    }
}

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

public static void main(String[] args) throws InterruptedException {

new CountDownLatchDemo().test();

}

private void test() throws InterruptedException {

CountDownLatch countDownLatch = new CountDownLatch(3);

new Thread(new Task(countDownLatch), "Thread1").start();

new Thread(new Task(countDownLatch), "Thread2").start();

new Thread(new Task(countDownLatch), "Thread3").start();

countDownLatch.await();

System.out.println("all thread finished, count is:" + countDownLatch.getCount());

}

class Task implements Runnable {

private CountDownLatch countDownLatch;

public Task(CountDownLatch coutDownLatch) {

this.countDownLatch = coutDownLatch;

}

@Override

public void run() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Thread:" + Thread.currentThread().getName() + " count");

countDownLatch.countDown();

}

执行结果：

Thread:Thread3 count
Thread:Thread1 count
Thread:Thread2 count
all thread finished, count is:0

Thread:Thread3 count

Thread:Thread1 count

Thread:Thread2 count

all thread finished, count is:0

再来一个模拟并发的示例：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Parallellimit {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            Task runnable = new Task(countDownLatch);
            executorService.execute(runnable);
        }
    }
}

class Task implements Runnable {
    private CountDownLatch countDownLatch;

    public Task(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        try {
            synchronized (countDownLatch) {
                // 每执行一次计数器减1
                countDownLatch.countDown();
                System.out.println("Thread name: " + Thread.currentThread().getName() + ", thread counts = "
                    + (countDownLatch.getCount()));
            }
            // 阻塞直到所有执行完成，计数器为0
            countDownLatch.await();
            System.out.println("Thread name: " + Thread.currentThread().getName() + " finish");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Parallellimit {

public static void main(String[] args) {

ExecutorService executorService = Executors.newCachedThreadPool();

CountDownLatch countDownLatch = new CountDownLatch(5);

for (int i = 0; i < 5; i++) {

Task runnable = new Task(countDownLatch);

executorService.execute(runnable);

}

class Task implements Runnable {

private CountDownLatch countDownLatch;

public Task(CountDownLatch countDownLatch) {

this.countDownLatch = countDownLatch;

}

@Override

public void run() {

try {

synchronized (countDownLatch) {

// 每执行一次计数器减1

countDownLatch.countDown();

System.out.println("Thread name: " + Thread.currentThread().getName() + ", thread counts = "

+ (countDownLatch.getCount()));

}

// 阻塞直到所有执行完成，计数器为0

countDownLatch.await();

System.out.println("Thread name: " + Thread.currentThread().getName() + " finish");

} catch (InterruptedException e) {

e.printStackTrace();

}

执行结果：

Thread name: pool-1-thread-1, thread counts = 4
Thread name: pool-1-thread-5, thread counts = 3
Thread name: pool-1-thread-3, thread counts = 2
Thread name: pool-1-thread-4, thread counts = 1
Thread name: pool-1-thread-2, thread counts = 0
Thread name: pool-1-thread-1 finish
Thread name: pool-1-thread-4 finish
Thread name: pool-1-thread-3 finish
Thread name: pool-1-thread-5 finish
Thread name: pool-1-thread-2 finish

Thread name: pool-1-thread-1, thread counts = 4

Thread name: pool-1-thread-5, thread counts = 3

Thread name: pool-1-thread-3, thread counts = 2

Thread name: pool-1-thread-4, thread counts = 1

Thread name: pool-1-thread-2, thread counts = 0

Thread name: pool-1-thread-1 finish

Thread name: pool-1-thread-4 finish

Thread name: pool-1-thread-3 finish

Thread name: pool-1-thread-5 finish

Thread name: pool-1-thread-2 finish

J.U.C工具包之CountDownLatch

暂无评论

发表评论取消回复

J.U.C工具包之CountDownLatch

发表评论 取消回复

发表评论取消回复