java:线程的几种创建写法

一、总结

项目	语法（自用的伪代码,省去了关键字和数据类型）	细节
1. 直接任务类继承 Thread	Task -继承-> Thread task.start()
2. 任务类实现 Runnable / Callable，由 Thread 调用	Runnable： Task -实现-> Runnable t = thread(task) t.start() Callable： Task -实现-> Callable futureTask = FutureTask<>(task) t = Thread(futureTask) t.start()	Runnable：无返回值Callable：- 有返回值（call）- 能抛异常- 不能直接给 Thread，用 FutureTask 包装
3. 任务类实现 Runnable / Callable，由 ExecutorService 调用	Runnable： Task -实现-> Runnable pool = ExecutorService(固定线程池/其他类型) pool.execute(task) Callable： Task -实现-> Callable pool = ExecutorService(固定线程池/其他类型) future = pool.submit(task) result = future.get()  // 获取返回值	Runnable：无返回值Callable：- 有返回值（call）- 能抛异常

二、具体写法

1.直接继承Thread

要点：直接写线程类并继承Thread类，重写run()，创建该线程对象，调用start()

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程运行中！");
    }
}

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

2.实现接口

2.1 实现Runnable接口

要点：先写任务类实现Runnable接口，重写run()  -->  创建线程对象，传入任务对象，调用start()启动线程

完整版

class MyTask implements Runnable {
    @Override
    public void run() {
        System.out.println("线程运行中！");
    }
}

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

简化版：匿名内部类（一种简写方式，不需要单独创建类，而是在内部创建匿名类）

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类 Runnable 线程运行中！");
            }
        });
        t.start();  // 启动线程
    }
}

更简化版：lambda表达式（一种基于上面匿名内部类，更为简写的方式）

public class Main {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("Lambda Runnable 线程运行中！")).start();
    }
}

2.2 实现Callable接口

要点：任务类实现Callable接口，重写call()  -->  创建futuretask对象，包装任务类  -->  创建线程对象，传入futuretask对象为参数，调用start()启动线程

完整版

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

public class Main {
    public static void main(String[] args) throws Exception {
        // 1. 定义 Callable 任务类
        class MyTask implements Callable<Integer> {
            @Override
            public Integer call() throws Exception {
                System.out.println("Callable任务执行中...");
                Thread.sleep(1000);
                return 123;
            }
        }

        // 2. 创建任务对象
        MyTask task = new MyTask();

        // 3. 用 FutureTask 包装 Callable
        FutureTask<Integer> futureTask = new FutureTask<>(task);

        // 4. 创建 Thread 并启动
        Thread t = new Thread(futureTask);
        t.start();

        // 5. 获取返回值
        Integer result = futureTask.get();
        System.out.println("返回值：" + result);
    }
}

简化版

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

public class Main {
    public static void main(String[] args) throws Exception {
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("Callable任务执行中...");
                Thread.sleep(1000);
                return 123;
            }
        });

        Thread t = new Thread(futureTask);
        t.start();

        Integer result = futureTask.get();
        System.out.println("返回值：" + result);
    }
}

更简化版

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

public class Main {
    public static void main(String[] args) throws Exception {
        FutureTask<Integer> futureTask = new FutureTask<>(
            (Callable<Integer>) () -> {
                System.out.println("Callable任务执行中...");
                Thread.sleep(1000);
                return 123;
            }
        );

        new Thread(futureTask).start();

        System.out.println("返回值：" + futureTask.get());
    }
}

3 线程池

3.1 Runable + 线程池写法

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

public class Main {
    public static void main(String[] args) {
        // 1. 创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);

        // 2. 提交 Runnable 任务
        pool.execute(() -> System.out.println("线程池中的任务运行中！"));

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

3.2 Callable + 线程池写法

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

public class Main {
    public static void main(String[] args) throws Exception {
        // 1. 创建 Callable 任务
        Callable<Integer> task = () -> {
            System.out.println("Callable 任务执行中");
            return 123;
        };

        // 2. 创建线程池
        ExecutorService pool = Executors.newSingleThreadExecutor();

        // 3. 提交任务，返回 Future
        Future<Integer> future = pool.submit(task);

        // 4. 获取返回值
        Integer result = future.get();
        System.out.println("返回值：" + result);

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