Java并发编程之Semaphore

简介

Semaphore是用来限制访问特定资源的并发线程的数量。

相对于内置锁synchronized和重入锁ReentrantLock的互斥性来讲，Semaphore能够容许多个线程同时访问共享资源。

Semaphored的使用

构造方法

Semaphore(int permits)：建立Semaphore，并指定许可证的数量。（公平策略为非公平）

Semaphore(int permits, boolean fair)：建立Semaphore，并指定许可证的数量和公平策略。

核心方法

acquire()：从Semaphore中获取一个许可证，若是获取不到则阻塞等待，直到其余线程释放了一个许可证或者当前线程被中断。

acquire(int permits)：从Semaphore中获取指定数量的许可证，若是获取不到则阻塞等待，直到其余线程释放了对应数量的许可证或者当前线程被中断。

acquireUninterruptibly()：从Semaphore中获取一个许可证，若是获取不到则阻塞等待，直到其余线程释放了一个许可证。（不响应中断）

tryAcquire()：尝试从Semaphore中获取一个许可证，获取成功则返回true，获取失败则返回false，不会进行等待。（不受公平策略的影响，许可证可用则当即得到）

tryAcquire(long timeout, TimeUnit unit)：尝试从Semaphore中获取一个许可证，获取成功则返回true，获取失败则等待指定的时间，直到等待时间结束仍是没有获取到许可证则返回false。

release()：释放一个许可证。

release(int permits)：释放指定数量的许可证。

示例

总共有5个许可证，最早获取到许可证的5个线程开始执行任务，没获取到的线程进入等待状态，直到获取到许可证的线程释放许可证后，再获取许可证执行任务。

public class Demo {

    public static void main(String[] args) {
        //建立许可证数量为5的Semaphore
        Semaphore semaphore = new Semaphore(5);

        Runnable runnable = () -> {
            String threadName = Thread.currentThread().getName();
            try{
                //获取一个许可证
                semaphore.acquire();
                System.out.println(threadName + "执行任务...");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放一个许可证
                semaphore.release();
            }
        };

        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for(int i = 0; i < 10; i++){
            executorService.execute(runnable);
        }

        executorService.shutdown();
    }

}

/* 开始输出：
 * pool-1-thread-1执行任务...
 * pool-1-thread-5执行任务...
 * pool-1-thread-6执行任务...
 * pool-1-thread-7执行任务...
 * pool-1-thread-3执行任务...
 * 三秒后输出：
 * pool-1-thread-4执行任务...
 * pool-1-thread-8执行任务...
 * pool-1-thread-2执行任务...
 * pool-1-thread-10执行任务...
 * pool-1-thread-9执行任务...
 */

使用Semaphore实现互斥

使用Semaphore实现互斥只须要将许可证数量设置为1，这样就能够保证只有一个线程能获取到许可证。

Semaphore semaphore = new Semaphore(1);

相比内置锁synchronized和重入锁ReentrantLock，使用Semaphore实现互斥有个明显的缺点：不可重入，没有释放许可证的状况下，再次调acquire方法将致使死锁。

示例：

public class Demo {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(1);

        Runnable runnable = () -> {
            String threadName = Thread.currentThread().getName();
            try {
                //获取一个许可证
                semaphore.acquire();
                System.out.println(threadName + "执行任务A...");
                semaphore.acquire();
                System.out.println(threadName + "执行任务B...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放一个许可证
                semaphore.release();
            }
        };

        new Thread(runnable).start();
    }

}

/*
 * 输出结果：
 * Thread-0执行任务A...
 */

“执行任务B”永远不会打印，由于许可证只有一个，第二次acquire方法的调用会由于没法获取到许可证而一直阻塞。