Semaphore 信号量及其理解

一、Semaphore 信号量

Semaphore (信号量)是由计算机科学家Dijkstra在1965年提出的，广泛应用不同的操作系统，在管程提出之前信号量就是并发编程领域的霸主！几乎所有并发的语言都支持信号量机制。

Semaphore 也有被翻译成信号灯，因为其机制就像我们日常生活中的红绿灯，车辆的通行看红绿灯，对应编程世界的线程能不能执行得看信号灯！

Semaphore 用来多线程互斥问题，相对于synchronized和Lock来说它允许多个线程访问一个临界区！例如各种池：数据库连接池、对象池等，这些池的需求就是同一时刻允许多个线程同时使用连接池。

Semaphore的模型可以概括为一个计数器、一个等待队列、三个方法。三个方法原子性分别是init()、down()、up()；

init()：设置计数器的初始值。
down()：将计数器的值减一，如果减了一之后，计数器的值小于0，则当前的线程被阻塞，否则继续执行。
up()：将计数器的值加一，如果加了一之后，计数器的值小于等于0，则唤醒等待队列中的一个线程，并且将它移除出等待队列。(注意是小于等于0，不应该理解为大于等于0，因为大于等于0表明此时没有等待的线程，所以不会有唤醒这个操作。)

简单的理解就是Semaphore就是通过这三个方法来改变计数器，通过计数器的值来判断此时的线程是应该加入到等待队列中等待还是成功执行。

信号量模型也被称为PV原语，也就是down和up操作最早称为P操作和V操作，有些人还称为semWait和semSignal。在JAVA中信号量模型是由 java.util.concurrent.Semaphore 的实现，并且down和up对应的实现方法是acquire和release，我们来看下简单的使用例子

int count;
final Semaphore semaphore   = new Semaphore(1);//初始化信号量
//用信号量保证互斥
void addOne() {
    try {
        semaphore.acquire();//对应down
        count += 1;
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        semaphore.release();//对应up
    }
}

如果你想多让几个线程进去临界区，那么就把Semaphore构造器中的1改为你想要的线程数。
可以理解为颁发许可证，比如想同时允许3个线程进入临界区，构造器中的数就填3，理解为搞了3张许可证，然后颁发出去，谁拿到了许可证谁就能进临界区，进入临界区后的线程搞完事了，就归还许可证，然后出去。
Semaphore的内部共存在Sync、NonfairSync、FairSync三个类，NonfairSync与FairSync类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类，也就Semaphore是依托于NonfairSync、FairSync来实现的。

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

可以通过构造函数来指定为公平锁还是非公平锁，公平的意思这个许可只会给按先来后到的顺序给等待队列中的线程。而非公平的意思就是对于任何申请许可的线程，都第一时间看是否有多余的许可，如果有则给此线程。

protected int tryAcquireShared(int acquires) {//公平
    for (;;) {
        if (hasQueuedPredecessors()) {
            return -1;
        }
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
                compareAndSetState(available, remaining)) {
            return remaining;
        }
    }
}

protected int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires);//非公平
}

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

差别就在于有没hasQueuedPredecessors()，这个方法就是判断当前线程是否是等待队列中的头结点，如果不是，则不给于分配。
大致Semaphore的模型和模型实现思路就是这样，建议多看看源码，不难的可以加深理解，并且懂得具体实现之后能掌握把控更多细节，还不怕面试官问。

二、Semaphore信号量理解

Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个release方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有实际的许可证这个对象，Semaphore只是维持了一个可获得许可证的数量。

Semaphore经常用于限制获取某种资源的线程数量。下面举个例子，比如说操场上有5个跑道，一个跑道一次只能有一个学生在上面跑步，一旦所有跑道在使用，那么后面的学生就需要等待，直到有一个学生不跑了，下面是这个例子：

package com.tpr;
import java.util.concurrent.Semaphore;

/**
 * 操场，有5个跑道 Created by canghaihongxin on 2018-12-09.
 */
public class Playground {
    /**
     * 跑道类
     */
    static class Track {
        private int num; // 几号跑道 

        public Track(int num) {
            this.num = num;
        }

        @Override
        public String toString() {
            return "Track{" + "num=" + num + '}';
        }
    }
    
