多线程之锁(五)

并发编程中最常出现的情形就是多个线程共享一个资源，这些共享的资源很可能导致错误或者数据不一致的情形，需要想办法来解决这种问题。

临界区(critical section)：最多只能有一个线程执行的代码块来访问某些共享资源。

一般锁能够防止多个线程同时访问某些资源，但是有些锁可以允许多个线程并发的读取共享资源，比如读写锁。

两个基本的锁机制：

• synchronized关键字，之前也提到过
• Lock接口

锁的注意事项

锁是最常用的同步方法之一。但是在高并发情况下锁的竞争会导致程序的性能下降。为了降低这种副作用，这里有一些使用锁的建议。

• 减少锁的持有时间。
• 减小锁的粒度，即缩小锁作用的对象范围。
• 锁分离，如读多写少的场合，可以使用读写锁。其余需要使用独占锁的时候，尝试根据功能，分离锁。
• 锁粗化：这个和减少锁的持有时间相反，根据具体场景来衡量，假如某个线程不断的请求，同步和释放锁，也会浪费性能，根据实际情况进行权衡。

在学习或者使用Java的过程中进程会遇到各种各样的锁的概念：公平锁、非公平锁、自旋锁、可重入锁、偏向锁、轻量级锁、重量级锁、读写锁、互斥锁等等。

这篇文章整理了各种常见的Java锁：http://www.importnew.com/19472.html

Lock与synchronized的区别

在Lock接口出现前，Java都是依靠synchronized关键字的，在JavaSE5之后，新增了Lock接口以及相关类来实现类似功能。

• Lock接口在使用时需要显示的获取和释放锁，synchronized关键字是隐式获取和释放锁
• Lock接口更加灵活，在获取锁的时候可以指定更多的操作，可中断锁，超时获取锁，指定时间释放锁，非阻塞的获取锁。
• Lock接口可以允许读写分离，多个读，但是只有一个写

Lock可以说是synchronzed的增强版。

• 超时获取锁：在指定时间未获取到锁，则返回
• 非阻塞获取锁：当前线程尝试获取锁，如果未获取到，立刻返回，如果成功则获取到锁。
• 能被中断的获取锁：获取到锁的线程可以响应中断。

重入锁-ReenterantLock

可重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。

Java中重入锁使用java.util.concurrent.locks.ReentrantLock实现。syncrhonzed也是可重入锁。

// 一个简单的案例 public class ReentrantLockTest implements Runnable{ private ReentrantLock lock = new ReentrantLock(); public void get() { // get两次加锁，set又加锁。 lock.lock(); lock.lock(); System.out.println("线程当前ID：" + Thread.currentThread().getId()); set(); lock.unlock(); lock.unlock(); } public void set() { lock.lock(); System.out.println("线程当前ID：" + Thread.currentThread().getId()); lock.unlock(); } @Override public void run() { get(); } public static void main(String[] args) { ReentrantLockTest test = new ReentrantLockTest(); new Thread(test,"A").start(); new Thread(test,"B").start(); new Thread(test,"C").start(); } } 

ReentrantLock有几个重要方法：

• lock() : 获得锁，如果锁已经被占用，则等待
• lockInterruptibly() : 获得锁，但优先响应中断
• tryLock() : 无阻塞锁，如果成功返回true，失败返回false，该方法不等的，立刻返回
• tryLock(long time,TimeUnit unit) : 在给定时间内尝试获得锁
• unlock(): 释放锁

这几个方法都比较简单，可以自行尝试。

读写锁-ReadWriteLock

读写分离锁可以有效的减少锁竞争，以提升系统性能。

	读	写
读	非阻塞	阻塞
写	阻塞	阻塞

• 读读不互斥
• 读写互斥
• 写写互斥

如果在系统中，读操作的次数远远大于写操作，则读写锁就可以发挥最大的功效。JDK并发包中提供读写锁的实现是ReentrantReadWriteLock。

// 这个demo，用来验证读写锁的性能比一般的锁要好。 // 直接运行此demo，程序几秒钟就可以运行完毕 // 如果注释掉读写所，让sreadLock = sLock, sWriteLock = sLock。那么程序要运行20多秒才结束 public class ReadWriteLockDemo { private static Lock sLock = new ReentrantLock(); private static ReadWriteLock sReadWriteLock = new ReentrantReadWriteLock(); // 分别获取读写锁 private static Lock sReadLock = sReadWriteLock.readLock(); // private static Lock sReadLock = sLock; private static Lock sWriteLock = sReadWriteLock.writeLock(); // private static Lock sWriteLock = sLock; private int value; // 模拟读操作 public int read() throws InterruptedException { try { sReadLock.lock(); Thread.sleep(1000); return value; }finally { sReadLock.unlock(); } } // 模拟写操作 public void write(int index) throws InterruptedException { try { sWriteLock.lock(); Thread.sleep(1000); value = index; }finally { sWriteLock.unlock(); } } static class ReadRunnable implements Runnable{ private ReadWriteLockDemo mDemo; public ReadRunnable(ReadWriteLockDemo demo) { mDemo = demo; } @Override public void run() { try { mDemo.read(); } catch (InterruptedException e) { e.printStackTrace(); } } } static class WriteRunnable implements Runnable{ private ReadWriteLockDemo mDemo; public WriteRunnable(ReadWriteLockDemo demo) { mDemo = demo; } @Override public void run() { try { mDemo.write(new Random().nextInt(1000)); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) { ReadWriteLockDemo demo = new ReadWriteLockDemo(); ReadRunnable readRunnable = new ReadRunnable(demo); WriteRunnable writeRunnable = new WriteRunnable(demo); for (int i = 0; i < 20; i++) { if (i < 18){ new Thread(readRunnable).start(); }else { new Thread(writeRunnable).start(); } } } } 

锁的公平性

重入锁和读写锁，构造器都提供了一个参数fair，允许你控制锁的公平性，默认情况下是不公平的。
非公平锁：在多个线程抢占锁的时候，系统随机挑选一个线程持有锁。
公平锁：多个线程抢占锁的时候，系统挑选等待时间最长的线程持有锁。

我们只需要在构造锁对象的时候，传入true参数即可获得公平锁对象。

new ReentrantLock(true); new ReentrantReadWriteLock(true); 

Condition

在JDK内部，重入锁和Condition对象经常一起用到。之前我们在并发基础中提到过wait与notify要与synchronized关键字配合使用。Condition与重入锁一起使用，功能与wait和notify类似。

Lock接口的newCondition()方法可以生成一个与当前重入锁绑定的Condition实例，利用Condition我们可以让线程在特定的时间等待，在特定的时刻受到通知。

以ArrayBlockingQueue为例：

public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable { //存储数据元素 final Object[] items; /** 主要的锁 */ final ReentrantLock lock; /** 等待taoke的条件 */ private final Condition notEmpty; /** 等待put的条件 */ private final Condition notFull; public ArrayBlockingQueue(int capacity, boolean fair) { if (capacity <= 0) throw new IllegalArgumentException(); this.items = new Object[capacity]; //构造锁与condition lock = new ReentrantLock(fair); notEmpty = lock.newCondition(); notFull = lock.newCondition(); } public E take() throws InterruptedException { final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { while (count == 0) //如果队列为空，等待队列非空的信号 notEmpty.await(); return dequeue(); } finally { lock.unlock(); } } // 如果入队成功，发出不空的信号 private void enqueue(E x) { // assert lock.getHoldCount() == 1; // assert items[putIndex] == null; final Object[] items = this.items; items[putIndex] = x; if (++putIndex == items.length) putIndex = 0; count++; //发信号 notEmpty.signal(); } public void put(E e) throws InterruptedException { checkNotNull(e); final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { while (count == items.length) //如果队列已满，等待队列有足够的空间 notFull.await(); enqueue(e); } finally { lock.unlock(); } } //如果出队成功，发出 不满 的信号 private E dequeue() { // assert lock.getHoldCount() == 1; // assert items[takeIndex] != null; final Object[] items = this.items; @SuppressWarnings("unchecked") E x = (E) items[takeIndex]; items[takeIndex] = null; if (++takeIndex == items.length) takeIndex = 0; count--; if (itrs != null) itrs.elementDequeued(); //发信号 notFull.signal(); return x; } } 

最后

这篇文章主要说了下使用锁的时候需要注意的几点，然后提了重入锁与读写锁。公平锁，最后说了重入锁的搭档Condition。
篇幅有限，没办法面面俱到，感兴趣的还望自己再摸索。希望能帮助大家。

参考

• Java中synchronized的实现原理与应用
• Java锁的种类以及辨析（四）：可重入锁
• 《Java高并发程序设计》
• 《并发编程的艺术》