java同步器

最新推荐文章于 2024-05-06 21:08:10 发布
最新推荐文章于 2024-05-06 21:08:10 发布
阅读量165 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xixingzhe2/article/details/134423968
版权

1、概述

        JUC提供了一些工具类，实现了一些常见的线程间同步模式，常用同步器如下

  • CountDownLatch : 计数递减门闩，用于控制一个线程等待其他线程都到达指定位置时才开始工作。
  • CyclicBarrier : 循环栅栏，用于控制多个线程在一些指定的位置同步，可以指定多个位置。
  • Phaser : 动态阶段同步器，相当于增强的CyclicBarrier和CountDownLatch。
  • Semaphore : 信号量，用于控制线程同步。
  • Exchanger : 交换器，用于两个线程交换数据。
  • CompletableFuture : 多任务异步处理工具。

2、Semaphore 同步器

经典的信号量，通过计数器控制对共享资源的访问。

方法

  • Semaphore(int count): 创建拥有 count 个许可证的信号量
  • acquire()/acquire(int num) :  获取 1/num 个许可证
  • release/release(int num) :  释放 1/num 个许可证

代码demo

package com.ybw.jdk8.demo.synchronizer;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Semaphore;

/**
 * 同步器-信号量
 *
 * @author weixiansheng
 * @version V1.0
 * @className SemaphoreDemo
 * @date 2023/11/15
 **/
@Slf4j
public class SemaphoreDemo {

    /**
     * 这段代码演示了如何使用java.util.concurrent.Semaphore来控制同时访问某个资源的线程数量。
     * 在这个例子中，Semaphore对象被初始化为具有2个许可证的数量。每个线程在执行任务之前都会获取许可证，
     * 然后释放许可证以便其他线程可以获取。当所有许可证都被占用时，尝试获取许可证的线程将会被阻塞，直到有其他线程释放许可证。
     * 这个例子中，两个线程每次运行1秒，因此每次只有一个线程运行，总共运行10秒。
     *
     * @param args
     * @methodName: main
     * @return: void
     * @author: weixiansheng
     * @date: 2023/11/15
     **/
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(2);

        Thread t1 = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    semaphore.acquire();
                    log.info("Thread 1: Running");
                    Thread.sleep(1000);
                    semaphore.release();
                }
            } catch (InterruptedException e) {
                log.error("Thread 1: Interrupted");
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    semaphore.acquire();
                    log.info("Thread 2: Running");
                    Thread.sleep(1000);
                    semaphore.release();
                }
            } catch (InterruptedException e) {
                log.error("Thread 2: Interrupted");
            }
        });

        t1.start();
        t2.start();
    }
}

        这段代码演示了如何使用java.util.concurrent.Semaphore来控制同时访问某个资源的线程数量。在这个例子中，Semaphore对象被初始化为具有2个许可证的数量。每个线程在执行任务之前都会获取许可证，然后释放许可证以便其他线程可以获取。当所有许可证都被占用时，尝试获取许可证的线程将会被阻塞，直到有其他线程释放许可证。这个例子中，两个线程每次运行1秒，因此每次只有一个线程运行，总共运行10秒。

打印日志如下

[INFO ] 2023-11-15 16:53:54.887 [Thread-1] c.y.j.d.synchronizer.SemaphoreDemo - Thread 2: Running
[INFO ] 2023-11-15 16:53:54.887 [Thread-0] c.y.j.d.synchronizer.SemaphoreDemo - Thread 1: Running
[INFO ] 2023-11-15 16:53:55.923 [Thread-0] c.y.j.d.synchronizer.SemaphoreDemo - Thread 1: Running
[INFO ] 2023-11-15 16:53:55.923 [Thread-1] c.y.j.d.synchronizer.SemaphoreDemo - Thread 2: Running
[INFO ] 2023-11-15 16:53:56.933 [Thread-0] c.y.j.d.synchronizer.SemaphoreDemo - Thread 1: Running
[INFO ] 2023-11-15 16:53:56.933 [Thread-1] c.y.j.d.synchronizer.SemaphoreDemo - Thread 2: Running
[INFO ] 2023-11-15 16:53:57.943 [Thread-0] c.y.j.d.synchronizer.SemaphoreDemo - Thread 1: Running
[INFO ] 2023-11-15 16:53:57.943 [Thread-1] c.y.j.d.synchronizer.SemaphoreDemo - Thread 2: Running
[INFO ] 2023-11-15 16:53:58.957 [Thread-1] c.y.j.d.synchronizer.SemaphoreDemo - Thread 2: Running
[INFO ] 2023-11-15 16:53:58.957 [Thread-0] c.y.j.d.synchronizer.SemaphoreDemo - Thread 1: Running

