java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java线程Thread.sleep对象wait

java线程Thread.sleep()对比对象的wait示例解析

作者：赵KK日常技术记录

这篇文章主要为大家介绍了java线程Thread.sleep()对比对象的wait示例解析,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

java多线程

多线程编程是现代软件开发中的常见需求，而线程的控制和协作则是其中的关键挑战之一。在Java中，有两种主要的方法可以用来让线程暂停执行：Thread类的sleep()方法和对象的wait()方法。本文将深入研究这两种方法，分析它们的区别，以及在不同情况下何时使用哪种方式来控制线程的执行。

Thread.sleep() 方法

Thread.sleep()方法是Thread类的静态方法，用于让当前线程休眠一段指定的时间。该方法接受一个毫秒数作为参数，表示线程将休眠的时间长度。在休眠期间，线程不会释放它所持有的任何锁，因此其他线程无法获得这些锁。

以下是一个简单的示例，演示了如何使用Thread.sleep()方法：

public class SleepExample {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Start of the program");
        Thread.sleep(2000); // 线程休眠2秒
        System.out.println("End of the program");
    }
}

在上面的示例中，主线程休眠了2秒后继续执行。

对象的 wait() 方法

wait()方法是Object类的方法，用于让当前线程等待，直到其他线程调用相同对象的notify()或notifyAll()方法来唤醒它。wait()方法通常与synchronized关键字一起使用，以确保线程在等待期间释放锁，从而允许其他线程访问共享资源。

以下是一个示例，演示了如何使用wait()和notify()方法来实现线程的协作：

public class WaitNotifyExample {
    public static void main(String[] args) {
        final Object lock = new Object();
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {
                    System.out.println("Thread 1: Waiting...");
                    try {
                        lock.wait(); // 等待被唤醒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread 1: Resumed.");
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {
                    System.out.println("Thread 2: Waking up Thread 1...");
                    lock.notify(); // 唤醒等待的线程
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}

在上面的示例中，thread1等待被thread2唤醒，然后继续执行。

Thread.sleep() vs. 对象的 wait()：区别对比

现在让我们比较一下Thread.sleep()方法和对象的wait()方法的区别。

1. 暂停的对象不同：

2. 使用场景不同：

3. 锁的释放情况不同：

4. 唤醒方式不同：

5. 异常处理不同：

示例代码

让我们继续之前的示例，演示如何使用wait()和notify()来实现线程的协作。

public class WaitNotifyExample {
    public static void main(String[] args) {
        final Object lock = new Object();
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {
                    System.out.println("Thread 1: Waiting...");
                    try {
                        lock.wait(); // 等待被唤醒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread 1: Resumed.");
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {
                    try {
                        Thread.sleep(2000); // 等待2秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread 2: Waking up Thread 1...");
                    lock.notify(); // 唤醒等待的线程
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}

在这个续篇示例中，thread1使用wait()方法等待被thread2唤醒，而thread2使用Thread.sleep()方法休眠2秒后唤醒thread1。这个示例演示了Thread.sleep()和wait()在协作中的不同用法。

结语

Thread.sleep()方法和对象的wait()方法都可以让线程暂停执行，但它们有不同的用途和行为。选择哪种方式取决于你的需求和场景。希望本文能够帮助你更好地理解这两种方法的区别，以及如何在多线程编程中使用它们。

以上就是java线程Thread.sleep()对比对象的wait示例解析的详细内容，更多关于java线程Thread.sleep对象wait的资料请关注脚本之家其它相关文章！

阅读全文