Examples of edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch

Package edu.emory.mathcs.backport.java.util.concurrent

Examples of edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch

edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch
void main() throws InterruptedException { CountDownLatch startSignal = new CountDownLatch(1); CountDownLatch doneSignal = new CountDownLatch(N); for (int i = 0; i < N; ++i) // create and start threads new Thread(new Worker(startSignal, doneSignal)).start(); doSomethingElse(); // don't let run yet startSignal.countDown(); // let all threads proceed doSomethingElse(); doneSignal.await(); // wait for all to finish } } class Worker implements Runnable { private final CountDownLatch startSignal; private final CountDownLatch doneSignal; Worker(CountDownLatch startSignal, CountDownLatch doneSignal) { this.startSignal = startSignal; this.doneSignal = doneSignal; } public void run() { try { startSignal.await(); doWork(); doneSignal.countDown(); } catch (InterruptedException ex) {} // return; } void doWork() { ... } }
Another typical usage would be to divide a problem into N parts, describe each part with a Runnable that executes that portion and counts down on the latch, and queue all the Runnables to an Executor. When all sub-parts are complete, the coordinating thread will be able to pass through await. (When threads must repeatedly count down in this way, instead use a {@link CyclicBarrier}.)
```
 class Driver2 { // ... void main() throws InterruptedException { CountDownLatch doneSignal = new CountDownLatch(N); Executor e = ... for (int i = 0; i < N; ++i) // create and start threads e.execute(new WorkerRunnable(doneSignal, i)); doneSignal.await();           // wait for all to finish } } class WorkerRunnable implements Runnable { private final CountDownLatch doneSignal; private final int i; WorkerRunnable(CountDownLatch doneSignal, int i) { this.doneSignal = doneSignal; this.i = i; } public void run() { try { doWork(i); doneSignal.countDown(); } catch (InterruptedException ex) {} // return; } void doWork() { ... } } 
```
Memory consistency effects: Actions in a thread prior to calling {@code countDown()}happen-before actions following a successful return from a corresponding {@code await()} in another thread. @since 1.5 @author Doug Lea

 * */
public class StartWorkExecutor implements WorkExecutor {


    public void doExecute(WorkerContext work, Executor executor)
            throws WorkException, InterruptedException {
        CountDownLatch latch = work.provideStartLatch();
        executor.execute(new NamedRunnable("A J2EE Connector", work));
        latch.await();
    }

View Full Code Here

            for (int x = 0; x < data.length; ++x)
            {
                data[x] = testUtils_.getStructuredEvent();
            }
            
            final CountDownLatch latch = new CountDownLatch(1);
            new Thread()
            {
                public void run()
                {
                    System.out.println("Begin to send");


                    try
                    {
                        sender.pushEvents(data);
                    } catch (Disconnected e)
                    {
                        active.set(false);
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }


                    System.out.println("Sent " + data.length);


                    latch.countDown();
                }
            }.start();


            latch.await();


            System.out.println(receiver);


            Thread.sleep(60000);

View Full Code Here

        _sender.shutdown();
    }


    public void testSendEventPushPush_MisbehavingConsumer() throws Exception
    {
        final CountDownLatch disconnectedLatch = new CountDownLatch(1);


        // start a receiver thread
        AnyPushReceiver _receiver = new AnyPushReceiver(getClientORB())
        {
            public void push(Any any)
            {
                throw new TRANSIENT();
            }


            public void disconnect_push_consumer()
            {
                super.disconnect_push_consumer();


                disconnectedLatch.countDown();
            }
        };
        _receiver.connect(channel_, false);


        Thread _receiverThread = new Thread(_receiver);


        // start a sender
        AnyPushSender _sender = new AnyPushSender(getClientORB(), testPerson_);


        _sender.connect(channel_, false);


        _receiverThread.start();


        _sender.run();


        assertTrue(disconnectedLatch.await(20000, TimeUnit.MILLISECONDS));


        assertTrue(!_receiver.isConnected());


        _sender.shutdown();
    }

View Full Code Here


    public void testSendPushPush_MisbehavingConsumer() throws Exception
    {
        StructuredPushSender _sender = getPushSender();


        final CountDownLatch disconnectedLatch = new CountDownLatch(1);
        
        StructuredPushReceiver _receiver = new StructuredPushReceiver(getClientORB())
        {
            public void push_structured_event(StructuredEvent event) 
            {
                throw new TRANSIENT();
            }
            
            public void disconnect_structured_push_consumer()
            {
                super.disconnect_structured_push_consumer();
                
                disconnectedLatch.countDown();
            }
        };


        _sender.connect(channel_, false);
        _receiver.connect(channel_, false);


        _receiver.start();
        _sender.start();


        _sender.join();
        _receiver.join();


        assertTrue(disconnectedLatch.await(20000, TimeUnit.MILLISECONDS));


        assertFalse(_receiver.isConnected());
    }

View Full Code Here

                new Property("operation", toAny(DRINKING_COFFEE_ID)),
                new Property("name", toAny("alphonse")), new Property("minutes", toAny(10)) });


        _event.setAny(_any);


        final CountDownLatch _hasReceived = new CountDownLatch(1);
        
        // setup mock
        MockCoffee _mockCoffee = new MockCoffee()
        {
            public void drinking_coffee(String name, int minutes)
            {
                super.drinking_coffee(name, minutes);
               
                assertEquals("alphonse", name);
                assertEquals(10, minutes);
                
                _hasReceived.countDown();
            }
        };


        _mockCoffee.drinking_coffee_expect = 1;


        // setup and connect consumer
        final Coffee _coffee = _mockCoffee._this(getClientORB());


        MockTypedPushConsumer _mockConsumer = new MockTypedPushConsumer()
        {
            public org.omg.CORBA.Object get_typed_consumer()
            {
                return _coffee;
            }
        };


        TypedPushConsumer _consumer = _mockConsumer._this(getClientORB());


        proxyPushSupplier_.connect_typed_push_consumer(_consumer);


        // run test
        objectUnderTest_.getMessageConsumer().queueMessage(_event.getHandle());


        assertTrue(_hasReceived.await(5000, TimeUnit.MILLISECONDS));
        
        // verify results
        _mockCoffee.verify();
    }

