理解Java的线程安全问题

已于 2023-01-09 22:14:05 修改
阅读量1k 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言
于 2023-01-09 21:53:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46306264/article/details/128617660
版权
文章讨论了在Java中处理线程安全问题的几种方法，包括使用同步代码块、同步方法以及Lock锁。通过示例代码展示了如何解决多窗口售票系统中的重票问题，解释了同步监视器（锁）的概念，并比较了synchronized与Lock的区别。
摘要由CSDN通过智能技术生成

目录

目录

举例：三个窗口卖票

运行结果：出现重票

如何解决？

方式一：同步代码块，第一个例子

 运行结果：

改进：

 运行结果：

方法一：同步代码块的第二个例子。把锁和ticket都改为静态

运行结果：

方法二：同步方法，第一个例子

 方式二：同步方法第二个例子

 错误示范：show方法的锁是this，this指的是Window4的对象，即t1,t2,t3，3个线程用的不是同一个锁，所以线程不安全

正确示范：把show方法改为静态的，private static synchronized void show()，此时同步监视器（锁）是Window4.class

方式三：Lock锁方式解决线程安全问题

运行结果：

synchronized与Lock的异同？

举例：三个窗口卖票

 class Window1 implements Runnable{

	private int ticket=100;
	@Override
	public void run() {
		while(true) {
			if(ticket>0) {
				
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
				
				System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
				ticket--;
			}else {
				break;
			}
		}
		
	}

}


public class WindowTest1 {

	public static void main(String[] args) {
		Window1 w=new Window1();
		
		Thread t1=new Thread(w);
		Thread t2=new Thread(w);
		Thread t3=new Thread(w);
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
		
		
	}
}

运行结果：出现重票

问题：卖票的过程中，出现了重票、错票---->出现了线程安全问题

问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票

窗口2:卖票，票号为：100
窗口1:卖票，票号为：100
窗口3:卖票，票号为：100
窗口1:卖票，票号为：97
窗口2:卖票，票号为：97
窗口3:卖票，票号为：97

.......
窗口3:卖票，票号为：7
窗口3:卖票，票号为：4
窗口1:卖票，票号为：4
窗口2:卖票，票号为：4
窗口3:卖票，票号为：1
窗口1:卖票，票号为：1
窗口2:卖票，票号为：0

如何解决？

当线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以操作ticket。这种情况即使是线程a出现了阻塞，也不能被改变

在Java中，程序使用同步机制来解决

方式1：同步代码块

synchronized (同步监视器){

        //需要被同步的代码

}

说明：1.操作共享数据的代码，即为需要被同步的代码

2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据

3. 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

4.多个线程公用同一个锁。

方式2：同步方法

如果操作共享数据的代码完整声明在一个方法中，我们不妨将此方法声明为同步方法。

方式一：同步代码块，第一个例子

同步代码块解决Runnable接口创建的线程的安全问题

 class Window1 implements Runnable{

	private int ticket=100;
	Object obj=new Object();
	
	@Override
	public void run() {
		while(true) {
			
			synchronized(obj) {
			
			if(ticket>0) {
				
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
				
				System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
				ticket--;
			}else {
				break;
			}
			
			}
		}
		
	}

}

public class WindowTest1 {

	public static void main(String[] args) {
		Window1 w=new Window1();
		
		Thread t1=new Thread(w);
		Thread t2=new Thread(w);
		Thread t3=new Thread(w);
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
		
		
	}
}

 运行结果：

没有重票问题。但是，全是窗口3在卖票。没有3个窗口交替出现。理论上讲，没问题。

窗口3:卖票，票号为：100
窗口3:卖票，票号为：99
窗口3:卖票，票号为：98
窗口3:卖票，票号为：97
窗口3:卖票，票号为：96
.......

改进：

把sleep放到synchronized()上面。

class Window1 implements Runnable{

	private int ticket=100;
	Object obj=new Object();
	
	@Override
	public void run() {
		while(true) {
			
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			
			
			synchronized(obj) {
			
				if(ticket>0) {
					
					
					
					System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
					ticket--;
				}else {
					break;
				}
			
			}
		}
		
	}

}


public class WindowTest1 {

	public static void main(String[] args) {
		Window1 w=new Window1();
		
		Thread t1=new Thread(w);
		Thread t2=new Thread(w);
		Thread t3=new Thread(w);
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
		
		
	}
}

 运行结果：

没有重票问题，3个窗口交替卖票

窗口1:卖票，票号为：100
窗口2:卖票，票号为：99
窗口3:卖票，票号为：98
窗口1:卖票，票号为：97
窗口2:卖票，票号为：96
窗口3:卖票，票号为：95
......

窗口2:卖票，票号为：9
窗口1:卖票，票号为：8
窗口3:卖票，票号为：7
窗口1:卖票，票号为：6
窗口2:卖票，票号为：5
窗口2:卖票，票号为：4
窗口1:卖票，票号为：3
窗口3:卖票，票号为：2
窗口1:卖票，票号为：1

方法一：同步代码块的第二个例子。把锁和ticket都改为静态

因为Window2是线程类，3个线程要共用同一种ticket和锁

同步代码块处理继承Thread类的线程安全问题

锁可以用synchronized(Window2.class)，Window2.class只会加载一次，类也是对象

class Window2 extends Thread{

	private static int ticket=100;
	
//	静态锁，确保所有线程公用一个锁
	private static Object obj=new Object();
	@Override
	public void run() {
		while(true) {
			synchronized (obj) {
				if(ticket>0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
					System.out.println(getName()+"卖票，票号为:"+ticket);
					ticket--;
				}
				else {
					break;
				}
			}
		}
	}
}


public class WindowTest2 {

	public static void main(String[] args) {
		Window2 t1=new Window2();
		Window2 t2=new Window2();
		Window2 t3=new Window2();
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

运行结果：

窗口2卖票，票号为:100
窗口2卖票，票号为:99
窗口2卖票，票号为:98
窗口2卖票，票号为:97
窗口2卖票，票号为:96

....................

窗口3卖票，票号为:6
窗口3卖票，票号为:5
窗口3卖票，票号为:4
窗口3卖票，票号为:3
窗口3卖票，票号为:2
窗口3卖票，票号为:1

方法二：同步方法，第一个例子

同步方法解决Runnable接口创建的线程的安全问题

class Window3 implements Runnable{

	private   int ticket=100;

	@Override
	public void run() {
			while (true) {
				show();
				if(ticket<=0)  break;
			}		
			
		
	}
	
	
	//同步方法同步监视器是this
//	在本例子中，this指的是当前类的对象，即wtc
	private  synchronized void show() {

			if(ticket>0) {
				
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+" ticket:"+ticket);
				--ticket;
			}

	}
}


public class WindowTest3 {

	public static void main(String[] args) {
		Window3 wtc=new Window3();
		Thread th1=new Thread(wtc);
		Thread th2=new Thread(wtc);
		Thread th3=new Thread(wtc);
		
		th1.setName("窗口1");
		th2.setName("窗口2");
		th3.setName("窗口3");
		
		th1.start();
		th2.start();
		th3.start();
	}
}

 方式二：同步方法第二个例子

解决继承Thread类创建的线程的线程安全问题

 错误示范：show方法的锁是this，this指的是Window4的对象，即t1,t2,t3，3个线程用的不是同一个锁，所以线程不安全

class Window4 extends Thread{

	private static int ticket=100;
	

	@Override
	public void run() {
		while(true) {
			show();
			if(ticket<=0) break;
		}
	}


	/**
	 * 线程不安全
	 * private synchronized void show()表示同步监视器(锁)是this
	 * 这里的this指的是3个Window4的对象，即t1,t2,t3
	 */
	private synchronized void show() {
		if(ticket>0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			System.out.println(getName()+"卖票，票号为:"+ticket);
			ticket--;
		}
	}
}

public class WindowTest4 {

