并发编程中最常出现的情形就是多个线程共享一个资源，这些共享的资源很可能导致错误或者数据不一致的情形，需要想办法来解决这种问题。
锁
临界区(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的增强版。
- 超时获取锁：在指定时间未获取到锁，则返回
- 非阻塞获取锁：当前线程尝试获取锁，如果未获取到，立刻返回，如果成功则获取到锁。
- 能被中断的获取锁：获取到锁的线程可以响应中断。
Lock.png
重入锁-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高并发程序设计》
- 《并发编程的艺术》
