多线程8锁问题

最新推荐文章于 2023-01-12 22:17:37 发布
最新推荐文章于 2023-01-12 22:17:37 发布
阅读量222 收藏 1
点赞数
分类专栏： JUC 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36525300/article/details/106135600
版权

多线程8锁问题

在多线程环境中，访问资源类的顺序到底是如何？
最近，在网络上看到一道题目，通过多线程的8种锁情况了解访问资源类的顺序。

  1. 标准访问，先打印邮件方法还是短信方法？
class Phone{
    public synchronized void sendEmail(){
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        //睡眠4毫秒
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}

运行结果：

synchronized关键字锁的不是当前方法，而是该方法所在的整个资源类，也就是说，同一时间下，只能有一个线程进入当前的资源类访问同步方法，所以运行结果跟方法调用的顺序相同。


  1. 邮件方法暂停4秒，先打印邮件方法还是短信方法？
class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}

运行结果：

第二锁的原理跟第一锁相同，只不过是在发邮件方法中线程睡眠了4秒，当线程A访问发邮件方法睡眠时，线程B无法进入该资源类，所以运行结果还是相同。


  1. 新增一个普通方法hello，先打印邮件方法还是短信方法？
class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public void hello(){
        System.out.println("----hello----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone.hello();
        }, "B").start();
    }
}

运行结果：

新增的hello方法并没有被synchronized关键字修饰，不是同步方法，所以在线程A访问发邮件方法时，线程B可以访问到hello方法，而线程A需要睡眠4秒，所以运行结果是hello先。


  1. 两个资源类，先打印邮件方法还是短信方法？
class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone2.sendSMS();
        }, "B").start();
    }
}

运行结果：

第四锁中创建了两个资源类，main方法中访问的是两个不同资源类的方法，相互并不干扰，而发邮件的方法睡眠4秒，所以发短信的方法会先打印。

  1. 两个静态同步方法，同一个资源类，先打印邮件方法还是短信方法？
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public static synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}

运行结果：

这题涉及到static静态，锁的不再是这个资源类对象，锁的是这个对象在类加载器中的类模板（.class），但由于还是同一个资源类，所以的顺序原理还是跟第一锁差不多。

  1. 两个静态同步方法，两个资源类，先打印邮件方法还是短信方法？
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public static synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone2.sendSMS();
        }, "B").start();
    }
}

运行结果：

第六锁变换成两个资源类，但由于static锁的是整个类的类模板（.class），所以不论实例化多少个资源类访问的结果还是相同的。

  1. 一个同步方法，一个静态同步方法，一个资源类，先打印邮件方法还是短信方法？
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}

运行结果：

第七锁，一个静态同步方法，一个普通同步方法，一个锁的是整个类模板，一个锁的是当前对象，两者相互不冲突，所以发短信先显示，发邮件的需要睡眠4秒才显示。

  1. 一个同步方法，一个静态同步方法，两个资源类，先打印邮件方法还是短信方法？
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone2.sendSMS();
        }, "B").start();
    }
}

运行结果：

第八锁与第七锁的原理类似。

总结

synchronized实现同步的基础：Java中的每个对象都可以作为锁。
具体表现为以下三种形式：

  • 对于普通同步方法，锁的是当前实例对象
  • 对于静态同步方法，锁的是当前类的Class对象
  • 对于同步方法快，锁的是synchronized括号里配置的对象
