@Override public Disposable schedule(Runnable task, long delay, TimeUnit unit) { CachedService cached = pick(); return Schedulers.directSchedule(cached.exec, new DirectScheduleTask(task, cached), delay, unit); }
@Override public Disposable schedulePeriodically(Runnable task, long initialDelay, long period, TimeUnit unit) { return Schedulers.directSchedulePeriodically(pick(), task, initialDelay, period, unit); }
@Override public void dispose() { if (compareAndSet(false, true)) { parent.delete(this); } }
private Mono<Void> stopScheduler() { return Mono.fromRunnable(() -> { this.scheduler.dispose(); for (int i = 0; i < 20; i++) { if (this.scheduler.isDisposed()) { break; } try { Thread.sleep(100); } catch (Throwable ex) { break; } } }); }
@Override protected Publisher<Void> handle(Flux<InstanceEvent> publisher) { return publisher.subscribeOn(Schedulers.newSingle("info-updater")) .filter(event -> event instanceof InstanceEndpointsDetectedEvent || event instanceof InstanceStatusChangedEvent || event instanceof InstanceRegistrationUpdatedEvent) .flatMap(this::updateInfo); }
@Override public Worker createWorker() { return new BoundedWorker(actual.createWorker()); }
@Override public void cancel() { if (!cancelled) { cancelled = true; worker.dispose(); } } }
@Override public Object scanUnsafe(Attr key) { if (key == Attr.NAME) return parent.scanUnsafe(key); if (key == Attr.PARENT) return parent; if (key == Attr.TERMINATED || key == Attr.CANCELLED) return isDisposed(); if (key == Attr.CAPACITY) { //assume 1 if unknown, otherwise use the one from underlying executor Integer capacity = (Integer) Schedulers.scanExecutor(exec, key); if (capacity == null || capacity == -1) return 1; } return Schedulers.scanExecutor(exec, key); } }
@Override public Object scanUnsafe(Attr key) { if (key == Attr.TERMINATED || key == Attr.CANCELLED) return isDisposed(); if (key == Attr.NAME) return this.toString(); if (key == Attr.CAPACITY || key == Attr.BUFFERED) return 1; //BUFFERED: number of workers doesn't vary return Schedulers.scanExecutor(executor, key); }
@Override public Worker createWorker() { return trampoline ? new ExecutorSchedulerTrampolineWorker(executor) : new ExecutorSchedulerWorker(executor); }
@Override public Object scanUnsafe(Attr key) { if (key == Attr.TERMINATED || key == Attr.CANCELLED) return isDisposed(); if (key == Attr.NAME) return Schedulers.FROM_EXECUTOR_SERVICE + "(" + executor + ")"; return Schedulers.scanExecutor(executor, key); }
DelegateServiceScheduler(ExecutorService executorService) { ScheduledExecutorService exec = convert(executorService); this.executor = Schedulers.decorateExecutorService(this, exec); }
@Override public Disposable schedule(Runnable task, long delay, TimeUnit unit) { return Schedulers.directSchedule(pick(), task, delay, unit); }
@Override public Worker createWorker() { return new ExecutorServiceWorker(pick()); } }
@Override public Object scanUnsafe(Attr key) { if (key == Attr.TERMINATED || key == Attr.CANCELLED) return isDisposed(); if (key == Attr.NAME) return cached.scanUnsafe(key) + ".worker"; if (key == Attr.PARENT) return cached.parent; return cached.scanUnsafe(key); } }
@Override public Worker createWorker() { return new ElasticWorker(pick()); }
/** * {@link Scheduler} that hosts a fixed pool of single-threaded ExecutorService-based * workers and is suited for parallel work. * * @return default instance of a {@link Scheduler} that hosts a fixed pool of single-threaded * ExecutorService-based workers */ public static Scheduler parallel() { return cache(CACHED_PARALLEL, PARALLEL, PARALLEL_SUPPLIER); }
@Override protected Publisher<Void> handle(Flux<InstanceEvent> publisher) { return publisher.subscribeOn(Schedulers.newSingle("endpoint-detector")) .filter(event -> event instanceof InstanceStatusChangedEvent || event instanceof InstanceRegistrationUpdatedEvent) .flatMap(this::detectEndpoints); }
@Override public Disposable schedule(Runnable task) { CachedService cached = pick(); return Schedulers.directSchedule(cached.exec, new DirectScheduleTask(task, cached), 0L, TimeUnit.MILLISECONDS); }
@Override public Disposable schedule(Runnable task) { return Schedulers.directSchedule(pick(), task, 0L, TimeUnit.MILLISECONDS); }