Android中的Handler消息机制_Android, Python及开发编程讨论区_Weblogic技术|Tuxedo技术|中间件技术|Oracle论坛|JAVA论坛|Linux/Unix技术|hadoop论坛_联动北方技术论坛  
网站首页 | 关于我们 | 服务中心 | 经验交流 | 公司荣誉 | 成功案例 | 合作伙伴 | 联系我们 |
联动北方-国内领先的云技术服务提供商
»  游客             当前位置:  论坛首页 »  自由讨论区 »  Android, Python及开发编程讨论区 »
总帖数
1
每页帖数
101/1页1
返回列表
0
发起投票  发起投票 发新帖子
查看: 1751 | 回复: 0   主题: Android中的Handler消息机制        下一篇 
nini
注册用户
等级:新兵
经验:56
发帖:63
精华:0
注册:2011-12-16
状态:离线
发送短消息息给nini 加好友    发送短消息息给nini 发消息
发表于: IP:您无权察看 2015-4-23 10:16:10 | [全部帖] [楼主帖] 楼主

在分析Android消息机制之前,我们先来看一段代码:

  1. publicclass MainActivity extends Activity implements View.OnClickListener { 
  2.       
  3.       private TextView stateText; 
  4.       private Button btn; 
  5.       
  6.       @Override
  7.       publicvoid onCreate(Bundle savedInstanceState) { 
  8.             super.onCreate(savedInstanceState); 
  9.              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.       publicvoid onClick(View v) { 
  18.             new WorkThread().start(); 
  19.        } 
  20.       
  21.       //工作线程
  22.       privateclass WorkThread extends Thread { 
  23.             @Override
  24.             publicvoid run() { 
  25.                   //......处理比较耗时的操作
  26.                   
  27.                   //处理完成后改变状态
  28.                    stateText.setText("completed"); 
  29.              } 
  30.        } 

这段代码似乎看上去很正常,但是当你运行时就会发现,它会报一个致命性的异常:

  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对象。

我们稍微修改一下上面的代码:

  1. publicclass MainActivity extends Activity implements View.OnClickListener { 
  2.       
  3.       privatestaticfinalint COMPLETED = 0; 
  4.       
  5.       private TextView stateText; 
  6.       private Button btn; 
  7.       
  8.       private Handler handler = new Handler() { 
  9.             @Override
  10.             publicvoid handleMessage(Message msg) { 
  11.                   if (msg.what == COMPLETED) { 
  12.                          stateText.setText("completed"); 
  13.                    } 
  14.              } 
  15.        }; 
  16.       
  17.       @Override
  18.       publicvoid 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.       publicvoid onClick(View v) { 
  29.             new WorkThread().start(); 
  30.        } 
  31.       
  32.       //工作线程
  33.       privateclass WorkThread extends Thread { 
  34.             @Override
  35.             publicvoid run() { 
  36.                   //......处理比较耗时的操作
  37.                   
  38.                   //处理完成后给handler发送消息
  39.                    Message msg = new Message(); 
  40.                    msg.what = COMPLETED; 
  41.                    handler.sendMessage(msg); 
  42.              } 
  43.        } 

通过上面这种方式,我们就可以解决线程安全的问题,把复杂的任务处理工作交给子线程去完成,然后子线程通过handler对象告知主线程,由主线程更新视图,这个过程中消息机制起着重要的作用。

下面,我们就来分析一下Android中的消息机制。

熟悉Windows编程的朋友知道Windows程序是消息驱动的,并且有全局的消息循环系统。Google参考了Windows的消息循环机制,也在Android系统中实现了消息循环机制。Android通过Looper、Handler来实现消息循环机制。Android的消息循环是针对线程的,每个线程都可以有自己的消息队列和消息循环。

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

前面提到,Android的消息队列和消息循环都是针对具体线程的,一个线程可以存在一个消息队列和消息循环,特定线程的消息只能分发给本线程,不能跨线程和跨进程通讯。但是创建的工作线程默认是没有消息队列和消息循环的,如果想让工作线程具有消息队列和消息循环,就需要在线程中先调用Looper.prepare()来创建消息队列,然后调用Looper.loop()进入消息循环。下面是我们创建的工作线程:

  1. class WorkThread extends Thread { 
  2.       public Handler mHandler; 
  3.       
  4.       publicvoid run() { 
  5.              Looper.prepare(); 
  6.             
  7.              mHandler = new Handler() { 
  8.                   publicvoid handleMessage(Message msg) { 
  9.                         // 处理收到的消息
  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的两个构造方法:

  1. /**
  2.  * Default constructor associates this handler with the queue for the
  3.  * current thread.
  4.  *
  5.  * If there isn't one, this handler won't be able to receive messages.
  6.  */
  7. public Handler() { 
  8.       if (FIND_POTENTIAL_LEAKS) { 
  9.             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.             thrownew 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.  * Use the provided queue instead of the default one.
  27.  */
  28. public Handler(Looper looper) { 
  29.        mLooper = looper; 
  30.        mQueue = looper.mQueue; 
  31.        mCallback = null; 
  32.  } 

下面是消息机制中几个重要成员的关系图:

北京联动北方科技有限公司

北京联动北方科技有限公司

一个Activity中可以创建出多个工作线程,如果这些线程把他们消息放入Activity主线程的消息队列中,那么消息就会在主线程中处理了。因为主线程一般负责视图组件的更新操作,对于不是线程安全的视图组件来说,这种方式能够很好的实现视图的更新。

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

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

深入理解Android消息处理机制对于应用程序开发非常重要,也可以让我们对线程同步有更加深刻的认识,希望这篇文章可以对朋友们有所帮助。

--转自 北京联动北方科技有限公司




赞(0)    操作        顶端 
总帖数
1
每页帖数
101/1页1
返回列表
发新帖子
请输入验证码: 点击刷新验证码
您需要登录后才可以回帖 登录 | 注册
技术讨论