线程创建的四种方式

在Java中，有4种主要的方式来创建线程：通过继承Thread类和通过实现Runnable接口，实现Callable接口，线程池。下面分别介绍这两4种方法，并提供相应的代码例子。

1. 通过继承Thread类
通过继承Thread类，需要重写run()方法，并在run()方法中定义线程要执行的任务。

java
public class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getId() + " Value " + i);
        }
    }

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

        MyThread t2 = new MyThread();
        t2.start(); // 启动另一个线程
    }
}

在上述例子中，通过继承Thread类创建了一个线程类MyThread，并重写了run()方法。在main方法中，创建了两个线程对象t1和t2，并通过调用start()方法启动线程。

2. 通过实现Runnable接口
通过实现Runnable接口，需要实现run()方法，然后将实现了Runnable接口的类的实例传递给Thread类的构造函数。

java
public class MyRunnable implements Runnable {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getId() + " Value " + i);
        }
    }

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

        Thread t2 = new Thread(new MyRunnable());
        t2.start(); // 启动另一个线程
    }
}

在上述例子中，创建了一个实现了Runnable接口的类MyRunnable，并实现了run()方法。然后，通过创建Thread对象并将MyRunnable的实例传递给构造函数，启动了两个线程。

这两种方式都可以用于创建线程，选择哪种方式取决于具体的需求和设计考虑。通常，推荐使用实现Runnable接口的方式，因为它避免了Java单继承的限制，同时更符合面向对象的设计原则。

3. 使用Callable和Future
Callable接口是类似于Runnable接口的一种方式，但它允许线程执行有返回值的任务。Callable接口通过Future接口来获取线程执行的结果。

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

public class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 5; i++) {
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);

        Thread thread = new Thread(futureTask);
        thread.start();

        // 获取线程执行结果
        int result = futureTask.get();
        System.out.println("Result: " + result);
    }
}

在上述例子中，通过实现Callable接口创建了一个可调用的任务，并使用FutureTask包装该任务。然后，通过创建一个线程来执行FutureTask，最后通过get()方法获取线程执行的结果。

4. 使用线程池
线程池是一种重用线程的机制，它管理和执行线程，可以有效地提高系统的性能和资源利用率。Java中提供了ExecutorService接口和ThreadPoolExecutor类来实现线程池。

java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        // 提交任务给线程池
        for (int i = 0; i < 5; i++) {
            RunnableTask task = new RunnableTask(i);
            executorService.submit(task);
        }
        // 关闭线程池
        executorService.shutdown();
    }
}
class RunnableTask implements Runnable {
    private int taskId;
    public RunnableTask(int taskId) {
        this.taskId = taskId;
    }
    public void run() {
        System.out.println("Task ID: " + taskId + " executed by " + Thread.currentThread().getName());
    }
}

在上述例子中，通过Executors.newFixedThreadPool(2)创建了一个固定大小为2的线程池，然后提交了5个任务给线程池执行。RunnableTask实现了Runnable接口，表示一个可执行的任务。最后，通过shutdown()方法关闭线程池。

使用线程池可以更有效地管理线程，避免频繁创建和销毁线程的开销。同时，线程池提供了更多的配置选项，如线程池大小、任务队列等，以满足不同的需求。