提出问题

新手刚开始接触Android线程编程的时候，会想到如下使用如下代码：

复制到剪贴板  Java代码

1. new Thread( new Runnable() {    
2.     public void run() {    
3.          myView.invalidate();   
4.      }           
5. }).start();  

但是：该实现方法是不可行的。

分析问题：

因为：Android UI操作并不是线程安全的,这些操作必须在UI线程中执行。

1.myView.invalidate()是UI操作；

2.new Thread创建了一个新的线程，是一个子线程，而不是UI线程，在这个新的线程里面对view进行刷新，这样是不安全的。

解决问题：

那么如何解决这个问题呢？

答案：使用Handler来实现UI线程的更新的。

实现步骤：

1.在view类里面定义一个Handler变量，这并没有开启一个新的线程，因此在handler里面更新本view是安全的；

2.然后我们创建一个线程，通过这个线程来给activity的handler变量发送消息，同时通过这个线程进行延时。

意即：

1．Handler接收消息和处理消息；

2．创建一个线程，来给Handler发送消息；

消息处理三部曲：

1．发送消息；

2．接收消息；

3．处理消息；

代码参考

首先创建简单的View,代码如下：

复制到剪贴板  Java代码

1. package com.ray.handler;  
2. import android.content.Context;  
3. import android.graphics.Canvas;  
4. import android.graphics.Color;  
5. import android.graphics.Paint;  
6. import android.graphics.Point;  
7. import android.graphics.drawable.Drawable;  
8. import android.view.View;  
9.    
10. public class BounceView extends View {  
11.    
12.     float x = 40;  
13.     public BounceView(Context context) {  
14.          super(context);  
15.     }  
16.    
17.     @Override  
18.     protected void onDraw(Canvas canvas) {  
19.          x+=10;  
20.          Paint mPaint = new Paint();  
21.          mPaint.setAntiAlias(true);  
22.          mPaint.setColor(Color.GREEN);  
23.          canvas.drawCircle(x, 40, 40, mPaint);  
24.     }  
25. }  
26.    

创建Activity类，代码如下：

复制到剪贴板  Java代码

1. package com.ray.handler;  
2. import android.app.Activity;  
3. import android.content.Context;  
4. import android.graphics.Canvas;  
5. import android.graphics.Color;  
6. import android.graphics.Paint;  
7. import android.os.Bundle;  
8. import android.os.Handler;  
9. import android.os.Message;  
10. import android.view.View;  
11. import android.view.Window;  
12.    
13. public class TestHandler extends Activity {  
14.      protected static final int GUIUPDATEIDENTIFIER = 0x101;  
15.    
16.      Thread myRefreshThread = null;  
17.      BounceView myBounceView = null;  
18.    
19.      Handler myHandler = new Handler() {//在主线程中创建Handler对象  
20.           public void handleMessage(Message msg) {//处理消息  
21.                switch (msg.what) {  
22.                     case TestHandler.GUIUPDATEIDENTIFIER://  
23.                          myBounceView.invalidate();//UI界面更新  
24.                          break;  
25.                }  
26.                super.handleMessage(msg);  
27.           }  
28.      };  
29.    
30.    
31.      public void onCreate(Bundle savedInstanceState) {  
32.    
33.           super.onCreate(savedInstanceState);  
34.           this.requestWindowFeature(Window.FEATURE_NO_TITLE);  
35.           this.myBounceView = new BounceView(this);  
36.           this.setContentView(this.myBounceView);  
37.    
38.           new Thread(new myThread()).start();//创建一个子线程  
39.    
40.      }  
41.    
42. //线程类，这个线程只是发送消息，然后延时而已。  
43.    
44.      class myThread implements Runnable {  
45.    
46.           public void run() {  
47.    
48.                while (!Thread.currentThread().isInterrupted()) {   
49.    
50.                       
51.    
52.                     Message message = new Message();  
53.    
54.                     message.what = TestHandler.GUIUPDATEIDENTIFIER;  
55.    
56.                       
57.    
58.                     TestHandler.this.myHandler.sendMessage(message); //发送一次消息，自动调用上面handler类的handleMessage函数，从而更新view类。  
59.    
60.                     try {  
61.    
62.                          Thread.sleep(100); //延时  
63.    
64.                     } catch (InterruptedException e) {  
65.    
66.                          Thread.currentThread().interrupt();  
67.    
68.                     }  
69.    
70.                }  
71.    
72.           }  
73.    
74.      }  
75.    
76. }