当前位置： 首页 > news >正文

脏读+synchronized使用

news 来源：原创 2024/5/3 7:20:48

脏读

对于对象的同步和异步的方法，在设计自己程序的时候，一定要考虑问题的整体，不然就会出现数据不一致的错误，很经典的错误就是脏读。

在我们对一个对象的方法加锁的时候，需要考虑业务的整体性，即为setValue/getValue方法同时加锁synchronized同步关键字，保证业务的原子性，不然就会出现业务错误（也从侧面保证业务的一致性）

/**
 * 业务整体需要使用完整的synchronized，保持业务的原子性。
 *
 */
public class DirtyRead {

	private String username = "hebei";
	private String password = "hb";
	
	public synchronized void setValue(String username, String password){
		this.username = username;
		
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		this.password = password;
		
		System.out.println("setValue最终结果：username = " + username + " , password = " + password);
	}
	
	public void getValue(){
		System.out.println("getValue方法得到：username = " + this.username + " , password = " + this.password);
	}
	
	
	public static void main(String[] args) throws Exception{
		
		final DirtyRead dr = new DirtyRead();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				dr.setValue("beijing", "bj");		
			}
		});
		t1.start();
		Thread.sleep(1000);
		
		dr.getValue();
	}
}

代码执行后，在主线程main执行的过程中，创建的子线程t1也在执行。程序的目的是:先给username、password赋值，然后获取最新的username、password的值。但是主线程在休眠1s后继续执行getValue()的时候，子线程由于内部休眠2s中，还没有完成对password的赋值，因此主线程main执行getValue()获得的password值为hb.

在Eclipse的console中输出



为了达到程序的目的，可以在getValue()添加synchronized

public synchronized void getValue()

此时，执行程序，输出结果为：



synchronized锁重入

关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到了一个对象的锁后，再次请求此对象时可以再次得到该对象的锁。

/**
 * synchronized的重入
 *
 */
public class SyncDubbo1 {

	public synchronized void method1(){
		System.out.println("method1..");
		method2();
	}
	public synchronized void method2(){
		System.out.println("method2..");
		method3();
	}
	public synchronized void method3(){
		System.out.println("method3..");
	}
	
	public static void main(String[] args) {
		final SyncDubbo1 sd = new SyncDubbo1();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				sd.method1();
			}
		});
		t1.start();
	}
}

在Eclipse的console中输出 



/**
 * synchronized的重入
 *
 */
public class SyncDubbo2 {

	static class Main {
		public int i = 10;
		public synchronized void operationSup(){
			try {
				i--;
				System.out.println("Main print i = " + i);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	static class Sub extends Main {
		public synchronized void operationSub(){
			try {
				while(i > 0) {
					i--;
					System.out.println("Sub print i = " + i);
					Thread.sleep(100);		
					this.operationSup();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				Sub sub = new Sub();
				sub.operationSub();
			}
		});
		
		t1.start();
	}
	
	
}

上述代码中内部类Main、Main的子类Sub，在主线程main中创建子线程，子线程中创建Sub类的对象，并调用其同步方法operationSub()，在该方法中每次循环都要调用父类main中的operationSup()方法，operationSup()方法也是一个同步方法。

Eclipse的console中输出



synchronized异常

根据实际的项目需求，出现异常后，是跳过异常继续向下执行，还是结束该线程，分别进行不同的异常处理。

/**
 * synchronized异常
 *
 */
public class SyncException {

	private int i = 0;
	public synchronized void operation(){
		while(true){
			try {
				i++;
				Thread.sleep(100);
				System.out.println(Thread.currentThread().getName() + " , i = " + i);
				if(i == 10){
					Integer.parseInt("a");
				}
			} catch (Exception e) {
				e.printStackTrace();
				continue;//跳过异常，线程继续执行
				//throw new RuntimeException();//让线程停止
			}
		}
	}
	
	public static void main(String[] args) {
		
		final SyncException se = new SyncException();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				se.operation();
			}
		},"t1");
		t1.start();
	}
}
Eclipse中console输出



若代码改为

//continue;//跳过异常，线程继续执行
throw new RuntimeException();//让线程停止

run as --java application,在console中输出如下：



synchronized对象锁、类锁、任意对象锁

/**
 * 使用synchronized代码块加锁,比较灵活
 *
 */
public class ObjectLock {

	public void method1(){
		synchronized (this) {	//对象锁
			try {
				System.out.println("do method1..");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public void method2(){		//类锁
		synchronized (ObjectLock.class) {
			try {
				System.out.println("do method2..");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	private Object lock = new Object();
	public void method3(){		//任何对象锁
		synchronized (lock) {
			try {
				System.out.println("do method3..");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	public static void main(String[] args) {
		
		final ObjectLock objLock = new ObjectLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				objLock.method1();
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				objLock.method2();
			}
		});
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				objLock.method3();
			}
		});
		
		t1.start();
		t2.start();
		t3.start();
	}
}

不要使用字符串常量加锁，如：synchronized ("AAA")

若对字符串变量加锁，在synchronized代码块内部不要修改加锁的这个字符串变量的值。

/**
 * 锁对象的改变问题
 *
 */
public class ChangeLock {

	private String lock = "lock";
	
	private void method(){
		synchronized (lock) {
			try {
				System.out.println("当前线程 : "  + Thread.currentThread().getName() + "开始");
				//lock = "change lock";
				Thread.sleep(2000);
				System.out.println("当前线程 : "  + Thread.currentThread().getName() + "结束");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
	
		final ChangeLock changeLock = new ChangeLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				changeLock.method();
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				changeLock.method();
			}
		},"t2");
		t1.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.start();
	}
	
}
Eclipse中的console输出


若lock = "change lock";取消注释，则相当于t1在获取锁后，修改了这个lock变量的值。主线程main休眠1s后，子线程t2开始start，此时t2获取的是lock新值的锁，与t1线程运行获取的lock原值的锁不同，因此t1线程休眠2s并不会影响t2线程的正常执行。这时，run as--java application，在Eclipse的console中输出如下：



对象内部的属性发生变化，不影响对象锁

使用synchronized关键字获取的对象锁，这个对象内部的属性发生变化，不影响对象锁。

/**
 * 同一对象属性的修改不会影响锁的情况
 * @author alienware
 *
 */
public class ModifyLock {
	
	private String name ;
	private int age ;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public synchronized void changeAttributte(String name, int age) {
		try {
			System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 开始");
			this.setName(name);
			this.setAge(age);
			
			System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 修改对象内容为： " 
					+ this.getName() + ", " + this.getAge());
			
			Thread.sleep(2000);
			System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 结束");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		final ModifyLock modifyLock = new ModifyLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				modifyLock.changeAttributte("张三", 20);
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				modifyLock.changeAttributte("李四", 21);
			}
		},"t2");
		
		t1.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.start();
	}
	
}
子线程t1在执行的过程中，需要休眠2s，而主线程在休眠1s后，开始执行子线程t2。此时，在子线程t1的执行过程中对对象的name、age属性进行了修改，2s的休眠还未结束，由于changeAttributte(String name, int age)使用关键字synchronized修饰，所以需要首先获取对象锁，才能执行方法体中的内容。这时，t2等待t1执行完毕后，再获取对象锁并执行方法changeAttributte(String name, int age)





相关文章：

  • volatile使用
  • Can not find the tag library descriptor for http://java.sun.com/jsp/jstl/ core
  • javax.servlet.jsp.JspException cannot be resolved to a type
  • 使用wait/notify模拟Queue+ThreadLocal
  • 多线程模式中的单例
  • Semaphore信号量
  • Linux中./configure、make、make install 命令
  • 无锁并行计算框架Disruptor
  • 重入锁+读写锁+公平锁+非公平锁
  • JVM各组成部分说明+相关参数设置
  • java中垃圾回收算法+垃圾收集器
  • Linux中安装Nexus+Maven
  • Oracle数据库创建实例
  • Nginx中log_format日志格式参数及说明
  • Eclispe SVN 创建分支
  • JavaScript 如何正确处理 Unicode 编码问题！
  • 【css3】浏览器内核及其兼容性
  • 【MySQL经典案例分析】 Waiting for table metadata lock
  • 〔开发系列〕一次关于小程序开发的深度总结
  • es6--symbol
  • js写一个简单的选项卡
  • leetcode讲解--894. All Possible Full Binary Trees
  • MyEclipse 8.0 GA 搭建 Struts2 + Spring2 + Hibernate3 （测试）
  • SAP云平台里Global Account和Sub Account的关系
  • SpiderData 2019年2月23日 DApp数据排行榜
  • 阿里云前端周刊 - 第 26 期
  • 缓存与缓冲
  • 聊聊redis的数据结构的应用
  • 面试遇到的一些题
  • 掌握面试——弹出框的实现（一道题中包含布局/js设计模式）
  • Salesforce和SAP Netweaver里数据库表的元数据设计
  • 阿里云API、SDK和CLI应用实践方案
  • ​Base64转换成图片,android studio build乱码,找不到okio.ByteString接腾讯人脸识别
  • #NOIP 2014# day.2 T2 寻找道路
  • （2015）JS ES6 必知的十个 特性
  • (echarts)echarts使用时重新加载数据之前的数据存留在图上的问题
  • (function(){})()的分步解析
  • （Note）C++中的继承方式
  • （ZT）出版业改革：该死的死，该生的生
  • （八十八）VFL语言初步 - 实现布局
  • (办公)springboot配置aop处理请求.
  • （二十一）devops持续集成开发——使用jenkins的Docker Pipeline插件完成docker项目的pipeline流水线发布
  • （附源码）spring boot校园拼车微信小程序 毕业设计 091617
  • （论文阅读22/100）Learning a Deep Compact Image Representation for Visual Tracking
  • （转载）从 Java 代码到 Java 堆
  • .bat批处理（三）：变量声明、设置、拼接、截取
  • .gitattributes 文件
  • .Net IE10 _doPostBack 未定义
  • .Net(C#)自定义WinForm控件之小结篇
  • .NET/ASP.NETMVC 大型站点架构设计—迁移Model元数据设置项（自定义元数据提供程序）...
  • .net下简单快捷的数值高低位切换
  • .php结尾的域名,【php】php正则截取url中域名后的内容
  • @Builder用法
  • [1127]图形打印 sdutOJ
  • [AI]文心一言爆火的同时，ChatGPT带来了这么多的开源项目你了解吗