Android 多线程

作者: android开发经验总结 | 来源:发表于2016-07-28 19:46 被阅读1130次

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

Android 多线程

1、AsyncTask

2、HandlerThread

3、IntentService

4、android中的线程池

corPoolSize

maximumPoolSize

keepAliveTime

unit

workQueue

threadFactory

1、FixedThreadPool

2、CachedThreadPool

3、ScheduledThreadPool

4、SingleThreadExecutor

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

安卓集中营

程序猿

技术

Android开发经验谈

首页投稿（暂停使用，暂停投稿）

Android开发

大牛聚集之地

Android开发