服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - Java多线程Semaphore工具的使用详解

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

2023-05-11 01:06未知服务器之家 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();
            }
        }
    }
    原文地址:https://lfsun666.blog.csdn.net/article/details/130536162

    延伸 · 阅读

    精彩推荐