多线程编程之IntentService

2017-04-18 本文已影响159人明朗__

在分析IntentService之前需要了解下Android四大组件之一的Service(服务)同时为了更好的理解IntentService需要了解HandlerThread
多线程编程之HandlerThread

Service

定义:

用来在后台完成一个时间跨度比较大的工作的应用组件
Service的生命周期方法运行在主线程,如果Service想做持续时间比较长的工作，需要启动一个分线程；
应用退出：Service不会停止(在没有主动停止Service或手机room杀死的情况下)
再次进入应用可以与正在运行的Service进行通信
启动和停止：
一般启动与停止

startService(intent)
stopService(intent)

2.绑定启动与解绑

bindService(.....)
unbindService(serviceConnection)

每次startService(intent)都会调用Service的onStartCommand()方法
针对于绑定的方式，如果onBind()方法返回值非空，则会调用启动者(比如：activity)中的ServiceConnection中的onServiceConnected()方法

Service生命周期

上面只是对Service做了简单的介绍其实Serviec还区分Local Service(本地服务),Remote Service(远程服务)以及各自的通信方式等这里就不做深入了解

IntentService

定义：
IntentService是处理异步请求的Service,客户端通过发送请求调用startService(intent)来根据自身业务启动IntentService,IntentService会创建独立的worker线程来依次处理所有的Intent请求；
特征：

会创建独立的分线程来处理onHandleIntent()方法中的代码实现，无需处理多线程问题
当处理完所有请求IntentService会自动停止服务,无需手动停止服务
IntentService只能通过startService(intent)启动,onBind()默认实现为null;
除第一次startService(intent)外以后每次启动服务都只会调用onStartCommand(Intent intent, int flags, int startId)并将Intent和startId封装为Message对象通过Handler发送该消息添加到MessageQueue队列中

使用：

public class MyIntentService extends IntentService {
    public MyIntentService() {
        //需要指定一个线程名称
        super("MyIntentService");
    }
    //实现onHandleIntent抽象方法 处理Handler发送的消息
    @Override
    protected void onHandleIntent(Intent intent) {
        if (intent != null) {
           //处理耗时操作业务逻辑
            String action = intent.getStringExtra("action");
            if("start".equals(action)){
                for(int i=0;i<5;i++){
                    Log.e(action,Thread.currentThread().getName()+"执行了  "+i+"次");
                }
            }
        }
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(action,"IntentService----死亡");
    }
}

//配置清单文件注册
<application>
<service
    android:name=".MyIntentService"
    android:exported="false"/>
<application/>

//启动
 Intent intent = new Intent(this, MyIntentService.class);
 intent.putExtra("action","start");
 startService(intent);

start: IntentService[MyIntentService]执行了  0次
start: IntentService[MyIntentService]执行了  1次
start: IntentService[MyIntentService]执行了  2次
start: IntentService[MyIntentService]执行了  3次
start: IntentService[MyIntentService]执行了  4次
IntentService----死亡

上面是一个简单的案例,从中也看到了通过启动服务后onHandleIntent(Intent intent)就在线程名称为MyIntentService的分线程中执行执行完后自动停止服务从onDestroy()生命周期方法打印就可以看出
分析：

IntentService和HndlerThread有很高的关联性其实只要弄懂了HndlerThread一切就很直白了可以先看看我的上篇文章多线程编程之HandlerThread

通过上图源码分析得到：

IntentService继承自Service 是一个服务需要在配置清单文件中注册
在构造方法中需要传入一个String参数指定为分线程名称
在onCreate中创建了HandlerTher线程并启动同时以HandlerTher线程中的Looper对象创建了Handler对象
在onStart()和onStartCommand()中将Intent和startId封装为Message对象通过Handler发送消息
在Handler的handleMessage(Message)处理消息函数中调用抽象方法onHandleIntent()交由我们自己实现处理且该抽象函数在分线程中执行。

问题：

IntentService会创建独立的worker线程来依次处理所有的Intent请求每处理一个完成一个请求便会将该次服务停止掉是怎么实现的呢？

@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;
  }

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);
      }
  }

通过源码分析我们知道了Message对象包含2个信息一个是Intent 一个是startId 其中Intent不用说是我的请求意图当消息处理完后调用stopSelf(msg.arg1)从字面上理解就是停止服务是怎么实现的呢首先先看看startService(Intent)都做了什么

public final class ActivityManagerService {
    final ActiveServices mServices;
    @Override
    public ComponentName startService(IApplicationThread caller, Intent service,
          String resolvedType, int userId) {
      enforceNotIsolatedCaller("startService");
    。。。。。。。。。
      synchronized(this) {
          。。。。。。。。
          //启动服务
          ComponentName res = mServices.startServiceLocked(caller, service,
                  resolvedType, callingPid, callingUid, userId);
          。。。。。。
          return res;
      }
  }

}

public final class ActiveServices {
ComponentName startServiceLocked(IApplicationThread caller,
Intent service, String resolvedType,
int callingPid, int callingUid, int userId) {
......
ServiceLookupResult res =
retrieveServiceLocked(service, resolvedType,
callingPid, callingUid, userId, true, callerFg);
......
ServiceRecord r = res.record;
r.pendingStarts.add(new ServiceRecord.StartItem(r, false, r.makeNextStartId(),
service, neededGrants));
}
}

final class ServiceRecord extends Binder {
public int getLastStartId() {
return lastStartId;
}
//每次启动服务lastStartId就会加一
public int makeNextStartId() {
lastStartId++;
if (lastStartId < 1) {
lastStartId = 1;
}
return lastStartId;
}
}

从源码初略的分析当startService(intent)时会执行ActivityManagerService的startService()接着调用ActiveServices的startServiceLocked()在该函数里面调用了ServiceRecord的makeNextStartId() 其中有个成员变量lastStartId会在每次启动服务的时候自增1,再来看停止服务

//调用Service的stopSelf(startId) 参数为startId
public final void stopSelf(int startId) {
if (mActivityManager == null) {
return;
}
try {
mActivityManager.stopServiceToken(
new ComponentName(this, mClassName), mToken, startId);
} catch (RemoteException ex) {
}
}

public final class ActivityManagerService {
final ActiveServices mServices;
@Override
public boolean stopServiceToken(ComponentName className, IBinder token,int startId) {
synchronized(this) {
return mServices.stopServiceTokenLocked(className, token, startId);
}
}

public final class ActiveServices {
boolean stopServiceTokenLocked(ComponentName className, IBinder token,int startId) {

    ServiceRecord r = findServiceLocked(className, token, UserHandle.getCallingUserId());
    if (r != null) {
        if (startId >= 0) {
            //根据startId获取StartItem对象
            ServiceRecord.StartItem si = r.findDeliveredStart(startId, false);
            if (si != null) {
                while (r.deliveredStarts.size() > 0) {
                //StartItem不为空 且deliveredStarts集合元素个数大于0 就删除第1个
                    ServiceRecord.StartItem cur = r.deliveredStarts.remove(0);
                    //将StartItem的UriPermissionOwner对象置空
                    cur.removeUriPermissionsLocked();
                    if (cur == si) {
                        break;
                    }
                }
            }
            //判断是否为最后一个服务 
            if (r.getLastStartId() != startId) {
                return false;
            }
        synchronized (r.stats.getBatteryStats()) {
        //BatteryStatsImpl.Uid.Pkg.Serv.stopRunningLocked()停止服务
            r.stats.stopRunningLocked();
        }
       。。。。。。。。。。
        //将该服务不再是可用
        bringDownServiceIfNeededLocked(r, false, false);
        //调用native方法重置该服务
        Binder.restoreCallingIdentity(origId);
        return true;
    }
    return false;
}

****  
以上就是我对IntentService的理解 可能在startService(Intent)源码分析有不正确之处欢迎大家踊跃指出

多线程编程之IntentService

Service

IntentService

猜你喜欢

热点阅读