java8 线程

package com.cdkj.project.syn.common;

import org.apache.commons.compress.utils.Lists;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.stream.Collectors;

public class AcquireResultTest {
    @Resource(name="threadPoolTaskExecutor")
    ThreadPoolTaskExecutor executor;
    public static void main(String[] args) throws Exception {
        //getNow方法测试
       /* CompletableFuture cp1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("测试函数2");
            try {
                Thread.sleep(10 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("测试函数");
            return "hello world";
        });*/

        /**
         *         立即获取结果不阻塞，结果计算已完成将返回结果或计算过程中的异常，如果未计算完成将返回设定的valueIfAbsent值
         *          cp1.getNow 的调用与方法执行没有关系
         */
      /*  System.out.println(cp1.getNow("0"));
         if("0".equals(cp1.getNow("0"))){
             Thread.sleep(100 );
             System.out.println(cp1.getNow("02"));
         }*/
        //join方法测试 方法里不会抛出异常
        //   CompletableFuture cp2 = CompletableFuture.supplyAsync((()-> 1 / 0));
        // System.out.println(cp2.join());

        //get方法测试 get()和get(long timeout, TimeUnit unit) => 在Future中就已经提供了，后者提供超时处理，如果在指定时间内未获取结果将抛出超时异常
        // CompletableFuture cp3 = CompletableFuture.supplyAsync((()-> 1 / 0));
        //  System.out.println(cp3.get());
        List> consumers = Lists.newArrayList();
        // 验证allof/join 方案
        Consumer consumer = value -> {
            try {
                System.out.println(Thread.currentThread().getName()+value + "测试allof");
                Thread.sleep(10000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+value + "测试allof444");
        };
        consumers.add(consumer);
        Consumer consumer2 = value -> {
            try {
                System.out.println(Thread.currentThread().getName()+value + "测试allof22");
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+value + "测试allof44422");
        };
        consumers.add(consumer2);
        Consumer consumer3 = value -> {
            try {
                System.out.println(Thread.currentThread().getName()+value + "测试allof33");
                Thread.sleep(20000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+value + "测试allof44433");
        };
        consumers.add(consumer3);
        System.out.println("*****开始******");
        consumers.stream().map(a ->CompletableFuture.runAsync(()->a.accept("hahahha"))).map(CompletableFuture::join).collect(Collectors.toList());
        System.out.println("*****结束******");
    }
}

import java.util.Random;
import java.util.concurrent.CompletableFuture;

/**allOf方法没有返回值，适合没有返回值并且需要前面所有任务执行完毕才能执行后续任务的应用场景
 * 适合前边的执行完成之后在执行后面的
 */
public class AllOfTest {
    private static Random random = new Random();
    public static void main(String[] args) throws  Exception {
        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("hello");
            return null;
        });
        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            randomSleep();
            System.out.println("world"); return null;
        });
        CompletableFuture future3 = CompletableFuture.supplyAsync(() -> {
            randomSleep();
            System.out.println("world2"); return null;
        });
        //allOf方法没有返回值，适合没有返回值并且需要前面所有任务执行完毕才能执行后续任务的应用场景
        CompletableFuture result = CompletableFuture.allOf(future1, future2,future3);
        // 起到一个阻塞作用，所有前程都执行完成之后再返回
        System.out.println(result.get());
        randomSleep();
        System.out.println("hahah");
    }



    private static void randomSleep() {
        try {
            Thread.sleep(random.nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 两个线程都会将结果打印出来，但是get方法只会返回最先完成任务的结果。
 * 该方法比较适合只要有一个返回值就可以继续执行其他任务的应用场景
 */
public class AnyOfTest {
    private static Random random = new Random();
    public static void main(String[] args) throws Exception {
        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            randomSleep();
            System.out.println("hello");
            return "hello";});
        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            randomSleep();
            System.out.println("world");
            return "world";
        });
        CompletableFuture