【其它|Android Handler】android的UI操作不是线程安全的，同时也只有主线程才能够操作UI，同时主线程对于UI操作有一定的时间限制（最长5秒）。为了能够做一些比较耗时的操作（比如下载、打开大文件等），android提供了一些列机制。《android基础知识02——线程安全》系列文章就是参考了网上许多网友的文章后，整理出来的一个系列，介绍了主要的方法。分别如下：
android基础知识02——线程安全1：定义及例子
android基础知识02——线程安全2：handler、message、runnable

android基础知识02——线程安全3：Message，MessageQueue，Handler，Looper
android基础知识02——线程安全4：HandlerThread
android基础知识02——线程安全5： AsyncTask


四、使用消息队列的实现
在上文中，我们提到在android中只有主线程才可以进行UI操作，我们例子中让子线程操作UI结果出现了错误。
为了使该程序得以运行，我们使用如下解决方案：

[java]view plain copy

1. private EditText editText;
2. private Handler messageHandler;
3. @Override
4. public void onCreate(Bundle savedInstanceState) {
5. super.onCreate(savedInstanceState);
6. setContentView(R.layout.main);
7. editText = (EditText) findViewById(R.id.weather_city_edit);
8. Button button = (Button) findViewById(R.id.goQuery);
9. button.setOnClickListener(this);
10. //得到当前线程 的Looper实例，由于 当前线程是UI线程也可以 通过Looper.getMainLooper()得到
11. Looper looper = Looper.myLooper();
12. //此处甚至可以 不需要设置Looper，因为 Handler默认就使用当 前线程的Looper
13. messageHandler = new MessageHandler(looper);
14. }

[java]view plain copy

1. @Override
2. public void onClick(View v) {
3. //创建一个子线 程去做耗时的网络连接工作
4. new Thread() {
5. @Override
6. public void run() {
7. //活动用户输入 的城市名称
8. String city = editText.getText().toString();
9. //调用Google 天气API查询指定城 市的当日天气情况
10. String weather = getWetherByCity(city);
11. //创建一个Message对象，并把得 到的天气信息赋值给Message对象
12. Message message = Message.obtain();
13. message.obj = weather;
14. //通过Handler发布携带有天 气情况的消息
15. messageHandler.sendMessage(message);
16. }
17. }.start();
18. }

[java]view plain copy

1. //子类化一个Handler
2. class MessageHandler extends Handler {
3. public MessageHandler(Looper looper) {
4. super(looper);
5. }
6. @Override
7. public void handleMessage(Message msg) {
8. //处理收到的消 息，把天气信息显示在title上
9. setTitle((String) msg.obj);
10. }
11. }

以上程序使用消息队列来实现，通过消息队列改写过后的天气预报程序已经可以成功运行，因为Handler的handleMessage方法实 际是由关联有该消息队列的UI thread调用，而在UI thread中更新title并没有违背Android的单线程模型的原则。

五、消息队列
在上文中使用到了android的消息队列。说到消息队列，我们可以想到一个流程：产生消息——接收消息（存入消息队列)——消息队列——处理消息。这里android的实现，涉及handler、messagequeue、looper等定义，下面来一一介绍：
1、handler
主要接受子线程发送的数据, 并用此数据配合主线程更新UI.
解释: 当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发, 比如说, 你要是点击一个 Button, Android会分发事件到Button上，来响应你的操作。如果此时需要一个耗时的操作，例如: 联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象, 如果5秒钟还没有完成的话，会收到Android系统的一个错误提示"强制关闭".这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，Android主线程是线程不安全的，也就是说，更新UI只能在主线程中更新，子线程中操作是危险的. 这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传弟)Message对象，(里面包含数据), 把这些消息放入主线程队列中，配合主线程进行更新UI。

handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),
它有两个作用: (1):安排消息或Runnable 在某个主线程中某个地方执行, (2)安排一个动作在不同的线程中执行

Handler中分发消息的一些方法
post(Runnable)
postAtTime(Runnable,long)
postDelayed(Runnable long)
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message,long)
sendMessageDelayed(Message,long)
以上post类方法允许你排列一个Runnable对象到主线程队列中,
sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

1.1 message和runnable
通过创建一个Handler子类的对象，每个acvivity只需一个Handler对象。后台进程可通过两种方式Handler进行通信：message和Runnable对象，其结果实质都是将在Handler的队列中放入内容，message是放置信息，可以传递一些参数，Handler获取这些信息并将判度如何处理，而Runnable则是直接给出处理的方法。队列就是依次执行，Handler会处理完一个消息或者执行完某个处理在进行下一步，这样不会出现多个线程同时要求进行UI处理而引发的混乱现象。

这些队列中的内容（无论Message还是Runnable）可以要求马上执行，延迟一定时间执行或者指定某个时刻执行，如果将他们放置在队列头，则表示具有最高有限级别，立即执行。这些函数包括有:sendMessage(), sendMessageAtFrontOfQueue(), sendMessageAtTime(), sendMessageDelayed()以及用于在队列中加入Runnable的post(), postAtFrontOfQueue(), postAtTime(),postDelay()。

