当前位置： 首页 > news >正文

Java并发编程实战 02 | 为什么创建线程只有一种方法？

news 来源：原创 2024/9/20 8:13:56

在 Java 中，我们如何创建和使用线程？为什么说线程的创建方式本质上只有一种呢？本文将从并发编程的基础——如何创建线程开始，希望大家能够打好基础。虽然线程的创建看起来很简单，但其中还是有很多细节值得深入探讨。最后，我们将揭开线程实现的面纱，看清它的本质。

首先，大家可以思考一个问题：线程的实现方式有几种？大多数人会回答 2 种、3 种，甚至 4 种，但很少有人会说只有 1 种。我们先来看看常见的两种线程实现方式，以及它们背后的本质。

Thread 类和 Runnable 接口

继承Thread类

创建线程的第一种方式是继承类Thread`类，重写其中的run()方法：

class SayHelloThread extends Thread {public void run() {System.out.println("hello world");}
}public class ThreadJavaApp {public static void main(String[] args) {SayHelloThread sayHelloThread = new SayHelloThread();sayHelloThread.start();}
}//输出：
hello world

示例中在主线程中创建 SayHelloThread 实例并调用start()方法后，子线程才会启动！

实现 Runnable 接口

在 Java 中，除了直接继承 Thread 类来实现线程之外，我们还可以通过实现 Runnable 接口来创建线程。

首先我们看一下Runnable接口的地源码：

@FunctionalInterface
public interface Runnable {public abstract void run();
}

我们需要实现 Runnable 接口中的 run() 方法来定义线程的任务。

然而，无论是哪种方式，最终我们还是需要通过 Thread 类来启动和驱动线程。换句话说，Runnable 接口只是定义了任务的内容，而实际的线程启动和执行还是依赖于 Thread 类。

class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("Hello Runnable");}
}public class RunnableDemo {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();new Thread(myRunnable).start();}
}//输出：
Hello Runnable

此外，从 Runnable 接口的定义可以看出，它是一个函数式接口。这意味着我们可以利用 Java 8 的函数式编程 来简化代码。通过使用 Lambda 表达式，我们可以更简洁地创建和传递线程任务。

public class RunnableDemo {public static void main(String[] args) {// Java 8 functional programming, you can omit the definition of MyThread classnew Thread(() -> {System.out.println("Lambda expression implement Runnable");}).start();}
}//输出：
Lambda expression implement Runnable

Callable、Future 和 FutureTask

无论是通过实现 Runnable接口 还是继承 Thread 类来创建新线程，这两种方式都有一个缺点，就是 run() 方法没有返回值。

但是大多数场景我们希望启动一个线程执行某项任务，并在任务完成后获得一个返回值。为了解决这个问题，JDK 提供了 Callable 接口。

Callable接口

Callable 接口与 Runnable 类似，也是一个只有一个抽象方法的函数式接口。不同之处在于，Callable 的 call() 方法有返回值，并且支持泛型。这使得我们能够在执行任务时，获取到具体类型的结果。

@FunctionalInterface
public interface Callable<V> {V call() throws Exception;
}

通常，Callable 接口用于定义一个有返回值的任务。与 Runnable 类似，我们可以将实现了 Callable 接口的类传递给线程来执行。然而，你可能会发现，JDK 8 中的 Thread 类并没有提供接收 Callable 作为参数的构造函数。这并不是 Java 的错误，而是有意的设计选择。

Future 接口和 FutureTask 类

为了处理 Callable 任务并获得返回值，Java 提供了 FutureTask 类。FutureTask 实现了 RunnableFuture 接口，而 RunnableFuture 接口则继承了 Runnable 接口和 Future 接口。

这意味着 FutureTask 既可以作为 Runnable 被传递给 Thread 来执行，也可以用来处理异步计算并获取结果。

public interface RunnableFuture<V> extends Runnable, Future<V> {void run();
}

Future接口只有几个简单的方法：

public abstract interface Future<V> {public abstract boolean cancel(boolean paramBoolean);public abstract boolean isCancelled();public abstract boolean isDone();public abstract V get() throws InterruptedException, ExecutionException;public abstract V get(long paramLong, TimeUnit paramTimeUnit)throws InterruptedException, ExecutionException, TimeoutException;
}

各个方法的作用如下：

  • get()：阻塞当前线程，直到计算完成，并返回结果。
  • get(long timeout, TimeUnit unit)：阻塞当前线程，最多等待指定的时间。如果在这个时间内计算完成，则返回结果；如果超时未完成，则抛出 TimeoutException。
  • isDone：检查任务是否已完成。任务完成的状态包括正常终止、异常终止或被取消。无论是哪种情况，这个方法都会返回 true。
  • isCancelled：检查任务是否在正常完成之前被取消。如果是，返回 true。
  • cancel(boolean mayInterruptIfRunning)：尝试取消任务的执行。取消并不是一定成功的，因为任务可能已经完成或者由于其他原因无法取消。boolean 类型的返回值表示取消是否成功。参数 mayInterruptIfRunning 决定是否在取消任务时中断正在执行的线程。

有时，我们会使用 Callable 代替 Runnable，以便能够在任务执行过程中获取结果或取消任务。如果使用 Future 是为了获取可取消任务的结果，Future 的结果可能是 null。正如前面所说，Future 只是一个接口，若自己实现可能会很复杂。因此，Java 提供了 FutureTask 类，简化了 Future 的实现。

FutureTask 类结合 Callable 用于完成有返回值的异步计算。它提供了 Future 接口的方法，如 cancel、get 和 isDone，并将它们的实现封装起来，方便我们直接使用。以下是一个简单的 FutureTask 使用示例：

class MyCallable implements Callable<Integer> {/*** Calculate the sum from 1 to 4* @return*/@Overridepublic Integer call() {int res = 0;for (int i = 0; i < 5; i++) {res += i;}return res;}
}public class CallableDemo {public static void main(String[] args) throws ExecutionException, InterruptedException {// 1.Generate an instance of MyCallableMyCallable myCallable = new MyCallable();// 2.Create a FutureTask object through myCallableFutureTask<Integer> futureTask = new FutureTask<>(myCallable);// 3.Create a Thread object through FutureTaskThread t = new Thread(futureTask);// 4.start the threadt.start();// 5.Get calculation resultInteger res = futureTask.get();System.out.println(res);}
}//输出：
10

为什么只有一种方法来实现线程？

通过上面的介绍，相信这个问题大家基本上都有答案了：不管是通过实现Runnable接口，实现Callable接口还是直接继承Thread类来创建线程，最终的目的都是为了创建一个Thread实例来启动线程，也就是new Thread()，只是创建的形式不同而已！

除了这些常见创建线程的方法，还有其他的线程管理方式。例如，我们可以使用线程池等预置的工具类来创建和管理线程，这些工具类可以更高效地处理线程的生命周期和资源分配。后续的文章会单独介绍。

实现Runnable接口比继承Thread类更好。

Thread类的优点：

  • 简单直观：由于 Thread 类直接继承自 Thread，代码结构比较简单，容易理解和使用。
  • 线程控制：可以直接调用 Thread 类的方法来控制线程的状态，例如启动、暂停和停止等操作。

Thread类的缺点：

  • 单重继承的局限性：Java 不支持多重继承，因此如果继承了 Thread 类，就无法继承其他类，限制了类的扩展。
  • 代码耦合度：线程类与线程执行逻辑紧密耦合，可能导致代码的复用性和维护性下降。

Runnable接口的优点：

  • 更好的代码重用：通过实现 Runnable 接口，可以将线程执行逻辑（即 run() 方法中的代码）与线程的管理逻辑（如启动和控制线程的操作）分开了，实现更高的代码重用性。
  • 多重实现灵活性：由于接口可以实现多个，因此可以避免 Thread 类的单一继承限制。

Runnable接口的缺点：

  • 代码稍微复杂一些：需要创建一个实现 Runnable 接口的类，并实现 run() 方法，然后通过 Thread 类来启动线程。
  • 没有线程控制方法： Runnable 接口本身不包含线程控制方法，需要通过 Thread 对象来调用这些控制方法。

因此，综合考虑，通常建议通过实现Runnable接口来创建线程，以获得更好的代码可重用性和可扩展性。

线程的start()方法

在 Java 中，线程的启动是通过调用 start() 方法来实现的。当你在程序中调用 start() 方法时，虚拟机会首先创建一个新的线程，并且会等待这个线程首次获得 CPU 时间片之后才会调用 run() 方法来执行具体的任务。

需要注意的是，start() 方法只能被调用一次。如果尝试对同一个线程对象再次调用 start()，将会抛出 IllegalThreadStateException 异常。因为线程一旦启动，其状态会变为“准备”，之后不能再被重新启动。

下面是 start() 方法的简化源码说明：

public synchronized void start() {//0对应于状态“NEW”。if (threadStatus != 0)throw new IllegalThreadStateException();group.add(this);   boolean started = false;try {start0();   //The native method calls the underlying method that actually creates the thread.started = true;} finally {try {if (!started) {group.threadStartFailed(this);}} catch (Throwable ignore) {/* do nothing. If start0 threw a Throwable thenit will be passed up the call stack */}}
}

start() 方法的真正工作是由 start0() 完成的。start0() 是一个原生方法，它由底层操作系统实现，用于实际创建和启动线程。这一过程包括线程的初始化和调度，使得线程能够在 JVM 中并行执行。

关于ThreadGroup的概念我们会在后续的文章中介绍，这里可以先忽略，有个印象即可。

Thread类的几个常用方法

这里我们简要介绍一下 Thread 类的一些常用方法，了解这些方法可以帮助你更好地进行多线程编程。具体的使用场景将在后续的文章中详细讨论：

  • currentThread()：这是一个静态方法，用于返回当前正在执行的线程对象的引用。通过这个方法，你可以获取到当前线程的信息。
  • sleep(long millis)：这是一个静态方法，使当前线程休眠指定的时间（以毫秒为单位）。调用这个方法可以暂停线程的执行，直到指定的时间到达。
  • yield()：这个方法表示当前线程愿意让出对处理器的占用，从而允许其他线程获得执行机会。请注意，即使调用了 yield() 方法，当前线程仍然可能继续运行，具体是否让出取决于线程调度器的实现。
  • join()：这个方法使当前线程等待另一个线程执行完成后才继续执行。内部实际上是通过调用 Object 类的 wait() 方法来实现的。这对于确保一个线程在另一个线程完成后再继续执行非常有用。

相关文章：

  • 北京网站建设多少钱？
  • 辽宁网页制作哪家好_网站建设
  • 高端品牌网站建设_汉中网站制作
  • 【运维】Linux 离线升级指定版本的MariaDB
  • 天宇微纳ATE测试系统精准检测的方法
  • 【区块链 + 人才服务】区块链综合实训平台 | FISCO BCOS应用案例 | FISCO BCOS应用案例
  • Redis八种数据结构简介
  • 羲和能源大数据平台——Python数据绘图方法
  • NXP，S32K1XX汽车通用微控制器开发笔记
  • jdbc-day01
  • [python]线程与进程的区别及代码演示
  • C语言编译的过程
  • 数据资产入表元年，企业如何抓住数据资产增值的机遇？
  • 日志系统（最新版）
  • 09-03 周二 ansible部署与使用指南
  • 深入解析 Netty 的线程模型
  • Android13修改Setting实现电量低于30%的话不可执行Rest操作
  • 腾讯云Linux服务器运维，安装JDK、rabbitmq、nginx、Redis、ClickHouse
  • Angular4 模板式表单用法以及验证
  • canvas绘制圆角头像
  • JavaScript 无符号位移运算符 三个大于号 的使用方法
  • Java面向对象及其三大特征
  • js操作时间（持续更新）
  • REST架构的思考
  • sessionStorage和localStorage
  • TypeScript实现数据结构（一）栈，队列，链表
  • 官方新出的 Kotlin 扩展库 KTX，到底帮你干了什么？
  • 蓝海存储开关机注意事项总结
  • 我建了一个叫Hello World的项目
  • 限制Java线程池运行线程以及等待线程数量的策略
  • 原生Ajax
  • 你对linux中grep命令知道多少？
  • ​【数据结构与算法】冒泡排序：简单易懂的排序算法解析
  • #include到底该写在哪
  • $jQuery 重写Alert样式方法
  • （2015）JS ES6 必知的十个 特性
  • （solr系列:一）使用tomcat部署solr服务
  • （顶刊）一个基于分类代理模型的超多目标优化算法
  • （二）丶RabbitMQ的六大核心
  • （附源码）spring boot北京冬奥会志愿者报名系统 毕业设计 150947
  • (三分钟了解debug)SLAM研究方向-Debug总结
  • (算法)硬币问题
  • (微服务实战)预付卡平台支付交易系统卡充值业务流程设计
  • （小白学Java）Java简介和基本配置
  • ***php进行支付宝开发中return_url和notify_url的区别分析
  • .Net Remoting常用部署结构
  • .net wcf memory gates checking failed
  • .net 提取注释生成API文档 帮助文档
  • .NET导入Excel数据
  • .net后端程序发布到nignx上，通过nginx访问
  • .NET上SQLite的连接
  • .NET中统一的存储过程调用方法(收藏)
  • /usr/lib/mysql/plugin权限_给数据库增加密码策略遇到的权限问题
  • @Documented注解的作用
  • @RequestBody的使用
  • @require_PUTNameError: name ‘require_PUT‘ is not defined 解决方法
  • [2010-8-30]
  • [BZOJ] 3262: 陌上花开