Question

我正在尝试构建服务器但是使用线程池引入了内存泄漏，导致我的堆溢出。

我的服务器从主线程Acceptor和Consumer创建两个主线程。我是JProfiler的新手，但它似乎非常清楚地指出以下代码（Acceptor）是罪魁祸首。

enter image description here

Acceptor线程接受来自客户端的新连接。在接受调用时，线程池中的新线程用于处理连接。

public class AcceptorThread implements Runnable{
LinkedBlockingQueue<LinkedList<Log_Message>> queue = null;
public AcceptorThread(LinkedBlockingQueue<LinkedList<Log_Message>> queue){
    this.queue = queue;
}

@Override
public void run() {
    ExecutorService acceptors = Executors.newCachedThreadPool();
    ServerSocket socket = null;
    try {
        socket = new ServerSocket(44431);
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    while(!init_LogServer.isStopped()){
        Socket connectionSocket = null;
        try {
            connectionSocket = socket.accept();
        } catch (IOException e) {
            e.printStackTrace();
        }
        init_LogServer.addList();
        System.out.println("Accepted New List: " + init_LogServer.getListCount());
        Runnable worker = new List_Acceptor(connectionSocket, queue);
        acceptors.execute(worker);
    }
}

}

线程池中的新线程接收对象的链接列表，此列表将添加到队列中并且线程已完成。我的理解是，在完成下面的代码后，线程将终止，下面的对象将被GC收集，并且线程将重新进入线程池以供重用。我无法看到任何明显的内存泄漏，因此我猜测会发生的事情是GC从未收集到下面的类导致堆构建，这是正确的吗？收到的列表添加到队列后，如何销毁以下对象？

public class List_Acceptor implements Runnable{
Socket socket = null;
private LinkedList<Log_Message> lmList = null;
private LinkedBlockingQueue<LinkedList<Log_Message>> queue = null;
private String dumpMessage = null;

public List_Acceptor(Socket socket, LinkedBlockingQueue<LinkedList<Log_Message>> queue){
    this.queue = queue;
    this.socket = socket;
}

@Override
public void run() {
    ObjectInputStream input = null;
    try {
        input = new ObjectInputStream(socket.getInputStream());
    } catch (IOException e3) {
        // TODO Auto-generated catch block
        e3.printStackTrace();
    }
    Object received = null;
    try {
        received = input.readObject();
    } catch (ClassNotFoundException | IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    try {
        lmList = (LinkedList<Log_Message>) received;
    } catch (Exception e1) {
        //e1.printStackTrace();
        System.out.println("Received DumpLog");
        dumpMessage = (String) received;
        System.out.println("Dump: "+dumpMessage);
        init_LogServer.stop();
        e1.printStackTrace();
    }

    //close socket
    try {
        socket.close();
        input.close();
    } catch (IOException e2) {e2.printStackTrace();}

    try {
        queue.put(lmList);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}

}

编辑：我已经了解到，当一个对象/类通过线程实例化时，就像我对线程池一样，GC被限制清理该对象。这似乎是内存泄漏的可能原因，可能是我的问题。考虑到明天我将重新设计，以便AcceptorTread执行必要的步骤将接收的列表放入队列，它应该更慢，但将防止堆问题。那有意义吗？

Answer 1

关于上次编辑：当前线程不会保留所有创建的List_Acceptor个对象（BTW，Java命名约定为ListAcceptor）。

JProfiler中的分配热点视图只是告诉您分配了仍在堆上的对象。这并不意味着那些对象不能被GCed。

要分析实际强烈引用的对象，请转到JProfiler中的“Heap walker”。然后选择所有List_Acceptor个对象并转到“传入引用”视图。使用单个对象，单击“显示GC根路径”。然后，您将看到一系列引用，阻止对象被GCed。

使用“累计传入参考”视图，您可以检查是否所有List_Acceptor个对象都是这种情况。

Answer 2

如果你的线程在完成请求之后继续引用对象，只在新请求进入时覆盖它们，那么原始对象被“固定”到内存中，直到该线程再次变为活动状态。这些固定的对象会被多次复制并占用ram，以便稍后释放。

该循环的工作线程应始终清除所有对象引用，然后再等待另一个对象工作。

线程池中的Java内存泄漏

2 个答案: