Semaphore信号量

已于 2022-03-15 10:55:23 修改
阅读量210 收藏
点赞数
分类专栏： java
于 2022-03-14 14:47:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hljliao/article/details/123478328
版权

java 开发语言

java.util.concurrent简称JUC，日常总结

Semaphore 信号量

Semaphore 信号量 英[ˈseməfɔː®]，Semaphore可以控制同时访问的线程个数，通过acquire()方法获取一个许可，如果没有就等待，通过release()可以释放一个许可。

构造方法
    /**
     * 使用指定数量许可和非公平规则创建一个信号量
     *
     * @param permits 指定信号量的数量
     */
    public Semaphore(int permits) {
        sync = new Nonfai
    }
	/**
     * 使用指定数量许可和指定公平规则创建一个信号量
     *
     * @param permits 指定信号量的数量
     * @param fair 是否是公平的，即等待时间越久的越先获取许可
     */
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }
常用方法
	/**
     * 尝试获取一个许可，如果获取成功，则立即返回true。如果获取失败，则立即返回false。如果没有许可可以获得，则会一直等待，直到获得许可。
     */
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    /**
     * 尝试获取permits个许可，如果获取成功，则立即返回true。如果获取失败，则立即返回false。如果没有许可可以获得，则会一直等待，直到获得许可。
     * @param permits 信号量的数量
     */
    public void acquire(int permits) throws InterruptedException {
        if (permits < 0) throw new IllegalArgumentException();
        sync.acquireSharedInterruptibly(permits);
    }
	/**
     * 释放1个许可证，并发回给信号机。将可用许可证数量增加1。
     */
    public void release() {
        sync.releaseShared(1);
    }
    /**
     * 尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
     */
    public boolean tryAcquire(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        return sync.nonfairTryAcquireShared(permits) >= 0;
    }
	/**
     * 尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
     */
    public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
        throws InterruptedException {
        if (permits < 0) throw new IllegalArgumentException();
        return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
    }
	/**
     * 尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
     */
    public boolean tryAcquire(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        return sync.nonfairTryAcquireShared(permits) >= 0;
    }
/**
     * 尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
     */
    public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
        throws InterruptedException {
        if (permits < 0) throw new IllegalArgumentException();
        return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
    }
	/**
     * 返回此信号量中当前可用的许可证数。
     * @return 可用的许可数目
     */
    public int availablePermits() {
        return sync.getPermits();
    }
举一个简单的例子

通过Semaphore信号量来实现。我们的工厂一共就有5台机器可以同时生产材料。一台机器同时只能被1个工人使用，只有这个工人使用完了，其他工人才能继续使用。

package com.test.juc;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Semaphore;

/**
 * @author liao
 * @version 1.0.0
 * @description
 * @date 2022/3/10 14:33
 **/
@Slf4j
public class TestSemaphore {
    public static void main(String[] args) {
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for (int i = 0; i < N; i++) {
            new Worker(i, semaphore).start();
        }
        log.info("END");
    }

    static class Worker extends Thread {
        private int num;
        private Semaphore semaphore;

        public Worker(int num, Semaphore semaphore) {
            this.num = num;
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                log.info("工人" + this.num + "占用一个机器在生产...");
                Thread.sleep(2000);
                log.info("工人" + this.num + "释放出机器");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
执行结果
14:14:15.240 [Thread-4] INFO com.test.juc.TestSemaphore - 工人4占用一个机器在生产...
14:14:15.239 [Thread-1] INFO com.test.juc.TestSemaphore - 工人1占用一个机器在生产...
14:14:15.239 [Thread-3] INFO com.test.juc.TestSemaphore - 工人3占用一个机器在生产...
14:14:15.240 [Thread-2] INFO com.test.juc.TestSemaphore - 工人2占用一个机器在生产...
14:14:15.240 [main] INFO com.test.juc.TestSemaphore - END
14:14:15.240 [Thread-0] INFO com.test.juc.TestSemaphore - 工人0占用一个机器在生产...
14:14:17.257 [Thread-4] INFO com.test.juc.TestSemaphore - 工人4释放出机器
14:14:17.257 [Thread-1] INFO com.test.juc.TestSemaphore - 工人1释放出机器
14:14:17.257 [Thread-0] INFO com.test.juc.TestSemaphore - 工人0释放出机器
14:14:17.257 [Thread-5] INFO com.test.juc.TestSemaphore - 工人5占用一个机器在生产...
14:14:17.257 [Thread-2] INFO com.test.juc.TestSemaphore - 工人2释放出机器
14:14:17.257 [Thread-6] INFO com.test.juc.TestSemaphore - 工人6占用一个机器在生产...
14:14:17.257 [Thread-3] INFO com.test.juc.TestSemaphore - 工人3释放出机器
14:14:17.258 [Thread-7] INFO com.test.juc.TestSemaphore - 工人7占用一个机器在生产...
14:14:19.264 [Thread-7] INFO com.test.juc.TestSemaphore - 工人7释放出机器
14:14:19.264 [Thread-6] INFO com.test.juc.TestSemaphore - 工人6释放出机器
14:14:19.264 [Thread-5] INFO com.test.juc.TestSemaphore - 工人5释放出机器
实战
工具类
package com.test.juc;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * 线程信号量
 *
 * @author tengbx
 */
public class ThreadSemaphoreUtil {
    private final static Logger LOGGER = LoggerFactory.getLogger(ThreadSemaphoreUtil.class);

    /**
     * 线程执行信号量
     */
//	public static final int THREAD_SEMAPHORE= Integer.parseInt(PropertyUtil.getProperty("THREAD_SEMAPHORE", "/config/properties/system.properties"));
    public static final int THREAD_SEMAPHORE = 3;
    //信号量
    static Semaphore SEMAPHORE = new Semaphore(THREAD_SEMAPHORE, true);
    //线程池
    static ExecutorService pool = Executors.newCachedThreadPool();
    static long start = System.currentTimeMillis();

    //重新执行
    public static void restart() {
        SEMAPHORE = new Semaphore(THREAD_SEMAPHORE, true);
        pool = Executors.newCachedThreadPool();
        start = System.currentTimeMillis();
    }

    //执行线程
    public static void execute(Runnable runnable) throws InterruptedException {
        pool.execute(runnable);
    }

    //等待全部线程池任务执行完成
    public static void allDone() throws InterruptedException {
        pool.shutdown();
        int i = 0;
        while (true) {
            LOGGER.info("allDone当前系统的并发数是：" + (THREAD_SEMAPHORE - SEMAPHORE.availablePermits()));
            // 线程池关闭后所有任务执行完成 && 设置线程数-信号量中的可用的令牌数量==0
            if (pool.isTerminated() && THREAD_SEMAPHORE - SEMAPHORE.availablePermits() == 0) {
                LOGGER.info("allDone所有的子线程都结束了");
                break;
            }
            if (++i > 60) {
                Thread.sleep(6000);
            } else if (++i > 30) {
                Thread.sleep(3000);
            } else {
                Thread.sleep(1000);
            }
        }
    }

    public static void acquire() throws InterruptedException {
        SEMAPHORE.acquire();//获取信号灯许可
        LOGGER.info("获取信号灯许可");
    }

    public static void release() {
        SEMAPHORE.release();//释放信号灯
        LOGGER.info("释放信号灯");
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            final int j = i;
            Runnable runnable = () -> {
                try {
                    ThreadSemaphoreUtil.acquire();//获取信号灯许可
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(new Random().nextInt(10000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ThreadSemaphoreUtil.release();//释放信号灯
            };
            ThreadSemaphoreUtil.execute(runnable);
        }
        ThreadSemaphoreUtil.allDone();
    }
}
执行结果
14:28:35.300 [pool-1-thread-4] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:35.301 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:35.300 [pool-1-thread-1] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:35.301 [pool-1-thread-3] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:35.947 [pool-1-thread-3] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:35.947 [pool-1-thread-2] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:36.316 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:36.603 [pool-1-thread-5] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:36.603 [pool-1-thread-2] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:37.317 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:38.317 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:38.989 [pool-1-thread-5] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:38.989 [pool-1-thread-6] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:39.317 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:40.317 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:40.578 [pool-1-thread-9] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:40.578 [pool-1-thread-1] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:41.318 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:42.318 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:43.012 [pool-1-thread-6] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:43.012 [pool-1-thread-10] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:43.158 [pool-1-thread-9] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:43.158 [pool-1-thread-7] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:43.319 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:43.598 [pool-1-thread-4] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:43.598 [pool-1-thread-8] INFO com.test.juc.ThreadSemaphoreUtil - 获取信号灯许可
14:28:44.319 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：3
14:28:45.304 [pool-1-thread-7] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:45.321 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：2
14:28:46.321 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：2
14:28:47.321 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：2
14:28:48.322 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：2
14:28:48.857 [pool-1-thread-8] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:49.323 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：1
14:28:50.323 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：1
14:28:50.855 [pool-1-thread-10] INFO com.test.juc.ThreadSemaphoreUtil - 释放信号灯
14:28:53.323 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone当前系统的并发数是：0
14:28:53.323 [main] INFO com.test.juc.ThreadSemaphoreUtil - allDone所有的子线程都结束了
总结

Semaphore信号量，用于管理一组资源。其内部是基于AQS的共享模式，AQS的状态标识许可证的数量，在许可证数量不够时，线程将会被挂起。而一旦有一个线程释放一个资源，那么就有可能重新唤醒等待队列中的线程继续执行。主要作用是控制线程的执行。

问题总结
Semaphore初始化令牌数量可以为负数吗？

可以。源码中指出，初始化令牌数可以为负数，此时线程获取令牌会进入阻塞状态，需要调用release方法添加令牌。

semaphore初始化有10个令牌，11个线程同时各调用1次acquire方法，会发生什么?

拿不到令牌的线程阻塞，不会继续往下运行。

semaphore初始化有10个令牌，一个线程重复调用11次acquire方法，会发生什么?

线程阻塞，不会继续往下运行。可能你会考虑类似于锁的重入的问题，很好，但是，令牌没有重入的概念。你只要调用一次acquire方法，就需要有一个令牌才能继续运行。

semaphore初始化有1个令牌，1个线程调用一次acquire方法，然后调用两次release方法，之后另外一个线程调用acquire(2)方法，此线程能够获取到足够的令牌并继续运行吗?

能，原因是release方法会添加令牌，并不会以初始化的大小为准。

semaphore初始化有2个令牌，一个线程调用1次release方法，然后一次性获取3个令牌，会获取到吗?

能，原因是release会添加令牌，并不会以初始化的大小为准。Semaphore中release方法的调用并没有限制要在acquire后调用。

一路向南panda
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C 语言编程 — semaphore 信号量操作
烟云的计算
03-14 1798
二元信号量（Binary Semaphore），即：计数器维护的 Value 只有 0 和 1 着两种可能，以此来实现互斥，所以也称为互斥信号量。信号量（semaphore）是一种常被用于多线程或多进程场景中的同步机制，用于保证多线程或多进程对共享数据的读/写操作是顺序的。：当线程完成了共享数据的访问后，应该使用 sem_post() 释放二元信号量，即：将 Value 变 1，让其他线程可以获取。另外，二元信号量的使用应尽量避免死锁问题的发生，即：避免出现多个线程相互等待的情况。
信号量Semaphore详解
m0_71777195的博客
11-30 4922
大家应该都用过关键字加锁，用来保证某个时刻只允许一个线程运行。那么如果控制某个时刻允许指定数量的线程执行，有什么好的办法呢?答案就是JUC提供的信号量Semaphore。Semaphore（信号量）可以用来限制能同时访问共享资源的线程上限，它内部维护了一个许可的变量，也就是线程许可的数量Semaphore的许可数量如果小于0个，就会阻塞获取，直到有线程释放许可Semaphore是一个非重入锁构造方法permits表示许可线程的数量fair表示公平性，如果设为true。
Java中Semaphore(信号量)的使用
weixin_30709061的博客
11-29 1048
Semaphore的作用：在java中，使用了synchronized关键字和Lock锁实现了资源的并发访问控制，在同一时间只允许唯一了线程进入临界区访问资源(读锁除外)，这样子控制的主要目的是为了解决多个线程并发同一资源造成的数据不一致的问题。在另外一种场景下，一个资源有多个副本可供同时使用，比如打印机房有多个打印机、厕所有多个坑可供同时使用，这种情况下，Java提供了另外的并发访问控制--...
semaphore信号量
Joy
07-08 569
文章目录信号量机制什么是信号量信号量的分类信号量的工作机制实战分析：信号量的特点Java中如何使用信号量构造函数应用生产者消费者模型死锁恢复我们构建这样一个死锁场景：实现 信号量机制 什么是信号量 信号量是一种变量或抽象数据类型，用于控制并发系统中多个进程对公共资源的访问 一个普通的信号量是一个普通的变量，可以对它进行递增或递减，或切换等操作。 引用一波百度百科的解释： 以一个停车场的运作为例...
Semaphore 信号量
vvgg
03-21 110
[url]http://www.java2000.net/p14873[/url] Semaphore 信号量，就是一个允许实现设置好的令牌。也许有1个，也许有10个或更多。 谁拿到令牌(acquire)就可以去执行了，如果没有令牌则需要等待。 执行完毕，一定要归还(release)令牌，否则令牌会被很快用光，别的线程就无法获得令牌而执行下去了。 [code="java"]i...
信号量 Semaphore
木村的博客
05-29 1426
信号量 Semaphore 1. 简介 信号量 Semaphore 是一个控制访问多个共享资源的计数器，和 CountDownLatch 一样，其本质上是一个“共享锁”。 一个计数信号量。从概念上讲，信号量维护了一个许可集。 如有必要，在许可可用前会阻塞每一个 acquire，然后再获取该许可。 每个 release 添加一个许可，从而可能释放一个正在阻塞的获取者。 但是，不使用实际的许可对...
vxworks多任务（task和semaphore信号量及事件）例程.zip
03-09
资源包含了vxworks多任务（task和semaphore信号量及事件）的相关编程例子，通过创建多任务的简单例子，帮助大家了解taskSpawn函数、信号量semaphore、以及事件event的使用方法。
java并发之Semaphore信号量.md
07-24
Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个release方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有...
Java中的Semaphore信号量详解
Semaphore信号量的概述 Semaphore信号量在并发编程中扮演着重要的角色，它可以控制同时访问特定资源的线程数量，从而实现对共享资源的有效管理。接下来我们将深入探讨Semaphore信号量的概念、作用以及基本原理。让...
java Semaphore 关键字
hougechuanqi的专栏
04-22 247
 Semaphore当前在多线程环境下被扩放使用，操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。  Semap...
windows系统调用 semaphore信号量
最新发布
05-13
在Windows系统中，信号量（Semaphore）是一种同步对象，用于在多个线程之间协调共享资源的访问。Windows提供了一组API函数来创建、操作和销毁信号量。 以下是一些与信号量相关的API函数： 1. CreateSemaphore：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值