八锁现象带你了解 synchronized 到底是锁什么？

最新推荐文章于 2023-09-25 00:32:02 发布
最新推荐文章于 2023-09-25 00:32:02 发布
阅读量405 收藏 2
点赞数 1
分类专栏： java基础 文章标签： synchronized java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44613591/article/details/109567727
版权

什么是八锁现象？

八锁现象就是加锁的地方不一样，像加在普通方法，静态方法等，可以帮我们搞懂锁锁住的东西是什么。

  • 第一种：标准情况下，两个线程先打印 发短信还是 打电话？
//标准情况下，两个线程先打印 发短信还是 打电话？ 
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

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

class Phone{

    public synchronized void sendSms(){
        System.out.println("发短信");
    }

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

}

谁先调用谁先执行

原因：普通方法 sendSms 和 call 锁的是调用对象，每个对象都会有自己的一把锁。

  • 第二种：sendSms延迟4秒，两个线程先打印 发短信还是 打电话？
//
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{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

发短信
打电话

原因：由于锁的是对象，而主线程会先睡一秒，因此是先调用 sendSms ，等到 sendSms 执行完释放锁后才执行 call

  • 第三种：增加了一个普通方法后！先执行发短信还是Hello？
    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.hello();
        },"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");
    }
}

hello
发短信

原因：hello没有加锁，而 sendSms 睡眠了四秒，所以在调用 hello 时会直接执行，所以 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 class Test3  {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();

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

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

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

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

    // synchronized 锁的对象是方法的调用者！
    // static 静态方法
    // 类一加载就有了！锁的是Class
    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类也有它自己的锁，静态方法锁的就是这把锁，同一个类的不同静态方法共享这个锁，在调用时，锁的是class的锁，因此谁先拿到谁先执行

  • 第六种：两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？
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 锁的对象是方法的调用者！
    // static 静态方法
    // 类一加载就有了！锁的是Class
    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文件会有自己的锁，同一个类的不同静态方法共享这个锁，所以不同对象在调用时也是谁先拿到谁先执行。

  • 第七种：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(()->{
            phone1.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("打电话");
    }

}

打电话
发短信

原因：class 自己有一把锁，而对象也有自己的一把锁，他们之间互不干扰，A线程调用的时class文件的锁，而B线程锁住的是phone1对象，互不干扰，所以先输出打电话，再输出发短信

  • 第八种：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("打电话");
    }

}

打电话
发短信

原因：A线程调用的时class文件的锁，而B线程锁住的是phone2对象，互不干扰，所以先输出打电话，再输出发短信

总结

首先，每个对象以及每个class文件都会有自己的锁（实质是标志位），如果调用的方法是非静态方法，那么jvm会锁住调用的对象，但是如果是静态方法则会锁住class的锁，不同对象都会有自己的锁，他们之间互不干扰，而不同对象又共享 class 的锁。

