创建线程的几种方式

1、继承Thread类

重写run()方法，调用start()启动。
// 1. 创建一个继承自Thread的子类

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程要执行的任务
        System.out.println("线程运行了: " + Thread.currentThread().getName());
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        // 2. 创建线程对象
        MyThread thread = new MyThread();
        
        // 3. 启动线程（注意：是调用start()，不是run()！）
        thread.start(); // 输出：线程运行了: Thread-0

        // 直接调用run()方法是在主线程中执行，不会启动新线程
        // thread.run(); // 输出：线程运行了: main
    }
}

2、实现Runnbale接口

实现run()方法，用Thread包装后启动。

// 1. 创建一个实现了Runnable接口的类
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程运行了: " + Thread.currentThread().getName());
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        // 2. 创建实现类对象
        MyRunnable myRunnable = new MyRunnable();
        
        // 3. 将此对象作为参数传递到Thread类的构造器中，创建Thread对象
        Thread thread = new Thread(myRunnable);
        
        // 4. 通过Thread对象调用start()
        thread.start(); // 输出：线程运行了: Thread-0

        // 匿名内部类写法（更简洁）
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类线程运行了");
            }
        }).start();

        // Lambda表达式写法（Java 8+，最简洁）
        new Thread(() -> System.out.println("Lambda线程运行了")).start();
    }
}

3、实现Callable接口

实现call()方法，有返回值，可抛异常，用FutureTask包装，再交给Thread启动。

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

// 1. 创建一个实现Callable接口的类
class MyCallable implements Callable<Integer> {
    // 计算1~100的和
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum; // 返回计算结果
    }
}

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 2. 创建Callable实现类的对象
        MyCallable myCallable = new MyCallable();
        
        // 3. 将Callable对象作为参数传递到FutureTask构造器中，创建FutureTask对象
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        
        // 4. 将FutureTask对象作为参数传递到Thread构造器中，创建Thread对象并启动
        new Thread(futureTask).start();

        // 5. 获取Callable中call()方法的返回值（可选）
        // get()方法会阻塞当前线程（main线程），直到call()方法执行完成并返回结果
        Integer sum = futureTask.get();
        System.out.println("总和为: " + sum); // 输出：总和为: 5050
    }
}

4、使用线程池

使用线程池ExecutorService，提交Runnable或者Callable任务给线程池。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 1. 创建线程池（这里使用Executors工具类创建固定大小的线程池）
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // 2. 执行Runnable任务
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行Runnable任务");
            }
        });

        // 3. 提交Callable任务（可以获取返回值Future）
        // Future<?> future = executorService.submit(new MyCallable());

        // 4. 关闭线程池（重要！）
        executorService.shutdown();
    }
}