一般而言，推荐是Messge方式，这样程序设计得可以更为灵活，而Runnable在某些简单明确的方式中使用。我们将通过三种方法编写一个小例子来学习。这个例子是一个进度条，每隔1秒，进度条步进5，如果acvity停止时，进度条归零。
Android XML ：


[html]view plain copy

4. style="?android:attr/progressBarStyleHorizontal"
5. android:layout_width="fill_parent"
6. android:layout_height="wrap_content" />

例子一：线程开启，采用Message传递后台线程和UI主线程之间的信息

[java]view plain copy

1. public class Chapter15Test1 extends Activity{
2. private ProgressBar bar = null;
3. private boolean isRunning = false;
5. /* 我们为这个Acivity创建一个用于和后台程序通信的handler，简单地，只要一收到message，就将progressbar进度增加5。*/
6. /* 步骤1：创建Handler，并通过handleMessage()给出当收到消息是UI需要进行如何处理，例子简单不对msg的内容进行分析*/
7. Handler handler= new Handler(){
8. public void handleMessage (Message msg) {
9. bar.incrementProgressBy(5);
10. }
11. };
13. protected void onCreate(Bundle savedInstanceState) {
14. super.onCreate(savedInstanceState);
15. setContentView(R.layout.chapter_15_test1);
16. bar=(ProgressBar)findViewById(R.id.c15_progress);
17. }
19. /*on Start是UI初始化并显示时调用*/
20. protected void onStart() {
21. super.onStart();
22. bar.setProgress(0);
23. /*步骤2：建立后台线程处理，采用Thread，其中run()的内容，就是线程并行处理的内容，Thread是Runnable的implements*/
24. Thread background = new Thread(new Runnable(){
25. public void run () {
26. try{
27. for(int i = 0; i < 20 && isRunning; i ++){
28. Thread.sleep(1000);
29. /* 步骤2.1：发送Message到队列中，参数中的obtainMessage()是用于给出一个新Message，本例无参数，对应的在handler在队列中收到这条消息时，则通过handleMessage()进行处理*/
30. handler.sendMessage (handler.obtainMessage ());
31. }
32. }catch(Throwable t){
33. //jest end the thread
34. }
35. }
37. });
38. isRunning = true;
39. /*步骤3：启动线程*/
40. background.start();
41. }
43. /*onStop是UI停止显示时调用，例如我们按了返回键*/
44. protected void onStop() {
45. super.onStop();
46. isRunning = false;
47. }
48. }

例子2：采用Runnable


我们在上面的例子的基础上进行修改，如下

[java]view plain copy

1. /*步骤1：由于不需要处理Message，也即不需要处理handleMessage()*/
2. Handler handler= new Handler();
3. /*步骤1.1：定义处理动作，采用Runnable的实例，通过implements run（）来定制处理，这里是简单将进度条步进5。由于我们将在Thread中使用这个实例，所以考虑采用final的方式*/
4. final Runnable r = new Runnable() {
5. public void run(){
6. bar.incrementProgressBy(5);
7. }
8. };
9. /* ... ...在onStart()中的步骤2：线程的处理，和提供message不同，对于runnable方式，采用post */
10. Thread background = new Thread(new Runnable(){
11. public void run() {
12. try{
13. for(int i = 0; i < 20 && isRunning; i ++){
14. Thread.sleep(1000);
15. handler.post(r);
16. }
17. }catch(Throwable t){
18. //jest end the thread
19. }
20. }
21. });
22. background.start();

例子3：本程序还可以用延迟处理实现定时触发，让程序更为简单
在这里例子，事实我们是进行定时的处理，利用Handler队列可以设置延期处理的方式，我们并不需要创建一个后台运行的线程，也可以实现

[java]view plain copy

1. Handler handler= new Handler();
3. ... ... 在onStart() ... ...
4. //利用handler.postDelayed(r,1000)，在队列中要求延迟1秒后进行r的处理，而在r的处理中， 最后在handler的队列中加 入一个要求延迟1秒的处理，如是，就可以实现每隔1秒的定期处理。
5. handler.postDelayed(new Runnable() {
6. public void run() {
7. if(isRunning && Chapter15Test2.step < 20){
8. step ++;
9. bar.incrementProgressBy(5);
10. handler.postDelayed(this, 1000);
11. }
12. }
13. },1000 );

在这个例子中，我们基础某种判度，自动停止向队列加入处理。如果有某种情况，我们需要清除队列中的消息或者理，可以使用removMessages()或者removeCallbacks()的处理，这种对于延迟处理方式是非常有用的，可以中断定期的处理。当然，一般来讲我们希望能够得到某种判度，以使得定期处理能够优雅地结束，而不是简单地从队列中将消息或者处理删除。

例子4：不知道在UI主线程还是在后台线程

有时候，我们并不清楚代码将在UI线程还是后台线程运行，例如这些代码封装为一个JAR，提供给其他人调用，我们并不清楚其他人如何使用这些代码。为了解决这个问题Android在activity中提供了runOnUiThread()，如果在UI线程，则马上执行，如果在后台线程，则将Runnable的执行内容加入到后台线程的队列中，这样无论代码在UI线程还是后台线程都能安全地执行。

我们在例子1的基础上进行试验：

1、建立一个Runnable，以便我们将在UI和后台Thread中进行试验


[java]view plain copy

1. Runnable runAction = new Runnable(){
2. public void run(){
3. //注意，我们不能使用Toast.makeText(this,....)，因为我们无法确定Runnable具体运行的context
4. Toast.makeText(getApplicationContext (),"Hello!",Toast.LENGTH_SHORT).show();
5. //Log.d("WEI","runAction .... is called");
6. }
7. };

由于Toast的显示和隐藏需要一定的时间，而间隔1秒显然不够，我们将例子1的间隔时间1000ms，改为5000ms这样会比较清晰，当然可以采用Log.d的方式来替代。

2、在UI线程中执行该操作，在后台线程中增加该操作，这个操作无论是在UI还是在后台线程都是可以正确执行的。


[java]view plain copy

1. protected void onStart() {
2. ... ...
3. Thread background = new Thread(new Runnable(){
4. public void run() {
5. try{
6. for(int i = 0; i < 20 && isRunning; i ++){
7. Thread.sleep(5000);
8. handler.sendMessage(handler.obtainMessage());
9. runOnUiThread (runAction);
10. }
11. }catch(Throwable t){
12. //jest end the thread
13. }
14. }
15. });
17. isRunning = true;
18. background.start();
19. runOnUiThread (runAction);
20. }

例子5：HandlerThread

在上面的例子中，无论是否使用了后台线程（例子1-2），Handler的处理实际就是UI主线程的处理，一般的使用方式为我们通过后台线程执行某些操作，如果需要进行UI的互动，将消息或者处理方式到Handler的的队列中，然手在UI主线程中进行处理。这是我们通用的情况。

之前我们讨论过为何UI的归UI，处理的处理，然而，可能有这样的需求，举个例子，在某些情况下，Handler收到消息触发的处理中可能会有Sleep()，这会导致main线程进入sleep状态，不是我们期待的。因此我们希望通过一个线程专门处理Hanlder的消息，这个线程也是依次从Handler的队列中获取信息，逐个进行处理，保证安全，不会出现混乱引发的异常。

针对此Android提供的HandlerThread。方式使用方法如下：


[java]view plain copy

1. //步骤1：创新HandlerThread的一个对象，并开启这个线程，HandlerThread将通过Looper来处理Handler对来中的消息，也就是如果发现Handler中有消息，将在HandlerThread这个线程中进行处理。
2. HandlerThread ht = new HandlerThread("hander_thread");
3. //步骤2：启动handerhandler这个线程;
4. ht.start();
6. //步骤3：创建handler中，带上Looper的参数，即handlerThread.getLooper()。注意，此处理必须在HandlerThread启动后才能调用，否则会报错 ，getLooper()会返回null，则程序异常出错
7. Handler handler = new Handler(ht.getLooper()){
8. ....
9. public void handleMessage(Message msg){
10. ... .../*这里的处理，将不在主线程中执行，而在HandlerThread线程中执行，可以通过Thread.currentThread().getId()或者Thread.currentThread().getName()来确定*/
11. }
12. };

推荐阅读

• 

  汽车积碳是什么意思
• 

  redis多节点同步
• 

  27岁有稳定工作,想用20万存款当做第二职业来投资,投资什么好呢？
• 

  上海戏剧学院分数线 2019年上海戏剧学院分数线
• 

  去加拿大必买清单 去加拿大买什么最划算
• 

  室内阳台养什么花最好 室内阳台适合养什么花好
• 

  火理财什么时间可以申请债权转让？债权转让收费吗
• 

  塑料菜板发黑怎么办
• 

  癌细胞|癌细胞已经转移，为什么人的精神依旧很好，而且很能吃？是好事？
• 

  详细步骤及注意事项 g2810加墨水后如何操作
• 

  佳能相机7100 佳能7100单反
• 

  有什么好看的书推荐？
• 

  你喜欢看军事小说吗？
• 

  空气阻尼器时间继电器 空气阻尼器结构图
• 

  2023春节坐高铁需要全程戴口罩吗 2021春节能坐高铁吗
• 

  台高官被问“你有接受过性招待吗
• 

  农村籍独生子女补贴如何领取？四类人无法领取有你吗？
• 

  甲氰菊酯有效是多久 甲氰菊酯药效是几天，水里多久失效
• 

  c语言连接数据库函数 c语言数据库连接池
• 

  有宠app怎么关闭资讯推送通知？有宠app关闭资讯推送通知的方法