开启成长之旅！这是我参加「日新方案 2 月更文应战」的第 30 天，点击检查活动概况
前语
正文
一. 承继Thread
能够经过创立Thread的子类并在子类中重写run() 办法完成线程创立。示例如下所示。
public class ThreadTest {
@Test
public void 承继Thread() throws Exception {
// 创立线程目标
MyThread myThread = new MyThread();
// 发动线程
myThread.start();
// 睡1秒，等候子线程履行完使命
Thread.sleep(1000);
}
private static class MyThread extends Thread {
@Override
public void run() {
System.out.println("线程履行了");
}
}
}
运转测验程序，打印如下。
其实能够只承继Thread，而不重写run() 办法，此时是不会报错的，只不过调用start() 办法后线程不会履行任何逻辑。示例如下。
public class ThreadTest {
@Test
public void 承继Thread时能够不重写run办法() {
// 创立没有重写run()办法的线程目标
MyThreadNotOverrideRun myThread = new MyThreadNotOverrideRun();
// 发动线程，不报错，履行的是Thread的run()办法，无任何逻辑
myThread.start();
}
private static class MyThreadNotOverrideRun extends Thread {}
}
二. 创立Runnable目标
能够经过创立Runnable接口的完成类，然后将Runnable目标作为Thread目标的履行使命，来创立线程。示例如下。
public class ThreadTest {
@Test
public void 根据Runnable() throws Exception {
// 创立Runnable使命目标
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("使命履行");
}
};
// 创立Thread目标时将Runnable使命目标经过结构函数传入
Thread thread = new Thread(runnable);
// 发动线程
thread.start();
// 睡1秒，等候子线程履行完使命
Thread.sleep(1000);
}
}
运转测验程序，履行成果如下所示。
三. 创立Callable目标
Callable接口也是能够作为使命被线程履行，其与Runnable接口的差异在于Callable使命能够有回来值，而Runnable使命没有回来值。
由于Thread目标只能履行Runnable使命，因此无法直接让Thread履行Callable使命，可是能够先将Callable封装成FutureTask，而FutureTask是完成了Runnable接口的，所以Thread目标能够履行FutureTask使命。示例如下。
public class ThreadTest {
@Test
public void 根据Callable() throws Exception {
// 创立Callable使命目标
Callable<String> callable = new Callable<String>() {
@Override
public String call() throws Exception {
return "使命履行成果";
}
};
// 将Callable封装成FutureTask
FutureTask<String> futureTask = new FutureTask<>(callable);
// 创立Thread目标时将FutureTask经过结构函数传入
Thread thread = new Thread(futureTask);
// 发动线程
thread.start();
// 经过FutureTask拿到履行成果
System.out.println(futureTask.get());
}
}
运转测验程序，成果如下。
四. 根据Runnable创立FutureTask
在第三小节中是根据Callable来创立的FutureTask，本小节将根据Runnable来创立FutureTask。在此之前，先看一下FutureTask的类图，如下所示。
所以FutureTask即能够作为Runnable被履行，也能够作为Future获取异步履行的成果。FutureTask有两个结构函数，签名如下。
// 根据Callable创立FutureTask
public FutureTask(Callable<V> callable)
// 根据Runnable创立FutureTask
public FutureTask(Runnable runnable, V result)
下面重点看一下如何根据Runnable创立FutureTask，源码如下所示。
public FutureTask(Runnable runnable, V result) {
// 运用Executors东西类将Runnable封装成Callable
this.callable = Executors.callable(runnable, result);
this.state = NEW;
}
持续看Executors#callable(java.lang.Runnable, T) 办法，如下所示。
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null) {
throw new NullPointerException();
}
// 将Runnable封装成RunnableAdapter
return new RunnableAdapter<T>(task, result);
}
那么Executors#callable(java.lang.Runnable, T) 办法中就是将Runnable封装成了RunnableAdapter，最后再看一下RunnableAdapter的完成。
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
// 履行Runnable的逻辑
task.run();
// 履行完毕后，result作为成果回来
return result;
}
}
所以这儿能够知道，根据Runnable创立FutureTask，其本质是将Runnable先封装为Callable，然后再将Callable封装成FutureTask。还有一点需要留意，在根据Runnable创立FutureTask时，除了传入Runnable，还能够传入一个作为回来成果的目标，Runnable履行完毕后，会将这个目标回来，这个目标也能够传一个null，表明不需要回来值。
根据Runnable创立FutureTask的一个示例如下。
public class ThreadTest {
@Test
public void 根据Runnable来构建FutureTask() throws Exception {
// 创立成果目标
MyResult myResult = new MyResult();
// 创立Runnable使命目标
Runnable runnable = new Runnable() {
@Override
public void run() {
myResult.setResult("使命履行");
}
};
// 将Runnable封装成FutureTask
// Runnable履行后，会改变MyResult目标
FutureTask<MyResult> futureTask = new FutureTask<>(runnable, myResult);
// 创立Thread目标时将FutureTask经过结构函数传入
Thread thread = new Thread(futureTask);
// 发动线程
thread.start();
// 经过FutureTask拿到履行成果
System.out.println(futureTask.get().getResult());
}
private static class MyResult {
String result;
public MyResult() {}
public MyResult(String result) {
this.result = result;
}
public String getResult() {
return result;
}
public void setResult(String result) {
this.result = result;
}
}
}
运转测验程序，成果如下所示。
总结
线程的创立，总的概括有三种方式。
-
承继
Thread并重写run()办法； -
创立
Thread并履行Runnable使命； -
创立
Thread并履行Callable使命。
开启成长之旅！这是我参加「日新方案 2 月更文应战」的第 30 天，点击检查活动概况
