Java Scheduler类代码示例

import io.reactivex.Scheduler; //导入依赖的package包/类
@Override
protected void starting(Description description) {
  if (restoreHandlers) {
    // https://github.com/ReactiveX/RxAndroid/pull/358
    //            originalInitMainThreadInitHandler =
    // RxAndroidPlugins.getInitMainThreadScheduler();
    //            originalMainThreadHandler = RxAndroidPlugins.getMainThreadScheduler();
  }
  RxAndroidPlugins.reset();
  RxAndroidPlugins.setInitMainThreadSchedulerHandler(
      new Function<Callable<Scheduler>, Scheduler>() {
        @Override
        public Scheduler apply(Callable<Scheduler> schedulerCallable) throws Exception {
          return delegatingMainThreadScheduler;
        }
      });
  RxAndroidPlugins.setMainThreadSchedulerHandler(
      new Function<Scheduler, Scheduler>() {
        @Override
        public Scheduler apply(Scheduler scheduler) throws Exception {
          return delegatingMainThreadScheduler;
        }
      });
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
@Test
public void defaultMainThreadSchedulerIsInitializedLazily() {
	Function<Callable<Scheduler>, Scheduler> safeOverride = new Function<Callable<Scheduler>, Scheduler>() {
		@Override
		public Scheduler apply(Callable<Scheduler> scheduler) {
			return new EmptyScheduler();
		}
	};
	Callable<Scheduler> unsafeDefault = new Callable<Scheduler>() {
		@Override
		public Scheduler call() throws Exception {
			throw new AssertionError();
		}
	};

	RxSwtPlugins.setInitMainThreadSchedulerHandler(safeOverride);
	RxSwtPlugins.initMainThreadScheduler(unsafeDefault);
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
private static void demo2() throws Exception {
    final ExecutorService executor = Executors.newFixedThreadPool(1000);
    final Scheduler pooledScheduler = Schedulers.from(executor);

    Observable.range(1, 10000)
            .flatMap(i -> Observable.just(i)
                    .subscribeOn(pooledScheduler)
                    .map(Sandbox::importantLongTask)
            )
            .doOnTerminate(WAIT_LATCH::countDown)
            .map(Objects::toString)
            .subscribe(e -> log("subscribe", e));

    WAIT_LATCH.await();
    executor.shutdown();
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
/**
 * Initializes a scheduler that will be used for offloading IO work performed by {@link Extract}s
 * <p/>
 * <p/> Threads executed on this scheduler have {@link Thread#NORM_PRIORITY}
 * @param ioPoolSize Size of thread pool for this scheduler
 */
private Scheduler initExtractScheduler(Integer ioPoolSize) {
    ThreadFactory factory = newThreadFactory("TaskManager-Extract-%s", Thread.NORM_PRIORITY);
    ExecutorService executor = Executors.newFixedThreadPool(ioPoolSize, factory);
    shutdownHook.registerExecutor(executor);
    return Schedulers.from(executor);
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
@Test(expected = NullPointerException.class)
public void testapplyRequireNonNullThrowsNPE() {
	RxSwtPlugins.applyRequireNonNull(new Function<Callable<Scheduler>, Scheduler>() {

		@Override
		public Scheduler apply(Callable<Scheduler> t) throws Exception {
			return null;
		}
	}, null);
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
@BeforeClass public static void init() throws Exception {
  // Tell RxAndroid to not use android main ui thread scheduler
  RxAndroidPlugins.setInitMainThreadSchedulerHandler(
      new Function<Callable<Scheduler>, Scheduler>() {
        @Override public Scheduler apply(@NonNull Callable<Scheduler> schedulerCallable)
            throws Exception {
          return Schedulers.trampoline();
        }
      });
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
/**
 * Initializes a scheduler that will be used for offloading IO work performed by {@link Load}s
 * <p/>
 * <p/> Threads executed on this scheduler have {@link Thread#NORM_PRIORITY}+2
 * @param ioPoolSize Size of thread pool for this scheduler
 */
private Scheduler initLoadScheduler(Integer ioPoolSize) {
    ThreadFactory factory = newThreadFactory("TaskManager-Load-%s", Thread.NORM_PRIORITY + 2);
    ExecutorService executor = Executors.newFixedThreadPool(ioPoolSize, factory);
    shutdownHook.registerExecutor(executor);
    return Schedulers.from(executor);
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
static Scheduler applyRequireNonNull(Function<Callable<Scheduler>, Scheduler> f, Callable<Scheduler> s) {
    Scheduler scheduler = apply(f,s);
    if (scheduler == null) {
        throw new NullPointerException("Scheduler Callable returned null");
    }
    return scheduler;
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
/**
 * Overrides the default implementation, to simplify implementing async transforms
 * <p/>
 * <p/> {@link PollingTransform}s are observed on the specified scheduler
 */
@Override
public Flowable<List<List<Transmutation>>> applyAsync(List<List<Transmutation>> input, Scheduler scheduler) {
    // determine if the implementing class should run
    if (skipTransform(input)) {
        return Flowable.just(input);
    }

    // remove items that should not be processed
    List<List<Transmutation>> toProcess = filter(input);
    if (isNull(toProcess)) {
        logger.info("Stopping processing in {} due to threshold not met...", this.getClass().getSimpleName());
        return Flowable.empty();
    }

    return Flowable.just(toProcess)
            .observeOn(scheduler)

            // send payload
            .map(this::sendRequest)

            .flatMap(req -> tryRetrieve(req, -1))

            // or timeout after the specified number of ms
            .timeout(timeoutMillis(), TimeUnit.MILLISECONDS)
            .doOnError(this::logAsyncError)
            .onErrorResumeNext(Flowable.empty());
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
@Test
public void getInitMainThreadSchedulerHandlerReturnsHandler() {
    Function<Callable<Scheduler>, Scheduler> handler = new Function<Callable<Scheduler>, Scheduler>() {
        @Override public Scheduler apply(Callable<Scheduler> schedulerCallable) throws Exception {
            return Schedulers.trampoline();
        }
    };
    RxAndroidPlugins.setInitMainThreadSchedulerHandler(handler);
    assertSame(handler, RxAndroidPlugins.getInitMainThreadSchedulerHandler());
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
RxJava2CallAdapter(Type responseType, Scheduler scheduler, boolean isAsync, boolean isResult,
    boolean isBody, boolean isFlowable, boolean isSingle, boolean isMaybe,
    boolean isCompletable) {
  this.responseType = responseType;
  this.scheduler = scheduler;
  this.isAsync = isAsync;
  this.isResult = isResult;
  this.isBody = isBody;
  this.isFlowable = isFlowable;
  this.isSingle = isSingle;
  this.isMaybe = isMaybe;
  this.isCompletable = isCompletable;
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
private MessageGroupSubscriber(long messageTimeoutNanos,
                               int bufferedMaxMessages,
                               Sender<M, R> sender,
                               Scheduler scheduler) {
  this.messageTimeoutNanos = messageTimeoutNanos == 0 ? Long.MAX_VALUE : messageTimeoutNanos;
  this.bufferedMaxMessages = bufferedMaxMessages;
  this.sender = sender;
  this.scheduler = scheduler;
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
@Test public void runningWorkReportsBusy() {
  Scheduler.Worker worker = scheduler.createWorker();
  worker.schedule(new Runnable() {
    @Override public void run() {
      assertBusy();
    }
  });
  delegate.triggerActions();
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
@Inject @Replaceable
public TodayWeatherViewModel(NavigationController navigation,
                             @RxObservable(PAGE) Observable<Integer> pageChangeObservable,
                             PermissionService permissionService,
                             LocationService locationService, WeatherService weatherService,
                             TodayWeatherResponseFilter weatherParser,
                             @RxScheduler(MAIN) Scheduler androidScheduler) {
    super(navigation, pageChangeObservable, permissionService, locationService, weatherService, weatherParser, androidScheduler);
}
 

import io.reactivex.Scheduler; //导入依赖的package包/类
public RxToFXListBinding(Scheduler scheduler, ObservableList<E> rxList, javafx.collections.ObservableList<E> fxList) {
    this.rxList = rxList;
    this.fxList = fxList;
    fxList.clear();
    disposer.register(rxList.observable().observeOn(scheduler).subscribe(fxList::add));
    disposer.register(rxList.onAdded().observeOn(scheduler).subscribe(c -> fxList.add(c.getIndex(), c.getValue())));
    disposer.register(rxList.onRemoved().observeOn(scheduler).subscribe(c -> fxList.remove(c.getIndex())));
    disposer.register(rxList.onUpdatedChanged().observeOn(scheduler).subscribe(c ->
            fxList.set(c.getNewValue().getIndex(), c.getOldValue().getValue())));
    disposer.register(rxList.onMoved().observeOn(scheduler).subscribe(c ->
            fxList.add(c.getNewValue().getIndex(), fxList.remove(c.getOldValue().getIndex()))));
}