Android中的线程机制

Android中的好多应用，如UI更新，游戏开发，和耗时的操作都需要用到多线程的知识。而对Android中的线程机制好多人多觉得学习有困难。下面我们就一起来学习一下。

谈及Android中的线程我们会涉及到如下几个概念：

1. Handler 2. Looper 3. HandlerThread 4.Message 5. MessageQueue

下面我们由浅入深来探讨一下。我们用java多线程中很经典的例子计时器为例。我们要编写实现一个计时器，该如何编写呢？按照java中多线程的思路，我们很自然的会这样实现

代码如下：

 package xuan.blog.hander;

 import android.app.Activity;
 import android.os.Bundle;
 import android.util.Log;
 import android.view.View;
 import android.widget.Button;
 import android.widget.TextView;

 public class clockActivity extends Activity {
     /** Called when the activity is first created. */
     private String TAG="clockActivity";
     private Button endButton;
     private TextView textView;
     private Thread clockThread;
     private int timer=0;
     private boolean isRunning=true;
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         endButton=(Button)findViewById(R.id.endBtn);
         textView=(TextView)findViewById(R.id.textview);
         endButton.setOnClickListener(new View.OnClickListener() {

             @Override
             public void onClick(View v) {
                 // TODO Auto-generated method stub
                 isRunning=false;
             }
         });
         clockThread=new Thread(new Runnable(){

             @Override
             public void run() {
                 // TODO Auto-generated method stub
                 while(isRunning){
                     try{
                         Thread.currentThread().sleep(1000);
                         timer++;
                         textView.setText("走了"+timer+"秒");
                         Log.d(TAG,"time:"+timer);
                     }catch(InterruptedException e){
                         e.printStackTrace();
                     }
                 }
             }});
         clockThread.start();
     }
 }

我们用Thread的构造方法创建了一个线程对象，并启动了该线程，在该线程中来计算并更新textView。

然而，在Android中运行我们会发现这样会抛出异常！！

这是因为Android系统中的视图组件并不是线程安全的，在Android中UI的更新必须由主线程来完成。而上面我们违反了这一规则。

我们应该如何解决这个问题呢？我们应该让主线程负责创建，显示和更新UI控件，启动子线程，停止子线程。让子线程完成计算并向主线程发出更新UI的消息让主线程来更新UI。

如何实现子线程和主线程之间的消息传递呢？Android中为我们提供了Handler机制。

Handler是android中多线程间传递消息和计划任务的“工具”类。Handler 会在多个线程中发送Message和Runnable。

andler在多线程中有两方面的应用：

1.发送消息，在不同的线程间发送消息，使用方法sendXXX();

2.计算任务，在未来执行某任务，使用方法postXXX();

一个线程发出消息后，接受消息是通过重写Handler类中的handleMessage(Message)方法实现。

Handler也可以通过postXXX()方法提交计划任务，当取出一个任务Runnable是便会执行其中的run（）方法。

经过分析，我们用handler发送消息的应用修改上述代码：

 public class clockActivity extends Activity {
     /** Called when the activity is first created. */
     private String TAG="clockActivity";
     private Button endButton;
     private TextView textView;
     private Thread clockThread;
     private int timer=0;
     private boolean isRunning=true;
     private Handler handler;
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         endButton=(Button)findViewById(R.id.endBtn);
         textView=(TextView)findViewById(R.id.textview);
         endButton.setOnClickListener(new View.OnClickListener() {

             @Override
             public void onClick(View v) {
                 // TODO Auto-generated method stub
                 isRunning=false;
             }
         });
         handler=new Handler(){

             @Override
             public void handleMessage(Message msg) {
                 // TODO Auto-generated method stub
                 super.handleMessage(msg);
                 switch(msg.what){
                 case 0:textView.setText("走了"+timer+"秒");
                 }
             }

         };
         clockThread=new Thread(new Runnable(){

             @Override
             public void run() {
                 // TODO Auto-generated method stub
                 while(isRunning){
                     try{
                         Thread.currentThread().sleep(1000);
                         timer++;
                         //textView.setText("走了"+timer+"秒");
                         Message msg=new Message();
                         msg.obj=timer;
                         msg.what=0;
                         handler.sendMessage(msg);
                         Log.d(TAG,"time:"+timer);
                     }catch(InterruptedException e){
                         e.printStackTrace();
                     }
                 }
             }});
         clockThread.start();
     }
 }

通过这种方式便实现了子线程和主线程之间的通信。当然我们也可以通过Handler的执行计划任务来完成这计时器的功能，代码如下：

 public class clockActivity extends Activity {
     /** Called when the activity is first created. */
     private String TAG="clockActivity";
     private Button endButton;
     private TextView textView;
     private int timer=0;
     private boolean isRunning=true;
     private Handler handler;
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         endButton=(Button)findViewById(R.id.endBtn);
         textView=(TextView)findViewById(R.id.textview);
         endButton.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
                 // TODO Auto-generated method stub
                 isRunning=false;
             }
         });
         handler=new Handler();
         Runnable r=new Runnable(){

             @Override
             public void run() {
                 // TODO Auto-generated method stub
                 if(isRunning){
                     textView.setText("走了"+timer+"秒");
                     timer++;
                     handler.postDelayed(this, 1000);//提交任务r，延时1秒执行
                 }
             }
         };
         handler.postDelayed(r, 1000);
         }
 }

注意运行完handler.postDelayed(r, 1000);只是提交了一次任务，因此为了反复执行要在run()方法中再次提交。注意上述方法中发送任务和执行任务都是在主线程中实现的，我们并没有令启动线程。

在下一篇文章中，我们在具体分析一下Android中的消息机制。