Java synchornized与ReentrantLock处理并发出现的错误

更新时间：2023年01月05日 08:45:31 作者：欲无缘

synchronized机制提供了对每个对象相关的隐式监视器锁，并强制所有锁的获取和释放都必须在同一个块结构中。当获取了多个锁时，必须以相反的顺序释放。即synchronized对于锁的释放是隐式的

什么是并发错误

多个线程共享操作同一个对象的时候，线程体当中连续的多行操作未必能够连续执行很可能操作只完成了一部分，时间片突然耗尽，此时，另一个线程抢到时间片，直接拿走并访问了操作不完整的数据（操作不完整的数据，从逻辑上讲是错误数据）。

并发错误是如何产生的

根本原因：多个线程共享操作同一份数据

直接原因：线程体当中连续的多行语句，未必能够连续执行，很可能操作只完成了一半时间片突然耗尽。

此时另一个线程刚好抢到时间片，直接拿走了操作不完整的数据 - 错误数据。

导火索：时间片突然耗尽

演示并发错误

public class TestConcurrentError{
	public static void main(String[] args){
		Student stu = new Student("张朝伟","先生");
		PrintThread pt = new PrintThread(stu);
		ChangeThread ct = new ChangeThread(stu);
		pt.start();
		ct.start();
	}
}
class PrintThread extends Thread{
	Student stu;
	public PrintThread(Student stu){
		this.stu = stu;
	}
	@Override
	public void run(){
		while(true){
			System.out.println(stu);
		}
	}
}
class ChangeThread extends Thread{
	Student stu;
	public ChangeThread(Student stu){
		this.stu = stu;
	}
	@Override
	public void run(){
		boolean isOkay = true;
		while(true){
				if(isOkay){ 
					stu.name = "张曼玉";
					stu.gender = "女士";
				}else{ 
					stu.name = "梁朝伟";
					stu.gender = "先生";
				}
				isOkay = !isOkay;
		}
	}
}
class Student{
	String name;
	String gender;//性别
	public Student(String name,String gender){
		this.name = name;
		this.gender = gender;
	}
	@Override
	public String toString(){
		return name + " : " + gender;
	}
}

我们看运行结果发现一个非常严重的问题

我们的代码从来没有写过将梁朝伟赋值为女士，也没有写过将张曼玉赋值为女士我们的程序为什么会出现这样的情况 ?

线程体当中连续的多行操作未必能够连续执行假如我们将stu的名字赋值为梁朝伟，此时CPU时间片耗尽了，另一个打印的线程抢到时间片的情况下就会将原来的正确的值改为错误的数据从而产生并发错误。

如何解决并发错误

要想解决并发错误加锁是必须的

使用synchornized解决并发错误

synchronize语法级别的加锁也叫互斥锁=互斥标记=锁标记=锁旗标=监视器= Monitor

synchornized修饰代码块

synchronized(临界资源){
	//需要连续执行的操作
}

synchornized修饰整个方法

public synchronized void add(){
}
//等价于
public void add(){
	synchronized(){
	}
}

注意：即便synchronized加在方法上，其实还是对对象进行加锁，而且锁的是调用方法的那个对象Java世界里只有每个对象才有锁标记，所以加锁只能对对象加锁。

public class TestConcurrentError{
	public static void main(String[] args){
		Student stu = new Student("张朝伟","先生");
		PrintThread pt = new PrintThread(stu);
		ChangeThread ct = new ChangeThread(stu);
		pt.start();
		ct.start();
	}
}
//1st.用于打印显示数据的线程 
class PrintThread extends Thread{
	Student stu;
	public PrintThread(Student stu){
		this.stu = stu;
	}
	@Override
	public void run(){
		while(true){
			synchronized(stu){//我们要对一组连续的操作加锁 不要对所有操作加锁
							  //我们去厕所 只是锁一次上厕所的过程 不要一辈子死在厕所里
				System.out.println(stu);
			}
		}
	}
}
class ChangeThread extends Thread{
	Student stu;
	public ChangeThread(Student stu){
		this.stu = stu;
	}
	@Override
	public void run(){
		boolean isOkay = true;
		while(true){
			synchronized(stu){
				if(isOkay){ 
					stu.name = "张曼玉";
					stu.gender = "女士";
				}else{ 
					stu.name = "梁朝伟";
					stu.gender = "先生";
				}
				isOkay = !isOkay;
			}
		}
	}
}
class Student{
	String name;
	String gender;
	public Student(String name,String gender){
		this.name = name;
		this.gender = gender;
	}
	@Override
	public String toString(){
		return name + " : " + gender;
	}
}

