Java Code Examples for reactor.core.scheduler.Scheduler#Worker

@Test
  public void scanIntervalRunnable() {
Scheduler.Worker worker = Schedulers.single().createWorker();

try {
      CoreSubscriber<Long> actual = new LambdaSubscriber<>(null, e -> {}, null, null);
      FluxInterval.IntervalRunnable test = new FluxInterval.IntervalRunnable(actual, worker);

      assertThat(test.scan(Scannable.Attr.RUN_ON)).isSameAs(worker);
      assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(actual);
      assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse();
      test.cancel();
      assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue();
}
finally {
	worker.dispose();
}
  }
 

@Override
public CoreSubscriber<? super T> subscribeOrReturn(CoreSubscriber<? super T> actual) {
	Scheduler.Worker worker = scheduler.createWorker();

	SubscribeOnSubscriber<T> parent = new SubscribeOnSubscriber<>(source,
			actual, worker);
	actual.onSubscribe(parent);

	try {
		worker.schedule(parent);
	}
	catch (RejectedExecutionException ree) {
		if (parent.s != Operators.cancelledSubscription()) {
			actual.onError(Operators.onRejectedExecution(ree, parent, null, null,
					actual.currentContext()));
		}
	}
	return null;
}
 

@Test
public void externalGetOrSetTakenIntoAccount() {
	Scheduler.Worker subscriptionWorker = VirtualTimeScheduler.getOrSet().createWorker();
	List<String> source = Stream.of("first", "second", "third").collect(Collectors.toList());


	StepVerifier.withVirtualTime(() -> {
		FluxIdentityProcessor<String> fluxEmitter = Processors.multicast();

		subscriptionWorker.schedulePeriodically(() -> {
			if (source.size() > 0) {
				fluxEmitter.onNext(source.remove(0));
			}
			else {
				fluxEmitter.onComplete();
			}
		}, 0, 10, TimeUnit.MILLISECONDS);
		return fluxEmitter;
	})
	            .expectNext("first")
	            .expectNoEvent(Duration.ofMillis(10))
	            .expectNext("second")
	            .expectNoEvent(Duration.ofMillis(10))
	            .expectNext("third")
	            .expectNoEvent(Duration.ofMillis(10))
	            .expectComplete()
	            .verify(Duration.ofSeconds(2));
}
 

@Test
public void scanSubscribeOnSubscriber() {
	Scheduler.Worker worker = Schedulers.single().createWorker();

	try {
		final Flux<String> source = Flux.just("foo");
		CoreSubscriber<String>
				actual = new LambdaMonoSubscriber<>(null, e -> {}, null, null);
		MonoSubscribeOn.SubscribeOnSubscriber<String> test = new MonoSubscribeOn.SubscribeOnSubscriber<>(
				source, actual, worker);
		Subscription parent = Operators.emptySubscription();
		test.onSubscribe(parent);

		test.requested = 3L;
		assertThat(test.scan(Scannable.Attr.REQUESTED_FROM_DOWNSTREAM)).isEqualTo(3L);

		assertThat(test.scan(Scannable.Attr.RUN_ON)).isSameAs(worker);
		assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(parent);
		assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(actual);

		assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse();
		test.cancel();
		assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue();
	}
	finally {
		worker.dispose();
	}
}
 

@Test
public void scanSubscriber() {
	CoreSubscriber<List<String>> actual = new LambdaSubscriber<>(null, e -> {}, null, null);

	final Scheduler.Worker worker = Schedulers.boundedElastic()
	                                          .createWorker();
	FluxBufferTimeout.BufferTimeoutSubscriber<String, List<String>> test = new FluxBufferTimeout.BufferTimeoutSubscriber<String, List<String>>(
					actual, 123, 1000, TimeUnit.MILLISECONDS,
			worker, ArrayList::new);

	try {
		Subscription subscription = Operators.emptySubscription();
		test.onSubscribe(subscription);

		test.requested = 3L;
		test.index = 100;

		assertThat(test.scan(Scannable.Attr.RUN_ON)).isSameAs(worker);
		assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(subscription);
		assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(actual);

		assertThat(test.scan(Scannable.Attr.REQUESTED_FROM_DOWNSTREAM)).isEqualTo(3L);
		assertThat(test.scan(Scannable.Attr.CAPACITY)).isEqualTo(123);
		assertThat(test.scan(Scannable.Attr.BUFFERED)).isEqualTo(23);

		assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse();
		assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse();

		test.onError(new IllegalStateException("boom"));
		assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse();
		assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue();
	}
	finally {
		worker.dispose();
	}
}
 

@Test
public void scanSubscriber() {
	Scheduler.Worker worker = Schedulers.immediate().createWorker();

	CoreSubscriber<String> actual = new LambdaSubscriber<>(null, null, null, null);
	Subscription s = Operators.emptySubscription();

	FluxDelaySequence.DelaySubscriber test = new DelaySubscriber<>(actual, Duration.ofSeconds(1), worker);

	test.onSubscribe(s);

	assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(s);
	SerializedSubscriber serializedSubscriber = (SerializedSubscriber) test.scan(Scannable.Attr.ACTUAL);
	assertThat(serializedSubscriber)
			.isNotNull()
			.satisfies(ser -> assertThat(ser.actual).isSameAs(actual));

	assertThat(test.scan(Scannable.Attr.RUN_ON)).isEqualTo(worker);

	assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse();
	assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse();

	test.cancel();
	assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse();
	assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue();

	test.done = true;
	assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue();
}
 

BufferTimeoutSubscriber(CoreSubscriber<? super C> actual,
		int maxSize,
		long timespan,
		TimeUnit unit,
		Scheduler.Worker timer,
		Supplier<C> bufferSupplier) {
	this.actual = actual;
	this.timespan = timespan;
	this.unit = unit;
	this.timer = timer;
	this.flushTask = () -> {
		if (terminated == NOT_TERMINATED) {
			int index;
			for(;;){
				index = this.index;
				if(index == 0){
					return;
				}
				if(INDEX.compareAndSet(this, index, 0)){
					break;
				}
			}
			flushCallback(null);
		}
	};

	this.batchSize = maxSize;
	this.bufferSupplier = bufferSupplier;
}
 

DelaySubscriber(CoreSubscriber<? super T> actual, Duration delay, Scheduler.Worker w) {
	super();
	this.actual = new SerializedSubscriber<>(actual);
	this.w = w;
	this.delay = delay.toNanos();
	this.timeUnit = TimeUnit.NANOSECONDS;
}
 

private static <T> void timer(Supplier<T> action, Scheduler.Worker worker, Duration delay, MonoSink<T> sink) {
    worker.schedule(() -> {
        try {
            T result = action.get();
            if (result != null) {
                sink.success(result);
            } else {
                sink.success();
            }
        } catch (Exception e) {
            sink.error(e);
        }
    }, delay.toMillis(), TimeUnit.MILLISECONDS);
}
 

static <T> Mono<T> timer(Supplier<T> action, Scheduler.Worker worker, Duration delay) {
    if (worker.isDisposed()) {
        return Mono.empty();
    }

    return Mono.create(sink -> {
        if (worker.isDisposed()) {
            sink.success();
        } else {
            timer(action, worker, delay, sink);
        }
    });
}
 

/**
 * Runs an action on the provided worker.
 */
public static <T> Mono<T> onWorker(Supplier<T> action, Scheduler.Worker worker) {
    return TimerWithWorker.timer(action, worker, Duration.ZERO);
}
 

@Override
public CoreSubscriber<? super T> subscribeOrReturn(CoreSubscriber<? super T> actual) {
	Scheduler.Worker w = scheduler.createWorker();

	return new DelaySubscriber<T>(actual, delay, w);
}
 

@Override
public Scheduler.Worker createWorker() {
  return this.worker;
}
 

static Mono<Void> timer(Runnable action, Scheduler.Worker worker, Duration delay) {
    return timer(() -> {
        action.run();
        return null;
    }, worker, delay);
}
 

/**
 * Runs an action on the provided worker with the provided delay.
 */
public static Mono<Void> onWorker(Runnable action, Scheduler.Worker worker, Duration delay) {
    return TimerWithWorker.timer(action, worker, delay);
}
 

/**
 * Runs an action on the provided worker.
 */
public static Mono<Void> onWorker(Runnable action, Scheduler.Worker worker) {
    return TimerWithWorker.timer(action, worker, Duration.ZERO);
}
 

/**
 * Runs an action on the provided worker with the provided delay.
 */
public static <T> Mono<T> onWorker(Supplier<T> action, Scheduler.Worker worker, Duration delay) {
    return TimerWithWorker.timer(action, worker, delay);
}