概要

继承 Thread 类

public class Test extends Thread {
    @Override
    public void run() {
        System.out.println("current thread is:" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.start();//启动线程
    }
}

实现 Runnable 接口

方式1：

public class Test implements Runnable {
    @Override
    public void run() {
        System.out.println("current thread is:" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Test test = new Test();
        Thread thread = new Thread(test);
        thread.start();
    }
}

方式2：
参数 new Runnable() { … } 是一个匿名内部类实现 Runnable 接口。【传参，new一个接口，需要实现该接口的方法】

public class Test{
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("current thread is:"+Thread.currentThread().getName());
            }
        });
        thread.start();
    }
}

方式3：
只有一个抽象方法的接口被称为函数式接口。函数式接口可以用于 Lambda 表达式

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("current thread is:" + Thread.currentThread().getName());
        });
        thread.start();
    }
}

实现 Callable 接口

public class Test implements Callable<String> { // 和Runnable这个有返回值
    @Override
    public String call() throws Exception {
        System.out.println("current thread is:" + Thread.currentThread().getName());
        return "yes";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Test test = new Test();
        // FutureTask用来包装Callable的实例
        FutureTask<String> futureTask = new FutureTask<>(test);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get()); // 返回值
    }
}

线程池

在工作中，使用线程池是更为推荐的方法，因为它能更好地管理和复用线程资源，避免频繁创建和销毁线程带来的开销。

@Slf4j
@Configuration
public class testConfig {

    @Bean
    public Executor testExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 1.核心线程池大小
        executor.setCorePoolSize(5);
        // 2.最大线程池大小
        executor.setMaxPoolSize(10);
        // 3.队列大小
        executor.setQueueCapacity(99999);
        // 4.线程名称前缀
        executor.setThreadNamePrefix("test-executor-");
        // 5.拒绝策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        executor.initialize();
        return executor;
    }
}

拒绝策略 ：

• 当任务队列已满且线程数已达到最大值时，新任务会被拒绝。常用的拒绝策略有：
  • AbortPolicy：直接抛出 RejectedExecutionException。
  • CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务。
  • DiscardPolicy：直接丢弃任务，不抛出异常。
  • DiscardOldestPolicy：丢弃队列中最老的任务，然后重新尝试提交新任务。

---

总结：可能面试的时候经常考线程相关的笔试，可以重视一下，比如volatile synchronized wait/notify等

---

❤觉得有用的可以留个关注~❤