Android的线程和线程池

作者: Lucida_star | 来源:发表于2018-05-14 17:31 被阅读76次

Android线程池的使用
Android的线程和线程池
笔记：Android线程和线程池
线程池创建和相关知识
Android面试之线程和线程池
<> Chapter 11
Android 的线程和线程池
线程池
要点提炼|开发艺术之线程
Android 开发艺术探索读书笔记 11 -- Android

微信公众号：Lucidastar
如有问题或建议，请公众号留言
最近更新：2018-05-14

今天我们通过提问问题的方式来进行学习，主要是分析AsyncTask类，HandlerThread类，IntentService类及ThreadPoolExecutor类
1、线程和线程池的概念？
在操作系统中，线程是操作系统调度的最小单元。线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。
2、AsyncTask是什么？
是一种轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程并在主线程中更新UI。
3、AsyncTask的使用？
AsyncTask是一个抽象类，我们需要继承他实现它的抽象方法。

private class MyAsyncTask extends AsyncTask<String,Integer,String> {
    private String mName = "AsyncTask";
    public MyAsyncTask(String name) {
        super();
        mName = name;
    }
    @Override
    protected void onPreExecute() {
        Log.d(TAG, "onPreExecute: ");
    }
    @Override
    protected void onPostExecute(String s) {
        Log.d(TAG, "onPostExecute: "+s);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Log.d(TAG, "onPostExecute: "+dateFormat.format(new Date()));
        mTextView.setText(mName);
    }
    @Override
    protected void onProgressUpdate(Integer... values) {
        Log.d(TAG, "onProgressUpdate: ");
    }
    @Override
    protected void onCancelled(String s) {
        Log.d(TAG, "onCancelled: ");
    }
    @Override
    protected void onCancelled() {
        Log.d(TAG, "onCancelled: ");
    }
    @Override
    protected String doInBackground(String... strings) {
        Log.d(TAG, "doInBackground: "+strings);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return mName;
    }
}
new MyAsyncTask("ceshi").execute("");

4、AsyncTask的注意事项？

它并不适合进行特别耗时的后台任务，对于特别耗时的任务来说，建议使用线程池。
AsyncTask必须在主线程中加载
execute方法必须在UI线程调用
不要在程序中直接调用onPreExecute(),onPostExecute(),doInBackground()和onProgressUpdate方法。
在Android1.6之前AsyncTask是串行执行的，Android1.6的时候AsyncTask采用线程池并行执行，但是从Android3.0开始，为了避免AsyncTask所带来的并发错误，又采用了一个线程来串行执行任务，我们仍可以通过AsyncTask的executeOnExecutor方法来执行并行任务。

5、AsyncTask的执行过程？（根据例子）
三个泛型参数：
Params表示参数的类型，Progress表示后台任务的执行进度的类型，Result表示的后台任务返回的结果。
根据上面例子，我们可以知道，AsyncTask提供了4个核心方法，如下

①onPreExecute(),在主线程中执行，在异步任务执行之前，此方法会被调用，一般可以用于做一些准备工作。
②doInBackground(Params...params)，此方法必须需要实现，在线程池中执行，用于执行异步任务，params参数表示异步任务的输入参数。在此方法中可以通过publishProgress方法来更新任务的进度，publishProgress方法会调用onProgressUpdate方法。另外此方法需要返回计算结果给onPostExecute方法。
③onProgressUpdate（Progress...values），在主线程中执行，当后台的执行进度发生改变时此方法会被调用。
④onPostExecute（Result result），在主线程中执行，在异步任务执行之后，此方法会被调用，其中result参数是后台任务的返回值，及DoInBackground的返回值。

6、AsyncTask的执行原理？（根据源码分析）
我们从它的execute方法开始，execute有调用了executeOnExecutor方法，如下

@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}
@MainThread
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();//这里回调了当开始AsyncTask时的方法
    mWorker.mParams = params;
    exec.execute(mFuture);
    return this;
}

sDefaultExecutor实际上是一个串行的线程池，一个进程中所有的AsyncTask全部在这个串行的线程池中排队执行

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);
        }
    }
}
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}//WorkerRunnable实现了Callable接口，

