Java StampedLock.unlockWrite方法代码示例

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
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()); } }};
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * write-locking and read-locking an unlocked lock succeed
 */
public void testLock() {
    StampedLock lock = new StampedLock();
    assertFalse(lock.isWriteLocked());
    assertFalse(lock.isReadLocked());
    assertEquals(lock.getReadLockCount(), 0);
    long s = lock.writeLock();
    assertTrue(lock.isWriteLocked());
    assertFalse(lock.isReadLocked());
    assertEquals(lock.getReadLockCount(), 0);
    lock.unlockWrite(s);
    assertFalse(lock.isWriteLocked());
    assertFalse(lock.isReadLocked());
    assertEquals(lock.getReadLockCount(), 0);
    long rs = lock.readLock();
    assertFalse(lock.isWriteLocked());
    assertTrue(lock.isReadLocked());
    assertEquals(lock.getReadLockCount(), 1);
    lock.unlockRead(rs);
    assertFalse(lock.isWriteLocked());
    assertFalse(lock.isReadLocked());
    assertEquals(lock.getReadLockCount(), 0);
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * A stamp obtained from a successful lock operation validates
 */
public void testValidate() throws InterruptedException {
    StampedLock lock = new StampedLock();
    long s = lock.writeLock();
    assertTrue(lock.validate(s));
    lock.unlockWrite(s);
    s = lock.readLock();
    assertTrue(lock.validate(s));
    lock.unlockRead(s);
    assertTrue((s = lock.tryWriteLock()) != 0L);
    assertTrue(lock.validate(s));
    lock.unlockWrite(s);
    assertTrue((s = lock.tryReadLock()) != 0L);
    assertTrue(lock.validate(s));
    lock.unlockRead(s);
    assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
    assertTrue(lock.validate(s));
    lock.unlockWrite(s);
    assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
    assertTrue(lock.validate(s));
    lock.unlockRead(s);
    assertTrue((s = lock.tryOptimisticRead()) != 0L);
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * timed tryReadLock times out if write-locked
 */
public void testReadTryLock_Timeout() {
    final StampedLock lock = new StampedLock();
    long s = lock.writeLock();
    Thread t = newStartedThread(new CheckedRunnable() {
        public void realRun() throws InterruptedException {
            long startTime = System.nanoTime();
            long timeoutMillis = 10;
            long rs = lock.tryReadLock(timeoutMillis, MILLISECONDS);
            assertEquals(rs, 0L);
            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
        }});

    awaitTermination(t);
    assertTrue(lock.isWriteLocked());
    lock.unlockWrite(s);
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
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()); } }};
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * Releases write lock, checking isWriteLocked before and after
 */
void releaseWriteLock(StampedLock lock, long stamp) {
    assertTrue(lock.isWriteLocked());
    assertValid(lock, stamp);
    lock.unlockWrite(stamp);
    assertFalse(lock.isWriteLocked());
    assertFalse(lock.validate(stamp));
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * A stamp obtained from an unsuccessful lock operation does not validate
 */
public void testValidate2() throws InterruptedException {
    StampedLock lock = new StampedLock();
    long s = assertNonZero(lock.writeLock());
    assertTrue(lock.validate(s));
    assertFalse(lock.validate(lock.tryWriteLock()));
    assertFalse(lock.validate(lock.tryWriteLock(randomExpiredTimeout(),
                                                randomTimeUnit())));
    assertFalse(lock.validate(lock.tryReadLock()));
    assertFalse(lock.validate(lock.tryWriteLock(randomExpiredTimeout(),
                                                randomTimeUnit())));
    assertFalse(lock.validate(lock.tryOptimisticRead()));
    lock.unlockWrite(s);
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * A serialized lock deserializes as unlocked
 */
public void testSerialization() {
    StampedLock lock = new StampedLock();
    lock.writeLock();
    StampedLock clone = serialClone(lock);
    assertTrue(lock.isWriteLocked());
    assertFalse(clone.isWriteLocked());
    long s = clone.writeLock();
    assertTrue(clone.isWriteLocked());
    clone.unlockWrite(s);
    assertFalse(clone.isWriteLocked());
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * toString indicates current lock state
 */
public void testToString() {
    StampedLock lock = new StampedLock();
    assertTrue(lock.toString().contains("Unlocked"));
    long s = lock.writeLock();
    assertTrue(lock.toString().contains("Write-locked"));
    lock.unlockWrite(s);
    s = lock.readLock();
    assertTrue(lock.toString().contains("Read-locks"));
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * tryOptimisticRead stamp does not validate if a write lock intervenes
 */
public void testValidateOptimisticWriteLocked() {
    final StampedLock lock = new StampedLock();
    final long p = assertValid(lock, lock.tryOptimisticRead());
    final long s = assertValid(lock, lock.writeLock());
    assertFalse(lock.validate(p));
    assertEquals(0L, lock.tryOptimisticRead());
    assertTrue(lock.validate(s));
    lock.unlockWrite(s);
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * write-unlocking an unlocked lock throws IllegalMonitorStateException
 */
public void testWriteUnlock_IMSE() {
    StampedLock lock = new StampedLock();
    try {
        lock.unlockWrite(0L);
        shouldThrow();
    } catch (IllegalMonitorStateException success) {}
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * write-unlocking an unlocked lock throws IllegalMonitorStateException
 */
public void testWriteUnlock_IMSE2() {
    StampedLock lock = new StampedLock();
    long s = lock.writeLock();
    lock.unlockWrite(s);
    try {
        lock.unlockWrite(s);
        shouldThrow();
    } catch (IllegalMonitorStateException success) {}
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * write-unlocking after readlock throws IllegalMonitorStateException
 */
public void testWriteUnlock_IMSE3() {
    StampedLock lock = new StampedLock();
    long s = lock.readLock();
    try {
        lock.unlockWrite(s);
        shouldThrow();
    } catch (IllegalMonitorStateException success) {}
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * A stamp obtained from an unsuccessful lock operation does not validate
 */
public void testValidate2() throws InterruptedException {
    StampedLock lock = new StampedLock();
    long s;
    assertTrue((s = lock.writeLock()) != 0L);
    assertTrue(lock.validate(s));
    assertFalse(lock.validate(lock.tryWriteLock()));
    assertFalse(lock.validate(lock.tryWriteLock(10L, MILLISECONDS)));
    assertFalse(lock.validate(lock.tryReadLock()));
    assertFalse(lock.validate(lock.tryReadLock(10L, MILLISECONDS)));
    assertFalse(lock.validate(lock.tryOptimisticRead()));
    lock.unlockWrite(s);
}
 

import java.util.concurrent.locks.StampedLock; //导入方法依赖的package包/类
/**
 * tryOptimisticRead succeeds and validates if unlocked, fails if locked
 */
public void testValidateOptimistic() throws InterruptedException {
    StampedLock lock = new StampedLock();
    long s, p;
    assertTrue((p = lock.tryOptimisticRead()) != 0L);
    assertTrue(lock.validate(p));
    assertTrue((s = lock.writeLock()) != 0L);
    assertFalse((p = lock.tryOptimisticRead()) != 0L);
    assertTrue(lock.validate(s));
    lock.unlockWrite(s);
    assertTrue((p = lock.tryOptimisticRead()) != 0L);
    assertTrue(lock.validate(p));
    assertTrue((s = lock.readLock()) != 0L);
    assertTrue(lock.validate(s));
    assertTrue((p = lock.tryOptimisticRead()) != 0L);
    assertTrue(lock.validate(p));
    lock.unlockRead(s);
    assertTrue((s = lock.tryWriteLock()) != 0L);
    assertTrue(lock.validate(s));
    assertFalse((p = lock.tryOptimisticRead()) != 0L);
    lock.unlockWrite(s);
    assertTrue((s = lock.tryReadLock()) != 0L);
    assertTrue(lock.validate(s));
    assertTrue((p = lock.tryOptimisticRead()) != 0L);
    lock.unlockRead(s);
    assertTrue(lock.validate(p));
    assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
    assertFalse((p = lock.tryOptimisticRead()) != 0L);
    assertTrue(lock.validate(s));
    lock.unlockWrite(s);
    assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
    assertTrue(lock.validate(s));
    assertTrue((p = lock.tryOptimisticRead()) != 0L);
    lock.unlockRead(s);
    assertTrue((p = lock.tryOptimisticRead()) != 0L);
}