java创建线程

1. 继承 Thread 类：
   • 创建一个新的类，让它继承自 java.lang.Thread 类。
   • 重写 Thread 类的 run() 方法，定义线程执行体。
   • 创建该类的实例，并调用 start() 方法启动线程。

1public class MyThread extends Thread {
2    @Override
3    public void run() {
4        // 这里是线程执行的逻辑
5    }
6
7    public static void main(String[] args) {
8        MyThread thread = new MyThread();
9        thread.start();
10    }
11}

1. 实现 Runnable 接口：
   • 创建一个新的类，实现 java.lang.Runnable 接口。
   • 重写 Runnable 接口的 run() 方法，定义线程执行体。
   • 创建 Thread 对象时，传入这个 Runnable 实例作为目标对象。
   • 同样通过调用 Thread 对象的 start() 方法启动线程。

1public class MyRunnable implements Runnable {
2    @Override
3    public void run() {
4        // 这里是线程执行的逻辑
5    }
6
7    public static void main(String[] args) {
8        Thread thread = new Thread(new MyRunnable());
9        thread.start();
10    }
11}

1. 使用 Callable 和 Future：
   • 创建一个类实现 java.util.concurrent.Callable 接口，重写 call() 方法，它可以有返回值并且可以抛出受检异常。
   • 使用 FutureTask 包装 Callable 实例，FutureTask 是实现了 Runnable 接口，因此可以作为线程的目标。
   • 创建 Thread 对象并传入 FutureTask，调用 start() 方法执行线程。
   • 可以通过 FutureTask 获取线程执行结果。

1import java.util.concurrent.Callable;
2import java.util.concurrent.FutureTask;
3
4public class MyCallable implements Callable<String> {
5    @Override
6    public String call() throws Exception {
7        // 执行任务并返回结果
8        return "Callable result";
9    }
10
11    public static void main(String[] args) {
12        MyCallable myCallable = new MyCallable();
13        FutureTask<String> futureTask = new FutureTask<>(myCallable);
14        Thread thread = new Thread(futureTask);
15        thread.start();
16
17        try {
18            String result = futureTask.get(); // 阻塞等待结果
19            System.out.println(result);
20        } catch (Exception e) {
21            // 处理可能的异常
22        }
23    }
24}
25
26// 或者通过ExecutorService等线程池机制提交Callable任务

1. 使用线程池（ExecutorService）：
   • 通过 java.util.concurrent.ExecutorService 和相关的类如 ThreadPoolExecutor 创建线程池。
   • 使用线程池的 submit() 方法提交 Runnable 或 Callable 任务给线程池执行。

1import java.util.concurrent.ExecutorService;
2import java.util.concurrent.Executors;
3
4public class ThreadPoolExample {
5    public static void main(String[] args) {
6        ExecutorService executor = Executors.newFixedThreadPool(5); // 创建固定大小的线程池
7        executor.submit(new MyRunnable()); // 提交Runnable任务
8        // 或者
9        executor.submit(new MyCallable()); // 提交Callable任务
10        
11        // 在适当时候关闭线程池
12        executor.shutdown();
13    }
14}

        其中，使用线程池能够更有效地管理和控制线程资源，提高性能和资源利用率，尤其是对于大量短生命周期的线程任务特别适用。同时，Callable 接口允许开发者获取线程执行的返回值，相比 Runnable 更加灵活。