Java Worker.schedule方法代码示例

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerScheduleOnceUsesHook() {
    final CountingRunnable newCounter = new CountingRunnable();
    final AtomicReference<Runnable> runnableRef = new AtomicReference<>();
    RxJavaPlugins.setScheduleHandler(new Function<Runnable, Runnable>() {
        @Override public Runnable apply(Runnable runnable) {
            runnableRef.set(runnable);
            return newCounter;
        }
    });

    Worker worker = scheduler.createWorker();

    CountingRunnable counter = new CountingRunnable();
    worker.schedule(counter);

    // Verify our runnable was passed to the schedulers hook.
    assertSame(counter, runnableRef.get());

    runUiThreadTasks();
    // Verify the scheduled runnable was the one returned from the hook.
    assertEquals(1, newCounter.get());
    assertEquals(0, counter.get());
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerScheduleOnceWithDelayUsesHook() {
    final CountingRunnable newCounter = new CountingRunnable();
    final AtomicReference<Runnable> runnableRef = new AtomicReference<>();
    RxJavaPlugins.setScheduleHandler(new Function<Runnable, Runnable>() {
        @Override public Runnable apply(Runnable runnable) {
            runnableRef.set(runnable);
            return newCounter;
        }
    });

    Worker worker = scheduler.createWorker();

    CountingRunnable counter = new CountingRunnable();
    worker.schedule(counter, 1, MINUTES);

    // Verify our runnable was passed to the schedulers hook.
    assertSame(counter, runnableRef.get());

    idleMainLooper(1, MINUTES);
    runUiThreadTasks();
    // Verify the scheduled runnable was the one returned from the hook.
    assertEquals(1, newCounter.get());
    assertEquals(0, counter.get());
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerUnsubscriptionDuringSchedulingCancelsScheduledAction() {
    final AtomicReference<Worker> workerRef = new AtomicReference<>();
    RxJavaPlugins.setScheduleHandler(new Function<Runnable, Runnable>() {
        @Override public Runnable apply(Runnable runnable) {
            // Purposefully unsubscribe in an asinine point after the normal unsubscribed check.
            workerRef.get().dispose();
            return runnable;
        }
    });

    Worker worker = scheduler.createWorker();
    workerRef.set(worker);

    CountingRunnable counter = new CountingRunnable();
    worker.schedule(counter);

    runUiThreadTasks();
    assertEquals(0, counter.get());
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerUnsubscriptionDoesNotAffectOtherWorkers() {
    Worker workerA = scheduler.createWorker();
    CountingRunnable counterA = new CountingRunnable();
    workerA.schedule(counterA, 1, MINUTES);

    Worker workerB = scheduler.createWorker();
    CountingRunnable counterB = new CountingRunnable();
    workerB.schedule(counterB, 1, MINUTES);

    workerA.dispose();

    runUiThreadTasksIncludingDelayedTasks();
    assertEquals(0, counterA.get());
    assertEquals(1, counterB.get());
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerDispose() throws Exception {
    Task t = new Task(1);

    Worker w = SwingSchedulers.edt().createWorker();
    try {
        Disposable d = w.schedule(t, 500, TimeUnit.MILLISECONDS);

        Thread.sleep(100);

        d.dispose();

        Thread.sleep(500);

        Assert.assertEquals(0, t.calls);
    } finally {
        w.dispose();
    }
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test(timeout = 5000)
public void futureDisposeRace() throws Exception {
    SharedScheduler scheduler = new SharedScheduler(Schedulers.computation());
    try {
        Worker w = scheduler.createWorker();
        for (int i = 0; i < 1000; i++) {
           w.schedule(this);
        }

        while (calls != 1000) {
            Thread.sleep(100);
        }
    } finally {
        scheduler.shutdown();
    }
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
protected void taskThrows(Scheduler s) throws InterruptedException {
    try {
        List<Throwable> errors = TestHelper.trackPluginErrors();

        Worker w = s.createWorker();

        w.schedule(new Runnable() {
            @Override
            public void run() {
                calls.getAndIncrement();
                throw new IllegalStateException();
            }
        });

        while (errors.isEmpty()) {
            Thread.sleep(20);
        }

        TestHelper.assertError(errors, 0, IllegalStateException.class);
    } finally {
        s.shutdown();
    }
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void setFutureRace() {
    final Scheduler s = new ParallelScheduler(2, true);
    try {
        for (int i = 0; i < 1000; i++) {
            final Worker w = s.createWorker();

            Runnable r1 = new Runnable() {
                @Override
                public void run() {
                    w.schedule(ParallelSchedulerTest.this);
                }
            };

            Runnable r2 = new Runnable() {
                @Override
                public void run() {
                    w.dispose();
                }
            };
            TestHelper.race(r1, r2, Schedulers.single());
        }
    } finally {
        s.shutdown();
    }
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
public static void blockUntilWorkFinished(Scheduler scheduler, int numThreads, long timeout, TimeUnit unit) {
    final CountDownLatch latch = new CountDownLatch(numThreads);
    for (int i = 1; i <= numThreads; i++) {
        final Worker worker = scheduler.createWorker();
        worker.schedule(new Runnable() {
            @Override
            public void run() {
                worker.dispose();
                latch.countDown();
            }
        });
    }
    try {
        boolean finished = latch.await(timeout, unit);
        if (!finished) {
            throw new RuntimeException("timeout occured waiting for work to finish");
        }
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerScheduleOncePostsImmediately() {
    Worker worker = scheduler.createWorker();

    CountingRunnable counter = new CountingRunnable();
    worker.schedule(counter);

    runUiThreadTasks();
    assertEquals(1, counter.get());
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerScheduleOnceWithNegativeDelayPostsImmediately() {
    Worker worker = scheduler.createWorker();

    CountingRunnable counter = new CountingRunnable();
    worker.schedule(counter, -1, TimeUnit.MINUTES);

    runUiThreadTasks();
    assertEquals(1, counter.get());
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerScheduleOnceDisposedDoesNotRun() {
    Worker worker = scheduler.createWorker();

    CountingRunnable counter = new CountingRunnable();
    Disposable disposable = worker.schedule(counter);
    disposable.dispose();

    runUiThreadTasks();
    assertEquals(0, counter.get());
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerScheduleOnceWithDelayPostsWithDelay() {
    Worker worker = scheduler.createWorker();

    CountingRunnable counter = new CountingRunnable();
    worker.schedule(counter, 1, MINUTES);

    runUiThreadTasks();
    assertEquals(0, counter.get());

    idleMainLooper(1, MINUTES);
    runUiThreadTasks();
    assertEquals(1, counter.get());
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerScheduleOnceWithDelayDisposedDoesNotRun() {
    Worker worker = scheduler.createWorker();

    CountingRunnable counter = new CountingRunnable();
    Disposable disposable = worker.schedule(counter, 1, MINUTES);

    idleMainLooper(30, SECONDS);
    disposable.dispose();

    idleMainLooper(30, SECONDS);
    runUiThreadTasks();
    assertEquals(0, counter.get());
}
 

import io.reactivex.Scheduler.Worker; //导入方法依赖的package包/类
@Test
public void workerDisposableTracksDisposedState() {
    Worker worker = scheduler.createWorker();

    CountingRunnable counter = new CountingRunnable();
    Disposable disposable = worker.schedule(counter);
    assertFalse(disposable.isDisposed());

    disposable.dispose();
    assertTrue(disposable.isDisposed());
}