创建线程的四种方式

1. 继承Thread类

需要重写Thread的run方法，并通过.start()方法启动线程执行任务

public class mythread extends Thread{
    @Override
    public void run(){
       System.out.println("Im running!") 
    }
}
class main{
    public static void main(String[] args){
        mythread mythread1 = new mythread();
        mythread mythread2 = new mythread();
        mythread1.setName("thread1");
		mythread1.setName("thread1");
        
        mythread1.start();
        mythread2.start();
    }
}

2. 实现Runnable接口

大约步骤是：写一个实现Runnable接口的类，创建一个实例对象，将其传入Thread中作为参数新建线程，启动线程。

Thread 类也实现了 Runnable 接口，这意味着构造函数 Thread(Runnable target) 不仅可以传入 Runnable 接口的对象，而且可以传入一个 Thread 类的对象，这样就可以将一个 Thread 对象中的 run() 方法交由其他线程进行调用。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我是通过实现 Runnable 接口创建的多线程，我叫" + Thread.currentThread().getName());
    }
}

class TestMyRunnable {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

3. 实现Callable接口

和Runnable类似，不过其需要实现的call方法是有返回值的。

步骤如下：

1. 创建 MyCallable 类实现 Callable 接口。
2. 创建 MyCallable 类的实例对象 myCallable。
3. 把实例对象 myCallable 作为参数来创建 FutureTask 类的实例对象 futureTask。
4. 把实例对象 futureTask 作为参数来创建 Thread 类的实例对象 thread，实例对象 thread 就是一个新线程。
5. 调用 start() 方法，启动线程。

class CallableTask implements Callable<String> {
    public String call() throws InterruptedException {
        Thread.sleep(2000);//模拟阻塞2s，主线程才收到
        return "这是Callable接口实现线程";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableTask task = new CallableTask();
        FutureTask<String> futureTask = new FutureTask<>(task);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println("主线程开始");
        System.out.println(futureTask.get());
        System.out.println("主线程结束");
    }
}

4.线程池

线程池是用来管理和复用线程的工具，它可以减少线程的创建和销毁开销。

步骤大约是使用Executor框架中的ThreadPoolExecutor来创建自定义的线程池，有7大参数和4大拒绝策略，通过线程池执行线程操作

class CustomRejectedHandler {
    public static void main(String[] args) {
        // 自定义拒绝策略
        RejectedExecutionHandler rejectedHandler = (r, executor) -> {
            System.out.println("Task " + r.toString() + " rejected. Queue size: " 
                               + executor.getQueue().size());
        };

        // 自定义线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2,                      // 核心线程数
            4,                      // 最大线程数
            10,                     // 空闲线程存活时间
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(2),  // 阻塞队列容量
            Executors.defaultThreadFactory(),
            rejectedHandler          // 自定义拒绝策略
        );

        for (int i = 0; i < 10; i++) {
            final int taskNumber = i;
            executor.execute(() -> {
                System.out.println("Executing task " + taskNumber);
                try {
                    Thread.sleep(1000); // 模拟任务耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}