There is no way to cancel this schedule. I have a somewhat contrived example to demonstrate:

```java
public class SubscribeOnTest {
    static class DelayingScheduler extends Scheduler {
        final Scheduler actual;
        final long delay;
        final TimeUnit unit;

        public DelayingScheduler(Scheduler actual, long delay, TimeUnit unit) {
            this.actual = actual;
            this.delay = delay;
            this.unit = unit;
        }

        @Override
        public Subscription schedule(Action1<Inner> action) {
            MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
            mas.set(actual.schedule(i -> {
                mas.set(actual.schedule(action, delay, unit));
            }));
            return mas;
        }

        @Override
        public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit delayUnit) {
            MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
            mas.set(actual.schedule(i -> {
                long nanos = unit.toNanos(delay) + delayUnit.toNanos(delayTime);
                mas.set(actual.schedule(action, nanos, TimeUnit.NANOSECONDS));
            }));
            return mas;
        }
    }
    public static void main(String[] args) throws Exception {
        
        Subscriber<Integer> sb = Subscribers.create(System.out::println, Throwable::printStackTrace, () -> System.out.println("Done"));

        sb.unsubscribe();
        
        Observable.from(1)
                .subscribeOn(new DelayingScheduler(Schedulers.computation(), 2, TimeUnit.SECONDS))
                .subscribe(sb);
        
    }
}
```

As for the ```testNewSubscriberDoesntBlockExisting```, it deadlocks because observer2 onNext awaits for the ```makeSlow``` latch which can't be released as the main thread is blocked on L315.

Worse thing is that the subscribeOn changes made most Async code synchronous and tests fail accordingly.

This won't complete until the delayed subscription happens. 

In addition, unsubscription doesn't happen on the inner scheduler at all; was this intentional?

See some of the fixes in #850