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

Example 66 with Worker

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

the class AbstractSchedulerConcurrencyTests method unsubscribeRecursiveScheduleFromInside.

@Test
public void unsubscribeRecursiveScheduleFromInside() throws InterruptedException {
    final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
    final AtomicInteger counter = new AtomicInteger();
    final Worker inner = getScheduler().createWorker();
    try {
        inner.schedule(new Runnable() {

            @Override
            public void run() {
                inner.schedule(new Runnable() {

                    int i;

                    @Override
                    public void run() {
                        System.out.println("Run: " + i++);
                        if (i == 10) {
                            inner.dispose();
                        }
                        counter.incrementAndGet();
                        inner.schedule(this);
                    }
                });
            }
        });
        unsubscribeLatch.countDown();
        // let time pass to see if the scheduler is still doing work
        Thread.sleep(200);
        assertEquals(10, counter.get());
    } finally {
        inner.dispose();
    }
}

Example 67 with Worker

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

the class AbstractSchedulerConcurrencyTests method recursion.

@Test
public void recursion() throws InterruptedException {
    final CountDownLatch latch = new CountDownLatch(1);
    final Worker inner = getScheduler().createWorker();
    try {
        inner.schedule(new Runnable() {

            private long i;

            @Override
            public void run() {
                i++;
                if (i % 100000 == 0) {
                    System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
                }
                if (i < 1000000L) {
                    inner.schedule(this);
                } else {
                    latch.countDown();
                }
            }
        });
        latch.await();
    } finally {
        inner.dispose();
    }
}

Example 68 with Worker

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

the class AbstractSchedulerConcurrencyTests method recursionAndOuterUnsubscribe.

@Test
public void recursionAndOuterUnsubscribe() throws InterruptedException {
    // use latches instead of Thread.sleep
    final CountDownLatch latch = new CountDownLatch(10);
    final CountDownLatch completionLatch = new CountDownLatch(1);
    final Worker inner = getScheduler().createWorker();
    try {
        Flowable<Integer> obs = Flowable.unsafeCreate(new Publisher<Integer>() {

            @Override
            public void subscribe(final Subscriber<? super Integer> subscriber) {
                inner.schedule(new Runnable() {

                    @Override
                    public void run() {
                        subscriber.onNext(42);
                        latch.countDown();
                        // this will recursively schedule this task for execution again
                        inner.schedule(this);
                    }
                });
                subscriber.onSubscribe(new Subscription() {

                    @Override
                    public void cancel() {
                        inner.dispose();
                        subscriber.onComplete();
                        completionLatch.countDown();
                    }

                    @Override
                    public void request(long n) {
                    }
                });
            }
        });
        final AtomicInteger count = new AtomicInteger();
        final AtomicBoolean completed = new AtomicBoolean(false);
        ResourceSubscriber<Integer> s = new ResourceSubscriber<Integer>() {

            @Override
            public void onComplete() {
                System.out.println("Completed");
                completed.set(true);
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("Error");
            }

            @Override
            public void onNext(Integer args) {
                count.incrementAndGet();
                System.out.println(args);
            }
        };
        obs.subscribe(s);
        if (!latch.await(5000, TimeUnit.MILLISECONDS)) {
            fail("Timed out waiting on onNext latch");
        }
        // now unsubscribe and ensure it stops the recursive loop
        s.dispose();
        System.out.println("unsubscribe");
        if (!completionLatch.await(5000, TimeUnit.MILLISECONDS)) {
            fail("Timed out waiting on completion latch");
        }
        // the count can be 10 or higher due to thread scheduling of the unsubscribe vs the scheduler looping to emit the count
        assertTrue(count.get() >= 10);
        assertTrue(completed.get());
    } finally {
        inner.dispose();
    }
}

Example 69 with Worker

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

the class CachedThreadSchedulerTest method cancelledTaskRetention.

@Test
public void cancelledTaskRetention() throws InterruptedException {
    Worker w = Schedulers.io().createWorker();
    try {
        ExecutorSchedulerTest.cancelledRetention(w, false);
    } finally {
        w.dispose();
    }
    w = Schedulers.io().createWorker();
    try {
        ExecutorSchedulerTest.cancelledRetention(w, true);
    } finally {
        w.dispose();
    }
}

Example 70 with Worker

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

the class CachedThreadSchedulerTest method workerDisposed.

@Test
public void workerDisposed() {
    Worker w = Schedulers.io().createWorker();
    assertFalse(((Disposable) w).isDisposed());
    w.dispose();
    assertTrue(((Disposable) w).isDisposed());
}