/** compareAndSet in one thread enables another waiting for value to succeed */
public void testCompareAndSetInMultipleThreads() throws Exception {
x = one;
final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
try {
a =
AtomicReferenceFieldUpdater.newUpdater(
AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
} catch (RuntimeException ok) {
return;
}
Thread t =
new Thread(
new CheckedRunnable() {
public void realRun() {
while (!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three))
Thread.yield();
}
});
t.start();
assertTrue(a.compareAndSet(this, one, two));
t.join(LONG_DELAY_MS);
assertFalse(t.isAlive());
assertSame(a.get(this), three);
}
/**
* Waits for the specified time (in milliseconds) for the thread to terminate (using {@link
* Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and
* fails.
*/
void awaitTermination(Thread t, long timeoutMillis) {
try {
t.join(timeoutMillis);
} catch (InterruptedException ie) {
threadUnexpectedException(ie);
} finally {
if (t.getState() != Thread.State.TERMINATED) {
t.interrupt();
fail("Test timed out");
}
}
}
/** compareAndSet in one thread enables another waiting for value to succeed */
public void testCompareAndSetInMultipleThreads() {
final AtomicLong ai = new AtomicLong(1);
Thread t =
new Thread(
new Runnable() {
public void run() {
while (!ai.compareAndSet(2, 3)) Thread.yield();
}
});
try {
t.start();
assertTrue(ai.compareAndSet(1, 2));
t.join(LONG_DELAY_MS);
assertFalse(t.isAlive());
assertEquals(ai.get(), 3);
} catch (Exception e) {
unexpectedException();
}
}
private void bug40333Simulation(final Region region, final String queryStr) throws Exception {
final QueryService qs = CacheUtils.getQueryService();
Region rgn = CacheUtils.getRegion("/new_pos");
for (int i = 1; i < 100; ++i) {
NewPortfolio pf = new NewPortfolio("name" + i, i);
rgn.put("name" + i, pf);
}
final Object lock = new Object();
final boolean[] expectionOccured = new boolean[] {false};
final boolean[] keepGoing = new boolean[] {true};
Thread indexCreatorDestroyer =
new Thread(
new Runnable() {
public void run() {
boolean continueRunning = true;
do {
synchronized (lock) {
continueRunning = keepGoing[0];
}
try {
Index indx1 =
qs.createIndex(
"MarketValues",
IndexType.FUNCTIONAL,
"itr2.mktValue",
"/new_pos itr1, itr1.positions.values itr2");
Index indx2 =
qs.createIndex("Name", IndexType.FUNCTIONAL, "itr1.name", "/new_pos itr1");
Index indx3 =
qs.createIndex("nameIndex", IndexType.PRIMARY_KEY, "name", "/new_pos");
Index indx4 = qs.createIndex("idIndex", IndexType.FUNCTIONAL, "id", "/new_pos");
Index indx5 =
qs.createIndex("statusIndex", IndexType.FUNCTIONAL, "status", "/new_pos");
Index indx6 =
qs.createIndex(
"undefinedFieldIndex",
IndexType.FUNCTIONAL,
"undefinedTestField.toString",
"/new_pos");
Thread.sleep(800);
qs.removeIndex(indx1);
qs.removeIndex(indx2);
qs.removeIndex(indx3);
qs.removeIndex(indx4);
qs.removeIndex(indx5);
qs.removeIndex(indx6);
} catch (Throwable e) {
region.getCache().getLogger().error(e);
e.printStackTrace();
synchronized (lock) {
expectionOccured[0] = true;
keepGoing[0] = false;
continueRunning = false;
}
}
} while (continueRunning);
}
});
indexCreatorDestroyer.start();
final Query q = qs.newQuery(queryStr);
final int THREAD_COUNT = 10;
Thread queryThreads[] = new Thread[THREAD_COUNT];
final int numTimesToRun = 75;
for (int i = 0; i < THREAD_COUNT; ++i) {
queryThreads[i] =
new Thread(
new Runnable() {
public void run() {
boolean continueRunning = true;
for (int i = 0; i < numTimesToRun && continueRunning; ++i) {
synchronized (lock) {
continueRunning = keepGoing[0];
}
try {
SelectResults sr = (SelectResults) q.execute();
} catch (Throwable e) {
e.printStackTrace();
region.getCache().getLogger().error(e);
synchronized (lock) {
expectionOccured[0] = true;
keepGoing[0] = false;
continueRunning = false;
}
break;
}
}
}
});
}
synchronized (lock) {
assertFalse(expectionOccured[0]);
}
for (int i = 0; i < THREAD_COUNT; ++i) {
queryThreads[i].start();
}
for (int i = 0; i < THREAD_COUNT; ++i) {
queryThreads[i].join();
}
synchronized (lock) {
keepGoing[0] = false;
}
indexCreatorDestroyer.join();
synchronized (lock) {
assertFalse(expectionOccured[0]);
}
}