JDK8函数编程及JDK9中响应式流

最新推荐文章于 2024-03-02 21:00:46 发布
最新推荐文章于 2024-03-02 21:00:46 发布
阅读量741 收藏 2
点赞数 1
分类专栏： spring5 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenbj123/article/details/120639042
版权

一、前言

Spring5是基于Reactor框架实现响应式流，其中Spring Boot WebFlux是完全依赖reactor-core来实现；直接上手Spring WebFlux，虽然能简单使用，但对其原理未做深入了解，难免会有不少迷惑，故建议从基础出发，按照如下步骤进行学习：
1、掌握JDK8的函数式编程及stream流；

2、学习JDK9的flux的响应式流设计原理及实现机制

3、上手spring Boot webflux（JDK8函数式编程及stream流 + JDK9响应式流 的结合）

二、JDK8中的函数式编程及stream流

jdk8中最大的特点之一就是支持函数式编程及stream流，下面就其中重点做下基本的简介和示例：

（一）lamda表达式

Lambda 表达式，也可称为闭包，本质上来说其允许把函数作为一个方法的参数。

public class LambdaDemo1 {
    public static void main(String[] args) {
    	// 非lambda表达式代码示例
        Runnable thread1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("普通线程");
            }
        };
        new Thread(target).start();

        // jdk8 lambda表达式代码示例
        //返回一个接口，可以使用强转的方式（不过我觉得应该没人这么用）
        Runnable thread2 = (Runnable)() -> System.out.println("ok");
        new Thread(thread2).start();
    }
}

通过上面示例，可看出lambda表单式的很大的一个特点就是把复杂的代码逻辑，变得更为简洁和紧凑。

另外，lambda表达式还有其他的如下写法：

interface InterfaceDemo1 {
    int doubleNum(int i);
    int addNum(int i1, int i2);
}

public class LambdaDemo1 {
    public static void main(String[] args) {
    	// 函数逻辑多行时，需要加大括号
        InterfaceDemo1 i1 = (int i) -> {
            System.out.println("----------");
            return i * 2;
        };
        
    	// 函数逻辑仅为一行时，可省去大括号和return
        InterfaceDemo1 i2 = (int i) -> i * 2;
        
        // 参数可省去类型
        InterfaceDemo1 i3 = (i) -> i * 2;
        
    	// 单个参数时，可以省去括号
    	InterfaceDemo1 i4 = i -> i * 2;
    	
        // 多个参数时，需要加括号
        InterfaceDemo1 i5 = (i1, i2) -> i1 + i2;
    }
}

（二）函数式接口

函数式接口：只有一个方法的interface接口，一般通过添加注解 @FunctionalInterface来标注（不添加注解也可以，但建议加上注解以供编译时检验，加上注解后如果有多个方法会报错）

默认接口： interface接口中使用default关键字标注的实现方法；该方法可以不被实现，也可以被重写，和类中的方法一样，可以在方法使用this调用接口中的方法。

@FunctionalInterface
interface InterfaceDemo2 {
	// jdk8之后建议接口设计尽量的小，一个接口只做一件事，也就是更加便于函数式接口的使用
    int doubleNum(int i);
    // 默认方法
    default int add(int x, int y) {
        return x + y;
    }
}

public class LambdaDemo2 {
    public static void main(String[] args) {
        InterfaceDemo2 i1 = i -> i * 2;
        // 调用接口默认方法
        System.out.println(i1.add(3, 7));
        System.out.println(i1.doubleNum(20));
    }
}

（三）内置函数接口

1、四大核心函数式接口

函数式接口参数类型返回类型方法说明
ConsumerTvoidvoid accept(T t)无返回值，对指定T类型参数进行处理
Supplier无TT get()无入参，通过处理返回指定T类型对象
Function<T,R>TRR apply(T)对指定T类型参数进行处理，通过处理返回指定R类型对象
PredicateTbooleanboolean test(T)对指定T类型参数进行处理，判断是否满足某种条件
public class FunctionDemo1 {
    public static void main(String[] args) {
     	// Consumer<T>
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("1");
        
        // Supplier<T>
        Supplier<String> supplier = () -> "2";
        System.out.println(supplier.get());
        
        // Function<T,R>
        Function<Integer, Integer> function = i -> i * 2;
        System.out.println(function.apply(3));
        
        // Predicate<T>
        Predicate<Integer> predicate = i -> i > 0;
        System.out.println(predicate.test(-4));
    }
}
2、 其他演变函数式接口
函数式接口参数类型返回类型方法说明
BiFunction<T,U,R>T,URR apply(T t, U u)对指定T类型和U类型参数进行处理，通过处理返回指定R类型对象
UnaryOperatorTTT apply(T t)对指定T类型参数进行处理，通过处理返回相同T类型对象，
其是Function<T,R>子接口
BinaryOperatorT,TTT apply(T t, T t)对两个指定的T类型参数进行处理，通过处理返回相同T类型对象，
其是BiFunction<T,U,R>子接口
BiConsumer<T,U>T,Uvoidvoid accept(T t,U u)无返回值，对指定T类型和U类型参数进行处理

