Apache
/
commons-lang
mirror of https://github.com/apache/commons-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Better names in test. Use final. Sort members.

This commit is contained in:
Gary Gregory 2020-07-23 09:24:53 -04:00
parent 4e9460413a
commit 3276da82f0
1 changed files with 73 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
src/test/java/org/apache/commons/lang3/concurrent/locks/LockingVisitorsTest.java
View File

@ -28,41 +28,59 @@ import org.apache.commons.lang3.function.FailableConsumer;
import org.junit.jupiter.api.Test;
public class LockingVisitorsTest {
private static final int NUMBER_OF_THREADS = 10;
private static final long DELAY_MILLIS = 3000;
private static final int NUMBER_OF_THREADS = 10;
private static final long TOTAL_DELAY_MILLIS = NUMBER_OF_THREADS * DELAY_MILLIS;
@Test
public void testStampedLockNotExclusive() throws Exception {
/*
* If our threads are running concurrently, then we expect to be faster than running one after the other.
*/
boolean[] booleanValues = new boolean[10];
runTest(DELAY_MILLIS, false, l -> assertTrue(l < TOTAL_DELAY_MILLIS), booleanValues,
LockingVisitors.stampedLockVisitor(booleanValues));
protected boolean containsTrue(final boolean[] booleanArray) {
synchronized (booleanArray) {
for (final boolean element : booleanArray) {
if (element) {
return true;
}
}
return false;
}
}
@Test
public void testReentrantReadWriteLockNotExclusive() throws Exception {
private void runTest(final long delayMillis, final boolean exclusiveLock, final LongConsumer runTimeCheck,
final boolean[] booleanValues, final LockVisitor<boolean[], ?> visitor) throws InterruptedException {
final boolean[] runningValues = new boolean[10];
/*
* If our threads are running concurrently, then we expect to be faster than running one after the other.
*/
boolean[] booleanValues = new boolean[10];
runTest(DELAY_MILLIS, false, l -> assertTrue(l < TOTAL_DELAY_MILLIS), booleanValues,
LockingVisitors.reentrantReadWriteLockVisitor(booleanValues));
final long startTime = System.currentTimeMillis();
for (int i = 0; i < booleanValues.length; i++) {
final int index = i;
final FailableConsumer<boolean[], ?> consumer = b -> {
b[index] = false;
Thread.sleep(delayMillis);
b[index] = true;
set(runningValues, index, false);
};
final Thread t = new Thread(() -> {
if (exclusiveLock) {
visitor.acceptWriteLocked(consumer);
} else {
visitor.acceptReadLocked(consumer);
}
});
set(runningValues, i, true);
t.start();
}
while (containsTrue(runningValues)) {
Thread.sleep(100);
}
final long endTime = System.currentTimeMillis();
for (final boolean booleanValue : booleanValues) {
assertTrue(booleanValue);
}
// WRONG assumption
// runTimeCheck.accept(endTime - startTime);
}
@Test
public void testStampedLockExclusive() throws Exception {
/*
* If our threads are running concurrently, then we expect to be no faster than running one after the other.
*/
boolean[] booleanValues = new boolean[10];
runTest(DELAY_MILLIS, true, l -> assertTrue(l >= TOTAL_DELAY_MILLIS), booleanValues,
LockingVisitors.stampedLockVisitor(booleanValues));
protected void set(final boolean[] booleanArray, final int offset, final boolean value) {
synchronized (booleanArray) {
booleanArray[offset] = value;
}
}
@Test
@ -71,11 +89,22 @@ public class LockingVisitorsTest {
/*
* If our threads are running concurrently, then we expect to be no faster than running one after the other.
*/
boolean[] booleanValues = new boolean[10];
final boolean[] booleanValues = new boolean[10];
runTest(DELAY_MILLIS, true, l -> assertTrue(l >= TOTAL_DELAY_MILLIS), booleanValues,
LockingVisitors.reentrantReadWriteLockVisitor(booleanValues));
}
@Test
public void testReentrantReadWriteLockNotExclusive() throws Exception {
/*
* If our threads are running concurrently, then we expect to be faster than running one after the other.
*/
final boolean[] booleanValues = new boolean[10];
runTest(DELAY_MILLIS, false, l -> assertTrue(l < TOTAL_DELAY_MILLIS), booleanValues,
LockingVisitors.reentrantReadWriteLockVisitor(booleanValues));
}
@Test
public void testResultValidation() {
final Object hidden = new Object();
@ -90,54 +119,25 @@ public class LockingVisitorsTest {
assertNotSame(hidden, o2);
}
private void runTest(final long delayMillis, final boolean exclusiveLock, final LongConsumer runTimeCheck,
boolean[] booleanValues, LockVisitor<boolean[], ?> visitor) throws InterruptedException {
final boolean[] runningValues = new boolean[10];
@Test
public void testStampedLockExclusive() throws Exception {
final long startTime = System.currentTimeMillis();
for (int i = 0; i < booleanValues.length; i++) {
final int index = i;
final FailableConsumer<boolean[], ?> consumer = b -> {
b[index] = false;
Thread.sleep(delayMillis);
b[index] = true;
modify(runningValues, index, false);
};
final Thread t = new Thread(() -> {
if (exclusiveLock) {
visitor.acceptWriteLocked(consumer);
} else {
visitor.acceptReadLocked(consumer);
}
});
modify(runningValues, i, true);
t.start();
}
while (someValueIsTrue(runningValues)) {
Thread.sleep(100);
}
final long endTime = System.currentTimeMillis();
for (int i = 0; i < booleanValues.length; i++) {
assertTrue(booleanValues[i]);
}
// WRONG assumption
// runTimeCheck.accept(endTime - startTime);
/*
* If our threads are running concurrently, then we expect to be no faster than running one after the other.
*/
final boolean[] booleanValues = new boolean[10];
runTest(DELAY_MILLIS, true, l -> assertTrue(l >= TOTAL_DELAY_MILLIS), booleanValues,
LockingVisitors.stampedLockVisitor(booleanValues));
}
protected void modify(final boolean[] booleanArray, final int offset, final boolean value) {
synchronized (booleanArray) {
booleanArray[offset] = value;
}
}
@Test
public void testStampedLockNotExclusive() throws Exception {
protected boolean someValueIsTrue(final boolean[] booleanArray) {
synchronized (booleanArray) {
for (int i = 0; i < booleanArray.length; i++) {
if (booleanArray[i]) {
return true;
}
}
return false;
}
/*
* If our threads are running concurrently, then we expect to be faster than running one after the other.
*/
final boolean[] booleanValues = new boolean[10];
runTest(DELAY_MILLIS, false, l -> assertTrue(l < TOTAL_DELAY_MILLIS), booleanValues,
LockingVisitors.stampedLockVisitor(booleanValues));
}
}