什么是线程

线程（Thread）是计算机科学中的一个重要概念，它是操作系统能够进行运算调度的最小单位。线程是比进程更小的执行单元，一个进程中可以包含多个线程，这些线程共享进程的资源和内存空间，每个线程都有自己独立的执行路径。

线程的基本特性

1. 轻量级: 相对于进程而言，线程的创建和销毁成本更低，切换速度更快。
2. 共享资源: 同一进程内的所有线程共享进程的内存空间和其他资源，这使得线程间的通信更加容易。
3. 并发执行: 多个线程可以并发执行，这意味着它们可以在同一时间内看似同时运行（实际上是由操作系统调度执行）。
4. 独立性: 每个线程有自己的执行路径（即线程函数）和一组寄存器（包括程序计数器），这意味着每个线程有自己的控制流。

线程的状态

线程在其生命周期中可能会处于以下几种状态：

• 新建 (New): 线程对象已经创建，但尚未开始执行。
• 就绪 (Runnable): 线程已准备好执行，等待 CPU 分配时间片。
• 运行 (Running): 线程正在使用 CPU 执行。
• 阻塞 (Blocked): 线程因等待某种条件（如 I/O 操作或锁）而暂时不能执行。
• 死亡 (Terminated): 线程执行完毕或因异常而终止。
• 示意图
  

线程的调度

操作系统负责线程的调度，通常有两种主要的调度模式：

• 抢占式调度 (Preemptive Scheduling): 操作系统可以随时中断正在运行的线程，并将 CPU 分配给另一个线程。
• 非抢占式调度 (Non-preemptive Scheduling): 也称为合作式调度，线程必须显式地放弃 CPU 时间片。

线程的实现方式

在 Java 中实现线程有多种方式，每种方式都有其适用的场景。以下是几种常见的实现线程的方式：

1. 继承 Thread 类

这是最直接的方式，通过继承 Thread 类并重写 run() 方法来定义线程的行为。这种方式简单易懂，但是由于 Java 不支持多重继承，因此如果还想让自己的类继承其他类的话，这种方式就不适用了。

public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("线程正在运行...");
        // 在这里执行线程的任务
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

2. 实现 Runnable 接口

实现 Runnable 接口是更常用的方式之一，因为它避免了类继承的问题，并且提供了更好的封装性。这种方式允许你将线程逻辑分离出来，使得类的设计更加模块化。

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("线程正在运行...");
        // 在这里执行线程的任务
    }

    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start(); // 启动线程
    }
}

3. 使用 Callable 和 Future

如果你希望线程能够返回一个结果，那么可以使用 Callable 接口代替 Runnable 接口。Callable 的 call() 方法可以返回一个值，并且可以抛出异常。通过 Future 接口可以获取这个返回值。

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

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("线程正在运行...");
        // 在这里执行线程的任务并返回结果
        return "线程执行完毕";
    }

    public static void main(String[] args) {
        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start(); // 启动线程

        try {
            String result = futureTask.get(); // 获取线程的结果
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4. 使用 ExecutorService

使用 ExecutorService 是一种更高级的方式，它可以管理和控制线程池中的线程，提供了更强大的功能，如线程管理、异步执行、回调等。

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

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("线程正在运行...");
        // 在这里执行线程的任务
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池
        MyRunnable runnable = new MyRunnable();
        executor.execute(runnable); // 提交任务到线程池
        executor.shutdown(); // 关闭线程池
    }
}

总结

以上是 Java 中实现线程的一些常见方式。选择哪种方式取决于具体的应用场景和个人喜好。对于简单的任务，可以直接使用 Thread 或 Runnable。对于需要返回结果的任务，可以使用 Callable 和 Future。而对于更复杂的并发任务管理，建议使用 ExecutorService。