synchronized原理、偏向锁、轻量级锁、重量级锁知识点整理

末蓝、 2022-11-19 06:27 230阅读 0赞

### synchronized原理： ###

*  ### synchronized的参数是什么意思？ ###

运行结果 k 的最终值不是20000，而是小于 20000

public class IntegerAndLongTest {
        public static Integer k = 0;
        public static void main(String[] args) {
            for(int i=0;i<20;i++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        synchronized (this){
                            System.out.println(this);
                            for(int j=0;j<1000;j++){
                                add();
                                System.out.println(k);
                            }
                        }
                    }
                }).start();
            }
        }
        public static void add(){
            k++;
        }
    }

我们试着打印这个this，发现，this是不断变化的对象

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70][]

synchronized(obj.class)里面的参数表示从哪里获取锁的意思，通俗来说，假设家里面只有一个厕所，那么小明上厕所的时候，小明就从厕所这里获取了锁，其他人无法进入，必须等到小明上完厕所了，锁释放了，其他人才可以进入，就相当于这个obj.class只有一个。如果obj.class是变化的，当小明上公共厕所的时候，于是从厕所获取了锁，其他人自己找别的厕所去获取锁了，然而小明的厕所和别人的厕所不是同一个厕所，也就是不是同一把锁，相当于这个obj.class每进入一个线程获取资源的时候，直接new一把锁给自己，这样就没有加锁的意义了，小明和别人同时干事情，达不到同步的效果。

### 所以要把synchronized的参数this改为Main.class，可以试一试直接把this改为new String() ，也是失去加锁的意义了 ###

*  ### synchronized锁在jdk1.6以后是怎么优化的？ ###

先复习一下对象头的组成

public class ObjectHead {
        public static void main(String[] args) {
            Object obj = new Object();
            System.out.println(obj.hashCode());
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 2][]

引用博文部分内容：https://blog.csdn.net/weixin\_38481963/article/details/88384493

JDK1.6早期，Synchronized是通过对象内部的一个叫做监视器锁（monitor）来实现的，监视器锁本质又是依赖于底层的操作系统的Mutex Lock（互斥锁）来实现的。而操作系统实现线程之间的切换需要从用户态转换到核心态，当无锁的时候，用户态就可以完成任务，加锁过程是要委托操作系统底层老大来完成任务的，这时候切换为内核态，这个成本非常高，状态之间的转换需要相对比较长的时间，这就是为什么Synchronized效率低的原因。因此，这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。

### （1）偏向锁 ###

偏向锁是jdk1.6中引用的优化，加了synchronized锁的时候，如果没有其它线程竞争资源，则不会加锁触发同步，进一步提高程序的性能，这个就是偏向锁的作用。

当我们Object obj = new Object(); 的时候，这个obj在程序运行4秒以后，会由无锁状态升级为持有偏向锁状态。

假设我们的代码是这么写的：

Object obj = new Object();
    synchronized(obj){
        ......
    }

此时没有其它线程竞争，obj处于偏向锁状态，那么它的对象头有个54位的 "当前线程指针" ，我们叫ThreadID吧。如果最先进来的A线程，先进入这个同步块，它会判断 对象头的ThreadID 是不是自己的线程ID，如果为空，那么设置为自己的线程ID，这时候，突然有B线程过来竞争，那么这个obj的对象头的 ThreadID 就会设置为B线程的ID，说明B线程过来抢占资源了，这时候，obj的偏向锁就被撤销，升级为轻量级锁。

### （2）轻量级锁 ###

轻量级锁的本质是CAS，假设A线程先占用了资源，B线程和C线程去抢占，如果抢占失败，那么自旋，再次尝试抢占这把锁，直到抢占成功为止。如果业务耗时过长，可能会导致频繁自旋，如果有过多的线程去竞争这把锁，也可能会导致频繁自旋，而自旋是消耗cpu资源的，所以当业务耗时过长以及多线程竞争太过于激烈的情况下，自旋消耗cpu的代价要比用户态和内核态之间的切换更加大的时候，就会升级为重量级锁。

### （3）重量级锁 ###

重量级锁的加锁和解锁过程，线程要依赖操作系统Mutex Lock互斥锁，好比一个用户级别的线程要委托操作系统老大去做加锁解锁的操作。这适用于线程竞争非常激烈以及业务耗时较长的场景。如果其它线程抢锁失败，那么会被操作系统调度，让线程进入等待队列，该轮到谁抢锁的时候就唤醒谁去抢锁。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70]: /images/20221022/dc448f4dc2454b8d93bd129191241d0d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 1]: /images/20221022/58d25364e9f84329afbcfbb7b7d0f7d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 2]: /images/20221022/fa1cc9c093ed4e4cb9a2611cd4831f11.png