（四）stream流

Stream流是一个来自数据源的元素队列并支持聚合操作，其有如下三个要素：

  1. 元素：特定类型的对象，基于该类型对象形成一个队列，且Stream流并不存储元素，而是仅按需进行操作；
  2. 数据源： Stream流的数据来源，可以是集合，数组，I/O channel， 产生器generator 等；
  3. 聚合操作：对元素做的简便操作，比如filter, map, reduce, find, match, sorted等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

  1. Pipelining：Stream流并不存储元素，而是仅按需进行操作，且中间操作都会返回流对象本身；基于此多个操作可串联起来，形成一个类似管道一样的操作序列；
  2. 内部迭代： Stream流通过访问者模式(Visitor)实现了内部迭代 。

1、 流的创建

来源方法
集合Collection.stream/parallelStream
数组Arrays.stream
数字StreamIntStream/LongStream.range/rangeClosed
Random.ins/longs/doubles
直接创建Stream.generate/interate
public class StreamDemo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // 集合创建
        list.stream();
        list.parallelStream();

        // 数组创建
        Arrays.stream(new int[]{1, 2, 3});

        // 数字Stream创建
        IntStream.of(1, 2, 3);
        IntStream.rangeClosed(1, 5);

        // 创建一个无限流
        new Random().ints().limit(5);

        // 创建
        Random rd= new Random();
        Stream.generate(rd::nextInt).limit(20);
    }
}

2、流的中间操作

操作分类相关方法
无状态
（有数据存储功能，线程不安全）		map/mapToXxx
flatMap/flatMapToXxx
filter
peek
unordered
有状态
（一次操作，不能保存数据，线程安全）		distinct
sorted
limit/skip

3、流的终止操作

操作分类相关方法
非短路操作
（有数据存储功能，线程不安全）		forEach/forEachOrdered
collect/toArray
reduce
min/max/count
短路操作
（不需要等待所有结果都计算完就可以结束流的操作）		findFirst/findAny
allMatch/anyMatch/noneMatch
public class StreamDemo2 {
    public static void main(String[] args) {
        String str = "Hello world";
        // 迭代器forEach
        // 使用并行流，乱序（效率更高）
        str.chars().parallel().forEach(i -> System.out.print((char)i));
        System.out.println("+++++++++++++++++++");
        // 使用 forEachOrdered保证顺序
        str.chars().parallel().forEachOrdered(i -> System.out.print((char)i));
        System.out.println("+++++++++++++++++++");

        // 收集器collect
        // 收集到集合
        List<String> list = Stream.of(str.split(" ")).collect(Collectors.toList());
        System.out.println(list);
        // 收集到Set
        Set<String> set = Stream.of(str.split(" ")).collect(Collectors.toSet());
        System.out.println(set);

        // 归约reduce，将流中的元素结合起来得到一个值
        // 拼接字符串
        Optional<String> letters = Stream.of(str.split(" ")).reduce((s1, s2) -> s1 + "，" + s2);
        // 使用optional进行空判断
        System.out.println(letters.orElse(null));

        // 带初始化值的reduce，默认值也会被算入元素中
        String reduce = Stream.of(str.split(" ")).reduce("java语言：", (s1, s2) -> s1 + "，" + s2);
        System.out.println(reduce);

        // 计算所有单词总长度
        Integer length = Stream.of(str.split(" ")).map(String::length).reduce(0, (s1, s2) -> s1 + s2);
        System.out.println(length);

        // max的使用，找出最长的单词
        Optional<String> maxLengthWorld = Stream.of(str.split(" ")).max(Comparator.comparingInt(String::length));
        System.out.println(maxLengthWorld.orElse(null));
        // min的使用，找出最短的单词
        Optional<String> minLengthWorld = Stream.of(str.split(" ")).min(Comparator.comparingInt(String::length));
        System.out.println(minLengthWorld.orElse(null));
        // count的使用，统计有多少个单词
        long count = Stream.of(str.split(" ")).count();
        System.out.println(count);

        // 使用 allMatch判断是否所有单词长度都大于1，返回boolean
        // anyMatch和noneMatch用法差不多，都是返回boolean
        boolean all = Stream.of(str.split(" ")).anyMatch(s -> s.length() > 1);
        System.out.println(all);

        // 使用 findFirst 短路操作
        OptionalInt findFirst = new Random().ints().findFirst();
        System.out.println(findFirst.orElse(0));
        // 使用 findAny 短路操作
        OptionalInt findAny = new Random().ints().findAny();
        System.out.println(findAny.orElse(0));
    }
}

三、JDK9中的响应式流

JDK9中的响应式流与JDK8中的函数式编程及stream流其实没有什么关系，其是依据Reactive Streams—响应式流规范而实现的，本质是一个发布-订阅模式的实现，其中核心类为java.util.concurrent.Flow，其中定义了Publisher、Subscriber、Subscription、Proccessor等核心响应式编程接口。

（一）简单demo

相关依赖：

JDK：1.9 以上
maven依赖：lombok
1、定义消费者Subscriber对象
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Flow;

// 实现java.util.concurrent.Flow.Subscriber
@Slf4j
public class BizSubscriber implements Flow.Subscriber<Integer> {

    private Flow.Subscription subscription;

    @Override
    public void onSubscribe(Flow.Subscription subscription) {
    	// 绑定Subscription
        this.subscription = subscription;
        // 通过Subscription向Publisher请求数据
        this.subscription.request(1);
    }

    @Override
    public void onNext(Integer item) {
        log.info("subscriber 接收数据：" + item);
        // TODO 
        // do some biz things ……
        
        // 处理完成后，重新通过Subscription向Publisher请求数据
        this.subscription.request(1);
    }

    @Override
    public void onError(Throwable throwable) {
        log.error("subscriber 处理错误", throwable);
        // 处理发生异常时的错误处理
        // TODO
    	// do some things when error
        
        this.subscription.cancel();
    }

    @Override
    public void onComplete() {
    	log.info("subscriber 完成数据处理！！");
    	// 处理完成后的业务逻辑处理
    	// TODO
    	// do some things when complete
    }
}
2、demo代码
import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;

public class FlowTest {
    public static void main(String[] args) throws Exception {
		// 1、定义发布者实例，这里直接使用jdk自带的SubmissionPublisher（实现了Publisher接口），同时定义发布的数据类型式Integer
        SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();
        
        // 2、定义消费者实例
        Flow.Subscriber subscriber = new BizSubscriber();
        
        // 3、建立发布-订阅消费绑定关系
        publisher.subscribe(subscriber);

		// 4、发布者开始发布数据
        publisher.submit(1);
        publisher.submit(2);
        publisher.submit(3);
        publisher.submit(4);

		// 5、发布者发布完成后关闭
        publisher.close();

		// 这里为了演示需要，设置主线程延迟停止（否则发布者发布的数据还没有消费完，就可能会退出）
        Thread.currentThread().join(1000);
    }
}

最后执行接口如下：

16:10:15.589 [ForkJoinPool.commonPool-worker-3] INFO com.abinge.boot.staging.flow.BizSubscriber - subscriber 接收数据：1
16:10:15.593 [ForkJoinPool.commonPool-worker-3] INFO com.abinge.boot.staging.flow.BizSubscriber - subscriber 接收数据：2
16:10:15.593 [ForkJoinPool.commonPool-worker-3] INFO com.abinge.boot.staging.flow.BizSubscriber - subscriber 接收数据：3
16:10:15.593 [ForkJoinPool.commonPool-worker-3] INFO com.abinge.boot.staging.flow.BizSubscriber - subscriber 接收数据：4
16:10:15.593 [ForkJoinPool.commonPool-worker-3] INFO com.abinge.boot.staging.flow.BizSubscriber - subscriber 完成数据处理！！

（二）源码解析

1、时序图示

下面我们结合上面的例子，深入到JDK的源码中查看整个链路的执行过程，我这里大致梳理了整体执行时序如下图所示：

jdk9____________

通过上面图示我们可以总结出如下内容：

1、整个响应式流的逻辑核心处理逻辑是在Subscription中的；

2、Subscription的初始化工作是由Publisher来控制的，具体是在与subscriber创建绑定关系时做的；

3、Publisher真正提交数据时，也就是submit数据时，Subsciber才会真正的通过request方法请求到数据，并真实的消费处理数据。

2、关键步骤源码跟踪
（1）发布者定义
// 1、定义发布者实例，这里直接使用jdk自带的SubmissionPublisher（实现了Publisher接口），同时定义发布的数据类型式Integer
SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();

// 这里做了两件事情：
// 1、设置Publisher异步执行线程池executor=ASYNC_POOL，最终默认线程池是ForkJoinPool.commonPool()
// 2、设置最大的缓存空间（也就是背压容量）为Flow.defaultBufferSize()，默认为256

// java.util.concurrent.SubmissionPublisher#SubmissionPublisher()
public SubmissionPublisher() {
    this(ASYNC_POOL, Flow.defaultBufferSize(), null);
}

// 最终执行的SubmissionPublisher的构造方法
// java.util.concurrent.SubmissionPublisher#SubmissionPublisher(java.util.concurrent.Executor, int, java.util.function.BiConsumer<? super java.util.concurrent.Flow.Subscriber<? super T>,? super java.lang.Throwable>)
public SubmissionPublisher(Executor executor, int maxBufferCapacity,
                               BiConsumer<? super Subscriber<? super T>, ? super Throwable> handler) {
        if (executor == null)
            throw new NullPointerException();
        if (maxBufferCapacity <= 0)
            throw new IllegalArgumentException("capacity must be positive");
        this.executor = executor;
        this.onNextHandler = handler;
        this.maxBufferCapacity = roundCapacity(maxBufferCapacity);
}

// ASYNC_POOL的初始逻辑
private static final Executor ASYNC_POOL =
        (ForkJoinPool.getCommonPoolParallelism() > 1) ?
        ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();
（2）发布者与消费者绑定订阅关系
// 3、建立发布-订阅消费绑定关系
publisher.subscribe(subscriber);

// java.util.concurrent.SubmissionPublisher#subscribe
public void subscribe(Subscriber<? super T> subscriber) {
        if (subscriber == null) throw new NullPointerException();
        // 1、初始化背压容器，设置背压容器的最大容量
        int max = maxBufferCapacity; // allocate initial array
        Object[] array = new Object[max < INITIAL_CAPACITY ?
                                    max : INITIAL_CAPACITY];
        
        // 2、初始化绑定关系Subscription实例，也就是BufferedSubscription实例         
        BufferedSubscription<T> subscription =
            new BufferedSubscription<T>(subscriber, executor, onNextHandler,
                                        array, max);
                                        
        // 3、同步操作，这里就标明Publisher的subscribe方法是阻塞执行                      
        synchronized (this) {
            if (!subscribed) {
                subscribed = true;
                owner = Thread.currentThread();
            }
            // 4、这里是死循环会一直尝试执行，直到发生错误或执行完成
            for (BufferedSubscription<T> b = clients, pred = null;;) {
                if (b == null) {
                	// 5、首次进来，b = clients 为null，开始执行8、subscription.onSubscribe()方法
                    Throwable ex;
                    subscription.onSubscribe();
                    if ((ex = closedException) != null)
                        subscription.onError(ex);
                    else if (closed)
                        subscription.onComplete();
                    else if (pred == null)
                        clients = subscription;
                    else
                        pred.next = subscription;
                    break;
                }
                BufferedSubscription<T> next = b.next;
                if (b.isClosed()) {   // remove
                    b.next = null;    // detach
                    if (pred == null)
                        clients = next;
                    else
                        pred.next = next;
                }
                else if (subscriber.equals(b.subscriber)) {
                	// 6、发生错误后，停止死循环
                    b.onError(new IllegalStateException("Duplicate subscribe"));
                    break;
                }
                else
                    pred = b;
                    
                // 7、执行下一个存在绑定关系（也就是下一个消费者实例）
                b = next;
            }
        }
    }
    
// 8、java.util.concurrent.SubmissionPublisher.BufferedSubscription#onSubscribe
final void onSubscribe() {
    startOnSignal(RUN | ACTIVE);
}

// 9、java.util.concurrent.SubmissionPublisher.BufferedSubscription#startOnSignal
final void startOnSignal(int bits) {
      if ((ctl & bits) != bits &&
          (getAndBitwiseOrCtl(bits) & (RUN | CLOSED)) == 0)
          tryStart();
}

// 10、java.util.concurrent.SubmissionPublisher.BufferedSubscription#tryStart
// 这里开始异步执行具体的任务
final void tryStart() {
      try {
          Executor e;
          // ConsumerTask的初始化逻辑详见下面11
          // 这里的this就是上面2、中创建的BufferedSubscription实例 
          ConsumerTask<T> task = new ConsumerTask<T>(this);
          if ((e = executor) != null)   // skip if disabled on error
              e.execute(task);
       } catch (RuntimeException | Error ex) {
          getAndBitwiseOrCtl(ERROR | CLOSED);
           throw ex;
       }
}

// 11、java.util.concurrent.SubmissionPublisher.ConsumerTask
// 这里是ConsumerTask的初始化方法，其中consumer就是上面10中的this，也就是2、中创建的BufferedSubscription实例
// 通过该类的run方法，我们可以看到其最终执行的是BufferedSubscription实例的consume方法
static final class ConsumerTask<T> extends ForkJoinTask<Void>
        implements Runnable, CompletableFuture.AsynchronousCompletionTask {
        final BufferedSubscription<T> consumer;
        ConsumerTask(BufferedSubscription<T> consumer) {
            this.consumer = consumer;
        }
        public final Void getRawResult() { return null; }
        public final void setRawResult(Void v) {}
        public final boolean exec() { consumer.consume(); return false; }
        public final void run() { consumer.consume(); }
}

// 12、java.util.concurrent.SubmissionPublisher.BufferedSubscription#consume
// 这里是整个响应式流背压执行的核心逻辑，其中head、tail等都是对array背压容量的相关位置记录
final void consume() {
			// 13、注意这里的s，此处设值为subscriber，也就是2、中初始化时我们创建绑定关系的那个消费者BizSubscriber实例
            Subscriber<? super T> s;
            if ((s = subscriber) != null) {          // hoist checks
            	// 14、这里开始传入消费者实例，确定与消费者之间的绑定关系，并会执行subscriber的onSubscribe方法
                subscribeOnOpen(s);
                long d = demand;
                
                // 15、这里又是一个死循环，不断是对背压容器array的遍历操作执行
                for (int h = head, t = tail;;) {
                    int c, taken; boolean empty;
                    if (((c = ctl) & ERROR) != 0) {
                        closeOnError(s, null);
                        break;
                    }
                    // 15-1、首次进来，会执行takeItems方法，其中把subscriber消费者实例传递了进去，具体详见15-2
                    // 在Publisher尚未submit提交数据时，taker永远是0，不会真实的执行subscriber中的逻辑
                    else if ((taken = takeItems(s, d, h)) > 0) {
                        head = h += taken;
                        d = subtractDemand(taken);
                    }
                    else if ((d = demand) == 0L && (c & REQS) != 0)
                        weakCasCtl(c, c & ~REQS);    // exhausted demand
                    else if (d != 0L && (c & REQS) == 0)
                        weakCasCtl(c, c | REQS);     // new demand
                    else if (t == (t = tail)) {      // stability check
                        if ((empty = (t == h)) && (c & COMPLETE) != 0) {
                            closeOnComplete(s);      // end of stream
                            break;
                        }
                        else if (empty || d == 0L) {
                            int bit = ((c & ACTIVE) != 0) ? ACTIVE : RUN;
                            if (weakCasCtl(c, c & ~bit) && bit == RUN)
                                break;               // un-keep-alive or exit
                        }
                    }
                }
            }
        }
        
// 14-1、java.util.concurrent.SubmissionPublisher.BufferedSubscription#subscribeOnOpen
// 此处的入参s就是2、中初始化时创建绑定关系的那个消费者BizSubscriber实例
final void subscribeOnOpen(Subscriber<? super T> s) {
    if ((ctl & OPEN) == 0 && (getAndBitwiseOrCtl(OPEN) & OPEN) == 0)
        consumeSubscribe(s);
}

// 14-2、java.util.concurrent.SubmissionPublisher.BufferedSubscription#consumeSubscribe
// 此处的入参s就是2、中初始化时创建绑定关系的那个消费者BizSubscriber实例
final void consumeSubscribe(Subscriber<? super T> s) {
    try {
        if (s != null) // ignore if disabled
        	// 此处开始执行subscriber的onSubscribe方法
            s.onSubscribe(this);
    } catch (Throwable ex) {
        closeOnError(s, ex);
    }
}

// 14-3、com.abinge.boot.staging.flow.BizSubscriber#onSubscribe
public void onSubscribe(Flow.Subscription subscription) {
    // 绑定Subscription
    this.subscription = subscription;
    // 通过Subscription向Publisher请求数据
    this.subscription.request(1);
}

// 14-4、java.util.concurrent.SubmissionPublisher.BufferedSubscription#request
public final void request(long n) {
    if (n > 0L) {
        for (;;) {
            long p = demand, d = p + n;  // saturate
            if (casDemand(p, d < p ? Long.MAX_VALUE : d))
                break;
        }
        // 最终仍会执行到最初的startOnSignal方法
        startOnSignal(RUN | ACTIVE | REQS);
    }
    else
        onError(new IllegalArgumentException(
                    "non-positive subscription request"));
}


// 15-2、java.util.concurrent.SubmissionPublisher.BufferedSubscription#takeItems
// 这里的入参s就是2、中初始化时创建绑定关系的那个消费者BizSubscriber实例
final int takeItems(Subscriber<? super T> s, long d, int h) {
    Object[] a;
    int k = 0, cap;
    // 在Publisher尚未submit提交数据时，k永远是0，不会继续执行到15-4中去真实的执行subscriber中的逻辑
    if ((a = array) != null && (cap = a.length) > 0) {
        int m = cap - 1, b = (m >>> 3) + 1; // min(1, cap/8)
        int n = (d < (long)b) ? (int)d : b;
        // 15-3、这里又是一个死循环，仍然是对背压容器array的相关操作
        for (; k < n; ++h, ++k) {
            Object x = QA.getAndSet(a, h & m, null);
            if (waiting != 0)
                signalWaiter();
            if (x == null)
                break;
            //  15-4、首次执行，会进入到consumeNext方法， 其中s就是2、中初始化时创建绑定关系的那个消费者BizSubscriber实例
            else if (!consumeNext(s, x))
                break;
        }
    }
    return k;
}

// 15-5、java.util.concurrent.SubmissionPublisher.BufferedSubscription#consumeNext
// 这里s就是2、中初始化时创建绑定关系的那个消费者BizSubscriber实例
final boolean consumeNext(Subscriber<? super T> s, Object x) {
    try {
        @SuppressWarnings("unchecked") T y = (T) x;
        if (s != null)
        // 15-6、此处会去真正的执行BizSubscriber实例的onNext方法
            s.onNext(y);
        return true;
    } catch (Throwable ex) {
        handleOnNext(s, ex);
        return false;
    }
}

// 15-6、com.abinge.boot.staging.flow.BizSubscriber#onNext
// 这里就会去执行我们自定义的BizSubscriber实例的onNext方法，其中可包含具体的业务逻辑，执行完成后再次向Publisher请求数据
public void onNext(Integer item) {
    log.info("subscriber 接收数据：" + item);
    // TODO 
    // do some biz things ……
    
    // 处理完成后，重新通过Subscription向Publisher请求数据，具体可参见14-4
    this.subscription.request(1);
}
（3）Publisher真实的提交数据
// 4、发布者开始发布数据
publisher.submit(1);
publisher.submit(2);
publisher.submit(3);
publisher.submit(4);

此处源码跟踪可自行查询，其大致逻辑是把item放入背压容器array中，然后执行10、java.util.concurrent.SubmissionPublisher.BufferedSubscription#tryStart方法，真实的启动subscriber的相应业务逻辑。

