Java之JUC

VIP文章 已于 2022-04-09 18:20:38 修改
阅读量797 收藏 2
点赞数 1
分类专栏： JUC Java 文章标签： java 开发语言 后端
于 2021-11-02 19:41:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyw4631/article/details/121107385
版权

文章目录

前置要求

线程基础知识复习

Futrue和Callable接口

  Future接口定义了操作异步任务执行一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。
  Callable接口定义了需要有返回的任务需要实现的方法。
  比如主线程让一个子线程去执行任务，子线程可能比较耗时，启动子线程开始执行任务后，主线程就去做其他事了，过了一会儿去取子任务的执行结果。

public class FutureTaskDemo {
   

    public static void main(String[] args) 
    	throws ExecutionException, InterruptedException
    {
   
        FutureTask<Integer> futureTask = new FutureTask<>(()->{
   
            System.out.println(Thread.currentThread().getName()+
                    "\t"+"===come in.");
            try {
   
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
   
            }
            return 1024;
        });
        new Thread(futureTask).start();
        System.out.println("======阳哥继续讲课=====");
        System.out.println(futureTask.get());
    }
}

运行结果：

======阳哥继续讲课=====
Thread-0	===come in.
1024

推荐 futureTask.get() 放在最后，如果不放在最后的话，我们再来看：

new Thread(futureTask).start();
// 只要出现future.get()方法，不管是否计算完成都阻塞，等待结果出来再运行
System.out.println(futureTask.get());
System.out.println("======阳哥继续讲课=====");

运行结果：

Thread-0	===come in.
1024
======阳哥继续讲课=====

针对上面说的 futrure.get()方法：

// 只要出现future.get()方法，不管是否计算完成都阻塞，等待结果出来再运行
// 工作中别用这个，别给自己挖坑
System.out.println(futureTask.get());
// 过时不候
System.out.println(futureTask.get(2, TimeUnit.SECONDS));

那么，如何避免阻塞呢？
答：用轮询来代替阻塞。
小总结：不见不散 - 过时不候 - 轮询

从之前的FutureTask说

如果要做一些复杂的任务呢？比如：
应对Future的完成时间，完成了可以告诉我，也就是我们的回调通知。
将两个异步计算合成一个异步计算，这两个异步计算互相对立，同时第二个又依赖第一个的结果。
当Future集合中某个任务最快结束时，返回结果。
等待Future结合中的所有任务都完成。
。。。。。。。。。。

对Future的改进

CompetableFuture和CompletionStage源码分别介绍

类架构说明

在这里插入图片描述

接口CompletionStage是什么

  CompletionStage代表异步计算过程中的某一阶段，一个阶段完成以后可能会触发另外一个阶段。
  一个阶段的计算执行可以是一个Function，Consumer或者Runnable。
  一个阶段的执行可能是被单个阶段的完成触发，也可能是有多个阶段一起触发。
  代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段，有些类似Linux系统的管道分隔符
在这里插入图片描述

类CompletableFuture是什么

  在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合CompletableFuture的方法。
  它可以代表一个明确完成的Future，也有可能代表一个完成阶段（CompletionStage），它支持计算完成以后触发一些函数或执行某些动作。
  它实现了Future和CompletionStage接口。

核心的四个静态方法，来创建一个异步操作

public static void main(String[] args) throws Exception {
   
   ThreadPoolExecutor threadPoolExecutor = 
 		new ThreadPoolExecutor(1, 20, 1L, TimeUnit.SECONDS,
           	new LinkedBlockingDeque<>(50), Executors.defaultThreadFactory(), 
          	 new ThreadPoolExecutor.AbortPolicy());
   CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
   
       System.out.println(Thread.currentThread().getName() + "\t" + "===come in.");
   });
   // 线程池用在哪些地方？
   CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
   
       System.out.println(Thread.currentThread().getName() + "\t" + "===come in.");
   }, threadPoolExecutor);
   threadPoolExecutor.shutdown();
 }

运行结果

ForkJoinPool.commonPool-worker-1	===come in.
pool-1-thread-1	===come in.

public static void main(String[] args) throws Exception {
   
    ThreadPoolExecutor threadPoolExecutor = 
 		new ThreadPoolExecutor(1, 20, 1L, TimeUnit.SECONDS,
           	new LinkedBlockingDeque<>(50), Executors.defaultThreadFactory(), 
    CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(()->{
   
        System.out.println(Thread.currentThread().getName() + "\t" + "===come in.");
        return 11;
    });
    CompletableFuture<Integer> future4 = CompletableFuture.supplyAsync(()->{
   
        System.out.println(Thread.currentThread().getName() + "\t" + "===come in.");
        return 12;
    }, threadPoolExecutor);
    
    threadPoolExecutor.shutdown();
}

运行结果：

ForkJoinPool.commonPool-worker-1	===come in.
pool-1-thread-1	===come in.

Executor参数说明：
没有指定Executor的方法，直接使用默认的ForkJoinPool.commonPool()，作为它的线程池执行异步代码。
如果指定线程池，则使用我们自定义的或者特别指定的线程池执行异步代码。

函数式接口名称 方法名称 参数 返回值
Runnable run 无 无
Function apply 7 有
Consume appept 7 无
Supplier get 无 有
BiConsumer accept 2 无

案例精讲-从电商网站的比价需求说

函数式编程已经成为主流

先说说join和get对比

get()
public static void main(String[] args) 
	throws ExecutionException, InterruptedException 
{
   
    System.out.println(CompletableFuture.supplyAsync(() -> {
   
        try {
    TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {
    }
        return 1;
    }).whenComplete((v, e) -> {
   
        if (e == null) {
   
            System.out.println("==result==" + v);
        }
    }).exceptionally(e -> {
   
        e.printStackTrace();
        return null;
    }).get());
    try {
    TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {
    }
}
join()
public static void main(String[] args) {
   
    System.out.println(CompletableFuture.supplyAsync(() -> {
   
        try {
    TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {
    }
        return 1;
    }).whenComplete((v, e) -> {
   
        if (e == null) {
   
            System.out.println("==result==" + v);
        }
    }).exceptionally(e -> {
   
        e.printStackTrace();
        return null;
    }).join());
    try {
    TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {
    }
}
发现了什么

get和join是一样的，只是，join不抛出异常

大厂业务需求说明

案例说明：电商比价需求

  1. 同一款产品，同时搜索出同款商品在各大电商的售价
  2. 同一款商品，同时搜索出本产品在某一个电商平台下，各个入驻门店的售价是多少
    出来结果是同款产品的在不同地方的价格清单列表，返回一个list
    e.g.
    《MySQL》in jd price is 88.05
    《MySQL》in pdd price is 86.11
    《MySQL》in taobao price is 90.43
  3. 要求深刻理解
    3.1 函数式编程
    3.2 链式编程
    3.3 Stream流式计算
public class FutureTaskDemo {
   

    public static void main(String[] args) {
   
        List<NetMall> list =
        	  Arrays.asList(new NetMall("jd"), new NetMall("ebay"),
				        	new NetMall("pdd"), new NetMall("taobao"),
				        	new NetMall("dangdang"),new NetMall("tmall"),
				        	new NetMall("suning"),new NetMall("amazon"));
				        	

        long start1 = System.currentTimeMillis();
        List<String> list1 = getPriceByStep(list, "mysql");
        for (String element : list1) {
   
            System.out.println(element);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("耗时"+(end1-start1)+"毫秒");

        long start2 = System.currentTimeMillis();
        List<String> list2 = getPriceByStep(list, "mysql");
        for (String element : list2) {
   
            System.out.println(element);
        }
        long end2 = System.currentTimeMillis();
        System.out.println("耗时"+(end2-start2)+"毫秒");
    }
    // 一步步走
    public static List<String> getPriceByStep(List<NetMall> list, String mallName) {
   
          return list.stream()
                .map(netMall ->  String.format("%s in %s price is %.2f",
                                                mallName,
                                                netMall.getMallName(),
                                                netMall.getPrice()))
                .collect(Collectors.toList());
    }
    // 万箭齐发
  public static List<String> getPriceByAsync(List<NetMall> list, String mallName) {
   
       return list.stream().
          map(netMall -> 
                CompletableFuture.supplyAsync(() -> String.format("%s in %s price is %.2f",
                                                             mallName, 
                                                             netMall.getMallName(),
                                                             netMall.getPrice())))
         .collect(Collectors.toList())
         .stream()
         .map(CompletableFuture::join)
         .collect(Collectors.toList());
    }
}

class NetMall {
   

    private String mallName;

    public NetMall(String mallName) {
   
        this.mallName = mallName;
    }
    public double getPrice() {
   
        return ThreadLocalRandom.current().nextDouble() * 2 + "mysql".charAt(0);
    }
    public String getMallName() {
   
        return this.mallName;
    }
}

CompletableFutrue常用方法

获得结果和触发计算

get()
getNow()
public static void main(String[] args) {
   
   CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
   
        try {
    TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) {
    }
        return 1;
    });
    try {
    TimeUnit.MILLISECONDS.sleep(100); } catch (InterruptedException e) {
    }
    // 立即返回，如果获取不到值，则返回自己定义的默认值
    System.out.println(future.getNow(999));
    System.out.println("============================================");

    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
   
        try {
    TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) {
    }
        return 1;
    });
    try {
    TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) {
    }
    // 立即返回，如果获取不到值，则返回自己定义的默认值
    System.out.println(future2.getNow(999));
    System.out.println("=============================================");

    CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
   
        try {
    TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) {
    }
        return 1;
    });
    try {
    TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) {
    }
    // 立即返回，如果获取不到值，则返回自己定义的默认值
    System.out.println(future3.getNow(999));
}

