Semaphore应用及原理

最新推荐文章于 2024-07-12 10:00:00 发布
最新推荐文章于 2024-07-12 10:00:00 发布
阅读量330 收藏
点赞数
分类专栏： # Java并发编程 文章标签： Semaphore 锁 jkd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/demon7552003/article/details/90546448
版权

信号量Semaphore的介绍

我们以一个停车场运作为例来说明信号量的作用。假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了三辆车，看门人允许其中它们进入进入，然后放下车拦。以后来的车必须在入口等待，直到停车场中有车辆离开。这时，如果有一辆车离开停车场，看门人得知后，打开车拦，放入一辆，如果又离开一辆，则又可以放入一辆，如此往复。

在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。信号量是一个非负整数，表示了当前公共资源的可用数目（在上面的例子中可以用空闲的停车位类比信号量），当一个线程要使用公共资源时（在上面的例子中可以用车辆类比线程），首先要查看信号量，如果信号量的值大于1，则将其减1，然后去占有公共资源。如果信号量的值为0，则线程会将自己阻塞，直到有其它线程释放公共资源。

在信号量上我们定义两种操作： acquire（获取） 和 release（释放）。当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

示例

Semaphore包含公平锁与非公平锁2种实现

非公平锁

package main.java.study;
import java.util.Calendar;
import java.util.Date;
import java.util.concurrent.*;

public class SemaphoreDemo {
	final static Semaphore sema = new Semaphore(5);
	
	public static class Runner implements Runnable
	{

		int i;
		public Runner(int i)
		{
			this.i = i;
		}
		@Override
		public void run() {
			try
			{
				sema.acquire();
				Thread.sleep(1000);
				System.out.println( "Runner【" + i + "】:" + new Date().toString() + " done!");
			}
			catch ( InterruptedException ex)
			{
				ex.printStackTrace();
			}
			sema.release();
			
		}
		
	}
	public static  void main (String[] args)
	{
		
		ExecutorService service = Executors.newFixedThreadPool(10);
		
		
		for(int i = 0 ;i < 20;i++)
		{
			service.execute(new Runner(i));
		}
	}
}

结果如下：

Runner【2】:Sat May 25 14:27:55 CST 2019 done!
Runner【0】:Sat May 25 14:27:55 CST 2019 done!
Runner【4】:Sat May 25 14:27:55 CST 2019 done!
Runner【3】:Sat May 25 14:27:55 CST 2019 done!
Runner【1】:Sat May 25 14:27:55 CST 2019 done!
Runner【10】:Sat May 25 14:27:56 CST 2019 done!
Runner【12】:Sat May 25 14:27:56 CST 2019 done!
Runner【11】:Sat May 25 14:27:56 CST 2019 done!
Runner【13】:Sat May 25 14:27:56 CST 2019 done!
Runner【14】:Sat May 25 14:27:56 CST 2019 done!
Runner【5】:Sat May 25 14:27:57 CST 2019 done!
Runner【15】:Sat May 25 14:27:57 CST 2019 done!
Runner【7】:Sat May 25 14:27:57 CST 2019 done!
Runner【18】:Sat May 25 14:27:57 CST 2019 done!
Runner【19】:Sat May 25 14:27:57 CST 2019 done!
Runner【9】:Sat May 25 14:27:58 CST 2019 done!
Runner【6】:Sat May 25 14:27:58 CST 2019 done!
Runner【16】:Sat May 25 14:27:58 CST 2019 done!
Runner【17】:Sat May 25 14:27:58 CST 2019 done!
Runner【8】:Sat May 25 14:27:58 CST 2019 done!

 公平锁

package main.java.study;
import java.util.Calendar;
import java.util.Date;
import java.util.concurrent.*;

public class SemaphoreDemo {
	final static Semaphore sema = new Semaphore(5,true);
	
	public static class Runner implements Runnable
	{

