ToB企服应用市场:ToB评测及商务社交产业平台

标题: Java 创建多线程的三种方法 [打印本页]

---

作者: 知者何南    时间: 2023-12-22 02:23
标题: Java 创建多线程的三种方法
在Java中创建多线程，往往都要通过Thread类来实现，今天学习下Java中创建多线程的三种方法[1]。
1.继承Thread类

通过继承 Thread类 实现多线程。
主要方法：

• 1.void run(), 线程开启后，方法将被调用执行
  
• 2.void start(), 使此线程开始执行, Java虚拟机会调用run()方法
  

实现步骤:

• 1.定义类，继承 Thread类
  
• 2.重写 run() 方法
  
• 3.创建多线程类对象
  
• 4.通过实例方法 start() 启动线程
  

demo

1. public class MyThreadExtendsThread extends Thread {
2.     private int num;
3.     public MyThreadExtendsThread() {};
5.     public MyThreadExtendsThread(int num) {
6.         this.num = num;
7.     }
9.     @Override
10.     public void run() {
11.         for (int i = 0; i < num; i++) {
12.             System.out.println(Thread.currentThread().getName() + " 子线程：" + i);
13.         }
14.     }
16.     public static void main(String[] args) throws InterruptedException {
17.         Thread t1 = new MyThreadExtendsThread();
18.         Thread t2 = new MyThreadExtendsThread(100000);
20.         t2.setDaemon(true); // true, 主线程结束，子线程也随之退出, false, 主线程结束后，子线程继续执行
22.         t1.start();
23.         t2.start();
25.         for (int i = 0; i < 10; i++) {
26.             System.out.println("主线程：" + i);
27.         }
28.         // 等待子线程完成任务
29.         Thread.sleep(10L);
30.         /*
31.         子线程：0
32.         子线程：1
33.         主线程：0
34.         子线程：2
35.         主线程：1
36.         主线程：2
37.         主线程：3
38.         主线程：4
39.         主线程：5
40.         主线程：6
41.         主线程：7
42.         子线程：3
43.         子线程：4
44.         子线程：5
45.         子线程：6
46.         子线程：7
47.         子线程：8
48.         子线程：9
49.         主线程：8
50.         主线程：9
51.          */
52.     }
53. }

复制代码

2.实现Runnable接口

通过实现 Runnable接口 实现多线程。
主要方法：

• 1.void run()，重写run方法
  

实现步骤：

• 1.定义类，实现 Runnable 接口
  
• 2.类中重写 run()方法
  
• 3.创建多线程类对象
  
• 4.创建 Thread 类对象，通过传入多线程类对象作为构造方法参数
  
• 5.通过 Thread 类对象的 start 方法启动线程
  

demo

1. public class MyThreadImplementsRunnable implements Runnable {
2.     @Override
3.     public void run() {
4.         for (int i = 0; i < 5; i++) {
5.             System.out.println("子线程：" + i);
6.         }
7.     }
9.     public static void main(String[] args) throws InterruptedException {
10.         Runnable t1 = new MyThreadImplementsRunnable();
11.         new Thread(t1).start();
13.         for (int i = 0; i < 5; i++) {
14.             System.out.println("主线程：" + i);
15.         }
17.         Thread.sleep(1000L);
18.         /*
19.         子线程：0
20.         主线程：0
21.         主线程：1
22.         主线程：2
23.         主线程：3
24.         主线程：4
25.         子线程：1
26.         子线程：2
27.         子线程：3
28.         子线程：4
29.          */
30.     }
31. }

复制代码

3.实现Callable接口

通过实现 Callable接口 实现多线程。
主要方法：

• 1.V call(), 计算结果，如无，则抛出异常
  
• 2.V get(), 如必要，等待计算完成，然后获取结果
  

实现步骤：

• 1.定义类实现 Callable 接口
  
• 2.在刚定义的类中重写 call()方法
  
• 3.创建 MyThreadImplementsCallable 对象
  
• 4.创建 Future 接口的实现类 FutureTask 对象，传入 MyThreadImplementsCallable 作为构造方法的参数
  
• 5.创建 Thread 类对象，传入FutureTask作为构造方法参数
  
• 6.启动线程
  
• 7.如有需要，通过调用 get() 方法, 获取线程任务结束后的结果
  

demo

1. import java.util.concurrent.Callable;
2. import java.util.concurrent.ExecutionException;
3. import java.util.concurrent.FutureTask;
5. public class MyThreadImplementsCallable implements Callable {
6.     private int num;
8.     public MyThreadImplementsCallable(int num) {
9.         this.num = num;
10.     }
12.     @Override
13.     public String call() throws Exception {
14.         int sum = 0;
16.         for (int i = 0; i < num; i++) {
17.             sum += i;
18.         }
20.         return "线程求出 -> " + num + "之内的和为：" + sum;
21.     }
23.     public static void main(String[] args) throws InterruptedException, ExecutionException {
24.         Callable callable = new MyThreadImplementsCallable(1000);
25.         // 创建未来任务实现Callable接口
26.         FutureTask<String> futureTask = new FutureTask<>(callable);
27.         new Thread(futureTask).start();
29.         // 获取线程任务结束后的结果
30.         String res = futureTask.get();
31.         System.out.println("res: " + res);
32.         // res: 线程求出 -> 1000之内的和为：499500
33.     }
34. }

复制代码

4.方法对比

以下为多线程中类关系图：

从关系图中可知：

• 三种方法实现多线程，都与Runnable接口有关
  
• 从实现RUnnable接口的MyRunnable和MyCallable两种方法中，也都要通过Thread类来创建多线程
  

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享[2]。
总结：
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类
参考：

• 多线程详解
  
• Java多线程详解-入门篇
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4