Introduction

Using boolean isUnsubscribed in the state

    static final class State {
        final Subscription s1;
        final Subscription s2;
        final boolean isUnsubscribed;
        public State(Subscription s1, 
                Subscription s2, 
                boolean isUnsubscribed) {
            this.s1 = s1;
            this.s2 = s2;
            this.isUnsubscribed = isUnsubscribed;

        }
    }
    // ...

public final class TwoSubscribersLockFree1 
implements Subscription {
    static final class State { 
        // ...
    }

    static final State EMPTY = 
        new State(null, null, false);                  // (1)

    static final State UNSUBSCRIBED = 
        new State(null, null, true);                   // (2)

    final AtomicReference<State> state = 
        new AtomicReference<>(EMPTY);                  // (3)

    public void set(boolean first, Subscription s) {
        // implement
    }

    @Override
    public void unsubscribe() {
        // implement
    }

    @Override
    public boolean isUnsubscribed() {
        // implement
    }
}

    public void set(boolean first, Subscription s) {
        for (;;) {
            State current = state.get();                    // (1)
            if (current.isUnsubscribed) {                   // (2)
                s.unsubscribe();
                return;
            }
            State next;
            Subscription old;
            if (first) {
                next = new State(s, current.s2, false);     // (3)
                old = current.s1;                           // (4)
            } else {
                next = new State(current.s1, s, false);
                old = current.s2;
            }
            if (state.compareAndSet(current, next)) {       // (5)
                if (old != null) {
                    old.unsubscribe();                      // (6)
                }
                return;
            }
        }
    }

1. The current state value is read.
2. If the current state is unsubscribed, the terminal state of this container is was reached, we unsubscribe the parameter and quit.
3. Otherwise, we'll create a new state based on the old one, replace the appropriate subscription with the provided one.
4. Since the subscription needs to be unsubscribed on replacement, we save its instance locally.
5. The CAS operation will atomically swap in the new, updated state or we perform a new iteration in case a concurrent modification happened to the state.
6. With a successful CAS, the original subscription (if any) is unsubscribed and the loop is quit.

    // ...
    @Override
    public boolean isUnsubscribed() {
        return state.get().isUnsubscribed;
    }
    // ...

    @Override
    public void unsubscribe() {
        State current = state.get();                        // (1)
        if (!current.isUnsubscribed) {                      // (2)
            current = state.getAndSet(UNSUBSCRIBED);        // (3)
            if (!current.isUnsubscribed) {                  // (4)
                List<Throwable> errors = null;              // (5)

                errors = unsubscribe(current.s1, errors);   // (6)
                errors = unsubscribe(current.s2, errors);

                Exceptions.throwIfAny(errors);              // (7)
            }
        }
    }

    private List<Throwable> unsubscribe(Subscription s,     // (8)
            List<Throwable> errors) {
        if (s != null) {
            try {
                s.unsubscribe();
            } catch (Throwable e) {
                if (errors == null) {
                    errors = new ArrayList<>();
                }
                errors.add(e);
            }
        }
        return errors;
    }
}

1. We retrieve the current state.
2. If the current state is already unsubscribed, there is nothing to do and the method quits.
3. Otherwise, we atomically exchange the current state with the constant terminal state.
4. If the previous state was unsubscribed, the method can quit, otherwise, since the getAndSet is atomic there will be exactly one caller who transitions from a non-terminated state into the terminated state. There is no need for a CAS loop here and the unsubscription, so far, can be wait-free on platforms with intrinsified getAndSet.
5. The possible exceptions are collected into an errors list.
6. I've factored out the unsubscription and error collection into a method and it is called for each of the contained subscriptions.
7. If any of the unsubscriptions threw, the exception(s) are rethrown.
8. The convenience method of unsubscribing a subscription and updating the errors list if necessary.

Using the UNSUBSCRIBED state reference

public final class TwoSubscribersLockFree2 implements Subscription {
    static final class State {
        final Subscription s1;
        final Subscription s2;
        public State(Subscription s1, 
                Subscription s2) {
            this.s1 = s1;
            this.s2 = s2;

        }
    }

    // ...
    static final State EMPTY = new State(null, null);         // (1) 
    static final State UNSUBSCRIBED = new State(null, null);

    final AtomicReference<tate> state
        = new AtomicReference<>(EMPTY);

    public void set(boolean first, Subscription s) {
        for (;;) {
            State current = state.get();
            if (current == UNSUBSCRIBED) {                    // (2)
                s.unsubscribe();
                return;
            }
            State next;
            Subscription old;
            if (first) {
                next = new State(s, current.s2);
                old = current.s1;
            } else {
                next = new State(current.s1, s);
                old = current.s2;
            }
            if (state.compareAndSet(current, next)) {
                if (old != null) {
                    old.unsubscribe();
                }
                return;
            }
        }
    }

    @Override
    public boolean isUnsubscribed() {
        return state.get() == UNSUBSCRIBED;                    // (3)
    }

    @Override
    public void unsubscribe() {
        State current = state.get();
        if (current != UNSUBSCRIBED) {                         // (4)
            current = state.getAndSet(UNSUBSCRIBED);
            if (current != UNSUBSCRIBED) {                     // (5)
                List<Throwable> errors = null;

                errors = unsubscribe(current.s1, errors);
                errors = unsubscribe(current.s2, errors);

                Exceptions.throwIfAny(errors);
            }
        }
    }
    // ...

Conclusion

Introduction

Array-backed container

@SuppressWarnings({"rawtypes", "unchecked"})                 // (1)
public class SubscriberContainer<T> {
    static final Subscriber[] EMPTY = new Subscriber[0];     // (2)
    static final Subscriber[] TERMINATE = new Subscriber[0];

    final AtomicReference<Subscriber[]> array
        = new AtomicReference<>(EMPTY);                      // (3)

    public Subscriber<T>[] get() {                           // (4)
        return array.get();
    }

    public boolean add(Subscriber<T> s) {                    // (5)
        // implement
    }

    public boolean remove(Subscriber<T> s) {                 // (6)
        // implement
    }

    public Subscriber<T>[] getAndTerminate() {               // (7)
        return array.getAndSet(TERMINATE);
    }

    public boolean isTerminated() {                          // (8)
        return get() == TERMINATED;
    }
}

1. Java doesn't allow generic base types for arrays and doesn't like certain type conversions so we are forced to suppress the warnings regarding raw types and converting those raw values back to parametric types. Generally, the implementation has to be safe but the user of the class will remain typesafe.
2. We use a constant array for indicating the empty state and the terminated state.
3. We store the current array in an AtomicReference instance, but if you know the class won't be extended further, you can just extend AtomicReference directly.
4. The get() method returns the current array of contained items. For performance reasons, one should use this array in read-only manner (otherwise, defensive copies are required on each invocation).
5. The add() method takes a properly-typed Subscriber and returns true if it could be added or false if the container was terminated.
6. The remove() method tries to remove the given subscriber instance and returns true if successful.
7. Instead of a plain unsubscribe() method, we do a handy trick: the current array is replaced with the terminal indicator and return the previous array. It becomes useful when an atomic termination and post-termination actions are needed.
8. Since a regular empty array can't be told apart from the terminated state, a method is needed which checks for this terminal state explicitly.

    // ...
    public boolean add(Subscriber<T> s) {
        for (;;) {
            Subscriber[] current = array.get();
            if (current == TERMINATED) {                  // (1)
                return false;
            }
            int n = current.length;
            Subscriber[] next = new Subscriber[n + 1];
            System.arraycopy(current, 0, next, 0, n);     // (2)
            next[n] = s;
            if (array.compareAndSet(current, next)) {     // (3)
                return true;
            }
        }
    }
    // ...

1. If the container contains the terminated token, the method returns with false and the subscriber is not added to the container. The caller can then decide what to do with said subscriber (i.e., send onCompleted event to it).
2. A copy of the current contents are made into an array with length + 1 and the subscriber is assigned to the very end.
3. The CAS will try to 'commit' the changes and the method returns true. Otherwise, a new attempt is made.

    // ...
    public boolean remove(Subscriber<T> s) {
        for (;;) {
            Subscriber[] current = array.get();
            if (current == EMPTY 
                    || current == TERMINATED) {             // (1)
                return false;
            }
            int n = current.length;
            int j = -1;
            for (int i = 0; i < n; i++) {                   // (2)
                Subscriber e = current[i];
                if (e.equals(s)) {
                    j = i;
                    break;
                }
                i++;
            }
            if (j < 0) {                                    // (3)
                return false;
            }
            Subscriber[] next;
            if (n == 1) {                                   // (4)
                next = EMPTY;
            } else {
                next = new Subscriber[n - 1];
                System.arraycopy(current, 0, next, 0, j);
                System.arraycopy(current, j + 1, 
                    next, j, n - j - 1);                    // (5)
            }
            if (array.compareAndSet(current, next)) {       // (6)
                return true;
            }
        }
    }

Conclusion

Introduction

The Scheduler API

1. All methods should be thread-safe.
2. Workers should make sure undelayed, sequentially scheduled tasks execute in FIFO order.
3. Workers must make best effort to cancel outstanding tasks when unsubscribed.
4. Unsubscription of a Worker should not affect other Worker instances of the same Scheduler.

1. Tasks scheduled on a Worker should try to avoid hopping threads. (Thread locality improves performance.)
2. Delayed tasks scheduled sequentially and with the same delay amount should keep their FIFO order (with concurrent scheduling, the ordering bets are off).

Implementing a custom Scheduler

public final class ContextAwareScheduler 
extends Scheduler {

    public static final ContextAwareScheduler INSTANCE = 
            new ContextAwareScheduler();                       // (1)

    final NewThreadWorker worker;

    private ContextAwareScheduler() {
        this.worker = new NewThreadWorker(
                new RxThreadFactory("ContextAwareScheduler")); // (2)
    }
    @Override
    public Worker createWorker() {
        return new ContextAwareWorker(worker);                 // (3)
    }

    static final class ContextAwareWorker extends Worker {

        final CompositeSubscription tracking;                  // (4)
        final NewThreadWorker worker;

        public ContextAwareWorker(NewThreadWorker worker) {
            this.worker = worker;
            this.tracking = new CompositeSubscription();
        }
        @Override
        public Subscription schedule(Action0 action) {
            // implement
        }
        @Override
        public Subscription schedule(Action0 action, 
                long delayTime, TimeUnit unit) {
            // implement
        }
        @Override
        public boolean isUnsubscribed() {
            return tracking.isUnsubscribed();                  // (5)
        }
        @Override
        public void unsubscribe() {
            tracking.unsubscribe();
        }
    }
}

1. Since we want a single global thread, we can't allow multiple instances of the Scheduler to exist and thus we use a static instance variable for it.
2. The scheduler will delegate most of its work to a single underlying worker. We reuse the NewThreadWorker class and the RxThreadFactory to get a single daemon-thread backed worker instance.
3. Instead of handing out the single worker, we need to 'split' it among usages to conform to requirement #4. Otherwise, if the worker is unsubscribed, everyone's worker is now unsubscribed and useless from then on.
4. We still need to make sure requirement #3 is met, therefore, we need to track tasks submitted to each particular worker.
5. The tracking structure also gives the means to check for and issue unsubscriptions.

public final class ContextManager {
    static final ThreadLocal<Object> ctx = new ThreadLocal<>();

    private ContextManager() {
        throw new IllegalStateException();
    }

    public static Object get() {
        return ctx.get();
    }
    public static void set(Object context) {
        ctx.set(context);
    }
}

    // ...
    @Override
    public Subscription schedule(Action0 action) {
        return schedule(action, 0, null);               // (1)
    }
    @Override
    public Subscription schedule(Action0 action, 
            long delayTime, TimeUnit unit) {

        if (isUnsubscribed()) {                         // (2)
            return Subscriptions.unsubscribed();
        }

        Object context = ContextManager.get();          // (3)
        Action0 a = () -> {
            ContextManager.set(context);                // (4)
            action.call();
        };

        return worker.scheduleActual(a, 
            delayTime, unit, tracking);                 // (5)
    }
    // ...

1. We delegate the undelayed scheduling as if the initial delay is zero. All underlying structure will interpret this zero correctly and perform the required undelayed FIFO execution.
2. In case the current worker is unsubscribed, we don't do anything and return a constant unsubscribed subscription. Note that unsubscribing always involves some small race window where tasks (or events) may slip through. This race is internally resolved in the scheduleActual; more on this below.
3. We hold onto the current thread's context value and wrap the action into another action. 
4. Inside, the context value is restored to that particular thread's local storage. Since the worker is single threaded and non-reentrant, the thread-local context can't be overwritten by the next scheduled task while a previous task is running.
5. Finally, we delegate the wrapping action and the delay information to the underlying NewThreadWorker instance. By passing in the tracking composite, the action will be properly tracked and removed if the task completes, gets unsubscribed or the entire worker gets unsubscribed.

Worker w = INSTANCE.createWorker();

CountDownLatch cdl = new CountDownLatch(1);

ContextManager.set(1);
w.schedule(() -> {
    System.out.println(Thread.currentThread());
    System.out.println(ContextManager.get());
});

ContextManager.set(2);
w.schedule(() -> {
    System.out.println(Thread.currentThread());
    System.out.println(ContextManager.get());
    cdl.countDown();
});

cdl.await();

ContextManager.set(3);

Observable.timer(500, TimeUnit.MILLISECONDS, INSTANCE)
.doOnNext(v -> {
    System.out.println(Thread.currentThread());
    System.out.println(ContextManager.get());
}).toBlocking().first();

w.unsubscribe();

Conclusion

Introduction

#9: Subscribing twice

public final class OnSubscribeRunAction<T> 
implements OnSubscribe<T> {
    final Observable actual;
    final Action0 action;
    public OnSubscribeRunAction(Observable actual, Action0 action) {
        this.action = action;
        this.actual = actual;
    }
    @Override
    public void call(Subscriber child) {
        try {
            action.call();
        } catch (Throwable e) {
            child.onError(e);
            return;
        }
        actual.unsafeSubscribe(child);
    }
}

Observable<Integer> source = Observable.create(
    new OnSubscribeRunAction<>(Observable.range(1, 3),
() -> {
    System.out.println("Subscribing!");
}));

TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
    @Override
    public void onStart() {
        Thread t = new Thread(() -> {
            System.out.println("Starting helper thread "
                + Thread.currentThread());
        });
        t.start();
    }
};
source.unsafeSubscribe(ts);

        // ...
        try {
            action.call();
        } catch (Throwable e) {
            child.onError(e);
            return;
        }
        actual.unsafeSubscribe(new Subscriber<T>(child) {
            @Override
            public void onNext(T t) {
                child.onNext(t);
            }
            @Override
            public void onError(Throwable e) {
                child.onError(e);
            }
            @Override
            public void onCompleted() {
                child.onCompleted();
            }
        });
        // ...

#10: Leaking scheduler workers

public final class OnSubscribeRunActionDelayed<T>
implements OnSubscribe<T> {
    final Observable actual;
    final Action0 action;
    final long delay;
    final TimeUnit unit;
    final Scheduler scheduler;
    public OnSubscribeRunActionDelayed(Observable actual, 
            Action0 action, long delay, 
            TimeUnit unit, Scheduler scheduler) {
        this.action = action;
        this.actual = actual;
        this.delay = delay;
        this.unit = unit;
        this.scheduler = scheduler;
    }
    @Override
    public void call(Subscriber<? super T> child) {
        SerializedSubscriber<T> s = 
            new SerializedSubscriber<>(child);

        Worker w = scheduler.createWorker();                 // (1)

        Subscription cancel = w.schedule(() -> {
            try {
                action.call();
            } catch (Throwable e) {
                s.onError(e);
            }
        }, delay, unit);

        actual
        .doOnCompleted(cancel::unsubscribe)
        .unsafeSubscribe(s);
    }
}

Observable<Integer> source = Observable.create(
    new OnSubscribeRunActionDelayed<>(Observable
        .just(1).delay(1, TimeUnit.SECONDS),
() -> {
    System.out.println("Sorry, it takes too long...");
}, 500, TimeUnit.MILLISECONDS, Schedulers.io()));

Subscription s = source.subscribe(System.out::println);

Thread.sleep(250);

s.unsubscribe();

Thread.sleep(1000);

source.subscribe(System.out::println);

Thread.sleep(1500);

for (Thread t : Thread.getAllStackTraces().keySet()) {
    if (t.getName().startsWith("RxCached")) {
            System.out.println(t);
        }
    }
}

    // ...
    SerializedSubscriber<T> s = new SerializedSubscriber<>(child);

    Worker w = scheduler.createWorker(); 
    child.add(w);

    w.schedule(() -> {
        try {
            action.call();
        } catch (Throwable e) {
            s.onError(e);
        }
    }, delay, unit);

    actual
    .doOnCompleted(w::unsubscribe)
    .unsafeSubscribe(s);
    // ...

#11: Adding the worker to the subscriber

public final class ValueDelayer<T> 
implements Operator<Observable<T>, T> {
    final Scheduler scheduler;
    final long delay;
    final TimeUnit unit;

    public ValueDelayer(long delay, 
            TimeUnit unit, Scheduler scheduler) {
        this.delay = delay;
        this.unit = unit;
        this.scheduler = scheduler;
    }

    @Override
    public Subscriber<? super T> call(
            Subscriber<? super Observable<T>> child) {
        Worker w = scheduler.createWorker();
        child.add(w);

        Subscriber<T> parent = new Subscriber<T>(child, false) {
            @Override
            public void onNext(T t) {
                BufferUntilSubscriber<T> bus = 
                        BufferUntilSubscriber.create();

                w.schedule(() -> {
                    bus.onNext(t);
                    bus.onCompleted();
                }, delay, unit);

                child.onNext(bus);
            }
            @Override
            public void onError(Throwable e) {
                child.onError(e);
            }
            @Override
            public void onCompleted() {
                child.onCompleted();
            }
        };

        child.add(parent);

        return parent;
    }
}

Observable.range(1, 3)
    .lift(new ValueDelayer<>(1, TimeUnit.SECONDS, 
         Schedulers.computation()))
    .take(1)
    .doOnNext(v -> v.subscribe(System.out::println))
    .subscribe();

Thread.sleep(1500);

        // ...
        Worker w = scheduler.createWorker();

        final AtomicBoolean once = new AtomicBoolean();
        final AtomicInteger wip = new AtomicInteger(1);           // (1)

        Subscriber<T> parent = new Subscriber<T>(child, false) {
            @Override
            public void onNext(T t) {

                if (wip.getAndIncrement() == 0) {                 // (2)
                    wip.set(0);
                    return;
                }

                BufferUntilSubscriber<T> bus = 
                        BufferUntilSubscriber.create();

                w.schedule(() -> {
                    try {
                        bus.onNext(t);
                        bus.onCompleted();
                    } finally {
                        release();                                // (3)
                    }
                }, delay, unit);

                child.onNext(bus);
                if (child.isUnsubscribed()) {
                    if (once.compareAndSet(false, true)) {        // (4)
                        release();
                    }
                }
            }
            @Override
            public void onError(Throwable e) {
                child.onError(e);
            }
            @Override
            public void onCompleted() {
                if (once.compareAndSet(false, true)) {
                    release();                                    // (5)
                }
                child.onCompleted();
            }
            void release() {
                if (wip.decrementAndGet() == 0) {
                    w.unsubscribe();
                }
            }
        };
        parent.add(Subscriptions.create(() -> {                   // (6)
            if (once.compareAndSet(false, true)) {
                if (wip.decrementAndGet() == 0) {
                    w.unsubscribe();
                }
            }
        }));

        child.add(parent);

        return parent;
    }
    // ...

1. We need an atomic integer and an atomic boolean. The former one counts the unconsumed inner Observables as well as the active main upstream source of Ts. Since the upstream can end at many locations and perhaps 'multiple times' (i.e., terminating just after the onNext but the upstream still sends an onCompleted which then triggers an unsubscription coming from downstream). Since the upstream should count as 1, we need to use the once to make sure the upstream's single decrement happens only once.
2. We increment the number of 'open windows' by one before even attempting to schedule its task. However, since (6) can asynchronously decrement the wip value to zero, an increment from 0 to 1 indicates an onNext slipped through in which case the worker is already unsubscribed and the child would receive an Observable that can't ever emit.
3. Once the individual inner Observables could emit their values, we release one 'window'.
4. We eagerly check if the child has just unsubscribed after the emission of the inner 'window'. If so, we try to release the upstream once.
5. If the downstream didn't unsubscribe, the onCompleted has to try and release the upstream once too.
6. But since unsubscription can happen at any time, even between event emissions, we still have to try and release the upstream once.

Conclusion

Introduction

The ScheduledAction class

public final class ScheduledAction 
implements Runnable, Subscription {
    final Action0 action;                       // (1)
    final SubscriptionList slist;               // (2)

    public ScheduledAction(Action0 action) {
        this.action = action;
        this.slist = new SubscriptionList();
    }
    @Override
    public void run() {
        try {
            action.call();                      // (3)
        } finally {
            unsubscribe();                      // (4)
        }
    }
    @Override
    public boolean isUnsubscribed() {
        return slist.isUnsubscribed();
    }
    @Override
    public void unsubscribe() {
        slist.unsubscribe();
    }

    public void add(Subscription s) {           // (5)
        slist.add(s);
    }
}

1. We hold onto the real action to be executed.
2. We need a composite to store all the unsubscription actions. Since this list will be add-only, the SubscriptionList will suffice.
3. Since the ExecutorService requires a Runnable instance, the class extends this interface and in the run() method, we delegate to the actual action.
4. Whether or not the call succeeds, we call unsubscribe() on ourselves which should trigger the necessary cleanup actions.
5. However, these cleanup actions need to be registered with this ScheduledAction thus we need to expose the add() method of the SubscriptionList.

