674 lines
27 KiB
Java
674 lines
27 KiB
Java
/*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* This file is available under and governed by the GNU General Public
|
|
* License version 2 only, as published by the Free Software Foundation.
|
|
* However, the following notice accompanied the original version of this
|
|
* file:
|
|
*
|
|
* Written by Doug Lea with assistance from members of JCP JSR-166
|
|
* Expert Group and released to the public domain, as explained at
|
|
* http://creativecommons.org/publicdomain/zero/1.0/
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8005697
|
|
* @summary Basic tests for StampedLock
|
|
* @library /lib/testlibrary/
|
|
* @author Chris Hegarty
|
|
*/
|
|
|
|
import static java.util.concurrent.TimeUnit.SECONDS;
|
|
import static java.util.concurrent.TimeUnit.MILLISECONDS;
|
|
import static java.util.concurrent.TimeUnit.NANOSECONDS;
|
|
|
|
import java.util.Iterator;
|
|
import java.util.concurrent.Phaser;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import java.util.concurrent.locks.Lock;
|
|
import java.util.concurrent.locks.ReadWriteLock;
|
|
import java.util.concurrent.locks.StampedLock;
|
|
import jdk.testlibrary.Utils;
|
|
|
|
public class Basic {
|
|
static final long LONG_DELAY_MS = Utils.adjustTimeout(10_000);
|
|
|
|
static void checkResult(Locker l, Class<? extends Throwable> c) {
|
|
Throwable t = l.thrown();
|
|
if (! ((t == null && c == null) || (c != null && c.isInstance(t)))) {
|
|
fail("Mismatch in thread " +
|
|
l.getName() + ": " +
|
|
t + ", " +
|
|
(c == null ? "<null>" : c.getName()));
|
|
}
|
|
|
|
if (c == null)
|
|
check(l.stamp() != 0L); // must have acquired the lock
|
|
else
|
|
check(l.stamp() == 0L); // must NOT have acquired the lock
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
// Mechanism to get all test threads into "running" mode.
|
|
//----------------------------------------------------------------
|
|
static void toTheStartingGate(Phaser gate) {
|
|
try {
|
|
gate.arriveAndAwaitAdvance();
|
|
} catch (Throwable t) {
|
|
unexpected(t);
|
|
}
|
|
}
|
|
|
|
abstract static class Locker extends Thread {
|
|
static AtomicInteger count = new AtomicInteger(1);
|
|
private volatile Throwable thrown;
|
|
private volatile long stamp;
|
|
protected void thrown(Throwable thrown) { this.thrown = thrown; }
|
|
public Throwable thrown() { return thrown; }
|
|
protected void stamp(long stamp) { this.stamp = stamp; }
|
|
public long stamp() { return stamp; }
|
|
|
|
Locker() {
|
|
this("Locker");
|
|
}
|
|
|
|
Locker(String name) {
|
|
this.setName(name + ":" + count.getAndIncrement());
|
|
this.setDaemon(true);
|
|
}
|
|
}
|
|
|
|
abstract static class Reader extends Locker {
|
|
Reader() { super("Reader"); }
|
|
Reader(String name) { super(name); }
|
|
}
|
|
|
|
static Reader reader(final StampedLock sl, final Phaser gate) {
|
|
return new Reader() { public void run() {
|
|
if (gate != null ) toTheStartingGate(gate);
|
|
stamp(sl.readLock());
|
|
try {
|
|
check(sl.validate(stamp()));
|
|
check(sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
} finally { sl.unlockRead(stamp()); } }};
|
|
}
|
|
|
|
static Reader readerView(final StampedLock sl, final Phaser gate) {
|
|
return new Reader("ReaderView") { public void run() {
|
|
if (gate != null ) toTheStartingGate(gate);
|
|
final Lock rl = sl.asReadLock();
|
|
rl.lock();
|
|
try {
|
|
stamp(1L); // got the lock
|
|
check(sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
} finally { rl.unlock(); } }};
|
|
}
|
|
|
|
static Reader reader(StampedLock sl, Phaser gate, boolean view) {
|
|
return view ? readerView(sl, gate) : reader(sl, gate);
|
|
}
|
|
|
|
static Reader interruptibleReader(final StampedLock sl,
|
|
final long timeout,
|
|
final TimeUnit unit,
|
|
final Phaser gate) {
|
|
return new Reader("InterruptibleReader") { public void run() {
|
|
if (gate != null ) toTheStartingGate(gate);
|
|
try {
|
|
if (timeout < 0)
|
|
stamp(sl.readLockInterruptibly());
|
|
else
|
|
stamp(sl.tryReadLock(timeout, unit));
|
|
check(sl.validate(stamp()));
|
|
check(sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
} catch (Throwable x) { thrown(x);
|
|
} finally { if (stamp() != 0L) sl.unlockRead(stamp()); } }};
|
|
}
|
|
|
|
static Reader interruptibleReaderView(final StampedLock sl,
|
|
final long timeout,
|
|
final TimeUnit unit,
|
|
final Phaser gate) {
|
|
return new Reader("InterruptibleReaderView") { public void run() {
|
|
if (gate != null ) toTheStartingGate(gate);
|
|
final Lock rl = sl.asReadLock();
|
|
|
|
try {
|
|
if (timeout < 0)
|
|
rl.lockInterruptibly();
|
|
else
|
|
rl.tryLock(timeout, unit);
|
|
stamp(1L); // got the lock
|
|
check(sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
} catch (Throwable x) { thrown(x);
|
|
} finally { if (stamp() != 0L) rl.unlock(); } }};
|
|
}
|
|
|
|
static Reader interruptibleReader(final StampedLock sl,
|
|
final long timeout,
|
|
final TimeUnit unit,
|
|
final Phaser gate,
|
|
final boolean view) {
|
|
return view ? interruptibleReaderView(sl, timeout, unit, gate)
|
|
: interruptibleReader(sl, timeout, unit, gate);
|
|
}
|
|
|
|
abstract static class Writer extends Locker {
|
|
Writer() { super("Writer"); }
|
|
Writer(String name) { super(name); }
|
|
}
|
|
|
|
static Writer writer(final StampedLock sl, final Phaser gate) {
|
|
return new Writer() { public void run() {
|
|
if (gate != null ) toTheStartingGate(gate);
|
|
try {
|
|
stamp(sl.writeLock());
|
|
check(sl.validate(stamp()));
|
|
check(!sl.isReadLocked());
|
|
check(sl.isWriteLocked());
|
|
} finally { sl.unlockWrite(stamp()); } }};
|
|
}
|
|
|
|
static Writer writerView(final StampedLock sl, final Phaser gate) {
|
|
return new Writer("WriterView") { public void run() {
|
|
if (gate != null ) toTheStartingGate(gate);
|
|
Lock wl = sl.asWriteLock();
|
|
wl.lock();
|
|
try {
|
|
stamp(1L); // got the lock
|
|
check(!sl.isReadLocked());
|
|
check(sl.isWriteLocked());
|
|
} finally { wl.unlock(); } }};
|
|
}
|
|
|
|
static Writer writer(StampedLock sl, Phaser gate, boolean view) {
|
|
return view ? writerView(sl, gate) : writer(sl, gate);
|
|
}
|
|
|
|
static Writer interruptibleWriter(final StampedLock sl,
|
|
final long timeout,
|
|
final TimeUnit unit,
|
|
final Phaser gate) {
|
|
return new Writer("InterruptibleWriter") { public void run() {
|
|
if (gate != null ) toTheStartingGate(gate);
|
|
try {
|
|
if (timeout < 0)
|
|
stamp(sl.writeLockInterruptibly());
|
|
else
|
|
stamp(sl.tryWriteLock(timeout, unit));
|
|
check(sl.validate(stamp()));
|
|
check(!sl.isReadLocked());
|
|
check(sl.isWriteLocked());
|
|
} catch (Throwable x) { thrown(x);
|
|
} finally { if (stamp() != 0L) sl.unlockWrite(stamp()); } }};
|
|
}
|
|
|
|
static Writer interruptibleWriterView(final StampedLock sl,
|
|
final long timeout,
|
|
final TimeUnit unit,
|
|
final Phaser gate) {
|
|
return new Writer("InterruptibleWriterView") { public void run() {
|
|
if (gate != null ) toTheStartingGate(gate);
|
|
Lock wl = sl.asWriteLock();
|
|
try {
|
|
if (timeout < 0)
|
|
wl.lockInterruptibly();
|
|
else
|
|
wl.tryLock(timeout, unit);
|
|
stamp(1L); // got the lock
|
|
check(!sl.isReadLocked());
|
|
check(sl.isWriteLocked());
|
|
} catch (Throwable x) { thrown(x);
|
|
} finally { if (stamp() != 0L) wl.unlock(); } }};
|
|
}
|
|
|
|
static Writer interruptibleWriter(final StampedLock sl,
|
|
final long timeout,
|
|
final TimeUnit unit,
|
|
final Phaser gate,
|
|
final boolean view) {
|
|
return view ? interruptibleWriterView(sl, timeout, unit, gate)
|
|
: interruptibleWriter(sl, timeout, unit, gate);
|
|
}
|
|
|
|
// Returns an infinite lazy list of all possible reader combinations.
|
|
static Iterator<Reader> readerIterator(final StampedLock sl,
|
|
final Phaser gate) {
|
|
return new Iterator<Reader>() {
|
|
int i = 0;
|
|
boolean view = false;
|
|
public boolean hasNext() { return true; }
|
|
public Reader next() {
|
|
switch ((i++)&7) {
|
|
case 1: case 4: case 7:
|
|
return reader(sl, gate, view ^= true);
|
|
case 2: case 5:
|
|
return interruptibleReader(sl, -1, SECONDS, gate, view ^= true);
|
|
default:
|
|
return interruptibleReader(sl, LONG_DELAY_MS, MILLISECONDS, gate, view ^= true); }}
|
|
public void remove() {throw new UnsupportedOperationException();}};
|
|
}
|
|
|
|
// Returns an infinite lazy list of all possible writer combinations.
|
|
static Iterator<Writer> writerIterator(final StampedLock sl,
|
|
final Phaser gate) {
|
|
return new Iterator<Writer>() {
|
|
int i = 0;
|
|
boolean view = false;
|
|
public boolean hasNext() { return true; }
|
|
public Writer next() {
|
|
switch ((i++)&7) {
|
|
case 1: case 4: case 7:
|
|
return writer(sl, gate, view ^= true);
|
|
case 2: case 5:
|
|
return interruptibleWriter(sl, -1, SECONDS, gate, view ^= true);
|
|
default:
|
|
return interruptibleWriter(sl, LONG_DELAY_MS, MILLISECONDS, gate, view ^= true); }}
|
|
public void remove() {throw new UnsupportedOperationException();}};
|
|
}
|
|
|
|
static class SimpleTimer {
|
|
long startTime = System.nanoTime();
|
|
long elapsedMillis() {
|
|
long now = System.nanoTime();
|
|
long elapsed = NANOSECONDS.toMillis(now - startTime);
|
|
startTime = now;
|
|
return elapsed;
|
|
}
|
|
void printElapsed() { System.out.println(elapsedMillis() + " ms"); }
|
|
}
|
|
|
|
static void waitForThreadToBlock(Thread thread) {
|
|
for (long startTime = 0;;) {
|
|
Thread.State state = thread.getState();
|
|
if (state == Thread.State.WAITING ||
|
|
state == Thread.State.TIMED_WAITING)
|
|
break;
|
|
if (startTime == 0) startTime = System.nanoTime();
|
|
else if (System.nanoTime() - startTime > 10L * 1000L * 1000L * 1000L)
|
|
throw new AssertionError("timed out waiting for thread to block");
|
|
}
|
|
}
|
|
|
|
private static void realMain(String[] args) throws Throwable {
|
|
SimpleTimer timer = new SimpleTimer();
|
|
|
|
//----------------------------------------------------------------
|
|
System.out.print("Some basic sanity: ");
|
|
//----------------------------------------------------------------
|
|
try {
|
|
final StampedLock sl = new StampedLock();
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
long stamp = sl.tryOptimisticRead();
|
|
check(stamp != 0L);
|
|
check(sl.validate(stamp));
|
|
check(!sl.validate(0));
|
|
|
|
stamp = sl.writeLock();
|
|
try {
|
|
check(sl.validate(stamp));
|
|
check(!sl.isReadLocked());
|
|
check(sl.isWriteLocked());
|
|
check(sl.tryReadLock() == 0L);
|
|
check(sl.tryReadLock(1, MILLISECONDS) == 0L);
|
|
check(sl.tryOptimisticRead() == 0L);
|
|
check(sl.tryWriteLock() == 0L);
|
|
check(sl.tryWriteLock(1, MILLISECONDS) == 0L);
|
|
check(!sl.tryUnlockRead());
|
|
check(sl.tryConvertToWriteLock(stamp) == stamp);
|
|
try {
|
|
sl.unlockRead(stamp);
|
|
fail("Expected unlockRead to throw when not holding read lock");
|
|
} catch (IllegalMonitorStateException x) {
|
|
pass();
|
|
}
|
|
check(sl.validate(stamp));
|
|
} finally {
|
|
sl.unlockWrite(stamp);
|
|
}
|
|
check(!sl.isWriteLocked());
|
|
|
|
stamp = sl.readLock();
|
|
try {
|
|
check(sl.validate(stamp));
|
|
check(sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(sl.tryOptimisticRead() != 0L);
|
|
check(sl.tryWriteLock() == 0L);
|
|
check(sl.tryWriteLock(1, MILLISECONDS) == 0L);
|
|
check(!sl.tryUnlockWrite());
|
|
check(sl.tryConvertToReadLock(stamp) == stamp);
|
|
try {
|
|
sl.unlockWrite(stamp);
|
|
fail("Expected unlockWrite to throw when not holding read lock");
|
|
} catch (IllegalMonitorStateException x) {
|
|
pass();
|
|
}
|
|
check(sl.validate(stamp));
|
|
} finally {
|
|
sl.unlockRead(stamp);
|
|
}
|
|
check(!sl.isReadLocked());
|
|
|
|
stamp = sl.tryReadLock(1, MILLISECONDS);
|
|
try {
|
|
check(stamp != 0L);
|
|
} finally {
|
|
sl.unlockRead(stamp);
|
|
}
|
|
} catch (Throwable t) { unexpected(t); }
|
|
timer.printElapsed();
|
|
|
|
//----------------------------------------------------------------
|
|
System.out.print("Multiple writers single reader: ");
|
|
//----------------------------------------------------------------
|
|
try {
|
|
StampedLock sl = new StampedLock();
|
|
int nThreads = 10;
|
|
Phaser gate = new Phaser(nThreads + 2);
|
|
Iterator<Writer> writers = writerIterator(sl, gate);
|
|
Iterator<Reader> readers = readerIterator(sl, gate);
|
|
for (int i = 0; i < 2; i++) {
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(!sl.tryUnlockRead());
|
|
check(!sl.tryUnlockWrite());
|
|
check(sl.tryOptimisticRead() != 0L);
|
|
Locker[] wThreads = new Locker[nThreads];
|
|
for (int j=0; j<nThreads; j++)
|
|
wThreads[j] = writers.next();
|
|
for (int j=0; j<nThreads; j++)
|
|
wThreads[j].start();
|
|
Reader reader = readers.next(); reader.start();
|
|
toTheStartingGate(gate);
|
|
reader.join();
|
|
for (int j=0; j<nThreads; j++)
|
|
wThreads[j].join();
|
|
for (int j=0; j<nThreads; j++)
|
|
checkResult(wThreads[j], null);
|
|
checkResult(reader, null);
|
|
}
|
|
} catch (Throwable t) { unexpected(t); }
|
|
timer.printElapsed();
|
|
|
|
//----------------------------------------------------------------
|
|
System.out.print("Multiple readers single writer: ");
|
|
//----------------------------------------------------------------
|
|
try {
|
|
StampedLock sl = new StampedLock();
|
|
int nThreads = 10;
|
|
Phaser gate = new Phaser(nThreads + 2);
|
|
Iterator<Writer> writers = writerIterator(sl, gate);
|
|
Iterator<Reader> readers = readerIterator(sl, gate);
|
|
for (int i = 0; i < 2; i++) {
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(!sl.tryUnlockRead());
|
|
check(!sl.tryUnlockWrite());
|
|
check(sl.tryOptimisticRead() != 0L);
|
|
Locker[] rThreads = new Locker[nThreads];
|
|
for (int j=0; j<nThreads; j++)
|
|
rThreads[j] = readers.next();
|
|
for (int j=0; j<nThreads; j++)
|
|
rThreads[j].start();
|
|
Writer writer = writers.next(); writer.start();
|
|
toTheStartingGate(gate);
|
|
writer.join();
|
|
for (int j=0; j<nThreads; j++)
|
|
rThreads[j].join();
|
|
for (int j=0; j<nThreads; j++)
|
|
checkResult(rThreads[j], null);
|
|
checkResult(writer, null);
|
|
}
|
|
} catch (Throwable t) { unexpected(t); }
|
|
timer.printElapsed();
|
|
|
|
//----------------------------------------------------------------
|
|
System.out.print("thread interrupted: ");
|
|
//----------------------------------------------------------------
|
|
try {
|
|
// We test interrupting both before and after trying to acquire
|
|
boolean view = false;
|
|
StampedLock sl = new StampedLock();
|
|
for (long timeout : new long[] { -1L, LONG_DELAY_MS, -1L, LONG_DELAY_MS }) {
|
|
long stamp;
|
|
Thread.State state;
|
|
|
|
stamp = sl.writeLock();
|
|
try {
|
|
Reader r = interruptibleReader(sl, timeout, MILLISECONDS, null, view);
|
|
r.start();
|
|
r.interrupt();
|
|
r.join();
|
|
checkResult(r, InterruptedException.class);
|
|
} finally {
|
|
sl.unlockWrite(stamp);
|
|
}
|
|
|
|
stamp = sl.writeLock();
|
|
try {
|
|
Reader r = interruptibleReader(sl, timeout, MILLISECONDS, null, view);
|
|
r.start();
|
|
waitForThreadToBlock(r);
|
|
r.interrupt();
|
|
r.join();
|
|
checkResult(r, InterruptedException.class);
|
|
} finally {
|
|
sl.unlockWrite(stamp);
|
|
}
|
|
|
|
stamp = sl.readLock();
|
|
try {
|
|
Writer w = interruptibleWriter(sl, timeout, MILLISECONDS, null, view);
|
|
w.start();
|
|
w.interrupt();
|
|
w.join();
|
|
checkResult(w, InterruptedException.class);
|
|
} finally {
|
|
sl.unlockRead(stamp);
|
|
}
|
|
|
|
stamp = sl.readLock();
|
|
try {
|
|
Writer w = interruptibleWriter(sl, timeout, MILLISECONDS, null, view);
|
|
w.start();
|
|
waitForThreadToBlock(w);
|
|
w.interrupt();
|
|
w.join();
|
|
checkResult(w, InterruptedException.class);
|
|
} finally {
|
|
sl.unlockRead(stamp);
|
|
}
|
|
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(!sl.tryUnlockRead());
|
|
check(!sl.tryUnlockWrite());
|
|
check(sl.tryOptimisticRead() != 0L);
|
|
if (timeout == LONG_DELAY_MS)
|
|
view = true;
|
|
}
|
|
} catch (Throwable t) { unexpected(t); }
|
|
timer.printElapsed();
|
|
|
|
//----------------------------------------------------------------
|
|
System.out.print("timeout: ");
|
|
//----------------------------------------------------------------
|
|
try {
|
|
StampedLock sl = new StampedLock();
|
|
for (long timeout : new long[] { 0L, 5L }) {
|
|
long stamp = sl.writeLock();
|
|
try {
|
|
check(sl.tryReadLock(timeout, MILLISECONDS) == 0L);
|
|
} finally {
|
|
sl.unlockWrite(stamp);
|
|
}
|
|
stamp = sl.readLock();
|
|
try {
|
|
check(sl.tryWriteLock(timeout, MILLISECONDS) == 0L);
|
|
} finally {
|
|
sl.unlockRead(stamp);
|
|
}
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(!sl.tryUnlockRead());
|
|
check(!sl.tryUnlockWrite());
|
|
check(sl.tryOptimisticRead() != 0L);
|
|
}
|
|
} catch (Throwable t) { unexpected(t); }
|
|
timer.printElapsed();
|
|
|
|
//----------------------------------------------------------------
|
|
System.out.print("optimistic read: ");
|
|
//----------------------------------------------------------------
|
|
try {
|
|
StampedLock sl = new StampedLock();
|
|
Iterator<Writer> writers = writerIterator(sl, null);
|
|
Iterator<Reader> readers = readerIterator(sl, null);
|
|
for (int i = 0; i < 10; i++) {
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(!sl.tryUnlockRead());
|
|
check(!sl.tryUnlockWrite());
|
|
long stamp = sl.tryOptimisticRead();
|
|
check(stamp != 0L);
|
|
check(sl.tryConvertToOptimisticRead(stamp) == stamp);
|
|
Reader r = readers.next(); r.start();
|
|
r.join();
|
|
checkResult(r, null);
|
|
check(sl.validate(stamp));
|
|
check(sl.tryConvertToOptimisticRead(stamp) == stamp);
|
|
Writer w = writers.next(); w.start();
|
|
w.join();
|
|
checkResult(w, null);
|
|
check(sl.validate(stamp) == false);
|
|
}
|
|
} catch (Throwable t) { unexpected(t); }
|
|
timer.printElapsed();
|
|
|
|
//----------------------------------------------------------------
|
|
System.out.print("convert: ");
|
|
//----------------------------------------------------------------
|
|
try {
|
|
StampedLock sl = new StampedLock();
|
|
for (int i = 0; i < 2; i++) {
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(!sl.tryUnlockRead());
|
|
check(!sl.tryUnlockWrite());
|
|
long stamp = sl.tryOptimisticRead();
|
|
check(stamp != 0L);
|
|
check((stamp = sl.tryConvertToReadLock(stamp)) != 0L);
|
|
check(sl.validate(stamp));
|
|
check(sl.isReadLocked());
|
|
check(sl.tryWriteLock() == 0L);
|
|
check(sl.tryWriteLock(1L, MILLISECONDS) == 0L);
|
|
check((stamp = sl.tryConvertToWriteLock(stamp)) != 0L);
|
|
check(sl.validate(stamp));
|
|
check(!sl.isReadLocked());
|
|
check(sl.isWriteLocked());
|
|
check(sl.tryReadLock(1L, MILLISECONDS) == 0L);
|
|
if (i != 0) {
|
|
sl.unlockWrite(stamp);
|
|
continue;
|
|
}
|
|
// convert down
|
|
check((stamp = sl.tryConvertToReadLock(stamp)) != 0L);
|
|
check(sl.validate(stamp));
|
|
check(sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(sl.tryWriteLock() == 0L);
|
|
check(sl.tryWriteLock(1L, MILLISECONDS) == 0L);
|
|
check((stamp = sl.tryConvertToOptimisticRead(stamp)) != 0L);
|
|
check(sl.validate(stamp));
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(sl.validate(stamp));
|
|
}
|
|
} catch (Throwable t) { unexpected(t); }
|
|
timer.printElapsed();
|
|
|
|
//----------------------------------------------------------------
|
|
System.out.print("views: ");
|
|
//----------------------------------------------------------------
|
|
try {
|
|
StampedLock sl = new StampedLock();
|
|
|
|
Lock rl = sl.asReadLock();
|
|
Lock wl = sl.asWriteLock();
|
|
for (int i = 0; i < 2; i++) {
|
|
rl.lock();
|
|
try {
|
|
check(sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
check(sl.tryWriteLock() == 0L);
|
|
check(sl.tryWriteLock(1L, MILLISECONDS) == 0L);
|
|
} finally {
|
|
rl.unlock();
|
|
}
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
|
|
wl.lock();
|
|
try {
|
|
check(!sl.isReadLocked());
|
|
check(sl.isWriteLocked());
|
|
check(sl.tryWriteLock() == 0L);
|
|
check(sl.tryWriteLock(1L, MILLISECONDS) == 0L);
|
|
} finally {
|
|
wl.unlock();
|
|
}
|
|
check(!sl.isReadLocked());
|
|
check(!sl.isWriteLocked());
|
|
|
|
ReadWriteLock rwl = sl.asReadWriteLock();
|
|
rl = rwl.readLock();
|
|
wl = rwl.writeLock();
|
|
}
|
|
} catch (Throwable t) { unexpected(t); }
|
|
timer.printElapsed();
|
|
}
|
|
|
|
//--------------------- Infrastructure ---------------------------
|
|
static volatile int passed = 0, failed = 0;
|
|
static void pass() {passed++;}
|
|
static void fail() {failed++; Thread.dumpStack();}
|
|
static void fail(String msg) {System.out.println(msg); fail();}
|
|
static void unexpected(Throwable t) {failed++; t.printStackTrace();}
|
|
static void check(boolean cond) {if (cond) pass(); else fail();}
|
|
static void equal(Object x, Object y) {
|
|
if (x == null ? y == null : x.equals(y)) pass();
|
|
else fail(x + " not equal to " + y);}
|
|
public static void main(String[] args) throws Throwable {
|
|
try {realMain(args);} catch (Throwable t) {unexpected(t);}
|
|
System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
|
|
if (failed > 0) throw new AssertionError("Some tests failed");}
|
|
}
|