Debian Codegraph @

src/test/java/io/reactivex/rxjava3/schedulers/ExecutorSchedulerFairTest.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.schedulers;
15
16 import static org.junit.Assert.*;
17
18 import java.util.List;
19 import java.util.concurrent.*;
20 import java.util.concurrent.atomic.AtomicInteger;
21
22 import org.junit.Test;
23
24 import io.reactivex.rxjava3.core.*;
25 import io.reactivex.rxjava3.core.Scheduler.Worker;
26 import io.reactivex.rxjava3.disposables.Disposable;
27 import io.reactivex.rxjava3.functions.*;
28 import io.reactivex.rxjava3.internal.disposables.EmptyDisposable;
29 import io.reactivex.rxjava3.internal.functions.Functions;
30 import io.reactivex.rxjava3.internal.schedulers.RxThreadFactory;
31 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
32 import io.reactivex.rxjava3.processors.PublishProcessor;
33 import io.reactivex.rxjava3.subscribers.TestSubscriber;
34 import io.reactivex.rxjava3.testsupport.TestHelper;
35
36 public class ExecutorSchedulerFairTest extends AbstractSchedulerConcurrencyTests {
37
38 static final Executor executor = Executors.newFixedThreadPool(2, new RxThreadFactory("TestCustomPool"));
39
40 @Override
41 protected Scheduler getScheduler() {
42 return Schedulers.from(executor, false, true);
43 }
44
45 @Test
46 public final void handledErrorIsNotDeliveredToThreadHandler() throws InterruptedException {
47 SchedulerTestHelper.handledErrorIsNotDeliveredToThreadHandler(getScheduler());
48 }
49
50 @Test
51 public void cancelledTaskRetention() throws InterruptedException {
52 ExecutorService exec = Executors.newSingleThreadExecutor();
53 Scheduler s = Schedulers.from(exec, false, true);
54 try {
55 Scheduler.Worker w = s.createWorker();
56 try {
57 ExecutorSchedulerTest.cancelledRetention(w, false);
58 } finally {
59 w.dispose();
60 }
61
62 w = s.createWorker();
63 try {
64 ExecutorSchedulerTest.cancelledRetention(w, true);
65 } finally {
66 w.dispose();
67 }
68 } finally {
69 exec.shutdownNow();
70 }
71 }
72
73 /** A simple executor which queues tasks and executes them one-by-one if executeOne() is called. */
74 static final class TestExecutor implements Executor {
75 final ConcurrentLinkedQueue<Runnable> queue = new ConcurrentLinkedQueue<>();
76 @Override
77 public void execute(Runnable command) {
78 queue.offer(command);
79 }
80 public void executeOne() {
81 Runnable r = queue.poll();
82 if (r != null) {
83 r.run();
84 }
85 }
86 public void executeAll() {
87 Runnable r;
88 while ((r = queue.poll()) != null) {
89 r.run();
90 }
91 }
92 }
93
94 @Test
95 public void cancelledTasksDontRun() {
96 final AtomicInteger calls = new AtomicInteger();
97 Runnable task = new Runnable() {
98 @Override
99 public void run() {
100 calls.getAndIncrement();
101 }
102 };
103 TestExecutor exec = new TestExecutor();
104 Scheduler custom = Schedulers.from(exec, false, true);
105 Worker w = custom.createWorker();
106 try {
107 Disposable d1 = w.schedule(task);
108 Disposable d2 = w.schedule(task);
109 Disposable d3 = w.schedule(task);
110
111 d1.dispose();
112 d2.dispose();
113 d3.dispose();
114
115 exec.executeAll();
116
117 assertEquals(0, calls.get());
118 } finally {
119 w.dispose();
120 }
121 }
122
123 @Test
124 public void cancelledWorkerDoesntRunTasks() {
125 final AtomicInteger calls = new AtomicInteger();
126 Runnable task = new Runnable() {
127 @Override
128 public void run() {
129 calls.getAndIncrement();
130 }
131 };
132 TestExecutor exec = new TestExecutor();
133 Scheduler custom = Schedulers.from(exec, false, true);
134 Worker w = custom.createWorker();
135 try {
136 w.schedule(task);
137 w.schedule(task);
138 w.schedule(task);
139 } finally {
140 w.dispose();
141 }
142 exec.executeAll();
143 assertEquals(0, calls.get());
144 }
145
146 @Test
147 public void plainExecutor() throws Exception {
148 Scheduler s = Schedulers.from(new Executor() {
149 @Override
150 public void execute(Runnable r) {
151 r.run();
152 }
153 }, false, true);
154
155 final CountDownLatch cdl = new CountDownLatch(5);
156
157 Runnable r = new Runnable() {
158 @Override
159 public void run() {
160 cdl.countDown();
161 }
162 };
163
164 s.scheduleDirect(r);
165
166 s.scheduleDirect(r, 50, TimeUnit.MILLISECONDS);
167
168 Disposable d = s.schedulePeriodicallyDirect(r, 10, 10, TimeUnit.MILLISECONDS);
169
170 try {
171 assertTrue(cdl.await(5, TimeUnit.SECONDS));
172 } finally {
173 d.dispose();
174 }
175
176 assertTrue(d.isDisposed());
177 }
178
179 @Test
180 public void rejectingExecutor() {
181 ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
182 exec.shutdown();
183
184 Scheduler s = Schedulers.from(exec, false, true);
185
186 List<Throwable> errors = TestHelper.trackPluginErrors();
187
188 try {
189 assertSame(EmptyDisposable.INSTANCE, s.scheduleDirect(Functions.EMPTY_RUNNABLE));
190
191 assertSame(EmptyDisposable.INSTANCE, s.scheduleDirect(Functions.EMPTY_RUNNABLE, 10, TimeUnit.MILLISECONDS));
192
193 assertSame(EmptyDisposable.INSTANCE, s.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 10, 10, TimeUnit.MILLISECONDS));
194
195 TestHelper.assertUndeliverable(errors, 0, RejectedExecutionException.class);
196 TestHelper.assertUndeliverable(errors, 1, RejectedExecutionException.class);
197 TestHelper.assertUndeliverable(errors, 2, RejectedExecutionException.class);
198 } finally {
199 RxJavaPlugins.reset();
200 }
201 }
202
203 @Test
204 public void rejectingExecutorWorker() {
205 ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
206 exec.shutdown();
207
208 List<Throwable> errors = TestHelper.trackPluginErrors();
209
210 try {
211 Worker s = Schedulers.from(exec, false, true).createWorker();
212 assertSame(EmptyDisposable.INSTANCE, s.schedule(Functions.EMPTY_RUNNABLE));
213
214 s = Schedulers.from(exec, false, true).createWorker();
215 assertSame(EmptyDisposable.INSTANCE, s.schedule(Functions.EMPTY_RUNNABLE, 10, TimeUnit.MILLISECONDS));
216
217 s = Schedulers.from(exec, false, true).createWorker();
218 assertSame(EmptyDisposable.INSTANCE, s.schedulePeriodically(Functions.EMPTY_RUNNABLE, 10, 10, TimeUnit.MILLISECONDS));
219
220 TestHelper.assertUndeliverable(errors, 0, RejectedExecutionException.class);
221 TestHelper.assertUndeliverable(errors, 1, RejectedExecutionException.class);
222 TestHelper.assertUndeliverable(errors, 2, RejectedExecutionException.class);
223 } finally {
224 RxJavaPlugins.reset();
225 }
226 }
227
228 @Test
229 public void reuseScheduledExecutor() throws Exception {
230 ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
231
232 try {
233 Scheduler s = Schedulers.from(exec, false, true);
234
235 final CountDownLatch cdl = new CountDownLatch(8);
236
237 Runnable r = new Runnable() {
238 @Override
239 public void run() {
240 cdl.countDown();
241 }
242 };
243
244 s.scheduleDirect(r);
245
246 s.scheduleDirect(r, 10, TimeUnit.MILLISECONDS);
247
248 Disposable d = s.schedulePeriodicallyDirect(r, 10, 10, TimeUnit.MILLISECONDS);
249
250 try {
251 assertTrue(cdl.await(5, TimeUnit.SECONDS));
252 } finally {
253 d.dispose();
254 }
255 } finally {
256 exec.shutdown();
257 }
258 }
259
260 @Test
261 public void reuseScheduledExecutorAsWorker() throws Exception {
262 ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
263
264 Worker s = Schedulers.from(exec, false, true).createWorker();
265
266 assertFalse(s.isDisposed());
267 try {
268
269 final CountDownLatch cdl = new CountDownLatch(8);
270
271 Runnable r = new Runnable() {
272 @Override
273 public void run() {
274 cdl.countDown();
275 }
276 };
277
278 s.schedule(r);
279
280 s.schedule(r, 10, TimeUnit.MILLISECONDS);
281
282 Disposable d = s.schedulePeriodically(r, 10, 10, TimeUnit.MILLISECONDS);
283
284 try {
285 assertTrue(cdl.await(5, TimeUnit.SECONDS));
286 } finally {
287 d.dispose();
288 }
289 } finally {
290 s.dispose();
291 exec.shutdown();
292 }
293
294 assertTrue(s.isDisposed());
295 }
296
297 @Test
298 public void disposeRace() {
299 ExecutorService exec = Executors.newSingleThreadExecutor();
300 final Scheduler s = Schedulers.from(exec, false, true);
301 try {
302 for (int i = 0; i < 500; i++) {
303 final Worker w = s.createWorker();
304
305 final AtomicInteger c = new AtomicInteger(2);
306
307 w.schedule(new Runnable() {
308 @Override
309 public void run() {
310 c.decrementAndGet();
311 while (c.get() != 0) { }
312 }
313 });
314
315 c.decrementAndGet();
316 while (c.get() != 0) { }
317 w.dispose();
318 }
319 } finally {
320 exec.shutdownNow();
321 }
322 }
323
324 @Test
325 public void runnableDisposed() {
326 final Scheduler s = Schedulers.from(new Executor() {
327 @Override
328 public void execute(Runnable r) {
329 r.run();
330 }
331 }, false, true);
332 Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE);
333
334 assertTrue(d.isDisposed());
335 }
336
337 @Test
338 public void runnableDisposedAsync() throws Exception {
339 final Scheduler s = Schedulers.from(new Executor() {
340 @Override
341 public void execute(Runnable r) {
342 new Thread(r).start();
343 }
344 }, false, true);
345 Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE);
346
347 while (!d.isDisposed()) {
348 Thread.sleep(1);
349 }
350 }
351
352 @Test
353 public void runnableDisposedAsync2() throws Exception {
354 final Scheduler s = Schedulers.from(executor, false, true);
355 Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE);
356
357 while (!d.isDisposed()) {
358 Thread.sleep(1);
359 }
360 }
361
362 @Test
363 public void runnableDisposedAsyncCrash() throws Exception {
364 final Scheduler s = Schedulers.from(new Executor() {
365 @Override
366 public void execute(Runnable r) {
367 new Thread(r).start();
368 }
369 }, false, true);
370 Disposable d = s.scheduleDirect(new Runnable() {
371 @Override
372 public void run() {
373 throw new IllegalStateException();
374 }
375 });
376
377 while (!d.isDisposed()) {
378 Thread.sleep(1);
379 }
380 }
381
382 @Test
383 public void runnableDisposedAsyncTimed() throws Exception {
384 final Scheduler s = Schedulers.from(new Executor() {
385 @Override
386 public void execute(Runnable r) {
387 new Thread(r).start();
388 }
389 }, false, true);
390 Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.MILLISECONDS);
391
392 while (!d.isDisposed()) {
393 Thread.sleep(1);
394 }
395 }
396
397 @Test
398 public void runnableDisposedAsyncTimed2() throws Exception {
399 ExecutorService executorScheduler = Executors.newScheduledThreadPool(1, new RxThreadFactory("TestCustomPoolTimed"));
400 try {
401 final Scheduler s = Schedulers.from(executorScheduler, false, true);
402 Disposable d = s.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.MILLISECONDS);
403
404 while (!d.isDisposed()) {
405 Thread.sleep(1);
406 }
407 } finally {
408 executorScheduler.shutdownNow();
409 }
410 }
411
412 @Test
413 public void unwrapScheduleDirectTaskAfterDispose() {
414 Scheduler scheduler = getScheduler();
415 final CountDownLatch cdl = new CountDownLatch(1);
416 Runnable countDownRunnable = new Runnable() {
417 @Override
418 public void run() {
419 cdl.countDown();
420 }
421 };
422 Disposable disposable = scheduler.scheduleDirect(countDownRunnable, 100, TimeUnit.MILLISECONDS);
423 SchedulerRunnableIntrospection wrapper = (SchedulerRunnableIntrospection) disposable;
424 assertSame(countDownRunnable, wrapper.getWrappedRunnable());
425 disposable.dispose();
426
427 assertSame(Functions.EMPTY_RUNNABLE, wrapper.getWrappedRunnable());
428 }
429
430 @Test
431 public void fairInterleaving() {
432 ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
433 try {
434 final Scheduler sch = Schedulers.from(exec, false, true);
435
436 PublishProcessor<Integer> pp = PublishProcessor.create();
437
438 TestSubscriber<Integer> ts = pp
439 .publish(new Function<Flowable<Integer>, Flowable<Integer>>() {
440 @Override
441 public Flowable<Integer> apply(Flowable<Integer> v) throws Throwable {
442 return Flowable.merge(
443 v.filter(new Predicate<Integer>() {
444 @Override
445 public boolean test(Integer w) throws Throwable {
446 return w % 2 == 0;
447 }
448 }).observeOn(sch, false, 1).hide(),
449 v.filter(new Predicate<Integer>() {
450 @Override
451 public boolean test(Integer w) throws Throwable {
452 return w % 2 != 0;
453 }
454 }).observeOn(sch, false, 1).hide()
455 );
456 }
457 })
458 .test();
459
460 for (int i = 1; i < 11; i++) {
461 pp.onNext(i);
462 }
463 pp.onComplete();
464
465 ts
466 .awaitDone(5, TimeUnit.SECONDS)
467 .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
468 } finally {
469 exec.shutdown();
470 }
471 }
472
473 @Test
474 public void fairInterleavingWithDelay() {
475 ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
476 try {
477 final Scheduler sch = Schedulers.from(exec, false, true);
478
479 PublishProcessor<Integer> pp = PublishProcessor.create();
480
481 TestSubscriber<Integer> ts = pp
482 .publish(new Function<Flowable<Integer>, Flowable<Integer>>() {
483 @Override
484 public Flowable<Integer> apply(Flowable<Integer> v) throws Throwable {
485 return Flowable.merge(
486 v.filter(new Predicate<Integer>() {
487 @Override
488 public boolean test(Integer w) throws Throwable {
489 return w % 2 == 0;
490 }
491 }).delay(0, TimeUnit.SECONDS, sch).hide(),
492 v.filter(new Predicate<Integer>() {
493 @Override
494 public boolean test(Integer w) throws Throwable {
495 return w % 2 != 0;
496 }
497 }).delay(0, TimeUnit.SECONDS, sch).hide()
498 );
499 }
500 })
501 .test();
502
503 for (int i = 1; i < 11; i++) {
504 pp.onNext(i);
505 }
506 pp.onComplete();
507
508 ts
509 .awaitDone(5, TimeUnit.SECONDS)
510 .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
511 } finally {
512 exec.shutdown();
513 }
514 }
515 }