Android Learning：多线程与异步消息处理机制

　　

　　在最近学习Android项目源码的过程中，遇到了很多多线程以及异步消息处理的机制。由于之前对这块的知识只是浅尝辄止，并没有系统的理解。但是工程中反复出现让我意识到这个知识的重要性。所以我整理出这篇博客，主要介绍了线程和异步处理机制的意义和用法，目的在于帮助初学者能够加深对异步消息处理机制的理解，在实际Android工程中能够更多地使用AsyncTask工具类在子线程中进行UI更新。 

 

一、Android当中的多线程[1]

　　在Android当中，当一个应用程序的组件启动的时候，并且没有其他的应用程序组件在运行时，Android系统就会为该应用程序组件开辟一个新的线程来执行。默认的情况下，在一个相同Android应用程序当中，其里面的组件都是运行在同一个线程里面的，这个线程我们称之为Main线程。当我们通过某个组件来启动另一个组件的时候，这个时候默认都是在同一个线程当中完成的。当然，我们可以自己来管理我们的Android应用的线程，我们可以根据我们自己的需要来给应用程序创建额外的线程。

 

二、Main Thread 和 Worker Thread

　　在Android当中，通常将线程分为两种，一种叫做Main Thread，除了Main Thread之外的线程都可称为Worker Thread。当一个应用程序运行的时候，Android操作系统就会给该应用程序启动一个线程，这个线程就是我们的Main Thread，这个线程非常的重要，它主要用来加载我们的UI界面，完成系统和我们用户之间的交互，并将交互后的结果又展示给我们用户，所以Main Thread又被称为UI Thread。

　　Android系统默认不会给我们的应用程序组件创建一个额外的线程，所有的这些组件默认都是在同一个线程中运行。然而，某些时候当我们的应用程序需要完成一个耗时的操作的时候，例如访问网络或者是对数据库进行查询时，此时我们的UI Thread就会被阻塞。例如，当我们点击一个Button，然后希望其从网络中获取一些数据，如果此操作在UI Thread当中完成的话，当我们点击Button的时候，UI线程就会处于阻塞的状态，此时，我们的系统不会调度任何其它的事件，更糟糕的是，当我们的整个现场如果阻塞时间超过5秒钟(官方是这样说的)，这个时候就会出现 ANR (Application Not Responding)的现象，此时，应用程序会弹出一个框，让用户选择是否退出该程序。对于Android开发来说，出现ANR的现象是绝对不能被允许的。

　　另外，由于我们的Android UI控件是线程不安全的，所以我们不能在UI Thread之外的线程当中对我们的UI控件进行操作。因此在Android的多线程编程当中，我们有两条非常重要的原则必须要遵守：

  • 绝对不能在UI Thread当中进行耗时的操作，不能阻塞我们的UI Thread
  • 不能在UI Thread之外的线程当中操纵我们的UI元素

 

三、多线程的常见操作[2]

　　1、创建线程

　　在Android中，提供了两种创建线程的方法。（一种是通过Thread类的构造方法创建线程对象，并重写run()方法实现，另一种是通过实现Runnable接口来实现。）

　　/*第一种方法：*/
　　Thread thread=new Thread(new Runnable(){
　　　　@Override
　　　　public void run(){
　　　　//要执行的操作
　　　　}
　　});
　　thread.start();

　　/*第二种方法：*/
　　public class MainActivity extends Activity implement Runnable{
　　@Override
　　    public void run(){
　　　　    //要执行的操作
　　　　    }
　　}

　　2、开启线程

　　3、线程休眠

　　4、中断线程  

　　

四、如何处理UI Thread 和 Worker Thread之间的通信

　　既然在Android当中有两条重要的原则要遵守，那么我们可能就有疑问了？我们既不能在主线程当中处理耗时的操作，又不能在工作线程中来访问我们的UI控件，那么我们比如从网络中要下载一张图片，又怎么能将其更新到UI控件上呢？这就关系到了我们的主线程和工作线程之间的通信问题了。在Android当中，提供了两种方式来解决线程直接的通信问题，一种是通过Handler的机制,还有一种就是 AsyncTask 机制。

（一）、Handler机制 

　　就应用程序而言，Android系统中JAVA的应用程序和其他系统上相同，都是靠消息驱动来工作的，他们大致的工作原理如下： 

