Lock应用之 尝试锁获取

当线程请求内部锁时，如果锁已经被占用，则请求线程必须无条件等待，这往往会造成很多奇怪问题，相互等待是造成死锁的重要原因之一，著名的哲学家就餐问题就是个典型的案例。新的Lock锁提供了尝试获取锁失败自动放弃的方法tryLock()，具有更完善的错误恢复机制。

boolean  tryLock();
boolean  tryLock( long  time, TimeUnit unit)  throws  InterruptedException;

Lock接口定义了两个重载tryLock()函数，第一个函数表示如果锁可用则立即获得锁并返回true，如果请求的锁当前不可用则立即放弃并返回false；第二个函数表示如果请求的锁当前可用则立即获得锁并返回true，如果锁不可用则等待指定的时间，在等待期间，线程可能被中断，可能获得锁，如果等待时间结束还未获取到锁则自动放弃并返回false，明显相对第一个函数提供了更多的灵活性。

当然我们还可以自己利用循环轮询调用tryLock()，以实现轮询锁等，实现更多的灵活机制，这就是Lock相对内部锁的好处，特别是当线程需要同时获取多把不同锁时，tryLock()大有用处。

举一个实际简单应用场景，假设我们有个定时任务，定时清理垃圾，但每次清理垃圾耗费的时间可能不同，如果新任务发现上个任务还没执行完就自己结束，因为不需要这次任务。其实ScheduledExecutorService.scheduleAtFixedRate()函数就提供这样的功能，每个定时任务都是等上个任务完成才开始执行。

import  java.util.concurrent.Executors;
import  java.util.concurrent.ScheduledExecutorService;
import  java.util.concurrent.TimeUnit;
import  java.util.concurrent.locks.Lock;
import  java.util.concurrent.locks.ReentrantLock;
public  class  TestTryLock {
    private  Lock mLock;
    private  volatile  boolean  isTimeoutEnabled;

    public  TestTryLock(){
        this .mLock =  new  ReentrantLock();
        this .isTimeoutEnabled =  false ;
    }

    public  void  clearRubbish()  throws  InterruptedException{
        if (mLock.tryLock()){
            try {
                System.out.println(Thread.currentThread().getName() +  ":get the lock successfully." );
                int  estTime = ( int ) ( 10  * Math.random());
                System.out.println(Thread.currentThread().getName() +  ":estimate time for finish job:"  + estTime);
                TimeUnit.SECONDS.sleep(estTime);
            }
            finally {
                mLock.unlock();
            }
        }
        else {
            System.out.println(Thread.currentThread().getName() +  ":failed to get the lock." );
        }
    }

    public  void  clearRubbishWithTimeout()  throws  InterruptedException{
        if (mLock.tryLock( 2 , TimeUnit.SECONDS)){
            try {
                System.out.println(Thread.currentThread().getName() +  ":get the lock successfully by waiting 2 seconds." );
                int  estTime = ( int ) ( 10  * Math.random());
                System.out.println(Thread.currentThread().getName() +  ":estimate time for finish job:"  + estTime);
                TimeUnit.SECONDS.sleep(estTime);
            }
            finally {
                mLock.unlock();
            }
        }
        else {
            System.out.println(Thread.currentThread().getName() +  ":failed to get the lock after waiting 2 seconds." );
        }
    }

    private  class  Worker  implements  Runnable{
        @Override
        public  void  run() {
            try  {
                if (isTimeoutEnabled){
                    clearRubbishWithTimeout();
                }
                else {
                    clearRubbish();
                }

                isTimeoutEnabled = !isTimeoutEnabled;
            }  catch  (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private  class  TimerWorker  implements  Runnable{
        @Override
        public  void  run() {
            new  Thread( new  Worker()).start();
        }
    }
    public  static  void  main(String[] args) {
        TestTryLock testTryLock =  new  TestTryLock();
        ScheduledExecutorService service = Executors.newScheduledThreadPool( 1 );
        service.scheduleAtFixedRate(testTryLock.  new  TimerWorker(),  0 ,  3 , TimeUnit.SECONDS);
    }
}

     本文转自sarchitect 51CTO博客，原文链接：http://blog.51cto.com/stevex/1301077，如需转载请自行联系原作者