使用ReentrantLock解决并发错误

java.util.concurrent.locks.ReentrantLock(jdk 5.0开始)：java包的工具包的并发包的可重入锁

ReentrantLock :lock（加锁） unlock(解锁):放在finally{}中

ReentrantLock可以在构造方法中传公平锁和非公平锁（公平与否针对第一个先来的线程而言）

公平锁：new Reetrantlock(true);

JDK6.0之前这个Lock的机制比synchronized效率高很多 JDK6.0开始
重新对synchronized修改了底层实现，加入了一堆新的概念 (偏向锁轻量级锁锁的自旋机制) 从JDK6.0开始 synchronized 跟 Lock性能上不相上下

import java.util.concurrent.locks.*;
public class TestConcurrentErrorWithLock{
	public static void main(String[] args){
		Lock lock = new ReentrantLock();
		Student stu = new Student("张朝伟","先生");
		PrintThread pt = new PrintThread(stu,lock);
		ChangeThread ct = new ChangeThread(stu,lock);
		pt.start();
		ct.start();
	}
}
//1st.用于打印显示数据的线程
class PrintThread extends Thread{
	Student stu;
	Lock lock;
	public PrintThread(Student stu,Lock lock){
		this.stu = stu;
		this.lock = lock;
	}
	@Override
	public void run(){
		while(true){
			lock.lock();//锁 既是一个名词 又是一个动词
			try{
			//synchronized(stu){//我们要对一组连续的操作加锁 不要对所有操作加锁
							  //我们去厕所 只是锁一次上厕所的过程 不要一辈子死在厕所里
				System.out.println(stu);
			//}
			}finally{
				lock.unlock();
			}
		}
	}
}
class ChangeThread extends Thread{
	Student stu;
	Lock lock;
	public ChangeThread(Student stu,Lock lock){
		this.stu = stu;
		this.lock = lock;
	}
	@Override
	public void run(){
		boolean isOkay = true;
		while(true){
			//synchronized(stu){
				lock.lock();
				try{
					if(isOkay){ 
						stu.name = "张曼玉";
						stu.gender = "女士";
					}else{ 
						stu.name = "梁朝伟";
						stu.gender = "先生";
					}
					isOkay = !isOkay;
				}finally{
					lock.unlock();
				}
			//}
		}
	}
}
class Student{
	String name;
	String gender;//性别
	public Student(String name,String gender){
		this.name = name;
		this.gender = gender;
	}
	@Override
	public String toString(){
		return name + " : " + gender;
	}
}

此时已经解决了并发错误

到此这篇关于Java synchornized与ReentrantLock处理并发出现的错误的文章就介绍到这了,更多相关Java synchornized与ReentrantLock内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

SpringBoot实现application.yml文件敏感信息加密
本文主要介绍了SpringBoot实现application.yml文件敏感信息加密，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-07-07
java编写猜数字游戏
这篇文章主要为大家详细介绍了java编写猜数字游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2020-05-05
SpringBoot多环境打包与配置文件排除实践记录
本文介绍了SpringBoot项目多环境打包与配置文件排除实践,包括多环境配置的实现方法、打包时排除配置文件的方法以及动态加载外部配置文件的最佳实践,感兴趣的朋友跟随小编一起看看吧
2024-11-11
Java 超详细讲解设计模式之中的建造者模式
建造者模式，是一种对象构建模式它可以将复杂对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构造出不同表现的对象。本文将通过示例讲解建造者模式，需要的可以参考一下
2022-03-03
java中常用工具类之字符串操作类和MD5加密解密类
这篇文章主要介绍了java中常用工具类之字符串操作类和MD5加密解密类,需要的朋友可以参考下
2014-07-07
Java中 % 与Math.floorMod() 区别详解
这篇文章主要介绍了Java中 % 与Math.floorMod() 区别详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2020-08-08
Java源码解析之详解ReentrantLock
今天给大家带来的是关于Java并发的相关知识,文章围绕着ReentrantLock源码展开,文中有非常详细的介绍及代码示例,需要的朋友可以参考下
2021-06-06
java中对象的序列化与反序列化深入讲解
这篇文章主要给大家介绍了关于java中对象的序列化与反序列化的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2018-09-09
Spring启动时实现初始化的几种方案
这篇文章主要介绍了Spring启动时实现初始化的几种方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-06-06
SpringBoot拦截器使用精讲
拦截器可以根据 URL 对请求进行拦截，主要应用于登陆校验、权限验证、乱码解决、性能监控和异常处理等功能上。SpringBoot同样提供了拦截器功能。本文将为大家详细介绍一下
2021-12-12