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

最新推荐文章于 2023-09-25 00:32:02 发布
最新推荐文章于 2023-09-25 00:32:02 发布
阅读量406 收藏 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 的锁。

碌碌无为_心不在烟
关注
专栏目录
synchronized锁的是什么？
03-11 1171
https://www.cnblogs.com/keita/p/8583281.html synchronized是java中并发编程最重要的关键字之一。如果没搞清楚synchronized锁的是什么，可能导致用了没效果，没控制住并发访问 synchronized常用的方式有以下四种 public class SyncTest{ publicsynchronizedvoi...
Java synchronized关键字的用法以及锁的等级：方法锁、对象锁、类锁
杨春建的博客
01-15 7040
原文地址：http://blog.csdn.net/le_le_name/article/details/52348314 首先说明一下：方法锁和对象锁说的是一个东西，即只有方法锁或对象锁 和类锁两种锁 在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，下面看看这个关键字的用法。 因为synchronized关键字涉及到锁的概
Java synchronized到底锁住的是什么？
weixin_34242331的博客
07-25 182
使用环境：多线程java程序中。 作用：在多线程的环境下，控制synchronized代码段不被多个线程同时执行。synchronized既可以加在一段代码上，也可以加在方法上。 使用：synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。 通过以下两个案例说明： //包含了synchronized ...
synchronize的8锁现象带你彻底了解
烟花易冷
09-12 491
关于锁的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 44
new this 具体的一个手机static class 唯一的一个模板如果锁的对象是同一个，那么一个方法执行前需要等待另一个方法释放锁，如果锁的对象不是同一个，那么两个方法执行不需要等待彼此释放锁。当synchronized修饰实例方法，锁的对象是方法的实例。这种情况下创建出了一个实例，锁的是一个实例，用这个对象调用两个同步实例方法，它们共用的是一把锁。创建出两个实例，锁的对象是两个实例，分别调用两个同步方法，它们用的是两个不同的锁。当修饰静态方法，锁的对象是当前类。
JUC并发编程 常用锁 三个辅助类的使用
Andrew0219的博客
08-12 164
1
【程序员必知必会】线程8锁现象：让你彻底理解synchronized到底锁了什么
qq_35754976的博客
12-21 667
我们都知道synchronized实现同步具体表现为以下三种形式： 1. 对于普通同步方法，锁是当前实例对象 2. 对于静态同步方法，锁是当前类的Class对象 3. 对于同步方法块，锁是synchronized括号里配置的对象 但是一到真实场景中，就难以判断synchronized锁的是谁了。 那么本篇文章，引用了著名的”8锁现象“，每个问题都会附一套代码，来帮助你彻底理解synchronized到底锁了什么，让你不论在多么复杂的场景下，都可以正确地判断锁的是谁。
Synchronized 同步锁详解
qq_56263094的博客
07-21 1510
Synchronized是JAVA的关键字，是基于JVM层面的独占式的悲观锁，同时也属于可重入锁经常来用于解决多个线程之间访问访问资源的同步性，保证在同一时刻只有一个线程访问这个资源。
synchronized详解及偏向锁、轻量级锁、自旋锁、重量级锁
dekulugu的博客
10-05 825
要了解synchronized的原理及应用场景就得先了解并发编程是什么，对并发编程不了解的话可以看看这篇博客：https://blog.csdn.net/dekulugu/article/details/108754623 一、synchronized的基本使用 为什么要使用synchronized？ 在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。synchronized关键字可以保证在同一时刻，只有一个线程可以执行某个方法或代码块，同时synchronized
Synchronized你以为你真的懂？
lyztyycode的博客
04-09 2935
synchronized是个啥 在多线程并发编程中synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE 1.6对 synchronized进行了各种优化之后，有些情况下它就并不那么重了，Java SE 1.6中为了减少获得锁和释放锁带来的 性能消耗而引入的偏向锁和轻量级锁，以及锁的存储结构和升级过程。 如果你对于synchronized的基础知识和用法...
Synchronized八锁
EmpressL的博客
08-13 190
标准访问，先打印短信还是邮件标准访问，先打印短信还是邮件说明：这种情况锁的对象是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 796
第二章 多线程入门之高级 第一章 多线程入门之概念 第二章 多线程入门之基础 第二章 多线程入门之高级 文章目录第二章 多线程入门之高级前言一、引入共享变量1.1 小故事正常情况下，小明使用完小红使用，最后的res=0没有任何问题。如下图所示： ![在这里插入图片描述](https://img-blog.csdnimg.cn/e0f1ebc598514544bc7d6db2b26a88b5.png) 可是有一天小明将res=1之后病倒了，老王看小明病倒了实在不能工作了就告诉小明那你先记着这个res的结果，
synchronized八锁现象理解
lczcxyit的博客
04-19 1853
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
Java并发——Synchronized关键字和锁升级，详细分析偏向锁和轻量级锁的升级
qq_36777191的博客
02-02 269
目录 一、Synchronized使用场景 二、Synchronized实现原理 三、锁的优化 1、锁升级 2、锁粗化 3、锁消除 一、Synchronized使用场景 Synchronized是一个同步关键字，在某些多线程场景下，如果不进行同步会导致数据不安全，而Synchronized关键字就是用于代码同步。什么情况下会数据不安全呢，要满足两个条件：一是数据共享（临界资源），二是多线程同时访问并改变该数据。 例如： public class AccountingSync imple
8锁现象
c19990515的博客
02-09 152
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 402
以下都是为了更好的解释锁。 1 标准访问，先打印邮件还是先发送短信 解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。 class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ //TimeUnit.SECONDS.sleep(3);//新的写法 //Threa..
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1531
synchronized关键字到底锁的是谁？
synchronized的线程八锁问题
蒋大钊的博客
02-04 522
synchronized线程八锁问题可以很好地辨析学习synchronized锁的是哪个对象。
理解数据库锁：为何开发者必修课
本文首先解释了锁的基本概念，指出在计算机中，锁是用来控制对共享资源并发访问的机制，如Java中的Lock和synchronized，以及数据库中的特定锁类型。 1.1 数据库锁的作用 数据库锁在数据库管理系统中扮演着协调多...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值