Java语言高级-05异常与多线程-第３节线程同步机制

于 2022-09-18 11:32:14 发布
阅读量91 收藏
点赞数
分类专栏： Java学习教程 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37975179/article/details/126862274
版权

线程安全问题的概述
在这里插入图片描述
线程安全问题的代码实现

package demo03;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
	public static void main(String[] args) {
		//创建Runnable接口的实现类对象
		RunnableImpl run = new RunnableImpl();
		//创建Thread类对象，构造方法中传递Runnable接口中的实现类对象
		Thread t0 = new Thread(run);
		Thread t1 = new Thread(run);
		Thread t2 = new Thread(run);
		//调用start方法开启多线程
		t0.start();
		t1.start();
		t2.start();
	}
}


package demo03;

/*
	实现买票案例
 */
public class RunnableImpl implements Runnable{

	//定义一个多个线程共享的资源
	private int ticket = 100;
	
	//设置线程任务：卖票
	@Override
	public void run() {
		//使用死循环，让卖票操作重复执行
		while(true) {
			//先判断是否存在
			if (ticket>0) {
				//提高安全问题出现的概率，让程序睡眠
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
				ticket--;
			}
		}
	}
}

线程安全问题产生的原理
在这里插入图片描述

解决线程安全问题 同步代码块

package demo04;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
	public static void main(String[] args) {
		//创建Runnable接口的实现类对象
		RunnableImpl run = new RunnableImpl();
		//创建Thread类对象，构造方法中传递Runnable接口中的实现类对象
		Thread t0 = new Thread(run);
		Thread t1 = new Thread(run);
		Thread t2 = new Thread(run);
		//调用start方法开启多线程
		t0.start();
		t1.start();
		t2.start();
	}
}


package demo04;

/*
	卖票案例出现了线程安全问题
	卖出了不存在的票和重复的票
	解决线程安全问题的一种解决方案：使用同步代码块
	格式：
		synchronized(锁对象){
			可能会出现线程安全问题的代码(访问了共享数据的代码)
		}
	注意：
		1、通过代码中的锁对象，可以使用任意的对象
		2、但是必须保证多个线程使用的锁对象是同一个
		3、锁对象作用：
			把同步代码块锁住，只让一个线程在同步代码块中执行
			
	
 */
public class RunnableImpl implements Runnable{

	//定义一个多个线程共享的资源
	private int ticket = 100;
	
	//创建一个锁对象
	Object obj = new Object();
	
	//设置线程任务：卖票
	@Override
	public void run() {
		//使用死循环，让卖票操作重复执行
		while(true) {
			//同步代码块
			synchronized (obj) {
				//先判断是否存在
				if (ticket>0) {
					//提高安全问题出现的概率，让程序睡眠
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
					//票存在，卖票ticket--
					System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
					ticket--;
				}
			}
		}
	}
}

同步技术的原理
在这里插入图片描述
解决线程安全问题 同步方法

package demo05;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
	public static void main(String[] args) {
		//创建Runnable接口的实现类对象
		RunnableImpl run = new RunnableImpl();
		System.out.println("run:"+run);
		//创建Thread类对象，构造方法中传递Runnable接口中的实现类对象
		Thread t0 = new Thread(run);
		Thread t1 = new Thread(run);
		Thread t2 = new Thread(run);
		//调用start方法开启多线程
		t0.start();
		t1.start();
		t2.start();
	}
}


package demo05;

/*
	卖票案例出现了线程安全问题
	卖出了不存在的票和重复的票
	
	解决线程安全问题的第二种解决方案：使用同步方法
	使用步骤：
		
		1、把访问的共享数据的代码抽取出来，放到一个方法中
		2、在方法上添加synchroized修饰符
	格式：定义方法的格式
	修饰符：synchronized 返回值类型 方法名(参数列表){
		可能会出现的线程安全问题的代码(访问了共享数据的代码)
	}
			
	
 */
public class RunnableImpl implements Runnable{

	//定义一个多个线程共享的资源
	private int ticket = 100;
	
	//创建一个锁对象
	Object obj = new Object();
	
	//设置线程任务：卖票
	@Override
	public void run() {
		System.out.println(this);
		//使用死循环，让卖票操作重复执行
		while(true) {
			payTicket();
		}
	}
	
	
	/*
	 	定义一个同步方法
	 	同步方法也会把方法内部的代码锁住
	 	只让一个线程执行
	 	同步方法的锁对象是谁？
	 	就是实现类对象 new RunnableImpl()
	 	也就是this
	 */
	public /*synchronized*/ void payTicket() {
		//同步代码块
		synchronized (this) {
			//先判断是否存在
			if (ticket>0) {
				//提高安全问题出现的概率，让程序睡眠
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				//票存在，卖票ticket--
				System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
				ticket--;
			}
		}
	}
}

静态同步方法