abinge89
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
响应式编程基础 --- 发布订阅模式、JDK9: Flow
化身强盗的博客
04-27 970
一、发布订阅模式 1.1 基本概念 反应式编程离不开发布-订阅模式 发布订阅模式有基本的三个概念： 订阅者可以订阅发布者 名为订阅的连接 消息(也叫事件)，它们通过连接传输 1.2 示例：对两个流求和 发布订阅 的一个简单例子就是整合两个信息源的事件并发布给其他用户使用 例如想象成电子表格：C3 = C1+C2这样一个公式，只要C1或者C2更新，C3也会更新这些变化 1、先对保存值的单元格进行建模： private static class SimpleCell { private int v
JDK8+Tomcat9
08-03
1. Lambda表达式：这是一种简洁的匿名函数语法，允许程序员以更简洁的方式处理函数式编程，极大地提高了代码的可读性和简洁性。 2. 方法引用和构造器引用：与Lambda表达式相配合，可以直接引用类的方法或构造器，...
【JDK8】响应式编程
the_fool_的博客
10-14 1058
响应式编程简称RP（Reactive Programming） 响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。 eg: public static void main(String[] args) { Map map = new HashMap(4); ...
浅谈JDK 9—Flow
Java部落格
02-18 1430
一、响应式编程 JDK 9 Flow 是JDK对Reactive Stream (响应式流/反应流) 的实现，Reactive Stream是一套基于发布/订阅模式的数据处理规范。响应式流从2013年开始，作为提供非阻塞背压的异步流处理标准的倡议。 它旨在解决处理元素流的问题——如何将元素流从发布者传递到订阅者，而不需要发布者阻塞，或订阅者需要有无限制的缓冲区或丢弃。更确切地说，Reactive流目的是“找到最小的一组接口，方法和协议，用来描述必要的操作和实体以实现这样的目标：以非阻塞背压方式实现数据的异步
Java Flux contains_Reactor：响应式开发库，支持构建基于JVM的非阻塞式应用程序
weixin_28273593的博客
03-04 175
Reactor Core Non-Blocking Reactive Streams Foundation for the JVM both implementing a Reactive Extensions inspired API and efficient event streaming support.The master branch is now dedicated t...
响应式编程学习指南
八荒六合唯我独尊
11-13 472
1. 响应式编程入门 JDK历史版本对响应式编程的支持。jdk8中，已经出现了一些响应式编程的影子（CompletableFuture&Stream）。jdk9通过java.util.concurrent.Flow包，提供了对于 Reactive 的完整支持。Reactive响应式流入门这篇文章基于jdk9给出了一个"hello world"级别的例子，给初学者一个初式的印象。 2. 进一步了解响应式编程 spring5及spring boot2开启了对响应式编程的支持，这两个版本基于jdk8
JDK帮助文档（jdk6,8,9,10,11）
11-29
- **Lambda表达式**：这是JDK 8最重要的特性，引入了函数式编程的概念，简化了多线程编程和处理集合。 - **默认方法**：在接口中添加了默认方法，允许接口提供非抽象方法的实现。 - **日期时间API（java.time）**...
jdk api 1.8 chm 中文文档.zip
07-02
**JDK 1.8 API 中文文档**是Java开发者不可或缺的重要参考资料，它详细记录了Java Development Kit（JDK）1.8版本中的各种类、接口、方法和异常等核心组件。这个文档以CHM（Microsoft Compiled HTML Help）格式提供...
jdk-8u301-windows.zip
12-23
1. **Lambda表达式**：这是JDK 8最重要的特性之一，引入了一种新的语法结构，允许开发者以更简洁的方式编写函数式编程风格的代码。Lambda表达式可以被用作方法参数，或者用在函数式接口的实例化中，极大提高了代码的...
jdk-8u401-windows-x64.zip
最新发布
04-15
1. **Lambda表达式**：这是JDK 8最重要的特性之一，它引入了函数式编程的概念，使得代码更加简洁、可读性强。Lambda表达式允许将匿名函数作为方法参数传递，或者用作方法的返回值。 2. **方法引用和构造器引用**：...
Java 9 响应式流（Reactive Streams）
xharvard的专栏
02-20 669
首先出现响应式编程理念，然后出现响应式编程实现，再然后出现响应式规范，响应流主要解决处理元素流的问题—如何将元素流从发布者传递到订阅者，不而不需要发布者阻塞，或者要求订阅者有无限的缓冲区，有限的缓冲区在到达缓冲上界的时候，对到达的元素进行丢弃或者拒绝，订阅者可以异步通知发布者降低或提升数据生产发布的速率，它是响应式编程实现效果的核心特点。
从实际出发记一次优化⭐《G1、JDK17、Flux性能调优》⭐
qq_35040959的博客
11-07 933
本文从实际项目出发记录一次项目性能调优，很多时候都是无效优化，但学习过程十分有意义
flux在java中的使用项目代码示例
tqs_123456的博客
03-02 705
在Java中，Flux是一个来自Project Reactor库的概念，它是响应式编程模型的一部分，用于处理异步和非阻塞数据流。请注意，这个示例展示了如何在Java中使用Flux进行基本的响应式编程，而不是在React或Flux架构中使用Flux。在Java的响应式编程中，Flux用于处理0到N个元素的异步序列，而Mono则用于处理0到1个元素的异步序列。在Java中，使用Project Reactor的Flux，你可以创建响应式流来处理数据。如果你使用Maven，可以在。来验证Flux的行为。
【基础】Reactor 响应式编程
情绪瓜皮皮丶的学习之路
01-18 2689
整理总结了响应式编程框架 Reactor 的基础概念和常用 API
JAVA Reactor API ( Flux和Mono)的简单使用
热门推荐
weixin_47951400的博客
04-21 1万+
1. 创建Flux及Mono 1.1 使用just从现有的已知内容和大小的数据创建Flux或Mono Flux.just(new Integer[]{1, 2, 3, 4}) //观察者监听被观察者(消费者) .subscribe(System.out::println); //使用可变参数创建Flux Flux.just(1, 2, 3, 4) .subscribe(System.out::println); //使用just创建Mono Mono.just("1s") .subscribe(
HTTP及HTTP缓存框架HttpResponseCache
yzpbright的博客
06-06 581
请求报文格式 1）请求行，第一行是请求行：请求方法 URL路径 HTTP版本号 ， 如：GET http://news.baidu.com/ HTTP/1.1 2）请求头，如： Host: news.baidu.com Connection: keep-alive Accept: text/html Accept-Encoding: gzip, deflate, sdch Accept-Language: zh-CN 3）请求体，get方法不适用，post方法提交数据时，用于存放请求的参数 响应报文
精讲响应式WebClient第2篇-GET请求阻塞与非阻塞调用方法详解
字母哥博客
08-21 3031
本文是精讲响应式WebClient第2篇，前篇的blog访问地址如下： 精讲响应式webclient第1篇-响应式非阻塞IO与基础用法 在上一篇文章为大家介绍了响应式IO模型和WebClient的基本用法。本节来继续深入的为大家介绍：如何使用WebClient作为Http客户端发送GET请求与进行响应结果的接收。 一、block()阻塞式获取响应结果 WebClient客户端既支持同步异步、阻塞与非阻塞IO，我们先来为大家介绍一下同步阻塞式的编程方式。即：在请求发送之后使用block()方法，阻塞当前线
注解方式实现接口限流
weixin_38400347的博客
03-21 359
需求：使用自定义注解，实现加注解后，对该接口实现限流功能 思路 自定义一个注解，注解中添加两个属性，分别是时间和次数，表示在此时间内，最多允许访问的次数 新增一个切面，切点为自定义注解，切面方法使用环绕通知，执行正常方法前判断，是否满足限流条件，如果满足，则直接返回已限流错误信息，如果不限流，则正常执行方法后返回。 限流条件设计： 使用一个map，用于存储接口 其他 ...
03-Mono & Flux操作
Tong_Rui的博客
04-03 3877
上一节主要介绍了如何基于Mono和Flux构建一个数据流，Mono是Flux的特例，但大部分API 都是一致的所以重点讲的是Flux。本章将讲Flux和Mono的操作符，如 转换、过滤、异常处理、日志、Debug等一些API。 1. buffer buffer方法相当于将序列中的一部分数据收集到一个集合中，并作为一个新的流元素发送到下游。 这里看buffer的重载方法特别多啊，基本功能肯定是一样的只是多了一些附加条件。我们加单示例几种。 示例1： 指定收集的元素个数 public static void
使用jdk8自带的包构建一个响应式编程的例子
04-25
好的，我能够帮你回答这个问题。你可以使用 JDK 8 自带的流(Stream)和 CompletableFuture 类来构建一个简单的响应式编程的例子。 首先，让我们来看一个使用流(Stream)的例子。流是一个数据元素的序列，在处理时可以以函数式编程的方式对其进行操作。比如下面的例子演示了如何对一个数组中的所有元素求和： ```java int[] numbers = { 1, 2, 3, 4, 5 }; int sum = Arrays.stream(numbers).sum(); System.out.println(sum); ``` 这段代码使用 `Arrays.stream()` 方法将一个 `int` 数组转化为一个流，然后使用 `sum()` 方法进行求和操作。 接下来，让我们看看如何使用 CompletableFuture 类来构建一个异步响应式编程的例子。CompletableFuture 类是一个基于 Future 接口的异步编程模型，可以使用它来构建异步函数式编程的应用。下面的例子演示了如何使用 CompletableFuture 类来实现一个简单异步的乘法操作： ```java CompletableFuture<Integer> futureResult = CompletableFuture.supplyAsync(() -> { int a = 2, b = 3; return a * b; }); futureResult.thenAccept(result -> System.out.println(result)); ``` 这段代码使用 `supplyAsync()` 方法来创建一个异步任务，在任务中执行乘法操作，并返回结果。然后使用 `thenAccept()` 方法对任务结果进行处理，并打印到控制台上。 希望这个例子能够对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值