（1）、有一个消息队列，可以往这个消息队列中投递消息。 

（2）、有一个消息循环，不断从消息队列中取出消息，然后处理。 

　　在Android中，一个线程对应一个Looper对象，而一个Looper对象又对应一个MessageQueue（用于存放message）。接下来，我们来了解几个类：循环者Looper类，消息处理类Handler，消息类Message。 

　1.　Message

　　Message是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同的线程之间交换数据，如Message的what字段，和arg1,arg2来携带一些整型的数据，使用obj字段携带一个Object对象。消息类(Message)被存放在MessageQueue中，一个MessageQueue中可以包含多个Message对象。每个Message对象可以通过Message.obtain()方法或者Handler.obtainMessage()方法获得。

　2.　Handler

　　Handler是处理者的意思，主要用于发送和处理消息。发送信息一般使用Handler的sendMessage()方法，发出的消息经过一系列辗转处理后，最终会传递到Handler的handleMessage()方法中。消息处理类（Handler）允许发送和处理Message和Runnable对象到其所在线程的MessageQueue中。它主要有两个作用：

　　（1）、将Message或Runnable应用post()方法或sendMessage()方法发送到MessageQueue中，在发送时可以指定延时时间、发送时间或者要携带的bundle数据。当MessageQueue循环到该Message时，调用相应的Handler对象的handlerMessage()方法对其进行处理。

　　（2）、在子线程中与主线程进行通信，也就是在工作线程中与UI线程进行通信。）另外，在一个线程中只能有一个Looper和MessageQueue，但是可以有多个Handler,而且这些Handler可以共享一个Looper和MessageQueue。

  3.　MessageQueue

　　MessageQueue是消息队列的意思，它主要用于存放所有通过Handler发送的消息。这部分消息会一直存在于消息队列中，等待被处理。每个线程中只会有一个MessageQueue对象。 

  4.　Looper

　　Looper是每个线程中的MessageQueue的管家，调用Looper的Loop()方法后，就会进入到一个无限的循环中，每当发现MessageQueue中存在一条消息，就会将它取出来，并传递到Handler的handleMessage()方法中。Looper对象用来为一个线程开启一个消息循环，用来操作MessgeQueue。默认情况下，Android中新创建的线程是没有开启消息循环的（主线程除外）。

异步消息处理机制流程图[3] 

　　总结一下流程为：首先在主线程中创建一个Handler对象，并重写handleMessage()方法。然后再子线程中需要进行UI操作时，就创建一个Message对象，并通过Handler把这条消息发送出去。之后这条消息会被添加到MessageQueue的队列等待被处理，而Looper则会一直尝试从MessageQueue中取出这条待处理的信息，最后发回给Handler的HandleMessage()方法中。

　　由于Handler是在主线程中创建的，所以handleMessage()方法也会在主线程中运行，这样就可以放心进行UI操作了。 

public class MainActivity extends Activity {
    private TextView tv;
    private Handler handler=new Handler(){
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case 1://获取到what属性为1的message
                tv.setText((String)msg.obj);//将message的内容填充到TextView中
                break;
            default:
                break;
            }
        };
    };      

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button btn=(Button) findViewById(R.id.btn);
        tv = (TextView) findViewById(R.id.tv);
        btn.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    
                    @Override
                    public void run() {
                        Message msg=new Message();
                        msg.obj="您已点击按钮，数据发生改变";//message的内容
                        msg.what=1;//指定message
                        handler.sendMessage(msg);//handler发送message                        
                    }
                }).start();                
            }
        });
    }
}

 

（二）、AsyncTask

　　AsyncTask：异步任务，从字面上来说，就是在我们的UI主线程运行的时候，异步的完成一些操作。AsyncTask允许我们的执行一个异步的任务在后台。我们可以将耗时的操作放在异步任务当中来执行，并随时将任务执行的结果返回给我们的UI线程来更新我们的UI控件。通过AsyncTask我们可以轻松的解决多线程之间的通信问题，AsyncTask工具类的出现极大地方便了我们在子线程中进行UI操作，但其本质仍然是异步消息处理机制，只不过是Android替我们做的很好的封装而已[4]。

