✨ Feat : Counter

.github/workflows/gradle-test-main.yml

@@ -28,5 +28,6 @@ jobs:
                 with:
                     token: ${{ secrets.CODECOV_TOKEN }}
                     slug: spring-templates/spring-concurrency-thread
-                    fail_ci_if_error: true 
+                    flags: integration
+                    fail_ci_if_error: true
                     verbose: true 

.github/workflows/gradle-test.yml

@@ -2,8 +2,9 @@ name: Run gradlew test
 
 on:
     pull_request:
-        branches-ignore:
-            - main
+        branches:
+            - develop
+            - feature/**
 
 jobs:
     build:
@@ -36,6 +37,6 @@ jobs:
                 with:
                     token: ${{ secrets.CODECOV_TOKEN }}
                     slug: spring-templates/spring-concurrency-thread
-                    fail_ci_if_error: true 
-                    verbose: true 
-                    flags: unittests
+                    fail_ci_if_error: true
+                    verbose: true
+                    flags: ${{ github.ref == 'refs/pull/develop' && 'integration' || 'unittests' }}

codecov.yml

@@ -0,0 +1,10 @@
+coverage:
+    status:
+        project:
+            default:
+                target: 40%
+                threshold: 10%
+        patch:
+            default:
+                target: 30%
+                threshold: 10%

src/main/java/com/thread/concurrency/counter/BatchingCounter.java

@@ -0,0 +1,38 @@
+package com.thread.concurrency.counter;
+
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+@Component
+public class BatchingCounter implements Counter {
+    private static final ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
+    private static final ConcurrentLinkedQueue<Integer> jobQueue = new ConcurrentLinkedQueue<>();
+    private static volatile int count = 100;
+
+    public BatchingCounter() {
+        Runnable runnableTask = () -> {
+            while (!jobQueue.isEmpty()) {
+                synchronized (this) {
+                    var value = jobQueue.poll();
+                    count += value == null ? 0 : value;
+                }
+            }
+        };
+        // context switching을 최소화하는 최소한의 시간마다 실행하여 성능 향상
+        scheduledExecutorService.scheduleAtFixedRate(runnableTask, 4, 5, TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public void add(int value) {
+        jobQueue.add(value);
+    }
+
+    @Override
+    public int show() {
+        return count;
+    }
+}

src/main/java/com/thread/concurrency/counter/LockCounter.java

@@ -0,0 +1,26 @@
+package com.thread.concurrency.counter;
+
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+@Component
+public class LockCounter implements Counter {
+    private static final ReentrantLock lock = new ReentrantLock();
+    private static int count = 100;
+
+    @Override
+    public void add(int value) {
+        lock.lock();
+        try {
+            count += value;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    public int show() {
+        return count;
+    }
+}

src/main/java/com/thread/concurrency/counter/PollingCounter.java

@@ -0,0 +1,34 @@
+package com.thread.concurrency.counter;
+
+import org.springframework.stereotype.Component;
+
+@Component
+// use technique spin-lock(busy waiting)
+// this approach can lead to high CPU usage if the lock is heavily contended
+public class PollingCounter implements Counter {
+    private static int count = 100;
+    private static volatile boolean lock = false;
+
+    private static void doAdd(int value) {
+        count += value;
+    }
+
+    @Override
+    public void add(int value) {
+        while (true) {
+            if (!lock) {
+                synchronized (PollingCounter.class) {
+                    lock = true;
+                    doAdd(value);
+                    lock = false;
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public int show() {
+        return count;
+    }
+}

src/test/java/com/thread/concurrency/counter/CounterTest.java

@@ -0,0 +1,64 @@
+package com.thread.concurrency.counter;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.stream.Stream;
+
+import static java.lang.Thread.sleep;
+
+@SpringBootTest
+public class CounterTest {
+
+    public static Stream<Counter> counterProvider() {
+        return Stream.of(new BatchingCounter(), new LockCounter(), new PollingCounter(), new BasicCounter());
+    }
+
+    private static void assertThen(Counter counter, int expectedValue, int actualValue) {
+        System.out.println("Expected value: " + expectedValue);
+        System.out.println("Actual value: " + actualValue);
+        if (counter instanceof BasicCounter) {
+            System.out.println("BasicCounter is not thread-safe");
+            Assertions.assertNotEquals(expectedValue, actualValue);
+        } else {
+            System.out.println("Counter is thread-safe");
+            Assertions.assertEquals(expectedValue, actualValue);
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("counterProvider")
+    public void stressTest(Counter counter) throws InterruptedException {
+        int initialValue = counter.show();
+        int nThreads = 100;
+        int nAddsPerThread = 1000;
+        int valueToAdd = 1;
+        int expectedValue = initialValue + nThreads * nAddsPerThread * valueToAdd;
+
+
+        // define runnable job
+        CountDownLatch latch = new CountDownLatch(nThreads);
+        Runnable job = () -> {
+            try {
+                latch.countDown(); // decrease the count
+                latch.await(); // wait until the count reaches 0
+                for (int i = 0; i < nAddsPerThread; i++) {
+                    counter.add(valueToAdd);
+                }
+            } catch (InterruptedException ignored) {
+            }
+        };
+
+        // start nThreads threads
+        for (int i = 0; i < nThreads; i++) {
+            Thread.ofVirtual().start(job);
+        }
+
+        sleep(300); // wait for all threads to finish
+
+        assertThen(counter, expectedValue, counter.show());
+    }
+}