当前位置：首页 > news >正文

Android学习总结之service篇

news 来源：原创 2025/6/17 4:28:14

引言

在 Android 开发里，Service 与 IntentService 是非常关键的组件，它们能够让应用在后台开展长时间运行的操作。不过，很多开发者仅仅停留在使用这两个组件的层面，对其内部的源码实现了解甚少。本文将深入剖析 Service 和 IntentService 的源码，揭示它们的工作原理与区别。

Service 源码剖析

1. Service 概述

Service 是 Android 四大组件之一，用于在后台执行长时间运行的操作，且不提供用户界面。它可以通过 startService() 启动，也能通过 bindService() 绑定，从而与其他组件进行交互。

2. 生命周期方法

Service 的生命周期方法定义在 android.app.Service 类中，主要包含 onCreate()、onStartCommand()、onBind() 和 onDestroy()。

Service
├─ onCreate()          // 初始化（仅一次）
├─ onStartCommand()    // 处理 startService 请求（可多次调用）
├─ onBind()            // 处理 bindService 请求（返回 IBinder）
├─ onDestroy()         // 释放资源
└─ 需手动管理子线程    // 耗时操作需自行创建线程

onCreate()：服务创建时调用，通常用于初始化操作，此方法仅调用一次。
onStartCommand()：每次调用 startService() 启动服务时都会调用该方法，其返回值决定了服务在被系统杀死后的重启策略。
onBind()：当调用 bindService() 时调用，需要返回一个 IBinder 对象，用于与服务进行通信。
onDestroy()：服务销毁时调用，可用于释放资源。


    A[Service 生命周期] --> B[onCreate()]
    B --> C{启动方式}
    C -->|startService()| D[onStartCommand()]
    C -->|bindService()| E[onBind()]
    D --> F[手动调用 stopSelf()/stopService()]
    E --> G[解绑时 onUnbind()]
    F & G --> H[onDestroy()]

    I[IntentService 生命周期] --> J[onCreate()]
    J --> K[创建 HandlerThread & ServiceHandler]
    K --> L[onStartCommand() 调用 onStart()]
    L --> M[ServiceHandler 处理 Message]
    M --> N[调用 onHandleIntent(intent)（子线程）]
    N --> O[自动调用 stopSelf()]
    O --> P[onDestroy()（Looper.quit()）]

3. 启动流程

当调用 startService() 方法时，最终会调用到 ActivityManagerService 中的相关方法，它会负责创建 Service 实例并调用其生命周期方法。

// ActivityManagerService.java
public ComponentName startService(IApplicationThread caller, Intent service,
        String resolvedType, int userId) {
    // 处理启动服务的逻辑
    synchronized(this) {
        // ...
        ServiceRecord r = startServiceLocked(caller, service, resolvedType, callingPid,
                callingUid, userId);
        // ...
    }
    // ...
}

4. 注意事项

Service 默认在主线程中运行，若在 Service 中执行耗时操作，会导致界面卡顿。因此，若有耗时操作，应在 Service 中手动创建子线程。

IntentService 源码剖析

1. IntentService 概述

IntentService 是 Service 的子类，它是一个异步的、会自动停止的服务。它内部使用 HandlerThread 创建了一个子线程，所有的 Intent 都会在这个子线程中处理。

2. 关键源码分析

IntentService（继承 Service）
├─ onCreate()          
│  └─ 创建 HandlerThread（子线程）
│  └─ 获取 Looper，创建 ServiceHandler（绑定子线程 Looper）
├─ onStartCommand()    
│  └─ 调用 onStart()，将 Intent 封装为 Message 发送给 ServiceHandler
├─ ServiceHandler（Handler 子类）
│  └─ handleMessage()：调用 onHandleIntent() 处理 Intent，调用 stopSelf()
├─ onHandleIntent()     // 开发者需实现的核心业务逻辑（在子线程执行）
└─ onDestroy()         
   └─ 调用 Looper.quit() 终止子线程

// android.app.IntentService
public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }

    public IntentService(String name) {
        super();
        mName = name;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

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

    protected abstract void onHandleIntent(@Nullable Intent intent);
}

3. 关键流程

onCreate()：创建一个 HandlerThread 并启动它，然后获取该线程的 Looper，创建一个 ServiceHandler 并关联该 Looper。
onStartCommand()：调用 onStart() 方法，将传递的 Intent 封装成 Message 发送给 ServiceHandler。
ServiceHandler 的 handleMessage()：调用 onHandleIntent() 方法处理 Intent，处理完成后调用 stopSelf() 停止服务。

4. 特点总结

异步处理：所有的 Intent 都会在子线程中处理，避免了在主线程中执行耗时操作。
自动停止：当所有的 Intent 处理完成后，IntentService 会自动调用 stopSelf() 方法停止服务。
顺序处理：IntentService 会按照 Intent 到达的顺序依次处理，不会并发处理多个 Intent。

Service 与 IntentService 的区别

1. 线程方面

Service 默认在主线程中运行，若要执行耗时操作，需手动创建子线程。
IntentService 内部创建了一个子线程，所有的 Intent 都会在该子线程中处理。

2. 停止方式

Service 需要手动调用 stopSelf() 或 stopService() 来停止服务。
IntentService 在处理完所有的 Intent 后会自动停止。

3. 处理方式

Service 可以同时处理多个请求。
IntentService 会按顺序依次处理 Intent，不会并发处理。

总结图表

特性	Service	IntentService
继承关系	直接继承 `ContextWrapper`，实现 `ComponentCallbacks2`	继承自 `Service`，是 `Service` 的子类
线程环境	默认运行在主线程（UI 线程），需手动创建子线程处理耗时任务	内部创建 `HandlerThread` 子线程，通过 `ServiceHandler` 在子线程处理所有 `Intent`
启动后的处理逻辑	需重写 `onStartCommand`，手动处理业务逻辑，需手动调用 `stopSelf()` 停止服务	自动将 `Intent` 封装为 `Message`，通过 `ServiceHandler` 按顺序处理，处理完自动停止
生命周期控制	需手动调用 `stopService()` 或 `stopSelf()` 停止，或通过 `onStartCommand` 返回值控制重启策略	无需手动停止，处理完所有 `Intent` 后自动调用 `stopSelf()` 停止
并发处理	可同时处理多个 `startService` 请求（需自行处理多线程同步）	按 `Intent` 接收顺序串行处理，同一时间仅处理一个 `Intent`
默认 `onBind` 返回值	返回 `null`（需开发者自定义 `IBinder`）	直接返回 `null`（不支持绑定，如需绑定需自定义子类）
适用场景	复杂后台逻辑（如跨组件通信、长期运行任务）	简单异步任务（如网络请求、文件操作），任务完成后自动停止