//構(gòu)造器1
public Semaphore(int permits) {
  sync = new NonfairSync(permits);
}

//構(gòu)造器2
public Semaphore(int permits, boolean fair) {
  sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

//獲取一個(gè)許可證(響應(yīng)中斷)
public void acquire() throws InterruptedException {
  sync.acquireSharedInterruptibly(1);
}

//獲取一個(gè)許可證(不響應(yīng)中斷)
public void acquireUninterruptibly() {
  sync.acquireShared(1);
}

//嘗試獲取許可證(非公平獲取)
public boolean tryAcquire() {
  return sync.nonfairTryAcquireShared(1) >= 0;
}

//嘗試獲取許可證(定時(shí)獲取)
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException {
  return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

//以可中斷模式獲取鎖(共享模式)
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
  //首先判斷線程是否中斷, 如果是則拋出異常
  if (Thread.interrupted()) {
    throw new InterruptedException();
  }
  //1.嘗試去獲取鎖
  if (tryAcquireShared(arg) < 0) {
    //2. 如果獲取失敗則進(jìn)人該方法
    doAcquireSharedInterruptibly(arg);
  }
}

abstract static class Sync extends AbstractQueuedSynchronizer {
  //非公平方式嘗試獲取
  final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
      //獲取可用許可證
      int available = getState();
      //獲取剩余許可證
      int remaining = available - acquires;
      //1.如果remaining小于0則直接返回remaining
      //2.如果remaining大于0則先更新同步狀態(tài)再返回remaining
      if (remaining < 0 || compareAndSetState(available, remaining)) {
        return remaining;
      }
    }
  }
}

//非公平同步器
static final class NonfairSync extends Sync {
  private static final long serialVersionUID = -2694183684443567898L;

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

  //嘗試獲取許可證
  protected int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires);
  }
}

//公平同步器
static final class FairSync extends Sync {
  private static final long serialVersionUID = 2014338818796000944L;

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

  //嘗試獲取許可證
  protected int tryAcquireShared(int acquires) {
    for (;;) {
      //判斷同步隊(duì)列前面有沒(méi)有人排隊(duì)
      if (hasQueuedPredecessors()) {
        //如果有的話就直接返回-1，表示嘗試獲取失敗
        return -1;
      }
      //獲取可用許可證
      int available = getState();
      //獲取剩余許可證
      int remaining = available - acquires;
      //1.如果remaining小于0則直接返回remaining
      //2.如果remaining大于0則先更新同步狀態(tài)再返回remaining
      if (remaining < 0 || compareAndSetState(available, remaining)) {
        return remaining;
      }
    }
  }
}

//以可中斷模式獲取鎖(共享模式)
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
  //首先判斷線程是否中斷, 如果是則拋出異常
  if (Thread.interrupted()) {
    throw new InterruptedException();
  }
  //1.嘗試去獲取鎖
  //負(fù)數(shù)：表示獲取失敗
  //零值：表示當(dāng)前線程獲取成功, 但是后繼線程不能再獲取了
  //正數(shù)：表示當(dāng)前線程獲取成功, 并且后繼線程同樣可以獲取成功
  if (tryAcquireShared(arg) < 0) {
    //2. 如果獲取失敗則進(jìn)人該方法
    doAcquireSharedInterruptibly(arg);
  }
}

//釋放一個(gè)許可證
public void release() {
  sync.releaseShared(1);
}

//釋放鎖的操作(共享模式)
public final boolean releaseShared(int arg) {
  //1.嘗試去釋放鎖
  if (tryReleaseShared(arg)) {
    //2.如果釋放成功就喚醒其他線程
    doReleaseShared();
    return true;
  }
  return false;
}

abstract static class Sync extends AbstractQueuedSynchronizer {
  ...
  //嘗試釋放操作
  protected final boolean tryReleaseShared(int releases) {
    for (;;) {
      //獲取當(dāng)前同步狀態(tài)
      int current = getState();
      //將當(dāng)前同步狀態(tài)加上傳入的參數(shù)
      int next = current + releases;
      //如果相加結(jié)果小于當(dāng)前同步狀態(tài)的話就報(bào)錯(cuò)
      if (next < current) {
        throw new Error("Maximum permit count exceeded");
      }
      //以CAS方式更新同步狀態(tài)的值, 更新成功則返回true, 否則繼續(xù)循環(huán)
      if (compareAndSetState(current, next)) {
        return true;
      }
    }
  }
  ...
}

public class ConnectPool {
  
  //連接池大小
  private int size;
  //數(shù)據(jù)庫(kù)連接集合
  private Connect[] connects;
  //連接狀態(tài)標(biāo)志
  private boolean[] connectFlag;
  //剩余可用連接數(shù)
  private volatile int available;
  //信號(hào)量
  private Semaphore semaphore;
  
  //構(gòu)造器
  public ConnectPool(int size) { 
    this.size = size;
    this.available = size;
    semaphore = new Semaphore(size, true);
    connects = new Connect[size];
    connectFlag = new boolean[size];
    initConnects();
  }
  
  //初始化連接
  private void initConnects() {
    //生成指定數(shù)量的數(shù)據(jù)庫(kù)連接
    for(int i = 0; i < this.size; i++) {
      connects[i] = new Connect();
    }
  }
  
  //獲取數(shù)據(jù)庫(kù)連接
  private synchronized Connect getConnect(){ 
    for(int i = 0; i < connectFlag.length; i++) {
      //遍歷集合找到未使用的連接
      if(!connectFlag[i]) {
        //將連接設(shè)置為使用中
        connectFlag[i] = true;
        //可用連接數(shù)減1
        available--;
        System.out.println("【"+Thread.currentThread().getName()+"】以獲取連接   剩余連接數(shù)：" + available);
        //返回連接引用
        return connects[i];
      }
    }
    return null;
  }
  
  //獲取一個(gè)連接
  public Connect openConnect() throws InterruptedException {
    //獲取許可證
    semaphore.acquire();
    //獲取數(shù)據(jù)庫(kù)連接
    return getConnect();
  }
  
  //釋放一個(gè)連接
  public synchronized void release(Connect connect) { 
    for(int i = 0; i < this.size; i++) {
      if(connect == connects[i]){
        //將連接設(shè)置為未使用
        connectFlag[i] = false;
        //可用連接數(shù)加1
        available++;
        System.out.println("【"+Thread.currentThread().getName()+"】以釋放連接   剩余連接數(shù)：" + available);
        //釋放許可證
        semaphore.release();
      }
    }
  }
  
  //剩余可用連接數(shù)
  public int available() {
    return available;
  }
  
}

public class TestThread extends Thread {
  
  private static ConnectPool pool = new ConnectPool(3);
  
  @Override
  public void run() {
    try {
      Connect connect = pool.openConnect();
      Thread.sleep(100); //休息一下
      pool.release(connect);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
  
  public static void main(String[] args) {
    for(int i = 0; i < 10; i++) {
      new TestThread().start();
    }
  }

}