8锁问题

最新推荐文章于 2024-03-04 12:04:32 发布
最新推荐文章于 2024-03-04 12:04:32 发布
阅读量99 收藏
点赞数
分类专栏： java 文章标签： java 多线程 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35098287/article/details/114684358
版权

8锁问题

1 标准访问，一个对象，两个同步方法 ，先执行哪个：随机

class Phone{
	public synchronized void sendEmail(){
		System.out.println("=====Email");
	}

	public synchronized void sendSMS(){
		System.out.println("=====SMS");
	}
}
 
public class Lock8 {
	public static void main(String[] args) {
		Phone phone = new Phone();

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

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

情景2:邮件方法暂停4秒，一个对象，两个同步方法 哪个先执行：
答案 ： 邮件

解释：被 synchronized 修饰的方式，锁的对象是方法的调用者
所以说这里两个方法调用的对象是同一个，先调用的先执行

package lock8;

import java.util.concurrent.TimeUnit;

class Phone2{
	public synchronized void sendEmail() throws Exception{
//		Thread.sleep(4000);
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("=====Email");
	}

	public synchronized void sendSMS() throws Exception{
		System.out.println("=====SMS");
	}
}

/**
 */
public class Lock8Demo2 {
	public static void main(String[] args) throws Exception {
		Phone2 phone = new Phone2();

		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"A").start();

		Thread.sleep(4);

		new Thread(()->{
			try {
				phone.sendSMS();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"B").start();
	}
}

情景3 ：新增一个普通方法 hello( ),一个对象，哪个方法先执行
答案： hello( )
解释：新增加的这个方法没有 synchronized 修饰，不是同步方法，不受锁的影响！

package lock8;

import java.util.concurrent.TimeUnit;

class Phone3{
	public synchronized void sendEmail() throws Exception{
//		Thread.sleep(4000);
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("=====Email");
	}

	public synchronized void sendSMS() throws Exception{
		System.out.println("=====SMS");
	}

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

/**
 * 多线程8锁
 * 1 标准访问 一个对象，两个同步方法  哪个先执行：随机
 * 2 邮件方法暂停4秒，一个对象，两个同步方法 哪个先执行：，
 * 3 新增一个普通方法  hello(),一个对象，哪个方法先执行
 */
public class Lock8Demo3 {
	public static void main(String[] args) throws Exception {
		Phone3 phone = new Phone3();

		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"A").start();

		Thread.sleep(4);

		new Thread(()->{
			try {
				phone.hello();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"B").start();
	}
}

情景4
两个实例，分别执行 Email (sleep 4 秒） MSM，那个先执行
答案：MSM
这里锁的是两个不同的调用者，所以互不影响

package lock8;

import java.util.concurrent.TimeUnit;

class Phone4{
	public synchronized void sendEmail() throws Exception{
//		Thread.sleep(4000);
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("=====Email");
	}

	public synchronized void sendSMS() throws Exception{
		System.out.println("=====SMS");
	}

}

/**
 * 多线程8锁
 * 1 标准访问 一个对象，两个同步方法  哪个先执行：随机
 * 2 邮件方法暂停4秒，一个对象，两个同步方法 哪个先执行：，
 * 3 新增一个普通方法  hello(),一个对象，哪个方法先执行
 * 4 两个实例  邮件方法暂停4秒 哪个先执行
 */
public class Lock8Demo4 {
	public static void main(String[] args) throws Exception {
		Phone4 phone = new Phone4();
		Phone4 phone2 = new Phone4();

		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"A").start();

		Thread.sleep(4);

		new Thread(()->{
			try {
				phone2.sendSMS();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"B").start();
	}
}

情景5： 两个静态同步方法 同一个实例
Email先执行
只要方法被 static 修饰，锁的对象就是 Class模板对象,这个则全局唯一！
所以说这里是同一个锁，并不是因为synchronized 这里程序会从上往下依次执行

package lock8;

import java.util.concurrent.TimeUnit;

class Phone5{
	public static synchronized void sendEmail() throws Exception{
//		Thread.sleep(4000);
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("=====Email");
	}

	public static synchronized void sendSMS() throws Exception{
		System.out.println("=====SMS");
	}

}

/**
 * 多线程8锁
 * 1 标准访问 一个对象，两个同步方法  哪个先执行：随机
 * 2 邮件方法暂停4秒，一个对象，两个同步方法 哪个先执行：，
 * 3 新增一个普通方法  hello(),一个对象，哪个方法先执行
 * 4 两个实例  邮件方法暂停4秒 哪个先执行
 * 5 两个静态同步方法 同一个实例
 */
public class Lock8Demo5 {
	public static void main(String[] args) throws Exception {
		Phone5 phone = new Phone5();

		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"A").start();
		
		new Thread(()->{
			try {
				phone.sendSMS();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"B").start();
	}
}

情景6
两个静态同步方法 两个实例

package lock8;

import java.util.concurrent.TimeUnit;

class Phone6{
	public static synchronized void sendEmail() throws Exception{
//		Thread.sleep(4000);
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("=====Email");
	}

	public static synchronized void sendSMS() throws Exception{
		System.out.println("=====SMS");
	}

}

/**
 * 多线程8锁
 * 1 标准访问 一个对象，两个同步方法  哪个先执行：随机
 * 2 邮件方法暂停4秒，一个对象，两个同步方法 哪个先执行：，
 * 3 新增一个普通方法  hello(),一个对象，哪个方法先执行
 * 4 两个实例  邮件方法暂停4秒 哪个先执行
 * 5 两个静态同步方法 同一个实例
 * 6 两个静态同步方法 两个实例
 */
public class Lock8Demo6 {
	public static void main(String[] args) throws Exception {
		Phone6 phone = new Phone6();
		Phone6 phone2 = new Phone6();

		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"A").start();

		new Thread(()->{
			try {
				phone2.sendSMS();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"B").start();
	}
}

情景7
一个静态同步方法 一个普通同步方法 一个实例
SMS先执行
解释：只要被static修饰锁的是class模板, 而synchronized 锁的是调用的对象

  • 这里是两个锁互不影响，按时间先后执行
package lock8;

import java.util.concurrent.TimeUnit;

class Phone7{
	public static synchronized void sendEmail() throws Exception{
//		Thread.sleep(4000);
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("=====Email");
	}

	public synchronized void sendSMS() throws Exception{
		System.out.println("=====SMS");
	}

}

/**
 * 多线程8锁
 * 1 标准访问 一个对象，两个同步方法  哪个先执行：随机
 * 2 邮件方法暂停4秒，一个对象，两个同步方法 哪个先执行：，
 * 3 新增一个普通方法  hello(),一个对象，哪个方法先执行
 * 4 两个实例  邮件方法暂停4秒 哪个先执行
 * 5 两个静态同步方法 同一个实例
 * 6 两个静态同步方法 两个实例
 * 7 一个静态同步方法  一个普通同步方法 一个实例
 */
public class Lock8Demo7 {
	public static void main(String[] args) throws Exception {
		Phone7 phone = new Phone7();

		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"A").start();

		Thread.sleep(3);

		new Thread(()->{
			try {
				phone.sendSMS();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"B").start();
	}
}

情景8 一个静态同步方法 一个普通同步方法 两个实例
sms先执行
两个锁互不影响
看执行速度 谁先调用谁执行

package lock8;

import java.util.concurrent.TimeUnit;

class Phone8{
	public static synchronized void sendEmail() throws Exception{
//		Thread.sleep(4000);
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("=====Email");
	}

	public synchronized void sendSMS() throws Exception{
		System.out.println("=====SMS");
	}

}

/**
 * 多线程8锁
 * 1 标准访问 一个对象，两个同步方法  哪个先执行：随机
 * 2 邮件方法暂停4秒，一个对象，两个同步方法 哪个先执行：，
 * 3 新增一个普通方法  hello(),一个对象，哪个方法先执行
 * 4 两个实例  邮件方法暂停4秒 哪个先执行
 * 5 两个静态同步方法 同一个实例
 * 6 两个静态同步方法 两个实例
 * 7 一个静态同步方法  一个普通同步方法 一个实例
 * 8 一个静态同步方法  一个普通同步方法 两个实例
 */
public class Lock8Demo8 {
	public static void main(String[] args) throws Exception {
		Phone8 phone = new Phone8();
		Phone8 phone2 = new Phone8();

		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"A").start();

		Thread.sleep(3);

		new Thread(()->{
			try {
				phone2.sendSMS();
			} catch (Exception e) {
				e.printStackTrace();
			}
		},"B").start();
	}
}
qq_35098287
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
八锁问题详解
酷小亚
06-10 700
“八锁”有什么含义？ 很好理解，就是：有关8个锁的问题！
8锁问题示例-通俗易懂
weixin_45216009的博客
06-16 364
synchronized：互斥锁： 分为 静态互斥锁，非静态互斥锁。在一个类中用 synchronized 修饰两个方法，然后实例化当前类(一个对象)， 对象调用当前类中两个方法，两方法执行顺序？锁谁？锁的对象：就是方法的调用者(实例化对象)；两个方法用的是同一把锁，先拿到先执行。(取决于CPU的调度)错误解释：而不是对象先调用哪个方法就先执行。在一个类中用 synchronized 修饰一个方法(设置延迟4s)，一个普通方法，然后实例化当前类(一个对象)， 对象调用当前类中两个方法，两方法执行顺序？普通方
深入理解JUC的8锁现象
qq_51447436的博客
04-15 8001
深入理解JUC的8锁现象
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1466
synchronized关键字到底锁的是谁？
Java并发编程-八锁问题带你彻底理解对象锁和类锁
Java硬件工程师的博客
01-15 2172
8锁问题演示 1.标准访问 标准访问，先打印邮件还是短信. 不一定谁先被打印。取决于CPU的执行情况.激活他们的是main线程，后面谁先被调度，不知道。 为了保证效果，我们在A和B的代码之间加thread.sleep(100).此时，可以确保A先被打印。 解释： 进入到main方法中之后，就是A找邮件，B找短信的方法。加完锁之后，同时进来，各回各家，各找各妈。因为我们人为的在A和B之间加了休眠时间，那么A肯定发生在B之前。按照标准访问。此时先打印邮件 /*手机类可以发邮件和发短信*/ class Phone
GBase 8s 锁简介
04-25
GBase 8s 锁简介 GBase 8s 锁是指在关系型数据库中，对数据库中的数据对象加锁，以...解决 GBase 8t 锁的问题需要从多方面进行尝试，包括应用程序锁使用模式设置、应用程序避免使用不必要的锁、避免死锁、避免活锁等。
三星s8 s8+ note8网络锁卡锁区域锁解锁教程
01-20
### 三星S8/S8+/Note8网络锁、卡锁及区域锁解锁教程 #### 一、网络锁概念与背景 手机网络锁是一种常见的限制措施，通常出现在与运营商捆绑销售的合约机上，尤其是国外市场。为了防止用户将手机转售至其他地区或...
8 种方案解决重复提交问题
10-05
解决重复提交问题的8种方案 在本篇文章中，我们将讨论重复提交问题的八种解决方案。重复提交问题是指在Web应用程序中，当用户提交表单时，可能会导致重复提交，导致数据不一致和其他问题。为了解决这个问题，我们...
MYSQL锁表问题的解决方法
12-15
MySQL锁表问题通常是由于并发操作或者长时间运行的事务导致的，这会影响到数据库的正常运行和服务。以下是一些解决MySQL锁表问题的方法： 1. **查看并杀死锁定进程**： 使用`SHOW PROCESSLIST`命令可以查看当前...
多功能锁 程序文件.rar_stm8
09-23
在本文中，我们将深入探讨STM8在多功能锁程序中的应用，以及如何结合MDK（Keil Microcontroller Development Kit）进行开发。 STM8系列微控制器广泛应用于各种嵌入式系统，包括消费电子、工业控制、汽车电子等领域...
经典8锁问题--助你彻底搞懂锁的概念
最新发布
weixin_42290025的博客
03-04 360
一个被static+synchronized 修饰的方法和普通的synchronized方法，先执行sendEmail()还是callPhone()？* 同被static+synchronized 修饰的两个方法，是先sendEmail()还是callPhone()?* 被synchronized 修饰的普通方法和静态方法 是先sendEmail() 还是 callPhone()?* 被synchronized 修饰的方式和普通方法 先执行sendEmail() 还是 callPhone()
8锁问题，面试必懂知识
细数长流
11-15 170
最近听到一些人问说8锁是什么，这里简单的用代码解释一下。 1、是先打电话还是先发短信？ 2、电话方法内停4秒，是先打电话还是发短信？ 3、新增普通方法充电，是先打电话还是先充电？ 4、现在有两部手机，先打电话还是先发短信？ 5、现在打电话和发短信变成静态同步方法，一部手机，是先打电话还是先发短信？ 6、现在打电话和发短信变成静态同步方法，两部手机，是先打电话还是先发短信？ 7、一个静态同步方法，一个普通同步方法，一部手机，是先打电话还是先发短信？ 8、一个静态同步方法，一个普通同步方法，两部手机，是先打电话
JUC-02-八锁问题，集合类的安全问题，Callable
09-25 145
目录01，八锁问题问题一问题二问题三问题四：问题五问题六问题七问题八（注意和问题七的对比）02，集合类的安全问题ListmapSet03，java.util.concurrent.Callable接口 01，八锁问题 对象锁（synchronized method{}） 类锁（static sychronized method{}） 注意：对象锁和类锁不是同一个锁（一定记住这句话） 8锁问题：关于锁的8个问题 问题一 示例程序 public class Test01 { public sta
关于8锁问题详细介绍
CP-Objeck的博客
05-18 1519
关于8锁问题 1、两个同步方法，一个对象调用。乌龟先跑？还是兔子先跑？ 答：乌龟先跑 /** * @Description: * @Package: com.cp.lock8 * @ClassName: Lock2 * @Author: cp * @Date: 2020/5/18 21:50 * @Version: 1.0 */ public class Lock1 { public static void main(String[] args) { Animal1
经典 8 锁问题
yage124的博客
05-15 358
示例代码 1、资源类 import java.util.concurrent.TimeUnit; public class Phone { // 此方法根据题目需要添加 static public synchronized void sendSMS() { // 使用 TimeUnit 工具类执行 sleep 方法，比 Thread.sleep(毫秒)， // 方便控制输入的时间单位 // 根据题目要求设置该方法的休眠时间 try { TimeUnit.SEC
8锁问题，探究锁到底锁了谁，谁被锁了
qq_42388853的博客
12-25 359
8锁就是8个锁的问题，直接探究出到底锁的是谁：下面看题和结果就可以了。 题的情况很简单，就是一个Phone类，里面有打电话和发短信俩方法，答案就是先发短信还是先打电话即可： 问题1：正常情况下，谁会先输出出来 package lock8; import java.util.concurrent.TimeUnit; //1、正常情况下，谁会先输出出来 public class Test1 { public static void main(String[] args) { Phone
多线程8锁问题 详解
weixin_45631253的博客
04-08 193
多线程8锁问题详解 1.案例准备 首先我们准备一个资源类，在资源类定义两个同步方法，来测试在不同的访问方式下， 会产生什么样的结果。代码如下： class MyPhone { public synchronized void sendEmail() { // 发送邮件 System.out.println("----sendEmail"); } // 发送短信 public synchronized void sendMS() {
juc----举例说明8锁问题
qq_40927884的博客
05-20 515
class Phone { public static synchronized void SendSMS() throws InterruptedException { TimeUnit.SECONDS.sleep(4); System.out.println("发了短信"); } public synchronized void ...
Windows 8黑客攻略：解锁操作系统潜力
10. **硬件和驱动程序**：讨论如何识别和更新硬件驱动程序，以及解决硬件兼容性问题。 11. **开发者工具**：对于开发者，可能会介绍如何在Windows 8上开发应用，包括Visual Studio和开发者工具的使用。 12. **升级...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值