当前位置：首页 > news >正文

Java 创建线程的方法

news 2025/7/8 11:01:45

🙈作者简介：练习时长两年半的Java up主
🙉个人主页：程序员老茶
🙊 ps:点赞👍是免费的，却可以让写博客的作者开兴好久好久😎
📚系列专栏：Java全栈，计算机系列（火速更新中）
💭 格言：种一棵树最好的时间是十年前，其次是现在
🏡动动小手，点个关注不迷路，感谢宝子们一键三连

课程名：Java
- 内容/作用：知识点/设计/实验/作业/练习
- 学习：Java 创建线程的所有方法
Java 创建线程的所有方法
- 1. 继承Thread类
- 2. 实现Runnable接口
- 3. 实现Callable接口和FutureTask类
- 4. 使用Executor框架
- 5. 使用Fork/Join框架
- 6. 通过线程池创建线程
- 总结

课程名：Java

内容/作用：知识点/设计/实验/作业/练习

学习：Java 创建线程的所有方法

Java 创建线程的所有方法

Java中创建线程的方式有很多，本文将介绍以下几种方法：

继承Thread类
实现Runnable接口
实现Callable接口和FutureTask类
使用Executor框架
使用Fork/Join框架
通过线程池创建线程

1. 继承Thread类

通过继承Thread类并重写其run()方法来创建线程。

class MyThread extends Thread {@Overridepublic void run() {// 线程执行的任务System.out.println("MyThread is running");}
}public class Main {public static void main(String[] args) {MyThread myThread = new MyThread();myThread.start(); // 启动线程}
}

2. 实现Runnable接口

通过实现Runnable接口并重写其run()方法来创建线程。

class MyRunnable implements Runnable {@Overridepublic void run() {// 线程执行的任务System.out.println("MyRunnable is running");}
}public class Main {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread thread = new Thread(myRunnable);thread.start(); // 启动线程}
}

3. 实现Callable接口和FutureTask类

通过实现Callable接口并实现call()方法来创建线程，然后使用FutureTask类来获取线程执行的结果。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;class MyCallable implements Callable<Integer> {@Overridepublic Integer call() throws Exception {// 线程执行的任务System.out.println("MyCallable is running");return 0;}
}public class Main {public static void main(String[] args) {MyCallable myCallable = new MyCallable();FutureTask<Integer> futureTask = new FutureTask<>(myCallable);Thread thread = new Thread(futureTask);thread.start(); // 启动线程try {Integer result = futureTask.get(); // 获取线程执行的结果System.out.println("Result: " + result);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}
}

4. 使用Executor框架

通过Executor框架来创建线程，可以灵活地控制线程的创建、启动、关闭等。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;class MyRunnable implements Runnable {@Overridepublic void run() {// 线程执行的任务System.out.println("MyRunnable is running");}
}public class Main {public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池MyRunnable myRunnable = new MyRunnable();executorService.execute(myRunnable); // 提交任务到线程池executorService.shutdown(); // 关闭线程池}
}

5. 使用Fork/Join框架

通过Fork/Join框架来创建线程，可以将一个大任务拆分成多个小任务并行执行。

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;class MyRecursiveTask extends RecursiveTask<Integer> {private int start;private int end;public MyRecursiveTask(int start, int end) {this.start = start;this.end = end;}@Overrideprotected 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;MyRecursiveTask leftTask = new MyRecursiveTask(start, mid);MyRecursiveTask rightTask = new MyRecursiveTask(mid, end);leftTask.fork(); // 异步执行左子任务int rightResult = rightTask.compute(); // 同步计算右子任务的结果int leftResult = leftTask.join(); // 等待左子任务完成并获取结果return leftResult + rightResult; // 合并左右子任务的结果}}
}public class Main {public static void main(String[] args) {ForkJoinPool forkJoinPool = new ForkJoinPool(); // 创建一个Fork/Join线程池MyRecursiveTask myRecursiveTask = new MyRecursiveTask(0, 100);int result = forkJoinPool.invoke(myRecursiveTask); // 提交任务到线程池并获取结果System.out.println("Result: " + result);}
}

6. 通过线程池创建线程

Java提供了Executor框架，可以方便地创建和管理线程池。示例代码如下：

ExecutorService executor = Executors.newFixedThreadPool(5);for (int i = 0; i < 10; i++) {executor.execute(new Runnable() {public void run() {System.out.println("线程开始执行");// 线程要执行的任务System.out.println("线程执行结束");}});
}executor.shutdown(); // 关闭线程池