创建线程的8种方法，90%的人不知道

苏三说技术2024-12-30 11:08

前言

在Java开发中，线程是并发编程中的核心工具。

无论是为了提高程序运行效率，还是为了处理复杂的并发任务，我们都需要在代码中使用线程。

但如果你只知道 Thread 和 Runnable 两种方式，那可就有点落后了。

其实，Java 提供了多种方式来创建线程，每一种都有其独特的优势和适用场景。

这篇文章将从浅入深，详细剖析 Java 创建线程的8种方法，每种方法都会附带示例代码和场景解析，帮你彻底掌握线程的创建与管理，希望对你会有所帮助。

(我最近开源了一个基于 SpringBoot+Vue+uniapp 的商城项目，欢迎访问和star。)[https://gitee.com/dvsusan/susan_mall]

1. 继承 Thread 类

直接继承 Thread 类，重写 run() 方法，将任务逻辑写在 run() 中。

通过调用 start() 方法启动线程。

示例代码

java 复制代码 
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程名称：" + Thread.currentThread().getName() + " 正在执行任务");
    }
}

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

场景解析

继承 Thread 是最简单的方式，非常适合初学者学习线程的基本原理。但这种方式扩展性差，因为 Java 是单继承语言，继承了 Thread 后就不能再继承其他类。

优缺点

  • 优点： 简单直观，适合小型任务。
  • 缺点： 限制了类的继承，无法复用已有的逻辑。

2. 实现 Runnable 接口

实现 Runnable 接口，将任务逻辑写在 run() 方法中。

通过 Thread 构造方法将 Runnable 对象传入，启动线程。

示例代码

java 复制代码 
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程名称：" + Thread.currentThread().getName() + " 正在执行任务");
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());
        thread1.start();
        thread2.start();
    }
}

场景解析

相比继承 Thread，实现 Runnable 接口更灵活，避免了单继承的限制。大多数开发场景中，更推荐使用这种方式。

优缺点

  • 优点： 解耦任务逻辑和线程对象，灵活性更高。
  • 缺点： 需要额外创建 Thread 对象。

3. 实现 Callable 接口

Callable 接口是 Java 5 引入的，类似于 Runnable，但它支持返回值，并可以抛出异常。

示例代码

java 复制代码 
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "线程名称：" + Thread.currentThread().getName() + "，任务执行完成";
    }
}

public class CallableExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();

        // 获取线程返回结果
        System.out.println("线程返回结果：" + futureTask.get());
    }
}

场景解析

如果你的线程需要返回结果，Callable 是更好的选择，比如数据查询、复杂计算等场景。

优缺点

  • 优点： 支持返回值和异常处理，功能更强大。
  • 缺点： 代码复杂度比 Runnable 略高。

4. 使用线程池

线程池是一种高效的线程管理机制，可以复用线程，减少创建和销毁线程的开销。

示例代码

java 复制代码 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        Runnable task = () -> System.out.println("线程名称：" + Thread.currentThread().getName() + " 正在执行任务");

        for (int i = 0; i < 5; i++) {
            executorService.execute(task);
        }

        executorService.shutdown();
    }
}

场景解析

适用于需要高并发处理任务的场景，比如 Web 服务的请求处理。

优缺点

  • 优点： 高效管理线程生命周期，避免频繁创建和销毁线程。
  • 缺点： 需要合理配置线程池参数，否则可能导致资源浪费。

5. 使用 ScheduledExecutorService

ScheduledExecutorService 是 Java 提供的一种定时任务调度机制，可以在指定时间点或周期性地执行任务。

示例代码

java 复制代码 
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        Runnable task = () -> System.out.println("当前时间：" + System.currentTimeMillis());

        // 延迟1秒后，每2秒执行一次
        scheduler.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);

        // 程序运行一段时间后需要手动关闭线程池
        // scheduler.shutdown();
    }
}

场景解析

适用于周期性任务，比如定时备份、定时清理缓存等。

优缺点

  • 优点： 易于实现定时和周期性任务。
  • 缺点： 不适合复杂调度场景。

6. 使用 Fork/Join 框架

Fork/Join 是 Java 7 引入的一种并行计算框架，适合将大任务分解成多个子任务并行处理。

示例代码

java 复制代码 
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

class SumTask extends RecursiveTask<Integer> {
    private final int start, end;

    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= 10) {
            int sum = 0;
            for (int i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else {
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(start, mid);
            SumTask rightTask = new SumTask(mid + 1, end);
            invokeAll(leftTask, rightTask);
            return leftTask.join() + rightTask.join();
        }
    }
}

public class ForkJoinExample {
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        SumTask task = new SumTask(1, 100);
        System.out.println("总和：" + pool.invoke(task));
    }
}

场景解析

适合大量数据的并行处理，比如递归计算。

优缺点

  • 优点： 提高多核 CPU 的利用率。
  • 缺点： 不适合 I/O 密集型任务。

7. 使用 CompletableFuture

CompletableFuture 是 Java 8 提供的一种异步编程工具，支持链式调用，非常适合复杂任务的分解与组合。

示例代码

java 复制代码 
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            System.out.println("任务执行：" + Thread.currentThread().getName());
            return "任务结果";
        }).thenApply(result -> {
            System.out.println("处理结果：" + result);
            return "最终结果";
        }).thenAccept(System.out::println);
    }
}

场景解析

适用于异步任务链式调用，比如远程服务调用。

优缺点

  • 优点： 功能强大，代码简洁。
  • 缺点： 学习成本较高。

8. 使用 Guava 的 ListenableFuture

Guava 提供了 ListenableFuture，对 Future 进行了增强，支持任务完成后的回调处理。

java 复制代码 
import com.google.common.util.concurrent.*;

import java.util.concurrent.Executors;

public class ListenableFutureExample {
    public static void main(String[] args) {
        ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(2));

        ListenableFuture<String> future = service.submit(() -> {
            Thread.sleep(1000);
            return "任务完成";
        });

        Futures.addCallback(future, new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println("任务成功，结果：" + result);
            }

            @Override
            public void onFailure(Throwable t) {
                System.out.println("任务失败：" + t.getMessage());
            }
        }, service);

        service.shutdown();
    }
}

总结

以上就是 Java 中创建线程的 8 种方法，每一种方法都有其适用场景和优缺点。

下面给大家总结一下各自的优缺点：

方法 适用场景 优点 缺点
继承Thread类 简单任务 直观易懂 限制了类的继承
实现Runnable接口 大多数场景 灵活，不影响继承关系 无返回值
实现Callable接口 返回结果或抛异常的任务 支持返回值 需要配合 FutureTask 使用
线程池（ExecutorService） 高并发任务 高效管理线程 配置复杂
ScheduledExecutorService 周期性任务 易于实现定时调度 不适合复杂调度
Fork/Join框架 数据并行计算 提高多核利用率 不适合 I/O 密集型任务
CompletableFuture 异步任务链式调用 功能强大 学习曲线高
Guava的ListenableFuture 异步任务并带回调 回调机制强大，扩展性好 引入了第三方依赖

希望大家在实际开发中，能根据场景选择合适的方式。

比如：小任务用 Runnable，复杂计算用 Callable，高并发场景用线程池，而异步任务可以用 CompletableFuture 或 ListenableFuture等等。

通过这些方法的组合，可以让你的代码更加高效、优雅！

最后说一句(求关注，别白嫖我)

如果这篇文章对您有所帮助，或者有所启发的话，帮忙关注一下我的同名公众号：苏三说技术，您的支持是我坚持写作最大的动力。

求一键三连：点赞、转发、在看。

关注公众号：【苏三说技术】，在公众号中回复：进大厂，可以免费获取我最近整理的10万字的面试宝典，好多小伙伴靠这个宝典拿到了多家大厂的offer。

热门推荐
01渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了02半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)03HCIA-datacom数通题库和录播视频资料04【bug记录】清除僵尸进程，释放GPU显存05新手学习VR全景需要知道的几个问题06校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站07【模型压缩】 LPPN论文阅读笔记08ubuntu22.04.5本地apt源部署09优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间10音频——I2S TDM 模式(六)