一、JUC强大的辅助类

1.CountDownLatch(减少计数)

CountDownLatch 记录线程个数
CountDownLatch.countDown() 线程数减-1
CountDownLatch.awit() 知道线程的个数为0的时候，就不等待了
直到6个人全部离开教师之后，班长锁门

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //直到6个人全部离开教师之后，班长锁门
        CountDownLatch countDownLatch = new CountDownLatch(6);

        //循环
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\t 号同学离开教师");
                //减少数据
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }

        //如果初始化不为0的话，那么应该等待
        countDownLatch.await();
        //如果走完了，班长关门
        System.out.println(Thread.currentThread().getName()+"\t 班长关门走人");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.CyclicBarrier(循环栅栏)

CyclicBarrier 循环栅栏
cyclicBarrier.await(); // 如果没有满足初始化值的时候，那么就会等待！

集齐7颗龙珠，召唤神龙

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

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //集齐7颗龙珠，召唤神龙
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("集齐7颗龙珠，可以召唤神龙");
        });

        for (int i = 1; i <= 7 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\t 星龙珠被收集 ");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            },String.valueOf(i)).start();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3.Semaphore(信号灯)

semaphore.acquire(); 获取资源
semaphore.release(); 释放资源

三个停车场，停6辆汽车

import java.util.concurrent.Semaphore;

public class SemaphoreDemo {
    //三个停车场，停6辆汽车
    public static void main(String[] args) {
        //设置3个停车场
        Semaphore semaphore = new Semaphore(3);
        //模拟6辆汽车
        for (int i = 1; i <= 6 ; i++) {
            //创建一个线程
            new Thread(()->{
                try {
                    //获取资源  获得车位
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"\t 抢到了车位");
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName()+"\t------- 离开");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally {
                    //释放资源 让出车位
                    semaphore.release();
                }

            },String.valueOf(i)).start();
        }
    }
}

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