synchronized与锁升级

打灰高手

已于 2023-09-21 23:49:45 修改

阅读量55

点赞数

分类专栏：多线程文章标签： java 开发语言

于 2023-09-20 13:19:52 首次发布

本文链接：https://blog.csdn.net/weixin_46439731/article/details/133074986

版权

多线程专栏收录该内容

9 篇文章 0 订阅

订阅专栏

synchronized

在Java5之前，

为什么每个Java对象都可以作为锁？

在这里插入图片描述

无锁

代码示例：

package multiThreads;

import org.openjdk.jol.info.ClassLayout;

public class SynchronizedTest {
    public static void main(String[] args) {
        Object o = new Object();
        int hashCode = o.hashCode();
        System.out.println("10进制 hashCode:" + hashCode);
        System.out.println("16进制 hashCode:" + Integer.toHexString(hashCode));
        System.out.println("2进制 hashCode:" + Integer.toBinaryString(hashCode));
        System.out.println(ClassLayout.parseInstance(o).toPrintable());

        System.out.println("-------");

    }
}

运行结果：
在这里插入图片描述

偏向锁

偏向锁：单线程竞争。当线程A第一次获取时，通过操作修改Mark Word中的偏向线程Id、偏向模式。如果不存在其他线程竞争，那么线程A将永远不需要进行同步。

为什么需要偏向锁呢？或者说偏向锁为什么会被设计出来？

以下面的案例阐释一下：
假设三个线程卖50张票，代码如下：

package multiThreads;

import java.util.*;
import java.util.concurrent.CountDownLatch;

public class SaleTicketsTest {
    public static void main(String[] args) throws InterruptedException {
        int threadNum = 3;
        CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        TicketsSale sale = new TicketsSale();
        for (int i = 0; i < threadNum; i++) {
            new Thread(() -> {
                sale.sale();
                countDownLatch.countDown();
            }, ""+ i).start();
        }

        countDownLatch.await();
        sale.getAllThreadCount();
        System.out.println("-------------");
    }
}

class TicketsSale {
    private int num = 100;

    Map<Thread, Integer> countMap = new HashMap<>();

    public void sale () {
        while (true) {
            synchronized (this) {
                if (num > 0) {
                    num--;
                    Thread thread = Thread.currentThread();
                    System.out.println(thread.getName() + "售出一张票，现在还剩" + num + "张票");
                    boolean keyExists = countMap.containsKey(thread);
                    if (keyExists) {
                        Integer count = countMap.get(thread);
                        countMap.put(thread, ++count);
                    } else {
                        countMap.put(thread, 1);
                    }
                } else {
                    break;
                }
            }
        }
    }

    public void getAllThreadCount () {
        Set<Map.Entry<Thread, Integer>> entries = countMap.entrySet();
        for (Map.Entry<Thread, Integer> entry : entries) {
            System.out.println(entry.getKey().getName() + "卖出:" + entry.getValue() + "张票");
        }
    }
}

运行结果：
在这里插入图片描述
可以看到，我们设定是三个线程卖一百张票，但是实际上可能一个线程卖了99张票。这种情况下，对于一个同步代码块，如果一直被同一个线程多次访问，那么就可以让此线程在后续访问时自动获取锁。这就是偏向锁。

结论

HotSpot作者发现在多线程情况下，可能会出现多线程竞争，都可以差不多的概率执行同步代码块的情况，也可能出现同步代码基本一直被某一个线程执行的情况下，针对基本一直被某个线程执行的情况，使用了偏向锁，目的就是在只有一个线程执行同步代码的情况下提高性能。
偏向锁会倾向于第一个访问的线程，如果在接下来的运行过程中，该锁没有被其他线程访问，那么持有偏向锁的线程永远不需要触发同步。即偏向锁在没有其他线程竞争的情况下，消除了同步语句，懒得连CAS都不执行了，提高了程序性能。

理论落地

