Android线程和线程池
- Android中的线程操作相关的类有
AsyncTask IntentService HandleThread
-
AsyncTask
AsyncTask必须在主线程中初始化
Android 3.0开始 AsyncTask默认使用串行方式执行任务队列，即单线程串行，但可定制线程池并行执行通过executOnExecutor()。
主要是SerialExcutor负责任务的排队，THREAD_POOL_EXCUTOR负责真正的任务执行。
executor()方法必须在UI线程中执行
一个AsyncTask对象只能执行一次，否则会报错
AsyncTask中有用到抽象工厂模式（多线程环境下工厂类创建线程）
AsyncTask中对任务包装主要是FutureTask
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。
-
HandleThread
继承自Thread,主要是内部创建了Looper，关联Looper，不用手动创建Thread中prepare Looper和loop了。
-
IntentService
一个抽象类，继承自Service
适用于执行后台耗时任务，任务停止后，Service自动停止
由于它是服务，它比其他线程优先级高很多，不容易被系统kill
内部它封装了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);
}
- IntentSerivce 通过调用startService传递Intent到onStartCommand，onStartCommand会通过Handle发送Message至IntentService内部的HandleThread中，根据Intent
中携带的参数，调用重写的onHandleIntent处理任务，onHandleIntent执行完毕后，执行stopSelf(startId)
这里为何调用stopSelf(startId) 它与stopSelf()区别
stopSelf(startId)不会立即停止当前Serivce,而是等待所有Intent都执行完毕后才会终止服务，每调用一次startService(Intent)都会调用一次onStartCommand传递Intent。
stopSelf()会立即停止服务
- 因为IntentService内部HandleThread的消息机制，所以，传递给IntentService的Intent任务也是顺序执行的。
Android中的线程池
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory)
corePoolSize: 核心线程数，默认情况下一直存活的线程，即使空闲状态下，如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，则闲置的线程在等待新任务到来时会有超时策略，超时时间由keepAliveTime来决定，当超时后，核心线程就会被终止
maximumPoolSize： 线程池所能容纳的最大线程数，当活动线程数达到这个数值后，后续的新任务将会被阻塞
keepAliveTime：非核心线程线程闲置时间超时时长。超过这个时长，线程将会被回收
unit：指定keepAliveTime所用的时间单位
workQueue：线程池中的任务队列，通过execute提交的Runnable对象会存储在这个队列中。
threadFactory：线程工厂，为线程池创建新的线程，为一个接口。
- ThreadpoolExecutor 执行任务大致规则：
- 如果线程池中的核心线程数未达到核心线程的数量，那么会启动核心线程来执行任务。
- 如果线程池中的线程数量已经达到或超过核心线程数量，那么新来的任务会被插入到任务队列中排队等待执行
- 如果在步骤2中无法将任务插入到任务队列，这是由于任务队列已经满了，这个时候如果线程数量未达到线程池规定的最大数量，那么会立刻启动一个非核心线程来执行任务。
- 如果步骤3中的线程数量已经达到线程池的最大值，则拒绝此任务，ThreadPoolExecutor会调用RejectedExecutionHandler的rejectExecution方法通知调用者。具体可以看源码.
- AsyncTask中的任务队列容量为128
- Android中四种常用的线程池：
-
FixedThreadPool
Executors.newFixedThreadPool()
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
线程数量固定，当线程处于空闲时，线程并不会被回收，除非线程池关闭，当所有线程处于活动状态时，新任务就会处于等待状态，直到有线程空闲下来.
由于FixedThreadPool只有核心线程，并且不会被♻️，所以它会更加快速的响应外界的请求。没有超时机制，任务队列大小也没闲置。
-
CachedThreadPool
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
threadFactory);
它是一个线程数量不固定的线程池，当线程池中的线程都处于活动状态，线程池会创建新的线程来处理任务，否者就会利用空闲的线程来处理新任务
空闲的线程超过60秒就会被回收
SynchronousQueue很特殊，无法存储元素的队列。
该线程池适合大量耗时较少的任务，当整个线程池中的线程都处于空闲状态时，线程会因超时而被♻️，这时它几乎不占用任何资源
- ScheduledThreadPoolExecutor
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, ThreadFactory threadFactory) {
return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
public ScheduledThreadPoolExecutor(int corePoolSize,
ThreadFactory threadFactory) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue(), threadFactory);
}
核心线程数固定，非核心线程数没有限制，当非核心线程空闲会被立刻回收
适合执行定时任务和有固定周期的重复任务
参考最后使用示例
- SingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
只有一个核心线程，所有的任务都会放到一个线程中去顺序执行
它统一了所有的外界任务到一个线程中，使得这些任务不需要处理线程间的同步问题。
- 使用示例
Runnable command = new Runnable() {
@Override
public void run() {
SystemClock.sleep(1000);
}
};
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
fixedThreadPool.execute(command);
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
cachedThreadPool.execute(command);
//2000ms后执行command
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
scheduledExecutorService.schedule(command, 2000, TimeUnit.MILLISECONDS);
//延迟10ms后执行，以后每隔1000ms执行一次command
scheduledExecutorService.scheduleAtFixedRate(command, 10, 1000, TimeUnit.MILLISECONDS);
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
singleThreadExecutor.execute(command);
