异步编程-线程实现异步编程

使用线程实现异步
第一种方式
第二种方式
问题

在日常开发中我们经常会遇到这样的情况，即需要异步地处理一些事情，而不需要知道异步任务的结果。比如在调用线程里面异步打日志，为了不让日志打印阻塞调用线程，会把日志设置为异步方式。

在Java中，每当我们需要执行异步任务时，可以直接开启一个线程来实现，也可以把异步任务封装为任务对象投递到线程池中来执行。接下来我们来看看Java如何实现异步。

使用线程实现异步

在Java中实现异步编程最简单的方式是：每当有异步任务要执行时，使用Tread类来创建一个线程来进行异步执行。在讲解如何显式使用Thread实现异步编程前，我们先来看下在同步编程模型下，在一个线程中要做两件事情的代码是怎样的

// 1．执行任务A
public static void doSomethingA() {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("--- doSomethingA---");
}
// 2．执行任务B
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 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 {// 1．开启异步单元执行任务Along start = System.currentTimeMillis();Thread thread = new Thread(() -> {try {doSomethingA();} catch (Exception e) {e.printStackTrace();}}, "threadA");thread.start();// 2．执行任务BdoSomethingB();// 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") {@Overridepublic 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方法，然后启动了线程执行。

问题

上面我们介绍了显式使用Thread创建异步任务的两种方式，但是上述实现方式存在几个问题：

1、每当执行异步任务时，会直接创建一个Thread来执行异步任务，这在生产实践中是不建议使用的，因为线程创建与销毁是有开销的，并且没有限制线程的个数，如果使用不当可能会把系统线程用尽，从而造成错误。在生产环境中一般创建一个线程池，然后使用线程池中的线程来执行异步任务，线程池中的线程是可以被复用的，这可以大大减少线程创建与销毁开销；另外线程池可以有效限制创建的线程个数。

2、上面使用Thread执行的异步任务并没有返回值，如果我们想异步执行一个任务，并且需要在任务执行完毕后获取任务执行结果，则上面这个方式是满足不了的，这时候就需要用到JDK中的Future了。

3、另外，每当需要异步执行时，我们需要显式地创建线程并启动，这是典型的命令式编程方式，增加了编程者的心智负担。我们需要的是声明式的异步编程方式，即告诉程序我们要异步执行，但是具体怎么实现异步应该对我们透明。