java并发编程(十一): 并发程序的测试

最新推荐文章于 2024-07-15 22:27:18 发布
最新推荐文章于 2024-07-15 22:27:18 发布
阅读量91 收藏
点赞数
文章标签： java python 测试
原文链接：https://my.oschina.net/indestiny/blog/225958
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

并发程序的测试：

  • 测试并发程序最大的挑战在于：错误的发生并不具有确定性，而是随机的。
  • 并发测试大致分为：安全性测试和活跃性测试。
  • 与活跃性相关的还有性能测试：即吞吐量，响应性，可伸缩性测试。

正确性测试：

  • 测试一个有界缓存。
  • 代码实现。 
/**
 * 基于信号量实现的有界缓存
 */
public class BoundedBuffer<E> {
	private final Semaphore availableItems, availableSpaces;
	private final E[] items;
	private int putPosition = 0, takePosition = 0;
	
	public BoundedBuffer(int capacity){
		availableItems = new Semaphore(0);
		availableSpaces = new Semaphore(capacity);
		items = (E[]) new Object[capacity];
	}
	
	public boolean isEmpty(){
		return availableItems.availablePermits() == 0;
	}
	
	public boolean isFull(){
		return availableSpaces.availablePermits() == 0;
	}
	
	public void put(E x) throws InterruptedException{
		availableSpaces.acquire();
		doInsert(x);
		availableItems.release();
	}
	
	public E take() throws InterruptedException{
		availableItems.acquire();
		E item = doExtract();
		availableSpaces.release();
		return item;
	}

	private synchronized void doInsert(E x) {
		int i = putPosition;
		items[i] = x;
		putPosition = (++i == items.length) ? 0 : i;
	}

	private synchronized E doExtract() {
		int i = takePosition;
		E x = items[i];
		items[i] = null; // let gc working
		takePosition = (++i == items.length) ?0 : i;
		return x;
	}
}

基本的单元测试：

  • 例如上面BoundedBuffer的测试用例。 
public class BoundedBufferTests {
	
	@Test
	public void testIsEmptyWhenConstructed(){
		BoundedBuffer<String> bf = new BoundedBuffer<String>(10);
		assertTrue(bf.isEmpty());
	}
	
	@Test
	public void testIsFullAfterPuts() throws InterruptedException{
		BoundedBuffer<String> bf = new BoundedBuffer<String>(10);
		for (int i=0; i<10; i++){
			bf.put("" + i);
		}
		assertTrue(bf.isFull());
		assertTrue(bf.isEmpty());
	}
}

对阻塞操作的测试：

  • 测试阻塞行为及对中断的响应性。 
@Test
public void testTaskBlocksWhenEmpty(){
	final BoundedBuffer<Integer> bb = new BoundedBuffer<>(10);
	Thread taker = new Thread(){
		@Override
		public void run() {
			try {
			       int unused =  bb.take();
				fail(); //不应执行到这里
			} catch (InterruptedException e) {
			}
		}
	};
	try {
		taker.start();
		Thread.sleep(1000);
		taker.interrupt();
		taker.join(2000); //保证即使taker永久阻塞也能返回
		assertFalse(taker.isAlive());
	} catch (InterruptedException e) {
		fail();
	}
}

安全性测试：

  • 在构建对并发类的安全性测试中，需要解决的关键性问题在于，要找出那些容易检查的属性，这些属性在发生错误的情况下极有可能失败，同时又不会使得错误检查代码人为地限制并发性。理想情况是，在测试属性中不需要任何同步机制。 
/**
 * 测试BoundedBuffer的生产者-消费者程序
 */
public class PutTakeTest {
	private static final ExecutorService pool = 
			Executors.newCachedThreadPool();
	private final AtomicInteger putSum = new AtomicInteger(0);
	private final AtomicInteger takeSum = new AtomicInteger(0);
	private final CyclicBarrier barrier;
	private final BoundedBuffer<Integer> bb;
	private final int nTrials, nPairs;
	
	public PutTakeTest(int capacity, int npairs, int ntrials) {
		this.bb = new BoundedBuffer<Integer>(capacity);
		this.nTrials = ntrials;
		this.nPairs = npairs;
		this.barrier = new CyclicBarrier(npairs * 2 + 1);
	}
	
	void test(){
		try {
			for (int i=0; i<nPairs; i++){
				pool.execute(new Producer());
				pool.execute(new Consumer());
			}
			barrier.await(); // 等待所有的线程就绪
			barrier.await(); // 等待所有的线程执行完成
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	class Producer implements Runnable{
		@Override
		public void run() {
			try {
				int seed = hashCode() ^ (int) System.nanoTime();
				int sum = 0;
				barrier.await(); //等待所有线程都准备好了，再执行
				for (int i=nTrials; i>0; --i){
					bb.put(seed);
					sum += seed;
					seed = xorShift(seed);
				}
				putSum.getAndAdd(sum);
				barrier.await();
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
	}
	
	class Consumer implements Runnable{
		@Override
		public void run() {
			try {
				barrier.await(); //等待所有线程都准备好了，再执行
				int sum = 0;
				for (int i=nTrials; i>0; --i){
					sum += bb.take();
				}
				takeSum.getAndAdd(sum);
				barrier.await();
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
	}
       ..,
}

资源管理的测试：

  • 再由自己掌握资源分配的时候，必须主要对资源的回收操作。 
void testLeak() throws InterruptedException{
BoundedBuffer<Big> bb = new BoundedBuffer<Big>(CAPACITY);
	// 生成堆快照
	for (int i=0; i<CAPACITY; i++){
		bb.put(new Big());
	}
	for (int i=0; i<CAPACITY; i++){
		bb.take(); //这里必须会通过doExtract(): items[i] = null;来释放资源
	}
	// 生成堆快照, 应该和上一个快照内存容量基本相同
}
	
class Big {
	double[] data = new double[100000];
}

使用回调：

  • 我们可以通过自定义扩展类来进行相关测试。 
public class TestingThreadFactory implements ThreadFactory {
	public final AtomicInteger numCreated = 
			new AtomicInteger(); //记录创建的线程数
	private final ThreadFactory factory = 
			Executors.defaultThreadFactory();
	
	@Override
	public Thread newThread(Runnable r) {
		numCreated.incrementAndGet();
		return factory.newThread(r);
	}
}
/**
 * 验证线程扩展能力
 * @throws InterruptedException
 */
public void testPoolExpansion() throws InterruptedException{
	int MAX_SIZE = 10;
	TestingThreadFactory threadFactory = new TestingThreadFactory();
	ExecutorService exec = Executors.newFixedThreadPool(MAX_SIZE, threadFactory);
		
	for (int i=0; i<10*MAX_SIZE; i++){
		exec.execute(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(Long.MAX_VALUE);
				} catch (InterruptedException e) {
					Thread.currentThread().interrupt();
				}
			}
		});
	}
		
	for (int i=0; i<20 && 
			threadFactory.numCreated.get() < MAX_SIZE; i++){
		Thread.sleep(100);
	}
	assertEquals(threadFactory.numCreated.get(), MAX_SIZE);
	exec.shutdownNow();
}

产生更多的交替操作：

  • 可使用Thread.yield()产生更多的上下文切换(与平台有关)。
  • 或者用Thread.sleep(shortTime)进行短时间睡眠。 
public synchronized void transferCredits(Account from, Account to, int amount){
	from.setBalance(from.getBalance() - amount);
	if (random.nextInt(1000) > THRESHOLD){
		Thread.yield();
	}
	to.setBalance(to.getBalance() + amount);
}

性能测试：

  • 性能测试的目标：

       1. 衡量典型测试用例中的端到端性能。

       2. 根据经验值来调整各种不同的限值，如线程数量，缓存容量等。

  • 对PutTakeTest进行定时扩展： 
this.timer = new BarrierTimer();
this.barrier = new CyclicBarrier(npairs * 2 + 1, timer);

/**
 * 基于栅栏的定时器
 */
public class BarrierTimer implements Runnable{
	private boolean started;
	private long startTime, endTime;
		
	@Override
	public synchronized void run() {
		long t = System.nanoTime();
		if (!started){
			started = true;
			startTime = t;
		} else{
			endTime = t;
		}
	}
		
	public synchronized long getTime(){
		return endTime - startTime;
	}
		
	public synchronized void clear(){
		started = false;
	}
}
其测试方法： 
void test(){
	try {
		timer.clear();
		for (int i=0; i<nPairs; i++){
			pool.execute(new Producer());
			pool.execute(new Consumer());
		}
		barrier.await(); // 等待所有的线程就绪
		barrier.await(); // 等待所有的线程执行完成
		long nsPerItem = timer.getTime();
		System.out.println("cost time: " + nsPerItem);
	} catch (Exception e) {
		throw new RuntimeException(e);
	}
}
测试用例： 
public static void main(String[] args) throws InterruptedException {
	int tpt = 100000;	//每个线程测试次数
	for (int cap = 1; cap <= tpt; cap*=10){
		System.out.println("Capacity: " + cap);
		for (int pairs = 1; pairs <= 128; pairs *= 2){
			TimedPutTakeTest t = new TimedPutTakeTest(cap, pairs, tpt);
			System.out.println("Pairs: " + pairs);
			t.test();
			Thread.sleep(1000);
			t.test();
			Thread.sleep(1000);
		}
	}
}

多种算法的比较：

  • BoundedBuffer, ArrayBlockingQueue, ListBlockingQueue比较

响应性衡量：

  • 除非线程由于密集的同步需求而被持续的阻塞，否则非公平的信号量通常能实现更好的吞吐量，而公平的信号量则实现更低的变动性。

  • 公平信号量的开销主要来自线程阻塞造成，通过单元素缓存来进行类似测试：

避免性能测试的陷阱

垃圾回收：

  • 两种防止垃圾回收对测试结果产生偏差的策略：

      1. 保证垃圾回收在执行测试程序期间不被执行，可通过-verbose:gc查看垃圾回收信息。

      2. 保证垃圾回收在执行测试程序期间执行多次，可以充分反映出运行期间的内存分配和垃圾回收等开销。

动态编译：

  • 可以让测试程序运行足够长时间，防止动态编译对测试结果产生的偏差。

对代码路径的不真实采样：

  • 测试程序不仅要大致判断某个典型应用程序的使用模式，还要尽量覆盖在该应用程序中将执行的代码路径集合。

不真实的竞争程度：

  • 并发应用可以交替执行两种不同类型的工作：访问共享数据(如线程池的工作队列)和执行线程本地的计算。

无用代码的消除：

  • 优化编译器能找出并消除那些不会对输出结果产生任何影响的无用代码(Dead Code), 不要留提醒。
  • 要编写有效的性能测试程序，就需要告诉优化器不要将基准测试当作无用代码而优化掉，这就要求在程序中对每个计算结果都要通过某种方式来是使用，这种方式不需要或者大量的计算。

其他的测试方法

代码审查；

  • 花一定时间让其他人来审查代码总是物有所值的(Code Review)。

静态分析工具：

  • FindBugs, CheckStyle等。

面向方面的测试技术：

  • AOP保证某些不变性条件不被破坏，或者与同步策略的某些方面保持一致。

分析与监测工具：

  • 通过ThreadInfo类或JMX代理可以监控一些线程信息。

不吝指正。

转载于:https://my.oschina.net/indestiny/blog/225958

weixin_33698823
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《java并发编程实战》 第十二章 并发程序的测试
乌鸦大大
02-10 629
《java并发编程实战笔记》第十二章 并发程序的测试正确性测试基本单元测试对阻塞操作的测试安全性测试资源管理测试使用回调产生更多的交替操作性能测试 第十二章 并发程序的测试 并发测试大致分为两类：安全性测试（不发生任何错误的行为）和活跃性测试（某个良好的行为终究会发生）。 安全测试 - 通常采用测试不变性条件的形式，即判断某个类的行为是否与其他规范保持一致。 活跃性测试 - 包括进展测试和无进展测...
Java并发编程-3.pdf
05-28
Java并发编程中的多线程协作机制 在 Java 并发编程中，多线程协作机制是非常重要的一部分。多线程协作机制是指在多线程编程中，多个线程之间如何协作、同步和通信，以达到共同完成某个任务的目的。Java 提供了多种...
《Java并发编程实战》第十四章 构建自己定义的同步工具 读书笔记
weixin_33816821的博客
01-30 85
一、状态依赖性的管理 有界缓存实现的基类 @ ThreadSafe public abstract class BaseBoundedBuffer&lt;E&gt; { @GuardeBy( "this" ) private final E[] buf; @GuardeBy( "this" ) private int tail; ...
Java并发编程中状态依赖性的管理
杨春建的博客
08-11 1211
类库中包含了很多状态依赖性的类，例如FutureTask、Semaphore和BlockingQueue等。在这些类的一些操作中有着基于状态的前提条件，例如，不能从一个空的队列中删除元素，或者获取一个尚未结束的任务的计算结果，在这些操作可以执行之前，必须等到队列进入“非空”状态，或者任务进入“已完成”状态。 在单线程程序中调用一个方法时，如果某个基于状态的前提条件未得到满足（例如“连接池必须非空
第 12 章 并发程序的测试
crazy的博客
10-07 729
            @@@  在编写并发程序时，可以采用与编写串行程序时相同的设计原则与设计模式。二者的差异             在于，并发程序存在一定程度的不确定性，而在串行程序中不存在这个问题。这种不确定性将增加             不同交互模式以及故障模式的数量，因此在设计并发程序时必须对这些模式进行分析。             @@@  在测试串行程序正确性与性能等方面...
Java并发编程详解：实现高效并发应用的关键技术
热门推荐
唯有努力，方可自信！
06-22 1万+
本文介绍了Java并发编程的关键技术，包括线程安全性、锁机制、并发集合、原子操作和并发工具。通过使用synchronized关键字和ReentrantLock锁来实现线程安全性，使用ConcurrentHashMap和CopyOnWriteArrayList等并发集合来实现安全数据访问，以及使用AtomicBoolean和AtomicInteger等原子类来实现线程安全的原子操作。此外，还介绍了CountDownLatch和CyclicBarrier等并发工具，用于线程间的同步操作。通过学习和运用这些技术，
java并发编程实战源码,java并发编程实战pdf,Java
09-10
《Java并发编程实战》是Java并发编程领域的一本经典著作，它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例，可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...
Java并发编程：核心理论
12-22
并发编程是Java程序员重要的技能之一，也是难掌握的一种技能。它要求编程者对计算机底层的运作原理有深刻的理解，同时要求编程者逻辑清晰、思维缜密，这样才能写出高效、安全、可靠的多线程并发程序。本系列会从线程...
Java并发编程：阻塞队列
01-20
我们讨论了同步容器(Hashtable、Vector），也讨论了并发容器（ConcurrentHashMap、CopyOnWriteArrayList），这些工具都为我们编写多线程程序提供了很大的方便。我们来讨论另外一类容器：阻塞队列。 　在前面我们...
java并发编程2
02-15
Java并发编程是Java开发中的重要领域，特别是在多核处理器和分布式系统中，高效地利用并发可以极大地提升程序的性能和响应速度。以下是对标题和描述中所提及的几个知识点的详细解释： 1. **线程与并发** - **线程*...
配置Java开发环境
Broken_x的博客
07-10 1621
Java开发环境配置
java集合工具类
药的博客
07-12 486
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 582
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 314
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 558
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
最新发布
liangzai215的专栏
07-15 315
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 637
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 410
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
从零手写实现 nginx-27-return 指令
07-14 540
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值