public interface MyNonBlockingStack<T> {
    void put(T t) throws InterruptedException;

    T poll() throws InterruptedException;
}

class MyNonBlockingStackImpl<T> implements MyNonBlockingStack<T> {

    private Object internalMonitor = new Object();
    private List<T> list = new ArrayList<>();
    private int maxSize;

    public MyNonBlockingStackImpl(int maxSize) {
        this.maxSize = maxSize;
    }

    @Override
    public synchronized void put(T t) throws InterruptedException {
        while (maxSize <= list.size()) {
            System.out.println("wait put by " + Thread.currentThread().getId());
            wait();
            System.out.println("wait put by " + Thread.currentThread().getId());

        }
        list.add(t);
        notify();

    }

    @Override
    public synchronized T poll() throws InterruptedException {
        while (list.size() == 0) {
            System.out.println("wait read by " + Thread.currentThread().getId());
            wait();
            System.out.println("woken up read by " + Thread.currentThread().getId());

        }
        T t = list.get(list.size()-1);
        list.remove(t);
        notify();
        return t;
    }
}

class MyNonBlockingStackImpl<T> implements MyNonBlockingStack<T> {

    private List<T> list = new ArrayList<>();
    private int maxSize;

    public MyNonBlockingStackImpl(int maxSize) {
        this.maxSize = maxSize;
    }

    @Override
    public synchronized void put(T t) throws InterruptedException {
        while (maxSize <= list.size()) {
            wait();
        }
        list.add(t);
        notify();

    }

    @Override
    public synchronized T poll() throws InterruptedException {
        while (list.size() == 0) {
            wait();
        }
        T t = list.get(list.size()-1);
        list.remove(t);
        notify();
        return t;
    }
}

class Main {
    public static void main(String[] args) throws InterruptedException {
        MyNonBlockingStackImpl<Integer> myNonBlockingStack = new MyNonBlockingStackImpl<>(5);

        for (int i = 0; i < 10; i++) {
            final int currentValue = i;
            //writer
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        myNonBlockingStack.put(currentValue);
                        //System.out.println("Put " + currentValue + " by " + Thread.currentThread().getId());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        Thread.sleep(5000);
        for (int i = 0; i < 10; i++) {
            //reader
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // System.out.println("Read " +
                        myNonBlockingStack.poll();
                        //         + " by " + Thread.currentThread().getId());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
            Thread.sleep(10);
        }

    }
}

public synchronized

class Main {
    public static void main(String[] args) throws InterruptedException {
        BlockingConcurrentStack<Integer> myNonBlockingStack = new BlockingConcurrentStack<>(5);

        for (int i = 0; i < 10; i++) {
            final int currentValue = i;
            //writer
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        myNonBlockingStack.put(currentValue);
                        //System.out.println("Put " + currentValue + " by " + Thread.currentThread().getId());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        Thread.sleep(5000);
        for (int i = 0; i < 10; i++) {
            //reader
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // System.out.println("Read " +
                        myNonBlockingStack.poll();
                        //         + " by " + Thread.currentThread().getId());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
            Thread.sleep(10);
        }

    }
}

public interface ConcurrentStack<T> {
    void put(T t) throws InterruptedException;

    T poll() throws InterruptedException;
}

class BlockingConcurrentStack<T> implements ConcurrentStack<T> {

    private List<T> list = new ArrayList<>();
    private int maxSize;

    public BlockingConcurrentStack(int maxSize) {
        this.maxSize = maxSize;
    }

    @Override
    public synchronized void put(T t) throws InterruptedException {
        while (maxSize <= list.size()) {
            //System.out.println("wait Put " + t + " by " + Thread.currentThread().getId());
            wait();
        }
        list.add(t);
        System.out.println("Put " + t + " by " + Thread.currentThread().getId());
        notify();

    }

    @Override
    public synchronized T poll() throws InterruptedException {
        while (list.size() == 0) {
            //System.out.println("wait poll " + " by " + Thread.currentThread().getId());
            wait();
        }
        T t = list.get(list.size() - 1);
        list.remove(t);
        System.out.println("Read " + t + " by " + Thread.currentThread().getId());
        notify();
        return t;
    }
}

List list = Collections.synchronizedList(...);

    volatile AtomicBoolean isReading = new AtomicBoolean(false);
    volatile AtomicBoolean isWriting = new AtomicBoolean(false);

    @Override // non-blocking
    public boolean offer(T t) {
        if (isReading.compareAndSet(false, true)) {
            if (isWriting.compareAndSet(false, true)) {

                if (list.size() >= maxSize) {
                    return false;
                }
                boolean addResult = list.add(t);
                isWriting.set(false);
                isReading.set(false);
                return addResult;
            }
            isReading.set(false);
        }
        return false;
    }

