JUC中常用API详解

一、CountDownLatch

从以下版本开始：

1.5

适用场景：当我们需要等待其他所有业务都完成后，才能做一些业务操作的时候，可以用CountDownLatch来实现（类似倒计时）

常用方法：

1、构造器

2、countDown()

减少锁存器的计数，如果计数达到零，释放所有等待的线程。

3、await()

导致当前线程等到锁存器计数到零，除非线程是 interrupted 。

4、await(long timeout, TimeUnit unit)

使当前线程等待直到锁存器计数到零为止，除非线程为 interrupted或指定的等待时间过去。

5、getCount()

返回当前计数。

代码实现：

package com.lzp.juc;

import java.util.concurrent.CountDownLatch;

/**
 * @Author LZP
 * @Date 2021/7/3 22:54
 * @Version 1.0
 *
 * 班上所有同学都离开教室之后，班长才能关门
 */
public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch count = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t" + "离开教室");
                count.countDown();
            }, String.valueOf(i)).start();
        }

        count.await();

        System.out.println("班长关门****");
    }

}

运行结果：

二、CyclicBarrier

从以下版本开始：

1.5

适用场景：当我们在做一件事之前需要具备其他条件（类似 集齐七颗龙珠召唤神龙）时，我们才能去完成最终的任务

常用方法：

1、构造器

2、await()

等待所有 parties已经在这个障碍上调用了await。

3、await(long timeout, TimeUnit unit)

等待所有 parties 已经在此屏障上调用 await，或指定的等待时间过去。

4、reset()

将屏障重置为初始状态。

代码实现：

package com.lzp.juc;

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

/**
 * @Author LZP
 * @Date 2021/7/3 22:57
 * @Version 1.0
 *
 * 集齐七颗龙珠召唤
 */
public class CyclicBarrierTest {

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙");
        });

        for (int i = 1; i <= 7; i++) {
            final int tempInt = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t" + "获得第" + tempInt + "颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }

}

运行结果：

三、Semaphore

从以下版本开始：

1.5

适用场景：多线程抢占多个资源（多人抢红包）

常用方法：

1、构造器

2、acquire()

从该信号量获取许可证，阻止直到可用，或线程为 interrupted 。

3、release()

释放许可证，将其返回到信号量。

代码实现（多位车主抢占多个停车位）：

package com.lzp.juc;

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

/**
 * @Author LZP
 * @Date 2021/7/3 23:17
 * @Version 1.0
 *
 * 多线程抢占多个资源（不再是以前的一个共享资源）
 * 需求：7个车主抢占3个停车位
 */
public class SemaphoreTest {

    public static void main(String[] args) {
        int people = 7;
        int carSeat = 3;
        /*
            Semaphore(int permits)
            创建一个 Semaphore与给定数量的许可证和非公平公平设置。
         */
        Semaphore semaphore = new Semaphore(carSeat); // 没有默认的无参构造
        Random r = new Random();

        for (int i = 1; i <= people; i++) {
            new Thread(() -> {
                try {
                    // 开始抢
                    semaphore.acquire();
                    // 抢到了
                    System.out.println(Thread.currentThread().getName() + "\t" + "抢到了停车位");
                    // 模拟车位占用时间
                    TimeUnit.SECONDS.sleep(r.nextInt(3) + 1);
                    System.out.println(Thread.currentThread().getName() + "\t" + "离开了停车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放资源
                    semaphore.release();
                }
            }, String.valueOf("车主" + i)).start();
        }
    }

}

运行结果：