use of java.util.concurrent.ConcurrentHashMap in project mapdb by jankotek.
the class ConcurrentHashMap8Test method testCompute2.
/**
* compute adds when the given key is not present
*/
public void testCompute2() {
ConcurrentHashMap map = map5();
assertEquals("Z", map.compute(six, (x, y) -> "Z"));
}
use of java.util.concurrent.ConcurrentHashMap in project mapdb by jankotek.
the class ConcurrentHashMap8Test method map5.
/**
* Returns a new map from Integers 1-5 to Strings "A"-"E".
*/
private static ConcurrentHashMap map5() {
ConcurrentHashMap map = new ConcurrentHashMap(5);
assertTrue(map.isEmpty());
map.put(one, "A");
map.put(two, "B");
map.put(three, "C");
map.put(four, "D");
map.put(five, "E");
assertFalse(map.isEmpty());
assertEquals(5, map.size());
return map;
}
use of java.util.concurrent.ConcurrentHashMap in project jersey by jersey.
the class ManagedAsyncResourceTest method testChatResource.
@Test
public void testChatResource() throws InterruptedException {
final WebTarget resourceTarget = target().path("chat");
final int MAX_MESSAGES = 100;
final int LATCH_WAIT_TIMEOUT = 10 * getAsyncTimeoutMultiplier();
final boolean debugMode = false;
final boolean sequentialGet = false;
final boolean sequentialPost = false;
final Object sequentialGetLock = new Object();
final Object sequentialPostLock = new Object();
final ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactoryBuilder().setNameFormat("async-resource-test-%d").setUncaughtExceptionHandler(new JerseyProcessingUncaughtExceptionHandler()).build());
final Map<Integer, Integer> postResponses = new ConcurrentHashMap<Integer, Integer>();
final Map<Integer, Message> getResponses = new ConcurrentHashMap<Integer, Message>();
final CountDownLatch postRequestLatch = new CountDownLatch(MAX_MESSAGES);
final CountDownLatch getRequestLatch = new CountDownLatch(MAX_MESSAGES);
try {
for (int i = 0; i < MAX_MESSAGES; i++) {
final int requestId = i;
executor.submit(new Runnable() {
@Override
public void run() {
if (debugMode || sequentialPost) {
synchronized (sequentialPostLock) {
post();
}
} else {
post();
}
}
private void post() {
try {
int attemptCounter = 0;
while (true) {
attemptCounter++;
try {
final Response response = resourceTarget.request().post(Entity.json(new Message("" + requestId, "" + requestId)));
postResponses.put(requestId, response.getStatus());
break;
} catch (Throwable t) {
LOGGER.log(Level.WARNING, String.format("Error POSTING message <%s> for %d. time.", requestId, attemptCounter), t);
}
if (attemptCounter > 3) {
break;
}
Thread.sleep(10);
}
} catch (InterruptedException ignored) {
LOGGER.log(Level.WARNING, String.format("Error POSTING message <%s>: Interrupted", requestId), ignored);
} finally {
postRequestLatch.countDown();
}
}
});
executor.submit(new Runnable() {
@Override
public void run() {
if (debugMode || sequentialGet) {
synchronized (sequentialGetLock) {
get();
}
} else {
get();
}
}
private void get() {
try {
int attemptCounter = 0;
while (true) {
attemptCounter++;
try {
final Message response = resourceTarget.request("application/json").get(Message.class);
getResponses.put(requestId, response);
break;
} catch (Throwable t) {
LOGGER.log(Level.SEVERE, String.format("Error sending GET request <%s> for %d. time.", requestId, attemptCounter), t);
}
if (attemptCounter > 3) {
break;
}
Thread.sleep(10);
}
} catch (InterruptedException ignored) {
LOGGER.log(Level.WARNING, String.format("Error sending GET message <%s>: Interrupted", requestId), ignored);
} finally {
getRequestLatch.countDown();
}
}
});
}
if (debugMode) {
postRequestLatch.await();
getRequestLatch.await();
} else {
if (!postRequestLatch.await(LATCH_WAIT_TIMEOUT, TimeUnit.SECONDS)) {
LOGGER.log(Level.SEVERE, "Waiting for all POST requests to complete has timed out.");
}
if (!getRequestLatch.await(LATCH_WAIT_TIMEOUT, TimeUnit.SECONDS)) {
LOGGER.log(Level.SEVERE, "Waiting for all GET requests to complete has timed out.");
}
}
} finally {
executor.shutdownNow();
}
StringBuilder messageBuilder = new StringBuilder("POST responses received: ").append(postResponses.size()).append("\n");
for (Map.Entry<Integer, Integer> postResponseEntry : postResponses.entrySet()) {
messageBuilder.append("POST response for message ").append(postResponseEntry.getKey()).append(": ").append(postResponseEntry.getValue()).append('\n');
}
messageBuilder.append('\n');
messageBuilder.append("GET responses received: ").append(getResponses.size()).append("\n");
for (Map.Entry<Integer, Message> getResponseEntry : getResponses.entrySet()) {
messageBuilder.append("GET response for message ").append(getResponseEntry.getKey()).append(": ").append(getResponseEntry.getValue()).append('\n');
}
LOGGER.info(messageBuilder.toString());
for (Map.Entry<Integer, Integer> postResponseEntry : postResponses.entrySet()) {
assertEquals("Unexpected POST notification response for message " + postResponseEntry.getKey(), 200, postResponseEntry.getValue().intValue());
}
final List<Integer> lost = new LinkedList<Integer>();
final Collection<Message> getResponseValues = getResponses.values();
for (int i = 0; i < MAX_MESSAGES; i++) {
if (!getResponseValues.contains(new Message("" + i, "" + i))) {
lost.add(i);
}
}
if (!lost.isEmpty()) {
fail("Detected a posted message loss(es): " + lost.toString());
}
assertEquals(MAX_MESSAGES, postResponses.size());
assertEquals(MAX_MESSAGES, getResponses.size());
}
use of java.util.concurrent.ConcurrentHashMap in project jersey by jersey.
the class ManagedAsyncResourceTest method testLongRunningResource.
@Test
public void testLongRunningResource() throws InterruptedException {
final WebTarget resourceTarget = target().path(App.ASYNC_LONG_RUNNING_MANAGED_OP_PATH);
final String expectedResponse = SimpleJerseyExecutorManagedLongRunningResource.NOTIFICATION_RESPONSE;
final int MAX_MESSAGES = 100;
final int LATCH_WAIT_TIMEOUT = 10 * getAsyncTimeoutMultiplier();
final boolean debugMode = false;
final boolean sequentialGet = false;
final Object sequentialGetLock = new Object();
final ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactoryBuilder().setNameFormat("async-resource-test-%d").setUncaughtExceptionHandler(new JerseyProcessingUncaughtExceptionHandler()).build());
final Map<Integer, String> getResponses = new ConcurrentHashMap<Integer, String>();
final CountDownLatch getRequestLatch = new CountDownLatch(MAX_MESSAGES);
try {
for (int i = 0; i < MAX_MESSAGES; i++) {
final int requestId = i;
executor.submit(new Runnable() {
@Override
public void run() {
if (debugMode || sequentialGet) {
synchronized (sequentialGetLock) {
get();
}
} else {
get();
}
}
private void get() {
try {
int attemptCounter = 0;
while (true) {
attemptCounter++;
try {
final String response = resourceTarget.queryParam("id", requestId).request().get(String.class);
getResponses.put(requestId, response);
break;
} catch (Throwable t) {
LOGGER.log(Level.SEVERE, String.format("Error sending GET request <%s> for %d. time.", requestId, attemptCounter), t);
}
if (attemptCounter > 3) {
break;
}
Thread.sleep(10);
}
} catch (InterruptedException ignored) {
LOGGER.log(Level.WARNING, String.format("Error sending GET message <%s>: Interrupted", requestId), ignored);
} finally {
getRequestLatch.countDown();
}
}
});
}
if (debugMode) {
getRequestLatch.await();
} else {
if (!getRequestLatch.await(LATCH_WAIT_TIMEOUT, TimeUnit.SECONDS)) {
LOGGER.log(Level.SEVERE, "Waiting for all GET requests to complete has timed out.");
}
}
} finally {
executor.shutdownNow();
}
StringBuilder messageBuilder = new StringBuilder("GET responses received: ").append(getResponses.size()).append("\n");
for (Map.Entry<Integer, String> getResponseEntry : getResponses.entrySet()) {
messageBuilder.append("GET response for message ").append(getResponseEntry.getKey()).append(": ").append(getResponseEntry.getValue()).append('\n');
}
LOGGER.info(messageBuilder.toString());
for (Map.Entry<Integer, String> entry : getResponses.entrySet()) {
assertTrue("Unexpected GET notification response for message " + entry.getKey(), entry.getValue().contains(expectedResponse));
}
assertEquals(MAX_MESSAGES, getResponses.size());
}
use of java.util.concurrent.ConcurrentHashMap in project jersey by jersey.
the class AsyncResourceTest method testLongRunningResource.
@Test
public void testLongRunningResource() throws InterruptedException {
final WebTarget resourceTarget = target().path(App.ASYNC_LONG_RUNNING_OP_PATH);
final String expectedResponse = SimpleLongRunningResource.NOTIFICATION_RESPONSE;
final int MAX_MESSAGES = 100;
final int LATCH_WAIT_TIMEOUT = 25 * getAsyncTimeoutMultiplier();
final boolean debugMode = false;
final boolean sequentialGet = false;
final Object sequentialGetLock = new Object();
final ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactoryBuilder().setNameFormat("async-resource-test-%02d").setUncaughtExceptionHandler(new JerseyProcessingUncaughtExceptionHandler()).build());
final Map<Integer, String> getResponses = new ConcurrentHashMap<Integer, String>();
final CountDownLatch getRequestLatch = new CountDownLatch(MAX_MESSAGES);
try {
for (int i = 0; i < MAX_MESSAGES; i++) {
final int requestId = i;
executor.submit(new Runnable() {
@Override
public void run() {
if (debugMode || sequentialGet) {
synchronized (sequentialGetLock) {
get();
}
} else {
get();
}
}
private void get() {
try {
int attemptCounter = 0;
while (true) {
attemptCounter++;
try {
final String response = resourceTarget.request().get(String.class);
getResponses.put(requestId, response);
break;
} catch (Throwable t) {
LOGGER.log(Level.SEVERE, String.format("Error sending GET request <%s> for %d. time.", requestId, attemptCounter), t);
}
if (attemptCounter > 3) {
break;
}
Thread.sleep(10);
}
} catch (InterruptedException ignored) {
LOGGER.log(Level.WARNING, String.format("Error sending GET message <%s>: Interrupted", requestId), ignored);
} finally {
getRequestLatch.countDown();
}
}
});
}
if (debugMode) {
getRequestLatch.await();
} else {
if (!getRequestLatch.await(LATCH_WAIT_TIMEOUT, TimeUnit.SECONDS)) {
LOGGER.log(Level.SEVERE, "Waiting for all GET requests to complete has timed out.");
}
}
} finally {
executor.shutdownNow();
}
final ArrayList<Map.Entry<Integer, String>> responseEntryList = new ArrayList<Map.Entry<Integer, String>>(getResponses.entrySet());
Collections.sort(responseEntryList, new Comparator<Map.Entry<Integer, String>>() {
@Override
public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
return o1.getKey().compareTo(o2.getKey());
}
});
StringBuilder messageBuilder = new StringBuilder("GET responses received: ").append(responseEntryList.size()).append("\n");
for (Map.Entry<Integer, String> getResponseEntry : responseEntryList) {
messageBuilder.append(String.format("GET response for message %02d: ", getResponseEntry.getKey())).append(getResponseEntry.getValue()).append('\n');
}
LOGGER.info(messageBuilder.toString());
for (Map.Entry<Integer, String> entry : responseEntryList) {
assertEquals(String.format("Unexpected GET notification response for message %02d", entry.getKey()), expectedResponse, entry.getValue());
}
assertEquals(MAX_MESSAGES, getResponses.size());
}
Aggregations