JUC编程：线程池-四大函数式接口-Stream流

作者: 弹钢琴的崽崽 | 来源:发表于2020-03-26 08:40 被阅读0次

JUC编程：线程池-四大函数式接口-Stream流
Java8（2）Stream类
恕我直言你可能真的不会java第2篇：Java Stream A
java基础-day23-函数式接口和Stream流
新特性4-Streams API
玩转Java8Stream（二、函数式接口）
java stream 2 函数式接口
Stream API使用
博客系列-2019年时间轴
2018-11-11

1. 读写锁

ReadWriteLock

独占锁（写锁）一次只能被一个线程占有
共享锁（读锁）多个线程可以同时占有
ReadWriteLock
读-读可以共存！
读-写不能共存！
写-写不能共存！

package com.kuang.rw;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 独占锁（写锁） 一次只能被一个线程占有
* 共享锁（读锁） 多个线程可以同时占有
* ReadWriteLock
* 读-读 可以共存！
* 读-写 不能共存！
* 写-写 不能共存！
*/
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        // 写入
        for (int i = 1; i <= 5 ; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        // 读取
        for (int i = 1; i <= 5 ; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}
// 加锁的
class MyCacheLock{
    private volatile Map<String,Object> map = new HashMap<>();
    // 读写锁： 更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock lock = new ReentrantLock();
    // 存，写入的时候，只希望同时只有一个线程写
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
    // 取，读，所有人都可以读！
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}
/**
* 自定义缓存
*/
class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();
    // 存，写
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入OK");
    }
    // 取，读
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取OK");
    }
}

2. 阻塞队列

阻塞队列：

BlockingQueue BlockingQueue 不是新的东西

什么情况下我们会使用阻塞队列：多线程并发处理，线程池！

2.1 学会使用队列

添加、移除

四组API

方式	抛出异常	有返回值，不抛出异常	阻塞等待	超时等待
添加	add	offer()	put()	offer(,,)
移除	remove	poll()	take()	poll(,)
检测队首元素	element	peek	-	-

抛出异常的方法：

/**
* 抛出异常
*/
public static void test1(){
    // 队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
    System.out.println(blockingQueue.add("a"));
    System.out.println(blockingQueue.add("b"));
    System.out.println(blockingQueue.add("c"));
    // IllegalStateException: Queue full 抛出异常！
    // System.out.println(blockingQueue.add("d"));
    System.out.println("=-===========");
    System.out.println(blockingQueue.remove());
    System.out.println(blockingQueue.remove());
    System.out.println(blockingQueue.remove());
    // java.util.NoSuchElementException 抛出异常！
    // System.out.println(blockingQueue.remove());
}

有返回值，不抛出异常

/**
* 有返回值，没有异常
*/
public static void test2(){
    // 队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
    System.out.println(blockingQueue.offer("a"));
    System.out.println(blockingQueue.offer("b"));
    System.out.println(blockingQueue.offer("c"));
    // System.out.println(blockingQueue.offer("d")); // false 不抛出异常！
    System.out.println("============================");
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll()); // null 不抛出异常！
}

阻塞等待

/**
* 等待，阻塞（一直阻塞）
*/
public static void test3() throws InterruptedException {
    // 队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
    // 一直阻塞
    blockingQueue.put("a");
    blockingQueue.put("b");
    blockingQueue.put("c");
    // blockingQueue.put("d"); // 队列没有位置了，一直阻塞
    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take()); // 没有这个元素，一直阻塞
}

超时等待：

/**
* 等待，阻塞（等待超时）
*/
public static void test4() throws InterruptedException {
    // 队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
    blockingQueue.offer("a");
    blockingQueue.offer("b");
    blockingQueue.offer("c");
    // blockingQueue.offer("d",2,TimeUnit.SECONDS); // 等待超过2秒就退出
    System.out.println("===============");
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    blockingQueue.poll(2,TimeUnit.SECONDS); // 等待超过2秒就退出
}

SynchronousQueue 同步队列

没有容量，

进去一个元素，必须等待取出来之后，才能再往里面放一个元素！

put、take

同步队列
和其他的BlockingQueue不一样， SynchronousQueue 不存储元素
put了一个元素，必须从里面先take取出来，否则不能在put进去值！

package com.kuang.bq;
import java.sql.Time;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
/**
* 同步队列
* 和其他的BlockingQueue 不一样， SynchronousQueue 不存储元素
* put了一个元素，必须从里面先take取出来，否则不能在put进去值！
*/
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>(); // 同步队列
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+" put 1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName()+" put 2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName()+" put 3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1").start();
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"=>"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"=>"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"=>"+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2").start();
    }
}

