Question

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

消费者等待应用程序“服务器”端的消息，然后将“客户端”端的消息转发到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();
            }
        }
    }
}

基本上在alive之后设置为false生产者实际上被终止了。消费者没有。它只是挂在list.wait()线上。显然，生产者的list.notify()（或list.notifyAll()？）在终止后不会被传递，因此消费者永远不会检查alive布尔值。

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

感谢。

Answer 1

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

但是为了回答你的问题，我建议寄一个毒丸。消费者在收到消息时将关闭的特殊对象。

使用Java中的wait / notify机制终止Producer-Consumer线程

1 个答案: