Java多线程（二）对象及变量的并发访问 7.25

最新推荐文章于 2019-10-16 14:42:26 发布
最新推荐文章于 2019-10-16 14:42:26 发布
阅读量101 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyl042/article/details/97286623
版权

synchronized同步方法：

方法内的变量为线程安全；

实例变量非线程安全：

如果多个线程共同访问一个对象中的实例变量，则有可能出现“非线程安全”问题；

加关键字synchronized ： 在两个线程访问同一个对象中的同步方法一定是线程安全的。

public class HasSelfPrivateNum {
	synchronized	public void addI(String username) {
		try {
			int num = 0;
			if (username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);

			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num = " + num);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
public class RunHS {
	public static void main(String[] args) {
		HasSelfPrivateNum numRef = new HasSelfPrivateNum();
		ThreadA threada = new ThreadA(numRef);
		threada.start();
		ThreadB threadb = new ThreadB(numRef);
		threadb.start();
	}
}
public class ThreadA extends Thread{
	private HasSelfPrivateNum numRef;
	public ThreadA(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}
	public void run() {
		super.run();
		numRef.addI("a");
	}
}
public class ThreadB extends Thread{
	private HasSelfPrivateNum numRef;
	public ThreadB(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}
	public void run() {
		super.run();
		numRef.addI("b");
	}
}

多个对象多个锁：

public class HasSelfTwoLock {
	private int num = 0;
	synchronized public void addI(String username) {
		try {
			if(username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);
			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num = " + num );
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
public class RunTAB {
	public static void main(String[] args) {
		HasSelfTwoLock numRef1 = new HasSelfTwoLock();
		HasSelfTwoLock numRef2 = new HasSelfTwoLock();
		ThreadTA threada = new ThreadTA(numRef1);
		threada.start();
		ThreadTB threadb = new ThreadTB(numRef2);
		threadb.start();
	}
}
public class ThreadTA extends Thread{
	private HasSelfTwoLock numRef;
	public ThreadTA(HasSelfTwoLock numRef) {
		super();
		this.numRef = numRef;
	}
	public void run() {
		super.run();
		numRef.addI("a");
	}
}
public class ThreadTB extends Thread{
	private HasSelfTwoLock numRef;
	public ThreadTB(HasSelfTwoLock numRef) {
		super();
		this.numRef = numRef;
	}
	public void run() {
		super.run();
		numRef.addI("b");
	}
}

关键字synchronized取得的锁都是对象锁，而不是把一段代码或方法当作锁；

public class MyObject {
	synchronized	public void methodA() {
		try {
			System.out.println("begin methodA threadName = " 
					+ Thread.currentThread().getName());
			Thread.sleep(5000);
			System.out.println("end");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public void methodB() {
		try {
			System.out.println("begin methodB threadName = " 
					+ Thread.currentThread().getName());
			Thread.sleep(5000);
			System.out.println("end");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

public class RunOb {
	public static void main(String[] args) {
		MyObject object = new MyObject();
		ThreadA threada = new ThreadA(object);
		threada.setName("A");
		ThreadB threadb = new ThreadB(object);
		threadb.setName("B");
		threada.start();
		threadb.start();
	}
}
public class ThreadA extends Thread{
	private MyObject object;
	public ThreadA(MyObject object) {
		super();
		this.object = object;
	}
	public void run() {
		super.run();
		object.methodA();
	}
}
public class ThreadB extends Thread{
	private MyObject object;
	public ThreadB(MyObject object) {
		super();
		this.object = object;
	}
	public void run() {
		super.run();
		object.methodB();
	}
}

1）A线程先持有object对象的Lock锁，B线程可以以异步的方式调用object对象中的非synchronized类型的方法；

2）A线程先持有object对象的Lock锁，B线程如果在这时候调用object对象中的synchronized类型的方法则需等待，也就是同步；

脏读：

脏读（dirtyRead）一定会出现操作实例变量的情况下，这就是不同线程“争抢”实例变量的结果；

public class PublicVar {
	public String username = "A";
	public String password = "AA";
	synchronized public void setValue(String username, String password) {
		try {
			this.username = username;
			Thread.sleep(5000);
			this.password = password;
			System.out.println("setValue method thread name = "
					+ Thread.currentThread().getName() + " username = "
					+ username + " password = " + password);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
	synchronized public void getValue(){
		System.out.println("getValue method thread name = "
				+ Thread.currentThread().getName() + " username = "
				+ username + " password" + password);
	}
}
public class Test {
	public static void main(String[] args) {
		try {
			PublicVar publicVarRef = new PublicVar();
			ThreadA thread = new ThreadA(publicVarRef);
			thread.start();
			Thread.sleep(200);
			publicVarRef.getValue();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
public class ThreadA extends Thread{
	private PublicVar publicVar;
	public ThreadA(PublicVar publicVar) {
		super();
		this.publicVar = publicVar;
	}
	public void run() {
		super.run();
		publicVar.setValue("B", "BB");
	}
}

出现脏读时因为 getValue方法并不是同步的，所以可以在任意时候进行调用；加上synchronized关键字；

synchronized锁重入：

当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的；

这也证明在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以得到锁的；

可重入锁也支持在父子类继承的环境中；

出现异常，锁自动释放；

同步不具有继承性；

public class Service {
	synchronized public void service1() {
		System.out.println("service 111");
		service2();
	}
	synchronized public void service2() {
		System.out.println("service 222");
		service3();
	}
	synchronized public void service3() {
		System.out.println("service 333");
	}
}
public class Sub extends Main{
	synchronized public void operateISubMethod() {
		try {
			while(i > 0) {
				i--;
				System.out.println("sub print i = " + i);
				Thread.sleep(100);
				this.operateIMainMethod();
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
public class Main {
	public int i = 10;
	synchronized public void operateIMainMethod() {
		try {
			i--;
			System.out.println("main print i = " + i);
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
public class RunMT {
	public static void main(String[] args) {
		MyThread t = new MyThread();
		t.start();
	}
}

synchronized同步语句块：

public class CommonUtils {
	public static long beginTime1;
	public static long endTime1;
	public static long beginTime2;
	public static long endTime2;
}
public class Task {
	private String getData1;
	private String getData2;
	public void doLongTimeTask() {
		try {
			System.out.println("begin task");
			Thread.sleep(3000);
			String privateGetData1 = "return111 threadName = " + Thread.currentThread().getName();
			String privateGetData2 = "return222 threadName = " + Thread.currentThread().getName();
			synchronized(this) {
				getData1 = privateGetData1;
				getData2 = privateGetData2;
			}
			System.out.println(getData1);
			System.out.println(getData2);
			System.out.println("end task");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
public class Thread1 extends Thread{
	private Task task;
	public Thread1 (Task task) {
		super();
		this.task = task;
	}
	public void run() {
		super.run();
		CommonUtils.beginTime1 = System.currentTimeMillis();
		task.doLongTimeTask();
		CommonUtils.endTime1 = System.currentTimeMillis();
	}
}
public class Thread2 extends Thread{
	private Task task;
	public Thread2 (Task task) {
		super();
		this.task = task;
	}
	public void run() {
		super.run();
		CommonUtils.beginTime2 = System.currentTimeMillis();
		task.doLongTimeTask();
		CommonUtils.endTime2 = System.currentTimeMillis();
	}
}

public class Run12 {
	public static void main(String[] args) {
		Task task = new Task();
		Thread1 t1 = new Thread1(task);
		t1.start();
		Thread2 t2 = new Thread2(task);
		t2.start();
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		long beginTime = CommonUtils.beginTime1;
		if (CommonUtils.beginTime2 < CommonUtils.beginTime1) {
			beginTime = CommonUtils.beginTime2;
		}
		long endTime = CommonUtils.beginTime1;
		if (CommonUtils.beginTime2 > CommonUtils.beginTime1) {
			endTime = CommonUtils.endTime2;
		}
		System.out.println("Time == "  + ((endTime - beginTime)/ 1000D));
	}
}

synchronized同步代码块的使用：

//用同步代码块解决同步方法的弊端
public class RunOAB {
	public static void main(String[] args) {
		ObjectService service = new ObjectService();
		ThreadA a = new ThreadA(service);
		a.setName("a");
		a.start();
		ThreadB b = new ThreadB(service);
		b.setName("b");
		b.start();
	}
}
public class ObjectService {
	public void serviceMethod() {
		try {
			synchronized(this) {
				System.out.println("begin time = " + System.currentTimeMillis());
				Thread.sleep(2000);
				System.out.println("end  end = " + System.currentTimeMillis());
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
public class ThreadA extends Thread{
	private ObjectService service;
	public ThreadA(ObjectService service) {
		super();
		this.service = service;
	}
	
	public void run() {
		super.run();
		service.serviceMethod();
	}
}

public class ThreadB extends Thread{
	private ObjectService service;
	public ThreadB(ObjectService service) {
		super();
		this.service = service;
	}
	public void run() {
		super.run();
		service.serviceMethod();
	}
}

当一个线程访问object的一个synchronized同步代码块时，

另一个线程仍然可以访问该object对象中的非synchronized（this）的同步代码块

一半同步，一半异步：

public class Task {
	public void doLongTimeTask() {
		for (int i = 0; i < 100; i++) {
			System.out.println("Nosynchronized threadName == " 
					+ Thread.currentThread().getName() + " i = " + (i + 1));
		}
		System.out.println("");
		synchronized (this) {
			for (int i = 0; i < 100; i++) {
				System.out.println("Synchronized threadName == "
						+ Thread.currentThread().getName() + " i = " + (i + 1));
			}
		}
	}
}

//一半同步，一半异步
public class RunAB {
	public static void main(String[] args) {
		Task task = new Task();
		ThreadA ta = new ThreadA(task);
		ta.start();
		ThreadB tb = new ThreadB(task);
		tb.start();
	}
}
public class ThreadA extends Thread{
	private Task task;
	public ThreadA(Task task) {
		super();
		this.task = task;
	}
	public void run(){
		super.run();
		task.doLongTimeTask();
	}
	
}

public class ThreadB extends Thread{
	private Task task;
	public ThreadB(Task task) {
		super();
		this.task = task;
	}
	public void run(){
		super.run();
		task.doLongTimeTask();
	}
	
}

不在synchronized块中就是异步执行，在synchronized块中就是同步执行；

 

将任意对象作为对象监视器：

（1）synchronized同步方法

1）对其他synchronized同步方法或synchronized（this）同步代码块调用呈阻塞状态

2）同一时间只有一个线程可以执行synchronized同步方法的代码

（2）synchronized（this）同步代码块

1）对其他同步方法或同步代码块调用呈阻塞状态

2）同一时间只有一个线程可以执行同步代码块的代码

正一降圣威盟箓
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java性能优化亿级流量秒杀解决方案及电商项目秒杀实现（7.25G）
04-11
Day1:秒杀场景及优化核心知识.rar;c Day2:高性能秒杀方案框架解读.rar Day3:性能及压力测试.rar Day4:分布式服务器部署.rar Day5:缓存方案及接入实操.rar Day6:静态化及cdn部署.rar'q#Y:a9K%d)W0-0M'p!f Day7:缓存与...
Drools 7.25安裝手冊.pdf
08-14
Drools 通過自定義shell腳本在centos7上進行安裝,並整合workbench和kie-server
7.25~7.31.txt
08-23
7.25~7.31.txt
2021-2022计算机二级等级考试试题及答案No.15384.docx
10-28
【计算机二级等级考试知识点】 1. 内联函数（Inline Function）：内联函数是...20. Access 同时操作：Access支持多用户同时访问和修改数据库，但可能需要考虑并发控制和数据一致性问题，尤其是在多人编辑同一记录时。
2021-2022计算机二级等级考试试题及答案No.1509.docx
10-28
计算机二级等级考试主要涵盖计算机基础知识、程序设计语言、数据库、网页制作、软件工程等多个方面的内容。以下是根据题目中给出的部分内容解析的相关知识点： 1. 浏览器对象模型：在JavaScript中，`window`对象是...
Java基础学习（八）其他内容 Swing中 按钮的 点击和回车确认问题
zyl042的博客
07-08 719
import java.awt.BorderLayout; import java.awt.EventQueue; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; import jav...
Java基础学习（八）Swing和NetBeans的使用 2019.7.5
zyl042的博客
07-05 694
NetBeans是Sun公司（2009年被甲骨文收购）在2000年创立的开放源代码供开发人员和客户社区的家园，旨在构建世界级的Java IDE。NetBeans当前可以在Solaris、Windows、Linux和Macintosh OS X平台上进行开发，并在SPL(Sun公用许可)范围内使用。 NetBeans包括开源的开发环境和应用平台，NetBeans IDE可以使开发人员利用Java平台...
Java基础学习（三）2019.6.27
zyl042的博客
06-30 673
9.抽象类 <访问符> abstract class 类名 { [访问符] abstract<返回类型> 方法名([参数列表])； ...... } 注意：1）abstract放在class前，指明该类是抽象类； 2）abstract放在方法声明中，则该方法是抽象方法，抽象方法没有方法体； 3）一个抽象类至少含有一个抽象类，可以含有多个抽...
复选框工具8.7——Needleman Wusch算法全局比对
zyl042的博客
08-07 634
Needleman Wusch算法 是经典的全局比对算法，用于比对两条DNA序列或者蛋白质序列的同源性或者说相似性； 全局序列比对： 尝试找到两个完整的序列 S1 和 S2 之间的最佳比对。如S1=GCCCTAGCG S2=GCGCAATG 如果设定每个匹配字符为1分，每个空格为-2分，每个不匹配为-1分，则下面的比对就是全局最优比对：S1'=GCCCTAGCG S2'=GCGC_AATG...
Java基础学习（六）swing图形化界面 2019.7.3
zyl042的博客
07-03 402
框架定位： setLocation和setDbounds方法用于设置框架的位置。 setIconImage用于告诉窗口系统在标题栏，任务切换窗口等位置显示哪个图标。 setTitle用于改变标题栏的文字。 setResizable利用一个boolean值确定框架的大小是否允许用户改变。 绘制图像：java.awt.Graphics boolean drawImage(Image,...
Netbeans使用——复选框测试工具 2019.7.20
zyl042的博客
07-20 338
需求： 从目录下扫描文件，在界面中显示出来，点击确定开始执行选中的文件，弹出窗口回显结果 设计过程： 使用Swing图形化界面，使用Netbeans开发； 注意：initComponents() 是netbeans界面代码，不能修改 自己编写inittable（）代码；实现按钮等的监听事件； 运用JDialog弹出窗口，new NewJDialog(getThis(), true)...
复选框工具8.5——xml配置文件；比对结果弹框
zyl042的博客
08-05 305
目前： 配置文件获取两个路径； 先进行初步比对，双击时比对选择的内容；不一致地方红色标出； 修正代码规范：一般只有final声明才大写；注意全局变量的使用； import java.awt.Component; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt...
复选框工具8.9——导师优化和代码规范
zyl042的博客
08-09 285
package com.highgo.main; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import jav...
XML转换为Json并解析
zyl042的博客
10-16 227
import java.io.IOException; import org.json.*; import net.sf.json.JSONObject; public class JsonUtils { public static String xml2jsonString() throws JSONException, IOException { ...
Java多线程（三）synchronized volatile 以及 原子性 有序性和可见性 7.25
zyl042的博客
07-26 209
三大性质 原子性 原子性是指一个操作是不可中断的，要么全部执行成功要么全部执行失败 由原子性变量操作read,load,use,assign,store,write， 可以大致认为基本数据类型的访问读写具备原子性（例外就是long和double的非原子性协定） synchronized满足原子性； volatile并不能保证原子性； 如果让volatile保证原子性，必须符合以下...
复选框工具8.3——xml配置文件；比对结果弹框
zyl042的博客
08-03 205
需求： 目前： 完成配置文件读取；完成简单比对； 无法匹配所有比对文件；无法分开展示比对结果；无法使用命令行 代码： import java.awt.Component; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.KeyEvent; ...
Java基础学习（七）事件和监听 2019.7.4
zyl042的博客
07-04 204
事件处理的步骤 第1步 - 用户单击按钮并生成事件。第2步 - 自动创建相关事件类的对象，并在同一对象中填充有关源和事件的信息。第3步 - 将事件对象转发到已注册的监听器类方法。第4步 - 监听器类方法执行并返回。 关于监听器的要点 为了设计一个监听器类，必须开发一些监听器接口。这些监听器接口预测了一些公共抽象回调方法，这些方法必须由监听器类实现。 如果未实现任何预定义接口，则类不能充当源...
复选框工具7.23——递归方式遍历目录和子目录 返回到树
zyl042的博客
07-24 188
树： 用递归的方式遍历目录和子目录，控制了递归的次数，并将结果返回到树中； 完整代码： import java.awt.Component; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.KeyEvent; import java.awt.eve...
Swing—SQL测试工具编写
zyl042的博客
07-09 182
通过IO流进行文件的输入输出； 1） 点击确定，将SQL脚本（data.sql）读取并执行，然后结果返回到（out.txt）中去， 2）点击开始比对，把（out.txt）和（true.txt）进行比较，最后返回结果到（result.txt）中； 3）点击打开目录，可以打开相对路径； 输出结果同时显示在文本框中； /* * To change this licen...
ssrp7.25由来
最新发布
01-13
ssrp7.25的由来可以追溯到很久以前，当时一群热爱探索和表达的年轻人聚在一起，探讨着如何用文字和图像来传达自己的想法和情感。在这个过程中，他们不断尝试新的表达方式，积极追求创新和突破。在不断的探索和实践中，ssrp7.25逐渐形成了自己独特的风格和特点。 ssrp7.25的命名来源于创建者的理念和想法。"ssrp"代表着"Share, Show, Reveal, Publish"，表达了他们希望分享、展示、揭示和出版自己的作品和想法的愿望。而"7.25"则代表着特定的日期，这一天对于ssrp7.25的创始人们来说有着特殊的意义，因为在这一天他们齐聚一堂，探讨和决定了ssrp7.25的创立。 ssrp7.25的成立初衷是为了打破传统的艺术表达方式，让更多的人能够参与到艺术创作和分享的过程中。通过网络平台和线下活动，ssrp7.25鼓励人们用自己独特的方式来发现和展示美、传递情感、表达思想，促进艺术和文化的交流与融合。 总的来说，ssrp7.25的由来是源自于一群年轻人对于艺术和表达的执着追求，他们想用自己的热情和创造力来打造一个完全属于他们的、独特而有意义的平台。如今，ssrp7.25已经成长为一个具有一定影响力的平台，吸引了许多有志于艺术和创造的人们，成为了大家艺术表达与交流的重要场所。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值