线程创建：并发编程的起点

引言：
线程是并发编程的核心基础。在 Java 中，线程的创建方式多种多样，各有特点。掌握线程的创建方法是我们迈向并发编程的大门，也是提升程序性能的起点。

本文不仅全面介绍线程的三种主要创建方式，还将通过实际案例与拓展思考，帮助你深刻理解线程的运行原理及使用场景。

1. 为什么要使用线程？

线程是现代计算机多任务操作的核心。使用线程可以显著提高程序的性能和响应速度。

常见场景：

• 高并发处理：如服务器处理多个用户请求。
• 任务并行：如图像处理、大数据计算。
• 异步任务：如文件下载、消息处理。

但是，线程也带来了资源竞争、同步问题，因此合理设计线程是并发编程的关键。

2. Java 创建线程的四种方式

2.1 继承 Thread 类

实现步骤：

1. 创建一个类继承 Thread。
2. 重写 run() 方法，将任务逻辑写入其中。
3. 创建线程对象并调用 start() 方法启动线程。

优点：

• 逻辑清晰，使用简单。

缺点：

• 继承限制（Java 不支持多继承）。
• 线程和任务逻辑耦合，不够灵活。

代码示例：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程 " + Thread.currentThread().getName() + " 正在运行");
    }

    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.start();
        thread2.start();
    }
}

常见误区：

如果直接调用 run() 方法，而不是 start()，线程不会真正启动，而是同步执行：

thread.run(); // 错误用法，仅在当前线程调用 run 方法
thread.start(); // 正确用法，启动新线程

2.2 实现 Runnable 接口

实现步骤：

1. 创建一个类实现 Runnable 接口。
2. 重写 run() 方法。
3. 将 Runnable 实例作为参数传递给 Thread 构造器。
4. 调用 start() 方法启动线程。

优点：

• 解耦任务逻辑和线程实现，灵活性更高。
• 支持多继承，可以同时继承其他类。

代码示例：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程 " + Thread.currentThread().getName() + " 正在运行");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());

        thread1.start();
        thread2.start();
    }
}

扩展场景：

利用匿名内部类快速实现：

Thread thread = new Thread(() -> System.out.println("线程 " + Thread.currentThread().getName() + " 正在运行"));
thread.start();

2.3 使用 Callable 接口（支持返回值）

实现步骤：

1. 创建一个类实现 Callable 接口。
2. 实现 call() 方法（支持返回值）。
3. 使用 FutureTask 包装 Callable 对象。
4. 将 FutureTask 作为参数传递给 Thread。
5. 使用 FutureTask.get() 获取返回值。

优点：

• 支持任务返回值。
• 可处理异常，功能更强大。

代码示例：

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

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() {
        System.out.println("线程 " + Thread.currentThread().getName() + " 正在运行");
        return 42;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(task);
        thread.start();

        try {
            Integer result = task.get();
            System.out.println("任务返回结果：" + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2.4 使用线程池创建线程

线程池是实际开发中最常用的线程管理方式。
实现步骤：

1. 使用 Executors 创建线程池。
2. 提交任务到线程池执行。
3. 使用 shutdown() 关闭线程池。

优点：

• 高效管理线程，避免频繁创建销毁线程的开销。
• 支持任务调度和线程复用。

代码示例：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3); // 创建线程池

        for (int i = 1; i <= 5; i++) {
            int taskId = i;
            executor.submit(() -> System.out.println("线程：" + Thread.currentThread().getName() + " 正在处理任务：" + taskId));
        }

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

3. 常见误区与注意事项

1. 线程重复启动
   每个线程对象只能调用一次 start() 方法，重复调用会抛出异常：

   thread.start();
   thread.start(); // IllegalThreadStateException
   

2. 线程安全问题

   • 多线程访问共享资源时，需考虑同步（使用 synchronized 或其他锁机制）。
   • 错误的并发控制可能导致死锁或数据不一致。

4. 各种方式的对比

5. 小结与展望

• Runnable 是最通用的线程创建方式，推荐优先使用。
• Callable 支持返回值，适合复杂任务。
• 实际开发中线程池是首选，尤其在高并发环境下。