package demo05;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
	public static void main(String[] args) {
		//创建Runnable接口的实现类对象
		RunnableImpl run = new RunnableImpl();
		System.out.println("run:"+run);
		//创建Thread类对象，构造方法中传递Runnable接口中的实现类对象
		Thread t0 = new Thread(run);
		Thread t1 = new Thread(run);
		Thread t2 = new Thread(run);
		//调用start方法开启多线程
		t0.start();
		t1.start();
		t2.start();
	}
}


package demo05;

/*
	卖票案例出现了线程安全问题
	卖出了不存在的票和重复的票
	
	解决线程安全问题的第二种解决方案：使用同步方法
	使用步骤：
		
		1、把访问的共享数据的代码抽取出来，放到一个方法中
		2、在方法上添加synchroized修饰符
	格式：定义方法的格式
	修饰符：synchronized 返回值类型 方法名(参数列表){
		可能会出现的线程安全问题的代码(访问了共享数据的代码)
	}
			
	
 */
public class RunnableImpl implements Runnable{

	//定义一个多个线程共享的资源
	private static int ticket = 100;
	
	//创建一个锁对象
	Object obj = new Object();
	
	//设置线程任务：卖票
	@Override
	public void run() {
		System.out.println(this);
		//使用死循环，让卖票操作重复执行
		while(true) {
			payTicketStatic();
		}
	}	

	/*
	 静态的同步方法
	 锁对象是谁？
	 不能是this
	 this是创建对象之后产生的，静态方法优先于对象
	 静态方法的锁对象是本类的class属性-->class文件对象(反射)
	 */
	public static synchronized void payTicketStatic() {
		synchronized(RunnableImpl.class) {
			if (ticket>0) {
				//提高安全问题出现的概率，让程序睡眠
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				//票存在，卖票ticket--
				System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
				ticket--;
			}
		}

	}
}

解决线程安全问题 Lock锁

package demo05;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
	public static void main(String[] args) {
		//创建Runnable接口的实现类对象
		RunnableImpl run = new RunnableImpl();
		System.out.println("run:"+run);
		//创建Thread类对象，构造方法中传递Runnable接口中的实现类对象
		Thread t0 = new Thread(run);
		Thread t1 = new Thread(run);
		Thread t2 = new Thread(run);
		//调用start方法开启多线程
		t0.start();
		t1.start();
		t2.start();
	}
}


package demo05;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
	卖票案例出现了线程安全问题
	卖出了不存在的票和重复的票
	
	解决线程安全问题的第三种解决方案：使用Lock锁
	java.util.concurrent.locks.lock接口
	lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作
	Lock接口中的方法：
		void lock()获取锁。
		void unlock()释放锁。
	java.util.concurrent.locks.Reentrantlock implements lock接口	
	
	使用步骤：
		1、在成员位置创建一个Reentrantlock对象
		2、在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
		3、在可能会出现安全问题的代码后调用lock接口中的方法unlock释放锁
 */
public class RunnableImpl implements Runnable{

	//定义一个多个线程共享的资源
	private int ticket = 100;
	
