Android中有着和J2SE同样优秀的多线程支持，可以把那些耗时较多的操作放在新线程中操作。但是当新线程中有涉及到操作UI的操作时，就会对主线程产生危险，因此，Android提供了Handler作为主线程和子线程的纽带。同时，Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，因此可以利用Handler所包含的消息队列，制定一些操作的顺序。

根据SDK文档的说明：“A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue.”由此可以清楚的知道，可以把消息和Runnble对象发送到与Handler对象所关联的消息队列中去。

下面，就Handler的以上两点作用，分别进行讨论。

1. 传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。

在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，有Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。当然，Handler对象是在主线程中初始化的，以为它需要绑定在主线程的消息队列中。

类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。


                        
                                
  1. //Handler处理子线程消息代码示例： 
    2.                             
    3.                             
  3. publicclassActivity01extendsActivity 
    4.                             
  4. { 
    5.                             
  5. //声明ProgressBar对象 
    6.                             
  6. privateProgressBarm_ProgressBar; 
    7.                             
  7. privateProgressBarm_ProgressBar2; 
    8.                             
  8. privateButtonmButton01; 
    9.                             
  9. protectedstaticfinalintGUI_STOP_NOTIFIER=0x108; 
    10.                             
  10. protectedstaticfinalintGUI_THREADING_NOTIFIER=0x109; 
    11.                             
  11. publicintintCounter=0; 
    12.                             
  12. /**Calledwhentheactivityisfirstcreated.*/
    13.                             
  13. @Override
    14.                             
  14. publicvoidonCreate(BundlesavedInstanceState) 
    15.                             
  15. { 
    16.                             
  16. super.onCreate(savedInstanceState); 
    17.                             
  17. //设置窗口模式，，因为需要显示进度条在标题栏 
    18.                             
  18. requestWindowFeature(Window.FEATURE_PROGRESS); 
    19.                             
  19. setProgressBarVisibility(true); 
    20.                             
  20. setContentView(R.layout.main); 
    21.                             
  21.  
    22.                             
  22. //取得ProgressBar 
    23.                             
  23. m_ProgressBar=(ProgressBar)findViewById(R.id.ProgressBar01); 
    24.                             
  24. m_ProgressBar2=(ProgressBar)findViewById(R.id.ProgressBar02); 
    25.                             
  25. mButton01=(Button)findViewById(R.id.Button01); 
    26.                             
  26.  
    27.                             
  27. m_ProgressBar.setIndeterminate(false); 
    28.                             
  28. m_ProgressBar2.setIndeterminate(false); 
    29.                             
  29.  
    30.                             
  30. //当按钮按下时开始执行, 
    31.                             
  31. mButton01.setOnClickListener(newButton.OnClickListener() 
    32.                             
  32. { 
    33.                             
  33. @Override
    34.                             
  34. publicvoidonClick(Viewv) 
    35.                             
  35. { 
    36.                             
  36. //TODOAuto-generatedmethodstub 
    37.                             
  37.  
    38.                             
  38. //设置ProgressBar为可见状态 
    39.                             
  39. m_ProgressBar.setVisibility(View.VISIBLE); 
    40.                             
  40. m_ProgressBar2.setVisibility(View.VISIBLE); 
    41.                             
  41. //设置ProgressBar的最大值 
    42.                             
  42. m_ProgressBar.setMax(100); 
    43.                             
  43. //设置ProgressBar当前值 
    44.                             
  44. m_ProgressBar.setProgress(0); 
    45.                             
  45. m_ProgressBar2.setProgress(0); 
    46.                             
    47.                             
  47. //通过线程来改变ProgressBar的值 
    48.                             
  48. newThread(newRunnable(){ 
    49.                             
  49. publicvoidrun() 
    50.                             
  50. { 
    51.                             
  51. for(inti=0;i<10;i++) 
    52.                             
  52. { 
    53.                             
  53. try
    54.                             
  54. { 
    55.                             
  55. intCounter=(i+1)*20; 
    56.                             
  56. Thread.sleep(1000); 
    57.                             
    58.                             
  58. if(i==4) 
    59.                             
  59. { 
    60.                             
  60. Messagem=newMessage(); 
    61.                             
    62.                             
  62. m.what=Activity01.GUI_STOP_NOTIFIER; 
    63.                             
  63. Activity01.this.myMessageHandler.sendMessage(m);
    64.                             
  64.  //将message发送到消息队列 
    65.                             
  65. break; 
    66.                             
  66. } 
    67.                             
  67. else
    68.                             
  68. { 
    69.                             
  69. Messagem=newMessage(); 
    70.                             
  70. m.what=Activity01.GUI_THREADING_NOTIFIER; 
    71.                             
  71. Activity01.this.myMessageHandler.sendMessage(m); 
    72.                             
  72.  //将message发送到消息队列 
    73.                             
  73. } 
    74.                             
  74. } 
    75.                             
  75. catch(Exceptione) 
    76.                             
  76. { 
    77.                             
  77. e.printStackTrace(); 
    78.                             
  78. } 
    79.                             
  79. } 
    80.                             
  80. } 
    81.                             
  81. }).start(); 
    82.                             
  82. } 
    83.                             
  83. }); 
    84.                             
  84. } 
    85.                             
    86.                             
  86. //通过匿名类复写Handler类中的handleMessage方法，用于接收传递到消息队列中的Message，并进行UI操作。
    87.                             
  87. HandlermyMessageHandler=newHandler() 
    88.                             
  88. { 
    89.                             
  89. //@Override 
    90.                             
  90. publicvoidhandleMessage(Messagemsg) 
    91.                             
  91. { 
    92.                             
  92. switch(msg.what) 
    93.                             
  93. { 
    94.                             
  94. //ProgressBar已经是对大值 
    95.                             
  95. caseActivity01.GUI_STOP_NOTIFIER: 
    96.                             
  96. m_ProgressBar.setVisibility(View.GONE); 
    97.                             
  97. m_ProgressBar2.setVisibility(View.GONE); 
    98.                             
  98. Thread.currentThread().interrupt(); 
    99.                             
  99. break; 
    100.                             
  100. caseActivity01.GUI_THREADING_NOTIFIER: 
    101.                             
  101. if(!Thread.currentThread().isInterrupted()) 
    102.                             
  102. { 
    103.                             
  103. //改变ProgressBar的当前值 
    104.                             
  104. m_ProgressBar.setProgress(intCounter); 
    105.                             
  105. m_ProgressBar2.setProgress(intCounter); 
    106.                             
  106.  
    107.                             
  107. //设置标题栏中前景的一个进度条进度值 
    108.                             
  108. setProgress(intCounter*100); 
    109.                             
  109. //设置标题栏中后面的一个进度条进度值 
    110.                             
  110. setSecondaryProgress(intCounter*100);// 
    111.                             
  111. } 
    112.                             
  112. break; 
    113.                             
  113. } 
    114.                             
  114. super.handleMessage(msg); 
    115.                             
  115. } 
    116.                             
  116. }; 
    117.                             
  117. } 
    118.

以上的例子中，子线程只是对进度条的参数进行了变更，并将结果以message形式发送到消息队列中去，子线程的内部并未进行UI操作，而是在重写的Handler的handlerMessage方法中操作了UI界面。

2. 传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。

Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。

                        
                                
  1. publicclassHandlerActivityextendsActivity{ 
    2.                             
  2. /**Calledwhentheactivityisfirstcreated.*/
    3.                             
  3. //声明两个按钮控件 
    4.                             
  4. privateButtonstartButton=null; 
    5.                             
  5. privateButtonendButton=null; 
    6.                             
  6. @Override
    7.                             
  7. publicvoidonCreate(BundlesavedInstanceState){ 
    8.                             
  8. super.onCreate(savedInstanceState); 
    9.                             
  9. setContentView(R.layout.main); 
    10.                             
  10. //根据控件的ID得到代表控件的对象，并未这两个按钮设置相应的监听器 
    11.                             
  11. startButton=(Button)findViewById(R.id.startButton); 
    12.                             
  12. startButton.setOnClickListener(newStartButtonListener()); 
    13.                             
  13. endButton=(Button)findViewById(R.id.endButton); 
    14.                             
  14. endButton.setOnClickListener(newEndButtonListener()); 
    15.                             
  15.  
    16.                             
  16. } 
    17.                             
  17. classStartButtonListenerimplementsOnClickListener{ 
    18.                             
    19.                             
  19. @Override
    20.                             
  20. publicvoidonClick(Viewv){ 
    21.                             
  21. //调用Handler的post方法，将要执行的线程对象添加到队列当中 
    22.                             
  22. handler.post(updateThread); 
    23.                             
  23. } 
    24.                             
  24.  
    25.                             
  25. } 
    26.                             
  26.  
    27.                             
  27. classEndButtonListenerimplementsOnClickListener{ 
    28.                             
    29.                             
  29. @Override
    30.                             
  30. publicvoidonClick(Viewv){ 
    31.                             
  31. handler.removeCallbacks(updateThread); 
    32.                             
  32. } 
    33.                             
  33.  
    34.                             
  34. } 
    35.                             
  35. //创建一个Handler对象 
    36.                             
  36. Handlerhandler=newHandler(); 
    37.                             
  37. //将要执行的操作写在线程对象的run方法当中 
    38.                             
  38. RunnableupdateThread=newRunnable(){ 
    39.                             
    40.                             
  40. @Override
    41.                             
  41. publicvoidrun(){ 
    42.                             
  42. System.out.println("UpdateThread"); 
    43.                             
  43. //在run方法内部，执行postDelayed或者是post方法 
    44.                             
  44. handler.postDelayed(updateThread,3000); 
    45.                             
  45. } 
    46.                             
  46.  
    47.                             
  47. }; 
    48.                             
  48. }
    49.

程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。

3. Handler和多线程

post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。

这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，当它被加入到消息队列中之后执行会占用很长的时间，以至于处于同一线程的其他操作无法继续执行，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。SDK文档中也提供了相关说明：

When a process is created for your application, its main thread is dedicated to running a message queue that takes care of managing the top-level application objects (activities, broadcast receivers, etc) and any windows they create. You can create your own threads, and communicate back with the main application thread through a Handler. This is done by calling the same post or sendMessage methods as before, but from your new thread. The given Runnable or Message will than be scheduled in the Handler's message queue and processed when appropriate.

具体操作方法如下：


                        
                                
  1. publicclassHandlerTest2extendsActivity{ 
    2.                             
    3.                             
  3. @Override
    4.                             
  4. protectedvoidonCreate(BundlesavedInstanceState){ 
    5.                             
  5. //TODOAuto-generatedmethodstub 
    6.                             
  6. super.onCreate(savedInstanceState); 
    7.                             
  7. setContentView(R.layout.main); 
    8.                             
  8. //打印了当前线程的ID 
    9.                             
  9. System.out.println("Activity-->"+Thread.currentThread().getId()); 
    10.                             
  10. //生成一个HandlerThread对象 
    11.                             
  11. HandlerThreadhandlerThread=newHandlerThread("handler_thread"); 
    12.                             
  12. //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程; 
    13.                             
  13. handlerThread.start();
    14.                             
  14.  //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。 
    15.                             
  15. MyHandlermyHandler=newMyHandler(handlerThread.getLooper()); 
    16.                             
  16. Messagemsg=myHandler.obtainMessage(); 
    17.                             
  17. //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象 
    18.                             
  18. Bundleb=newBundle(); 
    19.                             
  19. b.putInt("age",20); 
    20.                             
  20. b.putString("name","Jhon"); 
    21.                             
  21. msg.setData(b); 
    22.                             
  22. msg.sendToTarget(); //将msg发送到myHandler
    23.                             
  23. } 
    24.                             
  24.  
    25.                             
  25.  //定义类
    26.                             
  26. classMyHandlerextendsHandler{ 
    27.                             
  27. publicMyHandler(){ 
    28.                             
  28.  
    29.                             
  29. } 
    30.                             
  30.  
    31.                             
  31. publicMyHandler(Looperlooper){ 
    32.                             
  32. super(looper); 
    33.                             
  33. } 
    34.                             
  34. @Override
    35.                             
  35. publicvoidhandleMessage(Messagemsg){ 
    36.                             
  36. Bundleb=msg.getData(); 
    37.                             
  37. intage=b.getInt("age"); 
    38.                             
  38. Stringname=b.getString("name"); 
    39.                             
  39. System.out.println("ageis"+age+",nameis"+name); 
    40.                             
  40. System.out.println("Handler--->"+Thread.currentThread().getId()); 
    41.                             
  41. System.out.println("handlerMessage"); 
    42.                             
  42. } 
    43.                             
  43. } 
    44.                             
  44. } 
    45.

这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。

这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。

更多相关文章

  1. android中handler使用WeakReference防止内存泄露
  2. Android并发编程1-----多线程
  3. Android(安卓)深入讲解Handler机制
  4. Android同步类：Mutex和Condition
  5. 面试时总被面试官挖的Android基础题掉坑里？整理了26道面试题 ，牢固
  6. Android线程池-学习总结
  7. Android多线程的实现方式及使用场景
  8. 很通俗易懂的概念Activity,Window,DecorView
  9. AsyncTask的用法总结

随机推荐

  1. 【MySQL】如何对SQL语句进行跟踪（trace）？
  2. MySQL SQL hint 提示
  3. nmap***测试--版本探测
  4. centos7下安装docker
  5. python实战系列之python变量
  6. MySQL 隐式类型转换
  7. 学Linux运维的前景
  8. python实战课程--控制结构
  9. 在Oracle中，如何判断一个字符串是否为数字
  10. Mybatis 最近知识总结（1）