【JUC中的 “8锁现象” 】 —— 每天一点小知识-Toy模板网

这篇具有很好参考价值的文章主要介绍了【JUC中的 “8锁现象” 】 —— 每天一点小知识。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

【JUC中的 “8锁现象” 】 —— 每天一点小知识

💧 $\color{#FF1493}{JUC中的 “8锁现象” }$ 💧

🌷 仰望天空，妳我亦是行人.✨
🦄 个人主页——微风撞见云的博客🎐
🐳 《数据结构与算法》专栏的文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺
💧 《Java学习笔记》专栏的文章是本人在Java学习中总结的一些知识点~ 💐
🥣 《每天一点小知识》专栏的文章可以丰富你的知识库，滴水成河~ 🌊
🪁 希望本文能够给读者带来一定的帮助~🌸文章粗浅，敬请批评指正！🐥

JUC中的8锁现象

💧在Java并发编程中，锁是一种关键的同步机制，用于控制多个线程对共享资源的访问。然而，在某些情况下，使用锁可能会引发性能问题，其中一个典型例子就是JUC中的8锁现象，也被称为锁粗化。

🌊什么是8锁现象？

💧8锁现象指的是在多线程环境下，当多个线程同时对同一个对象的不同锁进行操作时，可能导致性能下降的现象。每个对象都有一个与之关联的监视器锁，也称为内置锁或互斥锁。当一个线程试图进入一个同步代码块时，它需要先获得该对象的监视器锁。如果锁已经被另一个线程获得，则线程将被阻塞，直到锁被释放。

💧在并发编程中，当多个线程竞争同一个对象的不同锁时，会产生线程切换和竞争的开销，从而导致性能下降。这是因为每个对象都有自己的锁，并且每个锁都有自己的计数器和等待队列。当多个线程同时竞争同一个对象上的不同锁时，会频繁地发生线程切换，造成性能瓶颈。

🌊为什么会产生8锁现象？

💧8锁现象的产生与Java虚拟机（JVM）对锁的优化机制有关。在某些情况下，JVM会尝试对连续的同步块进行优化，将多个锁的获取和释放合并为一个更大的同步块，从而减少线程之间的竞争和切换。这个过程称为锁粗化。

💧然而，当多个线程对同一个对象的不同锁进行操作时，JVM无法进行锁粗化优化。每个锁都需要独立获取和释放，导致频繁的线程切换和竞争，从而降低并发性能。

🌊如何避免8锁现象？

💧为了避免8锁现象带来的性能问题，可以尝试以下优化策略：

合并锁： 如果多个锁操作的是同一个对象，可以考虑将它们合并成一个锁。通过合并相同对象的多个锁，减少锁的竞争，从而提高程序的并发性能。这需要仔细设计代码结构，确保多个锁的操作在合并后仍然保持独立性和正确性。
细粒度锁： 通过将对象分解成更小的粒度，可以减小锁的粒度。如果可能，可以将一个大的共享对象拆分为多个小的独立对象，每个对象使用自己的锁。这样可以使得多个线程可以同时访问不同的锁，减少竞争和线程切换的开销。细粒度锁同样需要对代码进行仔细的分析和设计，以确保线程安全和正确性。
使用并发集合类： Java提供了一些高效的并发集合类，如ConcurrentHashMap和ConcurrentLinkedQueue。这些并发集合类内部实现了细粒度的并发控制机制，可以减少对锁的依赖，提高并发性能。通过使用这些并发集合类，可以避免手动管理锁带来的复杂性，同时保证线程安全和高效的并发访问。
使用并发框架： JUC（Java Util Concurrent）中提供了一些高级的并发编程框架，如线程池和Future模式。通过使用这些框架，可以更好地管理线程和任务，提高并发性能和可扩展性。线程池可以重用线程，减少线程创建和销毁的开销；Future模式可以异步执行任务并获取结果，提高程序的并发度。

需要注意的是，优化锁的使用需要根据具体的业务场景和代码结构进行分析和调整。过度优化可能会引入新的问题或复杂性。在进行优化之前，建议进行性能测试和基准测试，以确保优化策略的有效性和稳定性。

🌊狂神谈 “8锁现象”

8锁，就是关于锁的8个问题。如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！

下面通过 4 个案例来直观的感受一下 “8锁现象” ↓

案例一（先打印“发短信”）

标准情况下，两个线程先打印发短信还是打电话？ 1/发短信 2/打电话。
sendSms延迟4秒，两个线程先打印发短信还是打电话？ 1/发短信 2/打电话。

public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}

class Phone{

    // synchronized 锁的对象是方法的调用者！、
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

}

💧案例一总结：synchronized 锁的对象是方法的调用者，两个方法用的是同一个锁，谁先拿到谁执行。

案例二（先打印“打电话”）

增加了一个普通方法后！先执行发短信还是Hello？普通方法。
两个对象，两个同步方法，发短信还是打电话？ // 打电话

public class Test2  {
    public static void main(String[] args) {
        // 两个对象，两个调用者，两把锁！
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone2{

    // synchronized 锁的对象是方法的调用者！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

    // 这里没有锁！不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }

}

💧案例二总结：synchronized 锁的对象是方法的调用者，hello() 没有锁！不是同步方法，所以不受锁的影响。

案例三（先打印“发短信”）

增加两个静态的同步方法，只有一个对象，先打印发短信？打电话？
两个对象！增加两个静态的同步方法，先打印发短信？打电话？

public class Test3  {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

// Phone3唯一的一个 Class 对象
class Phone3{

    // synchronized 锁的对象是方法的调用者！
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }


}

💧案例三总结：两个对象的Class类模板只有一个。static 静态方法在类一加载就有了！锁的是Class。

案例四（先打印“打电话”）

1个静态的同步方法，1个普通的同步方法，一个对象，先打印发短信？打电话？
1个静态的同步方法，1个普通的同步方法，两个对象，先打印发短信？打电话？

public class Test4  {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

// Phone3唯一的一个 Class 对象
class Phone4{

    // 静态的同步方法 锁的是 Class 类模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    // 普通的同步方法  锁的调用者
    public synchronized void call(){
        System.out.println("打电话");
    }

}