Semaphore原理

源码解析

Semaphore（信号量），这个类是用来控制并发时线程的数量的，首先这个类是实现了序列化接口
public class Semaphore implements Serializable（序列化）

我们主要来看看内部的一个结构和主要的方法acquire（获得）和release（释放）方法

其中这个类中有几个内部类，首先是抽象类 Sync 继承了同步器，

 abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 1192457210091910933L;
        //构造方法，设置了同步状态的值
        Sync(int permits) {
            setState(permits);
        }
        //返回当前的同步状态的值
        final int getPermits() {
            return getState();
        }
        //尝试获取不公平的锁
        final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                //得到的同步状态的值
                int available = getState();
                //根据得到的值尝试修改同步状态的值
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }
        //尝试释放锁
        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;
            }
        }
        //减少同步状态值
        final void reducePermits(int reductions) {
            for (;;) {
                int current = getState();
                int next = current - reductions;
                if (next > current) // underflow
                    throw new Error("Permit count underflow");
                if (compareAndSetState(current, next))
                    return;
            }
        }
       //返回剩余的同步状态值
        final int drainPermits() {
            for (;;) {
                int current = getState();
                if (current == 0 || compareAndSetState(current, 0))
                    return current;
            }
        }
    }

然后分别有两个静态的内部类 NonfairSync（不公平模式）和FairSync（公平模式）实现了抽象类Sync，可以看到分别重写了同步器中的tryAcquireShared方法，下面是源码

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;
        //调用了父类的构造函数
        NonfairSync(int permits) {
            super(permits);
        }
       //尝试获取锁，实际调用父类的nonfairTryAcquireShared方法
        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
    }

    /**
     * Fair version
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = 2014338818796000944L;
       //调用了父类的构造方法
        FairSync(int permits) {
            super(permits);
        }
        //可以看到和父类的方法中，只是多了一个hasQueuedPredecessors方法来先判断当前的
       // 对列中是否还有任务
        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;
            }
        }

接下来是构造方法

    //默认创建一个同步状态值为permits的不公平模式
    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }
    //根据boolean判断生成不公平还是公平的模式
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

然后是acquire() 方法

    //设置每个线程每个线程需要占用的同步状态值 默认为1
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    //自定义每个线程每个线程需要占用的同步状态值
    public void acquire(int permits) throws InterruptedException {
        //必须大于0，否则抛出异常
        if (permits < 0) throw new IllegalArgumentException();
        sync.acquireSharedInterruptibly(permits);
    }

然后是release方法

   //释放当前线程所占用的同步状态值，默认为1
    public void release() {
        sync.releaseShared(1);
    }
 //释放当前线程所占用的同步状态值
    public void release(int permits) {
        //必须大于0 否则抛出异常
        if (permits < 0) throw new IllegalArgumentException();
        sync.releaseShared(permits);
    }

下面是一个Semaphore使用的示例

public class Demo extends Thread {
    private  Semap semap;
    public Demo(Semap semap){
        this.semap=semap;
    }
    @Override
    public void run(){
          semap.Test();
    }
}

public class Semap {
        //设置一个同步值为3的Semaphore
        Semaphore semaphore=new Semaphore(3);
        public void Test(){
            try {
                //设置每个线程要占用的同步值 默认为1
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " 开始： " + LocalTime.now());
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " 结束： " + LocalTime.now());
                //释放所占用的状态值
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
}
//运行
public class SemaphoreDemo{
    public static void main(String[] args) {
        Semap semap=new Semap();
        for(int i=0;i<5;i++){
            new Demo(semap).start();
        }
    }
}
//运行结果
Thread-0 开始： 15:35:38.643
Thread-1 开始： 15:35:38.643
Thread-2 开始： 15:35:38.643
Thread-0 结束： 15:35:39.643
Thread-1 结束： 15:35:39.643
Thread-2 结束： 15:35:39.643
Thread-4 开始： 15:35:39.643
Thread-3 开始： 15:35:39.643
Thread-3 结束： 15:35:40.644
Thread-4 结束： 15:35:40.644

总结

可以看出来其实Semaphore内部其实是根据同步状态的值来限制并发的时线程的数量，当同步状态值为0时，后来的线程将被阻塞，直到有线程释放。