[Java并发包学习五]CountDownLatch和CyclicBarrier介绍

最新推荐文章于 2024-03-14 11:03:03 发布
最新推荐文章于 2024-03-14 11:03:03 发布
阅读量943 收藏 3
点赞数 1
分类专栏： Java 文章标签： java 并发

概述

JDK中提供了一些用于线程之间协同等待的工具类，CountDownLatch和CyclicBarrier就是最典型的两个线程同步辅助类。下面分别详细介绍这两个类，以及他们之间的异同点。

CountDownLatch类

CountDownLatch顾名思义：倒计数锁存器。没错，他就是一个计数器，并且是倒着计数的。他的应用场景如下：

一个任务A，他需要等待其他的一些任务都执行完毕之后它才能执行。就比如说赛跑的时候，发令员需要等待所有运动员都准备好了才能发令，否则不被K才怪嘞！

此时CountDownLatch就可以大展身手了。

常用操作

本节介绍CountDownLatch的基本操作函数。

构造函数

函数签名如下：

1

public CountDownLatch(int count)

用一个给定的数值初始化CountDownLatch，之后计数器就从这个值开始倒计数，直到计数值达到零。

await函数

await函数用两种形式，签名分别如下：

1
2

public void await() throws InterruptedException
public boolean await(long timeout, TimeUnit unit)

这两个函数的作用都是让线程阻塞等待其他线程，直到CountDownLatch的计数值变为0才继续执行之后的操作。区别在于第一个函数没有等待时间限制，可以等到天荒地老，海枯石烂，第二个函数给定一个等待超时时间，超过该时间就直接放弃了，并且第二个函数具有返回值，超时时间之内CountDownLatch的值达到0就返回true,等待时间结束计数值都还没达到0就返回false。这两个操作在等待过程中如果等待的线程被中断，则会抛出InterruptedException异常。

countDown函数

这个函数用来将CountDownLatch的计数值减一，函数签名如下：

1

public void countDown()

需要说明的是，如果调用这个函数的时候CountDownLatch的计数值已经为0，那么这个函数什么也不会做。

getCount函数

该函数用来获取当前CountDownLatch的计数值，函数签名如下：

1

public void countDown()

模拟实验

理论知识讲完了，需要真枪实战地来演示一下这个类的作用，我们就以下面这个场景为例子，用CountDownLatch来实现这个需求：

有5个运动员赛跑，开跑之前，裁判需要等待5个运动员都准备好才能发令，并且5个运动员准备好之后也都需要等待裁判发令才能开跑。

首先分析一下依赖关系：

裁判发令 -> 5个运动员都准备好；
5个运动员开跑 -> 裁判发令。

好，依赖关系已经出来了，代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

package com.winwill.test;

import java.util.Random;
import java.util.concurrent.CountDownLatch;

/**
 * @author qifuguang
 * @date 15/8/24 23:35
 */
public class TestCountDownLatch {
    private static final int RUNNER_NUMBER = 5; // 运动员个数
    private static final Random RANDOM = new Random();

    public static void main(String[] args) {
        // 用于判断发令之前运动员是否已经完全进入准备状态，需要等待5个运动员，所以参数为5
        CountDownLatch readyLatch = new CountDownLatch(RUNNER_NUMBER);
        // 用于判断裁判是否已经发令，只需要等待一个裁判，所以参数为1
        CountDownLatch startLatch = new CountDownLatch(1);
        for (int i = 0; i < RUNNER_NUMBER; i++) {
            Thread t = new Thread(new Runner((i + 1) + "号运动员", readyLatch, startLatch));
            t.start();
        }
        try {
            readyLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        startLatch.countDown();
        System.out.println("裁判：所有运动员准备完毕，开始...");
    }

    static class Runner implements Runnable {
        private CountDownLatch readyLatch;
        private CountDownLatch startLatch;
        private String name;

        public Runner(String name, CountDownLatch readyLatch, CountDownLatch startLatch) {
            this.name = name;
            this.readyLatch = readyLatch;
            this.startLatch = startLatch;
        }

        public void run() {
            int readyTime = RANDOM.nextInt(1000);
            System.out.println(name + "：我需要" + readyTime + "秒时间准备.");
            try {
                Thread.sleep(readyTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "：我已经准备完毕.");
            readyLatch.countDown();
            try {
                startLatch.await();  // 等待裁判发开始命令
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "：开跑...");
        }
    }
}

运行结果如下：

1号运动员：我需要389秒时间准备.
2号运动员：我需要449秒时间准备.
3号运动员：我需要160秒时间准备.
4号运动员：我需要325秒时间准备.
5号运动员：我需要978秒时间准备.
3号运动员：我已经准备完毕.
4号运动员：我已经准备完毕.
1号运动员：我已经准备完毕.
2号运动员：我已经准备完毕.
5号运动员：我已经准备完毕.
裁判：所有运动员准备完毕，开始…
1号运动员：开跑…
5号运动员：开跑…
2号运动员：开跑…
4号运动员：开跑…
3号运动员：开跑…

可以看到，一切都是如此地完美，运动员准备好了之后裁判才发令，裁判发令之后运动员才开跑。

CyclicBarrier类

CyclicBarrier翻译过来就是：循环的屏障。什么是循环？可以重复利用呗，对这个类就是一个可以重复利用的屏障类。CyclicBarrier主要用于一组固定大小的线程之间，各个线程之间相互等待，当所有线程都完成某项任务之后，才能执行之后的任务。
如下场景：

有若干个线程都需要向一个数据库写数据，但是必须要所有的线程都讲数据写入完毕他们才能继续做之后的事情。

分析一下这个场景的特征：

  • 各个线程都必须完成某项任务(写数据)才能继续做后续的任务；
  • 各个线程需要相互等待，不能独善其身。

这种场景便可以利用CyclicBarrier来完美解决。

常用函数

本节介绍CyclicBarrier的基本操作函数。

构造函数

有两种类型的构造函数，函数签名分别如下：

1
2

public CyclicBarrier(int parties, Runnable barrierAction)
public CyclicBarrier(int parties)

参数parties表示一共有多少线程参与这次“活动”，参数barrierAction是可选的，用来指定当所有线程都完成这些必须的“神秘任务”之后需要干的事情，所以barrierAction这里的动作在一个相互等待的循环内只会执行一次。

getParties函数

getParties用来获取当前的CyclicBarrier一共有多少线程参数与，函数签名如下：

1

public int getParties()

返回参与“活动”的线程个数。

await函数

await函数用来执行等待操作，有两种类型的函数签名：

1
2
3
4
5

public int await() throws InterruptedException, BrokenBarrierException
public int await(long timeout, TimeUnit unit)
        throws InterruptedException,
               BrokenBarrierException,
               TimeoutException

第一个函数是一个无参函数，第二个函数可以指定等待的超时时间。它们的作用是：一直等待知道所有参与“活动”的线程都调用过await函数，如果当前线程不是即将调用await函数的的最后一个线程，当前线程将会被挂起，直到下列某一种情况发生：

  • 最后一个线程调用了await函数；
  • 某个线程打断了当前线程；
  • 某个线程打断了其他某个正在等待的线程；
  • 其他某个线程等待时间超过给定的超时时间；
  • 其他某个线程调用了reset函数。

如果等待过程中线程被打断了，则会抛出InterruptedException异常；
如果等待过程中出现下列情况中的某一种情况，则会抛出BrokenBarrierException异常：

  • 其他线程被打断了；
  • 当前线程等待超时了；
  • 当前CyclicBarrier被reset了；
  • 等待过程中CyclicBarrier损坏了；
  • 构造函数中指定的barrierAction在执行过程中发生了异常。

如果等待时间超过给定的最大等待时间，则会抛出TimeoutException异常，并且这个时候其他已经嗲用过await函数的线程将会继续后续的动作。

返回值：返回当前线程在调用过await函数的所以线程中的编号，编号为parties-1的表示第一个调用await函数，编号为0表示是最后一个调用await函数。

isBroken函数

给函数用来判断barrier是否已经损坏，函数签名如下：

1

public boolean isBroken()

如果因为任何原因被损坏返回true，否则返回false。

reset函数

顾名思义，这个函数用来重置barrier，函数签名如下：

1

public void reset()

如果调用了该函数，则在等待的线程将会抛出BrokenBarrierException异常。

getNumberWaiting函数

该函数用来获取当前正在等待该barrier的线程数，函数签名如下：

1

public int getNumberWaiting()

模拟实验

下面用代码实现下面的场景：

有5个线程都需要向一个数据库写数据，但是必须要所有的线程都讲数据写入完毕他们才能继续做之后的事情。

一般情况

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

package com.winwill.test;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author qifuguang
 * @date 15/8/25 00:34
 */
public class TestCyclicBarrier {
    private static final int THREAD_NUMBER = 5;
    private static final Random RANDOM = new Random();

    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(THREAD_NUMBER, new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getId() + "：我宣布，所有小伙伴写入数据完毕");
            }
        });
        for (int i = 0; i < THREAD_NUMBER; i++) {
            Thread t = new Thread(new Worker(barrier));
            t.start();
        }
    }

    static class Worker implements Runnable {
        private CyclicBarrier barrier;

        public Worker(CyclicBarrier barrier) {
            this.barrier = barrier;
        }

        public void run() {
            int time = RANDOM.nextInt(1000);
            System.out.println(Thread.currentThread().getId() + "：我需要" + time + "毫秒时间写入数据.");
            try {
                Thread.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getId() + "：写入数据完毕，等待其他小伙伴...");
            try {
                barrier.await(); // 等待所有线程都调用过此函数才能进行后续动作
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getId() + "：所有线程都写入数据完毕，继续干活...");
        }
    }
}

