线程学习笔记-Semaphore

     Semaphore（信号量）是用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。很多年以来，我都觉得从字面上很难理解Semaphore所表达的含义，只能把它比作是控制流量的红绿灯，比如XX马路要限制流量，只允许同时有一百辆车在这条路上行使，其他的都必须在路口等待，所以前一百辆车会看到绿灯，可以开进这条马路，后面的车会看到红灯，不能驶入XX马路，但是如果前一百辆中有五辆车已经离开了XX马路，那么后面就允许有5辆车驶入马路，这个例子里说的车就是线程，驶入马路就表示线程在执行，离开马路就表示线程执行完成，看见红灯就表示线程被阻塞，不能执行。

Semaphore的主要方法摘要：

void acquire():从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。

void release():释放一个许可，将其返回给信号量。

int availablePermits():返回此信号量中当前可用的许可数。

boolean hasQueuedThreads():查询是否有线程正在等待获取。
　　drainPermits():获取所有的许可证。

借助Semaphore实现显示lock锁,semaphore构造时候，传入的许可证为1的时候，可以实现锁

package com.picc.concerrent3.chapter6;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreExample1 {
  public static void main(String[] args) {
    final SemaphoreLock lock = new SemaphoreLock();
    for(int i=0;i<2;i++) {
      new Thread() {
        @Override
        public void run() {
          try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " get the SemaphoreLock");
            TimeUnit.SECONDS.sleep(10);
          } catch (InterruptedException e) {
            e.printStackTrace();
          } finally {
            lock.unlock();
          }
          System.out.println(Thread.currentThread().getName() + " realese the SemaphoreLock");
        }
      }.start();
    }
  }

  static class SemaphoreLock{
    private final Semaphore semaphore = new Semaphore(1);

    public void lock() throws InterruptedException{
      // 申请一个许可证
      semaphore.acquire();
    }

    public void unlock(){
      semaphore.release();
    }
  }
}

package com.picc.concerrent3.chapter6;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 连接池
 * 当没有获得可用的连接执行的策略
 * 1.100s之后抛出异常
 * 2.组塞
 * 3.丢弃
 * 4.直接抛出异常
 * 5.注册回调，当有可用的连接之后，
 */
public class SemaphoreExample2 {
  public static void main(String[] args) {
    final Semaphore semaphore = new Semaphore(2);
    for(int i=0;i<2;i++) {
      new Thread(){
        @Override
        public void run() {
          System.out.println(Thread.currentThread().getName()+" in");
          try {
            // 申请了两个许可证
            semaphore.acquire(2);
            System.out.println(Thread.currentThread().getName()+" get the semaphore");
            TimeUnit.SECONDS.sleep(5);
          } catch (InterruptedException e) {
            e.printStackTrace();
          } finally {
            //释放了一个许可证，当下一个线程进来之后，申请两个，但是许可证不够，线程block了
            semaphore.release(1);
          }
          System.out.println(Thread.currentThread().getName()+" out");
        }
      }.start();
    }
  }
}