八锁的现象与八锁的解释

最新推荐文章于 2024-06-14 10:13:49 发布
最新推荐文章于 2024-06-14 10:13:49 发布
阅读量156 收藏
点赞数 1
分类专栏： juc高并发编程 文章标签： jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45541846/article/details/126517735
版权

synchronized 锁的是调用这个方法的对象对象，也就是同一时间段不可能有两个线程同时进到这个资源类，同一时间段，只允许有一个线程访问资源类里面的其中一个synchronized 方法！
T1：1.标准访问，请问先打印邮件还是短信？

代码：

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "A").start();
        Thread.sleep(100);
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

class Phone {
    public synchronized void sendEmail() throws Exception {
        System.out.println("----sendEmail");
    }

    public synchronized void sendSMS() throws Exception {
        System.out.println("----sendSMS");
    }
}

结果：不一定，看cpu的调度，被 synchronized 修饰的方式，锁的对象是方法的调用者，因为这两个方法锁的是同一个对象，所以先调用的先执行。

T2：邮件方法暂停4s，请问先打印邮件还是短信？
代码如下：

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "A").start();
        Thread.sleep(100);
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

class Phone {
    public synchronized void sendEmail() throws Exception {
        Thread.sleep(4000);
        System.out.println("----sendEmail");
    }

    public synchronized void sendSMS() throws Exception {
        System.out.println("----sendSMS");
    }
}

结果：不一定的，与上题一样的
综合T1，T2：
结论：一个对象里面如果有多个synchronized 方法，某一时刻内，只要有一个线程去调用synchronized 方法了，那么其他的线程只能够等待，换句话说，某一时刻只能够有一个线程去访问这些synchronized方法，锁的是当前对象this，被锁定后，其他的同一个对象调用都不能进入到其他synchronized 方法

