android 中的 Handler Thread Runnable 的理解

前不久转载了一篇 Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系  文章，里面 提及到过 handler post 没有new 新的 thread，而是在UI thread 里面的。

handler 发送消息有下面这些：

       // post(Runnable)  

  

       // postAtTime(Runnable,long)  

  

       // postDelayed(Runnable,long)  

 

       // sendEmptyMessage(int)  

  

       // sendMessage(Message);  

  

       // sendMessageAtTime(Message,long)  

  

       // sendMessageDelayed(Message,long) 

今天有人问我，你说Handler的post方法创建的线程和UI线程有什么关系？

其实这个问题也是出现这篇博客的原因之一；这里需要说明，有时候为了方便，我们会直接写如下代码：

 mHandler.post(new Runnable()
         {
             @Override
             public void run()
             {
                 Log.e("TAG", Thread.currentThread().getName());
                 mTxt.setText("yoxi");
             }
         });

因为有回调 Looper 从messagequeue 读取 message ，对应应该回调 callback。 

 public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

分发消息的时候，如果是有 callback 不为空，则处理 

handleCallback(msg);   callback 其实就是 

 mHandler.post(new Runnable()

Runnable 。所以post 可以在 Runnable 里面直接处理

注意： run方法中可以写更新UI的代码，其实这个Runnable并没有创建什么线程，而是发送了一条消息。

好了，现在言归正传，开始今天真正要讨论的问题了，thread  、handler、 runnable 之间的区别。

先上个代码：通过线程更新button的内容。

 public class MyHandlerActivity extends Activity {

     Button button;

     MyHandler myHandler;



     protected void onCreate(Bundle savedInstanceState) {

         super.onCreate(savedInstanceState);

         setContentView(R.layout.handlertest);



         button = (Button) findViewById(R.id.button);

         myHandler = new MyHandler();

         // 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据

         // Handler有两个作用, (1) : 定时执行Message和Runnalbe 对象

         // (2): 让一个动作,在不同的线程中执行.



         // 它安排消息,用以下方法

         // post(Runnable)

         // postAtTime(Runnable,long)

         // postDelayed(Runnable,long)

         // sendEmptyMessage(int)

         // sendMessage(Message);

         // sendMessageAtTime(Message,long)

         // sendMessageDelayed(Message,long)



         // 以上方法以 post开头的允许你处理Runnable对象

         //sendMessage()允许你处理Message对象(Message里可以包含数据,)



         MyThread m = new MyThread();

         new Thread(m).start();

     }



     /**

     * 接受消息,处理消息 ,此Handler会与当前主线程一块运行

     * */



     class MyHandler extends Handler {

         public MyHandler() {

         }



         public MyHandler(Looper L) {

             super(L);

         }



         // 子类必须重写此方法,接受数据

         @Override

         public void handleMessage(Message msg) {

             // TODO Auto-generated method stub

             Log.d("MyHandler", "handleMessage......");

             super.handleMessage(msg);

             // 此处可以更新UI

             Bundle b = msg.getData();

             String color = b.getString("color");

             MyHandlerActivity.this.button.append(color);



         }

     }



     class MyThread implements Runnable {

         public void run() {



             try {

                 Thread.sleep(10000);

             } catch (InterruptedException e) {

                 // TODO Auto-generated catch block

                 e.printStackTrace();

             }



             Log.d("thread.......", "mThread........");

             Message msg = new Message();

             Bundle b = new Bundle();// 存放数据

             b.putString("color", "我的");

             msg.setData(b);



             MyHandlerActivity.this.myHandler.sendMessage(msg); // 向Handler发送消息,更新UI



         }

     }



 }

这个实例是变相的。其实原理是一样的。直接简单粗暴，不继承handler 和 runnable ，直接new操作和处理。原理是一样的。

 package com.example.span.view;

 import java.util.LinkedList;
 import android.app.AlertDialog;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Point;
 import android.graphics.RectF;
 import android.os.Handler;
 import android.os.Message;
 import android.util.AttributeSet;
 import android.view.KeyEvent;
 import android.view.View;
 import android.widget.Toast;

 import com.example.span.view.domain.Block;


 public class GameView extends View {

     public static boolean flag = true;
     public static Block block;
     public Handler handler;
     public static int dir = 2;
     public static final int DIRTOP = -1;
     public static final int DIRLEFT = -2;
     public static final int DIRDOWN = 1;
     public static final int DIRRIGHT = 2;
     public static int descount = 2;
     public Canvas canvas;
     public static Food food;
     public LinkedList<Point> points = new LinkedList<Point>();

     public LinkedList<Point> getPoints() {
         return points;
     }

     public void setPoints(LinkedList<Point> points) {
         this.points = points;
     }

     public GameView(Context context, AttributeSet attrs) {
         super(context, attrs);
         block = new Block(this);
         for (int i = 0; i < 3; i++) {
             Point point = new Point(block.getCx(), block.getCy());
             block.setCx(block.getCx() - 20);
             points.addLast(point);
         }
         food = new Food(this);
         handler = new Handler() {

             @Override
             public void handleMessage(Message msg) {
                 super.handleMessage(msg);
                 switch (msg.what) {
                 case DIRLEFT:
                     if (msg.what + descount != 0) {
                         descount = -2;
                         block.moveLeft();
                     } else {
                         block.moveRight();
                     }
                     break;
                 case DIRRIGHT:
                     if (msg.what + descount != 0) {
                         descount = 2;
                         block.moveRight();
                     } else {
                         block.moveLeft();
                     }
                     break;
                 case DIRTOP:
                     if (msg.what + descount != 0) {
                         descount = -1;
                         block.giveUp();
                     } else {
                         block.downLoad();
                     }
                     break;
                 case DIRDOWN:
                     if (msg.what + descount != 0) {
                         descount = 1;
                         block.downLoad();
                     } else {
                         block.giveUp();
                     }
                     break;
                 case -3:
                     Toast.makeText(getContext(), "Game Over", Toast.LENGTH_LONG)
                             .show();
                     new AlertDialog.Builder(getContext())
                             .setTitle("游戏提示")
                             .setMessage("Game Over")
                             .setPositiveButton("退出",
                                     new DialogInterface.OnClickListener() {

                                         @Override
                                         public void onClick(
                                                 DialogInterface dialog,
                                                 int which) {
                                             Thread.currentThread().stop();
                                         }
                                     })
                             .setNegativeButton("返回菜单",
                                     new DialogInterface.OnClickListener() {

                                         @Override
                                         public void onClick(
                                                 DialogInterface dialog,
                                                 int which) {

                                             Intent intent = new Intent();
                                             intent.setAction("android.intent.action.MAI");
                                             intent.addCategory("android.intent.category.LAUNCHER");
                                             intent.setFlags(0x10200000);
                                             intent.setComponent(new ComponentName(
                                                     "com.example.span",
                                                     "com.example.span.SpanActivity"));
                                             getContext().startActivity(intent);

                                         }
                                     }).show();
                     break;
                 }
             }
         };
         new Thread(new Runnable() {

             @Override
             public void run() {
                 while (flag) {
                     try {
                         Thread.sleep(500);
                         handler.sendEmptyMessage(dir);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
                 handler.sendEmptyMessage(-3);
             }
         }).start();
     }

     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
         System.out.println(keyCode);
         return super.onKeyDown(keyCode, event);
     }

     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         this.canvas = canvas;
         food.chsw(canvas);
         /*
          * if (descount == 2) { chsw(); } else { if (points.contains(new
          * Point(40, 40))) { System.out.println("吃掉食物了,,.."); } else { chsw(); }
          * }
          */
         Paint paint = new Paint();
         paint.setARGB(255, 255, 140, 0);
         for (Point p : points) {
             RectF rect = new RectF(p.x, p.y, 20 + p.x, 20 + p.y);
             canvas.drawRect(rect, paint);
         }
         // canvas.drawArc(rect, 0, 360, true, paint);

         // canvas.drawCircle(block.getCx(), block.getCy(), 10, paint);
     }

 }

Handler的定义:

 主要接受子线程发送的数据, 并用此数据配合主线程更新UI.


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


二、Handler一些特点


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

三、Thread 的多线程局限

只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。


下面看例子：


package org.thread.demo; 
class MyThread extends Thread{ 
private String name; 
public MyThread(String name) { 
super(); 
this.name = name; 
} 
public void run(){ 
for(int i=0;i<10;i++){ 
System.out.println("线程开始："+this.name+",i="+i); 
} 
} 
} 
package org.thread.demo; 
public class ThreadDemo01 { 
public static void main(String[] args) { 
MyThread mt1=new MyThread("线程a"); 
MyThread mt2=new MyThread("线程b"); 
mt1.run(); 
mt2.run(); 
} 
}
但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动start()方法启动线程：


package org.thread.demo;  
public class ThreadDemo01 {  
public static void main(String[] args) {  
MyThread mt1=new MyThread("线程a");  
MyThread mt2=new MyThread("线程b");  
mt1.start();  
mt2.start();  
}  
};
这样程序可以正常完成交互式运行。那么为啥非要使用start();方法启动多线程呢？

package org.demo.dff;  
class MyThread extends Thread{  
private int ticket=10;  
public void run(){  
for(int i=0;i<20;i++){  
if(this.ticket>0){  
System.out.println("卖票：ticket"+this.ticket--);  
}  
}  
}  
};
下面通过三个线程对象，同时卖票：


package org.demo.dff;  
public class ThreadTicket {  
public static void main(String[] args) {  
MyThread mt1=new MyThread();  
MyThread mt2=new MyThread();  
MyThread mt3=new MyThread();  
mt1.start();//每个线程都各卖了10张，共卖了30张票  
mt2.start();//但实际只有10张票，每个线程都卖自己的票  
mt3.start();//没有达到资源共享  
}  
}

四、Runnable接口

在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。


public interface Runnable{  
public void run();  
} 
例子：
package org.runnable.demo;  
class MyThread implements Runnable{  
private String name;  
public MyThread(String name) {  
this.name = name;  
}
public void run(){  
for(int i=0;i<100;i++){  
System.out.println("线程开始："+this.name+",i="+i);  
}  
}  
};
但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。（start()可以协调系统的资源）：


package org.runnable.demo;  
import org.runnable.demo.MyThread;  
public class ThreadDemo01 {  
public static void main(String[] args) {  
MyThread mt1=new MyThread("线程a");  
MyThread mt2=new MyThread("线程b");  
new Thread(mt1).start();  
new Thread(mt2).start();  
}  
}

package org.demo.runnable; 
class MyThread implements Runnable{ 
private int ticket=10; 
public void run(){ 
for(int i=0;i<20;i++){ 
if(this.ticket>0){ 
System.out.println("卖票：ticket"+this.ticket--); 
} 
} 
} 
} 
package org.demo.runnable; 
public class RunnableTicket { 
public static void main(String[] args) { 
MyThread mt=new MyThread(); 
new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一 
new Thread(mt).start();//个实例化对象mt，就会出现异常 
new Thread(mt).start(); 
} 
};

通过 上面 thread  runnable 的对买票系统代码区别会发现  实现Runnable接口相比继承Thread类有如下好处：

• 避免点继承的局限，一个类可以继承多个接口。
• 适合于资源的共享

而且在开发中多线程都用 runnable 接口实现。

Runnable接口和Thread之间的联系：

public class Thread extends Object implements Runnable

发现Thread类也是Runnable接口的子类。

呵呵，这下好玩了，也很多事情说的通了，

Thread是系统给你的资源，有了Thread你才有从CPU那里得到可执行时间片的权力， 

  Thread并不认识你的程序，不知道有test 这样的类，因为编序员有千千万，每个人命名都不一样，想要做的事都不一样， 所以 Thread只认识一个！ 那就是Runnable 。

 Thread认识Runnable 并且知道Runnable 里面有一个run方法. 一旦调用Thread的start方法，Runnable 方法里的run就会被Thread自动运行。 

所以，当我们把我们的类继承（这里应该叫实现接口）自Runnable 的时候，我们的程序就是属于Runnable 一个类型的了。 虽然是Runnable 的子类，但人家认识你爸爸，当然也知道了你。 Thread可以不管你内部有什么情况，他只管你有run()方法就行了，他就调start让你去运行run 

所以我们在run里面写点东西，这样就可以让系统运行我们想要做的代码了。 

是不是很通俗很易懂呢？ 所以要运行线程的步骤是， 

1。生成我们自己的类对象 

2。从系统那里得到Thread 

3。让Threa调我们的类对象，让其start起来 代码: test a=new test(); Thread thread=new Thread(a); //Thread需要一个参数，就是你编的线程类，这样他就认识了你的线程，也有资格向系统申请拿到CPU时间片thread.start(); 你可以简单点写： new Thread(a).start();

Runnable 并不一定是新开一个线程，比如下面的调用方法就是运行在UI主线程中的：

   Handler mHandler=new Handler(); 
     mHandler.post(new Runnable(){ 
        @Override public void run() 
        { // TODO Auto-generated method stub 
         } 
     });

Runnable是一个接口，不是一个线程，一般线程会实现Runnable。所以如果我们使用匿名内部类是运行在UI主线程的，如果我们使用实现这个Runnable接口的线程类，则是运行在对应线程的。

具体来说，这个函数的工作原理如下：

View.post(Runnable)方法。在post(Runnable action)方法里，View获得当前线程（即UI线程）的Handler，然后将action对象post到Handler里。在Handler里，它将传递过来的action对象包装成一个Message（Message的callback为action），然后将其投入UI线程的消息循环中。在Handler再次处理该Message时，有一条分支（未解释的那条）就是为它所设，直接调用runnable的run方法。而此时，已经路由到UI线程里，因此，我们可以毫无顾虑的来更新UI。

如下图，前面看到的代码，我们这里Message的callback为一个Runnable的匿名内部类

这种情况下，由于不是在新的线程中使用，所以千万别做复杂的计算逻辑。

五、handler，Thread和Runnable这三个类，那么他们之间的关系

首先说明Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。

而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。

HandlerThread顾名思义就是可以处理消息循环的线程，他是一个拥有Looper的线程，可以处理消息循环。

与其说Handler和一个线程绑定，不如说Handler是和Looper一一对应的。

最后需要说明的是，在UI线程(主线程)中：

　mHandler=new Handler();
　　mHandler.post(new Runnable(){
　　void run(){
　　//执行代码...
　　}
　　});
　　这个线程其实是在UI线程之内运行的，并没有新建线程。
　　常见的新建线程的方法是：
　　Thread thread = new Thread();
　　thread.start();
　　HandlerThread thread = new HandlerThread("string");
　　thread.start();

六、