多线程的8锁问题

最新推荐文章于 2021-09-25 16:13:28 发布
最新推荐文章于 2021-09-25 16:13:28 发布
阅读量129 收藏 1
点赞数
分类专栏： 多线程并发编程 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17690301/article/details/108512082
版权

我们现在有一个资源类Phone，它有两个基础操作，sendEmail发送邮件和sendMessage发送短信，这两个操作均加上了synchronized锁

问题：

1.标准访问，请问是先打印邮件还是短信？
/**
 * 
 * @ClassName: Phone
 * @Description: 手机资源类
 * @author: fuling
 * @date: 2020年9月10日 下午1:29:17
 */
class Phone{
	/**
	 * 
	 * @Title: sendEmail
	 * @Description: 发邮件
	 * @return: void
	 */
	public synchronized void sendEmail() {
		System.out.println("发邮件。。。");
	}
	
	/**
	 * 
	 * @Title: sendMessage
	 * @Description: 发短信
	 * @return: void
	 */
	public synchronized void sendMessage() {
		System.out.println("发短信。。。");
	}
}

//问题1
	public static void ques1() {
		Phone phone = new Phone();//一个手机资源
		//创建两个线程
		
		//线程A发送邮件
		new Thread(()->{
			phone.sendEmail();
		}, "A").start();

		
		//线程B发送短信
		new Thread(()->{
			phone.sendMessage();
		}, "B").start();
	}
执行结果

发邮件。。。
发短信。。。

结果分析

结果是哪个先打印都是有可能的，先执行start()不代表就能先执行，这和操作系统调度的顺序有关

2.邮件方法暂停4秒，请问是先打印邮件还是短信？（我们在创建线程A后先sleep100毫秒让线程A先执行）
/**
 * 
 * @ClassName: Phone
 * @Description: 手机资源类
 * @author: fuling
 * @date: 2020年9月10日 下午1:29:17
 */
class Phone {
	/**
	 * 
	 * @Title: sendEmail
	 * @Description: 发邮件
	 * @return: void
	 */
	public synchronized void sendEmail() {
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("发邮件。。。");
	}

	/**
	 * 
	 * @Title: sendMessage
	 * @Description: 发短信
	 * @return: void
	 */
	public synchronized void sendMessage() {
		System.out.println("发短信。。。");
	}
}

