多线程常用的辅助类

标签：变量   down   案例   interrupt   amp   子线程   star   new   http   

CountDownLatch 减法计数器

官方定义：允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

通俗理解：就是一个减法计数器，当减到值为0的时候才做某事。

常用方法：

• countDown 减一操作；
• await 等待计数器归零；

示例 ：一个教室关门的案例（人走完（0）才能关门）

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        //6个同学出教室
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"==>Go Out");
                countDownLatch.countDown(); //每个线程都数量-1
            },String.valueOf(i)).start();
        }
        try {
            // 等待计数器归零，然后向下执行（保证了执行的顺序）【人走完，才关门】
            //如果不用这个方法，按照多线程的特性，可能会上面线程还没执行完成，下面的主线程内容就会执行。
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("close door");
    }
}

执行结果

1==>Go Out
2==>Go Out
3==>Go Out
4==>Go Out
5==>Go Out
6==>Go Out
close door

CyclickBarrier 加法计数器

官方定义：允许一组线程全部等待彼此达到共同屏障点的同步辅助。

通俗理解：加法计数器，当值加到某一个规定的值的时候就执行某个操作

构造方法

CyclicBarrier(int parties) 
//创建一个新的 CyclicBarrier ，当给定数量的线程（线程）等待它时，它将跳闸，并且当屏障跳闸时不执行预定义的动作。  
CyclicBarrier(int parties, Runnable barrierAction) 
//创建一个新的 CyclicBarrier ，当给定数量的线程（线程）等待时，它将跳闸，当屏障跳闸时执行给定的屏障动作，由最后一个进入屏障的线程执行。  

示例 集齐七龙珠

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

public class CyclickBarrierTest {
    public static void main(String[] args) {
        //主线程 当集齐七颗龙珠后，就召唤神龙（7个子线程执行完，就执行主线程内容）
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙");
        });

        for (int i = 1; i <= 7; i++) {
            //子线程
            // 线程内部不能访问for中的变量，我们设置一个temp变量接收
            int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集了第"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await();//加法计数等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

结果

Thread-1收集了第2颗龙珠
Thread-0收集了第1颗龙珠
Thread-2收集了第3颗龙珠
Thread-3收集了第4颗龙珠
Thread-4收集了第5颗龙珠
Thread-5收集了第6颗龙珠
Thread-6收集了第7颗龙珠
召唤神龙

Semaphore 通行证

官方定义：一个计数信号量。在概念上，信号量维持一组许可证。

通俗理解：就是用来规定每次同时执行多少条线程。一条执行完成，有空位置，其它线程在加入执行。始终保持执行规定数量的线程。

示例 6辆车子，3个停车位（始终只能停三辆车，其它车需要等待有车子出来才能进出）

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreExample {
    public static void main(String[] args) {
        //参数表示同时能够执行的线程数量，该类常用于限流
        //这里的3我们理解我3个停车位
        Semaphore semaphore = new Semaphore(3);
        //有6辆车子需要停车
        //只有3个车位，只有等待其他车子出了车位，其他车子才能进去停车
        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                //acquire()得到（理解为得到停车位）
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);//停车时间
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //释放  理解为离开车位
                    semaphore.release();
                }
            },i+"号车").start();
        }
    }
}

结果

1号车抢到车位
2号车抢到车位
3号车抢到车位
2号车离开车位
3号车离开车位
1号车离开车位
5号车抢到车位
4号车抢到车位
6号车抢到车位
6号车离开车位
4号车离开车位
5号车离开车位

参考教程：https://www.kuangstudy.com/

多线程常用的辅助类

标签：变量   down   案例   interrupt   amp   子线程   star   new   http   

原文地址：https://www.cnblogs.com/lanxinren/p/14699188.html