	public static void main(String[] args) {
//		window4是线程类
		Window4 t1=new Window4();
		Window4 t2=new Window4();
		Window4 t3=new Window4();
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

正确示范：把show方法改为静态的，private static synchronized void show()，此时同步监视器（锁）是Window4.class

class Window4 extends Thread{

	private static int ticket=100;
	

	@Override
	public void run() {
		while(true) {
			show();
			if(ticket<=0) break;
		}
	}


	/**
	 * 线程安全
	 * private staic synchronized void show()表示同步监视器(锁)是Window4.class
	 * Window4.class是唯一的
	 */
	private static synchronized void show() {
		if(ticket>0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			System.out.println(Thread.currentThread().getName()+"卖票，票号为:"+ticket);
			ticket--;
		}
	}
}


public class WindowTest4 {

	public static void main(String[] args) {
//		window4是线程类
		Window4 t1=new Window4();
		Window4 t2=new Window4();
		Window4 t3=new Window4();
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

同步方法总结：

1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明

2.非静态的同步方法，同步监视器是this

        静态方法的同步方法，同步监视器是：当前类本身，即xxx.class

方式三：Lock锁方式解决线程安全问题

JDK5.0新增

class Window5 implements Runnable{

	private int ticket=100;
	//true是公平锁，个进程排队获得锁，释放锁。
	private ReentrantLock  lock=new ReentrantLock(true);
	@Override
	public void run() {
		while (true) {
//			调用锁定方法
			lock.lock();
			try {
				
				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;				
				}else {
					break;
				}
			} finally {
//				调用解锁方法
				lock.unlock();
			}
			
		}
		
	}
	
}


public class WindowTest5 {

	public static void main(String[] args) {
		Window5 win=new Window5();
		
//		3个线程公用1个win对象
		Thread th1=new Thread(win);
		Thread th2=new Thread(win);
		Thread th3=new Thread(win);
		
		th1.setName("窗口1");
		th2.setName("窗口2");
		th3.setName("窗口3");
		th1.start();
		th2.start();
		th3.start();
	}
}

运行结果：

窗口1:100
窗口2:99
窗口3:98
窗口1:97
窗口2:96
窗口3:95
窗口1:94

................

窗口1:7
窗口2:6
窗口3:5
窗口1:4
窗口2:3
窗口3:2
窗口1:1

synchronized与Lock的异同？

相同：二者都可以解决线程安全问题

不同 ：synchronized机制在执行完相应的同步代码后，自动的释放同步监视器。Lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现（unlock() ）

Singcing
关注
专栏目录
Java线程安全问题小结_动力节点Java学院整理
08-30
Java线程安全问题主要涉及到并发环境下多个线程对共享资源的访问和修改，这可能导致数据不一致、死锁等问题。Java内存模型（JMM）是Java语言为了保证跨平台的并发正确性而设定的一套规范，它规定了线程如何访问和...
Java多线程-线程安全问题练习题
01-30
在Java多线程编程中，线程安全问题是非常关键的概念，它涉及到多个线程访问共享资源时可能出现的数据不一致或异常情况。本题主要通过两个练习题来加深对线程安全的理解。 ### 练习题1：新年倒计时 #### 题目描述 ...
java中线程安全问题以及解决方法
weixin_53870975的博客
01-11 550
首先为什么会引发线程安全问题： 多线程共享数据时存在线程的安全问题（线程间没有共享数据是不会发生线程安全问题） 这边我们举个例子来说明 第一个 ：窗口卖票问题 我们现在有三个窗口要卖100张票 代码如下： class Window1 implements Runnable{ private int ticket=100; @Override public void run() { while(true){ if(ticket>0.
Java多线程（三）：线程安全问题与解决方法
澄白易的博客
04-20 1968
1. 什么是线程安全问题 如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。线程不安全指的是程序在多线程的执行结果不符合预期。 2. 导致线程不安全的因素 2.1 抢占式执行 2.2 多个线程同时修改了同一个变量 public class ThreadDemo16 { static class Counter { // 变量 private int number = 0; ...
探索自然语言处理新纪元：JTokkit - Java的高效令牌化工具库
gitblog_00019的博客
08-16 524
探索自然语言处理新纪元：JTokkit - Java的高效令牌化工具库 jtokkitJTokkit is a Java tokenizer library designed for use with OpenAI models.项目地址:https://gitcode.com/gh_mirrors/jt/jtokkit ???? JTokkit 是一个为OpenAI模型量身定制的Java令牌化库，它...
Java多线程-线程安全问题的原因和解决方案
m0_62468521的博客
03-31 270
5000字带你深度理解Java多线程-线程安全问题的原因和解决方案
关于JAVA中的线程安全
02-24 1530
 原理：    首先要明白线程的工作原理，jvm有一个main   memory，而每个线程有自己的working   memory，一个线程对一个variable进行操作时，都要在自己的working   memory里面建立一个copy，操作完之后再写入main   memory。多个线程同时操作同一个variable，就可能会出现不可预知的结果。根据上面的解释，很容易想出相应的scena
在java当中，什么是线程安全问题
frankruan_的博客
09-02 160
public class Ticket implements Runnable { private int ticket = 100; /* * 执行卖票操作 */ @Override public void run() { //每个窗口卖票的操作 //窗口 永远开启 while (true) { if (ticket > 0) {//有票 可以卖 //出票操作 //使用sleep模拟...
完美解决Java中的线程安全问题
08-29
解决 Java 中的线程安全问题需要我们对线程安全机制有深入的理解和掌握。今天，我们讨论了使用 synchronized 关键字来解决线程安全问题，但这只是解决线程安全问题的一种方法，还有其他方法和技术可以解决这个问题。
Java ThreadLocal 线程安全问题解决方案
09-01
Java中的ThreadLocal是解决线程安全问题的一个重要工具，它提供了一种在多线程环境下为每个线程维护独立变量副本的方法，从而避免了共享状态带来的竞态条件和线程安全问题。 线程安全问题通常由全局变量和静态变量...
Java通过WTC调Tuxedo服务实例(String)
01-05
Java通过WTC调Tuxedo服务实例,传入类型：String型
java类属性线程安全_1.java面试问题 之 基础类型属性（int）能否线程安全？
weixin_30135925的博客
03-02 693
脑海第一感觉 static int 公告的属性肯定是非线程安全的。int直接公告的属性难道也是非线程安全吗？(疑问)。通过题面意思就能感觉到面试官的用意，他就是想让你说是非线程安全的。而后他好问为什么。结果我直接说不知道。说实话真拿不准，于是自己通过实践验证得出了少量结论并记录下来。加申印象。private static int value = 1;private int value = 1;以下...
推荐开源项目： JTokkit - Java 的高效 Tokenizer 工具包
gitblog_00039的博客
05-24 678
推荐开源项目：???? JTokkit - Java 的高效 Tokenizer 工具包 jtokkitJTokkit is a Java tokenizer library designed for use with OpenAI models.项目地址:https://gitcode.com/gh_mirrors/jt/jtokkit 1、项目介绍 走进 JTokkit，一个专为 Java 开发者...
大模型：JTokkit 分词
最新发布
m0_37559973的博客
09-25 207
JTokkit 是一个专为 Java 开发者设计的高效文本分词库，主要适用于与 OpenAI 模型进行集成。它提供了一种简单易用的接口，使开发者能够轻松地对输入文本进行编码和解码，尤其是在准备向 GPT-3.5 等模型发送请求时。这个库的设计初衷是为了在 JVM 生态系统中实现类似 Python 中 tiktoken 库的功能。
JTokkit 开源项目教程
gitblog_00973的博客
08-16 817
JTokkit 开源项目教程 jtokkitJTokkit is a Java tokenizer library designed for use with OpenAI models.项目地址:https://gitcode.com/gh_mirrors/jt/jtokkit 1. 项目的目录结构及介绍 JTokkit 是一个用于 OpenAI 模型的 Java 分词器库。以下是其目录结构的...
【开源免费】ChatGPT-Java版SDK重磅更新至1.0.10版，支持Tokens计算，快来一键接入！！！
BASK2311的博客
04-08 5373
目前收获将近1000个star。有bug欢迎朋友们指出，互相学习，所有咨询全部免费。
抖音sdk调用，同步抖音粉丝列表
ruanquanf的博客
05-31 203
抖音sdk调用，同步抖音粉丝列表 /** * 同步抖音粉丝 * @author wechat:happybabby110 * @blog http://www.wlkankan.cn */ @Async public void handleMsg(ChannelHandlerContext ctx,TransportMessage vo, String contentJsonStr) { try { log.d
深入理解Java线程安全：内存模型与同步机制
理解Java线程安全的核心在于掌握Java内存模型（JMM）和线程同步机制。 Java内存模型规定了所有线程共享主内存，每个线程都有自己的工作内存，其中保存了主内存中的变量副本。线程对变量的操作必须遵循特定的步骤：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值