运行结果如下：

10：我需要16毫秒时间写入数据.
11：我需要353毫秒时间写入数据.
12：我需要101毫秒时间写入数据.
13：我需要744毫秒时间写入数据.
14：我需要51毫秒时间写入数据.
10：写入数据完毕，等待其他小伙伴…
14：写入数据完毕，等待其他小伙伴…
12：写入数据完毕，等待其他小伙伴…
11：写入数据完毕，等待其他小伙伴…
13：写入数据完毕，等待其他小伙伴…
13：我宣布，所有小伙伴写入数据完毕
13：所有线程都写入数据完毕，继续干活…
10：所有线程都写入数据完毕，继续干活…
12：所有线程都写入数据完毕，继续干活…
14：所有线程都写入数据完毕，继续干活…
11：所有线程都写入数据完毕，继续干活…

可以看到，线程小伙伴们非常团结，写完自己的数据之后都在等待其他小伙伴，所有小伙伴都完成之后才继续后续的动作。

重复使用

上面的例子并没有体现CyclicBarrier可以循环使用的特点，所以有如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

package com.winwill.test;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author qifuguang
 * @date 15/8/25 00:34
 */
public class TestCyclicBarrier {
    private static final int THREAD_NUMBER = 5;
    private static final Random RANDOM = new Random();

    public static void main(String[] args) throws Exception {
        CyclicBarrier barrier = new CyclicBarrier(THREAD_NUMBER, new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getId() + "：我宣布，所有小伙伴写入数据完毕");
            }
        });
        for (int i = 0; i < THREAD_NUMBER; i++) {
            Thread t = new Thread(new Worker(barrier));
            t.start();
        }
        Thread.sleep(10000);
        System.out.println("================barrier重用==========================");
        for (int i = 0; i < THREAD_NUMBER; i++) {
            Thread t = new Thread(new Worker(barrier));
            t.start();
        }
    }

    static class Worker implements Runnable {
        private CyclicBarrier barrier;

        public Worker(CyclicBarrier barrier) {
            this.barrier = barrier;
        }

        public void run() {
            int time = RANDOM.nextInt(1000);
            System.out.println(Thread.currentThread().getId() + "：我需要" + time + "毫秒时间写入数据.");
            try {
                Thread.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getId() + "：写入数据完毕，等待其他小伙伴...");
            try {
                barrier.await(); // 等待所有线程都调用过此函数才能进行后续动作
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getId() + "：所有线程都写入数据完毕，继续干活...");
        }
    }
}

运行结果：

10：我需要228毫秒时间写入数据.
11：我需要312毫秒时间写入数据.
12：我需要521毫秒时间写入数据.
13：我需要720毫秒时间写入数据.
14：我需要377毫秒时间写入数据.
10：写入数据完毕，等待其他小伙伴…
11：写入数据完毕，等待其他小伙伴…
14：写入数据完毕，等待其他小伙伴…
12：写入数据完毕，等待其他小伙伴…
13：写入数据完毕，等待其他小伙伴…
13：我宣布，所有小伙伴写入数据完毕
13：所有线程都写入数据完毕，继续干活…
10：所有线程都写入数据完毕，继续干活…
11：所有线程都写入数据完毕，继续干活…
14：所有线程都写入数据完毕，继续干活…
12：所有线程都写入数据完毕，继续干活…
================barrier重用==========================
15：我需要212毫秒时间写入数据.
16：我需要691毫秒时间写入数据.
17：我需要530毫秒时间写入数据.
18：我需要758毫秒时间写入数据.
19：我需要604毫秒时间写入数据.
15：写入数据完毕，等待其他小伙伴…
17：写入数据完毕，等待其他小伙伴…
19：写入数据完毕，等待其他小伙伴…
16：写入数据完毕，等待其他小伙伴…
18：写入数据完毕，等待其他小伙伴…
18：我宣布，所有小伙伴写入数据完毕
18：所有线程都写入数据完毕，继续干活…
15：所有线程都写入数据完毕，继续干活…
19：所有线程都写入数据完毕，继续干活…
16：所有线程都写入数据完毕，继续干活…
17：所有线程都写入数据完毕，继续干活…

可以看到，barrier的确是重用了。

等待超时

如果await的时候设置了一个最长等待时间，并且等待超时，则会怎么样呢？下面的例子故意让一个线程延迟一段时间才开始写数据，这样就会出现先等待的线程等待最后一个线程抛出等待超时异常的情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

package com.winwill.test;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * @author qifuguang
 * @date 15/8/25 00:34
 */
public class TestCyclicBarrier {
    private static final int THREAD_NUMBER = 5;
    private static final Random RANDOM = new Random();

    public static void main(String[] args) throws Exception {
        CyclicBarrier barrier = new CyclicBarrier(THREAD_NUMBER, new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getId() + "：我宣布，所有小伙伴写入数据完毕");
            }
        });
        for (int i = 0; i < THREAD_NUMBER; i++) {
            if (i < THREAD_NUMBER - 1) {
                Thread t = new Thread(new Worker(barrier));
                t.start();
            } else {  //最后一个线程故意延迟3s创建。
                Thread.sleep(3000);
                Thread t = new Thread(new Worker(barrier));
                t.start();
            }
        }
    }

    static class Worker implements Runnable {
        private CyclicBarrier barrier;

        public Worker(CyclicBarrier barrier) {
            this.barrier = barrier;
        }

        public void run() {
            int time = RANDOM.nextInt(1000);
            System.out.println(Thread.currentThread().getId() + "：我需要" + time + "毫秒时间写入数据.");
            try {
                Thread.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getId() + "：写入数据完毕，等待其他小伙伴...");
            try {
                barrier.await(2000, TimeUnit.MILLISECONDS); // 只等待2s，必然会等待最后一个线程超时
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getId() + "：所有线程都写入数据完毕，继续干活...");
        }
    }
}

运行结果：

