android IntentService Service HandlerThread 源码解读

来源：互联网发布：ubuntu 命令行 deb 编辑：程序博客网时间：2024/06/05 09:42

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

阅读全文

0 0