JUC详解8

落日映苍穹つ 2022-12-18 01:48 227阅读 0赞

### JUC详解8 ###

*  四大函数式接口
 *   *  function
     *  Predicate
     *  Consumer
     *  supplier
 *  Stream流式计算
 *  ForkJoin
 *   *  异步回调

# 四大函数式接口 #

> **lambda表达式、链式编程、函数式接口、Stream流式计算**

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

@FunctionalInterface
    public interface Runnable { 
        public abstract void run();
    }
    //可以简化编程，在新版框架含有大量应用函数式接口

> ## function ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]

public class Test01 { 
        public static void main(String[] args) { 
            /** * Function,一个传入参数，一个返回值 * 只要是函数式接口，就可以使用lambda表达式 */
            /*Function<String, String> function = new Function<String, String>() { @Override public String apply(String s) { return s; } };*/
            Function<String, String> function = (s)->{  return s; };
            System.out.println(function.apply("set"));
        }
    }

> ## Predicate ##
> 
> 断定型接口；有一个输入参数，返回类型只能是 boolean

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]

public class Test02 { 
        public static void main(String[] args) { 
            /*Predicate<String> predicate =new Predicate<String>(){ @Override public boolean test(String s) { if ("abc".equals(s)) { return true; } return false; } };*/
            Predicate<String> predicate=(s)->{ if ("abc".equals(s)) { 
                return true;
            }
                return false;
            };
            System.out.println(predicate.test("as"));
            System.out.println(predicate.test("abc"));
        }
    }

> ## Consumer ##
> 
> 消费型接口，只有输入，没有输出

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]

public class Teat03 { 
        public static void main(String[] args) { 
            /*Consumer<String > consumer = new Consumer<String>() { @Override public void accept(String s) { System.out.println(s); } };*/
            Consumer<String > consumer =(str)->{ 
                System.out.println(str);
            };
                    consumer.accept("qwerr");
        }
    }

> ## supplier ##
> 
> 供给型，没有传入参数，只有输出

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]

public class Test04 { 
        public static void main(String[] args) { 
            Supplier<String> supplier = new Supplier<String>() { 
                @Override
                public String get() { 
                    return "这是一个供给型接口1";
                }
            };
            Supplier<String> supplier2 = ()->{ return "这是一个供给型接口2";};
            System.out.println(supplier.get());
            System.out.println(supplier2.get());
        }
    }

# Stream流式计算 #

> 什么是Stream流式计算

大数据=存储+计算  
集合、MySql本质都是用来存储的  
计算都交给流去处理

**看一道题**

