synchronized锁的8个问题

最新推荐文章于 2023-07-24 09:30:03 发布
最新推荐文章于 2023-07-24 09:30:03 发布
阅读量253 收藏
点赞数
分类专栏： 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38307826/article/details/118343719
版权

关于synochronized的八个问题

1 标准访问，先打印短信还是邮件 短信

class Phone
{

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

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

}
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

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

        Thread.sleep(100);

        new Thread(() -> {
            try {
                phone.sendEmail();
//                phone.getHello();
//                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

答案是短信，解释如下：标准访问：各线程和个方法中都没有睡眠时间，此时可能先打印短信，也可能先打印邮件，但是在打印短信的线程后面加上睡眠100毫秒，那就是先打印短信，因为一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法

2 停4秒在短信方法内，先打印短信还是邮件 短信

class Phone
{

    public  synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized  void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

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

}
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

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

        Thread.sleep(1000);

        new Thread(() -> {
            try {
                phone.sendEmail();
//                phone.getHello();
//                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

答案是短信，解释如下：只要打印短信后面有100毫秒的睡眠时间，那么先打印的就是短信，因为一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待

3 新增普通的hello方法，是先打短信还是hello (短信方法中有睡眠4秒) hello

class Phone
{

    public  synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized  void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

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

}
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

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

        Thread.sleep(1000);

        new Thread(() -> {
            try {
                //phone.sendEmail();
                phone.getHello();
//                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

答案是hello，只要打印短信的方法中有睡眠4秒的代码，那么就是先打印hello，因为普通方法不在synchronized锁的范围内，所以打印hello的线程不受影响

4 现在有两部手机，先打印短信还是邮件(短信方法中有睡眠4秒) 邮件

class Phone
{

    public  synchronized void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized  void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

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

}
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

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

        Thread.sleep(1000);

        new Thread(() -> {
            try {
                //phone.sendEmail();
                //phone.getHello();
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

先打印邮件，因为这是两个对象，其各自的线程不再是同一把锁，因为打印短信方法有4秒的延迟，所以先打印邮件

5 两个静态同步方法，1部手机，先打印短信还是邮件(短信方法中有睡眠4秒) 短信

class Phone
{

    public  synchronized static void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized static void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

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

}
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

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

        Thread.sleep(1000);

        new Thread(() -> {
            try {
                //phone.sendEmail();
                //phone.getHello();
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

答案是短信 解释：synchronized实现同步的基础：Java中的每一个对象都可以作为锁。
具体表现为以下3种形式。
对于普通同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前类的Class对象。
对于同步方法块，锁是Synchonized括号里配置的对象
问题5中synchronized修饰的是静态同步方法，所以锁的是当前类的Class对象，先获取锁的线程先执行，由于打印邮件线程前有100毫秒的延迟，所以打印短信的线程先获取锁，所以先打印短信

6 两个静态同步方法，2部手机，先打印短信还是邮件(短信方法中有睡眠4秒) 短信

class Phone
{

    public  synchronized static void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized static void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

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

}
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

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

        Thread.sleep(1000);

        new Thread(() -> {
            try {
                //phone.sendEmail();
                //phone.getHello();
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

同上答案相同，也是打印短信，因为synchronized修饰的是两个静态同步方法，锁的是当前类的Class对象，是同一把锁，所以先打印短信

7 1个静态同步方法,1个普通同步方法，1部手机，先打印短信还是邮件(短信方法中有睡眠4秒) 邮件

class Phone
{

    public  synchronized static void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized  void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

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

}
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

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

        Thread.sleep(1000);

        new Thread(() -> {
            try {
                //phone.sendEmail();
                //phone.getHello();
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

答案是邮件 解释：一个静态同步方法和一个普通方法的synchronized不是同一个锁，虽然修饰静态同步方法的synchronized的锁锁的是当前类的Class对象，但是二者不是同一把锁，所以先打印的是没有延迟的邮件方法

8 1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件(短信方法中有睡眠4秒) 邮件

class Phone
{

    public  synchronized static void sendSMS() throws Exception
    {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized  void sendEmail() throws Exception
    {
        System.out.println("------sendEmail");
    }

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

}
public class Lock_8
{
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

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

        Thread.sleep(1000);

        new Thread(() -> {
            try {
                //phone.sendEmail();
                //phone.getHello();
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

跟上面一样，不是同一把锁，所以先打印的是没有延迟的邮件方法

是个可爱的小伙砸
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
synchronized锁字符串存在的问题以及intern常量池基础问题
daiming573的专栏
04-01 2771
一、问题阐述 在日常项目中可能存在需要防止用户数据并发操作的问题，需要对代码块加锁保护。例如：用户输入存数据库，重复数据不存DB；用户操作缓存数据等，这里想尽可能把锁的对象放小，因此通常都是锁用户而不是锁整个对象；然而在用synchronized(userId)的时候可能会存在一些问题。 二、synchronized 锁字符串的问题 使用synchronized 锁字符串存在的问题，下面示例锁一个...
Java synchronized锁升级jol过程详解
08-19
Java synchronized锁升级jol过程详解是Java并发编程中一个重要的概念，了解锁升级过程对Java开发者来说非常重要。本文将通过示例代码详细介绍Java synchronized锁升级jol过程详解的过程。 一、锁升级过程 Java ...
浅谈java synchronized 锁的问题
weixin_45935149的博客
08-28 162
java 锁的一些基础用法
8锁，就是关于锁的8个问题
weixin_45752694的博客
09-17 264
synchronized 锁的对象是方法的调用者,经过8锁问题能更加理解这个概念
JUC-多线程锁
weixin_30922589的博客
08-27 178
多线程锁的练习题 1、标准访问，先打印短信还是邮件 class Phone { public synchronized void sendSMS() throws Exception { Thread.sleep(400);题【2】添加延时 System. out .println( "------se...
Java并发编程-八锁问题带你彻底理解对象锁和类锁
Java硬件工程师的博客
01-15 2180
8锁问题演示 1.标准访问 标准访问，先打印邮件还是短信. 不一定谁先被打印。取决于CPU的执行情况.激活他们的是main线程，后面谁先被调度，不知道。 为了保证效果，我们在A和B的代码之间加thread.sleep(100).此时，可以确保A先被打印。 解释： 进入到main方法中之后，就是A找邮件，B找短信的方法。加完锁之后，同时进来，各回各家，各找各妈。因为我们人为的在A和B之间加了休眠时间，那么A肯定发生在B之前。按照标准访问。此时先打印邮件 /*手机类可以发邮件和发短信*/ class Phone
深入理解java内置锁(synchronized)和显式锁(ReentrantLock)
08-28
深入理解Java内置锁(synchronized)和显式锁(ReentrantLock) Java中有两种锁机制：内置锁（synchronized）和显式锁（ReentrantLock）。内置锁是Java语言提供的一种同步机制，使用synchronized关键字声明的方法或...
Java中synchronized正确使用方法解析
08-25
解决这个问题的方法是使用锁，锁可以确保在多线程环境下，共享资源的访问安全性。 二、锁的原理 锁的原理是通过互斥修改共享变量来实现的。在单核 CPU 中，锁可以保证原子性，但是在多核 CPU 中，锁只能保证 CPU ...
java synchronized用法详解
09-01
`synchronized`具有可重入性，即一个线程已经持有对象锁，还能再次获取同一对象的锁，这在递归调用或嵌套`synchronized`块时非常重要。 8. **替代方案** 虽然`synchronized`简单易用，但在某些复杂场景下可能不够...
JAVA基础及8个并发面试问题共2页.pdf.zip
11-21
这个标题表明了文档的主要内容，涵盖了Java编程的基础知识以及八个与并发编程相关的面试问题。Java是世界上最流行的编程语言之一，广泛应用于企业级应用、云计算、大数据处理等多个领域。对于Java开发者来说，扎实的...
并发编程中Synchronized锁的七个问题 带你了解锁的究竟是谁
weixin_43788143的博客
01-19 2539
锁能锁的东西只有两个，一个是new出来的对象， 另一个是Class模板
由Synchronized引发的一系列问题
weixin_43588401的博客
03-11 604
说起线程安全，那就不得不提到加锁，说起加锁呢，自然而然脑子里就会浮现出synchronized这个关键字。而对于Synchronized，又了解多少呢？ Synchronized 的用法 Synchronized是Java提供的一个并发控制的关键字。主要有两种用法：同步方法和同步代码块。 修饰实例方法，对当前实例对象this加锁（下面两种写法是等价的） public class Synchronized { public synchronized void test(){ // 逻辑操作
JUC-----------（三）详解synchronized八种情况
weixin_43664907的博客
04-10 158
8锁现象 1、标准访问，请问先打印邮件还是短信 public class A { public static void main(String[] args) { Phone phone = new Phone(); new Thread(() -> { phone.sendEmail(); }, "A").start(); new Thread(() -> { phone.s
使用synchronized的线程安全问题
zmm0420的专栏
07-30 148
先来回顾一下synchronized关键字的使用。 synchronized关键字解决并发问题时通常有三种使用方式： 同步普通方法，锁的是当前对象； 同步静态方法，锁的是当前Class对象； 同步块，锁的是()中的对象； 错误实例： public class SyncTest implements Runnable { private Integer count = 0; @Override public void run() { ..
synchronized - 不要锁常量
面朝大海，春暖花开
06-07 577
synchronized - 不要锁常量 It is not recommended to use objects which are pooled and reused, if you do so there is a chance of getting into deadlock condition down the line. 不要尝试使用池化或者重用的对象，有可能会造成死锁或者竞态条件 有些时候使用 synchronized 时会这样写, 这样的不建议的: String rs1 = "lock
Java的synchronized以及锁的相关概念
学渣的博客
05-25 189
synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？ 在上面一篇文章中，我们了解到如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况： 1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有； 2）线程执行发生异常，此时JVM会让线程自动释放锁。 那么如果这个获取锁的线程由于要等待IO或者...
synchronized：锁的对象到底是谁？快速理解八锁现象
最新发布
saya21的博客
07-24 899
通过总结和例子帮助快速理解八锁现象。
JAVA多线程二（死锁，线程安全问题及解决：synchronized和Lock）
m0_61160520的博客
07-12 940
当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程`只有读操作`，那么不会发生线程安全问题。但是如果多个线程中对资源有`读和写`的操作，就容易出现线程安全问题。如何寻找问题并解决？
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值