Java并发编程--Lock的用法

概要

上一节提到了线程同步互斥的方法采用的是synchronized加锁的方法，但这种方式有个缺点就是其它线程会一直被阻塞，直到拿到锁后才能继续执行

另一个缺点就是当线程执行异常后会自动释放到加锁对象

试想这样一种场景，当前线程获取了一个临界锁，而这个时候线程要去处理很长的一个操作，比如IO读取文件，或者批量操作数据库，这个时候其它线程就会一直处理等待阻塞的状态，什么也做不了，导致效率极低。

对于这种情况就体现出了Lock的好处

总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点：

　　1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

　　2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

　　3）Lock可以知道我们是否加锁成功，可以获取到加锁状态

LOCK

接口

public abstract interface java.util.concurrent.locks.Lock { public abstract void lock(); public abstract void lockInterruptibly() throws InterruptedException; public abstract boolean tryLock(); public abstract boolean tryLock(long arg0, TimeUnit arg1) throws InterruptedException; public abstract void unlock(); public abstract newCondition(); } lock()

获取锁如果锁被其它线程锁持有，会一直等待，之前已经说过lock需要人工释放锁，因此lock加锁必须放在try/catch/finally中，确保在finally中对锁进行释放，防止死锁

Lock lock .... lock.lock() try{ }catch(){ }finally{ lock.unlock(); } tryLock()

获取锁会立刻返回一个结果值，拿到锁返回true，没有拿到锁则返回FALSE，也就是说这种加锁的方法会立刻返回，如果没有拿到锁就会返回FALSE，不会一直等待。

tryLock(long arg0, TimeUnit arg1)

和上面的用法一样，不同的是如果拿不到锁会等待一定的时间，如果超过这个设定的时间点还是没有拿到锁，则返回FALSE，如果中间或者方开始就拿到锁，则返回true

