Java 创建线程的方法

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

课程名：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(); // 启动线程
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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(); // 启动线程
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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(); // 关闭线程池
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

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(); // 关闭线程池
1
2
3
4
5
6
7
8
9
10
11
12
13

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

总结

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