JAVA 并发编程（五）线程安全之 synchronized 和 ReentrantLock
前面我们介绍了很多关于多线程的内容，在多线程中有一个很重要的课题需要我们攻克，那就是线程安全问题。线程安全问题指的是在多线程中，各线程之间因为同时操作所产生的数据污染或其他非预期的程序运行结果。
线程安全
1）非线程安全事例
比如 A 和 B 同时给 C 转账的问题，假设 C 原本余额有 100 元，A 给 C 转账 100 元，正在转的途中，此时 B 也给 C 转了 100 元，这个时候 A 先给 C 转账成功，余额变成了 200 元，但 B 事先查询 C 的余额是 100 元，转账成功之后也是 200 元。当 A 和 B 都给 C 转账完成之后，余额还是 200 元，而非预期的 300 元，这就是典型的线程安全的问题。
2）非线程安全代码示例
上面的内容没看明白没关系，下面来看非线程安全的具体代码：
class ThreadSafeTest {
static int number = 0;
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(() -> addNumber());
Thread thread2 = new Thread(() -> addNumber());
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("number：" + number);
}
public static void addNumber() {
for (int i = 0; i < 10000; i++) {
++number;
}
}
}以上程序执行结果如下：
number：12085每次执行的结果可能略有差异，不过几乎不会等于（正确的）累计之和 20000。
3）线程安全的解决方案
线程安全的解决方案有以下几个维度：
数据不共享，单线程可见，比如 ThreadLocal 就是单线程可见的；
使用线程安全类，比如 StringBuffer 和 JUC（java.util.concurrent）下的安全类（后面文章会专门介绍）；
使用同步代码或者锁。
线程同步和锁
1）synchronized
(1) synchronized 介绍
synchronized 是 Java 提供的同步机制，当一个线程正在操作同步代码块（synchronized 修饰的代码）时，其他线程只能阻塞等待原有线程执行完再执行。
(2) synchronized 使用
synchronized 可以修饰代码块或者方法，示例代码如下：
// 修饰代码块
synchronized (this) {
// do something
}
// 修饰方法
synchronized void method() {
// do something
}使用 synchronized 完善本文开头的非线程安全的代码。
方法一：使用 synchronized 修饰代码块，代码如下：
class ThreadSafeTest {
static int number = 0;
public static void main(String[] args) throws InterruptedException {
Thread sThread = new Thread(() -> {
// 同步代码
synchronized (ThreadSafeTest.class) {
addNumber();
}
});
Thread sThread2 = new Thread(() -> {
// 同步代码
synchronized (ThreadSafeTest.class) {
addNumber();
}
});
sThread.start();
sThread2.start();
sThread.join();
sThread2.join();
System.out.println("number：" + number);
}
public static void addNumber() {
for (int i = 0; i < 10000; i++) {
++number;
}
}
}以上程序执行结果如下：
number：20000方法二：使用 synchronized 修饰方法，代码如下：
class ThreadSafeTest {
static int number = 0;
public static void main(String[] args) throws InterruptedException {
Thread sThread = new Thread(() -> addNumber());
Thread sThread2 = new Thread(() -> addNumber());
sThread.start();
sThread2.start();
sThread.join();
sThread2.join();
System.out.println("number：" + number);
}
public synchronized static void addNumber() {
for (int i = 0; i < 10000; i++) {
++number;
}
}
}以上程序执行结果如下：
number：20000synchronized 实现原理
synchronized 本质是通过进入和退出的 Monitor 对象来实现线程安全的。
以下面代码为例：
public class SynchronizedTest {
public static void main(String[] args) {
synchronized (SynchronizedTest.class) {
System.out.println("Java");
}
}
}当我们使用 javap 编译之后，生成的字节码如下：
Compiled from "SynchronizedTest.java"
public class com.interview.other.SynchronizedTest {
public com.interview.other.SynchronizedTest();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: ldc #2 // class com/interview/other/SynchronizedTest
2: dup
3: astore_1
4: monitorenter
5: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
8: ldc #4 // String Java
10: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
13: aload_1
14: monitorexit
15: goto 23
18: astore_2
19: aload_1
20: monitorexit
21: aload_2
22: athrow
23: return
Exception table:
from to target type
5 15 18 any
18 21 18 any
}可以看出 JVM（Java 虚拟机）是采用 monitorenter 和 monitorexit 两个指令来实现同步的，monitorenter 指令相当于加锁，monitorexit 相当于释放锁。而 monitorenter 和 monitorexit 就是基于 Monitor 实现的。
2）ReentrantLock
(1) ReentrantLock 介绍
ReentrantLock（再入锁）是 Java 5 提供的锁实现，它的功能和 synchronized 基本相同。再入锁通过调用 lock() 方法来获取锁，通过调用 unlock() 来释放锁。
(2) ReentrantLock 使用
ReentrantLock 基础使用，代码如下：
Lock lock = new ReentrantLock();
lock.lock(); // 加锁
// 业务代码...
lock.unlock(); // 解锁使用 ReentrantLock 完善本文开头的非线程安全代码，请参考以下代码：
public class LockTest {
static int number = 0;
public static void main(String[] args) throws InterruptedException {
// ReentrantLock 使用
Lock lock = new ReentrantLock();
Thread thread1 = new Thread(() -> {
try {
lock.lock();
addNumber();
} finally {
lock.unlock();
}
});
Thread thread2 = new Thread(() -> {
try {
lock.lock();
addNumber();
} finally {
lock.unlock();
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("number：" + number);
}
public static void addNumber() {
for (int i = 0; i < 10000; i++) {
++number;
}
}
}尝试获取锁
ReentrantLock 可以无阻塞尝试访问锁，使用 tryLock() 方法，具体使用如下：
Lock reentrantLock = new ReentrantLock();
// 线程一
new Thread(() -> {
try {
reentrantLock.lock();
Thread.sleep(2 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
reentrantLock.unlock();
}
}).start();
// 线程二
new Thread(() -> {
try {
Thread.sleep(1 * 1000);
System.out.println(reentrantLock.tryLock());
Thread.sleep(2 * 1000);
System.out.println(reentrantLock.tryLock());
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();以上代码执行结果如下：
false
true尝试一段时间内获取锁
tryLock() 有一个扩展方法 tryLock(long timeout, TimeUnit unit) 用于尝试一段时间内获取锁，具体实现代码如下：
Lock reentrantLock = new ReentrantLock();
// 线程一
new Thread(() -> {
try {
reentrantLock.lock();
System.out.println(LocalDateTime.now());
Thread.sleep(2 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
reentrantLock.unlock();
}
}).start();
// 线程二
new Thread(() -> {
try {
Thread.sleep(1 * 1000);
System.out.println(reentrantLock.tryLock(3, TimeUnit.SECONDS));
System.out.println(LocalDateTime.now());
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();以上代码执行结果如下：
2019-07-05 19:53:51
true
2019-07-05 19:53:53可以看出锁在休眠了 2 秒之后，就被线程二直接获取到了，所以说 tryLock(long timeout, TimeUnit unit) 方法内的 timeout 参数指的是获取锁的最大等待时间。
(3) ReentrantLock 注意事项
使用 ReentrantLock 一定要记得释放锁，否则该锁会被永久占用。
- 扫码关注“火龙果编程”公众号，早日成为编程大神
本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可。