关于JAVA多线程并发synchronized的测试与合理使用

最新推荐文章于 2024-03-20 10:15:00 发布
最新推荐文章于 2024-03-20 10:15:00 发布
阅读量1.1k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hxx688/article/details/8509647
版权

  在项目开发中, 或许会碰到JAVA的多线程处理, 为保证业务数据的正常, 必须加上锁机制,  常用的处理方法一般是加上synchronized关键字, 目前JDK版本对synchronized已经做了很好的优化,  我们不用再考虑其性能,  但在实际使用中,  往往由于处理不当,  导致系统性能的严重下降, 那么该如何合理的使用synchronized,  必须对其使用方式有个全面了解, 在网上搜寻的资料, 给出的是四种使用方式, 其实可总结为两种, 一个是同步代码块, 一个是同步方法体, 那么该如何使用, 请看下面的测试:

  准备两个方法,  对同一个变量做加法, 再对每个方法, 分别开十个线程执行:

public class ThreadUnit
{
	private int i = 0;

	private Object obj1 = new Object();

	private Object obj2 = new Object();

	public synchronized Integer doAdd1(Long start) throws Exception
	{

		Thread.sleep(100);
		++i;
		Thread.sleep(100);

		return i;

	}

	public Integer doAdd2(Long start) throws Exception
	{

		Thread.sleep(100);
		++i;
		Thread.sleep(100);

		return i;
	}
}


相关代码:

                  // 十个线程同时执行方法2
		for (int i = 0; i < 10; i++)
		{
			new Thread(new MessageThread(1, threadUnit)).start();
		}
		// 十个线程同时执行方法2
		for (int j = 0; j < 10; j++)
		{
			new Thread(new MessageThread(2, threadUnit)).start();
		}

线程处理:

public void run()
		{

			try
			{
				if (operate == 2)
				{
					long start = System.currentTimeMillis();
					int i = threadUnit.doAdd2(start);
					long takeTime = System.currentTimeMillis() - start;
					System.out.println("doAdd2() => i=" + i + ", spendTime=" + takeTime + "ms");
					spendTime += takeTime;
				}
				else
				{
					long start = System.currentTimeMillis();
					int i = threadUnit.doAdd1(start);
					long takeTime = System.currentTimeMillis() - start;
					System.out.println("doAdd1() => i=" + i + ", spendTime=" + takeTime + "ms");
					spendTime += takeTime;
				}

			}
			catch (Exception e)
			{
				e.printStackTrace();
			}
		}


 

 运行结果:
1. 在两个方法体上都加上synchronized

public synchronized Integer doAdd1(Long start) throws Exception
public synchronized Integer doAdd2(Long start) throws Exception

执行结果:

doAdd1() => i=1, spendTime=203ms
doAdd2() => i=2, spendTime=406ms
doAdd2() => i=3, spendTime=609ms
doAdd2() => i=4, spendTime=796ms
doAdd2() => i=5, spendTime=1000ms
doAdd2() => i=6, spendTime=1203ms
doAdd2() => i=7, spendTime=1406ms
doAdd2() => i=8, spendTime=1609ms
doAdd2() => i=9, spendTime=1812ms
doAdd2() => i=10, spendTime=2015ms
doAdd2() => i=11, spendTime=2218ms
doAdd1() => i=12, spendTime=2406ms
doAdd1() => i=13, spendTime=2609ms
doAdd1() => i=14, spendTime=2812ms
doAdd1() => i=15, spendTime=3015ms
doAdd1() => i=16, spendTime=3218ms
doAdd1() => i=17, spendTime=3421ms
doAdd1() => i=18, spendTime=3625ms
doAdd1() => i=19, spendTime=3828ms
doAdd1() => i=20, spendTime=4015ms
花费时间:42226ms

都是有序执行, 变量值没有产生错乱, 但花费时间42226ms

 

2.在doAdd1方法上加上synchronized, doAdd2不加.

public synchronized Integer doAdd1(Long start) throws Exception

执行结果:

doAdd1方法加上synchronized:
doAdd1() => i=9, spendTime=204ms
doAdd2() => i=9, spendTime=188ms
doAdd2() => i=9, spendTime=188ms
doAdd2() => i=9, spendTime=188ms
doAdd2() => i=9, spendTime=188ms
doAdd2() => i=9, spendTime=188ms
doAdd2() => i=9, spendTime=188ms
doAdd2() => i=9, spendTime=188ms
doAdd2() => i=9, spendTime=188ms
doAdd2() => i=9, spendTime=188ms
doAdd2() => i=9, spendTime=188ms
doAdd1() => i=10, spendTime=391ms
doAdd1() => i=11, spendTime=610ms
doAdd1() => i=12, spendTime=813ms
doAdd1() => i=13, spendTime=1016ms
doAdd1() => i=14, spendTime=1219ms
doAdd1() => i=15, spendTime=1422ms
doAdd1() => i=16, spendTime=1610ms
doAdd1() => i=17, spendTime=1813ms
doAdd1() => i=18, spendTime=2016ms
花费时间:12994ms

doAdd2方法瞬间执行完成, 之后doAdd1方法则是串行有序执行. 这时doAdd2方法获取的变量值已经错乱,  doAdd1获取的正常.  花费时间:12994ms


3. 两个方法在都没使用synchronized前的情况:

执行结果:

doAdd1() => i=16, spendTime=203ms
doAdd1() => i=16, spendTime=203ms
doAdd1() => i=16, spendTime=203ms
doAdd1() => i=16, spendTime=203ms
doAdd1() => i=16, spendTime=203ms
doAdd1() => i=16, spendTime=203ms
doAdd1() => i=16, spendTime=203ms
doAdd1() => i=16, spendTime=203ms
doAdd1() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
doAdd1() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
doAdd2() => i=16, spendTime=203ms
花费时间:4060ms

可以看到, 两个方法的变量值获取已经错乱,  但花费时间最少4060ms

4. 使用同步块, 在两个方法内采用不同的对象锁:

doAdd1:

synchronized (obj1)
  {

   Thread.sleep(100);
   ++i;
   Thread.sleep(100);

   return i;
  }

doAdd2:

synchronized (obj2)
		{

			Thread.sleep(100);
			++i;
			Thread.sleep(100);

			return i;
		}

执行结果:

doAdd1() => i=2, spendTime=203ms
doAdd2() => i=2, spendTime=203ms
doAdd1() => i=4, spendTime=406ms
doAdd2() => i=4, spendTime=406ms
doAdd1() => i=6, spendTime=609ms
doAdd2() => i=6, spendTime=609ms
doAdd1() => i=8, spendTime=812ms
doAdd2() => i=8, spendTime=812ms
doAdd1() => i=10, spendTime=1000ms
doAdd2() => i=10, spendTime=1015ms
doAdd1() => i=12, spendTime=1203ms
doAdd2() => i=12, spendTime=1203ms
doAdd1() => i=14, spendTime=1406ms
doAdd2() => i=14, spendTime=1406ms
doAdd1() => i=16, spendTime=1609ms
doAdd2() => i=16, spendTime=1609ms
doAdd1() => i=18, spendTime=1812ms
doAdd2() => i=18, spendTime=1812ms
doAdd1() => i=20, spendTime=2015ms
doAdd2() => i=20, spendTime=2015ms
花费时间:22165ms

两个方法有序交替执行, 互不影响,  花费时间:22165ms, 相对加锁同一对象执行的时间缩短.

 

5. 使用同步块, 使用方法参数作为对象锁:

public Integer doAdd1(Long start) throws Exception
	{

		synchronized (start)
		{

			Thread.sleep(100);
			++i;
			Thread.sleep(100);

			return i;
		}

	}

执行结果:

doAdd1() => i=15, spendTime=203ms
doAdd1() => i=15, spendTime=203ms
doAdd1() => i=15, spendTime=203ms
doAdd1() => i=15, spendTime=203ms
doAdd1() => i=15, spendTime=203ms
doAdd1() => i=15, spendTime=203ms
doAdd1() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
doAdd1() => i=15, spendTime=203ms
doAdd1() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
doAdd1() => i=15, spendTime=203ms
doAdd2() => i=15, spendTime=203ms
花费时间:4060ms

执行效果和第三种情况相同,  每个参数作为不同的对象, 即便加上synchronized也不能起到锁的效果.


 

6. 把调用的类改为静态类, 只在一个方法上加锁:

加锁doAdd1方法:

public static synchronized Integer doAdd1(Long start) throws Exception


执行结果:

doAdd1() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd2() => i=9, spendTime=203ms
doAdd1() => i=10, spendTime=406ms
doAdd1() => i=11, spendTime=609ms
doAdd1() => i=12, spendTime=812ms
doAdd1() => i=13, spendTime=1015ms
doAdd1() => i=14, spendTime=1218ms
doAdd1() => i=15, spendTime=1406ms
doAdd1() => i=16, spendTime=1609ms
doAdd1() => i=17, spendTime=1812ms
doAdd1() => i=18, spendTime=2015ms
花费时间:13135ms

和第二种情形类似,  没有加锁的doAdd2方法瞬间执行完成,  doAdd1方法则是串行有序执行.


总结:

1. synchronized关键在于锁定的对象, 如果是同一对象, 那么所有执行线程, 必须等待对象锁释放后才能执行,  如果是不同对象,  那么只对各对象所关联的线程生效.

2. synchronized若加在方法体上,  默认锁定的是对象本身. 对于所有加锁的方法,  都是按照串行规则有序执行,  对于没有加锁的方法, 不受任何影响,  静态类同理.

3. 合理使用synchronized, 既要保证稳定性, 又要保证性能, 需要在两者间作出权衡,  尽量把synchronized范围细度化, 合理控制业务处理流程;  对象操作原子化, 减少锁的使用;

不要盲目在方法体上加synchronized关键字, 如果每个方法负责处理的是不同业务,  那么尽量采用第四种情形, 使用不同的对象锁处理, 而不是锁定整个对象.

 

 

 

麦神-mirson
关注
015 压测模拟并发测试，使用synchronized处理并发
Matea's Record
03-17 322
使用简易工具Apache ab ab -n 100 -c 100 http://www.baidu.com/ 100个请求 100个并发 ab -t 60 -c 100 http://www.baidu.com/ 连续60s 不断并发请求 可变现cmd文件命令 ab.exe -n 40 -c 40 http://www.baidu.com/ pause 使用synchronized可以处理并...
多线程锁synchronized多种测试案例
guochaoHNU的博客
02-10 835
1、标准访问，先打印短信还是邮件 class Phone { public synchronized void sendSMS() throws Exception { //TimeUnit.SECONDS.sleep(4); //即使是当前线程sleep4秒，其他线程也无法调用此类中的所有synchronized方法，因为锁就是当前调用此方法的对象，且并没有释放。 System.out.println("------sendSMS"); }
一次对于synchronized和Lock两种锁的性能测试和比较
weixin_41644977的博客
09-23 1107
对于这两种锁，在jdk1.6之前synchronized的性能是远不如Lock的，因为synchronized需要调用操作系统的函数，操作内核来完成，比较费时，在JDK1.6以后Oracle公司对synchronized进行了大量优化，而synchronized也从重量级的锁采用了CAS的方式编程了JVM级别的锁，性能得到了大大的跃升，才普遍使用JDK1.8的现在，出于好奇，我简单测试了下sync...
ReenTrantLock 、synchronized 高并发性能测试
湖人•总冠军
02-28 6334
前言： Synchronized是依赖于JVM实现的，表现为原生语法层面的互斥锁。开发者是无法直接看到相关源码，但是我们可以通过利用javap工具查看生成的class文件信息来分析Synchronize的实现。同步代码块是使用monitorenter和monitorexit指令实现的，同步方法依靠的是方法修饰符上的ACC_SYNCHRONIZED实现。 ReenTr...
java synchronized测试程序
acxingyun的博客
05-15 643
看了些网上相关的文章，感觉有些结果不对，于是自己跑了一遍这些demo并附上每段程序结果和一些心得。非线程安全的代码public class Run { public static void main(String[] args) { HasSelfPrivateNum numRef = new HasSelfPrivateNum(); ThreadA athread
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 23万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 3万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
【多线程与高并发】- 浅谈volatile
qq_43843951的博客
02-24 21万+
volatile是Java语言中的一种轻量级的同步机制，它可以确保共享变量的内存可见性，也就是当一个线程修改了共享变量的值时，其他线程能够立即知道这个修改。
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
Java多线程中使用synchronized说明
12-22
在Java多线程编程中，`synchronized`有多种用法，包括修饰实例方法、静态方法以及作为代码块来锁定特定的对象引用。 1. **修饰实例方法**： 当`synchronized`关键字用于实例方法时，它会对该实例对象加锁。这意味...
Java多线程（Synchronized+Volatile+JUC 并发工具原理+线程状态+CAS+线程池）
06-21
Java 多线程（Synchronized+Volatile+JUC 并发工具原理+线程状态+CAS+线程池） Java 多线程是 Java 语言中的一种并发编程机制，允许程序同时执行多个线程，以提高程序的执行效率和响应速度。 Java 多线程机制提供了...
java 多线程测试_java多线程——并发测试
weixin_26937243的博客
02-12 1454
这是多线程系列第六篇，其他请关注以下：编写并发程序时候，可以采取和串行程序相同的编程方式。唯一的难点在于，并发程序存在不确定性，这种不确定性会令程序出错的地方远比串行程序多，出现的方式也没有固定规则。这对程序的应用会造成一些困难，那么如何在测试中，尽可能的暴露出这些问题，并且了解其性能瓶颈，这也是对开发者带来新的挑战。本篇基于多线程知识，梳理一些多线程测试需要掌握的方法和原则，以期望可能的在开发阶...
【气动学】基于matlab三种导引律下的弹道仿真【含Matlab源码 8026期】.mp4
09-26
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
性能测试面试题宝典-覆盖大部分性能专项面试题
09-26
性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性能专项面试题性能测试面试题宝典--覆盖大部分性
Java工程师面试-笔试部分
09-26
Java工程师面试-笔试部分
时域门对方向图测量环境改善的研究.pdf
最新发布
09-26
时域门对方向图测量环境改善的研究
OCR图片识别和重命名文件软件工具
09-26
OCR批量识别和重命名文件工具 此程序不需要联网，通过调用UWP的库，来实现文字识别 支持：Win10 以上的系统 原理：用系统 OCR 识别图片上的文字 功能： 1、重命名：批量识别文件框选位置的文字，并重命名 2、提取文字：批量识别文件，并提取文字
Java多线程并发编程详解：synchronized与wait/notify机制
深入探究Java多线程并发编程的要点主要聚焦于如何在Java中有效地管理线程之间的交互和同步。首先，我们关注的是关键字`synchronized`的使用，它是Java中实现线程同步的关键机制。`synchronized`可以用于修饰函数或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

麦神-mirson

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值