Java线程饥饿与锁竞争：策略与最佳实践

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(); // 确保锁被释放
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Infinite loop thread interrupted.");
                break;
            } catch (Exception e) {
                System.err.println("Error in infinite loop task: " + e.getMessage());
            }

            // 关键步骤：休眠一小段时间，让其他线程有机会获取锁
            ThreadUtil.sleep(10); // 假设 ThreadUtil.sleep 是一个简单的休眠工具方法
        }
    }

    private void doSomething() throws InterruptedException {
        // 模拟实际业务逻辑
        System.out.println(Thread.currentThread().getName() + " acquired lock and doing something.");
        Thread.sleep(50); // 模拟业务执行时间
    }

    // 假设其他线程（如调度任务）也会调用此方法
    public void scheduledTask() {
        try {
            if (writeLock.tryLock(100, TimeUnit.MILLISECONDS)) {
                try {
                    System.out.println(Thread.currentThread().getName() + " acquired lock for scheduled task.");
                    // 执行调度任务
                } finally {
                    writeLock.unlock();
                }
            } else {
                System.out.println(Thread.currentThread().getName() + " failed to acquire lock for scheduled task.");
            }
        } 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();
    }
}

// 简单的 ThreadUtil 类，用于模拟休眠
class ThreadUtil {
    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

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

public class ConditionSynchronizationExample {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean resourceReady = false; // 共享资源状态，表示资源是否可用

    // 生产者线程（无限循环任务）
    public void producerTask() {
        while (true) {
            lock.lock(); // 获取锁
            try {
                // 模拟生产资源
                System.out.println(Thread.currentThread().getName() + " is producing resource...");
                ThreadUtil.sleep(100); // 模拟生产时间
                resourceReady = true; // 资源已准备好
                condition.signalAll(); // 通知所有等待的消费者线程
            } finally {
                lock.unlock(); // 释放锁
            }
            ThreadUtil.sleep(50); // 生产者线程稍作休息，避免过于频繁地生产
        }
    }

    // 消费者线程（调度任务或手动触发任务）
    public void consumerTask(String taskName) {
        lock.lock(); // 获取锁
        try {
            while (!resourceReady) { // 如果资源未准备好，则等待
                System.out.println(taskName + " is waiting for resource...");
                condition.await(); // 释放锁并等待，直到被signalAll唤醒
            }
            // 资源已准备好，消费资源
            System.out.println(taskName + " consumed resource!");
            resourceReady = false; // 重置状态，等待下一次生产
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println(taskName + " interrupted while waiting.");
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public static void main(String[] args) {
        ConditionSynchronizationExample example = new ConditionSynchronizationExample();
        new Thread(example::producerTask, "ProducerThread").start();
        new Thread(() -> example.consumerTask("ConsumerTask-1"), "ConsumerThread-1").start();
        new Thread(() -> example.consumerTask("ConsumerTask-2"), "ConsumerThread-2").start();
    }
}