多线程锁-8锁案例编码演示

原创 已于 2023-10-08 22:17:53 修改 · 289 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

于 2023-10-07 23:30:45 首次发布
本文通过8个具体的多线程锁案例，包括标准访问、暂停操作、同步方法与同步代码块等，深入浅出地探讨了锁在Java中的工作原理。总结得出：普通同步方法锁定当前实例对象，静态同步方法锁定类的Class对象，同步方法块则根据括号内指定的对象决定锁的对象。

3.2 通过8种情况演示锁运行案例，看看锁到底是什么

3.2.1 锁相关的8种案例演示code

1.标准访问ab两个线程，请问先打印邮件还是短信？

package com.nanjing.gulimall.zhouyimo.test;

import java.util.concurrent.TimeUnit;

/**
 * @author zhou
 */

//资源类，口诀：线程操作资源类
class Phone {
    public synchronized void sendEmail() {
        System.out.println("------sendEmail");
    }

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

}

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

        //暂停毫秒，保证A线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

        //1 标准访问ab两个线程，请问先打印邮件还是短信？
        /*------sendEmail
        ------sendSMS*/
        //先邮件，后短信  共用一个对象锁
    }
}

2. sendEmail钟加入暂停3秒钟，请问先打印邮件还是短信？ 

package com.nanjing.gulimall.zhouyimo.test;

import java.util.concurrent.TimeUnit;

/**
 * @author zhou
 */

//资源类，口诀：线程操作资源类
class Phone {
    public synchronized void sendEmail() {
        //暂停3秒钟
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

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

}

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

        //暂停毫秒，保证A线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

        //2. sendEmail钟加入暂停3秒钟，请问先打印邮件还是短信？
        /*------sendEmail
        ------sendSMS*/
        //依然是先邮件，后短信  共用一个对象锁
    }
}

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

package com.nanjing.gulimall.zhouyimo.test;

import java.util.concurrent.TimeUnit;

/**
 * @author zhou
 */

//资源类，口诀：线程操作资源类
class Phone {
    public synchronized void sendEmail() {
        //暂停3秒钟
        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 Lock8Demo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        },"A").start();

        //暂停200毫秒，保证A线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


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

        //3. 添加一个普通的hello方法，请问先打印普通方法还是邮件？
        /*
        ------hello
        ------sendEmail*/
        //程序执行在sendEmail()中锁了并在方法中睡3秒，外部在睡200毫秒后调用hello()，因为无锁因此直接执行
    }
}

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

package com.nanjing.gulimall.zhouyimo.test;

import java.util.concurrent.TimeUnit;

/**
 * @author zhou
 */

//资源类，口诀：线程操作资源类
class Phone {
    public synchronized void sendEmail() {
        //暂停3秒钟
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

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

}

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

        //暂停200毫秒，保证A线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


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

        //4. 有两部手机，请问先打印邮件还是短信？
        /*
        ------sendSMS
        ------sendEmail*/
        //程序调用sendEmail()时锁住phone，外部睡1秒后调用sendSMS()时锁phone2，互不影响
    }
}

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

package com.nanjing.gulimall.zhouyimo.test;

import java.util.concurrent.TimeUnit;

/**
 * @author zhou
 */

//资源类，口诀：线程操作资源类
class Phone {
    public static synchronized void sendEmail() {
        //暂停3秒钟
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

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

}

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

        //暂停200毫秒，保证A线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


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

        //5. 有两个静态同步方法，一步手机， 请问先打印邮件还是短信？
        /*
        ------sendEmail
        ------sendSMS*/
        //这里多了静态static，因此此时锁的东西改变了，sendEmail()和sendSMS()都是锁的Phone这个class，
        //程序在执行sendEmail()时锁住Phone class，睡200毫秒后调用sendSMS()，sendSMS()等待sendEmail()内睡完释放锁后再执行
        
    }
}

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

package com.nanjing.gulimall.zhouyimo.test;

import java.util.concurrent.TimeUnit;

/**
 * @author zhou
 */

//资源类，口诀：线程操作资源类
class Phone {
    public static synchronized void sendEmail() {
        //暂停3秒钟
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

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

}

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

        //暂停200毫秒，保证A线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


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

        //6. 有两个静态同步方法，两部手机， 请问先打印邮件还是短信？
        /*
        ------sendEmail
        ------sendSMS*/
        //要注意的是，不管现在new结果对象，调用方法后锁的都是Phone class，sendSMS()会被sendEmail()阻塞

    }
}

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

package com.nanjing.gulimall.zhouyimo.test;

import java.util.concurrent.TimeUnit;

/**
 * @author zhou
 */

//资源类，口诀：线程操作资源类
class Phone {
    public static synchronized void sendEmail() {
        //暂停3秒钟
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

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

}

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

        //暂停200毫秒，保证A线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


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

        //7. 有一个静态同步方法 一个普通同步方法，1部手机，请问先打印邮件还是短信？
        /*
        ------sendSMS
        ------sendEmail*/
        //同样只要确认锁的是不是一个东西就知道会不会阻塞，调用sendEmail()时阻塞的是Phone class，调用sendSMS()时阻塞的是phone

    }
}

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

package com.nanjing.gulimall.zhouyimo.test;

import java.util.concurrent.TimeUnit;

/**
 * @author zhou
 */

//资源类，口诀：线程操作资源类
class Phone {
    public static synchronized void sendEmail() {
        //暂停3秒钟
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

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

}

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

        //暂停200毫秒，保证A线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


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

        //8. 有一个静态同步方法，一个普通同步方法，两部手机，请问先打印邮件还是短信？
        /*
        ------sendSMS
        ------sendEmail*/
        //解题跟7一致，调用sendEmail()时阻塞的是Phone class，调用sendSMS()时阻塞的是phone2，一个类锁一个对象锁

    }
}

​​分析：

结论：

1.对于普通同步方法，锁的是当前实例对象，通常指this，所有的同步方法用的

都是同一把锁--->实例对象本身

2.对于静态同步方法，锁的时当前类的Class对象

3.对于同步方法块，锁的时synchronized括号内的对象

多线程8锁问题-优快云博客

线程八锁-优快云博客​​​​​​​

多线程编程全攻略：提升性能与线程安全的必备知识
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
10-14 10万+
介绍多线程编程的相关概念、同步机制以及无锁编程。从线程的基础概念出发，包括逻辑线程和硬件线程的比较，以及线程、核心和函数的关系。随后，我们探讨了多线程编程的基本原则，包括时间分片、上下文切换、线程安全函数和可重入函数等。接着，我们讨论了为什么需要多线程同步、什么情况需要进行同步以及多线程同步的方式，包括串行化、原子操作和锁等。我们还深入研究了非阻塞的无锁同步机制，如CAS循环和无锁数据结构。最后，我们解释了程序序、内存序、乱序执行、存储缓冲区和失效队列等概念，以帮助更好地理解多线程编程。
精选资源
Java编程期末考试重点与代码案例复习 - 面向对象编程、异常处理、IO、多线程和集合
01-08
最后则涉及到较为复杂的多线程编程，给出了让两个不同线程交错打印1~5的方法，体现了并发控制的知识点。每一个示例都配有实际可运行的代码片段，使理论与实操得以紧密结合。 适合人群：正在备战 Java 考试的学生，...
多线程8锁案例演示
KEELON的博客
08-31 379
比如代码中A线程持有A锁，希望获得B锁，B锁又被B线程持有，B锁又希望或者A，他们都获得不得想要的锁，只能等待了。非公平锁是，是指的多个线程获取锁的顺序并不是按照申请锁的顺序，有个后申请锁的顺序的线程优先或许锁。在方法上加的锁，都是对象锁，一旦一个线程进入某个被锁的方法，其他线程也不能进入其他枷锁的方法。公平锁 是指多个线程按照申请锁的顺序来获取锁。可冲入锁，又名递归锁。wait进入等待是时候，释放所持有的锁，等待其他线程notify唤醒。类锁锁的事整个类，即该类new出来的其他对象都是持有相同的锁。...
多线程synchronized对象锁与静态锁之间的8锁问题理解
m0_52889702的博客
02-02 740
8锁问题 锁1：多个线程使用同一对象分别调用不同带有带synchronized关键字且非静态的方法 锁2：在锁1基础上，增加A线程执行的方法的执行时间，使得B有机会参与执行 锁3：多个线程使用同一对象，一个线程执行带有对象锁的方法，一个线程执行普通方法 锁4：多个线程使用不同对象分别调用不同带有对象锁的方法 锁5：多个线程同一个对象分别调用对各自静态锁的方法 锁6：多个线程同多个对象分别调用对各自静态锁的方法 锁7：多个线程同一个对象分别调用对象锁的方法和静态锁的方法 锁8：多个线程不同对象分别调用对象锁的
经典 8 锁问题
yage124的博客
05-15 425
示例代码 1、资源类 import java.util.concurrent.TimeUnit; public class Phone { // 此方法根据题目需要添加 static public synchronized void sendSMS() { // 使用 TimeUnit 工具类执行 sleep 方法，比 Thread.sleep(毫秒)， // 方便控制输入的时间单位 // 根据题目要求设置该方法的休眠时间 try { TimeUnit.SEC
Java多线程——线程八锁案例分析
qq_15138049的博客
06-13 287
摘要：本文主要学习了多线程并发中的一些案例。 部分内容来自以下博客： https://blog.youkuaiyun.com/dyt443733328/article/details/80019352 多线程的八个案例 通过分析代码，推测打印结果，并运行代码进行验证。 1）两个线程调用同一个对象的两个同步方法 代码如下： 1 public class Demo { 2 public static void main(String[] args) { 3 Number ...
多线程8锁问题 详解
weixin_45631253的博客
04-08 252
多线程8锁问题详解 1.案例准备 首先我们准备一个资源类，在资源类定义两个同步方法，来测试在不同的访问方式下， 会产生什么样的结果。代码如下： class MyPhone { public synchronized void sendEmail() { // 发送邮件 System.out.println("----sendEmail"); } // 发送短信 public synchronized void sendMS() {
c++11多线程实现libx264编码
12-19
5. **Testx264_01**：这个文件很可能是实验或示例代码，用于演示如何使用C++11的多线程功能来并行执行libx264编码。可能包含了线程创建、数据传递、同步机制的实现等关键部分。通过分析和运行这个代码，可以深入理解...
WPF多线程编程案例演示与分析
标题：“WPF多线程演示”和描述：“WPF多线程演示 好用的案例分析 多线程调用”暗示了这次分享是一个面向熟悉WPF框架和C#编程语言的开发者的案例讲解，旨在展示如何在使用WPF进行界面开发时实现多线程的调用。...
行业分类-设备装置-多媒体演示系统及方法.zip
08-17
同时，为了提升性能，系统优化也必不可少，如内存管理、多线程编程、GPU加速等。 六、案例分析 在教育领域，多媒体教室的运用，通过互动白板和丰富的课件，使教学更加生动；商业展示中，大型商场的产品广告显示屏，...
多线程八锁详细分析 + 个人理解
qwertyu0103的博客
03-29 279
线程八锁： 1、标准访问，请问先执行发邮件还是先发短信？ 2、如果让发邮件sleep()三秒钟是先发邮件还是先发短信？ 3、新增一个普通方法hello()，先发邮件还是先执行hello()？ 4、两部手机（两个资源类对象），先发邮件还是先发送短信？ 5、两个静态方法，同一部手机，先发邮件还是先发短信？ 6、两个静态方法，两部手机，先发邮件还是先发短信？ 7、一个普通方法，一个静态方法，一部手机，先发邮件还是先发短信？ 8、一个普通方法，一个静态方法，两部手机，先发邮件还是先发短信？ 这里我认为需要加一些前提
JUC-多线程锁
weixin_30922589的博客
08-27 233
多线程锁的练习题 1、标准访问，先打印短信还是邮件 class Phone { public synchronized void sendSMS() throws Exception { Thread.sleep(400);题【2】添加延时 System. out .println( "------se...
synchronized：锁的对象到底是谁？快速理解八锁现象
saya21的博客
07-24 1303
通过总结和例子帮助快速理解八锁现象。
玩转多线程--解决线程安全（超详细讲述八锁问题！！！）
最新发布
2401_83429250的博客
01-11 1113
关于多线程创建和造成线程安全的原因，博主已经在前面的玩转多线程--入门-优快云博客有详细介绍哦，大家可以直接点击链接进入阅读！！由上述代码转化为指令执行，可以明白t2线程只能等到加锁的t1线程全部执行完毕并且释放锁，才能加锁再执行t2的操作保证原子性指的是所有的指令不执行完毕不会释放锁，但是中途指令可以调出CPU注意：不要将锁定和CPU调度搞混！！！根据上述几种方案可以推断：要使用synchronized解决线程安全问题，锁对象可以任意选择，但是一定注意一个点，那就是多个线程竞争的锁对象一定是唯一的！！
Java那些“锁”事 - “八锁”案例
大后生大大大的博客
07-26 296
阿里巴巴规范手册中有提到：高并发时，同步调用应该去考量锁的性能消耗。能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。
【字节一面】线程八锁
激流丶的博客
07-04 923
线程八锁是指在多线程环境下，使用synchronized关键字对代码进行同步时，可能出现的八种不同的情况。 线程八锁。也是常见的面试题，**主要是针对锁对象的提问。**
并发编程学习之线程8锁
weixiaohuai的博客
02-26 1027
一、简介 所谓线程八锁，其实就是就是线程锁的8种情况，对应于是否加上synchronized，是否加上static等8种常见情况，具体见下面详解。 二、线程8锁 第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? /** * 线程八锁第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? * <p> * 运行结果: ...
java并发编程笔记3----详解线程八锁
baidu_41860619的博客
04-20 699
原课程B站地址：全面深入学习java并发编程，中级程序员进阶必会 基础概念 临界区：一段代码块内如果对共享资源的多线程读写操作，称这段代码块为临界区 竞态条件：多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件 为了避免临界区内竞态条件发生，有两种主要手段，阻塞式(采用synchronized,lock)和非阻塞式(原子变量) 而此篇介绍的线程八锁指的是使用sy...
Java 线程八锁经典案例
wwxy1995的博客
10-14 219
phone 的sendEmail方法和sendSMS方法均为同步方法，问两者谁先执行 第二锁，新增一个sleep方法，问谁先执行 第三锁，在类中新增加一个sayHello方法，看看谁先执行 第四锁，创建两个对象，分别执行，问谁先执行 第五锁，一个对象，两个方法均设为静态同步 第六锁，两个对象，两个方法均设为静态同步 注意，普通同步方法锁住的是整个类，当一个普通同...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ZHOU_VIP

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

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

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

打赏作者

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

抵扣说明：

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

余额充值