深入学习semaphore

深入学习semaphore

控制同时访问资源线程数
访问特定资源前，先使用acquire(1)获得许可，如果许可数量为0，该线程则一直阻塞，直到有可用许可。
访问资源后，使用release()释放许可。

demo:

import java.util.concurrent.Semaphore;

public class SemaphoreDemo {
    public static void main(String[] args) {
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for(int i=0;i<N;i++)
            new Worker(i,semaphore).start();
    }

    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

工人0占用一个机器在生产...
工人2占用一个机器在生产...
工人1占用一个机器在生产...
工人3占用一个机器在生产...
工人5占用一个机器在生产...
工人2释放出机器
工人5释放出机器
工人1释放出机器
工人4占用一个机器在生产...
工人0释放出机器
工人6占用一个机器在生产...
工人7占用一个机器在生产...
工人3释放出机器
工人4释放出机器
工人7释放出机器
工人6释放出机器

构造方法：

public Semaphore(int permits) {          //参数permits表示许可数目，即同时可以允许多少线程进行访问
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

获取释放许可：

public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

如果想立即得到执行结果，可以使用下面几个方法：

public boolean tryAcquire() { };    //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

源码分析：

获取许可：

public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

代码继续往下走：

public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

调用doAcquireSharedInterruptibly()方法：

  /**
     * Acquires in shared interruptible mode.
     * @param arg the acquire argument
     */
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

非公平策略

acquire实现，核心代码如下：

final int nonfairTryAcquireShared(int acquires) {
 for (;;) {
     int available = getState();//当前还有多少个资源可用
     int remaining = available - acquires; //可用资源减去线程索取，如果少于0说明资源不够 进入下一轮循环，直到资源够
     if (remaining < 0 ||
         compareAndSetState(available, remaining))/CAS原子性操作
         return remaining;
 }
}

acquires值默认为1，表示尝试获取1个许可，remaining代表剩余的许可数。

如果remaining>0并且成功使用设置available,则获取成功.返回remaining
如果remaining < 0，表示目前没有剩余的许可.结束方法。当前线程进入AQS中的doAcquireSharedInterruptibly方法等待可用许可并挂起，直到被唤醒。

2.release实现，核心代码如下：

protected final boolean tryReleaseShared(int releases) {
 for (;;) {
     int current = getState();
     int next = current + releases;
     if (next < current) // overflow
         throw new Error("Maximum permit count exceeded");
     if (compareAndSetState(current, next))
         return true;
 }
}

releases值默认为1，表示尝试释放1个许可，next 代表如果许可释放成功，可用许可的数量。

通过unsafe.compareAndSwapInt修改state的值，确保同一时刻只有一个线程可以释放成功。
许可释放成功，当前线程进入到AQS的doReleaseShared方法，唤醒队列中等待许可的线程。

公平策略

acquire实现，核心代码如下：

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;
 }
}

在获取前先检查当前节点是否有前继节点(公平性)

2. release实现，和非公平策略一样。