「 Java并发编程 」 线程停止的方式_java线程暂停和恢复

「 Java并发编程 」 线程停止的方式

---

---

前言

在Java中，线程暂停是一种常见的操作，它可以使一个线程暂停执行一段时间，然后再继续执行。这种操作主要用于控制线程的运行状态和调度。线程暂停可以通过多种方式实现，例如：使用Thread.sleep()方法、使用Object.wait()方法等。不同的线程暂停方式适用于不同的场景，开发者需要根据具体情况选择合适的方式。在本篇博文中，我们将会介绍Java中常用的线程暂停方式以及它们的应用场景。

一、Thread.sleep()

使用Thread.sleep()方法，让线程休眠一段时间。

例如：

try {
    Thread.sleep(5000); // 让线程休眠5秒钟
} catch (InterruptedException e) {
    e.printStackTrace();
}
1
2
3
4
5

---

二、Object.wait()

使用Object.wait()方法挂起线程，在另一个线程中调用notify()或notifyAll()方法唤醒线程。

例如：

Object lock = new Object();

// 等待线程
synchronized (lock) {
    System.out.println("Waiting...");
    try {
        lock.wait();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("Resumed");
}

// 唤醒线程
synchronized (lock) {
    lock.notifyAll();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个例子中，等待线程首先获取了锁对象，并调用了wait()方法挂起自己，然后唤醒线程获取了相同的锁并调用了notifyAll()方法唤醒等待的线程。

---

三、Lock和Condition

使用java.util.concurrent包中的Lock和Condition接口实现线程挂起和唤醒。

例如：

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

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

// 等待线程
lock.lock();
try {
    System.out.println("Waiting...");
    condition.await();
    System.out.println("Resumed");
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    lock.unlock();
}

// 唤醒线程
lock.lock();
try {
    System.out.println("Notifying...");
    condition.signalAll();
} finally {
    lock.unlock();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在这个例子中，等待线程首先获取了锁对象，并调用了await()方法挂起自己，然后唤醒线程获取了相同的锁并调用了signalAll()方法唤醒等待的线程。

---

四、Thread.yield()

使用Thread.yield()方法，让当前线程让出CPU时间片，使得其他线程有机会获得执行。

例如：

Thread.yield(); // 当前线程让出CPU时间片
1

---

五、volatile关键字

5. 使用volatile关键字控制线程的可见性，通过修改共享变量的值来暂停或恢复线程的执行。

例如：

volatile boolean suspended = false;

// 等待线程
while (suspended) {
    Thread.sleep(1000); // 线程休眠1秒钟
}

// 暂停线程
suspended = true;

// 恢复线程
suspended = false;
1
2
3
4
5
6
7
8
9
10
11
12

在这个例子中，等待线程通过检查suspended变量的值来判断是否需要暂停自己的执行。当需要暂停时，线程调用sleep()方法休眠一段时间，然后再次检查suspended变量的值。暂停线程则通过修改suspended变量的值来通知等待线程暂停自己的执行。恢复线程则同样通过修改suspended变量的值来通知等待线程恢复自己的执行。需要注意的是，使用volatile变量来控制线程的可见性必须保证所有读写该变量的线程都是使用volatile关键字进行访问。

---

六、Thread.suspend()和Thread.resume()

使用Thread.suspend()和Thread.resume()方法暂停和恢复线程的执行。不过需要注意，这两个方法已经被标记为不推荐使用，并且可能会产生死锁等问题，因此尽量避免使用。

例如：

// 创建一个线程
Thread thread = new Thread(() -> {
    while (true) {
        System.out.println("Running...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

// 启动线程
thread.start();

// 暂停线程
thread.suspend();

// 恢复线程
thread.resume();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这个例子中，通过调用Thread对象的suspend()方法暂停线程的执行，再通过调用resume()方法恢复线程的执行。可以看到，这种方式可能会导致线程死锁等问题，因此建议尽量避免使用。