10：我需要820毫秒时间写入数据.
11：我需要140毫秒时间写入数据.
12：我需要640毫秒时间写入数据.
13：我需要460毫秒时间写入数据.
11：写入数据完毕，等待其他小伙伴…
13：写入数据完毕，等待其他小伙伴…
12：写入数据完毕，等待其他小伙伴…
10：写入数据完毕，等待其他小伙伴…
java.util.concurrent.BrokenBarrierException
12：所有线程都写入数据完毕，继续干活…
at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
13：所有线程都写入数据完毕，继续干活…
11：所有线程都写入数据完毕，继续干活…
10：所有线程都写入数据完毕，继续干活…
at com.winwill.test.TestCyclicBarrier$Worker.run(TestCyclicBarrier.java:52)
at java.lang.Thread.run(Thread.java:744)
java.util.concurrent.BrokenBarrierException
at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
at com.winwill.test.TestCyclicBarrier$Worker.run(TestCyclicBarrier.java:52)
at java.lang.Thread.run(Thread.java:744)
java.util.concurrent.TimeoutException
at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:257)
at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
at com.winwill.test.TestCyclicBarrier$Worker.run(TestCyclicBarrier.java:52)
at java.lang.Thread.run(Thread.java:744)
java.util.concurrent.BrokenBarrierException
at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
at com.winwill.test.TestCyclicBarrier$Worker.run(TestCyclicBarrier.java:52)
at java.lang.Thread.run(Thread.java:744)
14：我需要850毫秒时间写入数据.
java.util.concurrent.BrokenBarrierException
14：写入数据完毕，等待其他小伙伴…
14：所有线程都写入数据完毕，继续干活…
at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
at com.winwill.test.TestCyclicBarrier$Worker.run(TestCyclicBarrier.java:52)
at java.lang.Thread.run(Thread.java:744)

可以看到，前面四个线程等待最后一个线程超时了，这个时候他们不再等待最后这个小伙伴了，而是抛出异常并都继续后续的动作。最后这个线程屁颠屁颠地完成写入数据操作之后也继续了后续的动作。需要说明的是，发生了超时异常时候，还没有完成“神秘任务”的线程在完成任务之后不会做任何等待，而是会直接执行后续的操作。

总结

CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

  • CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；
  • CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；
  • CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

注意事项

转载请注明出处：http://qifuguang.me/2015/08/25/[Java并发包学习五]CountDownLatch和CyclicBarrier介绍

