Java并发编程深入解析：从synchronized到Lock

public class SyncDemo {
    private final Object lock = new Object();

    public void syncBlock() {
        synchronized (lock) {
            System.out.println("inside synchronized block");
        }
    }
}

/**
 * 演示synchronized在不同竞争条件下的锁升级
 * 可通过JOL (Java Object Layout)工具观察对象头变化
 */
public class LockEscalationDemo {
    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        // Phase 1: 偏向锁 - 单线程重复获取
        for (int i = 0; i < 5; i++) {
            synchronized (lock) {
                // 只有main线程访问，保持偏向锁状态
            }
        }

        // Phase 2: 轻量级锁 - 两个线程交替访问
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                synchronized (lock) {
                    // 交替执行，CAS竞争
                }
            }
        });
        t1.start();
        t1.join();

        // Phase 3: 重量级锁 - 多线程同时竞争
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                synchronized (lock) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            }).start();
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class ReentrantLockDemo {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    /**
     * 标准用法：try-finally确保释放锁
     */
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在finally中释放锁
        }
    }

    /**
     * 可超时获取锁，避免死锁
     */
    public boolean tryIncrement(long timeout) throws InterruptedException {
        if (lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
            try {
                count++;
                return true;
            } finally {
                lock.unlock();
            }
        }
        return false; // 超时未获取到锁
    }

    /**
     * 可中断获取锁
     */
    public void interruptibleIncrement() throws InterruptedException {
        lock.lockInterruptibly(); // 等待过程中可被中断
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

// 非公平锁（默认）- 允许插队，吞吐量更高
ReentrantLock unfairLock = new ReentrantLock(false);

// 公平锁 - 按请求顺序获取锁，避免饥饿
ReentrantLock fairLock = new ReentrantLock(true);

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 使用Condition实现生产者-消费者模式
 * 相比wait/notify，Condition支持多个等待队列，逻辑更清晰
 */
public class BoundedBuffer<T> {
    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();  // 队列未满条件
    private final Condition notEmpty = lock.newCondition(); // 队列非空条件

    public BoundedBuffer(int capacity) {
        this.capacity = capacity;
    }

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                notFull.await(); // 队列满了，等待消费者消费
            }
            queue.offer(item);
            notEmpty.signal(); // 通知消费者可以消费了
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await(); // 队列空了，等待生产者生产
            }
            T item = queue.poll();
            notFull.signal(); // 通知生产者可以生产了
            return item;
        } finally {
            lock.unlock();
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 基于ReadWriteLock实现的线程安全缓存
 * 读操作并发执行，写操作独占访问
 */
public class ReadWriteCache<K, V> {
    private final Map<K, V> cache = new HashMap<>();
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public V get(K key) {
        rwLock.readLock().lock();
        try {
            return cache.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void put(K key, V value) {
        rwLock.writeLock().lock();
        try {
            cache.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    /**
     * 锁降级：写锁 -> 读锁（安全的）
     * 先获取写锁修改数据，然后降级为读锁继续使用数据
     */
    public V computeIfAbsent(K key, java.util.function.Function<K, V> mappingFunction) {
        rwLock.readLock().lock();
        try {
            V value = cache.get(key);
            if (value != null) {
                return value;
            }
        } finally {
            rwLock.readLock().unlock();
        }

        // 读锁中未命中，升级为写锁
        rwLock.writeLock().lock();
        try {
            // double-check: 可能其他线程已经写入
            V value = cache.get(key);
            if (value == null) {
                value = mappingFunction.apply(key);
                cache.put(key, value);
            }
            // 锁降级：在释放写锁前先获取读锁
            rwLock.readLock().lock();
            return value;
        } finally {
            rwLock.writeLock().unlock();
            // 此时仍持有读锁，可以安全使用数据
            rwLock.readLock().unlock();
        }
    }
}

import java.util.concurrent.locks.StampedLock;

/**
 * StampedLock实现的二维点坐标
 * 演示乐观读、悲观读和写锁的使用
 */
public class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();

    /**
     * 写操作：独占锁
     */
    public void move(double deltaX, double deltaY) {
        long stamp = sl.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    /**
     * 乐观读：不阻塞写操作，性能最优
     * 如果在读取过程中发生了写操作，则回退到悲观读锁
     */
    public double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead(); // 获取乐观读stamp，不加锁
        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);
    }
}