运行结果：

999
============================================
999
=============================================
1
boolean complete(T value)
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
   
  try {
    TimeUnit.SECONDS.sleep(20); } catch (InterruptedException e) {
    }
      return 1;
  });
  try {
    TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {
    }
  // 是否打断上面的线程，如果打断，则返回打断后自定义的值
  System.out.println(future.complete(-44) + "\t" + future.get());
}

运行结果：

-44

对计算结果进行处理

thenApply

由于存在依赖关系（当前步错，不走下一步），当前步骤有异常的话就叫停
先来看看正常的：

public static void main(String[] args) {
   
  Integer num = CompletableFuture.supplyAsync(() -> {
   
        return 1;
    }).thenApply(f -> {
   
        return f + 2;
    }).thenApply(f -> {
   
        return f + 3;
    }).whenComplete((v, e) -> {
   
        if (e == null) {
   
            System.out.println("result is " + v);
        }
    }).exceptionally(e -> {
   
        e.printStackTrace();
        return null;
    }).join();
    System.out.println("num is " + num);
}

运行结果：

result is 6
num is 6

那么，如果中途发生异常呢？

public static void main(String[] args) {
   
  Integer num = CompletableFuture.supplyAsync(() -> {
   
       return 1;
   }).thenApply(f -> {
   
   	   // 抛出异常
       int i = f / 0;
       return f + 2;
   }).whenComplete((v, e) -> {
   
       if (e == null) {
   
           System.out.println("result is " + v);
       }
   }).exceptionally(e -> {
   
       e.printStackTrace();
       return null;
   }).join();
   System.out.println("num is " + num);
}

运行结果：