3、CountDownLatch 同步器

特征：
必须发生指定数量的事件后才可以继续运行 ( 比如赛跑比赛，裁判喊出 3,2,1 之后大家才同时跑 )

方法：

  • CountDownLatch(int count): 必须发生 count 个数量才可以打开锁存器
  • await: 等待锁存器，
    • 如果想让某个线程处于等待中，该线程调用countdownLatch.await()。
    • 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。
  • countDown: 触发事件
    • 通过其他线程调用countdownLatch.countDown()减少计数器，直到减少到0，被await()挂起的线程恢复执行。

代码demo

package com.ybw.jdk8.demo.synchronizer;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;

/**
 * CountDownLatch 同步器
 *
 * @author weixiansheng
 * @version V1.0
 * @className CountDownLatchDemo
 * @date 2023/11/15
 **/
@Slf4j
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(10);

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                log.info("Thread " + Thread.currentThread().getId() + " is running.");
                log.info("Thread " + Thread.currentThread().getId() + " is finished.");
                //递减锁存器的计数
                latch.countDown();
            }).start();
        }

        log.info("All threads have started.");
        // 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。
        latch.await();
        log.info("All threads have ended.");
    }
}

日志如下

[INFO ] 2023-11-15 17:11:52.589 [main] c.y.j.d.s.CountDownLatchDemo - All threads have started.
[INFO ] 2023-11-15 17:11:52.589 [Thread-2] c.y.j.d.s.CountDownLatchDemo - Thread 24 is running.
[INFO ] 2023-11-15 17:11:52.589 [Thread-3] c.y.j.d.s.CountDownLatchDemo - Thread 25 is running.
[INFO ] 2023-11-15 17:11:52.589 [Thread-5] c.y.j.d.s.CountDownLatchDemo - Thread 27 is running.
[INFO ] 2023-11-15 17:11:52.589 [Thread-8] c.y.j.d.s.CountDownLatchDemo - Thread 30 is running.
[INFO ] 2023-11-15 17:11:52.589 [Thread-1] c.y.j.d.s.CountDownLatchDemo - Thread 23 is running.
[INFO ] 2023-11-15 17:11:52.589 [Thread-7] c.y.j.d.s.CountDownLatchDemo - Thread 29 is running.
[INFO ] 2023-11-15 17:11:52.589 [Thread-0] c.y.j.d.s.CountDownLatchDemo - Thread 22 is running.
[INFO ] 2023-11-15 17:11:52.589 [Thread-4] c.y.j.d.s.CountDownLatchDemo - Thread 26 is running.
[INFO ] 2023-11-15 17:11:52.589 [Thread-6] c.y.j.d.s.CountDownLatchDemo - Thread 28 is running.
[INFO ] 2023-11-15 17:11:52.589 [Thread-9] c.y.j.d.s.CountDownLatchDemo - Thread 31 is running.
[INFO ] 2023-11-15 17:11:52.593 [Thread-3] c.y.j.d.s.CountDownLatchDemo - Thread 25 is finished.
[INFO ] 2023-11-15 17:11:52.593 [Thread-7] c.y.j.d.s.CountDownLatchDemo - Thread 29 is finished.
[INFO ] 2023-11-15 17:11:52.593 [Thread-2] c.y.j.d.s.CountDownLatchDemo - Thread 24 is finished.
[INFO ] 2023-11-15 17:11:52.593 [Thread-0] c.y.j.d.s.CountDownLatchDemo - Thread 22 is finished.
[INFO ] 2023-11-15 17:11:52.593 [Thread-1] c.y.j.d.s.CountDownLatchDemo - Thread 23 is finished.
[INFO ] 2023-11-15 17:11:52.593 [Thread-8] c.y.j.d.s.CountDownLatchDemo - Thread 30 is finished.
[INFO ] 2023-11-15 17:11:52.593 [Thread-6] c.y.j.d.s.CountDownLatchDemo - Thread 28 is finished.
[INFO ] 2023-11-15 17:11:52.593 [Thread-5] c.y.j.d.s.CountDownLatchDemo - Thread 27 is finished.
[INFO ] 2023-11-15 17:11:52.593 [Thread-4] c.y.j.d.s.CountDownLatchDemo - Thread 26 is finished.
[INFO ] 2023-11-15 17:11:52.593 [Thread-9] c.y.j.d.s.CountDownLatchDemo - Thread 31 is finished.
[INFO ] 2023-11-15 17:11:52.593 [main] c.y.j.d.s.CountDownLatchDemo - All threads have ended.

4、CyclicBarrier同步器

       翻译为“可循环利用的屏障”。它是一个同步的工具， 能够允许一组线程去互相等待直到都到达了屏障，CyclicBarrier对于涉及到固定大小的线程是非常有用的，线程们必须相互等待。该屏障称之为循环屏障，是因为当等待屏障的线程被释放之后，该屏障能循环使用。

特征：

适用于只有多个线程都到达预定点时才可以继续执行 ( 比如斗地主，需要等齐三个人才开始 )。

方法：

  • CyclicBarrier(int num) : 等待线程的数量
  • CyclicBarrier(int num, Runnable action) : 等待线程的数量以及所有线程到达后的操作
  • await() :  到达临界点后暂停线程

适用场景：

        有若干个线程，比如说有N个线程，需要它们都到达了某一个点之后才能开始一起执行，也就是说假如其中只有N-1个线程到达了这个点，还差一个线程没到达，此时这N-1个线程都会进入等待状态，直到第N个线程也到达了这个点之后，这N个线程才开始一起进行执行状态，这个场景跟CountDownLatch很类似。

代码demo

package com.ybw.jdk8.demo.synchronizer;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

/**
 * CyclicBarrier 同步器
 *
 * @author weixiansheng
 * @version V1.0
 * @className CyclicBarrierDemo
 * @date 2023/11/15
 **/
@Slf4j
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // 创建一个线程池
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(20);
        int corePoolSize = 20;
        int maximumPoolSize = 30;
        long keepAliveTime = 60L;
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

        // 创建一个屏障
        // parties：屏障解除之前必须调用await方法的线程数
        // barrierAction：屏障解除时执行的动作
        CyclicBarrier cyclicBarrier = new CyclicBarrier(10, () -> {
            log.info(Thread.currentThread().getName() + "已经到达检查点");
        });


        for (int i = 0; i < 10; i++) {
            threadPoolExecutor.submit(() -> {
                try {
                    log.info(Thread.currentThread().getName() + "已经到达屏障");
                    cyclicBarrier.await();
                    log.info(Thread.currentThread().getName() + "已经冲破屏障");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        threadPoolExecutor.shutdown();

    }
}

日志如下

[INFO ] 2023-11-16 19:05:15.852 [pool-1-thread-5] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-5已经到达屏障
[INFO ] 2023-11-16 19:05:15.853 [pool-1-thread-4] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-4已经到达屏障
[INFO ] 2023-11-16 19:05:15.852 [pool-1-thread-7] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-7已经到达屏障
[INFO ] 2023-11-16 19:05:15.852 [pool-1-thread-10] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-10已经到达屏障
[INFO ] 2023-11-16 19:05:15.852 [pool-1-thread-3] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-3已经到达屏障
[INFO ] 2023-11-16 19:05:15.852 [pool-1-thread-9] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-9已经到达屏障
[INFO ] 2023-11-16 19:05:15.853 [pool-1-thread-1] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-1已经到达屏障
[INFO ] 2023-11-16 19:05:15.852 [pool-1-thread-6] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-6已经到达屏障
[INFO ] 2023-11-16 19:05:15.853 [pool-1-thread-2] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-2已经到达屏障
[INFO ] 2023-11-16 19:05:15.852 [pool-1-thread-8] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-8已经到达屏障
[INFO ] 2023-11-16 19:05:15.860 [pool-1-thread-2] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-2已经到达检查点
[INFO ] 2023-11-16 19:05:15.860 [pool-1-thread-2] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-2已经冲破屏障
[INFO ] 2023-11-16 19:05:15.860 [pool-1-thread-9] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-9已经冲破屏障
[INFO ] 2023-11-16 19:05:15.860 [pool-1-thread-5] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-5已经冲破屏障
[INFO ] 2023-11-16 19:05:15.860 [pool-1-thread-10] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-10已经冲破屏障
[INFO ] 2023-11-16 19:05:15.860 [pool-1-thread-4] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-4已经冲破屏障
[INFO ] 2023-11-16 19:05:15.860 [pool-1-thread-7] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-7已经冲破屏障
[INFO ] 2023-11-16 19:05:15.861 [pool-1-thread-6] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-6已经冲破屏障
[INFO ] 2023-11-16 19:05:15.861 [pool-1-thread-1] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-1已经冲破屏障
[INFO ] 2023-11-16 19:05:15.861 [pool-1-thread-3] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-3已经冲破屏障
[INFO ] 2023-11-16 19:05:15.861 [pool-1-thread-8] c.y.j.d.s.CyclicBarrierDemo - pool-1-thread-8已经冲破屏障

5、CompletableFuture

         简单的任务，用Future获取结果还好，但我们并行提交的多个异步任务，往往并不是独立的，很多时候业务逻辑处理存在串行[依赖]、并行、聚合的关系。如果要我们手动用 Fueture 实现，是非常麻烦的。

        CompletableFuture是Future接口的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富地扩展，完美地弥补了Future上述的种种问题。

        更为重要的是，CompletableFuture实现了对任务的编排能力。借助这项能力，我们可以轻松地组织不同任务的运行顺序、规则以及方式。从某种程度上说，这项能力是它的核心能力。而在以往，虽然通过CountDownLatch等工具类也可以实现任务的编排，但需要复杂的逻辑处理，不仅耗费精力且难以维护。

  • CompletionStage接口: 执行某一个阶段，可向下执行后续阶段。异步执行，默认线程池是ForkJoinPool.comcommonPool()。

方法思维导图

方法总结

  • 描述依赖关系
    • thenApply() 把前面异步任务的结果，交给后面的Function
    • thenCompose()用来连接两个有依赖关系的任务，结果由第二个任务返回
  • 描述and聚合关系
    • thenCombine 任务合并，有返回值
    • thenAccepetBoth 两个任务执行完成后，将结果交给thenAccepetBoth消耗，无返回值
    • runAfterBoth 两个任务都执行完成后，执行下一步操作（Runnable）
  • 描述or聚合关系
    • applyToEither 两个任务谁执行的快，就使用那一个结果，有返回值
    • acceptEither 两个任务谁执行的快，就消耗那一个结果，无返回值
    • runAfterEither 任意一个任务执行完成，进行下一步操作(Runnable)
  • 并行执行
    • CompletableFuture类自己也提供了anyOf()和allOf()用于支持多个CompletableFuture并行执行。

静态方法

// 无返回值
public static CompletableFuture<Void> runAsync(Runnable runnable)
// 无返回值 可以自定义线程池
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
// 有返回值
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
// 有返回值 可以自定义线程池
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)
  • supply开头：这种方法，可以返回异步线程执行之后的结果。
  • run开头：这种不会返回结果，就只是执行线程任务。

        如果你想异步运行一些后台任务并且不想从任务中返回任何东西，那么你可以使用run开头的。

示例代码

package com.ybw.jdk8.demo.synchronizer;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * @author weixiansheng
 * @version V1.0
 * @className CompletableFutureDemo
 * @date 2023/11/16
 **/
@Slf4j
public class CompletableFutureDemo {
    public static void main(String[] args) throws InterruptedException {
        //1、执行无返回结果的异步任务
        CompletableFuture.runAsync(() -> log.info("执行无返回结果的异步任务"));
        //2、执行有返回值的异步任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            log.info("执行有返回值的异步任务");
            return "hello";
        });
        //3、获取异步任务的执行结果
        // t和u，代表任务的执行结果和异常
        future.whenComplete((t, u) -> {
            // 任务执行完成后,执行回调
            log.info("异步任务执行完成:{}", t);
        });
        TimeUnit.DAYS.sleep(1);
    }
}

打印日志如下

[INFO ] 2023-11-16 19:44:57.515 [ForkJoinPool.commonPool-worker-9] c.y.j.d.s.CompletableFutureDemo - 执行无返回结果的异步任务
[INFO ] 2023-11-16 19:44:57.515 [ForkJoinPool.commonPool-worker-2] c.y.j.d.s.CompletableFutureDemo - 执行有返回值的异步任务
[INFO ] 2023-11-16 19:44:57.520 [ForkJoinPool.commonPool-worker-2] c.y.j.d.s.CompletableFutureDemo - 异步任务执行完成:hello

thenApply()方法

        拿到上一个异步线程返回的结构进行后续处理。

示例代码

package com.ybw.jdk8.demo.synchronizer;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @author weixiansheng
 * @version V1.0
 * @className CompletableFutureDemo
 * @date 2023/11/16
 **/
@Slf4j
public class CompletableFutureDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                log.info("业务开始");
                // 模拟业务时长
                TimeUnit.SECONDS.sleep(1);
                log.info("业务结束");
            } catch (InterruptedException e) {
                throw new IllegalStateException(e);
            }
            return "商品信息";
        });

        CompletableFuture<String> resultFuture = future.thenApply(name -> "订单信息 " + name);
        log.info(resultFuture.get());


        TimeUnit.DAYS.sleep(1);
    }
}

打印日志

[INFO ] 2023-11-16 19:52:31.168 [ForkJoinPool.commonPool-worker-9] c.y.j.d.s.CompletableFutureDemo - 业务开始
[INFO ] 2023-11-16 19:52:32.183 [ForkJoinPool.commonPool-worker-9] c.y.j.d.s.CompletableFutureDemo - 业务结束
[INFO ] 2023-11-16 19:52:32.184 [main] c.y.j.d.s.CompletableFutureDemo - 订单信息 商品信息

thenAccept() 和 thenRun()方法

        如果你不想从你的回调函数中返回任何东西，只想在 Future 完成后运行一些代码，那么可以使用thenAccept()andthenRun()方法。这些方法是消费者Consumer<? super T> action，通常用作回调链中的最后一个回调。

  • thenAccept()可以拿到上一次的结果，然后执行。
  • thenRun()无法拿到上一次的结果，thenRun()意为然后执行什么，里面接收一个Runnable参数。
  • thenAccept、thenRun都是主线程执行的任务，顺序执行。

示例代码

package com.ybw.jdk8.demo.synchronizer;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @author weixiansheng
 * @version V1.0
 * @className CompletableFutureDemo
 * @date 2023/11/16
 **/
@Slf4j
public class CompletableFutureDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "商品信息");
        future.thenAccept(product  -> log.info("我拿到了 " + product));
        future.thenRun(()->{
            log.info("我执行完成了");
        });
        log.info("main");

        TimeUnit.DAYS.sleep(1);
    }
}

打印日志

[INFO ] 2023-11-16 20:01:28.468 [main] c.y.j.d.s.CompletableFutureDemo - 我拿到了 商品信息
[INFO ] 2023-11-16 20:01:28.471 [main] c.y.j.d.s.CompletableFutureDemo - 我执行完成了
[INFO ] 2023-11-16 20:01:28.471 [main] c.y.j.d.s.CompletableFutureDemo - main

complete()

        注意complete()其实也是个消费操作，但是与thenRun()不同的是，里面可以可抛出的异常

// 区别就是不是异步处理
public CompletableFuture<T>  whenComplete(BiConsumer<? super T,? super Throwable> action)
// 使用异步处理
public CompletableFuture<T>  whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)
// 区别在于可以指定线程池
public CompletableFuture<T>  whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)
// 接收一个可抛出的异常，且必须有返回值
public CompletableFuture<T>  exceptionally(Function<Throwable,? extends T> fn)

示例代码

package com.ybw.jdk8.demo.synchronizer;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @author weixiansheng
 * @version V1.0
 * @className CompletableFutureDemo
 * @date 2023/11/16
 **/
@Slf4j
public class CompletableFutureDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 异步执行
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            int a = 10 / 0;
            log.info("执行结束！");
            return "hello";
        });
        // 完成时执行
        future.whenComplete((t, action) -> log.info(t + " 执行完成！"));

        // 异常时执行
        future.exceptionally(t -> {
            log.info("执行失败：" + t.getMessage());
            return "异常";
        }).join();

        TimeUnit.DAYS.sleep(1);
    }
}

日志打印

[INFO ] 2023-11-16 20:15:24.009 [main] c.y.j.d.s.CompletableFutureDemo - null 执行完成！
[INFO ] 2023-11-16 20:15:24.012 [main] c.y.j.d.s.CompletableFutureDemo - 执行失败：java.lang.ArithmeticException: / by zero

handle()

public <U> CompletableFuture<U> handle(BiFunction<? super T,Throwable,? extends U> fn)
public <U> CompletableFuture<U> handleAsync(BiFunction<? super T,Throwable,? extends U> fn)
public <U> CompletableFuture<U> handleAsync(BiFunction<? super T,Throwable,? extends U> fn, Executor executor)

        handle方法集和上面的complete方法集没有区别，同样有两个参数一个返回结果和可抛出异常，区别就在于返回值。

CompletableFuture 组合

示例代码

package com.ybw.jdk8.demo.synchronizer;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @author weixiansheng
 * @version V1.0
 * @className CompletableFutureDemo
 * @date 2023/11/16
 **/
@Slf4j
public class CompletableFutureDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        String result = CompletableFuture.supplyAsync(() -> "商品信息")
                .thenApply(product -> product + " 用户信息").join();
        log.info(result);

        TimeUnit.DAYS.sleep(1);
    }
}

日志打印

[INFO ] 2023-11-16 20:21:46.542 [main] c.y.j.d.s.CompletableFutureDemo - 商品信息 用户信息

多个 CompletableFuture 组合在一起

        假设有3个接口 获取用户信息，获取商品信息，获取会员信息,先每个接口1s,那个3个接口总耗时3s。按顺序执行此操作，但这将花费大量时间，所以异步线程会大大减少耗时，增加程序的性能。

CompletableFuture.allOf()

        CompletableFuture.allOf()里面包含了多个CompletableFuture操作，接收一个CompletableFuture类型的可变参数。

package com.ybw.jdk8.demo.synchronizer;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @author weixiansheng
 * @version V1.0
 * @className CompletableFutureDemo
 * @date 2023/11/16
 **/
@Slf4j
public class CompletableFutureDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        log.info("任务开始");
        // 异步执行1
        CompletableFuture<String> future1 = CompletableFuture
                .supplyAsync(() -> {
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    log.info("future1完成！");
                    return "future1完成！";
                });
        // 异步执行2
        CompletableFuture<String> future2 = CompletableFuture
                .supplyAsync(() -> {
                    log.info("future2完成！");
                    return "future2完成！";
                });
        // 等待两个任务都完成
        CompletableFuture<Void> combindFuture = CompletableFuture
                .allOf(future1, future2);
        try {
            // 等待所有任务都完成
            combindFuture.get();
        } catch (Exception e) {
            log.error("异常", e);
        }
        log.info("任务结束");

        TimeUnit.DAYS.sleep(1);
    }
}

日志打印

[INFO ] 2023-11-17 09:49:58.601 [main] c.y.j.d.s.CompletableFutureDemo - 任务开始
[INFO ] 2023-11-17 09:49:58.639 [ForkJoinPool.commonPool-worker-2] c.y.j.d.s.CompletableFutureDemo - future2完成！
[INFO ] 2023-11-17 09:50:00.644 [ForkJoinPool.commonPool-worker-9] c.y.j.d.s.CompletableFutureDemo - future1完成！
[INFO ] 2023-11-17 09:50:00.644 [main] c.y.j.d.s.CompletableFutureDemo - 任务结束

