JUC常用工具类

文章目录

    • 1.JUC
      • 1.1 CountDownLatch
        • 1.1.1 介绍
        • 1.1.2 举例
        • 1.1.3 注意
      • 1.2 CyclicBarrier
        • 1.2.1 介绍
        • 1.2.2 举例
        • 1.2.3 注意
      • 1.3 Semaphore
        • 1.3.1 介绍
        • 1.3.2 举例
        • 1.3.3 注意
      • 1.4 Exchanger
        • 1.4.1 介绍
        • 1.4.2 举例
    • 参考

1.JUC

JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包,JDK 1.5开始出现的。
分类说明JUC包常用类有哪些

1.1 CountDownLatch

1.1.1 介绍

CountDownLatch是一个同步工具类,用来协调多个线程之间的同步,或者说起到线程之间的通信(而不是用作互斥的作用)。
CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后,再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后,计数器的值就会减一。当计数器的值为0时,表示所有的线程都已经完成一些任务,然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

1.1.2 举例

比如老师检查学生作业,有三个学生,这三个学生需要都做完作业后,老师才一起进行检查。这里,我们把每一个学生对应一个线程,老师对应一个主线程,当主线程要进行检查操作时,必须等待三个线程都处理完了,才开始主线程自己的步骤。

学生类:

/**
 * 学生
 */
public class Student implements Runnable{

    //线程内共享倒计数门阀
    private CountDownLatch downLatch;
    private String name;


    public Student(CountDownLatch downLatch, String name) {
        this.downLatch = downLatch;
        this.name = name;
    }

    public void run() {
        System.out.printf("学生%s 开始做作业!\n",name);
        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.printf("学生%s 作业结束!\n",name);
        //当前线程执行完后,记得调用门阀
        downLatch.countDown();

    }
}

老师类:

/**
 * 老师
 */
public class Teacher {

    public static void main(String[] args) {
        //创建倒计数(CountDown)门闩(Latch)
        CountDownLatch latch = new CountDownLatch(3);
        ExecutorService executor = Executors.newCachedThreadPool();

        executor.execute(new Student(latch,"A"));
        executor.execute(new Student(latch,"B"));
        executor.execute(new Student(latch,"C"));
        //线程池用完了记得关闭,不然资源一直占用,比如main方法会一直在执行
        executor.shutdown();

        System.out.printf("老师%s 等待学生作业!\n",Thread.currentThread().getName());
        try {
            //等待三个线程全部执行完
            latch.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.printf("老师%s 学生作业全部做完,开始检查!\n",Thread.currentThread().getName());

    }

}

打印:
JUC常用工具类_第1张图片

1.1.3 注意

1.各个线程中最好有异常处理,不要让一个线程阻塞了导致请他线程也跟着阻塞

1.2 CyclicBarrier

1.2.1 介绍

CyclicBarrier字面意思是“可重复使用的栅栏”,CyclicBarrier 相比 CountDownLatch 来说,要简单很多,其源码没有什么高深的地方,它是 ReentrantLock 和 Condition 的组合使用。
在CyclicBarrier类的内部有一个计数器,每个线程在到达屏障点的时候都会调用await方法将自己阻塞,此时计数器会减1,当计数器减为0的时候所有因调用await方法而被阻塞的线程将被唤醒。这就是实现一组线程相互等待的原理

1.2.2 举例

例如100米赛跑,有3个运动员参加,教练需要看到3个运动员都准备好了,然后才鸣枪,三个运动员同时起跑。现在三个运动员对应三个线程,当教练(主线程)执行100米比赛时,通过查看cyclicBarrier的计数是否为0,为0则所有线程开始都被唤醒开始同时进行。

远动员:

/**
 * 运动员
 */
public class Player implements Runnable{

    private CyclicBarrier cyclicBarrier;
    private String name;

    public Player(CyclicBarrier cyclicBarrier, String name) {
        this.cyclicBarrier = cyclicBarrier;
        this.name = name;
    }
    public void run() {
        try {
            //睡眠阻塞
            cyclicBarrier.await();
            System.out.printf("运动员%s 开始起跑!时间:%s\n",name,getDateTime());
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.printf("运动员%s 100米跑道终点!时间:%s\n",name,getDateTime());
    }

    public String getDateTime(){
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(d);
    }
}

教练:

/**
 * 教练
 */
public class Trainer {
    public static void main(String[] args) {
        int threadCount = 3;
        //创建栅栏
        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount);
        ExecutorService executor = Executors.newCachedThreadPool();

