活锁与饥饿

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * 活锁示例：两个 Worker 互相谦让，导致谁都无法完成任务
 */
public class LivelockDemo {
 
    // 定义共享资源（两把锁）
    static final Lock lock1 = new ReentrantLock(); // 资源 1
    static final Lock lock2 = new ReentrantLock(); // 资源 2
 
    public static void main(String[] args) {
        // 创建两个线程，分别尝试获取两把锁
        Thread worker1 = new Thread(() -> doWork("Worker-1", lock1, lock2), "Worker-1");
        Thread worker2 = new Thread(() -> doWork("Worker-2", lock2, lock1), "Worker-2");
 
        worker1.start(); // 启动线程 1
        worker2.start(); // 启动线程 2
    }
 
    /**
     * 工作方法：先获取自己的锁，再尝试获取对方的锁
     * 如果对方的锁被占用，就"礼貌地"释放自己的锁，然后重试
     *
     * @param name   Worker 名称（用于日志打印）
     * @param first  该 Worker 首先获取的锁
     * @param second 该 Worker 其次需要获取的锁
     */
    static void doWork(String name, Lock first, Lock second) {
        while (true) {
            // 第一步：尝试获取自己的主锁
            first.lock();
            System.out.println(name + " 已获取第一把锁，尝试获取第二把...");
 
            // 第二步：尝试获取对方的锁（非阻塞方式）
            if (second.tryLock()) {
                try {
                    // ✅ 成功获取两把锁，执行业务逻辑
                    System.out.println(name + " 成功获取两把锁，完成任务！");
                    return; // 任务完成，退出循环
                } finally {
                    second.unlock(); // 释放第二把锁
                }
            } else {
                // ❌ 无法获取第二把锁，"礼貌地"释放自己的锁
                System.out.println(name + " 无法获取第二把锁，释放第一把锁，稍后重试...");
                first.unlock(); // 释放第一把锁，让给对方
            }
 
            // 【关键致命缺陷】此处没有任何随机延迟！
            // 两个线程以完全相同的节奏运行，导致：
            //   T1: lock(lock1) -> tryLock(lock2) 失败 -> unlock(lock1)
            //   T2: lock(lock2) -> tryLock(lock1) 失败 -> unlock(lock2)
            // 然后双方同时重试，再次进入相同的循环 → 活锁！
        }
    }
}

Worker-1 已获取第一把锁，尝试获取第二把...
Worker-2 已获取第一把锁，尝试获取第二把...
Worker-1 无法获取第二把锁，释放第一把锁，稍后重试...
Worker-2 无法获取第二把锁，释放第一把锁，稍后重试...
Worker-1 已获取第一把锁，尝试获取第二把...
Worker-2 已获取第一把锁，尝试获取第二把...
Worker-1 无法获取第二把锁，释放第一把锁，稍后重试...
Worker-2 无法获取第二把锁，释放第一把锁，稍后重试...
... (无限循环，永远看不到 "完成任务")

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.ThreadLocalRandom;
 
/**
 * 活锁解决方案：随机退避 (Random Backoff)
 */
public class LivelockSolution {
 
    static final Lock lock1 = new ReentrantLock(); // 资源 1
    static final Lock lock2 = new ReentrantLock(); // 资源 2
 
    public static void main(String[] args) {
        // 启动两个 Worker，分别以不同顺序获取锁
        Thread worker1 = new Thread(() -> doWork("Worker-1", lock1, lock2), "Worker-1");
        Thread worker2 = new Thread(() -> doWork("Worker-2", lock2, lock1), "Worker-2");
 
        worker1.start(); // 启动线程 1
        worker2.start(); // 启动线程 2
    }
 
