Java多线程（一）Thread、Runnable、Callable、Future、ExecutorService接口

Java多线程类和接口

在Java中，多线程编程是一项非常重要的技能，它允许程序同时执行多个任务，从而提高程序的执行效率和响应速度。

Java通过提供一系列的类和接口来支持多线程编程，主要包括Thread类、Runnable接口、Callable接口、Future接口以及ExecutorService接口等。

下面我们将逐一深入介绍这些类和接口。

1. Thread 类

Thread 是Java中实现多线程的核心类。

一个线程就是Thread类的一个实例。

Java虚拟机（JVM）允许应用程序并发地运行多个执行线程。每个线程都可以并行执行不同的任务。

主要方法：

• start(): 启动线程，使线程进入就绪状态（ready state），等待被调度执行。

• run(): 线程在被调度时执行的操作。通常，我们会重写Thread类的run方法来定义线程的执行体。

• join(): 等待该线程终止。这个方法会阻塞调用它的线程，直到目标线程结束。

• sleep(long millis): 使当前正在执行的线程以指定的毫秒数暂停（临时停止执行）。

示例：

public class MyThread extends Thread {  
    public void run() {  
        System.out.println("Hello from MyThread!");  
    }  
  
    public static void main(String[] args) {  
        MyThread t = new MyThread();  
        t.start();  
    }  
}

2. Runnable 接口

Runnable 接口提供了一种更灵活的方式来创建线程。

实现Runnable接口的类需要实现run()方法。

与继承Thread类相比，这种方式更加灵活，因为Java不支持多重继承，但可以实现多个接口。

主要方法：

• run(): 当线程启动时，此方法会被执行。

示例：

public class MyRunnable implements Runnable {  
    public void run() {  
        System.out.println("Hello from MyRunnable!");  
    }  
  
    public static void main(String[] args) {  
        Thread t = new Thread(new MyRunnable());  
        t.start();  
    }  
}

3. Callable 接口和Future接口

Callable 接口类似于Runnable接口，但它可以返回一个结果，并且可以抛出异常。

Future接口用于表示异步计算的结果。它是Callable任务执行完成后的结果。

主要方法（Callable）:

• V call() throws Exception: 计算返回的结果。

Future主要方法：

• V get() throws InterruptedException, ExecutionException: 如有必要，等待计算完成，然后检索其结果。

• boolean isDone(): 如果计算完成，则返回true。

示例：在Java中，Callable 接口和 Future 接口经常一起使用，以实现可以返回结果的异步计算。Callable 接口类似于 Runnable，但它可以返回一个结果，并且可以抛出一个异常。当你提交一个 Callable 任务给 ExecutorService 时，它会返回一个 Future 对象，该对象代表异步计算的结果。

以下是一个使用 Callable 接口和 Future 接口的示例：

import java.util.concurrent.*;

// 实现Callable接口
class MyCallable implements Callable<Integer> {
    private int number;

    public MyCallable(int number) {
        this.number = number;
    }

    @Override
    public Integer call() throws Exception {
        // 模拟耗时计算
        Thread.sleep(1000);
        return number * number;
    }
}

public class CallableFutureExample {
    public static void main(String[] args) {
        // 创建一个ExecutorService
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交Callable任务给ExecutorService
        Future<Integer> future1 = executor.submit(new MyCallable(5));
        Future<Integer> future2 = executor.submit(new MyCallable(10));

        try {
            // 获取并打印结果
            System.out.println("Result of 5 * 5 = " + future1.get());
            System.out.println("Result of 10 * 10 = " + future2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

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

在这个示例中：

1. 我们定义了一个 MyCallable 类，它实现了 Callable<Integer> 接口。call 方法模拟了一个耗时操作（通过 Thread.sleep(1000)），然后返回了输入数字的平方。

2. 在 main 方法中，我们创建了一个 ExecutorService，它管理着一组线程，这些线程用于异步执行任务。

3. 我们向 ExecutorService 提交了两个 MyCallable 任务，每个任务都封装在 Future<Integer> 对象中。Future 对象用于跟踪异步计算的结果。

4. 通过调用 future1.get() 和 future2.get()，我们等待并获取了异步计算的结果。注意，get 方法会阻塞调用它的线程，直到计算完成。

5. 最后，我们关闭了 ExecutorService 以释放资源。

这个示例展示了如何使用 Callable 和 Future 来实现可返回结果的异步计算。与 Runnable 相比，Callable 提供了更丰富的功能，特别是能够处理返回结果和异常。

4. ExecutorService 接口

ExecutorService 提供了一种管理终止（shutdown）以及方法提交（submit）任务的接口。

它扩展了Executor接口，并添加了用于管理生命周期和任务结果的方法。

主要方法：

• void shutdown(): 启动关闭过程，不再接受新任务，但已提交的任务将继续执行。

• List<Future<?>> shutdownNow(): 尝试停止所有正在执行的任务，停止处理正在等待的任务，并返回等待执行的任务列表。

• <T> Future<T> submit(Callable<T> task): 提交一个Callable任务用于执行，并返回一个表示该任务等待完成的Future。

• void execute(Runnable command): 执行给定的命令。可能由于新任务的到达而在线程池的任何线程中异步执行。

示例：

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class ThreadPoolExample {  
    public static void main(String[] args) {  
        ExecutorService executor = Executors.newFixedThreadPool(2);  
  
        for (int i = 0; i < 5; i++) {  
            Runnable worker = new WorkerThread("" + i);  
            executor.execute(worker);  
        }  
        executor.shutdown();  
        while (!executor.isTerminated()) {  
            // 等待所有任务完成  
        }  
        System.out.println("所有任务完成");  
    }  
  
    static class WorkerThread implements Runnable {  
        private String command;  
  
        public WorkerThread(String s) {  
            this.command = s;  
        }  
  
        @Override  
        public void run() {  
            System.out.println(Thread.currentThread().getName() + " 开始执行命令: " + command);  
            processCommand();  
            System.out.println(Thread.currentThread().getName() + " 命令执行完毕: " + command);  
        }  
  
        private void processCommand() {  
            try {  
                Thread.sleep(500);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

最后

Java多线程编程是一个广泛的主题，这里只是介绍了其中的一些基础类和接口。

深入理解这些类和接口及其使用场景，对于编写高效、稳定的多线程Java程序至关重要。