java.util.concurrent

According to Java Concurrency in Practice, chapter 11.4.3 says: Lock splitting can sometimes be extended to partition locking on a variablesized set of independent objects, in which case it is called lock striping. For example, the implementation of ConcurrentHashMap uses an array of 16 locks, each of which guards 1/16 of the hash buckets; bucket N is guarded by lock N mod 16. I still have problems to understand and visualize the lock striping and buckets mechanism. Can someone explain this with good understanding words :) Thanks in advance. The hash map is built on an array, where the hash

I have heard Java 8 provides a lot of utilities regarding concurrent computing. Therefore I am wondering what is the simplest way to parallelise the given for loop? public static void main(String[] args) { Set<Server> servers = getServers(); Map<String, String> serverData = new ConcurrentHashMap<>(); for (Server server : servers) { String serverId = server.getIdentifier(); String data = server.fetchData(); serverData.put(serverId, data); } } Read up on streams , they're all the new rage. Pay especially close attention to the bit about parallelism: "Processing elements with an explicit for-loop

I have a scenario where I have to execute 5 thread asynchronously for the same callable. As far as I understand, there are two options: 1) using submit(Callable) ExecutorService executorService = Executors.newFixedThreadPool(5); List<Future<String>> futures = new ArrayList<>(); for(Callable callableItem: myCallableList){ futures.add(executorService.submit(callableItem)); } 2) using invokeAll(Collections of Callable) ExecutorService executorService = Executors.newFixedThreadPool(5); List<Future<String>> futures = executorService.invokeAll(myCallableList)); What should be the preferred way? Is

Can the following piece of code be rewritten w/o using Collections.synchronizedMap() yet maintaining correctness at concurrency? Collections.synchronizedMap(new WeakHashMap<Class, Object>()); i.e. is there something from java.util.concurrent one can use instead? Note that merely replacing with new ConcurrentHashMap<Class, Object>(new WeakHashMap<Class, Object>())); obviously won't work Steven Schlansker Guava 's CacheBuilder class allows you to do this easily. CacheBuilder.newBuilder().weakKeys().build() Note that this changes key equality semantics to be == instead of .equals() which will not

I see that the above annotations are used extensively in the book JCIP . I think it is really useful because even in the absence of proper documentation it says some things about the synchronization policies . I also see that Intellij Idea makes use of these annotations Are they now actually part of the Java language itself ? assylias These are custom annotations that are not part of the standard JDK. To be able to use them in your code, you need to add a dependency. At jcip.net , there is a link to the library and its source in the bottom part of the page " Concurrency annotations: jar,

In JDK8, how many threads are spawned when i'm using parallelStream? For instance, in the code: list.parallelStream().forEach(/** Do Something */); If this list has 100000 items, how many threads will be spawned? Also, do each of the threads get the same number of items to work on or is it randomly allotted? Umberto Raimondi The Oracle's implementation[1] of parallel stream uses the current thread and in addition to that, if needed, also the threads that compose the default fork join pool ForkJoinPool.commonPool() , which has a default size equal to one less than the number of cores of your

Wanted to run collection of Runnable task through invokeAll(..) method of ExecutorService . But that's not supported as of now ( supports collection of Callable task only ) Any specific reason for this? What's the alternative to do something similar. Simply transform the runnables into callables: List<Callable<Void>> callables = new ArrayList<>(); for (Runnable r : runnables) { callables.add(toCallable(r)); } executor.invokeAll(callables); private Callable<Void> toCallable(final Runnable runnable) { return new Callable<Void>() { @Override public Void call() { runnable.run(); return null; } };