线程安全应用:

最新推荐文章于 2024-10-12 23:00:53 发布
最新推荐文章于 2024-10-12 23:00:53 发布
阅读量688 收藏 6
点赞数 27
文章标签： 安全 java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57463864/article/details/139552120
版权

线程安全应用:

线程安全应用:

ArrayList:

ArrayList是线程不安全的集合。

解决方案1：使用Vector – synchronized锁
 
解决方案2：使用Collections的synchronizedList方法将ArrayList转换为线程安全的集合 – synchronized锁

ArrayList<Object> list = new ArrayList<>();

List<Object> synchronizedList = Collections.synchronizedList(list);

 
解决方案3：使用CopyOnWriteArrayList – lock锁

CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<>();
	list.add("aaa");
	list.add("bbb");
	list.add("ccc");
	list.add("ddd");

​

​ 总结：Vector和synchronizedList()底层使用synchronized（重量级锁），效率很低。项目中推荐使用CopyOnWriteArrayList。

 
 

死锁：

死锁：多个线程中的多个锁对象被互相占用。
 
解决方案：尽可能的不要使用锁嵌套。

//哲学家1抢到a筷子，哲学家2抢到b筷子，发生死锁，程序不能进行。
public static void main(String[] args) {
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (KuaiZi.a) {
					//try {
					//	Thread.sleep(1);
					//} catch (InterruptedException e) {
					//	e.printStackTrace();
					//}
					synchronized (KuaiZi.b) {
						System.out.println("哲学家1吃饭饭");
					}
				}
			}
		}, "哲学家1");
		
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (KuaiZi.b) {
                    //休眠增加死锁概率
					//try {
					//	Thread.sleep(1);
					//} catch (InterruptedException e) {
					//	e.printStackTrace();
					//}
					synchronized (KuaiZi.a) {
						System.out.println("哲学家2吃饭饭");
					}
				}
			}
		}, "哲学家2");
		
		t1.start();
		t2.start();
		
	}

 

 

可重入锁：

​ 可重入锁：一个锁使用了一次之后，不需要立即解锁，就可再使用该锁一次。
 
​ 就是一个线程不用释放，可以重复的获取一个锁n次，只是在释放的时候，也需要相应的释放n次。
 
​ 简单来说：A线程在某上下文中获取了某锁，当A线程想要再次获取该锁时，不会因为锁已经被自己占用，而需要先等到锁的释放。

synchronized同步代码块是可重入锁。
synchronized同步方法是可重入锁。
Lock锁是可重入锁。

public class Task01 implements Runnable{

	@Override
	public void run() {
		synchronized (this) {
			System.out.println("获取到锁对象：" + this);
			
			synchronized (this) {
				System.out.println("获取到锁对象：" + this);
				
				System.out.println("释放锁对象：" + this);
			}
			
			System.out.println("释放锁对象：" + this);
		}
	}
}


public class Task02 implements Runnable{

	@Override
	public void run() {
		method1();
	}
	
	public synchronized void method1(){
		System.out.println("获取到锁对象：" + this);
		method2();
		System.out.println("释放锁对象：" + this);
	}
	
	public synchronized void method2(){
		System.out.println("获取到锁对象：" + this);
		
		System.out.println("释放锁对象：" + this);
	}
}


public class Task03 implements Runnable{

	private Lock lock = new ReentrantLock();
	
	@Override
	public void run() {
		
		lock.lock();
		System.out.println("获取到锁对象：" + this);
		lock.lock();
		System.out.println("获取到锁对象：" + this);
		lock.unlock();
		System.out.println("释放锁对象：" + this);
		lock.unlock();
		System.out.println("释放锁对象：" + this);
	}
}

 
 

生产者消费者模型：

​ 生产者消费者模型：重点加锁的逻辑放在线程中。

 

一个生产者一个消费者：

一个生产者一个消费者的情况。
 
步骤：
1.生产者线程、消费者线程不断的操作同一个产品对象
脏数据：
       null – 0.0
       华为 – 0.0
 
2.两个产品之间来回切换（目的：放大步骤1的问题）
脏数据：
       null – 0.0
       华为 – 0.0
       小米 – 3999.0
       华为 – 1999.0
出现原因：设置完品牌后，还没来得及设置价格，就被消费者线程抢到CPU资源。
解决方案：生产者线程设置完品牌+价格后，消费者线程才能执行自己的代码 – 加锁。
 
