Java中的并发编程：实现一个线程安全的栈

Question

在Java并发编程中，确保数据在多线程环境下的安全性是至关重要的。栈（Stack）作为一种后进先出（LIFO）的数据结构，在并发环境下其操作（如push、pop）如果不加以适当的同步控制，很容易引起数据不一致的问题。

设计一个线程安全的栈（Thread-Safe Stack），要求支持以下操作：

1. push(E item): 将元素压入栈顶。
2. pop(): 移除并返回栈顶元素；如果栈为空，则返回null或抛出异常（视设计而定）。
3. peek(): 返回栈顶元素但不移除它；如果栈为空，则返回null或抛出异常（视设计而定）。

Answer 1

import java.util.concurrent.locks.ReentrantLock;
import java.util.EmptyStackException;

public class ThreadSafeStack<E> {
    private Node<E> top;
    private ReentrantLock lock = new ReentrantLock();

    private static class Node<E> {
        E value;
        Node<E> next;

        Node(E value) {
            this.value = value;
        }
    }

    // push: 将元素压入栈顶
    public void push(E item) {
        lock.lock();
        try {
            Node<E> newNode = new Node<>(item);
            newNode.next = top;
            top = newNode;
        } finally {
            lock.unlock();
        }
    }

    // pop: 移除栈并返回栈顶元素，如果栈为空，返回null或抛出异常
    public E pop() {
        lock.lock();
        try {
            if (top == null) {
                throw new EmptyStackException();
            }
            E value = top.value;
            top = top.next;
            return value;
        } finally {
            lock.unlock();
        }
    }

    // peek: 返回栈顶元素但不移除它，如果栈为空，返回null或抛出异常
    public E peek() {
        lock.lock();
        try {
            if (top == null) {
                throw new EmptyStackException();
            }
            return top.value;
        } finally {
            lock.unlock();
        }
    }

    // 判断栈是否为空
    public boolean isEmpty() {
        lock.lock();
        try {
            return top == null;
        } finally {
            lock.unlock();
        }
    }
}