    static void doWork(String name, Lock first, Lock second) {
        while (true) {
            // 第一步：获取自己的主锁
            first.lock();
            System.out.println(name + " 已获取第一把锁，尝试获取第二把...");
 
            // 第二步：尝试获取对方的锁
            if (second.tryLock()) {
                try {
                    // ✅ 两把锁都获取成功，执行任务
                    System.out.println(name + " ✅ 成功获取两把锁，完成任务！");
                    return; // 任务完成，退出
                } finally {
                    second.unlock(); // 释放第二把锁
                    first.unlock();  // 释放第一把锁
                }
            } else {
                // ❌ 获取第二把锁失败，释放第一把锁
                first.unlock();
                System.out.println(name + " 释放锁，准备随机退避...");
 
                // ====== 【核心修复】随机退避 ======
                try {
                    // 随机等待 1~100 毫秒
                    // 使用 ThreadLocalRandom（线程安全且高性能）
                    long backoff = ThreadLocalRandom.current().nextLong(1, 100);
                    System.out.println(name + " 退避 " + backoff + " ms");
                    Thread.sleep(backoff); // 随机休眠，打破对称性
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 恢复中断标志
                    return; // 被中断则退出
                }
                // ====================================
            }
        }
    }
}

Worker-1 已获取第一把锁，尝试获取第二把...
Worker-2 已获取第一把锁，尝试获取第二把...
Worker-1 释放锁，准备随机退避...
Worker-2 释放锁，准备随机退避...
Worker-1 退避 73 ms
Worker-2 退避 12 ms
Worker-2 已获取第一把锁，尝试获取第二把...
Worker-2 ✅ 成功获取两把锁，完成任务！
Worker-1 已获取第一把锁，尝试获取第二把...
Worker-1 ✅ 成功获取两把锁，完成任务！

// 所有线程都按相同顺序加锁：先 lock1，再 lock2
// 这样就不会出现 "你持有1要2，我持有2要1" 的对称冲突
static void doWorkOrdered(String name) {
    lock1.lock();   // 所有线程都先获取 lock1
    try {
        lock2.lock(); // 然后获取 lock2
        try {
            System.out.println(name + " ✅ 完成任务");
        } finally {
            lock2.unlock(); // 按逆序释放
        }
    } finally {
        lock1.unlock(); // 按逆序释放
    }
}

import java.util.concurrent.TimeUnit;
 
static void doWorkWithTimeout(String name, Lock first, Lock second) {
    try {
        // 尝试在 500ms 内获取第一把锁
        if (first.tryLock(500, TimeUnit.MILLISECONDS)) {
            try {
                // 尝试在 500ms 内获取第二把锁
                if (second.tryLock(500, TimeUnit.MILLISECONDS)) {
                    try {
                        System.out.println(name + " ✅ 完成任务");
                        return; // 成功完成
                    } finally {
                        second.unlock(); // 释放第二把锁
                    }
                }
            } finally {
                first.unlock(); // 释放第一把锁
            }
        }
        // 超时获取失败，可记录日志或采取降级策略
        System.out.println(name + " ⏱️ 获取锁超时，放弃本次操作");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // 恢复中断标志
    }
}

