commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Benedikt Ritter <brit...@apache.org>
Subject Re: svn commit: r1661762 - in /commons/proper/lang/trunk/src: changes/ main/java/org/apache/commons/lang3/concurrent/ test/java/org/apache/commons/lang3/concurrent/
Date Wed, 25 Feb 2015 14:20:44 GMT
2015-02-23 21:47 GMT+01:00 Oliver Heger <oliver.heger@oliver-heger.de>:

>
>
> Am 23.02.2015 um 21:35 schrieb Benedikt Ritter:
> > Oliver Heger has raised concerns about this commit in JIRA [1]:
> >
> >> This is a strong change in the behavior of this class. The main property
> > of atomic initializers was that they are non
> >> blocking. Now a blocking wait has been introduced. When there is so much
> > contention that the busy wait is
> >> actually a problem, wouln't it then be better to directly use a blocking
> > variant like lazy initializer?
> >
> > I've looked through the JavaDoc of AtomicInitializer once more. It says:
> > "Because {@code AtomicSafeInitializer} does not use synchronization at
> all
> > it probably outruns {@link LazyInitializer}, at least under low or
> moderate
> > concurrent access."
> >
> > This is the only thing I can find regarding concurrency properties of
> > AtomicInitializer. I think this still holds, doesn't it?
>
> No, the CountDownLatch is synchronized.
>
> There are multiple initializer implementations with different properties
> which are suitable for different use cases and scenarios. The atomic
> initializers are useful if you want to avoid blocking calls, but they
> might be an inferior solution under high contention.
>
> My fear is that this commit optimizes the class for a use case which can
> be served better by another initializer implementation which is already
> blocking; and this optimization has negative impact on the original
> intention of AtomicSafeInitializer.
>

Okay. Looks like we should address this intend better in the JavaDoc of
AtomicSafeInitializer. Maybe it should even have a better name like
BusyWaitInitializer (could be changed for lang4).

Do you think the changes made to AtomicSafeInitializer are an optimization
that would better fit into LazyInitializer?

I'll revert this change as soon as I get the time.

Benedikt


