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进行了很多优化