显式锁Lock、ReentrantLock

java有两种锁，隐式锁（synchronized）和显式锁（Lock），两种锁都能实现对共享资源的控制，但显式锁更加灵活。

本文主要介绍：Lock和其实现类ReentrantLock的使用方式

Lock接口

[code]public interface Lock{
void lock();  // 获取锁
void lockInterruptibly(); // 优先考虑响应中断，而不是获取锁；使用此方式获的锁，允许在等待时由其他线程的通过Thread.interrupt()方法来中断等待线程而直接返回
void tryLock(); // 如果锁可用，则获取锁，并立即返回值 true，否则返回false
void tryLock(long timeout,TimeUnit unit); // 在等待时间内如果锁可用，则获取锁，成功返回true，否则返回false
void unlock(); // 释放锁
Condition newCondition(); // 得到绑定到此 Lock 实例的新 Condition 实例
}

Lock的使用方式

[code]//默认为false，即非公平锁，true为公平锁
public static Lock lock=new ReentrantLock(false);  

方式一：
    lock.lock();  //获得锁
    try{
        ...
    }finally(){
       lock.unLock();  //释放锁
    }

方式二：
    if(lock.tryLock()){
        try{
            ...
        }finally(){
            lock.unLock();  //释放锁
        }
    }else{
        //获取锁失败
    }

方式三：
    lock.lockInterruptibly();  //获得锁，中断有限
    try{
        ...
    }finally(){
       lock.unLock();  //释放锁
    }

condition是一个多线程间协调通信的工具类，通过condition我们能控制多个线程的等待（await()）和唤醒（signal()）

[code]public class Demo{
    public static Lock lock=new ReentrantLock(); 
    public static Condition full =  lock.newCondition();
    public static Condition empty =  lock.newCondition();
    public static List =new ArrayList();

    public void full(){
        whlie(true){
          lock.lock();  //获得锁
          try{
              if(list.size>0){
                  System.out.println("full等待");
                  full.await(); 
              }else{
                  list.add(1);
                  System.out.println("empty唤醒");
                  empty.signal(); 
              }
          }finally(){
              lock.unLock();  //释放锁
          }
        }
    }

    public void empty(){
        while(true){
          lock.lock();  //获得锁
          try{
              if(list.size<1){
                  System.out.println("empty等待");
                  empty.await(); 
              }else{
                  list.remove(0);
                  System.out.println("full唤醒");
                  full.signal(); 
              }
          }finally(){
              lock.unLock();  //释放锁
          }
        }
    }

    public void main(String[] args) throws Exception{
        final Demo demo=new Demo();
        new Thread(new Runnable(){
            public void run(){
                demo.full();
            }
        }).start();

        new Thread(new Runnable(){
            public void run(){
                demo.empty();
            }
        }).start();
    }
}