Android 多线程创建

阳光穿透心脏的1/2处 2022-12-21 00:53 122阅读 0赞

当我们启动一个App的时候，Android系统会启动一个Linux Process，该Process包含一个Thread，称为UI Thread或Main Thread。通常一个应用的所有组件都运行在这一个Process中，当然，你可以通过修改四大组件在Manifest.xml中的代码块(<activity><service><provider><receiver>)中的android:process属性指定其运行在不同的process中。当一个组件在启动的时候，如果该process已经存在了，那么该组件就直接通过这个process被启动起来，并且运行在这个process的UI Thread中。

UI Thread中运行着许多重要的逻辑，如系统事件处理，用户输入事件处理，UI绘制，Service，Alarm等，如下图：

![6f8b3cf2fce02ec23c650f2392a0c51f.webp][]

UI Thread包含的逻辑

而我们编写的代码则是穿插在这些逻辑中间，比如对用户触摸事件的检测和响应，对用户输入的处理，自定义View的绘制等。如果我们插入的代码比价耗时，如网络请求或数据库读取，就会阻塞UI线程其他逻辑的执行，从而导致界面卡顿。如果卡顿时间超过5秒，系统就会报ANR错误。所以，如果要执行耗时的操作，我们需要另起线程执行。

在新线程执行完耗时的逻辑后，往往需要将结果反馈给界面，进行UI更新。Android的UI toolkit不是线程安全的，不能在非UI线程进行UI的更新，所有对界面的更新必须在UI线程进行。

**Android提供了四种常用的操作多线程的方式，分别是：  
1. Handler+Thread  
2. AsyncTask  
3. ThreadPoolExecutor  
4. IntentService**

下面分布对四种方式进行介绍。

# **Handler+Thread** #

Android主线程包含一个消息队列(MessageQueue)，该消息队列里面可以存入一系列的Message或Runnable对象。通过一个Handler你可以往这个消息队列发送Message或者Runnable对象，并且处理这些对象。每次你新创建一个Handle对象，它会绑定于创建它的线程(也就是UI线程)以及该线程的消息队列，从这时起，这个handler就会开始把Message或Runnable对象传递到消息队列中，并在它们出队列的时候执行它们。

![3e85f83153db374b1adca7ecb84e5ab0.webp][]

Handler Thread原理图

Handler可以把一个Message对象或者Runnable对象压入到消息队列中，进而在UI线程中获取Message或者执行Runnable对象，Handler把压入消息队列有两类方式，Post和sendMessage：

Post方式：

Post允许把一个Runnable对象入队到消息队列中。它的方法有：  
post(Runnable)/postAtTime(Runnable,long)/postDelayed(Runnable,long)

对于Handler的Post方式来说，它会传递一个Runnable对象到消息队列中，在这个Runnable对象中，重写run()方法。一般在这个run()方法中写入需要在UI线程上的操作。

![c482ccd92c9a4de2fd7ffed1da8c5477.webp][]

handler post用法

sendMessage：

sendMessage允许把一个包含消息数据的Message对象压入到消息队列中。它的方法有：sendEmptyMessage(int)/sendMessage(Message)/sendMessageAtTime(Message,long)/sendMessageDelayed(Message,long)

Handler如果使用sendMessage的方式把消息入队到消息队列中，需要传递一个Message对象，而在Handler中，需要重写handleMessage()方法，用于获取工作线程传递过来的消息，此方法运行在UI线程上。Message是一个final类，所以不可被继承。

![ee60485a8b93af084ca8bf6f06151c35.webp][]

handler定义

![c1824e13ef1c07d9cfdc9651fb11ea3f.webp][]

handler sendMessage用法

优缺点

1. Handler用法简单明了，可以将多个异步任务更新UI的代码放在一起，清晰明了
    2. 处理单个异步任务代码略显多

适用范围

1. 多个异步任务的更新UI

# **AsyncTask** #

AsyncTask是android提供的轻量级的异步类,可以直接继承AsyncTask，在类中实现异步操作，并提供接口反馈当前异步执行的程度(可以通过接口实现UI进度更新)，最后反馈执行的结果给UI主线程。

AsyncTask通过一个阻塞队列BlockingQuery<Runnable>存储待执行的任务，利用静态线程池THREAD\_POOL\_EXECUTOR提供一定数量的线程，默认128个。在Android 3.0以前，默认采取的是并行任务执行器，3.0以后改成了默认采用串行任务执行器，通过静态串行任务执行器SERIAL\_EXECUTOR控制任务串行执行，循环取出任务交给THREAD\_POOL\_EXECUTOR中的线程执行，执行完一个，再执行下一个。

用法举例：

class DownloadTask extends AsyncTask<Integer, Integer, String>{  
        // AsyncTask<Params, Progress, Result>
        //后面尖括号内分别是参数（例子里是线程休息时间），进度(publishProgress用到)，返回值类型
        @Override
        protected void onPreExecute() {
            //第一个执行方法
            super.onPreExecute();
        }
        @Override
        protected String doInBackground(Integer... params) {
            //第二个执行方法,onPreExecute()执行完后执行
            for(int i=0;i<=100;i++){
                publishProgress(i);
                try {
                    Thread.sleep(params[0]);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return "执行完毕";
        }
        @Override
        protected void onProgressUpdate(Integer... progress) {
            //这个函数在doInBackground调用publishProgress时触发，虽然调用时只有一个参数
            //但是这里取到的是一个数组,所以要用progesss[0]来取值
            //第n个参数就用progress[n]来取值
            tv.setText(progress[0]+"%");
            super.onProgressUpdate(progress);
        }
        @Override
        protected void onPostExecute(String result) {
            //doInBackground返回时触发，换句话说，就是doInBackground执行完后触发
            //这里的result就是上面doInBackground执行后的返回值，所以这里是"执行完毕"
            setTitle(result);
            super.onPostExecute(result);
        }
    }

优缺点

1. 处理单个异步任务简单，可以获取到异步任务的进度
    2. 可以通过cancel方法取消还没执行完的AsyncTask
    3. 处理多个异步任务代码显得较多

适用范围

1. 单个异步任务的处理

# **ThreadPoolExecutor** #

ThreadPoolExecutor提供了一组线程池，可以管理多个线程并行执行。这样一方面减少了每个并行任务独自建立线程的开销，另一方面可以管理多个并发线程的公共资源，从而提高了多线程的效率。所以ThreadPoolExecutor比较适合一组任务的执行。Executors利用工厂模式对ThreadPoolExecutor进行了封装，使用起来更加方便。

![6ac829208490869c36ab0041b3e8db4f.webp][]

ThreadPoolExecutor

Executors提供了四种创建ExecutorService的方法，他们的使用场景如下：

1. Executors.newFixedThreadPool()
       创建一个定长的线程池，每提交一个任务就创建一个线程，直到达到池的最大长度，这时线程池会保持长度不再变化
    2. Executors.newCachedThreadPool()
       创建一个可缓存的线程池，如果当前线程池的长度超过了处理的需要时，它可以灵活的回收空闲的线程，当需要增加时，
        它可以灵活的添加新的线程，而不会对池的长度作任何限制
    3. Executors.newScheduledThreadPool()
       创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer
    4. Executors.newSingleThreadExecutor()
       创建一个单线程化的executor，它只创建唯一的worker线程来执行任务

适用范围

1. 批处理任务

# **IntentService** #

IntentService继承自Service，是一个经过包装的轻量级的Service，用来接收并处理通过Intent传递的异步请求。客户端通过调用startService(Intent)启动一个IntentService，利用一个work线程依次处理顺序过来的请求，处理完成后自动结束Service。

使用步骤

*  IntentService是一个抽象类内部有一个抽象的方法 handleIntent(),继承至Service类.所以使用它需要继承它实现抽象方法。

public class MyIntentService extends IntentService {
      private static final String TAG = "MyIntentService";
      public MyIntentService() {
          super("MyIntentService");
      }
    
      @Override
      protected void onHandleIntent(Intent intent) {
          //在这里通过intent携带的数据，开进行任务的操作。
          Log.d(TAG, "onHandleIntent: " + Thread.currentThread().getName());
      }
    
      @Override
      public void onDestroy() {
          super.onDestroy();
          Log.d(TAG, "onDestroy: ");
        }
    }

然后调用StartService()启动异步后台服务类 IntentService。

startService.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View v) {
                  Intent intent = new Intent(MainActivity.this, MyIntentService.class);
                  startService(intent);
              }
          });

源码分析

*  服务启动的过程中，会去执行服务的生命周期方法，在开启服务的时候，有两种方式，分别为startService和bindService
 *  startService方式启动，生命周期方法执行的顺序是 onCreate()，onStartCommand() onStart() onDestroy(),按照生命周期执行顺序我们查看IntentService的源码