public class StarvationDemo {
    public static void main(String[] args) {
        // 创建一个共享的 Runnable 任务
        Runnable task = () -> {
            // 无限循环，模拟持续竞争资源
            while (true) {
                // 打印当前线程的名字和优先级
                System.out.println(Thread.currentThread().getName()
                        + " (priority=" + Thread.currentThread().getPriority() + ") is running");
                try {
                    // 短暂休眠，给其他线程一点机会
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    // 如果被中断，恢复中断标志位并退出循环
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        };
 
        // ========== 创建多个高优先级线程 ==========
        for (int i = 0; i < 5; i++) {
            // 为每个线程命名为 HighPriority-0 ~ HighPriority-4
            Thread highThread = new Thread(task, "HighPriority-" + i);
            // 设为最高优先级（10）
            highThread.setPriority(Thread.MAX_PRIORITY);
            // 启动线程
            highThread.start();
        }
 
        // ========== 创建一个低优先级线程（可能被饿死） ==========
        Thread lowThread = new Thread(task, "★ LowPriority ★");
        // 设为最低优先级（1）
        lowThread.setPriority(Thread.MIN_PRIORITY);
        // 启动线程
        lowThread.start();
    }
}

// 默认构造：非公平锁
ReentrantLock unfairLock = new ReentrantLock();        // 等价于 new ReentrantLock(false)
 
// 显式构造：公平锁
ReentrantLock fairLock = new ReentrantLock(true);      // 传入 true 表示公平

import java.util.concurrent.locks.ReentrantLock;
 
public class UnfairLockStarvation {
 
    // 创建非公平锁（默认即非公平）
    private static final ReentrantLock lock = new ReentrantLock(false);
 
    // 共享计数器：记录每个线程成功获取锁的次数
    private static final int[] acquireCounts = new int[6];
 
    public static void main(String[] args) throws InterruptedException {
 
        // 创建 6 个线程竞争同一把非公平锁
        Thread[] threads = new Thread[6];
        for (int i = 0; i < threads.length; i++) {
            // 使用 final 变量在 lambda 中捕获线程编号
            final int id = i;
            threads[i] = new Thread(() -> {
                // 每个线程尝试获取锁 10000 次
                for (int j = 0; j < 10000; j++) {
                    // 获取锁
                    lock.lock();
                    try {
                        // 成功获取锁，计数加一
                        acquireCounts[id]++;
                    } finally {
                        // 无论如何都要在 finally 中释放锁
                        lock.unlock();
                    }
                }
            }, "Thread-" + i);
        }
 
        // 启动所有线程
        for (Thread t : threads) {
            t.start();
        }
 
        // 等待所有线程执行完毕
        for (Thread t : threads) {
            t.join();
        }
 
        // 打印每个线程获取锁的次数分布
        System.out.println("====== 非公平锁下各线程获取锁的次数 ======");
        for (int i = 0; i < acquireCounts.length; i++) {
            // 打印线程编号和对应的获取锁次数
            System.out.printf("Thread-%d : %d 次%n", i, acquireCounts[i]);
        }
    }
}

public class LongHoldingStarvation {
 
    // 共享锁对象
    private static final Object lock = new Object();
 
    public static void main(String[] args) {
        // 线程 A：长时间持有锁执行耗时操作
        new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread-A 获取锁，开始执行耗时操作...");
                try {
                    // 模拟一个非常耗时的操作（如数据库批量写入）
                    Thread.sleep(10_000); // 持有锁 10 秒
                } catch (InterruptedException e) {
                    // 恢复中断标志位
                    Thread.currentThread().interrupt();
                }
                System.out.println("Thread-A 耗时操作完成，释放锁");
            }
        }, "Thread-A").start();
 
        // 短暂等待，确保 Thread-A 先拿到锁
        try { Thread.sleep(100); } catch (InterruptedException ignored) {}
 
        // 线程 B ~ E：都想获取锁执行快速操作，但被迫长期等待
        for (int i = 0; i < 4; i++) {
            new Thread(() -> {
                long waitStart = System.currentTimeMillis(); // 记录等待开始时间
                synchronized (lock) {
                    // 计算实际等待时长
                    long waited = System.currentTimeMillis() - waitStart;
                    System.out.println(Thread.currentThread().getName()
                            + " 获取锁，等待了 " + waited + " ms");
                }
            }, "Thread-" + (char)('B' + i)).start();
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;
 
public class FairLockSolution {
 
    // 关键：构造函数传入 true，启用公平模式
    private static final ReentrantLock fairLock = new ReentrantLock(true);
 
    // 共享计数器
    private static final int[] acquireCounts = new int[6];
 
    public static void main(String[] args) throws InterruptedException {
 
        Thread[] threads = new Thread[6];
        for (int i = 0; i < threads.length; i++) {
            final int id = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    // 获取公平锁——严格按照 FIFO 顺序
                    fairLock.lock();
                    try {
                        // 成功获取，计数加一
                        acquireCounts[id]++;
                    } finally {
                        // 释放锁
                        fairLock.unlock();
                    }
                }
            }, "Thread-" + i);
        }
 
        // 启动所有线程
        for (Thread t : threads) {
            t.start();
        }
 
        // 等待所有线程结束
        for (Thread t : threads) {
            t.join();
        }
 
        // 打印结果——公平锁下分布应非常均匀
        System.out.println("====== 公平锁下各线程获取锁的次数 ======");
        for (int i = 0; i < acquireCounts.length; i++) {
            System.out.printf("Thread-%d : %d 次%n", i, acquireCounts[i]);
        }
    }
}

public class PriorityAdjustSolution {
    public static void main(String[] args) {
        Runnable task = () -> {
            // 每个线程运行一段计算密集型任务
            long sum = 0;
            for (long i = 0; i < 1_000_000_000L; i++) {
                sum += i;
            }
            // 打印线程名、优先级和结果
            System.out.println(Thread.currentThread().getName()
                    + " (priority=" + Thread.currentThread().getPriority()
                    + ") finished, sum=" + sum);
        };
 
        // 创建线程并设置为"正常偏高"优先级（而非极端值）
        Thread worker = new Thread(task, "ImportantWorker");
        // 设为 7（介于 NORM 5 和 MAX 10 之间），温和提升
        worker.setPriority(7);
        worker.start();
 
        // 其他后台线程保持默认优先级
        for (int i = 0; i < 3; i++) {
            Thread bg = new Thread(task, "Background-" + i);
            // 默认优先级 5，无需显式设置
            bg.start();
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;
 
public class MinimizeLockScope {
 
    private final ReentrantLock lock = new ReentrantLock();
 
    // ❌ 反面示例：在锁内执行了大量不需要同步的操作
    public void badApproach(String data) {
        lock.lock();
        try {
            // 1. 数据校验（不涉及共享状态，不需要锁保护）
            validate(data);
            // 2. 数据转换（不涉及共享状态，不需要锁保护）
            String transformed = transform(data);
            // 3. 写入共享状态（需要锁保护）
            writeToSharedState(transformed);
            // 4. 日志记录（不涉及共享状态，不需要锁保护）
            log(transformed);
        } finally {
            lock.unlock();
        }
    }
 
    // ✅ 正面示例：仅在真正需要同步的最小代码段持有锁
    public void goodApproach(String data) {
        // 1. 数据校验——锁外执行
        validate(data);
        // 2. 数据转换——锁外执行
        String transformed = transform(data);
 
        // 3. 写入共享状态——仅此处需要锁保护
        lock.lock();
        try {
            writeToSharedState(transformed);
        } finally {
            lock.unlock();
        }
 
        // 4. 日志记录——锁外执行
        log(transformed);
    }
 
    // ---- 辅助方法（省略具体实现） ----
    private void validate(String data) { /* 校验逻辑 */ }
    private String transform(String data) { return data.toUpperCase(); }
    private void writeToSharedState(String data) { /* 写入共享变量 */ }
    private void log(String data) { System.out.println("Logged: " + data); }
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
 
public class TryLockSolution {
 
    private static final ReentrantLock lock = new ReentrantLock();
 
    public void safeAccess() {
        try {
            // 尝试在 3 秒内获取锁
            boolean acquired = lock.tryLock(3, TimeUnit.SECONDS);
            if (acquired) {
                try {
                    // 成功获取锁，执行正常业务逻辑
                    System.out.println(Thread.currentThread().getName() + " 获取锁成功，执行业务...");
                    doBusinessLogic();
                } finally {
                    // 在 finally 中释放锁，确保一定释放
                    lock.unlock();
                }
            } else {
                // 超时未获取到锁，执行降级策略
                System.out.println(Thread.currentThread().getName() + " 获取锁超时，执行降级逻辑...");
                fallbackLogic();
            }
        } catch (InterruptedException e) {
            // 等待过程中被中断，恢复中断标志
            Thread.currentThread().interrupt();
            System.out.println(Thread.currentThread().getName() + " 等待锁时被中断");
        }
    }
 
    private void doBusinessLogic() { /* 正常业务 */ }
    private void fallbackLogic() { /* 降级处理：如返回缓存数据、记录日志等 */ }
}

import java.util.concurrent.locks.ReentrantReadWriteLock;
 
public class ReadWriteLockSolution {
 
    // 创建读写锁（可传 true 启用公平模式）
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(true);
    // 获取读锁引用
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    // 获取写锁引用
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
 
    // 共享数据
    private String sharedData = "initial";
 
    // 读操作：多个读线程可同时进入，不会互相阻塞
    public String read() {
        // 获取读锁
        readLock.lock();
        try {
            // 读取共享数据（多个读线程可并发执行此处）
            return sharedData;
        } finally {
            // 释放读锁
            readLock.unlock();
        }
    }
 
    // 写操作：独占，会等待所有读锁释放
    public void write(String newData) {
        // 获取写锁
        writeLock.lock();
        try {
            // 修改共享数据（此时不会有任何其他读或写线程进入）
            sharedData = newData;
        } finally {
            // 释放写锁
            writeLock.unlock();
        }
    }
}