SynchroStack rewritten with some debug logs

Author: potat-dev

README.md

@@ -12,12 +12,11 @@ My formatted Lab tasks: [TASKS.md](TASKS.md)
 1. Clone this repository
    ```bash
    git clone https://github.com/cypotat/Java-Labs.git
-   cd Java-Labs
+   cd Java-Labs/src
    ```
 2. Compile the specific lab
 
    ```bash
-   cd src
    javac labs/sem1/lab1/*.java
    ```
 

src/labs/sem1/lab10/Main.java

@@ -3,42 +3,43 @@
 public class Main {
   public static void main(String[] args) {
     SynchroStack stack = new SynchroStack();
-    for (int i = 0; i < 10; i++) {
+    Utils.initCSV();
+
+    for (int i = 0; i < 100; i++) {
       stack.push(i);
     }
 
-    System.out.println(stack);
-
-    // multiple threads
+    Thread[] threads = new Thread[4];
 
-    Thread t1 = new Thread(new Runnable() {
-      @Override
-      public void run() {
-        for (int i = 0; i < 10; i++) {
-          stack.push(i);
+    for (int i = 0; i < 2; i++) {
+      threads[i * 2] = new Thread(() -> {
+        Utils.printRow("START - Stack 10 pushes");
+        for (int j = 0; j < 10; j++) {
+          stack.push(j);
         }
-      }
-    });
+        Utils.printRow("END - Stack 10 pushes");
+      });
 
-    Thread t2 = new Thread(new Runnable() {
-      @Override
-      public void run() {
-        for (int i = 0; i < 10; i++) {
+      threads[i * 2 + 1] = new Thread(() -> {
+        Utils.printRow("START - Stack 10 pops");
+        for (int j = 0; j < 10; j++) {
           stack.pop();
         }
-      }
-    });
-
-    t1.start();
-    t2.start();
+        Utils.printRow("END - Stack 10 pops");
+      });
+    }
 
-    try {
-      t1.join();
-      t2.join();
-    } catch (InterruptedException e) {
-      e.printStackTrace();
+    for (int i = 0; i < threads.length; i++) {
+      threads[i].start();
     }
 
-    System.out.println(stack);
+    for (int i = 0; i < threads.length; i++) {
+      try {
+        threads[i].join();
+        Utils.printRow("END - Thread " + i + " join");
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      }
+    }
   }
 }

src/labs/sem1/lab10/Stack.java

@@ -0,0 +1,77 @@
+package labs.sem1.lab10;
+
+// class Stack - parent class for SynchroStack and SynchroStackFast
+
+public class Stack {
+  protected StackNode head;
+  protected int size;
+
+  public void push(int i) {
+    StackNode node = new StackNode(i);
+    node.next = head;
+    head = node;
+    size++;
+  }
+
+  public int pop() throws RuntimeException {
+    if (head == null) {
+      throw new RuntimeException("Stack is empty");
+    }
+    int value = head.value;
+    head = head.next;
+    size--;
+    return value;
+  }
+
+  public int size() {
+    return size;
+  }
+
+  public boolean equals(Object o) {
+    if (o == null) {
+      return false;
+    }
+    if (o == this) {
+      return true;
+    }
+    if (!(o instanceof Stack)) {
+      return false;
+    }
+    Stack other = (Stack) o;
+    StackNode node1 = head;
+    StackNode node2 = other.head;
+    while (node1 != null && node2 != null) {
+      if (node1.value != node2.value) {
+        return false;
+      }
+      node1 = node1.next;
+      node2 = node2.next;
+    }
+    return node1 == null && node2 == null;
+  }
+
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append("[");
+    StackNode node = head;
+    while (node != null) {
+      sb.append(node.value);
+      sb.append(", ");
+      node = node.next;
+    }
+    if (head != null) {
+      sb.delete(sb.length() - 2, sb.length());
+    }
+    sb.append("]");
+    return sb.toString();
+  }
+
+  class StackNode {
+    int value;
+    StackNode next;
+
+    StackNode(int value) {
+      this.value = value;
+    }
+  }
+}

src/labs/sem1/lab10/SynchroStack.java

@@ -1,106 +1,31 @@
 package labs.sem1.lab10;
 
-// SynchroStack:
-// Реализовать класс Stack, используя связный список.
-// Добавить synchronized ключевые слова к методам push() и pop() для защиты от многопоточной модификации.
-
-class Stack {
-  private StackNode top;
-
-  public void push(int i) {
-    StackNode node = new StackNode(i);
-    node.next = top;
-    top = node;
-  }
-
-  public int pop() {
-    if (top == null) {
-      throw new RuntimeException("Stack is empty");
-      // return 0;
-    }
-    int value = top.value;
-    top = top.next;
-    return value;
-  }
-
-  public boolean equals(Object o) {
-    if (o == null) {
-      return false;
-    }
-    if (o == this) {
-      return true;
-    }
-    if (!(o instanceof Stack)) {
-      return false;
-    }
-    Stack other = (Stack) o;
-    StackNode node1 = top;
-    StackNode node2 = other.top;
-    while (node1 != null && node2 != null) {
-      if (node1.value != node2.value) {
-        return false;
-      }
-      node1 = node1.next;
-      node2 = node2.next;
-    }
-    return node1 == null && node2 == null;
-  }
-
-  public String toString() {
-    StringBuilder sb = new StringBuilder();
-    sb.append("[");
-    StackNode node = top;
-    while (node != null) {
-      sb.append(node.value);
-      sb.append(", ");
-      node = node.next;
-    }
-    if (top != null) {
-      sb.delete(sb.length() - 2, sb.length());
-    }
-    sb.append("]");
-    return sb.toString();
-  }
-
-  class StackNode {
-    int value;
-    StackNode next;
-
-    StackNode(int value) {
-      this.value = value;
-    }
-  }
-}
-
-public class SynchroStack {
-  private Stack stack = new Stack();
+public class SynchroStack extends Stack {
 
   public synchronized void push(int i) {
-    System.out.println("Thread: " + Thread.currentThread().getName() + " locked stack");
-    synchronized (stack) {
-      stack.push(i);
-      System.out.println("Thread: " + Thread.currentThread().getName() + " unlocked stack");
-    }
+    Utils.printRow("START - Push");
+    super.push(i);
+    Utils.printRow("END - Push");
   }
 
   public synchronized int pop() {
-    System.out.println("Thread: " + Thread.currentThread().getName() + " locked stack");
-    synchronized (stack) {
-      int value = stack.pop();
-      System.out.println("Thread: " + Thread.currentThread().getName() + " unlocked stack");
-      return value;
-    }
+    Utils.printRow("START - Pop");
+    int i = super.pop();
+    Utils.printRow("END - Pop");
+    return i;
   }
 
-  public boolean equals(Object o) {
-    synchronized (stack) {
-      return stack.equals(o);
-    }
+  public synchronized boolean equals(Object o) {
+    Utils.printRow("START - Equals");
+    boolean b = super.equals(o);
+    Utils.printRow("END - Equals");
+    return b;
   }
 
-  public String toString() {
-    synchronized (stack) {
-      return stack.toString();
-    }
+  public synchronized String toString() {
+    Utils.printRow("START - toString");
+    String s = super.toString();
+    Utils.printRow("END - toString");
+    return s;
   }
 }

src/labs/sem1/lab10/SynchroStackStats.xlsx

@@ -0,0 +1,32 @@
+package labs.sem1.lab10;
+
+public class Utils {
+  private static int threadsCount = 4;
+
+  public static void initCSV() {
+    // generate string with headers (e.g. "main,Thread-0,Thread-1,...")
+    String[] headers = new String[threadsCount + 1];
+    headers[0] = "main";
+    for (int i = 1; i < headers.length; i++) {
+      headers[i] = "Thread-" + (i - 1);
+    }
+    System.out.println(String.join(",", headers));
+  }
+
+  public static void printRow(String s) {
+    // print s at the column of the current thread
+    // other columns should be empty
+    String[] row = new String[threadsCount + 1];
+    for (int i = 0; i < row.length; i++) {
+      row[i] = "\"\"";
+    }
+    // get current thread id from "Thread-0" -> 1 (main -> 0)
+    String threadName = Thread.currentThread().getName();
+    if (threadName.equals("main")) {
+      row[0] = s;
+    } else {
+      row[Integer.parseInt(threadName.substring(7)) + 1] = s;
+    }
+    System.out.println(String.join(",", row));
+  }
+}