        for (int i = 1; i <= threadCount; i++) {
            executor.execute(new Player(cyclicBarrier,"A"+i));
            System.out.printf("运动员%s准备就绪,等待其他玩家!\n","A"+i);
        }
        executor.shutdown();
    }
}

打印:
JUC常用工具类_第2张图片

1.2.3 注意

1.CountDownLatch 是一次性的,CyclicBarrier 是可循环利用的
2.CountDownLatch 参与的线程的职责是不一样的,有的在倒计时,有的在等待倒计时结束。CyclicBarrier 参与的线程职责是一样的。
3CountDownLatch是线程组之间的等待,即一个(或多个)线程等待N个线程完成某件事情之后再执行;而CyclicBarrier则是线程组内的等待,即每个线程相互等待,即N个线程都被拦截之后,然后依次执行。
4.CountDownLatch是减计数方式,而CyclicBarrier是加计数方式。
5.CountDownLatch计数为0无法重置,而CyclicBarrier计数达到初始值,则可以重置。

1.3 Semaphore

1.3.1 介绍

Semaphore用于限制可以访问某些资源(物理或逻辑的)的线程数目,他维护了一个许可证集合,有多少资源需要限制就维护多少许可证集合,假如这里有N个资源,那就对应于N个许可证,同一时刻也只能有N个线程访问。一个线程获取许可证就调用acquire方法,用完了释放资源就调用release方法。
Semaphore 类是一个计数信号量,必须由获取它的线程释放, 通常用于限制可以访问某些资源(物理或逻辑的)线程数目

1.3.2 举例

比如一个停车场有三个车位,有6辆车进入,那么当停满3辆车后,停车场是不能再进去停车场的,必须其中一个车出来,空出一个车位后,后面的车才能再次进入。车位就相当于Semaphore信号量,车辆可看做一个线程,程序中只允许3个线程进行执行,不管后面线程有多少,当一个线程执行完了,那么后面线程才能有一个开始执行。

车辆类:

public class Car implements Runnable{

    private Semaphore semaphore;
    private String name;

    public Car(Semaphore semaphore, String name) {
        this.semaphore = semaphore;
        this.name = name;
    }

    public void run() {
        try {
            //查看是否还有车位
            semaphore.acquire();
            System.out.printf("车主%s 有车位,开车进入!\n",name);
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
            System.out.printf("车主%s 离开停车场!\n",name);
            //释放占用的车位
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

停车场类:

/**
 * 停车场
 */
public class Park {

    public static void main(String[] args) {
        //信号量,即3个车位
        Semaphore ParkingLot = new Semaphore(3);
        ExecutorService executor = Executors.newCachedThreadPool();
        //6辆车开车进入
        for (int i = 1; i <= 6; i++) {
            executor.execute(new Car(ParkingLot,"A"+i));
        }
        executor.shutdown();
    }

}

打印:
JUC常用工具类_第3张图片

1.3.3 注意

1.4 Exchanger

1.4.1 介绍

Exchanger并发辅助类,允许在并发任务之间交换数据。具体来说Exchanger类在两个线程之间定义同步点。当两个线程到达同步点时,它们交换数据结构。
Exchanger 是 JDK 1.5 开始提供的一个用于两个工作线程之间交换数据的封装工具类,简单说就是一个线程在完成一定的事务后想与另一个线程交换数据,则第一个先拿出数据的线程会一直等待第二个线程,直到第二个线程拿着数据到来时才能彼此交换对应数据。
平时没怎么用到

1.4.2 举例

两个生产者线程,当调用Exchanger时,会互相传递数据

public class ProducerA extends Thread{

    private Exchanger<Integer> exchanger;
    private static int data = 2;

    public ProducerA(Exchanger<Integer> exchanger, String name) {
        super.setName(name);
        this.exchanger = exchanger;
    }

    @Override
    public void run() {

        System.out.println(getName()+" 交换前:" + data);
        try {
            TimeUnit.SECONDS.sleep(2);
            data = exchanger.exchange(data);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName()+" 交换后:" + data);
    }
}

public class ProducerB extends Thread{

    private Exchanger<Integer> exchanger;
    private static int data = 0;

    public ProducerB(Exchanger<Integer> exchanger, String name) {
        this.exchanger = exchanger;
        super.setName(name);
    }

    @Override
    public void run() {
        System.out.println(getName()+" 交换前:" + data);
        try {
            TimeUnit.SECONDS.sleep(1);
            data = exchanger.exchange(data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName()+" 交换后:" + data);
    }
}

public class Test {

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

        Exchanger<Integer> exchanger = new Exchanger<Integer>();
        new ProducerA(exchanger,"AA").start();
        new ProducerB(exchanger,"BB").start();
        TimeUnit.SECONDS.sleep(5);

    }
}


JUC常用工具类_第4张图片

参考

Java Exchanger 必知必会
Semaphore的工作原理及实例
semaphore/
Semaphore 相关整理
Java并发编程之CyclicBarrier详解
CountDownLatch的理解和使用

你可能感兴趣的:(#,线程(JAVA))