In this lab, we consider a concurrent stack. We start from the following skeleton of a sequential stack. Note that the class Stack does not implement a stack correctly.

/**
 * A stack.  It stores integers.
 *
 * @author
 */
public class Stack {
  private int[] content;
  private int size;
 
  /*
   * The maximal number of integers that can be stored in a stack.
   */
  private final static int CAPACITY = 5;
 
  /**
   * Initializes this stack to be empty.
   */
  public Stack() {
    this.content = new int[Stack.CAPACITY];
    this.size = 0;
  }
 
  /**
   * Pushes the given integer onto this stack.
   *
   * @param value the integer to be pushed onto this stack.
   */
  public void push(int value) {
    this.content[this.size] = value;
    this.size++;
    System.out.printf("Push %d\n", value);
  }
 
  /**
   * Pops the top of this stack and returns the integer.
   *
   * @return the top of this stack.
   */
  public int pop() {
    this.size--;
    int value = this.content[this.size];
    System.out.printf("Pop %d\n", value);
    return value;
  }
}

Implement the following classes.

• The class Pusher. Each Pusher object is a Thread that pushes the integers 0, 1, …, 9 onto a stack. The stack is provided as an argument to the constructor of the Pusher class. The jar file pop.jar contains the class Popper. Each Popper object is a Thread that pops ten integers from a stack. The stack is provided as an argument to the constructor of the Popper class.
• The class Stack. This class is based on the above skeleton and allows Threads to concurrently call the push and pop methods on the stack.
• The class Main. This class only contains a main method. In the main method, a number of Popper and Pusher objects are created (for example, 10 Poppers and 5 Pushers) and all these Threads are run concurrently.

To receive feedback, submit your code using the submit command:

submit 4315 lab7 <name of class>.java