碌碌无为_心不在烟
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
synchronized锁的是什么？
03-11 1166
https://www.cnblogs.com/keita/p/8583281.html synchronized是java中并发编程最重要的关键字之一。如果没搞清楚synchronized锁的是什么，可能导致用了没效果，没控制住并发访问 synchronized常用的方式有以下四种 public class SyncTest{ publicsynchronizedvoi...
Java synchronized关键字的用法以及锁的等级：方法锁、对象锁、类锁
杨春建的博客
01-15 7035
原文地址：http://blog.csdn.net/le_le_name/article/details/52348314 首先说明一下：方法锁和对象锁说的是一个东西，即只有方法锁或对象锁 和类锁两种锁 在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，下面看看这个关键字的用法。 因为synchronized关键字涉及到锁的概
Java synchronized到底锁住的是什么？
weixin_34242331的博客
07-25 181
使用环境：多线程java程序中。 作用：在多线程的环境下，控制synchronized代码段不被多个线程同时执行。synchronized既可以加在一段代码上，也可以加在方法上。 使用：synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。 通过以下两个案例说明： //包含了synchronized ...
synchronize的8锁现象带你彻底了解
烟花易冷
09-12 488
关于锁的8个问题前言例子1例子2例子3例子4 前言 synchronize的8锁现象，其实就是利用锁的8种应用场景的代码，带你彻底搞懂： synchronized 锁的对象是方法的调用者 下面我们开始看例子 例子1 public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); //这里注意不是先调用 phone.sendSms()，而是因为锁的存在
synchronized 8锁的现象
最新发布
09-25 43
new this 具体的一个手机static class 唯一的一个模板如果锁的对象是同一个，那么一个方法执行前需要等待另一个方法释放锁，如果锁的对象不是同一个，那么两个方法执行不需要等待彼此释放锁。当synchronized修饰实例方法，锁的对象是方法的实例。这种情况下创建出了一个实例，锁的是一个实例，用这个对象调用两个同步实例方法，它们共用的是一把锁。创建出两个实例，锁的对象是两个实例，分别调用两个同步方法，它们用的是两个不同的锁。当修饰静态方法，锁的对象是当前类。
JUC并发编程 常用锁 三个辅助类的使用
Andrew0219的博客
08-12 163
1
【程序员必知必会】线程8锁现象：让你彻底理解synchronized到底锁了什么
qq_35754976的博客
12-21 666
我们都知道synchronized实现同步具体表现为以下三种形式： 1. 对于普通同步方法，锁是当前实例对象 2. 对于静态同步方法，锁是当前类的Class对象 3. 对于同步方法块，锁是synchronized括号里配置的对象 但是一到真实场景中，就难以判断synchronized锁的是谁了。 那么本篇文章，引用了著名的”8锁现象“，每个问题都会附一套代码，来帮助你彻底理解synchronized到底锁了什么，让你不论在多么复杂的场景下，都可以正确地判断锁的是谁。
synchronized详解及偏向锁、轻量级锁、自旋锁、重量级锁
dekulugu的博客
10-05 822
要了解synchronized的原理及应用场景就得先了解并发编程是什么，对并发编程不了解的话可以看看这篇博客：https://blog.csdn.net/dekulugu/article/details/108754623 一、synchronized的基本使用 为什么要使用synchronized？ 在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。synchronized关键字可以保证在同一时刻，只有一个线程可以执行某个方法或代码块，同时synchronized
Synchronized你以为你真的懂？
lyztyycode的博客
04-09 2933
synchronized是个啥 在多线程并发编程中synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE 1.6对 synchronized进行了各种优化之后，有些情况下它就并不那么重了，Java SE 1.6中为了减少获得锁和释放锁带来的 性能消耗而引入的偏向锁和轻量级锁，以及锁的存储结构和升级过程。 如果你对于synchronized的基础知识和用法...
教你完全理解ReentrantLock重入锁
10-16
ReentrantLock是Java中的一种高级锁，它实现了Lock接口，提供比synchronized更精细的锁控制。ReentrantLock支持重入性，意味着一个线程可以多次进入同一段被该锁保护的代码，只要这个线程还没有释放这个锁。这种特性...
Synchronized八锁
EmpressL的博客
08-13 188
标准访问，先打印短信还是邮件标准访问，先打印短信还是邮件说明：这种情况锁的对象是this,既phone实例停4秒在短信方法内，先打印短信还是邮件说明：这种情况锁的对象是this,既phone实例新增普通的hello方法，是先打短信还是hello说明：getHello方法是普通方法所以它先执行现在有两部手机，先打印短信还是邮件。
synchronized锁——8锁
weixin_34413065的博客
04-08 151
前言 多线程是Java面试中最喜欢问的问题之一，有一篇公众号推文内容很详细，推荐看看 但凡面试官考“多线程”，一定会问这10个问题！ 本文中仅对synchronized关键字的加锁进行一定分析 一、标准情况访问 按照普通的情况访问同步方法，查看输出 1 class Phone { 2 public synchronized void getIOS() thro...
第二章 多线程入门之高级
黑魔仙小月的博客
05-13 795
第二章 多线程入门之高级 第一章 多线程入门之概念 第二章 多线程入门之基础 第二章 多线程入门之高级 文章目录第二章 多线程入门之高级前言一、引入共享变量1.1 小故事正常情况下，小明使用完小红使用，最后的res=0没有任何问题。如下图所示： ![在这里插入图片描述](https://img-blog.csdnimg.cn/e0f1ebc598514544bc7d6db2b26a88b5.png) 可是有一天小明将res=1之后病倒了，老王看小明病倒了实在不能工作了就告诉小明那你先记着这个res的结果，
synchronized八锁现象理解
lczcxyit的博客
04-19 1845
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
Java并发——Synchronized关键字和锁升级，详细分析偏向锁和轻量级锁的升级
qq_36777191的博客
02-02 268
目录 一、Synchronized使用场景 二、Synchronized实现原理 三、锁的优化 1、锁升级 2、锁粗化 3、锁消除 一、Synchronized使用场景 Synchronized是一个同步关键字，在某些多线程场景下，如果不进行同步会导致数据不安全，而Synchronized关键字就是用于代码同步。什么情况下会数据不安全呢，要满足两个条件：一是数据共享（临界资源），二是多线程同时访问并改变该数据。 例如： public class AccountingSync imple
8锁现象
c19990515的博客
02-09 150
5、8锁现象 如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！ /** * 8锁，就是关于锁的8个问题 * 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 * 2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 */ public class Test1 { public static void main(String[] args) { Phone phone = new Phone();
8锁 现象
DaDaguai001的博客
07-01 401
以下都是为了更好的解释锁。 1 标准访问，先打印邮件还是先发送短信 解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。 class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ //TimeUnit.SECONDS.sleep(3);//新的写法 //Threa..
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1522
synchronized关键字到底锁的是谁？
synchronized的线程八锁问题
蒋大钊的博客
02-04 521
synchronized线程八锁问题可以很好地辨析学习synchronized锁的是哪个对象。
理解数据库锁：为何开发者必修课
本文首先解释了锁的基本概念，指出在计算机中，锁是用来控制对共享资源并发访问的机制，如Java中的Lock和synchronized，以及数据库中的特定锁类型。 1.1 数据库锁的作用 数据库锁在数据库管理系统中扮演着协调多...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值