ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/CyclicBarrierTest.java
(Generate patch)

Comparing jsr166/src/test/tck/CyclicBarrierTest.java (file contents):
Revision 1.21 by jsr166, Sat May 28 14:52:11 2011 UTC vs.
Revision 1.31 by jsr166, Fri Feb 1 19:14:23 2019 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
10 – import java.util.*;
11 – import java.util.concurrent.*;
12 – import java.util.concurrent.locks.*;
13 – import java.util.concurrent.atomic.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  
11 + import java.util.concurrent.BrokenBarrierException;
12 + import java.util.concurrent.CountDownLatch;
13 + import java.util.concurrent.CyclicBarrier;
14 + import java.util.concurrent.ExecutorService;
15 + import java.util.concurrent.Executors;
16 + import java.util.concurrent.ThreadLocalRandom;
17 + import java.util.concurrent.TimeoutException;
18 + import java.util.concurrent.atomic.AtomicBoolean;
19 + import java.util.concurrent.atomic.AtomicInteger;
20 +
21 + import junit.framework.Test;
22 + import junit.framework.TestSuite;
23 +
24   public class CyclicBarrierTest extends JSR166TestCase {
25      public static void main(String[] args) {
26 <        junit.textui.TestRunner.run(suite());
26 >        main(suite(), args);
27      }
28      public static Test suite() {
29          return new TestSuite(CyclicBarrierTest.class);
30      }
31  
32 <    private volatile int countAction;
33 <    private class MyAction implements Runnable {
34 <        public void run() { ++countAction; }
32 >    /**
33 >     * Spin-waits till the number of waiters == numberOfWaiters.
34 >     */
35 >    void awaitNumberWaiting(CyclicBarrier barrier, int numberOfWaiters) {
36 >        long startTime = System.nanoTime();
37 >        while (barrier.getNumberWaiting() != numberOfWaiters) {
38 >            if (millisElapsedSince(startTime) > LONG_DELAY_MS)
39 >                fail("timed out");
40 >            Thread.yield();
41 >        }
42      }
43  
44      /**
45 <     * Creating with negative parties throws IAE
45 >     * Creating with negative parties throws IllegalArgumentException
46       */
47      public void testConstructor1() {
48          try {
# Line 37 | Line 52 | public class CyclicBarrierTest extends J
52      }
53  
54      /**
55 <     * Creating with negative parties and no action throws IAE
55 >     * Creating with negative parties and no action throws
56 >     * IllegalArgumentException
57       */
58      public void testConstructor2() {
59          try {
# Line 71 | Line 87 | public class CyclicBarrierTest extends J
87       * The supplied barrier action is run at barrier
88       */
89      public void testBarrierAction() throws Exception {
90 <        countAction = 0;
91 <        CyclicBarrier b = new CyclicBarrier(1, new MyAction());
90 >        final AtomicInteger count = new AtomicInteger(0);
91 >        final Runnable incCount = new Runnable() { public void run() {
92 >            count.getAndIncrement(); }};
93 >        CyclicBarrier b = new CyclicBarrier(1, incCount);
94          assertEquals(1, b.getParties());
95          assertEquals(0, b.getNumberWaiting());
96          b.await();
97          b.await();
98          assertEquals(0, b.getNumberWaiting());
99 <        assertEquals(countAction, 2);
99 >        assertEquals(2, count.get());
100      }
101  
102      /**
# Line 186 | Line 204 | public class CyclicBarrierTest extends J
204              }});
205          Thread t2 = newStartedThread(new CheckedRunnable() {
206              public void realRun() throws Exception {
207 <                while (c.getNumberWaiting() == 0)
190 <                    Thread.yield();
207 >                awaitNumberWaiting(c, 1);
208                  long startTime = System.nanoTime();
209                  try {
210                      c.await(timeoutMillis(), MILLISECONDS);
# Line 215 | Line 232 | public class CyclicBarrierTest extends J
232              }});
233          Thread t2 = newStartedThread(new CheckedRunnable() {
234              public void realRun() throws Exception {
235 <                while (c.getNumberWaiting() == 0)
219 <                    Thread.yield();
235 >                awaitNumberWaiting(c, 1);
236                  long startTime = System.nanoTime();
237                  try {
238                      c.await(timeoutMillis(), MILLISECONDS);
# Line 250 | Line 266 | public class CyclicBarrierTest extends J
266          t1.start();
267          t2.start();
268          await(pleaseReset);
269 +
270 +        awaitNumberWaiting(c, 2);
271          c.reset();
272          awaitTermination(t1);
273          awaitTermination(t2);
# Line 293 | Line 311 | public class CyclicBarrierTest extends J
311                          c.await();
312                          shouldThrow();
313                      }
314 <                    catch (BrokenBarrierException ok) {}
297 <                    catch (InterruptedException ok) {}
314 >                    catch (BrokenBarrierException | InterruptedException ok) {}
315                  }}});
316  
317          for (int i = 0; i < 4; i++) {
# Line 386 | Line 403 | public class CyclicBarrierTest extends J
403                  }});
404              Thread t2 = newStartedThread(new CheckedRunnable() {
405                  public void realRun() throws Exception {
406 <                    while (barrier.getNumberWaiting() == 0)
390 <                        Thread.yield();
406 >                    awaitNumberWaiting(barrier, 1);
407                      long startTime = System.nanoTime();
408                      try {
409                          barrier.await(timeoutMillis(), MILLISECONDS);
# Line 432 | Line 448 | public class CyclicBarrierTest extends J
448              t1.start();
449              t2.start();
450              start.await();
451 <            while (barrier.getNumberWaiting() < 2) { Thread.yield(); }
451 >            awaitNumberWaiting(barrier, 2);
452              try {
453                  barrier.await();
454                  shouldThrow();
# Line 446 | Line 462 | public class CyclicBarrierTest extends J
462              assertEquals(0, barrier.getNumberWaiting());
463          }
464      }
465 +
466 +    /**
467 +     * There can be more threads calling await() than parties, as long as each
468 +     * task only calls await once and the task count is a multiple of parties.
469 +     */
470 +    public void testMoreTasksThanParties() throws Exception {
471 +        final ThreadLocalRandom rnd = ThreadLocalRandom.current();
472 +        final int parties = rnd.nextInt(1, 5);
473 +        final int nTasks = rnd.nextInt(1, 5) * parties;
474 +        final AtomicInteger tripCount = new AtomicInteger(0);
475 +        final AtomicInteger awaitCount = new AtomicInteger(0);
476 +        final CyclicBarrier barrier =
477 +            new CyclicBarrier(parties, () -> tripCount.getAndIncrement());
478 +        final ExecutorService e = Executors.newFixedThreadPool(nTasks);
479 +        final Runnable awaiter = () -> {
480 +            try {
481 +                if (ThreadLocalRandom.current().nextBoolean())
482 +                    barrier.await();
483 +                else
484 +                    barrier.await(LONG_DELAY_MS, MILLISECONDS);
485 +                awaitCount.getAndIncrement();
486 +            } catch (Throwable fail) { threadUnexpectedException(fail); }};
487 +        try (PoolCleaner cleaner = cleaner(e)) {
488 +            for (int i = nTasks; i--> 0; )
489 +                e.execute(awaiter);
490 +        }
491 +        assertEquals(nTasks / parties, tripCount.get());
492 +        assertEquals(nTasks, awaitCount.get());
493 +        assertEquals(0, barrier.getNumberWaiting());
494 +    }
495   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines