Lock 与显式锁详解

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

/**
 * 飞翔科技 - 资源池管理 tryLock 超时演示
 * 
 * 场景：数据库连接池只有 3 个连接（每个连接一把锁）
 *       多个业务线程尝试获取连接，2 秒超时放弃
 *       大翔(10001)、白歌(10002)、小崔(10003)、Frank(10004)
 */
public class ResourcePoolDemo {

    // 资源池：3 个连接，每个连接对应一把锁
    static class ConnectionPool {
        private final ReentrantLock[] locks;
        private final String[] connectionNames;

        public ConnectionPool(int size) {
            locks = new ReentrantLock[size];
            connectionNames = new String[size];
            for (int i = 0; i < size; i++) {
                locks[i] = new ReentrantLock();
                connectionNames[i] = "DB-Conn-" + (i + 1);
            }
        }

        /**
         * 尝试获取连接，超时放弃
         * @param workerName 业务线程名称
         * @param timeout 超时时间（秒）
         * @return 获取到的连接名称，null 表示获取失败
         */
        public String acquireConnection(String workerName, long timeout) {
            for (int i = 0; i < locks.length; i++) {
                try {
                    // ★ tryLock 超时 — 尝试获取锁，超时则放弃
                    if (locks[i].tryLock(timeout, TimeUnit.SECONDS)) {
                        System.out.printf("[%s] ✓ 获取连接 %s\n", workerName, connectionNames[i]);
                        return connectionNames[i];
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return null;
                }
            }
            System.out.printf("[%s] ✗ 所有连接都被占用，超时放弃\n", workerName);
            return null;
        }

        /**
         * 释放连接
         */
        public void releaseConnection(String connName) {
            for (int i = 0; i < connectionNames.length; i++) {
                if (connectionNames[i].equals(connName) && locks[i].isHeldByCurrentThread()) {
                    locks[i].unlock();
                    System.out.printf("[释放] %s 已归还\n", connName);
                    return;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ConnectionPool pool = new ConnectionPool(3);
        System.out.println("========== 飞翔科技连接池管理 (tryLock 超时) ==========\n");
        System.out.println("连接池大小: 3 | 超时时间: 2秒 | 业务线程: 4\n");

        // 线程1：大翔(10001) — 执行业务查询
        Thread t1 = new Thread(() -> {
            String conn = pool.acquireConnection("大翔-10001", 2);
            if (conn != null) {
                try { Thread.sleep(3000); } catch (InterruptedException e) { }
                pool.releaseConnection(conn);
            }
        }, "大翔");

        // 线程2：白歌(10002) — 执行报表生成
        Thread t2 = new Thread(() -> {
            String conn = pool.acquireConnection("白歌-10002", 2);
            if (conn != null) {
                try { Thread.sleep(3000); } catch (InterruptedException e) { }
                pool.releaseConnection(conn);
            }
        }, "白歌");

        // 线程3：小崔(10003) — 执行数据导入
        Thread t3 = new Thread(() -> {
            String conn = pool.acquireConnection("小崔-10003", 2);
            if (conn != null) {
                try { Thread.sleep(3000); } catch (InterruptedException e) { }
                pool.releaseConnection(conn);
            }
        }, "小崔");

        // 线程4：Frank(10004) — 执行数据导出（第4个线程，晚启动）
        Thread t4 = new Thread(() -> {
            try { Thread.sleep(500); } catch (InterruptedException e) { }
            String conn = pool.acquireConnection("Frank-10004", 2);
            if (conn != null) {
                try { Thread.sleep(3000); } catch (InterruptedException e) { }
                pool.releaseConnection(conn);
            }
        }, "Frank");

        t1.start(); t2.start(); t3.start(); t4.start();

        t1.join(); t2.join(); t3.join(); t4.join();
        System.out.println("\n========== 所有业务处理完毕 ==========");
    }
}

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

/**
 * 飞翔科技 - 生产者消费者 Condition 精确唤醒
 * 
 * 场景：大翔(10001) 计算薪资放入队列，白歌(10002) 从队列取出发放
 *       队列容量 5，使用 Lock + Condition 实现
 *       notFull: 队列未满条件，notEmpty: 队列非空条件
 */
public class ProducerConsumerConditionDemo {

    static class SalaryQueue {
        private final Queue<Float> queue = new LinkedList<>();
        private final int capacity;

        private final Lock lock = new ReentrantLock();
        // ★ 两个 Condition — 精确控制生产者和消费者的唤醒
        private final Condition notFull = lock.newCondition();   // 队列未满
        private final Condition notEmpty = lock.newCondition();  // 队列非空

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

        /**
         * 生产者：大翔计算薪资并放入队列
         */
        public void produce(float salary, int employeeId) throws InterruptedException {
            lock.lock();
            try {
                // ★ while 循环防止虚假唤醒
                while (queue.size() == capacity) {
                    System.out.printf("[生产者] 队列已满，等待消费者消费...\n");
                    notFull.await();  // 等待 notFull 条件
                }

                queue.offer(salary);
                System.out.printf("[生产者-大翔] 计算工号%d 薪资: %.2f 元, 队列: %d/%d\n",
                        employeeId, salary, queue.size(), capacity);

                // ★ 唤醒消费者 — 精确唤醒等待 notEmpty 的线程
                notEmpty.signal();
            } finally {
                lock.unlock();  // ★ 必须在 finally 中释放锁
            }
        }

        /**
         * 消费者：白歌从队列取出薪资并发放
         */
        public float consume() throws InterruptedException {
            lock.lock();
            try {
                while (queue.isEmpty()) {
                    System.out.printf("[消费者] 队列为空，等待生产者生产...\n");
                    notEmpty.await();  // 等待 notEmpty 条件
                }

                float salary = queue.poll();
                System.out.printf("[消费者-白歌] 发放薪资: %.2f 元, 队列: %d/%d\n",
                        salary, queue.size(), capacity);

                // ★ 唤醒生产者 — 精确唤醒等待 notFull 的线程
                notFull.signal();
                return salary;
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SalaryQueue salaryQueue = new SalaryQueue(5);
        System.out.println("========== 飞翔科技薪资计算系统 (Condition) ==========\n");

        // 生产者线程：大翔(10001)
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int employeeId = 10001 + i;
                    float salary = 8888.88f + i * 100;  // 不同员工的薪资
                    salaryQueue.produce(salary, employeeId);
                    Thread.sleep(300); // 模拟计算耗时
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Producer-大翔");

        // 消费者线程：白歌(10002)
        Thread consumer = new Thread(() -> {
            try {
                float totalPaid = 0;
                for (int i = 0; i < 10; i++) {
                    float salary = salaryQueue.consume();
                    totalPaid += salary;
                    Thread.sleep(500); // 模拟发放耗时
                }
                System.out.printf("\n[消费者-白歌] 总计发放薪资: %.2f 元\n", totalPaid);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Consumer-白歌");

        producer.start();
        consumer.start();

        producer.join();
        consumer.join();

        System.out.println("\n========== 本月薪资发放完毕 ==========");
    }
}

/**
 * 飞翔科技 - 公平锁 vs 非公平锁对比
 */
public class FairVsUnfairDemo {

    public static void main(String[] args) {
        // 公平锁：先到先得
        ReentrantLock fairLock = new ReentrantLock(true);
        // 非公平锁：允许插队（默认）
        ReentrantLock unfairLock = new ReentrantLock(false);

        System.out.println("========== 飞翔科技锁模式对比 ==========\n");

        // 公平锁测试
        System.out.println("--- 公平锁 ---");
        testLock("公平锁", fairLock);

        // 非公平锁测试
        System.out.println("\n--- 非公平锁 ---");
        testLock("非公平锁", unfairLock);
    }

    private static void testLock(String label, ReentrantLock lock) {
        for (int i = 0; i < 5; i++) {
            final int workerId = 10001 + i;
            new Thread(() -> {
                System.out.printf("[工号%d] 请求 %s...\n", workerId, label);
                lock.lock();
                try {
                    System.out.printf("[工号%d] ✓ 获得 %s\n", workerId, label);
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    lock.unlock();
                }
            }).start();
        }
        try { Thread.sleep(2000); } catch (InterruptedException e) { }
    }
}

/**
 * 飞翔科技 - lockInterruptibly 可中断锁获取演示
 */
public class LockInterruptDemo {

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();

        // 大翔(10001) 先获取锁并长时间持有
        Thread holding = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("[大翔-10001] 获取锁，将持有 5 秒...");
                Thread.sleep(5000);
                System.out.println("[大翔-10001] 释放锁");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                lock.unlock();
            }
        }, "大翔-10001");

        // 小崔(10003) 尝试获取锁，但可以被中断
        Thread waiting = new Thread(() -> {
            try {
                System.out.println("[小崔-10003] 尝试获取锁（可中断）...");
                lock.lockInterruptibly();  // ★ 可被中断的锁获取
                try {
                    System.out.println("[小崔-10003] 获取锁成功");
                } finally {
                    lock.unlock();
                }
            } catch (InterruptedException e) {
                System.out.println("[小崔-10003] 等待被中断，放弃获取锁");
            }
        }, "小崔-10003");

        holding.start();
        Thread.sleep(500); // 确保大翔先获取锁
        waiting.start();
        Thread.sleep(1000); // 等 1 秒后中断小崔
        System.out.println("[管理员] 中断小崔的等待...");
        waiting.interrupt();

        holding.join();
        waiting.join();
        System.out.println("\n========== 演示结束 ==========");
    }
}

// ✗ 错误：如果临界区抛异常，unlock() 不会执行 → 锁永远不会释放！
ReentrantLock lock = new ReentrantLock();
lock.lock();
doSomething();  // 如果这里抛异常...
lock.unlock();  // ...这行不会执行！

// ✓ 正确：unlock 必须在 finally 中
lock.lock();
try {
    doSomething();
} finally {
    lock.unlock();  // 无论如何都会释放锁
}

// ✗ 错误：if 只检查一次，虚假唤醒后不会重新检查条件
lock.lock();
try {
    if (queue.isEmpty()) {
        condition.await();  // 被虚假唤醒后直接往下执行，可能队列仍为空！
    }
    queue.poll();  // 可能抛出 NoSuchElementException
} finally {
    lock.unlock();
}

// ✓ 正确：使用 while 循环，每次唤醒都重新检查条件
lock.lock();
try {
    while (queue.isEmpty()) {  // ★ while 循环防虚假唤醒
        condition.await();
    }
    queue.poll();
} finally {
    lock.unlock();
}

// ✗ 错误：多生产者-多消费者场景用 signal() 可能唤醒同类型线程导致死锁
// 例如：消费者唤醒消费者，两者都等待 notEmpty → 永远无法唤醒
notEmpty.signal();  // 可能唤醒另一个消费者

// ✓ 正确：不确定时统一使用 signalAll()
notEmpty.signalAll();  // 唤醒所有等待线程，让它们竞争

// ✗ 错误：tryLock 返回 false 时仍然操作共享资源
ReentrantLock lock = new ReentrantLock();
lock.tryLock();  // 忽略了返回值！
sharedResource++;  // ⚠ 可能没有获取到锁！
lock.unlock();     // ⚠ 可能抛出 IllegalMonitorStateException

// ✓ 正确：必须在 tryLock 成功后才操作
if (lock.tryLock()) {
    try {
        sharedResource++;
    } finally {
        lock.unlock();
    }
} else {
    // 处理获取失败的情况
}