3.生产一个消费一个
产品类加一个库存的属性 – boolean store = false。
 
​ 生产者线程在每次生产之前都得判断是否有库存，有就等待(等待消费者线程消费后再生产)，没有就生产。
 
​ 消费者线程在每次消费之前都得判断是否有库存，有就消费，没有就等待(等待生产者线程生产后再消费)。
 
​ 生产者线程和消费者线程互相唤醒。

public class Phone {
	
	private String brand;
	private double price;
	private boolean store;
	
	public Phone() {
	}

	public Phone(String brand, double price) {
		this.brand = brand;
		this.price = price;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}
	
	public boolean isStore() {
		return store;
	}

	public void setStore(boolean store) {
		this.store = store;
	}

	@Override
	public String toString() {
		return "Phone [brand=" + brand + ", price=" + price + "]";
	}
}


//生产者线程
public class Produce extends Thread{
	
	private Phone phone;
	
	public Produce(Phone phone) {
		this.phone = phone;
	}

	@Override
	public void run() {
		
		boolean flag = true;
		
		while(true){
            //phone是锁对象
			synchronized(phone){
				//phone是对象，调用phone的方法
				if(phone.isStore()){
					try {
						/**
						 * 等待：
						 * 		1.释放锁资源
						 * 		2.在对象监视器(phone)中记录当前线程被等待（阻塞）
						 * 		3.当前线程进入到阻塞状态
						 */
                        //phone为对象监视器
						phone.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				if(flag){
					phone.setBrand("华为");
					phone.setPrice(3999);
				}else{
					phone.setBrand("小米");
					phone.setPrice(1999);
				}
				flag = !flag;
				phone.setStore(true);
				
				phone.notify();//唤醒：唤醒对象监视器中任意一个线程
			}
		}
	}
}


//消费者线程
public class Consumer extends Thread{
	
	private Phone phone;
	
	public Consumer(Phone phone) {
		this.phone = phone;
	}

	@Override
	public void run() {
		while(true){
			synchronized(phone){
				
				if(!phone.isStore()){
					try {
						/**
						 * 等待：
						 * 		1.释放锁资源
						 * 		2.在对象监视器(phone)中记录当前线程被等待（阻塞）
						 * 		3.当前线程进入到阻塞状态
						 */
						phone.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				System.out.println(phone.getBrand() + " -- " + phone.getPrice());
				phone.setStore(false);
				
				phone.notify();//唤醒：唤醒对象监视器中任意一个线程
				
			}
		}
	}
}


public static void main(String[] args) {
		
		Phone phone = new Phone();
		
		Produce p = new Produce(phone);
		Consumer c = new Consumer(phone);
		
		p.start();
		c.start();
	}

 
 

多个生产者多个消费者：

//生产者线程
public class Produce extends Thread{
	
	private Phone phone;
	
	public Produce(Phone phone) {
		this.phone = phone;
	}
	
	private static boolean flag = true;
	@Override
	public void run() {
		
		while(true){
			synchronized(phone){
				
				while(phone.isStore()){
					try {
						/**
						 * 等待：
						 * 		1.释放锁资源
						 * 		2.在对象监视器(phone)中记录当前线程被等待（阻塞）
						 * 		3.当前线程进入到阻塞状态
						 */
						phone.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				if(flag){
					phone.setBrand("华为");
					phone.setPrice(3999);
				}else{
					phone.setBrand("小米");
					phone.setPrice(1999);
				}
				flag = !flag;
				phone.setStore(true);
				
				phone.notifyAll();//唤醒：唤醒对象监视器中所有线程
			}
		}
	}
}


//消费者线程
public class Consumer extends Thread{
	
	private Phone phone;
	
	public Consumer(Phone phone) {
		this.phone = phone;
	}

	@Override
	public void run() {
		while(true){
			synchronized(phone){
				
				while(!phone.isStore()){
					try {
						/**
						 * 等待：
						 * 		1.释放锁资源
						 * 		2.在对象监视器(phone)中记录当前线程被等待（阻塞）
						 * 		3.当前线程进入到阻塞状态
						 */
						phone.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				System.out.println(phone.getBrand() + " -- " + phone.getPrice());
				phone.setStore(false);
				
				phone.notifyAll();//唤醒：唤醒对象监视器中所有线程
				
			}
		}
	}
}


public static void main(String[] args) {
		
		Phone phone = new Phone();
		
		Produce p1 = new Produce(phone);
		Produce p2 = new Produce(phone);
		Consumer c1 = new Consumer(phone);
		Consumer c2 = new Consumer(phone);
		
		p1.start();
		p2.start();
		c1.start();
		c2.start();
	}

 
 

仓储模型:

仓储模型：重点加锁的逻辑放在线程外。

需求：
生产者线程不断的生产蛋糕（将蛋糕对象添加到仓库）。
消费者线程不断的消费蛋糕（将蛋糕对象从仓库中取出）。
先生产的蛋糕，先卖出。
 
分析：
1.蛋糕类、仓库类、生产者线程、消费者线程。
2.仓库类里有一个存放蛋糕对象的集合 – LinkedList。

 

一个生产者线程一个消费者线程:

对象监视器用谁：锁对象用谁，对象监视器就用谁。

//蛋糕类
public class Cake {

	private String brand;
	private String datetime;
	
	public Cake() {
	}

	public Cake(String brand, String datetime) {
		this.brand = brand;
		this.datetime = datetime;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getDatetime() {
		return datetime;
	}

	public void setDatetime(String datetime) {
		this.datetime = datetime;
	}

	@Override
	public String toString() {
		return "Cake [brand=" + brand + ", datetime=" + datetime + "]";
	}
}


import java.util.LinkedList;

//仓库类
public class Store {
	
	private int curCapacity;//当前容量
	private int maxCapacity;//最大容量
	private LinkedList<Cake> list;//蛋糕容器
	
	public Store(int maxCapacity) {
		this.maxCapacity = maxCapacity;
		list =  new LinkedList<>();
	}
	
	//入库(此方法被生产者线程不断的调用)
	public synchronized void push(Cake cake){
		if(curCapacity >= maxCapacity){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		list.add(cake);
		curCapacity++;
		System.out.println("入库 - 当前容量为：" + curCapacity);
		this.notify();
	}
	
	
	//出库(此方法被消费者线程不断的调用)
	public synchronized Cake pop(){
		if(curCapacity <= 0){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		Cake cake = list.removeFirst();
		curCapacity--;
		System.out.println("出库 - 当前容量为：" + curCapacity + "，卖出的蛋糕为：" + cake);
		this.notify();
		return cake;
	}
	
}


import java.time.LocalDateTime;

//生产者线程
public class Produce extends Thread{

	private Store store;

	public Produce(Store store) {
		this.store = store;
	}
	
	@Override
	public void run() {
		while(true){
			Cake cake = new Cake("桃李", LocalDateTime.now().toString());
			store.push(cake);
		}
	}
}


//消费者线程
public class Consumer extends Thread{
	
	private Store store;
	
	public Consumer(Store store) {
		this.store = store;
	}

	@Override
	public void run() {
		while(true){
			store.pop();
		}
	}
}


public static void main(String[] args) {
		
		Store store = new Store(20);
		
		Produce p = new Produce(store);
		Consumer c = new Consumer(store);
		
		p.start();
		c.start();
	}

 

 

多个生产者线程多个消费者线程：

import java.util.LinkedList;

//仓库类
public class Store {
	
	private int curCapacity;//当前容量
	private int maxCapacity;//最大容量
	private LinkedList<Cake> list;//蛋糕容器
	
	public Store(int maxCapacity) {
		this.maxCapacity = maxCapacity;
		list =  new LinkedList<>();
	}
	
	//入库(此方法被生产者线程不断的调用)
	public synchronized void push(Cake cake){
		while(curCapacity >= maxCapacity){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		list.add(cake);
		curCapacity++;
		System.out.println("入库 - 当前容量为：" + curCapacity);
		this.notifyAll();
	}
	
	//出库(此方法被消费者线程不断的调用)
	public synchronized Cake pop(){
		while(curCapacity <= 0){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		Cake cake = list.removeFirst();
		curCapacity--;
		System.out.println("出库 - 当前容量为：" + curCapacity + "，卖出的蛋糕为：" + cake);
		this.notifyAll();
		return cake;
	}
	
}


public static void main(String[] args) {
		
		Store store = new Store(20);
		
		Produce p1 = new Produce(store);
		Produce p2 = new Produce(store);
		Consumer c1 = new Consumer(store);
		Consumer c2 = new Consumer(store);
		
		p1.start();
		p2.start();
		c1.start();
		c2.start();
	}
欧阳大帅哥
关注
构建线程安全应用程序
09-18
当对一个复杂对象进行某种操作时，从操作开始到操作结束，被操作的对象往往会经历若干非法的中间状态。这跟外科医生做手术有点像，尽管手术的目的是改善患者的健康，但医生把手术过程分成了几个步骤，每个步骤如果不是完全结束的话，都会严重损害患者的健康。想想看，如果一个医生切开患者的胸腔后要休三周假会怎么样？与此类似，调用一个函数（假设该函数是正确的）操作某对象常常会使该对象暂时陷入不可用的状态（通常称为不稳定状态），等到操作完全结束，该对象才会重新回到完全可用的状态。如果其他线程企图访问一个处于不可用状态的对象，该对象将不能正确响应从而产生无法预料的结果，如何避免这种情况发生是线程安全性的核心问题
线程安全的std :: map和无锁映射的速度
04-11
- `Real_app_bench.zip`、`CDS_test.zip`、`benchmark.zip`：这些可能是包含实际应用的基准测试代码或测试结果，用于比较线程安全的std::map与无锁映射的性能。 - `safe_ptr.zip`：可能包含了一些线程安全指针的...
Linux：线程安全，多线程的应用
weixin_58368590的博客
06-30 347
如何保证线程安全：同步和添加线程安全函数 多线程的应用
JAVA多线程的线程安全以及锁的应用
qq_34407675的博客
03-19 145
** JAVA多线程的线程安全以及锁的应用 ** 目录: 什么是线程安全？怎么实现线程安全？ 什么是进程？ 什么是线程？ 什么是线程安全？ 添加一个状态呢？ 如何确保线程安全？ synchronized lock 什么是进程？ 电脑中时会有很多单独运行的程序，每个程序有一个独立的进程，而进程之间是相互独立存在的。比如下图中的QQ、酷狗播放器、电脑管家等等。在这里插入图片描述 什么是线程？ 进程想要...
（27）线程安全的实际应用
qq_2533491534的博客
12-11 320
1，   同步方法 2，   同步代码块 3，   使用Lock锁 4，   比较同步方法，同步代码块和Lock锁的区别 如何解决线程安全的问题 1，同步方法，具体实现如下： public static void main(String[] args) { ...
java并发控制机制
DanEmpress的博客
09-06 2317
并行程序开发不可避免地要涉及多线程、多任务的协作和数据共享等问题。在JDK中，提供了多种途径实现多线程间的并发控制。比如常用的：内部锁、重入锁、读写锁和信号量。 Java内存模型 在java中，每一个线程有一块工作内存区，其中存放着被所有线程共享的主内存中的变量的值的拷贝。当线程执行时，它在自己的工作内存中操作这些变量。 为了存取一个共享的变量，一个线程通常先获取锁定并且清除它的
C++多线程：std::thread
iuices的博客
02-23 9642
最近这段时间在学习C++多线程相关的知识，打算将学习的内容记录下来，加深理解和记忆。C++11 新标准中引入了五个头文件来支持多线程编程，他们分别是<atomic> ,<thread>,<mutex>,<condition_variable>和<future>。<atomic>：该头文主要声明了两个类, std::atomic 和 std::atomic_flag，另外还声明了一套C风格的原子类型和与C兼容的原子操作的函数。<th
Java 基础 —— 线程安全
IT__learning的博客
10-31 9008
一、线程安全问题 线程安全 当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的 一个程序在运行起来的时候会转换成进程，通常含有多个线程。通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。又比如实际生活中，银行取钱问题、火车票多个售票窗口的问题，通常会涉及到并发的问题，从而需要多线程的技术。 当进程中
Java 面试题：如何保证集合是线程安全的? ConcurrentHashMap 如何实现高效地线程安全？
栗筝i的博客
06-22 3115
在多线程编程中，保证集合的线程安全是一个常见而又重要的问题。线程安全意味着多个线程可以同时访问集合而不会导致数据不一致或程序崩溃。在 Java 中，确保集合线程安全的方法有多种，包括使用同步包装类、锁机制以及并发集合类。 最简单的方法是使用 Collections.synchronizedXXX 方法来包装集合，例如 Collections.synchronizedList 和 Collections.synchronizedMap。然而，这种方式的性能较低，因为它在每个操作上都添加了同步锁。 为了解决
124.线程的安全:synchronized锁的应用；
嘻哈怪才的博客
02-21 3714
线程的安全 【示例】 模拟窗口卖票，2个窗口同时在卖100张火车票，每张票间隔50毫秒； @Data class Ticket{ //票号 private int no; //车次 private String car; } class TicTunnable implements Runnable{ //常量 //最大的票号 private int max = 100; //当前的票号 private int curr = 0;
Java 多线程技术：（四）获取线程基本信息_暂停线程_线程的优先级_多线程的安全性_线程同步
12-20
在Java编程中，多线程技术是至关重要的，特别是在处理并发任务时，它能提高程序的...开发者应始终考虑线程安全性和同步策略，以避免竞态条件和死锁等问题。通过熟练掌握这些技巧，可以更好地设计和实现并发应用程序。
浅析iOS应用开发中线程间的通信与线程安全问题
01-04
线程间的通信   简单说明 线程间通信：在1个进程中，线程往往不是孤立存在的，多个线程之间需要经常进行通信   线程间通信的体现 1个线程传递数据给另1个线程 在1个线程中执行完特定任务后，转到另1个线程继续执行...
C#多线程List的非线程安全性
11-07
总之，理解并处理多线程环境下的线程安全问题是提升C#应用程序稳定性和性能的关键。在使用List或其他非线程安全的数据结构时，要时刻警惕潜在的并发问题，并采取适当的同步措施，确保数据的一致性和完整性。
禁用微软的windos安全中心
最新发布
qq_54523516的博客
10-12 672
描述：下载第三方软件常常会收到病毒防护秒杀，第2---提前下载在U盘解压会被干掉程序文件。第3---运行的时候报错，被干掉运行文件。选择禁用windows defender。打开WDControl 1.5.0软件。打开windows安全中心。第1---直接无法下载。
域1：安全与风险管理 第2章-人员安全与风险管理
rm -rf /*
10-12 957
风险管理过程包括识别可能造成数据损坏或泄漏的因素，根据数据价值和控制措施的成本评估这些因素，并实施具有成本效益的解决方案来减轻或者降低风险。通过执行风险管理，为全面降低风险奠定基础。
如何选择安全的谷歌浏览器插件
2403_86768603的博客
10-12 565
在数字时代，浏览器插件为我们提供了极大的便利，增强了我们的浏览体验。然而，随着便利性的增加，安全性问题也日益凸显。以下是详细的教程，帮助你选择和使用安全的谷歌浏览器插件。在安装任何插件之前，查看其开发者信息，包括开发者的名称、网站以及其他用户的评价。一个仅仅提供网页高亮功能的插件请求访问你的联系人列表显然是不合理的。记住，保护个人信息的安全是一场持久战，需要我们持续的关注和努力。最后，安装可靠的安全软件可以帮助防止恶意软件和病毒的入侵。确保这些密码的安全性，避免使用简单或重复的密码。
探索光耦：光耦助力高速电吹风安全与性能的革命性提升
forvevr的博客
10-10 487
一旦电吹风内部温度过高或电路出现故障，光耦能够迅速传递故障信号至控制器，触发自动保护机制，切断电源，从而防止元器件损坏，延长电吹风的使用寿命。综上所述，选择搭载光耦技术的高速电吹风，不仅意味着为头发护理带来了更健康、智能的解决方案，更是对安全性和耐用性的有力保障。这一利用光信号实现电气隔离的电子元件，通过独特的非接触式传输方式，有效隔绝了电路的电气联系，从而显著提高了设备的安全性，避免了高压电路可能带来的风险。其中，光耦（光电耦合器）的引入，无疑为电吹风的性能优化与安全保障开辟了新路径。
企业内部文档安全外发如何挑选合适的外发系统？
镭速的博客
10-12 646
镭速技术已成功帮助多家企业实现文档安全外发管理，如在B2B模式下，通过镭速技术，企业可以构建一个安全、高效、可控的文档外发管理体系，从而在激烈的市场竞争中占据优势。然而，如何在保证信息安全的同时实现高效、便捷的文档外发，成为了一个不小的挑战。：镭速技术已成功帮助多家企业实现文档安全外发管理，如在B2B模式下，通过镭速技术，企业可以构建一个安全、高效、可控的文档外发管理体系，从而在激烈的市场竞争中占据优势。：通过多层次的安全机制，如数据传输全程加密、审批流程、传输日志记录等，确保文档在传输过程中的安全性。
网络安全的全面指南
qq_42568323的博客
10-09 1197
网络安全是指保护计算机网络及其数据免受未经授权访问、攻击或破坏的过程。其目标是确保信息的机密性、完整性和可用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值