package nonstatick;

import java.util.concurrent.atomic.AtomicReference;

public class Stack<T>
{
	private static class Node<T>
	{
		private final T data;
		private volatile Node<T> next;
		
		public Node(T data, Node<T> next) 
		{
			super();
			this.data = data;
			this.next = next;
		}

		public Node<T> getNext() 
		{
			return next;
		}

		public void setNext(Node<T> next) 
		{
			this.next = next;
		}

		public T getData() 
		{
			return data;
		}
	}

	
	private final AtomicReference<Node<T>> top;

	public Stack() 
	{
		super();
		this.top = new AtomicReference<Node<T>>();
	}

	public T pop() throws Exception
	{
		Node<T> node;
		do
		{
			node = this.top.get();
			if (node == null)
			{
				throw new Exception();
			}
		}
		while (!this.top.compareAndSet(node, node.getNext()));
		return node.getData();
	}

	public void push(T data)
	{
		Node<T> node = new Node<T>(data, null);
		do
		{
			node.setNext(this.top.get());
		}
		while (!this.top.compareAndSet(node.getNext(), node));
	}
}