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

Example 76 with Worker

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

the class SchedulerTest method disposeSelfPeriodic.

@Test
public void disposeSelfPeriodic() {
    final int[] count = { 0 };
    TestScheduler scheduler = new TestScheduler();
    Worker worker = scheduler.createWorker();
    try {
        final SequentialDisposable sd = new SequentialDisposable();
        Disposable d = worker.schedulePeriodically(new Runnable() {

            @Override
            public void run() {
                count[0]++;
                sd.dispose();
            }
        }, 100, 100, TimeUnit.MILLISECONDS);
        sd.set(d);
        assertEquals(0, count[0]);
        assertFalse(d.isDisposed());
        scheduler.advanceTimeBy(400, TimeUnit.MILLISECONDS);
        assertEquals(1, count[0]);
        assertTrue(d.isDisposed());
    } finally {
        worker.dispose();
    }
}

Example 77 with Worker

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

the class TrampolineSchedulerTest method doWorkOnNewTrampoline.

private static Worker doWorkOnNewTrampoline(final String key, final ArrayList<String> workDone) {
    Worker worker = Schedulers.trampoline().createWorker();
    worker.schedule(new Runnable() {

        @Override
        public void run() {
            String msg = key + ".1";
            workDone.add(msg);
            System.out.println(msg);
            Worker worker3 = Schedulers.trampoline().createWorker();
            worker3.schedule(createPrintAction(key + ".B.1", workDone));
            worker3.schedule(createPrintAction(key + ".B.2", workDone));
        }
    });
    return worker;
}

Example 78 with Worker

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

the class TrampolineSchedulerTest method nestedTrampolineWithUnsubscribe.

@Test
public void nestedTrampolineWithUnsubscribe() {
    final ArrayList<String> workDone = new ArrayList<>();
    final CompositeDisposable workers = new CompositeDisposable();
    Worker worker = Schedulers.trampoline().createWorker();
    try {
        workers.add(worker);
        worker.schedule(new Runnable() {

            @Override
            public void run() {
                workers.add(doWorkOnNewTrampoline("A", workDone));
            }
        });
        final Worker worker2 = Schedulers.trampoline().createWorker();
        workers.add(worker2);
        worker2.schedule(new Runnable() {

            @Override
            public void run() {
                workers.add(doWorkOnNewTrampoline("B", workDone));
                // we unsubscribe worker2 ... it should not affect work scheduled on a separate Trampline.Worker
                worker2.dispose();
            }
        });
        assertEquals(6, workDone.size());
        assertEquals(Arrays.asList("A.1", "A.B.1", "A.B.2", "B.1", "B.B.1", "B.B.2"), workDone);
    } finally {
        workers.dispose();
    }
}

Example 79 with Worker

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

the class ExecutorSchedulerInterruptibleTest method reuseScheduledExecutorAsWorker.

@Test
public void reuseScheduledExecutorAsWorker() throws Exception {
    ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
    Worker s = Schedulers.from(exec, true).createWorker();
    assertFalse(s.isDisposed());
    try {
        final CountDownLatch cdl = new CountDownLatch(8);
        Runnable r = new Runnable() {

            @Override
            public void run() {
                cdl.countDown();
            }
        };
        s.schedule(r);
        s.schedule(r, 10, TimeUnit.MILLISECONDS);
        Disposable d = s.schedulePeriodically(r, 10, 10, TimeUnit.MILLISECONDS);
        try {
            assertTrue(cdl.await(5, TimeUnit.SECONDS));
        } finally {
            d.dispose();
        }
    } finally {
        s.dispose();
        exec.shutdown();
    }
    assertTrue(s.isDisposed());
}

Example 80 with Worker

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

the class ExecutorSchedulerInterruptibleTest method nonInterruptibleWorkerTaskTimed.

@Test
public void nonInterruptibleWorkerTaskTimed() throws Exception {
    ExecutorService exec = Executors.newSingleThreadExecutor();
    try {
        Scheduler scheduler = Schedulers.from(exec, false);
        Worker worker = scheduler.createWorker();
        try {
            final AtomicInteger sync = new AtomicInteger(2);
            final AtomicBoolean isInterrupted = new AtomicBoolean();
            Disposable d = worker.schedule(new Runnable() {

                @Override
                public void run() {
                    if (sync.decrementAndGet() != 0) {
                        while (sync.get() != 0) {
                        }
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
                        isInterrupted.set(true);
                    }
                }
            }, 1, TimeUnit.MILLISECONDS);
            if (sync.decrementAndGet() != 0) {
                while (sync.get() != 0) {
                }
            }
            Thread.sleep(500);
            d.dispose();
            int i = 20;
            while (i-- > 0 && !isInterrupted.get()) {
                Thread.sleep(50);
            }
            assertFalse("Interruption happened", isInterrupted.get());
        } finally {
            worker.dispose();
        }
    } finally {
        exec.shutdown();
    }
}