java中常用的并发工具类有哪些？

被冻感冒的脚趾头

已于 2022-02-14 11:03:59 修改

阅读量447

点赞数

文章标签： java 开发语言后端多线程

于 2022-02-13 22:18:40 首次发布

原文链接：https://mp.weixin.qq.com/s/vil323dgIjWwoLBWckkhpw

版权

Semaphore(信号量)-允许多个线程同时访问：synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。

信号量的用法也很简单，定义信号量时会初始化一个数量，可以理解为一块令牌，每当release的时候，就相当于给阻塞的acquire方法发一个令牌，acquire方法才由阻塞状态变为可通行状态。案例中，初始化为0，意味着只有别人release的时候，acquire才能获得一块令牌通行；当初始化为1的时候，acquire方法可以直接通行，但是初始化的值相应减少1，如果要再次调用acquire方法，就会阻塞，需要等到别的线程给令牌（调用release方法），acquire方法才能执行。

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Semaphore;
 
/**
 * 实现一个容器，提供add，size方法
 * 两个线程，线程一添加十个元素到容器中，线程二监控元素的个数，当个数到5时，线程二给出提示并结束
 *
 * @author zab
 * @date 2019-10-20 21:54
 */
public class ThreadCommunicationTest {
 
    private volatile MyContainer myContainer = new MyContainer();
 
    Semaphore semaphore1 = new Semaphore(0);
    Semaphore semaphore2 = new Semaphore(0);
 
    public void f1() {
        for (int i = 1; i <= 10; i++) {
            myContainer.add("test");
            System.out.println("add" + i);
            if (i == 5) {
                semaphore1.release();
                try {
                    semaphore2.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
    public void f2() {
        try {
            semaphore1.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("size等于5啦！！！");
        semaphore2.release();
    }
 
 
 
    public static void main(String[] args) {
        ThreadCommunicationTest t = new ThreadCommunicationTest();
        new Thread(t::f2).start();
        new Thread(t::f1).start();
    }
}
 
class MyContainer {
    List<String> list = new LinkedList<>();
 
    public void add(String s) {
        list.add(s);
    }
 
    public int size() {
        return list.size();
    }
 
}

CountDownLatch(倒计时器)：CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。

门栓定义的时候，传入一个值，每调用一次countDown方法，就减少一，当减少到0，门栓对应的await方法就由阻塞状态释放。

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.LockSupport;
 
/**
 * 实现一个容器，提供add，size方法
 * 两个线程，线程一添加十个元素到容器中，线程二监控元素的个数，当个数到5时，线程二给出提示并结束
 *
 * @author zab
 * @date 2019-10-20 21:54
 */
public class ThreadCommunicationTest4 {
 
    private volatile MyContainer4 myContainer4 = new MyContainer4();
    CountDownLatch latch = new CountDownLatch(5);
    CountDownLatch latch1 = new CountDownLatch(1);
 
    public void f1() {
 
        for (int i = 1; i <= 10; i++) {
            myContainer4.add("test");
            System.out.println("add" + i);
            latch.countDown();
            if (i == 5) {
                try {
                    latch1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
 
    }
 
    public void f2() {
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("size等于5啦！！！");
        latch1.countDown();
    }
 
 
    public static void main(String[] args) {
        ThreadCommunicationTest4 t = new ThreadCommunicationTest4();
        new Thread(t::f2).start();
        new Thread(t::f1).start();
    }
}
 
class MyContainer4 {
    List<String> list = new LinkedList<>();
 
    public void add(String s) {
        list.add(s);
    }
 
    public int size() {
        return list.size();
    }
 
}

CyclicBarrier(循环栅栏)：CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await()方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。

模拟一个场景，我们去公司上班，会在某个地方等公司班车，班车司机会先后到达乘车点，装满一车人就会开往公司。这个类似于CyclicBarrier的作用，一个新起的线程（一个人）过来遇到await方法，就会阻塞（坐车上等着），但是阻塞到循环屏障定义的次数（理解为装满人了）后，就放行所有线程（发车了），并且调用定义的方法。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
 * 
* @author zab
* @date 2019-11-09 18:44
*/
public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(20,()->System.out.println("满二十人，发车"));
        for (int i = 0; i < 100; i++) {
           new Thread(new Runnable(){
                @Override
                public void run() {
                    try {
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

输出的结果是：