不想当程序汪的第N天
关注
专栏目录
使用Windbg分析多线程临界区死锁问题分享
dvlinker的技术专栏
01-03 4万+
使用Windbg分析多线程临界区死锁问题分享。
线程八锁问题超简单理解
weixin_45953000的博客
11-15 253
在并发的环境中，锁机制一个良好的控制同步的方法，使用synchronize关键字对临界资源的锁，在普通的成员方法中添加锁的是调用该方法的对象public synchronized void Sem(){//普通同步的发邮件的方法 System.out.println("发邮件"); }，而在静态方法中使用 则锁的整个类对象（类对象是在class加载的时候进行创建的，每一个类只用有一个）public static synchronized void Sem(){//普通同步的发邮件的方法 System.out
java多线程 线程八锁
ankan7400的博客
02-05 127
package com.java.juc; /** * 题目：判断打印 "one" or "two" * * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印thr...
线程八锁问题
qq_40822132的博客
01-13 4354
线程八锁
Java多线程-线程八锁
超超级钢铁侠
07-06 3808
所有的非静态同步方法用的都是同一把锁，即实例对象本身，或者说this对象，如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁。如果别的对象的非静态同步方法与该实例对象的非静态同步方法获取不同的锁，则不需要等待。 所有的静态同步方法用的也是同一把锁，即类对象本身，所以静态同步方法与非静态同步方法之间是不会有竞态条件的，但是一个静态同步方法获
QT中sqlite多线程操作4个注意问题
02-26
然而，当在多线程环境中使用SQLite时，需要注意一些关键问题以确保数据的安全性和一致性。以下是四个重要的考虑因素： 1. **线程安全**： SQLite本身并不提供完全的线程安全，这意味着在不同线程中并发访问数据库...
Python中多线程及程序锁浅析
12-25
Python中多线程使用到Threading模块。Threading模块中用到的主要的类是Thread，我们先来写一个简单的多线程代码： 复制代码 代码如下: # coding : uft-8 __author__ = ‘Phtih0n’ import threading class MyThread...
Java多线程中Lock锁的使用总结
08-18
Java中的Lock锁是用于解决多线程访问共享资源时的同步问题的。Lock锁可以分为两种：独占锁和共享锁。独占锁允许多个线程访问同一个资源，但是同一时刻只能有一个线程可以访问该资源。共享锁允许多个线程同时访问同一...
27道顶尖的Java多线程、锁、内存模型面试题！.pdf
09-26
Java多线程、锁以及内存模型是Java编程中不可或缺的部分，尤其在面试中，这些问题的掌握程度往往被视为衡量开发者技术水平的重要标准。以下是一些关于Java并发编程的关键知识点： 1. **Synchronized原理**：...
多线程--线程八锁
喝醉的咕咕鸟
01-30 253
线程八锁:理解锁的关键。 案例分析： 1 标准访问，先打印吃鸡还是LOL 2 新增Thread.sleep(4000),先打印吃鸡还是LOL class Game{ public synchronized void getChicken() throws Exception { //TimeUnit.SECONDS.sleep(4); 第二种情况时候需要放...
线程第六课(附加)——八锁问题
Geek
11-28 402
  搞懂以下八个问题，同步锁就算真的搞懂了。   1 标准访问，先打印短信还是邮件   public class Lock_8 {     public static void main(String[] args) throws InterruptedException {         Phone phone1 = new Phone();         Phone ...
线程8锁问题
Uponz的博客
03-31 236
1.标准访问，先发送短信还是邮件 public class ThreadDemo5 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(()->{ try { phone.sendEmail(); } catch (InterruptedException e) {
Java多线程-线程8锁
liudashuaide的博客
05-28 171
多线程的八个案例 通过分析代码，推测打印结果，并运行代码进行验证。 1）两个线程调用同一个对象的两个同步方法 代码如下： 1 public class Demo { 2 public static void main(String[] args) { 3 Number number = new Number(); 4 5 new Thread(new Runnable() { 6 @Override 7
线程8锁
weixin_41047933的博客
01-23 733
思路： 线程 操作 共享资源 1）创建资源类，在资源类中定义线程操作方法，根据需要添加同步锁或同步代码块 2）创建线程对象，使用线程对象调用响应的同步方法 对象锁和类锁的定义： 对象锁： 1）对象锁也叫方法锁，是针对一个对象实例的，它只在该对象的某个内存位置声明一个标识该对象是否拥有锁，所有它只会锁住当前的对象，而并不会对其他对象实例的锁产生任何影响，不同对象访问同一个被syn...
【Java并发编程] 线程八锁问题
最新发布
小新的博客
01-12 1314
生活总会有惊喜，谁知道下一秒会发生什么呢
多线程中的8锁现象
Ron_的博客
01-14 7366
题目：多线程8锁 1 标准访问，请问先打印邮件还是短信？ 2 邮件新增暂停4秒钟的方法，请问先打印邮件还是短信？ 3 新增普通的hello方法，请问先打印邮件还是hello 4 有两部手机，请问先打印邮件还是短信？ 5 两个静态同步方法，同一部手机，请问先打印邮件还是短信？ 6 两个静态同步方法，2部手机，请问先打印邮件还是短信？ 7 1个静态同步方法,1个普通同步方法，1部手机，请问先打印邮件还是短信？ 8 1个静态同步方法,1个普通同步方法，2部手机，请问先打印邮件还是短信？ 1、标
Qt多线程同步锁技术与GUI演示教学
资源摘要信息:"本资源主要围绕Qt框架下的多线程编程实践展开，特别强调锁机制的应用，包括加锁操作、文件锁以及生产消费锁的概念与实现。通过Visual Studio 2019（VS2019）进行开发，创建了具有图形用户界面（GUI）...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值