Java 创建线程的方式

在 Java 中，有多种方式可以创建线程。以下是一些常用的创建线程的方式：

1. 继承 Thread 类

你可以通过继承 Thread 类并重写 run() 方法来创建线程。

示例：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running!");
    }
}

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

2. 实现 Runnable 接口
   通过实现 Runnable 接口来创建线程，并将其传递给 Thread 类的构造函数。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running!");
    }
}

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

3. 使用线程池（ ExecutorService）

这是日常开发中最常用的方式
对于大规模的多线程任务，推荐使用线程池（ExecutorService）来管理线程。线程池可以重用线程，避免了频繁创建和销毁线程的开销。

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

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

        // 提交任务
        executorService.submit(() -> System.out.println("Thread is running!"));

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

4. 使用匿名内部类

你可以使用匿名内部类的方式实现 Runnable 接口，这种方式更加简洁。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread is running!");
            }
        });
        thread.start();  // 启动线程
    }
}

5. 使用 Lambda 表达式（Java 8及以上）

从 Java 8 开始，你可以使用 Lambda 表达式来实现 Runnable 接口，进一步简化代码。

public class Main {
    public static void main(String[] args) {
        Runnable task = () -> System.out.println("Thread is running!");
        Thread thread = new Thread(task);
        thread.start();  // 启动线程
    }
}

对比

线程池工具类的使用

日常开发中，涉及到多线程的功能大部分情况下都是使用线程池的方式ExecutorService来创建线程。线程池可以重用线程，避免了频繁创建和销毁线程的开销，但创建线程池和销毁线程池是怎么管理的呢，不合理的管理线程池对系统性能也是一个比较大的消耗，所以有了如下这个线程池工具类：

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

/**
 *
 * @author wds
 * @DateTime 2024/12/19 17:15
 */
public class ExecutorServiceUtils {
    private static ExecutorService executorService;
    /**
     * 初始化线程池 默认
     */
    public static synchronized void init() {
        // 默认大小为 CPU 核数的2倍
        init(Runtime.getRuntime().availableProcessors() * 2);
    }
    /**
     * 初始化线程池
     *
     * @param threadPoolSize 线程池大小
     */
    public static synchronized void init(Integer threadPoolSize) {
        if (executorService == null || executorService.isShutdown()) {
            executorService = Executors.newFixedThreadPool(threadPoolSize);
        }
    }

    /**
     * 获取线程池实例
     */
    public static ExecutorService get() {
        return executorService;
    }

    /**
     * 提交任务到线程池
     *
     * @param task 任务
     */
    public static void submit(Runnable task) {
        if (executorService == null || executorService.isShutdown()) {
            // 如果线程池为空或已关闭，重新初始化线程池
            init();
        }
        executorService.submit(task);
    }

    /**
     * 关闭线程池
     * 应用关闭时调用
     */
    public static synchronized void shutdown() {
        if (executorService != null) {
            try {
                executorService.shutdown();
                if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                    executorService.shutdownNow();
                    if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                        System.err.println("线程池未能在规定时间内停止");
                    }
                }
            } catch (InterruptedException e) {
                executorService.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
}

当你需要用到这个工具类的时候，在对应的模块启动时调用init初始化线程池方法，服务关闭时调用shutdown关闭线程池方法，即可实现即插即用。如：

import com.sato.mini.common.core.util.ExecutorServiceUtils;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @author wds
 * @DateTime: 2024/12/19 17:17
 */
@Component
public class ExecutorServiceConfig {

    @PostConstruct
    public void init() {
        // 在应用启动时初始化线程池
        ExecutorServiceUtils.init(8);
    }

    // 关闭线程池
    @PreDestroy
    public void shutdown() {
        ExecutorServiceUtils.shutdown();
    } 
}