package com.fly.juc.function;
    
    import java.lang.reflect.Array;
    import java.util.Arrays;
    import java.util.List;
    
    /** * 现有5个用户！筛选 * 1、ID必须为奇数 * 2、年龄必须小于24岁 * 3、用户名转换为大写字母 * 4、用户名倒着排序 * 5、只输出一个用户 */
    public class StreamTest { 
        public static void main(String[] args) { 
            User user1 = new User(1,"as",18);
            User user2 = new User(2,"awers",19);
            User user3 = new User(3,"aswere",28);
            User user4 = new User(4,"axcs",32);
            User user5 = new User(5,"asds",21);
            User user6 = new User(6,"axdcs",15);
            List<User> users = Arrays.asList(user1, user2, user3, user4, user5, user6);
            users.stream()
                    .filter(u->{ return u.getId()%2!=0;})
                    .filter(u->{ return u.getAge()<24;})
                    .map(user ->{ return user.getName().toUpperCase();} )
                    .sorted((u1,u2)->{ return u2.compareTo(u1);})
                    .limit(1)
                    .forEach(System.out::println);
        }
    }
    class User{ 
        private int id ;
        private String name;
        private int age;
        public User(int id, String name, int age) { 
            this.id = id;
            this.name = name;
            this.age = age;
        }
        public int getId() { 
            return id;
        }
        public void setId(int id) { 
            this.id = id;
        }
        public String getName() { 
            return name;
        }
        public void setName(String name) { 
            this.name = name;
        }
        public int getAge() { 
            return age;
        }
        public void setAge(int age) { 
            this.age = age;
        }
        @Override
        public String toString() { 
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

# ForkJoin #

> 什么是ForkJoin

ForkJoin在JDK1.7,并行执行任务,大数据量!

大数据: Map Reduce( 把大任务拆分成小任务)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 4]  
**ForkJoin特点: 工作窃取**  
使用

package com.czp.forkjoin;
    
    import java.time.Duration;
    import java.time.Instant;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ForkJoinPool;
    import java.util.concurrent.ForkJoinTask;
    import java.util.stream.LongStream;
    
    public class Test { 
    
        public static void main(String[] args) { 
    // test1(1L, 200_0000_0000L);//执行时间为10570毫秒 sum = -2914184820805067776
            test2(1L, 200_0000_0000L);//执行时间为202979毫秒 sum = -2935156330807653376
    // test3(1L, 200_0000_0000L);//执行时间为15894毫秒 sum = -2914184800805067776
        }
    
        public static void test1(long start, long end) { 
            Instant instant = Instant.now();
            long sum = 0;
            for (long i = start; i < end; i++) { 
                sum += i;
            }
            Instant instant1 = Instant.now();
            Duration duration = Duration.between(instant, instant1);
            System.out.println("执行时间为" + duration.toMillis() + "毫秒"+"sum = " + sum);
    
        }
    
        public static void test2(long start, long end) { 
            Instant instant = Instant.now();
            ForkJoinPool joinPool = new ForkJoinPool();
            ForkJoinTask<Long> task = new ForkJoinDemo(start, end);
            ForkJoinTask<Long> result = joinPool.submit(task);//提交任务
            Long sum = null;
            try { 
                sum = result.get();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            }
            Instant instant1 = Instant.now();
            Duration duration = Duration.between(instant, instant1);
            System.out.println("执行时间为" + duration.toMillis() + "毫秒"+"sum = " + sum);
    
        }
    
    
        // stream 并行流
        public static void test3(Long start, Long end) { 
            Instant instant = Instant.now();
            //range() 开区间 rangeClosed() 闭区间左开右闭
            long sum = LongStream.rangeClosed(start, end).parallel().reduce(0, Long::sum);
            Instant instant1 = Instant.now();
            Duration duration = Duration.between(instant, instant1);
            System.out.println("执行时间为" + duration.toMillis() + "毫秒"+"sum = " + sum);
        }
    }
    
    
    /** * 求和计算的任务 * 1. forkjoinpool 通过它来执行 * 2. 计算任务forkJoinPool, execute(forkjoinTask task) * 3. 计算类要继承自forkjointask */
    public class ForkJoinDemo extends RecursiveTask<Long> { 
    
        private long start;     // 1
        private long end;       // 20_0000_0000
        private long temp = 1_0000L;
    
        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 { 
                //分支合并计算
                long middle = (end + start) / 2;  //中间值
                ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
                task1.fork(); // 拆分任务,把任务压入线程队列
                ForkJoinDemo task2 = new ForkJoinDemo(middle + 1, end);
                task2.fork();// 拆分任务,把任务压入线程队列
    
    
                return task1.join() + task2.join();
            }
        }
    }

## 异步回调 ##

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 5]

/** * 异步调用: CompletableFuture * 异步执行 * 成功回调 * 失败回调 */
    public class Demo01 { 
    
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
            // 发起一个请求
    
    // CompletableFuture future = CompletableFuture.runAsync(()->{ 
    // System.out.println("发送一个没有返回值的异步请求");
    // });
    //
    // System.out.println("1111");
    //
    // future.get(); //获取执行结果
    
            //callable就可以实现异步调用,为什么要使用CompletableFuture呢,
            //CompletableFuture更加强大, callable只有成功回调
            //CompletableFuture可以有成功回调,异常(失败)回调
    // ExecutorService service = Executors.newCachedThreadPool();
    // Future<?> submit = service.submit(() -> { 
    // System.out.println("这个是callable实现的异步调用,异步是目的,多线程是实现方式!!!");
    // });
    // System.out.println("1111");
    // submit.get(); //获取执行结果
    
    
            CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> { 
                System.out.println("供应型接口");
                return 200;
            });
    
            //返回的结果
            Integer integer = completableFuture.whenComplete((t, u) -> { 
                //成功方法
                System.out.println(t); //正常的返回结果
                //出现的异常
                System.out.println(u); // 错误信息
            }).exceptionally((e) -> { 
                //失败方法
                e.printStackTrace();
                e.getMessage();
                return 500;
            }).get();
    
        }
    }

**上一篇：**[JUC详解7——线程池][JUC_7]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221122/0d53372fcdc54c0d837e68c2fa017d03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221122/e31549c739a94d6c9de7bdd0ff7699be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221122/a2842e0579654b2cba5cd5a47dc7280e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221122/7fefaad1135f408bae75deba7f961ef4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221122/7fcbf7a90d5b4fae801dbe46d52974a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221122/bb6ecacd733745379aa0a5934301ff11.png
[JUC_7]: https://blog.csdn.net/qq_41510551/article/details/109262718