Android学习笔记--Handler用法总结

不错的例子：http://www.cnblogs.com/menlsh/archive/2013/06/07/3125341.html

转自：一叶知秋的博客 http://blog.sina.com.cn/s/blog_77c6324101016jp8.html

1、Handler的定义:
　　Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI，用来跟UI主线程交互用。好比
　　(1) 能够用handler发送一个message，而后在handler的线程中来接收、处理该消息，以免直接在UI主线程中处理事务致使影响UI主线程的其余处理工做，Android提供了Handler做为主线程和子线程的纽带；
　　(2) 也能够将handler对象传给其余进程，以便在其余进程中经过handler给你发送事件；
　　(3) 还能够经过handler的延时发送message，能够延时处理一些事务的处理。

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

2、Handler一些特色
　　handler能够分发Message对象和Runnable对象到主线程中, 每一个Handler实例,都会绑定到建立他的线程中(通常是位于主线程), 也就是说Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，所以能够利用Handler所包含的消息队列，制定一些操做的顺序。

3、Handler中分发消息的一些方法
　　post(Runnable)
　　postAtTime(Runnable,long)
　　postDelayed(Runnable long)
　　　　post类方法容许你排列一个Runnable对象到主线程队列中
　　sendEmptyMessage(int)
　　sendMessage(Message)
　　sendMessageAtTime(Message,long)
　　sendMessageDelayed(Message,long)
　　　　sendMessage类方法, 容许你安排一个带数据的Message对象到队列中，等待更新.

4、应用实例：
1. 传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。
　　在Android中，对于UI的操做一般须要放在主线程中进行操做。若是在子线程中有关于UI的操做，那么就须要把数据消息做为一个Message对象发送到消息队列中，而后，用Handler中的handlerMessge方法处理传过来的数据信息，并操做UI。类sendMessage(Message msg)方法实现发送消息的操做。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操做。
2. 传递Runnable对象。用于经过Handler绑定的消息队列，安排不一样操做的执行顺序。
　　Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，能够将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不一样的Runnable对象中的run方法。
　　另外，Android的CPU分配的最小单元是线程，Handler通常是在某个线程里建立的，于是Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。因此说，他俩都算一个进程。

public class HandlerActivity extends Activity {
    // 声明两个按钮控件
    private Button startButton = null;
    private Button endButton = null;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        // 根据控件的ID获得表明控件的对象，并为这两个按钮设置相应的监听器
        startButton = (Button) findViewById(R.id.startButton);
        startButton.setOnClickListener(new StartButtonListener());
        endButton = (Button) findViewById(R.id.endButton);
        endButton.setOnClickListener(new EndButtonListener());
    }

    class StartButtonListener implements OnClickListener {
        @Override
        public void onClick(View v) {
            // 调用Handler的post方法，将要执行的线程对象添加到队列当中
            handler.post(updateThread);
        }
    }

    class EndButtonListener implements OnClickListener {
        @Override
        public void onClick(View v) {
            handler.removeCallbacks(updateThread);
        }
    }

    // 建立一个Handler对象
    Handler handler = new Handler();
    // 将要执行的操做写在线程对象的run方法当中
    Runnable updateThread = new Runnable() {
        @Override
        public void run() {
            System.out.println("UpdateThread");
            // 在run方法内部，执行postDelayed或者是post方法
            handler.postDelayed(updateThread, 3000);
        }
    };
}

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

3.  Handler和多线程
post方法虽然发送的是一个实现了Runnable接口的类对象，可是它并不是建立了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操做和主线程处于同一个线程。（验证：http://blog.sina.com.cn/s/blog_78c913e30100uqmf.html）
　　这样对于那些简单的操做，彷佛并不会影响。可是对于耗时较长的操做，就会出现“假死”。为了解决这个问题，就须要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。

public class HandlerTest2 extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        // 打印了当前线程的ID
        System.out.println("Activity-->" + Thread.currentThread().getId());
        // 生成一个HandlerThread对象
        HandlerThread handlerThread = new HandlerThread("handler_thread");
        // 在使用HandlerThread的getLooper()方法以前，必须先调用该类的start()，同时开启一个新线程;
        handlerThread.start();
        // 将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。
        // HandlerThread顾名思义就是能够处理消息循环的线程，它是一个拥有Looper的线程，能够处理消息循环；
        // 其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是一一对应的。
        MyHandler myHandler = new MyHandler(handlerThread.getLooper());
        Message msg = myHandler.obtainMessage();
        // 将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象
        Bundle b = new Bundle();
        b.putInt("age", 20);
        b.putString("name", "Jhon");
        msg.setData(b);
        msg.sendToTarget(); // 将msg发送到myHandler
    }

    // 定义类
    class MyHandler extends Handler {
        public MyHandler() {
        }

        public MyHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            Bundle b = msg.getData();
            int age = b.getInt("age");
            String name = b.getString("name");
            System.out.println("age is " + age + ", name is" + name);
            System.out.println("Handler--->" + Thread.currentThread().getId());
            System.out.println("handlerMessage");
        }
    }
}

　　这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操做完成时候继续进行，不会影响当前的操做。
　　这里须要注意，这里用到的多线程并不是由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是做为一个封装了操做的对象被传递，并未产生新线程。

另外再强调一遍，在UI线程（主线程）中：

mHandler=new Handler();
mHandler.post(new Runnable(){
    void run(){
        //执行代码..
    }
});

这个线程实际上是在UI线程以内运行的，并无新建线程。

常见的新建线程的方法是：

Thread thread = new Thread();
thread.start();

HandlerThread thread = new HandlerThread("string");
thread.start();

 

注意：：：：：http://blog.csdn.net/catherine880619/article/details/6719707

 

Message msg = handler.obtainMessage();
                        msg.arg1 = i;
                        msg.sendToTarget(); 

 

Message msg=new Message();
    msg.arg1=i;
    handler.sendMessage(msg);

 

 

相关资料：http://www.cnblogs.com/playing/archive/2011/03/24/1993583.html