同步栈Stack示例demo

背景

多线程中的生产者和消费者我们经常会使用到，而嫁接生产者和消费者之前的桥梁可以是队列也可以是栈，我们今天就使用栈来手写一个栈demo

栈特点：FILO（先进后出）

示例demo

同步栈：

/**
 * 同步栈
 **/
public class SynchronizedStack<T> {
    private static final int DEFAULT_SIZE = 128;
    // 默认是-1，表示无限制
    private static final int DEFAULT_LIMIT = -1;

    private int size;
    private int limit;
    private int index = -1;
    private Object[] stack;

    public SynchronizedStack() {
        this(DEFAULT_SIZE, DEFAULT_LIMIT);
    }

    public SynchronizedStack(int size, int limit) {
        if (limit > -1 && size > limit) {
            this.size = limit;
        } else {
            this.size = size;
        }
        this.limit = limit;
        this.stack = new Object[this.size];
    }

    public synchronized boolean push(T object) {
        index++;
        if (index == size) {
            if (limit == -1 || size < limit) {
                // 扩容
                expand();
            } else {
                index--;
                return false;
            }
        }

        stack[index] = object;
        System.out.println("push objet:" + object);
        return true;
    }

    public synchronized T pop() {
        if (index == -1) {
            return null;
        }
        T result = (T) stack[index];
        stack[index--] = null;
        return result;
    }

    public synchronized void clear() {
        if (index > -1) {
            for (int i = 0; i < index + 1; i++) {
                stack[i] = null;
            }
        }
        index = -1;
    }

    private void expand() {
        int newSize = size * 2;
        if (limit > -1 && newSize > limit) {
            newSize = limit;
        }
        Object[] newStack = new Object[newSize];
        System.arraycopy(stack, 0, newStack, 0, size);
        stack = newStack;
        size = newSize;
    }

    public synchronized int index(){
        return index;
    }
}

生产者和消费者测试类：

/**
 * 栈测试类
 **/
public class StackTest {
    public static void main(String[] args) {
        SynchronizedStack<String> synchronizedStack = new SynchronizedStack<>(5,10);

        // 生产者
        new Thread(() -> {
            int index = 0;
            for (; ; ) {
                index++;
                synchronizedStack.push("producer" + index);
                if (index % 3 == 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (index >= 10) {
                    return;
                }
            }
        }).start();

        // 消费者
        new Thread(() -> {
            for (; ; ) {
                if (synchronizedStack.index() > -1) {
                    System.out.println("时间：" + new Date() +", 消费者消费：" + synchronizedStack.pop());
                }
            }
        }).start();
    }
}

运行结果：