Java并发——Java中的并发类工具

最新推荐文章于 2024-04-02 17:36:40 发布

tongdanping

最新推荐文章于 2024-04-02 17:36:40 发布

阅读量4.5k

点赞数

分类专栏： Java并发文章标签：并发工具类 CountDownLatch CyclicBarrier semaphore Exchanger

本文链接：https://blog.csdn.net/tongdanping/article/details/79589253

版权

Java并发专栏收录该内容

13 篇文章 17 订阅

订阅专栏

在JDK的并发包里面提供了几个非常有用的工具类：CountDwonLatch、CyclicBarrier、Semaphore、Exchanger。

其中CountDwonLatch、CyclicBarrier、Semaphore工具类提供了一种并发流程控制的手段，Exchanger提供了一种在线程间交换数据的手段。

一、四种并发工具类

1、CountDwonLatch（闭锁）

CountDwonLatch用来等待一个或者多个线程完成操作，作用类似于当前线程里调用join（）方法，让当前线程等待join（）进来的线程执行完毕再执行当前线程剩下的逻辑，但是CountDownLatch比join（）的功能更加强大，使用方法如下：

import java.util.concurrent.CountDownLatch;
class test{
    static CountDownLatch cdl = new CountDownLatch(2);   //①新建一个CountDwonLatch对象并传入计数器的值
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    System.out.println("thread 1: 1 ");
                    Thread.sleep(1000);
                    System.out.println("thread 1 : 2");
                    cdl.countDown();                   //②在被等待的线程或者步骤执行完毕后调用countDwon（）方法让计数器减1
                }
                catch(InterruptedException e){
                    e.printStackTrace();
                }

            }
        }).start();
        new Thread(new Runnable(){
            @Override
            public void run(){
                try{
                    System.out.println("thread 2 : 1");
                    Thread.sleep(1000);
                    System.out.println("thread 2 : 2");
                    cdl.countDown();
                }
                catch(InterruptedException e){
                    e.printStackTrace();
                }


            }        }).start();
        cdl.await();                                 //③在等待的主线程中调用await（）方法等待其他线程，知道计数器为0 再执行主线程接下来的逻辑
        System.out.println("thread : main");

    }

}

输出结果：

thread 1: 1 
thread 2 : 1
thread 1 : 2
thread 2 : 2
thread : main

CountDwonLatch的使用方法：

在CountDwonLatch中，countDwon（）方法和await（）方法搭配使用才能起到类似join（）的作用：

（1）首先创建一个CountDwonLatch对象并传入要等待的线程的数量，这是个计数器；

（2）在被等待的线程或者步骤执行完毕后调用countDwon（）方法让计数器减1，countDwon（）方法是一个等待的计数器，每次调用countDwon（）方法，计数器减1，直到计数器为0，countDwon可以用在任何地方，可以是一个步骤的一个点，也可以是一个线程。

（3）在等待其他线程的主线程中，调用await（）方法来等待其他调用了countDwon（）的线程，直到计数器为0，再执行该线程接下来的逻辑，当然，如果某个线程执行的时间过久，当前线程不可能一直等待，那么可以调用await（long time, TimeUnit unit）方法。

*注意：计数器大于0时才会阻塞当前线程，一旦计数器等于0就不会再阻塞调用await（）的当前线程；

在创建CountDwonLatch时传入计数器的初始值后，计数器就不能重新初始化了；

2、CyclicBarrier（同步屏障）

让一组线程到达一个屏障（或者同步点）时被阻塞，知道所有线程到达同步屏障后，同步屏障开门，所有线程继续执行。

同步屏障的使用：同步屏障有两种使用方式，从CyclicBarrier的构造方式撒谎个可以看出来

 //构造器 1
public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }

//构造器 2 
public CyclicBarrier(int parties) {
     this(parties, null);
}

构造器1：传入要阻塞的线程的数量parties和一个Runnable的对象，这个对象的作用是用于处理以下复杂的业务场景情形：当需要在第一个线程到达屏障前，前处理一个任务，这个任务可以写在barrierAction中。

构造器2：runnable对象为null说明只需要简单的等待其他线程到达同步屏障即可。

接下来举例说明两种同步屏障的使用：

构造器2：

（1）创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量；

（2）在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；

