StampedLock (Java Platform SE 8 )

java.lang.Object
- java.util.concurrent.locks.StampedLock

All Implemented Interfaces:

Serializable
```
public class StampedLock
extends Object
implements Serializable
```
一种基于能力的锁的三种控制读/写访问模式。一个stampedlock状态由一个版本和模式。锁定捕获方法返回表示和控制访问相对于锁状态的标记；“尝试”版本的这些方法可能会返回特殊的值为零，以表示未能获得访问权限。锁定释放和转换方法需要将这些参数作为参数，如果它们不匹配锁的状态，将失败。三种模式是：
- 写作。方法writeLock()可能等待独家访问，返回一个邮票，可以用在方法unlockWrite(long)释放锁。还提供了tryWriteLock不计时和计时的版本。当锁是在写模式，没有读锁可以得到，所有乐观读取验证将失败。
- 阅读。方法readLock()可能等待非独家访问，返回一个邮票，可以用在方法unlockRead(long)释放锁。不计时和计时还提供版本tryReadLock。
- 乐观。方法tryOptimisticRead()返回非零的邮票只有锁不目前关押在写模式。方法validate(long)返回true如果锁尚未获得在写模式由于获得一个给定的邮票。这种模式可以被认为是一个非常弱版本的读锁，可以打破一个作家在任何时间。使用乐观模式的短只读代码段经常减少争用，提高吞吐量。然而，它的使用本质上是脆弱的。乐观的阅读部分应该只读取字段，并将它们保持在本地变量中，以供验证后使用。而在乐观的领域阅读模式可能非常不一致，所以使用仅适用于当你足够熟悉数据表示的一致性检查和/或多次调用方法validate()。例如，这些步骤通常是在第一次阅读的对象或数组引用，然后访问它的一个领域，元素或方法。
该类还支持有条件地提供三种模式的转换的方法。例如，方法tryConvertToWriteLock(long)试图“升级”模式，返回一个有效的写邮票如果（1）已经在写作模式（2）阅读模式并没有其他读者或（3）在乐观的模式和锁可用。这些方法的形式是为了帮助减少一些代码膨胀，否则发生在重试的基础设计。

stampedlocks设计用于在线程安全的组件开发的内部设施。他们的使用依赖于知识的数据，对象和方法，他们正在保护的内部属性。他们是不可重入的，所以锁定机构不应调用其他未知的方法，可以尝试重新获取锁（尽管你可以通过邮票的其他的方法，可以使用或转换）。读锁模式的使用依赖于相关的代码部分，该部分是无副作用的。未经验证的乐观的阅读部分不能调用的方法不被容忍的潜在矛盾。邮票使用有限的陈述，而不是加密的安全（例如，一个有效的邮票可以被猜到的）。邮票值可以回收（不比）一年连续运行。没有使用或验证的邮票，比这一时期更长的时间可能无法正确验证。stampedlocks是可序列化的，但总是反序列化为初始解锁状态，所以他们不用于远程锁定。

对stampedlock调度政策不一贯喜欢读者对作家或反之亦然。所有“尝试”的方法是最好的努力，不一定符合任何调度或公平的政策。一零返回从任何“尝试”的方法获取或转换锁不携带任何关于锁的状态的信息，随后的调用可能会成功。

因为它支持协调使用跨多个锁模式，这类不直接实现Lock或ReadWriteLock接口。然而，一个stampedlock可以视asReadLock()，asWriteLock()，或asReadWriteLock()在只需要相关的功能的应用。

示例用法。以下说明一类，保持简单的二维点的一些用法的成语。示例代码说明了一些try/catch公约虽然它们不是严格需要在这里因为没有例外可以在他们的bodies.
发生
```
 class Point {
   private double x, y;
   private final StampedLock sl = new StampedLock();

   void move(double deltaX, double deltaY) { // an exclusively locked method
     long stamp = sl.writeLock();
     try {
       x += deltaX;
       y += deltaY;
     } finally {
       sl.unlockWrite(stamp);
     }
   }

   double distanceFromOrigin() { // A read-only method
     long stamp = sl.tryOptimisticRead();
     double currentX = x, currentY = y;
     if (!sl.validate(stamp)) {
        stamp = sl.readLock();
        try {
          currentX = x;
          currentY = y;
        } finally {
           sl.unlockRead(stamp);
        }
     }
     return Math.sqrt(currentX * currentX + currentY * currentY);
   }

   void moveIfAtOrigin(double newX, double newY) { // upgrade
     // Could instead start with optimistic, not read mode
     long stamp = sl.readLock();
     try {
       while (x == 0.0 && y == 0.0) {
         long ws = sl.tryConvertToWriteLock(stamp);
         if (ws != 0L) {
           stamp = ws;
           x = newX;
           y = newY;
           break;
         }
         else {
           sl.unlockRead(stamp);
           stamp = sl.writeLock();
         }
       }
     } finally {
       sl.unlock(stamp);
     }
   }
 }
```
从以下版本开始：

一点八

另请参见：

Serialized Form

构造方法摘要

构造方法
Constructor and Description
`StampedLock()` 创建一个新的锁，最初处于解锁状态。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`Lock`	`asReadLock()` 返回本stampedlock， `Lock.lock()`方法映射到 `readLock()`平原 `Lock`视图，和类似的其他方法。
`ReadWriteLock`	`asReadWriteLock()` 返回该stampedlock， `ReadWriteLock.readLock()`方法映射到一个 `ReadWriteLock` `asReadLock()`来看，和 `ReadWriteLock.writeLock()`到 `asWriteLock()`。
`Lock`	`asWriteLock()` 返回本stampedlock， `Lock.lock()`方法映射到 `writeLock()`平原 `Lock`视图，和类似的其他方法。
`int`	`getReadLockCount()` 查询此锁的读取锁的数量。
`boolean`	`isReadLocked()` 返回 `true`如果锁是目前持有的非专。
`boolean`	`isWriteLocked()` 返回 `true`如果锁是目前独家持有。
`long`	`readLock()` 非独占获取锁，阻塞，如果必要的，直到可用。
`long`	`readLockInterruptibly()` 非独占获取锁，如果必要，阻塞，直到可用或当前线程被中断。
`String`	`toString()` 返回一个确定此锁的字符串，以及它的锁状态。
`long`	`tryConvertToOptimisticRead(long stamp)` 如果锁定状态与给定的标记相匹配，则如果该标记表示持有锁，则释放它并返回一个观察标记。
`long`	`tryConvertToReadLock(long stamp)` 如果锁状态与给定的标记相匹配，将执行下列操作之一。
`long`	`tryConvertToWriteLock(long stamp)` 如果锁状态与给定的标记相匹配，将执行下列操作之一。
`long`	`tryOptimisticRead()` 返回一个可以验证的邮票，或完全锁定的零。
`long`	`tryReadLock()` 非独占获取锁，如果它是立即可用。
`long`	`tryReadLock(long time, TimeUnit unit)` 非独占获取锁，如果它是在给定的时间内可用，当前线程没有被中断。
`boolean`	`tryUnlockRead()` 释放一个保持读锁，如果它举行，而不需要一个邮票值。
`boolean`	`tryUnlockWrite()` 释放写锁，如果它被保持，而不需要一个标记值。
`long`	`tryWriteLock()` 只获取锁，如果它立即可用。
`long`	`tryWriteLock(long time, TimeUnit unit)` 只获取锁，如果它是在给定的时间内可用，当前线程没有被中断。
`void`	`unlock(long stamp)` 如果锁状态与给定的标记相匹配，将释放该锁的相应模式。
`void`	`unlockRead(long stamp)` 如果锁状态与给定的标记相匹配，将释放非互斥锁。
`void`	`unlockWrite(long stamp)` 如果锁状态与给定的标记相匹配，将释放互斥锁。
`boolean`	`validate(long stamp)` 如果从给定的给定标记的发行以来未完全获得锁定，则返回真。
`long`	`writeLock()` 只获取锁，阻塞，如果有必要，直到可用。
`long`	`writeLockInterruptibly()` 只获取锁，如果必要，阻塞，直到可用或当前线程被中断。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - StampedLock
```
public StampedLock()
```
    创建一个新的锁，最初处于解锁状态。
- 方法详细信息
  - writeLock
```
public long writeLock()
```
    只获取锁，阻塞，如果有必要，直到可用。
    
    结果
    
    可以用来解锁或转换模式的一种邮票
  - tryWriteLock
```
public long tryWriteLock()
```
    只获取锁，如果它立即可用。
    
    结果
    
    一个可以用来解锁或转换模式的邮票，或零，如果锁不可用
  - tryWriteLock
```
public long tryWriteLock(long time,
                         TimeUnit unit)
                  throws InterruptedException
```
    只获取锁，如果它是在给定的时间内可用，当前线程没有被中断。行为在超时和中断比赛， Lock.tryLock(long,TimeUnit)指定方法。
    
    参数
    
    time -最大时间等待锁
    
    unit的 time争论的时间单位
    
    结果
    
    一个可以用来解锁或转换模式的邮票，或零，如果锁不可用
    
    异常
    
    InterruptedException -如果当前线程在获取锁中断
  - writeLockInterruptibly
```
public long writeLockInterruptibly()
                            throws InterruptedException
```
    只获取锁，如果必要，阻塞，直到可用或当前线程被中断。中断比赛， Lock.lockInterruptibly()指定行为的方法。
    
    结果
    
    可以用来解锁或转换模式的一种邮票
    
    异常
    
    InterruptedException -如果当前线程在获取锁中断
  - readLock
```
public long readLock()
```
    非独占获取锁，阻塞，如果必要的，直到可用。
    
    结果
    
    可以用来解锁或转换模式的一种邮票
  - tryReadLock
```
public long tryReadLock()
```
    非独占获取锁，如果它是立即可用。
    
    结果
    
    一个可以用来解锁或转换模式的邮票，或零，如果锁不可用
  - tryReadLock
```
public long tryReadLock(long time,
                        TimeUnit unit)
                 throws InterruptedException
```
    非独占获取锁，如果它是在给定的时间内可用，当前线程没有被中断。行为在超时和中断比赛， Lock.tryLock(long,TimeUnit)指定方法。
    
    参数
    
    time -最大时间等待锁
    
    unit的 time争论的时间单位
    
    结果
    
    一个可以用来解锁或转换模式的邮票，或零，如果锁不可用
    
    异常
    
    InterruptedException -如果当前线程在获取锁中断
  - readLockInterruptibly
```
public long readLockInterruptibly()
                           throws InterruptedException
```
    非独占获取锁，如果必要，阻塞，直到可用或当前线程被中断。中断比赛， Lock.lockInterruptibly()指定行为的方法。
    
    结果
    
    可以用来解锁或转换模式的一种邮票
    
    异常
    
    InterruptedException -如果当前线程在获取锁中断
  - tryOptimisticRead
```
public long tryOptimisticRead()
```
    返回一个可以验证的邮票，或完全锁定的零。
    
    结果
    
    一枚邮票，或零，如果完全锁定
  - validate
```
public boolean validate(long stamp)
```
    如果从给定的给定标记的发行以来未完全获得锁定，则返回真。总是返回假，如果邮票是零。如果该标记表示当前保持的锁，则返回真。调用这个方法不是从 tryOptimisticRead()或锁定方法对该锁获得的值没有定义的效果或结果。
    
    参数
    
    stamp -邮票
    
    结果
    
    true如果锁还没有完全获得从给定的邮票发行；其他虚假
  - unlockWrite
```
public void unlockWrite(long stamp)
```
    如果锁状态与给定的标记相匹配，将释放互斥锁。
    
    参数
    
    stamp -邮票返回一个写锁操作
    
    异常
    
    IllegalMonitorStateException如果标记不符合这个锁的当前状态
  - unlockRead
```
public void unlockRead(long stamp)
```
    如果锁状态与给定的标记相匹配，将释放非互斥锁。
    
    参数
    
    stamp -邮票返回读取锁定操作
    
    异常
    
    IllegalMonitorStateException如果标记不符合这个锁的当前状态
  - unlock
```
public void unlock(long stamp)
```
    如果锁状态与给定的标记相匹配，将释放该锁的相应模式。
    
    参数
    
    stamp -邮票由锁操作
    
    异常
    
    IllegalMonitorStateException如果标记不符合这个锁的当前状态
  - tryConvertToWriteLock
```
public long tryConvertToWriteLock(long stamp)
```
    如果锁状态与给定的标记相匹配，将执行下列操作之一。如果印章代表持有写锁，则返回它。或者，如果一个读锁，如果写锁是可用的，释放读锁，并返回一个写邮票。或者，如果一个乐观的阅读，返回一个写邮票，如果立即可用。这种方法在所有其他情况下返回零。
    
    参数
    
    stamp -邮票
    
    结果
    
    一个有效的写戳，或零故障
  - tryConvertToReadLock
```
public long tryConvertToReadLock(long stamp)
```
    如果锁状态与给定的标记相匹配，将执行下列操作之一。如果该印章代表持有写锁，释放它，并获得一个读锁。或者，如果一个读锁，返回它。或者，如果一个乐观的阅读，获得一个读锁，并返回一个读邮票，只有立即可用。这种方法在所有其他情况下返回零。
    
    参数
    
    stamp -邮票
    
    结果
    
    一个有效的读取标记，或在失败上为零
  - tryConvertToOptimisticRead
```
public long tryConvertToOptimisticRead(long stamp)
```
    如果锁定状态与给定的标记相匹配，则如果该标记表示持有锁，则释放它并返回一个观察标记。或者，如果一个乐观的阅读，返回它，如果验证。此方法返回零在所有其他情况下，所以可能是有用的作为一种形式的“tryunlock”。
    
    参数
    
    stamp -邮票
    
    结果
    
    一个有效的乐观读邮票，或零故障
  - tryUnlockWrite
```
public boolean tryUnlockWrite()
```
    释放写锁，如果它被保持，而不需要一个标记值。这种方法可能是有用的错误后的恢复。
    
    结果
    
    true如果锁举行，其他假
  - tryUnlockRead
```
public boolean tryUnlockRead()
```
    释放一个保持读锁，如果它举行，而不需要一个邮票值。这种方法可能是有用的错误后的恢复。
    
    结果
    
    true如果读锁举行，其他假
  - isWriteLocked
```
public boolean isWriteLocked()
```
    返回 true如果锁是目前独家持有。
    
    结果
    
    true如果锁是目前独家持有
  - isReadLocked
```
public boolean isReadLocked()
```
    返回 true如果锁是目前持有的非专。
    
    结果
    
    true如果锁是目前持有的非专
  - getReadLockCount
```
public int getReadLockCount()
```
    查询此锁的读取锁的数量。这种方法是专为在监控系统状态下使用的，不是用于同步控制的。
    
    结果
    
    举行的读锁的数量
  - toString
```
public String toString()
```
    返回一个确定此锁的字符串，以及它的锁状态。括号内的状态，包括字符串 "Unlocked"或字符串或字符串 "Write-locked" "Read-locks:"后跟当前数读锁。
    
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    确定该锁的字符串，以及它的锁状态
  - asReadLock
```
public Lock asReadLock()
```
    返回本stampedlock， Lock.lock()方法映射到 readLock()平原 Lock视图，和类似的其他方法。返回的锁不支持 Condition；方法 Lock.newCondition()抛出 UnsupportedOperationException。
    
    结果
    
    锁
  - asWriteLock
```
public Lock asWriteLock()
```
    返回本stampedlock， Lock.lock()方法映射到 writeLock()平原 Lock视图，和类似的其他方法。返回的锁不支持 Condition；方法 Lock.newCondition()抛出 UnsupportedOperationException。
    
    结果
    
    锁
  - asReadWriteLock
```
public ReadWriteLock asReadWriteLock()
```
    返回该stampedlock， ReadWriteLock.readLock()方法映射到一个 ReadWriteLock asReadLock()来看，和 ReadWriteLock.writeLock()到 asWriteLock()。
    
    结果
    
    锁

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class StampedLock

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Constructor Detail

StampedLock

方法详细信息

writeLock

tryWriteLock

tryWriteLock

writeLockInterruptibly

readLock

tryReadLock

tryReadLock

readLockInterruptibly

tryOptimisticRead

validate

unlockWrite

unlockRead

unlock

tryConvertToWriteLock

tryConvertToReadLock

tryConvertToOptimisticRead

tryUnlockWrite

tryUnlockRead

isWriteLocked

isReadLocked

getReadLockCount

toString

asReadLock

asWriteLock

asReadWriteLock