synchronized8锁学习总结

最新推荐文章于 2024-03-28 09:38:18 发布
最新推荐文章于 2024-03-28 09:38:18 发布
阅读量117 收藏
点赞数
分类专栏： Java多线程 文章标签： 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_33043795/article/details/129542778
版权
文章通过8个不同的示例展示了Java中锁的使用和线程执行顺序。在涉及同步方法的情况下，锁的对象决定了线程的执行次序。当锁对象相同时，线程会有锁的竞争；而锁对象不同时，线程可并发执行。静态同步方法锁定的是类对象，普通同步方法锁定的是实例对象。示例涵盖了不同锁配置下的输出结果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

通过8种情况演示锁运行案例，看看我们到底锁的是什么。
输出结果我会放在最底下。可以思考一下，然后对照，代码都是基于Java8运行。

案例：

情况1：标准访问有a b两个线程，请问先打印邮件还是短信 ?

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) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendEmail();
        },"a").start();

        //暂停200ms 保证a先启动
        try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(()->{
            phone.sendSMS();
        },"b").start();

    }
}

情况2：sendEmail故意停3秒？，请问先打印邮件还是短信 ?

class Phone{
    public  synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("-------------sendEmail");

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

}

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendEmail();
        },"a").start();

        //暂停200ms 保证a先启动
        try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(()->{
            phone.sendSMS();
        },"b").start();

    }
}

情况3：添加一个普通的hello方法，请问先打印邮件还是hello

class Phone{
    public  synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("-------------sendEmail");

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

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

}

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendEmail();
        },"a").start();

        //暂停200ms 保证a先启动
        try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(()->{
            phone.hello();
        },"b").start();

    }
}

情况4：有2部phone , 请问先打印邮件还是短信 ?

class Phone{
    public  synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("-------------sendEmail");

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

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

}

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        
        new Thread(()->{
            phone.sendEmail();
        },"a").start();

        //暂停200ms 保证a先启动
        try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(()->{
            phone2.sendSMS();
        },"b").start();

    }
}

情况5：有2个静态同步方法，有一部phone ，请问先打印邮件还是短信 ?

class Phone{
    public  static synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("-------------sendEmail");

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

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

}

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();


        new Thread(()->{
            phone.sendEmail();
        },"a").start();

        //暂停200ms 保证a先启动
        try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(()->{
            phone.sendSMS();
        },"b").start();

    }
}

情况6：有2个静态同步方法，有两部phone，请问先打印邮件还是短信 ?


class Phone{
    public  static synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("-------------sendEmail");

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

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

}

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();


        new Thread(()->{
            phone.sendEmail();
        },"a").start();

        //暂停200ms 保证a先启动
        try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(()->{
            phone2.sendSMS();
        },"b").start();

    }
}

情况7：有1个静态同步方法，1个普通同步方法，有1部phone_，_请问先打印邮件还是短信 ?

class Phone{
    public  static synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("-------------sendEmail");

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

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

}

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();



        new Thread(()->{
            phone.sendEmail();
        },"a").start();

        //暂停200ms 保证a先启动
        try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(()->{
            phone.sendSMS();
        },"b").start();

    }
}

情况8：有1个静态同步方法，1个普通同步方法，有2部phone_，_请问先打印邮件还是短信 ?

class Phone{
    public  static synchronized void sendEmail(){
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("-------------sendEmail");

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

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

}

public class Lock8 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();


        new Thread(()->{
            phone.sendEmail();
        },"a").start();

        //暂停200ms 保证a先启动
        try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(()->{
            phone2.sendSMS();
        },"b").start();

    }
}

锁的说明：

对于被synchronize关键字修饰普通方法。锁是this。
对于被synchronize关键字修饰static方法。锁是类对象。
对于同步方法块。锁的是synchronize（xxx）括号内的对象。
如果锁对象不同，就不会产生锁的竞争。

8种情况解释说明：

情况1,2：
sendEmail 和sendSMS 都是同步方法。而且锁对象都是phone。所以会产生竞争，从代码执行顺序来看，
sendEmail 先执行，那就先获得锁。sendSMS 则等待sendEmail 执行完毕。
情况3：
hello是个普通方法并未和synchronize修饰的sendEmail方法产生锁的争抢。但sendEmail中睡了3秒，所以hello先输出。
情况4：
有两个phone锁对象，sendEmail 和 sendSMS没有锁的竞争。但sendEmail中睡了3秒，所以sendSMS先输出。
情况5，6：
sendEmail 和 sendSMS 都是静态同步方法，锁对象都是当前类对象。sendEmail 会先抢到锁，sendSMS 进行等待。sendEmail先执行。
情况7：
sendEmail 是静态同步方法，锁对象都是当前类对象。sendSMS 是普通同步方法，锁对象是this。两者没有锁的竞争。但sendEmail中睡了3秒，所以sendSMS先输出。
情况8：
虽然有两个phone对象，但是道理还是和情况7一样。

运行结果：

情况1:

-------------sendEmail
-------------sendSMS

情况2：

-------------sendEmail
-------------sendSMS

情况3：

---------hello
-------------sendEmail

情况4：

-------------sendSMS
-------------sendEmail

情况5：

-------------sendEmail
-------------sendSMS

情况6：

-------------sendEmail
-------------sendSMS

情况7：

-------------sendSMS
-------------sendEmail

情况8：

-------------sendSMS
-------------sendEmail