import java.util.concurrent.CyclicBarrier;
class test{
    static CyclicBarrier cb = new CyclicBarrier(2);  //创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量；
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    cb.await();    //在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
                    System.out.println(1);
                }
                catch(Exception e){
                    System.out.println("thread 1");
                }
            }
        }).start();
        try{
            cb.await();       //在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
            System.out.println(3);
        }
        catch(Exception e){
            System.out.println("main");
        }
    }

}

构造器1：

（1）创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量，和barrierAction对象；

（2）写一个实现Runnable接口的class，用于实现第一个线程到达同步屏障前的业务逻辑；

（3）在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；

import java.util.concurrent.CyclicBarrier;  
class test{
    static CyclicBarrier cb = new CyclicBarrier(2,new DoSomeThing()); //创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量，和barrierAction对象；
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    cb.await();             // 在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
                    System.out.println(1);
                }
                catch(Exception e){
                    System.out.println("thread 1");
                }
            }
        }).start();
        try{
            cb.await();
            System.out.println(2);
        }
        catch(Exception e){
            System.out.println("main");
        }
    }
    public static class DoSomeThing implements Runnable{  //写一个实现Runnable接口的class，用于实现第一个线程到达同步屏障前的业务逻辑；
        @Override
        public void run(){
            System.out.println("happen-before CyclicBarrier");
        }
    }
}

*注意：

因为cb.await( )方法会抛出InterruptedException和BrokenBarrierException异常，因此在子线程中要使用try-catch方法来捕捉这两种异常；

CyclicBarrier中的线程计数器可以使用reset（）方法重置；

在所有线程到达同步屏障后，并不是所有线程“同时”开始执行，而是使各个线程的启动时间降到最低；

3、Semaphore（信号量）

Semaphore用于流量控制，用于控制访问特定资源的线程数量，通过协调各个线程，以保证合理的使用公共资源。Semaphore就像公路上的交通信号灯或者收费站，用于控制车的流量，如果一条公路只允许10 个车通行，相当于在路口设置一个颁发通行证的收费站，一辆车只有收到了通行证才能进入这条公路，如果通行证颁发完毕了，那么其他的车就先等在收费站外面，如果公路上的车出了这条公路，那么他把通行证还给收费站，收费站又可以继续把通行证颁发给等在收费站外面的车。

Semaphore的使用方法：

（1）创建一个Semaphore对象，并传入一个int类型的参数，初始化通行证数量；

（2）在要占用公共资源的子线程业务逻辑前，调用s.acquire( )方法获得通行证，在实现业务逻辑后，调用release（）方法释放通行证；

import java.util.concurrent.Semaphore;
class test{
    static Semaphore s = new Semaphore(5);  //创建一个Semaphore对象，并传入一个int类型的参数，初始化通行证数量；
    public static void main(String[] args) throws InterruptedException {
        for(int i = 0; i<10; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        s.acquire(); //在要占用公共资源的子线程业务逻辑前，调用s.acquire( )方法获得通行证
                        System.out.println(Thread.currentThread() + "is saving data    " + "availablePermits:" + s.availablePermits() + "   getQueueLength:" + s.getQueueLength());
                        Thread.sleep(1000);
                        s.release();  //在实现业务逻辑后，调用release（）方法释放通行证；
                    }
                    catch(Exception e){
                        System.out.println("thread 1");
                    }

                }
            }).start();
        }

    }

}

输出结果：

Thread[Thread-3,5,main]is saving data    availablePermits:4   getQueueLength:0
Thread[Thread-7,5,main]is saving data    availablePermits:3   getQueueLength:0
Thread[Thread-0,5,main]is saving data    availablePermits:2   getQueueLength:0
Thread[Thread-4,5,main]is saving data    availablePermits:1   getQueueLength:0
Thread[Thread-8,5,main]is saving data    availablePermits:0   getQueueLength:0
Thread[Thread-2,5,main]is saving data    availablePermits:0   getQueueLength:4
Thread[Thread-6,5,main]is saving data    availablePermits:0   getQueueLength:3
Thread[Thread-1,5,main]is saving data    availablePermits:0   getQueueLength:2
Thread[Thread-5,5,main]is saving data    availablePermits:0   getQueueLength:1
Thread[Thread-9,5,main]is saving data    availablePermits:0   getQueueLength:0