	//1、在成员位置创建一个Reentrantlock对象
	Lock l = new ReentrantLock();
	
	
	//设置线程任务：卖票
	@Override
	public void run() {
		System.out.println(this);
		//使用死循环，让卖票操作重复执行
		while(true) {
			//2、在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
			l.lock();

			//先判断票是否存在
			if (ticket>0) {
				//提高安全问题出现的概率，让程序睡眠
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					//3、在可能会出现安全问题的代码后调用lock接口中的方法unlock释放锁
					l.unlock();//无论程序是否异常，都会把锁给释放掉
				}
				//票存在，卖票ticket--
				System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
				ticket--;
			}
		}
	}	
}
朗朗乾坤光风霁月
关注
专栏目录
Java多线程--同步机制解决线程安全问题方式一：同步代码块
人生得意须尽欢
01-29 1515
Java多线程--同步机制解决线程安全问题方式一：同步代码块
Java高级特性 - 多线程基础（3）线程同步
Junds0的博客
08-07 713
本关任务：使右侧代码中的insert方法在同一时刻只有一个线程能访问。本关任务：使用volatile关键字与同步实现右侧程序输出10000。本关任务：使用Lock，实现对于某一块代码的互斥访问。
面试突击37：线程安全问题的解决方案有哪些？
m0_56069948的博客
04-07 1085
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 线程安全是指某个方法或某段代码，在多线程中能够正确的执行，不会出现数据不一致或数据污染的情况，我们把这样的程序称之为线程安全的，反之则为非线程安全的。在 Java 中，解决线程安全问题有以下 3 种手段： 使用线程安全类，比如 AtomicInteger。 加锁排队执行 使
Java学习笔记②④( 线程安全问题产生的概述、原理以及解决线程安全问题的三种方法)
weixin_45994391的博客
04-18 222
一、线程安全 1. 线程安全问题概述
java解决线程安全问题的三种方法
weixin_44234016的博客
06-14 969
为什么会出现线程安全问题？ 先来运行一段程序(售票系统)，采用Runnable接口，代码如下： public class MyRunnable implements Runnable { private int ticket = 10; @Override public void run() { while (true){ if (ticket > 0){ try {
多线程之线程的同步
jothan的博客
11-05 345
1前言：线程的同步的知识略微杂乱，通过自己的学习做一些对基本知识的记录和梳理。以后有机会再干个大的。 2 线程同步的引子 2.1代码分析 //模拟火车站售票程序，开启三个窗口售票。 public class TestTrainTickets implements Runnable { private int ticketNum = 100; @Override public void run() { while (ticketNum > 0
解决线程安全问题的三种方法
陈福国的博客
05-29 3663
解决线程安全问题的三种方法 一、使用同步代码块 如：卖票案例 出现了线程安全 重复的票不能出现 步骤 成员位置建立锁对象； synchronized(锁对象){ 出现安全问题代码 } 1 锁对象 任意对象 2 必须保证多个线程使用的是同一个锁对象 3 把{} 只让一个线程进 例子： public class RunnableImpl implements Runnable...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
02-02
### Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题 #### 死锁 ##### 1. 说明 在多线程编程中，死锁是一种常见的问题，指的是两个或多个线程在执行过程中，因为竞争资源而造成的一种相互等待...
WHUT-java多线程实验-第二周-异常处理.zip
01-16
在"WHUT-java多线程实验-第二周-异常处理"这个实验中，我们将学习如何在多线程环境下进行异常捕获和处理。实验基于IntelliJ IDEA这个强大的Java集成开发环境进行，IDEA提供了友好的界面和丰富的工具，方便我们进行...
头歌之Java高级特性 - 多线程基础（3）线程同步.rar
最新发布
07-09
里面的内容分别为： 第1关：并发编程的三个概念 第2关：使用synchronized关键字同步线程 第3关：使用线程锁（Lock）实现线程同步 第4关：使用volatile实现变量的可见性
解决线程安全问题的三种方式
OKkkbh的博客
11-17 988
什么是线程安全问题？线程安全问题的产生是因为多给线程访问了共享数据。 举一个耳熟能详的例子，三个售票处在网上售卖100张票，假如此时的售票处都在出售第50张票，此时三个窗口卖出去了，而三个售票员都想修改余票数。但是三个人修改之后票数却只少了1张，这就莫名其妙多出了两张。为了解决这种问题，引入了线程安全问题的解决方法。 1、同步代码块 使用同步锁的方法，锁对象可以是任意对象，但是必须保证多个线程的使用的对象是同一个锁对象。锁对象的作用是把同步代码块锁住，每次只让一个线程在同步代...
关于解决线程安全的三个方法
m0_49641053的博客
05-18 221
解决线程安全问题的三个方法以及关于此处的面试题： 方式一：同步代码块 synchronized(同步监视器){ //需要被同步的代码 } 代码举例： class NewWindow implements Runnable { public int ticket = 100; Object o1 = new Object(); @Override public void run() { while (true) {
解决多线程安全问题三种方式
weixin_44769733的博客
02-06 342
解决多线程安全问题的三种方式: 一:同步代码块 同步代码块格式: synchronized (锁对象){被多线程执行的代码} 锁对象: 锁对象可以实任意对象 3 1.声明线程 //声明线程 public class MyRunnable implements Runnable { //1.定义全局变量 private int i = 100; //2.创建对象,作为同步代码...
【Java】第三十三节 解决线程安全性问题的三种方法
景谦Nice的博客
01-10 214
以上一节中多窗口卖票出现的问题来说明同步机制 方式一：同步代码块 synchronized(同步监视器){ //需要被同步的代码 } 1、操作共享数据(多个线程共同操作的变量)的代码需要被同步； 2、同步监视器，俗称锁。任何一个类的实例化对象都可以充当同步监视器，但是要保证处理共享数据的线程要共用一个同步监视器。因此： 如果是Thread类子类实例化方式创建的线程，同步监视器可以用该子类对应...
线程安全三种方式
weixin_44672631的博客
06-07 2230
方式一:同步代码块： synchronized(同步监视器){ //需要被同步的代码 } 说明: 1. 操作共享数据的代码，即为需要被同步的代码.--->不能包多代码，也别包少代码。 2.共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。 3.同步监视器，俗称:锁。任何一个类的对象，都是可以充当锁的。 要求：多个线程必须要公用同一把锁。 5.同步的方式，解决了线程的安全问题。---好处 操作同步代码时，只能有一个线程参与，其他线程等
线程安全问题解决的三个方案
qq_43149023的博客
08-02 1448
1.解决线程安全问题有三种方案： 1.1 同步代码块 syncnized(锁对象){ 可能出现线程安全问题的代码，访问了共享数据的daima } 注意：a.代码块中的锁对象，可以使用任意对象 b.必须保证多线程使用的锁对象是同一个 c.锁对象将同步...
Java多线程：线程安全与同步机制解析
"Java多线程编程中，线程安全问题和同步机制是核心话题。本文将探讨线程安全问题的产生原因以及如何通过不同方式解决，包括实现Runnable接口和继承Thread类。此外，还将分类总结线程安全问题，如局部变量、实例变量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值