Examples with CopyOnWriteArrayList java.util.concurrent.CopyOnWriteArrayList used on opensource projects

Example 96 with CopyOnWriteArrayList

use of java.util.concurrent.CopyOnWriteArrayList in project tomee by apache.

the class PoolTest method testFlush.

public void testFlush() throws Exception {
    System.out.println("PoolTest.testFlush");
    final int min = 4;
    final int max = 9;
    final int sweepInterval = 200;
    final List<Bean> discarded = new CopyOnWriteArrayList<Bean>();
    final CountDownLatch discard = new CountDownLatch(max);
    final CountDownLatch created = new CountDownLatch(min);
    final CountDownLatch createInstances = new CountDownLatch(1);
    final Pool.Builder builder = new Pool.Builder();
    builder.setMinSize(min);
    builder.setMaxSize(max);
    builder.setSweepInterval(new Duration(sweepInterval, TimeUnit.MILLISECONDS));
    builder.setSupplier(new Pool.Supplier<Bean>() {

        public void discard(final Bean bean, final Pool.Event reason) {
            bean.discard();
            discarded.add(bean);
            discard.countDown();
        }

        public Bean create() {
            try {
                createInstances.await();
            } catch (final InterruptedException e) {
                Thread.interrupted();
            }
            try {
                return new Bean();
            } finally {
                created.countDown();
            }
        }
    });
    final Pool pool = this.pool = builder.build().start();
    // Fill pool to max
    Bean.instances.set(0);
    for (int i = 0; i < max; i++) {
        assertTrue(pool.add(new Bean()));
    }
    {
        // Should have a full, non-null pool
        final List entries = drain(pool, 100);
        checkMin(min, entries);
        checkEntries(max, entries);
        push(pool, entries);
    }
    pool.flush();
    // Wait for the Evictor to come around and sweep out the pool
    await(discard, 10, TimeUnit.SECONDS);
    // All instances should have been removed
    assertEquals(max, discarded.size());
    for (final Bean bean : discarded) {
        final long flushTime = bean.discarded - bean.accessed;
        // It shouldn't be too much more either
        assertTrue("flush took too long", flushTime < (sweepInterval * 2));
    }
    // Minimum instances are still being created
    // The rest of the pool should be empty (null)
    {
        final List entries = drain(pool, 100);
        // Should have "non-min" number of entries
        checkMax(max - min, entries);
        // Nothing should be a "min" item as those
        // are still being created
        checkMin(0, entries);
        // And as the pool was just drained all the
        // entries we get should be null
        checkNull(entries);
        push(pool, entries);
    }
    Bean.instances.set(0);
    // Try and trick the pool into adding more "min" items
    // Fill the pool as much as we can -- should only let us
    // fill to the max factoring in the "min" instances that
    // are currently being created
    {
        final List entries = drain(pool, 100);
        // Should reject the instance we try to add
        assertFalse(pool.add(new Bean()));
        // Empty the pool
        discard(pool, entries);
        // Now count how many instances it lets us add
        Bean.instances.set(0);
        while (pool.add(new Bean())) ;
        // As the "min" instances are still being created
        // it should only let us fill max - min, then + 1
        // to account for the instance that gets rejected
        // and terminates the while loop
        final int expected = max - min + 1;
        assertEquals(expected, Bean.instances.getAndSet(0));
    }
    // Ok, let the "min" instance creation threads continue
    createInstances.countDown();
    // Wait for the "min" instance creation to complete
    assertTrue(created.await(sweepInterval * 10, TimeUnit.MILLISECONDS));
    {
        // Pool should be full again
        final List entries = drain(pool, 100);
        checkMin(min, entries);
        checkEntries(max, entries);
        push(pool, entries);
    }
//  -- DONE --
}

Example 97 with CopyOnWriteArrayList

use of java.util.concurrent.CopyOnWriteArrayList in project tomee by apache.

the class StatelessContainer method retrieveAroundInvokes.

private List<Method> retrieveAroundInvokes(final Class<?> interceptorClass) {
    final List<Method> cached = this.interceptorCache.get(interceptorClass);
    if (cached != null) {
        return cached;
    }
    final ClassFinder finder = new ClassFinder(interceptorClass);
    List<Method> annotated = finder.findAnnotatedMethods(AroundInvoke.class);
    if (StatelessContainer.class.getClassLoader() == interceptorClass.getClassLoader()) {
        // use cache only for server classes
        final List<Method> value = new CopyOnWriteArrayList<Method>(annotated);
        // ensure it to be thread safe
        annotated = this.interceptorCache.putIfAbsent(interceptorClass, annotated);
        if (annotated == null) {
            annotated = value;
        }
    }
    return annotated;
}