从源码中可以看出，系统会把AsyncTask的Params参数封装为FutureTask对象，FutureTask是一个并发类，充当Runnable的作用。接着这个FutureTask会交给SerialExecutor的execute方法去处理，SerialExecutor的execute方法首先会把FutureTask对象插入到任务对列mTask中，如果这个时候没有正在活动的AsyncTask任务，就会调用SerialExecutor的scheduleNext方法来执行下一个AsyncTask任务。

AsyncTask中有两个线程池（SerialExecutor和THREAD_POOL_EXECUTOR）和一个Handler（InteranlHandler），SerialExecutor用于任务的排队，THREAD_POOL_EXECUTOR用于真正执行任务，InternalHandler用于将执行环境从线程池中切换到主线程。

7、HandlerThread是什么及作用
HandlerThread继承了Thread，它是一种可以使用Handler的Thread，通过在Run方法中通过Looper.prepare()来创建消息队列，并通过Looper.loop（）来开启消息循环。
8、HandlerThread中创建的Handler的作用？
因为创建了一个Looper，一个消息队列，但我们需要把这些消息给发送出去来进行处理，当然我们也可以在外部创建一个Handler(IntentService就是这样干的)
9、IntentService的认识及简单实用
IntentService是一种特殊的Service，它可以执行后台耗时的任务，当执行完后会自动的停止，同时由于IntentService是服务的原因，这导致它的优先级比单纯的线程要高的多，所以比较适合执行一些高优先级的后台任务。
使用可以看这个例子
10、IntentService的执行流程及原理
首先来看onCreate()方法

@Override
public void onCreate() {
    super.onCreate();
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");//创建一个HandlerThread，也是一个线程
    thread.start();//开启线程
    mServiceLooper = thread.getLooper();//获取线程的Looper
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

private final class ServiceHandler extends Handler {//创建一个Handler
    public ServiceHandler(Looper looper) {
        super(looper);
    }
    @Override
    public void handleMessage(Message msg) {
        onHandleIntent((Intent)msg.obj);//在子线程中处理完任务后的回调。
        stopSelf(msg.arg1);
    }
}
@Override
public void onStart(@Nullable Intent intent, int startId) {
    Message msg = mServiceHandler.obtainMessage();
    msg.arg1 = startId;
    msg.obj = intent;
    mServiceHandler.sendMessage(msg);//传递过来一个消息放到子线程中的消息队列，并且开始轮询
}

每次startService()时，如果服务没有停止，然后就会回调onStart()方法，然后把任务放到send到子线程中进行处理
经过我的分析，等同如下：

Handler mHandler ;
Looper mLooper;
new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                mLooper = Looper.myLooper();
                Looper.loop();
            }
        }).start();
        try {
            Thread.sleep(2000);//这里做的意义，害怕子线程中mLooper还没有实例化好，睡两分钟再往下执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        mHandler = new Handler(mLooper){//子线程的Looper
            @Override
            public void handleMessage(Message msg) {
                if (msg.what == 0){
                    try {
//这里做一些耗时的操作，因为在创建handler时就是拿到子线程的Looper
                        Thread.sleep(5000);
                        Log.d(TAG, "handleMessage: "+msg.obj);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        };
        Message msg = mHandler.obtainMessage();
        msg.what = 0;
        msg.obj = "你好";
        mHandler.sendMessage(msg);//要放到队列中

如上就等同于HandlerThread，一样的道理。

11、线程池的优点？

重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销
能有效控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。
能够对线程进行简单的管理并提供定时执行以及指定间隔循环执行等功能。

12、线程池的分类？
FixedThreadPool

线程数量固定的线程池，当线程都处于闲置状态是，也不会回收，除非线程池被关闭了。当都处于活跃状态时，新任务处于等待状态。它只有核心线程，并且不会被回收，他能够更加快速的响应外界的请求。

CachedThreadPool

它是一种线程数量不定的线程池，它只有非核心线程，最大为Integer.MAX_VALUE。比较适合执行大量的耗时较少的任务。

ScheduledThreadPool

核心线程数量是固定的，而非核心线程数是没有限制的，非核心线程闲置时就会立刻被回收。主要用于执行定时任务和具有固定周期的重复任务。

SinggleThreadExecutor

只有一个核心线程，它确保所有的任务都在同一个线程中按顺序执行。统一所有的外界任务到一个线程中，不需要处理线程同步的问题。

13、线程池的了解
ThreadPoolExecutor是线程池的真实实现

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}

corePoolSize：
线程池的核心线程数，默认情况下，核心线程数会在线程池中一直存活，即时他们处于闲置状态。如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置成true，那么闲置的核心线程在等待新任务到来时会有超时策略，这个时间间隔由keepAliveTime所指定，当等待时间查过keepAliveTime所指定的时长后，核心线程就会被终止。

maximumPoolSize:
线程池所能容纳的最大线程数，当活动线程数达到这个数值后，后续的新任务将会被阻塞。

keepAliveTime：
非核心线程闲置时的超时时长，超过这个时长，非核心线程数就会被回收。当ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true时，keepAliveTime同样会作用于核心线程。

unit：
用于指定keepAliveTime参数的时间单位，这是一个枚举，常用的有TimeUnit.MILLISECONDS(毫秒)、TimeUnit.SECONDS(秒)以及TimeUnit.MINUTES(分钟)等。

workQueue:
线程池中的任务队列，通过线程池的execute方法提交的Runnable对象会存储到这个参数中。

ThreadFactory：
线程工厂，为线程池提供创建新线程的功能。ThreadFactory是一个接口，它只有一个方法：Thread newThread(Runnable r)。

我们来看一下AsyncTask中线程池的体现：

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();//cup的核心数
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));//核心线程池的大小
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;//最大线程数
private static final int KEEP_ALIVE_SECONDS = 30;//保持活跃时间
private static final ThreadFactory sThreadFactory = new ThreadFactory() {//线程工厂
    private final AtomicInteger mCount = new AtomicInteger(1);

    public Thread newThread(Runnable r) {
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
    }
};

private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);  //线程池中的任务队列，容量是128

/**
 * An {@link Executor} that can be used to execute tasks in parallel.
 */
public static final Executor THREAD_POOL_EXECUTOR;
static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,//秒
            sPoolWorkQueue, sThreadFactory);
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

看后思考：
通过分析AsyncTask，如果只是单独的执行一个线程，然后获取到结果，完全可以使用FutureTask来进行实现，因为AsyncTask内部也是使用了FutureTask进行了实现，不过AsyncTask使用了线程池的方式，如果有多个任务，那AsyncTask可以发挥很好的优势。
使用FutureTask的优势就是我们能够很容易的得到线程处理完的结果，平常我们是无法获取到线程的结果的，应该使用回调能够把结果进行抛出来，我们来看一下FutureTask的使用。

FutureTask<Integer> f = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("当前线程"+Thread.currentThread().getName());
                return 8;
            }
        });
        Thread thread = new Thread(f);
        thread.start();
        try {
            int result = f.get();
            System.out.println("当前线程"+Thread.currentThread().getName());
            System.out.println("结果："+result);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

对HandlerThread的简单分析，如同上面的例子雷同

通过学习，我们需要掌握如下几点

AsyncTask的使用及参数的意义
AsyncTask的使用注意事项
HandlerThread的原理如上
IntentService的使用场景及简单分析

image

Android线程池的使用
一、线程与线程池，为什么要使用线程池 1、Android中的线程在Android中有主线程和子线程的区分。主线程...
Android的线程和线程池
Android的线程和线程池标签（空格分隔）： android 一些概念：线程分类：主线程和子线程，主线程主要...
笔记：Android线程和线程池
Android线程和线程池 Android中的线程操作相关的类有 AsyncTask IntentService ...
线程池创建和相关知识
线程池创建(单例):Android线程池得要这么用 - 简书线程池相关知识:Android开发之线程池使用总结 ...
Android面试之线程和线程池
Android中的线程形态 AsyncTask底层用到了线程池。AsyncTask封装了线程池和Handler，它...
<> Chapter 11
Android的线程和线程池主线程和子线程 Android中的主线程也叫UI线程，主要作用是运行四大组件以及处理...
Android 的线程和线程池
Android 的线程分为主线程和子线程。主线程更新 UI 子线程执行耗时操作 AsyncTask封装了线程池和...
线程池
话题：线程池Android中的线程池有哪些？它们的区别是什么？为什么要使用线程池？线程是Android里面一个很...
要点提炼|开发艺术之线程
本篇的主要内容是Android的线程和线程池：概述线程形态AsyncTaskHandlerThreadInte...
Android 开发艺术探索读书笔记 11 -- Android
本篇文章主要介绍以下几个知识点：主线程和子线程Android 中的线程形态Android 中的线程池 11.1 主...