0

我正在维护的应用程序（通过许多编码器）具有使用等待/通知机制实现的生产者-消费者问题。

消费者在应用程序的“服务器”端等待消息，然后将“客户端”端的消息转发到 LDAP 服务器。

问题是建立/终止多个连接时。生产者线程只是不断增加，并且在应该终止时永远不会终止。

当连接终止时，生产者/消费者线程也应该终止。随着大量已建立/终止的连接，内存使用量变得异常庞大。

编码：

class Producer extends Thread {
    public void run() {
        long previous = 0;
        long last = 0;
        long sleeptime = 1;

        while (alive) {
            try{
                last = System.currentTimeMillis();

                byte[] aux;
                if ((aux = cliente.readmessage()) != null){

                    sleeptime = 1;
                    previous = last;

                    synchronized (list) {
                        while (list.size() == MAX)
                            try {
                                list.wait();
                            } catch (InterruptedException ex) {
                            }
                        list.addFirst(new Messagetimestamped(aux, System
                                .currentTimeMillis()));
                        list.notifyAll();
                    }
                }
                else{
                    if (last-previous > 1000)
                        sleeptime = 1000;
                    else
                        sleeptime = 1;
                    sleep(sleeptime);
                }
            }
            catch (Exception e){
                if (lives()){
                    System.out.println("++++++++++++++++++ Basic Process - Producer");
                    kill();
                    nf.notify(false, processnumber);
                }
                return;
            }
        }
    }
}


class Consumer extends Thread{

    public void run() {
        while (alive) {
            byte[] message = null;
            Messagetimestamped  mt;
            synchronized(list) {
                while (list.size() == 0) {
                    try {
                        list.wait(); //HANGS HERE!
                        if (!alive) return;
                        sleep(1);
                    }
                    catch (InterruptedException ex) {}
                }
                mt = list.removeLast();
                list.notifyAll();
            }
            message = mt.mensaje;

            try{
                long timewaited = System.currentTimeMillis()-mt.timestamp;

                if (timewaited < SLEEPTIME)
                    sleep (SLEEPTIME-timewaited);

                if ( s.isClosed() || s.isOutputShutdown() ){
                    System.out.println("++++++++++++++++++++ Basic Process - Consumer - Connection closed!(HLR)");
                    kill();
                    nf.notify(false, processnumber);
                }
                else {
                    br.write(message);
                    br.flush();
                }
            } catch(SocketException e){
                return;
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

基本上，在 live 设置为falseProducer 之后，它实际上被终止了。消费者没有。它只是保持list.wait()在线状态。显然，来自 Producer 的list.notify()（或list.notifyAll()？）在终止后没有交付，因此 Consumer 永远不会检查alive布尔值。

如何使用尽可能少的修改来解决这个问题？

谢谢。

4

1 回答 1

3

我只想使用一个 ExecutorService 来包装队列，管理你的线程并为你处理关机。如果你这样做，几乎所有的代码都会消失。

但要回答你的问题，我建议送一颗毒丸。消费者在收到它时将关闭的特殊对象。

于 2013-06-13T13:08:08.223 回答