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

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

在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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

运行上面代码会启动一个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．开启异步单元执行任务A
    long start = System.currentTimeMillis();
    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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

如上面代码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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

上面代码1创建了Thread的匿名类的实现，并重写了run方法，然后启动了线程执行。

问题

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

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

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

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