多线程八 Lock （二）

public long tryOptimisticRead() {...}

/**
     * Exclusively acquires the lock, blocking if necessary
     * until available.
     *
     * @return a stamp that can be used to unlock or convert mode
     */
    public long writeLock() {
        long s, next;  // bypass acquireWrite in fully unlocked case only
        return ((((s = state) & ABITS) == 0L &&
                 U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?
                next : acquireWrite(false, 0L));
    }

//一旦写锁可用立即获取,返回值可以用作释放锁或被锁的转换使用, 0表示没有获取到锁
     /**
     * Exclusively acquires the lock if it is immediately available.
     *
     * @return a stamp that can be used to unlock or convert mode,
     * or zero if the lock is not available
     */
    public long tryWriteLock() {
        long s, next;
        return ((((s = state) & ABITS) == 0L &&
                 U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?
                next : 0L);
    }
    //延迟获取锁
         /**
     * Exclusively acquires the lock if it is available within the
     * given time and the current thread has not been interrupted.
     * Behavior under timeout and interruption matches that specified
     * for method {@link Lock#tryLock(long,TimeUnit)}.
     *
     * @param time the maximum time to wait for the lock
     * @param unit the time unit of the {@code time} argument
     * @return a stamp that can be used to unlock or convert mode,
     * or zero if the lock is not available
     * @throws InterruptedException if the current thread is interrupted
     * before acquiring the lock
     */
    public long tryWriteLock(long time, TimeUnit unit)
    ...
    // 非独占的获取读锁
      /**
     * Non-exclusively acquires the lock, blocking if necessary
     * until available.
     *
     * @return a stamp that can be used to unlock or convert mode
     */
    public long readLock() {
        long s = state, next;  // bypass acquireRead on common uncontended case
        return ((whead == wtail && (s & ABITS) < RFULL &&
                 U.compareAndSwapLong(this, STATE, s, next = s + RUNIT)) ?
                next : acquireRead(false, 0L));
    }
    // 一旦锁可用,立即非独占的获取读锁
    /**
     * Non-exclusively acquires the lock if it is immediately available.
     *
     * @return a stamp that can be used to unlock or convert mode,
     * or zero if the lock is not available
     */
    public long tryReadLock() {
        for (;;) {
            long s, m, next;
            if ((m = (s = state) & ABITS) == WBIT)
                return 0L;
            else if (m < RFULL) {
                if (U.compareAndSwapLong(this, STATE, s, next = s + RUNIT))
                    return next;
            }
            else if ((next = tryIncReaderOverflow(s)) != 0L)
                return next;
        }
    }

/**
     * Returns a stamp that can later be validated, or zero
     * if exclusively locked.
     *
     * @return a stamp, or zero if exclusively locked
     */
    public long tryOptimisticRead() {
        long s;
        return (((s = state) & WBIT) == 0L) ? (s & SBITS) : 0L;
    }

/**
     * Returns true if the lock has not been exclusively acquired
     * since issuance of the given stamp. Always returns false if the
     * stamp is zero. Always returns true if the stamp represents a
     * currently held lock. Invoking this method with a value not
     * obtained from {@link #tryOptimisticRead} or a locking method
     * for this lock has no defined effect or result.
     *
     * @param stamp a stamp
     * @return {@code true} if the lock has not been exclusively acquired
     * since issuance of the given stamp; else false
     */
    public boolean validate(long stamp) {
        U.loadFence();
        return (stamp & SBITS) == (state & SBITS);
    }

/**
     * If the lock state matches the given stamp, releases the
     * exclusive lock.
     *
     * @param stamp a stamp returned by a write-lock operation
     * @throws IllegalMonitorStateException if the stamp does
     * not match the current state of this lock
     */
    public void unlockWrite(long stamp) {
        WNode h;
        if (state != stamp || (stamp & WBIT) == 0L)
            throw new IllegalMonitorStateException();
        state = (stamp += WBIT) == 0L ? ORIGIN : stamp;
        if ((h = whead) != null && h.status != 0)
            release(h);
    }
  //释放任意匹配成功的锁
    /**
     * If the lock state matches the given stamp, releases the
     * corresponding mode of the lock.
     *
     * @param stamp a stamp returned by a lock operation
     * @throws IllegalMonitorStateException if the stamp does
     * not match the current state of this lock
     */
    public void unlock(long stamp) {

public long tryConvertToWriteLock(long stamp) {
     ..}
      public long tryConvertToWriteLock(long stamp) {
    ..}
    //释放读锁
    public void unlockRead(long stamp) {..}
    //释放写锁
    public void unlockWrite(long stamp) {..}

/*
* StampedLock的简单使用
* */
public class StampedLock01 {
private  int balance;
StampedLock stamptedLock = new StampedLock();
//悲观读
public void read(){
    long s = stamptedLock.readLock();
try{
    try {
        System.out.println("拿到读锁"+Thread.currentThread().getName()+System.currentTimeMillis());
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}finally {
    stamptedLock.unlockRead(s);
}
}
// 乐观锁
public void OptimismRead(){
    //获取乐观锁,拿到 标记
    long stm = stamptedLock.tryOptimisticRead();
    try {
        System.out.println("一开始读取到的balance=="+balance);
        //方便测试     睡一会
        Thread.sleep(200);
        // 在读的时候,可能会出现现写操作-- 判断
        if(!stamptedLock.validate(stm)){  //1 锁空闲可用  2 拥有当前stm的线程获取到锁,返回true  其他返回false
            //重新读取
            long l = stamptedLock.readLock();
            System.out.println("乐观锁中发现了在读时,发现写操作,重新读结果为:  "+balance);
            // 更新标记, 用于锁的释放
            stm=l;
        }
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        //释放锁
        stamptedLock.unlockRead(stm);
    }
}
// 带条件的读写锁
public void MyConditionReadWriteLock(int v){
    //判断balance是否符合更新的条件
    long stm = stamptedLock.readLock();
    try{
        // 为什么不会if  而用while
        while(stm>0){
            //转换成写锁;
            long s1 = stamptedLock.tryConvertToWriteLock(stm);
            if (s1!=0){// 成功转换
                balance+=v;
                System.out.println("进行写操作:  balance=="+balance+99);
                stm=s1;
                break;
            }else{  //没有转换成功
                //释放读锁
                stamptedLock.unlockRead(stm);
                // 获取写
                long s2 = stamptedLock.writeLock();
                stm=s2;
                System.out.println("手动获取写锁...");
            }
        }
    }finally {
        stamptedLock.unlock(stm);
    }
}
//独占的写
public void write(int v){
        long stamp = stamptedLock.writeLock();
        try{
            balance+=v;
            System.out.println("进行写的操作...结果:  "+balance+"  "+Thread.currentThread().getName()+"  "+"write中的标记为:"+stamp);
            Thread.sleep(2000);
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            stamptedLock.unlockWrite(stamp);
        }
}
public static void main(String[] args) {
    StampedLock01 stampedLock01 = new StampedLock01();
    //测试普通的read  // 测试成功 异步执行
    //测试独占的写  成功
/*       new Thread(()->{
        // 乐观读
        stampedLock01.OptimismRead();
    }).start();
    new Thread(()->{
        stampedLock01.write(3);
    }).start();
*/
    new Thread(()->{
        stampedLock01.MyConditionReadWriteLock(1);
    }).start();
}
}