View Full Code Here

                _objectAsString));


        final StringHolder _name = new StringHolder();
        final IntHolder _minutes = new IntHolder();


        final CountDownLatch _latch = new CountDownLatch(1);


        new Thread()
        {
            public void run()
            {
                _pullCoffee.drinking_coffee(_name, _minutes);
                _latch.countDown();
            }
        }.start();


        objectUnderTest_.getMessageConsumer().queueMessage(_mesg.getHandle());


        assertTrue(_latch.await(1000, TimeUnit.MICROSECONDS));


        assertEquals("jacorb", _name.value);
        assertEquals(10, _minutes.value);
    }

View Full Code Here

    { 
        final AnyMessage mesg = new AnyMessage();


        final AtomicBoolean received = new AtomicBoolean(false);
        final AtomicBoolean delivered = new AtomicBoolean(false);
        final CountDownLatch threadsDone = new CountDownLatch(1);
        final CountDownLatch getPutOrder = new CountDownLatch(1);


        final CyclicBarrier barrier = new CyclicBarrier(2, new Runnable()
        {
            public void run()
            {
                threadsDone.countDown();
            }
        });


        Runnable getCommand = new Runnable()
        {
            public void run()
            {
                try
                {
                    synchronized (lock_)
                    {
                        getPutOrder.countDown();
                        objectUnderTest_.getMessageBlocking();
                    }


                    received.set(true);


                    barrier.await();
                } catch (Exception e)
                {
                    fail();
                }
            }
        };


        Runnable putCommand = new Runnable()
        {
            public void run()
            {
                try
                {
                    getPutOrder.await();


                    objectUnderTest_.enqeue(mesg.getHandle());


                    delivered.set(true);

View Full Code Here


        structuredEvent_.header.variable_header[0] = new Property(StartTime.value, _startTimeAny);


        final Message _event = messageFactory_.newMessage(structuredEvent_, proxyConsumerMock_);


        final CountDownLatch _latch = new CountDownLatch(1);


        // TODO check if MockTaskProcessor can be used here
        final DefaultTaskFactory _defaultTaskFactory = new DefaultTaskFactory(getConfiguration());
        addDisposable(_defaultTaskFactory);
        DefaultTaskProcessor _taskProcessor = new DefaultTaskProcessor(getConfiguration(), _defaultTaskFactory)
        {
            public void processMessageInternal(Message event)
            {
                try
                {
                    long _recvTime = System.currentTimeMillis();
                    assertEquals(event, _event);
                    assertTrue(_recvTime >= _startTime.getTime());
                    
                    failed.set(false);
                } finally
                {
                    _latch.countDown();
                }
            }
        };


        _taskProcessor.processMessage(_event);


        _latch.await();


        assertFalse(failed.get());
        
        _taskProcessor.dispose();
    }

View Full Code Here


      acf = createConnectionFactory(URL1);
      pcf = new PooledConnectionFactory(acf);


      // Only listen on the first queue.. let the 2nd queue fill up.
      doneLatch = new CountDownLatch(NUM_MESSAGE_TO_SEND);
      container1 = createDefaultMessageListenerContainer(acf,  new TestMessageListener1(500), QUEUE1_NAME);
      container1.afterPropertiesSet();


      Thread.sleep(2000);

View Full Code Here


      pcf = new PooledConnectionFactory(acf1);


      Thread.sleep(1000);


      doneLatch = new CountDownLatch(MAX_PRODUCERS * NUM_MESSAGE_TO_SEND);
      container1 = createDefaultMessageListenerContainer(acf2, new TestMessageListener1(500), QUEUE1_NAME);
      container1.afterPropertiesSet();


      final ExecutorService executor = Executors.newCachedThreadPool();
      for (int i = 0; i < MAX_PRODUCERS; i++) {

View Full Code Here

0 1 2 3 4 5 6 7

TOP

Related Classes of edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch

JMSClient

org.apache.activeio.journal.active.BatchedWrite

org.apache.activemq.AMQDeadlockTest3

org.apache.activemq.broker.region.cursors.CursorDurableTest

org.apache.activemq.JmsBenchmark

org.apache.activemq.JMSConsumerTest

org.apache.activemq.JmsSessionRecoverTest

org.apache.activemq.kaha.LoadTest

org.apache.activemq.LoadTestBurnIn

org.apache.activemq.network.DemandForwardingBridgeSupport

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.