JAVA——开启异步任务

通过JAVA8提供的 CompletableFuture 来实现 异步操作

用法 新建一个抽象类AsynAbstract即可

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Consumer;
import java.util.function.Supplier;

// 异步 执行任务
public abstract class AsynAbstract {

    // @since 1.5
    // ExecutorService是Java提供的线程池
    // 也就是说，每次我们需要使用线程的时候，可以通过ExecutorService获得线程。
    // 它可以有效控制最大并发线程数，提高系统资源的使用率
    // 同时避免过多资源竞争，避免堵塞，同时提供定时执行、定期执行、单线程、并发数控制等功能
    ExecutorService executor = Executors.newFixedThreadPool(20);

    public void execute(Object resultObj) {

        //异步实现 @since 1.8
        CompletableFuture<String> cupdResult = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    request(resultObj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, executor);

        cupdResult.thenAccept(new Consumer<String>() {
            @Override
            public void accept(String str) {
                callBack(str);
            }
        });
        System.out.println("完成异步前操作。。。。。");
    }

    /**
     *  实现此方法
     *  调用 execute(resultObj)即可异步执行
     * @param resultObj
     * @return
     */
    public abstract void request(Object resultObj);

    /**
     * 实现此方法
     * request 执行完，即可执行
     * @return
     */
    public abstract void callBack(String str);

}

测试：

import java.util.HashMap;
import java.util.Map;


public class AsynDemo extends AsynAbstract{


    @Override
    public void request(Object resultObj) {

        System.out.println("异步开始");

        /*try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/

        System.out.println(resultObj);

        for(int i = 0; i < 10; i++){
            System.out.println(i);
        }
    }

    @Override
    public void callBack(String str) {

        System.out.println("异步完成" + str);
    }


    public static void main(String[] args) {
        AsynDemo ad = new AsynDemo();

        Map<String, String> map = new HashMap<>();
        map.put("1", "a");
        map.put("2", "b");
        map.put("3", "c");

        ad.execute(map);

        System.out.println("main 走完");
    }

}

结果：

完成异步前操作。。。。。
main 走完
异步开始
{1=a, 2=b, 3=c}
0
1
2
3
4
5
6
7
8
9
异步完成null

每次结果顺序不一定一致

能保证的是  ad.execute(map); 是异步的