@Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); timer.replace(scheduler.schedulePeriodicallyDirect(this, period, period, unit)); s.request(Long.MAX_VALUE); } }
@Test(expected = UnsupportedOperationException.class) public void scheduleDirectPeriodic() { ImmediateThinScheduler.INSTANCE.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 1, 1, TimeUnit.SECONDS); } @Test
@Override public void subscribeActual(Observer<? super Long> s) { IntervalObserver is = new IntervalObserver(s); s.onSubscribe(is); Disposable d = scheduler.schedulePeriodicallyDirect(is, initialDelay, period, unit); is.setResource(d); }
@Override public void subscribeActual(Observer<? super Long> s) { IntervalRangeObserver is = new IntervalRangeObserver(s, start, end); s.onSubscribe(is); Disposable d = scheduler.schedulePeriodicallyDirect(is, initialDelay, period, unit); is.setResource(d); }
@Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); Disposable d = scheduler.schedulePeriodicallyDirect(this, period, period, unit); DisposableHelper.replace(timer, d); } }
@Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); Disposable d = scheduler.schedulePeriodicallyDirect(this, period, period, unit); DisposableHelper.replace(timer, d); } }
@Override public void subscribeActual(Subscriber<? super Long> s) { IntervalRangeSubscriber is = new IntervalRangeSubscriber(s, start, end); s.onSubscribe(is); Scheduler sch = scheduler; if (sch instanceof TrampolineScheduler) { Worker worker = sch.createWorker(); is.setResource(worker); worker.schedulePeriodically(is, initialDelay, period, unit); } else { Disposable d = sch.schedulePeriodicallyDirect(is, initialDelay, period, unit); is.setResource(d); } }
@Override public void subscribeActual(Subscriber<? super Long> s) { IntervalSubscriber is = new IntervalSubscriber(s); s.onSubscribe(is); Scheduler sch = scheduler; if (sch instanceof TrampolineScheduler) { Worker worker = sch.createWorker(); is.setResource(worker); worker.schedulePeriodically(is, initialDelay, period, unit); } else { Disposable d = sch.schedulePeriodicallyDirect(is, initialDelay, period, unit); is.setResource(d); } }
@NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { if (executor instanceof ScheduledExecutorService) { Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); try { ScheduledDirectPeriodicTask task = new ScheduledDirectPeriodicTask(decoratedRun); Future<?> f = ((ScheduledExecutorService)executor).scheduleAtFixedRate(task, initialDelay, period, unit); task.setFuture(f); return task; } catch (RejectedExecutionException ex) { RxJavaCommonPlugins.onError(ex); return REJECTED; } } return super.schedulePeriodicallyDirect(run, initialDelay, period, unit); } /* public: test support. */
@NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { if (executor instanceof ScheduledExecutorService) { Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); try { ScheduledDirectPeriodicTask task = new ScheduledDirectPeriodicTask(decoratedRun); Future<?> f = ((ScheduledExecutorService)executor).scheduleAtFixedRate(task, initialDelay, period, unit); task.setFuture(f); return task; } catch (RejectedExecutionException ex) { RxJavaCommonPlugins.onError(ex); return REJECTED; } } return super.schedulePeriodicallyDirect(run, initialDelay, period, unit); } /* public: test support. */
@Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; window = UnicastSubject.<T>create(bufferSize); Observer<? super Observable<T>> a = actual; a.onSubscribe(this); a.onNext(window); if (!cancelled) { Disposable d = scheduler.schedulePeriodicallyDirect(this, timespan, timespan, unit); DisposableHelper.replace(timer, d); } } }
@NonNull @Override public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) { if (executor instanceof ScheduledExecutorService) { Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); try { ScheduledDirectPeriodicTask task = new ScheduledDirectPeriodicTask(decoratedRun); Future<?> f = ((ScheduledExecutorService)executor).scheduleAtFixedRate(task, initialDelay, period, unit); task.setFuture(f); return task; } catch (RejectedExecutionException ex) { RxJavaCommonPlugins.onError(ex); return REJECTED; } } return super.schedulePeriodicallyDirect(run, initialDelay, period, unit); } /* public: test support. */
@Test public void periodicDirectTaskRaceIO() throws Exception { final Scheduler scheduler = Schedulers.io(); for (int i = 0; i < 100; i++) { final Disposable d = scheduler.schedulePeriodicallyDirect( Functions.EMPTY_RUNNABLE, 0, 0, TimeUnit.MILLISECONDS); Thread.sleep(1); d.dispose(); } }
@Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; window = UnicastSubject.<T>create(bufferSize); Observer<? super Observable<T>> a = actual; a.onSubscribe(this); a.onNext(window); if (!cancelled) { Disposable d = scheduler.schedulePeriodicallyDirect(this, timespan, timespan, unit); DisposableHelper.replace(timer, d); } } }
@Override public void subscribeActual(Observer<? super Long> s) { IntervalRangeObserver is = new IntervalRangeObserver(s, start, end); s.onSubscribe(is); Scheduler sch = scheduler; if (sch instanceof TrampolineScheduler) { Worker worker = sch.createWorker(); is.setResource(worker); worker.schedulePeriodically(is, initialDelay, period, unit); } else { Disposable d = sch.schedulePeriodicallyDirect(is, initialDelay, period, unit); is.setResource(d); } }
@Override public void subscribeActual(Observer<? super Long> s) { IntervalObserver is = new IntervalObserver(s); s.onSubscribe(is); Scheduler sch = scheduler; if (sch instanceof TrampolineScheduler) { Worker worker = sch.createWorker(); is.setResource(worker); worker.schedulePeriodically(is, initialDelay, period, unit); } else { Disposable d = sch.schedulePeriodicallyDirect(is, initialDelay, period, unit); is.setResource(d); } }
@Test(timeout = 10000) public void schedulePeriodicallyDirectZeroPeriod() throws Exception { Scheduler s = Schedulers.single(); for (int initial = 0; initial < 2; initial++) { final CountDownLatch cdl = new CountDownLatch(1); final SequentialDisposable sd = new SequentialDisposable(); try { sd.replace(s.schedulePeriodicallyDirect(new Runnable() { int count; @Override public void run() { if (++count == 10) { sd.dispose(); cdl.countDown(); } } }, initial, 0, TimeUnit.MILLISECONDS)); assertTrue("" + initial, cdl.await(5, TimeUnit.SECONDS)); } finally { sd.dispose(); } } }
@Test(timeout = 7000) public void scheduleDirectPeriodic() throws Exception { Scheduler s = getScheduler(); if (s instanceof TrampolineScheduler) { // can't properly stop a trampolined periodic task return; } final CountDownLatch cdl = new CountDownLatch(5); Disposable d = s.schedulePeriodicallyDirect(new Runnable() { @Override public void run() { cdl.countDown(); } }, 10, 10, TimeUnit.MILLISECONDS); try { assertTrue(cdl.await(5, TimeUnit.SECONDS)); } finally { d.dispose(); } assertTrue(d.isDisposed()); }
@Test public void rejectingExecutor() { ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor(); exec.shutdown(); Scheduler s = Schedulers.from(exec); List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { assertSame(Scheduler.REJECTED, s.scheduleDirect(Functions.EMPTY_RUNNABLE)); assertSame(Scheduler.REJECTED, s.scheduleDirect(Functions.EMPTY_RUNNABLE, 10, TimeUnit.MILLISECONDS)); assertSame(Scheduler.REJECTED, s.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 10, 10, TimeUnit.MILLISECONDS)); TestCommonHelper.assertUndeliverable(errors, 0, RejectedExecutionException.class); TestCommonHelper.assertUndeliverable(errors, 1, RejectedExecutionException.class); TestCommonHelper.assertUndeliverable(errors, 2, RejectedExecutionException.class); } finally { RxJavaCommonPlugins.reset(); } }
@Test public void rejectingExecutor() { ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor(); exec.shutdown(); Scheduler s = Schedulers.from(exec); List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { assertSame(Scheduler.REJECTED, s.scheduleDirect(Functions.EMPTY_RUNNABLE)); assertSame(Scheduler.REJECTED, s.scheduleDirect(Functions.EMPTY_RUNNABLE, 10, TimeUnit.MILLISECONDS)); assertSame(Scheduler.REJECTED, s.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 10, 10, TimeUnit.MILLISECONDS)); TestCommonHelper.assertUndeliverable(errors, 0, RejectedExecutionException.class); TestCommonHelper.assertUndeliverable(errors, 1, RejectedExecutionException.class); TestCommonHelper.assertUndeliverable(errors, 2, RejectedExecutionException.class); } finally { RxJavaCommonPlugins.reset(); } }