    @Override // non-blocking
    public T take() {
        if (isReading.compareAndSet(false, true)) {
            T t = list.get(list.size() - 1);
            isReading.set(false);
            return t;
        }
        return null;
    }

 volatile AtomicBoolean locked = new AtomicBoolean(false);

    @Override
    public boolean offer(T t) {
        if (locked.compareAndSet(false, true)) {

            if (list.size() >= maxSize) {
                return false;
            }
            boolean addResult = list.add(t);
            locked.set(false);
            return addResult;
        }
        return false;
    }

    @Override
    public T take() {
        if (locked.compareAndSet(false, true)) {
            T t = list.get(list.size() - 1);
            locked.set(false);
            return t;
        }
        return null;
    }

public interface ConcurrentStack<T> {
    //blocking
    void put(T t) throws InterruptedException;

    //blocking
    T poll() throws InterruptedException;

    //non-blocking put
    boolean offer(T t);

    //non-blocking get
    T take();
}

class ConcurrentStackImpl<T> implements ConcurrentStack<T> {
    private volatile AtomicBoolean locked = new AtomicBoolean(false);
    private List<T> internalList = new ArrayList<T>();
    private final int maxSize;

    public ConcurrentStackImpl(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException();
        }
        this.maxSize = maxSize;
    }

    @Override //blocking
    public void put(T t) throws InterruptedException {
        while (!locked.compareAndSet(false, true)) ;//busy waiting
        internalList.add(t);
        locked.set(false);
    }

    @Override // non-blocking
    public T poll() throws InterruptedException {
        while (!locked.compareAndSet(false, true)) ;//busy waiting
        T value = internalList.get(internalList.size() - 1);
        locked.set(false);
        return value;
    }

    @Override
    public boolean offer(T t) {
        if (locked.compareAndSet(false, true)) {

            if (internalList.size() >= maxSize) {
                return false;
            }
            boolean addResult = internalList.add(t);
            locked.set(false);
            return addResult;
        }
        return false;
    }

    @Override
    public T take() {
        if (locked.compareAndSet(false, true)) {
            T t = internalList.get(internalList.size() - 1);
            locked.set(false);
            return t;
        }
        return null;
    }

}

class ConcurrentStack<E> {
	
	private final AtomicReference<Entry<E>> pointer = new AtomicReference<>();
	
	public void push(E element) {
		boolean finish = false;
		do {
			Entry<E> currentTop = pointer.get();
			Entry<E> newTop = new Entry<>(element, currentTop);
			finish = pointer.compareAndSet(currentTop, newTop);
		} while(!finish);
	}
	
	public E pop() {
		E ret = null;
		boolean finish = false;
		do {
			Entry<E> currentTop = pointer.get();
			Entry<E> newTop = null;
			if(currentTop != null) {
				ret = currentTop.element;	
				newTop = currentTop.prev;
			}
			finish = pointer.compareAndSet(currentTop, newTop);
		} while(!finish);
		return ret;
	}
	
	private static class Entry<E> {
		final E element; 
		final Entry<E> prev; 
		//здесь файналы не обязательны строго говоря, но так best practice (у нас hb //создает запись/чтение pointer

		Entry(E element, Entry<E> prev) {
			this.element = element;
			this.prev = prev;
		}
	}
}

class BlockingStack<E> {
	
	final private ConcurrentStack<E> concurrentStack = new ConcurrentStack<E>();
	final private Semaphore blockStuff = new Semaphore(0);
	
	public void push(E element) {
		concurrentStack.push(element);
		blockStuff.release();
	}
	
	public E pop() throws InterruptedException {
		blockStuff.acquire();
		return concurrentStack.pop();
	}
}

do{
  oldState = atom.get();//1
 //some sork
}while(atom.compareAndSet(oldState, newState))

list = new ArrayList<T>(this.maxSize = maxSize);

public void push(E element) {
		boolean finish = false;
		do {
			Entry<E> currentTop = pointer.get();
			Entry<E> newTop = new Entry<>(element, currentTop);
			finish = pointer.compareAndSet(currentTop, newTop);
		} while(!finish);
	}

     @Override //blocking
    public void put(T t) throws InterruptedException {
        while (!locked.compareAndSet(false, true)) ;//busy waiting
        internalList.add(t);  //да, здесь нужна проверка на размер предварительно
        locked.set(false);
    }

public void push(E element) {
		boolean finish = false;
		do {
			Entry<E> currentTop = pointer.get();
			Entry<E> newTop = new Entry<>(element, currentTop);
			finish = pointer.compareAndSet(currentTop, newTop);
		} while(!finish);
	}

     @Override //blocking
    public void put(T t) throws InterruptedException {
        while (!locked.compareAndSet(false, true)) ;//busy waiting
        internalList.add(t);  //да, здесь нужна проверка на размер предварительно
        locked.set(false);
    }