Handler使用笔记

最新推荐文章于 2015-07-18 16:10:46 发布

碗豆先生

最新推荐文章于 2015-07-18 16:10:46 发布

阅读量466

点赞数

分类专栏： Android

本文链接：https://blog.csdn.net/u010297828/article/details/46806261

版权

Android 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

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

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

new Thread( new Runnable() {     
publicvoid run() {     
         myView.invalidate();    
     }            
}).start();

但是，但是这样是不行的，因为它违背了单线程模型：Android UI操作并不是线程安全的并且这些操作必须在UI线程中(主线程)执行。
Android中常用的方法是利用Handler来实现UI线程的更新的。Handler来根据接收的消息，处理UI更新。Thread线程发出Handler消息，通知更新UI。

Handler myHandler = new Handler() {  
publicvoid handleMessage(Message msg) {   
switch (msg.what) {   
case TestHandler.GUIUPDATEIDENTIFIER:   
                         myBounceView.invalidate();  
break;   
               }   
super.handleMessage(msg);   
          }   
     };  



class myThread implements Runnable {   
publicvoid run() {  
while (!Thread.currentThread().isInterrupted()) {    

        Message message = new Message();   
        message.what = TestHandler.GUIUPDATEIDENTIFIER;   

        TestHandler.this.myHandler.sendMessage(message);   
try {   
        Thread.sleep(100);    
     } catch (InterruptedException e) {   
        Thread.currentThread().interrupt();   
     }   
   }   
 }   
}

二、Handler一些特点
handler可以分发Message对象和Runnable对象到主线程中，每个Handler实例，都会绑定到创建他的线程中(一般是位于主线程)，它有两个作用：

(1)安排消息或Runnable 在某个主线程中某个地方执行；

(2)安排一个动作在不同的线程中执行。
Handler中分发消息的一些方法

post(Runnable)

postAtTime(Runnable，long)

postDelayed(Runnable long)

sendEmptyMessage(int)

sendMessage(Message)

sendMessageAtTime(Message，long)

sendMessageDelayed(Message，long)

以上post类方法允许你排列一个Runnable对象到主线程队列中，

sendMessage类方法，允许你安排一个带数据的Message对象到队列中，等待更新。

三、Handler消息机制
这一部分参考：这里写链接内容
andriod提供了Handler 和 Looper 来满足线程间的通信。Handler先进先出原则。Looper类用来管理特定线程内对象之间的消息交换(MessageExchange)。
1)Looper: 一个线程可以产生一个Looper对象，由它来管理此线程里的MessageQueue(消息队列)。
2)Handler: 你可以构造Handler对象来与Looper沟通，以便push新消息到MessageQueue里;或者接收Looper从Message Queue取出)所送来的消息。
3) Message Queue(消息队列):用来存放线程放入的消息。
4)线程：UIthread 通常就是main thread，而Android启动程序时会替它建立一个MessageQueue。

1.Handler创建消息
每一个消息都需要被指定的Handler处理，通过Handler创建消息便可以完成此功能。Android消息机制中引入了消息池。Handler创建消息时首先查询消息池中是否有消息存在，如果有直接从消息池中取得，如果没有则重新初始化一个消息实例。使用消息池的好处是：消息不被使用时，并不作为垃圾回收，而是放入消息池，可供下次Handler创建消息时使用。消息池提高了消息对象的复用，减少系统垃圾回收的次数。消息的创建流程如图所示。
这里写图片描述
2.Handler发送消息

UI主线程初始化第一个Handler时会通过ThreadLocal创建一个Looper，该Looper与UI主线程一一对应。使用ThreadLocal的目的是保证每一个线程只创建唯一一个Looper。之后其他Handler初始化的时候直接获取第一个Handler创建的Looper。Looper初始化的时候会创建一个消息队列MessageQueue。至此，主线程、消息循环、消息队列之间的关系是1:1:1。

Handler、Looper、MessageQueue的初始化流程如图所示:
这里写图片描述
Hander持有对UI主线程消息队列MessageQueue和消息循环Looper的引用，子线程可以通过Handler将消息发送到UI线程的消息队列MessageQueue中。
3.Handler处理消息