3. 线程池(重点)

线程池：三大方法、7大参数、4种拒绝策略

池化技术

程序的运行，本质：占用系统的资源！ 优化资源的使用！=>池化技术

线程池、连接池、内存池、对象池///..... 创建、销毁。十分浪费资源

池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。

线程池的好处:

降低资源的消耗
提高响应的速度
方便管理。

线程复用、可以控制最大并发数、管理线程

线程池：三大方法

ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
ExecutorService threadPool = Executors.newFixedThreadPool(5);// 创建一个固定的线程池的大小
ExecutorService threadPool = Executors.newCachedThreadPool();// 可伸缩的，遇强则强，遇弱则弱

package com.kuang.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// Executors 工具类、3大方法
public class Demo01 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
            // ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
            // ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的，遇强则强，遇弱则弱
            try {
                for (int i = 0; i < 100; i++) {
                    // 使用了线程池之后，使用线程池来创建线程
                    threadPool.execute(()->{
                        System.out.println(Thread.currentThread().getName()+" ok");
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 线程池用完，程序结束，关闭线程池
                threadPool.shutdown();
            }
    }
}

7大参数

源码分析：

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(5, 5,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

本质ThreadPoolExecutor（）

public ThreadPoolExecutor(int corePoolSize, // 核心线程池大小
                          int maximumPoolSize, // 最大核心线程池大小
                          long keepAliveTime, // 超时了没有人调用就会释放
                          TimeUnit unit, // 超时单位
                          BlockingQueue<Runnable> workQueue, // 阻塞队列
                          ThreadFactory threadFactory, // 线程工厂：创建线程的，一般不用动
                          RejectedExecutionHandler handle // 拒绝策略) {
                          if (corePoolSize < 0 ||
                              maximumPoolSize <= 0 ||
                              maximumPoolSize < corePoolSize ||
                              keepAliveTime < 0)
                          throw new IllegalArgumentException();
                          if (workQueue == null || threadFactory == null || handler == null)
                          throw new NullPointerException();
                          this.acc = System.getSecurityManager() == null ?
                          null :
                          AccessController.getContext();
                          this.corePoolSize = corePoolSize;
                          this.maximumPoolSize = maximumPoolSize;
                          this.workQueue = workQueue;
                          this.keepAliveTime = unit.toNanos(keepAliveTime);
                          this.threadFactory = threadFactory;
                          this.handler = handler;
                          }

可以对照银行办理业务

核心线程数：永远开启的窗口
最大线程数：所有窗口
阻塞队列：侯客区
拒绝策略：人满了，对进来的人的处理方式

手动创建一个线程池

package com.kuang.pool;
import java.util.concurrent.*;
// Executors 工具类、3大方法
/**
* new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异
常
* new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！
* new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
* new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会
抛出异常！
*/
public class Demo01 {
    public static void main(String[] args) {
        // 自定义线程池！工作 ThreadPoolExecutor
        ExecutorService threadPool = new ThreadPoolExecutor(
            2,
            5,
            3,
            TimeUnit.SECONDS,
            new LinkedBlockingDeque<>(3),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.DiscardOldestPolicy()); //队列满了，尝试去和最早的竞争，也不会抛出异常！
            try {
                // 最大承载：Deque + max
                // 超过 RejectedExecutionException
                for (int i = 1; i <= 9; i++) {
                    // 使用了线程池之后，使用线程池来创建线程
                    threadPool.execute(()->{
                        System.out.println(Thread.currentThread().getName()+" ok");
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 线程池用完，程序结束，关闭线程池
                threadPool.shutdown();
            }
    }
}

4种拒绝策略

new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异
常
new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！
new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会
抛出异常！

小结和拓展

池的最大的大小如何去设置！

了解：IO密集型，CPU密集型：（调优）

1、CPU 密集型，几核，就是几，可以保持CPu的效率最高！

获得CPU核数：Runtime.getRuntime().availableProcessors()

2、IO 密集型 > 判断你程序中十分耗IO的线程，程序 15个大型任务 io十分占用资源！

package com.kuang.pool;
import java.util.concurrent.*;
public class Demo01 {
    public static void main(String[] args) {
        // 自定义线程池！工作 ThreadPoolExecutor
        // 最大线程到底该如何定义
        // 1、CPU 密集型，几核，就是几，可以保持CPu的效率最高！
        // 2、IO 密集型 > 判断你程序中十分耗IO的线程，
        // 程序 15个大型任务 io十分占用资源！
        // 获取CPU的核数
        System.out.println(Runtime.getRuntime().availableProcessors());
        ExecutorService threadPool = new ThreadPoolExecutor(
            2,
            Runtime.getRuntime().availableProcessors(),
            3,
            TimeUnit.SECONDS,
            new LinkedBlockingDeque<>(3),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.DiscardOldestPolicy()); //队列满了，尝试去和最早的竞争，也不会抛出异常！
            try {
                // 最大承载：Deque + max
                // 超过 RejectedExecutionException
                for (int i = 1; i <= 9; i++) {
                    // 使用了线程池之后，使用线程池来创建线程
                    threadPool.execute(()->{
                        System.out.println(Thread.currentThread().getName()+" ok");
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 线程池用完，程序结束，关闭线程池
                threadPool.shutdown();
            }
    }
}

4. 四大函数式接口（必需掌握）

新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算

函数式接口：只有一个方法的接口

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
// 泛型、枚举、反射
// lambda表达式、链式编程、函数式接口、Stream流式计算
// 超级多FunctionalInterface
// 简化编程模型，在新版本的框架底层大量应用！
// foreach(消费者类的函数式接口)

Function函数式接口

package com.kuang.function;
import java.util.function.Function;
/**
* Function 函数型接口, 有一个输入参数，有一个输出
* 只要是 函数型接口 可以 用 lambda表达式简化
*/
public class Demo01 {
    public static void main(String[] args) {
        //
        // Function<String,String> function = new Function<String,String>() {
        // @Override
        // public String apply(String str) {
        // return str;
        // }
        // };
        Function<String,String> function = (str)->{return str;};
        System.out.println(function.apply("asd"));
    }
}

断定型接口：有一个输入参数，返回值只能是布尔值！

package com.kuang.function;
import java.util.function.Predicate;
/**
* 断定型接口：有一个输入参数，返回值只能是 布尔值！
*/
public class Demo02 {
    public static void main(String[] args) {
        // 判断字符串是否为空
        // Predicate<String> predicate = new Predicate<String>(){
        //// @Override
        //// public boolean test(String str) {
        //// return str.isEmpty();
        //// }
        //// };
        Predicate<String> predicate = (str)->{return str.isEmpty(); };
        System.out.println(predicate.test(""));
    }
}

Consumer 消费型接口

package com.kuang.function;
import java.util.function.Consumer;
/**
* Consumer 消费型接口: 只有输入，没有返回值
*/
public class Demo03 {
    public static void main(String[] args) {
        // Consumer<String> consumer = new Consumer<String>() {
        // @Override
        // public void accept(String str) {
        // System.out.println(str);
        // }
        // };
        Consumer<String> consumer = (str)->{System.out.println(str);};
        consumer.accept("sdadasd");
    }
}

Supplier 供给型接口

package com.kuang.function;
import java.util.function.Supplier;
/**
* Supplier 供给型接口 没有参数，只有返回值
*/
public class Demo04 {
    public static void main(String[] args) {
        // Supplier supplier = new Supplier<Integer>() {
        // @Override
        // public Integer get() {
        // System.out.println("get()");
        // return 1024;
        // }
        // };
        Supplier supplier = ()->{ return 1024; };
        System.out.println(supplier.get());
    }
}

5. Stream流式计算

什么是Stream流式计算

大数据：存储 + 计算

集合、MySQL 本质就是存储东西的；

计算都应该交给流来操作！

package com.kuang.stream;
import java.util.Arrays;
import java.util.List;
/**
* 题目要求：一分钟内完成此题，只能用一行代码实现！
* 现在有5个用户！筛选：
* 1、ID 必须是偶数
* 2、年龄必须大于23岁
* 3、用户名转为大写字母
* 4、用户名字母倒着排序
* 5、只输出一个用户！
*/
public class Test {
    public static void main(String[] args) {
        User u1 = new User(1,"a",21);
        User u2 = new User(2,"b",22);
        User u3 = new User(3,"c",23);
        User u4 = new User(4,"d",24);
        User u5 = new User(6,"e",25);
        // 集合就是存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
        // 计算交给Stream流
        // lambda表达式、链式编程、函数式接口、Stream流式计算
        list.stream()
            .filter(u->{return u.getId()%2==0;})
            .filter(u->{return u.getAge()>23;})
            .map(u->{return u.getName().toUpperCase();})
            .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
            .limit(1)
            .forEach(System.out::println);
    }
}

6. ForkJoin

什么是 ForkJoin

ForkJoin 在 JDK 1.7 ，并行执行任务！提高效率。大数据量！

大数据：Map Reduce （把大任务拆分为小任务）

ForkJoin 特点：工作窃取

这个里面维护的都是双端队列

ForkJoin

package com.kuang.forkjoin;
import java.util.concurrent.RecursiveTask;
/**
* 求和计算的任务！
* 3000 6000（ForkJoin） 9000（Stream并行流）
* // 如何使用 forkjoin
* // 1、forkjoinPool 通过它来执行
* // 2、计算任务 forkjoinPool.execute(ForkJoinTask task)
* // 3. 计算类要继承 ForkJoinTask
*/
public class ForkJoinDemo extends RecursiveTask<Long> {
    private Long start; // 1
    private Long end; // 1990900000
    // 临界值
    private Long temp = 10000L;
    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }
    // 计算方法
    @Override
    protected Long compute() {
        if ((end-start)<temp){
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }else { // forkjoin 递归
            long middle = (start + end) / 2; // 中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork(); // 拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork(); // 拆分任务，把任务压入线程队列
            return task1.join() + task2.join();
        }
    }
}

测试：

package com.kuang.forkjoin;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
/**
* 同一个任务，别人效率高你几十倍！
*/
public class Test {
    public static void main(String[] args) throws ExecutionException,
    InterruptedException {
        // test1(); // 12224
        // test2(); // 10038
        // test3(); // 153
    }
    // 普通程序员
    public static void test1(){
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }
    // 会使用ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);// 提交任务
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }
    public static void test3(){
        long start = System.currentTimeMillis();
        // Stream并行流 () (]
        long sum = LongStream.rangeClosed(0L,
                                          10_0000_0000L).parallel().reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+"时间："+(end-start));
    }
}

7. 异步回调

Future 设计的初衷：对将来的某个事件的结果进行建模

无返回值：

package com.kuang.future;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
/**
* 异步调用： CompletableFuture
* // 异步执行
* // 成功回调
* // 失败回调
*/
public class Demo01 {
    public static void main(String[] args) throws ExecutionException,
    InterruptedException {
        // 没有返回值的 runAsync 异步回调
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"runAsync=>Void");
        });
        System.out.println("1111");
        completableFuture.get();//获取阻塞执行结果
    }
}

又返回值：

package com.kuang.future;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
/**
* 异步调用： CompletableFuture
* // 异步执行
* // 成功回调
* // 失败回调
*/
public class Demo01 {
    public static void main(String[] args) throws ExecutionException,
    InterruptedException {
        // 有返回值的 supplyAsync 异步回调
        // ajax，成功和失败的回调
        // 返回的是错误信息；
        CompletableFuture<Integer> completableFuture =
            CompletableFuture.supplyAsync(()->{
                System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
                int i = 10/0;
                return 1024;
            });
        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t=>" + t); // 正常的返回结果
            System.out.println("u=>" + u); // 错误信息：           java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233; // 可以获取到错误的返回结果
        }).get());
        /**
* succee Code 200
* error Code 404 500
*/
    }
}

