wrote README w/ output

Author: wolfram77

ArrayQueue.java

@@ -20,7 +20,7 @@ class ArrayQueue<T> {
   public ArrayQueue(int capacity) {
     headLock = new ReentrantLock();
     tailLock = new ReentrantLock();
-    data = (T[]) new Object[capacity];
+    data = (T[]) new Object[capacity+1];
     head = 0;
     tail = 0;
   }

Main.java

@@ -1,76 +1,76 @@
 import java.util.*;
 
 class Main {
-  static Deque<Integer> stack;
-  static ArrayQueue<Integer> concurrentStack;
-  static List<Integer>[] poppedValues;
+  static Deque<Integer> queue;
+  static ArrayQueue<Integer> concurrentQueue;
+  static List<Integer>[] deqValues;
   static int TH = 10, NUM = 1000;
 
-  // Each unsafe thread pushes N numbers and pops N, adding
-  // them to its own poppedValues for checking; using Java's
-  // sequential stack implementation, ArrayDeque.
+  // Each unsafe thread enqs N numbers and deqs N, adding
+  // them to its own deqValues for checking; using Java's
+  // sequential queue implementation, ArrayDeque.
   static Thread unsafe(int id, int x, int N) {
     return new Thread(() -> {
-      String action = "push";
+      String action = "enq";
       try {
       for (int i=0, y=x; i<N; i++)
-        stack.push(y++);
+        queue.addLast(y++);
       Thread.sleep(1000);
-      action = "pop";
+      action = "deq";
       for (int i=0; i<N; i++)
-        poppedValues[id].add(stack.pop());
+        deqValues[id].add(queue.removeFirst());
       }
       catch (Exception e) { log(id+": failed "+action); }
     });
   }
 
-  // Each safe thread pushes N numbers and pops N, adding
-  // them to its own poppedValues for checking; using
-  // ArrayStack.
+  // Each safe thread enqs N numbers and deqs N, adding
+  // them to its own deqValues for checking; using
+  // ArrayQueue.
   static Thread safe(int id, int x, int N) {
     return new Thread(() -> {
-      String action = "push";
+      String action = "enq";
       try {
       for (int i=0, y=x; i<N; i++)
-        concurrentStack.push(y++);
+        concurrentQueue.enq(y++);
       Thread.sleep(1000);
-      action = "pop";
+      action = "deq";
       for (int i=0; i<N; i++)
-        poppedValues[id].add(concurrentStack.pop());
+        deqValues[id].add(concurrentQueue.deq());
       }
       catch (Exception e) { log(id+": failed "+action);
       e.printStackTrace(); }
     });
   }
 
-  // Checks if each thread popped N values, and they are
+  // Checks if each thread dequeued N values, and they are
   // globally unique.
   static boolean wasLIFO(int N) {
     Set<Integer> set = new HashSet<>();
     boolean passed = true;
     for (int i=0; i<TH; i++) {
-      int n = poppedValues[i].size();
+      int n = deqValues[i].size();
       if (n != N) {
-        log(i+": popped "+n+"/"+N+" values");
+        log(i+": dequeued "+n+"/"+N+" values");
         passed = false;
       }
-      for (Integer x : poppedValues[i])
+      for (Integer x : deqValues[i])
         if (set.contains(x)) {
           log(i+": has duplicate value "+x);
           passed = false;
         }
-      set.addAll(poppedValues[i]);
+      set.addAll(deqValues[i]);
     }
     return passed;
   }
 
   @SuppressWarnings("unchecked")
   static void testThreads(boolean safe) {
-    stack = new ArrayDeque<>();
-    concurrentStack = new ArrayQueue<>(TH*NUM);
-    poppedValues = new List[TH];
+    queue = new ArrayDeque<>();
+    concurrentQueue = new ArrayQueue<>(TH*NUM);
+    deqValues = new List[TH];
     for (int i=0; i<TH; i++)
-      poppedValues[i] = new ArrayList<>();
+      deqValues[i] = new ArrayList<>();
     Thread[] threads = new Thread[TH];
     for (int i=0; i<TH; i++) {
       threads[i] = safe?
@@ -86,11 +86,11 @@ static void testThreads(boolean safe) {
   }
 
   public static void main(String[] args) {
-    log("Starting "+TH+" threads with sequential stack");
+    log("Starting "+TH+" threads with sequential queue");
     testThreads(false);
     log("Was LIFO? "+wasLIFO(NUM));
     log("");
-    log("Starting "+TH+" threads with array stack");
+    log("Starting "+TH+" threads with array queue");
     testThreads(true);
     log("Was LIFO? "+wasLIFO(NUM));
     log("");

README.md

@@ -1,59 +1,64 @@
-Array stack is a bounded lock-based stack using an
-array. It uses a common lock for both push and pop
-operations.
+Array queue is a bounded lock-based FIFO queue using
+an array. It uses 2 separate locks for head and tail.
 
 ```java
-push():
-1. Lock stack.
-2. Try push.
-3. Unlock stack.
+enq():
+1. Lock tail.
+2. Try enq.
+3. Unlock tail.
 ```
 
 ```java
-pop():
-1. Lock stack.
-2. Try pop.
-3. Unlock stack.
+deq():
+1. Lock head.
+2. Try deq.
+3. Unlock head.
 ```
 
 ```java
-tryPush():
-1. Ensure stack is not full
-2. Save data at top.
-3. Increment top.
+tryEnq():
+1. Ensure queue is not full
+2. Save data at tail.
+3. Increment tail.
 ```
 
 ```java
-tryPop():
-1. Ensure stack is not empty.
-2. Decrement top.
-3. Return data at top.
+tryDeq():
+1. Ensure queue is not empty.
+2. Return data at head.
+3. Increment head.
 ```
 
 ```bash
 ## OUTPUT
-Starting 10 threads with sequential stack
-7: failed pop
-1: failed pop
-5: failed pop
-8: failed pop
-9: failed pop
-1: popped 0/1000 values
-5: popped 158/1000 values
-7: popped 0/1000 values
-8: popped 0/1000 values
-9: popped 31/1000 values
+Starting 10 threads with sequential queue
+2: failed enq
+5: failed deq
+6: failed deq
+7: failed deq
+8: failed deq
+1: failed deq
+4: failed deq
+9: failed deq
+1: dequeued 0/1000 values
+2: dequeued 0/1000 values
+4: dequeued 0/1000 values
+5: dequeued 698/1000 values
+6: dequeued 0/1000 values
+7: dequeued 0/1000 values
+8: dequeued 0/1000 values
+9: dequeued 0/1000 values
 Was LIFO? false
 
-Starting 10 threads with array stack
+Starting 10 threads with array queue
 Was LIFO? true
 ```
 
-See [ArrayStack.java] for code, [Main.java] for test, and [repl.it] for output.
+See [ArrayQueue.java] for code, [Main.java] for test, and [repl.it] for output.
 
-[ArrayStack.java]: https://repl.it/@wolfram77/array-stack#ArrayStack.java
-[Main.java]: https://repl.it/@wolfram77/array-stack#Main.java
-[repl.it]: https://array-stack.wolfram77.repl.run
+[ArrayQueue.java]: https://repl.it/@wolfram77/array-queue#ArrayQueue.java
+[Main.java]: https://repl.it/@wolfram77/array-queue#Main.java
+[repl.it]: https://array-queue.wolfram77.repl.run
 
 
 ### references