这一章比较有趣，说的是线程和线程池，线程在Android中是一个很重要的概念，他分为主线程和子线程，主线程负责UI操作，子线程负责耗时操作，由于Android的特性，主线程耗时过长就会无响应，因此耗时操作必须放在子线程中去执行，除了Thread本身之外，Android自身还有一些线程类，比如AsyncTask和IntentService,像HandlerThread也算是一种特殊的线程，尽管AsyncThread来说，他的底层用到了线程池，对于IntentService和HandlerThread来说，他们的底层则直接使用了线程。
不同形式的线程池虽然都是线程，但是他们仍然具有不同的特性和使用场景，AsyncTask封装了线程池和Handler，他主要是为了方便开发者在线程中更新UI，HandlerThread是一种具有消息循环的线程，在他的内部可以使用Handler，IntentService是一个服务，系统对其进行了封装使其可以更方便的执行后台任务，IntentService内部采用了HandlerThread来执行任务，当任务完成后IntentService就会自动退出，从任务执行的角度来看，IntentService的作用很像一个后台进程，由于这个时候进程中没有活动的四大组件，那么这个进程的优先级会非常低，会很容易被系统杀死，这就是IntentService的优点。
在操作系统中，线程是操作系统最小的单元，同时线程又是一种受限的系统资源，即线程不可能无限制的产生，并且线程的创建和销毁都会有相应的开销，当系统中UC你在大量的线程时，系统会通过时间片轮转的方式来调度线程，因此线程不可能做到并行，除非线程数量小于等于CPU的核心数，这显然不是高效的做法，正确的做法是采用线程池，一个线程池可以缓存一定数量的线程，通过线程池就可以避免因为频繁创建和销毁线程所带来的系统开销，Android中的线程池来源于Java,主要是通过Executor来派生特定类型的线程池，不同种类的线程池又具有各自的特点。
一.主线程和子线程
主线程是指进程所拥有的线程，在JAVA中默认情况下一个进程只有一个线程，这个线程就是主线程，主线程主要处理界面交互相关的逻辑，因为用户随时会和界面发生交互，因此主线程在任何时候都必须有较高的效应速度，否则会产生一种界面卡顿的感觉，为了保持较高的相应速度，这就要求主线程中不能执行耗时任务，这个时候子线程就派上用处了。
Android沿用了Java的线程模式，其中的线程也分为主线程和子线程，其中主线程也叫UI线程，主线程的作用是运行四大组件以及处理他们的用户交互，而子线程的作用则是耗时任务，比如网络请求，IO操作等，从Android3.0开始系统要求网络访问必须在子线程中，这是避免主线程由于耗时操作所阻塞出现ANR现象。
二.Android中的线程形态
除了传统的Thread以外，还包含了AsyncTask，HandlerThread以及IntentService,这三者的底层实现也是线程，但是他们具有特殊的表现形式，同时在使用上也各有优缺点，我们接下来就分析下他们的使用过程
1.AsyncTask
AsyncTask是一种轻量级的异步任务类，他可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程并在主线程中更新UI，从实现上说，AsyncTask封装了Thread和Handler，通过AsyncTask我们更加方便的执行后台任务以及主线程访问UI，但是AsyncTask并不适合进行特别耗时的后台任务，这里建议线程池。
AsyncTask是一个抽象的泛型类，他提供了Params,Progress和Result这三个泛型参数，其中Params表示参数的类型，Progress表示后台任务的执行进度，Result表示结果的类型，如果AsyncTask确实不需要传递具体的参数，那么可以用Void来代替，AsyncTask这个类的声明如下
public abstract class AsyncTask<Params, Progress, Result>
AsyncTask提供了4个核心方法，他们的含义是
- onPreExecute
- 在主线程执行，在异步任务执行之前被调用，一般用于一些准备工作
- doInBackground
- 在线程池中执行，此方法用于执行异步任务，params参数表示异步任务的输入参数，在此方法中可以通过publishProgress方法来更新任务的进度，publishProgress会调用onProgressUpdate方法，此外此方法需要返回计算结果给onPostExecute
- onProgressUpdate
- 在主线程执行，异步任务结束后调用，返回结果
- onPostExecute
- 在主线程中执行，在异步任务结束后，此方法被调用，其中result参数是后台任务的返回值
上面几个方法，onPreExecute先执行，接着是doInBackground，最后才是onPostExecute，他还提供了一个onCancelled方法，他同样在主线程中执行，当异步任务被取消时，onCancelled就会被调用，这个时候onPostExecute就不会被调用，看例子
class DownloadTask extends AsyncTask<URL,Integer,Long>{
@Override
protected Long doInBackground(URL... urls) {
int count = urls.length;
long totalSize = 0;
for (int i = 0; i < totalSize; i++) {
totalSize += DownLoad.downloadFile(urls[i]);
publicProgress((int)((i / (float)count)*100));
if(isCancelled()){
break;
}
}
return totalSize;
}
@Override
protected void onProgressUpdate(Integer... values) {
setProgressPercent(values[0]);
}
@Override
protected void onPostExecute(Long aLong) {
showDialog(aLong);
}
}在上面的代码中实现了一个下载逻辑，他的输入参数是URL，后台任务的进程参数是Integer，而后台返回是Long类型，注意到doInBackground和onProgressUpdate方法他们的参数包含…字样，在JAVA中表示参数的数量不定，踏实一种数组型参数，我们可以这样执行
new DownloadTask().execute(url1,url2,url3);在DownloadTask中，doInBackground用来执行具体的下载任务并通过onProgressUpdate来更新进度，同时还要判断下载任务是否被外界取消了，下载任务完成后会返回结果
但是在使用的过程中，AsyncTask还是有一些条件限制：
1.AsyncTask的类必须在主线程加载，也就意味着第一次访问AsyncTask必须发生在主线程，当然这个过程在Android4.1之后已经被系统自动完成了，在Android5.0的源码中，可以看到ActivityThread的main方法，他会调用AsyncTask的init，这就满足了他必须在主线程中加载的条件
2.AsyncTask的对象必须在主线程创建
- 3.execute方法必须在UI线程调用
- 4.不要再程序中直接使用它的方法
- 5.一个AsyncTask对象只能执行一次，否则会报错
- 6.在Android1.6之前，AsyncTask是串行执行任务，之后采用线程池并行处理，从Android3.0开始，为了避免AsyncTask所带来的并发错误，AsyncTask又采用一个线程来串行任务，尽管如此，在Android3.0以及以后的版本中，我们也可以通过AsyncTask的executteOnExecutor方法来并行的执行任务。
2.AsyncTask的工作原理
为了分析AsyncTask的工作原理，我们从execute开始分析
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}在上面的代码中，sDefaultExecutor实际上是一个串行的线程池，一个进程中所有的AsyncTask全部在这个串行的的线程池中排队执行，这个过程后面会说明，这个方法中，onPreExecute方法最先执行，然后线程池开始执行，下面分析下线程池的执行过程：
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
从SerialExecutor的实现可以分析AsyncTask的排队执行的过程，首先系统会把AsyncTask的Params参数封装为FutureTask对象，FutureTask是一个并发类，在这里他充当了Runnable的作用，接着这个FutureTask会交给SerialExecutor的execute方法去处理，SerialExecutor的execute会将FutureTask对象插入到任务列表的mTask中，如果这个方法没有正在活动的AsyncTask任务，那么就会调用SerialExecutor的scheduleNext的方法来执行下一个AsyncTask任务，同时当一个AsyncTask任务执行后，AsyncTask会继续执行其他任务直到任务都被执行完为止，从这一点可以看出，AsyncTask是串行。
AsyncTask中有两个线程池（SerialExecutor和THREAD_POOL_EXECUTOR）和一个Handler，其中线程池SerialExecutor用于任务的排队，而线程池THREAD_POOL_EXECUTOR用于真正的执行任务，IntentalHandler用于将执行幻境从线程池切换到主线程，关于线程池的概念后面会说道，其本质仍然是线程的调用mWorker的call方法，因此mWorker的call方法最终会将线程池中执行。
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};在mWorker的call方法里，首先将mTaskInvoked设置为true,表示当前任务已经被调用过了，然后执行AsyncTask的doInBackgroup方法，接着将其返回值传递给postResult方法，他的实现如下：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}postResult会通过sHandler发送给一个MESSAGE_POST_RESULT
private static class InternalHandler extends Handler {
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult result = (AsyncTaskResult) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
可以发现，InternalHandler是一个静态的Handler对象，为了能够将执行环境切换到主线程，这就是要求sHandler这个对象必须在主线程创建，由于静态成员会在加载类的时候进行初始化，因此这就变相要求AsyncTask的类必须在主线程加载，否则无法工作，同时sHandler收到MESSAGE_POST_RESULT这个消息后会调用AsyncTask的finish方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}这个finish的逻辑比较简单，如果AsyncTask被取消执行了，那么就会调用onCancelled方法，窦泽就会调用onPostExecute，这样整个工作过程就完毕了
我们来看下实验，点击按钮同时启动五个AsyncTask任务，每一个会休眠3s来模拟耗时操作，同时把每个AsyncTask执行结束的时间打印出来，我们来看下
case R.id.btnAsync:
new MyAsyncTask("#1").execute("");
new MyAsyncTask("#2").execute("");
new MyAsyncTask("#3").execute("");
new MyAsyncTask("#4").execute("");
new MyAsyncTask("#5").execute("");
break;
}
}
class MyAsyncTask extends AsyncTask<String,Integer,String>{
private String sName = "AsyncTask";
public MyAsyncTask(String sName) {
this.sName = sName;
}
@Override
protected String doInBackground(String... strings) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return sName;
}
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Log.i(TAG,df.format(new Date()) + "");
}
}
}
我们来看下他的打印：
我们可以看到，每隔3s打印，很明显是串行的，但是如果运行在2.3的设备，就会发现是并行的，为了让AynscTask可以在Android3.0及以上的版本并行，可以采用AsyncTask的executeOnExecutor方法，需要注意的是这个方法是3.0新加的，并不能在低版本使用
3.HandlerThread
HandlerThread 继承了Thread，踏实一种可以使用Handler的Thread，他的实现也很简单，就是在run方法中通过Looper.prepare来创建消息队列，并通过loop来开启消息循环，这样在实际的使用中就允许在HandlerThread中创建Handler了，HandlerThread的run如下：
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}从HandlerThread的实现来看，他和普通的Thread有显著的不同之处，普通Thread主要用于在run方法中执行一个耗时操作，而HandlerThread在内部创建了消息队列，外界需要通过Handler的消息方式来通知HandlerThread执行一个具体的任务，HandlerThread是一个很有用的类，他在Android中的一个具体的使用场景是IntentService，IntentService将在稍后介绍，由于HandlerThread的run方法是一个无限循环，因此当明确不需要再使用HandlerThread时，可以通过他的quit或者quitSafely方法来终止线程的执行，这是一个良好的习惯。
4.IntentService
IntentService是一个特殊的Service,他继承了Service并且它是一个抽象类，因此必须创建他的子类才能使用IntentService，IntentService可用于执行后台耗时的任务，当任务执行后他会自动停止，同时由于IntentService是服务的原因，这导致他的优先级比单纯的线程要高很多，所以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第一次启动的时候，onCreate会创建一个HandlerThread，然后使用它的Looper来构造一个Handler对象mServiceHandler，这样通过mServiceHandler发送的消息最终都会在HandlerThread中执行，从这个角度来看，IntentService也可以用于执行后台任务，每次启动onstartCommon都会执行一次，所以在这里执行每一个后台任务的Intent，下面我们看下具体的处理：
@Override
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}可以看出，这里只是发送一个一个消息，这个消息会在HandlerThread中处理，mServiceHandler收到消息后，会将Intent对象传递给onHandlerIntent方法去处理，注意这个Intent对象的内容和外界的startService中的intent是完全一致的，通过这个Intent对象可以解析出外界启动IntentService所传递的参数，通过这些参数可以区分具体的任务，当onHandleIntent方法结束之后，IntentService会通过stopSelf方法来尝试停止服务，这里之所以采用stopSelf（int id）而不会stopSelf是因为stopSelf会立刻停止服务，而这个时候可能还有任务没有执行完成，stopSelf（int id）会让所有任务都完成后才执行的，这个策略可以从AMS的stopServiceToken方法的实现来找到依旧，我们看源码：
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);
}
}
IntentService的onHandleIntent方法是一个抽象方法，他需要我们在子类中实现，他的作用是从Intent参数中区分具体的任务并执行这些任务，如果目前只存在一个后台任务，那么onHandlerIntent方法执行完之后，stopSelf(int id)就会直接停止服务，如果目前存在多个后台任务，那么当onHandleIntent方法执行完最后一个任务时，stopSelf(int id)才会停止服务，另外由于每执行一个后台任务就必须启动一次IntentService，而IntentService内部则通过消息的方式向HandlerThread请求执行任务，Handler中的Looper是顺序处理消息的，这就意味着IntentService也是顺序执行的，当有多个后台任务时同时存在的，这些后台任务会按照外界发起的顺序排队执行。
下面通过一个案例来说明IntentService的工作方式，首先派生一个IntentService的子类，比如LocalIntentService
public class LocalIntentService extends IntentService {
private static final String TAG = "LocalIntentService";
public LocalIntentService() {
super(TAG);
}
@Override
protected void onHandleIntent( Intent intent) {
String action = intent.getStringExtra("task_action");
Log.i(TAG,"receiver action:" + action);
SystemClock.sleep(3000);
if("com.lgl.test.ACTION".equals(action)){
Log.i(TAG,"handler action:" + action);
}
}
@Override
public void onDestroy() {
Log.i(TAG,"onDestroy");
super.onDestroy();
}
}
三.Android中的线程池
线程池的好处很多，优先有如下几点
- 1.重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销
- 2.能有效控制线程池的最大并发数，避免大量的县城之间因互相抢占系统资源而导致的阻塞现象
- 3.能够对线程进行简单的管理，并提供定时执行以及指定间隔循环等能力
Android中的线程池的概念来源于JAVA中的Executor，Executor是一个接口，真正的线程池实现为ThreadPoolExecutor，ThreadPoolExecutor提供了一系列参数来配置线程池，通过不同的参数可以创建不同的线程池，从线程池的功能特性上来说，Android的线程池主要分为四类，都是通过Executor提供的工厂方法得到的，我们下面来细讲：
1.ThreadPoolExecutor
ThreadPoolExecutor是线程池的真正实现，他的构造方法提供了一系列的参数来配置，我们来看下
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue
ThreadFactory threadFactory) {- corePoolSize
- 线程池的核心线程数，默认情况下，核心线程会在线程池中一直存活，即使他们处于闲置状态，如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true,那么闲置的核心线程在等待新任务到来时就会有超市策略，这个间隔由keepAliveTime指定，当等待时间超过keepAliveTime所指的时长后，核心线程就会被终止
- maximumPoolSize
- 线程池所容纳最大的线程数，当活动线程数达到这个数值后，后续的新任务将会被阻塞
- keepAliveTime
- 非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收，当ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true时，keepAliveTime同样会作用于核心线程
- unit
- 用于指定keepAliveTime参数的时间单位，这是一个枚举，常用的有TimeUnit,毫秒，秒，分钟等
- workQueue
- 线程池的任务队列，通过线程池的execute方法提交的Runnable对象会存储在这个参数中
- threadFactory
- 线程工厂，为线程池提供创建新线程的功能，ThreadFactory是一个接口，他只有一个方法，Thread new Thread(Runnable r)
除了上面的一些主要参数外，ThreadPoolExecutor还有一个不常见的参数，RejectedExecutionHandler handler，当线程池无法执行新任务时，这可能是由于任务队列已满或者是无法成功执行任务，这个时候ThreadPoolExecutor会调用handler的RejectedExecutionHandler方法来通知调用者，默认情况下，RejectedExecutionHandler方法会直接抛出一个异常。
ThreadPoolExecutor执行任务时大致遵守如下规则：
- 1.如果线程池中的线程数量未达到核心线程的数量，那么直接启动一个核心线程来执行任务
- 2.如果线程池中的线程数量已经达到或者超过核心线程的数量，那么任务会被插入到任务队列中排队等待执行
- 3.如果在步骤2中无法将任务插入到任务队列中，这往往是由于任务队列已满，这个时候如果线程数量未达到线程池规定的最大值，那么会立刻启动一个非核心线程来执行任务。
- 4.如果步骤3中线程数量已经达到线程池规定的最大数量，那么就会拒绝执行此任务，ThreadPoolExecutor会调用RejectedExecutionHandler的rejectedExecution方法来通知调用者
ThreadPoolExecutor的参数配置在AsyncTask中有明显的提现，下面是AsyncTask的线程池的配置情况：
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
@Override
public Thread newThread(Runnable runnable) {
return new Thread(runnable, "AsyncTask #" + mCount.getAndIncrement());
}
};
private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingDeque<Runnable>(128);
public static final Executor THREAD_POOL_EXECUTOR =
new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);从上面的代码可以知道，AsyncTask对THREAD_POOL_EXECUTOR这个线程池进行了配置，配置后的线程池规格如下：
- 核心线程数等于CPU核心数 + 1
- 线程池的最大线程数为CPU核心数的2倍+1
- 核心线程无超时机制，非核心线程的限制时超时时间为1s
- 任务队列的容量为128
2.线程池的分类
我们有四个不同用途的线程池，一起来看下
- FixedThreadPool
- 通过Executors的newFixedThreadPool方法来创建，他是一种线程数量固定的线程池，当线程池处于空闲的状态时，他们并不会被回收，除非线程池被关闭了，当所有的线程池都处于活动状态时，新任务都处于等待状态，直到有线程空闲出来，由于FixedThreadPool只有核心线程并且只有核心线程不会被回收，这意味着他能够更快加速的相应外界的请求，newFixedThreadPool方法的实现如下，可以发现FixedThreadPool中只有核心线程并且这些核心线程没有超时机制，另外任务大小也是没有限制的：
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory);
}- 2.CachedThreadPool
通过Executors的newCachedThreadPooll来创建，这是一种线程数量不定的线程池，他只有非核心线程，并且其最大线程数为Integer.MAX_VALUE,由于Integer.MAX_VALUE是一个很大的数，实际上就相当于最大线程数可以任意大，当线程池中的线程都处于活动状态的时候，线程池会创建新的线程来处理新任务，否则就会利用空闲的线程来处理新任务，线程池的空闲线程都有超时机制，这个超时机制为60秒，超过就会被回收，和上面不同的事，CachedThreadPool的任务队列其实相当于一个空集合，这就导致任何任务都会立即被执行，因为在这种场景下，SynchronousQueue是无法插入任务的，SynchronousQueue是一个非常特殊的队列，在很多情况下可以把他简单理解为一个无法存储的元素队列，由于他在实际中较少使用，这里就不深入探讨它了，从SynchronousQueue的特性来看，这类线程池比较适合执行大量的耗时较少的任务，当整个线程池属于闲置状态的时候，线程池中的线程都会超时而被停止，这个时候CachedThreadPool之中实际上是没有任何线程，他几乎是不占用任何资源的，newCachedThreadPool的方法如下：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}- 3.ScheduleThreadPool
通过ScheduleThreadPool方法来创建，他的核心线程数量是固定的，而非核心线程是没有限制id，并且当非核心线程闲置时会立即回收，ScheduleThreadPool这类主要用于定时任务和具有固定周期的重复任务：
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1));
}- 4.SingleTheardExecutor
通过newSingleTheardExecutor创建，内部只有一个核心线程，确保所有的任务都在同一个线程按顺序执行，SingleTheardExecutor的意义是统一所有的外界任务到同一个线程中，这使得这些任务之间不需要处理线程同步的问题
public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1, threadFactory));
}下面我们来演示一下这些使用方法
Runnable common = new Runnable() {
@Override
public void run() {
SystemClock.sleep(2000);
}
};
ExecutorService fix = Executors.newFixedThreadPool(4);
fix.execute(common);
ExecutorService cache = Executors.newCachedThreadPool();
fix.execute(common);
ScheduledExecutorService schedu = Executors.newScheduledThreadPool(4);
schedu.schedule(common,2000,TimeUnit.MICROSECONDS);
schedu.scheduleAtFixedRate(common,10,1000,TimeUnit.MICROSECONDS);
ExecutorService single = Executors.newSingleThreadExecutor();
single.execute(common);谢谢！