android IntentService Service HandlerThread 源码解读
Service、线程:
service是运行在主进程的main线程上的，远程service则运行在独立进程的main线程上。线程主要是用来执行一些异步的操作。
生命周期，一个应用程序被强制终止后，应用程序中开启的线程也会被销毁，而service可以做到在应用被终止的情况下仍然在后台欢快的运行。
其次是同一个线程对象没法被多个activty控制，当Activity被finish之后，该Activty启动的线程还在执行，此时你失去了对该线程的引用，只能通过终止应用来停止该线程的运行。
比较关键的服务一般选择使用service，如果比较耗时则可以在service中创建和控制线程，进行异步操作
IntentService
是继承Service并处理异步请求intent的一个类(启动IntentService的方式和启动传统的Service一样)，在IntentService内有一个工作线程来处理耗时操作，当任务执行完后，IntentService会自动停止，
而不需要我们手动去控制或stopSelf()。可以启动IntentService多次，而每一个耗时操作会以工作队列的方式在IntentService的onHandleIntent回调方法中执行，
并且，每次只会执行一个工作线程，执行完第一个再执行第二个，以此类推。请求都在一个单线程中，不会阻塞应用程序的主线程（UI Thread），同一时间只处理一个请求
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) { // 消息处理，Looper发现MessageQueue中有Message的时候, 就会停止Handler去处理消息
onHandleIntent((Intent)msg.obj); //5、具体事务处理（调用onHandleIntent完成）
stopSelf(msg.arg1); //6、stopSelf()结束Service
}
}
/**
* Creates an IntentService. Invoked by your subclass's constructor.
*
* @param name Used to name the worker thread, important only for debugging.
*/
public IntentService(String name) { // 1、带参构造函数
super();
mName = name;
}
public void setIntentRedelivery(boolean enabled) {
mRedelivery = enabled;
}
@Override
public void onCreate() { //服务创建时调用， 从onCreate()内容很容易看出：IntentService实际上是Looper,Handler,Service的集合体,他不仅有服务的功能,还有消息循环、处理的功能.
// TODO: It would be nice to have an option to hold a partial wakelock
// during processing, and to have a static startService(Context, Intent)
// method that would launch the service & hand off a wakelock.
super.onCreate();
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]"); //2、创建处理线程（工作线程）
thread.start();
//HandlerThread继承于Thread，所以它本质就是个Thread。与普通Thread的差别就在于，主要的作用是建立了一个线程，并且创立了消息队列，有来自己的looper,可以让我们在自己的线程中分发和处理消息
mServiceLooper = thread.getLooper(); // 获取处理线程的Looper，在处理线程中启动一个消息循环
mServiceHandler = new ServiceHandler(mServiceLooper); // 3、根据处理线程的Looper创建ServiceHandler，IntentService关键就是内部实现一个工作线程HandlerThread以及它的异步消息处理ServiceHandler类
}
@Override
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg); //5、通过mServiceHandler向Looper发送消息， 产生一条附带startId和Intent的Message并发送到MessageQueue中
}
/**
* You should not override this method for your IntentService. Instead,
* override {@link #onHandleIntent}, which the system calls when the IntentService
* receives a start request.
* @see android.app.Service#onStartCommand
*/
@Override
public int onStartCommand(Intent intent, int flags, int startId) { // 4、onStartCommande()：在每次服务启动时调用（会被多次调用，但只有一个Service实例）
//intent传送流： onStartCommand() ->onStart() -> sendMessage()--intent插入到工作队列 -> handleMessage() -> onHandleIntent()实现业务功能
onStart(intent, startId); // 调用onStart()
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
/*
onStartComand（）返回值：
这个整形可以有四个返回值：START_STICKY、START_NOT_STICKY、START_REDELIVER_INTENT、START_STICKY_COMPATIBILITY。
1、START_STICKY：如果service进程被kill掉，保留service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建service，
由于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(Intent,int,int)方法。如果在此期间没有任何启动命令被传递到service，那么参数Intent将为null。
2、START_NOT_STICKY：“非粘性的”。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务
3、START_REDELIVER_INTENT：重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入。
4、START_STICKY_COMPATIBILITY：START_STICKY的兼容版本，但不保证服务被kill后一定能重启。
*/
@Override
public void onDestroy() { // 服务被销毁时调用，用于回收不再使用的资源
mServiceLooper.quit();
}
/**
* Unless you provide binding for your service, you don't need to implement this
* method, because the default implementation returns null.
* @see android.app.Service#onBind
*/
@Override
public IBinder onBind(Intent intent) { //Binder是IBinder的实现类，默认返回null，即子类不用重写onBind
return null;
}
/**
* This method is invoked on the worker thread with a request to process.
* Only one Intent is processed at a time, but the processing happens on a
* worker thread that runs independently from other application logic.
* So, if this code takes a long time, it will hold up other requests to
* the same IntentService, but it will not hold up anything else.
* When all requests have been handled, the IntentService stops itself,
* so you should not call {@link #stopSelf}.
*
* @param intent The value passed to {@link
* android.content.Context#startService(Intent)}.
*/
protected abstract void onHandleIntent(Intent intent); // 需子类实现、添加具体的功能
}Handler会关联一个单独的线程和消息队列。Handler默认关联主线程，虽然要提供Runnable参数，但默认是直接调用Runnable中的run()方法。
也就是默认下会在主线程执行，如果在这里面的操作会有阻塞，界面也会卡住。如果要在其他线程执行，可以使用HandlerThread。
HandlerThread继承于Thread，所以它本质就是个Thread。与普通Thread的差别就在于，主要的作用是建立了一个线程，并且创立了消息队列，有来自己的looper,可以让我们在自己的线程中分发和处理消息
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
protected void onLooperPrepared() {
}
public void run() {
mTid = Process.myTid();
Looper.prepare();
/*
public static void prepare() {
if (sThreadLocal.get() != null) { //判断保证一个Thread只能有一个Looper实例
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper()); // 初始化当前线程为一个Looper（new Looper()实例化一个Looper）， 实现Looper绑定线程
}
*/
synchronized (this) {
mLooper = Looper.myLooper(); // public static Looper myLooper() { return sThreadLocal.get();} // 返回当前线程与之关联的Looper实例
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop(); // 消息循环--执行从MessageQueue取消息、handler分发消息
mTid = -1;
}
public Looper getLooper() {
if (!isAlive()) {
return null;
}
// If the thread has been started, wait until the looper has been created.
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
public int getThreadId() {
return mTid;
}
}使用IntentService需要两个步骤：
1、写构造函数
2、实现虚函数onHandleIntent，并在里面根据Intent的不同进行不同的事务处理就可以了。
注意：IntentService的构造函数一定是参数为空的构造函数，然后再在其中调用super(“name”)这种形式的构造函数。
public class IntentServiceDemo extends IntentService {
public IntentServiceDemo() {
super("IntentServiceDemo"); // 调用父类带参构造函数
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
System.out.println("onStartCommand");
return super.onStartCommand(intent, flags, startId);
}
@Override
protected void onHandleIntent(Intent intent) {
String action = intent.getExtras().getString("param"); //根据Intent传入的参数不同执行不同的任务
if (action.equals("param0")) {
System.out.println("param0");
}else if (action.equals("param1")) {
System.out.println("param1");
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class MainActivity extends Activity implements OnClickListener {
private Button startService;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
...
startService = (Button) findViewById(R.id.start);
startService.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.start:
Intent intentService = new Intent(this, IntentServiceDemo.class);
Bundle bundle = new Bundle();
intentService.putString("param", "param0");
intentService.putExtras(bundle);
startService(intentService);
break;
default:
break;
}
}
}
扫一扫
676
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
