使用者/生产者异常处理

Question

我有一个循环缓冲区（数组/先进先出），一个消费者和一个生产者。生产者将随机数放入数组中，消费者获取第一个数字并检查它是否是相对素数。

我的代码工作正常，我认为它工作正常，但我想改进它。我不太确定我的“空运行”方法。我应该在其他地方做异常处理吗？改变“无限循环”？不应更改方法签名（它们是预定义的）。

我会很高兴每一个改进代码的建议。(不在乎知名度(公开，...)，还有静态的东西，我刚刚把它们放在一个文件里。

import java.math.BigInteger;
import java.util.Random;

public class ConsProd {

    static class CircularBuffer {

        private BigInteger[] buffer;
        //"pointers"
        private int read;
        private int write;

        public CircularBuffer(int size) {
            this.buffer = new BigInteger[size];
            this.read = 0;
            this.write = 0;
        }

        public boolean isFull() {
            for(int i = 0; i < buffer.length; i++) {
                if(buffer[i] == null)
                    return false;
            }
            return true;
        }

        public boolean isEmpty() {
            for(int i = 0; i < buffer.length; i++) {
                if(buffer[i] != null)
                    return false;
            }
            return true;    
        }

        public synchronized void put(BigInteger element) throws InterruptedException {
            while(isFull()){
                wait();
            }
            buffer[write] = element;
            write = (write+1)%buffer.length;
            notifyAll();
        }

        public synchronized BigInteger take() throws InterruptedException {
            while(isEmpty()){
                wait();
            }
            BigInteger temp = buffer[read];
            buffer[read] = null;
            read = (read+1)%buffer.length;
            notifyAll();
            return temp;
        }   
    }

    static class Consumer implements Runnable {

        private int id;
        private CircularBuffer buffer;

        public Consumer(int id, CircularBuffer b) {
            this.id = id;
            this.buffer = b;
        }

        private void consume(BigInteger e) {
            synchronized(e){
                System.out.println("consumer " + id + " retrieved: " + e);
                if (e.isProbablePrime(100)) {
                    System.out.println("     -----> probably prime!");
                }
            }
        }

        @Override
        public void run() {
            try { // TODO is this the right place to handle the exception? 
                while (!Thread.currentThread().isInterrupted()) {
                    BigInteger e = buffer.take();
                    consume(e);
                }
            } catch (InterruptedException e) { }
        }

    }

    static class Producer implements Runnable {

        private int id;
        private CircularBuffer buffer;

        public Producer(int id, CircularBuffer b) {
            this.id = id;
            this.buffer = b;
        }

        protected BigInteger produce() {
            BigInteger x = new BigInteger(10, new Random());
            System.out.println("producer " + id + " produced:  " + x.toString());
            return x;
        }

        @Override
        public void run() {

            try { // TODO is this the right place to handle the exception? 
                while (!Thread.currentThread().isInterrupted()) {
                    BigInteger e = produce();
                    buffer.put(e);
                }
            } catch (InterruptedException e) { }
        }
    }


    public static void main(String[] args) {

        CircularBuffer cbuf = new CircularBuffer(4);

        Thread t1 = new Thread(new Consumer(1, cbuf));
        Thread t2 = new Thread(new Consumer(2, cbuf));
        Thread t3 = new Thread(new Consumer(3, cbuf));

        Thread t4 = new Thread(new Producer(1, cbuf));
        Thread t5 = new Thread(new Producer(2, cbuf));

        t1.start();
        t2.start();
        t3.start();

        t4.start();
        t5.start();
    }
}

Answer 1

这是旧的，但我想我应该插话。将来，这个问题似乎对codereview.stackexchange.com.更好

我会很高兴每个改进代码的建议。

我的第一反应是你应该使用ExecutorService，而不是消费者线程和循环。制作人可以保持你写的一样，尽管我怀疑它是多线程的，会对你有所帮助。你的 e.isProbablePrime（） 方法比新的 BigInteger（10， new Random（））; 慢很多个数量级。

由于生产者和消费者之间的速度差异，您必须使用有限的BlockingQueue创建ExecutorService。如下所示：

threadPool = new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS,
                       new LinkedBlockingQueue<Runnable>(100));

然后，当你的生产者创建 BigInteger时，它会做一个：

threadPool.put(new Consumer(randomBigInteger());

然后，您的消费者将完全没有循环。这将处理线程、共享缓冲区和所有同步代码。你不需要管理它。您需要自己处理恢复任何结果，尽管您也可以提交＜code＞Callable

如果你不能使用ExecutorService的东西，那么你的代码看起来相当不错，尽管我会使用LinkedBlockingQueue而不是CircularBuffer。