>
> Oliver
>
> >
> > Benedikt
> >
> > [1] https://issues.apache.org/jira/browse/LANG-1086
> >
> > 2015-02-23 21:15 GMT+01:00 <britter@apache.org>:
> >
> >> Author: britter
> >> Date: Mon Feb 23 20:15:49 2015
> >> New Revision: 1661762
> >>
> >> URL: http://svn.apache.org/r1661762
> >> Log:
> >> LANG-1086: Remove busy wait from AtomicSafeInitializer.get(). This also
> >> fixes #46 from github. Thanks to github user artnaseef.
> >>
> >> Modified:
> >>     commons/proper/lang/trunk/src/changes/changes.xml
> >>
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializer.java
> >>
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AbstractConcurrentInitializerTest.java
> >>
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicInitializerTest.java
> >>
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializerTest.java
> >>
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/LazyInitializerTest.java
> >>
> >> Modified: commons/proper/lang/trunk/src/changes/changes.xml
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/changes/changes.xml?rev=1661762&r1=1661761&r2=1661762&view=diff
> >>
> >>
> ==============================================================================
> >> --- commons/proper/lang/trunk/src/changes/changes.xml [utf-8] (original)
> >> +++ commons/proper/lang/trunk/src/changes/changes.xml [utf-8] Mon Feb 23
> >> 20:15:49 2015
> >> @@ -22,6 +22,7 @@
> >>    <body>
> >>
> >>    <release version="3.4" date="tba" description="tba">
> >> +    <action issue="LANG-1086" type="update" dev="britter">Remove busy
> >> wait from AtomicSafeInitializer.get()</action>
> >>      <action issue="LANG-1081" type="fix" dev="britter" due-to="Jonathan
> >> Baker">DiffBuilder.append(String, Object left, Object right) does not
> do a
> >> left.equals(right) check</action>
> >>      <action issue="LANG-1055" type="fix" dev="britter" due-to="Jonathan
> >> Baker">StrSubstitutor.replaceSystemProperties does not work
> >> consistently</action>
> >>      <action issue="LANG-1082" type="add" dev="britter" due-to="Jonathan
> >> Baker">Add option to disable the "objectsTriviallyEqual" test in
> >> DiffBuilder</action>
> >>
> >> Modified:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializer.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializer.java?rev=1661762&r1=1661761&r2=1661762&view=diff
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializer.java
> >> (original)
> >> +++
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializer.java
> >> Mon Feb 23 20:15:49 2015
> >> @@ -16,6 +16,7 @@
> >>   */
> >>  package org.apache.commons.lang3.concurrent;
> >>
> >> +import java.util.concurrent.CountDownLatch;
> >>  import java.util.concurrent.atomic.AtomicReference;
> >>
> >>  /**
> >> @@ -62,20 +63,44 @@ public abstract class AtomicSafeInitiali
> >>      /** Holds the reference to the managed object. */
> >>      private final AtomicReference<T> reference = new
> AtomicReference<T>();
> >>
> >> +    /** Holds the exception that terminated the initialize() method, if
> >> an exception was thrown */
> >> +    private final AtomicReference<ConcurrentException> referenceExc =
> new
> >> AtomicReference<ConcurrentException>();
> >> +
> >> +    /** Latch for those threads waiting for initialization to
> complete. */
> >> +    private final CountDownLatch latch = new CountDownLatch(1);
> >> +
> >>      /**
> >>       * Get (and initialize, if not initialized yet) the required object
> >>       *
> >>       * @return lazily initialized object
> >>       * @throws ConcurrentException if the initialization of the object
> >> causes an
> >> -     * exception
> >> +     * exception or the thread is interrupted waiting for another
> thread
> >> to
> >> +     * complete the initialization
> >>       */
> >>      @Override
> >>      public final T get() throws ConcurrentException {
> >>          T result;
> >>
> >> -        while ((result = reference.get()) == null) {
> >> +        if ((result = reference.get()) == null) {
> >>              if (factory.compareAndSet(null, this)) {
> >> -                reference.set(initialize());
> >> +                try {
> >> +                    reference.set(result = initialize());
> >> +                } catch ( ConcurrentException exc ) {
> >> +                    referenceExc.set(exc);
> >> +                    throw exc;
> >> +                } finally {
> >> +                    latch.countDown();
> >> +                }
> >> +            } else {
> >> +                try {
> >> +                    latch.await();
> >> +                    if ( referenceExc.get() != null ) {
> >> +                        throw new
> >> ConcurrentException(referenceExc.get().getMessage(),
> >> referenceExc.get().getCause());
> >> +                    }
> >> +                    result = reference.get();
> >> +                } catch (InterruptedException intExc) {
> >> +                    throw new ConcurrentException("interrupted waiting
> >> for initialization to complete", intExc);
> >> +                }
> >>              }
> >>          }
> >>
> >>
> >> Modified:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AbstractConcurrentInitializerTest.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AbstractConcurrentInitializerTest.java?rev=1661762&r1=1661761&r2=1661762&view=diff
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AbstractConcurrentInitializerTest.java
> >> (original)
> >> +++
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AbstractConcurrentInitializerTest.java
> >> Mon Feb 23 20:15:49 2015
> >> @@ -18,6 +18,8 @@ package org.apache.commons.lang3.concurr
> >>
> >>  import static org.junit.Assert.assertEquals;
> >>  import static org.junit.Assert.assertNotNull;
> >> +import static org.junit.Assert.assertSame;
> >> +import static org.junit.Assert.assertTrue;
> >>
> >>  import java.util.concurrent.CountDownLatch;
> >>
> >> @@ -72,7 +74,41 @@ public abstract class AbstractConcurrent
> >>      @Test
> >>      public void testGetConcurrent() throws ConcurrentException,
> >>              InterruptedException {
> >> -        final ConcurrentInitializer<Object> initializer =
> >> createInitializer();
> >> +
> >> +        this.testGetConcurrentOptionallyWithException(false, null,
> null);
> >> +    }
> >> +
> >> +    /**
> >> +     * Tests the handling of exceptions thrown on the initialized when
> >> multiple threads execute concurrently.
> >> +     * Always an exception with the same message and cause should be
> >> thrown.
> >> +     *
> >> +     * @throws org.apache.commons.lang3.concurrent.ConcurrentException
> >> because the object under test may throw it
> >> +     * @throws java.lang.InterruptedException because the threading API
> >> my throw it
> >> +     */
> >> +    public void testGetConcurrentWithException(String expectedMessage,
> >> +                                               Exception expectedCause)
> >> +            throws ConcurrentException, InterruptedException {
> >> +
> >> +        this.testGetConcurrentOptionallyWithException(true,
> >> expectedMessage, expectedCause);
> >> +    }
> >> +
> >> +    /**
> >> +     * Tests whether get() can be invoked from multiple threads
> >> concurrently.  Supports the exception-handling case
> >> +     * and the normal, non-exception case.
> >> +     *
> >> +     * Always the same object should be returned, or an exception with
> >> the same message and cause should be thrown.
> >> +     *
> >> +     * @throws org.apache.commons.lang3.concurrent.ConcurrentException
> >> because the object under test may throw it
> >> +     * @throws java.lang.InterruptedException because the threading API
> >> my throw it
> >> +     */
> >> +    protected void testGetConcurrentOptionallyWithException(boolean
> >> expectExceptions, String expectedMessage,
> >> +                                                            Exception
> >> expectedCause)
> >> +            throws ConcurrentException, InterruptedException {
> >> +
> >> +        final ConcurrentInitializer<Object> initializer =
> >> expectExceptions ?
> >> +                createExceptionThrowingInitializer() :
> >> +                createInitializer();
> >> +
> >>          final int threadCount = 20;
> >>          final CountDownLatch startLatch = new CountDownLatch(1);
> >>          class GetThread extends Thread {
> >> @@ -106,9 +142,18 @@ public abstract class AbstractConcurrent
> >>          }
> >>
> >>          // check results
> >> -        final Object managedObject = initializer.get();
> >> -        for (final GetThread t : threads) {
> >> -            assertEquals("Wrong object", managedObject, t.object);
> >> +        if ( expectExceptions ) {
> >> +            for (GetThread t : threads) {
> >> +                assertTrue(t.object instanceof Exception);
> >> +                Exception exc = (Exception) t.object;
> >> +                assertEquals(expectedMessage, exc.getMessage());
> >> +                assertSame(expectedCause, exc.getCause());
> >> +            }
> >> +        } else {
> >> +            final Object managedObject = initializer.get();
> >> +            for (final GetThread t : threads) {
> >> +                assertEquals("Wrong object", managedObject, t.object);
> >> +            }
> >>          }
> >>      }
> >>
> >> @@ -119,4 +164,12 @@ public abstract class AbstractConcurrent
> >>       * @return the initializer object to be tested
> >>       */
> >>      protected abstract ConcurrentInitializer<Object>
> createInitializer();
> >> +
> >> +    /**
> >> +     * Creates a {@link ConcurrentInitializer} object that always
> throws
> >> +     * exceptions.
> >> +     *
> >> +     * @return
> >> +     */
> >> +    protected abstract ConcurrentInitializer<Object>
> >> createExceptionThrowingInitializer();
> >>  }
> >>
> >> Modified:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicInitializerTest.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicInitializerTest.java?rev=1661762&r1=1661761&r2=1661762&view=diff
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicInitializerTest.java
> >> (original)
> >> +++
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicInitializerTest.java
> >> Mon Feb 23 20:15:49 2015
> >> @@ -16,12 +16,29 @@
> >>   */
> >>  package org.apache.commons.lang3.concurrent;
> >>
> >> +import org.junit.Test;
> >> +
> >>  /**
> >>   * Test class for {@code AtomicInitializer}.
> >>   *
> >>   * @version $Id$
> >>   */
> >>  public class AtomicInitializerTest extends
> >> AbstractConcurrentInitializerTest {
> >> +    private Exception testCauseException;
> >> +    private String testExceptionMessage;
> >> +
> >> +    public AtomicInitializerTest() {
> >> +        testExceptionMessage = "x-test-exception-message-x";
> >> +        testCauseException = new Exception(testExceptionMessage);
> >> +    }
> >> +
> >> +    @Test
> >> +    public void testGetConcurrentWithException ()
> >> +            throws ConcurrentException, InterruptedException {
> >> +
> >> +        super.testGetConcurrentWithException(testExceptionMessage,
> >> testCauseException);
> >> +    }
> >> +
> >>      /**
> >>       * Returns the initializer to be tested.
> >>       *
> >> @@ -36,4 +53,20 @@ public class AtomicInitializerTest exten
> >>              }
> >>          };
> >>      }
> >> +
> >> +    @Override
> >> +    protected ConcurrentInitializer<Object>
> >> createExceptionThrowingInitializer() {
> >> +        return new ExceptionThrowingAtomicSafeInitializerTestImpl();
> >> +    }
> >> +
> >> +    /**
> >> +     * A concrete test implementation of {@code AtomicSafeInitializer}.
> >> This
> >> +     * implementation always throws an exception.
> >> +     */
> >> +    private class ExceptionThrowingAtomicSafeInitializerTestImpl
> extends
> >> AtomicSafeInitializer<Object> {
> >> +        @Override
> >> +        protected Object initialize() throws ConcurrentException {
> >> +            throw new ConcurrentException(testExceptionMessage,
> >> testCauseException);
> >> +        }
> >> +    }
> >>  }
> >>
> >> Modified:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializerTest.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializerTest.java?rev=1661762&r1=1661761&r2=1661762&view=diff
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializerTest.java
> >> (original)
> >> +++
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/AtomicSafeInitializerTest.java
> >> Mon Feb 23 20:15:49 2015
> >> @@ -17,7 +17,11 @@
> >>  package org.apache.commons.lang3.concurrent;
> >>
> >>  import static org.junit.Assert.assertEquals;
> >> +import static org.junit.Assert.assertFalse;
> >> +import static org.junit.Assert.assertSame;
> >> +import static org.junit.Assert.assertTrue;
> >>
> >> +import java.util.concurrent.CountDownLatch;
> >>  import java.util.concurrent.atomic.AtomicInteger;
> >>
> >>  import org.junit.Before;
> >> @@ -30,12 +34,19 @@ import org.junit.Test;
> >>   */
> >>  public class AtomicSafeInitializerTest extends
> >>          AbstractConcurrentInitializerTest {
> >> +
> >>      /** The instance to be tested. */
> >>      private AtomicSafeInitializerTestImpl initializer;
> >> +    private ExceptionThrowingAtomicSafeInitializerTestImpl
> >> exceptionThrowingInitializer;
> >> +    private Exception testCauseException;
> >> +    private String testExceptionMessage;
> >>
> >>      @Before
> >>      public void setUp() throws Exception {
> >>          initializer = new AtomicSafeInitializerTestImpl();
> >> +        exceptionThrowingInitializer = new
> >> ExceptionThrowingAtomicSafeInitializerTestImpl();
> >> +        testExceptionMessage = "x-test-exception-message-x";
> >> +        testCauseException = new Exception(testExceptionMessage);
> >>      }
> >>
> >>      /**
> >> @@ -49,6 +60,17 @@ public class AtomicSafeInitializerTest e
> >>      }
> >>
> >>      /**
> >> +     * Returns the exception-throwing initializer to be tested.
> >> +     *
> >> +     * @return the {@code AtomicSafeInitializer} under test when
> >> validating
> >> +     * exception handling
> >> +     */
> >> +    @Override
> >> +    protected ConcurrentInitializer<Object>
> >> createExceptionThrowingInitializer() {
> >> +        return exceptionThrowingInitializer;
> >> +    }
> >> +
> >> +    /**
> >>       * Tests that initialize() is called only once.
> >>       *
> >>       * @throws org.apache.commons.lang3.concurrent.ConcurrentException
> >> because {@link #testGetConcurrent()} may throw it
> >> @@ -62,6 +84,92 @@ public class AtomicSafeInitializerTest e
> >>                  initializer.initCounter.get());
> >>      }
> >>
> >> +    @Test
> >> +    public void testExceptionOnInitialize() throws ConcurrentException,
> >> +            InterruptedException {
> >> +
> >> +        testGetConcurrentWithException(testExceptionMessage,
> >> testCauseException);
> >> +    }
> >> +
> >> +    /**
> >> +     * Validate the handling of an interrupted exception on a thread
> >> waiting for another thread to finish calling the
> >> +     * initialize() method.
> >> +     *
> >> +     * @throws Exception
> >> +     */
> >> +    @Test(timeout = 3000)
> >> +    public void testInterruptedWaitingOnInitialize() throws Exception {
> >> +        this.execTestWithWaitingOnInitialize(true);
> >> +    }
> >> +
> >> +    /**
> >> +     * Test the success path of two threads reaching the initialization
> >> point at the same time.
> >> +     */
> >> +    @Test(timeout = 3000)
> >> +    public void testOneThreadWaitingForAnotherToInitialize () throws
> >> Exception {
> >> +        execTestWithWaitingOnInitialize(false);
> >> +    }
> >> +
> >> +
> >> +    /**
> >> +     * Execute a test that requires one thread to be waiting on the
> >> initialize() method of another thread.  This test
> >> +     * uses latches to guarantee the code path being tested.
> >> +     *
> >> +     * @throws Exception
> >> +     */
> >> +    protected void execTestWithWaitingOnInitialize(boolean
> interruptInd)
> >> throws Exception {
> >> +        final CountDownLatch startLatch = new CountDownLatch(1);
> >> +        final CountDownLatch finishLatch = new CountDownLatch(1);
> >> +        final WaitingInitializerTestImpl initializer = new
> >> WaitingInitializerTestImpl(startLatch, finishLatch);
> >> +
> >> +        InitializerTestThread execThread1 = new
> >> InitializerTestThread(initializer);
> >> +        InitializerTestThread execThread2 = new
> >> InitializerTestThread(initializer);
> >> +
> >> +        // Start the first thread and wait for it to get into the
> >> initialize method so we are sure it is the thread
> >> +        //  executing initialize().
> >> +        execThread1.start();
> >> +        startLatch.await();
> >> +
> >> +        // Start the second thread and interrupt it to force the
> >> InterruptedException.  There is no need to make sure
> >> +        //  the thread reaches the await() call before interrupting it.
> >> +        execThread2.start();
> >> +
> >> +        if ( interruptInd ) {
> >> +            // Interrupt the second thread now and wait for it to
> >> complete to ensure it reaches the wait inside the
> >> +            //  get() method.
> >> +            execThread2.interrupt();
> >> +            execThread2.join();
> >> +        }
> >> +
> >> +        // Signal the completion of the initialize method now.
> >> +        finishLatch.countDown();
> >> +
> >> +        // Wait for the initialize() to finish.
> >> +        execThread1.join();
> >> +
> >> +        // Wait for thread2 to finish, if it was not already done
> >> +        if ( ! interruptInd ) {
> >> +            execThread2.join();
> >> +        }
> >> +
> >> +        //
> >> +        // Validate: thread1 should have the valid result; thread2
> should
> >> have caught an interrupted exception, if
> >> +        //  interrupted, or should have the same result otherwise.
> >> +        //
> >> +        assertFalse(execThread1.isCaughtException());
> >> +        assertSame(initializer.getAnswer(), execThread1.getResult());
> >> +
> >> +        if ( interruptInd ) {
> >> +            assertTrue(execThread2.isCaughtException());
> >> +            Exception exc = (Exception) execThread2.getResult();
> >> +            assertTrue(exc.getCause() instanceof InterruptedException);
> >> +            assertEquals("interrupted waiting for initialization to
> >> complete", exc.getMessage());
> >> +        } else {
> >> +            assertFalse(execThread2.isCaughtException());
> >> +            assertSame(initializer.getAnswer(),
> execThread2.getResult());
> >> +        }
> >> +    }
> >> +
> >>      /**
> >>       * A concrete test implementation of {@code AtomicSafeInitializer}.
> >> This
> >>       * implementation also counts the number of invocations of the
> >> initialize()
> >> @@ -78,4 +186,90 @@ public class AtomicSafeInitializerTest e
> >>              return new Object();
> >>          }
> >>      }
> >> +
> >> +    /**
> >> +     * A concrete test implementation of {@code AtomicSafeInitializer}.
> >> This
> >> +     * implementation always throws an exception.
> >> +     */
> >> +    private class ExceptionThrowingAtomicSafeInitializerTestImpl
> extends
> >> AtomicSafeInitializer<Object> {
> >> +        @Override
> >> +        protected Object initialize() throws ConcurrentException {
> >> +            throw new ConcurrentException(testExceptionMessage,
> >> testCauseException);
> >> +        }
> >> +    }
> >> +
> >> +    /**
> >> +     * Initializer that signals it has started and waits to complete
> >> until signalled in order to enable a guaranteed
> >> +     * order-of-operations.  This allows the test code to peg one
> thread
> >> to the initialize method for a period of time
> >> +     * that the test can dictate.
> >> +     */
> >> +    private class WaitingInitializerTestImpl extends
> >> AtomicSafeInitializer<Object> {
> >> +        private final CountDownLatch startedLatch;
> >> +        private final CountDownLatch finishLatch;
> >> +        private final Object answer = new Object();
> >> +
> >> +        public WaitingInitializerTestImpl(CountDownLatch startedLatch,
> >> CountDownLatch finishLatch) {
> >> +            this.startedLatch = startedLatch;
> >> +            this.finishLatch = finishLatch;
> >> +        }
> >> +
> >> +        @Override
> >> +        protected Object initialize() throws ConcurrentException {
> >> +            this.startedLatch.countDown();
> >> +            try {
> >> +                this.finishLatch.await();
> >> +            } catch (InterruptedException intExc) {
> >> +                throw new ConcurrentException(intExc);
> >> +            }
> >> +
> >> +            return  answer;
> >> +        }
> >> +
> >> +        public Object getAnswer () {
> >> +            return answer;
> >> +        }
> >> +    }
> >> +
> >> +    /**
> >> +     * Test executor of the initializer get() operation that captures
> the
> >> result.
> >> +     */
> >> +    private class InitializerTestThread extends Thread {
> >> +        private AtomicSafeInitializer<Object>   initializer;
> >> +        private Object result;
> >> +        private boolean caughtException;
> >> +
> >> +        public InitializerTestThread(AtomicSafeInitializer<Object>
> >> initializer) {
> >> +            super("AtomicSafeInitializer test thread");
> >> +            this.initializer = initializer;
> >> +        }
> >> +
> >> +        @Override
> >> +        public void run() {
> >> +            try {
> >> +                this.result = initializer.get();
> >> +            } catch ( ConcurrentException concurrentExc ) {
> >> +                this.caughtException = true;
> >> +                this.result = concurrentExc;
> >> +            }
> >> +        }
> >> +
> >> +        /**
> >> +         * Resulting object, if the get() method returned successfully,
> >> or exception if an exception was thrown.
> >> +         *
> >> +         * @return resulting object or exception from the get() method
> >> call.
> >> +         */
> >> +        public Object getResult () {
> >> +            return  this.result;
> >> +        }
> >> +
> >> +        /**
> >> +         * Determine whether an exception was caught on the get() call.
> >> Does not guarantee that the get() method was
> >> +         * called or completed.
> >> +         *
> >> +         * @return true => exception was caught; false => exception was
> >> not caught.
> >> +         */
> >> +        public boolean  isCaughtException () {
> >> +            return  this.caughtException;
> >> +        }
> >> +    }
> >>  }
> >>
> >> Modified:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/LazyInitializerTest.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/LazyInitializerTest.java?rev=1661762&r1=1661761&r2=1661762&view=diff
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/LazyInitializerTest.java
> >> (original)
> >> +++
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/concurrent/LazyInitializerTest.java
> >> Mon Feb 23 20:15:49 2015
> >> @@ -17,6 +17,7 @@
> >>  package org.apache.commons.lang3.concurrent;
> >>
> >>  import org.junit.Before;
> >> +import org.junit.Test;
> >>
> >>  /**
> >>   * Test class for {@code LazyInitializer}.
> >> @@ -26,10 +27,16 @@ import org.junit.Before;
> >>  public class LazyInitializerTest extends
> >> AbstractConcurrentInitializerTest {
> >>      /** The initializer to be tested. */
> >>      private LazyInitializerTestImpl initializer;
> >> +    private ExceptionThrowingLazyInitializerTestImpl
> >> exceptionThrowingInitializer;
> >> +    private Exception testCauseException;
> >> +    private String testExceptionMessage;
> >>
> >>      @Before
> >>      public void setUp() throws Exception {
> >>          initializer = new LazyInitializerTestImpl();
> >> +        exceptionThrowingInitializer = new
> >> ExceptionThrowingLazyInitializerTestImpl();
> >> +        testExceptionMessage = "x-test-exception-message-x";
> >> +        testCauseException = new Exception(testExceptionMessage);
> >>      }
> >>
> >>      /**
> >> @@ -43,6 +50,18 @@ public class LazyInitializerTest extends
> >>          return initializer;
> >>      }
> >>
> >> +    @Override
> >> +    protected ConcurrentInitializer<Object>
> >> createExceptionThrowingInitializer() {
> >> +        return exceptionThrowingInitializer;
> >> +    }
> >> +
> >> +    @Test
> >> +    public void testGetConcurrentWithException ()
> >> +            throws ConcurrentException, InterruptedException {
> >> +
> >> +        super.testGetConcurrentWithException(testExceptionMessage,
> >> testCauseException);
> >> +    }
> >> +
> >>      /**
> >>       * A test implementation of LazyInitializer. This class creates a
> >> plain
> >>       * Object. As Object does not provide a specific equals() method,
> it
> >> is easy
> >> @@ -55,4 +74,16 @@ public class LazyInitializerTest extends
> >>              return new Object();
> >>          }
> >>      }
> >> +
> >> +
> >> +    /**
> >> +     * A concrete test implementation of {@code AtomicSafeInitializer}.
> >> This
> >> +     * implementation always throws an exception.
> >> +     */
> >> +    private class ExceptionThrowingLazyInitializerTestImpl extends
> >> LazyInitializer<Object> {
> >> +        @Override
> >> +        protected Object initialize() throws ConcurrentException {
> >> +            throw new ConcurrentException(testExceptionMessage,
> >> testCauseException);
> >> +        }
> >> +    }
> >>  }
> >>
> >>
> >>
> >
> >
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
> For additional commands, e-mail: dev-help@commons.apache.org
>
>


-- 
http://people.apache.org/~britter/
http://www.systemoutprintln.de/
http://twitter.com/BenediktRitter
http://github.com/britter

Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message