Java 并发编程创建线程的四种方式示例详解

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行逻辑
        System.out.println("继承Thread类的线程: " + Thread.currentThread().getName());
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        // 方式1：匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable匿名内部类线程: " + Thread.currentThread().getName());
            }
        }).start();
        // 方式2：Lambda表达式（推荐）
        new Thread(() -> {
            System.out.println("Runnable Lambda线程: " + Thread.currentThread().getName());
        }).start();
        // 方式3：实现类
        Runnable task = new MyRunnable();
        new Thread(task).start();
    }
}
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable接口的线程: " + Thread.currentThread().getName());
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建Callable任务
        Callable<String> callableTask = () -> {
            Thread.sleep(1000);
            return "Callable线程执行结果: " + Thread.currentThread().getName();
        };
        // 包装为FutureTask
        FutureTask<String> futureTask = new FutureTask<>(callableTask);
        // 启动线程
        new Thread(futureTask).start();
        // 获取结果（会阻塞直到任务完成）
        String result = futureTask.get();
        System.out.println(result);
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadPoolDemo {
    public static void main(String[] args) throws Exception {
        // 创建固定大小线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        // 提交Runnable任务
        executor.execute(() -> {
            System.out.println("线程池执行Runnable任务: " + Thread.currentThread().getName());
        });
        // 提交Callable任务
        Future<String> future = executor.submit(() -> {
            Thread.sleep(500);
            return "线程池执行Callable任务结果: " + Thread.currentThread().getName();
        });
        // 获取Callable结果
        System.out.println(future.get());
        // 关闭线程池
        executor.shutdown();
    }
}

import java.util.concurrent.*;
public class CustomThreadPool {
    public static void main(String[] args) {
        // 创建自定义线程池
        ExecutorService customPool = new ThreadPoolExecutor(
            4, // 核心线程数
            10, // 最大线程数
            60, // 空闲线程存活时间
            TimeUnit.SECONDS, // 时间单位
            new ArrayBlockingQueue<>(100), // 任务队列
            Executors.defaultThreadFactory(), // 线程工厂
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );
        // 提交任务
        for (int i = 0; i < 20; i++) {
            int taskId = i;
            customPool.execute(() -> {
                System.out.println("执行任务 " + taskId + " 线程: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        // 优雅关闭
        customPool.shutdown();
        try {
            if (!customPool.awaitTermination(60, TimeUnit.SECONDS)) {
                customPool.shutdownNow();
            }
        } catch (InterruptedException e) {
            customPool.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}