Semaphore(信号量)
作用
Semaphore的作用是控制并发访问的线程数目。
核心方法
//参数permits表示许可数目，即同时可以允许多少线程进行访问
public Semaphore(int permits);
//这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
public Semaphore(int permits, boolean fair);
//获取一个许可,如果没有继续等待
public void acquire() throws InterruptedException;
//尝试获取一个许可,获取到返回true,未获取到返回false
public boolean tryAcquire();
//尝试获取指定时间内的1个许可,超时后,不再尝试获取许可,直接返回false
public boolean tryAcquire(long timeout, TimeUnit unit);
//释放一个许可
public void release();
//获取多个许可
public void acquire(int permits) throws InterruptedException;
public void acquireUninterruptibly(int permits);
//尝试获取多个许可,获取到后返回true,未获取到返回false
public boolean tryAcquire(int permits);
//尝试获取指定时间内的多个许可,超时后,不再尝试获取许可,直接返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException;
//释放多个许可
public void release(int permits);
示例
获取一个许可
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* @author scottxuan
*/
@Slf4j
public class SemaphoreExample1 {
private final static int threadCount = 12;
public static void main(String[] args) {
//控制并发数目为3 (许可的总数)
Semaphore semaphore = new Semaphore(3);
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < threadCount; i++) {
final int num = i;
executor.execute(()->{
try {
//获取一个许可
semaphore.acquire();
update(num);
//释放一个许可
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
executor.shutdown();
}
private static void update(int num) throws InterruptedException {
log.info("current num {}",num);
//线程睡眠可以更明显的看到效果
Thread.sleep(3000);
}
}
//输出结果(注意时间,每次执行3个线程,间隔是设置的线程睡眠的时间3s)
//23:00:34.761 [pool-1-thread-3] INFO scottxuan.semaphore.SemaphoreExample1 - current num 2
//23:00:34.761 [pool-1-thread-2] INFO scottxuan.semaphore.SemaphoreExample1 - current num 1
//23:00:34.761 [pool-1-thread-1] INFO scottxuan.semaphore.SemaphoreExample1 - current num 0
//23:00:37.768 [pool-1-thread-6] INFO scottxuan.semaphore.SemaphoreExample1 - current num 5
//23:00:37.768 [pool-1-thread-5] INFO scottxuan.semaphore.SemaphoreExample1 - current num 4
//23:00:37.768 [pool-1-thread-4] INFO scottxuan.semaphore.SemaphoreExample1 - current num 3
//23:00:40.778 [pool-1-thread-8] INFO scottxuan.semaphore.SemaphoreExample1 - current num 7
//23:00:40.778 [pool-1-thread-9] INFO scottxuan.semaphore.SemaphoreExample1 - current num 8
//23:00:40.778 [pool-1-thread-7] INFO scottxuan.semaphore.SemaphoreExample1 - current num 6
//23:00:43.791 [pool-1-thread-10] INFO scottxuan.semaphore.SemaphoreExample1 - current num 9
//23:00:43.791 [pool-1-thread-11] INFO scottxuan.semaphore.SemaphoreExample1 - current num 10
//23:00:43.791 [pool-1-thread-12] INFO scottxuan.semaphore.SemaphoreExample1 - current num 11
获取多个许可
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* @author scottxuan
*/
@Slf4j
public class SemaphoreExample2 {
private final static int threadCount = 12;
public static void main(String[] args) {
//控制并发量为3
Semaphore semaphore = new Semaphore(3);
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < threadCount; i++) {
final int num = i;
executor.execute(()->{
try {
//获取多个许可,这里一个线程直接获取3个,就没有了,第二个线程等他执行完释放后,才可以执行
semaphore.acquire(3);
update(num);
//释放多个许可
semaphore.release(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
executor.shutdown();
}
private static void update(int num) throws InterruptedException {
log.info("current num {}",num);
Thread.sleep(1000);
}
}
//结果输出 注意时间 每秒,输出1次
//23:15:44.148 [pool-1-thread-1] INFO scottxuan.semaphore.SemaphoreExample2 - current num 0
//23:15:45.169 [pool-1-thread-2] INFO scottxuan.semaphore.SemaphoreExample2 - current num 1
//23:15:46.179 [pool-1-thread-3] INFO scottxuan.semaphore.SemaphoreExample2 - current num 2
//23:15:47.194 [pool-1-thread-4] INFO scottxuan.semaphore.SemaphoreExample2 - current num 3
//23:15:48.196 [pool-1-thread-5] INFO scottxuan.semaphore.SemaphoreExample2 - current num 4
//23:15:49.199 [pool-1-thread-6] INFO scottxuan.semaphore.SemaphoreExample2 - current num 5
//23:15:50.214 [pool-1-thread-7] INFO scottxuan.semaphore.SemaphoreExample2 - current num 6
//23:15:51.214 [pool-1-thread-8] INFO scottxuan.semaphore.SemaphoreExample2 - current num 7
//23:15:52.226 [pool-1-thread-9] INFO scottxuan.semaphore.SemaphoreExample2 - current num 8
//23:15:53.227 [pool-1-thread-10] INFO scottxuan.semaphore.SemaphoreExample2 - current num 9
//23:15:54.239 [pool-1-thread-11] INFO scottxuan.semaphore.SemaphoreExample2 - current num 10
//23:15:55.242 [pool-1-thread-12] INFO scottxuan.semaphore.SemaphoreExample2 - current num 11
尝试获取许可
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* @author scottxuan
*/
@Slf4j
public class SemaphoreExample3 {
private final static int threadCount = 12;
public static void main(String[] args) {
//控制并发量为3
Semaphore semaphore = new Semaphore(3);
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < threadCount; i++) {
final int num = i;
executor.execute(()->{
try {
//尝试获取1个许可
if (semaphore.tryAcquire()) {
update(num);
//释放一个许可
semaphore.release();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
executor.shutdown();
}
private static void update(int num) throws InterruptedException {
log.info("current num {}",num);
Thread.sleep(1000);
}
}
//输出结果 只有3个线程执行完了 3个线程获取到许可后,并发数目(许可总数)用完了 后续的线程获取不到,无法进入if中的代码
//23:17:35.375 [pool-1-thread-1] INFO scottxuan.semaphore.SemaphoreExample3 - current num 0
//23:17:35.375 [pool-1-thread-2] INFO scottxuan.semaphore.SemaphoreExample3 - current num 1
//23:17:35.375 [pool-1-thread-3] INFO scottxuan.semaphore.SemaphoreExample3 - current num 2
尝试获取带时间参数的许可
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* @author scottxuan
*/
@Slf4j
public class SemaphoreExample4 {
private final static int threadCount = 12;
public static void main(String[] args) {
//控制并发量为3(许可总数)
Semaphore semaphore = new Semaphore(3);
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < threadCount; i++) {
final int num = i;
executor.execute(()->{
try {
//尝试获取3s内的许可,获取不到则返回false
if (semaphore.tryAcquire(3, TimeUnit.SECONDS)) {
update(num);
//释放一个许可
semaphore.release();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
executor.shutdown();
}
private static void update(int num) throws InterruptedException {
log.info("current num {}",num);
Thread.sleep(1000);
}
}
//输出结果
//总计12个线程,并发为3,线程执行沉睡1s,所以每次执行3个线程,在第3次执行完成后,线程的睡眠总时间也到达3s了,
//尝试获取指定时间内的许可失败后,直接返回false
//23:25:11.166 [pool-1-thread-2] INFO scottxuan.semaphore.SemaphoreExample4 - current num 1
//23:25:11.166 [pool-1-thread-3] INFO scottxuan.semaphore.SemaphoreExample4 - current num 2
//23:25:11.166 [pool-1-thread-1] INFO scottxuan.semaphore.SemaphoreExample4 - current num 0
//23:25:12.176 [pool-1-thread-5] INFO scottxuan.semaphore.SemaphoreExample4 - current num 4
//23:25:12.176 [pool-1-thread-6] INFO scottxuan.semaphore.SemaphoreExample4 - current num 5
//23:25:12.176 [pool-1-thread-4] INFO scottxuan.semaphore.SemaphoreExample4 - current num 3
//23:25:13.187 [pool-1-thread-7] INFO scottxuan.semaphore.SemaphoreExample4 - current num 6
//23:25:13.187 [pool-1-thread-8] INFO scottxuan.semaphore.SemaphoreExample4 - current num 7
//23:25:13.187 [pool-1-thread-9] INFO scottxuan.semaphore.SemaphoreExample4 - current num 8