可以发现，我们在代码中，有10个线程在执行，但是只有5个线程并发的执行，剩余的线程都在等待队列中。

Semaphore还有一些其他的方法：

boolean tryAcquire（）尝试获取通行证；

int getQueueLength( )获取等待队列（线程）的长度；

int availablePermits（）获取剩余可用的通行证数量；

boolean QueuedThreads( )是否有线程在等待获取通行证；

void reducePermits(int reduction)减少通行证数量，这是一个protedcted方法；

Cillection getQueuedThreads( )获取等待获取通行证的线程集合，这是个protected方法；

4、Exchanger（交换者）

Exchanger是一个线程间提供数据交换功能的写作工具，他提供了一个同步点，在这个同步点，两个线程可以交换彼此的数据。线程间通过调用excahange（）方法交换数据，如果第一个线程先到达同步点，执行exchange方法，那么他会一直在同步点等待第二个线程到达同步点，第二个线程也执行exchange方法，这时两个线程都到达同步点，可以交换彼此的数据。

使用：

（1）创建一个Exchanger对象；

（2）在要交换（同步）数据的同步点调用excr.exchange( )方法

import java.util.concurrent.Exchanger;
class test{
    static Exchanger<String> exc = new Exchanger<>();  //创建一个Exchanger对象；
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    String A= "银行流水A";
                    String B = exc.exchange(A); //在要交换（同步）数据的同步点调用excr.exchange(  )方法
                    System.out.println("A的视角： A、B流水是否一致：" + A.equals(B) + "   A录入的是：" + A + "   B录入的是：" + B);

                }
                catch(Exception e){
                    e.printStackTrace();
                }

            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    String B= "银行流水B";
                    String A = exc.exchange(B);  //在要交换（同步）数据的同步点调用excr.exchange(  )方法
                    System.out.println("B的视角： A、B流水是否一致：" + A.equals(B) + "   A录入的是：" + A + "   B录入的是：" + B);
                }
                catch(Exception e){
                    e.printStackTrace();
                }

            }
        }).start();

    }

}

输出：

B的视角： A、B流水是否一致：false   A录入的是：银行流水A   B录入的是：银行流水B
A的视角： A、B流水是否一致：false   A录入的是：银行流水A   B录入的是：银行流水B

可以看出，Exchanger的“交换”更偏向于数据的同步与共享，而不是“你的给我，我的给你”这样有来有回的交换，是“你知道一个信息，我知道另一个消息，我们彼此交换了信息，那么我们就都知道了两个消息”。如果不愿意在同步点一直等待另一个线程，那么可以用设置等待时间的exchange方法：excr.exchange(V x, long timeout, timeUnit unit)。

*注意：

Exchanger交换数据是成对的交换；

Exchanger可以看做双向的同步队列，一个线程从个队列头部进行操作，一个从个队列尾部进行操作；

二、并发工具类的使用场景

1、CountDwonLatch：一个线程等到其它几个线程执行完才能执行的场景；

2、CyclicBarrier：需要多线程的计算结果最后对这些结果进行合并的场景；

3、Semaphore：公共资源有限而并发线程较多的场景；

4、Exchanger：需要数据交换共享的场景，例如遗传算法中，需要选择两个人来交配，交换两人的数据并根据交换规则来得到交配结果，再例如用于校对工作，交换两个线程的数据，用于校对两个线程的数据是否相等；

三、并发工具类CountDwonLatch与CyclicBarrier的区别

1、CountDwonLatch阻塞一个线程，CyclicBarrier阻塞多个线程；

2、CountDwonLatch的计数器在构造对象时确定了就不能更改，但是CyclicBarrier可以使用reset（）方法重置计数器；

3、CyclicBarrier的功能更加丰富，比如int getWaitingNumber（）方法返回被阻塞在同步屏障的线程数，boolean isBroken（）方法返回是否有阻塞的线程被中断

tongdanping

关注

0
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
Java并发——Java中的并发类工具

在JDK的并发包里面提供了几个非常有用的工具类：CountDwonLatch、CyclicBarrier、Semaphore、Exchanger。其中CountDwonLatch、CyclicBarrier、Semaphore工具类提供了一种并发流程控制的手段，Exchanger提供了一种在线程间交换数据的手段。一、四种并发工具类1、CountDwonLatch（闭锁）CountDwonLatch...
复制链接

扫一扫