线程八锁现象的理解

最新推荐文章于 2024-08-14 23:12:09 发布
最新推荐文章于 2024-08-14 23:12:09 发布
阅读量197 收藏
点赞数 2
分类专栏： JUC 文章标签： java 多线程 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1797834767/article/details/111255669
版权
本文详细探讨了Java多线程中关于锁的八个问题，包括正常情况下的线程执行顺序、线程睡眠后的执行顺序、同步方法与普通方法的区别、不同对象的执行顺序、静态同步方法的特性、两个对象与两个静态同步方法的执行情况、静态同步方法与普通同步方法的执行顺序以及两个对象、一个静态同步方法和一个普通同步方法的执行顺序。通过实例分析，揭示了synchronized锁的对象和执行逻辑。
摘要由CSDN通过智能技术生成

八锁即锁的八个问题

一、正常情况下线程的执行顺序

package demo_02;
// 八锁问题
// 正常线程执行情况

public class Test_01 {
    public static void main(String[] args) {
        PrintMessage pm = new PrintMessage();
        new Thread(()->{pm.printA();},"A").start();
        new Thread(()->{pm.printB();},"B").start();
    }
}
class PrintMessage{
    public synchronized void printA(){
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "A");
    }
    public synchronized void printB(){
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "B");
    }
}

执行结果：在这里插入图片描述

可以看到这里是先执行的printA，在执行的printB，可是原因是什么呢？因为先调用的printA方法，再调用的printB方法吗？答案是否定的

二、睡眠A线程3秒，线程的执行顺序

有人可能会觉得是因为先调用的printA方法再调用的printB方法的问题，因此我们让printA方法睡三秒

package demo_02;
// 八锁问题


import java.util.concurrent.TimeUnit;

public class Test_01 {
    public static void main(String[] args) {
        PrintMessage pm = new PrintMessage();
        new Thread(()->{
            try {
                pm.printA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{pm.printB();},"B").start();
    }
}
class PrintMessage{
    public synchronized void printA() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "A");
    }
    public synchronized void printB(){
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "B");
    }
}

执行结果：在这里插入图片描述

不管执行多少次都是先打印A再打印B，注意这里并不是因为先调用的printA方法，再调用printB方法的问题，这样理解根本没有理解到关键。
这里出现先打印A再打印B的原因是因为大家没有理解synchronized锁，锁的是什么？这个地方锁的是PrintMessage这个类的调用者pm对象，所以在A线程屌用printA方法时，会对pm对象加锁，B线程要等待A线程释放pm锁之后才可以获得pm对象。

三、普通方法和synchronized方法执行问题

package demo_02;
// 八锁问题


import java.util.concurrent.TimeUnit;

public class Test_01 {
    public static void main(String[] args) {
        PrintMessage pm = new PrintMessage();
        new Thread(()->{
            try {
                pm.printA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{pm.printC();},"C").start();
    }
}
class PrintMessage{
    public synchronized void printA() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "A");
    }
    public void printC(){
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "C");
    }
}

执行结果：在这里插入图片描述

这里为了让结果看起来更清晰，我将A线程睡了三秒。这里先打印C的原因是在A线程拿到了pm对象的锁的时候，C线程可以直接对pm对象进行操作，因为printC方法并不是同步方法，不需要进行同步操作，A线程有没有锁对C线程调用printC方法都没有影响。

四、两个线程不同的对象执行顺序

为了获取观察效果，在这里同样让线程A睡3秒

package demo_02;
// 八锁问题


import java.util.concurrent.TimeUnit;

public class Test_01 {
    public static void main(String[] args) {
        PrintMessage pm1 = new PrintMessage();
        PrintMessage pm2 = new PrintMessage();
        new Thread(()->{
            try {
                pm1.printA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{pm2.printB();},"B").start();
    }
}
class PrintMessage{
    public synchronized void printA() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "A");
    }
    public synchronized void printB(){
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "B");
    }
}

执行结果：在这里插入图片描述

这里虽然是两个同步方法，但是synchronized锁的对象不同，因此线程A和线程B调用的printA和printB方法分别是不对对象的方法，两个线程并不冲突，因为A线程睡眠的3秒，所以先打印B再打印A。

五、静态同步方法的执行顺序

将同步方法更改为static静态方法，看一看执行顺序有什么不同。
static修饰的方法会在类第一次载入的时候被执行。

package demo_02;
// 八锁问题


import java.util.concurrent.TimeUnit;

public class Test_01 {
    public static void main(String[] args) {
        PrintMessage pm = new PrintMessage();
        new Thread(()->{
            try {
                pm.printA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{pm.printB();},"B").start();
    }
}
class PrintMessage{
    public static synchronized void printA() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "A");
    }
    public static synchronized void printB(){
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "B");
    }
}

执行结果：
在这里插入图片描述

这里虽然和前面的正常情况的输出结果一样，但是其内在原理却不相同。首先我们需要理解一下static关键字，static声明的静态方法，会在类被加载的时候就执行。可以理解成static方法在对象被new的时候就已经执行，执行后的方法会放在class文件中（java文件编译后产生的class文件），class又被称为该类的模板，一个类在运行过程只只会有一个模板这里synchronized锁，锁的对象是一个模板，而不是一个类对象，虽然输出结果一样但是锁的对象并不相同。
可能很多同学还不是太懂于是就有了第六个锁的问题

六、两个对象，两个静态同步方法

如果之前大家可能还没有想通，我们创建两个PrintMessage的对象，分别调用打印方法，按道理如果A线程睡眠3秒，那B线程就会先打印，然后在打印A线程的输出方法，但是如果是静态同步方法呢？

package demo_02;
// 八锁问题


import java.util.concurrent.TimeUnit;

public class Test_01 {
    public static void main(String[] args) {
        PrintMessage pm1 = new PrintMessage();
        PrintMessage pm2 = new PrintMessage();
        new Thread(()->{
            try {
                pm1.printA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{pm2.printB();},"B").start();
    }
}
class PrintMessage{
    public static synchronized void printA() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "A");
    }
    public static synchronized void printB(){
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "B");
    }
}

执行结果：
在这里插入图片描述

七、一个静态同步方和一个普通方法，一个对象的执行顺序

package demo_02;
// 八锁问题


import java.util.concurrent.TimeUnit;

public class Test_01 {
    public static void main(String[] args) {
        PrintMessage pm = new PrintMessage();
        new Thread(()->{
            try {
                pm.printA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{pm.printB();},"B").start();
    }
}
class PrintMessage{
    public static synchronized void printA() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "A");
    }
    public  void printB(){
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "B");
    }
}

执行结果：

相信大家如果认真看了前面的问题，就知道这个问题的原因了，因为普通方法并不会获取锁资源，所以线程B的普通方法可以直接执行，线程A睡眠3秒后再执行。

八、两个对象，一个静态同步方法，一个普通同步方法，执行顺序

这个地方的关键是要明白锁的对象锁的是什么？

package demo_02;
// 八锁问题


import java.util.concurrent.TimeUnit;

public class Test_01 {
    public static void main(String[] args) {
        PrintMessage pm1 = new PrintMessage();
        PrintMessage pm2 = new PrintMessage();
        new Thread(()->{
            try {
                pm1.printA();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{pm2.printB();},"B").start();
    }
}
class PrintMessage{
    public static synchronized void printA() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "A");
    }
    public synchronized void printB(){
        System.out.println(Thread.currentThread().getName()+" 输出了 => " + "B");
    }
}

执行结果：
在这里插入图片描述

首先静态同步方法锁的是类模板（class文件），而普通同步方法锁的是PrintMessage的对象，所以两个锁的对象是不同的，两个锁并不冲突，自己锁自己的，线程A睡眠3秒后输出，线程B正常输出，所以先输出B线程再输出A线程。

该部分内容是笔者参考狂神的学习视频，做的一些总结以及自己的思考，如果有纰漏的地方，希望大家多多指出，一起学习！

