JavaEE(系列16) -- 多线程(信号量与CountDownLatch)

目录

1. 信号量Semaphore

2. CountDownLatch

---

1. 信号量Semaphore

信号量, 用来表示 "可用资源的个数". 本质上就是一个计数器.

1.理解信号量

可以把信号量想象成是停车场的展示牌: 当前有车位 100 个. 表示有 100 个可用资源.当有车开进去的时候, 就相当于申请一个可用资源, 可用车位就 -1 (这个称为信号量的 P 操作)当有车开出来的时候, 就相当于释放一个可用资源, 可用车位就 +1 (这个称为信号量的 V 操作)如果计数器的值已经为 0 了, 还尝试申请资源, 就会阻塞等待, 直到有其他线程释放资源.

  

Semaphore 的 PV 操作中的加减计数器操作都是原子的, 可以在多线程环境下直接使用.

2. 代码示例 

 

• 创建 Semaphore 示例, 初始化为 4, 表示有 4 个可用资源.
• acquire 方法表示申请资源(P操作), release 方法表示释放资源(V操作)
• 创建 20 个线程, 每个线程都尝试申请资源, sleep 1秒之后, 释放资源. 观察程序的执行效果.

package SemaphoreTest;

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    public static void main(String[] args) {
        // 1.创建信号量 表示有4个可用资源
        Semaphore semaphore = new Semaphore(4);

        // 2.创建一个可以执行的任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("申请资源");
                try {
                    semaphore.acquire();
                    System.out.println("我获取到资源了");
                    Thread.sleep(1000);
                    System.out.println("我释放资源了");
                    semaphore.release();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        for (int i = 0; i < 20; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }
}

 

2. CountDownLatch

CountDownLatch: 同时等待 N 个任务执行结束.

好像跑步比赛，10个选手依次就位，哨声响才同时出发；所有选手都通过终点，才能公布名次成绩。

1. 构造 CountDownLatch 实例, 初始化 10 表示有 10 个任务需要完成.
2. 每个任务执行完毕, 都调用 latch.countDown() . 在 CountDownLatch 内部的计数器同时自减.
3. 主线程中使用 latch.await(); 阻塞等待所有任务执行完毕. 相当于计数器为 0 了.

import java.util.Map;
import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(4);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep((int)(Math.random() * 10000));

                    latch.countDown();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        for (int i = 0; i < 4; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }

        latch.await();
        System.out.println("结束");
    }
}