/* * Copyright (c) 2016-present, RxJava Contributors. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See * the License for the specific language governing permissions and limitations under the License. */ package io.reactivex.rxjava3.internal.jdk8; import java.util.Objects; import java.util.concurrent.atomic.*; import java.util.function.*; import java.util.stream.Collector; import org.reactivestreams.*; import io.reactivex.rxjava3.core.*; import io.reactivex.rxjava3.exceptions.Exceptions; import io.reactivex.rxjava3.internal.subscriptions.*; import io.reactivex.rxjava3.internal.util.AtomicThrowable; import io.reactivex.rxjava3.parallel.ParallelFlowable; import io.reactivex.rxjava3.plugins.RxJavaPlugins; /** * Reduces all 'rails' into a single via a Java 8 {@link Collector} callback set. * * @param the value type * @param the accumulator type * @param the result type * @since 3.0.0 */ public final class ParallelCollector extends Flowable { final ParallelFlowable source; final Collector collector; public ParallelCollector(ParallelFlowable source, Collector collector) { this.source = source; this.collector = collector; } @Override protected void subscribeActual(Subscriber s) { ParallelCollectorSubscriber parent; try { parent = new ParallelCollectorSubscriber<>(s, source.parallelism(), collector); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); EmptySubscription.error(ex, s); return; } s.onSubscribe(parent); source.subscribe(parent.subscribers); } static final class ParallelCollectorSubscriber extends DeferredScalarSubscription { private static final long serialVersionUID = -5370107872170712765L; final ParallelCollectorInnerSubscriber[] subscribers; final AtomicReference> current = new AtomicReference<>(); final AtomicInteger remaining = new AtomicInteger(); final AtomicThrowable error = new AtomicThrowable(); final Function finisher; ParallelCollectorSubscriber(Subscriber subscriber, int n, Collector collector) { super(subscriber); this.finisher = collector.finisher(); @SuppressWarnings("unchecked") ParallelCollectorInnerSubscriber[] a = new ParallelCollectorInnerSubscriber[n]; for (int i = 0; i < n; i++) { a[i] = new ParallelCollectorInnerSubscriber<>(this, collector.supplier().get(), collector.accumulator(), collector.combiner()); } this.subscribers = a; remaining.lazySet(n); } SlotPair addValue(A value) { for (;;) { SlotPair curr = current.get(); if (curr == null) { curr = new SlotPair<>(); if (!current.compareAndSet(null, curr)) { continue; } } int c = curr.tryAcquireSlot(); if (c < 0) { current.compareAndSet(curr, null); continue; } if (c == 0) { curr.first = value; } else { curr.second = value; } if (curr.releaseSlot()) { current.compareAndSet(curr, null); return curr; } return null; } } @Override public void cancel() { for (ParallelCollectorInnerSubscriber inner : subscribers) { inner.cancel(); } } void innerError(Throwable ex) { if (error.compareAndSet(null, ex)) { cancel(); downstream.onError(ex); } else { if (ex != error.get()) { RxJavaPlugins.onError(ex); } } } void innerComplete(A value, BinaryOperator combiner) { for (;;) { SlotPair sp = addValue(value); if (sp != null) { try { value = combiner.apply(sp.first, sp.second); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); innerError(ex); return; } } else { break; } } if (remaining.decrementAndGet() == 0) { SlotPair sp = current.get(); current.lazySet(null); R result; try { result = Objects.requireNonNull(finisher.apply(sp.first), "The finisher returned a null value"); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); innerError(ex); return; } complete(result); } } } static final class ParallelCollectorInnerSubscriber extends AtomicReference implements FlowableSubscriber { private static final long serialVersionUID = -7954444275102466525L; final ParallelCollectorSubscriber parent; final BiConsumer accumulator; final BinaryOperator combiner; A container; boolean done; ParallelCollectorInnerSubscriber(ParallelCollectorSubscriber parent, A container, BiConsumer accumulator, BinaryOperator combiner) { this.parent = parent; this.accumulator = accumulator; this.combiner = combiner; this.container = container; } @Override public void onSubscribe(Subscription s) { SubscriptionHelper.setOnce(this, s, Long.MAX_VALUE); } @Override public void onNext(T t) { if (!done) { try { accumulator.accept(container, t); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); get().cancel(); onError(ex); } } } @Override public void onError(Throwable t) { if (done) { RxJavaPlugins.onError(t); return; } container = null; done = true; parent.innerError(t); } @Override public void onComplete() { if (!done) { A v = container; container = null; done = true; parent.innerComplete(v, combiner); } } void cancel() { SubscriptionHelper.cancel(this); } } static final class SlotPair extends AtomicInteger { private static final long serialVersionUID = 473971317683868662L; T first; T second; final AtomicInteger releaseIndex = new AtomicInteger(); int tryAcquireSlot() { for (;;) { int acquired = get(); if (acquired >= 2) { return -1; } if (compareAndSet(acquired, acquired + 1)) { return acquired; } } } boolean releaseSlot() { return releaseIndex.incrementAndGet() == 2; } } }