好玩的Handler

1. Android提供了Handler和Looper来满足线程间的通信;
2. Handler和Activity的任务栈不同,它是先进先出原则;
3. Handler:你可以构造Handler对象来与Looper沟通,以便push新消息到MessageQueue里,或者接口Looper从MessageQueue取出的消息;
4. Looper类用来管理特定线程内对象之间交换Message;
5. 一个线程可以产生一个Looper对象,由他来管理此线程的MessageQueue(消息队列);
6. MessageQueue:用来存放线程放入的消息;
7. 每一个消息都需要制定的Handler来处理,通过Handler创建消息便可以完成此功能.Android引入了消息池.Handler创建消息时首先查询消息池中是否有消息存在,如果有,则直接取出,如果没有,则重新初始化一个消息实例.
8. 使用消息池的好处是:消息不被使用时,并不作为垃圾回收,而是放入消息池中,可供下次Handler创建消息时使用.消息池提高了消息对象的复用,减少系统垃圾回收的次数.Message.obtain()来获取消息,最大数为50;
9. images/loading.gif' data-original="http://images2015.cnblogs.com/blog/752718/201611/752718-20161114092444717-1274431119.jpg" width="277" height="223" border="0"> 
   
10.  综上所述:这就是一个标准的的异步操作,就像我们寄信一样,我们只负责写好信(Message)通过邮递员(Handler)放入到邮箱(MessageQueue)中,由工作人员(Looper)去循环查询,再由邮递员处理(Handler)处理这些消息;
    
11. 应用场景:两秒后打开一个Activity
    1. //延迟两秒跳转
    2. newHandler().postDelayed(newRunnable(){
    4. @Override
    5. publicvoid run(){
    6. Intent intent=newIntent(MainActivity.this,TestActivity.class);
    7. startActivity(intent);
    8. }
    9. },2000);
    
     
    
12. 先来看一个简单的消息吧
    1. privateProgressBar mProgressBar;
    2. privateint i =0;
    3. privateHandler mHandler =newHandler(){ // 创建Handle
    4. @Override
    5. publicvoid handleMessage(Message msg){
    6. super.handleMessage(msg);
    7. Log.i("-mHandler->",i+"");
    8. mProgressBar.setProgress(i);
    9. }
    10. };
    11. privateRunnable runnable =newRunnable(){
    12. @Override
    13. publicvoid run(){
    14. Log.i("-Runnable->",i+"");
    15. i +=10;
    16. // 要做的事情，这里再次调用此Runnable对象，以实现每两秒实现一次的定时器操作
    17. mHandler.postDelayed(runnable,2000); // 定时器
    18. mHandler.sendMessageDelayed(Message.obtain(),0);// 发送消息才会触发重写的handleMessage方法
    19. }
    20. };
    22. @Override
    23. protectedvoid onCreate(@NullableBundle savedInstanceState){
    24. super.onCreate(savedInstanceState);
    25. setContentView(R.layout.activity_handler);
    26. mProgressBar =(ProgressBar) findViewById(R.id.pb_handler);
    27. mHandler.post(runnable);// 开始执行线程
    28. // runnable.run(); // 也可以用这个来开始线程
    29. }
    31. /**
    32. * 删除的时候停止线程操作
    33. */
    34. @Override
    35. protectedvoid onDestroy(){
    36. super.onDestroy();
    37. mHandler.removeCallbacks(runnable);
    38. }
    39. }
    
     
    
13. 获取Message的两种方法
    
    1. // 两种获取Message的方法 
    2. // Returns a new Message from the global message pool.
    3. mHandler.obtainMessage()和Message.obtain()
    
    
    1. // 两种方法其实是一样的,只不过一个是通过Handler获取,一个是通过Message的静态方法获得,查询Handler的源码会发现,obtainMessage的方法构成:
    2. publicfinalMessage obtainMessage()
    3. {
    4. returnMessage.obtain(this);
    5. }
    
    
    
14. 通过查询源码后发现,Message提供了诸如以下的变量
    1. Message的recycleUnchecked()方法
    2. void recycleUnchecked(){
    3. // Mark the message as in use while it remains in the recycled object pool.
    4. // Clear out all other details.
    5. flags = FLAG_IN_USE; //int
    6. what =0; // int
    7. arg1 =0; // int
    8. arg2 =0; // int
    9. obj =null; // Object
    10. replyTo =null; // Messenger 信使,信差
    11. sendingUid =-1;
    12. when =0; // long
    13. target =null; // Handler
    14. callback =null; // Runable
    15. data =null; // Bundle
    17. synchronized(sPoolSync){
    18. if(sPoolSize < MAX_POOL_SIZE){
    19. next = sPool;
    20. sPool =this;
    21. sPoolSize++;
    22. }
    23. }
    24. }
    
    使用系统变量的好处是可以大大减少系统的消耗;所以更新进度条的代码应修改为
    
    1. mProgressBar.setProgress(msg.arg1);
    
    
    1. privateRunnable runnable =newRunnable(){
    2. @Override
    3. publicvoid run(){
    4. Log.i("-Runnable->", i +"");
    5. i +=3;
    6. // 要做的事情，这里再次调用此Runnable对象，以实现每两秒实现一次的定时器操作
    7. mHandler.postDelayed(runnable,300);
    8. Message msg = mHandler.obtainMessage();
    9. msg.arg1 +=i;
    10. mHandler.sendMessage(msg);// 发送消息才会触发重写的handleMessage方法
    11. // mHandler.sendMessageDelayed(Message.obtain(),0); // 发送消息才会触发重写的handleMessage方法
    12. }
    13. };
    
     
    
    
15. 重新优化下Handler
    
    1. privateHandler mHandler =newHandler(){
    2. @Override
    3. publicvoid handleMessage(Message msg){
    4. super.handleMessage(msg);
    5. //Log.i("-mHandler->", i + "");
    6. if(msg.arg1 >100){
    7. mHandler.removeCallbacks(runnable);
    8. }else{
    9. mProgressBar.setProgress(msg.arg1);
    10. }
    11. }
    12. };
    
     
    

原标题：好玩的Handler

关键词：