设计自定义障碍的测试类
我不得不使用锁作为课程工作的一部分来实现自定义屏障类。 为了测试我的LockBarrier类，我想出了以下测试代码。 它工作正常，但我担心这是否是正确的方法。 你能否建议我可以做的改进，尤其是构建类。 我认为我的编码方式不正确。 欢迎任何建议。
public class TestDriver
{
private static LockBarrier barrier;
static class Runnable1 implements Runnable
{
public Runnable1()
{ }
public void run()
{
try
{
System.out.println(Thread.currentThread().getId()+" lazy arrived at barrier");
Thread.sleep(10000);
barrier.await();
System.out.println(Thread.currentThread().getId()+" passed barrier");
}
catch (InterruptedException ie)
{
System.out.println(ie);
}
}
}
static class Runnable2 implements Runnable
{
public Runnable2()
{ }
public void run()
{
try
{
System.out.println(Thread.currentThread().getId()+" quick arrived at barrier");
//barrier.await(1,TimeUnit.SECONDS);
barrier.await();
System.out.println(Thread.currentThread().getId()+" passed barrier");
}
catch (InterruptedException ie)
{
System.out.println(ie);
}
}
}
static class Runnable3 implements Runnable
{
public Runnable3()
{ }
public void run()
{
try
{
System.out.println(Thread.currentThread().getId()+" very lazy arrived at barrier");
Thread.sleep(20000);
barrier.await();
System.out.println(Thread.currentThread().getId()+" passed barrier");
}
catch (InterruptedException ie)
{
System.out.println(ie);
}
}
}
public static void main(String[] args) throws InterruptedException
{
barrier = new LockBarrier(3);
Thread t1 = new Thread(new TestDriver.Runnable1());
Thread t2 = new Thread(new TestDriver.Runnable2());
Thread t3 = new Thread(new TestDriver.Runnable3());
t1.start();
t2.start();
t3.start();
t1.join();
t2.join();
t3.join();
}
}
分离你的类的并发性
同时测试的东西很难（tm）！ GOOS和其他人建议将并发部分与正在做某些工作的部分分开。 所以，举例来说，如果你有一些Scheduler器应该在一个或多个线程上调度一些任务。 您可以将负责线程的部分传递给您的调度程序，只需测试调度程序与此对象的协作。 这更像是一种经典的单元测试风格。
“Scheduler”的例子就在这里，它使用了一个模拟框架来提供帮助。 如果你不熟悉这些想法，不要担心，它们可能与你的测试无关。
话虽如此，你可能实际上想要以多线程的方式在上下文中运行你的类。 这似乎是你在上面写的那种测试。 这里的诀窍是保持测试的确定性。 那么，我说，有几个选择。
确定性
如果您可以设置您的测试以确定性方式进行，那么在继续前进之前等待关键点满足条件，您可以尝试模拟要测试的特定条件。 这意味着要准确理解你想要测试的内容（例如，强制代码陷入死锁）并确定性地执行（例如，使用CountdownLatches等抽象来“同步”移动部分）。
当你试图让一些多线程测试同步它的移动部分时，你可以使用任何并发抽象可用，但它很难，因为它的并发; 事情可能会以意想不到的顺序发生。 你正试图通过使用sleep呼叫来测试你的测试。 我们通常不喜欢在测试中入睡，因为它会让测试运行更慢，并且当您有数千个测试运行时，每个ms都会计数。 如果您太多地降低睡眠时间，则测试变得不确定，并且不能保证排序。
一些例子包括
CountdownLatch强制死锁 您已经发现了主测试线程将在新生成的待测线程完成之前完成的一个陷阱（使用join ）。 另一种方法是等待一个条件，例如使用WaitFor。
浸泡/负载测试
另一种选择是设置一个测试来设置，运行和垃圾你的类，试图超载它们，并迫使它们背叛一些微妙的并发问题。 在这里，就像另一种风格一样，你需要设置特定的断言，以便你可以判断类是否和何时出卖自己。
因为你现在正在测试，我建议提出一个断言，以便你可以看到针对你的类的正面和负面运行，并替换sleep （和system.out调用。如果可以的话，从类似的东西运行你的测试JUnit更加特殊。
例如，您开始的样式中的基本测试可能如下所示
public class TestDriver {
private static final CyclicBarrier barrier = new CyclicBarrier(3);
private static final AtomicInteger counter = new AtomicInteger(0);
static class Runnable1 implements Runnable {
public void run() {
try {
barrier.await();
counter.getAndIncrement();
} catch (Exception ie) {
throw new RuntimeException();
}
}
}
@Test (timeout = 200)
public void shouldContinueAfterBarrier() throws InterruptedException {
Thread t1 = new Thread(new Runnable1());
Thread t2 = new Thread(new Runnable1());
Thread t3 = new Thread(new Runnable1());
t1.start();
t2.start();
t3.start();
t1.join();
t2.join();
t3.join();
assertThat(counter.get(), is(3));
}
}
如果可能的话，给Barrier添加一个超时是很好的做法，并且有助于写出这样的负面测试
public class TestDriver {
private static final CyclicBarrier barrier = new CyclicBarrier(3);
private static final AtomicInteger counter = new AtomicInteger(0);
static class Runnable1 implements Runnable {
public void run() {
try {
barrier.await(10, MILLISECONDS);
counter.getAndIncrement();
} catch (Exception ie) {
throw new RuntimeException();
}
}
}
@Test (timeout = 200)
public void shouldTimeoutIfLastBarrierNotReached() throws InterruptedException {
Thread t1 = new Thread(new Runnable1());
Thread t2 = new Thread(new Runnable1());
t1.start();
t2.start();
t1.join();
t2.join();
assertThat(counter.get(), is(not((3))));
}
}
如果你想发布你的实现，我们可能会建议更多的选择。 希望能给你一些想法，尽管...
编辑：另一种选择是达到你的屏障对象更细粒度的断言，例如，
@Test (timeout = 200)
public void shouldContinueAfterBarrier() throws InterruptedException, TimeoutException {
Thread t1 = new Thread(new BarrierThread(barrier));
Thread t2 = new Thread(new BarrierThread(barrier));
Thread t3 = new Thread(new BarrierThread(barrier));
assertThat(barrier.getNumberWaiting(), is(0));
t1.start();
t2.start();
waitForBarrier(2);
t3.start();
waitForBarrier(0);
}
private static void waitForBarrier(final int barrierCount) throws InterruptedException, TimeoutException {
waitOrTimeout(new Condition() {
@Override
public boolean isSatisfied() {
return barrier.getNumberWaiting() == barrierCount;
}
}, timeout(millis(500)));
}
编辑：我写了一些在http://tempusfugitlibrary.org/recipes/2012/05/20/testing-concurrent-code/
代码看起来不错。 也许你可以将LockBarrier传递给Runnable，而不是在外面声明它。
链接地址: http://www.djcxy.com/p/50801.html