UI主线程通过Looper循环查询消息队列UI_MQ，当发现有消息存在时会将消息从消息队列中取出。首先分析消息，通过消息的参数判断该消息对应的Handler，然后将消息分发到指定的Handler进行处理。

子线程通过Handler、Looper与UI主线程通信的流程如图所示。
这里写图片描述

四.Handler实例

Handler使用例1
这个例子是最简单的介绍handler使用的,是将handler绑定到它所建立的线程中.
本次实验完成的功能是:单击Start按钮，程序会开始启动线程，并且线程程序完成后延时1s会继续启动该线程，每次线程的run函数中完成对界面输出nUpdateThread…文字，不停的运行下去，当单击End按钮时，该线程就会停止，如果继续单击Start，则文字又开始输出了。
这里写图片描述


package com.example.handler1;  
 import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView; 
 public class MainActivity extends Activity { 
     private TextView text_view = null;
    private Button start = null;
    private Button end = null;

    //使用handler时首先要创建一个handler
    Handler handler = new Handler();
    //要用handler来处理多线程可以使用runnable接口，这里先定义该接口
    //线程中运行该接口的run函数
    Runnable update_thread = new Runnable()
    {
        public void run()
        {
            //线程每次执行时输出"UpdateThread..."文字,且自动换行
            //textview的append功能和Qt中的append类似，不会覆盖前面
            //的内容，只是Qt中的append默认是自动换行模式
            text_view.append("\nUpdateThread...");
            //延时1s后又将线程加入到线程队列中
            handler.postDelayed(update_thread, 1000);

        }
    };

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

        text_view = (TextView)findViewById(R.id.text_view);
        start = (Button)findViewById(R.id.start);
        start.setOnClickListener(new StartClickListener());
        end = (Button)findViewById(R.id.end);
        end.setOnClickListener(new EndClickListener());

    } 
     private class StartClickListener implements OnClickListener
    {
        public void onClick(View v) {
            // TODO Auto-generated method stub
            //将线程接口立刻送到线程队列中
            handler.post(update_thread);
        }                
    }

    private class EndClickListener implements OnClickListener
    { 
         public void onClick(View v) {
            // TODO Auto-generated method stub
            //将接口从线程队列中移除
            handler.removeCallbacks(update_thread);
        }

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }
}

Handler使用例2

这个例子比刚才那个例子稍微复杂些。因为这个例子中用到了handler的消息队列机制，即通过handler中一个线程向消息队列中用sendMessage方法发送消息，发送的消息当然可以用来传递参数。在handler中用handleMessage来处理消息，处理方法是获得消息队列中的消息参数，用这些参数来完成另外一些功能。
本实验实现的是当开始按钮按下时，会启动一个线程，并绑定到handler中，该线程发送带有参数的message到handler的消息队列中，消息队列的另一端获取该消息，并且用该消息的参数来更新进度条。
这里写图片描述

这里写图片描述


package com.example.handler2;  
 import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ProgressBar; 
 public class MainActivity extends Activity { 
     private ProgressBar progress_bar = null;
    private Button start = null;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        progress_bar = (ProgressBar)findViewById(R.id.progress_bar);
        start = (Button)findViewById(R.id.start);

        start.setOnClickListener(new StartOnClickListenr());
    }

    private class StartOnClickListenr implements OnClickListener
    {
        public void onClick(View v) {
            // TODO Auto-generated method stub
            //让进度条显示出来
            progress_bar.setVisibility(View.VISIBLE);
            //将线程加入到handler的线程队列中
            update_progress_bar.post(update_thread);

        }
    } 
     //创建一个handler，内部完成处理消息方法
    Handler update_progress_bar = new Handler()
    {
        @Override
        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            //super.handleMessage(msg);
            //显示进度条
            progress_bar.setProgress(msg.arg1);
            //重新把进程加入到进程队列中
            update_progress_bar.post(update_thread);
        }       
    };//不加这个分号则不能自动添加代码

    Runnable update_thread = new Runnable()
    {
        int i = 0;
        public void run() {
            // TODO Auto-generated method stub
            i += 10;
            //首先获得一个消息结构
            Message msg = update_progress_bar.obtainMessage();
            //给消息结构的arg1参数赋值
            msg.arg1 = i;
            //延时1s，java中的try+catch用来排错处理
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            //把消息发送到消息队列中
            update_progress_bar.sendMessage(msg);
            if(i == 100)
                //把线程从线程队列中移除
                update_progress_bar.removeCallbacks(update_thread);
        }       
    };

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }
}

Handler使用例3
上面2个例子表面上看handler使用了post方法启动了runnbale，其实启动的线程和activity主线程是同一个线程，因为它只是运行了线程的run方法，而不是start方法。Mars老师实验3的目的是为了验证仅使用handler的post方法是否处于同一个线程。
该实验在主activtiy的onCreate函数中打印了2条关于本线程的信息，然后创建一个handler并为它绑定一个线程，在线程的run方法中也打印了线程的信息，观察2者的信息是否一样。

结果如下：
说明这2个线程确实是同一线程，并且可以看出主界面中的文字大概过了10s才显示出来，因为语句setContentView(R.layout.activity_main);放在了handler的post启动语句后面，而handler绑定的线程中又延时了10s，所以同时也证明了只有是同一个线程才会出现这种情况。


package com.example.handler3;  
 import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.Menu; 
 public class MainActivity extends Activity { 
     //新建一个handler
    private Handler handler = new Handler();
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //将runnable加载到handler的线程队列中去
      //  handler.post(r);        
        Thread t = new Thread(r);
        t.start();
        setContentView(R.layout.activity_main);
        //打印activtiy线程信息
        System.out.println("activity_id---->"+Thread.currentThread().getId());
        System.out.println("activity_name---->"+Thread.currentThread().getName());
    } 
     Runnable r = new Runnable()
    {
        public void run() {
            // TODO Auto-generated method stub
            //打印新建线程信息
            System.out.println("handler_id---->"+Thread.currentThread().getId());
            System.out.println("handler_name---->"+Thread.currentThread().getName());
            //延时10s，为了观察主界面中内容出现的时间
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }

    };

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }
}

如果把语句：
handler.post(r);
换成：
Thread t = new Thread(r);
t.start();
其它的不变，则程序运行时主界面内容立刻就显示出来了，且系统输出如下：
这2者都说明这样绑定的线程与它所在的activity线程就不是同一个线程了。

Handler使用例4
这个例子将学会怎样不使用runnable来启动一个线程，而是用HandlerThread的looper来构造一个handler，然后该handler自己获得消息，并传递数据，然后又自己处理消息，当然这是在另一个线程中完成的。
消息结构中传递简单的整型可以采用它的参数arg1和arg2，或者传递一些小的其它数据，可以用它的object，该object可以是任意的对象。当需要传送比较大的数据是，可以使用消息的setData方法，该方法需要传递一个Bundle的参数。Bundle中存放的是键值对的map，只是它的键值类型和数据类型比较固定而已。


package com.example.handler4;  
 import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.view.Menu; 
 public class MainActivity extends Activity { 
     @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        System.out.println("activity_ID---->"+Thread.currentThread().getId());
        //新建一个HanderThread对象，该对象实现了用Looper来处理消息队列的功能
        HandlerThread handler_thread = new HandlerThread("handler_thread");
        handler_thread.start();
        //MyHandler类是自己继承的一个类，这里采用hand_thread的Looper来初始化它
        MyHandler my_handler = new MyHandler(handler_thread.getLooper());
        //获得一个消息msg
        Message msg = my_handler.obtainMessage();

        //采用Bundle保存数据，Bundle中存放的是键值对的map，只是它的键值类型和数据类型比较固定而已
        Bundle b = new Bundle();
        b.putString("whether", "晴天");
        b.putInt("temperature", 34);
        msg.setData(b);
      //将msg发送到自己的handler中，这里指的是my_handler,调用该handler的HandleMessage方法来处理该mug
        msg.sendToTarget();
    } 
     class MyHandler extends Handler
    {
        //空的构造函数
        public MyHandler()
        {}
        //以Looper类型参数传递的函数，Looper为消息泵，不断循环的从消息队列中得到消息并处理，因此
        //每个消息队列都有一个Looper，因为Looper是已经封装好了的消息队列和消息循环的类
        public MyHandler(Looper looper)
        {
            //调用父类的构造函数
            super(looper);
        }
        @Override
        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            System.out.println("Handler_ID---->"+Thread.currentThread().getId());
            System.out.println("Handler_Name---->"+Thread.currentThread().getId());
            //将消息中的bundle数据取出来
            Bundle b = msg.getData();
            String whether = b.getString("whether");
            int temperature = b.getInt("temperature");
            System.out.println("whether= "+whether+" ,temperature= "+temperature);
        }

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }
}

