[TOC] ## **Synchronized**同步锁 synchronized 它可以把任意一个非 NULL 的对象当作锁。他属于独占式的悲观锁，同时属于可重 入锁。 ### **Synchronized作用范围** 1. 作用于方法时，锁住的是对象的实例(this)； 2. 当作用于静态方法时，锁住的是 Class 实例，又因为 Class 的相关数据存储在永久带 PermGen （jdk1.8 则是 metaspace ），永久带是全局共享的，因此静态方法锁相当于类的一个全局锁， 会锁所有调用该方法的线程； 3. synchronized 作用于一个对象实例时，锁住的是所有以该对象为锁的代码块。它有多个队列， 当多个线程一起访问某个对象监视器的时候，对象监视器会将这些线程存储在不同的容器中。 ### **Synchronized核心组件** 1)**WaitSet**：哪些调用wait方法被阻塞的线程被放置在这里； 2)**Contention List**：竞争队列，所有请求锁的线程首先被放在这个竞争队列中； 3)**Entry List**：Contention List 中那些有资格成为候选资源的线程被移动到 Entry List 中； 4)**OnDeck** ：任意时刻，最多只有一个线程正在竞争锁资源，该线程被成为 OnDeck； 5)**Owner**：当前已经获取到所资源的线程被称为Owner； 6)**!Owner**：当前释放锁的线程。 ### **Synchronized实现** :-:  1. JVM 每次从队列的尾部取出一个数据用于锁竞争候选者（ OnDeck ），但是并发情况下，ContentionList 会被大量的并发线程进行 CAS 访问，为了降低对尾部元素的竞争，JVM 会将一部分线程移动到 EntryList 中作为候选竞争线程。 <br> 2. Owner 线程会在 unlock 时，将 ContentionList 中的部分线程迁移到 EntryList 中，并指定EntryList 中的某个线程为 OnDeck 线程（一般是最先进去的那个线程）。 <br> 3. Owner 线程并不直接把锁传递给 OnDeck 线程，而是把锁竞争的权利交给 OnDeck ，OnDeck 需要重新竞争锁。这样虽然牺牲了一些公平性，但是能极大的提升系统的吞吐量，在JVM 中，也把这种选择行为称之为“竞争切换”。 <br> 4. OnDeck 线程获取到锁资源后会变为 Owner 线程，而没有得到锁资源的仍然停留在 EntryList中。如果 Owner 线程被 wait 方法阻塞，则转移到 WaitSet 队列中，直到某个时刻通过 notify或者 notifyAll 唤醒，会重新进去 EntryList 中。 <br> 5. 处于 ContentionList 、 EntryList 、WaitSet 中的线程都处于阻塞状态，该阻塞是由操作系统来完成的（Linux 内核下采用 pthread\_mutex\_lock 内核函数实现的）。 <br> 6. Synchronized 是**非公平锁**。 Synchronized 在线程进入 ContentionList 时，等待的线程会先尝试自旋获取锁，如果获取不到就进入 ContentionList，这明显对于已经进入队列的线程是不公平的，还有一个不公平的事情就是自旋获取锁的线程还可能直接抢占 OnDeck 线程的锁资源。 参考：[https://blog.csdn.net/zqz\_zqz/article/details/70233767](http://https:/blog.csdn.net/zqz_zqz/article/details/70233767) <br> 7. 每个对象都有个 monitor 对象，加锁就是在竞争 monitor 对象，代码块加锁是在前后分别加上 monitorenter 和 monitorexit 指令来实现的，方法加锁是通过一个标记位来判断的 <br> 8. synchronized是一个**重量级**操作，需要调用操作系统相关接口，性能是低效的，有可能给线程加锁消耗的时间比有用操作消耗的时间更多。 <br> 9. Java1.6 ，synchronized 进行了很多的优化，有适应自旋、锁消除、锁粗化、轻量级锁及偏向锁等，效率有了本质上的提高。在之后推出的 Java1.7 与 1.8 中，均对该关键字的实现机理做了优化。引入了偏向锁和轻量级锁。都是在对象头中有标记位，不需要经过操作系统加锁。 <br> 10.锁可以从偏向锁升级到轻量级锁，再升级到重量级锁。这种升级过程叫做锁膨胀； <br> 11.JDK 1.6 中默认是开启偏向锁和轻量级锁，可以通过 -XX:-UseBiasedLocking 来禁用偏向锁。 <br> ### **synchronized用法** **1\. 同步一个代码块** ~~~java public void func() { synchronized (this) { // ... } } ~~~ 它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。 对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。 ~~~java public class SynchronizedExample { public void func1() { synchronized (this) { for (int i = 0; i < 10; i++) { System.out.print(i + " "); } } } } ~~~ ~~~java public static void main(String[] args) { SynchronizedExample e1 = new SynchronizedExample(); ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(() -> e1.func1()); executorService.execute(() -> e1.func1()); } ~~~ ~~~java 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 ~~~ 对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。 ~~~java public static void main(String[] args) { SynchronizedExample e1 = new SynchronizedExample(); SynchronizedExample e2 = new SynchronizedExample(); ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(() -> e1.func1()); executorService.execute(() -> e2.func1()); } ~~~ ~~~ 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 ~~~ **2\. 同步一个方法** ~~~java public synchronized void func () { // ... } ~~~ 它和同步代码块一样，作用于同一个对象。 **3\. 同步一个类** ~~~java public void func() { synchronized (SynchronizedExample.class) { // ... } } ~~~ 作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。 ~~~java public class SynchronizedExample { public void func2() { synchronized (SynchronizedExample.class) { for (int i = 0; i < 10; i++) { System.out.print(i + " "); } } } } ~~~ ~~~java public static void main(String[] args) { SynchronizedExample e1 = new SynchronizedExample(); SynchronizedExample e2 = new SynchronizedExample(); ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(() -> e1.func2()); executorService.execute(() -> e2.func2()); } ~~~ ~~~ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 ~~~ **4\. 同步一个静态方法** * 非静态同步函数的锁是：this * 静态的同步函数的锁是：字节码对象 ~~~java public synchronized static void fun() { // ... } ~~~ 作用于整个类。