一 點睛

1 什麼是“非同步呼叫”

“非同步呼叫”對應的是“同步呼叫”，同步呼叫指程式按照定義順序依次執行，每一行程式都必須等待上一行程式執行完成之後才能執行；非同步呼叫指程式在順序執行時，不等待非同步呼叫的語句返回結果就執行後面的程式。

二 實戰

1 新建pom

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
 

2 定義非同步任務

package com.didispace.async;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;

import java.util.Random;
import java.util.concurrent.Future;


@Component
public class Task {

    public static Random random =new Random();

    //在Spring Boot中，只需要通過使用@Async註解就能簡單的將原來的同步函式變為非同步函式
    @Async
    public Future<String> doTaskOne() throws Exception {
        System.out.println("開始做任務一");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任務一，耗時：" + (end - start) + "毫秒");
        return new AsyncResult<>("任務一完成");
    }

    @Async
    public Future<String> doTaskTwo() throws Exception {
        System.out.println("開始做任務二");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任務二，耗時：" + (end - start) + "毫秒");
        return new AsyncResult<>("任務二完成");
    }

    @Async
    public Future<String> doTaskThree() throws Exception {
        System.out.println("開始做任務三");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任務三，耗時：" + (end - start) + "毫秒");
        return new AsyncResult<>("任務三完成");
    }

}
 

3 啟動類

package com.didispace;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
//為了讓@Async註解能夠生效，還需要在Spring Boot的主程式中配置@EnableAsync
@EnableAsync
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}
 

4 測試類

package com.didispace;

import com.didispace.async.Task;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.concurrent.Future;


@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
public class ApplicationTests {

    @Autowired
    private Task task;

    @Test
    public void test() throws Exception {

        long start = System.currentTimeMillis();

        Future<String> task1 = task.doTaskOne();
        Future<String> task2 = task.doTaskTwo();
        Future<String> task3 = task.doTaskThree();

        while(true) {
            if(task1.isDone() && task2.isDone() && task3.isDone()) {
                // 三個任務都呼叫完成，退出迴圈等待
                break;
            }
            Thread.sleep(1000);
        }

        long end = System.currentTimeMillis();

        System.out.println("任務全部完成，總耗時：" + (end - start) + "毫秒");

    }

}

三 測試結果

開始做任務一

開始做任務二

開始做任務三

完成任務二，耗時：1065毫秒

完成任務三，耗時：8209毫秒

完成任務一，耗時：9563毫秒

任務全部完成，總耗時：10012毫秒

四 參考