1. Thread类与Runnable接口

Thread类常用构造方法如下：

而Runnable接口源码如下：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
1
2
3
4

创建线程时，我们只需要传递一个 Runnable接口对象 或其 实现类对象（FutureTask类实现了Runnable接口）即可创建一个线程，再通过 void Thread.start ( ) 来执行线程任务。

2. 实践：创建线程并执行任务

2.1. 通过Runnable对象创建线程

若接口被 @FunctionalInterface 修饰，且这个接口只有一个 abstract 方法，就可以使用lambda表达式简写。

可以像这样，先创建Runnable接口对象，并实现其中的 void run( ) 方法，再将这个对象传入线程

// 创建Runnable对象并实现run方法
Runnable r1 = new Runnable(){
    @Override
    public void run(){
        // code here
    }
};

// 将这个Runnable对象作为参数传入
Thread t1 = new Thread(r1);
// 执行任务
t1.start();
1
2
3
4
5
6
7
8
9
10
11
12

也可以使用lambda表达式简写，如下：

// 使用lambda表达式创建Runnable对象
Runnable r2 = () -> {
    // code here
}

// 将这个Runnable对象作为参数传入
Thread t2 = new Thread(r2);
// 执行任务
t2.start();
1
2
3
4
5
6
7
8
9

2.2. 通过FutureTask对象创建线程

使用FutureTask创建的线程可以通过 T FutureTask.get( ) 来获取任务执行的返回值，但该方法会阻塞主线程直到子线程执行完毕并返回结果。

FutureTask实现了Runnable接口，而FutureTask的构造函数中，需要传入一个Callable接口对象，而Callable接口对象需要实现 T call( )，因此有如下代码：

// 创建Callable并实现call方法
Callable<Integer> c1 = new Callable<>(){
    @Override
    public Integer call(){
        // code here
        return 456;		// 由于泛型定义了Integer，这里返回值就需要返回一个Integer
    }
}

// 将Callable对象作为参数传入FutureTask类的构造方法
FutureTask ft1 = new FutureTask(c1);

// 将FutureTask对象作为参数传入
Thread t3 = new Thread(ft1);
// 执行任务
t3.start();
// 获取任务执行的返回值：会阻塞主线程，直到子线程执行完毕并返回结果
int result = ft1.get();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

同样可以使用lambda表达式简化：

// 创建Callable并实现call方法
Callable<Integer> c2 = () -> {
    // code here
    return 456;		// 由于泛型定义了Integer，这里返回值就需要返回一个Integer
}

// 将Callable对象作为参数传入FutureTask类的构造方法
FutureTask ft2 = new FutureTask(c2);

// 将FutureTask对象作为参数传入
Thread t3 = new Thread(ft1);
// 执行任务
t4.start();
// 获取任务执行的返回值：会阻塞主线程，直到子线程执行完毕并返回结果
int result = ft2.get();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

参考资料

[视频] 创建线程-方法1

[视频] 创建线程-方法2

[视频] 创建线程-lambda简化