// 问题2
	public static void ques2() {
		Phone phone = new Phone();// 一个手机资源
		// 创建两个线程

		// 线程A发送邮件
		new Thread(() -> {
			phone.sendEmail();
		}, "A").start();

		// 休眠100毫秒，保证线程A先得到锁
		try {
			TimeUnit.MILLISECONDS.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// 线程B发送短信
		new Thread(() -> {
			phone.sendMessage();
		}, "B").start();
	}
执行结果

等待大约4秒后显示以下两行结果

发邮件。。。
发短信。。。

结果分析

A线程先抢到这个手机资源的锁，其抢到锁后立刻睡眠4秒，而sleep是一个只释放cpu时间片而不释放所持有锁的方法，所以A线程是一边“睡着”，一边紧握着锁不让其他线程访问这个手机资源里的同步操作，等待4秒后A线程醒过来，继续发邮件，发完后释放锁，B线程得到锁，打印出发短信

3.新增一个普通方法hello()，请问是先打印邮件还是hello？
/**
 * 
 * @ClassName: Phone
 * @Description: 手机资源类
 * @author: fuling
 * @date: 2020年9月10日 下午1:29:17
 */
class Phone {
	/**
	 * 
	 * @Title: sendEmail
	 * @Description: 发邮件
	 * @return: void
	 */
	public synchronized void sendEmail() {
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("发邮件。。。");
	}

	/**
	 * 
	 * @Title: sendMessage
	 * @Description: 发短信
	 * @return: void
	 */
	public synchronized void sendMessage() {
		System.out.println("发短信。。。");
	}
	
	//普通方法，不加锁
	public void hello() {
		System.out.println("hello。。。");
	}
}

// 问题3
		public static void ques3() {
			Phone phone = new Phone();// 一个手机资源
			// 创建两个线程

			// 线程A发送邮件
			new Thread(() -> {
				phone.sendEmail();
			}, "A").start();

			// 休眠100毫秒，保证线程A先得到锁
			try {
				TimeUnit.MILLISECONDS.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			// 线程B执行普通方法hello
			new Thread(() -> {
				phone.hello();
			}, "B").start();
		}
执行结果

先打印hello，大约隔4秒后打印发邮件

hello。。。
发邮件。。。

结果分析

锁只能锁住资源的同步方法，hello是普通方法，所以即使A线程先得到了锁，也不能阻止B线程访问hello方法。因此A线程得到锁后先睡眠4秒钟，期间B线程访问hello，4秒后A线程苏醒，打印发邮件

4.两个Phone资源类，请问是先打印邮件还是短信？
/**
 * 
 * @ClassName: Phone
 * @Description: 手机资源类
 * @author: fuling
 * @date: 2020年9月10日 下午1:29:17
 */
class Phone {
	/**
	 * 
	 * @Title: sendEmail
	 * @Description: 发邮件
	 * @return: void
	 */
	public synchronized void sendEmail() {
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("发邮件。。。");
	}

	/**
	 * 
	 * @Title: sendMessage
	 * @Description: 发短信
	 * @return: void
	 */
	public synchronized void sendMessage() {
		System.out.println("发短信。。。");
	}
}

// 问题4
	public static void ques4() {
		// 两个手机资源
		Phone phone1 = new Phone();
		Phone phone2 = new Phone();
		// 创建两个线程

		// 线程A使用手机1发送邮件
		new Thread(() -> {
			phone1.sendEmail();
		}, "A").start();

		// 休眠100毫秒，保证线程A先得到锁
		try {
			TimeUnit.MILLISECONDS.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// 线程B使用手机2发送短信
		new Thread(() -> {
			phone2.sendMessage();
		}, "B").start();
	}
执行结果

先打印发短信，大约隔4秒后打印发邮件

发短信。。。
发邮件。。。

结果分析

两个类就拥有两把不同的对象锁，线程A使用资源1发邮件，不影响线程B使用资源2发短信

5.把两个基本操作改为静态同步方法，同一个Phone资源，请问是先打印邮件还是短信？
/**
 * 
 * @ClassName: Phone
 * @Description: 手机资源类
 * @author: fuling
 * @date: 2020年9月10日 下午1:29:17
 */
class Phone {
	/**
	 * 
	 * @Title: sendEmail
	 * @Description: 发邮件
	 * @return: void
	 */
	public static synchronized void sendEmail() {
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("发邮件。。。");
	}

	/**
	 * 
	 * @Title: sendMessage
	 * @Description: 发短信
	 * @return: void
	 */
	public static synchronized void sendMessage() {
		System.out.println("发短信。。。");
	}
}

// 问题5
	public static void ques5() {
		// 一个手机资源
		Phone phone = new Phone();
		// 创建两个线程

		// 线程A使用手机发送邮件
		new Thread(() -> {
			phone.sendEmail();
		}, "A").start();

		// 休眠100毫秒，保证线程A先得到锁
		try {
			TimeUnit.MILLISECONDS.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// 线程B使用手机发送短信
		new Thread(() -> {
			phone.sendMessage();
		}, "B").start();
	}
执行结果

等待大约4秒后显示以下两行结果

发邮件。。。
发短信。。。

结果分析

静态同步方法锁住的是类而不是对象，发短信和发邮件在一个资源类里，共享同一把类锁，线程A先抢占到这把类锁，并执行sleep，不释放锁，等到4秒后继续发邮件，释放锁后线程B才能发短信

6.两个基本操作为静态同步方法，两个Phone资源，请问是先打印邮件还是短信？
/**
 * 
 * @ClassName: Phone
 * @Description: 手机资源类
 * @author: fuling
 * @date: 2020年9月10日 下午1:29:17
 */
class Phone {
	/**
	 * 
	 * @Title: sendEmail
	 * @Description: 发邮件
	 * @return: void
	 */
	public static synchronized void sendEmail() {
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("发邮件。。。");
	}

	/**
	 * 
	 * @Title: sendMessage
	 * @Description: 发短信
	 * @return: void
	 */
	public static synchronized void sendMessage() {
		System.out.println("发短信。。。");
	}

}

//问题6
public static void ques6() {
		// 两个手机资源
		Phone phone1 = new Phone();
		Phone phone2 = new Phone();
		// 创建两个线程

		// 线程A使用手机1发送邮件
		new Thread(() -> {
			phone1.sendEmail();
		}, "A").start();

		// 休眠100毫秒，保证线程A先得到锁
		try {
			TimeUnit.MILLISECONDS.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		// 线程B使用手机2发送短信
		new Thread(() -> {
			phone2.sendMessage();
		}, "B").start();
	}
执行结果

等待大约4秒后显示以下两行结果

发邮件。。。
发短信。。。

结果分析

类锁与资源对象的多少无关，多个资源对象共享一个类锁

7.发邮件为普通同步方法，发短信为静态同步方法，一个Phone资源，请问是先打印邮件还是短信？
/**
 * 
 * @ClassName: Phone
 * @Description: 手机资源类
 * @author: fuling
 * @date: 2020年9月10日 下午1:29:17
 */
class Phone {
	/**
	 * 
	 * @Title: sendEmail
	 * @Description: 发邮件
	 * @return: void
	 */
	public synchronized void sendEmail() {
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("发邮件。。。");
	}

	/**
	 * 
	 * @Title: sendMessage
	 * @Description: 发短信
	 * @return: void
	 */
	public static synchronized void sendMessage() {
		System.out.println("发短信。。。");
	}


}

// 问题7
public static void ques7() {
	// 一个手机资源
	Phone phone = new Phone();
	// 创建两个线程

	// 线程A使用手机发送邮件
	new Thread(() -> {
		phone.sendEmail();
	}, "A").start();

	// 休眠100毫秒，保证线程A先得到锁
	try {
		TimeUnit.MILLISECONDS.sleep(100);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}

	// 线程B使用手机发送短信
	new Thread(() -> {
		phone.sendMessage();
	}, "B").start();
}
执行结果

先打印发短信，大约隔4秒后打印发邮件

发短信。。。
发邮件。。。

结果分析

发邮件方法带的锁为对象锁，发短信带的锁为类锁，两把锁互不干扰

8.发邮件为普通同步方法，发短信为静态同步方法，两个Phone资源，请问是先打印邮件还是短信？
/**
 * 
 * @ClassName: Phone
 * @Description: 手机资源类
 * @author: fuling
 * @date: 2020年9月10日 下午1:29:17
 */
class Phone {
	/**
	 * 
	 * @Title: sendEmail
	 * @Description: 发邮件
	 * @return: void
	 */
	public synchronized void sendEmail() {
		try {
			TimeUnit.SECONDS.sleep(4);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("发邮件。。。");
	}

	/**
	 * 
	 * @Title: sendMessage
	 * @Description: 发短信
	 * @return: void
	 */
	public static synchronized void sendMessage() {
		System.out.println("发短信。。。");
	}
}


// 问题8
	public static void ques8() {
		// 两个手机资源
		Phone phone1 = new Phone();
		Phone phone2 = new Phone();
		// 创建两个线程
		
		// 线程A使用手机1发送邮件
		new Thread(() -> {
			phone1.sendEmail();
				}, "A").start();
			
				// 休眠100毫秒，保证线程A先得到锁
		try {
			TimeUnit.MILLISECONDS.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
			
		// 线程B使用手机2发送短信
		new Thread(() -> {
			phone2.sendMessage();
		}, "B").start();
	}
执行结果

先打印发短信，大约隔4秒后打印发邮件

发短信。。。
发邮件。。。

结果分析

发邮件方法带的锁为对象锁，发短信带的锁为类锁，两把锁互不干扰

总结

解决这类问有主要有两点需要注意
1.sleep只释放cpu时间片，不释放其占用的锁，wait既释放cpu时间片又释放其占用的锁
2.根据锁住的东西不同，可以分为对象锁和类锁，不同类型的锁互不干扰，不是同一把锁也互不干扰

茯苓1998
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC-多线程锁
weixin_30922589的博客
08-27 165
多线程锁的练习题 1、标准访问，先打印短信还是邮件 class Phone { public synchronized void sendSMS() throws Exception { Thread.sleep(400);题【2】添加延时 System. out .println( "------se...
多线程8锁问题
wumingdu1234的博客
05-29 99
1、一个对象，两个同步方法：优先拿到锁的先执行！只要是锁的一个对象， 方法都是同步方法应该都是谁先拿到锁，谁先执行，剩下的只能等待 2、两个对象，两个同步方法，两个同时执行，因为是两个锁 3、一个对象，一个同步方法，一个不是同步方法，两个线程去调用，非同步方法，因为不受阻塞限制 4、两个静态方法，两个对象，只要锁住一个，那么久斗殴锁住了，因为锁住的是类 5、1个静态的同步方法，1个普通的同步方法 ，一个对象 两个同时执行，不受限制 6、1个静态的同步方法，1个普通的同步方法 ，两个对象 两个同时执行，不受限
多线程8锁问题 详解
weixin_45631253的博客
04-08 187
多线程8锁问题详解 1.案例准备 首先我们准备一个资源类，在资源类定义两个同步方法，来测试在不同的访问方式下， 会产生什么样的结果。代码如下： class MyPhone { public synchronized void sendEmail() { // 发送邮件 System.out.println("----sendEmail"); } // 发送短信 public synchronized void sendMS() {
Java多线程JUC8锁问题
qq_41898181的博客
09-25 288
一、线程的8锁问题 前提：8锁问题的讨论是建立在使用Thread.sleep(200)后，假设A线程先于B线程被CPU调度的前提下。 1.1 标准访问，请问先打印邮件还是短信？ class Phone{ public synchronized void sendEmail() throws Exception{ System.out.println("----------sendEmail"); } public synchronized void sendS
线程锁8问
JohnXiao的博客
03-26 262
线程锁8问 class Phone { public synchronized void sendEmail() throws Exception{ TimeUnit.SECONDS.sleep(4); System.out.println("---------sendEmail"); } public synchronized void...
Python中多线程及程序锁浅析
12-25
Python中多线程使用到Threading模块。Threading模块中用到的主要的类是Thread，我们先来写一个简单的多线程代码： 复制代码 代码如下: # coding : uft-8 __author__ = ‘Phtih0n’ import threading class MyThread...
多线程系列相关的技术要点
12-27
1. Java多线程学习（一）Java多线程入门 2. Java多线程学习（二）synchronized关键字（1） 3. Java多线程学习（二）...8. Java多线程学习（七）并发编程中一些问题 9. Java多线程学习（八）线程池与Executor 框架
Python多线程编程（六）：可重入锁RLock
12-25
考虑这种情况：如果一个线程遇到锁嵌套的情况该怎么办，这个嵌套是指当我一个线程在获取临界资源时，又需要再次获取。 根据这种情况，代码如下： 复制代码 代码如下: ”’ Created on 2012-9-8   @author: ...
奇偶数交互多线程thread源码java
02-06
16:55:20.675 [main] INFO org.malin.allutils.makefile.ReadFileNameUtil - 获取到 文件名称： 10.并发调试和JDK8新特性.pdf 16:55:20.677 [main] INFO org.malin.allutils.makefile....锁的优化和注意事项.pdf
Python多线程编程（四）：使用Lock互斥锁
01-20
使用threading模块实现多线程编程二两种方式起线程和Python：使用threading模块实现多线程编程三threading.Thread类的重要函数，这两篇文章的示例都是演示了互不相干的独立线程，现在我们考虑这样一个问题：假设各个...
Java多线程：线程优先级，同步，死锁
zxh1996的博客
07-19 364
Java多线程（二） 1.线程优先级 java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行 线程的优先级数字表示范围：1~10 Thread.MIN_PRIORITY = 1; Thread.MAX_PRIORITY = 10; Thread.NORM_PRIORITY = 5; 获取优先级：getPriority(); 改变优先级：setPriority(int xxx); 优先级低表示被CPU调度的概率低，无法保证优先级高一定先执行
java语言编程规范_深入分析 java 8 编程语言规范：Threads and Locks
weixin_28933797的博客
11-29 270
在 java 并发编程中，线程和锁永远是最重要的概念。语言规范虽然是规范描述，但是其中也有非常多的知识和最佳实践是值得学习的，相信这篇文章还是可以给很多读者提供学习参考的。本文主要是翻译 + 解释 Oracle《The Java Language Specification, Java SE 8 Edition》的第17章《Threads and Locks》，原文大概30页pdf，我加入了很多自...
Java -- Thread中start和run方法的区别
weixin_33755557的博客
05-11 205
一、认识Thread的 start() 和 run() 1。start(): 我们先来看看API中对于该方法的介绍： 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 结果是两个线程并发地运行；当前线程（从调用返回给 start 方法）和另一个线程（执行其 run 方法）。 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启...
Java多线程-线程八锁
超超级钢铁侠
07-06 3760
所有的非静态同步方法用的都是同一把锁，即实例对象本身，或者说this对象，如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁。如果别的对象的非静态同步方法与该实例对象的非静态同步方法获取不同的锁，则不需要等待。 所有的静态同步方法用的也是同一把锁，即类对象本身，所以静态同步方法与非静态同步方法之间是不会有竞态条件的，但是一个静态同步方法获
多线程八锁详细分析 + 个人理解
qwertyu0103的博客
03-29 204
线程八锁： 1、标准访问，请问先执行发邮件还是先发短信？ 2、如果让发邮件sleep()三秒钟是先发邮件还是先发短信？ 3、新增一个普通方法hello()，先发邮件还是先执行hello()？ 4、两部手机（两个资源类对象），先发邮件还是先发送短信？ 5、两个静态方法，同一部手机，先发邮件还是先发短信？ 6、两个静态方法，两部手机，先发邮件还是先发短信？ 7、一个普通方法，一个静态方法，一部手机，先发邮件还是先发短信？ 8、一个普通方法，一个静态方法，两部手机，先发邮件还是先发短信？ 这里我认为需要加一些前提
Java日常学习总结并发进阶之线程初步、锁与同步篇
ORI的博客
08-23 159
线程状态 新创建 刚new出来的Thread还没有被运行， 可运行 一旦调用start 方法，线程处于runnable状态。一个可运行的线桿可能正在运行也可能没有运行， 这取决于操作系统给线程提供运行的时间。 被阻塞线程和等待线程 当线程处于被阻塞或等待状态时， 它暂时不活动。它不运行任何代码且消耗最少的资源。直到线程调度器重新激活它。细节取决于它是怎样达到非活动状态的 当一个线程试图获取一个...
多线程篇 之 ReentrantLock 与 Condition
saiuna的博客
07-13 736
一、 ReentrantLock ReentrantLock是一个互斥锁，也是一个可重入的互斥锁。ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，但是相比功能更加丰富，添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。 先来看构造: //默认非公平锁 public ReentrantLock() { sync = new NonfairSync(); } // 可选是否公平锁 public ReentrantLock(boolean
Java多线程（PART XXIV）公平锁和非公平锁
Don't rush and never settle. If it's meant to be, it will be.
11-13 258
定义公平锁：公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的。示例代码：import java.util.concurrent.locks.ReentrantLock; import java.lang.Thread; class MyService{ private ReentrantLock lock; public MyService(boolean isFair){
线程获取锁的顺序java_多线程(五) java的线程锁
weixin_29129833的博客
02-13 1400
在多线程中，每个线程的执行顺序，是无法预测不可控制的，那么在对数据进行读写的时候便存在由于读写顺序多乱而造成数据混乱错误的可能性。那么如何控制，每个线程对于数据的读写顺序呢？这里就涉及到线程锁。什么是线程锁？使用锁的目的是什么？先看一个例子。private voidtestSimple(){SimpleRunner runner= newSimpleRunner();pool.execute(ru...
多线程编程（求和问题）
最新发布
09-18
好的，我可以为您解答多线程编程中的求和问题。 在多线程编程中，求和问题通常是一个常见的问题。我们可以使用线程池来实现多线程求和，具体步骤如下： 1. 定义线程池，通过线程池来创建多个线程。 2. 将要求和的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值