Java多线程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 SemaphiEJomMhore(1);
        // 获取一个许可证，获编程客栈取成功
        boolean success1 = semaphore.tryAcquire();
        System.out.println("success1: " + success1); // 输出 true
        // 再次获取一个许可证，获取失败
        boolean success2 = semaphore.tryAcquire();
        System.out.println("success2: " + success2); // 输出 false
        // 释放一个许可证
        semaphore.release();
http://www.devze.com        // 再次获取一个许可证，获取成功
        boolean success3 = semaphore.tryAcquire();
        System.out.println("success3js: " + 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()); /开发者_Python开发/ 输出 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 http://www.devze.commain(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();
        }
    }
}

到此这篇关于Java多线程Semaphore工具的使用详解的文章就介绍到这了,更多相关Java多线程Semaphore内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！