BAEL-3855

core-java-modules/core-java-concurrency-collections-2/src/main/java/com/baeldung/concurrent/lock/ConcurrentAccessBenchmark.java

@@ -1,5 +1,7 @@
 package com.baeldung.concurrent.lock;
 
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 
 import org.openjdk.jmh.annotations.Benchmark;
@@ -7,14 +9,12 @@ import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
 import org.openjdk.jmh.annotations.Mode;
 import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Param;
 import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.annotations.Warmup;
 
 @State(Scope.Thread)
-@Fork(value = 1)
+@Fork(value = 2)
 @Warmup(iterations = 0)
 public class ConcurrentAccessBenchmark {
     ConcurrentAccessExperiment accessMyMap;
@@ -22,28 +22,31 @@ public class ConcurrentAccessBenchmark {
     static final int THREADS = 10000;
     static final int BUCKETS = Runtime.getRuntime().availableProcessors() * SLOTS;
 
-    @Param({"Single Lock", "Striped Lock"})
-    private String lockType;
-
-    @Param({"HashMap", "ConcurrentHashMap"})
-    private String mapType;
-
-    @Setup
-    public void setup() {
-        switch (lockType) {
-            case "Single Lock":
-                accessMyMap = new SingleLock();
-                break;
-            case "Striped Lock":
-                accessMyMap = new StripedLock(BUCKETS);
-                break;
-        }
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public void singleLockHashMap() throws InterruptedException {
+        (new SingleLock()).doWork(new HashMap<String,String>(), THREADS, SLOTS);
     }
 
     @Benchmark
     @BenchmarkMode(Mode.Throughput)
     @OutputTimeUnit(TimeUnit.MILLISECONDS)
-    public void test() throws InterruptedException {
-        accessMyMap.doWork(mapType, THREADS, SLOTS);
+    public void stripedLockHashMap() throws InterruptedException {
+    	(new StripedLock(BUCKETS)).doWork(new HashMap<String,String>(), THREADS, SLOTS);
+    }
+    
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public void singleLockConcurrentHashMap() throws InterruptedException {
+    	(new SingleLock()).doWork(new ConcurrentHashMap<String,String>(), THREADS, SLOTS);
+    }
+    
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public void stripedLockConcurrentHashMap() throws InterruptedException {
+    	(new StripedLock(BUCKETS)).doWork(new ConcurrentHashMap<String,String>(), THREADS, SLOTS);
     }
 }

core-java-modules/core-java-concurrency-collections-2/src/main/java/com/baeldung/concurrent/lock/ConcurrentAccessExperiment.java

@@ -1,30 +1,14 @@
 package com.baeldung.concurrent.lock;
 
-import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
 
 import com.google.common.base.Supplier;
 
 public abstract class ConcurrentAccessExperiment {
 
-    public ConcurrentAccessExperiment() {
-    }
-
-    private Map<String,String> doMapSetup(String typeOfMap) {
-        switch (typeOfMap) {
-            case "HashMap":
-                return new HashMap<String,String>();
-            case "ConcurrentHashMap":
-                return new ConcurrentHashMap<String,String>();
-        }
-        return null;
-    }
-
-    public final void doWork(String typeOfMap, int threads, int slots) {
+    public final Map<String,String> doWork(Map<String,String> map, int threads, int slots) {
         CompletableFuture<?>[] requests = new CompletableFuture<?>[threads * slots];
-        Map<String,String> map = doMapSetup(typeOfMap);
 
         for (int i = 0; i < threads; i++) {
             requests[slots * i + 0] = CompletableFuture.supplyAsync(putSupplier(map, i));
@@ -33,6 +17,8 @@ public abstract class ConcurrentAccessExperiment {
             requests[slots * i + 3] = CompletableFuture.supplyAsync(getSupplier(map, i));
         }
         CompletableFuture.allOf(requests).join();
+
+        return map;
     }
 
     protected abstract Supplier<?> putSupplier(Map<String,String> map, int key);

core-java-modules/core-java-concurrency-collections-2/src/main/java/com/baeldung/concurrent/lock/StripedLock.java

@@ -10,12 +10,7 @@ public class StripedLock extends ConcurrentAccessExperiment {
     Striped<Lock> lock;
 
     public StripedLock(int buckets) {
-        lock = getStripedLock(buckets);
-    }
-
-    private Striped<Lock> getStripedLock(int buckets) {
-        Striped<Lock> map = Striped.lock(buckets);
-        return map;
+        lock = Striped.lock(buckets);
     }
 
     protected synchronized Supplier<?> putSupplier(Map<String,String> map, int key) {