　　怎么来理解AsyncTask呢？通俗一点来说，AsyncTask就相当于Android给我们提供了一个多线程编程的一个框架，其介于Thread和Handler之间，我们如果要定义一个AsyncTask，就需要定义一个类来继承AsyncTask这个抽象类，并实现其唯一的一个 doInBackgroud 抽象方法。要掌握AsyncTask，我们就必须要一个概念，总结起来就是: 3个泛型，4个步骤。

　　3个泛型指的是什么呢？我们来看看AsyncTask这个抽象类的定义，当我们定义一个类来继承AsyncTask这个类的时候，我们需要为其指定3个泛型参数：

AsyncTask　<Params, Progress, Result>

Params: 这个泛型指定的是我们传递给异步任务执行时的参数的类型

Progress: 这个泛型指定的是我们的异步任务在执行的时候将执行的进度返回给UI线程的参数的类型

Result: 这个泛型指定的异步任务执行完后返回给UI线程的结果的类型

 我们在定义一个类继承AsyncTask类的时候，必须要指定好这三个泛型的类型，如果都不指定的话，则都将其写成Void，例如：

AsyncTask <Void, Void, Void>

　　4个步骤：当我们执行一个异步任务的时候，其需要按照下面的4个步骤分别执行

onPreExecute()：这个方法是在执行异步任务之前的时候执行，并且是在UI Thread当中执行的，通常我们在这个方法里做一些UI控件的初始化的操作，例如弹出要给ProgressDialog

doInBackground(Params... params)：在onPreExecute()方法执行完之后，会马上执行这个方法，这个方法就是来处理异步任务的方法，Android操作系统会在后台的线程池当中开启一个worker thread来执行我们的这个方法，所以这个方法是在worker thread当中执行的，这个方法执行完之后就可以将我们的执行结果发送给我们的最后一个 onPostExecute 方法，在这个方法里，我们可以从网络当中获取数据等一些耗时的操作

onProgressUpdate(Progess... values): 这个方法也是在UI Thread当中执行的，我们在异步任务执行的时候，有时候需要将执行的进度返回给我们的UI界面，例如下载一张网络图片，我们需要时刻显示其下载的进度，就可以使用这个方法来更新我们的进度。这个方法在调用之前，我们需要在 doInBackground 方法中调用一个 publishProgress(Progress) 的方法来将我们的进度时时刻刻传递给 onProgressUpdate 方法来更新

onPostExecute(Result... result): 当我们的异步任务执行完之后，就会将结果返回给这个方法，这个方法也是在UI Thread当中调用的，我们可以将返回的结果显示在UI控件上

　　为什么我们的AsyncTask抽象类只有一个 doInBackground 的抽象方法呢？？原因是，我们如果要做一个异步任务，我们必须要为其开辟一个新的Thread，让其完成一些操作，而在完成这个异步任务时，我可能并不需要弹出要给ProgressDialog，我并不需要随时更新我的ProgressDialog的进度条，我也并不需要将结果更新给我们的UI界面，所以除了 doInBackground 方法之外的三个方法，都不是必须有的，因此我们必须要实现的方法是 doInBackground 方法。

　　如果想要启动这个任务，需要执行结构如method().execute(params)的代码：

    private void task() {
        new AsyncTask<String, Void, Boolean>() {
            @Override
            protected Boolean doInBackground(String... params) {  /*传递多个String参数*/
                try {
                    //执行耗时操作
                } catch (Exception e) {
                    //打印异常
                }
            }

            @Override
            protected void onPostExecute(Boolean isSuccess) {
                if (isSuccess) {
                    //耗时操作成功后的操作
                } else {
                    //打印错误
                }
            }
        }.execute(params); /*传递参数*/

　

[1] xiaoluo501395377.Android 多线程-----AsyncTask详解.http://www.cnblogs.com/xiaoluo501395377/p/3430542.html.

[2] 银色的流星.Android线程与异步消息处理机制.http://www.cnblogs.com/scetopcsa/p/3661963.html.

[3] u012339794.Android异步消息处理机制.http://www.lai18.com/content/1849027.html.

[4] 郭霖. 第一行代码 Android[J]. 2014.  

 

posted @ 2016-02-06 19:26  coderbinbin  阅读(1574)  评论(0)  编辑  收藏  举报