From e5f43622bec8ee4be55a64f54ff889b24a7f3028 Mon Sep 17 00:00:00 2001 From: RanjeetKaur17 Date: Fri, 19 Oct 2018 19:58:50 +0400 Subject: [PATCH 1/6] Example to demonstrate differences between CyclicBarrier and CountDownLatch. --- .../CountdownLatchCountExample.java | 33 +++++++++++++ .../CountdownLatchResetExample.java | 41 ++++++++++++++++ .../CyclicBarrierCompletionMethodExample.java | 46 ++++++++++++++++++ .../CyclicBarrierCountExample.java | 32 +++++++++++++ .../CyclicBarrierResetExample.java | 47 +++++++++++++++++++ .../CountdownLatchCountExampleUnitTest.java | 15 ++++++ .../CountdownLatchResetExampleUnitTest.java | 17 +++++++ ...arrierCompletionMethodExampleUnitTest.java | 17 +++++++ .../CyclicBarrierCountExampleUnitTest.java | 15 ++++++ .../CyclicBarrierResetExampleUnitTest.java | 17 +++++++ 10 files changed, 280 insertions(+) create mode 100644 core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExample.java create mode 100644 core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java create mode 100644 core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExample.java create mode 100644 core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExample.java create mode 100644 core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java create mode 100644 core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExampleUnitTest.java create mode 100644 core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java create mode 100644 core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java create mode 100644 core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExampleUnitTest.java create mode 100644 core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExample.java new file mode 100644 index 0000000000..08c7eeec03 --- /dev/null +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExample.java @@ -0,0 +1,33 @@ +package com.baeldung.concurrent.countdownlatch; + +import java.util.concurrent.CountDownLatch; + +public class CountdownLatchCountExample { + + private int count; + + public CountdownLatchCountExample(int count) { + this.count = count; + } + + public boolean callTwiceInSameThread() { + CountDownLatch countDownLatch = new CountDownLatch(count); + Thread t = new Thread(() -> { + countDownLatch.countDown(); + countDownLatch.countDown(); + }); + t.start(); + + try { + countDownLatch.await(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return countDownLatch.getCount() == 0; + } + + public static void main(String[] args) { + CountdownLatchCountExample ex = new CountdownLatchCountExample(2); + System.out.println("Is CountDown Completed : " + ex.callTwiceInSameThread()); + } +} diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java new file mode 100644 index 0000000000..7effc9e374 --- /dev/null +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java @@ -0,0 +1,41 @@ +package com.baeldung.concurrent.countdownlatch; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +public class CountdownLatchResetExample { + + private int count; + private int threadCount; + private final List outputScraper; + + CountdownLatchResetExample(final List outputScraper, int count, int threadCount) { + this.outputScraper = outputScraper; + this.count = count; + this.threadCount = threadCount; + } + + public int countWaits() { + CountDownLatch countDownLatch = new CountDownLatch(count); + ExecutorService es = Executors.newFixedThreadPool(threadCount); + for (int i = 0; i < threadCount; i++) { + es.execute(() -> { + if (countDownLatch.getCount() > 0) { + outputScraper.add("Count Left : " + countDownLatch.getCount()); + } + countDownLatch.countDown(); + }); + } + + es.shutdown(); + return outputScraper.size(); + } + + public static void main(String[] args) { + CountdownLatchResetExample ex = new CountdownLatchResetExample(new ArrayList<>(),5,20); + System.out.println("Count : " + ex.countWaits()); + } +} diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExample.java new file mode 100644 index 0000000000..b7a32e2c8d --- /dev/null +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExample.java @@ -0,0 +1,46 @@ +package com.baeldung.concurrent.cyclicbarrier; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.BrokenBarrierException; +import java.util.concurrent.CyclicBarrier; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +public class CyclicBarrierCompletionMethodExample { + + private int count; + private int threadCount; + private final List outputScraper; + + CyclicBarrierCompletionMethodExample(final List outputScraper, int count, int threadCount) { + this.outputScraper = outputScraper; + this.count = count; + this.threadCount = threadCount; + } + + public int countTrips() { + + CyclicBarrier cyclicBarrier = new CyclicBarrier(count, () -> { + outputScraper.add("Barrier is Tripped"); + }); + + ExecutorService es = Executors.newFixedThreadPool(threadCount); + for (int i = 0; i < threadCount; i++) { + es.execute(() -> { + try { + cyclicBarrier.await(); + } catch (InterruptedException | BrokenBarrierException e) { + e.printStackTrace(); + } + }); + } + es.shutdown(); + return outputScraper.size(); + } + + public static void main(String[] args) { + CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(new ArrayList(), 5, 20); + System.out.println("Count : " + ex.countTrips()); + } +} diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExample.java new file mode 100644 index 0000000000..c7a9b20698 --- /dev/null +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExample.java @@ -0,0 +1,32 @@ +package com.baeldung.concurrent.cyclicbarrier; + +import java.util.concurrent.BrokenBarrierException; +import java.util.concurrent.CyclicBarrier; + +public class CyclicBarrierCountExample { + + private int count; + + public CyclicBarrierCountExample(int count) { + this.count = count; + } + + public boolean callTwiceInSameThread() { + CyclicBarrier cyclicBarrier = new CyclicBarrier(count); + Thread t = new Thread(() -> { + try { + cyclicBarrier.await(); + cyclicBarrier.await(); + } catch (InterruptedException | BrokenBarrierException e) { + e.printStackTrace(); + } + }); + t.start(); + return cyclicBarrier.isBroken(); + } + + public static void main(String[] args) { + CyclicBarrierCountExample ex = new CyclicBarrierCountExample(1); + System.out.println("Count : " + ex.callTwiceInSameThread()); + } +} diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java new file mode 100644 index 0000000000..c355b7eead --- /dev/null +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java @@ -0,0 +1,47 @@ +package com.baeldung.concurrent.cyclicbarrier; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.BrokenBarrierException; +import java.util.concurrent.CyclicBarrier; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +public class CyclicBarrierResetExample { + + private int count; + private int threadCount; + private final List outputScraper; + + CyclicBarrierResetExample(final List outputScraper, int count, int threadCount) { + this.outputScraper = outputScraper; + this.count = count; + this.threadCount = threadCount; + } + + public int countWaits() { + + CyclicBarrier cyclicBarrier = new CyclicBarrier(count); + + ExecutorService es = Executors.newFixedThreadPool(threadCount); + for (int i = 0; i < threadCount; i++) { + es.execute(() -> { + try { + if (cyclicBarrier.getNumberWaiting() > 0) { + outputScraper.add("Waiting Count : " + cyclicBarrier.getNumberWaiting()); + } + cyclicBarrier.await(); + } catch (InterruptedException | BrokenBarrierException e) { + e.printStackTrace(); + } + }); + } + es.shutdown(); + return outputScraper.size(); + } + + public static void main(String[] args) { + CyclicBarrierResetExample ex = new CyclicBarrierResetExample(new ArrayList(), 5, 20); + System.out.println("Count : " + ex.countWaits()); + } +} diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExampleUnitTest.java new file mode 100644 index 0000000000..835efa53f2 --- /dev/null +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchCountExampleUnitTest.java @@ -0,0 +1,15 @@ +package com.baeldung.concurrent.countdownlatch; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +public class CountdownLatchCountExampleUnitTest { + + @Test + public void whenCountDownLatch_completed() { + CountdownLatchCountExample ex = new CountdownLatchCountExample(2); + boolean isCompleted = ex.callTwiceInSameThread(); + assertTrue(isCompleted); + } +} diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java new file mode 100644 index 0000000000..2018c9168d --- /dev/null +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java @@ -0,0 +1,17 @@ +package com.baeldung.concurrent.countdownlatch; + +import static org.junit.Assert.assertEquals; + +import java.util.ArrayList; + +import org.junit.Test; + +public class CountdownLatchResetExampleUnitTest { + + @Test + public void whenCountDownLatch_noReset() { + CountdownLatchResetExample ex = new CountdownLatchResetExample(new ArrayList<>(),5,20); + int lineCount = ex.countWaits(); + assertEquals(5, lineCount); + } +} diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java new file mode 100644 index 0000000000..e8db84935a --- /dev/null +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java @@ -0,0 +1,17 @@ +package com.baeldung.concurrent.cyclicbarrier; + +import static org.junit.Assert.assertEquals; + +import java.util.ArrayList; + +import org.junit.Test; + +public class CyclicBarrierCompletionMethodExampleUnitTest { + + @Test + public void whenCyclicBarrier_countTrips() { + CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(new ArrayList<>(),5,20); + int lineCount = ex.countTrips(); + assertEquals(4, lineCount); + } +} diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExampleUnitTest.java new file mode 100644 index 0000000000..9b7f3d9945 --- /dev/null +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExampleUnitTest.java @@ -0,0 +1,15 @@ +package com.baeldung.concurrent.cyclicbarrier; + +import static org.junit.Assert.assertFalse; + +import org.junit.Test; + +public class CyclicBarrierCountExampleUnitTest { + + @Test + public void whenCyclicBarrier_notCompleted() { + CyclicBarrierCountExample ex = new CyclicBarrierCountExample(2); + boolean isCompleted = ex.callTwiceInSameThread(); + assertFalse(isCompleted); + } +} diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java new file mode 100644 index 0000000000..2871d16348 --- /dev/null +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java @@ -0,0 +1,17 @@ +package com.baeldung.concurrent.cyclicbarrier; + +import static org.junit.Assert.assertEquals; + +import java.util.ArrayList; + +import org.junit.Test; + +public class CyclicBarrierResetExampleUnitTest { + + @Test + public void whenCyclicBarrier_reset() { + CyclicBarrierResetExample ex = new CyclicBarrierResetExample(new ArrayList<>(),5,20); + int lineCount = ex.countWaits(); + assertEquals(16, lineCount); + } +} From a559137c8c31028fc0b757f86f2656d49122b438 Mon Sep 17 00:00:00 2001 From: RanjeetKaur17 Date: Wed, 24 Oct 2018 23:05:27 +0400 Subject: [PATCH 2/6] Changes as per review comments --- .../countdownlatch/CountdownLatchResetExample.java | 7 ++++--- .../cyclicbarrier/CyclicBarrierCountExample.java | 2 +- .../cyclicbarrier/CyclicBarrierResetExample.java | 6 +++--- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java index 7effc9e374..55e509e374 100644 --- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java @@ -23,10 +23,11 @@ public class CountdownLatchResetExample { ExecutorService es = Executors.newFixedThreadPool(threadCount); for (int i = 0; i < threadCount; i++) { es.execute(() -> { - if (countDownLatch.getCount() > 0) { - outputScraper.add("Count Left : " + countDownLatch.getCount()); - } + long prevValue = countDownLatch.getCount(); countDownLatch.countDown(); + if (countDownLatch.getCount() != prevValue) { + outputScraper.add("Count Updated"); + } }); } diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExample.java index c7a9b20698..9d637b428b 100644 --- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExample.java +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCountExample.java @@ -26,7 +26,7 @@ public class CyclicBarrierCountExample { } public static void main(String[] args) { - CyclicBarrierCountExample ex = new CyclicBarrierCountExample(1); + CyclicBarrierCountExample ex = new CyclicBarrierCountExample(7); System.out.println("Count : " + ex.callTwiceInSameThread()); } } diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java index c355b7eead..febeb0978e 100644 --- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java @@ -28,8 +28,8 @@ public class CyclicBarrierResetExample { es.execute(() -> { try { if (cyclicBarrier.getNumberWaiting() > 0) { - outputScraper.add("Waiting Count : " + cyclicBarrier.getNumberWaiting()); - } + outputScraper.add("Count Updated"); + } cyclicBarrier.await(); } catch (InterruptedException | BrokenBarrierException e) { e.printStackTrace(); @@ -41,7 +41,7 @@ public class CyclicBarrierResetExample { } public static void main(String[] args) { - CyclicBarrierResetExample ex = new CyclicBarrierResetExample(new ArrayList(), 5, 20); + CyclicBarrierResetExample ex = new CyclicBarrierResetExample(new ArrayList(), 7, 20); System.out.println("Count : " + ex.countWaits()); } } From 541fa8d5be14ed66591c1201ae4e010c870693d1 Mon Sep 17 00:00:00 2001 From: RanjeetKaur17 Date: Fri, 26 Oct 2018 20:50:07 +0400 Subject: [PATCH 3/6] Using AtomicInteger to avoid Race conditions --- .../CountdownLatchResetExample.java | 19 +++++++++---------- .../CyclicBarrierCompletionMethodExample.java | 15 +++++++-------- .../CyclicBarrierResetExample.java | 15 +++++++-------- .../CountdownLatchResetExampleUnitTest.java | 2 +- ...arrierCompletionMethodExampleUnitTest.java | 4 +--- .../CyclicBarrierResetExampleUnitTest.java | 4 +--- 6 files changed, 26 insertions(+), 33 deletions(-) diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java index 55e509e374..1828b7f91e 100644 --- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExample.java @@ -1,23 +1,22 @@ package com.baeldung.concurrent.countdownlatch; -import java.util.ArrayList; -import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; +import java.util.concurrent.atomic.AtomicInteger; public class CountdownLatchResetExample { private int count; private int threadCount; - private final List outputScraper; - - CountdownLatchResetExample(final List outputScraper, int count, int threadCount) { - this.outputScraper = outputScraper; + private final AtomicInteger updateCount; + + CountdownLatchResetExample(int count, int threadCount) { + updateCount = new AtomicInteger(0); this.count = count; this.threadCount = threadCount; } - + public int countWaits() { CountDownLatch countDownLatch = new CountDownLatch(count); ExecutorService es = Executors.newFixedThreadPool(threadCount); @@ -26,17 +25,17 @@ public class CountdownLatchResetExample { long prevValue = countDownLatch.getCount(); countDownLatch.countDown(); if (countDownLatch.getCount() != prevValue) { - outputScraper.add("Count Updated"); + updateCount.incrementAndGet(); } }); } es.shutdown(); - return outputScraper.size(); + return updateCount.get(); } public static void main(String[] args) { - CountdownLatchResetExample ex = new CountdownLatchResetExample(new ArrayList<>(),5,20); + CountdownLatchResetExample ex = new CountdownLatchResetExample(5, 20); System.out.println("Count : " + ex.countWaits()); } } diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExample.java index b7a32e2c8d..7c1299da62 100644 --- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExample.java +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExample.java @@ -1,20 +1,19 @@ package com.baeldung.concurrent.cyclicbarrier; -import java.util.ArrayList; -import java.util.List; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; +import java.util.concurrent.atomic.AtomicInteger; public class CyclicBarrierCompletionMethodExample { private int count; private int threadCount; - private final List outputScraper; + private final AtomicInteger updateCount; - CyclicBarrierCompletionMethodExample(final List outputScraper, int count, int threadCount) { - this.outputScraper = outputScraper; + CyclicBarrierCompletionMethodExample(int count, int threadCount) { + updateCount = new AtomicInteger(0); this.count = count; this.threadCount = threadCount; } @@ -22,7 +21,7 @@ public class CyclicBarrierCompletionMethodExample { public int countTrips() { CyclicBarrier cyclicBarrier = new CyclicBarrier(count, () -> { - outputScraper.add("Barrier is Tripped"); + updateCount.incrementAndGet(); }); ExecutorService es = Executors.newFixedThreadPool(threadCount); @@ -36,11 +35,11 @@ public class CyclicBarrierCompletionMethodExample { }); } es.shutdown(); - return outputScraper.size(); + return updateCount.get(); } public static void main(String[] args) { - CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(new ArrayList(), 5, 20); + CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(5, 20); System.out.println("Count : " + ex.countTrips()); } } diff --git a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java index febeb0978e..76b6198bc4 100644 --- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java +++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExample.java @@ -1,20 +1,19 @@ package com.baeldung.concurrent.cyclicbarrier; -import java.util.ArrayList; -import java.util.List; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; +import java.util.concurrent.atomic.AtomicInteger; public class CyclicBarrierResetExample { private int count; private int threadCount; - private final List outputScraper; + private final AtomicInteger updateCount; - CyclicBarrierResetExample(final List outputScraper, int count, int threadCount) { - this.outputScraper = outputScraper; + CyclicBarrierResetExample(int count, int threadCount) { + updateCount = new AtomicInteger(0); this.count = count; this.threadCount = threadCount; } @@ -28,7 +27,7 @@ public class CyclicBarrierResetExample { es.execute(() -> { try { if (cyclicBarrier.getNumberWaiting() > 0) { - outputScraper.add("Count Updated"); + updateCount.incrementAndGet(); } cyclicBarrier.await(); } catch (InterruptedException | BrokenBarrierException e) { @@ -37,11 +36,11 @@ public class CyclicBarrierResetExample { }); } es.shutdown(); - return outputScraper.size(); + return updateCount.get(); } public static void main(String[] args) { - CyclicBarrierResetExample ex = new CyclicBarrierResetExample(new ArrayList(), 7, 20); + CyclicBarrierResetExample ex = new CyclicBarrierResetExample(7, 20); System.out.println("Count : " + ex.countWaits()); } } diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java index 2018c9168d..658ab5301a 100644 --- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java @@ -10,7 +10,7 @@ public class CountdownLatchResetExampleUnitTest { @Test public void whenCountDownLatch_noReset() { - CountdownLatchResetExample ex = new CountdownLatchResetExample(new ArrayList<>(),5,20); + CountdownLatchResetExample ex = new CountdownLatchResetExample(5,20); int lineCount = ex.countWaits(); assertEquals(5, lineCount); } diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java index e8db84935a..f76b51c100 100644 --- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java @@ -2,15 +2,13 @@ package com.baeldung.concurrent.cyclicbarrier; import static org.junit.Assert.assertEquals; -import java.util.ArrayList; - import org.junit.Test; public class CyclicBarrierCompletionMethodExampleUnitTest { @Test public void whenCyclicBarrier_countTrips() { - CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(new ArrayList<>(),5,20); + CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(5,20); int lineCount = ex.countTrips(); assertEquals(4, lineCount); } diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java index 2871d16348..413a17e9ff 100644 --- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java @@ -2,15 +2,13 @@ package com.baeldung.concurrent.cyclicbarrier; import static org.junit.Assert.assertEquals; -import java.util.ArrayList; - import org.junit.Test; public class CyclicBarrierResetExampleUnitTest { @Test public void whenCyclicBarrier_reset() { - CyclicBarrierResetExample ex = new CyclicBarrierResetExample(new ArrayList<>(),5,20); + CyclicBarrierResetExample ex = new CyclicBarrierResetExample(5,20); int lineCount = ex.countWaits(); assertEquals(16, lineCount); } From 6ea369f248a8f0dad11a6efd9b9d30a566f6f4c6 Mon Sep 17 00:00:00 2001 From: RanjeetKaur17 Date: Fri, 26 Oct 2018 20:59:34 +0400 Subject: [PATCH 4/6] Fixing Test Cases --- .../CyclicBarrierCompletionMethodExampleUnitTest.java | 4 ++-- .../cyclicbarrier/CyclicBarrierResetExampleUnitTest.java | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java index f76b51c100..310063c86c 100644 --- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java @@ -8,8 +8,8 @@ public class CyclicBarrierCompletionMethodExampleUnitTest { @Test public void whenCyclicBarrier_countTrips() { - CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(5,20); + CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(7,20); int lineCount = ex.countTrips(); - assertEquals(4, lineCount); + assertEquals(2, lineCount); } } diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java index 413a17e9ff..7b6306df76 100644 --- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java @@ -8,8 +8,8 @@ public class CyclicBarrierResetExampleUnitTest { @Test public void whenCyclicBarrier_reset() { - CyclicBarrierResetExample ex = new CyclicBarrierResetExample(5,20); + CyclicBarrierResetExample ex = new CyclicBarrierResetExample(7,20); int lineCount = ex.countWaits(); - assertEquals(16, lineCount); + assertEquals(17, lineCount); } } From 512a6e05a1dd24ec7caa6c0da53e3e278d40e674 Mon Sep 17 00:00:00 2001 From: RanjeetKaur17 Date: Fri, 26 Oct 2018 21:09:58 +0400 Subject: [PATCH 5/6] Fixing Test Cases --- .../cyclicbarrier/CyclicBarrierResetExampleUnitTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java index 7b6306df76..913325f8e2 100644 --- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java @@ -8,8 +8,8 @@ public class CyclicBarrierResetExampleUnitTest { @Test public void whenCyclicBarrier_reset() { - CyclicBarrierResetExample ex = new CyclicBarrierResetExample(7,20); + CyclicBarrierResetExample ex = new CyclicBarrierResetExample(7,10); int lineCount = ex.countWaits(); - assertEquals(17, lineCount); + assertEquals(8, lineCount); } } From 39a828fbc995ee452b363e21432a3c0118bfec98 Mon Sep 17 00:00:00 2001 From: RanjeetKaur17 Date: Sun, 28 Oct 2018 16:45:15 +0400 Subject: [PATCH 6/6] Fixing Test Cases --- .../CountdownLatchResetExampleUnitTest.java | 8 +++----- .../cyclicbarrier/CyclicBarrierResetExampleUnitTest.java | 6 +++--- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java index 658ab5301a..d2d43f6312 100644 --- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchResetExampleUnitTest.java @@ -1,8 +1,6 @@ package com.baeldung.concurrent.countdownlatch; -import static org.junit.Assert.assertEquals; - -import java.util.ArrayList; +import static org.junit.Assert.assertTrue; import org.junit.Test; @@ -10,8 +8,8 @@ public class CountdownLatchResetExampleUnitTest { @Test public void whenCountDownLatch_noReset() { - CountdownLatchResetExample ex = new CountdownLatchResetExample(5,20); + CountdownLatchResetExample ex = new CountdownLatchResetExample(7,20); int lineCount = ex.countWaits(); - assertEquals(5, lineCount); + assertTrue(lineCount <= 7); } } diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java index 913325f8e2..8d2b148f06 100644 --- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierResetExampleUnitTest.java @@ -1,6 +1,6 @@ package com.baeldung.concurrent.cyclicbarrier; -import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; import org.junit.Test; @@ -8,8 +8,8 @@ public class CyclicBarrierResetExampleUnitTest { @Test public void whenCyclicBarrier_reset() { - CyclicBarrierResetExample ex = new CyclicBarrierResetExample(7,10); + CyclicBarrierResetExample ex = new CyclicBarrierResetExample(7,20); int lineCount = ex.countWaits(); - assertEquals(8, lineCount); + assertTrue(lineCount > 7); } }