synchronized 8锁的现象

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量38 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41915280/article/details/133256077
版权

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

     /**
     * 多线程的8锁
     * 1、标准访问，请问先打印邮件还是短信？
     */
    public class Lock8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            new Thread(() -> {
                try {
                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "A").start();
            Thread.sleep(200);
            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");
        }
    }
结论：被 synchronized 修饰的方法，锁的对象是方法的调用者。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行。

2、邮件方法暂停4秒钟，请问先打印邮件还是短信？ 

    /**
     * 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
     */
    public class Lock8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            new Thread(() -> {
                try {
                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "A").start();
            Thread.sleep(200);
            new Thread(() -> {
                try {
                    phone.sendSMS();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "B").start();
        }
    }

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

        public synchronized void sendSMS() throws Exception {
            System.out.println("sendSMS");
        }
    }
结论：被 synchronized 修饰的方法，锁的对象是方法的调用者。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行，第二个方法只有在第一个方法执行完释放锁之后才能执行。

3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？ 

    /**
     * 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？
     */
    public class Lock8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            new Thread(() -> {
                try {
                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "A").start();
            Thread.sleep(200);
            new Thread(() -> {
                try {
            // phone.sendSMS();
                    phone.hello();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "B").start();
        }
    }
    class Phone {
        public synchronized void sendEmail() throws Exception {
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendEmail");
        }
        public synchronized void sendSMS() throws Exception {
            System.out.println("sendSMS");
        }
        public void hello() {
            System.out.println("Hello");
        }
    }
结论：新增的方法没有被 synchronized 修饰，不是同步方法，不受锁的影响，所以不需要等待(先打印Hello 后打印邮件)。其他线程共用了一把锁，所以还需要等待。

4、两部手机、请问先打印邮件还是短信？

    /**
     * 4、两部手机、请问先打印邮件还是短信？
     */
    public class Lock8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            Phone phone2 = new Phone();
            new Thread(() -> {
                try {
                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "A").start();
            Thread.sleep(200);
            new Thread(() -> {
                try {
                    // phone.sendSMS();
                    // phone.hello();
                    phone2.sendSMS();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "B").start();
        }
    }

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

        public synchronized void sendSMS() throws Exception {
            System.out.println("sendSMS");
        }
    }
结论：被 synchronized 修饰的方法，锁的对象是方法的调用者。因为用了两个对象调用各自的方法，所以两个方法的调用者不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。(先打印sendSMS)

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

    /**
     * 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？
     */
    public class Lock8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            new Thread(() -> {
                try {
                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "A").start();
            Thread.sleep(200);
            new Thread(() -> {
                try {
                    phone.sendSMS();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "B").start();
        }
    }

    class Phone {
        public static synchronized void sendEmail() throws Exception {
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendEmail");
        }
        public static synchronized void sendSMS() throws Exception {
            System.out.println("sendSMS");
        }
    }
结论：被 synchronized 和 static 修饰的方法，锁的对象是类的 class 对象。因为两个同步方法都被 static修饰了，所以两个方法用的是同一个锁，后调用的方法需要等待先调用的方法.(先打印sendEmail)

6、两个静态同步方法，2部手机，请问先打印邮件还是短信？ 

    /**
     * 6、两个静态同步方法，2部手机，请问先打印邮件还是短信？
     */
    public class Lock8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            Phone phone2 = new Phone();
            new Thread(() -> {
                try {
                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "A").start();
            Thread.sleep(200);
            new Thread(() -> {
                try {
                    phone2.sendSMS();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "B").start();
        }
    }

    class Phone {
        public static synchronized void sendEmail() throws Exception {
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendEmail");
        }
        public static synchronized void sendSMS() throws Exception {
            System.out.println("sendSMS");
        }
    }
结论：被 synchronized 和 static 修饰的方法，锁的对象是类的 class 对象。因为两个同步方法都被 static 修饰了，即便用了两个不同的对象调用方法，两个方法用的还是同一个锁，后调用的方法需要等待先调用的方法。(先打印sendEmail)

7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？ 

 /**
     * 7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？
     */
    public class Lock8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            new Thread(() -> {
                try {
                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "A").start();
            Thread.sleep(200);
            new Thread(() -> {
                try {
                    phone.sendSMS();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "B").start();
        }
    }

    class Phone {
        public static synchronized void sendEmail() throws Exception {
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendEmail");
        }
        public synchronized void sendSMS() throws Exception {
            System.out.println("sendSMS");
        }
    }
结论：被 synchronized 和 static 修饰的方法，锁的对象是类的 class 对象。仅仅被 synchronized 修饰的方法，锁的对象是方法的调用者。因为两个方法锁的对象不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。(先打印sendSMS)

8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？

/**
     * 8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？
     */
    public class Lock8 {
        public static void main(String[] args) throws InterruptedException {
            Phone phone = new Phone();
            Phone phone2 = new Phone();
            new Thread(() -> {
                try {
                    phone.sendEmail();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "A").start();
            Thread.sleep(200);
            new Thread(() -> {
                try {
                    phone2.sendSMS();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "B").start();
        }
    }

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

        public synchronized void sendSMS() throws Exception {
            System.out.println("sendSMS");
        }
    }
结论：被 synchronized 和 static 修饰的方法，锁的对象是类的 class 对象。仅仅被 synchronized修饰的方法，锁的对象是方法的调用者。即便是用同一个对象调用两个方法，锁的对象也不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。(先打印sendSMS)

总结

new this 具体的一个手机
static class 唯一的一个模板
如果锁的对象是同一个，那么一个方法执行前需要等待另一个方法释放锁，如果锁的对象不是同一个，那么两个方法执行不需要等待彼此释放锁。
当synchronized修饰实例方法，锁的对象是方法的实例。
        这种情况下创建出了一个实例，锁的是一个实例，用这个对象调用两个同步实例方法，它们共用的是一把锁。
        创建出两个实例，锁的对象是两个实例，分别调用两个同步方法，它们用的是两个不同的锁。
当synchronized修饰静态方法，锁的对象是当前类。会作用于类的所有对象实例 。
        所以这种情况下不论创建几个对象，锁的对象都是同一个Class。
一个类里同时存在synchronized修饰的实例方法和静态方法，锁的对象是同一个吗？
        显然，从7、8可知实例同步方法是有根据实例创建锁的，有几个实例就有几个锁，静态
同步方法是根据类创建锁的，一个类只有一把锁，因此实例方法和静态方法锁的是不同对象。
没有synchronized修饰的方法是普通方法，不受锁的影响。
一个对象里面如果有多个synchronized方法，某个时刻内，只要一个线程去调用其中一个synchronized方法了，其他的线程都要等待，换句话说，在某个时刻内，只能有唯一一个线程去访问这些synchronized方法，锁的是当前对象this，被锁定后，其他的线程都不能进入到当前对象的其他的synchronized方法
加个普通方法后发现和同步锁无关，换成两个对象后，不是同一把锁，情况立刻变化
都换成静态同步方法后，情况又变化了。所有的非静态的同步方法用的都是同一把锁----实例对象本身
synchronized实现同步的基础： java中的每一个对象都可以作为锁
具体的表现为以下三种形式：
对于普通同步方法，锁的是当前实例对象
对于静态同步方法，锁的是当前的Class对象。
对于同步方法块，锁是synchronized括号里面的配置对象
当一个线程试图访问同步代码块时，他首先必须得到锁，退出或者是抛出异常时必须释放锁，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁
所有的静态同步方法用的也是同一把锁----类对象本身
非静态同步和静态同步的锁 这两把锁的是两个不同的对象，所以静态的同步方法与非静态的同步方法之间是不会有竞争条件的，但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要他们用一个的是同一个类的实例对象 (列6)

高老庄小呆子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
synchronized锁住的范围
爪哇岛咖啡种植农场
03-05 697
synchronized
Java中的关键字synchronized 详解
08-26
在这种情况下，synchronized锁的对象实例。 2、修饰静态方法 synchronized关键字也可以修饰静态方法，以便保护类中的静态资源。例如： ```java private static synchronized void synMethod() { // 方法体 } ```...
JUC并发编程 常用锁 三个辅助类的使用
Andrew0219的博客
08-12 156
1
synchronize的8锁现象带你彻底了解
烟花易冷
09-12 417
关于锁的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()，而是因为锁的存在
八锁现象带你了解 synchronized 到底是锁什么？
qq_44613591的博客
11-09 381
什么是八锁现象？ 八锁现象就是加锁的地方不一样，像加在普通方法，静态方法等，可以帮我们搞懂锁锁住的东西是什么。 第一种：标准情况下，两个线程先打印 发短信还是 打电话？ //标准情况下，两个线程先打印 发短信还是 打电话？ public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); //锁的存在 new Thread(()-
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1500
synchronized关键字到底锁的是谁？
synchronized八锁现象理解
lczcxyit的博客
04-19 1845
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
synchronized 八锁现象，搞懂 synchronized 的使用问题
小熊
10-13 387
一.同一个对象，两个线程分别调用对象的两个加锁方法 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"
synchronized：锁的对象到底是谁？快速理解八锁现象
saya21的博客
07-24 909
通过总结和例子帮助快速理解八锁现象。
互斥锁 Synchronized
雪人奥特曼的博客
05-17 373
使用锁来保护资源，首先需要确定锁和被保护资源的关系。为被保护资源R创建一把锁LR，然后再操作被保护资源R的时候对R进行加锁和解锁处理。 java语言提供的所技术：synchronized synchronized关键字，是锁的一种实现，可以用来修饰方法，代码块。为了确保lock() 和 unlock() 的成对出现。synchronized中内置了lock() 和 unlo...
Synchronized 同步锁详解
qq_56263094的博客
07-21 1463
Synchronized是JAVA的关键字，是基于JVM层面的独占式的悲观锁，同时也属于可重入锁经常来用于解决多个线程之间访问访问资源的同步性，保证在同一时刻只有一个线程访问这个资源。
详解Java中synchronized关键字的死锁和内存占用问题
09-02
通过实验验证，可以创建一个类，定义两个`synchronized`方法，然后启动两个线程分别调用这两个方法，观察是否出现锁竞争现象，从而确认这个隐形锁的存在。 总之，理解和合理使用`synchronized`关键字是Java多线程...
Java编程synchronized与lock的区别【推荐】
08-29
Lock 的使用需要手动释放锁，否则可能会导致死锁现象。Lock 提供了多种方法来获取锁，例如 lock()、tryLock()、tryLock(long time, TimeUnit unit) 等。 结论 synchronized 和 Lock 都可以实现同步访问，但是 Lock...
关于synchronized、Lock的深入理解
12-21
2. **非公平性**：`synchronized`采用的锁获取策略是非公平的，即线程获取锁的顺序并不保证是等待时间最长的线程优先，可能导致饥饿现象。 为了解决这些问题，Java提供了`Lock`接口，其中`ReentrantLock`是其最常见...
java synchronized 学习
12-03
Synchronized 同步锁的作用是解决多线程访问实例变量时可能造成的数据脏读现象。Synchronized 的使用方法有四种： 1. synchronized 修饰普通方法 2. synchronized 修饰普通代码块 3. synchronized 修饰静态方法 4. ...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 419
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 765
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 557
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 253
android apk 加固后的地图加载异常及重新签名
synchronized为什么是非公平锁
09-13
1. 不公平性：非公平锁可能导致某些线程长时间处于等待状态，而其他线程反复获取锁，造成线程饥饿现象。 2. 可能产生优先级倒置：如果高优先级的线程在一直等待低优先级的线程释放锁时，可能会导致优先级倒置的问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值