JUC-八锁现象

八锁现象就是关于锁的八的问题，通过解析这八个问题的答案与原因从而深入理解锁

下面通过一些简单的实例来进行解析

现在有实体类Phone如下：

class Phone{
    public synchronized void sendSms(){
        System.out.println("发短信");
    }
    public synchronized void sendCall(){
        System.out.println("打电话");
    }
}

类中有两个方法，分别加了synchronized锁

问题一：现在通过以下方法创建两个线程分别调用Phone类的两个方法，问打印结果

Phone phone = new Phone();
new Thread(phone::sendSms,"A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(phone::sendCall,"B").start();

问题二：当Phone类做出如下修改后，打印结果如何？

public synchronized void sendSms(){
    try {
        TimeUnit.SECONDS.sleep(4);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    System.out.println("发短信");
}

问题一打印结果为：先执行发短信，1秒后执行打电话

问题二打印结果为：先执行发短信，1秒后执行打电话

原因：synchronized锁的是phone这个对象，而不是方法，当phone对象在线程A中调用sendSms方法时，线程B需要等待线程A释放锁才能继续执行。

问题三：在Phone类中增加一个普通方法，并且线程B调用普通方法，问打印结果

class Phone{
    public synchronized void sendSms(){
        System.out.println("发短信");
    }
    public synchronized void sendCall(){
        System.out.println("打电话");
    }
}

Phone phone = new Phone();
new Thread(phone::sendSms,"A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(phone::sendHello,"B").start();

结果：1秒后打印hello，4秒后打印发短信

原因：hello方法并没有加锁，所以线程B在使用phone对象时并不受锁的影响

问题四：当创建两个对象，分别调用加锁的方法时，打印结果如何

Phone phone = new Phone();
Phone phone1 = new Phone();
new Thread(phone::sendSms,"A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(phone1::sendCall,"B").start();

结果：1秒后打印打电话，3秒后打印发短信

原因：锁的是对象，当对象不同时，互相不会产生影响

问题五：将发短信与打电话方法改为static方法，使用同一个对象进行调用，打印结果如何

问题六：将发短信与打电话方法改为static方法，使用同两个对象进行调用，打印结果如何

class Phone{
    public static synchronized void sendSms(){
        System.out.println("发短信");
    }
    public static synchronized void sendCall(){
        System.out.println("打电话");
    }
}

Phone phone = new Phone();
new Thread(phone::sendSms,"A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(phone::sendHello,"B").start();

问题五结果：先打印发短信，后打印打电话

问题六结果：先打印发短信，后打印打电话

原因：static方法是静态方法，类一加载就有了，所以synchronized锁的是class模板，而不是对象，所以不管是创建几个对象，只要是通过该class模板实例的对象，都会受到锁的影响

问题七：对Phone类进行如下改造：一个静态同步方法，一个普通同步方法，使用同一个对象，问打印顺序

问题八：对Phone类进行如下改造：一个静态同步方法，一个普通同步方法，使用同两个对象，问打印顺序

class Phone{
    // 静态同步方法
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    // 普通同步方法
    public synchronized void sendCall(){
        System.out.println("打电话");
    }
}

问题五结果：先打印打电话，再打印发短信

问题六结果：先打印打电话，再打印发短信

原因：静态同步方法锁的是class类模板，普通同步方法锁的是对象，所以不管是不是同一个对象进行调用，它们之间不会产生影响

小结： 锁的作用是在方法的调用者身上，普通同步方法锁的是实例化出来的对象，而静态同步方法锁的是class类模板

PS. 本文内容是通过学习B站UP主遇见狂神说的【狂神说Java】JUC并发编程最新版通俗易懂视频整理而出，如果想要通过视频学习可以去原文地址观看视频：https://www.bilibili.com/video/BV1B7411L7tE?p=10&vd_source=65254bb63a2bf425df392a7196e83ecd

---

👍 欢迎前往博客主页查看更多内容

👍 如果觉得不错，期待您的点赞、收藏、评论、关注

👍 ​ 如有错误欢迎指正！