    private Track[] tracks = { new Track(1), new Track(2), new Track(3), new Track(4), new Track(5) };//跑道数据 
    private volatile boolean[] used = new boolean[5];//默认是false
    private Semaphore semaphore = new Semaphore(5, true);//定义了五个信息号

    // 信号量 类似一个带有计算器功能的开关， 他能够阻塞线程。 
    // 线程1 在这里面获取了一把钥匙， 就要以执行以后的代码。其他的线程如果获取不到就不能执行，就会卡在信号量这里。 
    // 他初始化的时候，可以规定有几个钥匙

    /**
     * 获取一个跑道
     */
    public Track getTrack() throws InterruptedException {
        // 每个acquire方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；
        // 线程跑到这里，就会获取一个钥匙， 如果获取不到，就等着。

        semaphore.acquire(1); 
        System.out.println("获取钥匙");
        return getNextAvailableTrack();
    }

    /**
     * 释放一个跑道 ， 就是把一个有人的跑道设置成一个没有人的跑道 
     *  
     * 返回一个跑道
     *
     * @param track
     */
    public void releaseTrack(Track track) {
        if (makeAsUsed(track)) {
            semaphore.release(1);
        }
        //makeAsUsed(track);
    }

    /**
     * 遍历，找到一个没人用的跑道
     * 定义一个长度为五的布尔类型的数组是和五个跑道相对应的，当使用了一个跑道，就把相对应的数组改为true
     *  
     * @return
     */
    private Track getNextAvailableTrack() {
        for (int i = 0; i < used.length; i++) {
            if (!used[i]) {
                used[i] = true;
                return tracks[i];
            }
        }
        return null;
    }

    /**
     * 返回一个跑道
     *
     * @param track
     */
    private boolean makeAsUsed(Track track) {
        for (int i = 0; i < used.length; i++) {
            if (tracks[i] == track) {
                if (used[i]) {
                    used[i] = false;
                    return true;
                } else {
                    return false;
                }
            }
        }
        return false;
    }
}

从上面可以看到，创建了5个跑道对象，并使用一个boolean类型的数组记录每个跑道是否被使用了，初始化了5个许可证的Semaphore，在获取跑道时首先调用acquire(1)获取一个许可证，在归还一个跑道是调用release(1)释放一个许可证。接下来再看启动程序，如下：

package com.tpr;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
	static class Student implements Runnable {
        private int num;
        private Playground playground;

        public Student(int num, Playground playground) {
            this.num = num;
            this.playground = playground;
        }

        @Override
        public void run() {
        	try {
                //获取跑道
                Playground.Track track = playground.getTrack();

                if (track != null) {
                    System.out.println("学生" + num + "在" + track.toString() + "上跑步");
                    //TimeUnit.SECONDS.sleep(2);
                    //释放跑道
                    playground.releaseTrack(track);
                    System.out.println("学生" + num + "释放" + track.toString());
                }
         	} catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
	}

    public static void main(String[] args) {
        Executor executor = Executors.newCachedThreadPool();
        Playground playground = new Playground();

        for (int i = 0; i < 100; i++) {
        	executor.execute(new Student(i+1,playground));
        }
    }
}

输出结果

源码解析

Semaphore有两种模式，公平模式和非公平模式。公平模式就是调用acquire的顺序就是获取许可证的顺序，遵循FIFO；而非公平模式是抢占式的，也就是有可能一个新的获取线程恰好在一个许可证释放时得到了这个许可证，而前面还有等待的线程。

构造方法
Semaphore有两个构造方法，如下：

public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

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

从上面可以看到两个构造方法，都必须提供许可的数量，第二个构造方法可以指定是公平模式还是非公平模式，默认非公平模式。

Semaphore内部基于AQS的共享模式，所以实现都委托给了Sync类。

这里就看一下NonfairSync的构造方法：

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

可以看到直接调用了父类的构造方法，Sync的构造方法如下：

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

可以看到调用了setState方法，也就是说AQS中的资源就是许可证的数量。

总结

Semaphore是信号量，用于管理一组资源。其内部是基于AQS的共享模式，AQS的状态表示许可证的数量，在许可证数量不够时，线程将会被挂起；而一旦有一个线程释放一个资源，那么就有可能重新唤醒等待队列中的线程继续执行。主要作用是控制线程的执行。

转载：

https://www.jianshu.com/p/db4cf665cd31

https://www.jianshu.com/p/28aa2aa6ab29