Java并发编程：利用Sleep与Wait/Notify机制解决线程饥饿问题-java教程-PHP中文网

Java并发编程：利用Sleep与Wait/Notify机制解决线程饥饿问题

心靈之曲

发布： 2025-10-16 13:51:17

原创

1015人浏览过

Java并发编程：利用Sleep与Wait/Notify机制解决线程饥饿问题

本文深入探讨在java 并发编程中，多个线程竞争锁资源时可能出现的线程饥饿问题。我们将分析通过在循环线程中引入`thread.sleep()`来避免饥饿的策略，并比较固定时长与随机时长休眠的适用场景。更进一步，文章将介绍如何利用`object.wait()`和`object.notifyall()`机制实现更高效、更公平的线程协调，从而彻底解决资源竞争中的饥饿现象，提升系统的响应性和稳定性。

线程饥饿问题概述

在多线程环境中，当多个线程需要访问共享资源时，通常会使用锁（如java.util.concurrent.locks.ReentrantLock）来保证数据一致性。然而，如果一个线程（例如一个无限循环的后台任务）频繁地获取并释放锁，而其他优先级相同或较低的线程也需要获取同一个锁来执行关键任务（如定时任务或用户请求），就可能出现线程饥饿（Thread Starvation）问题。即，某些线程可能长时间无法获取到锁，导致其任务延迟或无法执行。

考虑以下场景：一个主线程在一个无限循环中持续执行任务并持有ReentrantLock，随后释放。同时，存在一个定时任务线程和一个人手动触发的WS调用线程也需要获取同一个锁来执行各自的操作。如果主线程释放锁后立即再次获取，其他线程可能永远没有机会获得锁。

策略一：通过Thread.sleep()缓解饥饿

为了缓解上述饥饿问题，一种直观且相对简单的做法是在主线程释放锁后，主动让其休眠一小段时间。这为其他等待获取锁的线程提供了获取CPU时间片和竞争锁的机会。

1. 固定时长休眠

在主线程释放锁后，通过调用Thread.sleep(milliseconds)让其暂停执行一段固定的时间。

立即学习“Java免费学习笔记（深入）”；

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

public class LockWithFixedSleep {
    private final Lock writeLock = new ReentrantLock(true); // 使用公平锁

    public void infiniteLoopTask() {
        while (true) {
            try {
                // 尝试获取锁，带超时，防止无限等待
                if (writeLock.tryLock(100, TimeUnit.MILLISECONDS)) {
                    try {
                        System.out.println(Thread.currentThread().getName() + " acquired lock and doing work.");
                        doSomething(); // 执行核心业务逻辑
                    } finally {
                        writeLock.unlock(); // 确保锁在任何情况下都被释放
                        System.out.println(Thread.currentThread().getName() + " released lock.");
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + " failed to acquire lock, retrying.");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println(Thread.currentThread().getName() + " interrupted.");
                break;
            }

            // 关键步骤：休眠一段时间，让其他线程有机会竞争锁
            try {
                Thread.sleep(10); // 固定休眠10毫秒
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println(Thread.currentThread().getName() + " interrupted during sleep.");
                break;
            }
        }
    }

    private void doSomething() {
        // 模拟耗时操作
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) {
        LockWithFixedSleep demo = new LockWithFixedSleep();

        // 启动无限循环线程
        new Thread(demo::infiniteLoopTask, "InfiniteLoopThread").start();

        // 启动定时任务线程
        new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(50); // 模拟定时触发
                    if (demo.writeLock.tryLock(100, TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println(Thread.currentThread().getName() + " acquired lock and doing scheduled task.");
                            // doScheduledTask();
                        } finally {
                            demo.writeLock.unlock();
                            System.out.println(Thread.currentThread().getName() + " released lock.");
                        }
                    } else {
                        System.out.println(Thread.currentThread().getName() + " failed to acquire lock for scheduled task.");
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }, "ScheduledTaskThread").start();
    }
}

登录后复制

优点： 简单易行，对于只有两个线程（一个主循环线程和一个竞争线程）的场景，固定休眠通常能有效避免饥饿。主循环线程的休眠确保了其不会立即重新抢占锁，为其他线程提供了窗口。

缺点：

性能开销： 无论是否有其他线程等待，主线程都会休眠，引入不必要的延迟。
非确定性： 无法保证其他线程一定能在休眠期间获取到锁。
多线程场景下的局限性： 当有三个或更多线程竞争锁时，固定休眠可能导致新的饥饿问题。例如，如果线程A、B、C都等待锁，主线程释放锁后休眠。如果线程B总是比线程C更快地尝试获取锁，并且在主线程休眠期间成功获取，那么线程C可能仍然会饥饿。

