JUC高并发编程(07) -- 多线程锁 -- 演示锁的八种情况

原创 已于 2022-05-10 17:52:27 修改 · 343 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2022-05-10 17:51:34 首次发布
本文通过六个示例详细解析了Java中synchronized锁的使用，包括标准访问、同步方法内暂停、普通方法、多对象、静态同步方法等场景，揭示了锁的对象范围和加锁效果，强调了同步的关键在于锁的对象和同步的作用域。

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

JUC高并发编程

六、多线程锁

6.1）演示锁的八种情况

6.1.1）标准访问

代码如下：

class Phone {
    // 打印短信
    public synchronized void sendSMS() throws Exception {
        System.out.println("------sendSMS");
    }
    // 打印邮件
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
}
​
public class Lock_8 {
    public static void main(String[] args) throws Exception {
        Phone phone = new Phone();
        // 创建线程AA
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();
​
        Thread.sleep(100);
        // 创建线程BB
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

输出：标准访问，先打印短后打印邮件

------sendSMS

------sendEmail

6.1.2）停4秒在短信方法内

代码如下：

class Phone {
    // 打印短信
    public synchronized void sendSMS() throws Exception {
        //停留4秒
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    // 打印邮件
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
}
​
public class Lock_8 {
    public static void main(String[] args) throws Exception {
        Phone phone = new Phone();
        // 创建线程AA
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();
​
        Thread.sleep(100);
        // 创建线程BB
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

输出：停4秒在短信方法内，先打印短后打印邮件

------sendSMS

------sendEmail

说明：上述两种情况输出结果相同，表示添加 synchronized 关键字后加锁的是当前使用的对象(即phone)，即先执行phone.sendSMS()再执行phone.sendEmail()。

6.1.3）新增普通方法

代码如下：

class Phone {
    // 打印短信
    public synchronized void sendSMS() throws Exception {
        //停留4秒
        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();
        // 创建线程AA
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();
​
        Thread.sleep(100);
        // 创建线程BB
        new Thread(() -> {
            try {
                phone.getHello();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

输出：新增普通的hello方法，先执行普通hello方法再打印短信

------getHello

------sendSMS

说明：上述输出结果表示，不添加 synchronized关键字的普通方法先执行，添加synchronized关键字的方法后执行，即先执行phone.getHello()再执行phone.sendSMS()。

6.1.4）两部手机

代码如下：

class Phone {
    // 打印短信
    public synchronized void sendSMS() throws Exception {
        //停留4秒
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    // 打印邮件
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
}
​
public class Lock_8 {
    public static void main(String[] args) throws Exception {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        // 创建线程AA
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();
​
        Thread.sleep(100);
        // 创建线程BB
        new Thread(() -> {
            try {
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

输出：现在有两部手机，先打印邮件再打印短信

------sendEmail

-----sendSMS

说明：上述输出结果表示添加 synchronized 关键字后加锁的是当前使用的对象(即phone)，现在出现了2个对象所以加锁失效，因为实际上是加了2把锁，并不是同一把锁，即先执行phone2.sendEmail()再执行phone.sendSMS()。

6.1.5）两个静态同步方法，1部手机

代码如下：

class Phone {
    // 打印短信
    public static synchronized void sendSMS() throws Exception {
        //停留4秒
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    // 打印邮件
    public static synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
}
​
public class Lock_8 {
    public static void main(String[] args) throws Exception {
        Phone phone = new Phone();
        // 创建线程AA
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();
​
        Thread.sleep(100);
        // 创建线程BB
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

输出：两个静态同步方法，1部手机，先打印短信再打印邮件

------sendSMS

------sendEmail

6.1.6）两个静态同步方法，2部手机

代码如下：

class Phone {
    // 打印短信
    public static synchronized void sendSMS() throws Exception {
        //停留4秒
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    // 打印邮件
    public static synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
}
​
public class Lock_8 {
    public static void main(String[] args) throws Exception {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        // 创建线程AA
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();
​
        Thread.sleep(100);
        // 创建线程BB
        new Thread(() -> {
            try {
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

输出：两个静态同步方法，2部手机，先打印短信再打印邮件

------sendSMS

------sendEmail

说明：上述两种情况输出结果相同，表示添加 static synchronized 关键字后加锁的是当前的字节码对象(即 class Phone )而不是实例对象(即 Phone )，相当于全局加锁了，即先执行phone2.sendEmail()再执行phone.sendSMS()。

6.1.7）1个静态同步方法,1个普通同步方法，1部手机

代码如下：

class Phone {
    // 打印短信
    public static synchronized void sendSMS() throws Exception {
        //停留4秒
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    // 打印邮件
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
}
​
public class Lock_8 {
    public static void main(String[] args) throws Exception {
        Phone phone = new Phone();
        // 创建线程AA
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();
​
        Thread.sleep(100);
        // 创建线程BB
        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

输出：1个静态同步方法,1个普通同步方法，1部手机，先打印邮件再打印短信

------sendEmail

------sendSMS

6.1.8）1个静态同步方法,1个普通同步方法，2部手机

代码如下：

class Phone {
    // 打印短信
    public static synchronized void sendSMS() throws Exception {
        //停留4秒
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    // 打印邮件
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
}
​
public class Lock_8 {
    public static void main(String[] args) throws Exception {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        // 创建线程AA
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();
​
        Thread.sleep(100);
        // 创建线程BB
        new Thread(() -> {
            try {
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

输出：1个静态同步方法,1个普通同步方法，2部手机，先打印邮件再打印短信

------sendEmail

------sendSMS

说明：上述两种情况输出结果相同，表示静态同步方法和普通同步方法的加锁对象不同，还是2把锁，所以锁实际是失效的，即先执行phone2.sendEmail()再执行phone.sendSMS()。

6.1.9）小结

一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了， 其它的线程都只能等待，就是说，某一个时刻内只能有唯一一个线程去访问这些 synchronized方法；

锁的是当前this对象，被锁定后，其它的线程都不能进入到当前对象的其它的 synchronized方法，加入普通方法后发现和同步锁无关；

换成两个对象后，不是同一把锁了，锁实际上是无效的。

synchronized实现同步的基础：Java中的每一个对象都可以作为锁，具体表现为以下3种形式：

  1. 对于普通同步方法，锁是当前实例对象；

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

  3. 对于同步方法块，锁是Synchonized括号里配置的对象

当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁；也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步 法必须等待获取锁的方法释放锁后才能获取锁， 可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁， 所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象， 以静态同步方法与非静态同步方法之间是不会有竞态条件的。

但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间还是不同的实例对象的静态同 步方法之间，只要它们同一个类的实例对象！

JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
JUC高并发编程(06) -- 集合的线程安全 -- HashSet集合和HashMap集合
姜皓的博客
05-10 1643
集合的线程安全 -- HashSet集合和HashMap集合
多线程8锁
weixin_42198596的博客
01-07 157
标准访问，请问先打印邮件还是短信？ 邮件方法暂停4秒钟，请问先打的邮件还是短信？ 新增一个普通方法hello（），请问先打印邮件还是hello？ 两部手机，请问先打印邮件还是短信？ 两个静态同步方法，同一部手机，请间先打印邮件还是短信？ 两个静态同步方法，2部手机，请问先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，1部手机，请间先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？ ...
10.JUC线程高级-线程八锁
weixin_34004576的博客
09-05 151
所谓线程八锁实际上对应于是否加上synchronized，是否加上static等8种常见情况，代码如下: 1.两个普通同步方法，两个线程，标准打印，结果：one two public class TestThread8Monitor { public static void main(String[]...
java多线程 线程八锁
ankan7400的博客
02-05 151
package com.java.juc; /** * 题目：判断打印 "one" or "two" * * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印thr...
【分布式锁的演化02】常用锁的种类以及解决方案
程序员老猫
12-17 284
前言 上一篇分布式锁的文章中，通过超市存放物品的例子和大家简单分享了一下Java锁。本篇文章我们就来深入探讨一下Java锁的种类，以及不同的锁使用的场景，当然本篇只介绍我们常用的锁。我们分为两大类，分别是乐观锁和悲观锁，公平锁和非公平锁。 乐观锁和悲观锁 乐观锁 老猫相信，很多的技术人员首先接触到的就是乐观锁和悲观锁。老猫记得那时候是在大学的时候接触到，当时是上数据库课程的时候。当时的应用场景主要是在更新数据的时候，当然多年工作之后，其实我们也知道了更新数据也是使用锁非常主要的场景之一。我们来回顾一下一般更
GUC-10 线程八锁
weixin_30932215的博客
03-05 194
/* * 题目：判断打印的 "one" or "two" ？ * * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two * 3. 新增普通方法 getThree() , 打印? //three one two * 4. 两个普通同步...
JUC代码演示 Java多线程并发
最新发布
05-03
总结来说，Java多线程并发编程是一个复杂但重要的领域。了解和掌握线程的基本概念（如用户线程与守护线程）、同步机制（如`synchronized`和`Lock`接口），以及线程间通信的方法对于开发高质量的并发应用至关重要。...
汪文君高并发编程实战视频资源下载.txt
08-08
│ 高并发编程第二阶段02讲、介绍四种Singleton方式的优缺点在多线程情况下.wmv │ 高并发编程第二阶段03讲、介绍三种高效优雅的Singleton实现方式.wmv │ 高并发编程第二阶段04讲、多线程的休息室WaitSet详细...
JUC高并发编程(15) -- ThreadPool 线程池
姜皓的博客
05-12 1215
ThreadPool 线程池
11、JUC--线程八锁
weixin_33923148的博客
05-02 125
线程八锁 • 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用　　其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻　　内，只能有唯一一个线程去访问这些synchronized方法 • 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的　　synchronized方法 • 加个普通方法后发现和同...
并发编程: 线程八锁的情况示范
wang5701071的博客
03-06 322
线程八锁即多线程的情况下由不同的调用方法或者限制来判断不同的执行结果.下面进行一一演示 示例1:这个例子的执行结果是 1,2 或者2,1,因为调用方法的时候 用了synchronized关键字,所以两个线程是互斥的,就看cpu先分配给线程a还是b了 示例2: 结果和实例1的结果一样,但有不同的地方就是,线程里面有休眠时间,两则是互斥的,所有执行a的时候会等待1秒才执行2 示例3:这个示例多了一个方法c 但是没有用synchronized来进行锁操作, 所以方法c在与 a,b 两个之间是并行的, .
【Java高级】JUC之线程八锁案例分析
阿杰
05-02 343
class Phone{ public static synchronized void sendEmail()throws Exception{ TimeUnit.SECONDS.sleep(4); System.out.println("****sendEmail"); } public synchronized void sendSMS...
juc-线程八锁
weixin_39535692的博客
10-27 399
松岛枫
《JUC并发编程 - 高级篇》03 - 共享对象之管程 上篇（共享带来的问题 | synchronized | 线程八锁 | 线程安全类）
LXYDSF的博客
06-13 432
《JUC并发编程 - 高级篇》03 - 共享对象之管程 上篇（共享带来的问题 | synchronized | 线程八锁 | 线程安全类）
JUC多线程编程八锁你都知道了吗？关于锁的八个问题
不会编程的派大星的博客
04-21 178
关于锁的八个问题—八锁 前面的文章中留下一个疑问，到底什么是锁，锁到底锁的是谁？ 这里我们就用打电话和发短信的例子来距离说明八锁问题—>锁的是对象方法的调用者或者Class模板（.class） 1、标准情况下，两个线程先打印 发短信还是 先打印 打电话？ import java.util.concurrent.TimeUnit; /** * @program: juc * @description * @author: 不会编程的派大星 * @create: 2021-04-21 12:42
JUC并发编程（二）-- 线程八锁
书生灬今天不吃饭的博客
11-28 270
JUC并发编程（二）-- 线程八锁1、两个线程，分别调用同一个资源类的两个方法，哪个先执行？2、两个线程A和B，分别调用同一个资源类的两个方法，A线程休眠3秒，哪个线程先执行？3、非同步方法是否会受到对象锁的影响？4、同一个类中两个对象的同步方法时候会相互影响？5、同一个类中的两个静态同步方法时候会互相影响？6、同一个类中，一个静态同步方法和一个普通同步方法，会相互影响吗？ 线程八锁，指的就是线程中关于锁的八个问题，用来分辨清晰Java多线程中，锁究竟锁的是什么。 以下 5 和 6 两个问题分别是两个子问题
JUC编程-多线程锁
m0_49760452的博客
04-11 527
文章目录1.公平锁及非公平锁公平锁实现方式：优点缺点非公平锁优点缺点2.可重入锁3.死锁什么是死锁？产生死锁原因： 1.公平锁及非公平锁 公平锁 按照线程等待顺序获取锁，一般将获取锁失败的线程放入等待队列中，每次从FIFO队列的队头取出线程获取锁。这种方式会造成性能低下，大量的时间花费在线程调度上。 实现方式： ReentrantLock lock=new ReentrantLock(true);//true表示获取公平锁 优点 雨露均沾 缺点 效率相对较低 非公平锁 不管等待顺序，每个线程获取
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2167
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
狂神解读Java多线程及JUC高级技术
狂神说Java的多线程+juc部分通常会以视频课程的方式，逐层深入地讲解Java多线程编程和JUC包中的高级并发工具，帮助学习者理解并发编程的复杂性，掌握利用这些工具简化并发编程实践的能力。 在文件标题“thread.zip-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值