6

我正在为 AtomicInteger 和 AtomicBoolean 编写单元测试。它们将用作参考测试，用于在 Objective-c 中测试这些类的仿真，用于翻译项目。

我认为 AtomicInteger 测试效果很好，基本上是通过在大量 for 循环中执行可预测数量的递增、递减、加法和减法操作，每个循环都在自己的线程中运行（每种操作类型有许多线程）。实际操作使用 CountDownLatch 同时开始。

当所有线程都完成后，我通过将原子整数与基于线程数、每个线程的迭代次数和每次迭代的预期增加/减少的预期整数值进行比较来断言。该测试通过。

但是如何测试 AtomicBoolean？基本操作是获取和设置，因此在许多线程中多次调用并期望最终结果为真或假似乎没有意义。我正在考虑的方向是使用两个应该始终具有相反值的 AtomicBooleans。像这样：

@Test
public void testAtomicity() throws Exception {

    // ====  SETUP  ====
    final AtomicBoolean booleanA = new AtomicBoolean(true);
    final AtomicBoolean booleanB = new AtomicBoolean(false);

    final int threadCount = 50;

    final int iterationsPerThread = 5000;

    final CountDownLatch startSignalLatch = new CountDownLatch(1);
    final CountDownLatch threadsFinishedLatch = new CountDownLatch(threadCount);

    final AtomicBoolean assertFailed = new AtomicBoolean(false);

    // ====  EXECUTE: start all threads ====
    for (int i = 0; i < threadCount; i++) {

        // ====  Create the thread  =====
        AtomicOperationsThread thread;
        thread = new AtomicOperationsThread("Thread #" + i, booleanA, booleanB, startSignalLatch, threadsFinishedLatch, iterationsPerThread, assertFailed);
        System.out.println("Creating Thread #" + i);

        // ====  Start the thread (each thread will wait until the startSignalLatch is triggered)  =====
        thread.start();
    }

    startSignalLatch.countDown();

    // ====  VERIFY: that the AtomicInteger has the expected value after all threads have finished  ====
    final boolean allThreadsFinished;
    allThreadsFinished = threadsFinishedLatch.await(60, TimeUnit.SECONDS);

    assertTrue("Not all threads have finished before reaching the timeout", allThreadsFinished);
    assertFalse(assertFailed.get());

}

private static class AtomicOperationsThread extends Thread {

    // #####  Instance variables  #####

    private final CountDownLatch startSignalLatch;
    private final CountDownLatch threadsFinishedLatch;

    private final int iterations;

    private final AtomicBoolean booleanA, booleanB;

    private final AtomicBoolean assertFailed;

    // #####  Constructor  #####

    private AtomicOperationsThread(final String name, final AtomicBoolean booleanA, final AtomicBoolean booleanB, final CountDownLatch startSignalLatch, final CountDownLatch threadsFinishedLatch, final int iterations, final AtomicBoolean assertFailed) {

        super(name);
        this.booleanA = booleanA;
        this.booleanB = booleanB;
        this.startSignalLatch = startSignalLatch;
        this.threadsFinishedLatch = threadsFinishedLatch;
        this.iterations = iterations;
        this.assertFailed = assertFailed;
    }

    // #####  Thread implementation  #####

    @Override
    public void run() {

        super.run();

        // ====  Wait for the signal to start (so all threads are executed simultaneously)  =====
        try {
            System.out.println(this.getName() + " has started. Awaiting startSignal.");
            startSignalLatch.await();  /* Awaiting start signal */
        } catch (InterruptedException e) {
            throw new RuntimeException("The startSignalLatch got interrupted.", e);
        }

        // ====  Perform the atomic operations  =====
        for (int i = 0; i < iterations; i++) {

            final boolean booleanAChanged;
            booleanAChanged = booleanA.compareAndSet(!booleanB.get(), booleanB.getAndSet(booleanA.get()));  /* Set A to the current value of B if A is currently the opposite of B, then set B to the current value of A */

            if (!booleanAChanged){
                assertFailed.set(true);
                System.out.println("Assert failed in thread: " + this.getName());
            }
        }

        // ====  Mark this thread as finished  =====
        threadsFinishedLatch.countDown();
    }
}

这适用于一个线程，但会失败多个。我想这是因为booleanAChanged = booleanA.compareAndSet(!booleanB.get(), booleanB.getAndSet(booleanA.get()));不是一个原子操作。

有什么建议么？

4

3 回答 3

4

我会专注于，这是一个和一个普通compareAndSet之间的真正区别。AtomicBooleanboolean

例如，用于compareAndSet(false, true)控制临界区。循环执行，直到返回 false，然后进入临界区。在临界区，做一些如果两个或多个线程同时运行很可能会失败的事情。例如，在读取旧值和写入新值之间增加一个短暂睡眠的计数器。在临界区结束时，将 设置AtomicBoolean为 false。

在启动线程之前将初始化AtomicBoolean为假，并初始化为零。globalCounter

for(int i=0; i<iterations; i++) {
  while (!AtomicBooleanTest.atomic.compareAndSet(false, true));
  int oldValue = AtomicBooleanTest.globalCounter;
  Thread.sleep(1);
  AtomicBooleanTest.globalCounter = oldValue + 1;
  AtomicBooleanTest.atomic.set(false);
}

最后，globalCounter值应该是t*iterations线程t数。

线程的数量应该与硬件可以同时运行的数量相似——这在多处理器上比在单处理器上失败的可能性要大得多。失败的最高风险是在 AtomicBoolean 变为 false 之后立即发生。所有可用的处理器都应该同时尝试获得对它的独占访问权，将其视为假，然后自动将其更改为真。

于 2013-07-01T23:50:15.373 回答
3

AtomicInteger正如您所指出的，我认为这将比 a 更难测试。可能值的空间要小得多，因此可能出错的事情的空间要小得多。由于像这样的测试基本上归结为运气（有很多循环来增加你的机会），所以要达到那个较小的目标会更加困难。

我的建议是启动许多可以访问单个AtomicBoolean. 让他们每个人都做一个 CAS，并且只有当他们成功时，才以原子方式递增一个AtomicInteger. 当所有线程都完成后，您应该只看到AtomicInteger. 然后只需冲洗，起泡，重复。

于 2013-07-01T23:57:04.900 回答
1

它是四个原子操作。鉴于您只希望一个布尔值与另一个布尔值相反，只需有一个布尔值并不断切换它。您可以从该值计算另一个。

于 2013-07-01T23:12:17.547 回答