Question

我必须使用锁作为我课程工作的一部分来实现自定义障碍类。为了测试我的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();
        }   
}

Answer 1

为您的班级分隔并发

同时测试内容很难（tm）！ GOOS其他人建议将并发部分与正在进行某些工作的部分分开。所以，例如，如果你有一些Scheduler，它应该在一个或多个线程上安排一些任务。您可以将负责线程的部分传递给调度程序，并测试调度程序是否正确地与此对象协作。这更像是经典的单元测试风格。

调度程序为here的示例，它使用模拟框架来提供帮助。如果您不熟悉这些想法，请不要担心，它们可能与您的测试无关。

话虽如此，您实际上可能希望以多线程方式在“上下文”中运行您的类。这似乎是你上面写的那种测试。这里的诀窍是保持测试的确定性。嗯，我说，有几个选择。

<强>确定性

如果您可以将测试设置为以确定的方式进行，在前进之前等待关键点以满足条件，您可以尝试模拟要测试的特定条件。这意味着要准确理解您要测试的内容（例如，强制代码进入死锁）并逐步确定（例如，使用CountdownLatches之类的抽象来“同步”移动部件。）

当你试图让一些多线程测试同步它的移动部分时，你可以使用任何可用的并发抽象，但它很难因为它的并发;事情可能以意想不到的顺序发生。您正在尝试使用sleep调用在测试中对此进行设置。我们通常不喜欢在测试中睡觉，因为它会使测试运行速度变慢，并且当您运行数千个测试时，每个ms都会计数。如果您将睡眠周期降低太多，则测试变得不确定，并且无法保证排序。

一些例子包括

Forcing a deadlock使用CountdownLatch
Setting up a thread to be interuptted

您已经发现主要测试线程将在测试完成的新生成的线程完成之前完成的其中一个问题（使用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));
    }
}

如果可能的话，在屏障上添加超时是很好的做法，并且有助于编写像这样的负面测试

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/

写了一些内容

Answer 2

代码对我来说很好看。也许你可以将LockBarrier传递给Runnable而不是在外面声明它。

为自定义屏障设计测试类

2 个答案: