[concurrency-interest] ThreadPoolExecutorTest occasionally fails with a broken barrier!?

Oliver Pfeiffer pfeiffer at tzi.de
Tue Feb 13 17:21:40 EST 2007


Hi,

I'm wondering why the given JUnit test (shown below) occasionally fails with
a broken barrier on multi processor systems using Java 5. The repetitive
test fails 27 times of 10.000 runs on my dual-core system. The test should
check wheter the acquired maximum number of simultaneous pool threads are
usable and that the pool doesn't fail even when the internal task queue is
full (caller runs policy).

Greetings
 Oliver

=====================

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import junit.extensions.RepeatedTest;
import junit.framework.Test;
import junit.framework.TestCase;

public class ThreadPoolExecutorTest extends TestCase {
  
  private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR =
    new ThreadPoolExecutor(
      0, 16, 10, TimeUnit.SECONDS,
      new SynchronousQueue<Runnable>(),
      new ThreadPoolExecutor.CallerRunsPolicy()
    );

  public ThreadPoolExecutorTest(String name) {
    super(name);
  }
  
  public static Test suite() {
    return new RepeatedTest(
      new ThreadPoolExecutorTest("testThreadPoolExecutor"), 10000
    );
  }

  public void testThreadPoolExecutor() throws InterruptedException {
    final int threads = THREAD_POOL_EXECUTOR.getMaximumPoolSize();
    final int loops = threads * 16;
    final CountDownLatch latch = new CountDownLatch(loops);
    final AtomicInteger counter = new AtomicInteger();
    final CyclicBarrier barrier = new CyclicBarrier(threads + 1);
    for (int i = 0; i < loops; i++) {
      THREAD_POOL_EXECUTOR.submit(new Runnable() {
        public void run() {
          if (counter.incrementAndGet() <= barrier.getParties()) {
            try {
              barrier.await(1, TimeUnit.SECONDS);
            } catch (Exception ign) {
              // can be ignored (broken barrier is tested below)
            }
          }
          latch.countDown();
        }
      });
    }
    assertTrue(latch.await(2, TimeUnit.SECONDS));
    assertFalse(barrier.isBroken());
    assertEquals(0, barrier.getNumberWaiting());
    assertEquals(loops, counter.get());
  }

}



More information about the Concurrency-interest mailing list