大付狗
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#线程锁介绍源码
03-12
通过上述代码示例，我们可以看到如何正确使用lock语句，并通过提问者的评价验证了正确使用线程锁的重要性。 总结来说，线程同步是一个复杂但又不可忽视的话题。开发者在设计应用程序时需要充分考虑线程安全的需要，...
线程八锁是什么意思？
bieliwotaijin的博客
06-07 3315
线程八锁 据说是平常工作中常见的情况，线程八锁的重点就是： ① 非静态方法的默认锁是this 静态方法的默认锁是class ②某一时刻内，只能有一个线程有锁，无论几个方法 打个比方 我就不举八个例子了，举几个重点例子给大家看看： public class ThreadEightLock { public static void main(String[] args) { thread t = new thread(); thread t2 = new thread(
27.线程八锁 -- 线程常使用的八种情况
kfengqingyangk的博客
04-06 3779
上案例： public class Thread8Monitor { public static void main(String[] args) { final Number number = new Number(); final Number number2 = new Number(); new Thread(new Runnable() { public void
线程8锁机制——小总结
weixin_48149536的博客
05-31 152
A 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了， 其它的线程都只能等待，换句话说，某一个时刻内，只能有 唯一 一个线程 去访问这些synchronized方法 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法 加个普通方法后发现和同步锁无关 换成两个对象后，不是同一把锁了，情况立刻变化。 synchronized实现同步的基础：Java中的每一个对象都可以作为锁。...
经典8锁问题--助你彻底搞懂锁的概念
iME_cho的博客
04-07 1864
下面将通过经典的8锁问题，认清锁原理 场景一 import java.util.concurrent.TimeUnit; /** * 标准情况下 是先sendEmail()　还是先callPhone()? * 答案：sendEmail * 解释：被 synchronized 修饰的方式，锁的对象是方法的调用者 * 所以说这里两个方法调用的对象是同一个，先调用的先执行！ */ pub...
多线程八锁详细分析 + 个人理解
qwertyu0103的博客
03-29 215
线程八锁： 1、标准访问，请问先执行发邮件还是先发短信？ 2、如果让发邮件sleep()三秒钟是先发邮件还是先发短信？ 3、新增一个普通方法hello()，先发邮件还是先执行hello()？ 4、两部手机（两个资源类对象），先发邮件还是先发送短信？ 5、两个静态方法，同一部手机，先发邮件还是先发短信？ 6、两个静态方法，两部手机，先发邮件还是先发短信？ 7、一个普通方法，一个静态方法，一部手机，先发邮件还是先发短信？ 8、一个普通方法，一个静态方法，两部手机，先发邮件还是先发短信？ 这里我认为需要加一些前提
Python多线程编程（四）：使用Lock互斥锁
09-22
在多线程环境中，如果多个线程同时尝试访问共享资源，而没有采取同步措施，就会发生线程不安全的现象。例如，在上述代码中，多个线程同时增加`counter`变量，导致结果不正确。为了解决这个问题，我们可以使用互斥锁...
教你完全理解ReentrantLock重入锁
10-16
公平锁的实现确保了等待获取锁的线程会按照它们请求锁的顺序获取，这在多线程环境中可以减少线程之间的竞争和饥饿现象。然而，公平锁也可能会导致性能下降，因为线程即使有机会获取锁，也可能因为遵守公平性而选择...
Java线程公平锁和非公平锁的差异讲解
08-26
- 非公平锁提高了锁的获取效率，但可能导致某些线程长时间等待，甚至可能出现饥饿现象，即某些线程始终无法获得锁。 - 在高竞争环境下，非公平锁通常表现出更好的性能，因为它减少了线程上下文切换的次数。 - 在低...
java 线程公平锁与非公平锁详解及实例代码
08-31
公平锁的优点在于它遵循“先来后到”的原则，避免了饥饿现象，即某些线程永远无法获取锁。 非公平锁则没有这样的限制，它允许线程尝试立即获取锁，即使在其他线程正在等待的情况下也是如此。这就是所谓的“插队”...
Java基础之原反补码
最新发布
u012135697的博客
08-14 108
整数类型数据在计算机底层进行存储或运算，以补码方式进行！ 正整数的原反补码，一模一样！
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 448
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 488
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
集合（1）
supercool7的博客
08-12 773
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
软件测试需要具备的基础知识【功能测试】---后端知识（三）
yang_xs的博客
08-12 1159
为了更好的学习软件测试的相关技能，需要具备一定的基础知识。需要学习的基础知识包括：1、计算机基础2、前端知识3、后端知识4、软件测试理论后期分四篇文章进行编写，这是第三篇CS架构BS架构效率：c/s效率高，某些内容已经安装在系统中了，b/s每次都要加载最新的数据升级：b/s无缝升级；c/s删除老版本再安装新版本安全：c/s更安全，需要安装、注册、登录；b/s有浏览器即可使用，安全程度低开发成本：b/s成本低；c/s需要不同的系统要不同的开发人员，成本高。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 144
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
Java：继承，this，super
m0_75257168的博客
08-10 392
可以同名，但参数列表不能相同（有参无参构造）
SpringBoot中生成条形码的方案实战
2301_76419561的博客
08-14 709
ZXing库是一个用于解析和生成多种格式的一维和二维条形码的开源Java库。ZXing（“zebra crossing”的缩写）库提供了多种条形码格式的支持，包括但不限于QR码、Data Matrix、EAN、UPC和Codabar等。它不仅能够在Java平台上使用，还提供了其他编程语言的端口，如C++、ObjC（用于iOS开发）以及ActionScript等。ZXing的设计旨在支持复杂的条形码识别功能，并能够通过摄像头捕获条形码图像进行解码。
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 484
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
深入理解Java多线程编程：从概念到实战
6. **死锁、活锁与饥饿**：线程同步中可能出现的问题，如多个线程相互等待对方释放资源导致的死锁，资源分配不当导致的活锁，以及优先级问题引发的饥饿现象。 7. **线程池**：Java的`ExecutorService`和`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值