优化Java并发：ReentrantLock竞争与线程饥饿的避免策略

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

public class LockContentionExample {
    private final Lock writeLock = new ReentrantLock(true); // 使用公平锁，有助于缓解饥饿

    public void infiniteLoopTask() {
        while (true) {
            try {
                // 尝试获取锁，设置超时时间以避免无限等待
                if (writeLock.tryLock(100, TimeUnit.MILLISECONDS)) {
                    try {
                        doSomething(); // 执行核心业务逻辑
                    } finally {
                        writeLock.unlock(); // 确保锁在任何情况下都被释放
                    }
                } else {
                    // 如果在超时时间内未能获取锁，可以做一些其他事情或直接继续循环
                    System.out.println(Thread.currentThread().getName() + " - 未能获取锁，重试...");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println(Thread.currentThread().getName() + " - 任务中断。");
                break;
            }

            // 释放锁后短暂休眠，给其他线程获取锁的机会
            ThreadUtil.sleep(10); // 假设 ThreadUtil.sleep 是一个简单的休眠工具方法
        }
    }

    public void scheduledTask() {
        try {
            if (writeLock.tryLock(100, TimeUnit.MILLISECONDS)) {
                try {
                    doScheduledWork();
                } finally {
                    writeLock.unlock();
                }
            } else {
                System.out.println(Thread.currentThread().getName() + " - 调度任务未能获取锁。");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println(Thread.currentThread().getName() + " - 调度任务中断。");
        }
    }

    private void doSomething() {
        System.out.println(Thread.currentThread().getName() + " - 正在执行核心任务...");
        // 模拟耗时操作
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private void doScheduledWork() {
        System.out.println(Thread.currentThread().getName() + " - 正在执行调度任务...");
        // 模拟耗时操作
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // 假设的 ThreadUtil 工具类
    static class ThreadUtil {
        public static void sleep(long millis) {
            try {
                Thread.sleep(millis);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    public static void main(String[] args) {
        LockContentionExample example = new LockContentionExample();
        new Thread(example::infiniteLoopTask, "InfiniteLoopThread").start();
        new Thread(example::scheduledTask, "ScheduledTaskThread-1").start();
        new Thread(example::scheduledTask, "ScheduledTaskThread-2").start();
    }
}

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

public class CoordinatedLockAccess {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean resourceAvailable = false; // 共享资源状态

    // 生产/提供资源线程
    public void producerTask() {
        lock.lock();
        try {
            // 模拟生产资源
            System.out.println(Thread.currentThread().getName() + " - 正在生产资源...");
            try { Thread.sleep(50); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            resourceAvailable = true; // 资源已准备好
            condition.signalAll(); // 通知所有等待的消费者线程
            System.out.println(Thread.currentThread().getName() + " - 资源生产完毕，通知消费者。");
        } finally {
            lock.unlock();
        }
    }

    // 消费/使用资源线程
    public void consumerTask() {
        lock.lock();
        try {
            while (!resourceAvailable) { // 循环检查条件，防止虚假唤醒
                System.out.println(Thread.currentThread().getName() + " - 资源未就绪，等待...");
                try {
                    condition.await(); // 释放锁并等待
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return;
                }
            }
            // 资源已就绪，进行消费
            System.out.println(Thread.currentThread().getName() + " - 资源已就绪，开始消费。");
            // 模拟消费资源
            try { Thread.sleep(20); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            resourceAvailable = false; // 消费后重置状态
            System.out.println(Thread.currentThread().getName() + " - 资源消费完毕。");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        CoordinatedLockAccess coordinator = new CoordinatedLockAccess();

        // 启动消费者线程
        new Thread(coordinator::consumerTask, "Consumer-1").start();
        new Thread(coordinator::consumerTask, "Consumer-2").start();

        // 稍后启动生产者线程
        try { Thread.sleep(100); } catch (InterruptedException e) { }
        new Thread(coordinator::producerTask, "Producer").start();
    }
}