JUC编程：线程池-四大函数式接口-Stream流
1. 读写锁 ReadWriteLock 独占锁（写锁）一次只能被一个线程占有共享锁（读锁）多个线程可以同时...
Java8（2）Stream类
参考书籍：《Java 8函数式编程》一. 四种最基本的函数式接口使用Stream类进行流操作之前，先了解一下四...
恕我直言你可能真的不会java第2篇：Java Stream A
一、什么是Java Stream API？ Java Stream函数式编程接口最初是在Java 8中引入的，并且...
java基础-day23-函数式接口和Stream流
函数式接口和Stream 1. 函数式接口 1.1 函数式接口概述 1.2 常用函数式接口 1.3 比较器函数式接...
新特性4-Streams API
流API是Java 8引入了函数式编程的证明，Stream API提供了元素流的函数式操作，包括list、set、...
玩转Java8Stream（二、函数式接口）
函数式接口是伴随着Stream的诞生而出现的，Java8Stream 作为函数式编程的一种具体实现，开发者无需关注...
java stream 2 函数式接口
函数式接口是伴随着Stream的诞生而出现的，Java8Stream 作为函数式编程的一种具体实现，开发者无需关注...
Stream API使用
其他内容请参考Stream官方文档。 1.为什么引入Stream？ Stream是Java函数式编程的主角。函数式...
博客系列-2019年时间轴
2019年 JUC线程池服务ExecutorService接口实现源码分析 Github Page：http://...
2018-11-11
函数式编程-Stream流 1. 概述[https://www.jianshu.com/writer#1-%E6%...