T3：新增一个普通方法hello()，请问先打印邮件还是hello？ 先hello
代码如下：

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "A").start();
        Thread.sleep(100);
        new Thread(() -> {
            try {
//                phone.sendSMS();
                phone.hello();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

class Phone {
    public synchronized void sendEmail() throws Exception {
        Thread.sleep(4000);
        System.out.println("----sendEmail");
    }

    public synchronized void sendSMS() throws Exception {
        System.out.println("----sendSMS");
    }

    public void hello() {
        System.out.println("----hello");

    }
}

结果：结果是先打印hello，其次4s后再sendEmail，因为hello没有被synchronized 修饰。
结论：普通方法和同步锁无关。

T4：两部手机，请问先打印邮件还是短信？
代码如下：

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "A").start();
        Thread.sleep(100);
        new Thread(() -> {
            try {
//                phone.sendSMS();
//                phone.hello();
                phone1.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

class Phone {
    public synchronized void sendEmail() throws Exception {
        Thread.sleep(4000);
        System.out.println("----sendEmail");
    }

    public synchronized void sendSMS() throws Exception {
        System.out.println("----sendSMS");
    }

    public void hello() {
        System.out.println("----hello");
    }
}

结果：先打印的phone1的sendSMS，4s后再打印phone的sendemail，因为资源对象是不同的。
结论：两个对象，就不是同一把锁了。

T5：两个静态同步方法,同一部手机，请问先打印邮件还是短信？

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "A").start();
        Thread.sleep(100);
        new Thread(() -> {
            try {
                phone.sendSMS();
//                phone.hello();
//                phone1.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

class Phone {
    public static synchronized void sendEmail() throws Exception {
        Thread.sleep(4000);
        System.out.println("----sendEmail");
    }

    public static synchronized void sendSMS() throws Exception {
        System.out.println("----sendSMS");
    }

    public void hello() {
        System.out.println("----hello");
    }
}

结果：4s过后先打印sendEmail，接着打印sendSMS。

T6:由上一题的一部手机换成两部手机，请问先打印邮件还是短信？
代码如下：

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "A").start();
        Thread.sleep(100);
        new Thread(() -> {
            try {
//                phone.sendSMS();
//                phone.hello();
                phone1.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

class Phone {
    public static synchronized void sendEmail() throws Exception {
        Thread.sleep(4000);
        System.out.println("----sendEmail");
    }

    public static synchronized void sendSMS() throws Exception {
        System.out.println("----sendSMS");
    }

    public void hello() {
        System.out.println("----hello");
    }
}

结果：4s过后先打印sendEmail，接着打印sendSMS。
综合T5,T6：
结论：此时锁的不是对象了，而是类！即锁的是phone.class！锁的是模板，Phone phone=new Phone() 锁的就是这个Phone。因为phone和phone1都是Phone的实例对象，而锁的是Phone，所以说，当phone正在执行的时候，phone1就得等着，因为锁的是模板。

T7：1个普通同步方法，1个静态同步方法，1部手机，请问先打印邮件还是短信？
代码如下：

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
//        Phone phone1 = new Phone();
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "A").start();
        Thread.sleep(100);
        new Thread(() -> {
            try {
                phone.sendSMS();
//                phone.hello();
//                phone1.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

class Phone {
    public static synchronized void sendEmail() throws Exception {
        Thread.sleep(4000);
        System.out.println("----sendEmail");
    }

    public  synchronized void sendSMS() throws Exception {
        System.out.println("----sendSMS");
    }

    public void hello() {
        System.out.println("----hello");
    }
}

结果：先打印的sendSMS，接着4s后打印的sendEmail。原因：因为sendEmail锁的是模板的（加了static），sendSMS锁的是当前调用的对象但也属于Phone 类的对象，所以被静态同步方法锁住。

T8：1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？
代码如下：

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "A").start();

        new Thread(() -> {
            try {
                phone1.sendSMS();
//                phone.hello();
//                phone1.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

class Phone {
    public static synchronized void sendEmail() throws Exception {
        Thread.sleep(4000);
        System.out.println("----sendEmail");
    }

    public  synchronized void sendSMS() throws Exception {
        System.out.println("----sendSMS");
    }

    public void hello() {
        System.out.println("----hello");
    }
}

结果：同T7一样，先打印的sendSMS，接着4s后打印的sendEmail。原因：因为sendEmail锁的是模板的（加了static），sendSMS锁的是当前调用的对象但也属于Phone 类的对象，所以被静态同步方法锁住。

总结：
synchronized实现同步基础：
java中的每一个对象都可以作为锁。
具体的表现形式有下面的三种：
1：对于普通方法而言，锁是当前实例对象（this）（当前调用该方法的对象）。
2：对于静态同步方法，锁是当前类的class对象。
3：对于同步方法块而言，锁是synchronized括号里配置的对象（当前调用该方法块的对象）。
当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。
也就是说当一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁。如果别的实例对象的非静态同步方法和和该实例对象的非静态同步方法用的是不同的锁，那么就不用等待该实例对象已获取的锁的非静态同步方法释放锁，直接获取他们自己的锁。
对象锁和类锁（this/class）是两个不同的对象，所以静态同步方法和非静态同步方法之间是不会有竞争条件的。但一旦静态方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。

编程老师傅
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程八锁是什么意思？
bieliwotaijin的博客
06-07 3300
线程八锁 据说是平常工作中常见的情况，线程八锁的重点就是： ① 非静态方法的默认锁是this 静态方法的默认锁是class ②某一时刻内，只能有一个线程有锁，无论几个方法 打个比方 我就不举八个例子了，举几个重点例子给大家看看： public class ThreadEightLock { public static void main(String[] args) { thread t = new thread(); thread t2 = new thread(
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1383
synchronized关键字到底锁的是谁？
JUC-八锁现象
菜鸟程序员的成长之路
11-21 1384
JUC 八锁现象 Java并发编程
synchronized八锁现象理解
lczcxyit的博客
04-19 1813
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
Java中的八种锁
chou_out_man的博客
11-16 1455
Java中的锁 java中所得分类 公平锁/非公平锁 可重入锁 独享锁/共享锁 互斥锁/读写锁 乐观锁/悲观锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 上面这些分类并不全是指所得状态 ， 有的指锁的特性 ， 有的指锁的设计。 一、公平锁/非公平锁 公平锁是指多个线程按照申请所得顺序来获取锁。 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序， 有可能后申请锁的线程 ， 先获取锁 。 有可
力学中的自锁现象及应用
05-27
力学中的自锁现象及应用
中华轿车中控门锁自动闭锁故障现象诊断与排除
01-18
 故障诊断与排除：根据上述故障现象，经分析认为，故障的原因有：①线路有问题；②相关的配件I作不可靠。 经分析，怀疑左右前门中的一个或两个三位开关有故障，产生错误信号给中央控制模块。 于是采用隔断法测试...
奇瑞A520轿车中控门锁会自动开锁故障现象诊断与排除
01-18
故障现象：2006年产的奇瑞A520轿车，中控门锁会自动开锁。 故障诊断与排除：进行基本检查，遥控器能正常操作。用故障检测仪进行检测，显示无故障。从电路图得知，该车4门闭锁器是受ISU（智能开关模块）控制的，其上...
汽车电子中的中华轿车中控门锁自动闭锁故障现象诊断与排除
11-14
 故障诊断与排除：根据上述故障现象，经分析认为，故障的原因有：①线路有问题；②相关的配件I作不可靠。 经分析，怀疑左右前门中的一个或两个三位开关有故障，产生错误信号给中央控制模块。 于是采用隔断法测试...
广本雅阁2.4L轿车门锁不工作故障现象诊断与排除
01-18
 故障诊断与排除：接车后进行试车，按主钥匙上的遥控器“Lock”键，4个车门上锁；按“Unlock”键，驾驶员侧车门打开；再按，4个车门全部打开。遥控器控制正常。用钥匙在驾驶员侧锁门、开门时，除了驾驶员侧门锁之外...
JVM+调优（整合拉勾、图灵等课程）
最新发布
hasagei_ly的博客
06-14 304
图方便对于JVM级缓存就简单使用一个hashmap，但是很少考虑这个map的容量问题，结果这个缓存map越来越大，一直占用着老年代的很多空间，时间长了就会导致full gc非常频繁。这就是一种内存泄漏，一些老旧数据没有及时清理导致一直占用着宝贵的内存资源，时间长了除了导致full gc，还有可能导致OOM。​ 这种情况完全可以考虑采用一些成熟的JVM级缓存框架来解决，比如ehcache等自带一些LRU数据淘汰算法的框架来作为JVM级的缓存。
刷题理解JVM内部的数据存储
m0_63852716的博客
06-11 721
从代码中分析数据的存储!
介绍JVM的JIT编译器
常备不懈
06-11 359
Java虚拟机（JVM）是Java编程语言的基础，它使Java程序能够在各种平台上运行。为了实现这一目标，JVM将Java字节码转换为机器代码。JIT编译器（Just-In-Time Compiler，即时编译器）是JVM中的一个重要组件，它在程序运行时将字节码动态编译为本地机器代码，从而提高程序的执行效率。
观察 jvm 运行时数据区内存大小(native memory tracking)
JellyfishMIX 的博客
06-11 336
jvm 运行时数据区包括且不限于以下几个部分:1. 堆(heap)。2. 方法区(method area)。3. 虚拟机栈(vm stack)。4. 本地方法栈(native method stack)。5. 程序计数器(program counter)。观察 jvm 运行时数据区内存情况可以使用 jcmd 命令。
Qt基于SQLite数据库的增删查改demo
qzt__l0ve的博客
06-08 568
首先获取输入框中对应的内容；在user表中，id字段设置为自增，所以不需要输入id的内容来进行添加。添加：在右边的QLineEdit标签上输入需要添加的内容，包含id，name，age三个字段，然后点击添加按钮，即可将数据添加至数据库。查询：从数据库中查找所有数据的所有内容，并显示在左边的QListWidget控件上。删除：根据在id控件输入框中输入的id，删除数据库中指定那一行内容。更新：根据输入的id号，对指定行数据的name字段内容进行修改。先获取输入框中的内容，然后进行编写修改的sql语句，使用。
一文了解JVM（中）
2201_75506216的博客
06-04 1481
说到对象的创建，首先让我们看看Java虚拟机遇到一条 new 指令时，先检查常量池是否已经加载相应的类，如果没有，必须先执行相应的类加载。类加载通过后，接下来分配内存。若 Java 堆中内存是绝对规整的，使用“指针碰撞“方式分配内存；如果不是规整的，就从空闲列表中分配，叫做”空闲列表“方式。划分内存时还需要考虑一个问题–并发，也有两种方式: CAS 同步处理，或者本地线程分配缓冲(Thread然后内存空间初始化操作，接着是做一些必要的对象设置(元信息、哈希码…)，最后执行方法。
JVM：Java虚拟机探秘
David的博客
06-08 414
Java Virtual Machine（JVM），作为Java技术的核心，是一个抽象化的计算模型，负责执行Java字节码。它不仅为Java程序提供了跨平台运行的能力，还通过内存管理、垃圾回收、即时编译（JIT）等一系列机制，保障了程序的高性能与安全性。深入理解JVM的工作原理，不仅有助于编写高效稳定的代码，还能在面对性能瓶颈和内存问题时，进行有效的诊断与优化。自动管理内存，回收不再使用的对象空间。常见的有Serial、Parallel、CMS、G1等多种收集器，各有侧重，如低延迟、高吞吐量等。
JVM知识点
weixin_43867181的博客
06-11 621
JVM 是 Java 能够跨平台的核心。
C++~~期末复习题目讲解---lijiajia版本
binhyun的博客
06-10 973
1.类和对象 （3）创建对象的个数 （3）全局变量，局部变量 （4）构造函数的执行次数 （5）静态动态析构和构造顺序 （6）初始化顺序和声明顺序 （7）构造和复制构造 （8）拷贝构造的三种情况和例题讲解 2.继承和派生 （1）派生的构造和析构 （2）赋值的兼容性规则 3.虚函数
公平锁与非公平锁的区别
02-11
公平锁与非公平锁是指多线程访问共享资源时，锁的两种不同类型。 公平锁是指多个线程按照申请锁的顺序来获得锁，确保了每个线程都有机会获得锁，防止饥饿现象的发生。因此，公平锁的性能较差，但是保证了公平性。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值