我的一个应用程序累积了很多 GC 无法拾取和清除的 Thread 实例。从长远来看，这种内存泄漏会使应用程序崩溃。

我不是100%确定它们来自哪里，但我有一种明显的感觉，以下可能是有问题的代码:

public class UraHostHttpConnection extends AbstractUraHostConnection {
    private Handler uiThreadHandler = new Handler(Looper.getMainLooper());
    private Executor taskExecutor = new Executor() {
         public void execute(Runnable command) {
             new Thread(command).start();
        }
    };
    private ConnectionTask task = null;

    @Override
    public void sendRequest(final HttpUriRequest request) {
        this.task = new ConnectionTask();
        this.uiThreadHandler.post(new Runnable() {
            public void run() {
                task.executeOnExecutor(taskExecutor, request);
            }
        });
   }

    @Override
    public void cancel() {
        if (this.task != null)
            this.task.cancel(true);
    }
}

此代码允许我并行运行多个 HTTP 连接，这些连接不会在默认的 AsyncTask Executor(它只是一个单线程队列)上相互阻塞。

我检查过，AsyncTask 实际上正在执行它们的 onPostExecute() 方法，而不是永远运行。在检查了一些内存转储后，我怀疑包装 Thread-Objects 在 AsyncTask 完成后不会停止运行。

上面的代码是否可能仍然是我的内存泄漏的原因，还是我应该开始寻找其他地方？

感谢任何帮助。

编辑:应该注意的是，sendRequest 只被调用过一次。上面示例中没有的代码的其他部分确保了这一点。

编辑 2: 父类(super class)如下所示:

public abstract class AbstractUraHostConnection {
    protected IUraHostConnectionListener listener = null;

    public void setListener(IUraHostConnectionListener listener) {
        this.listener = listener;
    }
    public abstract void sendRequest(HttpUriRequest request);
    public abstract void cancel();
}

AsyncTask 看起来像这样:

private class ConnectionTask extends AsyncTask<HttpUriRequest, Object, Void> {
    final byte[] buffer = new byte[2048];
    private ByteArrayBuffer receivedDataBuffer = new ByteArrayBuffer(524288);

    @Override
    protected Void doInBackground(HttpUriRequest... arg0) {
        UraHostHttpConnection.taskCounter++;
        AndroidHttpClient httpClient = AndroidHttpClient.newInstance("IVU.realtime.app");
        try {
            // Get response and notify listener
            HttpResponse response = httpClient.execute(arg0[0]);
            this.publishProgress(response);

            // Check status code OK before proceeding
            if (response.getStatusLine().getStatusCode() == 200) {
                HttpEntity entity = response.getEntity();
                InputStream inputStream = entity.getContent();
                int readCount = 0;

                // Read one kB of data and hand it over to the listener
                while ((readCount = inputStream.read(buffer)) != -1 && !this.isCancelled()) {
                    this.receivedDataBuffer.append(buffer, 0, readCount);
                    if (this.receivedDataBuffer.length() >= 524288 - 2048) {
                        this.publishProgress(receivedDataBuffer.toByteArray());
                        this.receivedDataBuffer.clear();
                    }
                }

                if (this.isCancelled()) {
                    if (arg0[0] != null && !arg0[0].isAborted()) {
                        arg0[0].abort();
                    }
                }
            }
        } catch (IOException e) {
            // forward any errors to listener
            e.printStackTrace();
            this.publishProgress(e);
        } finally {
            if (httpClient != null)
                httpClient.close();
        }

        return null;
    }

    @Override
    protected void onProgressUpdate(Object... payload) {
        // forward response
        if (payload[0] instanceof HttpResponse)
            listener.onReceiveResponse((HttpResponse) payload[0]);
        // forward error
        else if (payload[0] instanceof Exception)
            listener.onFailWithException((Exception) payload[0]);
        // forward data
        else if (payload[0] instanceof byte[])
            listener.onReceiveData((byte[]) payload[0]);
    }

    @Override
    protected void onPostExecute(Void result) {
        listener.onReceiveData(this.receivedDataBuffer.toByteArray());
        listener.onFinishLoading();
        UraHostHttpConnection.taskCounter--;
        Log.d(TAG, "There are " + UraHostHttpConnection.taskCounter + " running ConnectionTasks.");
    }
}

最佳答案

用 ThreadPoolExecutor 代替您的执行器，这样您就可以控制池的大小。如果 ThreadPoolExecutor 基本上是具有公开方法的 Executor，则可能只是默认最大池大小设置得非常高的情况。

官方文档here .

特别看看:

setCorePoolSize(int corePoolSize)
//Sets the core number of threads.

setKeepAliveTime(long time, TimeUnit unit)
//Sets the time limit for which threads may remain idle before being terminated.

setMaximumPoolSize(int maximumPoolSize)
//Sets the maximum allowed number of threads.

如果您想减少代码，还有一个替代方案(更好的主意取决于您真正想要多少控制权以及您将交换多少代码来获得它)。

Executor taskExecutor = Executors.newFixedThreadPool(x);

其中 x = 池的大小

关于android - 为什么我的线程不会死掉并导致内存泄漏？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/16210323/