import java.util.concurrent.atomic.AtomicReference;
/**
 * 簡單的自旋鎖實現(xiàn)
 * 核心：利用AtomicReference的CAS操作保證鎖的原子性競爭
 */
public class SimpleSpinLock {
    // 用AtomicReference存儲持有鎖的線程，初始為null（無鎖狀態(tài)）
    private final AtomicReference<Thread> lockOwner = new AtomicReference<>();
    // 獲取鎖（自旋邏輯）
    public void lock() {
        Thread currentThread = Thread.currentThread();
        // 自旋：CAS嘗試將lockOwner從null改為當(dāng)前線程，失敗則循環(huán)重試
        while (!lockOwner.compareAndSet(null, currentThread)) {
            // 空循環(huán)（自旋），也可以加入自旋次數(shù)限制、yield()等優(yōu)化
            // Thread.yield(); // 讓出CPU，減少空轉(zhuǎn)消耗
        }
        System.out.println(currentThread.getName() + " 獲取到鎖");
    }
    // 釋放鎖
    public void unlock() {
        Thread currentThread = Thread.currentThread();
        // 只有持有鎖的線程才能釋放鎖
        if (lockOwner.get() == currentThread) {
            lockOwner.compareAndSet(currentThread, null);
            System.out.println(currentThread.getName() + " 釋放了鎖");
        } else {
            throw new IllegalMonitorStateException("當(dāng)前線程未持有鎖，無法釋放");
        }
    }
    // 測試自旋鎖
    public static void main(String[] args) {
        SimpleSpinLock spinLock = new SimpleSpinLock();
        // 創(chuàng)建5個線程競爭鎖
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    spinLock.lock();
                    // 模擬持有鎖的短時間操作（自旋鎖適合短任務(wù)）
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    spinLock.unlock();
                }
            }, "線程" + i).start();
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
 * 基于讀寫鎖實現(xiàn)的線程安全緩存
 * 場景：多讀少寫，讀操作并行，寫操作獨占
 */
public class ReadWriteLockCache {
    // 緩存容器
    private final Map<String, Object> cache = new HashMap<>();
    // 讀寫鎖（默認非公平模式）
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    // 讀鎖（共享鎖）
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    // 寫鎖（排他鎖）
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
    // 從緩存讀取數(shù)據(jù)（讀操作，用讀鎖）
    public Object get(String key) {
        // 獲取讀鎖
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 讀取緩存，key=" + key);
            // 模擬讀操作耗時
            Thread.sleep(100);
            return cache.get(key);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        } finally {
            // 釋放讀鎖（必須在finally中釋放，避免鎖泄漏）
            readLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 釋放讀鎖");
        }
    }
    // 向緩存寫入數(shù)據(jù)（寫操作，用寫鎖）
    public void put(String key, Object value) {
        // 獲取寫鎖
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 寫入緩存，key=" + key + ", value=" + value);
            // 模擬寫操作耗時
            Thread.sleep(200);
            cache.put(key, value);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            // 釋放寫鎖
            writeLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 釋放寫鎖");
        }
    }
    // 清空緩存（寫操作，用寫鎖）
    public void clear() {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 清空緩存");
            cache.clear();
        } finally {
            writeLock.unlock();
        }
    }
    // 測試讀寫鎖
    public static void main(String[] args) {
        ReadWriteLockCache cache = new ReadWriteLockCache();
        // 1. 啟動5個讀線程（并行執(zhí)行）
        for (int i = 0; i < 5; i++) {
            new Thread(() -> cache.get("user_1"), "讀線程" + i).start();
        }
        // 2. 啟動2個寫線程（串行執(zhí)行，且阻塞讀線程）
        new Thread(() -> cache.put("user_1", "張三"), "寫線程1").start();
        new Thread(() -> cache.put("user_2", "李四"), "寫線程2").start();
    }
}

// 寫鎖降級為讀鎖
writeLock.lock();
try {
    // 執(zhí)行寫操作
    cache.put("key", "value");
    // 降級：先獲取讀鎖，再釋放寫鎖
    readLock.lock();
} finally {
    writeLock.unlock();
}
try {
    // 持有讀鎖，安全讀取數(shù)據(jù)
    System.out.println(cache.get("key"));
} finally {
    readLock.unlock();
}