java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
	at java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:273)
	at java.util.concurrent.CompletableFuture.completeThrowable(CompletableFuture.java:280)
	at java.util.concurrent.CompletableFuture.uniApply(CompletableFuture.java:604)
	at java.util.concurrent.CompletableFuture.uniApplyStage(CompletableFuture.java:614)
	at java.util.concurrent.CompletableFuture.thenApply(CompletableFuture.java:
最低0.47元/天 解锁文章
lyw4631
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java——JUC
12-29
用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;包含下载地址
Fork/Join 轻量级的形式Future
知我饭否
08-01 837
最近无意中看见这个Fork/Join ，研究了一下。写篇博客吧。算一算上一次写博客还是很久以前了。主要最近换公司了，学了一些常用的知识，不值当写。 进入正题。 正文 fork /join 是java7 里面出现的一个东西，大概意思呢，把一个大任务，拆分成好多个小任务，让多个线程去完成，等待最后 将任务结果合并就行。将大型任务拆分为较小的子任务，通常通过递归分解。作为一个非常粗略的经验法则，任务应该...
CompletableFuture之get和join
weixin_44277893的博客
10-07 766
异步框架CompletableFuture的get和join使用问题
Fork/Join以及FutureTask的原理分析（含RecursiveAction、RecursiveTask ）
qq_41864967的博客
12-18 858
FutureTask 首先讲一下FutureTask，它表示的是一种，异步操作的典范。我提交了任务，在未来我要拿到结果。 考虑一种简单的场景，甲问乙一个问题，乙一时回答不了，乙要去考虑一段时间（查一下资料），等到有结果了，再告诉甲。 这时，我们需要类甲，类乙。 它的使用原理可以博主之前的篇文章：https://blog.csdn.net/qq_41864967/article/de...
CompletableFuture的get和join对比
qq_35368296的博客
11-29 2386
1.get和join是一样的。 2.区别就是，get方法需要抛出异常，join方法不用抛异常。
【CompletableFuture】CompletableFuture中join()和get()方法的区别
热门推荐
Zero .
12-11 2万+
【CompletableFuture】CompletableFuture中join()和get()方法的区别 一.相同点： 　　join()和get()方法都是用来获取CompletableFuture异步之后的返回值 二.区别： 　　1.join()方法抛出的是uncheck异常（即未经检查的异常),不会强制开发者抛出， 　　会将异常包装成CompletionException异常 /CancellationException异常，但是本质原因还是代码内存在的真正的异常， 　　文档说明：.
CompletableFuture详解~join与get的区别
小强快跑~~
02-28 2万+
一.相同点： join()和get()方法都是用来获取CompletableFuture异步之后的返回值 二.区别： 1.join()方法抛出的是uncheck异常（即RuntimeException),不会强制开发者抛出， 　　会将异常包装成CompletionException异常 /CancellationException异常，但是本质原因还是代码内存在的真正的异常， public static void main(String[] args) { Compl
CompletableFuture.join() vs Future.get(),开发中哪个更好
weixin_44808225的博客
11-20 1152
CompletableFuture和Future都是Java中的接口，用于异步编程和并发处理。Future表示一种异步计算的结果，可以通过get()方法获取计算结果或等待计算的完成。但是，如果计算还未完成，get()方法会阻塞线程，这会影响并发性能。此外，Future只能描述单个异步计算过程，无法组合多个任务的结果。而CompletableFuture是Future的增强版本，在保留Future的基本功能的同时，还提供了更加方便的方法以支持异步操作的组合和链式调用。
关于CompletableFuture中join与get的区别
zcx12ZCX的博客
09-25 962
关于CompletableFuture中join与get的区别
java里面线程常用的方法get和join的区别
qq_35368296的博客
01-02 777
java里面线程get和join的区别
java之JUC系列.pdf
09-30
java之JUC系列.pdf
juc aqs java
12-14
juc 的aqs介绍。
Java-JUC学习PPT
05-31
Java基础之JUC学习!!!
Java JUC包 思维导图总结1
03-25
自己学习过程对Java JUC包知识的总结，看完并理解基本能应付各种基本的问题点，墙裂推荐分享 博客跳转链接： https://blog.csdn.net/qq_35642036/article/details/82767070
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 340
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1444
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 612
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1342
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 760
consul官网地址。
java的juc编程
09-29
JUC是指Java并发编程中的java.util.concurrent包，它提供了一系列新的关于并发操作的类，可以极大地方便我们实现并发编程。Java并发编程是基于多线程技术的一种编程技术，旨在解决资源利用率、响应速度和线程安全等问题，能够显著提高程序的运行效率。在Java中，创建多线程一般有四种方式，其中一种是继承Thread类，另外还有实现Runnable接口、使用Callable和Future以及使用线程池。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值