- AsyncTask
- HandlerThread
- IntentService
- android中的线程池
android 中的多线程主要通过Thread Handler 来完成,它提供了几种形态：AsyncTask、HandlerThread、IntentService，下面一 一介绍。
1、AsyncTask
它是一种轻量级的异步任务类，可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程并在主线程中更新UI。从实现上来说，AsyncTask封装了Thread 和Handler,通过AsyncTask可以更加方便的执行后台任务以及在主线程中处理UI，但是AsyncTask并不适合进行特别耗时的后台任务，对于这些耗时的任务建议使用线程池。AsyncTask在使用过程中有条件限制，主要有如下几点：
（1）AsyncTask类必须在主线程中加载。
因为AsyncTask里面有个一静态的Handler对象，为了能够将执行环境切换到主线程，这就要求Handler必须在主线程中创建，所以AsyncTask必须在主线程中进行类加载。
（2）AsyncTask的对象必须在主线程中创建。
（3）execute 方法必须在UI线程调用。
（4）一个AsyncTask对象只能执行一次，即只能调用一次execute方法，否则报运行时异常。
（5）在Android1.6之前，AsyncTask是串行执行任务的，Android1.6的时候AsyncTask开始使用线程池处理并行任务，但是从Android3.0开始，为了避免AsyncTask所带来的并发错误，AsyncTask又采用一个线程串行执行任务。尽管如此，在Android3.0以及后续的版本中，我们仍然可以通过AsyncTask的executeOnExecutor方法来并行地执行任务。
2、HandlerThread
HandlerThread继承了Thread，它是一种可以使用Handler的Thread,它的实现也很简单，就是run方法中通过Looper.prepare()来 创建消息队列，并通过Looper.loop()来开启消息循环，这样在实际使用中就允许在HandlerThread中创建Handler了。其run方法如下所示：
@Overridepublic void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
HandlerThread因为在内部创建了一个消息队列，所以需要在外部通过Handler发送消息通知HandlerThread执行一个具体的任务，其应用场景如下：
1、构建一个后台的Handler执行耗时操作
import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import org.json.JSONException;
import java.util.List;
/**
* 描述 具备后台线程和UI线程更新
*
* @author chenjinyuan
* @since 2013-12-2 上午9:45:00
*/
public abstract class BaseWorkerActivity extends BaseActivity {
protected HandlerThread mHandlerThread;
protected BackgroundHandler mBackgroundHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mHandlerThread = new HandlerThread("activity worker:" + getClass().getSimpleName());
mHandlerThread.start();
mBackgroundHandler = new BackgroundHandler(mHandlerThread.getLooper());
}
@Override
public void onDestroy() {
super.onDestroy();
if (mBackgroundHandler != null && mBackgroundHandler.getLooper() != null) {
mBackgroundHandler.getLooper().quit();
}
}
/**
* 处理后台操作
*/
protected abstract void handleBackgroundMessage(Message msg) throws JSONException;
/**
* 发送后台操作
*
* @param msg
*/
protected void sendBackgroundMessage(Message msg) {
if (mBackgroundHandler != null) {
mBackgroundHandler.sendMessage(msg);
}
}
/**
* 发送后台操作
*
* @param what
*/
protected void sendEmptyBackgroundMessage(int what) {
if (mBackgroundHandler != null) {
mBackgroundHandler.sendEmptyMessage(what);
}
}
// 后台Handler
@SuppressLint("HandlerLeak")
public class BackgroundHandler extends Handler {
BackgroundHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
try {
handleBackgroundMessage(msg);
} catch (JSONException e) {
e.printStackTrace();
}
}
}
}
2、IntentService封装了HandlerThread和Handler，这个在下一点会讲到。
注意：HandlerThread的run是一个无限循环，因此当明确不需要HandlerThread时，可以通过它的quit或者quitSafely方法来终止线程的执行。
3、IntentService
IntentService是一种特殊的Service，他继承了Service并且它是一个抽象类，因此必须创建它的子类才可以使用IntentService。IntentService封装了HandlerThread和Handler,这点可以从他的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是在onStartCommand中处理每个后台任务的Intent。在该方法中发送消息给ServiceHandler去处理，具体处理方法为：
@WorkerThreadprotected abstract void onHandleIntent(Intent intent);
是一个抽象方法，需要我们在子类中去实现。
4、android中的线程池
线程池的好处可以概括为一下三点：
- 重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。
- 能有效控制线程池的最大并发数，避免大量的线程之间因相互抢占系统资源而导致的阻塞现象。
- 能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。
Android中线程池的概念来源于Java中的Executor,Executor是一个接口，真正的线程池实现为ThreadPoolExecutor。ThreadPoolExecutor提供了一系列参数来配置线程池，主要为4类,在介绍这四类线程池之前先了解一下ThreadPoolExecutor。
ThreadPoolExecutor常用的构造方法：
public ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,threadFactory, defaultHandler);
}
corPoolSize
线程池的核心线程数，默认情况下，核心线程会在线程池中一直存活，即使他们处于闲置状态。如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，那么闲置的核心线程在等待新任务到来时会有超时策略，这个时间间隔有keepAliveTime所指定，当等待时间超过keepAliveTime所指定的时长后，核心线程就会被终止。
maximumPoolSize
线程池所能容纳的最大线程数。
keepAliveTime
非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收。当ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true时，keepAliveTime同样会作用于核心线程。
unit
用于指定keepAliveTime参数的时间单位，这是一个枚举，常用的有TimeUnit.MILLISECONDS(毫秒)、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）等。
workQueue
线程池中的任务队列，通过线程池的execute方法提交的Runnable对象会存储在这个参数中。
threadFactory
线程工厂，用来创建新的线程。它是一个接口，且它只有一个方法：Thread newThread(Runnable r)。
ThreadPoolExecutor执行任务时大致遵循如下规则：
（1） 如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行。
（2） 如果线程池中的线程数已经达到或者超过核心线程数，那么任务会被插入到任务队列中排队等待执行。
（3）如果在步骤2中无法将任务插入到任务队列中，这往往是由于任务队列已满，这时候如果线程池的线程数量没有达到规定的最大值，那么会立即启动一个非核心线程来执行任务。
(4) 如果步骤3中线程数量已经达到线程池规定的最大值，那么就拒绝执行此任务，ThreadPoolExecutor会调用RejectedExecutionHandler的rejectedExecution方法来通知调用者。
线程池的分类
Executors 中给我们提供了好几种线程池，他们都是通过Executors的newCacheThreadPool方法来创建的，常见的有以下四种：
1、FixedThreadPool
它是一种线程数量固定的线程池，它只有核心线程，并且当这些线程处在空闲状态时它不会被回收，除非线程池被关闭了，另外，任务队列也是没有大小限制的。
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads,nThreads,0L,TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(), threadFactory);
}
2、CachedThreadPool
它是一种线程数量不定的线程池，他只有非核心线程，并且其最大线程数为Integer.MAX_VALUE。实际上相当于最大线程数可以任意大。当线程池中的线程都处于活动状态时它会创建新的线程来执行，否则会利用闲置线程来处理任务，闲置线程 超时时间为60s，这时它的任务队列 相当于一个空集合。这类线程池适合执行大量的耗时较少的任务。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
3、ScheduledThreadPool
它的核心线程数是固定的，而非核心线程数是没有限制的，并且当非核心线程闲置时会被立即回收。这类线程主要用来执行定时任务和具有固定周期的重复任务。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 10, MILLISECONDS,
new DelayedWorkQueue());
}
4、SingleThreadExecutor
这类线程池内部只有一个核心线程，它确保所有任务都在同一线程中按顺序执行。SingleThreadExecutor的意义在于统一所有的外界任务到同一个线程中，这使得在这些任务之间不需要处理线程同步的问题。
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1,
0L,TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));
}
`以上资料参考《Android艺术开发探索》`
