Android并发编程高级面试题汇总（含详细解析十七）-摩杜云开发者社区

Android并发编程高级面试题汇总最全最细面试题讲解持续更新中👊👊 👀你想要的面试题这里都有👀 👇👇👇

AsyncTask中的任务是串行的还是并行的？

这道题想考察什么？

是否了解AsyncTask中的任务是串行的还是并行的与真实场景使用，是否熟悉AsyncTask中的任务是串行的还是并行的

考察的知识点

AsyncTask中的任务是串行的还是并行的概念在项目中使用与基本知识

考生应该如何回答

AsyncTask中的任务在4.0以上是串行执行的，在AsyncTask中提交的任务默认都会通过：SerialExecutor线程池执行：

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);//将任务添加到线程池
        }
    }
}

通过上面的源码可以发现，每次执行完一个任务后，才会调用scheduleNext往线程池里面添加任务，所以即使线程池是并行的，但是我添加任务的时候是串行的，所以api22中的asynctask是串行的，那么线程池其实再多的线程也没用了，反正每次都只有一个任务在里面。

另外，在AsyncTask中还存在一个executeOnExecutor(Executor exec, Params... params) 方法，能够指定线程池。所以非默认情况下，AsyncTask也能够并行执行任务。

Android中操作多线程的方式有哪些？

这道题想考察什么？

是否了解Android中操作多线程的方式有哪些与真实场景使用，是否熟悉Android中操作多线程在工作中的表现是什么？

考察的知识点

Android中操作多线程的方式有哪些的概念在项目中使用与基本知识

考生应该如何回答

常见的实现多线程的手段有五种：

第一种：Thread，Runnable

第二种：HandlerThread

第三种：AsyncTask

第四种：Executor

第五种：IntentService

Thread与Runnable

Android中创建线程最基本的两种方法，使用Thread类或Runnable接口：

此方式是线程最基础的用法，一般用于界面上比较简单的快捷用法，在Android中一般跟Handler一起使用，用于线程中的通信。那Android中为了方便这种通信方式，就生成了一个HandlerThread类，将Thread和Handler结合起来方便了使用。

/**
     * 继承Thread
     */
    public class NewThread extends Thread{
        @Override
        public void run() {
            super.run();
        }
    }

    /**
     * 实现Runnable接口
     */
    public class NewThread2 implements Runnable{
        @Override
        public void run() {

        }
    }

HandlerThread

HandlerThread本质上就是一个Thread，完成了对Thread与Handler的结合。主要解决的问题是，在一个已经运行的线程中去执行一些任务。官方解释是：

Thread. Handy class for starting a new thread that has a looper.
The looper can then be used to create handler classes.

下面代码中：HandlerThread在运行中，可以通过handler进行一些任务处理。

它的原理其实就是在HandlerThread线程内部有一个Looper变量，进行loop()的死循环，然后通过MessageQueue进行一系列任务的排队和处理。有开发者会想，这不就是普通的Thread+Looper+Handler吗，其实差不太多，HandlerThread就相当于系统帮你封装了一个带looper对象的线程，不需要你自己去手动操作Looper

那么这个HandlerThread到底有什么实际应用呢？一般用于Android中需要新建子线程进行多个任务处理，并且需要和主线程通信。后面要说的IntentService 内部其实就是用了HandlerThread实现的。（其实我个人在实际项目中用的很少，一般用Executors.newSingleThreadExecutor()方法代替，一样的线程中管理任务队列，后面会详细说到线程池）

HandlerThread mHandlerThread=new HandlerThread("");
        mHandlerThread.start();

        Handler mHandler =new Handler(mHandlerThread.getLooper()){
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);
            }
        };

        mHandler.sendEmptyMessage(0);

AsyncTask

AsyncTask是轻量级的异步任务类，可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程用于更新UI。如果需要新建线程进行多个任务排队串行执行并且完成和主线程通信，可以使用HandlerThread。那么如果是单一任务呢，简单的任务呢？比如我就需要请求一个接口，然后进行UI更新，那么就可以用到AsyncTask，它的优点在于简单快捷，过程可控。

new AsyncTask<Void, Void, String>() {

    @Override
    protected void onPreExecute() {
        //请求接口之前，初始化操作
        super.onPreExecute();
    }

    @Override
    protected String doInBackground(Void... parameters) {
        //请求接口
        return "";
    }

    @Override
    protected void onProgressUpdate(Void... values) {
        //在主线程显示线程任务执行的进度
        super.onProgressUpdate(values);
    }

    @Override
    protected void onPostExecute(String responseString) {
        //接收线程任务执行结果
    }
}.execute();

Executor

Executor即线程池，可以管理多个线程并行执行，线程池的优点就在于可以线程复用，并且合理管理所有线程。线程池具体使用与实现：《4.22 线程池有几种实现方式，线程池的七大参数有哪些？》

IntentService

IntentService是一个Service，自带工作线程，并且线程任务结束后自动销毁的一个类。IntentService其实封装了HandlerThread，同时又具备Service的特性。其中onHandleIntent方法即为异步执行的方法：

@Override
    public void onCreate() {
			  super.onCreate();
			  //创建新线程并start
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
        mServiceLooper = thread.getLooper();
        //创建新线程对应的handler
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
    
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
    		//service启动后发送消息给handler
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }
    
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }
        @Override
        public void handleMessage(Message msg) {
        		//handler收到消息后调用onHandleIntent方法
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }