Volley导致Android Service长期运行后应用崩溃问题求助

你这个问题是典型的后台任务资源管理不当导致的内存溢出，从报错信息能看出，不断创建新线程（每次Volley请求都新建RequestQueue）+ Timer任务管理混乱，最终导致线程堆积耗尽内存。下面是具体的优化步骤和完整代码：

1. 核心问题：复用Volley RequestQueue #

Volley的RequestQueue是单例设计，应该全局复用，而不是每次请求都新建实例。每次创建RequestQueue都会初始化缓存线程、网络线程池，频繁创建会直接导致线程数量爆炸，最终触发OOM。

优化方式： #

在Service的onCreate()中初始化一次RequestQueue，后续所有请求复用这个实例：

private RequestQueue mRequestQueue;

@Override
public void onCreate() {
    super.onCreate();
    // 全局初始化RequestQueue，只做一次
    mRequestQueue = Volley.newRequestQueue(this);
    this.db = openOrCreateDatabase("db", Context.MODE_PRIVATE, null);
    isRunning = true;
}

然后在updates()方法里直接使用这个全局实例，不要再调用Volley.newRequestQueue()：

// 替换原来的queue = Volley.newRequestQueue(this);
mRequestQueue.add(stringRequest);

2. 替换Timer为Handler+Runnable（适配Android生命周期） #

Timer在Android中有不少坑：比如任务执行超时会导致后续任务堆积，而且无法很好地和组件生命周期绑定。改用Handler.postDelayed()实现定时任务，不仅线程管理更安全，还能在Service销毁时及时停止任务。

优化方式： #

private Handler mHandler = new Handler(Looper.getMainLooper());
private Runnable mUpdateRunnable = new Runnable() {
    @Override
    public void run() {
        if (isRunning) {
            updates();
            // 30秒后再次触发任务
            mHandler.postDelayed(this, 30000);
        }
    }
};

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    // 启动定时任务，先移除可能存在的旧任务避免重复执行
    mHandler.removeCallbacks(mUpdateRunnable);
    mHandler.post(mUpdateRunnable);
    return Service.START_STICKY;
}

@Override
public void onDestroy() {
    super.onDestroy();
    isRunning = false;
    // 清理未执行的任务，防止内存泄漏
    mHandler.removeCallbacks(mUpdateRunnable);
    // 停止RequestQueue并释放资源
    if (mRequestQueue != null) {
        mRequestQueue.stop();
    }
}

3. 修复静态数据库实例的内存泄漏 #

静态的SQLiteDatabase会持有Service的上下文引用，即使Service销毁，这个引用也不会被释放，长期运行会导致内存泄漏。把它改成非静态变量，并在onDestroy()中关闭：

// 去掉static修饰符
private SQLiteDatabase db;

@Override
public void onDestroy() {
    super.onDestroy();
    // ...其他清理逻辑
    if (db != null && db.isOpen()) {
        db.close();
    }
}

4. 其他细节优化 #

• 给Volley请求设置标签，方便在Service销毁时取消未完成的请求，避免内存泄漏：

stringRequest.setTag(TAG);
// 在onDestroy()中取消所有该标签的请求
mRequestQueue.cancelAll(TAG);

• 不要忽略异常，添加日志打印方便后续调试：

catch (JSONException e) {
    Log.e(TAG, "解析响应失败", e);
    return;
}

public class Myupdates extends Service {

    private static final String TAG = "AutoUpdates";
    private static final long UPDATE_INTERVAL = 30000; // 30秒间隔

    private SQLiteDatabase db;
    private boolean isRunning = false;
    private RequestQueue mRequestQueue;
    private Handler mHandler;
    private Runnable mUpdateRunnable;

    @Override
    public void onCreate() {
        super.onCreate();
        // 全局初始化RequestQueue
        mRequestQueue = Volley.newRequestQueue(this);
        // 初始化数据库
        db = openOrCreateDatabase("db", Context.MODE_PRIVATE, null);
        isRunning = true;

        // 初始化定时任务
        mHandler = new Handler(Looper.getMainLooper());
        mUpdateRunnable = new Runnable() {
            @Override
            public void run() {
                if (isRunning) {
                    updates();
                    mHandler.postDelayed(this, UPDATE_INTERVAL);
                }
            }
        };
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 避免重复提交任务
        mHandler.removeCallbacks(mUpdateRunnable);
        mHandler.post(mUpdateRunnable);
        return Service.START_STICKY;
    }

    @Override
    public IBinder onBind(Intent arg0) {
        return null;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        isRunning = false;
        // 清理Handler任务
        mHandler.removeCallbacks(mUpdateRunnable);
        // 取消Volley未完成请求并停止队列
        if (mRequestQueue != null) {
            mRequestQueue.cancelAll(TAG);
            mRequestQueue.stop();
        }
        // 关闭数据库
        if (db != null && db.isOpen()) {
            db.close();
        }
        Log.i(TAG, "Service onDestroy");
    }

    protected void updates() {
        try {
            JSONObject manJson = new JSONObject();
            manJson.put("userid", "4444");
            manJson.put("version", "6.0");
            JSONObject json = new JSONObject();
            json.put("UPDATE", manJson);
            final String postData = json.toString();

            final String base_url = "https://myweburl.com";
            StringRequest stringRequest = new StringRequest(Request.Method.POST, base_url,
                    response -> {
                        try {
                            JSONObject object = (JSONObject) new JSONTokener(response).nextValue();
                            String update = object.getString("UPDATE");
                            // TODO: 这里处理你的更新逻辑
                        } catch (JSONException e) {
                            Log.e(TAG, "解析更新响应失败", e);
                        }
                    },
                    error -> Log.e(TAG, "请求更新失败", error)) {
                @Override
                protected Map<String, String> getParams() {
                    Map<String, String> params = new HashMap<>();
                    params.put("data", postData);
                    return params;
                }

                @Override
                public Map<String, String> getHeaders() throws AuthFailureError {
                    Map<String, String> headers = new HashMap<>();
                    headers.put("Content-Type", "application/x-www-form-urlencoded");
                    return headers;
                }
            };

            // 设置请求标签，方便后续取消
            stringRequest.setTag(TAG);
            mRequestQueue.add(stringRequest);

        } catch (JSONException e) {
            Log.e(TAG, "构建请求参数失败", e);
        }
    }
}

如果你的更新任务不需要实时运行（Android 8.0+对后台Service有严格限制），建议改用WorkManager实现周期性任务，它能更好地适配系统后台策略，避免Service被系统杀死，同时资源管理更高效。

内容的提问来源于stack exchange，提问作者JoDee