In Java 8, the forEach<\/strong>, search<\/strong> and reduce<\/strong> methods of the ConcurrentHashMap<\/strong> have parallel operation capability. Normally, it is indicated by the parameter called parallelismThreshold<\/strong>. This parameter specifies the number of elements before the execution becomes parallel. For example, if the parallelismThreshold is 10 then if the number of elements to process is below 10 then it will be processed in the current thread (i.e. single thread)<\/em> otherwise it will be processed in parallel.<\/p>\n The forEach method has different overloads but we will just be focusing on the simplest one. The one that accepts parallelismThreshold<\/strong> and BiConsumer<\/strong> parameters. To demonstrate parallel execution in action lets start with the ConcurrentHashMap that has items less than the parallelismThreshold like the following snippet (see the complete code<\/a> at the bottom)<\/em>:<\/p>\n Running the above snippet will not run in parallel execution since the items in the map is less than the parallelismThreshold. But updating the variable\u00a0parallelismThreshold <\/strong>variable to 9 and run it again. We must see an output like the following output:<\/p>\n Notice the ForkJoinPool.commonPool-worker<\/strong> thread which indicates that the forEach method is operating on parallel.<\/p>\n The search method is the functionality to find an item in the map with parallel support. This methods has siblings namely: searchEntries<\/strong>, searchKeys<\/strong> and searchValues <\/strong>but we will just be focusing on the search method with parallelismThreshold<\/strong> and BiFunction<\/strong> parameters. For the sample usage, see the following snippet\u00a0(see the complete code<\/a> at the bottom)<\/em>.<\/p>\n We can run the previous snippet after concatenating it with snippet 1. The search will stop when the BiFunction implementation return non-null value. Otherwise, the search will continue. This is good if you have a big map.<\/p>\n The reduce method is the one to use if we need to accumulate something from the map items to produce a single result. This also supports parallel operation and has many siblings (e.g. reduceEntries, reduceKeys, reduceValues, etc ...)<\/em>. But, we will only focus on the reduce method itself that accepts parallelismThreshold<\/strong>, transformer<\/strong> (i.e. BiFunction)<\/em> and reducer<\/strong> (i.e. BiFunction)<\/em>.<\/p>\n The transformer parameter is the one that prepares what the reducer will work on. Like for example if the wanted to work on the values of the map from snippet 1. The transformer would be something like the following:<\/p>\n Knowing what the transformer will give us. We can write a reducer logic what will add all the values returned by the transformer logic like the following:<\/p>\nUsing the forEach method<\/h4>\n
Snippet 1 - Elements less than parallelismThreshold<\/strong><\/h6>\n
ConcurrentHashMap<String, Integer> map<\/strong> = new ConcurrentHashMap<>();\r\n\r\n\/\/This will generate a stream with 1 to 9 as integer content.\r\nIntStream.range(1, 10).forEach(item -> map.put(String.valueOf(item), item));\r\n\r\nlong parallelismThreshold<\/strong> = 10;\r\n\r\nBiConsumer<String, Integer> biConsumer<\/strong> = (key, value) -> {\r\n System.out.println(\"key: \" + key + \" value: \" + value + \" thread: \" + Thread.currentThread().getName());\r\n};\r\n\r\nmap.forEach(parallelismThreshold, biConsumer);<\/strong><\/pre>\nOutput 1 - Updating the parallelismThreshold to 9 in snippet 1<\/h6>\n
key: 1 value: 1 thread: main\r\nkey: 8 value: 8 thread: ForkJoinPool.commonPool-worker-1\r\nkey: 2 value: 2 thread: main\r\nkey: 9 value: 9 thread: ForkJoinPool.commonPool-worker-1\r\nkey: 3 value: 3 thread: main\r\nkey: 4 value: 4 thread: main\r\nkey: 5 value: 5 thread: main\r\nkey: 6 value: 6 thread: main\r\nkey: 7 value: 7 thread: main<\/pre>\n
Using the search method<\/h4>\n
Snippet 2 - Sample usage of search method<\/h6>\n
BiFunction<String, Integer, Integer> biFunction<\/strong> = (key, value) -> {\r\n\r\n if (key.equals(\"9\")) {\r\n return value; \/\/Stop searching.\r\n }\r\n return null; \/\/Continue searching.\r\n};\r\n\r\nSystem.out.println(\"Value: \" + map.search(parallelismThreshold, biFunction)<\/strong>);\r\n<\/pre>\nUsing the reduce method<\/h4>\n
Snippet 3 - Transformer logic<\/h6>\n
BiFunction<String, Integer, Integer> transformer<\/strong> = (key, value) -> value;<\/pre>\n
Snippet 4 - Reducer logic<\/h6>\n
BiFunction<Integer, Integer, Integer> reducer<\/strong> = (aggr, value) -> aggr + value;\r\n<\/pre>\n