2. 随机时长休眠

为了解决固定休眠在多线程场景下的局限性，可以引入随机休眠时间。即，在释放锁后，线程休眠一个随机时长（例如，5到100毫秒之间）。

豆包AI编程

豆包推出的AI编程助手

483

查看详情

import cn.hutool.core.thread.ThreadUtil; // 假设使用Hutool工具类
import cn.hutool.core.util.RandomUtil; // 假设使用Hutool工具类
// ... (其他导入和LockWithFixedSleep类定义不变)

public class LockWithRandomSleep {
    private final Lock writeLock = new ReentrantLock(true);

    public void infiniteLoopTask() {
        while (true) {
            try {
                if (writeLock.tryLock(100, TimeUnit.MILLISECONDS)) {
                    try {
                        System.out.println(Thread.currentThread().getName() + " acquired lock and doing work.");
                        doSomething();
                    } finally {
                        writeLock.unlock();
                        System.out.println(Thread.currentThread().getName() + " released lock.");
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + " failed to acquire lock, retrying.");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println(Thread.currentThread().getName() + " interrupted.");
                break;
            }

            // 关键步骤：休眠一段随机时间
            ThreadUtil.sleep(RandomUtil.nextInt(5, 100)); // 随机休眠5到100毫秒
        }
    }

    private void doSomething() {
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // ... main 方法类似，可以启动更多竞争线程来观察效果
}

登录后复制

优点： 随机休眠打破了线程尝试获取锁的固定模式，使得多个竞争线程获得锁的机会更加均等，从而降低了特定线程持续饥饿的风险。

缺点：

性能开销： 同样存在不必要的休眠开销。
复杂性： 引入随机性增加了调试和预测行为的难度。
仍是启发式方法： 随机休眠仍然是一种启发式方法，不能从根本上保证公平性，只是通过增加不确定性来提高公平的概率。

策略二：利用wait()和notifyAll()实现协作式调度

Thread.sleep()方法本质上是一种“忙等”的改进，它只是让线程暂停执行，但并不知道其他线程是否已经准备好或是否需要资源。更优雅和高效的解决方案是使用Java的Object.wait()和Object.notifyAll()机制，实现线程间的协作式调度。这种方式允许线程在无法继续执行时主动放弃CPU，并在条件满足时被唤醒。

wait()和notifyAll()（或notify()）必须在synchronized块内部调用，并且它们操作的是同一个监视器对象。

工作原理：

无限循环线程（生产者/信号发送者）：
- 获取锁，执行其核心任务。
- 完成任务后，释放锁。
- 进入synchronized块，调用notifyAll()唤醒所有等待的线程。
- 可选地，如果该线程也需要等待其他线程完成某些操作才能继续其下一个循环，它可以调用wait()，进入等待状态，释放监视器锁。
其他竞争线程（消费者/信号接收者）：
- 进入synchronized块，检查是否满足获取锁的条件（例如，主线程已完成一轮工作）。
- 如果不满足条件，调用wait()，进入等待状态，释放监视器锁。
- 一旦被notify()或notifyAll()唤醒，重新检查条件。如果满足，退出synchronized块。
- 尝试获取ReentrantLock，执行其任务。
- 完成后，释放ReentrantLock。
- 进入synchronized块，调用notify()或notifyAll()，通知可能在等待的线程。

这种机制将线程从被动等待（sleep）转变为主动协作。JVM可以更有效地管理等待和唤醒的线程，从而更好地避免饥饿。

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

public class LockWithWaitNotify {
    private final Lock writeLock = new ReentrantLock(true); // 使用公平锁
    private final Object monitor = new Object(); // 用于wait/notify的监视器对象
    private boolean mainTaskCompletedCycle = false; // 共享状态，表示主任务是否完成了一个周期

    public void infiniteLoopTask() {
        while (true) {
            try {
                // 主线程获取ReentrantLock，执行核心任务
                writeLock.lock(); // 这里直接使用lock()，因为它会等待直到获取
                try {
                    System.out.println(Thread.currentThread().getName() + " acquired lock and doing main work.");
                    doSomething(); // 执行核心业务逻辑
                } finally {
                    writeLock.unlock();
                    System.out.println(Thread.currentThread().getName() + " released lock.");
                }

                // 任务完成后，通知其他等待线程
                synchronized (monitor) {
                    mainTaskCompletedCycle = true; // 设置条件
                    monitor.

登录后复制

以上就是Java并发编程：利用Sleep与Wait/Notify机制解决线程饥饿问题的详细内容，更多请关注php中文网其它相关文章！