hechurui
关注
专栏目录
java线程工具-CountDownLatch和CyclicBarrier使用详解
wendao76的专栏
09-21 287
是一种用于线程间同步的工具类，它允许一个或多个线程等待其他线程完成操作。它的工作原理是通过一个计数器来控制，当计数器的值降为零时，所有等待的线程将被释放。中提供的同步辅助类，用于协调多线程程序中的线程执行顺序。尽管它们有相似之处，但各自的设计目的和使用场景有所不同。是一种可以让一组线程相互等待，直到最后一个线程到达屏障点时再一起执行的工具。都是 Java 并发编程中很有用的工具，选择哪种工具取决于具体的应用场景和需求。可以被重用，即当所有线程都到达屏障点后，都是 Java 并发包。可以被重置以供下次使用。
Java 并发包与锁机制：深入了解Java的并发包，锁，以及异步编程，了解并使用ConcurrentHashMap, CountDownLatch, CyclicBarrier等并发工具类
最新发布
哎 你看的博客
05-29 1053
一、Java并发编程基础 Java线程模型 Java 内存模型 Java 并发包的设计目标与原则 二、Java 并发包中的重要类 ConcurrentHashMap：用于高并发的HashMap CountDownLatch：倒数计数器 CyclicBarrier: 循环阻塞同步工具 Semaphore: 多个线程控制访问共享资源的工具类 Phaser：更加灵活的CyclicBarrier 三、Java中的锁 Synchronized锁及其实现机制 Lock接口与实现类，与synchronized锁的比较
CountDownLatch和CyclicBarrier介绍
ccfeng
10-25 549
概述 JDK中提供了一些用于线程之间协同等待的工具类，CountDownLatch和CyclicBarrier就是最典型的两个线程同步辅助类。下面分别详细介绍这两个类，以及他们之间的异同点。 CountDownLatch类 CountDownLatch顾名思义：倒计数锁存器。没错，他就是一个计数器，并且是倒着计数的。他的应用场景如下： 一个任务A，他需要等待其他的一些任务都执行完毕
CountDownLatch与CyclicBarrier
weixin_44442186的博客
04-06 1174
CountDownLatch与CyclicBarrier区别 CountDownLatch JUC包下的并发工具类CountDownLatch，CountDownLatch为递减计数器，用于控制一个线 程等待多个线程。维护一个计数器count，表示需要等待的事件数量，countdown方法递减计数 器，表示事件发生，调用await()方法的线程会一直阻塞直到计数器为零，或者等待中的线程中断， 或者等待超时 CyclicBarrier CyclicBarrier，循环栅栏可以让一组线程等待至某个状态之后再全部
关于CyclicBarrier的使用介绍
橙子君的博客
03-16 3752
关于CyclicBarrier的使用介绍 前言：假如周末聚会，先到的人要等待还没有达到的人，要等到人到齐了之后才能开始吃饭，那么对于这种场景，用代码如何表示呢… 1.CyclicBarrier什么鬼 从字面上来看，Cyclic（可循环使用）Barrier（屏障）。它的功能是让一组线程达到一个屏障或者公共点时被阻塞，直到最后一个线程也到达屏障时，才会打开屏障，所有被屏障拦截的线程才会继续运行。 C...
谈谈CountDownLatch和CyclicBarrier
zalan01408980的博客
06-15 273
Java中CountDownLatch和CyclicBarrier都是用来做多线程同步的。下面分析一下他们功能的异同。 CountDownLatch CountDownLatch基于AQS(同步器AbstractQueueSynchronized)，CountDownLatch中有一个内部类Sync，Sync继承自AbstractQueuedSynchronizer。 我们先看一个CountDownLatch的例子，然后再具体分析源码。 一个CountDownLatch例子 import j.
并发编程学习笔记 之 工具类CountDownLatch、CyclicBarrier详解
向心行者
07-12 577
  CountDownLatch类允许一个或者多个线程去等待其他线程完成操作。CountDownLatch构建时接收一个int型参数，表示要等待的工作线程的个数，每个子任务执行完成后使用countDown方法进行减1操作，等待线程使用await方法进行等待操作，直到所有子任务完成，等待线程就会被唤起执行。  创建子线程，模拟执行任务，当子任务执行完成后，主线程被唤醒继续执行，具体实现如下： CountDownLatch常用方法 1、Sync 内部类   CountDownLatch通过内部类Sync来实现
