浅析Android中的消息机制

时间  2019-11-08
标签 浅析 android 消息 机制 栏目 Android 繁體版
原文   原文链接

在分析Android消息机制以前，咱们先来看一段代码： android

01 public class MainActivity extends Activity implements View.OnClickListener {
02      
03     private TextView stateText;
04     private Button btn;
05      
06     @Override
07     public void onCreate(Bundle savedInstanceState) {
08         super.onCreate(savedInstanceState);
09         setContentView(R.layout.main);
10         stateText = (TextView) findViewById(R.id.tv);
11         btn = (Button) findViewById(R.id.btn);
12          
13         btn.setOnClickListener(this);
14     }
15  
16     @Override
17     public void onClick(View v) {
18         new WorkThread().start();
19     }
20      
21     //工做线程
22     private class WorkThread extends Thread {
23         @Override
24         public void run() {
25             //......处理比较耗时的操做
26              
27             //处理完成后改变状态
28             stateText.setText("completed");
29         }
30     }
31 }

这段代码彷佛看上去很正常，可是当你运行时就会发现，它会报一个致命性的异常： 编程

1 ERROR/AndroidRuntime(421): FATAL EXCEPTION: Thread-8
2 ERROR/AndroidRuntime(421): android.view.ViewRoot$CalledFromWrongThreadException:
3 Only the original thread that created a view hierarchy can touch its views.

究竟是怎么回事呢？缘由在于，Android系统中的视图组件并非线程安全的，若是要更新视图，必须在主线程中更新，不能够在子线程中执行更新的操做。 安全

既然这样，咱们就在子线程中通知主线程，让主线程作更新操做吧。那么，咱们如何通知主线程呢？咱们须要使用到Handler对象。 ide

咱们稍微修改一下上面的代码： oop

01 public class MainActivity extends Activity implements View.OnClickListener {
02      
03     private static final int COMPLETED = 0;
04      
05     private TextView stateText;
06     private Button btn;
07      
08     private Handler handler = new Handler() {
09         @Override
10         public void handleMessage(Message msg) {
11             if (msg.what == COMPLETED) {
12                 stateText.setText("completed");
13             }
14         }
15     };
16      
17     @Override
18     public void onCreate(Bundle savedInstanceState) {
19         super.onCreate(savedInstanceState);
20         setContentView(R.layout.main);
21         stateText = (TextView) findViewById(R.id.tv);
22         btn = (Button) findViewById(R.id.btn);
23          
24         btn.setOnClickListener(this);
25     }
26  
27     @Override
28     public void onClick(View v) {
29         new WorkThread().start();
30     }
31      
32     //工做线程
33     private class WorkThread extends Thread {
34         @Override
35         public void run() {
36             //......处理比较耗时的操做
37              
38             //处理完成后给handler发送消息
39             Message msg = new Message();
40             msg.what = COMPLETED;
41             handler.sendMessage(msg);
42         }
43     }
44 }


经过上面这种方式，咱们就能够解决线程安全的问题，把复杂的任务处理工做交给子线程去完成，而后子线程经过handler对象告知主线程，由主线程更新视图，这个过程当中消息机制起着重要的做用。 this

下面，咱们就来分析一下Android中的消息机制。 spa

熟悉Windows编程的朋友知道Windows程序是消息驱动的，而且有全局的消息循环系统。Google参考了Windows的消息循环机制， 也在Android系统中实现了消息循环机制。Android经过Looper、Handler来实现消息循环机制。Android的消息循环是针对线程 的，每一个线程均可以有本身的消息队列和消息循环。 .net

Android系统中的Looper负责管理线程的消息队列和消息循环。经过Looper.myLooper()获得当前线程的Looper对象，经过Looper.getMainLooper()获得当前进程的主线程的Looper对象。 线程

前面提到，Android的消息队列和消息循环都是针对具体线程的，一个线程能够存在一个消息队列和消息循环，特定线程的消息只能分发给本线程，不 能跨线程和跨进程通信。可是建立的工做线程默认是没有消息队列和消息循环的，若是想让工做线程具备消息队列和消息循环，就须要在线程中先调用 Looper.prepare()来建立消息队列，而后调用Looper.loop()进入消息循环。下面是咱们建立的工做线程： 对象

01 class WorkThread extends Thread {
02           public Handler mHandler;
03  
04           public void run() {
05               Looper.prepare();
06  
07               mHandler = new Handler() {
08                   public void handleMessage(Message msg) {
09                       // 处理收到的消息
10                   }
11               };
12  
13               Looper.loop();
14           }
15       }


这样一来，咱们建立的工做线程就具备了消息处理机制了。

那么，为何前边的示例中，咱们怎么没有看到Looper.prepare()和Looper.loop()的调用呢？缘由在于，咱们的Activity是一个UI线程，运行在主线程中，Android系统会在Activity启动时为其建立一个消息队列和消息循环。

前面提到最多的是消息队列(MessageQueue)和消息循环(Looper)，可是咱们看到每一个消息处理的地方都有Handler的存在，它 是作什么的呢？Handler的做用是把消息加入特定的Looper所管理的消息队列中，并分发和处理该消息队列中的消息。构造Handler的时候能够 指定一个Looper对象，若是不指定则利用当前线程的Looper对象建立。下面是Handler的两个构造方法：

01 /**
02      * Default constructor associates this handler with the queue for the
03      * current thread.
04      *
05      * If there isn't one, this handler won't be able to receive messages.
06      */
07     public Handler() {
08         if (FIND_POTENTIAL_LEAKS) {
09             final Class<? extends Handler> klass = getClass();
10             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
11                     (klass.getModifiers() & Modifier.STATIC) == 0) {
12                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
13                     klass.getCanonicalName());
14             }
15         }
16  
17         mLooper = Looper.myLooper();
18         if (mLooper == null) {
19             throw new RuntimeException(
20                 "Can't create handler inside thread that has not called Looper.prepare()");
21         }
22         mQueue = mLooper.mQueue;
23         mCallback = null;
24     }
25  
26 /**
27      * Use the provided queue instead of the default one.
28      */
29     public Handler(Looper looper) {
30         mLooper = looper;
31         mQueue = looper.mQueue;
32         mCallback = null;
33     }
下面是消息机制中几个重要成员的关系图：


一个Activity中能够建立出多个工做线程，若是这些线程把他们消息放入Activity主线程的消息队列中，那么消息就会在主线程中处理了。由于主线程通常负责视图组件的更新操做，对于不是线程安全的视图组件来讲，这种方式可以很好的实现视图的更新。

那么，子线程如何把消息放入主线程的消息队列中呢？只要Handler对象以主线程的Looper建立，那么当调用Handler的 sendMessage方法，系统就会把消息主线程的消息队列，而且将会在调用handleMessage方法时处理主线程消息队列中的消息。

对于子线程访问主线程的Handler对象，你可能会问，多个子线程都访问主线程的Handler对象，发送消息和处理消息的过程当中会不会出现数据 的不一致呢？答案是Handler对象不会出现问题，由于Handler对象管理的Looper对象是线程安全的，不论是添加消息到消息队列仍是从消息队 列中读取消息都是同步保护的，因此不会出现数据不一致现象。

深刻理解Android消息处理机制对于应用程序开发很是重要，也可让咱们对线程同步有更加深入的认识，但愿这篇文章能够对朋友们有所帮助。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程