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

Example 1 with Semaphore

use of java.util.concurrent.Semaphore in project elasticsearch by elastic.

the class AbstractSimpleTransportTestCase method testTimeoutSendExceptionWithDelayedResponse.

public void testTimeoutSendExceptionWithDelayedResponse() throws Exception {
    CountDownLatch waitForever = new CountDownLatch(1);
    CountDownLatch doneWaitingForever = new CountDownLatch(1);
    Semaphore inFlight = new Semaphore(Integer.MAX_VALUE);
    serviceA.registerRequestHandler("sayHelloTimeoutDelayedResponse", StringMessageRequest::new, ThreadPool.Names.GENERIC, new TransportRequestHandler<StringMessageRequest>() {

        @Override
        public void messageReceived(StringMessageRequest request, TransportChannel channel) throws InterruptedException {
            String message = request.message;
            inFlight.acquireUninterruptibly();
            try {
                if ("forever".equals(message)) {
                    waitForever.await();
                } else {
                    TimeValue sleep = TimeValue.parseTimeValue(message, null, "sleep");
                    Thread.sleep(sleep.millis());
                }
                try {
                    channel.sendResponse(new StringMessageResponse("hello " + request.message));
                } catch (IOException e) {
                    logger.error("Unexpected failure", e);
                    fail(e.getMessage());
                }
            } finally {
                inFlight.release();
                if ("forever".equals(message)) {
                    doneWaitingForever.countDown();
                }
            }
        }
    });
    final CountDownLatch latch = new CountDownLatch(1);
    TransportFuture<StringMessageResponse> res = serviceB.submitRequest(nodeA, "sayHelloTimeoutDelayedResponse", new StringMessageRequest("forever"), TransportRequestOptions.builder().withTimeout(100).build(), new TransportResponseHandler<StringMessageResponse>() {

        @Override
        public StringMessageResponse newInstance() {
            return new StringMessageResponse();
        }

        @Override
        public String executor() {
            return ThreadPool.Names.GENERIC;
        }

        @Override
        public void handleResponse(StringMessageResponse response) {
            latch.countDown();
            fail("got response instead of exception");
        }

        @Override
        public void handleException(TransportException exp) {
            latch.countDown();
            assertThat(exp, instanceOf(ReceiveTimeoutTransportException.class));
        }
    });
    try {
        res.txGet();
        fail("exception should be thrown");
    } catch (Exception e) {
        assertThat(e, instanceOf(ReceiveTimeoutTransportException.class));
    }
    latch.await();
    List<Runnable> assertions = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        final int counter = i;
        // now, try and send another request, this times, with a short timeout
        TransportFuture<StringMessageResponse> result = serviceB.submitRequest(nodeA, "sayHelloTimeoutDelayedResponse", new StringMessageRequest(counter + "ms"), TransportRequestOptions.builder().withTimeout(3000).build(), new TransportResponseHandler<StringMessageResponse>() {

            @Override
            public StringMessageResponse newInstance() {
                return new StringMessageResponse();
            }

            @Override
            public String executor() {
                return ThreadPool.Names.GENERIC;
            }

            @Override
            public void handleResponse(StringMessageResponse response) {
                assertThat("hello " + counter + "ms", equalTo(response.message));
            }

            @Override
            public void handleException(TransportException exp) {
                logger.error("Unexpected failure", exp);
                fail("got exception instead of a response for " + counter + ": " + exp.getDetailedMessage());
            }
        });
        assertions.add(() -> {
            StringMessageResponse message = result.txGet();
            assertThat(message.message, equalTo("hello " + counter + "ms"));
        });
    }
    for (Runnable runnable : assertions) {
        runnable.run();
    }
    waitForever.countDown();
    doneWaitingForever.await();
    assertTrue(inFlight.tryAcquire(Integer.MAX_VALUE, 10, TimeUnit.SECONDS));
}

Example 2 with Semaphore

use of java.util.concurrent.Semaphore in project jetty.project by eclipse.

the class QoSFilter method init.

