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);
    }