JUC系列-《ReentrantLock深度解析：解锁JUC并发编程的密钥》

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;
    public void increment() {
        lock.lock(); // 手动获取锁（阻塞直到成功）
        try {
            count++; // 临界区代码
            // 可重入性演示：同一个线程可以再次获取锁
            if (count < 10) {
                this.increment(); // 递归调用，会再次成功获取锁
            }
        } finally {
            lock.unlock(); // 必须在finally中释放锁！
        }
    }
    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

public boolean tryIncrement() {
    // 尝试获取锁，立即返回成功与否，不会阻塞线程
    if (lock.tryLock()) {
        try {
            count++;
            return true;
        } finally {
            lock.unlock();
        }
    } else {
        // 没拿到锁，可以先去做别的事情
        System.out.println("没能获取到锁，执行其他逻辑...");
        return false;
    }
}
public boolean tryIncrementWithTimeout() throws InterruptedException {
    // 尝试获取锁，最多等待1秒
    if (lock.tryLock(1, TimeUnit.SECONDS)) {
        try {
            count++;
            return true;
        } finally {
            lock.unlock();
        }
    } else {
        System.out.println("1秒内都没获取到锁，放弃吧...");
        return false;
    }
}

public void interruptibleIncrement() throws InterruptedException {
    // 这个方法允许在等待锁的过程中被其他线程中断
    lock.lockInterruptibly(); // 可能会抛出InterruptedException
    try {
        // 模拟一个长时间操作
        while (true) {
            count++;
            Thread.sleep(1000); // 睡眠中可能被中断
        }
    } finally {
        lock.unlock();
    }
}

// 创建公平锁
ReentrantLock fairLock = new ReentrantLock(true);
// 创建非公平锁（默认）
ReentrantLock nonFairLock = new ReentrantLock();
ReentrantLock nonFairLock2 = new ReentrantLock(false);

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ProducerConsumerModel {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int capacity = 5;
    private final ReentrantLock lock = new ReentrantLock();
    // 为生产者创建一个条件队列：队列"未满"时才能生产
    private final Condition notFull = lock.newCondition();
    // 为消费者创建一个条件队列：队列"非空"时才能消费
    private final Condition notEmpty = lock.newCondition();
    public void produce(int item) throws InterruptedException {
        lock.lock();
        try {
            // 使用while循环防止"虚假唤醒"
            while (queue.size() == capacity) {
                // 队列已满，生产者等待在"notFull"条件上
                System.out.println("队列已满，生产者等待...");
                notFull.await(); // 释放锁并等待，被唤醒后重新获取锁
            }
            queue.offer(item);
            System.out.println("生产: " + item + ", 队列大小: " + queue.size());
            // 生产了一个，队列肯定不空了，唤醒等待在"notEmpty"上的消费者
            notEmpty.signalAll();
        } finally {
            lock.unlock();
        }
    }
    public void consume() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                // 队列为空，消费者等待在"notEmpty"条件上
                System.out.println("队列为空，消费者等待...");
                notEmpty.await();
            }
            Integer item = queue.poll();
            System.out.println("消费: " + item + ", 队列大小: " + queue.size());
            // 消费了一个，队列肯定不满了，唤醒等待在"notFull"上的生产者
            notFull.signalAll();
        } finally {
            lock.unlock();
        }
    }
}