Java并发编程Java并发包里面的CountDownLatch和CyclicBarrier
qq_35146979的博客
04-30 197
学习Java的并发编程是一件困难的事情，接触软件6年一直有编发编程的概念，但是一直没有真正懂得什么是并发编程，面对这个技术领域的学习困难，我分析了一下原因，分为以下几点： 学习坡度陡峭 无法根据一些定义了解全貌 需要了解枝节然后分析这个并发的知识树才能入门 解决方案，需要痛下决心，用力啃下这块硬骨头，接下来分析一下Java并发包里面的CountDownLatch和CyclicBarrier然后反复观看这个文章，不断的刻意使用到你的项目中去。 优化一下对账系统，虚拟一个场景，一个报表功能需要进行用户I
详解java CountDownLatch和CyclicBarrier在内部实现和场景上的区别
08-19
首先，CountDownLatch的内部实现基于Java并发包（java.util.concurrent）中的AbstractQueuedSynchronizer（AQS）类。AQS是一个抽象类，提供了线程同步的基础框架，它使用一个整型状态变量（在这里是count）来管理...
【Java核心-进阶】Semaphore、CountDownLatch、CyclicBarrier、Phaser
一个被IT搞的
01-10 377
Java并发包中有很多可以实现同步的结构。以下几种就属于典型的“非显式”锁： Semaphore：Java版本的信号量实现。 CountDownLatch：允许一个或多个线程等待某些操作完成。 CyclicBarrier：允许多个线程等待达到某个屏障。 Phaser：分阶段地等待多个线程达到某个屏障。 CountDownLatch vs CyclicBarr...
countDownLatch和CyclicBarrier
qq_43437044的博客
08-18 903
countDownLatch countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。 是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。 CyclicBarrier 从字面上的意思可以知道，这个类的中文意思是“循环栅栏”。大概的意思就是一个可循环利用的屏障。它的作用就是会让所有线程都等待完成后才会继续下一步行动。 就像生活中我们会约朋友们到某个餐厅
CountDownLatch与CyclicBarrier分析及其区别
Lisam Blog
12-08 1490
相同点： CountDownLatch、CyclicBarrier均在jdk1.5引入的，并且都在concurrent包(用于并发处理)下。均用于实现线程同步。差异点： 1 CountDownLatch计数器只能使用一次。CyclicBarrier则可以调用其reset()方法进行重置多次使用(在计算错误时可重置后再计算)。 2 CountDownLatch使用countDown()+await(...
CountDownLatch和CyclicBarrier区别和用法
张步云的专栏
07-17 711
CountDownLatch和CyclicBarrier都是juc下的并发工具类，二者功能在处理某些事情下看着很相似：都是阻塞线程，但是如果细品和查看源码的话会发现二者之间还是有区别的，本文从各个角度+源码+例子来做了各种对比和测试，一目了然。
JUC学习笔记 -- (11) CyclicBarrier介绍及其与CountDownLatch的区别
YellowStar的博客
11-12 401
CyclicBarrier是多线程中一个常用的辅助类，主要用于线程组内部之间的线程的相互等待问题。  CyclicBarrier根据英文拆分翻译可翻译为:可循环利用的屏障。顾名思义，首先，便是可重复利用，说明该类创建的对象可以复用；其次，屏障则体现了该类的原理：每个线程执行时，都会碰到一个屏障，直到所有线程执行结束，然后屏障便会打开，使所有线程继续往下执行。大致功效可以理解为：等待集合继续执行。...
CountDownLatch和CyclicBarrier有什么区别？
mischen520的博客
09-16 837
3.CyclicBarrier提供getNumberWaiting()方法，可以获得CyclicBarrier阻塞的线程数量，还提供isBroken()方法，可以判断阻塞的线程是否被中断，等等。2.CyclicBarrier能处理更为复杂的业务场景，比如计算发生错误，可以结束阻塞，重置计算器，重新执行程序。4.CountDownLatch会阻塞主线程，CyclicBarrier不会阻塞主线程，只会阻塞子线程。
CyclicBarrier和CountDownLatch使用上的区别
程序员青戈
08-20 4164
我在使用并发线程栅栏的时候发现了两种，分别是CyclicBarrier 和CountDownLatch。对于两者的对比的文章有很多，这里不再赘述。我来说下我的使用过程。 需求：有三位运动员，他们一起参加万米赛跑，但是他们准备的时间不同，要等他们都准备好了再开始一起跑。 使用CyclicBarrier 实现： import java.util.concurrent.*; public cla...
CountDownLatch与CyclicBarrier详解
任凭本心的博客
03-14 1263
本文详细介绍CountDownLatch与CyclicBarrier，以及其中容易发生的问题
CountDownLatch和CyclicBarrier详解
m0_54187478的博客
11-12 334
CountDownLatch 是 Java 中并发包（java.util.concurrent）提供的一种同步工具，用于在多线程环境中协调多个线程之间的执行顺序。它的作用是允许一个或多个线程等待其他线程完成操作。CountDownLatch 通过一个计数器来实现，计数器的初始值由用户设置，每当一个线程完成一项任务后，计数器的值就会减一。当计数器的值变为零时，等待在 CountDownLatch 上的线程就会被唤醒，可以继续执行。
CountDownLatch 和 CyclicBarrier
瞎叨叨的一天的博客
07-08 241
CountDownLatch 主要是用来解决一个线程等待多个线程的场景，而 CyclicBarrier 是一个屏障拦截多个线程。
深入理解Java并发包：集合篇综述
本篇Java分布式应用学习笔记主要关注的是JDK中的并发包及其在多线程和分布式环境中的应用总结。Java并发包，主要包括`java.util.concurrent`，是Java语言提供的一种高效、可扩展的并发编程工具集。这些包提供了多种...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值