1. synchronized简介
synchronized作为java关键字，是一种多线程同步的手段。可以保证资源在多线程共享的情况下的正确性。举反例，如下代码就是线程不安全的：
class Unsafe {
int count = 0;
public void increment() {
count++;
}
public static void main(String[] args) throws InterruptedException {
Unsafe unsafe = new Unsafe();
for (int i = 0; i < 100; i++) {
Thread thread = new Thread(() -> {
try {
Thread.sleep(1);
unsafe.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
thread.start();
}
Thread.currentThread().sleep(1000);
System.out.println(unsafe.count);
}
}
启动100个线程对共享的变量count进行+1操作，但是输出结果并不是想象中的100,有可能是99、98、97等，但是如果对方法increment()加上synchronized进行修饰，程序就能表现正常的输出结果100。为什么synchronized会有这样的魔力？其原理是什么样子的呢？
2.从java虚拟机内存层次简述例子的执行过程
JVM是以进程为单位的，所有的同步讨论范畴都是在多线程的范围内。
就以上面的栗子作为案例来叙述，先看下内存结构图
简单描述下单个线程进行方法调用的时候执行步骤：
1. 线程调用increment方法，读取Heap中count的值，并将count拷贝一个副本到当前堆栈中。
2. 将副本中的count值加1。
3. 将副本中的count值重新放到Heap中。
每次加1的操作都包含了3个具体的步骤，很明显不是原子操作，在多线程环境下肯定存在线程安全性的问题。
如果在increment方法上加上synchronized修饰，则执行过程变成如下的过程：
1. 抢占unsafe对象的Monitor lock(监视器锁，见下面的详解)
2. 抢占到锁后执行上面1~3的步骤，抢占不到则进入阻塞状态，等待监视器锁的释放，再次进行监视器锁的抢占。
3. 监视器锁
在JAVA世界中万物皆对象，每个对象都提供了与之相关的监视器锁。java虚拟机可以支持方法级的同步和方法内部一段指令序列的同步，这两种方式的同步结构都是使用监视器锁来支持的。
1. 方法级的同步
class Unsafe {
private int count = 0;
public synchronized void increment() {
count++;
}
public static void main(String[] args) {
Unsafe unsafe = new Unsafe();
unsafe.increment();
}
}
方法级的同步是隐式的，即无需通过字节码指令来控制。虚拟机可以从方法常量池的方法表结构中的ACC_SYNCHRONIZED访问标志得知一个方法是否声明为同步方法。当方法调用时，调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否被设置，如果设置了，则要求当前线程现持有当前监视器锁，退出时（不管是正常退出还是异常退出）则是否当前持有的监视器锁。应用到如上代码中，则在main线程调用unsafe.increment()方法时则需要首先获取当前对象监视器锁，在退出方法执行时则释放持有的监视器锁。
2. 方法内部同步
public class Unsafe {
private int count = 0;
public void increment() {
synchronized (this) {
count++;
}
}
public static void main(String[] args) {
Unsafe unsafe = new Unsafe();
unsafe.increment();
}
}
通过javap工具反编译出increment方法相关的字节码
public void increment();
Code:
0: aload_0
1: dup
2: astore_1
3: monitorenter
4: aload_0
5: dup
6: getfield #2 // Field count:I
9: iconst_1
10: iadd
11: putfield #2 // Field count:I
14: aload_1
15: monitorexit
16: goto 24
19: astore_2
20: aload_1
21: monitorexit
22: aload_2
23: athrow
24: return
Exception table:
from to target type
4 16 19 any
19 22 19 any
同步一段指令集序列通常是由java语言中synchronized语句块表示的，java虚拟机的指令集有monitorenter(第3行字节码)和monitorexit(第15行字节码)两条指令来支持同步原语。
应用到increment()方法时，进入到同步代码块之前，首先借助monitorenter指令获取当前unsafe对象的监视器锁，然后完成count加1的操作，在退出同步代码块时借助monitorexit完成对监视器锁的释放。
4. 应用
对于方法外部和内部的同步操作，底层的实现原理虽然是不同的，但是表现的结果是一致的。但是在实际应用的时候还是要注意区分对象锁和类对象锁的区别。
1. 对象锁
1.1 this对象
public class Unsafe {
private int count = 0;
public void increment() {
// 借助的是当前unsafe对象的监视器锁
synchronized (this) {
count++;
}
}
public static void main(String[] args) {
Unsafe unsafe = new Unsafe();
unsafe.increment();
}
}
这里increment()方法借助的是new出来的unsafe对象相关的对象锁来实现的线程安全。
1.2 任意Object对象
public class Unsafe {
private int count = 0;
private Object lock = new Object();
public void increment() {
// 这里借助object对象的监视器锁
synchronized (lock) {
count++;
}
}
public static void main(String[] args) {
Unsafe unsafe = new Unsafe();
unsafe.increment();
}
}
监视器锁是所有Object对象相关的，所以任意一个对象都可以使用如上的写法。这里借助的是new出来的object对象相关的监视器锁来实现的线程安全。针对同一类new出来的不同的对象，所以它们之间是没锁竞争关系的。
2. 类对象锁
2.1 类
public class Unsafe {
private int count = 0;
public void increment() {
synchronized (Unsafe.class) {
count++;
}
}
public static void main(String[] args) {
Unsafe unsafe = new Unsafe();
unsafe.increment();
}
}
2.2 静态方法
public class Unsafe {
private static int count = 0;
public static synchronized void increment() {
count++;
}
public static void main(String[] args) {
Unsafe unsafe = new Unsafe();
unsafe.increment();
}
}
因为对象的类的信息是在jvm中的方法区(永久代)保存的，是被所有的线程共享的，静态方法和成员变量也是被共享的。所以即便将上面的Unsafenew出不同的对象，它们之间还是存在锁竞争关系的。
写在最后：最近一段时间都在为年初跳槽做技术上的准备。之前一直对原理性的东西似懂非懂，希望能通过写博客的过程细化自己对技术细节的了解，也希望博客的内容能给广大的java道友提供一些的帮助和提升。由于笔者水平有限，如果内容有误，希望大家批评指出。
参考文献
. 《深入理解Java虚拟机》 周志明 著