总结：
Android中的handler可以用来完成异步的消息出来，即发送消息和接收消息相互独立，可以同时运行。在例1和例2中，实际上handler中使用的线程是与它所在的activity处于同一个主线程，因为handler中调用的runnable接口是直接运行该接口的run函数的，而不是start函数。例3专门比较了这2中情况。例4学会使用怎样在新线程中处理消息的方法。(感谢tornadomeet的实例与分析http://www.jb51.net/article/43360.htm)

五.总结与补充
初入Android或Java开发的新手对Thread、Looper、Handler和Message仍然比较迷惑，衍生的有HandlerThread、java.util.concurrent、Task、AsyncTask由于目前市面上的书籍等资料都没有谈到这些问题，今天就这一问题做更系统性的总结。我们创建的Service、Activity以及Broadcast均是一个主线程处理，这里我们可以理解为UI线程。但是在操作一些耗时操作时，比如I/O读写的大文件读写，数据库操作以及网络下载需要很长时间，为了不阻塞用户界面，出现ANR的响应提示窗口，这个时候我们可以考虑使用Thread线程来解决。

对于从事过J2ME开发的程序员来说Thread比较简单，直接匿名创建重写run方法，调用start方法执行即可。或者从Runnable接口继承，但对于Android平台来说UI控件都没有设计成为线程安全类型，所以需要引入一些同步的机制来使其刷新，这点Google在设计Android时倒是参考了下Win32的消息处理机制。　　

对于线程中的刷新一个View为基类的界面，可以使用postInvalidate()方法在线程中来处理，其中还提供了一些重写方法比如postInvalidate(int left,int top,int right,int bottom) 来刷新一个矩形区域，以及延时执行，比如postInvalidateDelayed(long delayMilliseconds)或postInvalidateDelayed(long delayMilliseconds,int left,int top,int right,int bottom) 方法，其中第一个参数为毫秒
当然推荐的方法是通过一个Handler来处理这些，可以在一个线程的run方法中调用handler对象的 postMessage或sendMessage方法来实现，Android程序内部维护着一个消息队列，会轮训处理这些，如果你是Win32程序员可以很好理解这些消息处理，不过相对于Android来说没有提供 PreTranslateMessage这些干涉内部的方法。
Looper又是什么呢? ，其实Android中每一个Thread都跟着一个Looper，Looper可以帮助Thread维护一个消息队列，但是Looper和Handler没有什么关系，我们从开源的代码可以看到Android还提供了一个Thread继承类HanderThread可以帮助我们处理，在HandlerThread对象中可以通过getLooper方法获取一个Looper对象控制句柄，我们可以将其这个Looper对象映射到一个Handler中去来实现一个线程同步机制，Looper对象的执行需要初始化Looper.prepare方法就是昨天我们看到的问题，同时推出时还要释放资源，使用Looper.release方法。
Message 在Android是什么呢? 对于Android中Handler可以传递一些内容，通过Bundle对象可以封装String、Integer以及Blob二进制对象，我们通过在线程中使用Handler对象的sendEmptyMessage或sendMessage方法来传递一个Bundle对象到Handler处理器。对于Handler类提供了重写方法handleMessage(Message msg) 来判断，通过msg.what来区分每条信息。将Bundle解包来实现Handler类更新UI线程中的内容实现控件的刷新操作。相关的Handler对象有关消息发送sendXXXX相关方法如下，同时还有postXXXX相关方法，这些和Win32中的道理基本一致，一个为发送后直接返回，一个为处理后才返回 .
java.util.concurrent对象分析，对于过去从事Java开发的程序员不会对Concurrent对象感到陌生吧，他是JDK 1.5以后新增的重要特性作为掌上设备，我们不提倡使用该类，考虑到Android为我们已经设计好的Task机制，这里不做过多的赘述，相关原因参考下面的介绍:
在Android中还提供了一种有别于线程的处理方式，就是Task以及AsyncTask，从开源代码中可以看到是针对Concurrent的封装，开发人员可以方便的处理这些异步任务。