コード例 #1
0
  @Test
  public void testLatchOnSingleThread() throws Exception {
    ReusableLatch latch = new ReusableLatch();

    for (int i = 1; i <= 100; i++) {
      latch.countUp();
      Assert.assertEquals(i, latch.getCount());
    }

    for (int i = 100; i > 0; i--) {
      Assert.assertEquals(i, latch.getCount());
      latch.countDown();
      Assert.assertEquals(i - 1, latch.getCount());
    }

    latch.await();
  }
コード例 #2
0
  @Test
  public void testLatchWithParameterizedDown() throws Exception {
    ReusableLatch latch = new ReusableLatch(1000);

    latch.countDown(5000);

    assertTrue(latch.await(1000));

    assertEquals(0, latch.getCount());
  }
コード例 #3
0
  /**
   * This test will open numberOfThreads threads, and add numberOfAdds on the VariableLatch After
   * those addthreads are finished, the latch count should be numberOfThreads * numberOfAdds Then it
   * will open numberOfThreads threads again releasing numberOfAdds on the VariableLatch After those
   * releaseThreads are finished, the latch count should be 0 And all the waiting threads should be
   * finished also
   *
   * @throws Exception
   */
  @Test
  public void testLatchOnMultiThread() throws Exception {
    final ReusableLatch latch = new ReusableLatch();

    latch.countUp(); // We hold at least one, so ThreadWaits won't go away

    final int numberOfThreads = 100;
    final int numberOfAdds = 100;

    class ThreadWait extends Thread {
      private volatile boolean waiting = true;

      @Override
      public void run() {
        try {
          if (!latch.await(5000)) {
            UnitTestLogger.LOGGER.error("Latch timed out");
          }
        } catch (Exception e) {
          UnitTestLogger.LOGGER.error(e);
        }
        waiting = false;
      }
    }

    class ThreadAdd extends Thread {
      private final CountDownLatch latchReady;

      private final CountDownLatch latchStart;

      ThreadAdd(final CountDownLatch latchReady, final CountDownLatch latchStart) {
        this.latchReady = latchReady;
        this.latchStart = latchStart;
      }

      @Override
      public void run() {
        try {
          latchReady.countDown();
          // Everybody should start at the same time, to worse concurrency
          // effects
          latchStart.await();
          for (int i = 0; i < numberOfAdds; i++) {
            latch.countUp();
          }
        } catch (Exception e) {
          UnitTestLogger.LOGGER.error(e.getMessage(), e);
        }
      }
    }

    CountDownLatch latchReady = new CountDownLatch(numberOfThreads);
    CountDownLatch latchStart = new CountDownLatch(1);

    ThreadAdd[] threadAdds = new ThreadAdd[numberOfThreads];
    ThreadWait waits[] = new ThreadWait[numberOfThreads];

    for (int i = 0; i < numberOfThreads; i++) {
      threadAdds[i] = new ThreadAdd(latchReady, latchStart);
      threadAdds[i].start();
      waits[i] = new ThreadWait();
      waits[i].start();
    }

    latchReady.await();
    latchStart.countDown();

    for (int i = 0; i < numberOfThreads; i++) {
      threadAdds[i].join();
    }

    for (int i = 0; i < numberOfThreads; i++) {
      Assert.assertTrue(waits[i].waiting);
    }

    Assert.assertEquals(numberOfThreads * numberOfAdds + 1, latch.getCount());

    class ThreadDown extends Thread {
      private final CountDownLatch latchReady;

      private final CountDownLatch latchStart;

      ThreadDown(final CountDownLatch latchReady, final CountDownLatch latchStart) {
        this.latchReady = latchReady;
        this.latchStart = latchStart;
      }

      @Override
      public void run() {
        try {
          latchReady.countDown();
          // Everybody should start at the same time, to worse concurrency
          // effects
          latchStart.await();
          for (int i = 0; i < numberOfAdds; i++) {
            latch.countDown();
          }
        } catch (Exception e) {
          UnitTestLogger.LOGGER.error(e.getMessage(), e);
        }
      }
    }

    latchReady = new CountDownLatch(numberOfThreads);
    latchStart = new CountDownLatch(1);

    ThreadDown down[] = new ThreadDown[numberOfThreads];

    for (int i = 0; i < numberOfThreads; i++) {
      down[i] = new ThreadDown(latchReady, latchStart);
      down[i].start();
    }

    latchReady.await();
    latchStart.countDown();

    for (int i = 0; i < numberOfThreads; i++) {
      down[i].join();
    }

    Assert.assertEquals(1, latch.getCount());

    for (int i = 0; i < numberOfThreads; i++) {
      Assert.assertTrue(waits[i].waiting);
    }

    latch.countDown();

    for (int i = 0; i < numberOfThreads; i++) {
      waits[i].join();
    }

    Assert.assertEquals(0, latch.getCount());

    for (int i = 0; i < numberOfThreads; i++) {
      Assert.assertFalse(waits[i].waiting);
    }
  }
コード例 #4
0
  @Test
  public void testReuseLatch() throws Exception {
    final ReusableLatch latch = new ReusableLatch(5);
    for (int i = 0; i < 5; i++) {
      latch.countDown();
    }

    latch.countUp();

    class ThreadWait extends Thread {
      private volatile boolean waiting = false;

      private volatile Exception e;

      private final CountDownLatch readyLatch = new CountDownLatch(1);

      @Override
      public void run() {
        waiting = true;
        readyLatch.countDown();
        try {
          if (!latch.await(1000)) {
            UnitTestLogger.LOGGER.error("Latch timed out!", new Exception("trace"));
          }
        } catch (Exception e) {
          UnitTestLogger.LOGGER.error(e);
          this.e = e;
        }
        waiting = false;
      }
    }

    ThreadWait t = new ThreadWait();
    t.start();

    t.readyLatch.await();

    Assert.assertEquals(true, t.waiting);

    latch.countDown();

    t.join();

    Assert.assertEquals(false, t.waiting);

    Assert.assertNull(t.e);

    latch.countUp();

    t = new ThreadWait();
    t.start();

    t.readyLatch.await();

    Assert.assertEquals(true, t.waiting);

    latch.countDown();

    t.join();

    Assert.assertEquals(false, t.waiting);

    Assert.assertNull(t.e);

    Assert.assertTrue(latch.await(1000));

    Assert.assertEquals(0, latch.getCount());

    latch.countDown();

    Assert.assertEquals(0, latch.getCount());
  }