Java Schedulers类代码示例

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
@Override
public Flux<Employee> readEmployeesByDescAge() {
	Scheduler subWorker = Schedulers.newSingle("sub-thread");
	Scheduler pubWorker = Schedulers.newSingle("pub-thread");
	Supplier<Flux<Employee>> deferredTask = ()->{
		System.out.println("flux:defer task executor: "+ Thread.currentThread().getName());
		System.out.println("flux:defer task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		return Flux.fromIterable(employeeDaoImpl.getEmployees());
	};
	Comparator<Employee> descAge = (e1, e2) -> {
		System.out.println("flux:sort task executor: " + Thread.currentThread().getName());
		System.out.println("flux:sort task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		if(e1.getAge().compareTo(e2.getAge()) == 0){
			return 0;
		} else if(e1.getAge().compareTo(e2.getAge()) > 0){
			return -1;
		} else return 1;
	};
	Flux<Employee> deferred = Flux.defer(deferredTask).sort(descAge).subscribeOn(subWorker).publishOn(pubWorker);
	return deferred;
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
@Test
public void blockingToReactive() {

	Callable<String> takesAWhile = () -> {
		Thread.sleep(2000);
		return "Mike";
	};

	Mono<String> naive = Mono.fromCallable(takesAWhile).publishOn(Schedulers.elastic())
			.doOnSubscribe(it -> System.out.println(Thread.currentThread().getName() + ": Subscribe"))
			.doOnSuccess(it -> System.out.println(Thread.currentThread().getName() + ": Success"));

	System.out.println("Before subscribe");
	naive.subscribeOn(Schedulers.parallel()).block();
	System.out.println("After subscribe");
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
public static void main(String[] args) {
  Mono<Integer> mono = Mono.just(2)
      .log()
      .publishOn(Schedulers.parallel())
      .log()
      .map(i -> i * 2)
      .log()
      .publishOn(Schedulers.parallel())
      .log()
      .map(i -> i - 2)
      .log();

  mono.block();
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
public static void main(String[] args) {
  Flux<LocalDateTime> flux = Flux.<LocalDateTime>create(e -> {
    Schedulers.newSingle("brc", true)
        .schedulePeriodically(
            () -> {
              LOGGER.info("calculating...");
              e.next(LocalDateTime.now(ZoneOffset.UTC));
            },
            0, 100, TimeUnit.MILLISECONDS);
  }, OverflowStrategy.LATEST).cache(1);

  flux.blockFirst();

  while (true) {
    LOGGER.info("{}", flux.blockFirst(Duration.ofMillis(0)));
    Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
  }
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
@Override
public Flux<Employee> readEmployeesFlux(int age) {
	Scheduler subWorker = Schedulers.newSingle("sub-thread");
	Scheduler pubWorker = Schedulers.newSingle("pub-thread");
	Predicate<Employee> validAge = (e) -> {
		System.out.println("flux:filter task executor: " + Thread.currentThread().getName());
		System.out.println("flux:filter task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		return e.getAge() > age;
	};
	Supplier<Flux<Employee>> deferredTask = ()->{
		System.out.println("flux:defer task executor: " + Thread.currentThread().getName());
		System.out.println("flux:defer task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		return Flux.fromIterable(employeeDaoImpl.getEmployees());
	};
	Flux<Employee> deferred = Flux.defer(deferredTask).filter(validAge).subscribeOn(subWorker).publishOn(pubWorker);
	return deferred;
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
@Override
public Flux<Employee> readEmployeesByAscLastName() {
	Scheduler subWorker = Schedulers.newSingle("sub-thread");
	Scheduler pubWorker = Schedulers.newSingle("pub-thread");
	Supplier<Flux<Employee>> deferredTask = ()->{
		System.out.println("flux:defer task executor: " + Thread.currentThread().getName());
		System.out.println("flux:defer task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		return Flux.fromIterable(employeeDaoImpl.getEmployees());
	};
	Comparator<Employee> descLName = (e1, e2) -> {
		System.out.println("flux:sort task executor: " + Thread.currentThread().getName());
		System.out.println("flux:sort task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		return e1.getLastName().compareTo(e2.getLastName());
	};
	Flux<Employee> deferred = Flux.defer(deferredTask).sort(descLName).subscribeOn(subWorker).publishOn(pubWorker);
	return deferred;
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
@Override
public Flux<String> repeatExecs() {
	Function<Employee, String> names = (emp) ->{
		System.out.println("flatMap thread: " + Thread.currentThread().getName());
		return emp.getFirstName().charAt(0) + emp.getLastName();
	};
	
	Flux<String> parallelEmpFlux = Flux.fromIterable(employeeDaoImpl.getEmployees())
       .repeat(2)
	.parallel(8) 
       .runOn (Schedulers.parallel())
       .sequential()
       .map(names)
       .doOnSubscribe(subscription ->
       {
           subscription.request(2);
           System.out.println(subscription);
       });
       
	return parallelEmpFlux;
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
/**
 * Creates a new subscriber which receives {@link Serializable} data and emits it on a websocket.
 *
 * @param writer The writer for serializing received Serializables
 * @param uri    The URI  of the websocket (eg. '/route').
 * @param port   The port of the websocket (eg. 1337).
 */
public WebSocketSubscriber(
    final Function<T, String> writer,
    final String uri,
    final int port) {
  this.writer = writer;
  HttpServer.create(port)
      .newHandler((in, out) ->
          in.uri().equals(uri)
              ? out.sendWebsocket((inboundWebsocket, outboundWebsocket) ->
              outboundWebsocket
                  .options(NettyPipeline.SendOptions::flushOnEach)
                  .sendString(this.outputPublisher))
              : out.sendNotFound())
      .subscribeOn(Schedulers.single())
      .subscribe();
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
public Mono<Boolean> decide(Authentication authentication, Object object, Flux<ConfigAttribute> configAttributes) {
	return Mono
		.just(Tuples.of(authentication, object, configAttributes))
		.publishOn(Schedulers.elastic())
		.filter((Tuple3<Authentication, Object, Flux<ConfigAttribute>> t) -> {
			Authentication auth = t.getT1();
			return auth != null && auth.isAuthenticated();
		})
		.then((Function<Tuple3<Authentication, Object, Flux<ConfigAttribute>>, Mono<Boolean>>) t -> {
			List<ConfigAttribute> attrs = new ArrayList<>();
			t.getT3().toIterable().forEach(attrs::add);

			try {
				accessDecisionManager.decide(t.getT1(), t.getT2(), attrs);
				return Mono.just(true);
			} catch(AccessDeniedException fail) {
				return Mono.just(false);
			}
		});
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
public Mono<Boolean> decide(Authentication authentication, Object object, Flux<ConfigAttribute> configAttributes) {
	return Mono
		.just(Tuples.of(authentication, object, configAttributes))
		.publishOn(Schedulers.elastic())
		.filter((Tuple3<Authentication, Object, Flux<ConfigAttribute>> t) -> {
			Authentication auth = t.getT1();
			return auth != null && auth.isAuthenticated();
		})
		.flatMap((Function<Tuple3<Authentication, Object, Flux<ConfigAttribute>>, Mono<Boolean>>) t -> {
			List<ConfigAttribute> attrs = new ArrayList<>();
			t.getT3().toIterable().forEach(attrs::add);

			try {
				accessDecisionManager.decide(t.getT1(), t.getT2(), attrs);
				return Mono.just(true);
			} catch(AccessDeniedException fail) {
				return Mono.just(false);
			}
		});
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
@Override
public void start() {
	if(this.concurrency == null){
		// We are assuming Brian Goetz (http://www.ibm.com/developerworks/java/library/j-jtp0730/index.html) cores * 1 + (1 + wait/service) and that http wait is taking 2x more than service
		this.concurrency = Runtime.getRuntime().availableProcessors() * 3;
	}
	this.processorCancellation = processor.groupBy(PubSubMessage::getTopic)
			.flatMap(group -> group.map(pubSubMessage -> {
				return pubSubMessage.getMessage();
			}).buffer(producerProperties.getExtension().getBatchSize(), Duration.ofMillis(producerProperties.getExtension().getWindowSize())).map(messages -> {
				return new GroupedMessage(group.key(), messages);
			})).parallel(concurrency).runOn(Schedulers.elastic()).doOnNext(groupedMessage -> {
				logger.info("Dispatching messages");
				resourceManager.publishMessages(groupedMessage);
			}).sequential().publishOn(Schedulers.elastic()).subscribe();
	running = true;
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
/**
 * Query async.
 *
 * @param array the array
 * @param query the query
 * @return the observable
 */
private Flux<JsonElement> queryAsync(JsonArray array, JsonObject query) {
  return Flux.fromIterable(array)
      .publishOn(Schedulers.elastic())
      .filter(json -> filter(json, query.get("where")))
      .compose(
          obs -> {
            Long limit = jsonLever.asLong(query.get("limit"), 0L);
            return limit > 0 ? obs.take(limit.intValue()) : obs;
          })
      .publishOn(Schedulers.elastic())
      .compose(
          obs ->
              StringUtils.equals(jsonLever.getString(query, "select"), "count")
                  ? obs.count().map(count -> new JsonPrimitive(count))
                  : obs.map(json -> select(json, query.get("select"))));
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
@Test
public void scanMainSubscriber() {
    CoreSubscriber<Integer> actual = new LambdaSubscriber<>(null, e -> {}, null, null);
    FluxSubscribeOnValue.ScheduledScalar<Integer> test =
    		new FluxSubscribeOnValue.ScheduledScalar<Integer>(actual, 1, Schedulers.single());

    assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(actual);
    assertThat(test.scan(Scannable.Attr.BUFFERED)).isEqualTo(1);

    assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse();
    test.future = FluxSubscribeOnValue.ScheduledScalar.FINISHED;
    assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue();

    assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse();
    test.future = OperatorDisposables.DISPOSED;
    assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue();
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
@Test
public void allEnabled() {
	Assert.assertFalse(Schedulers.newParallel("") instanceof VirtualTimeScheduler);
	Assert.assertFalse(Schedulers.newElastic("") instanceof VirtualTimeScheduler);
	Assert.assertFalse(Schedulers.newSingle("") instanceof VirtualTimeScheduler);

	VirtualTimeScheduler.getOrSet();

	Assert.assertTrue(Schedulers.newParallel("") instanceof VirtualTimeScheduler);
	Assert.assertTrue(Schedulers.newElastic("") instanceof VirtualTimeScheduler);
	Assert.assertTrue(Schedulers.newSingle("") instanceof VirtualTimeScheduler);

	VirtualTimeScheduler t = VirtualTimeScheduler.get();

	Assert.assertSame(Schedulers.newParallel(""), t);
	Assert.assertSame(Schedulers.newElastic(""), t);
	Assert.assertSame(Schedulers.newSingle(""), t);
}
 

import reactor.core.scheduler.Schedulers; //导入依赖的package包/类
@Test
public void assertNextWithSubscribeOnDirectProcessor() {
	Scheduler scheduler = Schedulers.newElastic("test");
	DirectProcessor<Integer> processor = DirectProcessor.create();
	Mono<Integer> doAction = Mono.fromSupplier(() -> 22)
	                             .doOnNext(processor::onNext)
	                             .subscribeOn(scheduler);

	assertThatExceptionOfType(AssertionError.class)
			.isThrownBy(
					StepVerifier.create(processor)
					            .then(doAction::subscribe)
					            .assertNext(v -> assertThat(v).isEqualTo(23))
					            .thenCancel()
							::verify);
}