class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();

    // 多個(gè)線程調(diào)用該方法，修改x和y的值
    void move(double deltaX, double deltaY) {
       long stamp = sl.writeLock();    // 獲取寫鎖
       try {
          x += deltaX;
          y += deltaY;
       } finally {
          sl.unlockWrite(stamp);       // 釋放寫鎖
       }
   }

   // 多個(gè)線程調(diào)用該方法，求距離
   double distenceFromOrigin() {

       // 樂觀讀
       long stamp = sl.tryOptimisticRead();
       // 將共享變量拷貝到線程棧, 讀：將一份數(shù)據(jù)拷貝到線程的棧內(nèi)存中

       double currentX = x, currentY = y;
       // 讀期間有其他線程修改數(shù)據(jù), 讀取后，對比讀之前的版本號和當(dāng)前的版本號，判斷數(shù)據(jù)是否可用
            // 根據(jù)stamp判斷在讀取數(shù)據(jù)和使用數(shù)據(jù)期間，有沒有其他線程修改數(shù)據(jù)
       if (!sl.validate(stamp)) {
          // 讀到的是臟數(shù)據(jù)，丟棄.重新使用悲觀讀
          stamp = sl.readLock();
          try {
             currentX = x;
             currentY = y;
          } finally {
             sl.unlockRead(stamp);
          }
       }
       return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

public boolean validate(long stamp) {
      VarHandle.acquireFence();
      return (stamp & SBITS) == (state & SBITS);
    }

public class StampedLockDemo {
    static int number = 37;
    static StampedLock stampedLock = new StampedLock();
    public void write() {
        long stamp = stampedLock.writeLock();
        System.out.println(Thread.currentThread().getName()+"\t"+"寫線程準(zhǔn)備修改");
        try {
            number = number + 13;
        }finally {
            stampedLock.unlockWrite(stamp);
        }
        System.out.println(Thread.currentThread().getName()+"\t"+"寫線程結(jié)束修改");
    }
    //悲觀讀，讀沒有完成時(shí)候?qū)戞i無法獲得鎖
    public void read() {
        long stamp = stampedLock.readLock();
        System.out.println(Thread.currentThread().getName()+"\t"+" come in readlock code block，4 seconds continue...");
        for (int i = 0; i < 4; i++) {
            // 暫停幾秒鐘線程
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+" 正在讀取中......");
        }
        try {
            int result = number;
            System.out.println(Thread.currentThread().getName()+"\t"+" 獲得成員變量值result："+result);
            System.out.println("寫線程沒有修改成功，讀鎖時(shí)候?qū)戞i無法介入，傳統(tǒng)的讀寫互斥");
        }finally {
            stampedLock.unlockRead(stamp);
        }
    }
    // 樂觀讀，讀的過程中也允許獲取寫鎖介入
    public void tryOptimisticRead() {
        long stamp = stampedLock.tryOptimisticRead();
        int result = number;
        // 故意間隔4秒鐘，很樂觀認(rèn)為讀取中沒有其它線程修改過number值，具體靠判斷
        System.out.println("4秒前stampedLock.validate方法值(true無修改，false有修改)"+"\t"+stampedLock.validate(stamp));
        for (int i = 0; i < 4; i++) {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+"正在讀取... "+i+" 秒" +
                    "后stampedLock.validate方法值(true無修改，false有修改)"+"\t"+stampedLock.validate(stamp));
        }
        if(!stampedLock.validate(stamp)) {
            System.out.println("有人修改過------有寫操作");
            stamp = stampedLock.readLock();
            try {
                System.out.println("從樂觀讀 升級為 悲觀讀");
                result = number;
                System.out.println("重新悲觀讀后result："+result);
            }finally {
                stampedLock.unlockRead(stamp);
            }
        }
        System.out.println(Thread.currentThread().getName()+"\t"+" finally value: "+result);
    }
    public static void main(String[] args) {
        StampedLockDemo resource = new StampedLockDemo();
        /* 傳統(tǒng)版
        new Thread(() -> {
            resource.read();
        },"readThread").start();
        //暫停幾秒鐘線程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t"+"----come in");
            resource.write();
        },"writeThread").start();
        //暫停幾秒鐘線程
        try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println(Thread.currentThread().getName()+"\t"+"number:" +number);*/
        new Thread(() -> {
            resource.tryOptimisticRead();
        },"readThread").start();
        // 暫停2秒鐘線程,讀過程可以寫介入，演示
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
        // 暫停6秒鐘線程
        // try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t"+"----come in");
            resource.write();
        },"writeThread").start();
    }
}

public class StampedLock implements java.io.Serializable {
       private static final int LG_READERS = 7;
       private static final long RUNIT = 1L;
       private static final long WBIT = 1L << LG_READERS; // 第8位表示寫鎖
       private static final long RBITS = WBIT - 1L; // 最低的7位表示讀鎖
       private static final long RFULL = RBITS - 1L; // 讀鎖的數(shù)目
       private static final long ABITS = RBITS | WBIT; // 讀鎖和寫鎖狀態(tài)合二為一
       private static final long SBITS = ~RBITS;
       private static final long ORIGIN = WBIT << 1; // state的初始值
       private transient volatile long state;
    }