多线程 - Semaphore

向右看齐 2024-03-22 03:21 124阅读 0赞

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();
            }
        }
    }