Examples of java.util.concurrent.CountDownLatch

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}.)
```
  {@code}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: Until the count reaches zero, 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


    @Test (enabled = false)
    public void testProgrammaticDisconnection() {
        logger.info("{}: running test: testProgrammaticDisconnection", getClass().getSimpleName());


        final CountDownLatch latch = new CountDownLatch(1);
        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            private long currentTime;


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException {
                currentTime = System.currentTimeMillis();
                event.suspend();
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {
                try {
                    assertTrue(event.isCancelled());
                    long time = System.currentTimeMillis() - currentTime;
                    if (time > 20000 && time < 25000) {
                        assertTrue(true);
                    } else {
                        assertFalse(false);
                    }
                } finally {
                    latch.countDown();
                }
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            Response r = c.prepareGet(urlTarget).execute().get();


            if (latch.getCount() != 0) {
                fail("timedout");
            }
            assertNotNull(r);
        } catch (Exception e) {
            logger.error("test failed", e);

View Full Code Here


    @Test(timeOut = 60000)
    public void testProgrammaticResume() {
        logger.info("{}: running test: testProgrammaticResume", getClass().getSimpleName());


        final CountDownLatch latch = new CountDownLatch(2);
        final CountDownLatch suspended = new CountDownLatch(1);
        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            AtomicBoolean b = new AtomicBoolean(false);
            AtmosphereResource<HttpServletRequest, HttpServletResponse> suspendedEvent;


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (!b.getAndSet(true)) {
                    try {
                        suspendedEvent = event;
                        event.suspend();
                    } finally {
                        suspended.countDown();
                    }
                } else {
                    suspendedEvent.getResponse().flushBuffer();
                    suspendedEvent.resume();
                }
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {


                try {
                    assertTrue(event.isResuming());
                } finally {
                    latch.countDown();
                }
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            c.prepareGet(urlTarget).execute(new AsyncCompletionHandler<String>() {


                @Override
                public String onCompleted(Response response) throws Exception {
                    try {
                        assertEquals(response.getResponseBody(),
                                AtmosphereResourceImpl.createCompatibleStringJunk());
                    } finally {
                        latch.countDown();
                    }
                    return null;
                }
            });


            suspended.await(20, TimeUnit.SECONDS);
            Response r = c.prepareGet(urlTarget).execute().get();


            try {
                latch.await(20, TimeUnit.SECONDS);
            } catch (InterruptedException e) {

View Full Code Here


    @Test(timeOut = 60000)
    public void testResumeOnBroadcast() {
        logger.info("{}: running test: testResumeOnBroadcast", getClass().getSimpleName());


        final CountDownLatch latch = new CountDownLatch(2);
        final CountDownLatch suspended = new CountDownLatch(1);
        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            AtomicBoolean b = new AtomicBoolean(false);


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (!b.getAndSet(true)) {
                    try {
                        event.suspend();
                    } finally {
                        suspended.countDown();
                    }
                } else {
                    event.getBroadcaster().broadcast("foo");
                }
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (event.isResuming()) {
                    return;
                }
                try {
                    assertFalse(event.isCancelled());
                    assertNotNull(event.getMessage());
                    assertEquals(event.getMessage(), "foo");
                    event.getResource().getResponse().flushBuffer();
                    event.getResource().resume();
                } finally {
                    latch.countDown();
                }
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            c.prepareGet(urlTarget).execute(new AsyncCompletionHandler<String>() {


                @Override
                public String onCompleted(Response response) throws Exception {
                    try {
                        assertEquals(response.getResponseBody(),
                                AtmosphereResourceImpl.createCompatibleStringJunk());
                    } finally {
                        latch.countDown();
                    }
                    return null;
                }
            });


            suspended.await(20, TimeUnit.SECONDS);
            Response r = c.prepareGet(urlTarget).execute().get();


            try {
                latch.await(20, TimeUnit.SECONDS);
            } catch (InterruptedException e) {

View Full Code Here


    @Test(timeOut = 60000)
    public void testDelayBroadcast() {
        logger.info("{}: running test: testDelayBroadcast", getClass().getSimpleName());


        final CountDownLatch latch = new CountDownLatch(2);
        final CountDownLatch suspended = new CountDownLatch(1);


        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            AtomicBoolean b = new AtomicBoolean(false);
            private long currentTime;


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (!b.getAndSet(true)) {
                    try {
                        event.suspend();
                    } finally {
                        suspended.countDown();
                    }
                } else {
                    currentTime = System.currentTimeMillis();
                    event.getBroadcaster().delayBroadcast("foo", 5, TimeUnit.SECONDS);
                }
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (event.isResuming()) {
                    return;
                }
                try {
                    long time = System.currentTimeMillis() - currentTime;
                    if (time > 5000 && time < 6000) {
                        assertTrue(true);
                    } else {
                        assertFalse(false);
                    }
                    assertFalse(event.isCancelled());
                    assertNotNull(event.getMessage());
                    assertEquals(event.getMessage(), "foo");
                    event.getResource().getResponse().flushBuffer();
                    event.getResource().resume();
                } finally {
                    latch.countDown();
                }
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            c.prepareGet(urlTarget).execute(new AsyncCompletionHandler<String>() {


                @Override
                public String onCompleted(Response response) throws Exception {
                    try {
                        assertEquals(response.getResponseBody(),
                                AtmosphereResourceImpl.createCompatibleStringJunk());
                    } finally {
                        latch.countDown();
                    }
                    return null;
                }
            });


            suspended.await(20, TimeUnit.SECONDS);
            Response r = c.prepareGet(urlTarget).execute().get();


            try {
                latch.await(20, TimeUnit.SECONDS);
            } catch (InterruptedException e) {

View Full Code Here


    @Test(timeOut = 60000)
    public void testDelayNextBroadcast() {
        logger.info("{}: running test: testDelayNextBroadcast", getClass().getSimpleName());


        final CountDownLatch latch = new CountDownLatch(2);


        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            AtomicBoolean b = new AtomicBoolean(false);
            AtomicInteger count  = new AtomicInteger(0);
            private long currentTime;


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException
            {
                if (!b.getAndSet(true)) {
                    event.suspend(-1, false);


                } else {
                    currentTime = System.currentTimeMillis();


                    if (count.get() < 4) {
                        event.getBroadcaster().delayBroadcast("message-" + count.getAndIncrement() + " ");
                    } else {
                        event.getBroadcaster().broadcast("message-final");
                    }
                }
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (event.isResuming()) {
                    return;
                }
                try {
                    event.getResource().getResponse().getWriter().write((String)event.getMessage());
                    event.getResource().getResponse().flushBuffer();
                    event.getResource().resume();
                } catch (Exception ex) {
                    logger.error("failure resuming resource", ex);
                } finally {
                    latch.countDown();
                }
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            Future<Response> f = c.prepareGet(urlTarget).execute();


            latch.await(5, TimeUnit.SECONDS);


            c.prepareGet(urlTarget).execute().get();
            c.prepareGet(urlTarget).execute().get();
            c.prepareGet(urlTarget).execute().get();
            c.prepareGet(urlTarget).execute().get();

View Full Code Here


    @Test(timeOut = 60000)
    public void testScheduleBroadcast() {
        logger.info("{}: running test: testScheduleBroadcast", getClass().getSimpleName());


        final CountDownLatch latch = new CountDownLatch(2);
        final CountDownLatch suspended = new CountDownLatch(1);


        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            AtomicBoolean b = new AtomicBoolean(false);
            private long currentTime;


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (!b.getAndSet(true)) {
                    try {
                        event.suspend();
                    } finally {
                        suspended.countDown();
                    }
                } else {
                    currentTime = System.currentTimeMillis();
                    event.getBroadcaster().scheduleFixedBroadcast("foo", 0, 5, TimeUnit.SECONDS);
                }
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (event.isResuming()) {
                    return;
                }
                try {
                    long time = System.currentTimeMillis() - currentTime;
                    if (time > 5000 && time < 6000) {
                        assertTrue(true);
                    } else {
                        assertFalse(false);
                    }
                    assertFalse(event.isCancelled());
                    assertNotNull(event.getMessage());
                    assertEquals(event.getMessage(), "foo");
                    event.getResource().getResponse().flushBuffer();
                    event.getResource().resume();
                } finally {
                    latch.countDown();
                }
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            c.prepareGet(urlTarget).execute(new AsyncCompletionHandler<String>() {


                @Override
                public String onCompleted(Response response) throws Exception {
                    try {
                        assertEquals(response.getResponseBody(),
                                AtmosphereResourceImpl.createCompatibleStringJunk());
                    } finally {
                        latch.countDown();
                    }
                    return null;
                }
            });
            suspended.await(20, TimeUnit.SECONDS);


            Response r = c.prepareGet(urlTarget).execute().get();
            assertNotNull(r);
            assertEquals(r.getStatusCode(), 200);
        } catch (Exception e) {

View Full Code Here


    @Test(timeOut = 60000)
    public void testDelayScheduleBroadcast() {
        logger.info("{}: running test: testDelayScheduleBroadcast", getClass().getSimpleName());


        final CountDownLatch latch = new CountDownLatch(2);
        final CountDownLatch suspended = new CountDownLatch(1);


        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            AtomicBoolean b = new AtomicBoolean(false);
            private long currentTime;


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (!b.getAndSet(true)) {
                    try {
                        event.suspend();
                    } finally {
                        suspended.countDown();
                    }
                } else {
                    currentTime = System.currentTimeMillis();
                    event.getBroadcaster().scheduleFixedBroadcast("foo", 10, 5, TimeUnit.SECONDS);
                }
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (event.isResuming()) {
                    return;
                }
                try {
                    long time = System.currentTimeMillis() - currentTime;
                    if (time > 15000 && time < 20000) {
                        assertTrue(true);
                    } else {
                        assertFalse(false);
                    }
                    assertFalse(event.isCancelled());
                    assertNotNull(event.getMessage());
                    assertEquals(event.getMessage(), "foo");
                    event.getResource().getResponse().flushBuffer();
                    event.getResource().resume();
                } finally {
                    latch.countDown();
                }
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            c.prepareGet(urlTarget).execute(new AsyncCompletionHandler<String>() {


                @Override
                public String onCompleted(Response response) throws Exception {
                    try {
                        assertEquals(response.getResponseBody(),
                                AtmosphereResourceImpl.createCompatibleStringJunk());
                    } finally {
                        latch.countDown();
                    }
                    return null;
                }
            });


            suspended.await(20, TimeUnit.SECONDS);
            Response r = c.prepareGet(urlTarget).execute().get();


            try {
                latch.await(20, TimeUnit.SECONDS);
            } catch (InterruptedException e) {

View Full Code Here


    @Test(timeOut = 60000)
    public void testBroadcastFilter() {
        logger.info("{}: running test: testBroadcastFilter", getClass().getSimpleName());


        final CountDownLatch latch = new CountDownLatch(2);
        final CountDownLatch suspended = new CountDownLatch(1);


        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            AtomicBoolean b = new AtomicBoolean(false);


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (!b.getAndSet(true)) {
                    try {
                        event.suspend();
                    } finally {
                        suspended.countDown();
                    }
                } else {
                    event.getBroadcaster().getBroadcasterConfig().addFilter(new BroadcastFilter() {


                        public BroadcastAction filter(Object o, Object message) {
                            return new BroadcastAction(BroadcastAction.ACTION.CONTINUE, "boo" + message);
                        }
                    });


                    event.getBroadcaster().broadcast("foo");
                }
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (event.isResuming()) {
                    return;
                }
                try {
                    assertFalse(event.isCancelled());
                    assertNotNull(event.getMessage());
                    assertEquals(event.getMessage(), "boofoo");
                    event.getResource().getResponse().flushBuffer();
                    event.getResource().resume();
                } finally {
                    latch.countDown();
                }
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            c.prepareGet(urlTarget).execute(new AsyncCompletionHandler<String>() {


                @Override
                public String onCompleted(Response response) throws Exception {
                    try {
                        assertEquals(response.getResponseBody(),
                                AtmosphereResourceImpl.createCompatibleStringJunk());
                    } finally {
                        latch.countDown();
                    }
                    return null;
                }
            });


            suspended.await(20, TimeUnit.SECONDS);
            Response r = c.prepareGet(urlTarget).execute().get();


            try {
                latch.await(20, TimeUnit.SECONDS);
            } catch (InterruptedException e) {

View Full Code Here


    @Test(timeOut = 60000)
    public void testAggregateFilter() {
        logger.info("{}: running test: testAggregateFilter", getClass().getSimpleName());


        final CountDownLatch latch = new CountDownLatch(2);
        final CountDownLatch suspended = new CountDownLatch(1);


        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            AtomicBoolean b = new AtomicBoolean(false);


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (!b.getAndSet(true)) {
                    // Will take 3 broadcast before it get pushed back.
                    StringFilterAggregator a = new StringFilterAggregator(25);
                    event.getBroadcaster().getBroadcasterConfig().addFilter(a);
                    try {
                        event.suspend();
                    } finally {
                        suspended.countDown();
                    }
                } else {
                    event.getBroadcaster().broadcast("12345678910");
                }
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (event.isResuming()) {
                    return;
                }
                assertFalse(event.isCancelled());
                assertNotNull(event.getMessage());
                assertEquals(event.getMessage(), "123456789101234567891012345678910");
                event.getResource().getResponse().flushBuffer();
                event.getResource().resume();
                latch.countDown();
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            c.prepareGet(urlTarget).execute(new AsyncCompletionHandler<String>() {


                @Override
                public String onCompleted(Response response) throws Exception {
                    try {
                        assertEquals(response.getResponseBody(),
                                AtmosphereResourceImpl.createCompatibleStringJunk());
                    } finally {
                        latch.countDown();
                    }
                    return null;
                }
            });


            suspended.await(20, TimeUnit.SECONDS);
            c.prepareGet(urlTarget).execute().get();
            c.prepareGet(urlTarget).execute().get();
            Response r = c.prepareGet(urlTarget).execute().get();


            try {

View Full Code Here

    @Test
    public void testHeaderBroadcasterCache() throws IllegalAccessException, ClassNotFoundException, InstantiationException {
        logger.info("{}: running test: testHeaderBroadcasterCache", getClass().getSimpleName());


        atmoServlet.setBroadcasterCacheClassName(HeaderBroadcasterCache.class.getName());
        final CountDownLatch latch = new CountDownLatch(1);


        long t1 = System.currentTimeMillis();
        atmoServlet.addAtmosphereHandler(ROOT, new AbstractHttpAtmosphereHandler() {


            public void onRequest(AtmosphereResource<HttpServletRequest, HttpServletResponse> event) throws IOException {
                try {
                    if (event.getRequest().getHeader(HeaderBroadcasterCache.HEADER_CACHE) != null) {
                        event.suspend(-1, false);
                        return;
                    }
                    event.getBroadcaster().broadcast("12345678910").get();
                } catch (InterruptedException e) {
                    logger.error("", e);
                } catch (ExecutionException e) {
                    logger.error("", e);
                }
                event.getResponse().flushBuffer();
            }


            public void onStateChange(AtmosphereResourceEvent<HttpServletRequest, HttpServletResponse> event) throws IOException {
                if (event.isResuming()) {
                    return;
                }
                try {
                    assertFalse(event.isCancelled());
                    assertNotNull(event.getMessage());
                    if (List.class.isAssignableFrom(event.getMessage().getClass())) {
                        for (String m : (List<String>) event.getMessage()) {
                            event.getResource().getResponse().getOutputStream().write(m.getBytes());
                        }
                    }
                    event.getResource().getResponse().flushBuffer();
                    event.getResource().resume();
                } finally {
                    latch.countDown();
                }
            }
        }, new RecyclableBroadcaster("suspend"));


        AsyncHttpClient c = new AsyncHttpClient();
        try {
            c.prepareGet(urlTarget).execute().get();
            c.prepareGet(urlTarget).execute().get();


            //Suspend
            Response r = c.prepareGet(urlTarget).addHeader(HeaderBroadcasterCache.HEADER_CACHE, String.valueOf(t1)).execute(new AsyncCompletionHandler<Response>() {


                @Override
                public Response onCompleted(Response r) throws Exception {
                    try {
                        return r;
                    } finally {
                        latch.countDown();
                    }
                }
            }).get();


            try {
                latch.await(20, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                fail(e.getMessage());
            }


            assertNotNull(r);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.util.concurrent.CountDownLatch

com.asakusafw.bulkloader.cache.LocalCacheInfoRepositoryTest

com.datastax.driver.core.HostAssert

com.jcabi.github.mock.MkStorageTest

com.linkedin.databus.core.util.DatabusEventRandomProducer

com.linkedin.parseq.promise.TestSettablePromise

com.linkedin.parseq.TestEngine

com.linkedin.parseq.TestIndirectDelayedExecutor

com.linkedin.parseq.TestParTask

com.nokia.dempsy.container.TestMpContainer

com.nokia.dempsy.container.TestMpContainerLoadHandling

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.