Java系列-线程-构建线程的几种方式

1. 继承Thread类

通过创建一个继承自Thread类的子类，然后覆盖run()方法来定义线程的执行逻辑。

class MyThread extends Thread {
    public void run() {
        // 线程执行的代码
        System.out.println("Thread is running");
    }
}

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

2. 实现Runnable接口

通过创建一个实现Runnable接口的类，然后将该类的实例传递给Thread类的构造函数。

class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的代码
        System.out.println("Runnable is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 启动线程
    }
}

3.实现Callable

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

class MyCallable implements Callable<String> {
    public String call() throws Exception {
        // 线程执行的代码，并返回一个结果
        return "Callable is running";
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个Callable任务
        Callable<String> callable = new MyCallable();

        // 将Callable任务封装成一个FutureTask
        FutureTask<String> futureTask = new FutureTask<>(callable);

        // 将FutureTask传递给Thread构造函数创建线程
        Thread thread = new Thread(futureTask);
        thread.start(); // 启动线程

        try {
            // 获取线程执行结果
            String result = futureTask.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4.线程池

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池，大小为3
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 提交任务给线程池
        for (int i = 1; i <= 5; i++) {
            final int taskId = i;
            executorService.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
            });
        }

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

在这个例子中，通过Executors.newFixedThreadPool(3)创建一个包含3个线程的固定大小线程池。然后通过executorService.submit()方法提交任务给线程池执行。最后，调用executorService.shutdown()来关闭线程池。

线程池的好处包括：

1. 线程重用： 可以重复使用已创建的线程，减少线程创建和销毁的开销。

2. 线程管理： 线程池提供了一些方法来管理线程的生命周期，例如启动、停止和等待。

3. 资源控制： 可以限制线程的数量，以控制系统资源的使用。

4. 性能提升： 通过合理配置线程池的大小，可以提高任务的执行效率。