Merge pull request #1854 from dhruba619/master

BAEL-839 added test cases and refactored code

core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedBlocks.java

@@ -0,0 +1,35 @@
+package com.baeldung.concurrent.synchronize;
+
+public class BaeldungSynchronizedBlocks {
+
+    private int count = 0;
+    private static int staticCount = 0;
+
+    public void performSynchronisedTask() {
+        synchronized (this) {
+            setCount(getCount() + 1);
+        }
+    }
+
+    public static void performStaticSyncTask() {
+        synchronized (BaeldungSynchronizedBlocks.class) {
+            setStaticCount(getStaticCount() + 1);
+        }
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    public void setCount(int count) {
+        this.count = count;
+    }
+
+    public static int getStaticCount() {
+        return staticCount;
+    }
+
+    public static void setStaticCount(int staticCount) {
+        BaeldungSynchronizedBlocks.staticCount = staticCount;
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedMethods.java

@@ -0,0 +1,37 @@
+package com.baeldung.concurrent.synchronize;
+
+public class BaeldungSynchronizedMethods {
+
+    private int sum = 0;
+    private int syncSum = 0;
+
+    public static int staticSum = 0;
+
+    public void calculate() {
+        setSum(getSum() + 1);
+    }
+
+    public synchronized void synchronisedCalculate() {
+        setSyncSum(getSyncSum() + 1);
+    }
+
+    public static synchronized void syncStaticCalculate() {
+        staticSum = staticSum + 1;
+    }
+
+    public int getSum() {
+        return sum;
+    }
+
+    public void setSum(int sum) {
+        this.sum = sum;
+    }
+
+    public int getSyncSum() {
+        return syncSum;
+    }
+
+    public void setSyncSum(int syncSum) {
+        this.syncSum = syncSum;
+    }
+}

core-java/src/test/java/com/baeldung/concurrent/synchronize/BaeldungSychronizedBlockTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.concurrent.synchronize;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+import org.junit.Test;
+
+public class BaeldungSychronizedBlockTest {
+
+    @Test
+    public void givenMultiThread_whenBlockSync() throws InterruptedException {
+        ExecutorService service = Executors.newFixedThreadPool(3);
+        BaeldungSynchronizedBlocks synchronizedBlocks = new BaeldungSynchronizedBlocks();
+
+        IntStream.range(0, 1000)
+            .forEach(count -> service.submit(synchronizedBlocks::performSynchronisedTask));
+        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+
+        assertEquals(1000, synchronizedBlocks.getCount());
+    }
+
+    @Test
+    public void givenMultiThread_whenStaticSyncBlock() throws InterruptedException {
+        ExecutorService service = Executors.newCachedThreadPool();
+
+        IntStream.range(0, 1000)
+            .forEach(count -> service.submit(BaeldungSynchronizedBlocks::performStaticSyncTask));
+        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+
+        assertEquals(1000, BaeldungSynchronizedBlocks.getStaticCount());
+    }
+
+}

core-java/src/test/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizeMethodsTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.concurrent.synchronize;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class BaeldungSynchronizeMethodsTest {
+
+    @Test
+    @Ignore
+    public void givenMultiThread_whenNonSyncMethod() throws InterruptedException {
+        ExecutorService service = Executors.newFixedThreadPool(3);
+        BaeldungSynchronizedMethods method = new BaeldungSynchronizedMethods();
+
+        IntStream.range(0, 1000)
+            .forEach(count -> service.submit(method::calculate));
+        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+
+        assertEquals(1000, method.getSum());
+    }
+
+    @Test
+    public void givenMultiThread_whenMethodSync() throws InterruptedException {
+        ExecutorService service = Executors.newFixedThreadPool(3);
+        BaeldungSynchronizedMethods method = new BaeldungSynchronizedMethods();
+
+        IntStream.range(0, 1000)
+            .forEach(count -> service.submit(method::synchronisedCalculate));
+        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+
+        assertEquals(1000, method.getSyncSum());
+    }
+
+    @Test
+    public void givenMultiThread_whenStaticSyncMethod() throws InterruptedException {
+        ExecutorService service = Executors.newCachedThreadPool();
+
+        IntStream.range(0, 1000)
+            .forEach(count -> service.submit(BaeldungSynchronizedMethods::syncStaticCalculate));
+        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+
+        assertEquals(1000, BaeldungSynchronizedMethods.staticSum);
+    }
+
+}