public void init(FilterConfig filterConfig) {
    int max_priority = __DEFAULT_MAX_PRIORITY;
    if (filterConfig.getInitParameter(MAX_PRIORITY_INIT_PARAM) != null)
        max_priority = Integer.parseInt(filterConfig.getInitParameter(MAX_PRIORITY_INIT_PARAM));
    _queues = new Queue[max_priority + 1];
    _listeners = new AsyncListener[_queues.length];
    for (int p = 0; p < _queues.length; ++p) {
        _queues[p] = new ConcurrentLinkedQueue<>();
        _listeners[p] = new QoSAsyncListener(p);
    }
    int maxRequests = __DEFAULT_PASSES;
    if (filterConfig.getInitParameter(MAX_REQUESTS_INIT_PARAM) != null)
        maxRequests = Integer.parseInt(filterConfig.getInitParameter(MAX_REQUESTS_INIT_PARAM));
    _passes = new Semaphore(maxRequests, true);
    _maxRequests = maxRequests;
    long wait = __DEFAULT_WAIT_MS;
    if (filterConfig.getInitParameter(MAX_WAIT_INIT_PARAM) != null)
        wait = Integer.parseInt(filterConfig.getInitParameter(MAX_WAIT_INIT_PARAM));
    _waitMs = wait;
    long suspend = __DEFAULT_TIMEOUT_MS;
    if (filterConfig.getInitParameter(SUSPEND_INIT_PARAM) != null)
        suspend = Integer.parseInt(filterConfig.getInitParameter(SUSPEND_INIT_PARAM));
    _suspendMs = suspend;
    ServletContext context = filterConfig.getServletContext();
    if (context != null && Boolean.parseBoolean(filterConfig.getInitParameter(MANAGED_ATTR_INIT_PARAM)))
        context.setAttribute(filterConfig.getFilterName(), this);
}

Example 3 with Semaphore

use of java.util.concurrent.Semaphore in project jetty.project by eclipse.

the class QoSFilter method setMaxRequests.

/**
     * Set the maximum number of requests allowed to be processed
     * at the same time.
     *
     * @param value the number of requests
     */
public void setMaxRequests(int value) {
    _passes = new Semaphore((value - getMaxRequests() + _passes.availablePermits()), true);
    _maxRequests = value;
}

Example 4 with Semaphore

use of java.util.concurrent.Semaphore in project che by eclipse.

the class MavenTaskExecutor method waitForEndAllTasks.

public void waitForEndAllTasks() {
    if (!isWorking) {
        return;
    }
    Semaphore semaphore = new Semaphore(1);
    try {
        semaphore.acquire();
        submitTask(semaphore::release);
        while (true) {
            if (!isWorking || semaphore.tryAcquire(1, TimeUnit.SECONDS)) {
                return;
            }
        }
    } catch (InterruptedException e) {
        LOG.debug(e.getMessage(), e);
    }
}

Example 5 with Semaphore

use of java.util.concurrent.Semaphore in project elasticsearch by elastic.

the class IndexShardTests method testAsyncFsync.

public void testAsyncFsync() throws InterruptedException, IOException {
    IndexShard shard = newStartedShard();
    Semaphore semaphore = new Semaphore(Integer.MAX_VALUE);
    Thread[] thread = new Thread[randomIntBetween(3, 5)];
    CountDownLatch latch = new CountDownLatch(thread.length);
    for (int i = 0; i < thread.length; i++) {
        thread[i] = new Thread() {

            @Override
            public void run() {
                try {
                    latch.countDown();
                    latch.await();
                    for (int i = 0; i < 10000; i++) {
                        semaphore.acquire();
                        shard.sync(TranslogTests.randomTranslogLocation(), (ex) -> semaphore.release());
                    }
                } catch (Exception ex) {
                    throw new RuntimeException(ex);
                }
            }
        };
        thread[i].start();
    }
    for (int i = 0; i < thread.length; i++) {
        thread[i].join();
    }
    assertTrue(semaphore.tryAcquire(Integer.MAX_VALUE, 10, TimeUnit.SECONDS));
    closeShards(shard);
}