【从入门到放弃-Java】并发编程-锁-synchronized

简介

上篇【从入门到放弃-Java】并发编程-线程安全中，我们了解到，可以通过加锁机制来保护共享对象，来实现线程安全。

synchronized是java提供的一种内置的锁机制。通过synchronized关键字同步代码块。线程在进入同步代码块之前会自动获得锁，并在退出同步代码块时自动释放锁。内置锁是一种互斥锁。

本文来深入学习下synchronized。

使用

同步方法

同步非静态方法

public class Synchronized {private static int count;private synchronized void add1() {count++;System.out.println(count);}public static void main(String[] args) throws InterruptedException {Synchronized sync = new Synchronized();Thread thread1 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync.add1();}});Thread thread2 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync.add1();}});thread1.start();thread2.start();Thread.sleep(1000);System.out.println(count);}
}

结果符合预期：synchronized作用于非静态方法，锁定的是实例对象，如上所示锁的是sync对象，因此线程能够正确的运行，count的结果总会是20000。

public class Synchronized {private static int count;private synchronized void add1() {count++;System.out.println(count);}public static void main(String[] args) throws InterruptedException {Synchronized sync = new Synchronized();Synchronized sync1 = new Synchronized();Thread thread1 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync.add1();}});Thread thread2 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync1.add1();}});thread1.start();thread2.start();Thread.sleep(1000);System.out.println(count);}
}

结果不符合预期：如上所示，作用于非静态方法，锁的是实例化对象，因此当sync和sync1同时运行时，还是会出现线程安全问题，因为锁的是两个不同的实例化对象。

同步静态方法

public class Synchronized {private static int count;private static synchronized void add1() {count++;System.out.println(count);}private static synchronized void add11() {count++;System.out.println(count);}public static void main(String[] args) throws InterruptedException {Synchronized sync = new Synchronized();Synchronized sync1 = new Synchronized();Thread thread1 = new Thread(() -> {for (int i = 0; i< 10000; i++) {Synchronized.add1();}});Thread thread2 = new Thread(() -> {for (int i = 0; i< 10000; i++) {Synchronized.add11();}});thread1.start();thread2.start();Thread.sleep(1000);System.out.println(count);}
}

结果符合预期：锁静态方法时，锁的是类对象。因此在不同的线程中调用add1和add11依然会得到正确的结果。

同步代码块

锁当前实例对象

public class Synchronized {private static int count;private void add1() {synchronized (this) {count++;System.out.println(count);}}private static synchronized void add11() {count++;System.out.println(count);}public static void main(String[] args) throws InterruptedException {Synchronized sync = new Synchronized();Synchronized sync1 = new Synchronized();Thread thread1 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync.add1();}});Thread thread2 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync1.add1();}});thread1.start();thread2.start();Thread.sleep(1000);System.out.println(count);}
}

结果不符合预期：当synchronized同步方法块时，锁的是实例对象时，如上示例在不同的实例中调用此方法还是会出现线程安全问题。

锁其它实例对象

public class Synchronized {private static int count;public String lock = new String();private void add1() {synchronized (lock) {count++;System.out.println(count);}}private static synchronized void add11() {count++;System.out.println(count);}public static void main(String[] args) throws InterruptedException {Synchronized sync = new Synchronized();Synchronized sync1 = new Synchronized();Thread thread1 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync.add1();}});Thread thread2 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync1.add1();}});thread1.start();thread2.start();Thread.sleep(1000);System.out.println(count);System.out.println(sync.lock == sync1.lock);}
}

结果不符合预期：当synchronized同步方法块时，锁的是其它实例对象时，如上示例在不同的实例中调用此方法还是会出现线程安全问题。

public class Synchronized {private static int count;public String lock = "";private void add1() {synchronized (lock) {count++;System.out.println(count);}}private static synchronized void add11() {count++;System.out.println(count);}public static void main(String[] args) throws InterruptedException {Synchronized sync = new Synchronized();Synchronized sync1 = new Synchronized();Thread thread1 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync.add1();}});Thread thread2 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync1.add1();}});thread1.start();thread2.start();Thread.sleep(1000);System.out.println(count);System.out.println(sync.lock == sync1.lock);}
}

结果符合预期：当synchronized同步方法块时，锁的虽然是其它实例对象时，但已上实例中，因为String = "" 是存放在常量池中的，实际上锁的还是相同的对象，因此是线程安全的

锁类对象

public class Synchronized {private static int count;private void add1() {synchronized (Synchronized.class) {count++;System.out.println(count);}}private static synchronized void add11() {count++;System.out.println(count);}public static void main(String[] args) throws InterruptedException {Synchronized sync = new Synchronized();Synchronized sync1 = new Synchronized();Thread thread1 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync.add1();}});Thread thread2 = new Thread(() -> {for (int i = 0; i< 10000; i++) {sync1.add1();}});thread1.start();thread2.start();Thread.sleep(1000);System.out.println(count);}
}

结果符合预期：当synchronized同步方法块时，锁的是类对象时，如上示例在不同的实例中调用此方法是线程安全的。

锁机制

public class Synchronized {private static int count;public static void main(String[] args) throws InterruptedException {synchronized (Synchronized.class) {count++;}}
}

使用javap -v Synchronized.class反编译class文件。

可以看到synchronized实际上是通过monitorenter和monitorexit来实现锁机制的。同一时刻，只能有一个线程进入监视区。从而保证线程的同步。

正常情况下在指令4进入监视区，指令14退出监视区然后指令15直接跳到指令23 return

但是在异常情况下异常都会跳转到指令18，依次执行到指令20monitorexit释放锁，防止出现异常时未释放的情况。
这其实也是synchronized的优点：无论代码执行情况如何，都不会忘记主动释放锁。

想了解Monitors更多的原理可以点击查看

锁升级

因为monitor依赖操作系统的Mutex lock实现，是一个比较重的操作，需要切换系统至内核态，开销非常大。因此在jdk1.6引入了偏向锁和轻量级锁。
synchronized有四种状态：无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁。

无锁

没有对资源进行锁定，所有线程都能访问和修改。但同时只有一个线程能修改成功

偏向锁

在锁竞争不强烈的情况下，通常一个线程会多次获取同一个锁，为了减少获取锁的代价引入了偏向锁，会在java对象头中记录获取锁的线程的threadID。

当线程发现对象头的threadID存在时。判断与当前线程是否是同一线程。
如果是则不需要再次加、解锁。
如果不是，则判断threadID是否存活。不存活：设置为无锁状态，其他线程竞争设置偏向锁。存活：查找threadID堆栈信息判断是否需要继续持有锁。需要持有则升级threadID线程的锁为轻量级锁。不需要持有则撤销锁，设置为无锁状态等待其它线程竞争。

因为偏向锁的撤销操作还是比较重的，导致进入安全点，因此在竞争比较激烈时，会影响性能，可以使用-XX:-UseBiasedLocking=false禁用偏向锁。