java Concurrent包学习笔记（五）：Semaphore

一、Semaphore 是什么 

信号量Semaphore是一个并发工具类，用来控制可同时并发的线程数，其内部维护了一组虚拟许可，构造函数初始化的时候可以指定许可的总数量

每次线程执行操作时先通过acquire方法获得许可，线程获得许可后Semaphore 的许可数量会减1，执行完毕再通过release方法释放许可，emaphore 的许可数量会加1。如果无可用许可，那么acquire方法将一直阻塞，直到其它线程释放许可。
主要方法：

• Semaphore(int permits): 构造方法，创建具有给定许可数的计数信号量并设置为非公平信号量。
• Semaphore(int permits,boolean fair): 构造方法，当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量。
• void acquire(): 从此信号量获取一个许可，如果没有获取到许可线程将一直阻塞。
• void acquire(int n): 从此信号量获取给定数目许可，在提供这些许可前一直将线程阻塞。
• void release(): 释放一个许可，将其返回给信号量。就如同车开走返回一个车位。
• void release(int n): 释放n个许可。
• int availablePermits()：当前可用的许可数

二、Semaphore 和线程池的区别

• 线程池：用来控制实际工作的线程数量，通过线程复用的方式来减小内存开销。线程池可同时工作的线程数量是一定的，超过该数量的线程需进入线程队列等待，直到有可用的工作线程来执行任务。
• Semaphore: 你创建了多少线程，实际就会有多少线程进行执行，只是可同时执行的线程数量会受到限制。但使用线程池，不管你创建多少线程，实际可执行的线程数是一定的。

示例程序：

package semaphore.demo;

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

/**
 * @author boshen
 * @date 2018/12/20
 */
public class SemaphoreTest1 {
    /**
     * 用线程池来控制工作线程
     */
    private static void testThreadPoll(){
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        for(int i = 0;i< 5;i++)
            executorService.submit(new Runnable() {
                public void run() {
                    try {
                        String name = UUID.randomUUID().toString().substring(4,10);
                        System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());
                        Thread.sleep(2000);
                        System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        executorService.shutdown();
    }

    /**
     * 用Semaphore来控制工作线程
     */
    private static void testSemaphore(){
        final Semaphore semaphore = new Semaphore(2);
        for(int i=0;i<5;i++){
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                        semaphore.acquire();
                        String name = UUID.randomUUID().toString().substring(4,10);
                        System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());
                        Thread.sleep(2000);
                        System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();
        }
    }

    public static void main(String[] args){
        System.out.println("以下是testThreadPoll输出的结果============================================");
        testThreadPoll();
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("以下是testSemaphore输出的结果============================================");
        testSemaphore();
    }
}

以下是testThreadPoll输出的结果============================================
学生:14fd-7 开始工作，线程号为：pool-1-thread-1
学生:6bc6-6 开始工作，线程号为：pool-1-thread-2
学生:6bc6-6 完成工作，线程号为：pool-1-thread-2
学生:6a3b-6 开始工作，线程号为：pool-1-thread-2
学生:14fd-7 完成工作，线程号为：pool-1-thread-1
学生:9e7b-9 开始工作，线程号为：pool-1-thread-1
学生:6a3b-6 完成工作，线程号为：pool-1-thread-2
学生:2ed3-4 开始工作，线程号为：pool-1-thread-2
学生:9e7b-9 完成工作，线程号为：pool-1-thread-1
学生:2ed3-4 完成工作，线程号为：pool-1-thread-2
以下是testSemaphore输出的结果============================================
学生:8121-6 开始工作，线程号为：Thread-1
学生:99e9-7 开始工作，线程号为：Thread-0
学生:99e9-7 完成工作，线程号为：Thread-0
学生:8121-6 完成工作，线程号为：Thread-1
学生:b9a5-7 开始工作，线程号为：Thread-3
学生:058d-3 开始工作，线程号为：Thread-2
学生:b9a5-7 完成工作，线程号为：Thread-3
学生:7f6a-c 开始工作，线程号为：Thread-4
学生:058d-3 完成工作，线程号为：Thread-2
学生:7f6a-c 完成工作，线程号为：Thread-4

由以上结果可知当使用前线池的时候，同时只有2个线程执行工作，线程号只会有1和2，线程会进行复用；Semaphore虽然也只有2个线程能同时工作，但是线程号是0、1、2、3、4，也就是5个线程都执行了，只不过同一时刻有三个线程阻塞了而已。

三、Semaphore 公平信号量和非公平信号量

示例：

package semaphore.demo;

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

/**
 * @author boshen
 * @date 2018/12/20
 */
public class SemaphoreTest2 {
    /**
     * 公平信号量
     */
    private static void testFairSemaphore(){
        final Semaphore semaphore1 = new Semaphore(2,true);
        for(int i=0;i<5;i++){
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                        String name = UUID.randomUUID().toString().substring(4,10);
                        System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());
                        semaphore1.acquire();
                        Thread.sleep(1000);
                        System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());
                        semaphore1.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();
        }
    }

    /**
     * 非公平信号量
     */
    private static void testUnFairSemaphore(){
        final Semaphore semaphore2 = new Semaphore(2);
        for(int i=0;i<5;i++){
            final Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                        String name = UUID.randomUUID().toString().substring(4,10);
                        System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());
                        semaphore2.acquire();
                        Thread.sleep(1000);
                        System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());
                        semaphore2.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();
        }
    }

    public static void main(String[] args){
        System.out.println("以下是testFairSemaphore输出的结果============================================");
        testFairSemaphore();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("以下是testUnFairSemaphore输出的结果============================================");
        testUnFairSemaphore();
    }
}

以下是testFairSemaphore输出的结果============================================
学生:81f2-0 开始工作，线程号为：Thread-0
学生:6981-d 开始工作，线程号为：Thread-1
学生:e212-a 开始工作，线程号为：Thread-4
学生:f059-d 开始工作，线程号为：Thread-2
学生:9ece-5 开始工作，线程号为：Thread-3
学生:81f2-0 完成工作，线程号为：Thread-0
学生:e212-a 完成工作，线程号为：Thread-4
学生:6981-d 完成工作，线程号为：Thread-1
学生:f059-d 完成工作，线程号为：Thread-2
学生:9ece-5 完成工作，线程号为：Thread-3
以下是testUnFairSemaphore输出的结果============================================
学生:9552-1 开始工作，线程号为：Thread-5
学生:4908-0 开始工作，线程号为：Thread-7
学生:e920-5 开始工作，线程号为：Thread-6
学生:be7a-f 开始工作，线程号为：Thread-9
学生:e4fc-b 开始工作，线程号为：Thread-8
学生:4908-0 完成工作，线程号为：Thread-7
学生:e920-5 完成工作，线程号为：Thread-6
学生:9552-1 完成工作，线程号为：Thread-5
学生:e4fc-b 完成工作，线程号为：Thread-8
学生:be7a-f 完成工作，线程号为：Thread-9

公平信号量的效果：哪信线程首先调用Semaphore.acquire（），哪个线程优先获得许可，首先启动的线程优先获取许可（不是100%，只是增加了概率）

非公平信号量的效果：是与线程的启动顺序与调用Semaphore.acquire（）顺序无关，也就是说先启动的线程并不一定先获得许可。