(详解版)创建线程的四种方式

Java中创建线程的四种方式

---

接下来我会详细解释这四种方式创建线程如何实现.

我们如果要创建线程实例,就需要先知道 **线程是什么? 在Java中又是以怎样的形式存在的?**只有了解了这些我们才能更好的理解可以通过多种方式来创建线程.

Q: 线程是什么?

A: 线程（Thread）是计算机科学中的一个基本概念，是进程内的一个独立执行单元。一个进程可以包含多个线程，这些线程共享进程的资源，但拥有各自的执行路径。每个线程都是独立运行的，有自己的程序计数器（Program Counter）、寄存器集合和栈。

线程是程序执行的最小单元，它执行进程中的指令序列。相比于进程，线程的创建和销毁的开销较小，线程间的切换成本也相对较低。多线程的优势在于能够更好地利用多核处理器的性能，以及更有效地进行并发编程。

线程通常有两种模型：用户级线程和内核级线程。

1. 用户级线程： 用户级线程是由用户空间的线程库（Thread Library）管理的，而不需要操作系统内核的支持。用户级线程的切换由线程库在用户空间完成，相对较快。然而，用户级线程的一个缺点是，如果一个线程发生阻塞，整个进程都会被阻塞，因为内核并不知道线程的存在。
2. 内核级线程： 内核级线程是由操作系统内核管理的，它直接受操作系统的支持。内核级线程的切换涉及到内核的介入，相对较慢。但是，内核级线程的一个优点是如果一个线程发生阻塞，其他线程仍然可以继续执行。

Q:Java中线程又是以怎样的形式存在的?

A: Java中，线程是通过java.lang.Thread类来表示的。Java提供了多线程的支持，通过继承Thread类或实现Runnable接口，可以创建和管理线程。线程的执行通常通过调用线程的start方法来启动，而线程的实际执行逻辑则由run方法定义。

---

1. 继承Thread类并重写 run 方法来创建线程

2. 实现Runnable接口并实现 run 方法来创建线程。

由于前两种创建线程的方式比较的简单,所以我们就一起讲了,看了之后的解释,你也就会明白我会什么会把这两种方式一起讲了,因为二者的本质其实没有什么非常大的差别.

结构决定性质,我们首先先初步认识下线程的结构,通过查看Java标准库中的 java.lang.Thread类 中的构造方法,我们就可以初步判断出线程Thread对象创建的两种方式,分别是

1.继承Thread类,使用的是Thread类中的缺省构造器(无参构造方法) .

2. 实现Runnable接口,通过观察可以直到在Thread类中其他有参构造方法几乎都有Runnable这个接口 .

如下图:

• 那么我们继续思考,是否可以继续扩展?

现在我通过观察Java.lang.Thread类中的构造方法,知道了创建线程至少可以有这两种方法,分别是继承Thread类以及实现Runnable接口,那么我们是否可以继续扩展,由于创建线程实例的目的是重写run方法或者实现run方法,定义线程的执行逻辑。那么我是否可以加上匿名内部类或者Lambda的知识呢?这样的话,创建线程的方式又可以细分.

组合搭配之后创建线程的流程主要包括以下步骤：

1. 继承 Thread 类：

   • 创建一个继承自 Thread 类的新类。
   • 在新类中重写 run 方法，定义线程的执行逻辑。
   • 创建该类的实例。
   • 调用实例的 start 方法，启动线程。

   class MyThread extends Thread {
       public void run() {
           // 线程执行逻辑
       }
   }
   
   // 创建线程的实例
   MyThread myThread = new MyThread();
   // 启动线程
   myThread.start();
   

2. 实现 Runnable 接口：

   • 创建一个实现 Runnable 接口的类。
   • 在该类中实现 run 方法，定义线程的执行逻辑。
   • 创建 Thread 类的实例，将实现了 Runnable 接口的对象传递给 Thread 构造方法。
   • 调用 start 方法，启动线程。

   class MyRunnable implements Runnable {
       public void run() {
           // 线程执行逻辑
       }
   }
   
   // 创建线程的实例
   Thread thread = new Thread(new MyRunnable());
   // 启动线程
   thread.start();
   

3. 使用匿名内部类：

   • 使用匿名内部类创建线程，同时实现 run 方法。
   • 创建 Thread 类的实例。
   • 调用 start 方法，启动线程。

   Thread thread = new Thread(new Runnable() {
       public void run() {
           // 线程执行逻辑
       }
   });
   
   // 启动线程
   thread.start();
   

4. 使用 Lambda 表达式：

• 使用 Lambda 表达式创建线程，直接在 Runnable 接口的匿名实现中定义 run 方法。
• 创建 Thread 类的实例。
• 调用 start 方法，启动线程。

Thread thread = new Thread(() -> {
    // 线程执行逻辑
});

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

这些步骤涵盖了主要的线程创建方式。选择哪种方式取决于任务的性质以及对代码的偏好。无论哪种方式，最终的目标是定义线程的执行逻辑并启动线程。

---

接下来我们来学习剩下的两个创建线程的方式.

3. 使用Callable接口创建线程

认识Callable

Callable 接口是 Java 中用于表示可调用任务（可以返回结果并抛出异常）的接口。与 Runnable 接口不同，Callable 的 call 方法可以返回执行结果，而 Runnable 的 run 方法则没有返回值。通常，Callable 接口结合 Future 接口一起使用，Future 代表一个异步计算的结果，可以通过它来获取任务的执行结果，或者等待任务执行完毕.

• 帮助文档->接口Callable

• 帮助文档->FutureTask类

我们通过对照对比的方式来学习Callable接口哈,这样能够更好的帮助我们理解Callable接口,光看上面的解释和图片你可能不能第一时间消化,现在我们有一个例子,我们需要使用多线程来模拟一个耗时操作

• 不使用Callable接口和Future类

public class RunnableExample {

    public static void main(String[] args) {
        // 使用Runnable创建一个任务
        Runnable runnableTask = () -> {
            System.out.println("Executing Runnable task...");
            // 模拟一个耗时操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        // 创建一个线程来执行Runnable任务
        Thread thread = new Thread(runnableTask);
        thread.start();

        // 此时可以执行一些其他的操作
    }
}

• 使用 Callable 和 Future 的情况

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableExample {

    public static void main(String[] args) {
        // 使用Callable创建一个任务
        Callable<Integer> callableTask = () -> {
            System.out.println("Executing Callable task...");
            Thread.sleep(2000); // 模拟一个耗时操作
            return 42;
        };

        // 使用FutureTask包装Callable任务
        FutureTask<Integer> futureTask = new FutureTask<>(callableTask);

        // 创建一个线程来执行FutureTask
        Thread thread = new Thread(futureTask);
        thread.start();

        // 此时可以执行一些其他的操作

        try {
            // 获取Callable任务的执行结果，此处会阻塞直到任务执行完毕
            Integer result = futureTask.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

通过上述的3两个代码块我们来简单的做个总结:

使用 Callable 的优点：

1. 可以返回结果： Callable 允许任务返回一个结果，而 Runnable 不支持返回结果。这使得在并发编程中更容易获取任务的执行结果。
2. 支持异常抛出： Callable 的 call 方法可以抛出受检查的异常，而 Runnable 的 run 方法不能。这使得在任务执行过程中发生异常时，更容易捕获和处理异常。
3. 使用 Future 进行异步操作： Future 接口允许异步地获取任务的执行结果，而不需要等待任务完成。这对于并发编程中需要异步操作的场景非常有用。

总体而言，Callable 接口和 Future 接口的结合，提供了更多的灵活性和控制权，特别是在需要获取任务执行结果、处理异常或进行异步操作的情况下。

---

4. 使用Executor框架创建线程

Java中的Executor框架是一套用于简化多线程编程的工具和框架。它位于java.util.concurrent包下，提供了一种管理和执行线程的方式，使得开发者能够更轻松地编写并发程序。

Executor框架的主要组件包括以下几个：

1. Executor接口： 是Executor框架的根接口，定义了一个单一的方法 execute(Runnable command)，用于执行传入的任务（实现了Runnable接口的对象）。

2. ExecutorService接口： 继承自Executor接口，提供了更丰富的任务生命周期管理方法，例如提交任务、获取Future对象、关闭ExecutorService等。常见的实现类有ThreadPoolExecutor。

3. ScheduledExecutorService接口： 继承自ExecutorService接口，支持任务的定时执行和周期性执行。常见的实现类有ScheduledThreadPoolExecutor。

4. Executors工厂类： 提供了一些静态方法，用于创建不同类型的ExecutorService实例，例如创建固定大小的线程池、缓存线程池、单线程线程池等。

以下是一个简单的例子，演示了如何使用Executor框架创建线程池并提交任务：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorExample {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);//这里必须要看懂,后面内容我有给出解释

        // 提交任务给线程池执行
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executorService.execute(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

在这个例子中，通过Executors.newFixedThreadPool(2)创建了一个固定大小为2的线程池，然后通过execute方法提交了5个任务给线程池执行。这种方式可以有效地管理线程，使得任务可以并发执行，提高了程序的性能。

其中我们对这行代码进行一个详细的解释:

这段代码创建了一个固定大小为2的线程池，使用了ExecutorService接口，并通过Executors.newFixedThreadPool(2)工厂方法来实现。

1. ExecutorService接口： ExecutorService是Java Executor框架的一个接口，它扩展了Executor接口，提供更多的方法用于管理线程池和任务执行。

2. Executors.newFixedThreadPool(2)： Executors是一个工具类，提供了一些静态方法用于创建不同类型的ExecutorService实例。newFixedThreadPool(2)是其中一种方法，它创建了一个固定大小为2的线程池。这意味着线程池中最多会同时存在两个线程。

3. executorService： 这是创建的ExecutorService实例的引用，通过该引用可以操作和管理线程池。

综合起来，这行代码的作用是创建了一个固定大小为2的线程池，将其引用赋给executorService。这样，你就可以使用executorService来提交任务，线程池会负责管理这两个线程的生命周期、执行任务和处理任务队列。

---

结尾

以上的内容就是这篇文章带给大家的内容,我们详细的阐述了Java中创建线程的四种方式,如果有任何的问题或者疑问,非常欢迎大家在评论区评论!!!

。

3. executorService： 这是创建的ExecutorService实例的引用，通过该引用可以操作和管理线程池。

综合起来，这行代码的作用是创建了一个固定大小为2的线程池，将其引用赋给executorService。这样，你就可以使用executorService来提交任务，线程池会负责管理这两个线程的生命周期、执行任务和处理任务队列。

---

以上的内容就是这篇文章带给大家的内容,我们详细的阐述了Java中创建线程的四种方式,如果有任何的问题或者疑问,非常欢迎大家在评论区评论!!!