Android 线程

1.为什么使用多线程
当我们需要执行一些耗时操作，比如发起一条网络请求，服务器未必会立刻响应我们的请求（造成ANR ，Application Not Response），因此必须将这些耗时操作放在子线程中，以此防止主线程被阻塞住。
2.实现方式
2.1） 继承自Thread类，重写它run()方法，通过它的start()来启动线程。
代码如下：

      class MyThread extends Thread {
                   @Override
                   public void run() {
                   //处理具体的逻辑     
           }       
}
new Thread.start();

2.2）实现Runnable接口，重写它run()方法，以这个对象来构造Thread对象。
代码如下：

     class MyThread implements Runnable {
                   @Override
                   public void run() {
                   //处理具体的逻辑     
           }       
}
MyThread myThread = new MyThread();//创建目标对象
Thread thread = new Thread(myThread);//创建线程，其目标对象是myThread
thread.start();//启动线程
//new Thread(myThread).start();

2.3）扩展java.lang.Thread类，使用匿名类方式。
代码如下：

     new Thread(new Runnable(){
          @Override
          public void run(){
          //处理具体的逻辑
          }
    }).start();
    或者
    Thread thread = new Thread(new Runnable(){
          @Override
          public void run(){
          //处理具体的逻辑
          }
    });
    thread.start();

3.异步消息处理机制
3.1） Android不允许在子线程中更新UI，为了解决此问题Android提供了一套异步消息处理机制。
3.2） Android中异步消息处理主要由四个部分组成，Message、Handler、MessageQueue和Looper。如下图所示。

因此，此图中可以看出消息处理的流程。首先需要在主线程中创建一个Handler对象，并重写handlerMessage()方法。然后当子线程中需要进行UI操作时，就创建一个Message对象，并通过Handler将此条消息发出。之后这条消息会被添加到MessageQueue的队列中等待被处理，而Looper则会一直尝试从MessageQueue中取出带处理消息，最后分发回Handler的handlerMessage()方法中并且在此方法中做对应的处理。
1） Message 是在线程之间传递消息，它可以携带少量信息，用于在不同的线程之间交换数据。可以使用Message的what、arg1、arg2和object字段。
2 ) Handler 处理者的意思，它主要用于发送和处理消息的。一般使用Handler的SendMessage()方法，经过一系列的处理最终会传递到Handler的handlerMessage()中。
3）MessageQueue 消息队列的意思，它主要用于存放所有通过Handler发送的消息。这部分消息会一直存在于消息队列中，等待被处理。每个线程只会有一个MessageQueue对象。
4）Looper 是每个线程中MessageQueue的管家，调用Looper的loop方法后，就会进入到一个无线循环当中，然后每当发现MessageQueue中存在一条消息，就会将它取出，并传递到Handler的handlerMessage()方法中。每个Thread只对应一个Looper，每个Looper只对应一个MessageQueue。
4.代码如下：
子线程向主线程发送消息更新UI

public class MainActivityClass extends Activity {

    private static final int UPDATE_VERSION = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        updateVersion();
    }

    private void updateVersion() {
        new Thread() {
            public void run() {
                //此处执行耗时操作
                //然后通过Handler发送Message
                Message msg = Message.obtain();
                msg.what = UPDATE_VERSION;
                mHandler.sendMessage(msg);
            }
        }.start();
    }

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case UPDATE_VERSION:
                    //收到对应的消息，进行下一步处理
                    break;

            }
        }
    };
}

主线程向子线程传递消息（你好，子线程）

public class MainActivityClass2 extends Activity {

    private final int MSG_SEND = 1;
    private Handler mHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new ChildThread().start();//新建并启动ChildThread 实例
        findViewById(R.id.btn).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String str = "你好，子线程";
                //发送消息到ChildThread实例
                mHandler.obtainMessage(MSG_SEND, str).sendToTarget();
            }
        });
    }

    private class ChildThread extends Thread {
        @Override
        public void run() {
            //建立消息循环的步
            Looper.prepare();//1、初始化Looper
            mHandler = new Handler() {//2、绑定handler到ChildThread 实例的Looper对象
                public void handleMessage(Message msg) {//3、定义处理消息的方法
                    switch (msg.what) {
                        case MSG_SEND:
                            //接收主线程发过来的消息，进行下一步处理。
                            Log.v("Sun", "ChildThread msg:" + (String) msg.obj);
                    }
                }
            };
            Looper.loop();//4、启动消息循环
        }
    }
}

总结：
第一段代码： 子线程向主线程发送消息更新UI；UI线程在创建的时候就建立了消息循环，因此我们可以在其他线程给UI线程的handler发送消息，达到更新UI的目的。
第二段代码：主线程向子线程传递消息（你好，子线程）；而子线程在创建的时候并没有建立消息循环，因此需要手动添加。子线程可以把Looper设为该线程的局部变量，通过Looper的prepare()方法就可以新建一个Looper，然后在通过Looper的loop()方法进行消息循环；此过程就相当于在这个线程建立了一个对应的消息队列。Looper持有消息队列MessageQueue对象，而Handler的作用就是封装发送消息和处理消息的过程，其他线程只需要操作Handler就可以发消息给创建Handler的线程。
最后介绍这篇文章，关于Android线程管理，即Handler的消息分发，处理机制。 由于这个连接是别人写的，所以标明转载出处。http://www.cnblogs.com/younghao/p/5116819.html