随笔- 129  评论- 0  文章- 0 

Java多线程:Semaphore

  Semaphore为并发包中提供用于控制某资源同时可以被几个线程访问的类
  实例代码:
  // 允许2个线程同时访问
  final Semaphore semaphore = new Semaphore(2);
  ExecutorService executorService = Executors.newCachedThreadPool();
  for (int i = 0; i < 10; i++) {
  final int index = i;
  executorService.execute(new Runnable() {
  public void run() {
  try {
  semaphore.acquire();
  // 这里可能是业务代码
  System.out.println("线程:" + Thread.currentThread()。getName() + "获得许可:" + index);
  TimeUnit.SECONDS.sleep(1);
  semaphore.release();
  System.out.println("允许TASK个数:" + semaphore.availablePermits());
  } catch (InterruptedException e) {
  e.printStackTrace();
  }
  }
  });
  }
  executorService.shutdown();
  构造方法1:
  public Semaphore(int permits) {
  sync = new NonfairSync(permits);
  }
  permits 初始许可数,也就是最大访问线程数
  构造方法2:
  public Semaphore(int permits, boolean fair) {
  sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
  }
  permits 初始许可数,也就是最大访问线程数
  fair 当设置为false时,线程获取许可的顺序是无序的,也就是说新线程可能会比等待的老线程会先获得许可;当设置为true时,信号量保证它们调用的顺序(即先进先出;FIFO)
  主要方法:托福答案 www.yztrans.com
  void acquire() 从信号量获取一个许可,如果无可用许可前 将一直阻塞等待,
  void acquire(int permits) 获取指定数目的许可,如果无可用许可前 也将会一直阻塞等待
  boolean tryAcquire() 从信号量尝试获取一个许可,如果无可用许可,直接返回false,不会阻塞
  boolean tryAcquire(int permits) 尝试获取指定数目的许可,如果无可用许可直接返回false,
  boolean tryAcquire(int permits, long timeout, TimeUnit unit) 在指定的时间内尝试从信号量中获取许可,如果在指定的时间内获取成功,返回true,否则返回false
  void release() 释放一个许可,别忘了在finally中使用,注意:多次调用该方法,会使信号量的许可数增加,达到动态扩展的效果,如:初始permits 为1, 调用了两次release,最大许可会改变为2
  int availablePermits() 获取当前信号量可用的许可
  JDK 非公平Semaphore实现:
  1.使用一个参数的构造创建Semaphore对象时,会创建一个NonfairSync对象实例,并将state值设为传入的值(permits ),
  public Semaphore(int permits) {
  sync = new NonfairSync(permits);
  }
  NonfairSync间接的继承了AbstractQueuedSynchronizer实现
  final static class NonfairSync extends Sync {
  private static final long serialVersionUID = -2694183684443567898L;
  NonfairSync(int permits) {
  super(permits);
  }
  protected int tryAcquireShared(int acquires) {
  return nonfairTryAcquireShared(acquires);
  }
  }
  abstract static class Sync extends AbstractQueuedSynchronizer {
  private static final long serialVersionUID = 1192457210091910933L;
  Sync(int permits) {
  setState(permits);
  }
  AbstractQueuedSynchronizer 的setState方法
  protected final void setState(int newState) {
  state = newState;
  }
  2.调用tryAcquire方法时,实际是调用NonfairSync的nonfairTryAcquireShared方法,nonfairTryAcquireShared在父类Sync中实现,
  Semaphore# tryAcquire方法:
  public boolean tryAcquire() {
  return sync.nonfairTryAcquireShared(1) >= 0;
  }
  Sync的nonfairTryAcquireShared方法
  final int nonfairTryAcquireShared(int acquires) {
  for (;;) {
  int available = getState();
  int remaining = available - acquires;
  if (remaining < 0 ||
  compareAndSetState(available, remaining))
  return remaining;
  }
  }
  nonfairTryAcquireShared方法通过获取当前的state,以此state减去需要获取信号量的个数,作为剩余个数,如果结果小于0,返回此剩余的个数;如果结果大于等于0,则基于CAS将state的值设置为剩余个数,当前步骤用到了for循环,所以只有在结果小于0或设置state值成功的情况下才会退出。
  如果返回的剩余许可个数大于0,tryAcquire方法则返回true;其余返回false.托福答案 www.qcwy123.com
  AbstractQueuedSynchronizer的compareAndSetState方法,
  protected final boolean compareAndSetState(int expect, int update) {
  // See below for intrinsics setup to support this
  return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
  }
  3.release方法,释放一个许可
  public void release() {
  sync.releaseShared(1);
  }
  AbstractQueuedSynchronizer的releaseShared方法,
  public final boolean releaseShared(int arg) {
  if (tryReleaseShared(arg)) {
  doReleaseShared();
  return true;
  }
  return false;
  }
  release方法间接的调用了Sync的tryReleaseShared方法,该方法基于Cas 将state的值设置为state+1,一直循环确保CAS操作成功,成功后返回true.
  protected final boolean tryReleaseShared(int releases) {
  for (;;) {
  int p = getState();
  if (compareAndSetState(p, p + releases))
  return true;
  }
  }
  根据上面分析,可以看得出,Semaphore采用了CAS来实现,尽量避免锁的使用,提高了性能。

posted on 2014-04-21 20:21  haosola  阅读(...)  评论(...编辑  收藏

toeflacttoeflieltstoefltoeflact