1. 多线程,CompletableFuture

最新推荐文章于 2024-08-22 04:29:14 发布
最新推荐文章于 2024-08-22 04:29:14 发布
阅读量421 收藏 1
点赞数 1
分类专栏： # juc&并发编程 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxsxkf/article/details/124582996
版权

多线程的原因

  • 硬件方面：摩尔定律失效，在主频不再提高且核数在不断增加的情况下，要想让程序更快就要用到并行或并发编程。
  • 软件方面：高并发系统，异步+回调等生产需求

private native void start0();

  1. openjdk8\jdk\src\share\native\java\lang thread.c
    java线程是通过start的方法启动执行的，主要内容在native方法start0中，Openjdk的写JNI一般是一一对应的，Thread.java对应的就是Thread.cstart0其实就是JVM_StartThread。此时查看源代码可以看到在jvm.h中找到了声明，jvm.cpp中有实现。
    在这里插入图片描述

  2. openjdk8\hotspot\src\share\vm\prims jvm.cpp
    在这里插入图片描述
    在这里插入图片描述

  3. openjdk8\hotspot\src\share\vm\runtime thread.cpp
    在这里插入图片描述

进程

  • 是程序的⼀次执⾏，是系统进⾏资源分配和调度的独⽴单位，每⼀个进程都有它⾃⼰的内存空间和系统资源

线程

  • 在同⼀个进程内⼜可以执⾏多个任务，⽽这每⼀个任务我们就可以看做是⼀个线程(⼀个进程会有1个或多个线程的)

管程

Monitor(监视器) ,锁
Monitor其实是一种同步机制，他的义务是保证（同一时间）只有一个线程可以访问被保护的数据和代码。
JVM中同步是基于进入和退出监视器对象(Monitor,管程对象)来实现的，每个对象实例都会有一个Monitor对象，

 Object o = new Object();

new Thread(() -> {
    synchronized (o)
    {

    }
},"t1").start();

Monitor对象会和Java对象一同创建并销毁，它底层是由C++语言来实现的。
在这里插入图片描述

用户线程和守护线程

  • 守护线程
    是一种特殊的线程，在后台默默地完成一些系统性的服务，比如垃圾回收线程

  • 用户线程
    是系统的工作线程，它会完成这个程序需要完成的业务操作

public class DaemonDemo
{
public static void main(String[] args)
{
    Thread t1 = new Thread(() -> {
        System.out.println(Thread.currentThread().getName()+"\t 开始运行，"+(Thread.currentThread().isDaemon() ? "守护线程":"用户线程"));
        while (true) {

        }
    }, "t1");
    //线程的daemon属性为true表示是守护线程，false表示是用户线程
    t1.setDaemon(true);
    t1.start();
    //3秒钟后主线程再运行
    try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }

    System.out.println("----------main线程运行完毕");
}

}

CompletableFuture

Future和Callable接口

  • Future接口定义了操作异步任务执行一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。
  • Callable接口中定义了需要有返回的任务需要实现的方法
    Callable有返回有异常
    在这里插入图片描述
    在这里插入图片描述

get方法会阻塞

public class CompletableFutureDemo
{
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException
    {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            System.out.println("-----come in FutureTask");
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            return ""+ThreadLocalRandom.current().nextInt(100);
        });

        Thread t1 = new Thread(futureTask,"t1");
        t1.start();

        //3秒钟后才出来结果，还没有计算你提前来拿(只要一调用get方法，对于结果就是不见不散，会导致阻塞)
        //System.out.println(Thread.currentThread().getName()+"\t"+futureTask.get());

        //3秒钟后才出来结果，我只想等待1秒钟，过时不候,会报错 java.util.concurrent.TimeoutException
        System.out.println(Thread.currentThread().getName()+"\t"+futureTask.get(1L,TimeUnit.SECONDS));

        System.out.println(Thread.currentThread().getName()+"\t"+" run... here");

    }
}

isDone()轮询

  • 轮询的方式会耗费无谓的CPU资源，而且也不见得能及时地得到计算结果.
  • 如果想要异步获取结果,通常都会以轮询的方式去获取结果尽量不要阻塞
    public static void main(String[] args) throws ExecutionException, InterruptedException
    {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            System.out.println("-----come in FutureTask");
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            return ""+ThreadLocalRandom.current().nextInt(100);
        });

        new Thread(futureTask,"t1").start();

        System.out.println(Thread.currentThread().getName()+"\t"+"线程完成任务");

        /**
         * 用于阻塞式获取结果,如果想要异步获取结果,通常都会以轮询的方式去获取结果
         */
        while(true)
        {
            if (futureTask.isDone())
            {
                System.out.println(futureTask.get());
                break;
            }
        }

    }

CompletableFuture

public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {

  • 接口CompletionStage
    在这里插入图片描述

  • 类CompletableFuture
    在这里插入图片描述

runAsync 无 返回值

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

  • public static CompletableFuture runAsync(Runnable runnable)
  • public static CompletableFuture runAsync(Runnable runnable,Executor executor)
public class CompletableFutureDemo2
{
    public static void main(String[] args) throws ExecutionException, InterruptedException
    {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName()+"\t"+"-----come in");
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("-----task is over");
        });
        System.out.println(future.get());
    }
}

在这里插入图片描述

supplyAsync 有 返回值

  • public static CompletableFuture supplyAsync(Supplier supplier)
  • public static CompletableFuture supplyAsync(Supplier supplier,Executor executor)
public class CompletableFutureDemo2
{
    public static void main(String[] args) throws ExecutionException, InterruptedException
    {
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "-----come in");
            //暂停几秒钟线程
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return ThreadLocalRandom.current().nextInt(100);
        });

        System.out.println(completableFuture.get());
    }
}

public class CompletableFutureDemo2
{
    public static void main(String[] args) throws ExecutionException, InterruptedException
    {
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "-----come in");
            //暂停几秒钟线程
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return ThreadLocalRandom.current().nextInt(100);
        });

        System.out.println(completableFuture.get());
    }
}

get和join

get会抛出异常，join不会抛出异常

CompletableFuture的优点

  • 异步任务结束时，会自动回调某个对象的方法；
  • 异步任务出错时，会自动回调某个对象的方法；
  • 主线程设置好回调后，不再关心异步任务的执行，异步任务之间可以顺序执行

获得结果和触发计算

public T get() 不见不散
public T get(long timeout, TimeUnit unit) 时间内不给会抛异常
public T getNow(T valueIfAbsent)
  • 计算完，返回计算完成后的结果
  • 没算完，返回设定的valueIfAbsent值
public boolean complete(T value)
  • 在调用的时候 如果已经计算结束了 就返回true,completableFuture.get()会返回计算完的值，不然返回传入的参数

对计算结果进行处理

thenApply，计算结果存在依赖关系，这两个线程串行化
  //当一个线程依赖另一个线程时用 thenApply 方法来把这两个线程串行化,
    CompletableFuture.supplyAsync(() -> {
        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("111");
        return 1024;
    }).thenApply(f -> {
        System.out.println("222");
        return f + 1;
    }).thenApply(f -> {
        //int age = 10/0; // 异常情况：那步出错就停在那步。
        System.out.println("333");
        return f + 1;
    }).whenCompleteAsync((v,e) -> {
    	// 会执行
        System.out.println("*****v: "+v);
    }).exceptionally(e -> {
        e.printStackTrace();
        // 异常返回的值
        return null;
    });

    System.out.println("-----主线程结束，END");
handle 有异常也可以往下一步走，根据带的异常参数可以进一步处理
public static void main(String[] args) throws ExecutionException, InterruptedException
    {
        //当一个线程依赖另一个线程时用 handle 方法来把这两个线程串行化,
        // 异常情况：有异常也可以往下一步走，根据带的异常参数可以进一步处理
        CompletableFuture.supplyAsync(() -> {
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("111");
            return 1024;
        }).handle((f,e) -> {
        	// 当前节点不走，下一节点接着走
            int age = 10/0;
            System.out.println("222");
            return f + 1;
        }).handle((f,e) -> {
            System.out.println("333");
            return f + 1;
        }).whenCompleteAsync((v,e) -> {
            System.out.println("*****v: "+v);
        }).exceptionally(e -> {
            e.printStackTrace();
            return null;
        });

        System.out.println("-----主线程结束，END");

        // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
    }

在这里插入图片描述
在这里插入图片描述

对计算结果进行消费

thenAccept
    CompletableFuture.supplyAsync(() -> {
        return 1;
    }).thenApply(f -> {
        return f + 2;
    }).thenApply(f -> {
        return f + 3;
    }).thenApply(f -> {
        return f + 4;
    }).thenAccept(r -> System.out.println(r));

对计算速度进行选用

applyToEither(谁快用谁)
        CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in ");
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            return 10;
        });

        CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in ");
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            return 20;
        });

        CompletableFuture<Integer> thenCombineResult = completableFuture1.applyToEither(completableFuture2,f -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in ");
            return f + 1;
        });

        System.out.println(Thread.currentThread().getName() + "\t" + thenCombineResult.get());

对计算结果进行合并

两个CompletionStage任务都完成后，最终能把两个任务的结果一起交给thenCombine 来处理

 public static void main(String[] args) throws ExecutionException, InterruptedException
    {
        CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in ");
            return 10;
        });

        CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in ");
            return 20;
        });

        CompletableFuture<Integer> thenCombineResult = completableFuture1.thenCombine(completableFuture2, (x, y) -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in ");
            return x + y;
        });
        
        System.out.println(thenCombineResult.get());
    }
土拨鼠饲养员
关注
专栏目录
java8--新特性CompletableFuture多线程
专搞技术的小兔子
07-13 736
java8新特性CompletableFuture多线程 参考文章: http://javadaily.cn/articles/2021/03/18/1616064645189.html https://www.liaoxuefeng.com/wiki/1252599548343744/1306581182447650 CompletableFuture可以指定异步处理流程： thenAccept()处理正常结果； exceptional()处理异常结果； thenApplyAsync()用于串行化另一个C
多线程之CompletableFuture全方面解析
洱涷zZ的博客
08-30 6246
多线程之CompletableFuture全方面解析
CompletableFuture多线程
qq_21480329的博客
05-03 1968
Java CompletableFuture多线程应用，在实际开发中，为了提高应用程序效率，该博客主要是在解决高并发调用第三方接口时设计，在同步情况下调用第三方接口200次，需要时间约为28秒左右，效率低，app体验差；需对其优化，故使用多线程，提高其效率，优化后，在10个线程下并发调用，需要时间约为5~7秒左右。 一.线程池 线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地...
【JAVA多线程】CompletableFuture原理剖析
最新发布
Joker_ZJN的博客
08-22 1197
详解异步编程利器，completablefuture
Java多线程之CompletableFuture
上善若泪
04-28 2万+
文章目录1 CompletableFuture1.1 简介1.2 创建CompletableFuture1.2.1 构造函数创建1.2.2 supplyAsync创建1.2.3 runAsync创建1.3 异步回调方法1.3.1 thenApply / thenAccept / thenRun互相依赖1.3.1.1 thenApply1.3.1.2 thenAccept / thenRun1.3.2 exceptionally有返回1.3.3 whenComplete无返回1.3.4 handle有返回1.
多线程之CompletableFuture使用
适恒
06-22 3800
一、简单介绍 CompletableFuture是java8新增的并发工具类，继承了FutureTask的同步任务的特点，同时新增了异步调用的特点（其中异步的方法名称都带有Async），换而言之同步获取方法的返回值的方式可以用CompletableFuture完成，与此同时，想要异步获取方法的返回值也可以使用CompletableFuture来完成。 异步带Async，并且底层执行的线程由ForkJoinPool支持。于此同时还多了异常处理（执行任务的时候可能会发生异常，以前使用FutureTask的
多线程之CompletableFuture
weixin_43914439的博客
04-28 778
浅谈多线程之CompletableFuture
Java 多线程工作之CompletableFuture.runAsync案例
热门推荐
u011556070的博客
01-26 3万+
在实际的工作中，我们会需要执行一些无返回的多线程任务以改善系统的运行效率。 接受kafka消息并对这些消息进行处理是一个典型案例，如果这里使用多线程的处理方式可以大大提高系统的处理性能。 以下就对CompletableFuture.runAsync的使用方式做一个案例展示 先定义一个处理的任务，这里可能是一个Runnable也可能是一个Callable，区别就是在于有无返回值 import lombok.extern.slf4j.Slf4j; /** * @author yhgu * @date 20
JAVA多线程(二十四)Java多线程之CompletableFuture类
yuan_xw的专栏
02-06 923
1.JAVA多线程(二十四)Java多线程之CompletableFuture类 1.1 什么是Future   Future是Java 5添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel方法停止任务的执行。 package com.yuanxw.chapter24; import ja...
多线程02-CompletableFuture深入
Strong_shady的博客
09-03 1514
CompletableFuture可以做future做的事 CompletableFuture优点： 1.异步任务结束时，自动回调某个对象的方法； 2.异步任务出错时，自动回调某个对象的方法； 3.主线程设置好回调后，不再关心异步任务的执行，异步任务之间可以顺序执行。 多线程异步调用/异步编排(减少阻塞及轮询)： public static void main(String[] args) throws ExecutionException, InterruptedException { T
java多线程CompletableFuture用法
weixin_43888912的博客
06-23 579
CompletableFuture
多线程之CompletableFuture（中）
Kincym的博客
11-07 1233
thenAcceptAsyncConsumer 接收上个阶段的返回值T,return Void;返回CompletableFuture<Void> thenAccept 该方法是同步的 public static void main(String[] args) { CompletableFuture<Void> stringCompletableFuture = Completa
CompletableFuture的执行线程
weixin_34232363的博客
02-24 143
为什么80%的码农都做不了架构师？>>> ...
一文秒懂 Java CompletableFuture
华章IT官方博客
06-12 373
在Java 8中，新增了许多非常有趣的功能，比如Labmda表达式、流式API（Stream API）等。这些语法糖或API让Java这门“古老”的编程语言也开始具备“现代”的气息。但是...
CompletableFuture与多线程结合使用
果酱 の 博客
05-29 6400
在Java 8中，引入了CompletableFuture类，它是Future的增强版，提供了更加灵活的异步编程方式，能够更好地利用多线程的优势。本文将详细讲解CompletableFuture的使用方法，并结合多线程实现异步编程。CompletableFuture是Java 8中新增的一个类，它实现了Future和CompletionStage接口，提供了一种更加灵活的异步编程方式。
CompletableFuture用法详解——多线程系列
超人2028的博客
11-20 4736
常见的两种创建线程的方式。继承Thread或者实现Runnable接口，但是这两种方法都存在一个缺陷，那就是没有返回值。虽然简单场景下已经满足，但是当我们需要返回值的时候怎么办呢？ Java 1.5 以后的Callable和Future接口就解决了这个问题， public static CompletableFuture<Void> runAsync(Runnable runnable) public static CompletableFuture<Void> runAsync(R
多线程的利器：CompletableFuture 你还可以这样使用多线程
qq_39664892的博客
12-13 5692
Completable 多线程使用
线程异步编排串行（CompletableFuture）
伍妖捌的小屋
06-27 409
美图 创建异步对象 CompletableFuture提供了四个静态方法来创建一个异步操作 无返回值 不需要指定线程池，使用默认线程池 CompletableFuture<Void> runAsync(Runnable runnable); 需要指定线程池，使用指定线程池 CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) 有返回 不需要指定线程池，使用默认线程池 Comple
response:java.util.concurrent.completablefuture@5785e813[not completed]
12-02
对于未完成的CompletableFuture对象，我们可以使用`CompletableFuture.get()`方法来阻塞当前线程，直到计算完成并返回结果。我们也可以使用`CompletableFuture.join()`方法来获取计算结果，但不会抛出受检异常。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值