【Java】了解线程 Thread 类的使用,如何创建、终止、等待一个线程以及获取线程的状态

一只淡水鱼66 2024-08-26 14:35:01 阅读 69

线程是什么

线程是操作系统中调度的基本单位,是比进程更小的执行单元。线程在进程内部运行,共享该进程的资源,如内存和文件句柄,但每个线程都有自己的执行栈和程序计数器。

线程的主要特点包括:

轻量级:线程相较于进程更加轻量,创建和销毁的开销较小。共享资源:同一进程中的线程共享该进程的内存空间和资源,从而可以更高效地进行数据交换。并发执行:多个线程可以并发执行,充分利用多核处理器,提高程序的执行效率。简化管理:线程的切换和管理相对于进程更为简单和迅速,有助于提升系统的响应速度。

线程的使用在现代操作系统中非常普遍,尤其是在需要高并发和高性能的应用场景中,例如网络服务器和多任务应用程序等。

为什么要有线程

首先, "并发编程" 成为 "刚需"。

单核 CPU 的发展遇到了瓶颈. 要想提高算力, 就需要多核 CPU. 而并发编程能更充分利用多核 CPU资源。

有些任务场景需要 "等待 IO", 为了让等待 IO 的时间能够去做一些其他的工作, 也需要用到并发编

程。

其次, 虽然多进程也能实现 并发编程, 但是线程比进程更轻量。

创建线程比创建进程更快.销毁线程比销毁进程更快.调度线程比调度进程更快.

创建出一个线程

在Java中,可以通过两种主要方式创建线程:继承<code>Thread类和实现Runnable接口。下面分别介绍这两种方式,并附上代码示例。

方法一:继承 Thread 类

创建一个子类,继承Thread类,并重写run()方法,该方法包含了线程的执行代码。创建子类的实例,然后调用start()方法来启动线程。

示例代码:

class MyThread extends Thread {

@Override

public void run() {

// 线程执行的代码

for (int i = 0; i < 5; i++) {

System.out.println("Thread running: " + i);

try {

Thread.sleep(1000); // 暂停1秒

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public class ThreadExample {

public static void main(String[] args) {

Thread thread = new MyThread(); // 创建线程对象

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

}

}

方法二:实现 Runnable 接口

创建一个类,实现Runnable接口,并实现run()方法。创建Runnable接口的实例,将其传递给Thread构造函数,然后调用start()方法启动线程。

示例代码:

class MyRunnable implements Runnable {

@Override

public void run() {

// 线程执行的代码

for (int i = 0; i < 5; i++) {

System.out.println("Runnable thread running: " + i);

try {

Thread.sleep(1000); // 暂停1秒

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public class RunnableExample {

public static void main(String[] args) {

MyRunnable myRunnable = new MyRunnable(); // 创建Runnable实例

Thread thread = new Thread(myRunnable); // 将Runnable实例传递给Thread

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

}

}

解析:

在这两个示例中,我们创建了一个简单的线程,该线程在运行时每秒打印一次数字(0到4)。使用Thread.sleep(1000)使线程暂停1秒,这样可以模拟一些耗时的操作,也使得输出不至于淹没在快速的执行中。调用start()方法时,Java虚拟机会调用线程的run()方法,而不是直接调用run()。这保证了线程的正确启动和管理。

总结:

通过这两种方式,Java允许灵活地创建和管理线程,开发者可以根据具体需求选择适合的方式。继承Thread类比较直接,但实现Runnable接口则可以实现更灵活的线程管理和资源共享。

引入匿名内部类和 Lambda 简化上述方法

匿名内部类

方法一

public class ThreadExample {

public static void main(String[] args) {

Thread thread = new Thread() {

// 线程执行的代码

@Override

public void run() {

// 线程执行的代码

for (int i = 0; i < 5; i++) {

System.out.println("Runnable thread running: " + i);

try {

Thread.sleep(1000); // 暂停1秒

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

};

thread.start();

}

}

方法二

public class ThreadExample {

public static void main(String[] args) {

Thread thread = new Thread(new Runnable() {

@Override

public void run() {

// 线程执行的代码

for (int i = 0; i < 5; i++) {

System.out.println("Runnable thread running: " + i);

try {

Thread.sleep(1000); // 暂停1秒

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

});

thread.start();

}

}

   Lambda 表达式

public class ThreadExample {

public static void main(String[] args) {

Thread thread = new Thread(() -> {

// 线程执行的代码

for (int i = 0; i < 5; i++) {

System.out.println("Runnable thread running: " + i);

try {

Thread.sleep(1000); // 暂停1秒

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

thread.start();

}

}

Lambda 表达式由于简洁,所以是日常开发中常用的方法。

查看线程

当我们创建好一个线程后如何查看线程的状态呢?

使用 jconsole 命令观察线程

我们打开 jdk 文件夹所在目录,找到 bin 文件夹。

找到 jconsole.exe 双击打开。

 

 选择我们的类名的选项,点击连接。

 连接好了后,选择线程,然后找到 Thread-0 这个就是我们手动创建的线程,我们可以查看该线程的运行情况。

 Thread 中常见的方法

<code>Thread类是Java中用于创建和管理线程的重要类,提供了多种方法来控制线程的行为和状态。以下是一些常见的Thread类方法:

**start()**:启动线程,JVM会调用线程的run()方法。

**run()**:线程执行的代码逻辑所在的方法。可以被重写来定义线程的任务。

**sleep(long millis)**:使当前线程暂停指定的时间(毫秒),在此期间线程不会执行。

**join()**:等待调用该方法的线程完成后再继续执行。这是实现线程间的同步的一种方式。

**interrupt()**:中断线程,设置线程的中断状态。如果该线程正在阻塞(例如在sleep()wait()中),则会抛出InterruptedException

**isAlive()**:判断线程是否仍在运行中,返回true表示线程处于活动状态。

**getName()**:返回线程的名称。

**setName(String name)**:设置线程的名称。

**getPriority()**:返回线程的优先级。

**setPriority(int priority)**:设置线程的优先级,优先级范围为Thread.MIN_PRIORITY(1)到Thread.MAX_PRIORITY(10)。

**yield()**:提示调度器当前线程愿意让出对 CPU 的占用,由其他同等或更高优先级的线程获得执行机会。

**currentThread()**:静态方法,返回对当前正在执行的线程对象的引用。

示例:

以下是一个简单的代码示例,演示了部分常见方法的用法:

class MyThread extends Thread {

@Override

public void run() {

System.out.println(getName() + " is running");

try {

sleep(1000); // 暂停1秒

} catch (InterruptedException e) {

System.out.println(getName() + " was interrupted");

}

System.out.println(getName() + " has finished running");

}

}

public class ThreadMethodsExample {

public static void main(String[] args) {

MyThread thread1 = new MyThread();

MyThread thread2 = new MyThread();

thread1.setName("Thread-1");

thread2.setName("Thread-2");

thread1.start();

thread2.start();

try {

thread1.join(); // 等待thread1完成

thread2.join(); // 等待thread2完成

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("All threads have finished executing.");

}

}

在这个示例中,我们创建了两个线程,设置了它们的名称,并演示了start()sleep()join()方法的使用。

如何中断一个线程

在Java中,手动中断一个线程的原理主要依赖于线程的 interrupt() 方法和线程的 isInterrupted() 状态。通过调用一个线程的 interrupt() 方法,可以设置该线程的中断状态为 true。这通常用于通知线程它应该停止当前的工作,并进行清理或其他的收尾操作。

当一个线程被中断后,如果该线程在阻塞状态(例如,等待输入、休眠等),则会抛出 InterruptedException。如果线程在其他执行状态中,通常需要在合适的位置检查该线程的中断状态,决定是否需要停止执行。

以下是一个简单的案例,展示如何手动中断一个线程:

示例代码

class MyRunnable implements Runnable {

@Override

public void run() {

try {

System.out.println("线程开始工作...");

// 模拟长时间工作的情况

for (int i = 0; i < 10; i++) {

// 检查线程是否被中断

if (Thread.currentThread().isInterrupted()) {

System.out.println("线程被中断,退出工作...");

return; // 退出运行

}

System.out.println("工作中: " + i);

// 模拟工作过程中的延时

Thread.sleep(1000);

}

} catch (InterruptedException e) {

// 如果线程因为sleep被中断,会抛出InterruptedException

System.out.println("线程被中断,捕获到异常: " + e.getMessage());

} finally {

System.out.println("线程清理工作,准备结束...");

}

}

}

public class ThreadInterruptExample {

public static void main(String[] args) throws InterruptedException {

Thread myThread = new Thread(new MyRunnable());

myThread.start();

// 主线程等待2秒,然后中断myThread

Thread.sleep(2000);

System.out.println("主线程请求中断myThread...");

myThread.interrupt(); // 中断线程

// 等待myThread结束

myThread.join();

System.out.println("主线程结束。");

}

}

代码解释

MyRunnable 类实现 Runnable 接口并重写 run() 方法。在 run() 方法中,模拟了一个长时间工作的循环,每次循环检查线程的中断状态。如果线程被中断,可以通过 Thread.currentThread().isInterrupted() 方法来检测,并通过返回来优雅地退出工作。在主线程中,创建并启动一个新线程,等待2秒后调用 interrupt() 方法中断它。如果在 sleep() 等待期间线程被中断,InterruptedException 将被抛出,因此可以在 catch 块中进行相应处理。最后,使用 join() 等待 myThread 完成所有操作后再结束主线程。

总结

通过这个案例,可以清晰地看到如何手动中断线程以及如何处理线程的中断状态。这种机制在多线程编程中非常重要,确保了线程可以在合适的时机响应中断请求,从而实现更好的资源管理和程序健壮性。

join 等待一个线程

在Java中,等待一个线程的原理主要依赖于 Thread 类中的 join() 方法。调用 join() 方法可以使当前线程(即调用 join() 的线程)等待另一个线程完成执行。原理是通过线程的状态管理,使得调用 join() 的线程在被调用线程执行完之前不会继续执行,确保线程之间的执行顺序。

示例代码

下面是一个简单的案例,展示如何等待一个线程的完成:

class MyRunnable implements Runnable {

@Override

public void run() {

System.out.println("线程 " + Thread.currentThread().getName() + " 开始工作...");

try {

// 模拟长时间的工作

Thread.sleep(2000); // 休眠2秒

} catch (InterruptedException e) {

System.out.println("线程被中断: " + e.getMessage());

}

System.out.println("线程 " + Thread.currentThread().getName() + " 工作完成。");

}

}

public class ThreadJoinExample {

public static void main(String[] args) {

Thread myThread = new Thread(new MyRunnable(), "MyThread");

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

try {

System.out.println("主线程等待 " + myThread.getName() + " 完成...");

myThread.join(); // 等待 myThread 完成

} catch (InterruptedException e) {

System.out.println("主线程被中断: " + e.getMessage());

}

System.out.println("主线程继续执行,已等待 " + myThread.getName() + " 完成。");

}

}

代码解释

MyRunnable 类:实现 Runnable 接口并重写 run() 方法。在 run() 方法中,我们模拟了一个长时间的工作,使用 Thread.sleep(2000) 使线程休眠 2 秒。主类 ThreadJoinExample

创建一个新的线程 myThread,并将 MyRunnable 实例作为参数传入。启动线程 myThread,这会调用其 run() 方法。在主线程中,调用 myThread.join(),这将使主线程等待 myThread 完成执行。一旦 myThread 执行完成,主线程将继续执行,并打印出相应的信息。

总结

通过这个案例,可以看到如何使用 join() 方法来等待线程的完成。这样可以有效地控制线程的执行顺序,确保在某些操作完成后再进行后续处理。例如,在多个线程之间需要协调工作时,使用 join() 使得某些操作依赖于另一个线程的完成,可以减少潜在的竞争和数据不一致问题。这种机制在多线程编程中非常重要,特别是在任务依赖的场景下。

获取线程的状态

在Java中,线程的状态主要有以下几种:

NEW(新建):当线程被创建但尚未开始运行时,处于此状态。RUNNABLE(可运行):线程可以运行,也可能正在运行。这并不一定意味着线程正在执行,因为线程调度可能把该线程挂起。BLOCKED(阻塞):线程在等待一个监视器锁时被阻塞,无法继续执行。WAITING(等待):线程在等待另一个线程执行特定动作时进入此状态,如等待锁的释放。TIMED_WAITING(计时等待):线程在等待特定时间段内的某个条件时进入此状态。TERMINATED(终止):线程完成执行或因异常退出后进入此状态。

如何获取线程状态

可以使用 Thread 类的 getState() 方法来获取线程的当前状态。下面是一个示例代码,展示了如何创建线程并获取其状态:

public class ThreadStateExample {

public static void main(String[] args) {

Thread thread = new Thread(new MyRunnable());

// 获取并打印状态:NEW

System.out.println("Thread state after creation: " + thread.getState());

thread.start();

// 获取并打印状态:RUNNABLE

System.out.println("Thread state after starting: " + thread.getState());

try {

// 主线程等待一段时间以确保子线程有机会运行

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

// 获取并打印状态:TERMINATED

System.out.println("Thread state after completion: " + thread.getState());

}

static class MyRunnable implements Runnable {

@Override

public void run() {

// 子线程正在运行

try {

// 模拟一些工作

Thread.sleep(200);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

说明

创建线程:在创建 Thread 对象后,可以通过 getState() 获取其状态,初始状态为 NEW启动线程:调用 start() 方法后,线程状态可能变为 RUNNABLE等待:主线程通过 sleep() 方法等待,使子线程有机会执行。观察状态:通过 getState() 方法可以随时获取线程的状态。

这种方式能够有效地跟踪线程的状态变化,以便在多线程编程中进行调试和控制。



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。