一、前言
Synchronized用于线程同步，相信大家都知道，但具体是如何保证线程同步的，有什么要求？今天我们就来聊聊这些。
二、Synchronized同步的是什么
首先，需要明确一下几个前提：
- 有多个线程在运行；
- 都需要访问同一个对象（或叫资源），并对资源做操作；
我们看个例子（多线程访问同一对象，未添加任何的同步措施）
public class Main {
private int ticket = 100;
public void decrease() {
ticket --;
System.out.println("after tickets = " + ticket + ", " + Thread.currentThread().getName());
}
public static void main(String[] args) {
Main ticket = new Main();
for (int i = 0; i < 5; i ++) {
new Thread(() -> {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticket.decrease();
}).start();
}
}
}
输出日志：
after tickets = 98, Thread-0
after tickets = 96, Thread-3
after tickets = 95, Thread-4
after tickets = 97, Thread-2
after tickets = 98, Thread-1
我们发现个问题：；
如果我们对『decrease』添加『 synchronized』关键字，再来看看结果：
public class Main {
private int ticket = 100;
public synchronized void decrease() {
ticket --;
System.out.println("after tickets = " + ticket + ", " + Thread.currentThread().getName());
}
public static void main(String[] args) {
Main ticket = new Main();
for (int i = 0; i < 5; i ++) {
new Thread(() -> {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticket.decrease();
}).start();
}
}
}
输出日志：
after tickets = 99, Thread-0
after tickets = 98, Thread-3
after tickets = 97, Thread-2
after tickets = 96, Thread-1
after tickets = 95, Thread-4
虽然线程执行的顺序还是随机的，但至少数据是对的。
三、Synchronized的用法
通过上一小节，我们初步了解 Syncrhonized 的作用，这节，我们具体的说说 Synchronized。
Java提供了一种内置锁的机制来支持原子性、可见性、有序性和可重入性：同步代码块（Synchronized Block）；同步代码块包含两部分：
- 锁的对象引用；
- 锁保护的代码块；
每一个 Java 对象都可以用于实现一个同步的锁，这种锅被称为『内置锁（Intrinsic Lock）』或『监视器锁（Monitor Lock）』。线程进入同步代码块之前会自动去尝试获取锁，一旦拿到锁，就能进入同步代码块，在退出同步代码块（正常返回或异常退出）时，都会自动释放锁。
3.1、Synchronized 特性
3.1.1、原子性
一个或多个操作，要么全部执行并且执行的过程不会被任何因素打断；要么就都不执行。
在 Java 中，基本数据类型变量的读了和赋值操作是原子性操作，这些操作不可中断，要么执行，要么不执行。但是像『i++』『i += 1』等操作就不是原子性的，它们被分成：读取、计算、赋值三步操作，原值在这些步骤还没完成时可能就已经被赋值，那么最后赋值写入的数据不是脏数据 ，因此无法保证原子性。
Synchronized 修饰的类或对象，其所有操作都是原子性的，因为在执行前，必需先获取类或对象的锁，之后才能执行，执行完后需要释放。执行过程中无法被中断，即保证了原子性。
3.1.2、可见性
多个线程访问同一个资源时，该资源的状态、值信息等对于其它线程都是可见的。
Synchronized 和 volatile 都具有可见性，其中 Synchronized 对一个类或对象加锁时，一个线程如果要访问该类或对象必须先获得它的锁，而这个锁的状态对于其他任何线程都是可见的，并且在释放锁之前会将对变量的修改刷新到主存当中，保证资源变量的可见性，如果某个线程占用了该锁，其他线程就必须在锁池中等待锁的释放。
而 volatile 的实现类似，被 volatile 修饰的变量，每当值需要修改时都会立即更新主存，主存是共享的，所有线程可见，所以确保了其他线程读取到的变量永远是最新值，保证可见性。
3.1.3、有序性
执行的顺序按照代码先后执行。
Synchronized 和 volatile 都具有有序性，Java允许编译器和处理器对指令进行重排，但是指令重排并不会影响单线程的顺序，它影响的是多线程并发执行的顺序性。Synchronized 保证了每个时刻都只有一个线程访问同步代码块，也就确定了线程执行同步代码块是分先后顺序的，保证了有序性。
3.1.4、可重入性
Synchronized 和 ReentrantLock 都是可重入锁。当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入锁。通俗一点讲就是说一个线程拥有了锁仍然还可以重复申请锁。
3.2、Synchronized作用
上面说了那么多内容，总结其作用为以下：
- 确保线程互斥；
- 确保当前只有一个线程可以操作；
- 保证共享的资源可修改（原子性），且有可见性；
- 有效解决重排序问题；
3.3、Synchronized用法
- 修饰普通方法
- 修饰代码块
- 修饰静态方法
四、实战演示
4.1、多线程 + 未同步方法调用
public class SyncTest {
public void first() {
System.out.println(System.currentTimeMillis() + " first --- in");
try {
System.out.println(System.currentTimeMillis() + " first --- exec");
Thread.sleep(2000);
} catch (Exception e) {
}
System.out.println(System.currentTimeMillis() + " first --- out");
}
public void second() {
System.out.println(System.currentTimeMillis() + " second --- in");
try {
System.out.println(System.currentTimeMillis() + " second --- exec");
Thread.sleep(1000);
} catch (Exception e) {
}
System.out.println(System.currentTimeMillis() + " second --- out");
}
public static void main(String[] args) {
SyncTest test = new SyncTest();
for (int i = 0; i < 2; i ++) {
final int idx = i;
new Thread(() -> {
if (idx == 0) {
test.first();
} else {
test.second();
}
}).start();
}
}
}
执行结果如下：
1612098570725 first --- in
1612098570726 first --- exec
1612098570725 second --- in
1612098570726 second --- exec
1612098571727 second --- out
1612098572729 first --- out
我们看到，两个线程是并发执行，因为『second方法中休眠一秒』，所以，后启动执行的线程先执行完成。
4.2、多线程 + 同步方法调用
稍微修改一下上面的代码，如下：
public class SyncTest {
public synchronized void first() {
System.out.println(System.currentTimeMillis() + " first --- in");
try {
System.out.println(System.currentTimeMillis() + " first --- exec");
Thread.sleep(2000);
} catch (Exception e) {
}
System.out.println(System.currentTimeMillis() + " first --- out");
}
public synchronized void second() {
System.out.println(System.currentTimeMillis() + " second --- in");
try {
System.out.println(System.currentTimeMillis() + " second --- exec");
Thread.sleep(1000);
} catch (Exception e) {
}
System.out.println(System.currentTimeMillis() + " second --- out");
}
public static void main(String[] args) {
SyncTest test = new SyncTest();
for (int i = 0; i < 2; i ++) {
final int idx = i;
new Thread(() -> {
if (idx == 0) {
test.first();
} else {
test.second();
}
}).start();
}
}
}
执行结果如下：
1612098877346 first --- in
1612098877346 first --- exec
1612098879350 first --- out
1612098879350 second --- in
1612098879350 second --- exec
1612098880355 second --- out
我们看到，与上一个例子相比，第二个线程必需等到第一个线程完全执行结束，才开始进入并执行。
4.3、多线程 + 同步代码块调用
public class SyncTest {
public void first() {
System.out.println(System.currentTimeMillis() + " first --- in");
try {
synchronized (this) {
System.out.println(System.currentTimeMillis() + " first --- exec");
Thread.sleep(2000);
}
} catch (Exception e) {
}
System.out.println(System.currentTimeMillis() + " first --- out");
}
public void second() {
System.out.println(System.currentTimeMillis() + " second --- in");
try {
synchronized (this) {
System.out.println(System.currentTimeMillis() + " second --- exec");
Thread.sleep(1000);
}
} catch (Exception e) {
}
System.out.println(System.currentTimeMillis() + " second --- out");
}
public static void main(String[] args) {
SyncTest test = new SyncTest();
for (int i = 0; i < 2; i ++) {
final int idx = i;
new Thread(() -> {
if (idx == 0) {
test.first();
} else {
test.second();
}
}).start();
}
}
}
执行结果如下：
1612099286790 first --- in
1612099286790 first --- exec
1612099286790 second --- in
1612099288795 second --- exec
1612099288795 first --- out
1612099289800 second --- out
我们看到，线程2进入到『second』方法中，但在执行同步代码块之前，需要等待线程1执行完同步代码块，才能开始执行。
4.4、多线程 + 静态方法（类）同步
public class SyncTest {
public static synchronized void first() {
System.out.println(System.currentTimeMillis() + " first --- in");
try {
System.out.println(System.currentTimeMillis() + " first --- exec");
Thread.sleep(2000);
} catch (Exception e) {
}
System.out.println(System.currentTimeMillis() + " first --- out");
}
public static synchronized void second() {
System.out.println(System.currentTimeMillis() + " second --- in");
try {
System.out.println(System.currentTimeMillis() + " second --- exec");
Thread.sleep(1000);
} catch (Exception e) {
}
System.out.println(System.currentTimeMillis() + " second --- out");
}
public static void main(String[] args) {
SyncTest test1 = new SyncTest();
SyncTest test2 = new SyncTest();
for (int i = 0; i < 2; i ++) {
final int idx = i;
new Thread(() -> {
if (idx == 0) {
test1.first(); // SyncTest.first() 一样
} else {
test2.second(); // SyncTest.second() 一样
}
}).start();
}
}
}
执行结果如下：
1612099702500 first --- in
1612099702500 first --- exec
1612099704503 first --- out
1612099704503 second --- in
1612099704503 second --- exec
1612099705505 second --- out
静态方法的同步，本质上是类的同步，因为，静态方法也是属于类的，而无法独立存在。因此，即使『test1』和『test2』是不同的对象，但是它们都属于『SyncTest类』，每个类都有一个默认的锁，叫作『类锁』。
五、Synchronized 原理
对于上面的这些同步的例子，我们本节会一一讲解其原理。
5.1、static 与 non-static 区别：
再了解原理之前，我们先来了解一下 static 与 non-static 的区别：
- 被 static 修饰的方法、成员都归类所有，该类的所有对象都可以访问；
- non-static 的方法与成员是归类的实例化对象所有，只有实例化后的对象才能访问；
这也就是为何 static 方法不能访问 non-static 方法或成员。
5.2、同步代码块
public class SyncTest {
public void first() {
synchronized (this) {
System.out.println();
}
}
}
编译后，我们通过命令：
查看编译后的 Class 内容：
Classfile /Users/qingye/Desktop/Java/Demo/out/production/Demo/com/chris/test/SyncTest.class
Last modified 2021年1月31日; size 573 bytes
SHA-256 checksum e5340e14a3844276f0f11d0b7ce4e3169bfd99c6ffcd68dbfeb0d228c7f764ac
Compiled from "SyncTest.java"
public class com.chris.test.SyncTest
......
{
......
public void first();
descriptor: ()V
flags: (0x0001) ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: aload_0
1: dup
2: astore_1
3: monitorenter // 重点 1
4: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
7: invokevirtual #3 // Method java/io/PrintStream.println:()V
10: aload_1
11: monitorexit // 重点 2
12: goto 20
15: astore_2
16: aload_1
17: monitorexit // 重点 3
18: aload_2
19: athrow
20: return
......
}
SourceFile: "SyncTest.java"
我们只关注上面的『重点1、2、3』，会发现有三条指令，其中两条相同，共两种指令：『monitorenter』和『monitorexit』，JVM规范中有对这两条指令的解释：
- monitorenter
意思如下：
- monitorexit
意思如下：
通过以上信息，我们了解了 Synchronized 的底层原理：
- Java 在编译时，将 Synchronized 所包裹的代码块的前、后分别插入『monitorenter』和『monitorexit』两条指令；
- JVM 通过一个 monitor 对象来监视所有要执行同步代码块的线程，通过竞争来获取 monitor 所有权，才被允许执行同步代码块内的代码；
- wait / notify 依赖 monitor ，这就是为何只能在同步代码块中才能调用 wait / notify 方法，否则会抛出 java.lang.IllegalMonitorStateException 异常；
11: monitorexit // 重点 2
12: goto 20 // 跳到 line 20
15: astore_2
16: aload_1
17: monitorexit // 重点 3
18: aload_2
19: athrow // throw exception
20: return
5.3、普通同步方法
public class SyncTest {
public synchronized void first() {
System.out.println();
}
}
......
public synchronized void first();
descriptor: ()V
flags: (0x0021) ACC_PUBLIC, ACC_SYNCHRONIZED // 重点
Code:
stack=1, locals=1, args_size=1
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: invokevirtual #3 // Method java/io/PrintStream.println:()V
6: return
LineNumberTable:
line 5: 0
line 6: 6
LocalVariableTable:
Start Length Slot Name Signature
0 7 0 this Lcom/chris/test/SyncTest;
}
SourceFile: "SyncTest.java"
我们并没有发现『monitorenter』和『monitorexit』两条指令，但多了一个修饰符：ACC_SYNCHRONIZED 标志。JVM 就是根据该标志来实现方法的同步：当方法被调用时，会先检查是否有该标志，如果有，则执行的线程需要先尝试获取 monitor ，成功获取之后才能执行方法体，之后再释放 monitor 。这种方式是通过隐式的方式来实现，无需插入字节码来完成。
5.4、静态方法（类）同步
该底层实现实际和 5.2 一样，只是一个是普通方法（基于对象锁），一个是静态方法（基于类锁）而已，但都是隐式的通过 monitor 来实现。
......
public static synchronized void first();
descriptor: ()V
flags: (0x0029) ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED // 重点
Code:
stack=1, locals=0, args_size=0
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: invokevirtual #3 // Method java/io/PrintStream.println:()V
6: return
LineNumberTable:
line 5: 0
line 6: 6
}
SourceFile: "SyncTest.java"
六、总结
Synchronized 是 Java 并发编程中最常用，也是最简单的，保证线程安全的措施之一。本文期望抛砖引玉，让大家了解 Synchronized 的同时，也能够稍微深入了解 monitor / JVM 底层知识；也期望大家能够进一步深入学习，更好的理解并发编程的机制。
除了使用 Synchronized （类锁或对象锁），还有其它方式的锁，我也会在后面给大家分享。
