Java多线程开发六——锁、条件变量、信号量 收藏

原创  Java多线程开发六——锁、条件变量、信号量 收藏

1.锁和条件变量
JDK1.5以上提供了锁和条件变量来控制线程的同步，想必同步方法和等待/通知函数，锁和条件变量提供了更直观的使用形式，更广泛的锁定操作，更灵活的数据结构。此外，多个条件变量可以和一个锁绑定。
使用示例，代码来源于JDK文档，可以看一下基本的用法。

class BoundedBuffer {

   final Lock lock = new ReentrantLock();

   final Condition notFull = lock.newCondition();

   final Condition notEmpty = lock.newCondition();



   final Object[] items = new Object[100];

   int putptr, takeptr, count;



   public void put(Object x) throws InterruptedException {

     lock.lock();

     try {

       while (count == items.length)

         notFull.await();

       items[putptr] = x;

       if (++putptr == items.length) putptr = 0;

       ++count;

       notEmpty.signal();

     } finally {

       lock.unlock();

     }

   }



   public Object take() throws InterruptedException {

     lock.lock();

     try {

       while (count == 0)

         notEmpty.await();

       Object x = items[takeptr];

       if (++takeptr == items.length) takeptr = 0;

       --count;

       notFull.signal();

       return x;

     } finally {

       lock.unlock();

     }

   }

}


锁代替了synchronized的使用，Condition代替了对象监控器方法（wait，notify）的使用。

2.信号量
信号量经常用来限制访问有限资源的线程数量。见一个例子（来源于JDK文档）：


class Pool {

   private static final MAX_AVAILABLE = 100;

   private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);



   public Object getItem() throws InterruptedException {

     available.acquire();//获取许可

     return getNextAvailableItem();

   }



   public void putItem(Object x) {

     if (markAsUnused(x))

       available.release();//释放许可

   }



   // Not a particularly efficient data structure; just for demo



   protected Object[] items = ... whatever kinds of items being managed

   protected boolean[] used = new boolean[MAX_AVAILABLE];



   protected synchronized Object getNextAvailableItem() {

     for (int i = 0; i < MAX_AVAILABLE; ++i) {

       if (!used[i]) {

          used[i] = true;

          return items[i];

       }

     }

     return null; // not reached

   }



   protected synchronized boolean markAsUnused(Object item) {

     for (int i = 0; i < MAX_AVAILABLE; ++i) {

       if (item == items[i]) {

          if (used[i]) {

            used[i] = false;

            return true;

          } else

            return false;

       }

     }

     return false;

   }



}

例子中最大支持100个线程并发访问，当前100个线程没有释放许可时，第101个线程就只能等待。
以上是简单的使用说明，如果需要了解更详细的信息，参考JDK文档。

附：一个用synchronized和wait、notify实现的信号量。

public class Semaphore {
    private int count;
    public Semaphore(int count){
        this.count=count;
    }
    synchronized public void acquire() {//throws InterruptedException{
        while (count==0){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        count --;
    }
    synchronized public void release(){
        count ++;
        notify();
    }
}