Java 创建线程的方法

🙈作者简介：练习时长两年半的Java up主

🙉个人主页：程序员老茶

🙊 ps:点赞👍是免费的，却可以让写博客的作者开兴好久好久😎

📚系列专栏：Java全栈，计算机系列（火速更新中）

💭 格言：种一棵树最好的时间是十年前，其次是现在

🏡动动小手，点个关注不迷路，感谢宝子们一键三连

目录

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

课程名：Java

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

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

Java 创建线程的所有方法

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

1. 继承Thread类
2. 实现Runnable接口
3. 实现Callable接口和FutureTask类
4. 使用Executor框架
5. 使用Fork/Join框架
6. 通过线程池创建线程

1. 继承Thread类

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

class MyThread extends Thread {
    @Override
    public 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 {
    @Override
    public 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> {
    @Override
    public 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 {
    @Override
    public 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;
    }

    @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;
            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(); // 关闭线程池

这段代码会创建一个固定大小为5的线程池，然后提交10个任务给线程池执行。当所有任务完成后，需要调用shutdown()方法关闭线程池。

总结

以上介绍了Java中常用的创建线程的方法，包括继承Thread类、实现Runnable接口、使用Callable和Future接口、以及通过线程池等方式。在实际开发中，应根据具体情况选择合适的创建线程的方法，并注意线程安全的问题。

往期专栏
Java全栈开发
数据结构与算法
计算机组成原理
操作系统
数据库系统
物联网控制原理与技术