Android 多线程

AsyncTaskHandlerThreadIntentServiceandroid中的线程池

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艺术开发探索》`