		int i;
		public Runner(int i)
		{
			this.i = i;
		}
		@Override
		public void run() {
			try
			{
				sema.acquire();
				Thread.sleep(1000);
				System.out.println( "Runner【" + i + "】:" + new Date().toString() + " done!");
			}
			catch ( InterruptedException ex)
			{
				ex.printStackTrace();
			}
			sema.release();
			
		}
		
	}
	public static  void main (String[] args)
	{
		
		ExecutorService service = Executors.newFixedThreadPool(10);
		
		
		for(int i = 0 ;i < 20;i++)
		{
			service.execute(new Runner(i));
		}
	}
}

结果如下：

Runner【2】:Sat May 25 14:33:49 CST 2019 done!
Runner【1】:Sat May 25 14:33:49 CST 2019 done!
Runner【3】:Sat May 25 14:33:49 CST 2019 done!
Runner【0】:Sat May 25 14:33:49 CST 2019 done!
Runner【4】:Sat May 25 14:33:49 CST 2019 done!
Runner【5】:Sat May 25 14:33:51 CST 2019 done!
Runner【6】:Sat May 25 14:33:51 CST 2019 done!
Runner【8】:Sat May 25 14:33:51 CST 2019 done!
Runner【9】:Sat May 25 14:33:51 CST 2019 done!
Runner【7】:Sat May 25 14:33:51 CST 2019 done!
Runner【10】:Sat May 25 14:33:53 CST 2019 done!
Runner【12】:Sat May 25 14:33:53 CST 2019 done!
Runner【11】:Sat May 25 14:33:53 CST 2019 done!
Runner【13】:Sat May 25 14:33:53 CST 2019 done!
Runner【14】:Sat May 25 14:33:53 CST 2019 done!
Runner【15】:Sat May 25 14:33:55 CST 2019 done!
Runner【17】:Sat May 25 14:33:55 CST 2019 done!
Runner【19】:Sat May 25 14:33:55 CST 2019 done!
Runner【16】:Sat May 25 14:33:55 CST 2019 done!
Runner【18】:Sat May 25 14:33:55 CST 2019 done!

源码

Semaphore：

    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

    public boolean tryAcquire() {
        return sync.nonfairTryAcquireShared(1) >= 0;
    }
    public boolean tryAcquire(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        return sync.nonfairTryAcquireShared(permits) >= 0;
    }

    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    public void acquireUninterruptibly() {
        sync.acquireShared(1);
    }



    public void acquire(int permits) throws InterruptedException {
        if (permits < 0) throw new IllegalArgumentException();
        sync.acquireSharedInterruptibly(permits);
    }
    public void acquireUninterruptibly(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        sync.acquireShared(permits);
    }

    //释放1个许可
    public void release() {
        sync.releaseShared(1);
    }
    //释放指定数量许可
    public void release(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        sync.releaseShared(permits);
    }


    //减少许可
    protected void reducePermits(int reduction) {
        if (reduction < 0) throw new IllegalArgumentException();
        sync.reducePermits(reduction);
    }
    //清空许可
    public int drainPermits() {
        return sync.drainPermits();
    }

Semaphore可以：

  • acqure 1个或者多个许可
  • release 1个或者多个许可
  • 默认是可中断acquire
  • 默认是非公平锁

Sync：

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 1192457210091910933L;

        Sync(int permits) {
            setState(permits);
        }

        final int getPermits() {
            return getState();
        }

        final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))  【1】
                    return remaining;
            }
        }

        protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                if (compareAndSetState(current, next))
                    return true;
            }
        }

        final void reducePermits(int reductions) {
            for (;;) {
                int current = getState();
                int next = current - reductions;
                if (next > current) // underflow
                    throw new Error("Permit count underflow");
                if (compareAndSetState(current, next))
                    return;
            }
        }

        final int drainPermits() {
            for (;;) {
                int current = getState();
                if (current == 0 || compareAndSetState(current, 0))
                    return current;
            }
        }
    }

Fair和NoFair

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;

        NonfairSync(int permits) {
            super(permits);
        }

        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
    }

    /**
     * Fair version
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = 2014338818796000944L;

        FairSync(int permits) {
            super(permits);
        }

        protected int tryAcquireShared(int acquires) {
            for (;;) {
                if (hasQueuedPredecessors())   //【2】
                    return -1;
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }
    }
    public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;

        //队列为空，或者head节点后置为null，表示本线程未在等待队列
        return 
        h != t 
        &&
            (
              (s = h.next) == null      //head节点的后置节点为null
              || 
              s.thread != Thread.currentThread() //或者后置节点关联线程不为本线程
           );
    }

 

比较：

  • 非公平锁，只要许可满足就acquire成功（见【1】）
  • 公平锁，仅当本线程在队列中没有前置节点时，才acquire成功（见【2】）

 

AbstractQueuedSynchronizer源码参考：https://blog.csdn.net/demon7552003/article/details/90105335

 

 

 

demon7552003
关注
专栏目录
Java中Semaphore的深入解析与实战应用
fudaihb的博客
12-28 621
在并发编程的世界里，线程同步是一个至关重要的话题。Java提供了多种同步机制，其中Semaphore（信号量）是一个非常强大的工具，它可以用来控制对共享资源的访问。在这篇博客中，我们将深入探讨Semaphore的概念、用法，并通过实例来加深理解。
Semaphore的简介及应用场景
android开发笔记
06-25 2145
Semaphore是一个计数信号量，常用于限制可以访问某些资源（物理或逻辑的）线程数目。 常用函数： 信号量的构造函数 非公平： public Semaphore(int permits);//permits就是允许同时运行的线程数目 公平（获得锁的顺序与线程启动顺序有关）： public Semaphore(int permits,boolean fair);//permits就是允许...
Java高并发理论到实践--JUC之Semaphore
最新发布
qq_40623672的博客
07-12 1697
由于最近的项目需求：要求限制对OpenMLDB的并发访问量。 当然也看到面试题问：有三个线程T1,T2,T3,如何保证顺序执行？ 以及之前去华为OD面试：三个线程交替打印ABC如何实现？ 这些问题我都采用Java并发工具Semaphore（信号量）来实现的，所以记录一下这个知识点。
Semaphore的使用
arthur.dy.lee的专栏
07-14 1063
Semaphore也是一个线程同步的辅助类，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数。
24.Semaphore的作用和原理
纵横千里 捭阖四方 的专栏
09-19 630
Semaphore就是信号灯的意思，主要功能是用来限制对某个资源同时访问的线性数量，它有两个核心方法：acquire()方法，获取一个令牌。release()方法，释放一个令牌。如下图所示，当多个线程访问某个限制访问流量的资源时，需要先调用acquire()方法获得一个访问令牌，如果能正常获得，则表示允许访问，如果令牌不够，则会阻塞当前线程。
并发编程之Tools&CountDownLatch&Semaphore原理与应用1
08-03
在示例代码中，SemaphoreSample展示了Semaphore的实际应用。创建一个拥有2个许可的Semaphore，然后启动5个线程。每个线程试图获取许可，执行任务（这里仅仅是打印时间和睡眠），然后释放许可。输出结果显示每次只有...
Python semaphore evevt生产者消费者模型原理解析
09-17
### Python Semaphore Event 生产者消费者模型原理 在多线程编程中，生产者-消费者模型是一种常见的模式，用于解决线程间的同步问题。本篇文章将深入解析如何利用Python中的`Semaphore`（信号量）和`Event`来实现...
semaphore:显示简单信号量的Android应用程序
05-02
标题“semaphore:显示简单信号量的Android应用程序”揭示了这是一个基于Android平台的应用程序，它使用了计算机科学中的“信号量”概念。在操作系统中，信号量是一种同步机制，用于控制对共享资源的访问，以防止多个...
semaphore完整搭建ansible部署方案
04-26
解压该文件后，你可以查看其结构，理解 Semaphore 的工作原理，并根据需要进行定制或扩展。源码通常包含 README 文件，提供关于如何编译和安装软件的指示。如果 Semaphore 使用了虚拟环境或特定的依赖项，这些信息也...
并发编程-juc-semaphore信号量实践
感性企鹅的专栏
04-20 223
背景 在进行限流与熔断的过程中，java信号量起到了很大的作用，本wiki将java的信号量做了最基础的实战。 实践过程 参考代码：https://gitee.com/wangtonggui/java_demo.git 创建信号量，公平模式就是先到先得，抢占式就是看运气 信号量阻塞-1，这个是线程安全的 当信号量的可用许可证为0的时候，acquire就会阻塞 release操作就是+1操作，...
Semaphore 机制及源码分析
城中行
10-31 191
前情提要: https://blog.csdn.net/qq_32140607/article/details/102669386 https://blog.csdn.net/qq_32140607/article/details/102796524 首先交代概念 Semaphore是一个计数信号量,Semaphore经常用于限制获取资源的线程数量; AbstractQu...
JUC回顾之-Semaphore底层实现和原理
aodaidi6752的博客
11-13 173
1.控制并发线程数的Semaphore Semaphore（信号量）是用来控制同时访问特定资源的线程数量，它通过协调各个线程，保证合理的使用公共资源。 线程可以通过acquire()方法来获取信号量的许可，当信号量中没有可用的许可的时候，线程阻塞，直到有可用的许可为止。线程可以通过release()方法释放它持有 的信号量的许可。 2.Semaphore的方法列...
一个最简单的实例理解Semaphore在Java中的作用
_Adler.
03-16 764
前言 阅读本篇文章，你需要先理解以下知识： Java基础知识 Thread多线程（点我跳转） 击鼓传花的玩法 你有没有和小伙伴们玩过击鼓传花这个游戏？多个人同时只有“一朵花”的情况下，只有一个人最后会“中奖”。Semaphore就像击鼓手一样控制着这朵“花”究竟“花落谁家”。 当然了，Semaphore不只支持调度一朵花。 它在Java中常被用于线程的调度，当有多个线程访问同一个资源时，我们可...
Semaphore 详解
qq_58148854的博客
12-19 867
可以把它简单的理解成我们停车场入口立着的那个显示屏，每有一辆车进入停车场显示屏就会显示剩余车位减1，每有一辆车从停车场出去，显示屏上显示的剩余车辆就会加1，当显示屏上的剩余车位为0时，停车场入口的栏杆就不会再打开，车辆就无法进入停车场了，直到有一辆车从停车场出去为止。每个停车场入口都有一个提示牌，上面显示着停车场的剩余车位还有多少，当剩余车位为0时，不允许车辆进入停车场，直到停车场里面有车离开停车场，这时提示牌上会显示新的剩余车位数。3、每有一辆车驶出停车场后，显示牌的剩余车位数响应的加1。
Java并发基础：Semaphore全面解析！
科技互联网领域深度探索者，乐于分享与写作。
01-31 2797
Semaphore通过控制许可数量，实现了对并发线程数的精细管理，有效避免了资源竞争和过载问题，能显著提升系统吞吐量和响应速度，同时，Semaphore还支持公平与非公平策略，具有更好的灵活性和适应性，满足了不同业务场景的需求。
java限流器_Semaphore：如何快速实现一个限流器？
weixin_29793001的博客
02-27 359
信号量模型信号量模型还是很简单的，可以简单概括为：一个计数器，一个等待队列，三个方法。在信号量模型里，计数器和等待队列对外是透明的，所以只能通过信号量模型提供的三个方法来访问它们，这三个方法分别是：init()、down() 和 up()。你可以结合下图来形象化地理解。这三个方法详细的语义具体如下所示。init()：设置计数器的初始值。down()：计数器的值减 1；如果此时计数器的值小于 0，则...
Semaphore实现原理
Mutou_ren的博客
01-04 185
示例代码 public class TestSemaphore { public static Semaphore semaphore=new Semaphore(2); public static void main(String[] args) { System.out.println("main start"); for (int i =0...
Java Semaphore深度解析与应用示例
本书旨在介绍如何在实际应用中使用Semaphore以及其内部工作原理。Semaphore是一种并发控制工具，自JDK 1.5起引入，用于限制对特定资源的并发访问线程数量，以确保资源的有效利用。它维护一个许可池，许可数量可由...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值