Examples with Worker io.reactivex.rxjava3.core.Scheduler.Worker used on opensource projects

Example 56 with Worker

use of io.reactivex.rxjava3.core.Scheduler.Worker in project RxJava by ReactiveX.

the class ObservableInterval method subscribeActual.

@Override
public void subscribeActual(Observer<? super Long> observer) {
    IntervalObserver is = new IntervalObserver(observer);
    observer.onSubscribe(is);
    Scheduler sch = scheduler;
    if (sch instanceof TrampolineScheduler) {
        Worker worker = sch.createWorker();
        is.setResource(worker);
        worker.schedulePeriodically(is, initialDelay, period, unit);
    } else {
        Disposable d = sch.schedulePeriodicallyDirect(is, initialDelay, period, unit);
        is.setResource(d);
    }
}

Example 57 with Worker

use of io.reactivex.rxjava3.core.Scheduler.Worker in project RxJava by ReactiveX.

the class PeriodicDirectTaskTest method runnableThrows.

@Test
public void runnableThrows() {
    List<Throwable> errors = TestHelper.trackPluginErrors();
    try {
        Scheduler.Worker worker = Schedulers.single().createWorker();
        PeriodicDirectTask task = new PeriodicDirectTask(() -> {
            throw new TestException();
        }, worker);
        try {
            task.run();
            fail("Should have thrown!");
        } catch (TestException expected) {
        // expected
        }
        TestHelper.assertUndeliverable(errors, 0, TestException.class);
        assertTrue(worker.isDisposed());
        task.run();
    } finally {
        RxJavaPlugins.reset();
    }
}

Example 58 with Worker

use of io.reactivex.rxjava3.core.Scheduler.Worker in project RxJava by ReactiveX.

the class DeferredScalarSubscriberTest method emissionRequestRace2.

@Test
public void emissionRequestRace2() {
    Worker w = Schedulers.io().createWorker();
    Worker w2 = Schedulers.io().createWorker();
    int m = 10000;
    if (Runtime.getRuntime().availableProcessors() < 3) {
        m = 1000;
    }
    try {
        for (int i = 0; i < m; i++) {
            final TestSubscriber<Integer> ts = TestSubscriber.create(0L);
            TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
            ds.setupDownstream();
            ds.onNext(1);
            final AtomicInteger ready = new AtomicInteger(3);
            w.schedule(new Runnable() {

                @Override
                public void run() {
                    ready.decrementAndGet();
                    while (ready.get() != 0) {
                    }
                    ts.request(1);
                }
            });
            w2.schedule(new Runnable() {

                @Override
                public void run() {
                    ready.decrementAndGet();
                    while (ready.get() != 0) {
                    }
                    ts.request(1);
                }
            });
            ready.decrementAndGet();
            while (ready.get() != 0) {
            }
            ds.onComplete();
            ts.awaitDone(5, TimeUnit.SECONDS);
            ts.assertValues(1);
            ts.assertNoErrors();
            ts.assertComplete();
        }
    } finally {
        w.dispose();
        w2.dispose();
    }
}

Example 59 with Worker

use of io.reactivex.rxjava3.core.Scheduler.Worker in project RxJava by ReactiveX.

the class SchedulerWhenTest method scheduledActionStates.

@Test
public void scheduledActionStates() {
    final AtomicInteger count = new AtomicInteger();
    ScheduledAction sa = new ScheduledAction() {

        private static final long serialVersionUID = -672980251643733156L;

        @Override
        protected Disposable callActual(Worker actualWorker, CompletableObserver actionCompletable) {
            count.incrementAndGet();
            return Disposable.empty();
        }
    };
    assertFalse(sa.isDisposed());
    sa.dispose();
    assertTrue(sa.isDisposed());
    sa.dispose();
    assertTrue(sa.isDisposed());
    // should not run when disposed
    sa.call(Schedulers.single().createWorker(), null);
    assertEquals(0, count.get());
    // should not run when already scheduled
    sa.set(Disposable.empty());
    sa.call(Schedulers.single().createWorker(), null);
    assertEquals(0, count.get());
    // disposed while in call
    sa = new ScheduledAction() {

        private static final long serialVersionUID = -672980251643733156L;

        @Override
        protected Disposable callActual(Worker actualWorker, CompletableObserver actionCompletable) {
            count.incrementAndGet();
            dispose();
            return Disposable.empty();
        }
    };
    sa.call(Schedulers.single().createWorker(), null);
    assertEquals(1, count.get());
}

Example 60 with Worker

use of io.reactivex.rxjava3.core.Scheduler.Worker in project RxJava by ReactiveX.

the class TrampolineSchedulerInternalTest method reentrantScheduleShutdown2.

@Test
public void reentrantScheduleShutdown2() {
    final Worker w = Schedulers.trampoline().createWorker();
    try {
        final int[] calls = { 0, 0 };
        w.schedule(new Runnable() {

            @Override
            public void run() {
                calls[0]++;
                w.dispose();
                assertSame(EmptyDisposable.INSTANCE, w.schedule(new Runnable() {

                    @Override
                    public void run() {
                        calls[1]++;
                    }
                }, 1, TimeUnit.MILLISECONDS));
            }
        });
        assertEquals(1, calls[0]);
        assertEquals(0, calls[1]);
    } finally {
        w.dispose();
    }
}