public class SynchronizedDemo {
    // 1. 實例方法鎖（對象鎖）：鎖當前實例對象
    public synchronized void objectLock() {
        System.out.println(Thread.currentThread().getName() + "獲取對象鎖");
        try { Thread.sleep(100); } catch (InterruptedException e) {}
    }
    // 2. 靜態(tài)方法鎖（類鎖）：鎖當前類的Class對象
    public static synchronized void classLock() {
        System.out.println(Thread.currentThread().getName() + "獲取類鎖");
        try { Thread.sleep(100); } catch (InterruptedException e) {}
    }
    // 3. 代碼塊鎖：自定義鎖對象（靈活度最高）
    private final Object lockObj = new Object();
    public void blockLock() {
        synchronized (lockObj) {
            System.out.println(Thread.currentThread().getName() + "獲取代碼塊鎖");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
        }
    }
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        // 競爭同一對象鎖，串行執(zhí)行
        new Thread(demo::objectLock, "線程1").start();
        new Thread(demo::objectLock, "線程2").start();
    }
}

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo {
    // 公平鎖（按請求順序獲取），默認非公平鎖（性能更高）
    private static final ReentrantLock lock = new ReentrantLock(true);
    public static void doTask() {
        // 1. 加鎖（可替換為lockInterruptibly()：可中斷鎖）
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "獲取鎖");
            // 模擬業(yè)務操作
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢復中斷狀態(tài)
        } finally {
            // 2. 釋放鎖（必須放finally，否則死鎖）
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
                System.out.println(Thread.currentThread().getName() + "釋放鎖");
            }
        }
    }
    public static void main(String[] args) {
        new Thread(ReentrantLockDemo::doTask, "線程A").start();
        new Thread(ReentrantLockDemo::doTask, "線程B").start();
    }
}

public class ReentrantDemo {
    public synchronized void outer() {
        System.out.println("外層方法獲取鎖");
        inner(); // 同一線程再次獲取同一鎖，無死鎖
    }
    public synchronized void inner() {
        System.out.println("內(nèi)層方法獲取鎖");
    }
    public static void main(String[] args) {
        new ReentrantDemo().outer(); // 正常執(zhí)行，無死鎖
    }
}

import java.util.concurrent.atomic.AtomicInteger;
public class OptimisticLockDemo {
    // CAS是樂觀鎖的核心實現(xiàn)
    private static final AtomicInteger count = new AtomicInteger(0);
    // 原子自增（無鎖，沖突時重試）
    public static void increment() {
        count.incrementAndGet();
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) increment();
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println("最終計數(shù)：" + count.get()); // 2000（線程安全）
    }
}

import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockDemo {
    private static final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private static final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
    private static int cacheData = 0; // 模擬緩存數(shù)據(jù)
    // 讀操作（共享鎖，多線程同時執(zhí)行）
    public static void readCache() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "讀取緩存：" + cacheData);
            Thread.sleep(200); // 模擬讀耗時
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            readLock.unlock();
        }
    }
    // 寫操作（獨占鎖，串行執(zhí)行）
    public static void updateCache(int newData) {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "更新緩存：" + newData);
            cacheData = newData;
            Thread.sleep(200); // 模擬寫耗時
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            writeLock.unlock();
        }
    }
    public static void main(String[] args) {
        // 5個讀線程（可同時執(zhí)行，并發(fā)效率高）
        for (int i = 0; i < 5; i++) {
            new Thread(ReadWriteLockDemo::readCache, "讀線程" + i).start();
        }
        // 1個寫線程（獨占，所有讀線程等待）
        new Thread(() -> updateCache(100), "寫線程").start();
    }
}