CountDownLatch / Semaphore 示例及使用场景

AQS系列

1、AQS核心原理
2、ReentrantLock 示例及原理
3、CountDownLatch / Semaphore 示例及使用场景
4、BlockingQueue 示例及使用场景

文章目录

  • AQS系列
  • 一、基本原理
  • 二、4人短跑赛 (CountDownLatch)
  • 三、请求限流(Semaphore)

一、基本原理

在 《AQS核心原理》 篇中提到的,AQS 内部有一个 state 标记状态,CountDownLatch 和 Semaphore 都是借助这个状态标记作为一个计数器来实现控制多个线程的,计数器的初始值为线程的数量,每个线程执行完后计数器会减一,当计数器的值是 0 的时候,表示所有的线程都已经完成了任务,我们可以看看构成方法如下:

public CountDownLatch(int count) {
 if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}

CountDownLatch 主要 API 是 CountDownLatch.countDown(),CountDownLatch.await() 。

public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

Semaphore 主要 API 是 Semaphore.acquire() throws InterruptedException(阻塞并获取许可),Semaphore.release()(释放许可),Semaphore.tryAcquire() (尝试阻塞并获取许可)。

二、4人短跑赛 (CountDownLatch)

用一个运动会的短跑比赛作为场景,用 CountDownLatch 来实现,主要由四个运动员赛跑,等裁判一声枪响后,四个人都开始全力跑,不过比赛完成是需要四个人都跑完才算,不能是跑完一个人就算比赛结束(需要每个线程执行结束主线程才能执行)。

//实例化 CountDownLatch, 线程数量为 4
    static final CountDownLatch latch = new CountDownLatch(4);
    public static void main(String[] args) {
        System.out.println("开始准备赛跑,所有参赛者准备");
        new Thread(() -> {
            try {
                Thread.sleep(2000);
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("第一个人跑完了,一片欢呼声~~~~~~~~~~~");
        }).start();
        System.out.print("第一个人准备好了|");
        new Thread(() -> {
            try {
                Thread.sleep(4000);
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                System.out.println("第二个人跑完了,好多人鼓掌~~~~~~~~~~~");
        }).start();
        System.out.print("第二个人准备好了|");
        new Thread(() -> {
            try {
                Thread.sleep(5000);
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                System.out.println("第三个人跑完了,没几个人鼓掌~~~~~~~~~~~");
        }).start();
        System.out.print("第三个人准备好了|");
        new Thread(() -> {
            try {
                Thread.sleep(7000);
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("第四个人跑完了~~~~~~~~~~~");
        }).start();
        System.out.println("第四个人准备好了");
        System.out.println("发令枪~~~~pong...");
        System.out.println("裁判员在等待着...");
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("赛跑项目结束了。");
    }

执行结果如下:

开始准备赛跑,所有参赛者准备
第一个人开始跑了|第二个人开始跑了|第三个人开始跑了|第四个人开始跑了
发令枪~~~~pong...
裁判员在等待着...
第一个人跑完了,一片欢呼声~~~~~~~~~~~
第二个人跑完了,好多人鼓掌~~~~~~~~~~~
第三个人跑完了,没几个人鼓掌~~~~~~~~~~~
第四个人跑完了~~~~~~~~~~~
赛跑项目结束了。

从执行结果中可以看出,四个人全部跑完 赛跑项目才结束,也就是 4 个线程都执行完之后,才回到主线程执行。

三、请求限流(Semaphore)

用一个请求限流的场景,用 Semaphore 来模拟这个场景实现。
首先实例化一个Semaphore信号量 是 3,表示每次只能有3 个线程执行任务,用一个 内部类 RequestTask 来模拟请求,每次请求耗时 2 秒。

public static void main(String[] args) {
  //初始化信号量为 3,每次只有3个线程执行
    Semaphore semaphore = new Semaphore(3);
    for (int i = 0; i < 10; i++) {
        new Thread(new RequestTask(semaphore, "请求任务" + i)).start();
    }
}

static class RequestTask implements Runnable{
    Semaphore semaphore;
    String taskName;

    public RequestTask(Semaphore semaphore, String taskName) {
        this.semaphore = semaphore;
        this.taskName = taskName;
    }

    @Override
    public void run() {
        try {
            semaphore.acquire();
            System.out.println(taskName + "任务执行中...");
            TimeUnit.SECONDS.sleep(2);
            System.out.println(taskName + "任务执行完成...");
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行结果如下:

请求任务1任务执行中...
请求任务2任务执行中...
请求任务0任务执行中...
请求任务2任务执行完成...
请求任务0任务执行完成...
请求任务1任务执行完成...
请求任务4任务执行中...
请求任务5任务执行中...
请求任务3任务执行中...
请求任务3任务执行完成...
请求任务5任务执行完成...
请求任务4任务执行完成...
请求任务7任务执行中...
请求任务6任务执行中...
请求任务8任务执行中...
请求任务6任务执行完成...
请求任务7任务执行完成...
请求任务9任务执行中...
请求任务8任务执行完成...
请求任务9任务执行完成...

从执行结果可以看出,总共 10 个线程,每次只有 3 个线程执行,最后一个时 任务9 执行,也就是说,每次是最多有 3 个线程执行。

你可能感兴趣的:(多线程,JAVA后台,java,后端,多线程)