1 基础准备

1.1 并发与并行

并发是不同的代码块交替执行，也就是交替可以做不同的事情。

并行是不同的代码块同时执行，也就是同时可以做不同的事情。

根据CPU 核数，线程运行是不同的

单核CPU（微观串行，宏观并行）操作系统的任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的线程使用，由于时间片切换很快，人的感觉是在并行，实际还是串行执行的。

 多核 cpu下，每个 核（core）都可以调度运行线程，这时候线程可以是并行的。

 1.2 进程、线程

（1）进程

进程基本上是一个正在执行的程序，它是操作系统中最小的资源分配单位。

进程的上下文切换是指 cpu 从一个进程切换到另一个进程。

进程上下文切换主要包含两个主要过程：进程地址空间切换和处理器状态切换。

（2）线程

线程是进程的子集，也称为轻量级进程。一个进程可以有多个线程，这些线程由调度器独立管理。一个进程内的所有线程都是相互关联的。线程是操作系统中最小的调度单位。每个进程至少包含一个线程，每个进程的初始线程被称作主线程。

线程没有自己的地址空间，同一进程的线程之间切换，他们共享同一进程的地址空间，所以只需要切换处理器状态；不同进程的线程之间切换，会引起进程切换。

2 并发实现

2.1 原子操作

用过synchronized 关键字来保证一次只有一个线程在执行代码块。

public synchronized void code() {
    // TODO
}

Volatile 关键字保证任何线程在读取Volatile修饰的变量的时候，读取的都是这个变量的最新数据。

使用lock锁机制，其中也包括相应的读写锁

2.2 Thread

public class MyRunnable implements Runnable {
    @Override
    public void run() {
     // TODO
    }
}

public class Main {
    public static void main(String[] args) {
        Runnable task = new MyRunnable();
        Thread worker = new Thread(task);
        worker.setName('Myrunnable');
        worker.start();
}

new Thread的弊端如下：

        a. 每次new Thread新建对象性能差。
        b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
        c. 缺乏更多功能，如定时执行、定期执行、线程中断。 

2.3 Executor

Java通过Executors提供四种线程池，分别为：

• newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
• newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
• newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
• newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

    public class MyRunnable implements Runnable {
        @Override
        public void run() {
         // TODO
        }
    }    

    private static final int NUM = 5;
    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        MyRunnable myRunnable = new MyRunnable();
        pool.submit(myRunnable);
       
        if(pool.isShutdown()){
            //  ....
        }
    }

2.4 Future

Runnable只是一个接口，里面只是声明了一个run方法，可以看到方法的返回值是void，所以线程执行完了没有任何的返回值；Callable也是一个接口，它里面声明了一个call方法，可以看到它是一个泛型接口，call()函数返回的类型就是传递进来的V类型。

public interface Callable<V> {
    V call() throws Exception;
}

线程的执行是异步的，一个线程和另外一个线程的执行是互不干扰的，Futrue可以监视目标线程调用call的情况，当你调用Future的get()方法以获得结果时，当前线程就开始阻塞，直接call方法结束返回结果。

所以通过实现Callback接口，并用Future可以来接收多线程的执行结果。

主要方法：

• get（）方法可以当任务结束后返回一个结果，如果调用时，工作还没有结束，则会阻塞线程，直到任务执行完毕
• get（long timeout,TimeUnit unit）获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null，这个就避免了一直获取不到结果使得当前线程一直阻塞的情况发生
• cancel（boolean mayInterruptIfRunning）用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。
  • 参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。
  • 如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false；
  • 如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；
  • 如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true
• isDone（）方法判断当前方法是否完成
• isCancel（）表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true

demo案例：

#假设存在两个任务
public class UserInfoService {

    public UserInfo getUserInfo(Long userId) throws InterruptedException {
        Thread.sleep(300);//模拟调用耗时
        return new UserInfo("666", "捡田螺的小男孩", 27); //一般是查数据库，或者远程调用返回的
    }
}

public class MedalService {

    public MedalInfo getMedalInfo(long userId) throws InterruptedException {
        Thread.sleep(500); //模拟调用耗时
        return new MedalInfo("666", "守护勋章");
    }
}


#实现异步调用
public class FutureTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        UserInfoService userInfoService = new UserInfoService();
        MedalService medalService = new MedalService();
        long userId =666L;
        long startTime = System.currentTimeMillis();

        //调用用户服务获取用户基本信息
        FutureTask<UserInfo> userInfoFutureTask = new FutureTask<>(new Callable<UserInfo>() {
            @Override
            public UserInfo call() throws Exception {
                return userInfoService.getUserInfo(userId);
            }
        });
        executorService.submit(userInfoFutureTask);

        Thread.sleep(300); //模拟主线程其它操作耗时

        FutureTask<MedalInfo> medalInfoFutureTask = new FutureTask<>(new Callable<MedalInfo>() {
            @Override
            public MedalInfo call() throws Exception {
                return medalService.getMedalInfo(userId);
            }
        });
        executorService.submit(medalInfoFutureTask);

        UserInfo userInfo = userInfoFutureTask.get();//获取个人信息结果
        MedalInfo medalInfo = medalInfoFutureTask.get();//获取勋章信息结果

        System.out.println("总共用时" + (System.currentTimeMillis() - startTime) + "ms");
    }
}

3 CompletableFuture

3.1 CompletableFuture使用

CompletableFuture提供了一种观察者模式类似的机制，可以让任务执行完成后通知监听的一方。

