Synchronized和ReentrantLock的区别
昨天面试，面试官问了自己一个synchronized和ReentrantLock的区别，感觉自己回答的并不是特别好，今天在翻书学习总结一下，毕竟书读百遍其义自见。
开始进入正题
两者的共同点：
1）协调多线程对共享对象、变量的访问
2）可重入，同一线程可以多次获得同一个锁
3）都保证了可见性和互斥性
两者的不同点：
1）ReentrantLock显示获得、释放锁，synchronized隐式获得释放锁
2）ReentrantLock可响应中断、可轮回，synchronized是不可以响应中断的，为处理锁的不可用性提供了更高的灵活性
3）ReentrantLock是API级别的，synchronized是JVM级别的
4）ReentrantLock可以实现公平锁
5）ReentrantLock通过Condition可以绑定多个条件
6）底层实现不一样， synchronized是同步阻塞，使用的是悲观并发策略，lock是同步非阻塞，采用的是乐观并发策略
虽然ReentrantLock可以提供比synchronized更高级的功能，但是仍不能替换synchronized
为什么呢？
《java并发编程实战》上说是因为如果使用reentrantlock时，你没有释放锁，很难追踪到最初发生错误的位置，因为没有记录应该释放锁的位置和时间。网上找了一下，没有找到其他比较合理的答案，先暂且记住吧
几个方法：
1） boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
time:等待锁定的最长时间
unit: 时间单位
这个方法起到了定时锁的作用，如果在指定时间内没有获取到锁，将会返回false
应用：具有时间限制的操作时使用
一个简单例子：
public class TestReentrantLock {
public static void main(String[] args) {
Lock r = new ReentrantLock();
//线程1
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
//获得锁
r.lock();
try {
System.out.println("线程1获得了锁");
//睡眠5秒
Thread.currentThread().sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
r.unlock();
}
}
});
thread1.start();
//线程2
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
try {
if (r.tryLock(1000, TimeUnit.MILLISECONDS)) {
System.out.println("线程2获得了锁");
} else {
System.out.println("获取锁失败了");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread2.start();
}
}
运行结果：
线程1获得了锁
获取锁失败了
此时线程2在1秒之内没有获得到锁
boolean tryLock();
只有在获得锁的情况下才会返回true，可以通过使用这个方法先判断一下能否获得锁，避免长时间获不到锁的等待，以及死锁的产生。这个方法只有一次尝试获得锁的机会。
void lockInterruptibly() throws InterruptedException;
获得可中断锁。可中断锁可以响应中断，可以让它中断自己或者在别的线程中中断它，中断后可以放弃等待，去处理其他事，而不可中断锁不会响应中断，将一直等待，synchronized就是不可中断。
举例子：
使用synchronized关键字
Buffer类：
public class Buffer {
private Object lock;
public Buffer() {
lock = this; //buffer自身
}
public void write() {
synchronized (lock) {
long startTime = System.currentTimeMillis();
System.out.println("往这个buffer写入数据...");
//死循环模拟要处理很长时间
for(;;) {
if (System.currentTimeMillis() - startTime > Integer.MAX_VALUE) {
break;
}
}
System.out.println("终于写完了");
}
}
public void read() {
synchronized (lock) {
System.out.println("从这个buff读数据");
}
}
public static void main(String[] args) {
Buffer buffer = new Buffer();
final Writer writer = new Writer(buffer);
final Reader reader = new Reader(buffer);
//启动线程
writer.start();
reader.start();
//尝试启动一个线程去中断reader线程
new Thread(new Runnable() {
@Override
public void run() {
long start = System.currentTimeMillis();
for(;;) {
//等待五秒钟去中断
if (System.currentTimeMillis() - start > 5000) {
System.out.println("不等了，尝试中断");
reader.interrupt();
break;
}
}
}
}).start();
}
}
Reader类：
public class Reader extends Thread {
private Buffer buffer;
public Reader(Buffer buffer) {
this.buffer = buffer;
}
public void run() {
buffer.read(); //这里将会引起长时间的阻塞
System.out.println("读结束");
}
}
Writer类：
public class Writer extends Thread {
private Buffer buffer;
public Writer(Buffer buffer) {
this.buffer = buffer;
}
public void run() {
buffer.write();
}
}
reader类没有被中断
使用ReentrantLock获得中断锁
BufferInterruptibly类：
public class BufferInterruptibly {
private Lock lock = new ReentrantLock();
public void write() {
lock.lock();
try {
long start = System.currentTimeMillis();
System.out.println("开始往这个buff写入数据...");
//模拟要处理很长时间
for (;;) {
if (System.currentTimeMillis() - start > Integer.MAX_VALUE) {
break;
}
}
System.out.println("终于写完了");
} finally {
lock.unlock();
}
}
public void read() throws InterruptedException {
lock.lockInterruptibly(); //获得可中断锁
try {
System.out.println("从这个buff读数据");
} finally {
lock.unlock();
}
}
public static void main(String args[]) {
BufferInterruptibly buff = new BufferInterruptibly();
final Writer2 writer = new Writer2(buff);
final Reader2 reader = new Reader2(buff);
writer.start();
reader.start();
new Thread(new Runnable() {
@Override
public void run() {
long start = System.currentTimeMillis();
for (;;) {
if (System.currentTimeMillis()
- start > 5000) {
System.out.println("不等了，尝试中断");
reader.interrupt(); //此处中断读操作
break;
}
}
}
}).start();
}
}
Reader2类
public class Reader2 extends Thread {
private BufferInterruptibly buff;
public Reader2(BufferInterruptibly buff) {
this.buff = buff;
}
@Override
public void run() {
try {
buff.read();//可以收到中断的异常，从而有效退出
} catch (InterruptedException e) {
System.out.println("我不读了");
}
System.out.println("读结束");
}
}
Writere2类：
public class Writer2 extends Thread {
private BufferInterruptibly buff;
public Writer2(BufferInterruptibly buff) {
this.buff = buff;
}
@Override
public void run() {
buff.write();
}
}
运行结果：
开始往这个buff写入数据...
不等了，尝试中断
我不读了
读结束
ReentrantLock的公平性
在ReentrantLock中的构造函数中，提供了一个参数，指定是否为公平锁。
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
如果指定了参数为true，默认为非公平锁。
公平锁：线程将按照它们发出的请求顺序来获得锁
非公锁：当一个线程请求非公平锁的时候，如果发出请求时，获得锁的线程刚好释放锁，则该线程将会获得锁而跳过在该锁上等待的线程。
一个公平锁例子：
public class TestReentrantLock2 {
private static Lock lock = new ReentrantLock(true); //lock为公平锁
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {
System.out.println("线程1启动...");
} finally {
lock.unlock();
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {
System.out.println("线程2启动...");
} finally {
lock.unlock();
}
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {
System.out.println("线程3启动...");
} finally {
lock.unlock();
}
}
});
t1.start();
t3.start();
t2.start();
}
}
运行结果：
线程1启动...
线程3启动...
线程2启动...
什么时候选择使用synchronized，什么使用选择使用ReentrantLock
仅当synchronized不能满足时才使用ReentrantLockk，因为使用ReentrantLock要非常小心，不释放锁将影响其他需要该锁的代码块运行
不能使用synchronized不满足的情形：
1）公平性
2）可中断
4）分块结构的加锁，比如jdk1.7ConcurrentHashMap的分段锁（目前还不是提别理解这个，先记住这个例子，后头补充）
synchronized和ReentrantLock两者之间性能的比较
从jdk1.5以后，性能就差不多了，因为jvm对synchronized进行了很多优化