public final class CustomWorker 
extends Scheduler.Worker {
    final ExecutorService exec;                             // (1)
    final CompositeSubscription tracking;                   // (2)
    final boolean shutdown;                                 // (3)

    public CustomWorker() {
        exec = Executors.newSingleThreadExecutor();
        tracking = new CompositeSubscription();
        shutdown = true;
    }
    public CustomWorker(ExecutorService exec) {
        this.exec = exec;
        tracking = new CompositeSubscription();
        shutdown = false;                                   // (4)
    }
    @Override
    public Subscription schedule(Action0 action) {
        return schedule(action, 0, null);                   // (5)
    }
    @Override
    public Subscription schedule(Action0 action,
            long delayTime, TimeUnit unit) {
        // implement
    }
    @Override
    public boolean isUnsubscribed() {
        return tracking.isUnsubscribed();                   // (6)
    }
    @Override
    public void unsubscribe() {
        if (shutdown) {
            exec.shutdownNow();                             // (7)
        }
        tracking.unsubscribe();
    }
}

1. We store the reference to the actual thread pool.
2. We also need to track the tasks submitted in order to mass-cancel them.
3. We plan to allow users to submit their own single-threaded executor services, in which case shutting it down should be the responsibility of the caller. 
4. We'll only shut down our own services but not those received through the constructor.
5. We delegate the non-delayed scheduling to the delayed-scheduling via a zero delayTime value.
6. The tracking structure doubles as the way of telling if the worker has been unsubscribed.
7. In case the ExecutorService was created by this class, we'll shut it down, then all tracked tasks are unsubscribed. (Note that if the service is our own, we don't really need to track the tasks because the service itself already tracks all submitted tasks the call to shutdownNow() will mass-cancel them.)

    // ...
    @Override
    public Subscription schedule(Action0 action, 
            long delayTime, TimeUnit unit) {
        if (isUnsubscribed()) {                                // (1)
            return Subscriptions.unsubscribed();
        }
        ScheduledAction sa = new ScheduledAction(action);      // (2)

        tracking.add(sa);                                      // (3)
        sa.add(Subscriptions.create(
            () -> tracking.remove(sa)));

        Future<?> f;
        if (delayTime <= 0) {                                  // (4)
            f = exec.submit(sa);
        } else 
        if (exec instanceof ScheduledExecutorService) {        // (5)
            f = ((ScheduledExecutorService)exec)
                 .schedule(sa, delayTime, unit);
        } else {
            f = genericScheduler.schedule(() -> {              // (6)
                Future<?> g = exec.submit(sa);
                sa.add(Subscriptions.create(                   // (7)
                    () -> g.cancel(false)));
            }, delayTime, unit);
        }

        sa.add(Subscriptions.create(                           // (8)
            () -> f.cancel(false)));

        return sa;                                             // (9)
    }
    // ...

1. If the worker is unsubscribed, the method will return with a constant unsubscribed subscription. Note that schedule calls slipping past this will likely receive an unchecked RejectedExecutionException from the underlying thread pool. You can wrap the rest of the method with try-catch and return the same constant as necessary.
2. We wrap the action into our ScheduledAction.
3. Before the action gets even scheduled, we add it to the tracking structure and add callback that will remove the ScheduledAction from the tracking structure if it completes or gets unsubscribed directly. Note that due to idempotence, the remove() can't get into an infinite loop by calling unsubscribe() on the ScheduledAction again.
4. In case there wasn't any delay time, we schedule the action directly and taking hold on the returned Future for it.
5. In case the ExecutorService is also a ScheduledExecutorService, we can call schedule() on it with the delay parameters directly.
6. Otherwise, we'll need some ScheduledExecutorService instance that will do the delaying for us, but we can't just schedule the action directly on it: it would run on the wrong thread. Instead, we need to schedule an intermediate task which when the time has come, will perform the actual scheduling, without delay, on the proper thread pool.
7. We need to wire up the returned future to be able to cancel the tasks via a unsubscribe() call. Here we'll add the inner future to the ScheduledAction instance.
8. Either scheduled directly or indirectly, we need a way to communicate the cancellation to the thread pool, therefore, we wrap the action of cancelling the future via cancel() into a Subscription and add it to the ScheduledAction. Here, you have the option to do an interrupting cancel or just a regular cancel. (RxJava does both depending on what thread issues the cancel call: if it is the same thread that runs the action, there is no need for interrupts.)
9. The wrapper itself will be the cancellation token directly.

    // ...
    static final ScheduledExecutorService genericScheduler;
    static {
        genericScheduler = Executors.newScheduledThreadPool(1, r -> {
            Thread t = new Thread(r, "GenericScheduler");
            t.setDaemon(true);
            return t;
        });
    }
    // ...

Conclusion

Introduction

The ExecutorScheduler

public final class ExecutorScheduler extends Scheduler {
    final Executor exec;
    public ExecutorScheduler(Executor exec) {
        this.exec = exec;
    }
    @Override
    public Worker createWorker() {
        return new ExecutorWorker();
    }

    final class ExecutorWorker extends Worker 
    implements Runnable {                             // (1)
        // data fields here
        @Override
        public Subscription schedule(
                Action0 action) {
            // implement
        }
        @Override
        public Subscription schedule(
                Action0 action, long delayTime,
                TimeUnit unit) {
            // implement
        }
        @Override
        public void run() {
            // implement
        }
        @Override
        public boolean isUnsubscribed() {
            // implement
        }
        @Override
        public void unsubscribe() {
            // implement
        }
    }
}

        // ...
        final AtomicInteger wip = new AtomicInteger();
        final Queue<ScheduledAction> queue = new ConcurrentLinkedQueue<>();
        final CompositeSubscription tracking = new CompositeSubscription();
        // ...

        // ...
        @Override
        public boolean isUnsubscribed() {
            return tracking.isUnsubscribed();
        }
        @Override
        public void unsubscribe() {
            queue.clear();
            tracking.unsubscribe();
        }
    }
}

    @Override
    public Subscription schedule(Action0 action) {
        if (isUnsubscribed()) {
            return Subscriptions.unsubscribed();
        }
        ScheduledAction sa = 
                new ScheduledAction(action);
        tracking.add(sa);
        sa.add(Subscriptions.create(
                () -> tracking.remove(sa)));        // (1)

        queue.offer(sa);                            // (2)

        sa.add(Subscriptions.create(
                () -> queue.remove(sa)));           // (3)

        if (wip.getAndIncrement() == 0) {           // (4)
            exec.execute(this);                     // (5)
        }

        return sa;
    }

1. We create our ScheduledAction (from part 2) and add the logic to remove itself from the tracking structure on unsubscription.
2. We offer the action to the queue which will keep the FIFO order of the actions submitted sequentially.
3. Then we add the logic to remove our task from the queue in case it gets unsubscribed. Note that this step is O(n) where n is the tasks waiting in the queue before the instance.
4. We should allow only a single drainer which can only happen if the wip counter transitions from 0 to 1.
5. If the current call to schedule won the right to drain the queue, we submit the worker itself so its run() method can poll the queue for available tasks.

    @Override
    public void run() {
        do {
            if (isUnsubscribed()) {                   // (1)
                queue.clear();
                return;
            }
            ScheduledAction sa = queue.poll();        // (2)
            if (sa != null && !sa.isUnsubscribed()) {
                sa.run();                             // (3)
            }
        } while (wip.decrementAndGet() > 0);          // (4)
    }

1. We check if the worker has been unsubscribed in the meantime, if so, we clear the queue (just in case) and return.
2. We poll the next task from the queue.
3. Since a removal or unsubscription could clear a queue while run() is executing, we need to check for null and we need to check if the particular ScheduledAction has been unsubscribed or not. If not, we execute it.
4. We decrement the wip counter until it reaches zero, where it becomes safe to re-schedule the method on the Executor with more tasks to drain if necessary.

    @Override
    public Subscription schedule(
            Action0 action, 
            long delayTime,
            TimeUnit unit) {

        if (delayTime <= 0) {
            return schedule(action);                      // (1)
        }
        if (isUnsubscribed()) {
            return Subscriptions.unsubscribed();          // (2)
        }

        ScheduledAction sa = 
                new ScheduledAction(action);
        tracking.add(sa);
        sa.add(Subscriptions.create(
                () -> tracking.remove(sa)));              // (3)

        ScheduledExecutorService schedex;
        if (exec instanceof ScheduledExecutorService) {
            schedex = (ScheduledExecutorService) exec;    // (4)
        } else {
            schedex = CustomWorker.genericScheduler;      // (5)
        }

        Future<?> f = schedex.schedule(() -> {            // (6)

            queue.offer(sa);                              // (7)

            sa.add(Subscriptions.create(
                    () -> queue.remove(sa)));

            if (wip.getAndIncrement() == 0) {
                exec.execute(this);
            }

        }, delayTime, unit);

        sa.add(Subscriptions.create(
                () -> f.cancel(false)));                  // (8)

        return sa;
    }

ExecutorService exec = Executors.newFixedThreadPool(3);
try {
    Scheduler s = new ExecutorScheduler(exec);

    Observable<Integer> source = Observable.just(1)
    .delay(500, TimeUnit.MILLISECONDS, s)
    .doOnNext(v -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println(Thread.currentThread());
    });

    TestSubscriber<Integer> ts1 = new TestSubscriber<>();
    TestSubscriber<Integer> ts2 = new TestSubscriber<>();
    TestSubscriber<Integer> ts3 = new TestSubscriber<>();

    source.subscribe(ts1);
    source.subscribe(ts2);
    source.subscribe(ts3);

    ts1.awaitTerminalEvent();
    ts1.assertNoErrors();
    ts1.assertValue(1);

    ts2.awaitTerminalEvent();
    ts2.assertNoErrors();
    ts2.assertValue(1);

    ts3.awaitTerminalEvent();
    ts3.assertNoErrors();
    ts3.assertValue(1);
} finally {
    exec.shutdown();
}

Thread[pool-1-thread-3,5,main]
Thread[pool-1-thread-1,5,main]
Thread[pool-1-thread-2,5,main]

Conclusion

Introduction

Working with non-Executor-based services

public interface GuiEventLoop {
    void run(Runnable task);
    void cancel(Runnable task);
}

public static final class EDTEventLoop 
implements GuiEventLoop {
    @Override
    public void run(Runnable task) {
        SwingUtilities.invokeLater(task);
    }

    @Override
    public void cancel(Runnable task) {
        // not supported
    }
}

Executor exec = SwingUtilities::invokeLater;

public final class GuiScheduler extends Scheduler {

    final GuiEventLoop eventLoop;

    public GuiScheduler(GuiEventLoop el) {
        this.eventLoop = el;
    }

    @Override
    public Worker createWorker() {
        return new GuiWorker();
    }

    final class GuiWorker extends Worker {
        final CompositeSubscription tracking = 
            new CompositeSubscription();
        @Override
        public void unsubscribe() {
            tracking.unsubscribe();
        }

        @Override
        public boolean isUnsubscribed() {
            return tracking.isUnsubscribed();
        }

        @Override
        public Subscription schedule(Action0 action) {
            // implement
        }

        @Override
        public Subscription schedule(
                Action0 action, 
                long delayTime,
                TimeUnit unit) {
            // implement
        }
    }
}

    @Override
    public Subscription schedule(Action0 action) {
        if (isUnsubscribed()) {                             // (1)
            return Subscriptions.unsubscribed();
        }
        ScheduledAction sa = new ScheduledAction(action);
        tracking.add(sa);
        sa.add(Subscriptions.create(
                () -> tracking.remove(sa)));                // (2)

        Runnable r = () -> {                                // (3)
            if (!sa.isUnsubscribed()) {
                sa.run();
            }
        };

        eventLoop.run(r);                                   // (4)

        sa.add(Subscriptions.create(
                () -> eventLoop.cancel(r)));                // (5)

        return sa;
    }

1. In case the worker has been unsubscribed, we just return an unsubscribed Subscription instance.
2. We wrap the action with our ScheduledAction and hookup the tracking and removal logic.
3. In this example, we care about that if the ScheduledAction is unsubscribed, we eagerly won't execute its body. Because the eventLoop API expects the same Runnable instance for cancellation and ScheduledAction.run() doesn't do an isUnsubscribed() check on itself, we need to wrap a small logic into a Runnable.
4. We submit this wrapper runnable to the eventLoop API,
5. then add a unsubscription action which will remove it as necessary. Note if we'd done this the other way around and the worker itself was unsubscribed just before (4), we'd immediately call cancel with an r that is not in the event loop and then schedule r regardless and have a larger retention window than in the current case.

    @Override
    public Subscription schedule(
            Action0 action, 
            long delayTime,
            TimeUnit unit) {

        if (delayTime <= 0) {                             // (1)
            return schedule(action);
        }
        if (isUnsubscribed()) {                           // (2)
            return Subscriptions.unsubscribed();
        }
        ScheduledAction sa = 
                new ScheduledAction(action);
        tracking.add(sa);
        sa.add(Subscriptions.create(
                () -> tracking.remove(sa)));              // (3)

        Future<?> f = CustomWorker.genericScheduler       // (4)
        .schedule(() -> {
            Runnable r = () -> {
                if (!sa.isUnsubscribed()) {
                    sa.run();
                }
            };

            eventLoop.run(r);

            sa.add(Subscriptions.create(
                    () -> eventLoop.cancel(r)));          // (5)

        }, delayTime, unit);

        sa.add(Subscriptions.create(
                () -> f.cancel(false)));

        return sa;
    }

1. We treat any non-positive delay as a regular schedule() call.
2. We return if the worker itself was already unsubscribed.
3. We perform the usual wrapping and hookups.
4. We take our genericScheduler and schedule a delayed action that will then relay the real action to the eventLoop,
5. which happens the same way as with the regular schedule() call: we wrap the action into a runnable that checks for its unsubscribed state, submit it to the event loop and add a cancel action.

Scheduler s = new GuiScheduler(new EDTEventLoop());

Observable source = Observable.just(1)
        .delay(500, TimeUnit.MILLISECONDS, s)
        .doOnNext(v -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
            System.out.println(Thread.currentThread());
        });

TestSubscriber ts1 = new TestSubscriber<>();
TestSubscriber ts2 = new TestSubscriber<>();
TestSubscriber ts3 = new TestSubscriber<>();

source.subscribe(ts1);
source.subscribe(ts2);
source.subscribe(ts3);

ts1.awaitTerminalEvent();
ts1.assertNoErrors();
ts1.assertValue(1);

ts2.awaitTerminalEvent();
ts2.assertNoErrors();
ts2.assertValue(1);

ts3.awaitTerminalEvent();
ts3.assertNoErrors();
ts3.assertValue(1);

Thread[AWT-EventQueue-0,6,main]
Thread[AWT-EventQueue-0,6,main]
Thread[AWT-EventQueue-0,6,main]

Conclusion

Introduction

Package and naming confusions

Java 9+ Flow

