JUC（4）八锁现象（关于锁的8个问题）

最新推荐文章于 2023-04-11 22:17:58 发布
最新推荐文章于 2023-04-11 22:17:58 发布
阅读量1.7k 收藏
点赞数 1
分类专栏： # 多线程与并发编程 文章标签： 锁的是谁 关于锁的8个问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/109996519
版权

文章目录

  • 锁是什么，如何判断锁的是谁?
  • 8锁，就是关于锁的8个问题

一、问题1与问题2

  • 问题一：标准情况下，下面的AB两个线程哪个先执行？ 发消息？ or 打电话？
  • 问题一答：总是先执行 发消息send() 再执行打电话call()。（为什么？ 如果你认为是顺序在前？ 这个答案是错误的！）
  • 问题二：让send() 方法休眠4s，此时AB两个线程哪个先执行？
  • 问题二答：还是先执行 发消息send() 再执行打电话call()
  • 为什么：
    • 因为，使用synchronized加锁，synchronized 锁的对象是方法的调用者! 两个方法用的是同一个锁， 谁先拿到谁执行，AB两个线程里面的方法是同一个对象调用的（这也是synchronized锁的特性，两个线程，线程A和线程B，如果当前线程A获得锁，线程B线程等待。如果线程A阻塞，线程B则会一直等待下去）
package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 问题1.标准情况下，下面的AB两个线程哪个先执行？ 发消息？ or 打电话？
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{phone.send();},"A").start();
        //休息1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone.call();},"B").start();
    }
}
class Phone{
    public synchronized void send(){
        System.out.println("发消息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}


package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 问题1.标准情况下，下面的AB两个线程哪个先执行？ 发消息？ or 打电话？
 * 问题2：让send() 方法休眠4s，此时AB两个线程哪个先执行？
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{phone.send();},"A").start();
        //休息1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone.call();},"B").start();
    }
}

class Phone{
    //synchronized 锁的对象是方法的调用者! .
    //两个方法用的是同一个锁， 谁先拿到谁执行。
    public synchronized void send(){
        //休眠4s
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

二、 问题3与问题4

  • 问题3：增加了一个普通方法后! 先执行发短信还是Hello? （调用方法的对象是同一个）
  • 问题三回答：先执行普通方法
  • 为什么：
    • 因为，hello是一个普通方法，不受synchronized锁的影响
  • 问题4：两个对象，两个同步方法，分两个线程执行，发短信还是 打电话?
  • 问题四答：先打电话，（发短信的休眠了4秒，如果没有休眠，应该是看代码执行顺序）
  • 为什么：
    • 先打电话，后发短信。原因：在发短信方法中延迟了4s，又因为synchronized锁的是对象，但是我们这使用的是两个对象，所以每个对象都有一把锁，所以不会造成锁的等待。正常执行
package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 问题3：加一个不带synchronized的普通的hello()方法，谁先执行
 */
public class Test2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        new Thread(()->{phone.send();},"A").start();

        //休息1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

}

class Phone2{

    //synchronized 锁的对象是方法的调用者!
    //两个方法用的是同一个锁， 谁先拿到谁执行。
    public synchronized void send(){
        //休眠4s
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

    //hello是一个普通方法，不受synchronized锁的影响
    public void hello(){
        System.out.println("hello");
    }
}


package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 问题3：加一个不带synchronized的普通的hello()方法，谁先执行
 * 问题4：两个对象，两个同步方法，发短信还是 打电话?  //先打电话，后发短信。原因：在发短信方法中延迟了4s，又因为synchronized锁的是对象，但是我们这使用的是两个对象，所以每个对象都有一把锁，所以不会造成锁的等待。正常执行
 */
public class Test2 {
    public static void main(String[] args) {
        //两个对象，两个方法的调用者，两把锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{phone1.send();},"A").start();

        //休息1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{phone2.call();},"B").start();
    }

}

class Phone2{

    //synchronized 锁的对象是方法的调用者!
    //两个方法用的是同一个锁， 谁先拿到谁执行。
    public synchronized void send(){
        //休眠4s
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

    //hello是一个普通方法，不受synchronized锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

三、 问题5与问题6

  • 如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？
  • 问题5：我们先来使用一个对象调用两个方法！
  • 问题5答：先发短信,后打电话
  • 问题6：如果我们使用两个对象调用两个方法！
  • 问题6答：还是先发短信，后打电话
  • 为什么：为什么加了static就始终前面一个对象先执行呢！为什么后面会等待呢？
    • 原因是：对于static静态方法来说，对于整个类Class来说只有一份，对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，如果静态static方法使用synchronized锁定，那么这个synchronized锁会锁住整个类！不管这个类多少个实例对象，对于静态的锁都只有一把锁，谁先拿到这个锁就先执行，其他的进程都需要等待！
package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 *如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？
 * 问题5：我们先来使用一个对象调用两个方法！ 答：先发短信,后打电话
 */
public class Test3 {
    public static void main(String[] args) {
        Phone3 phone = new Phone3();
        
        new Thread(()->{phone.send();},"A").start();

        //休息1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{phone.call();},"B").start();
    }
}

//Phone3 这个类 只有一个唯一的 Class 对象
class Phone3{

    // synchronized 锁的对象是方法的调用者!
    // static 静态方法
    //类一加载就有了! 此时锁的是CLass
    public static synchronized void send(){
        //休眠4s
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }
}

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 *如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？
 * 问题5：我们先来使用一个对象调用两个方法！ 答：先发短信,后打电话
 * 问题6：如果我们使用两个对象调用两个方法！答：还是先发短信，后打电话
 */
public class Test3 {
    public static void main(String[] args) {
        //两个对象的Class类只有一个，因为加了static，锁的是Class（而不是具体的对象）
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        new Thread(()->{phone1.send();},"A").start();

        //休息1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{phone2.call();},"B").start();
    }
}

//Phone3 这个类 只有一个唯一的 Class 对象
class Phone3{

    // synchronized 锁的对象是方法的调用者!
    // static 静态方法
    //类一加载就有了! 此时锁的是CLass
    public static synchronized void send(){
        //休眠4s
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }
}

四、问题7与问题8

  • 问题7：如果我们使用一个静态同步方法（加static）、一个同步方法（不加static）、一个对象调用顺序是什么？
  • 问题7答：先打电话，后发短信了。
  • 为什么：
    • 原因：因为一个锁的是Class类模板，一个锁的是对象调用者。后面那个打电话不需要等待发短信，直接运行就可以了。（有两把锁，和问题四类似）
  • 问题8：如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么呢？
  • 问题8答：先打电话、后发短信！
  • 为什么：
    • 原因：因为两个对象，一样的原因，两把锁锁的不是同一个东西，所以后面的第二个对象不需要等待第一个对象的执行。
package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 问题7：如果我们使用一个静态同步方法（加static）、一个同步方法（不加static）、一个对象调用顺序是什么？
 *  先打电话，后发短信了。
 */
public class Test4 {
    public static void main(String[] args) {

        Phone4 phone = new Phone4();

        new Thread(()->{phone.send();},"A").start();

        //休息1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{phone.call();},"B").start();
    }

}

//Phone3 这个类 只有一个唯一的 Class 对象
class Phone4{

    // synchronized 锁的对象是方法的调用者!
    // static 静态方法
    //类一加载就有了! 此时锁的是Class模板 (只有一个)
    public static synchronized void send(){
        //休眠4s
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    //普通的同步方法，锁的是 具体的类的实例对象
    public synchronized void call(){
        System.out.println("打电话");
    }

}

package com.wlw.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 问题7：如果我们使用一个静态同步方法（加static）、一个同步方法（不加static）、一个对象调用顺序是什么？
 *  先打电话，后发短信了。
 *问题8：如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么呢？
 * 先打电话，后发短信了。
 */
public class Test4 {
    public static void main(String[] args) {

        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(()->{phone1.send();},"A").start();

        //休息1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{phone2.call();},"B").start();
    }

}

//Phone3 这个类 只有一个唯一的 Class 对象
class Phone4{

    // synchronized 锁的对象是方法的调用者!
    // static 静态方法
    //类一加载就有了! 此时锁的是Class模板 (只有一个)
    public static synchronized void send(){
        //休眠4s
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }

    //普通的同步方法，锁的是 具体的类的实例对象
    public synchronized void call(){
        System.out.println("打电话");
    }

}

五、小结

  • 锁的是什么东西？
    • 只加synchronized的同步方法，锁的是 new出来的实例对象
    • 加了static的synchronized同步方法。锁的是一个类的Class类模板（Class对象）
悬浮海
关注
专栏目录
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
【Java多线程】JUC之显示锁(Lock)与初识AQS(队列同步器)
墩墩分墩
11-22 1336
**锁机制用于保证操作的原子性、可见性、顺序性**。`JDK1.5的concurrent并发包`中新增了`Lock接口以及相关实现类来实现锁功能`，最明显的特性就是需要显式的申请锁和释放锁。比synchronized更加灵活。 >显示锁的释放锁的操作一定要放到finally块中，否则可能会因为异常导致锁永远无法释放！这是显式锁最明显的缺点。
1 JUC（高并发）
wang_luwei的博客
10-06 751
文章目录1.什么是JUC2.进程和线程3.并发与并行4.线程的状态（六个）5.wait/sleep的区别6.Lock锁与Synchronized（重点）6.1传统的Synchronized （关键字）6.2lock锁 （lock是一个接口）6.2.1 ReentrantLock 可重入锁中的公平锁与非公平锁6.2.2 与6.1不同的加锁方式的买票案例6.3Synchronized 和 Lock区别7.生产者与消费者问题（线程通信）7.1传统版本，用Synchronized实现的7.1.1存在的问题(虚假唤醒
JUC高并发与线程安全(1)
weixin_45075077的博客
12-29 425
JUC高并发 1、谈谈你对volatile的理解 1.1volatile是Java虚拟机提供的轻量级的同步机制 1.1.1保证可见性 在内存模型中，线程将自身需要的对象数据从主机物理内存拷贝到线程工作内存（实际仍在物理内存，虚拟的划分约定），当线程对数据的修改经历三个步骤： 从物理内存拷贝数据到工作内存 在执行线程中修改数据 将数据写回物理内存 数据写完后，需要及时的通知其他需要此对象的线程，...
JUC高并发编程
LIAO_YUANLONG的博客
04-26 480
JUC高并发编程 线程和进程的概念 进程和线程 进程：是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是操作系统进行资源分配和调度的一个独立单位； 线程：是进程的一个实体，是CPU调度和分派的基本单位，是比进程更小的能独立运行的基本单位。线程的划分尺度小于进程，这使得多线程程序的并发性高；进程在执行时通常拥有独立的内存单元，而线程之间可以共享内存。 线程的状态 NEW（新建） RUNNABLE（准备就绪） BLOCKED（阻塞） WAITING（不见不散） TIMED_WAITING（过时不候）
JUC_公平锁/非公平锁/可重入锁/递归锁/自旋锁/读写锁
Chill Lyn
05-12 339
公平锁/非公平锁 公平锁是指多个线程按照申请锁的顺序来获取锁，类似队列，先进先出 非公平锁是指在多线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取到锁,在高并发的情况下,有可能造成优先级反转或者饥饿现象 ReentrantLock可以通过构造函数指定采用哪种方式，默认是非公平锁 非公平锁的优点是吞吐量比公平锁大 可重入锁（递归锁） 同一线程外层函数获得锁之后，内层递归函数仍然能获得该锁的代码，在同一线程的外层方法获取锁的时候，在进入内层方法会自动获取锁，也就是说，线程可以
Java——聊聊JUC中的锁（synchronized & Lock & ReentrantLock）
java_lujj的博客
09-12 355
这篇文章是关于锁的，是入门级别的文章，后续还会有更深入、更底层的JUC，我会慢慢更新的。。。
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
最新发布
07-26
4. **锁绑定条件**：ReentrantLock可以通过newCondition()创建多个条件变量，每个条件对应一组线程，而synchronized只有一个隐含的条件。 5. **锁的粒度**：ReentrantLock的锁可以更细粒度地控制，比如可以只锁住...
高级技术之 JUC 高并发编程
qq_40823822的博客
03-13 296
JUC
学习JUC高并发编程这一篇就够了（上篇）
Laptoy的博客
03-22 591
Lock，线程安全，八锁，多线程锁，线程通信详解
8锁，就是关于锁的8个问题
weixin_45752694的博客
09-17 269
synchronized 锁的对象是方法的调用者,经过8锁问题能更加理解这个概念
JUC高并发
qq_32388061的博客
04-11 1725
JVM中同步的实现是基于进入和推出监视器对象（Monitor，管程对象）来实现的，每个对象实例都会有一个Monitor对象。是一种特殊的线程，为其它线程服务，在后台默默地完成一些系统性的服务，比如垃圾回收线程就是最典型的例子。凡是包含handle的，有入参有返回结果，且入参包括了上一步的结果和异常。run入参是Runnable，这个函数式接口的run方法无入参，无返回值；适合写操作多的场景，先加锁可以保证数据的正确性，但是比较重，比较吃性能。适合读操作多的场景，操作时不会加锁，性能相对较高，但是安全性低。
多线程(三)关于锁的8个问题
sand_wich的博客
08-02 410
目录1、标准情况下，两个线程先打印哪个2、sendSms延迟四秒，执行顺序3、增加一个普通方法后，先发短信还是先hello；4、两个对象，两个同步方法，发短信还是打电话5.增加两个静态的同步方法6、两个对象，增加两个静态的同步方法7、一个静态同步方法，一个普通同步方法，先打印谁8、一个静态同同步方法，一个普通同步方法，两个对象 1、标准情况下，两个线程先打印哪个 使用synchronized锁 public class Test1 { public static void main(String[]
JUC多线程和高并发
Funny_Ma的博客
10-16 1085
JUC多线程及高并发 文章目录JUC多线程及高并发一、请你谈谈对volatile的理解1、volatile是java虚拟机提供的轻量级的同步机制2、JMM（java内存模型）3、你在那些地方用过volatile二、CAS你知道吗1、compareAndSet----比较并交换2、CAS底层原理？对Unsafe的理解3、CAS缺点三、原子类AtomicInteger的ABA问题？原子更新引用？1、A...
回归本质，关于锁的8个问题
秀
08-01 122
关于锁的8个问题 1、标准状态下先打印发短信还是打电话 发短信 synchronized锁的是方法的调用者，只有1把锁 package com.ShengChanXiaoFei; import java.util.concurrent.TimeUnit; public class EightSuo { public static void main(String[] args) throws InterruptedException { /* *
JUC扩展（高并发）
kubichengxuyuanz的博客
08-28 848
JUC概述： 在java5.0中提供了java.util.current包（简称juc），中提供了许多在并发编程工程中常用的工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO、轻量级框架、还提供了多线程上下文的Collectiion的实现。 Volatile:异变的，不稳定的 volatile：当多个线程并发操作数据时，可以保证内存中的数据可见性，相较于synchronized是一个较...
Java并发编程：深入理解锁机制与JUC包
这些锁类型具有不同的语义，如公平锁（所有线程按照请求顺序获取锁）、非公平锁（更快但可能不保证线程顺序）、重入锁（一个线程可以多次获取同一锁）。`ReentrantLock`是`Lock`接口的一个实现，它提供了可中断、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值