Semaphore的使用

最新推荐文章于 2025-10-23 09:38:15 发布

原创最新推荐文章于 2025-10-23 09:38:15 发布 · 511 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#java #多线程 #thread

Java 同时被 2 个专栏收录

13 篇文章

订阅专栏

JUC学习笔记

5 篇文章

订阅专栏

本文详细介绍了Java中的Semaphore类，探讨了其如何控制线程并发数量，包括Semaphore的基本概念、常见API使用方法，以及通过案例演示Semaphore在多线程环境下的工作原理。

Semaphore类

简介

   Semaphore类所提供的功能完全是synchorized关键字的升级版，但是它提供的功能更加的强大与方便，==主要作用就是控制线程并发的数量==，但是这一点，是synchorized所做不到的
常见API：

在这里插入图片描述

使用

   单词Semaphore的中文含义就是信号、信号系统，此类的主要作用的就是限制线程并发的数量，如果不限制现场并发的数量，则CPU资源很快被耗尽，每个线程执行的任务是相当缓慢。因为CPU要把时间片分配给不同的线程对象，而且上下文切换也要耗时，最终造成系统运行效率大幅降低。
   Smaphore类发放许可的计算方式是“减法”操作。

1、Semaphore类的同步性

   多线程中的同步概念其实就是排队执行任务，执行任务是一个一个执行，不能并行执行，优点是有助于程序逻辑的正确性，不会出现非线程安全的问题，保证软件功能的稳定性。
   现在使用一个案例来看Semaphore是如何限制并发数的：

public class Service {
    //permits为1代表同一时间内，最多允许一个线程同时执行acquire()和release()之间的代码
    private Semaphore semaphore = new Semaphore(1);
    public void testMethod(){
        try {
            //使用1个许可，是减法操作
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName()+"begin timer="+System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println(Thread.currentThread().getName()+"end timer="+System.currentTimeMillis());
            semaphore.release();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class ThreadA extends Thread {

    private Service service;

    public ThreadA(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}

public class ThreadB extends Thread {

    private Service service;

    public ThreadB(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}

public class ThreadC extends Thread {

    private Service service;

    public ThreadC(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}

public class Run {

    
    public static void main(String[] args) {
        Service service = new Service();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        ThreadB b = new ThreadB(service);
        b.setName("B");
        ThreadC c = new ThreadC(service);
        c.setName("C");

        a.start();
        b.start();
        c.start();
    }
}

运行结果：

在这里插入图片描述
由此可看到3个线程是同步的

2、API 方法的使用

2.1、方法acquire(int permits)参数作用及动态添加permits许可数量

有参方法acquire(int permits)的功能是每调用1次该方法，就使用x个许可
代码示例如下：

public class Service {

	private Semaphore semaphore = new Semaphore(10);
	
	public void testMethod() {
		try {
			semaphore.acquire(2);
			System.out.println("Test");
			Thread.sleep(5000);
			semaphore.release(2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

如果多次调用Semaphore类的release()或者release(int)方法时，还可以动态增加permits的个数，例如：

public class Run {

	public static void main(String[] args) {
		Semaphore semaphore = new Semaphore(5);
		try {
			semaphore.acquire();
			semaphore.acquire();
			semaphore.acquire();
			semaphore.acquire();
			semaphore.acquire();
			System.out.println(semaphore.availablePermits());
			semaphore.release();
			semaphore.release();
			semaphore.release();
			semaphore.release();
			semaphore.release();
			semaphore.release();
			System.out.println(semaphore.availablePermits());
			semaphore.release(4);
			System.out.println(semaphore.availablePermits());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

在这里插入图片描述
如结果所示：new Semaphore(5)中的5并不是最终的许可证数量，仅仅是初始的状态值。

2.2、方法acquireUninterruptibly的使用

方法acquireUninterruptibly()的作用是使等待进入acquire()方法的线程，不允许被中断。
中断案例：

public class Service {

	private Semaphore semaphore = new Semaphore(1);
	
	public void testMethod() {
		try {
			semaphore.acquire();
			System.out.println(Thread.currentThread().getName()+" begin timer="+System.currentTimeMillis());
			for(int i=0;i<10000/50;i++) {
				System.out.println(i);
				Thread.sleep(1000);
				
			}
			System.out.println(Thread.currentThread().getName()+" end timer="+System.currentTimeMillis());
			semaphore.release();
		} catch (InterruptedException e) {
			System.out.println("线程"+Thread.currentThread().getName()+"进入了catch");
			e.printStackTrace();
		}
	}
}

public class Run {

	public static void main(String[] args)  {
		Service service  = new Service();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		a.start();
		ThreadB b = new ThreadB(service);
		b.setName("B");
		b.start();
		a.interrupt();
		System.out.println("main中断了a");
	}
}

public class ThreadA extends Thread {

	private Service service;
	
	public ThreadA(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		service.testMethod();
	}
}

public class ThreadB extends Thread {

	private Service service;
	
	public ThreadB(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		service.testMethod();
	}
}

运行结果如图：
在这里插入图片描述
不可中断案例：
将Service中的acquire()修改成acquireUninterruptibly()方法，其他代码无需修改

public class Service {

	private Semaphore semaphore = new Semaphore(1);
	
	public void testMethod() {
		try {
		    //此处修改为不可中断获取
			semaphore.acquireUninterruptibly();
			System.out.println(Thread.currentThread().getName()+" begin timer="+System.currentTimeMillis());
			for(int i=0;i<10000/50;i++) {
				System.out.println(i);
				Thread.sleep(1000);
				
			}
			System.out.println(Thread.currentThread().getName()+" end timer="+System.currentTimeMillis());
			semaphore.release();
		} catch (InterruptedException e) {
			System.out.println("线程"+Thread.currentThread().getName()+"进入了catch");
			e.printStackTrace();
		}
	}
}

结果如下：
在这里插入图片描述

在此我们可以看到当使用acquireUninterruptibly和acquire的使用场景是不一样的，acquire是等待许可的过程中允许中断的，acquireUninterruptibly是等待许可的过程中不允许中断的，acquireUninterruptibly()以及acquireUninterruptibly（int permits）作用是一样的，如果成功获取锁，则取得指定的permits许可个数，具体使用哪一个取决于我们业务逻辑和场景。

2.3、方法availablePermits()和drainPermits()的使用

availablePermits()返回Semaphore对象中当前可用的许可数，此方法通常用于开发调试，因为许可的数量是实时在变化，不是一个固定的值
drainPermits()可以获取并返回立即可用的所有许可个数，并且将可用许可置为0

案例如下：

public class MyService {

	private Semaphore semaphore = new Semaphore(10);
	
	public void testMethod() {
		try {
			semaphore.acquire();
			System.out.println(semaphore.availablePermits());
			System.out.println(semaphore.drainPermits()+" "+semaphore.availablePermits());
			System.out.println(semaphore.drainPermits()+" "+semaphore.availablePermits());
			System.out.println(semaphore.drainPermits()+" "+semaphore.availablePermits());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			semaphore.release();
		}
	}
}

public class Run {

	public static void main(String[] args)  {
		MyService service = new MyService();
		service.testMethod();
	}
}

结果如图所示：
在这里插入图片描述

从结果我们可以发现:
drainPermits()会一次性消费所有的许可，因此当我们不想其他线程同时去消费许可，可以使用此方法来提前消费

2.4、方法getQueueLength()和hasQueueThreads()方法的使用

方法getQueueLength()的作用是取得等待许可的线程个数
方法hasQueueThreads()的作用是判断有没有线程在等待许可
这两个方法通常都是在判断当前有没有等待许可的线程信息时使用

案例如下：

public class MyService {
	
	private Semaphore semaphore  = new Semaphore(1);
	
	public void testMethod() {
		try {
			semaphore.acquire();
			Thread.sleep(1000);
			System.out.println("还有大约:"+semaphore.getQueueLength()+"个线程在等待");
			System.out.println("是否有线程正在等待信号量呢?"+semaphore.hasQueuedThreads());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally {
			semaphore.release();
		}
	}

}

public class MyThread  extends Thread{
	
	private MyService service;
	public MyThread(MyService service) {
		super();
		this.service = service;
	}
	
	@Override
	public void run() {
		service.testMethod();
	}

}

public class Run {

	public static void main(String[] args) {
		MyService service = new MyService();
		MyThread firstThread = new MyThread(service);
		firstThread.start();
		
		MyThread[] threadArray = new MyThread[4];
		for(int i=0;i<4;i++) {
			threadArray[i] = new MyThread(service);
			threadArray[i].start();
		}
	}
}

结果如图所示：
在这里插入图片描述

2.5、方法tryAcquire()及其重载方法的使用

无参方法tryAcquire()的作用是尝试地获取1个许可，如果获取不到则返回false,此方法通常与if语句结合使用，其具有无阻塞的特点。无阻塞的特点可以使线程不至于在同步处一直持续等待的状态，如果if语句判断不成立则线程会继续走else语句，程序会继续运行。
有参方法tryAcquire(int permits)的作用是尝试地获取x个许可，如果获取不到则返回false。
有参方法tryAcquire(int long timeout,TimeUnit unit)的作用是在指定的时间内尝试获取1个许可，如果获取不到则返回false。
有参方法tryAcquire(long permits,long timeout,TimeUnit unit)的作用是在指定的时间内尝试地获取x个许可，如果获取不到则返回false。

案例如下：

public class Service {
	private Semaphore semaphore = new Semaphore(3);
	
	public void testMethod() {
		try {
			if (semaphore.tryAcquire(3, 3, TimeUnit.SECONDS)) {
				System.out.println("ThreadName="+Thread.currentThread().getName()+"首选进入！");
				for (int i = 0; i < Integer.MAX_VALUE; i++) {
					
				}
				semaphore.release();
			}else {
				System.out.println("ThreadName="+Thread.currentThread().getName()+"未成功进入!");
			}
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

public class Run {

	public static void main(String[] args) {
		Service service = new Service();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		a.start();
		
		ThreadB b = new ThreadB(service);
		b.setName("B");
		b.start();
		
	}
}

结果如图所示：
在这里插入图片描述

2.6、公平和非公平信号量

所谓的公平信号量是获得锁的顺序与线程启动的顺序有关，但不代表100%地获得信号量，仅仅是在概率上能得到保证，而非公平信号量则与其无关。

案例如下：
非公平信号量：

public class MyService {
	private boolean isFair = false;
	private Semaphore semaphore = new Semaphore(1,isFair);
	
	public void testMethod() {
		try {
			semaphore.acquire();
			System.out.println("ThreadName="+Thread.currentThread().getName());
		} catch (InterruptedException e) {
			
			e.printStackTrace();
		}finally {
			semaphore.release();
		}
	}

}

public class MyThread  extends Thread{

	private MyService myService;
	
	public MyThread(MyService myService) {
		super();
		this.myService = myService;
	}
	@Override
	public void run() {
		System.out.println("ThreadName="+this.getName()+"启动了！");
		myService.testMethod();
	}
}

public class Run {

	public static void main(String[] args) {
		MyService service = new MyService();
		MyThread firstThread = new MyThread(service);
		firstThread.start();
		
		MyThread[] threadArray = new MyThread[4];
		for (int i = 0; i < 4; i++) {
			threadArray[i] = new MyThread(service);
			threadArray[i].start();
		}
	}
}

结果如图：
在这里插入图片描述

非公平信号量是线程启动的顺序和调用semaphore.acquire()的顺序无关，也就是线程先启动了并不代表获得许可
修改MyService中的代码如下：
private boolean isFair = true;

运行结果如图：
在这里插入图片描述

此现象说明即使是公平信号量，也不能保证线程启动顺序和semaphore.acquire()强一致性

在此，Semaphore常用的API已经基本学习完成了，后续将继续学习Exchanger的使用，加油！！！