正文

Java线程休眠，详解如何高效利用暂停与唤醒机制

/0 浏览量
1018

在Java编程中，线程休眠和唤醒是控制线程行为的重要手段。正确地使用线程休眠和唤醒机制可以提高程序的效率，避免资源浪费，同时还能使程序流程更加清晰。本文将详细解析Java中线程休眠与唤醒的原理和使用方法。

线程休眠（sleep）

1. 休眠的基本概念

Thread.sleep(long millis)方法是Java中用来使当前线程暂停执行的。当调用此方法时，当前线程会暂停执行指定的时间（以毫秒为单位）。在这个时间段内，线程不会占用CPU资源，因此可以被操作系统分配给其他线程执行。

2. 休眠的注意事项

  • Thread.sleep方法抛出InterruptedException异常，如果当前线程在休眠过程中被中断，会抛出此异常。因此，在使用Thread.sleep时，需要捕获此异常。
  • 休眠时间仅指CPU时间片，不包括I/O等待时间。
  • 休眠结束后，线程将自动恢复执行，无需显式唤醒。

3. 代码示例

public class SleepExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("Thread starting...");
                Thread.sleep(1000); // 休眠1000毫秒
                System.out.println("Thread woke up!");
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted during sleep.");
            }
        });
        thread.start();
    }
}

线程唤醒（notify）

1. 唤醒的基本概念

Thread.notify()方法用于唤醒在某个对象上等待的单个线程。调用此方法的线程必须拥有对象的监视器锁，否则会抛出IllegalMonitorStateException。

2. 唤醒的注意事项

  • notify()方法会随机唤醒等待线程池中的一个线程，而不是特定的线程。
  • 被唤醒的线程将继续执行，直到完成当前监视器锁的操作或者再次进入等待状态。
  • 如果一个线程是唯一等待在该对象上的，调用notify()方法会唤醒该线程。如果有多个线程在等待，则随机唤醒其中一个。

3. 代码示例

public class NotifyExample {
    public static void main(String[] args) {
        Object lock = new Object();

        Thread thread = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread is waiting...");
                    lock.wait(); // 等待唤醒
                    System.out.println("Thread woke up!");
                } catch (InterruptedException e) {
                    System.out.println("Thread was interrupted during wait.");
                }
            }
        });

        thread.start();

        try {
            Thread.sleep(500); // 主线程休眠，确保子线程先执行
            synchronized (lock) {
                lock.notify(); // 唤醒子线程
            }
        } catch (InterruptedException e) {
            System.out.println("Main thread was interrupted during sleep.");
        }
    }
}

线程唤醒所有等待线程（notifyAll）

1. 唤醒所有等待线程的基本概念

Thread.notifyAll()方法与notify()方法类似，但不同之处在于它会唤醒等待在该对象上的所有线程，而不仅仅是随机唤醒一个。

2. 代码示例

public class NotifyAllExample {
    public static void main(String[] args) {
        Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread1 is waiting...");
                    lock.wait();
                    System.out.println("Thread1 woke up!");
                } catch (InterruptedException e) {
                    System.out.println("Thread1 was interrupted during wait.");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread2 is waiting...");
                    lock.wait();
                    System.out.println("Thread2 woke up!");
                } catch (InterruptedException e) {
                    System.out.println("Thread2 was interrupted during wait.");
                }
            }
        });

        thread1.start();
        thread2.start();

        try {
            Thread.sleep(500);
            synchronized (lock) {
                lock.notifyAll(); // 唤醒所有等待线程
            }
        } catch (InterruptedException e) {
            System.out.println("Main thread was interrupted during sleep.");
        }
    }
}

总结

Java线程休眠与唤醒机制是线程同步的关键技术。正确地使用这些机制，可以帮助我们控制线程的执行顺序，提高程序的效率和可靠性。在实际编程中，我们需要根据具体需求选择合适的休眠和唤醒方法，确保线程间的协作和同步。

-- 展开阅读全文 --