Volley与内存泄露

前言

这几天突然很好奇volley的取消操作是如何实现的，就去看了下volley的源码，突然发现，volley的取消操作实现的很简单，很失望。然后突然想到另外一个很敏感的问题——内存泄露。

正文

首先来看下volley的源码吧

Request.cancel() && Request.isCanceled()

private boolean mCanceled;
/** 
 * Mark this request as canceled.  No callback will be delivered. 
 */
public void cancel() {    
    mCanceled = true;
}
/** 
 * Returns true if this request has been canceled. 
 */
public boolean isCanceled() {    
    return mCanceled;
}

cancel的操作十分简单，就单纯地给mCanceled赋了个true值。

NetworkDispatcher

这个类在volley库中负责网络请求的运行，继承自Thread类。

NetworkDispatcher.run()

@Override
public void run() {    
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);   
    Request<?> request;    
    while (true) {        
        long startTimeMs = SystemClock.elapsedRealtime();        
        // release previous request object to avoid leaking request object when mQueue is drained.
        request = null;       
        try {            
        // Take a request from the queue.            
            request = mQueue.take();        
            } catch (InterruptedException e) {            
            // We may have been interrupted because it was time to quit.            
                if (mQuit) {                
                    return;           
                }           
                continue;        
            }        
            try {            
                request.addMarker("network-queue-take");            
                // If the request was cancelled already, do not perform the            
                // network request.            
                if (request.isCanceled()) {                
                    request.finish("network-discard-cancelled");                
                    continue;           
                }            
                addTrafficStatsTag(request);            
                // Perform the network request.            
                NetworkResponse networkResponse = mNetwork.performRequest(request);                                
                request.addMarker("network-http-complete");            
                // If the server returned 304 AND we delivered a response already,            
                // we're done -- don't deliver a second identical response.            
                if (networkResponse.notModified && request.hasHadResponseDelivered()) {                          
                    request.finish("not-modified");                
                    continue;            
                }            
                //  缓存使用，只有没有网络的情况下，如果是返回失败，如果网络请求返回数据失败，怎么办，不刷新            
                // Parse the response here on the worker thread.            
                Response<?> response = request.parseNetworkResponse(networkResponse);                    
                request.addMarker("network-parse-complete");            
                // Write to cache if applicable.            
                // TODO: Only update cache metadata instead of entire record for 304s.            
                if (networkResponse.statusCode == HttpStatus.SC_SERVICE_UNAVAILABLE && request.shouldCache()) {                
                    Cache.Entry cacheEntry = mCache.get(request.getCacheKey());                
                    if (cacheEntry != null) {                    
                        networkResponse = new NetworkResponse(cacheEntry.data, cacheEntry.responseHeaders);                    
                        response = request.parseNetworkResponse(networkResponse);                
                    }            
                } else if (request.shouldCache() && response.cacheEntry != null) {                        
                    mCache.put(request.getCacheKey(), response.cacheEntry);                
                    request.addMarker("network-cache-written");            
                }           
                // Post the response back.           
                request.markDelivered();            
                mDelivery.postResponse(request, response);        
           } catch (VolleyError volleyError) {                    
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);                  
                parseAndDeliverNetworkError(request, volleyError);        
           } catch (Exception e) {            
               VolleyLog.e(e, "Unhandled exception %s", e.toString());            
               VolleyError volleyError = new VolleyError(e);                    
               volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);                    
               mDelivery.postError(request, volleyError);       
           }    
      }
}

从代码中可以看到，request在即将运行之前，首先会判断一次isCanceled()，假如我们在这之前已经将request取消了，那么request也就直接结束了，此时一般情况下不会出现内存泄露的情况，假如在那之后我们才调用cancel操作，那么我们继续往下看，此时run函数继续，request进入到performRequest阶段，然后最后postResponse。
我们会用到cancel操作的情况一般有：
1.不关心这个request的结果了，主动cancel，但是activity没有被关闭；
2.在activity关闭时，cancel掉所有这个activity发出的request请求。我们在使用request时，还需要传入Response.Listener和Response.ErrorListener的接口，用来当request请求结束时传数据。而我们在Response的接口中一般都要修改UI，这就意味着这个接口会持有对Activity的引用，所以这种情况下，Activity关闭，request虽然被cancel了，但是request还持有对Activity的引用，导致Activity的内存泄露。

解决

解决办法有两种：

1.新建一个自己的Request类

这里以StringRequest为例，那么直接上源码

public class MyStringRequest extends StringRequest{    
    public MyStringRequest(int method, String url, Response.Listener<String> listener, Response.ErrorListener errorListener) {        
        super(method, url, listener, errorListener);    
    }    
    public MyStringRequest(String url, Response.Listener<String> listener, Response.ErrorListener errorListener) {        
        super(url, listener, errorListener);    
    }    
    @Override    
    public void cancel(){        
        super.cancel();        
        onFinish();    
    }
}

onFinish函数会把listener直接设为空（onFinish函数为protected，所以只能在子类里调用了），而cancel操作会把errorListener设为空。

2.使用弱引用

现在的项目都是大部分使用的是MVP模式，一般情况下，我们是在Presenter中来实现Response的接口，使用的使用就直接XXXRequest request = new XXXRequest(method,url,this,this);
下面上改良好的代码：

MyResponseListener:

public class MyResponseListener<T extends BasePresenter> implements Response.Listener, Response.ErrorListener {    
    private WeakReference<Response.Listener> listenerRef;    
    private WeakReference<Response.ErrorListener> errorRef;    
    public MyResponseListener(Response.Listener listener, Response.ErrorListener error) {        
        listenerRef = new WeakReference<>(listener);        
        errorRef = new WeakReference<>(error);   
    }    
    @Override    
    public void onErrorResponse(VolleyError error) {        
        if (errorRef.get()!=null){            
            errorRef.get().onErrorResponse(error);        
        }    
    }    
    @Override    
    public void onResponse(Object response) {       
        if (listenerRef.get()!=null){            
            listenerRef.get().onResponse(response);        
        }    
    }
}

BasePresenter:

这里可以再做一层保护，自定义一个接口，让Presenter来实现这个接口，防止被人直接使用new XXXRequest(method,url,this,this)。

public abstract class BasePresenter implements Response.Listener, Response.ErrorListener {                
    private MyResponseListener listener;    
    public BasePresenter() {        
        initListener();    
    }    
    protected void initListener() {        
        listener = new MyResponseListener(this, this);    
    }
    protected Response.Listener getListener(){    
        return listener;
    }
    protected Response.ErrorListener getErrorListener(){    
        return listener;
    }
}