Java并发编程 | 第二篇：创建线程的几种方式

Java 提供了三种创建线程的方法

• 通过继承 Thread 类本身；
• 通过实现 Runnable 接口；
• 通过实现 Callable 接口 和 Future 创建线程。

• 继承Thread类

继承Thread类的方式，本质上也是实现了 Runnable 接口的一个实例。
• 定义一个继承Thread类的子类，并重写该类的run()方法；
• 创建Thread子类的实例，即创建了线程对象；
• 调用该线程对象的start()方法启动线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1//继承Thread类

2public class MyThread extends Thread {

3    //重写Thread类的run方法

4    public void run() {

5        System.out.println("线程启动了");

6    }

7

8    public static void main(String[] args) {

9        //创建线程的实例

10        MyThread myThread = new MyThread();

11        //启动线程

12        myThread.start();

13    }

14}

15

16执行结果：

17线程启动了

18

19

• 实现Runnable接口

通过实现Runnable接口的方式是非常常见的一种
• 定义Runnable接口的实现类，并重写该接口的run()方法；
• 创建Runnable实现类的实例，并以此实例作为Thread的target对象，即该Thread对象才是真正的线程对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1//实现Runnable接口

2public class DemoRun implements Runnable {

3

4    //重写run方法

5    @Override

6    public void run() {

7        System.out.println("我实现了Runnable");

8    }

9

10    public static void main(String[] args) {

11        //创建实例

12        DemoRun demoRun = new DemoRun();

13        //通过Thread来启动线程

14        new Thread(demoRun).start();

15    }

16}

17

18执行结果：

19我实现了Runnable

20

21

• 实现Callable接口，利用Future来创建线程（允许有返回值）

实现Callable接口的方式与实现Runnable的方式相似，区别就在于Callable可以有返回值。
• 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
• 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
• 使用FutureTask对象作为Thread对象的target创建并启动新线程。
• 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

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
1import java.util.concurrent.Callable;

2import java.util.concurrent.ExecutionException;

3import java.util.concurrent.FutureTask;

4

5//实现Callable接口，并定义返回值类型

6public class DemoCable implements Callable<String> {

7    //重写call方法

8    @Override

9    public String call() throws Exception {

10        System.out.println("我实现了Callable");

11        return "OK";

12    }

13

14    public static void main(String[] args) throws ExecutionException, InterruptedException {

15        //创建实例

16        DemoCable demoCable = new DemoCable();

17        //通过FutureTask类来包含Callable实现类

18        FutureTask<String> futureTask = new FutureTask<>(demoCable);

19        //启动线程

20        new Thread(futureTask).start();

21        //获取返回值

22        System.out.println(futureTask.get());

23    }

24}

25

26执行结果：

27我实现了Callable

28OK

29

30