JAVA中synchronized修饰方法的8锁问题
weixin_43907440的博客
04-22 517
JAVA中synchronized锁的总结 前提：phone类中有两个synchronized修饰的同步方法，让两个线程分别去执行这两个方法，判断谁先输出。 //基础代码，线程A\B分别执行send()和call() public class LockDemo { public static void main(String[] args) { Phone phone = ...
12.synchronized的锁重入、锁消除、锁升级原理？无锁、偏向锁、轻量级锁、自旋、重量级锁
chenzengnian123的博客
01-25 3657
什么是偏向锁？什么是轻量级锁？什么是锁自旋？什么是重量级锁？synchronized是怎么从偏向锁、轻量级锁、自旋、重量级锁一步步升级的？
synchronized锁——8锁
weixin_34413065的博客
04-08 185
前言 多线程是Java面试中最喜欢问的问题之一，有一篇公众号推文内容很详细，推荐看看 但凡面试官考“多线程”，一定会问这10个问题！ 本文中仅对synchronized关键字的加锁进行一定分析 一、标准情况访问 按照普通的情况访问同步方法，查看输出 1 class Phone { 2 public synchronized void getIOS() thro...
8锁问题和Synchronized
qq_37032116的博客
06-08 265
8锁问题和Synchronized的底层原理
synchronized - 八锁问题及扩展
江南烟雨却痴缠丶
11-24 1070
通过8锁问题，可以大致清楚synchronized是锁的什么东西。通过对8锁问题的扩展，可以进一步理解synchronized。 8锁问题 1、一个对象，两个synchronized方法，一个方法睡眠 public class LockTest { public static void main(String[] args) { Phone phone = new Phone(); // 一个Phone对象 new Thread(() -> {
synchronize的8锁现象带你彻底了解
烟花易冷
09-12 530
关于锁的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()，而是因为锁的存在
Java 并发编程学习笔记之Synchronized底层优化
09-02
Java并发编程中的...总结来说，Java并发编程中的Synchronized通过各种锁优化策略，如轻量级锁和偏向锁，尽可能减少锁的开销，提高多线程环境下的程序性能。理解这些优化机制对于编写高效的并发代码至关重要。
学习总结：synchronize原理与锁升级过程
weixin_42274562的博客
09-02 1093
关于 synchronize原理与锁升级过程的一些个人理解和总结
java锁-synchronized
qq_29899535的博客
11-26 876
java锁-synchronized关键字 详细讨论java中synchronized关键字底层加锁原理和应用。 文章目录java锁-synchronized关键字前言总结 前言 总结 提示：这里对文章进行总结： 例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。 ...
锁机制学习与总结笔记参考
01-12
例如，在Java中，可以使用`synchronized`关键字或`java.util.concurrent.locks`包下的`ReentrantLock`、`ReadWriteLock`等类来实现锁。在C++中，可以利用`std::mutex`、`std::lock_guard`等标准库来管理锁。 四、...
synchronized的线程八锁问题
蒋大钊的博客
02-04 558
synchronized线程八锁问题可以很好地辨析学习synchronized锁的是哪个对象。
synchronized8锁问题
zds448588952的博客
06-09 178
synchronized8锁问题
synchronized 八锁现象，搞懂 synchronized 的使用问题
小熊
10-13 470
一.同一个对象，两个线程分别调用对象的两个加锁方法 package com.example.demo.module.synchronized8Test; import java.util.concurrent.TimeUnit; public class Test { public static void main(String[] args) { Phone phone = new Phone(); new Thread(phone::sendSms,"A"
Java 多线程中用 synchronized 加锁的八锁问题
Ironhide的博客
09-14 457
看以下代码，有一个 phone 对象，A、B 线程分别调用该对象的方法，问两个方法谁先调用？答：先发短信再打电话，因为 synchronized 锁住的是 phone 对象（锁的对象是方法调用者）。 public static void main(String[] args) throws InterruptedException { phone phone = new phone(); new Thread(() -> { phone.sendMsg(); .
synchronized八锁现象理解
lczcxyit的博客
04-19 1913
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
多线程synchronized对象锁与静态锁之间的8锁问题理解
m0_52889702的博客
02-02 692
8锁问题 锁1：多个线程使用同一对象分别调用不同带有带synchronized关键字且非静态的方法 锁2：在锁1基础上，增加A线程执行的方法的执行时间，使得B有机会参与执行 锁3：多个线程使用同一对象，一个线程执行带有对象锁的方法，一个线程执行普通方法 锁4：多个线程使用不同对象分别调用不同带有对象锁的方法 锁5：多个线程同一个对象分别调用对各自静态锁的方法 锁6：多个线程同多个对象分别调用对各自静态锁的方法 锁7：多个线程同一个对象分别调用对象锁的方法和静态锁的方法 锁8：多个线程不同对象分别调用对象锁的
JAVA并发编程的8锁问题（synchronized，static synchronized和普通方法调用）
Dream_6666的博客
08-22 278
通过示例说明：（注意代码中的延时问题） 情况1、2 /* 8锁，就是锁的8个问题 1.标准情况下（只有上面的延迟），两个线程先打印发短信还是打电话? 1.发短信 2.打电话 （锁的是同一个对象即方法的调用者，所以是并发） 2.sendSms延迟4秒，两个线程先打印发短信还是打电话? 1.发短信 2.打电话 （锁的是同一个对象即方法的调用者，所以是并发），synchronized 锁的对象是方法的调用者！ */ public class Test1 {
JUC：synchronized详解与线程八锁问题解析
Cosmoshhhyyy的博客
03-28 1102
本章详细介绍了synchronized锁的使用和原理，同时包含线程八锁问题的解析帮我们更好的理解他的作用。
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1626
synchronized关键字到底锁的是谁？
synchronized锁是什么
最新发布
03-21
最后，生成相关问题时要围绕synchronized的关键作用、优化方法、与其他锁机制的区别等，确保问题有助于用户进一步学习。例如，如何避免死锁，或者synchronized和ReentrantLock的对比。 总结一下，回答的结构应该...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值