我正在为AtomicInteger和AtomicBoolean编写单元测试。它们将用作引用测试，以测试Objective-C中这些类的仿真，并用于翻译的项目中。
我认为AtomicInteger测试的效果很好，基本上是通过在大量for循环中执行可预测数量的增量，减量，加法和减法操作，每个循环都在各自的线程中运行(每种操作类型有多个线程)。实际操作同时使用CountDownLatch开始。
完成所有线程后，我通过将原子整数与线程数，每个线程的迭代次数以及每次迭代的预期增加/减少次数的期望整数值进行比较来断言。该测试通过。
但是如何测试AtomicBoolean？ 基本的操作是get和set的，因此在许多线程中多次调用并期望最终结果为true或false似乎没有任何意义。我在想的方向是使用两个应该始终具有相反值的AtomicBoolean。像这样:
@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()));不是一个原子操作。有什么建议么？
最佳答案
我将专注于compareAndSet，这是AtomicBoolean和普通boolean之间的真正区别。
例如，使用compareAndSet(false, true)控制关键区域。循环执行此操作，直到返回false，然后进入关键区域。在关键区域，如果两个或多个线程同时运行它，则很可能会失败。例如，在读取旧值和写入新值之间的短暂 sleep 中增加计数器。在关键区域的末尾，将AtomicBoolean设置为false。
在启动线程之前，将AtomicBoolean初始化为false，并将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之后立即发生。所有可用的处理器都应同时尝试获得对其的独占访问权，将其视为假，并将其原子性地更改为真。
关于java - 如何测试AtomicBoolean原子性？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/17414924/