乐趣区

关于android:Android-多线程IntentService详解

作者：

jiezi

在

IntentService
一、IntentService概述
上一篇咱们聊到了HandlerThread，本篇咱们就来看看HandlerThread在IntentService中的利用，看本篇前倡议先看看上篇的HandlerThread，有助于咱们更好把握IntentService。同样地，咱们先来看看IntentService的特点：

它实质是一种非凡的Service,继承自Service并且自身就是一个抽象类
它能够用于在后盾执行耗时的异步工作，当工作实现后会主动进行
它领有较高的优先级，不易被零碎杀死（继承自Service的缘故），因而比拟适宜执行一些高优先级的异步工作
它外部通过HandlerThread和Handler实现异步操作
创立IntentService时，只需实现onHandleIntent和构造方法，onHandleIntent为异步办法，能够执行耗时操作
二、IntentService的惯例应用套路
大略理解了IntentService的特点后，咱们就来理解一下它的应用形式，先看个案例：
IntentService实现类如下：

package com.zejian.handlerlooper;

import android.app.IntentService;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.IBinder;
import android.os.Message;

import com.zejian.handlerlooper.util.LogUtils;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;

/**

  • Created by zejian
  • Time 16/9/3.
  • Description:
    */

public class MyIntentService extends IntentService {

public static final String DOWNLOAD_URL="download_url";
public static final String INDEX_FLAG="index_flag";
public static UpdateUI updateUI;


public static void setUpdateUI(UpdateUI updateUIInterface){
    updateUI=updateUIInterface;
}

public MyIntentService(){
    super("MyIntentService");
}

/**
 * 实现异步工作的办法
 * @param intent Activity传递过去的Intent,数据封装在intent中
 */
@Override
protected void onHandleIntent(Intent intent) {

    //在子线程中进行网络申请
    Bitmap bitmap=downloadUrlBitmap(intent.getStringExtra(DOWNLOAD_URL));
    Message msg1 = new Message();
    msg1.what = intent.getIntExtra(INDEX_FLAG,0);
    msg1.obj =bitmap;
    //告诉主线程去更新UI
    if(updateUI!=null){
        updateUI.updateUI(msg1);
    }
    //mUIHandler.sendMessageDelayed(msg1,1000);

    LogUtils.e("onHandleIntent");
}
//----------------------重写一下办法仅为测试------------------------------------------
@Override
public void onCreate() {
    LogUtils.e("onCreate");
    super.onCreate();
}

@Override
public void onStart(Intent intent, int startId) {
    super.onStart(intent, startId);
    LogUtils.e("onStart");
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    LogUtils.e("onStartCommand");
    return super.onStartCommand(intent, flags, startId);

}

@Override
public void onDestroy() {
    LogUtils.e("onDestroy");
    super.onDestroy();
}

@Override
public IBinder onBind(Intent intent) {
    LogUtils.e("onBind");
    return super.onBind(intent);
}


public interface UpdateUI{
    void updateUI(Message message);
}


private Bitmap downloadUrlBitmap(String urlString) {
    HttpURLConnection urlConnection = null;
    BufferedInputStream in = null;
    Bitmap bitmap=null;
    try {
        final URL url = new URL(urlString);
        urlConnection = (HttpURLConnection) url.openConnection();
        in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);
        bitmap= BitmapFactory.decodeStream(in);
    } catch (final IOException e) {
        e.printStackTrace();
    } finally {
        if (urlConnection != null) {
            urlConnection.disconnect();
        }
        try {
            if (in != null) {
                in.close();
            }
        } catch (final IOException e) {
            e.printStackTrace();
        }
    }
    return bitmap;
}

}
通过代码能够看出，咱们继承了IntentService，这里有两个办法是必须实现的，一个是构造方法，必须传递一个线程名称的字符串，另外一个就是进行异步解决的办法onHandleIntent(Intent intent) 办法，其参数intent能够附带从activity传递过去的数据。这里咱们的案例次要利用onHandleIntent实现异步下载图片，而后通过回调监听的办法把下载完的bitmap放在message中回调给Activity（当然也能够应用播送实现），最初通过Handler去更新UI。上面再来看看Acitvity的代码：

