线程创建的方式介绍-Java

在 Java 中，创建线程有几种不同的方式。每种方式有其特定的应用场景，选择适合的方式可以提高程序的可维护性和性能。

1. 继承 `Thread` 类

这是最简单的一种创建线程的方式，通过继承 Thread 类并重写 run() 方法来定义线程要执行的任务。

步骤：

创建一个类继承 Thread。
重写 run() 方法，定义线程执行的任务。
创建该类的实例，并调用 start() 方法启动线程。

示例代码：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running.");
    }

    public static void main(String[] args) {
        // 创建线程对象
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

解释：

MyThread 继承了 Thread 类，并重写了 run() 方法。
start() 方法启动线程，而 run() 方法定义了线程的执行内容。
该方法适用于任务比较简单且只需要定义一个线程的场景。

2. 实现 `Runnable` 接口

另一种创建线程的方式是实现 Runnable 接口。相比于继承 Thread 类，这种方式更加灵活，因为 Java 是单继承的，若继承了 Thread 类，则无法继承其他类，而实现 Runnable 接口允许类继承其他类。

步骤：

创建一个类实现 Runnable 接口。
重写 run() 方法，定义线程执行的任务。
创建 Thread 对象，将 Runnable 实现类的实例传递给 Thread 构造方法。
调用 Thread 对象的 start() 方法启动线程。

示例代码：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running.");
    }

    public static void main(String[] args) {
        // 创建 Runnable 对象
        MyRunnable myRunnable = new MyRunnable();

        // 创建线程对象，并将 Runnable 传递给线程
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

解释：

MyRunnable 类实现了 Runnable 接口，并重写了 run() 方法。
通过将 MyRunnable 对象传递给 Thread 构造函数来创建线程。
这种方法适用于需要继承其他类同时又需要创建线程的情况。

3. 使用 `Callable` 和 `Future` 接口

Callable 是一个可以返回值的接口，它与 Runnable 类似，但它可以在任务完成时返回结果。Callable 接口的 call() 方法可以抛出异常，因此相比 Runnable 更灵活。

Callable 接口：用于执行任务并返回结果。
Future 接口：用于获取 Callable 执行的结果。

步骤：

创建一个类实现 Callable 接口。
重写 call() 方法，定义线程执行的任务。
创建 ExecutorService，提交 Callable 任务，并通过 Future 获取结果。

示例代码：

import java.util.concurrent.*;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " is running.");
        return "Task Completed";
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 创建 Callable 对象
        MyCallable myCallable = new MyCallable();

        // 创建 ExecutorService 对象
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // 提交任务并获取 Future 对象
        Future<String> future1 = executorService.submit(myCallable);
        Future<String> future2 = executorService.submit(myCallable);

        // 获取结果
        System.out.println("Result of thread 1: " + future1.get());
        System.out.println("Result of thread 2: " + future2.get());

        // 关闭 ExecutorService
        executorService.shutdown();
    }
}

解释：

MyCallable 实现了 Callable 接口，重写了 call() 方法。
ExecutorService 用于管理线程池，submit() 方法提交 Callable 任务，并返回一个 Future 对象。
Future.get() 方法可以获取 Callable 执行的返回值。
使用 Callable 和 Future 可以获取线程的返回值并处理异常，适用于需要计算结果并返回的场景。

4. 使用 `ExecutorService` 管理线程池

ExecutorService 是 Java 提供的一个线程池接口，它可以帮助你更高效地管理线程。使用线程池避免了频繁地创建和销毁线程，从而提高了性能。ExecutorService 提供了更灵活和高效的线程管理。

步骤：

使用 ExecutorService 创建线程池。
提交任务给线程池，线程池会根据需要执行这些任务。

示例代码：

import java.util.concurrent.*;

class Task implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running.");
    }

    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 提交多个任务
        for (int i = 0; i < 5; i++) {
            executorService.submit(new Task());
        }

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