Java并发编程之 lock (十)

一. 前言

synchronized 是Java的关键字，是Java的内置特性，在JVM层面实现了对临界资源的同步互斥访问，但 synchronized 粒度有些大，在处理实际问题时存在诸多局限性，比如响应中断等。Lock 提供了比 synchronized更广泛的锁操作，它能以更优雅的方式处理线程同步问题。

二.Lock相关接口

1.lock

void lock();

lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此，一般来说，使用Lock必须在try…catch…块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

Lock lock = ...;
lock.lock();
try{
    //处理业务逻辑
}catch(Exception ex){
	//异常处理
}finally{
 //释放锁
   lock.unlock();  
}

2.lockInterruptibly
当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为interrupt()方法只能中断阻塞过程中的线程而不能中断正在运行过程中的线程。因此，当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，那么只有进行等待的情况下，才可以响应中断的。与 synchronized 相比，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

void lockInterruptibly() throws InterruptedException;

常用方法:

public void method() throws InterruptedException {
	//中断正在等待阻塞中的线程
    lock.lockInterruptibly();
    try {  
     //获取锁,处理逻辑
    }
    finally {
    	//解锁
        lock.unlock();
    }  
}

3.tryLock
尝试是否能获得锁 如果不能获得立即返回。如果锁未被另一个线程保持，则获取锁。
如果当前线程已经保持此锁，则将保持计数加 1，该方法将返回 true。
如果锁被另一个线程保持，则此方法将立即返回 false 值。

boolean tryLock();

常用方法:

 Lock lock = ...;
      if (lock.tryLock()) {
        try {
          // 进行锁状态,执行任务
        } finally {
          lock.unlock();
        }
      } else {
        // 执行替代动作
      }}     

应用场景,比如防止重复提交业务

4.tryLock+time
如果在给定的等待时间内是空闲的，当超过时间无获取锁,调用B.interrupt()会被中断等待线程

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

实现可以检测到错误地使用锁，例如将导致调用的死锁，并且可能在这种情况下抛出（未检查）异常。

5.unlock
释放锁

void unlock();

6.newCondition

 Condition newCondition();

(1).Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。不同的是，Object中的这些方法是和同步锁捆绑使用的；而Condition是需要与互斥锁/共享锁捆绑使用的。
(2).Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。
例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒"读线程"；当从缓冲区读出数据之后，唤醒"写线程"；并且当缓冲区满的时候，"写线程"需要等待；当缓冲区为空时，“读线程"需要等待。
如果采用Object类中的wait(), notify(), notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒"读线程"时，不可能通过notify()或notifyAll()明确的指定唤醒"读线程”，而只能通过notifyAll唤醒所有线程(但是notifyAll无法区分唤醒的线程是读线程，还是写线程)。 但是，通过Condition，就能明确的指定唤醒读线程。

三.lock与synchronized区分

(1) Lock是一个接口，是JDK层面的实现；而synchronized是Java中的关键字，是Java的内置特性，是JVM层面的实现；
(2) synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
(3) Lock 可以让等待锁的线程响应中断，而使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
(4) 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到；
(5) Lock可以提高多个线程进行读操作的效率。

四.案例

1.模拟1000个线程同时对一个变量通过lock对一个变量进行增加操作

    static ExecutorService service=Executors.newCachedThreadPool();
    static Lock lock = new ReentrantLock();
    private static int num;
    public static void main(String[] args) {
        for (int i=0;i<1000;i++){
            service.submit(new Runnable() {
                @Override
                public void run() {   
                	caculateNum();                
                }
            });
        }
    }

    private  static void caculateNum() {
        try {
            lock.lock();
            num++;
        }finally {
            lock.unlock();
        }
        System.out.println("num:"+num);
    }

结果:最终可输出1000.

…
num:922
num:920
num:918
num:1000

2.通过newCondition模拟多线程并发执行对同一变量进行操作,通过对条件的操控,来对newCondition的认识

    static ExecutorService service= Executors.newCachedThreadPool();
    static Lock lock = new ReentrantLock();

    private static final Condition addCondition = lock.newCondition();
    private static final Condition reduceCondition = lock.newCondition();

    private static int  num;

    public static void main(String[] args) {
        for (int i=0;i<100;i++){
            service.submit(new AddTask());
        }

        for (int i=0;i<1000;i++){
            service.submit(new ReduceTask());
        }
    }

    public static class AddTask implements Runnable{
        @Override
        public void run() {
            try {
                lock.lock();
                if (num == 5) {
                    addCondition.await();
                }
                num++;
                System.out.println("线程AddTask===========:"+num);
                reduceCondition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static   class ReduceTask implements Runnable{
        @Override
        public void run() {
            try {
                lock.lock();
//                if (num == 0) {
//                    reduceCondition.wait();
//                }
                num--;
                addCondition.signal();
                System.out.println("线程ReduceTask:"+num);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

结果

…
线程ReduceTask:-883
线程ReduceTask:-884
线程ReduceTask:-885
线程ReduceTask:-886
线程ReduceTask:-887
线程ReduceTask:-888
线程ReduceTask:-889
线程ReduceTask:-890
线程ReduceTask:-891
线程ReduceTask:-892
线程ReduceTask:-893
线程ReduceTask:-894
线程ReduceTask:-895
线程ReduceTask:-896
线程ReduceTask:-897
线程ReduceTask:-898
线程ReduceTask:-899
线程ReduceTask:-900