FutureDemo

package async;

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class FutureDemo {
    public static void main(String[] args) {
        AtomicInteger integer = new AtomicInteger();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>() {
        });
        Future<AtomicInteger> future1 = executor.submit(() -> {
            integer.incrementAndGet();
            return integer;
        });
        Future<AtomicInteger> future2 = executor.submit(() -> {
            integer.incrementAndGet();
        }, integer);
        //Future<T> 表示这个 Future 对象可以持有类型为 T 的结果，而 Future<?> 表示这个 Future 对象可以持有任意类型的结果，包括空。
//        Future<?> future3 = executor.submit(() -> {
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            integer.incrementAndGet();
//        });
        //Future<?>中，?是一个通配符，可以匹配任意类型，可以为空。future3对应的就是空.?一般用在定义属性或方法参数？
        //目前对异步的理解是，提交任务之后，submit创建了futureTask并调用了excute方法。excute方法把任务放到workers队列，然后就直接返回空，实现了非阻塞
        try {
//            System.out.println(future1.get());
//            System.out.println(future2.get());
            System.out.println("xxxx");
            System.out.println("yyyy");
            System.out.println(future2.get());

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}