@Test public void dispose2() { ExecutorService exec = Executors.newSingleThreadExecutor(); Disposable.Composite composit = Disposables.composite(); try { InstantPeriodicWorkerTask task = new InstantPeriodicWorkerTask(errorRunnable, exec, composit); task.setFirst(new FutureTask<Void>(emptyRunnable, null)); task.setRest(new FutureTask<Void>(emptyRunnable, null)); assertThat(task.isDisposed()).isFalse(); task.dispose(); assertThat(task.isDisposed()).isTrue(); task.dispose(); assertThat(task.isDisposed()).isTrue(); } finally { exec.shutdownNow(); Schedulers.resetOnHandleError(); } }
static Disposable directSchedulePeriodically(ScheduledExecutorService exec, Runnable task, long initialDelay, long period, TimeUnit unit) { if (period <= 0L) { InstantPeriodicWorkerTask isr = new InstantPeriodicWorkerTask(task, exec); Future<?> f; if (initialDelay <= 0L) { f = exec.submit(isr); } else { f = exec.schedule(isr, initialDelay, unit); } isr.setFirst(f); return isr; } else { PeriodicSchedulerTask sr = new PeriodicSchedulerTask(task); Future<?> f = exec.scheduleAtFixedRate(sr, initialDelay, period, unit); sr.setFuture(f); return sr; } }
@Test public void dispose() { ExecutorService exec = Executors.newSingleThreadExecutor(); Disposable.Composite composit = Disposables.composite(); try { InstantPeriodicWorkerTask task = new InstantPeriodicWorkerTask(errorRunnable, exec, composit); assertThat(task.isDisposed()).isFalse(); task.dispose(); assertThat(task.isDisposed()).isTrue(); task.dispose(); assertThat(task.isDisposed()).isTrue(); } finally { exec.shutdownNow(); Schedulers.resetOnHandleError(); } }
new InstantPeriodicWorkerTask(task, exec, tasks); if (!tasks.add(isr)) { throw Exceptions.failWithRejected(); f = exec.schedule(isr, initialDelay, unit); isr.setFirst(f); isr.dispose(); isr.dispose();
@Test public void restCancelRace() { ExecutorService exec = Executors.newSingleThreadExecutor(); Disposable.Composite composit = Disposables.composite(); try { for (int i = 0; i < 10000; i++) { final InstantPeriodicWorkerTask task = new InstantPeriodicWorkerTask(errorRunnable, exec, composit); final FutureTask<Void> f1 = new FutureTask<Void>(emptyRunnable, null); Runnable r1 = () -> task.setRest(f1); Runnable r2 = task::dispose; RaceTestUtils.race(r1, r2); assertTrue(f1.isCancelled()); assertTrue(task.isDisposed()); } } finally { exec.shutdownNow(); Schedulers.resetOnHandleError(); } }
@Test public void firstCancelRace() { ExecutorService exec = Executors.newSingleThreadExecutor(); Disposable.Composite composit = Disposables.composite(); try { for (int i = 0; i < 10000; i++) { final InstantPeriodicWorkerTask task = new InstantPeriodicWorkerTask(errorRunnable, exec, composit); final FutureTask<Void> f1 = new FutureTask<Void>(emptyRunnable, null); Runnable r1 = () -> task.setFirst(f1); Runnable r2 = task::dispose; RaceTestUtils.race(r1, r2); assertTrue(f1.isCancelled()); assertTrue(task.isDisposed()); } } finally { exec.shutdownNow(); Schedulers.resetOnHandleError(); } }
@Test public void taskCrash() { ExecutorService exec = Executors.newSingleThreadExecutor(); Disposable.Composite composite = Disposables.composite(); List<Throwable> throwables = prepareErrorHook(); try { InstantPeriodicWorkerTask task = new InstantPeriodicWorkerTask(errorRunnable, exec, composite); assertThat(task.call()).isNull(); assertThat(throwables).containsOnly(exception); } finally { exec.shutdownNow(); Schedulers.resetOnHandleError(); } }
@Override @Nullable public Void call() { thread = Thread.currentThread(); try { try { task.run(); setRest(executor.submit(this)); } catch (Throwable ex) { Schedulers.handleError(ex); } } finally { thread = null; } return null; }
new InstantPeriodicWorkerTask(task, exec, tasks); if (!tasks.add(isr)) { throw Exceptions.failWithRejected(); f = exec.schedule(isr, initialDelay, unit); isr.setFirst(f); isr.dispose(); isr.dispose();
@Override @Nullable public Void call() { thread = Thread.currentThread(); try { try { task.run(); setRest(executor.submit(this)); } catch (Throwable ex) { Schedulers.handleError(ex); } } finally { thread = null; } return null; }
@Test public void dispose2CurrentThread() { ExecutorService exec = Executors.newSingleThreadExecutor(); Disposable.Composite composit = Disposables.composite(); try { InstantPeriodicWorkerTask task = new InstantPeriodicWorkerTask(errorRunnable, exec, composit); task.thread = Thread.currentThread(); task.setFirst(new FutureTask<Void>(emptyRunnable, null)); task.setRest(new FutureTask<Void>(emptyRunnable, null)); assertThat(task.isDisposed()).isFalse(); task.dispose(); assertThat(task.isDisposed()).isTrue(); assertThat(composit.size()).isEqualTo(0); task.dispose(); assertThat(task.isDisposed()).isTrue(); assertThat(composit.size()).isEqualTo(0); } finally { exec.shutdownNow(); Schedulers.resetOnHandleError(); } }
@Test public void dispose3() { ExecutorService exec = Executors.newSingleThreadExecutor(); Disposable.Composite composit = Disposables.composite(); try { InstantPeriodicWorkerTask task = new InstantPeriodicWorkerTask(errorRunnable, exec, composit); task.dispose(); FutureTask<Void> f1 = new FutureTask<Void>(emptyRunnable, null); task.setFirst(f1); assertThat(f1.isCancelled()).isTrue(); FutureTask<Void> f2 = new FutureTask<Void>(emptyRunnable, null); task.setRest(f2); assertThat(f2.isCancelled()).isTrue(); } finally { exec.shutdownNow(); Schedulers.resetOnHandleError(); } }
@Test public void disposeOnCurrentThread() { ExecutorService exec = Executors.newSingleThreadExecutor(); Disposable.Composite composit = Disposables.composite(); try { InstantPeriodicWorkerTask task = new InstantPeriodicWorkerTask(errorRunnable, exec, composit); task.thread = Thread.currentThread(); task.dispose(); FutureTask<Void> f1 = new FutureTask<Void>(emptyRunnable, null); task.setFirst(f1); assertThat(f1.isCancelled()).isTrue(); FutureTask<Void> f2 = new FutureTask<Void>(emptyRunnable, null); task.setRest(f2); assertThat(f2.isCancelled()).isTrue(); } finally { exec.shutdownNow(); Schedulers.resetOnHandleError(); } }