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

Example 26 with Worker

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

the class ExecutorSchedulerTest method reuseScheduledExecutorAsWorker.

@Test
public void reuseScheduledExecutorAsWorker() throws Exception {
    ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
    Worker s = Schedulers.from(exec).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 27 with Worker

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

the class ExecutorSchedulerTest method disposeRace.

@Test
public void disposeRace() {
    ExecutorService exec = Executors.newSingleThreadExecutor();
    final Scheduler s = Schedulers.from(exec);
    try {
        for (int i = 0; i < 500; i++) {
            final Worker w = s.createWorker();
            final AtomicInteger c = new AtomicInteger(2);
            w.schedule(new Runnable() {

                @Override
                public void run() {
                    c.decrementAndGet();
                    while (c.get() != 0) {
                    }
                }
            });
            c.decrementAndGet();
            while (c.get() != 0) {
            }
            w.dispose();
        }
    } finally {
        exec.shutdownNow();
    }
}

Example 28 with Worker

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

the class ExecutorSchedulerInterruptibleTest method nonInterruptibleWorkerTask.

@Test
public void nonInterruptibleWorkerTask() 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);
                    }
                }
            });
            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();
    }
}

Example 29 with Worker

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

the class ExecutorSchedulerInterruptibleTest method nonInterruptibleWorkerTaskScheduledExecutorTimed.

@Test
public void nonInterruptibleWorkerTaskScheduledExecutorTimed() throws Exception {
    ScheduledExecutorService exec = Executors.newScheduledThreadPool(1);
    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();
    }
}

Example 30 with Worker

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

the class ExecutorSchedulerInterruptibleTest method nonInterruptibleWorkerTaskScheduledExecutor.

@Test
public void nonInterruptibleWorkerTaskScheduledExecutor() throws Exception {
    ScheduledExecutorService exec = Executors.newScheduledThreadPool(1);
    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);
                    }
                }
            });
            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();
    }
}