conc nieconc

PC21-Watki/src/watki/gotowe/kolekcje/ConcMap_Zwykle.java

+package watki.gotowe.kolekcje;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+
+/* W tym przykładzie porównuję szybkość działania ConcurrentHashMap i zwykłwej HashMap opakowanej w synchronizedMap.
+ * Program tworzy N wątków, które operują na słowniku String→Integer w taki sposób, że
+ * - losują liczbę od 1 do K - po konwersji na tekst staje się ona kluczem w słowniku,
+ * - wykonują operację modyfikacji zawartości słownika pod tym kluczem; aby koszt losowania itp. nie zaszumił kosztu samej mapy, operacja jest powtarzana kilkukrotnie z tym samym kluczem.
+ */
+public class ConcMap_Zwykle {
+	// liczba wątków
+	private static final int N = 16;
+	
+	// wielkość słownika
+	private static final int K = 100;
+	
+	// ilość powtórzeń jednej operacji
+	private static final int P = 50;
+
+	// ilość powtórzeń całości
+	private static final int R = 10_000;
+
+	// odkomentuj jedną z wersji i sprawdź
+	private final Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());
+	// private final Map<String, Integer> map = new ConcurrentHashMap<>();
+	// private final ConcurrentMap<String, Integer> map = new ConcurrentHashMap<>();
+	
+
+	private void dzialaj() {
+		final ThreadLocalRandom random = ThreadLocalRandom.current();
+		for(int r=0; r < R; r++) {
+			final int k = random.nextInt(K);
+			final int d = random.nextInt(1000) - 500;
+			final String key = String.valueOf(k);
+			for(int p = 0; p < P; p++) {
+				Integer v = map.merge(key, d, (x, y) -> x+y);
+				//System.out.println(r + " " + p);
+			}
+		}
+	}
+	
+	public static void main(String[] args) {
+		ConcMap_Zwykle instance = new ConcMap_Zwykle();
+		ExecutorService pool = Executors.newFixedThreadPool(N);
+		System.out.println("Start");
+		long start = System.currentTimeMillis();
+		for(int i = 0; i < N; i++) {
+			pool.submit(instance::dzialaj);
+		}
+		
+		try {
+			pool.shutdown();
+			pool.awaitTermination(1, TimeUnit.HOURS);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		long end = System.currentTimeMillis();
+		System.out.println("Czas: " + (end - start));
+	}
+
+}