Java并发编程之Lock

一、Lock是什么？

      从Java 5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock，它是java.util.concurrent.locks包中的一个接口。

      也许有朋友会问，既然都可以通过synchronized来实现同步访问了，那么为什么还需要提供Lock呢？

二、Lock及其实现类的用法

下面我们就来探讨一下java.util.concurrent.locks包中常用的类和接口。

1、lock

首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口：

public interface Lock {    void lock();    void lockInterruptibly() throws InterruptedException;    boolean tryLock();    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;    void unlock();    Condition newCondition();}

Lock接口方法的使用：

   lock()、tryLock()、tryLock(long time, TimeUnit unit)、lockInterruptibly()都是用来获取锁的。 

   unLock() 方法是用来释放锁的。

四个获取锁方法的区别：

      ◆lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

  ◆tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

      ◆tryLock(longtime, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

      ◆lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

2、ReentrantLock

ReentrantLock，意思是“可重入锁”，ReentrantLock是实现了Lock接口的类，并且ReentrantLock提供了更多的方法。

下面通过一些实例看具体看一下如何使用ReentrantLock。

实例一:

package com.gyx.locktest;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class MyLockTest {static Lock lock = new ReentrantLock();public static void main(String[] args) {MyLockTest.MyThread thread1 = new MyLockTest().new MyThread();MyLockTest.MyThread thread2 = new MyLockTest().new MyThread();thread1.start();thread2.start();}class MyThread extends Thread {@Overridepublic void run() {Thread thread = Thread.currentThread();lock.lock(); // 得到锁try {System.out.println(thread.getName() + "得到了锁");} catch (Exception e) {} finally {System.out.println(thread.getName() + "释放了锁");lock.unlock(); // 释放锁}}}}

实例二:

package com.gyx.locktest;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class MyLockTest {static Lock lock = new ReentrantLock();public static void main(String[] args) {MyLockTest.MyThread thread1 = new MyLockTest().new MyThread();MyLockTest.MyThread thread2 = new MyLockTest().new MyThread();thread1.start();thread2.start();}class MyThread extends Thread {@Overridepublic void run() {Thread thread = Thread.currentThread();boolean tryLock = lock.tryLock(); // 尝试得到锁if (tryLock) {try {System.out.println(thread.getName() + "得到了锁");} catch (Exception e) {} finally {System.out.println(thread.getName() + "释放了锁");lock.unlock(); // 释放锁}} else {System.out.println(thread.getName() + "尝试获得锁失败");}}}}

实例三:

package com.gyx.locktest;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;import org.apache.activemq.broker.InsertableMutableBrokerFilter;public class MyLockTest {static Lock lock = new ReentrantLock();public static void main(String[] args) {MyLockTest.MyThread thread1 = new MyLockTest().new MyThread();MyLockTest.MyThread thread2 = new MyLockTest().new MyThread();thread1.start();thread2.start();// 为了让线程1获得锁这里使当前线程进行睡眠try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}thread2.interrupt();}public void insert(Thread thread) throws InterruptedException {lock.lockInterruptibly();try {System.out.println(thread.getName() + "得到了锁");long startTime = System.currentTimeMillis();for (;;) {// 得到锁的线程执行三秒if (System.currentTimeMillis() - startTime >= 3000)break;}} finally {System.out.println(Thread.currentThread().getName() + "执行finally");lock.unlock();System.out.println(thread.getName() + "释放了锁");}}class MyThread extends Thread {@Overridepublic void run() {try {insert(Thread.currentThread());} catch (InterruptedException e) {System.out.println(Thread.currentThread().getName() + "被中断");}}}}

3、ReentrantReadWriteLock

        读写锁 ReadWriteLock读写锁维护了一对相关的锁，一个用于只读操作，一个用于写入操作。

读写锁的作用:

    ◆使用读写锁，可以实现读写分离锁定，读操作并发进行，写操作只允许单个线程 

    ◆如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

    ◆如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

以下是读写锁的一个实例:

package com.gyx.locktest;import java.util.Random;import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReadWriteLockTest {public static void main(String[] args) {final ReadWriteHandle rwh = new ReadWriteHandle();for (int i = 0; i < 3; i++) {new Thread() {public void run() {while (true) { rwh.put(new Random().nextInt(10000)); }}}.start();new Thread() {public void run() {while (true) { rwh.get(); }}}.start();}}}class ReadWriteHandle {private Object data = 1000;private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();public void get() {rwl.readLock().lock(); // 上读锁try {Thread.sleep(500);System.out.println(Thread.currentThread().getName() + "准备读数据!");System.out.println(Thread.currentThread().getName() + "读到数据:"+ data);} catch (InterruptedException e) {e.printStackTrace();} finally {rwl.readLock().unlock();}}public void put(Object data) {rwl.writeLock().lock(); // 上写锁try {System.out.println(Thread.currentThread().getName() + "准备写数据!");Thread.sleep(500);this.data = data;System.out.println(Thread.currentThread().getName() + "写入数据:"+ data);} catch (InterruptedException e) {e.printStackTrace();} finally {rwl.writeLock().unlock();}}}

三、Lock和synchronized的选择

总结来说，Lock和synchronized有以下几点不同：
    1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
    2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动          通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
    3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响         应中断；
    4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
    5）Lock可以提高多个线程进行读操作的效率。
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。