// onCreate方法的分析
        @Override
       public void onCreate() {
           super.onCreate();
           HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
           //创建了一个Looper对象 & MessageQueue对象 调用了Looper.loop方法
           thread.start();
           //   获取到HandlerThread中创建好的Looper对象。
           mServiceLooper = thread.getLooper();
           //ServiceHandler extends Handler，绑定了HandlerThread中的Looper对象 ；那个线程调用了Looper中的loop方法，Handler的dispatchMessage方法就运行在那个线程中。
           mServiceHandler = new ServiceHandler(mServiceLooper);
       }
     //onStartCommand()方法分析
      public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
           // 调用了onStart方法
           onStart(intent, startId);
           return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
       }
    //onStart方法
    public void onStart(@Nullable Intent intent, int startId) {
           //在这里构造了一个消息对象
           Message msg = mServiceHandler.obtainMessage();
    
           msg.arg1 = startId;
           //将intent 包装到了Message的obj中，
           msg.obj = intent;
           //然后调用sendMessage()将消息插入到队列中。
           //最终消息被取出然后被分发，最后调用了handleMessage()来处理这个消息
           mServiceHandler.sendMessage(msg);
       }
       //ServiceHandler handleMessage方法的分析
       private final class ServiceHandler extends Handler {
           public ServiceHandler(Looper looper) {
               super(looper);
           }
    
           @Override
           public void handleMessage(Message msg) {
               //SeriviceHandler 的handleMessage()方法中 将接受到的消息交给onHandleIntent来处理，onHandleIntent方法就是我们实现的方法，获取到Intent，处理任务。
               onHandleIntent((Intent) msg.obj);
               //执行完 结束服务
               stopSelf(msg.arg1);
           }
       }
      // onDestroy()方法的处理
      @Override
       public void onDestroy() {
           //将消息队列中的所有消息给移除，包括处理中的和未处理的
           mServiceLooper.quit();
       }

总结说来就是，开启服务执行onCreate()方法，方法中创建好了一个子线程（HandlerThread），（子线程中创建好了一个Looper对象同时创建好了一个MessagqQueue消息队列，然后开启轮询消息队列。）内部创建好的Handler与子线程中的Looper对象绑定。onCreate只有在服务第一次创建的时候才会调用，之后每次调用都只会执行onStartCommand方法，在此方法中我们构建好了一个Message对象，并且将传递进来的Intent封装在Mesage，一起发送到消息队列中。经过轮询将消息分发到Handler的handleMessage中处理，此时获取到Message中携带的Intent传递给我们实现好的handleIntent方法中进行任务的处理，处理完毕自动调用StopSlef来结束服务。在onDestroy方法会把所有消息都给退出。

上文中我们分析了startService方法启动的服务，那bindService方式启动服务的分析如下（绑定服务，建立长期通信），bindService启动会执行 onCreate -> onBind -> onUnBind -> onDestroy方法。

//onCreate方法上文中已经分析
     //onBind()
      public IBinder onBind(Intent intent) {
           //直接返回null了。那么不对会Mesage对象和发送消息到队列中，
           //然后回调handleIntent方法了。
           return null;
       }

所以bindService方式启动服务，不会进行多线程的操作。

简单描述一下IntentService

*  IntentService是一个特殊的Service类，是实现了多线程处理异步请求的一个服务类，在handleIntent方法中进行耗时的操作，如果有多个耗时的操作任务，会按照顺序去一个一个的执行，执行完一个关闭一个。

在源码handleMessage方法中为什么执行完handleIntent方法会去调用带参数的stopSelf()

*  因为stopSelf()的执行会立刻将服务停止掉，而带参数的stopSelf(int startId)会在所有任务执行完毕后将服务给停止。通常情况下调用stopSelf(int satrtId)方法不会立刻去执行停止服务的操作，会去判断最近执行任务的次数是否和startId相等，如果相等就立刻执行停止服务的操作。

特点

1. 一个可以处理异步任务的简单Service

[6f8b3cf2fce02ec23c650f2392a0c51f.webp]: /images/20221120/ac4873b5af8c488d8023d6500353281e.png
[3e85f83153db374b1adca7ecb84e5ab0.webp]: /images/20221120/b9f6d1e9f00e444b99b21d177ac90f9b.png
[c482ccd92c9a4de2fd7ffed1da8c5477.webp]: /images/20221120/cef30fea3cfa441c92dd7512d4fe3eb0.png
[ee60485a8b93af084ca8bf6f06151c35.webp]: /images/20221120/62a70e754ce9455a80da730aae745308.png
[c1824e13ef1c07d9cfdc9651fb11ea3f.webp]: /images/20221120/35e70fe391fa457cafdf60b24d197729.png
[6ac829208490869c36ab0041b3e8db4f.webp]: /images/20221120/b955e5fb2e9c485fad89c5d5b1a5736c.png