xixingzhe2
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java高级：条件队列与同步器Synchronizer的原理+AQS的应用
qq3164069700的博客
12-24 695
14.构建自定义的同步工具 类库中包含了许多存在状态依赖性的类，例如 FutureTask ， Semaphore和 BlockingQueue等。在这些类中的一些操作中有着基于状态的前提条件，例如，不能从一个空的队列中删除元素，或者获取一个尚未结束的任务的计算结果，在这些操作可以执行之前，必须等到队列进入 “非空 ”状态，或者任务进入 “已完成 ”状态。 创建状态依赖类的最简单方法通常是在类库中现有的状态依赖类的基础上进行构造。本章将介绍实现状态依赖性的各种选择，以及在使用平台提供的状态依赖性机制时需
java 同步器SynchronousQueue详解及实例
08-30
Java 同步器 SynchronousQueue 详解及实例 Java 中的同步器 SynchronousQueue 是一种特殊的阻塞队列，它最多只能放一个元素，这个元素如果不在特定的时间消费掉就会被删除，队列的长度始终为 0。SynchronousQueue ...
Java 并发包锁实现的精髓----队列同步器（AbstractQueuedSynchronizer）
知识共享，你我皆是知识的搬运工
08-15 290
队列同步器理解
java并发编程之同步器
lklinkang的专栏
11-20 7026
从java5开始juc包为我们提供了很多方便使用的同步器类：    CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作前需要一个或多个其他的线程处于阻塞状态时我们可以使用它，如田径比赛中，将每一名运动员看做一个工作线程，成绩记录员看做另一线程，显然成绩记录员开始记录员开始记录成绩前需要所有的运动员都先做好比赛准备并且同时开始起跑，我们需要就最后参赛者所的成绩得出一个
2024年Java高级：条件队列与同步器Synchronizer的原理+AQS的应用(1)，华为java面试一共几轮
最新发布
2401_84557986的博客
05-06 718
这份文档从构建一个键值数据库的关键架构入手，不仅带你建立起全局观，还帮你迅速抓住核心主线。除此之外，还会具体讲解数据结构、线程模型、网络框架、持久化、主从同步和切片集群等，帮你搞懂底层原理。相信这对于所有层次的Redis使用者都是一份非常完美的教程了。你的支持，我的动力；祝各位前程似锦，offer不断！！！本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取。
java三个线程同步器的用法与源码解析
qq_43100957的博客
02-24 242
三种同步器的功能 本文主要介绍三个线程同步器，它们的功能分别是： CountDownLatch：确保所有子线程执行完成以后再执行汇总， 内部有一个计数器，一个子线程执行完就倒数一下，倒数完后返回； CyclicBarrier：让一组线程全部达到一个状态以后再全部同时执行， 当所有线程执行完毕以后，重置CyclicBarrier的状态之后还可以被重用； Semaphore：大家都很熟悉的信号量，内...
（JUC 下典型的类）Java 并发包中线程同步器
weixin_46448719的博客
04-22 852
文章介绍了并发包中关于线程协作的一些重要类。首先 CountDownLatch 通过计数器提供了更灵活的控制，只要检测到计数器值为 0，就可以往下执行，这相比于 join 必须等待线程执行完毕后主线程才会继续向下运行更灵活。另外，CyclicBarrier 也可以达到 CountDownLatch 的效果，但是后者在计数器值变为 0 后，就不能再被复用，而前者则可以使用 reset 方法重置后复用，前者对同一个算法但是输入参数不同的类似场景比较使用。而 Semaphore 采用了信号量递增的策略，一开始并不
Java多线程同步器代码详解
08-28
Java多线程同步器在并发编程中扮演着至关重要的角色，它们帮助开发者管理线程间的协作，确保资源的正确访问和程序的顺序执行。本文将深入解析四种主要的同步器：CountDownLatch、Semaphore、Barrier和Exchanger，并...
Java同步框架AbstractQueuedSynchronizer详解
08-29
Java同步框架AbstractQueuedSynchronizer详解 AbstractQueuedSynchronizer（AQS）是Java中的一个同步框架类，它实现了最核心的多线程同步的语义。AQS提供了一个基础的同步器实现，开发者可以通过继承AQS来实现自己...
java同步大杀器concurrent 包
11-05
java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大杀器concurrent 包java同步大...
Java同步函数代码详解
08-29
Java同步函数是为了保证多线程环境下的数据一致性与安全性，主要通过`synchronized`关键字来实现。本篇文章将深入解析Java中的同步函数及其相关代码示例。 同步函数，也称为同步方法，是Java中用于控制多线程并发...
JAVA并发基础: 同步器的使用
菲购程小序的专栏
09-18 1326
文章目录 前言 一、什么是同步器？ 二、同步器的使用 1.信号量 2.倒计时门栓 总结 前言 Semaphore、CountDownLatch、CyclicBarrier、Exchanger、Phaser 信号量、倒计时门栓、循环屏障、交换器、移相器 一、什么是同步器？ 线程之间相互合作时，需要用到同步器来完成同步，java.util.concurrent包提供了几个能帮助我们管理相互合作的线程集的类。这些机制具有为线程之间的公用集结点提供“预置功能”，这句话通俗理...
java并发编程之同步器，Android开发新手入门教程
m0_61067876的博客
03-21 688
外链图片转存中…(img-llmatU1l-1710970011094)][外链图片转存中…(img-gzLa2GeU-1710970011095)]
Java并发包下的锁(2)——队列同步器
皮皮的雅客
11-06 558
本文主要介绍队列同步器AbstractQueuedSynchronizer(AQS)，简称同步器，它是用来构建锁或者其他同步组件的基础框架，它使用一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。 文章目录同步器简介1. 什么是同步器？2. 同步器的API展示3. 自定义同步组件同步器的实现1. 同步队列2. 独占式同步状态获取与释放3. 独占式超时获取同步...
Java中的锁——队列同步器
惟愿无事
12-20 8140
队列同步器AbstractQueuedSynchronizer(AQS)，似乎我们不经常用，但是它是用来构建锁或者其他同步组件的基础框架，它使用了一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。下图显示了java.concurrent包的实现示意图 同步器的主要使用方式是继承，一般作为同步器组件的静态内部类，在同步器中仅定义了与状态相关的方法，且这个状
java同步器作用_java同步器__学习笔记
weixin_33343681的博客
02-28 157
参照：http://ifeve.com/introduce-abstractqueuedsynchronizer/前言：在java.util.concurrent.locks包中有很多Lock的实现类，常用的有ReentrantLock、ReadWriteLock(实现类ReentrantReadWriteLock)，内部实现都依赖AbstractQueuedSynchronizer类public...
JAVA并发——线程同步器AQS
海晨忆的博客
07-19 309
个人博客：haichenyi.com。感谢关注 前言   每一项技术的提出都是为了解决某一个问题，带着问题来理解技术，使得印象你对这个技术的理解印象更加深刻。 并发   举个栗子：现在有一个需求，网络请求分两批（A,B两个批次），A批次并行请求，B批次串行请求按顺序一个一个请求，有一个总超时时间，B批次每一次请求都有一个超时时间，A批次并发请求先请求，在规定时间内没有返回，再开始请求B批次，谁先返回用谁的。   这个是我们项目里面简化过后的一个逻辑，实际逻辑，比这个还要复杂。怎么实现这个功能呢？   带着这
head first java中文电子版_Java 中队列同步器 AQS（AbstractQueuedSynchronizer）实现原理
weixin_39934869的博客
11-29 164
前言在 Java 中通过 锁 来控制多个线程对共享资源的访问，使用 Java 编程语言开发的朋友都知道，可以通过 synchronized 关键字来实现锁的功能，它可以隐式的获取锁，也就是说我们使用该关键字并不需要去关心锁的获取和释放过程，但是在提供方便的同时也意味着其灵活性的下降。例如，有这样的一个场景，先获取锁 A，然后再获取锁 B，当锁 B 获取到之后，释放锁 A 同时获取锁 C，当获取锁 ...
Java并发---同步器
l1394049664的博客
07-26 728
同步器     信号量（Semaphore）     倒计时门栓（CountDownLatch）     障栅 （CyclicBarrier）     交换器 (Exchanger)     同步队列(SynchronousQueue)     CountDownLatch和CyclicBarrier区别...
java中的并发变成学习笔记2
05-27
其中，AQSAQS（AbstractQueueSynchronizer）作为同步器，在多线程编程中扮演着重要的角色。它底层使用双向列表来实现队列，同时也包括了同步列表和条件队列的概念。在线程池中，AQS设计体现了其灵活性和强大的功能，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值