/** * Returns a synchronized buffer backed by the given buffer that will * block on {@link Buffer#get()} and {@link Buffer#remove()} operations. * If the buffer is empty, then the {@link Buffer#get()} and * {@link Buffer#remove()} operations will block until new elements * are added to the buffer, rather than immediately throwing a * <code>BufferUnderflowException</code>. * * @param buffer the buffer to synchronize, must not be null * @return a blocking buffer backed by that buffer * @throws IllegalArgumentException if the Buffer is null */ public static Buffer blockingBuffer(Buffer buffer) { return BlockingBuffer.decorate(buffer); }
/** * Returns a synchronized buffer backed by the given buffer that will * block on {@link Buffer#get()} and {@link Buffer#remove()} operations * until <code>timeout</code> expires. If the buffer is empty, then the * {@link Buffer#get()} and {@link Buffer#remove()} operations will block * until new elements are added to the buffer, rather than immediately * throwing a <code>BufferUnderflowException</code>. * * @param buffer the buffer to synchronize, must not be null * @param timeoutMillis the timeout value in milliseconds, zero or less for no timeout * @return a blocking buffer backed by that buffer * @throws IllegalArgumentException if the Buffer is null * @since Commons Collections 3.2 */ public static Buffer blockingBuffer(Buffer buffer, long timeoutMillis) { return BlockingBuffer.decorate(buffer, timeoutMillis); }
/** * Returns a synchronized buffer backed by the given buffer that will * block on {@link Buffer#get()} and {@link Buffer#remove()} operations. * If the buffer is empty, then the {@link Buffer#get()} and * {@link Buffer#remove()} operations will block until new elements * are added to the buffer, rather than immediately throwing a * <code>BufferUnderflowException</code>. * * @param buffer the buffer to synchronize, must not be null * @return a blocking buffer backed by that buffer * @throws IllegalArgumentException if the Buffer is null */ public static Buffer blockingBuffer(Buffer buffer) { return BlockingBuffer.decorate(buffer); }
/** * Returns a synchronized buffer backed by the given buffer that will * block on {@link Buffer#get()} and {@link Buffer#remove()} operations * until <code>timeout</code> expires. If the buffer is empty, then the * {@link Buffer#get()} and {@link Buffer#remove()} operations will block * until new elements are added to the buffer, rather than immediately * throwing a <code>BufferUnderflowException</code>. * * @param buffer the buffer to synchronize, must not be null * @param timeoutMillis the timeout value in milliseconds, zero or less for no timeout * @return a blocking buffer backed by that buffer * @throws IllegalArgumentException if the Buffer is null * @since Commons Collections 3.2 */ public static Buffer blockingBuffer(Buffer buffer, long timeoutMillis) { return BlockingBuffer.decorate(buffer, timeoutMillis); }
public Object makeObject() { return BlockingBuffer.decorate( new MyBuffer() ); }
/** * Tests interrupted remove. */ public void testInterruptedRemove() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); // spawn a read thread to wait on the empty buffer ArrayList exceptionList = new ArrayList(); Thread thread = new ReadThread( blockingBuffer, obj, exceptionList, "remove" ); thread.start(); // Interrupting the thread should cause it to throw BufferUnderflowException thread.interrupt(); // Chill, so thread can throw and add message to exceptionList delay(); assertTrue( "Thread interrupt should have led to underflow", exceptionList.contains( "BufferUnderFlow" ) ); if( thread.isAlive() ) { fail( "Read thread has hung." ); } }
/** * Tests interrupted {@link BlockingBuffer#get()}. */ public void testInterruptedGet() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); // spawn a read thread to wait on the empty buffer ArrayList exceptionList = new ArrayList(); Thread thread = new ReadThread( blockingBuffer, obj, exceptionList ); thread.start(); // Interrupting the thread should cause it to throw BufferUnderflowException thread.interrupt(); // Chill, so thread can throw and add message to exceptionList delay(); assertTrue( "Thread interrupt should have led to underflow", exceptionList.contains( "BufferUnderFlow" ) ); if( thread.isAlive() ) { fail( "Read thread has hung." ); } }
public void testRemoveWithAddTimeout() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 100 ); Object obj = new Object(); new DelayedAdd( blockingBuffer, obj, 500 ).start(); try { blockingBuffer.remove(); } catch( BufferUnderflowException e ) { } } //-----------------------------------------------------------------------
public void testRemoveWithAddAllTimeout() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 100 ); Object obj = new Object(); new DelayedAddAll( blockingBuffer, obj, 500 ).start(); try { blockingBuffer.remove(); } catch( BufferUnderflowException e ) { } } //-----------------------------------------------------------------------
/** * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)} * using multiple read threads. * <p/> * Two read threads should block on an empty buffer until a collection with two distinct objects is added then both * threads should complete. Each thread should have read a different object. */ public void testBlockedRemoveWithAddAll2() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj1 = new Object(); Object obj2 = new Object(); Set objs = Collections.synchronizedSet( new HashSet() ); objs.add( obj1 ); objs.add( obj2 ); // run methods will remove and compare -- must wait for addAll Thread thread1 = new ReadThread( blockingBuffer, objs, "remove" ); Thread thread2 = new ReadThread( blockingBuffer, objs, "remove" ); thread1.start(); thread2.start(); // give hungry read threads ample time to hang delay(); blockingBuffer.addAll( objs ); // allow notified threads to complete delay(); assertEquals( "Both objects were removed", 0, objs.size() ); // There should not be any threads waiting. if( thread1.isAlive() || thread2.isAlive() ) { fail( "Live thread(s) when both should be dead." ); } }
/** * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#add(Object)}. */ public void testRemoveWithAdd() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); new DelayedAdd( blockingBuffer, obj ).start(); // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer . assertSame( obj, blockingBuffer.remove() ); }
/** * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#add(Object)}. */ public void testGetWithAdd() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); new DelayedAdd( blockingBuffer, obj ).start(); // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer . assertSame( obj, blockingBuffer.get() ); }
/** * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)} using * multiple read threads. * <p/> * Two read threads should block on an empty buffer until a singleton is added then both threads should complete. */ public void testBlockedGetWithAddAll() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); // run methods will get and compare -- must wait for addAll Thread thread1 = new ReadThread( blockingBuffer, obj ); Thread thread2 = new ReadThread( blockingBuffer, obj ); thread1.start(); thread2.start(); // give hungry read threads ample time to hang delay(); // notifyAll should allow both read threads to complete blockingBuffer.addAll( Collections.singleton( obj ) ); // allow notified threads to complete delay(); // There should not be any threads waiting. if( thread1.isAlive() || thread2.isAlive() ) { fail( "Live thread(s) when both should be dead." ); } }
public void testGetWithAddTimeout() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 500 ); Object obj = new Object(); new DelayedAdd( blockingBuffer, obj, 100 ).start(); // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer . assertSame( obj, blockingBuffer.get() ); }
public void testGetWithAddAllTimeout() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 500 ); Object obj = new Object(); new DelayedAddAll( blockingBuffer, obj, 100 ).start(); // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer . assertSame( obj, blockingBuffer.get() ); }
/** * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}. */ public void testGetWithAddAll() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); new DelayedAddAll( blockingBuffer, obj ).start(); // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer . assertSame( obj, blockingBuffer.get() ); }
/** * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}. */ public void testRemoveWithAddAll() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); new DelayedAddAll( blockingBuffer, obj ).start(); // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer . assertSame( obj, blockingBuffer.remove() ); }
/** * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#add(Object)} using multiple read * threads. * <p/> * Two read threads should block on an empty buffer until one object is added then both threads should complete. */ public void testBlockedGetWithAdd() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); // run methods will get and compare -- must wait for add Thread thread1 = new ReadThread( blockingBuffer, obj ); Thread thread2 = new ReadThread( blockingBuffer, obj ); thread1.start(); thread2.start(); // give hungry read threads ample time to hang delay(); // notifyAll should allow both read threads to complete blockingBuffer.add( obj ); // allow notified threads to complete delay(); // There should not be any threads waiting. if( thread1.isAlive() || thread2.isAlive() ) { fail( "Live thread(s) when both should be dead." ); } }
/** * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)} * using multiple read threads. * <p/> * Two read threads should block on an empty buffer until a singleton collection is added then one thread should * complete. The remaining thread should complete after the addition of a second singleton. */ public void testBlockedRemoveWithAddAll1() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); // run methods will remove and compare -- must wait for addAll Thread thread1 = new ReadThread( blockingBuffer, obj, null, "remove" ); Thread thread2 = new ReadThread( blockingBuffer, obj, null, "remove" ); thread1.start(); thread2.start(); // give hungry read threads ample time to hang delay(); blockingBuffer.addAll( Collections.singleton( obj ) ); // allow notified threads to complete delay(); // There should be one thread waiting. assertTrue( "There is one thread waiting", thread1.isAlive() ^ thread2.isAlive() ); blockingBuffer.addAll( Collections.singleton( obj ) ); // allow notified thread to complete delay(); // There should not be any threads waiting. if( thread1.isAlive() || thread2.isAlive() ) { fail( "Live thread(s) when both should be dead." ); } }
/** * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#add(Object)} using multiple read * threads. * <p/> * Two read threads should block on an empty buffer until one object is added then one thread should complete. The * remaining thread should complete after the addition of a second object. */ public void testBlockedRemoveWithAdd() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); // run methods will remove and compare -- must wait for add Thread thread1 = new ReadThread( blockingBuffer, obj, null, "remove" ); Thread thread2 = new ReadThread( blockingBuffer, obj, null, "remove" ); thread1.start(); thread2.start(); // give hungry read threads ample time to hang delay(); blockingBuffer.add( obj ); // allow notified threads to complete delay(); // There should be one thread waiting. assertTrue( "There is one thread waiting", thread1.isAlive() ^ thread2.isAlive() ); blockingBuffer.add( obj ); // allow notified thread to complete delay(); // There should not be any threads waiting. if( thread1.isAlive() || thread2.isAlive() ) { fail( "Live thread(s) when both should be dead." ); } }