activity_intent_service.xml

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”

android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">

<ImageView
    android:id="@+id/image"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

</LinearLayout>
IntentServiceActivity.java

package com.zejian.handlerlooper.util;

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.ImageView;

import com.zejian.handlerlooper.MyIntentService;
import com.zejian.handlerlooper.R;

/**

  • Created by zejian
  • Time 16/9/3.
  • Description:
    */

public class IntentServiceActivity extends Activity implements MyIntentService.UpdateUI{

/**
 * 图片地址汇合
 */
private String url[] = {
        "https://img-blog.csdn.net/20160903083245762",
        "https://img-blog.csdn.net/20160903083252184",
        "https://img-blog.csdn.net/20160903083257871",
        "https://img-blog.csdn.net/20160903083257871",
        "https://img-blog.csdn.net/20160903083311972",
        "https://img-blog.csdn.net/20160903083319668",
        "https://img-blog.csdn.net/20160903083326871"
};

private static ImageView imageView;
private static final Handler mUIHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        imageView.setImageBitmap((Bitmap) msg.obj);
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_intent_service);
    imageView = (ImageView) findViewById(R.id.image);

    Intent intent = new Intent(this,MyIntentService.class);
    for (int i=0;i<7;i++) {//循环启动工作
        intent.putExtra(MyIntentService.DOWNLOAD_URL,url[i]);
        intent.putExtra(MyIntentService.INDEX_FLAG,i);
        startService(intent);
    }
    MyIntentService.setUpdateUI(this);
}

//必须通过Handler去更新，该办法为异步办法，不可更新UI
@Override
public void updateUI(Message message) {
    mUIHandler.sendMessageDelayed(message,message.what * 1000);
}

}
代码比较简单，通过for循环屡次去启动IntentService，而后去下载图片，留神即便咱们屡次启动IntentService，但IntentService的实例只有一个，这跟传统的Service是一样的，最终IntentService会去调用onHandleIntent执行异步工作。这里可能咱们还会放心for循环去启动工作，而实例又只有一个，那么工作会不会被笼罩掉呢？其实是不会的，因为IntentService真正执行异步工作的是HandlerThread+Handler，每次启动都会把下载图片的工作增加到附丽的音讯队列中，最初由HandlerThread+Handler去执行。好~，咱们运行一下代码：

每距离一秒去更新图片，接着咱们看一组log：

  从Log能够看出onCreate只启动了一次，而onStartCommand和onStart屡次启动，这就证实了之前所说的，启动屡次，但IntentService的实例只有一个，这跟传统的Service是一样的，最初工作都执行实现后，IntentService主动销毁。以上便是IntentService德应用形式，怎么样，比较简单吧。接着咱们就来剖析一下IntentService的源码，其实也比较简单只有100多行代码。
三、IntentService源码解析
咱们先来看看IntentService的onCreate办法：

@Override
public void onCreate() {
// 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 + “]”);
thread.start();

mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}
当第一启动IntentService时，它的onCreate办法将会被调用，其外部会去创立一个HandlerThread并启动它，接着创立一个ServiceHandler（继承Handler），传入HandlerThread的Looper对象，这样ServiceHandler就变成能够解决异步线程的执行类了（因为Looper对象与HandlerThread绑定，而HandlerThread又是一个异步线程，咱们把HandlerThread持有的Looper对象传递给Handler后，ServiceHandler外部就持有异步线程的Looper，天然就能够执行异步工作了），那么IntentService是怎么启动异步工作的呢？其实IntentService启动后还会去调用onStartCommand办法，而onStartCommand办法又会去调用onStart办法，咱们看看它们的源码：

@Override
public void onStart(Intent intent, int startId) {

Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);

}

/**

  • 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) {

onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;

}
从源码咱们能够看出，在onStart办法中，IntentService通过mServiceHandler的sendMessage办法发送了一个音讯，这个音讯将会发送到HandlerThread中进行解决（因为HandlerThread持有Looper对象，所以其实是Looper从音讯队列中取出音讯进行解决，而后调用mServiceHandler的handleMessage办法），咱们看看ServiceHandler的源码：

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

}
}
这里其实也阐明onHandleIntent的确是一个异步解决办法（ServiceHandler自身就是一个异步解决的handler类），在onHandleIntent办法执行完结后，IntentService会通过 stopSelf(int startId)办法来尝试进行服务。这里采纳stopSelf(int startId)而不是stopSelf()来进行服务，是因为stopSelf()会立刻进行服务，而stopSelf(int startId)会期待所有音讯都解决完后才终止服务。最初看看onHandleIntent办法的申明：

protected abstract void onHandleIntent(Intent intent);
到此咱们就晓得了IntentService的onHandleIntent办法是一个形象办法，所以咱们在创立IntentService时必须实现该办法，通过下面一系列的剖析可知，onHandleIntent办法也是一个异步办法。这里要留神的是如果后台任务只有一个的话，onHandleIntent执行完，服务就会销毁，但如果后台任务有多个的话，onHandleIntent执行完最初一个工作时，服务才销毁。最初咱们要晓得每次执行一个后台任务就必须启动一次IntentService，而IntentService外部则是通过音讯的形式发送给HandlerThread的，而后由Handler中的Looper来解决音讯，而Looper是按程序从音讯队列中取工作的，也就是说IntentService的后台任务时程序执行的，当有多个后台任务同时存在时，这些后台任务会按内部调用的程序排队执行，咱们后面的应用案例也很好阐明了这点。最初贴一下到IntentService的全副源码，大家再次感受一下：

/*

  • Copyright (C) 2008 The Android Open Source Project
    *
  • Licensed under the Apache License, Version 2.0 (the “License”);
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at
    *
  • http://www.apache.org/license…
    *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an “AS IS” BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License.
    */

package android.app;

import android.annotation.WorkerThread;
import android.content.Intent;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;

/**

  • IntentService is a base class for {@link Service}s that handle asynchronous
  • requests (expressed as {@link Intent}s) on demand. Clients send requests
  • through {@link android.content.Context#startService(Intent)} calls; the
  • service is started as needed, handles each Intent in turn using a worker
  • thread, and stops itself when it runs out of work.
    *
  • <p>This “work queue processor” pattern is commonly used to offload tasks
  • from an application’s main thread. The IntentService class exists to
  • simplify this pattern and take care of the mechanics. To use it, extend
  • IntentService and implement {@link #onHandleIntent(Intent)}. IntentService
  • will receive the Intents, launch a worker thread, and stop the service as
  • appropriate.
    *
  • <p>All requests are handled on a single worker thread — they may take as
  • long as necessary (and will not block the application’s main loop), but
  • only one request will be processed at a time.
    *
  • <div class=”special reference”>
  • <h3>Developer Guides</h3>
  • <p>For a detailed discussion about how to create services, read the
  • Services developer guide.</p>
  • </div>
    *
  • @see android.os.AsyncTask
    */

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

/**
 * 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) {
    super();
    mName = name;
}

/**
 * Sets intent redelivery preferences.  Usually called from the constructor
 * with your preferred semantics.
 *
 * <p>If enabled is true,
 * {@link #onStartCommand(Intent, int, int)} will return
 * {@link Service#START_REDELIVER_INTENT}, so if this process dies before
 * {@link #onHandleIntent(Intent)} returns, the process will be restarted
 * and the intent redelivered.  If multiple Intents have been sent, only
 * the most recent one is guaranteed to be redelivered.
 *
 * <p>If enabled is false (the default),
 * {@link #onStartCommand(Intent, int, int)} will return
 * {@link Service#START_NOT_STICKY}, and if the process dies, the Intent
 * dies along with it.
 */
public void setIntentRedelivery(boolean enabled) {
    mRedelivery = enabled;
}

@Override
public void onCreate() {
    // 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 + "]");
    thread.start();

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

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

/**
 * 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) {
    onStart(intent, startId);
    return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}

@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) {
    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)}.
 */
@WorkerThread
protected abstract void onHandleIntent(Intent intent);

}
此IntentService的源码就剖析完了，嗯，本篇完结。

本文转自 https://blog.csdn.net/javazej…，如有侵权，请分割删除。

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章