显式使用线程实现异步编程
摘要
本章主要讨论如何显式的使用线程实现异步编程，这其中包含如何显式使用线程实现异步编程的缺点，如何显式实现异步编程的原理。
在Java中实现异步编程最简单的方式是：每当有异步任务要执行时，使用Thread来创建一个线程来进行异步执行。在讲解如何显式使用Thread实现异步编程前，我们先来看下在同步编程模型下，在一个线程中要做两件事情的代码是怎样的：
/**
* Copyright 2020. javaymw.com Studio All Right Reserved
* <p>
* Create on 03-28 19:15
* Created by zhaoxinguo
* Version 2.0.0
*/
package com.mtons.mblog.javaymw;
/**
* @description: TODO
* @author zhaoxinguo
* @date 2020/3/28 19:15
*/
public class SyncExample {
public static void doSomethingA() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---doSomethingA---");
}
public static void doSomethingB() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---doSomethingB---");
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
// 1.执行任务A
doSomethingA();
// 2.执行任务B
doSomethingB();
System.out.println(System.currentTimeMillis() - start);
}
}
运行上面的代码会启动一个Java虚拟机进程，进程内会创建一个用户线程来执行main函数(main线程)，main线程内首先执行doSometingA方法，然后执行了doSometingB方法，那么整个过程耗时4s左右，这是因为两个方法是顺序执行的。
在Java中，Java虚拟机允许应用程序同时运行多个执行线程，所以我们可在main函数内开启一个线程来异步执行任务doSometingA，而main函数所在线程执行doSometingB，即可大大缩短整个任务处理耗时。
Java中有两种方式来显式开启一个线程进行异步处理。第一种方式是实现java.lang.Runnable接口的run方法，然后传递Runnable接口的实现类作为创建Thread时
的参数，启动线程，对应这种方式的main函数代码可以修改为如下所示：
/**
* Copyright 2020. javaymw.com Studio All Right Reserved
* <p>
* Create on 03-28 19:15
* Created by zhaoxinguo
* Version 2.0.0
*/
package com.mtons.mblog.javaymw;
/**
* @description: TODO
* @author zhaoxinguo
* @date 2020/3/28 19:15
*/
public class SyncExample {
public static void doSomethingA() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---doSomethingA---");
}
public static void doSomethingB() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---doSomethingB---");
}
public static void main(String[] args) throws InterruptedException {
long start = System.currentTimeMillis();
// 1.开启异步单元执行任务A
Thread threadA = new Thread(() -> {
doSomethingA();
}, "threadA");
threadA.start();
// 2.执行任务B
doSomethingB();
// 3.同步等待线程A运行结束
threadA.join();
System.out.println(System.currentTimeMillis() - start);
}
}
如上面代码1，我们在main函数所在线程内首先使用lambda表达式创建了一个java.lang.Runnable接口的匿名实现类，用来异步执行doSometingA任务，然后将
其作为Thread的参数并启动。这时候线程A与main线程并发运行，也就是任务doSometingA与任务doSometingB并发运行，代码3则等main线程运行完doSometingB任务后同步等待线程A运行完毕。运行上面代码，这时整个过程耗时大概2s，可知使用异步编程可以大大缩短任务运行时间。
Java中第二种开启线程进行异步执行的方式是实现Thread类，并重写run方法，这种方式的代码如下：
/**
* Copyright 2020. javaymw.com Studio All Right Reserved
* <p>
* Create on 03-28 19:15
* Created by zhaoxinguo
* Version 2.0.0
*/
package com.mtons.mblog.javaymw;
/**
* @description: TODO
* @author zhaoxinguo
* @date 2020/3/28 19:15
*/
public class SyncExample {
public static void doSomethingA() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---doSomethingA---");
}
public static void doSomethingB() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---doSomethingB---");
}
public static void main(String[] args) throws InterruptedException {
long start = System.currentTimeMillis();
// 1.开启异步单元执行任务A
Thread thread = new Thread("threadA") {
@Override
public void run() {
try {
doSomethingA();
} catch (Exception e) {
e.printStackTrace();
}
}
};
thread.start();
// 2.执行任务B
doSomethingB();
// 3.同步等待线程A运行结束
thread.join();
System.out.println(System.currentTimeMillis() - start);
}
}
上面代码1创建了Thread的匿名类的实现，并重写了run方法，然后启动了线程执行。
这里有必要提一下Java中线程是有Deamon与非Deamon之分的，默认情况下我们创建的都是非Deamon线程，线程属于什么类型的与JVM退出条件有一定的关系。在
Java中，当JVM进程内不存在非Deamon的线程时JVM就退出了。那么如何创建一个Deamon线程呢？其实将调用线程的setDaemon(boolean on)方法设置为true就
可以了，更多详细内可以参考《Java并发编程之美》这本书。
上面我们介绍了显式使用Thread创建异步任务的两种方式，但是上述实现方式存在几个问题：
- 每当执行异步任务时，会直接创建一个Thread来执行异步任务，这在生产实践中是不建议使用的，因为线程创建于销毁是有开销的，并且没有限制线程的个数
，如果使用不当可能会把系统线程用尽，从而造成错误。在生产环境中一般创建一个线程池，然后使用线程池中的线程来执行异步任务，线程池中的线程是可以被
复用的，这可以大大减少线程创建与销毁开销；另外线程池可以有效限制创建的线程个数。 - 上面使用Thread执行的异步任务并没有返回值，如果我们想异步执行一个任务，并且需要在任务执行完毕后获取任务执行结果，则上面这个方式是满足不了的
，这时候就需要用到JDK中的Future了。 - 另外，每当需要异步执行时，我们需要显式地创建线程并启动，这是典型的命令式编程方式，增加了编程者的心智负担。我们需要的是声明式的异步编程方式，
即告诉程序我们要异步执行，但是具体怎么实现异步应该对我们透明。
针对第1个问题我们可以使用线程池来解决；针对第2个问题我们可以使用Future来解决；针对第3个问题，Java中提供了很多封装良好的类库来解决，在下面章节我们会一一详细介绍。
