Java多线程Semaphore工具的使用详解

目录

Semaphore 是一种用于控制线程并发访问数的同步工具。它通过维护一定数量的许可证来限制对共享资源的访问。 许可证的数量就是可以同时访问共享资源的线程数目。

当一个线程需要访问共享资源时，它必须先获取一个许可证，如果没有许可证可用，线程就会被阻塞，直到有一个许可证可用。 当一个线程完成了对共享资源的访问后，它必须释放一个许可证，以便其他线程可以获取许可证继续访问共享资源。

虽然 Semaphore 主要用于限制并发访问数，但是在实际应用中，Semaphore 还可以用于线程之间的协作，比如实现线程的顺序执行、线程间的消息传递等等。 所以，Semaphore 并不仅仅是限制并发数，它还可以用于实现更多的线程协作场景。

import java.util.concurrent.Semaphore;
/**
 *
 Semaphore 是一种用于控制线程并发访问数的同步工具。它通过维护一定数量的许可证来限制对共享资源的访问。
 许可证的数量就是可以同时访问共享资源的线程数目。
 当一个线程需要访问共享资源时，它必须先获取一个许可证，如果没有许可证可用，线程就会被阻塞，直到有一个许可证可用。
 当一个线程完成了对共享资源的访问后，它必须释放一个许可证，以便其他线程可以获取许可证继续访问共享资源。
 虽然 Semaphore 主要用于限制并发访问数，但是在实际应用中，
 Semaphore 还可以用于线程之间的协作，比如实现线程的顺序执行、线程间的消息传递等等。
 所以，Semaphore 并不仅仅是限制并发数，它还可以用于实现更多的线程协作场景。
 */
public class SemaphoreDemo {
    public static void main(String[] args) {
        //availablePermits(semaphore);
        tryAcquire();
    }
    private static void tryAcquire() {
        // 创建一个 Semaphore 对象，初始化许可证数量为 1
        Semaphore semaphore = new Semaphore(1);
        // 获取一个许可证，获取成功
        boolean success1 = semaphore.tryAcquire();
        System.out.println(\"success1: \" + success1); // 输出 true
        // 再次获取一个许可证，获取失败
        boolean success2 = semaphore.tryAcquire();
        System.out.println(\"success2: \" + success2); // 输出 false
        // 释放一个许可证
        semaphore.release();
        // 再次获取一个许可证，获取成功
        boolean success3 = semaphore.tryAcquire();
        System.out.println(\"success3: \" + success3); // 输出 true
    }
    private static void availablePermits() {
        // 创建一个 Semaphore 对象，初始化许可证数量为 3
        Semaphore semaphore = new Semaphore(3);
        System.out.println(\"available permits: \" + semaphore.availablePermits()); // 输出 3
        // 获取一个许可证
        try {
            semaphore.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(\"worker 1 is working...\");
        System.out.println(\"available permits: \" + semaphore.availablePermits()); // 输出 2
        // 释放一个许可证
        semaphore.release();
        System.out.println(\"worker 1 has finished his work.\");
        System.out.println(\"available permits: \" + semaphore.availablePermits()); // 输出 3
    }
}

package com.lfsun.highconcurrency000.juc.semaphore;
import java.util.concurrent.Semaphore;
/**
 * 定义了一个 SemaphoreDemo 类和一个 Worker 类。SemaphoreDemo 类中创建了一个 Semaphore 对象，并初始化许可证数量为 3。
 * 然后，创建 5 个 Worker 对象，并启动 5 个线程。
 *
 * Worker 类实现了 Runnable 接口，表示线程的具体工作。
 * 在 run 方法中，首先使用 acquire 方法获取一个许可证，表示该线程需要访问共享资源；
 * 然后，进行一些模拟的工作，通过 sleep 方法暂停线程一段时间；最后，使用 release 方法释放一个许可证，表示该线程已经使用完共享资源。
 * 在输出中可以看到，最多只有 3 个线程同时访问共享资源。
 *
 * 需要注意的是，acquire 和 release 方法都可能抛出 InterruptedException 异常，应该正确处理异常。
 * 另外，应该根据实际需求调整 Semaphore 的许可证数量，以达到最优的性能和效果。
 */
public class MySemaphoreDemo {
    public static void main(String[] args) {
        // 创建一个 Semaphore 对象，初始化许可证数量为 3
        Semaphore semaphore = new Semaphore(3);
        // 创建 5 个线程并启动
        for (int i = 1; i <= 5; i++) {
            new Thread(new Worker(i, semaphore)).start();
        }
    }
}
class Worker implements Runnable {
    private int id;
    private Semaphore semaphore;
    public Worker(int id, Semaphore semaphore) {
        this.id = id;
        this.semaphore = semaphore;
    }
    @Override
    public void run() {
        try {
            // 获取一个许可证
            semaphore.acquire();
            System.out.println(\"worker \" + id + \" is working...\");
            // 模拟工作过程
            Thread.sleep((long) (Math.random() * 5000));
            // 释放一个许可证
            semaphore.release();
            System.out.println(\"worker \" + id + \" has finished his work.\");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}