• This "common platform" won't be that common: only Java 9+ users will benefit from it. Having RS, which is Java 6+ and thus Android-friendly, is a better option; most projects already include many other libraries and plus 2 (RS + RxJava 2.0) is not an issue.
• Java 9 won't use it internally at all. No new async NIO, networking, File I/O and UI events based on the Observer++ pattern seems to be planned. Not to mention, without fluent API support, most users can't go zero-dependency with it. The situation can be remedied if Flow is backported to previos Java JDKs (with the same package location) in an update. Still, without extension methods in Java, users have to always rely on extra libraries and instance wrappings.
• I'm not sure the whole reactive paradigm is final in terms of capturing properties: for example, Applied Duality's AsyncObservable capturing the latency of onXXX methods might be some day incorporated in RS 2.0 (although I don't really see the need for it). Swapping out the dependencies to RS 2.0 and RxJava 3.0 might be much simpler than changing JDK's Flow API. On a historical note, Rx.NET got its IObservable/IObserver included in the BCL, and I think they painted themselves into a corner and in order them to join the RS-paradigm, they now have to figure out a way to have the new set of interface structures live alongside the old one, similar to how pre-generics and post-generics collections ended up. Note that I assume here they accept RS as the new basis for Rx.NET 3.0 and don't try to do something more complicated.

 Critique of RS

No exceptions other than NullPointerException

    // ...
    Subscription subscription;
    @Override
    public void onSubscribe(Subscription s) {
        if (subscription != null) {
            s.cancel();
            onError(new IllegalStateException("§x.y: ..."));
            return;
        }
        this.subscription = s;
        s.request(Long.MAX_VALUE);
    }

• The second onSubscribe() call's onError() is now, potentially, concurrently invoked with the first Publisher's onNext() call, which is correctly forbidden by the specification.
• Storing the first subscription can't be plain and requires an AtomicReference in case there is a subscription race due to multiple uses, adding overhead to a Subscriber implementation.

    // ...
    final AtomicReference subscription = ...;
    @Override
    public void onSubscribe(Subscription s) {
        if (!subscription.compareAndSet(null, s)) {
            s.cancel();
            new IllegalStateException("§x.y: ...").printStackTrace();
            return;
        }
        s.request(Long.MAX_VALUE);
    }

Illegal request amount

    // ...
    @Override
    public void request(long n) {
        if (n <= 0) {
            subscriber.onError(new IllegalArgumentException("§x.y: ..."));
            return;
        }
        // ...
    }

The request() can't throw NPE

Processors require Subscriptions

Processors have to support backpressure

Subscriptions will be conservative regardless

Conclusion

• Error handling: to paraphrase the latest Godzilla movie: "Let them throw!".
• Processors have the option to do backpressure and cancellation on their Subscriber side.
• Most non-trivial Subscriptions have to be conservative and made threadsafe.

Introduction

The SingleSubscription

import org.reactivestreams.*;

public final class SingleSubscription<T> 
extends AtomicBoolean implements Subscription {
    private static final long serialVersionUID = 1L;

    final T value;                                       // (1)
    final Subscriber<? super T> child;
    volatile boolean cancelled;                          // (2)

    public SingleSubscription(T value, 
            Subscriber<? super T> child) {               // (3)
        this.value = Objects.requireNonNull(value);
        this.child = Objects.requireNonNull(child);
    }
    @Override
    public void request(long n) {
        if (n <= 0) {
            throw new IllegalArgumentException(
"n > 0 required");                       // (4)
        }
        if (compareAndSet(false, true)) {
            if (!cancelled) {                            // (5)
                child.onNext(value);
                if (!cancelled) {
                    child.onComplete();
                }
            }
        }
    }
    @Override
    public void cancel() {
        cancelled = true;                                // (6)
    }
}

public final class SingleDelayedSubscription<T> 
extends AtomicInteger implements Subscription {
    /** */
    private static final long serialVersionUID = -1L;

    T value;
    final Subscriber<? super T> child;

    static final int CANCELLED = -1;                           // (1)
    static final int NO_VALUE_NO_REQUEST = 0;
    static final int NO_VALUE_HAS_REQUEST = 1;
    static final int HAS_VALUE_NO_REQUEST = 2;
    static final int HAS_VALUE_HAS_REQUEST = 3;

    public SingleDelayedSubscription(Subscriber<? super T> child) {
        this.child = Objects.requireNonNull(child);
    }
    @Override
    public void request(long n) {
        if (n <= 0) {
            throw new IllegalArgumentException("n > 0 required");
        }
        for (;;) {
            int s = get();
            if (s == NO_VALUE_HAS_REQUEST
                    || s == HAS_VALUE_HAS_REQUEST
                    || s == CANCELLED) {                       // (2)
                return;
            }
            if (s == NO_VALUE_NO_REQUEST) {
                if (!compareAndSet(s, NO_VALUE_HAS_REQUEST)) {
                    continue;
                }
            }
            if (s == HAS_VALUE_NO_REQUEST) {
                if (compareAndSet(s, HAS_VALUE_HAS_REQUEST)) {
                    T v = value;
                    value = null;
                    child.onNext(v);
                    if (get() != CANCELLED) {                  // (3)
                        child.onComplete();
                    }
                }
            }
            return;
        }
    }

    public void setValue(T value) {
       Objects.requireNonNull(value);
       for (;;) {
           int s = get();
           if (s == HAS_VALUE_NO_REQUEST
                   || s == HAS_VALUE_HAS_REQUEST
                   || s == CANCELLED) {                        // (4)
               return;
           } else
           if (s == NO_VALUE_NO_REQUEST) {
               this.value = value;
               if (!compareAndSet(s, HAS_VALUE_NO_REQUEST)) {
                   continue;
               }
           } else
           if (s == NO_VALUE_HAS_REQUEST) {
               if (compareAndSet(s, HAS_VALUE_HAS_REQUEST)) {
                   child.onNext(value);
                   if (get() != CANCELLED) {                   // (5)
                       child.onComplete();
                   }
               }
           }
           return;
       }
    }

    @Override
    public void cancel() {
        int state = get();
        if (state != CANCELLED) {                              // (6)
            state = getAndSet(CANCELLED);
            if (state != CANCELLED) {
                value = null;
            }
        }
    }
}

public final class RangeSubscription 
extends AtomicLong implements Subscription {
    /** */
    private static final long serialVersionUID = 1L;

    final Subscriber<? super Integer> child;
    int index;
    final int max;

    static final long CANCELLED = Long.MIN_VALUE;          // (1)

    public RangeSubscription(
            Subscriber<? super Integer> child, 
            int start, int count) {
        this.child = Objects.requireNonNull(child);
        this.index = start;
        this.max = start + count;
    }
    @Override
    public void request(long n) {
        if (n <= 0) {
            throw new IllegalArgumentException(
"n > required");
        }
        long r;
        for (;;) {
            r = get();
            if (r == CANCELLED) {                          // (2)
                return;
            }
            long u = r + n;
            if (u < 0) {
                u = Long.MAX_VALUE;
            }
            if (compareAndSet(r, u)) {
                break;
            }
        }
        if (r != 0L) {
            return;
        }
        for (;;) {
            r = get();
            if (r == CANCELLED) {                          // (3)
                 return;
            }
            int i = index;
            int m = max;
            long e = 0;
            while (r > 0L && i < m) {
                child.onNext(i);
                if (get() == CANCELLED) {                  // (4)
                    return;
                }
                i++;
                if (i == m) {
                    child.onComplete();
                    return;
                }
                r--;
                i++;
                e++;
            }
            index = i;
            if (e != 0) {
                for (;;) {
                    r = get();
                    if (r == CANCELLED) {                  // (5)
                        return;
                    }
                    long u = r - e;
                    if (u < 0) {
                        throw new IllegalStateException(
"more produced than requested!");
                    }
                    if (compareAndSet(r, u)) {
                        break;
                    }
                }
            }
            if (r <= 0L) {
                break;
            }
        }
    }
    @Override
    public void cancel() {
        if (get() != CANCELLED) {                          // (6)
            getAndSet(CANCELLED);
        }
    }
}

Introduction

Subscription vs. Subscription

interface Disposable {
    boolean isDisposed();
    void dispose();
}

interface DisposableCollection extends Disposable {
    boolean add(Disposable resource);
    boolean remove(Disposable resource);
    boolean removeSilently(Disposable resource);

    void clear();
    boolean hasDisposables();
    boolean contains(Disposable resource);
}

The DisposableSubscription

public final class DisposableSubscription
implements Disposable, Subscription {
    final Subscription actual;
    final DisposableCollection collection;
    public DisposableSubscription(
            Subscription actual, 
            DisposableCollection collection) {
        this.actual = Objects.requireNonNull(actual);
        this.collection = Objects.requireNonNull(collection);
    }
    public boolean add(Disposable resource) {
        return collection.add(resource);
    }
    public boolean remove(Disposable resource) {
        return collection.remove(resource);
    }
    public boolean removeSilently(Disposable resource) {
        return collection.remove(resource);
    }
    @Override
    public boolean isDisposed() {
        return collection.isDisposed();
    }
    @Override
    public void dispose() {
        cancel();
    }

    @Override
    public void cancel() {
        collection.dispose();
        actual.cancel();
    }
    @Override
    public void request(long n) {
        actual.request(n);
    }
}

TakeUntil

public final class OperatorTakeUntil<T> 
implements Operator<T, T> {
    final Publisher<?> other;
    public OperatorTakeUntil(Publisher<?> other) {
        this.other = Objects.requireNonNull(other);
    }
    @Override
    public Subscriber<? super T> call(
            Subscriber<? super T> child) {
        Subscriber<T> serial = 
            new SerializedSubscriber<>(child);

        SubscriptionArbiter arbiter = 
            new SubscriptionArbiter();                       // (1)
        serial.onSubscribe(arbiter);

        SerialDisposable sdUntil = new SerialDisposable();   // (2)
        SerialDisposable sdParent = new SerialDisposable();  // (3)

            // ...
        Subscriber<T> parent = new Subscriber<T>() {
            DisposableSubscription dsub;
            @Override
            public void onSubscribe(Subscription s) {
                DisposableSubscription dsub = 
                        new DisposableSubscription(s, 
                        new DisposableList());              // (1)
                dsub.add(sdUntil);                          // (2)
                sdParent.set(dsub);
                arbiter.setSubscription(dsub);              // (3)
            }
            @Override
            public void onNext(T t) {
                serial.onNext(t);
            }
            @Override
            public void onError(Throwable t) {
                serial.onError(t);
                sdParent.cancel();                          // (4)
            }
            @Override
            public void onComplete() {
                serial.onComplete();
                sdParent.cancel();
            }
        };

1. We create a DisposableSubscription wrapper with a List-based underlying collection.
2. We add the SerialDisposable - that will hold the Disposable to the other Subscription - to this composite. We also add the DisposableSubscription to the sdParent to allow the other Subscriber to finish before the parent one can even start.
3. We hand the wrapper down to the serializer.
4. In case an error or completion event happens, we'll make sure the composite is cancelled/disposed on the spot. Since the composite holds a reference to the other Subscriber's subscription, this will also cancel that stream.

        // ...
        Subscriber<Object> until = new Subscriber<Object>() {
            @Override
            public void onSubscribe(Subscription s) {
                sdUntil.set(Disposables.create(s::cancel));    // (1)
                s.request(Long.MAX_VALUE);
            }
            @Override
            public void onNext(Object t) {
                parent.onComplete();                           // (2)
            }
            @Override
            public void onError(Throwable t) {
                parent.onError(t);
            }
            @Override
            public void onComplete() {
                parent.onComplete();
            }
        };

        this.other.subscribe(until);

        return parent;
    }
}

    @Override
    // ...
    public Subscriber<? super T> call(Subscriber<? super T> child) {
        Subscriber<T> serial = new SerializedSubscriber<>(child);

        SubscriptionArbiter sa = new SubscriptionArbiter();        // (1)

        DisposableSubscription dsub = 
            new DisposableSubscription(sa, new DisposableList());  // (2)

        serial.onSubscribe(dsub);                                  // (3)

        Subscriber<T> parent = new Subscriber<T>() {
            @Override
            public void onSubscribe(Subscription s) {
                dsub.add(Disposables.create(s::cancel));           // (4)
                sa.setSubscription(s);                             // (5)
            }
            // ...
        };

        Subscriber<Object> until = 
        new Subscriber<Object>() {
            @Override
            public void onSubscribe(Subscription s) {
                dsub.add(Disposables.create(s::cancel));           // (6)
                s.request(Long.MAX_VALUE);
            }
            // ...

Introduction

public final class OnSubscribeDefer<T>
implements OnSubscribe<T> {
    final Func0<? extends Publisher<? extends T>> factory;
    public OnSubscribeDefer(
           Func0<? extends Publisher<? extends T>> factory) {
        this.factory = factory;
    }
    @Override
    public void call(Subscriber<? super T> child) {

        SubscriptionArbiter sa = new SubscriptionArbiter();
        child.onSubscribe(sa);                                 // (1)  

        Publisher<? extends T> p;
        try {
            p = factory.call();
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            child.onError(e);                                  // (2)
            return;
        }
        p.subscribe(new Subscriber<T>() {                      // (3)
            @Override
            public void onSubscribe(Subscription s) {
                sa.setSubscription(s);                         // (4)
            }

            @Override
            public void onNext(T t) {
                child.onNext(t);
            }

            @Override
            public void onError(Throwable t) {
                child.onError(t);
            }

            @Override
            public void onComplete() {
                child.onComplete();
            }

        });
    }
}

 Time-delayed subscribing

public final class OnSubscribeDelayTimed<T>
implements OnSubscribe<T> {
    final Publisher<T> source;
    final Scheduler scheduler;
    final long delay;
    final TimeUnit unit;
    public OnSubscribeDelayTimed(
            Publisher<T> source, 
            long delay, TimeUnit unit, 
            Scheduler scheduler) {
        this.source = source;
        this.delay = delay;
        this.unit = unit;
        this.scheduler = scheduler;
    }
    @Override
    public void call(Subscriber child) {
        Scheduler.Worker w = scheduler.createWorker();

        // child.add(w);

        w.schedule(() -> {
            // if (!child.isUnsubscribed()) {

                source.subscribe(child);

            // }
        }, delay, unit);
    }
}

    @Override
    public void call(Subscriber<? super T> child) {
        Scheduler.Worker w = scheduler.createWorker();

        SubscriptionArbiter sa = new SubscriptionArbiter();    // (1)

        DisposableSubscription dsub = 
            new DisposableSubscription(
                sa, new DisposableList());                     // (2)

        dsub.add(w);                                           // (3)

        child.onSubscribe(dsub);                               // (4)

        w.schedule(() -> {
            source.subscribe(new Subscriber<T>() {             // (5)
                @Override
                public void onSubscribe(Subscription s) {
                    sa.setSubscription(s);                     // (6)
                }

                @Override
                public void onNext(T t) {
                    child.onNext(t);
                }

                @Override
                public void onError(Throwable t) {
                    child.onError(t);
                }

                @Override
                public void onComplete() {
                    child.onComplete();
                }

            });
        }, delay, unit);

1. We need a SubscriptionArbiter because we need cancellation support while the delayed subscription happens, however, we won't have any real Subscription from source yet so we need to hold onto any requests that may come in in the meantime.
2. We need a way to cancel the schedule in case the child has decided to cancel() the whole operation. Since the arbiter doesn't have resource management, we need to wrap it into a disposable-container. Naturally, we don't really need a list for a single resource and you can implement your own, single resource disposable subscription.
3. The container will take care of cancellation if we add the Worker instance.
4. Once the arbiter+disposable are set up, we send the dsub to the child. This way, it can request() and cancel() at any time and both arbiter and dsub will forward the calls to the appropriate (re)sources.
5. Once the scheduled action runs, we can't just hand the original child Subscriber to it because we already have set a Subscriber on it. Therefore, we need to wrap it with another Subscriber instance that mostly forwards the onXXX calls except onSubscribe.
6. The onSubscribe needs to change and instead of setting the source Subscription on the child, we set it on the arbiter. The arbiter will then now relay any accumulated requests or cancel the source immediately.

Introduction

Observable.create(s -> {
   int i = 0;
   while (true) {
       s.onNext(i++);
   }
}).subscribe(System.out::println);

Imperative eventing

Subject changeEvents = ...

changeEvents.subscribe(System.out::println);
changeEvents.subscribe(System.out::println);

changeEvents.onNext("Added");
Thread.sleep(10);
changeEvents.onNext("Removed");
Thread.sleep(10);
changeEvents.onCompleted();

interface ISubject<T>: IObserver<T>, IObservable<T> { }

interface ISubject<T, U>: IObserver<T> IObservable<U> { }

abstract class Subject<T, R>
extends Observable<R> implements Observer<T> { }

Subject<String, String> changeEvents = ...

Subject<String, String> changeEvents = PublishSubject.create();

Flavors

• createWithSize(n) will retain at most n elements,
• createWithTime(t, u) will retain elements that are younger that than t and
• createWithTimeAndSize(n, t, u) will retain at most n elements which are also younger than t.

A reactive list

• a notification channel for the type of change,
• a notification channel of the value causing the change, which also remembers the last value that was involved in a change and
• a notification channel that holds onto the last 10 elements added to the list.

public final class ReactiveList<T> {

    public enum ChangeType { 
        ADD, REMOVE, UPDATE                      // (1)
    };

    final List<T> list = new ArrayList<>();      // (2)

    final PublishSubject<Changetype> changes = 
            PublishSubject.create();             // (3)
    final BehaviorSubject<T> changeValues = 
            BehaviorSubject.create();
    final ReplaySubject<T> latestAdded = 
            ReplaySubject.createWithSize(10);

    public Observable<ChangeType> changes() {    // (4)
        return changes;
    }

    public Observable<T> changeValues() {
        return changeValues;
    }

    public Observable<T> latestAdded() {
        return latestAdded;
    }

    public void add(T value) {
        // implement
    }
    public void remove(T value) {
        // implement
    }
    public void replace(T value, T newValue) {
        // implement
    }
}

1. We define an enum for the three kinds of change events: add, remove and update.
2. The data will be stored in a regular j.u.List instance.
3. We specify the Subjects for the various event outputs and
4. we specify methods that return an Observable of those outputs.

    // ...
    public void add(T value) {
        list.add(value);
        changes.onNext(ChangeType.ADD);
        changeValues.onNext(value);
        latestAdded.onNext(value);
    }
    public void remove(T value) {
        if (list.remove(value)) {
            changes.onNext(ChangeType.REMOVE);
            changeValues.onNext(value);
        }
    }
    public void replace(T value, T newValue) {
        int index = list.indexOf(value);
        if (index >= 0) {
            list.set(index, newValue);
            changes.onNext(ChangeType.UPDATE);
            changeValues.onNext(newValue);
        }
    }
}

A more reactive list

public class MoreReactiveList<T> {
    public enum ChangeType { 
        ADD, REMOVE 
    };

    final List<T> list = new ArrayList<>();

    final Subject<ChangeType, ChangeType> changes;  // (1)
    final Subject<T, T> changeValues;
    final Observer<T> addObserver;                  // (2)
    final Observer<T> removeObserver;

    public Observable<ChangeType> changes() {
        return changes;
    }

    public Observable<T> changeValues() {
        return changeValues;
    }

    public Observable<T> list() {                   // (3)
        List<T> copy = new ArrayList<>();
        synchronized (list) {
            copy.addAll(list);
        }
        return Observable.from(copy);
    }

    public Observer<T> adder() {                    // (4)
        return addObserver;
    }

    public Observer<T> remover() {
        return removeObserver;
    }

    void onAdd(T value) {                           // (5)
        synchronized (list) {
            list.add(value);
        }
        changes.onNext(ChangeType.ADD);
        changeValues.onNext(value);
    }

    void onRemove(T value) {
        synchronized (list) {
            if (!list.remove(value)) {
                return;
            }
        }
        changes.onNext(ChangeType.REMOVE);
        changeValues.onNext(value);
    }

    void clear() {
        synchronized (list) {
            list.clear();
        }
    }

    public MoreReactiveList() {
        // implement
    }
}

1. Since we are going to serialize the Subjects, we lose their concrete type and have to specify them as Subject<T, R>.
2. We will have a single set Observers for both add- and remove-channels.
3. Here we have the new a list() method that creates a snapshot of the underlying list and returns an Observable of it. Note the synchronization around the list itself: the class will be manipulated concurrently and we need to ensure thread safety.
4. We return the final Observer instances for the add- and remove-channels through the methods.
5. The actual list manipulation has been moved to the package-private onAdd and onRemove methods.

    // ...
    public MoreReactiveList() {
        changes = 
                PublishSubject.<ChangeType>create()
                .toSerialized();                     // (1)

        changeValues = 
                BehaviorSubject.<T>create()
                .toSerialized();                     

        addObserver = new SerializedObserver<>(      // (2)
            Observers.create(
                this::onAdd,
                t -> {
                    clear();
                    changes.onError(t);
                    changeValues.onError(t);
                },
                () -> { 
                    clear();
                    changes.onCompleted();
                    changeValues.onCompleted();
                }
        ));
        removeObserver = new SerializedObserver<>(   // (3)
            Observers.create(
                this::onRemove,
                t -> {
                    clear();
                    changes.onError(t);
                    changeValues.onError(t);
                },
                () -> { 
                    clear();
                    changes.onCompleted();
                    changeValues.onCompleted();
                }
        ));
    }
}

MoreReactiveList<Long> list = new MoreReactiveList<>();

Observable.timer(0, 1, TimeUnit.SECONDS)
    .take(10)
    .subscribe(list.adder());

Observable.timer(4, 1, TimeUnit.SECONDS)
    .take(10)
    .subscribe(list.remover());

list.changes().subscribe(System.out::println);

list.changes()
.flatMap(e -> list.list().toList())
.subscribe(System.out::println);

list.changeValues.toBlocking().forEach(System.out::println);

Introduction

Requirements

• [Observer] onXXX events have to be sequential and expected to be sequential
• [Observer] should conform the pattern onNext* (onError | onCompleted)?
• [Observable] subscribing to it should be thread-safe

UnicastSubject

public final class UnicastSubject<T> 
extends Subject<T, T> {

    public static <T> UnicastSubject<T> create() {   // (1)
        State<T> state = new State<>();

        return new UnicastSubject<>(state);
    }

    final State<T> state;                            // (2)

    protected UnicastSubject(State<T> state) {       // (3)
        super(state);
        this.state = state;
    }

    @Override
    public void onNext(T t) {
        // implement
    }

    @Override
    public void onError(Throwable e) {
        // implement
    }

    @Override
    public void onCompleted() {
        // implement
    }

    @Override
    public boolean hasObservers() {
        // implement
    }

    static class State<T> implements 
        OnSubscribe<T>, Observer<T>, 
        Producer, Subscription {                       // (4)

    }
}

public class MyObservable<T> extends Observable<T> {
    protected MyObservable() {
        super(this::handleSubscriber);
    }

    void handleSubscriber(Subscriber<? super T> s) {
    }
}

• OnSubscribe for handling subscription, 
• Observer for conveniently have onXXX methods that will be delegated to from the UnicastSubject.onXXX methods, 
• Producer, since we know there will be only a single Subscriber which needs only a single Producer to communicate with (saving on allocation and on cross-communication) and
• Subscription for handling the unsubscription call coming from the child directly (again saving on allocation and cross-communication).

    // ...
    @Override
    public void onNext(T t) {
        state.onNext(t);
    }

    @Override
    public void onError(Throwable e) {
        state.onError(e);
    }

    @Override
    public void onCompleted() {
        state.onCompleted();
    }

    @Override
    public boolean hasObservers() {
        return state.child != null;
    }
    // ...

static final class State<T> implements 
    OnSubscribe<T>, Observer<T>, Producer, Subscription {

        volatile Subscriber<? super T> child;                  // (1)

        final AtomicBoolean once = new AtomicBoolean();        // (2)

        final Queue<T> queue = new SpscLinkedAtomicQueue<>();  // (3)

        volatile boolean done;                                 // (4)
        Throwable error;

        volatile boolean unsubscribed;                         // (5)

        final AtomicLong requested = new AtomicLong();         // (6)

        final AtomicInteger wip = new AtomicInteger();         // (7)
        // ...

1. The child field will hold onto the only subscriber when it arrives and will be set back to null once it leaves. It has to be volatile because hasObservers() needs to check it in thread-safe manner.
2. We need to make sure only a single Subscriber is let in during the entire lifetime of the subject and we do this via an atomic boolean. Naturally, this field could have been inlined into State by StateextendsAtomicBoolean. An alternative, although requires more work would have been to use child directly and have a private static Subscriber instance that indicates a terminal state.
3. This queue will hold onto the incoming values until there is a Subscriber or said subscriber requests some elements. Here, I'm using a single-producer single-consumer linked queue implementation from RxJava, but this queue is relatively expensive due to constant node allocation. In an upcoming PR and in RxJava 2.x, we have a SpscLinkedArrayQueue (it is a slightly modified version of the JCTools SpscUnboundedArrayQueue) that amortizes this allocation by using 'islands' of Spsc buffers.
4. We hold onto the terminal event (which might be an error) in these two fields. Since error will be written once before done and read after done, it doesn't need to be a volatile in itself.
5. Since the child may go at any time, it would be infeasible to keep buffering events indefinitely since no one else could observe them after that. This flag, along with the done flag will be used in the onXXX methods to drop events.
6. We need to keep track of the requested amount of the child subscriber so we emit values no more than requested.
7. The wip field is part of the queue-drain approach explained in an earlier post and makes sure only a single thread is emitting values to the child subscriber, if any.

@Override
public void call(Subscriber<? super T> t) {
    if (!once.get() && once.compareAndSet(false, true)) {  // (1)
        t.add(this);
        t.setProducer(this);                               // (2)
        child = t;
        drain();                                           // (3)
    } else {
        if (done) {                                        // (4)
            Throwable e = error;
            if (e != null) {                               // (5)
                t.onError(e);
            } else {
                t.onCompleted();
            }
        } else {
            t.onError(new IllegalStateException(
"Only one subscriber allowed."));          // (6)
        }
    }
}

1. If once is not set and we succeed setting it to true atomically, we now have our single child subscriber.
2. It is important that setting up the unsubscription callback and the producer happens before the store to the child field, otherwise, an asynchronous onNext call may end up running before this setup. This isn't much of a problem in RxJava 1.x but it is of a large concern in a reactive-streams compliant Publisher (to which we'd like to port our code more easily.)
3. Once the producer/unsubscription are set up, we set the child reference. Whether or not the child is cancelled at this point, we need to call drain which will take care of replaying buffered values and cleaning up if the child has unsubscribed in the meantime.
4. If there is/was a subscriber already there, we need to check if the subject is actually terminated.
5. If the subject is terminated, we simply emit the terminal event (error or completion), similar to how the standard subjects behave.
6. Otherwise, if there is a subscriber and the subject isn't terminated, we simple emit an IllegalStateException explaining the situation.

@Override
public void onNext(T t) {
    if (done || unsubscribed) {
        return;
    }
    queue.offer(t);
    drain();
}

@Override
public void onNext(T t) {
    if (done || unsubscribed) {
        return;
    }
    if (wip.get() == 0 && wip.compareAndSet(0, 1)) {  // (1)
        long r = requested.get();                     // (2)
        if (r != 0 && queue.isEmpty()) {              // (3)
            child.onNext(t);
            if (r != Long.MAX_VALUE) {                // (4)
                requested.decrementAndGet();
            }
            if (wip.decrementAndGet() == 0) {         // (5)
                return;
            }
        } else {
            queue.offer(t);                           // (6)
        }
    } else {
        queue.offer(t);                               // (7)
        if (wip.getAndIncrement() != 0) {
            return;
        }
    }
    drainLoop();                                      // (8)
}

1. This is the entry to the fast-path; if we manage to set the wip counter from 0 to 1, we are in.
2. We retrieve the requested amount.
3. We need to check if the requested amount is non-zero and if the queue is empty. This queue check is crucial because otherwise the fast-path would skip the contents of the queue and thus reorder the events.
4. If the queue happens to be empty and the child runs in bounded mode, we emit the event and decrement the requested amount.
5. We also decrement the wip count and if it is zero, we simply return. If it is non-zero, it means a concurrent request() call arrived and we need to deal with it. The execution stay's in "emission mode" and continues on line (8)
6. If there is no request or the queue is non-empty, we enqueue the current value and let the drainLoop() deal with the situation (8).
7. If we couldn't enter the fast-path, we offer the value into the queue and try to enter the drain loop by incrementing wip. If it was actually zero, we enter the drain loop, otherwise, we did indicate a running drain loop there is more work to do.
8. Finally, while still in "emission mode", we jump to the drain loop.

@Override
public void onError(Throwable e) {
    if (done || unsubscribed) {
        return;
    }
    error = e;
    done = true;
    drain();
}

@Override
public void onCompleted() {
    if (done || unsubscribed) {
        return;
    }
    done = true;
    drain();
}

@Override
public void request(long n) {
    if (n < 0) {
        throw new IllegalArgumentException("n >= 0 required");
    }
    if (n > 0) {
        BackpressureUtils.getAndAddRequest(requested, n);      // (1)
        drain();
    }
}

@Override
public boolean isUnsubscribed() {
    return unsubscribed;
}

@Override
public void unsubscribe() {
    if (!unsubscribed) {
        unsubscribed = true;
        if (wip.getAndIncrement() == 0) {                      // (2)
            clear();
        }
    }
}

void clear() {
    queue.clear();
    child = null;
}

void drain() {
    if (wip.getAndIncrement() == 0) {
        drainLoop();
    }
}

void drainLoop() {
    int missed = 1;                                           // (1)

    final Queue<T> q = queue;
    Subscriber<? super T> child = this.child;                 // (2)

    for (;;) {

        if (child != null) {                                  // (3)

            if (checkTerminated(done, q.isEmpty(), child)) {  // (4)
                return;
            }

            long r = requested.get();
            boolean unbounded = r == Long.MAX_VALUE;
            long e = 0L;                                      // (5)

            while (r != 0L) {
                boolean d = done;
                T v = q.poll();
                boolean empty = v == null;                    // (6)

                if (checkTerminated(d, empty, child)) {
                    return;
                }

                if (empty) {
                    break;
                }

                child.onNext(v);

                r--;
                e--;                                          // (7)
            }

            if (e != 0) {
                if (!unbounded) {
                    requested.addAndGet(e);                   // (8)
                }
            }
        }

        missed = wip.addAndGet(-missed);                      // (9)
        if (missed == 0) {
            return;
        }

        if (child == null) {                                  // (10)
            child = this.child;
        }
    }
}

boolean checkTerminated(boolean done, boolean empty, 
        Subscriber<? super T> child) {
    if (unsubscribed) {                              // (1)
        clear();
        return true;
    }
    if (done && empty) {                             // (2)
        unsubscribed = true;
        this.child = null;
        Throwable e = error;
        if (e != null) {
            child.onError(e);
        } else {
            child.onCompleted();
        }
        return true;
    }
    return false;
}

boolean checkTerminated(boolean done, boolean empty, 
        Subscriber<? super T> child) {
    if (unsubscribed) {
        clear();
        return true;
    }
    if (done) {
        Throwable e = error;                            // (1)
        if (e != null) {
            unsubscribed = true;
            clear();
            child.onError(e);
            return true;
        } else 
        if (empty) {                                    // (2)
            unsubscribed = true;
            this.child = null;
            child.onCompleted();
            return true;
        }
    }
    return false;
}

Introduction

PublishSubject

enum BackpressureStrategy {
    DROP,
    BUFFER,
    ERROR
}

public static <T> PublishSubject&ltT> createWith(
        BackpressureStrategy strategy) {
    State&ltT> state = new State<>(strategy);
    return new PublishSubject<>(state);
}

static final class State<T> 
implements OnSubscribe<T>, Observer<T> {
    final BackpressureStrategy strategy;

    @SuppressWarnings("unchecked")
    volatile SubscriberState<T>[] subscribers = EMPTY;

    @SuppressWarnings("rawtypes")
    static final SubscriberState[] EMPTY = new SubscriberState[0];

    @SuppressWarnings("rawtypes")
    static final SubscriberState[] TERMINATED = 
        new SubscriberState[0];

    volatile boolean done;
    Throwable error;

    public State(BackpressureStrategy strategy) {
        this.strategy = strategy;
    }

    boolean add(SubscriberState<T> subscriber) {
        // TODO Auto-generated method stub

    }

    void remove(SubscriberState<T> subscriber) {
        // TODO Auto-generated method stub

    }

    Subscriber<T>[] terminate() {
        // TODO Auto-generated method stub

    }


    @Override
    public void call(Subscriber<? super T> t) {
        // TODO Auto-generated method stub

    }

    @Override
    public void onNext(T t) {
        // TODO Auto-generated method stub

    }

    @Override
    public void onError(Throwable e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void onCompleted() {
        // TODO Auto-generated method stub

    }
}

boolean add(SubscriberState<T> subscriber) {
    synchronized (this) {
        SubscriberState<T>[] a = subscribers;
        if (a == TERMINATED) {
            return false;
        }
        int n = a.length;

        @SuppressWarnings("unchecked")
        SubscriberState<T>[] b = new SubscriberState[n + 1];

        System.arraycopy(a, 0, b, 0, n);
        b[n] = subscriber;
        subscribers = b;
        return true;
    }
}

@SuppressWarnings("unchecked")
void remove(SubscriberState<T> subscriber) {
    synchronized (this) {
        SubscriberState<T>[] a = subscribers;
        if (a == TERMINATED || a == EMPTY) {
            return;
        }
        int n = a.length;

        int j = -1;
        for (int i = 0; i < n; i++) {
            if (a[i] == subscriber) {
                j = i;
                break;
            }
        }

        if (j < 0) {
            return;
        }
        SubscriberState<T>[] b;
        if (n == 1) {
            b = EMPTY;
        } else {
            b = new SubscriberState[n - 1];
            System.arraycopy(a, 0, b, 0, j);
            System.arraycopy(a, j + 1, b, j, n - j - 1);
        }
        subscribers = b;
    }
}

@SuppressWarnings("unchecked")
SubscriberState<T>[] terminate() {
    synchronized (this) {
        SubscriberState<T>[] a = subscribers;
        if (a != TERMINATED) {
            subscribers = TERMINATED;
        }
        return a;
    }
}

@Override
public void call(Subscriber<? super T> t) {
    SubscriberState<T> innerState = 
        new SubscriberState<>(t, this);                // (1)
    t.add(innerState);                                 // (2)
    t.setProducer(innerState);

    if (add(innerState)) {                             // (3)
        if (strategy == BackpressureStrategy.BUFFER) { // (4)
            innerState.drain();
        } else
        if (innerState.unsubscribed) {                 // (5)
            remove(innerState);
        }
    } else {
        Throwable e = error;                           // (6)
        if (e != null) {
            t.onError(e);
        } else {
            t.onCompleted();
        }
    }
}

1. We create and wrap the child subscriber into a SubscriberState that will manage the dispatching of events for each subscriber individually.
2. We add it to the child subscriber as a Subscription for unsubscription and request handling.
3. We try to add the innerState object into the array of subscribers, which may fail if the subject is concurrently terminating.
4. In case we run in a buffering mode, we need to start draining the buffer.
5. Even if the add() succeeded, the child might have unsubscribed concurrently and the subscribers array may still contain a reference to it. In this case, we explicitly try to remove it again.
6. If the add() failed on line (3), it means the subject reached its terminal state and we need to emit the terminal event to the child.

@Override
public void onNext(T t) {
    if (done) {
        return;
    }
    for (SubscriberState<T> innerState : subscribers) {
        innerState.onNext(t);
    }
}

@Override
public void onError(Throwable e) {
    if (done) {
        return;
    }
    error = e;
    done = true;
    for (SubscriberState<T> innerState : terminate()) {
        innerState.onError(e);
    }
}

@Override
public void onCompleted() {
    if (done) {
        return;
    }
    done = true;
    for (SubscriberState<T> innerState : terminate()) {
        innerState.onCompleted();
    }
}

static final class SubscriberState<T> 
implements Producer, Subscription, Observer<T> {
    final Subscriber<? super T> child;                      // (1)
    final State<T> state;                                   // (2)
    final BackpressureStrategy strategy;                    // (3)

    final AtomicLong requested = new AtomicLong();          // (4)

    final AtomicInteger wip = new AtomicInteger();          // (5)

    volatile boolean unsubscribed;                          // (6)

    volatile boolean done;
    Throwable error;

    final Queue<T> queue;                                   // (7)

    public SubscriberState(
            Subscriber<? super T> child, State<T> state) {
        this.child = child;
        this.state = state;
        this.strategy = state.strategy;
        Queue<T> q = null;
        if (strategy == BackpressureStrategy.BUFFER) {      // (8)
            q = new SpscLinkedAtomicQueue<>();
        }
        this.queue = q;
    }

    @Override
    public void onNext(T t) {
        // TODO Auto-generated method stub
    }

    @Override
    public void onError(Throwable e) {
        // TODO Auto-generated method stub
    }

    @Override
    public void onCompleted() {
        // TODO Auto-generated method stub
    }

    @Override
    public void request(long n) {
        // TODO Auto-generated method stub
    }

    @Override
    public boolean isUnsubscribed() {
        return unsubscribed;
    }

    @Override
    public void unsubscribe() {
        // TODO Auto-generated method stub
    }

    void drain() {
        // TODO Auto-generated method stub
    }
}

@Override
public void onNext(T t) {
    if (unsubscribed) {
        return;
    }
    switch (strategy) {
    case BUFFER:
        queue.offer(t);                               // (1)
        drain();
        break;
    case DROP: {
        long r = requested.get();                     // (2)
        if (r != 0L) {
            child.onNext(t);
            if (r != Long.MAX_VALUE) {
                requested.decrementAndGet();
            }
        }
        break;
    }
    case ERROR: {
        long r = requested.get();                     // (3)
        if (r != 0L) {
            child.onNext(t);
            if (r != Long.MAX_VALUE) {
                requested.decrementAndGet();
            }
        } else {
            unsubscribe();
            child.onError(
                new MissingBackpressureException());
        }

        break;
    }
    default:
    }
}

@Override
public void onError(Throwable e) {
    if (unsubscribed) {
        return;
    }
    if (strategy == BackpressureStrategy.BUFFER) {
        error = e;
        done = true;
        drain();
    } else {
        child.onError(e);
    }
}

@Override
public void onCompleted() {
    if (unsubscribed) {
        return;
    }
    if (strategy == BackpressureStrategy.BUFFER) {
        done = true;
        drain();
    } else {
        child.onCompleted();
    }
}

@Override
public void request(long n) {
    if (n < 0) {
        throw new IllegalArgumentException();
    }
    if (n > 0) {
        BackpressureUtils.getAndAddRequest(requested, n);
        if (strategy == BackpressureStrategy.BUFFER) {
            drain();
        }
    }
}

@Override
public boolean isUnsubscribed() {
    return unsubscribed;
}

@Override
public void unsubscribe() {
    if (!unsubscribed) {
        unsubscribed = true;
        state.remove(this);
        if (strategy == BackpressureStrategy.BUFFER) {
            if (wip.getAndIncrement() == 0) {
                queue.clear();
            }
        }
    }
}

void drain() {
    if (wip.getAndIncrement() != 0) {
        return;
    }

    int missed = 1;

    Queue<> q = queue;
    Subscriber child = this.child;

    for (;;) {

        if (checkTerminated(done, q.isEmpty(), child)) {
            return;
        }

        long r = requested.get();
        boolean unbounded = r == Long.MAX_VALUE;
        long e = 0L;

        while (r != 0) {
            boolean d = done;
            T v = q.poll();
            boolean empty = v == null;

            if (checkTerminated(d, empty, child)) {
                return;
            }

            if (empty) {
                break;
            }

            child.onNext(v);

            r--;
            e--;
        }

        if (e != 0) {
            if (!unbounded) {
                requested.addAndGet(e);
            }
        }

        missed = wip.addAndGet(-missed);
        if (missed == 0) {
            return;
        }
    }
}

boolean checkTerminated(boolean done, 
        boolean empty, 
        Subscriber<? super T> child) {
    if (unsubscribed) {
        queue.clear();                     // (1)
        state.remove(this);
        return true;
    }
    if (done && empty) {
        unsubscribed = true;               // (2)
        Throwable e = error;
        if (e != null) {
            child.onError(e);
        } else {
            child.onCompleted();
        }
        return true;
    }
    return false;
}

protected void emitNext(Object n, final NotificationLite<T> nl) {
    if (!fastPath) {
        synchronized (this) {
            first = false;
            if (emitting) {
                if (queue == null) {
                    queue = new ArrayList<Object>();
                }
                queue.add(n);
                return;
            }
        }
        fastPath = true;
    }
    nl.accept(actual, n);
}

protected void emitFirst(Object n, final NotificationLite<T> nl) {
    synchronized (this) {
        if (!first || emitting) {
            return;
        }
        first = false;
        emitting = n != null;
    }
    if (n != null) {
        emitLoop(null, n, nl);
    }
}

Introduction

• The number of source Observables is known when the downstream subscribes.
• We need to track all subscriptions in a collection other than CompositeSubscription because there is no way to cherry pick one and unsubscribe the rest.
• One has to relay the downstream request to all sources.
• Unsubscription, requesting and even the choosing of a "winner" may happen while subscribing to the source Observables.

Implementation: 1.x

Implementation: 2.x

class AmbSubscriber<T> 
extends AtomicReference<Subscription>
implements Subscriber<T>, Subscription {
    volatile long missedRequested;
    static final AtomicLongFieldUpdater MISSED_REQUESTED = ...;

    static final Subscription CANCELLED = ...;
}

@Override
public void cancel() {
    Subscription s = get();
    if (s != CANCELLED) {
        s = getAndSet(CANCELLED);
        if (s != CANCELLED && s != null) {
            s.cancel();
        }
    }
}

@Override
public void onSubscribe(Subscription s) {
    if (!compareAndSet(null, s)) {                         // (1)
        s.cancel();                                        // (2)
        if (get() != CANCELLED) {                          // (3)
            SubscriptionHelper.reportSubscriptionSet();
        }
        return;
    }

    long r = MISSED_REQUESTED.getAndSet(this, 0L);         // (4)
    if (r != 0L) {                                         // (5)
        s.request(r);
    }
}

@Override
public void request(long n) {
    Subscription s = get();
    if (s != null) {                                       // (1)
        s.request(n);
    } else {
        BackpressureHelper.add(MISSED_REQUESTED, this, n); // (2)
        s = get();
        if (s != null && s != CANCELLED) {                 // (3)
            long r = MISSED_REQUESTED.getAndSet(this, 0L); // (4)
            if (r != 0L) {                                 // (5)
                s.request(r);
            }
        }
    }
}

Introduction

• Since the output is a single value, one doesn't need to play around with request accounting and can let the operator request Long.MAX_VALUE from upstream. This gives the added benefit that it may trigger a fast-path and thus run with reduced overhead.
• Since the output is a single value, emitted even if the upstream is empty, one has to prepare for handling request amounts from downstream and only then emit the result.

Implementation: 1.x

Implementation: 2.x

@Override
public void onNext(T t) {
    if (done) {                             // (1)
        return;
    }
    boolean b;
    try {
         b = predicate.test(t);
    } catch (Throwable e) {                 // (2)
         lazySet(HAS_REQUEST_HAS_VALUE);
         done = true;
         s.cancel();
         actual.onError(e);
         return;
    }
    if (!b) {
        lazySet(HAS_REQUEST_HAS_VALUE);     // (3)
        done = true;
        s.cancel();
        actual.onNext(false);
        actual.onComplete();
    }
}

1. Cancellation is best effort in both Reactive-Streams and 1.x Observables and one can't rely upon the cancellation alone. The done flag drops all events after the termination/cancellation of the operator.
2. Callbacks can crash, in which case we set the state-machine to its terminal value HAS_REQUEST_HAS_VALUE which should prevent any value emission in a request call. In addition we set the done flag and call cancel on the Subscription.
3. If the predicate returned false, we can shortcut the stream by cancelling it and emitting the constant false as the result. Here, the state machine is also brought to its terminal state.

Conclusion

Introduction

Observable<Integer> source = Observable.range(1, 10);

ConnectableObservable<Integer> published = source.publish();

Observable<Integer> first = published;
Observable<Integer> second = published.skip(1);

Observable<String> both = first.zipWith(second, 
    (a, b) -> a + "+" + b);

both.subscribe(System.out::println);

published.connect();

ConnectableObservable requirements

• be thread safe when subscribing to it at any time and from any thread,
• allow synchronous unsubscription at any time and from any thread and
• be idempotent in respect of connect and disconnect (unsubscribe).

A basic implementation

public final class Multicast<T>
extends ConnectableObservable<T> {

    final Observable<T> source;
    final Subject<T, T> subject;

    final AtomicReference<Subscription> subscription;         // (1)

    public Multicast(Observable<T> source, 
            Subject<T, T> subject) {
        super(s -> {
            subject.subscribe(s);                             // (2)
        });
        this.source = source;
        this.subject = subject;
        this.subscription = new AtomicReference<>();
    }

    @Override
    public void connect(
        Action1<? super Subscription> connection) {
        // implement
    }
}

@Override
public void connect(Action1<? super Subscription> connection) {
    for (;;) {
        Subscription s = subscription.get();                   // (1)
        if (s != null) {
            connection.call(s);                                // (2)
            return;
        }

        Subscriber<T> subscriber = new Subscriber<T>() {       // (3)
            @Override
            public void onNext(T t) {
                subject.onNext(t);
            }

            @Override
            public void onError(Throwable e) {
                subject.onError(e);
            }

            @Override
            public void onCompleted() {
                subject.onCompleted();
            }
        };

        subscriber.add(Subscriptions.create(() -> {            // (4)
            subscription.set(null);
        }));

        if (subscription.compareAndSet(null, subscriber)) {    // (5)
            connection.call(subscriber);                       // (6)

            source.subscribe(subscriber);                      // (7)

            return;
        }
    }
}

    // ...
    @Override
    public void onError(Throwable e) {
        subject.onError(e);
        subscription.compareAndSet(this, null);
    }

    @Override
    public void onCompleted() {
        subject.onCompleted();
        subscription.compareAndSet(this, null);
    }
    // ...

subscriber.add(Subscriptions.create(() -> {
    subscription.compareAndSet(subscriber, null);
}));

static final class Connection<T> {
    Subject<T, T> subject;                           // (1)
    List<Subscriber<? super T>> subscribers;         // (2)
    boolean connect;                                 // (3)
    final SerialSubscription parent;                 // (4)

    public Connection() {
        this.subscribers = new ArrayList<>();
        this.parent = new SerialSubscription();
    }

    public void setSubject(Subject<T, T> subject) {  // (5)
        // implement

    }

    public void subscribe(Subscriber<? super T> s) { // (6)
        // implement
    }

    public boolean tryConnect() {                    // (7)
        // implement
    }
}

public void setSubject(Subject<T, T> subject) {
    List<Subscriber<? super T>> list;
    synchronized (this) {
        this.subject = subject;
        list = subscribers;
        subscribers = null;
    }
    for (Subscriber<? super T> s : list) {
        subject.subscribe(s);
    }
}

public void subscribe(Subscriber<? super T> s) {
    Subject<T, T> subject;
    synchronized (this) {
        subject = this.subject;
        if (subject == null) {
            subscribers.add(s);
            return;
        }
    }
    subject.subscribe(s);
}

public boolean tryConnect() {
   synchronized (this) {
        if (!connect) {
            connect = true;
            return true;
        }
        return false;
    }
}

public final class MulticastSupplier<T> 
extends ConnectableObservable<T> {
    public static <T> MulticastSupplier<T> create(        // (1)
            Observable<T> source, 
            Supplier<Subject<T, T>> subjectSupplier) {
        AtomicReference<Connection<T>> conn = 
            new AtomicReference<>(new Connection<>());    // (2)

        return new MulticastSupplier<>(
            source, subjectSupplier, conn);
    }



    final Observable<T> source;
    final Supplier<Subject<T, T>> subjectSupplier;
    final AtomicReference<Connection<T>> connection;      // (3)


    protected MulticastSupplier(Observable<T> source, 
            Supplier<Subject<T, T>> subjectSupplier,
            AtomicReference<Connection<T>> connection) {
        super(s -> {
            Connection<T> conn = connection.get();        // (4)
            conn.subscribe(s);
        });
        this.source = source;
        this.subjectSupplier = subjectSupplier;
        this.connection = connection; 
    }

    void replaceConnection(Connection<T> conn) {          // (5)
        Connection<T> next = new Connection<>();
        connection.compareAndSet(conn, next);
    }

    @Override
    public void connect(Action1<? super Subscription> connection) {
        // implement
    }
}

@Override
public void connect(
        Action1<? super Subscription> connection) {

    Connection<T> conn = this.connection.get();          // (1)

    if (conn.tryConnect()) {                             // (2)
        Subject<T, T> subject = subjectSupplier.get();

        Subscriber<T> parent = new Subscriber<T>() {     // (3)
            @Override
            public void onNext(T t) {
                subject.onNext(t);
            }

            @Override
            public void onError(Throwable e) {           // (4)
                subject.onError(e);
                replaceConnection(conn);
            }

            @Override
            public void onCompleted() {
                subject.onCompleted();
                replaceConnection(conn);
            }
        };

        conn.parent.set(parent);                         // (5)

        parent.add(Subscriptions.create(() -> {          // (6)
            replaceConnection(conn);
        }));

        conn.setSubject(subject);                        // (7)

        connection.call(conn.parent);                    // (8)

        source.subscribe(parent);                        // (9)
    } else {
        connection.call(conn.parent);                    // (10)
    }
}

1. First, we retrieve the current Connection object from the AtomicReference.
2. If not connected, set the state to connected and perform the connection logic, otherwise, go to (10).
3. Once we got a Subject, we create our wrapper Subscriber as before that references the Subject.
4. We'd like to disconnect eagerly once a terminal event has been received, therefore, we call replaceConnection() with the known connection object. Depending on what kind of races one wish to tolerate, you can swap the call on the subject with the replacement: this way, subscribers racing with the termination event will be added to the next connection instead of the current.
5. We then set the parent onto the connection. If there was a concurrent disconnect, this will unsubscribe the parent Subscriber immediately. Depending on how a connect-disconnect race should be handled, one can quit if isUnsubscribed() is true, don't even try to subscribe to the source but return a unsubscribed Subscription or retry the connection attempt. The latter requires a similar loop as in the basic example.
6. We set the unsubscribe action to replace the connection.
7. We set the subject on the current connection, which may trigger the early birds' subscription to the Subject.
8. Before the parent Subscriber is connected, we call the callback with the SerialSubscription (not the Subscriber!) to allow synchronous cancellation.
9. Then we subscribe the parent Subscriber to the source Observable.
10. If the tryConnect() returned false, we simply call the callback with the SerialSubscription of the current connection. Note here that this has to be non-null and thus the need of indirection around the parent Subscriber of (3).

Conclusion

Introduction

Implementation details

public Observable<T> autoConnect(int numConnections,
        Action1<Subscription> connection) {               // (1)
    if (numConnection == 0) {
        connect(connection);                              // (2)
        return this;
    }
    AtomicInteger count = new AtomicInteger();
    return create(s -> {
        unsafeSubscribe(s);                               // (3)
        if (count.incrementAndGet() == numConnections) {  // (4)
            connect(connection);
        }
    });
}

Conclusion