显式使用线程实现异步编程

Posted on | Post modified: | In | Visitors: | View

显式使用线程实现异步编程

摘要

本章主要讨论如何显式的使用线程实现异步编程，这其中包含如何显式使用线程实现异步编程的缺点，如何显式实现异步编程的原理。

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

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
36
37
38
39
40
41
42
43
44
/**
 * 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函数代码可以修改为如下所示：

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/**
 * 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方法，这种方式的代码如下：

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/**
 * 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创建异步任务的两种方式，但是上述实现方式存在几个问题：

  1. 每当执行异步任务时，会直接创建一个Thread来执行异步任务，这在生产实践中是不建议使用的，因为线程创建于销毁是有开销的，并且没有限制线程的个数
    ，如果使用不当可能会把系统线程用尽，从而造成错误。在生产环境中一般创建一个线程池，然后使用线程池中的线程来执行异步任务，线程池中的线程是可以被
    复用的，这可以大大减少线程创建与销毁开销；另外线程池可以有效限制创建的线程个数。
  2. 上面使用Thread执行的异步任务并没有返回值，如果我们想异步执行一个任务，并且需要在任务执行完毕后获取任务执行结果，则上面这个方式是满足不了的
    ，这时候就需要用到JDK中的Future了。
  3. 另外，每当需要异步执行时，我们需要显式地创建线程并启动，这是典型的命令式编程方式，增加了编程者的心智负担。我们需要的是声明式的异步编程方式，
    即告诉程序我们要异步执行，但是具体怎么实现异步应该对我们透明。

针对第1个问题我们可以使用线程池来解决；针对第2个问题我们可以使用Future来解决；针对第3个问题，Java中提供了很多封装良好的类库来解决，在下面章节我们会一一详细介绍。

MiCai wechat
扫一扫，关注微信订阅号
坚持原创技术分享，您的支持将鼓励我继续创作！