我一直在我们的 Android 应用程序中注意到，每次我们退出到主屏幕时，我们都会将堆大小(泄漏)增加 ByteArrayOutputStream 的数量。我能够管理的最好的方法是添加

this.mByteArrayOutputStream = null;

在 run() 结束时防止堆大小不断增加。如果有人能启发我，我将不胜感激。我写了下面的例子来说明这个问题。

主 Activity .java

public class MainActivity extends Activity {
    private Controller mController;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);        
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

    @Override
    protected void onStart() {
        super.onStart();

        this.mController = new Controller();
        mController.connect();
    }

    @Override
    protected void onStop() {
        super.onStop();

        mController.quit();
    }
}

Controller .java

public class Controller {
    public volatile ReaderThread mThread;

    public Controller() {
        super();
    }

    public void connect() {
        mThread = new ReaderThread("ReaderThread");
        mThread.start();
    }

    public void quit() {
        mThread.quit();
    }

    public static class ReaderThread extends Thread {
        private volatile boolean isProcessing;
        private ByteArrayOutputStream mByteArrayOutputStream;

        public ReaderThread(String threadName) {
            super(threadName);  
        }

        @Override
        public void run() {
            this.isProcessing = true;

            Log.d(getClass().getCanonicalName(), "START");
            this.mByteArrayOutputStream = new ByteArrayOutputStream(2048000);

            int i = 0;
            while (isProcessing) {
                Log.d(getClass().getCanonicalName(), "Iteration: " + i++);
                mByteArrayOutputStream.write(1);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }

            try {
                mByteArrayOutputStream.reset();
                mByteArrayOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

            Log.d(getClass().getCanonicalName(), "STOP");
        }

        public void quit() {
            this.isProcessing = false;
        }
    }
}

最佳答案

线程不受 GC 的影响，因为它们是 garbage collection roots .因此，JVM 很可能将您的 ReaderThread 及其成员变量的分配保留在内存中，从而造成泄漏。

正如您所指出的，取消 ByteArrayOutputStream 会使其缓冲数据(但不是 ReaderThread 本身)可用于 GC。

编辑:

经过一番调查，我们得知 the Android debugger was causing the perceived leak :

The VM guarantees that any object the debugger is aware of is not garbage collected until after the debugger disconnects. This can result in a buildup of objects over time while the debugger is connected. For example, if the debugger sees a running thread, the associated Thread object is not garbage collected even after the thread terminates.

关于java - 为什么线程会在 Android 上泄漏？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12956549/