@Override public Disposable schedule(Runnable task, long delay, TimeUnit unit) { return cached.schedule(task, delay, unit); }
@Test public void scheduledDoesntReject() { Scheduler s = Schedulers.fromExecutorService(Executors.newSingleThreadScheduledExecutor()); assertThat(s.schedule(() -> {}, 100, TimeUnit.MILLISECONDS)) .describedAs("direct delayed scheduling") .isNotNull(); assertThat(s.schedulePeriodically(() -> {}, 100, 100, TimeUnit.MILLISECONDS)) .describedAs("direct periodic scheduling") .isNotNull(); Worker w = s.createWorker(); assertThat(w.schedule(() -> {}, 100, TimeUnit.MILLISECONDS)) .describedAs("worker delayed scheduling") .isNotNull(); assertThat(w.schedulePeriodically(() -> {}, 100, 100, TimeUnit.MILLISECONDS)) .describedAs("worker periodic scheduling") .isNotNull(); }
@Override public Disposable schedule(Runnable task) { return cached.schedule(task); }
@Test public void scheduledDoesntReject() { Scheduler s = scheduler(); assertThat(s.schedule(() -> {}, 100, TimeUnit.MILLISECONDS)) .describedAs("direct delayed scheduling") .isNotNull(); assertThat(s.schedulePeriodically(() -> {}, 100, 100, TimeUnit.MILLISECONDS)) .describedAs("direct periodic scheduling") .isNotNull(); Scheduler.Worker w = s.createWorker(); assertThat(w.schedule(() -> {}, 100, TimeUnit.MILLISECONDS)) .describedAs("worker delayed scheduling") .isNotNull(); assertThat(w.schedulePeriodically(() -> {}, 100, 100, TimeUnit.MILLISECONDS)) .describedAs("worker periodic scheduling") .isNotNull(); }
@Override public void cancel() { if (CANCELLED.compareAndSet(this, 0, 1)) { try { scheduler.schedule(this); } catch (RejectedExecutionException ree) { throw Operators.onRejectedExecution(ree, actual.currentContext()); } } } }
@Test public void scheduledDoesntReject() { Scheduler s = scheduler(); assertThat(s.schedule(() -> {}, 100, TimeUnit.MILLISECONDS)) .describedAs("direct delayed scheduling") .isNotNull(); assertThat(s.schedulePeriodically(() -> {}, 100, 100, TimeUnit.MILLISECONDS)) .describedAs("direct periodic scheduling") .isNotNull(); Scheduler.Worker w = s.createWorker(); assertThat(w.schedule(() -> {}, 100, TimeUnit.MILLISECONDS)) .describedAs("worker delayed scheduling") .isNotNull(); assertThat(w.schedulePeriodically(() -> {}, 100, 100, TimeUnit.MILLISECONDS)) .describedAs("worker periodic scheduling") .isNotNull(); }
@Override public Disposable schedule(Runnable task) { if (tasksRemaining.decrementAndGet() < 0) throw new RejectedExecutionException("BoundedScheduler schedule: no more tasks"); return actual.schedule(task); }
@Override public Disposable schedule(Runnable task, long delay, TimeUnit unit) { if (tasksRemaining.decrementAndGet() < 0) throw new RejectedExecutionException("BoundedScheduler schedule with delay: no more tasks"); return actual.schedule(task, delay, unit); }
@Test public void authentiateWhenCustomSchedulerThenUsed() { when(this.userDetailsService.findByUsername(any())).thenReturn(Mono.just(this.user)); when(this.encoder.matches(any(), any())).thenReturn(true); this.manager.setScheduler(this.scheduler); this.manager.setPasswordEncoder(this.encoder); UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken( this.user, this.user.getPassword()); Authentication result = this.manager.authenticate(token).block(); verify(this.scheduler).schedule(any()); }
@Override public void onSubscribe(Subscription s) { Schedulers.single().schedule(() -> finish(s), 5000, TimeUnit.MILLISECONDS); s.request(Long.MAX_VALUE); }
@Override public void onNext(Integer t) { super.onNext(t); Schedulers.single().schedule(() -> { if (sync.decrementAndGet() != 0) { while (sync.get() != 0) { } } cancel(); cdl.countDown(); }); if (sync.decrementAndGet() != 0) { while (sync.get() != 0) { } } } };
@Override public void onNext(Integer t) { super.onNext(t); Schedulers.single().schedule(() -> { if (sync.decrementAndGet() != 0) { while (sync.get() != 0) { } } cancel(); cdl.countDown(); }); if (sync.decrementAndGet() != 0) { while (sync.get() != 0) { } } } };
@Override public void onNext(T t) { if (done) { Operators.onNextDropped(t, actual.currentContext()); return; } this.done = true; try { this.task = scheduler.schedule(() -> complete(t), delay, unit); } catch (RejectedExecutionException ree) { throw Operators.onRejectedExecution(ree, this, null, t, actual.currentContext()); } }
@Override public void subscribe(CoreSubscriber<? super Long> actual) { MonoDelayRunnable r = new MonoDelayRunnable(actual); actual.onSubscribe(r); try { r.setCancel(timedScheduler.schedule(r, delay, unit)); } catch (RejectedExecutionException ree) { if(r.cancel != OperatorDisposables.DISPOSED) { actual.onError(Operators.onRejectedExecution(ree, r, null, null, actual.currentContext())); } } }
@Override public void subscribe(CoreSubscriber<? super T> actual) { FluxSubscribeOnCallable.CallableSubscribeOnSubscription<T> parent = new FluxSubscribeOnCallable.CallableSubscribeOnSubscription<>(actual, callable, scheduler); actual.onSubscribe(parent); try { parent.setMainFuture(scheduler.schedule(parent)); } catch (RejectedExecutionException ree) { if(parent.state != FluxSubscribeOnCallable.CallableSubscribeOnSubscription.HAS_CANCELLED) { actual.onError(Operators.onRejectedExecution(ree, actual.currentContext())); } } }
@Override public void subscribe(CoreSubscriber<? super T> actual) { CallableSubscribeOnSubscription<T> parent = new CallableSubscribeOnSubscription<>(actual, callable, scheduler); actual.onSubscribe(parent); try { Disposable f = scheduler.schedule(parent); parent.setMainFuture(f); } catch (RejectedExecutionException ree) { if(parent.state != CallableSubscribeOnSubscription.HAS_CANCELLED) { actual.onError(Operators.onRejectedExecution(ree, actual.currentContext())); } } }
void trySchedule( @Nullable Subscription subscription, @Nullable Throwable suppressed, @Nullable Object dataSignal) { if(future != null){ return; } try { future = this.scheduler.schedule(this); } catch (RejectedExecutionException ree) { actual.onError(Operators.onRejectedExecution(ree, subscription, suppressed, dataSignal, actual.currentContext())); } }
@Test public void scanExecutorAttributes() { Scheduler fixedThreadPool = Schedulers.fromExecutorService(Executors.newFixedThreadPool(3)); Long test = Integer.MAX_VALUE + 1L; System.out.println(test.intValue() == Integer.MAX_VALUE); assertThat(Scannable.from(fixedThreadPool).scan(Scannable.Attr.CAPACITY)).isEqualTo(3); assertThat(Scannable.from(fixedThreadPool).scan(Scannable.Attr.BUFFERED)).isZero(); assertThat(Scannable.from(fixedThreadPool).scan(Scannable.Attr.LARGE_BUFFERED)).isZero(); fixedThreadPool.schedule(() -> { assertThat(Scannable.from(fixedThreadPool).scan(Scannable.Attr.BUFFERED)).isNotZero(); assertThat(Scannable.from(fixedThreadPool).scan(Scannable.Attr.LARGE_BUFFERED)).isNotZero(); }); } }
@Test public void schedulersInstrumentation() { try { assertThatCode(() -> { Schedulers.enableMetrics(); Scheduler s = Schedulers.newSingle("foo"); Schedulers.decorateExecutorService(s, Executors.newSingleThreadScheduledExecutor()); s.schedule(() -> System.out.println("schedulers instrumentation no micrometer")); }) .doesNotThrowAnyException(); } finally { Schedulers.disableMetrics(); } }