Question

我正在编写一个小应用程序（比“HelloWorld”更大的东西）。任务是创建一个生产者和几个消费者。生成器生成integeres并将它们放在动态堆栈（这是我的监视器对象）中，并且消费者尝试从堆栈中获取这些整数。我知道如何使用一个标志创建1个生成器+ 1个使用者，并在里面使用wait（）创建一个while。但如何与多个消费者做同样的事情。

请查看我的代码：

public interface StackQueueIF {
    void push(int value);
    int pop();
}

public class DynamicStack implements StackQueueIF{

    private volatile int stck[];
    private volatile int tos;

    boolean valueSet = false;

    public DynamicStack(int size) {
        stck = new int[size];
        tos = -1;
    }

    @Override
    public synchronized void push(int item) {
        while(valueSet){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        if (tos == stck.length-1) {
            System.out.println("---------STACK HAS BEEN DOUBLED--------");
            int temp[] = new int[stck.length * 2];
            for (int i = 0; i < stck.length; i++)   temp[i] = stck[i];
            stck = temp;
            stck[++tos] = item;
        }else
            stck[++tos] = item;

        valueSet = true;
        notifyAll();
    }

    @Override
    public synchronized int pop() {
        while(!valueSet){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        valueSet = false;
        notifyAll();
        return stck[tos--];
    }
}

class Producer implements Runnable{
    StackQueueIF queue;
    String producerName;
    private static int counter = 0;

    public Producer(StackQueueIF queue, String name) {
        this.queue = queue;
        this.producerName = name;
        new Thread(this,producerName).start();
    }

    @Override
    public void run() {
        while(true){
            System.out.println(this.producerName + " puts " + (++counter) 
              + " into stack");
            this.queue.push(counter);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.err.println(producerName + " interrupted");
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable{
    StackQueueIF queue;
    String consumerName;

    public Consumer(StackQueueIF queue, String consumerName) {
        this.queue = queue;
        this.consumerName = consumerName;
        new Thread(this, this.consumerName).start();
    }

    @Override
    public void run() {
        while(true){
            System.out.println(this.consumerName + " gets " + queue.pop() + " from stack");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.err.println(consumerName + "interrupted");
                e.printStackTrace();
            }
        }
    }

}

public class QueueTester {
    public static void main(String[] args) {
        StackQueueIF queue = new DynamicStack(10);
        new Producer(queue,"Producer №1");

        new Consumer(queue,"Consumer №1");
        new Consumer(queue,"Consumer №2");
    }
}

Answer 1

这就是我写堆栈的方法

public interface IntStack {
    void push(int value);
    int pop() throws InterruptedException;
}

public class DynamicStack implements IntStack {
    private int size = 0, stack[];

    public DynamicStack() {
        this(16);
    }

    public DynamicStack(int capacity) {
        stack = new int[capacity];
    }

    @Override
    public synchronized void push(int item) {
        if (size + 1 == stack.length)
            stack = Arrays.copyOf(stack, stack.length * 2);
        stack[size++] = item;
        notifyAll(); // notify() would also do.
    }

    @Override
    public synchronized int pop() throws InterruptedException {
        while (size == 0)
            wait();
        return stack[--size];
    }
}

使用java线程进行多个监视器同步

1 个答案: