synchronized是Java提供的一个用于并发控制的关键字，在平时的程序开发过程中在做并发控制的时候经常会使用到，但有时使用不当，不仅没有控制住并发，反而会导致系统问题，尤其在一些对并发要求比较高的场景会造成事故。
因此，有必要对synchronized进行一次系统的学习，把相关的知识梳理一遍，这样可以减少在开发过程中少走弯路，写出更加优雅的代码。
本文主要进行两个方面的分享：
- synchronized关键字的使用场景
- synchronized关键字在底层的工作机制是什么样的
使用场景
在Java中，每一个对象都会有一个叫做Monitor(中文翻译为监视器)的锁。
synchronized修饰方法
先来看代码示例一：
public class Test {
public static void main(String[] args) throws Exception{
Test test = new Test();
Thread t1 = new Thread(() -> test.m1());
t1.start()
Thread t2 = new Thread(() -> test.m1());
t2.start();
}
public synchronized void m1() {
System.out.println("m1");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
当线程t1访问test对象的synchronized关键字修饰的方法m1时，会给这个对象上锁，此时当有另一个线程t2访问该方法时会被阻塞，直到A线程执行完m1时，将锁释放掉，才能进入并执行m1方法。
上面的代码只是synchronized使用的一种情况，实际上可以分为两种：
一种是修饰普通方法
一种是修饰静态方法
它们都会给对象上锁，但是上锁的对象是不一样的。
上面的代码其实synchronized是在修饰的普通方法，它会给当前方法所在类的对象实例上锁，而修饰静态方法synchronized会给当前方法所在类的Class对象上锁。
来看下面的代码示例二：
public class Test {
public static void main(String[] args) throws Exception{
Test test = new Test();
Thread t1 = new Thread(() -> test.m1());
t1.start()
Thread t2 = new Thread(() -> test.m1());
t2.start();
}
public synchronized void m1() {
System.out.println("m1");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static synchronized void m2() {
System.out.println("m2");
}
}
当线程t1访问test对象的m1时，会给当前test对象的实例上加锁，而当线程t2访问test对象的m2时，会给当前对象的class对象加锁，因此当两个线程先后启动后，假设t1先执行m1，但由于t2访问对象的加锁目标和t1加锁的不同，所以t2不会受t1的执行而休眠3秒钟，会立即执行。
所以，如果在一个类中，一个线程访问用synchronized关键字修饰的普通方法，一个线程访问用synchronized关键字修饰的静态方法，则这两个对象的锁的目标是不一样的，因此互相之间不会影响。
另外，需要注意的是，如果一个类中，有两个都用synchronized关键字修饰的普通方法，一个线程访问其中一个时，另一个访问另一个会因为两个方法都具有相同的对象实例锁，因此另一个线程也会被阻塞。都用synchronized关键字修饰的静态方法，情况也是如此。
synchronized修饰代码块
除了synchronized关键字可以修饰方法以外，synchronized关键字还可以修饰代码块。
看一下代码示例三：
public class Test {
public static void main(String[] args) throws Exception{
Test test = new Test();
Thread t1 = new Thread(() -> test.m1());
t1.start()
Thread t2 = new Thread(() -> test.m1());
t2.start();
}
public void m1() {
synchronized(this){
System.out.println("m1");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void m2() {
synchronized(Test.class) {
System.out.println("m2");
}
}
}
当线程t1访问m1的时候，会对当前对象实例上锁，而当线程t2访问m2的时候，会对当前对象的class对象上锁，因此两个线程执行的时候不会互相受影响而被阻塞。在这里具体锁的控制和修饰方法类似。
两者的异同点
相同
两者都能给普通对象实例上锁和类的class对象上锁
区别
1.修饰方法是粗粒度的并发控制，某一时刻只能有一个线程访问被synchronized修饰的方法；而修饰代码块是一种更细粒度的并发控制，可以只对方法的局部代码进行并发控制，方法中代码块外的代码还可以被多个线程同时执行；
2.修饰代码块要比修饰方法的并发性能高；
底层原理
上面介绍了synchronized修饰符在方法和代码块中的应用，但这只是使用层面的内容。在方法或代码块上添加了它，就能进行并发控制，看起来并发控制很简单。本着知其然还要知其所以然的意愿，还需要了解下它在底层是如何做到这些的，一起来看下底层原理吧。
synchronized修饰符是Java的JDK提供的一个关键字，在底层是通过JVM来实现并发控制的。上面说过每一个Java对象都有一个Monitor锁，那么来看看synchronized修饰符通过编译器的编译后在字节码层面是什么样的。
以实例二为例
找到编译器编译后的class文件所在的目录, 通过jdk提供的命令javap -v Test反编译，得到下面的字节码
public synchronized void m1();
descriptor: ()V
flags: ACC_PUBLIC, ACC_SYNCHRONIZED
Code:
stack=2, locals=2, args_size=1
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String m1
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: ldc2_w #5 // long 3000l
11: invokestatic #7 // Method java/lang/Thread.sleep:(J)V
14: goto 22
17: astore_1
18: aload_1
19: invokevirtual #9 // Method java/lang/InterruptedException.printStackTrace:()V
22: return
public static synchronized void m2();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
Code:
stack=2, locals=0, args_size=0
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #10 // String m2
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
通过上面的字节码可以看出，
一个是在普通方法添加synchronized修饰
在flags上出现了ACC_SYNCHRONIZED，当线程t1访问方法m1时，发现flag 有此ACC_SYNCHRONIZED标志，则会对当前对象实例加锁，此时当t2线程访问方法m1时，会检查flags上是否有此标志，如有则会看当前对象实例是否加锁，如果加锁，就进入阻塞状态，等待t1线程执行完毕释放锁，然后再次进入。
一个是在静态方法添加synchronized修饰
在flags上出现了ACC_STATIC, ACC_SYNCHRONIZED，当线程t1访问方法m1时，发现flag同时具有ACC_STATIC标志和ACC_SYNCHRONIZED标志，则会对当前对象的class对象加锁，此时当t2线程访问方法m1时，会检查flags上是否也有这两个标志，如果有则会看当前对象的class对象是否加锁，如果加锁，就进入阻塞状态，等待t1线程执行完毕释放锁，然后再次进入。
再来看代码三：
通过javap -v Test反编译后的字节码如下
public void m1();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=4, args_size=1
0: aload_0
1: dup
2: astore_1
3: monitorenter
4: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
7: ldc #3 // String m1
9: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
12: ldc2_w #5 // long 3000l
15: invokestatic #7 // Method java/lang/Thread.sleep:(J)V
18: goto 26
21: astore_2
22: aload_2
23: invokevirtual #9 // Method java/lang/InterruptedException.printStackTrace:()V
26: aload_1
27: monitorexit
28: goto 36
31: astore_3
32: aload_1
33: monitorexit
34: aload_3
35: athrow
36: return
public static void m2();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=2, args_size=0
0: ldc #10 // class Test
2: dup
3: astore_0
4: monitorenter
5: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
8: ldc #11 // String m2
10: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
13: aload_0
14: monitorexit
15: goto 23
18: astore_1
19: aload_0
20: monitorexit
21: aload_1
22: athrow
23: return
通过上面的字节码可以看出，
一种是在对普通对象修饰synchronized修饰代码块
当t1调用方法m1时，检查flags有无ACC_SYNCHRONIZED标志和ACC_STATIC标志，如果没有，则发现执行过程中有monitorenter，则会对当前对象实例加锁，如果t2也调用方法，则也按如上过程，发现当前对象加锁，则会进入阻塞，等待t1执行完毕释放，然后进入执行。
一种是在class对象修饰synchronized修饰代码块
当t1调用方法m1时，检查flags有无ACC_SYNCHRONIZED标志和ACC_STATIC标志，如果有ACC_STATIC标志，没有ACC_SYNCHRONIZED，然后发现执行过程中有monitorenter，则会对当前class对象实例加锁，如果t2也调用方法，则也按如上过程，发现当前class对象加锁，则会进入阻塞，等待t1执行完毕释放，然后进入执行。
总结
-
jvm中的同步是基于进入与退出监视器对象(Monitor)来完成的。Monitor是通过C++来实现的，每个对象实例都有一个monitor对象，它会和java对象一起创造和销毁。当线程获取到monitor对象时，monitor是依赖于底层操作系统的mutex lock来实现互斥的，从而能够控制并发。
-
synchronized用在方法上，是通过flags的ACC_STATIC和monitorenter、monitorexit来控制加锁和释放锁
-
synchronized用在代码块上，是通过flags的ACC_STATIC, ACC_SYNCHRONIZED两个标志位来控制加锁和释放锁
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