在实际应用运行过程中发现，锁总是同一个线程持有，很少发生竞争，也就是说，锁总是被一个占用他的线程拥有，这个线程就是锁的偏向线程。
那么只需要在锁第一次被拥有的时候，记录下偏向线程ID。这样偏向线程就一直持有者锁（后续这个线程进入和退出这段同步锁的代码块时，不需要再次加锁和解锁）。而是直接去检查锁的MarkWord里面放的是不是自己的线程ID。

如果相等，表示偏向锁是基于当前线程的，就不需要再尝试获取锁了，直到竞争发生时才会释放锁。以后每次同步，检查锁的偏向线程ID与当前线程ID是否一致，如果一致则直接进入同步代码块，无需每次都加锁解锁以及去CAS更新对象头。如果自始至终都是同一个线程使用锁，那么偏向锁几乎没有额外开销，性能极高。如果不等，表示发生了竞争，锁已经不是总是偏向于同一个线程了，这个时候会尝试使用CAS来替换MarkWord里面的线程ID为新线程的ID。

       竞争成功，表示之前的线程不存在了，MarkWord里面的线程ID为新线程的ID，锁不会升级，仍为偏向锁。
竞争失败，这时候可能需要升级为轻量级锁，才能保证线程间公平竞争锁。
       注意，偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程是不会主动释放偏向锁的。
       技术实现：一个synchronized方法被一个线程抢到锁时，那这个方法所在对象就会在其MarkWord中将偏向锁状态修改为1（无锁：0，偏向锁：1）,同时还会占用前54bit位来存储线程指针作为标识。若该线程再次访问同一个synchronized方法时，该线程只需去对象头的MarkWord中去判断一下是否有偏向锁指向本身的ID，无需再次进入Monitor去竞争对象了。
在这里插入图片描述

案例说明

在这里插入图片描述

偏向锁说明

在这里插入图片描述

代码示例：

package multiThreads;

import org.openjdk.jol.info.ClassLayout;

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

同时需要设置虚拟机参数，让偏向锁立刻生效：
在这里插入图片描述
-XX:BiasedLockingStartupDelay=0

运行结果：
在这里插入图片描述
可以看到此时偏向锁标志是1，同步锁标志是01.符合预期。

偏向锁的线程指针什么时候写入？

代码如下：

package multiThreads;

import org.openjdk.jol.info.ClassLayout;

import java.util.concurrent.TimeUnit;

public class BiasedLockTest2 {
    public static void main(String[] args) throws InterruptedException {
        TimeUnit.SECONDS.sleep(5L);
        Object object = new Object();
        System.out.println(ClassLayout.parseInstance(object).toPrintable());
        System.out.println("-----------");
        synchronized (object) {
            System.out.println(ClassLayout.parseInstance(object).toPrintable());
        }
    }
}

运行结果：
在这里插入图片描述
可以看到，两次打印都开启了偏向锁，但是偏向锁对应的线程ID是在执行同步代码块后才写入。

偏向锁升级为轻量级锁

当有第二个线程和第一个线程开始竞争锁，此时锁有可能保留偏向锁，也有可能会升级成轻量级锁，这取决于第二个线程开始竞争锁时，第一个线程执行的时机。
在这里插入图片描述

偏向锁的获取和撤销流程

在这里插入图片描述

轻量级锁

轻量级锁：存在锁竞争，但是任意时刻最多存在一个线程进行竞争，即不存在锁激烈竞争的情况，也就没有线程阻塞。
在这里插入图片描述

代码演示：

package multiThreads;

import org.openjdk.jol.info.ClassLayout;

import java.util.concurrent.TimeUnit;

public class BiasedLockTest3 {
    public static void main(String[] args) throws InterruptedException {
        //记得添加参数 -XX:-UseBiasedLocking  禁用BiasedLocking
        TimeUnit.SECONDS.sleep(5L);
        Object object = new Object();
        new Thread(() ->{
            //已禁用偏向锁，此时是无锁状态
            System.out.println(ClassLayout.parseInstance(object).toPrintable());
            //已禁用偏向锁，同步代码块，此时直接升级为轻量级锁
            synchronized (object) {
                System.out.println(ClassLayout.parseInstance(object).toPrintable());
            }
        }).start();
    }
}

运行结果：
在这里插入图片描述

轻量级锁升级为重量级锁，需要自旋多少次？

Java6之前默认是10次，对应虚拟机参数为 -XX:ProLockSpin=10，或者自旋次数超过CPU核数的一半。Java6之后，是自适应自旋锁，原理如下：
在这里插入图片描述

重量级锁

在这里插入图片描述
代码示例：

package multiThreads;

import org.openjdk.jol.info.ClassLayout;

public class BiasedLockTest4 {
    public static void main(String[] args) {
        Object object = new Object();
        new Thread(() -> {
            synchronized (object) {
                System.out.println(ClassLayout.parseInstance(object).toPrintable());
            }
        }, "a").start();

        new Thread(() -> {
            synchronized (object) {
                System.out.println(ClassLayout.parseInstance(object).toPrintable());
            }
        }, "b").start();
    }
}

运行结果：
在这里插入图片描述

小总结：

1.锁升级后hashCode去哪了？
在这里插入图片描述

当一个对象已经调用过hashCode()后，如果被锁住，那么无法进入偏向锁状态，而是直接进入轻量级锁状态。
代码示例：

package multiThreads;

import org.openjdk.jol.info.ClassLayout;

import java.util.concurrent.TimeUnit;

public class BiasedLockTest2 {
    public static void main(String[] args) throws InterruptedException {
        //TimeUnit.SECONDS.sleep(5L);
        Object object = new Object();
        System.out.println(ClassLayout.parseInstance(object).toPrintable());
        System.out.println("-----------");
        object.hashCode();
        synchronized (object) {
            System.out.println(ClassLayout.parseInstance(object).toPrintable());
        }
    }
}

运行结果：
在这里插入图片描述
如果一个对象已经是偏向锁了，此时调用其hashCode()，则会导致偏向锁直接升级为重量级锁。
代码如下：

package multiThreads;

import org.openjdk.jol.info.ClassLayout;

import java.util.concurrent.TimeUnit;

public class BiasedLockTest2 {
    public static void main(String[] args) throws InterruptedException {
        TimeUnit.SECONDS.sleep(5L);
        Object object = new Object();
        synchronized (object) {
            System.out.println(ClassLayout.parseInstance(object).toPrintable());
            object.hashCode();
            System.out.println(ClassLayout.parseInstance(object).toPrintable());
        }
    }
}

运行结果：
在这里插入图片描述

各种锁的优缺点

在这里插入图片描述

JIT编译器对锁的优化

JIT:just in time Compiler，即时编译器。

锁消除

package multiThreads;

public class LockClear {
    
    //由于m1()的锁在每次调用的时候都会new一个新的对象，
    //相当于每次调用都持有不同的锁，在多线程情况下无法达到上锁的目的
    //JIT编译器会忽视synchronized代码声明，相当于消除了写得不合规的锁
    //这就是 JIT的锁消除
    public void m1() {
        Object object = new Object();
        synchronized (object) {
            System.out.println("lock clear");
        }
    }

    public static void main(String[] args) {
        LockClear lockClear = new LockClear();
        for (int i = 0; i < 10; i++) {
            new Thread(lockClear::m1).start();
        }
    }
}

锁粗化

package multiThreads;

public class LockRoughen {


    public static void main(String[] args) {
        new Thread(() -> {
            Object obj = new Object();
            synchronized (obj) {
                System.out.println("1111");
            }
            synchronized (obj) {
                System.out.println("2222");
            }
            synchronized (obj) {
                System.out.println("3333");
            }
            //JIT编译器会优化为如下代码
            synchronized (obj) {
                System.out.println("1111");
                System.out.println("2222");
                System.out.println("3333");
            }

        }).start();
    }
}