Lock lock = ...; if(lock.tryLock()) { try{ //处理任务 }catch(Exception ex){ }finally{ lock.unlock(); //释放锁 } }else { //如果不能获取锁，则直接做其他事情 } lockInterruptibly()

通过lockInterruptibly获取锁比较特殊，当lockInterruptibly获取锁在等待的过程中，该线程是可以被中断的。

比如线程A和线程B同时通过lockInterruptibly获取锁，此时A获取到了，B处于等待状态，这个时候我们可以调用线程B的interrupt()中断B的等待，让B去做其它事情。

当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程

通过 lockInterruptibly获取锁只有在没有获取到锁处于等待状态的线程才能被中断

synchronized方法获取锁是不能被打断的，只会一直等待下去，除非执行结束或者异常退出才会释放锁

ReentrantLock

ReentrantLock是唯一一个实现了Lock接口的类

由于Lock是对对象的方法或者成员加锁的，因此必须将Lock变量设置为成员变量。

public class Test { private ArrayList<Integer> list = new ArrayList<Integer>(); Lock lock = new ReentrantLock(); public void addNum(Thread thread) { lock.lock(); try { for (int i = 0; i < 5; i++) System.out.println(thread.getName() + "执行, i = " + i); } catch (Exception e) { } finally { lock.unlock(); } } public static void main(String[] args) { final Test test = new Test(); new Thread() { @Override public void run() { test.addNum(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { test.addNum(Thread.currentThread()); } }.start(); } } 执行结果： Thread-1执行, i = 0 Thread-1执行, i = 1 Thread-1执行, i = 2 Thread-1执行, i = 3 Thread-1执行, i = 4 Thread-2执行, i = 0 Thread-2执行, i = 1 Thread-2执行, i = 2 Thread-2执行, i = 3 Thread-2执行, i = 4

下面使用tryLock()

public class Test { private ArrayList<Integer> list = new ArrayList<Integer>(); Lock lock = new ReentrantLock(); public void addNum(Thread thread) { if (lock.tryLock()) { try { thread.sleep(500); for (int i = 0; i < 5; i++) System.out.println(thread.getName() + "执行, i = " + i); } catch (Exception e) { } finally { lock.unlock(); } } else { System.out.println(thread.getName() + "没有获取到锁"); } } public static void main(String[] args) { final Test test = new Test(); new Thread() { @Override public void run() { test.addNum(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { test.addNum(Thread.currentThread()); } }.start(); } } 执行结果 Thread-2没有获取到锁 Thread-1执行, i = 0 Thread-1执行, i = 1 Thread-1执行, i = 2 Thread-1执行, i = 3 Thread-1执行, i = 4

使用lockInterruptibly方法获取锁

public class Test extends Thread { private ArrayList<Integer> list = new ArrayList<Integer>(); private Lock lock = new ReentrantLock(); public void addNum(Thread thread) throws InterruptedException { lock.lockInterruptibly(); try { thread.sleep(1000); System.out.println(thread.getName() + "执行中"); } catch (Exception e) { System.out.println(thread.getName() + "获取锁异常"); } finally { lock.unlock(); System.out.println(thread.getName() + "释放锁"); } } @Override public void run() { try { addNum(Thread.currentThread()); } catch (Exception e) { System.out.println(Thread.currentThread().getName() + "被打断"); } } public static void main(String[] args) throws InterruptedException { final Test test = new Test(); Mytest test1 = new Mytest(test); Mytest test2 = new Mytest(test); test1.start(); test2.start(); Thread.sleep(300); test2.interrupt(); } } class Mytest extends Thread { private Test test; public Mytest(Test test) { this.test = test; } /** * @see java.lang.Thread#run() */ @Override public void run() { try { test.addNum(Thread.currentThread()); } catch (Exception e) { System.out.println(Thread.currentThread().getName() + "被打断"); } } } 执行结果： Thread-3被打断 Thread-2执行中 Thread-2释放锁

ReadWriteLock

ReadWriteLock也是一个接口，不过这个接口里面定义了两个方法

public interface ReadWriteLock { /** * Returns the lock used for reading. * * @return the lock used for reading. */ Lock readLock(); /** * Returns the lock used for writing. * * @return the lock used for writing. */ Lock writeLock(); }

一个用于读锁，一个用于写锁，即读锁和写锁分开来，从而可以让多个线程同时获取到读锁

ReentrantReadWriteLock实现了ReadWriteLock接口。

我们之前提过相对于synchronized来说，线程通过synchronized获取锁后，其它线程只能等待，直到之前线程释放锁后线程拿到锁才能正常往下执行。

比如目前多个线程要对文件进行读操作，通过synchronized的话任何时候只能有一个线程进行读操作，而ReentrantReadWriteLock 则可以实现多个线程的读操作。

public class Test extends Thread { private ArrayList<Integer> list = new ArrayList<Integer>(); private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); public void addNum(Thread thread) throws InterruptedException { lock.readLock().lock(); try { thread.sleep(1000); System.out.println(thread.getName() + "执行中"); } catch (Exception e) { System.out.println(thread.getName() + "获取锁异常"); } finally { lock.readLock().unlock(); System.out.println(thread.getName() + "释放锁"); } } @Override public void run() { try { addNum(Thread.currentThread()); } catch (Exception e) { System.out.println(Thread.currentThread().getName() + "被打断"); } } public static void main(String[] args) throws InterruptedException { final Test test = new Test(); Mytest test1 = new Mytest(test); Mytest test2 = new Mytest(test); Mytest test3 = new Mytest(test); test1.start(); test2.start(); test3.start(); } } class Mytest extends Thread { private Test test; public Mytest(Test test) { this.test = test; } /** * @see java.lang.Thread#run() */ @Override public void run() { try { test.addNum(Thread.currentThread()); } catch (Exception e) { System.out.println(Thread.currentThread().getName() + "被打断"); } } } 执行结果： Thread-4执行中 Thread-3执行中 Thread-2执行中 Thread-3释放锁 Thread-4释放锁 Thread-2释放锁

可见三个线程都获取去到读锁，这样就大大提升了读操作的效率。

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

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

Lock和synchronized的区别

locksynchronizedlock是一个接口synchronized是一个Java的关键字lock可以获取到加锁状态synchronized不知道是否加锁成功可以中断正在等待的线程不能人工中断需要手动释放锁否则会发生死锁执行完毕或在线程异常退出后才能释放锁可以提供多个线程的读的效率只能单个线程获取锁，其它线程会一直等待，效率低

锁的概念

重入锁

比如当线程获取到A对象的一个锁方法method1，而method1中又调用了另一个锁方法method2，这个时候就不需要再申请锁，而是直接可以使用method2的方法，这就是重入锁。

即锁是面向线程的，当前线程获取了这个对象的锁，则可以使用这个对象中的其它加锁的方法

synchronized和Lock都具备可重入性

可中断锁

可中断锁顾名思义就是可以被中断的锁

synchronized就不是可中断锁，而Lock是可中断锁

公平锁

公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。

　　非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

　　在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。

　　而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

在ReentrantLock中定义了2个静态内部类，一个是NotFairSync，一个是FairSync，分别用来实现非公平锁和公平锁。

我们可以在创建ReentrantLock对象时，通过以下方式来设置锁的公平性：

ReentrantLock lock = new ReentrantLock(true);

读写锁

将读锁和写锁分开，线程可以分别获取读锁和写锁

正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。

可以通过readLock()获取读锁，通过writeLock()获取写锁。