【Java并发】synchronized与ReentrantLock深入解析

public class Counter {
    private int count = 0;

    // 锁的是this对象
    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

public class Counter {
    private static int count = 0;

    // 锁的是Class对象
    public static synchronized void increment() {
        count++;
    }
}

public class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        // 锁指定对象
        synchronized (lock) {
            count++;
        }
    }

    public void decrement() {
        // 锁this
        synchronized (this) {
            count--;
        }
    }

    public static void staticMethod() {
        // 锁Class对象
        synchronized (Counter.class) {
            // ...
        }
    }
}

public void method() {
    synchronized (this) {
        // 临界区代码
    }
}

public class ProducerConsumer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int capacity = 10;

    public synchronized void produce(int item) throws InterruptedException {
        while (queue.size() == capacity) {
            wait();  // 队列满，等待消费者消费
        }
        queue.add(item);
        notifyAll();  // 通知消费者
    }

    public synchronized int consume() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();  // 队列空，等待生产者生产
        }
        int item = queue.poll();
        notifyAll();  // 通知生产者
        return item;
    }
}

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

    public void increment() {
        lock.lock();  // 获取锁
        try {
            count++;
        } finally {
            lock.unlock();  // 必须在finally中释放锁
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

// ReentrantLock.lock() 简化流程
public void lock() {
    // 1. 先尝试CAS直接获取锁（非公平：插队）
    if (compareAndSetState(0, 1)) {
        setExclusiveOwnerThread(currentThread);
        return;
    }

    // 2. CAS失败，进入AQS队列等待
    acquire(1);
}

// AQS.acquire()
public final void acquire(int arg) {
    // tryAcquire再次尝试获取
    if (!tryAcquire(arg) &&
        // 失败则加入队列并阻塞
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
        selfInterrupt();
    }
}

// 非公平锁（默认）
ReentrantLock unfairLock = new ReentrantLock();
ReentrantLock unfairLock = new ReentrantLock(false);

// 公平锁
ReentrantLock fairLock = new ReentrantLock(true);

// NonfairSync
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 直接CAS抢锁，不管队列中是否有等待的线程
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 重入逻辑...
    return false;
}

// FairSync
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 先检查队列中是否有等待的线程
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 重入逻辑...
    return false;
}

ReentrantLock lock = new ReentrantLock();

Thread t = new Thread(() -> {
    try {
        // 可中断地获取锁
        lock.lockInterruptibly();
        try {
            // 业务逻辑
        } finally {
            lock.unlock();
        }
    } catch (InterruptedException e) {
        System.out.println("获取锁时被中断");
    }
});

t.start();
Thread.sleep(1000);
t.interrupt();  // 中断等待中的线程

ReentrantLock lock = new ReentrantLock();

public void method() {
    boolean acquired = false;
    try {
        // 尝试获取锁，最多等待2秒
        acquired = lock.tryLock(2, TimeUnit.SECONDS);
        if (acquired) {
            // 获取到锁
        } else {
            // 超时未获取到锁
        }
    } catch (InterruptedException e) {
        // 等待过程中被中断
    } finally {
        if (acquired) {
            lock.unlock();
        }
    }
}

// 非阻塞尝试
if (lock.tryLock()) {
    try {
        // 立即获取到锁
    } finally {
        lock.unlock();
    }
} else {
    // 没有获取到锁，不阻塞
}

public class BoundedBuffer<T> {
    private final Object[] items;
    private int putIndex, takeIndex, count;

    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();   // 不满条件
    private final Condition notEmpty = lock.newCondition();  // 不空条件

    public BoundedBuffer(int capacity) {
        items = new Object[capacity];
    }

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) {
                notFull.await();  // 等待"不满"
            }
            items[putIndex] = item;
            if (++putIndex == items.length) putIndex = 0;
            count++;
            notEmpty.signal();  // 通知"不空"
        } finally {
            lock.unlock();
        }
    }

    @SuppressWarnings("unchecked")
    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();  // 等待"不空"
            }
            T item = (T) items[takeIndex];
            items[takeIndex] = null;
            if (++takeIndex == items.length) takeIndex = 0;
            count--;
            notFull.signal();  // 通知"不满"
            return item;
        } finally {
            lock.unlock();
        }
    }
}

public class Cache<K, V> {
    private final Map<K, V> map = new HashMap<>();
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final Lock readLock = rwLock.readLock();
    private final Lock writeLock = rwLock.writeLock();

    public V get(K key) {
        readLock.lock();  // 读锁：可以多线程同时读
        try {
            return map.get(key);
        } finally {
            readLock.unlock();
        }
    }

    public void put(K key, V value) {
        writeLock.lock();  // 写锁：独占
        try {
            map.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }

    public V computeIfAbsent(K key, Function<K, V> loader) {
        // 先用读锁检查
        readLock.lock();
        try {
            V value = map.get(key);
            if (value != null) {
                return value;
            }
        } finally {
            readLock.unlock();
        }

        // 需要写入，升级为写锁
        writeLock.lock();
        try {
            // 双重检查
            V value = map.get(key);
            if (value == null) {
                value = loader.apply(key);
                map.put(key, value);
            }
            return value;
        } finally {
            writeLock.unlock();
        }
    }
}

// 推荐使用synchronized的场景：
// 1. 简单同步，不需要高级功能
public synchronized void simpleMethod() {
    // ...
}

// 2. 确保锁一定被释放（不会忘记unlock）
synchronized (lock) {
    // 即使抛异常也会自动释放
}

// 推荐使用ReentrantLock的场景：

// 1. 需要可中断的锁
lock.lockInterruptibly();

// 2. 需要超时获取锁
if (lock.tryLock(1, TimeUnit.SECONDS)) { }

// 3. 需要公平锁
new ReentrantLock(true);

// 4. 需要多个条件变量
Condition notFull = lock.newCondition();
Condition notEmpty = lock.newCondition();

// 5. 需要读写锁
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

// 不好：锁整个方法
public synchronized void process() {
    readFromDB();      // 慢操作
    calculate();       // 快操作
    writeToFile();     // 慢操作
}

// 好：只锁需要同步的部分
public void process() {
    Data data = readFromDB();   // 不需要锁
    synchronized (this) {
        calculate(data);         // 只锁计算部分
    }
    writeToFile(data);          // 不需要锁
}

// 可能死锁：不同顺序获取多个锁
void method1() {
    synchronized (lockA) {
        synchronized (lockB) { }
    }
}

void method2() {
    synchronized (lockB) {  // 顺序相反
        synchronized (lockA) { }
    }
}

// 解决：固定加锁顺序
void method1() {
    synchronized (lockA) {
        synchronized (lockB) { }
    }
}

void method2() {
    synchronized (lockA) {  // 相同顺序
        synchronized (lockB) { }
    }
}

// 或使用tryLock避免死锁
boolean acquired = false;
try {
    acquired = lock1.tryLock(1, TimeUnit.SECONDS) &&
               lock2.tryLock(1, TimeUnit.SECONDS);
    if (acquired) {
        // 业务逻辑
    }
} finally {
    if (acquired) {
        lock2.unlock();
        lock1.unlock();
    }
}

ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
    // 业务逻辑
} finally {
    lock.unlock();  // 确保释放
}

// JDK 21虚拟线程中，synchronized会钉住载体线程
// 推荐使用ReentrantLock

// 不推荐
synchronized (lock) {
    Thread.sleep(1000);  // 会钉住载体线程
}

// 推荐
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    Thread.sleep(1000);  // 虚拟线程可以正常卸载
} finally {
    lock.unlock();
}