线程创建四种方式的详解

线程创建的4种方式

方式一：继承 Thread 类

原理：

通过继承java.lang.Thread类并覆盖其run方法，可以创建新的线程。当调用线程的start()方法时，会启动一个新的线程来执行run方法中的代码。

示例代码：

public class MyThread extends Thread {  
    @Override  
    public void run() {  
        System.out.println("线程运行中：" + Thread.currentThread().getName());  
    }  
  
    public static void main(String[] args) {  
        MyThread thread = new MyThread();  
        thread.start();  
    }  
}

优缺点：

优点：实现简单，易于理解。
缺点：Java不支持多重继承，如果当前类已经继承了其他类，则无法再继承Thread类。

方式二：实现 Runnable 接口

原理:

实现java.lang.Runnable接口，并将该实现类的实例传递给Thread类的构造器。这种方式与继承Thread类相比更加灵活，因为Java支持实现多个接口。

示例代码:

public class MyRunnable implements Runnable {  
    @Override  
    public void run() {  
        System.out.println("线程运行中：" + Thread.currentThread().getName());  
    }  
  
    public static void main(String[] args) {  
        Thread thread = new Thread(new MyRunnable());  
        thread.start();  
    }  
}

优缺点:

优点：灵活性高，支持实现多个接口，且易于与线程池等高级功能结合使用。
缺点：相对继承Thread类来说，代码稍显繁琐。

方式三：实现 Callable 接口

原理:

实现java.util.concurrent.Callable接口与实现Runnable接口类似，但Callable可以返回一个结果，并且可以抛出异常。Callable通常与FutureTask一起使用，FutureTask包装了Callable或Runnable对象，提供了更为强大的功能，比如可以检查计算是否完成，等待计算完成，并检索计算结果。

示例代码:

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() throws Exception {  
        return 123;  
    }  
  
    public static void main(String[] args) throws ExecutionException, InterruptedException {  
        FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());  
        Thread thread = new Thread(futureTask);  
        thread.start();  
  
        // 等待计算完成并获取结果  
        System.out.println("计算结果是：" + futureTask.get());  
    }  
}

优缺点:

优点：支持返回结果和抛出异常，功能更强大。
缺点：相比Runnable，实现稍显复杂，且通常与FutureTask一起使用，增加了代码的复杂性。

方式四：使用线程池

原理:

线程池是管理一组工作线程的资源池，用于执行异步任务。使用线程池可以减少线程创建和销毁的开销，提高系统的响应速度和吞吐量。Java提供了Executors工厂类来创建不同类型的线程池。

示例代码:

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class ThreadPoolExample {  
    public static void main(String[] args) {  
        // 创建一个固定大小的线程池  
        ExecutorService executor = Executors.newFixedThreadPool(5);  
  
        for (int i = 0; i < 10; i++) {  
            int taskId = i;  
            executor.submit(() -> {  
                System.out.println("线程运行中，任务ID：" + taskId);  
            });  
        }  
  
        // 关闭线程池（不再接受新任务，但已提交的任务会继续执行）  
        executor.shutdown();  
    }  
}

优缺点:

优点：减少线程创建和销毁的开销，提高资源利用率，易于管理和监控线程。
缺点：需要合理配置线程池。

作者：Seal^_^