review comments

data-structures/src/main/java/com/baeldung/circularbuffer/CircularBuffer.java

@@ -25,7 +25,7 @@ public class CircularBuffer<E> {
             int nextWriteSeq = writeSequence + 1;
             data[nextWriteSeq % capacity] = element;
 
-            writeSequence += 1;
+            writeSequence++;
             return true;
         }
 
@@ -37,7 +37,7 @@ public class CircularBuffer<E> {
         if (isNotEmpty()) {
 
             E nextValue = data[readSequence % capacity];
-            readSequence += 1;
+            readSequence++;
             return nextValue;
         }
 

data-structures/src/test/java/com/baeldung/circularbuffer/ProducerConsumerLiveTest.java

@@ -2,6 +2,11 @@ package com.baeldung.circularbuffer;
 
 import static org.junit.Assert.assertArrayEquals;
 
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.LockSupport;
 
 import org.junit.jupiter.api.Test;
@@ -11,38 +16,34 @@ public class ProducerConsumerLiveTest {
     private final String[] shapes = { "Circle", "Triangle", "Rectangle", "Square", "Rhombus", "Trapezoid", "Pentagon", "Pentagram", "Hexagon", "Hexagram" };
 
     @Test
-    public void givenACircularBuffer_whenInterleavingProducerConsumer_thenElementsMatch() throws InterruptedException {
+    public void givenACircularBuffer_whenInterleavingProducerConsumer_thenElementsMatch() throws Exception {
         CircularBuffer<String> buffer = new CircularBuffer<String>(shapes.length);
-        String[] consumedShapes = new String[shapes.length];
 
-        Thread producer = new Thread(new Producer(shapes, buffer));
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
-        Thread consumer = new Thread(new Consumer(consumedShapes, buffer));
 
-        producer.start();
+        executorService.submit(new Producer<String>(buffer, shapes));
-        consumer.start();
+        Future<String[]> consumed = executorService.submit(new Consumer<String>(buffer, shapes.length));
 
-        producer.join();
+        String[] shapesConsumed = consumed.get(5L, TimeUnit.SECONDS);
-        consumer.join();
+        assertArrayEquals(shapes, shapesConsumed);
-
-        assertArrayEquals(shapes, consumedShapes);
     }
 
-    static class Producer implements Runnable {
+    static class Producer<T> implements Runnable {
 
-        private String[] producerShapes;
+        private CircularBuffer<T> buffer;
-        private CircularBuffer<String> buffer;
+        private T[] items;
 
-        public Producer(String[] producerShapes, CircularBuffer<String> buffer) {
+        public Producer(CircularBuffer<T> buffer, T[] items) {
-            this.producerShapes = producerShapes;
             this.buffer = buffer;
+            this.items = items;
         }
 
         @Override
         public void run() {
 
-            for (int i = 0; i < producerShapes.length;) {
+            for (int i = 0; i < items.length;) {
-                if (buffer.offer(producerShapes[i])) {
+                if (buffer.offer(items[i])) {
-                    System.out.println("Produced: " + producerShapes[i]);
+                    System.out.println("Produced: " + items[i]);
                     i++;
                     LockSupport.parkNanos(5);
                 }
@@ -50,28 +51,30 @@ public class ProducerConsumerLiveTest {
         }
     }
 
-    static class Consumer implements Runnable {
+    @SuppressWarnings("unchecked")
+    static class Consumer<T> implements Callable<T[]> {
 
-        private CircularBuffer<String> buffer;
+        private CircularBuffer<T> buffer;
-        private String[] consumedShapes;
+        private int expectedCount;
 
-        public Consumer(String[] consumedShapes, CircularBuffer<String> buffer) {
+        public Consumer(CircularBuffer<T> buffer, int expectedCount) {
-            this.consumedShapes = consumedShapes;
             this.buffer = buffer;
+            this.expectedCount = expectedCount;
         }
 
         @Override
-        public void run() {
+        public T[] call() throws Exception {
-
+            T[] items = (T[]) new Object[expectedCount];
-            for (int i = 0; i < consumedShapes.length;) {
+            for (int i = 0; i < items.length;) {
-                String shape = buffer.poll();
+                T item = buffer.poll();
-                if (shape != null) {
+                if (item != null) {
-                    consumedShapes[i++] = shape;
+                    items[i++] = item;
 
                     LockSupport.parkNanos(5);
-                    System.out.println("Consumed: " + shape);
+                    System.out.println("Consumed: " + item);
                 }
             }
+            return items;
         }
     }
 }