异步编程 - 02 显式使用线程和线程池实现异步编程
异步编程 - 02 显式使用线程和线程池实现异步编程
概述
我们主要探讨如何显式地使用线程和线程池实现异步编程，这包含如何显式使用线程实现异步编程以及使用线程编程的缺点，如何显式使用线程池实现异步编程以及线程池实现原理。
显式使用线程实现异步编程
在Java中实现异步编程最简单的方式是：每当有异步任务要执行时，使用Tread来创建一个线程来进行异步执行。在讲解如何显式使用Thread实现异步编程前，我们先来看下在同步编程模型下，在一个线程中要做两件事情的代码是怎样的
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线程内首先执行了doSomethingA方法，然后执行了doSomethingB方法，那么整个过程耗时4s左右，这是因为两个方法是顺序执行的。
在Java中，Java虚拟机允许应用程序同时运行多个执行线程，所以我们可在main函数内开启一个线程来异步执行任务doSomethingA，而main函数所在线程执行doSomethingB，即可大大缩短整个任务处理耗时。
Java中有两种方式来显式开启一个线程进行异步处理。第一种方式是实现java.lang.Runnable接口的run方法，然后传递Runnable接口的实现类作为创建Thread时的参数，启动线程，对应这种方式的main函数代码可以修改为如下所示：
public static void main(String[] args) throws InterruptedException {
long start = System.currentTimeMillis();
// 1.开启异步单元执行任务A
Thread thread = new Thread(() -> {
try {
doSomethingA();
} catch (Exception e) {
e.printStackTrace();
}
}, "threadA");
thread.start();
// 2.执行任务B
doSomethingB();
// 3.同步等待线程A运行结束
thread.join();
System.out.println(System.currentTimeMillis() - start);
}如上面代码1，我们在main函数所在线程内首先使用lambda表达式创建了一个java.lang.Runnable接口的匿名实现类，用来异步执行doSomethingA任务，然后将其作为Thread的参数并启动。这时候线程A与main线程并发运行，也就是任务doSomethingA与任务doSomethingB并发运行，代码3则等main线程运行完doSomethingB任务后同步等待线程A运行完毕。运行上面代码，这时整个过程耗时大概2s，可知使用异步编程可以大大缩短任务运行时间。
Java中第二种开启线程进行异步执行的方式是实现Thread类，并重写run方法，这种方式的代码如下：
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就可以了 。
上面我们介绍了显式使用Thread创建异步任务的两种方式，但是上述实现方式存在几个问题：
- 每当执行异步任务时，会直接创建一个Thread来执行异步任务，这在生产实践中是不建议使用的，因为线程创建与销毁是有开销的，并且没有限制线程的个数，如果使用不当可能会把系统线程用尽，从而造成错误。在生产环境中一般创建一个线程池，然后使用线程池中的线程来执行异步任务，线程池中的线程是可以被复用的，这可以大大减少线程创建与销毁开销；另外线程池可以有效限制创建的线程个数。
- 上面使用Thread执行的异步任务并没有返回值，如果我们想异步执行一个任务，并且需要在任务执行完毕后获取任务执行结果，则上面这个方式是满足不了的，这时候就需要用到JDK中的Future了。
- 另外，每当需要异步执行时，我们需要显式地创建线程并启动，这是典型的命令式编程方式，增加了编程者的心智负担。我们需要的是声明式的异步编程方式，即告诉程序我们要异步执行，但是具体怎么实现异步应该对我们透明。
针对第1个问题我们可以使用线程池来解决；针对第2个问题我们可以使用Future来解决；针对第3个问题，Java中提供了很多封装良好的类库来解决。
显式使用线程池实现异步编程
在Java中我们可以使用线程池来实现线程复用，每当我们需要执行异步任务时，可以把任务投递到线程池里进行异步执行。我们可以修改上节的代码，使用线程池来执行异步任务，修改后代码如下：
无需获取执行结果
// 0自定义线程池
private final static int AVALIABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();
private final static ThreadPoolExecutor POOL_EXECUTOR = new ThreadPoolExecutor(AVALIABLE_PROCESSORS,
AVALIABLE_PROCESSORS * 2, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<>(5),
new ThreadPoolExecutor.CallerRunsPolicy());
public static void main(String[] args) throws InterruptedException, ExecutionException {
long start = System.currentTimeMillis();
// 1.开启异步单元执行任务A
POOL_EXECUTOR.execute(() -> {
try {
doSomethingA();
} catch (Exception e) {
e.printStackTrace();
}
});
// 2.执行任务B
doSomethingB();
// 3.同步等待线程A运行结束
System.out.println(System.currentTimeMillis() - start);
// 4.挂起当前线程
Thread.currentThread().join();
}上面代码0创建了一个线程池，这里我们设置线程池核心线程个数为当前物理机的CPU核数，最大线程个数为当前物理机CPU核数的2倍；设置线程池阻塞队列的大小为5；需要注意的是，我们将线程池的拒绝策略设置为CallerRunsPolicy，即当线程池任务饱和，执行拒绝策略时不会丢弃新的任务，而是会使用调用线程来执行；
创建完线程池后，代码1则把异步任务提交到了线程池内运行，而不是直接开启一个新线程来运行；这里使用线程池起到了复用线程的作用，避免了线程的频繁创建与销毁，另外对线程个数也起到了限制作用。
其实通过上面代码我们可以进一步释放main线程的负担，也就是可以把任务doSomethingB的执行也提交到线程池内进行异步执行，代码如下：
// 0自定义线程池
private final static int AVALIABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();
private final static ThreadPoolExecutor POOL_EXECUTOR = new ThreadPoolExecutor(AVALIABLE_PROCESSORS,
AVALIABLE_PROCESSORS * 2, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<>(5),
new ThreadPoolExecutor.CallerRunsPolicy());
public static void main(String[] args) throws InterruptedException, ExecutionException {
long start = System.currentTimeMillis();
// 1.开启异步单元执行任务A
POOL_EXECUTOR.execute(() -> {
try {
doSomethingA();
} catch (Exception e) {
e.printStackTrace();
}
});
// 2.执行任务B
POOL_EXECUTOR.execute(() -> {
try {
doSomethingB();
} catch (Exception e) {
e.printStackTrace();
}
});
// 3.同步等待线程A运行结束
System.out.println(System.currentTimeMillis() - start);
// 4.挂起当前线程
Thread.currentThread().join();
}如上面代码所示，main函数所在线程只需要把两个任务提交到线程池后就可以做自己的事情了，具体两个任务是由线程池中的线程执行。
获取执行结果
上面演示了向线程池内投递异步任务并没有返回值的情况，其实我们可以向线程池投递一个Callable类型的异步任务，并且获取其执行结果，代码如下：
public class AsyncThreadPoolExample {
public static String doSomethingA() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("--- doSomethingA---");
return "A Task Done";
}
// 0自定义线程池
private final static int AVALIABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();
private final static ThreadPoolExecutor POOL_EXECUTOR = new ThreadPoolExecutor(AVALIABLE_PROCESSORS,
AVALIABLE_PROCESSORS * 2, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<>(5),
new NamedThreadFactory("ASYNC-POOL"), new ThreadPoolExecutor.CallerRunsPolicy());
public static void main(String[] args) throws InterruptedException, ExecutionException {
// 1.开启异步单元执行任务A
Future<?> resultA = POOL_EXECUTOR.submit(() -> doSomethingA());
// 2.同步等待执行结果
System.out.println(resultA.get());
}
}如上面代码所示，doSomethingA方法具有String类型的返回值，代码0创建了一个线程池，在main方法中，代码1使用lambda表达式将Callable类型的任务提交到线程池，提交后会马上返回一个Future对象，代码2在futureA上调用get()方法阻塞等待异步任务的执行结果。
如上代码确实可以在main函数所在线程获取到异步任务的执行结果，但是main线程必须以阻塞的代价来获取结果，在异步任务执行完毕前，main函数所在线程就不能做其他事情了，这显然不是我们所需要的，具体怎么解决这个问题，后面分解 。
小结
我们首先探讨了Java中最基础的显式创建线程的方式来实现异步编程，并指出了其存在的三个问题；然后讲解了显式使用线程池来实现异步编程，并且讲解了线程池的实现原理。虽然线程池方式提供了线程复用可以获取任务返回值，但是获取返回值时还是需要阻塞调用线程的，所以接下来我们会讲解JDK提供的CompletableFuture来解决这个问题。
腾讯云开发者
