Java多線程進階—— J.U.C之locks架構：StampedLock

一、StampedLock類簡介

StampedLock類，在JDK1.8時引入，是對讀寫鎖ReentrantReadWriteLock的增強，該類提供了一些功能，優化了讀鎖、寫鎖的通路，同時使讀寫鎖之間可以互相轉換，更細粒度控制并發。

首先明确下，該類的設計初衷是作為一個内部工具類，用于輔助開發其它線程安全元件，用得好，該類可以提升系統性能，用不好，容易産生死鎖和其它莫名其妙的問題。

1.1 StampedLock的引入

先來看下，為什麼有了ReentrantReadWriteLock，還要引入StampedLock？

ReentrantReadWriteLock使得多個讀線程同時持有讀鎖（隻要寫鎖未被占用），而寫鎖是獨占的。

但是，讀寫鎖如果使用不當，很容易産生“饑餓”問題：

比如在讀線程非常多，寫線程很少的情況下，很容易導緻寫線程“饑餓”，雖然使用“公平”政策可以一定程度上緩解這個問題，但是“公平”政策是以犧牲系統吞吐量為代價的。（在ReentrantLock類的介紹章節中，介紹過這種情況）

1.2 StampedLock的特點

StampedLock的主要特點概括一下，有以下幾點：

所有擷取鎖的方法，都傳回一個郵戳（Stamp），Stamp為0表示擷取失敗，其餘都表示成功；
所有釋放鎖的方法，都需要一個郵戳（Stamp），這個Stamp必須是和成功擷取鎖時得到的Stamp一緻；
StampedLock是不可重入的；（如果一個線程已經持有了寫鎖，再去擷取寫鎖的話就會造成死鎖）
StampedLock有三種通路模式：

①Reading（讀模式）：功能和ReentrantReadWriteLock的讀鎖類似

②Writing（寫模式）：功能和ReentrantReadWriteLock的寫鎖類似

③Optimistic reading（樂觀讀模式）：這是一種優化的讀模式。
StampedLock支援讀鎖和寫鎖的互相轉換

我們知道RRW中，當線程擷取到寫鎖後，可以降級為讀鎖，但是讀鎖是不能直接更新為寫鎖的。

StampedLock提供了讀鎖和寫鎖互相轉換的功能，使得該類支援更多的應用場景。
無論寫鎖還是讀鎖，都不支援Conditon等待

我們知道，在ReentrantReadWriteLock中，當讀鎖被使用時，如果有線程嘗試擷取寫鎖，該寫線程會阻塞。

但是，在Optimistic reading中，即使讀線程擷取到了讀鎖，寫線程嘗試擷取寫鎖也不會阻塞，這相當于對讀模式的優化，但是可能會導緻資料不一緻的問題。是以，當使用Optimistic reading擷取到讀鎖時，必須對擷取結果進行校驗。

二、StampedLock使用示例

先來看一個Oracle官方的例子：

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

    void move(double deltaX, double deltaY) {
        long stamp = sl.writeLock();    //涉及對共享資源的修改，使用寫鎖-獨占操作
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    /**
     * 使用樂觀讀鎖通路共享資源
     * 注意：樂觀讀鎖在保證資料一緻性上需要拷貝一份要操作的變量到方法棧，并且在操作資料時候可能其他寫線程已經修改了資料，
     * 而我們操作的是方法棧裡面的資料，也就是一個快照，是以最多傳回的不是最新的資料，但是一緻性還是得到保障的。
     *
     * @return
     */
    double distanceFromOrigin() {
        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);
        }
    }
}

可以看到，上述示例最特殊的其實是distanceFromOrigin方法，這個方法中使用了“Optimistic reading”樂觀讀鎖，使得讀寫可以并發執行，但是“Optimistic reading”的使用必須遵循以下模式：

long stamp = lock.tryOptimisticRead();  // 非阻塞擷取版本資訊
copyVaraibale2ThreadMemory();           // 拷貝變量到線程本地堆棧
if(!lock.validate(stamp)){              // 校驗
    long stamp = lock.readLock();       // 擷取讀鎖
    try {
        copyVaraibale2ThreadMemory();   // 拷貝變量到線程本地堆棧
     } finally {
       lock.unlock(stamp);              // 釋放悲觀鎖
    }

}
useThreadMemoryVarables();              // 使用線程本地堆棧裡面的資料進行操作

三、StampedLock原理