public class FutureTest {

    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {

        UserInfoService userInfoService = new UserInfoService();
        MedalService medalService = new MedalService();
        long userId =666L;
        long startTime = System.currentTimeMillis();

        //调用用户服务获取用户基本信息
        CompletableFuture<UserInfo> completableUserInfoFuture = CompletableFuture.supplyAsync(() -> userInfoService.getUserInfo(userId));

        Thread.sleep(300); //模拟主线程其它操作耗时

        CompletableFuture<MedalInfo> completableMedalInfoFuture = CompletableFuture.supplyAsync(() -> medalService.getMedalInfo(userId)); 

        UserInfo userInfo = completableUserInfoFuture.get(2,TimeUnit.SECONDS);//获取个人信息结果
        MedalInfo medalInfo = completableMedalInfoFuture.get();//获取勋章信息结果
        System.out.println("总共用时" + (System.currentTimeMillis() - startTime) + "ms");

    }

CompletableFuture提供了几十种方法，辅助我们的异步任务场景。这些方法包括创建异步任务、任务异步回调、多个任务组合处理等方面。

CompletableFuture创建异步任务，一般有supplyAsync和runAsync两个方法

• supplyAsync执行CompletableFuture任务，支持返回值
• runAsync执行CompletableFuture任务，没有返回值。

//使用默认内置线程池ForkJoinPool.commonPool()，根据supplier构建执行任务
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
//自定义线程，根据supplier构建执行任务
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

//使用默认内置线程池ForkJoinPool.commonPool()，根据runnable构建执行任务
public static CompletableFuture<Void> runAsync(Runnable runnable) 
//自定义线程，根据runnable构建执行任务
public static CompletableFuture<Void> runAsync(Runnable runnable,  Executor executor)

3.2 异步回调

1）thenRun/thenRunAsync

通俗点讲就是，做完第一个任务后，再做第二个任务。某个任务执行完成后，执行回调方法；但是前后两个任务没有参数传递，第二个任务也没有返回值 

     
        CompletableFuture<Void> cp1 = CompletableFuture.runAsync(() -> {
            try {
                //执行任务A
                Thread.sleep(600);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });

        CompletableFuture<Void> cp2 =  cp1.thenRun(() -> {
            try {
                //执行任务B
                Thread.sleep(400);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

2）thenAccept/thenAcceptAsync
第一个任务执行完成后，执行第二个回调方法任务，会将该任务的执行结果，作为入参，传递到回调方法中，但是回调方法是没有返回值的。

      CompletableFuture<String> cp1 = CompletableFuture.supplyAsync(() -> {
            return "dev";

        });
      CompletableFuture<Void> cp2 =  cp1.thenAccept((a) -> {
            System.out.println("上一个任务的返回结果为: " + a);
        });
     
      cp2.get();

3）thenApply/thenApplyAsync
表示第一个任务执行完成后，执行第二个回调方法任务，会将该任务的执行结果，作为入参，传递到回调方法中，并且回调方法是有返回值的。

        CompletableFuture<String> cp1 = CompletableFuture.supplyAsync(() -> {
            return "dev";

        }).thenApply((a) -> {
            if(Objects.equals(a,"dev")){
                return "dev";
            }
            return "prod";
        });

3.3 多任务组合回调

thenCombine / thenAcceptBoth / runAfterBoth都表示：「当任务一和任务二都完成再执行任务三」。

区别在于：

• 「runAfterBoth」 不会把执行结果当做方法入参，且没有返回值
• 「thenAcceptBoth」: 会将两个任务的执行结果作为方法入参，传递到指定方法中，且无返回值
• 「thenCombine」：会将两个任务的执行结果作为方法入参，传递到指定方法中，且有返回值

   @Test
    public void testCompletableThenCombine() throws ExecutionException, InterruptedException {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //开启异步任务1
        CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务1，当前线程是：" + Thread.currentThread().getId());
            int result = 1 + 1;
            System.out.println("异步任务1结束");
            return result;
        }, executorService);

        //开启异步任务2
        CompletableFuture<Integer> task2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务2，当前线程是：" + Thread.currentThread().getId());
            int result = 1 + 1;
            System.out.println("异步任务2结束");
            return result;
        }, executorService);

        //任务组合
        CompletableFuture<Integer> task3 = task.thenCombineAsync(task2, (f1, f2) -> {
            System.out.println("执行任务3，当前线程是：" + Thread.currentThread().getId());
            System.out.println("任务1返回值：" + f1);
            System.out.println("任务2返回值：" + f2);
            return f1 + f2;
        }, executorService);

        Integer res = task3.get();
        System.out.println("最终结果：" + res);
    }

applyToEither / acceptEither / runAfterEither 都表示：「两个任务，只要有一个任务完成，就执行任务三」。

区别在于：

• 「runAfterEither」：不会把执行结果当做方法入参，且没有返回值
• 「acceptEither」: 会将已经执行完成的任务，作为方法入参，传递到指定方法中，且无返回值
• 「applyToEither」：会将已经执行完成的任务，作为方法入参，传递到指定方法中，且有返回值

3.4 其他

Future需要获取返回值，才能获取异常信息

  @Test
    public void test() {
        CompletableFuture<Double> future = CompletableFuture.supplyAsync(() -> {
            if (1 == 1) {
                throw new RuntimeException("出错了");
            }
            return 0.11;
        });

        //如果不加 get()方法这一行，看不到异常信息
        //future.get();
    }