Android异步消息处理机制完全解析-Handler详解

  1. 云栖社区>
  2. 博客>
  3. 正文

Android异步消息处理机制完全解析-Handler详解

javen205 2017-03-25 17:24:01 浏览603
展开阅读全文

参考资料
- 官方介绍文档
- Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系
- Android异步消息处理机制完全解析,带你从源码的角度彻底理解
- 慕课网课程-Android面试常客Handler详解

如果在非UI线程中更新UI会出现问题吗?

实践:

public class MainActivity extends AppCompatActivity {

    @BindView(R.id.id_tv)
    TextView idTv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);

        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000*5);
                    idTv.setText("Javen205测试非UI线程更新UI会出现什么异常呢?");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
}

我们运行项目就会以下异常

非UI线程中更新UI出现

为了更直观的看到报错原因,我们找到源码ViewRootImpl的checkThread方法,看它做了些什么。

ViewRootImpl.checkThread()
但是Android为什么要这样搞呢?

我们仔细看这句话,只有创建了View的线程才能对这个View进行操作。而我们一般View都是为了显式在UI上的。Android正是为了防止我们在非UI线程去操作这些UI上的控件,才加了限制的。因为UI体验对用户来说是最直观的,如果谁都有权限去操作一下,那UI要么很乱,要么控制很复杂。

竟然Android是不允许我们在非UI线程中去执行更新UI,那我们要怎么解决这个问题呢?那我们就要使用Android 提供的Hander机制去更新UI了

一、什么是Handler

Handler是Android提供的用来更新UI的一套机制,也是一套消息处理机制,我们可以通过它发送消息,也可以通过它处理消息。

二、为什么要使用Handler

Android在设计的时候,就封装了一套消息创建、传递、处理机制,如果不遵循这样的机制就没有办法更新UI信息,就会抛出异常。

三、Handler怎么用呢?

  • 在非UI线程借助Handler.post(Runnable)更新UI

首先在Activity中实例化一个Hander

Handler handler = new Handler();

然后在子线程中调用Handler.post(Runnable)更新UI
详细的代码如下:

public class MainActivity extends AppCompatActivity {

    @BindView(R.id.id_tv)
    TextView idTv;

    Handler handler = new Handler();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);

        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000*5);
//                    idTv.setText("Javen205测试非UI线程更新UI会出现什么异常呢?");
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            idTv.setText("Javen205测试非UI线程更新UI会出现什么异常呢?");
                        }
                    });
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
}
  • 在非UI线程借助Handler.postDelayed(Runnable, DelayTime)定时执行相关动作

栗子:实现三张图片自动切换

实现三张图片自动切换

 private  int images[]= {R.drawable.image4,R.drawable.image6,R.drawable.image7};

 private int index=0;

Handler handler = new Handler();

Thread myThread = new Thread(){
        @Override
        public void run() {
            index++;
            index = index%3;
            System.out.println(index);
            idImg.setImageResource(images[index]);
            handler.postDelayed(myThread,1000);
        }
    };


handler.postDelayed(myThread,1000);

要是我们想停止图片的切换,那要如何操作呢?

  • Handler移除一个消息
handler.removeCallbacks(myThread);
  • 自定义Handler和Message

自定义Hander(customHander)

Handler customHander = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            idTv.setText("msg.arg1>"+msg.arg1+ "\nmsg.arg2>" +msg.arg2 +"\nmsg.obj>"+((Dog)msg.obj).toString());
        }
    };

实体类

package com.javen205.entity;

import java.io.Serializable;



public class Dog implements Serializable{
    private String name;
    private int  age;

    public Dog() {
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

使用只定义Hander(customHander)发送消息

Dog dog=new Dog("萨摩耶",1);
Message message = new Message();
                message.arg1 = 1;
                message.arg2 = 2;
                message.obj = dog;
                customHander.sendMessage(message);               

复用Message

 Dog dog=new Dog("萨摩耶",1);
//                Message message = new Message();
                Message message= customHander.obtainMessage();
                message.arg1 = 1;
                message.arg2 = 2;
                message.obj = dog;
                customHander.sendMessage(message);

原理:obtainMessage()方法做了哪些操作呢?

 /**
     * Returns a new {@link android.os.Message Message} from the global message pool. More efficient than
     * creating and allocating new instances. The retrieved message has its handler set to this instance (Message.target == this).
     *  If you don't want that facility, just call Message.obtain() instead.
     */
    public final Message obtainMessage()
    {
        return Message.obtain(this);//this 就是Hander本身
    }

我们看看Message.obtain(Handler h) 又做了哪些操作呢?

 /**
     * Same as {@link #obtain()}, but sets the value for the <em>target</em> member on the Message returned.
     * @param h  Handler to assign to the returned Message object's <em>target</em> member.
     * @return A Message object from the global pool.
     */
    public static Message obtain(Handler h) {
        Message m = obtain();
        m.target = h; 

        return m;
    }

target就是Hander自己,指消息要发送给谁

再来看看obtain()方法

/**
     * Return a new Message instance from the global pool. Allows us to
     * avoid allocating new objects in many cases.
     */
    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

这个方法就是跟我们平常new Message 对象一样 ,只不过是在之前添加了一判断,判断系统中是否存在空的Message,如果存在就直接返回否则就创建一个Message对象。

其实发送消息也可以这样玩,不使用直接使用Hander而是使用Message的sendToTarget()方法,代码如下。

 Dog dog=new Dog("萨摩耶",1);
//                Message message = new Message();
                Message message= customHander.obtainMessage();
                message.arg1 = 1;
                message.arg2 = 2;
                message.obj = dog;
//                customHander.sendMessage(message);
                message.sendToTarget();

我们来看看Message.sendToTarget()方法源码

 /**
     * Sends this Message to the Handler specified by {@link #getTarget}.
     * Throws a null pointer exception if this field has not been set.
     */
    public void sendToTarget() {
        target.sendMessage(this);
    }

上面提到过target就是Hander自己,其实就是调用Hander自己的一个sendMessage,跟我们普通发送Message没有什么区别只是里面封装了一个target,本质还是调用了Hander.sendMessage(…)

  • Handler 消息拦截使其接收者接收不到消息

自定义Handler(interceptHander)拦截消息

Handler interceptHander = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            System.out.println("is intercept Handler>"+msg.what);
            // 设置true拦截消息
            return true;
        }
    }){
        @Override
        public void handleMessage(Message msg) {
            System.out.println("is intercept Handler");
        }
    };

interceptHander发送一个消息Message

 interceptHander.sendEmptyMessage(1);

四、Handler几种发送消息方式之间区别

可以参考:Handler发送sendMessage和postRunnable的区别

五、Handler的原理是什么?

handler原理图

  • Handler封装了消息的发送:内部会跟Looper关联

  • Looper(消息封装的载体):内部包含一个消息队列(MessageQueue),所有Handler发送的消息都会走向这个消息队列;
    Looper.Looper方法是一个死循环,不断的从MessageQueue取消息,如果有消息就处理消息,没有消息就阻塞。

  • MessageQueue(消息队列):可以添加消息,并处理消息

总结:Handler负责发送消息,Looper负责接收Handler发送的消息,并直接把消息回传给Handler自己(handleMessage),MessageQueue就是一个存储消息的容器。

六、自定义一个与线程相关的Handler

1、线程中创建一个Looper 可以使用 Looper.prepare();方法
2、实例化一个Handler
3、调用Looper.loop();方法循环处理消息

public class HandlerActivity extends AppCompatActivity {
    private MyThread myThread;

    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            System.out.println("UI :"+Thread.currentThread());
        }
    };

    class MyThread extends Thread{
        public Handler handler;
        @Override
        public void run() {
            Looper.prepare();

            handler= new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    System.out.println("currentThread:"+Thread.currentThread());
                }
            };

            Looper.loop();
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler);
        myThread = new MyThread();
        myThread.start();
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread.handler.sendEmptyMessage(1);
        handler.sendEmptyMessage(1);
    }
}

输出结果:

System.out: currentThread:Thread[Thread-151,5,main]
System.out: UI :Thread[main,5,main]

七、非UI线程真的不能更新UI吗?

我们运行下面的代码测试:

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
        new Thread() {
            @Override
            public void run() {
                idTv.setText("Javen205测试非UI线程更新UI会出现什么异常呢?");
            }
        }.start();
    }

最开始的案例中我们去掉Thread.sleep(…)会正常运行吗?答案:可正常运行。是不是感觉有点奇怪呢?那为什么直接在Activity的onCreate中添加子线程可以直接更新UI呢?

详细解答: 为什么我们可以在非UI线程中更新UI

八、Handler异步消息处理(HandlerThread)

Android HandlerThread 完全解析

Android异步消息处理机制完全解析,带你从源码的角度彻底理解

一个简单的例子

public class HandlerThreadActivity extends AppCompatActivity {
    private Handler handler;
    private HandlerThread thread;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_thread);
        thread = new HandlerThread("Handler Thread");
        thread.start();
        handler = new Handler(thread.getLooper()){
            @Override
            public void handleMessage(Message msg) {
                // 处理耗时操作
               System.out.println("current thread>"+Thread.currentThread());
            }
        };
        handler.sendEmptyMessage(1);
    }
}

测试输出结果
I/System.out: current thread>Thread[Handler Thread,5,main]

九、如何在主线程给子线程发送消息


public class HandlerThreadActivity extends AppCompatActivity {
    @BindView(R.id.id_btn1)
    Button idBtn1;
    @BindView(R.id.id_btn2)
    Button idBtn2;
    private Handler threadhandler;
    private HandlerThread thread;

    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            System.out.println("UI thread>" + Thread.currentThread());
            // 给主线程发送消息
            Message message = new Message();
            message.what =1;
            threadhandler.sendMessageDelayed(message, 1000);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_thread);
        ButterKnife.bind(this);
        thread = new HandlerThread("Handler Thread");
        thread.start();
        threadhandler = new Handler(thread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                // 处理耗时操作
                System.out.println("current thread>" + Thread.currentThread());
                // 给主线程发送消息
                Message message = new Message();
                message.what =1;
                handler.sendMessageDelayed(message, 1000);
            }
        };
//        threadhandler.sendEmptyMessage(1);
    }

    @OnClick({R.id.id_btn1, R.id.id_btn2})
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.id_btn1:
                handler.sendEmptyMessage(1);
                break;
            case R.id.id_btn2:
                handler.removeMessages(1);
                threadhandler.removeMessages(1);
                break;
        }
    }
}

十、Android中更新UI的几种方式

  • handler sendMessage
  • runOnUIThread
  • handler post
  • view post

项目源码地址:https://github.com/Javen205/Hander

推荐阅读
AndroidStudio多渠道打包
Android依赖管理与私服搭建
Android Studio 上传aar(Library)到JCenter
Android版-支付宝APP支付
Android版-微信APP支付
支付宝Wap支付你了解多少?
一张二维码集成微信、支付宝支付

安利时间:
JPay是对微信App支付、支付宝App支付的二次封装,对外提供一个相对简单的接口以及支付结果的回调

极速开发微信公众号是对微信公众平台接口的二次封装。包括开发者模式、事件回调监听、微信模板消息、微信客服消息、自定义菜单、微信支付、素材管理等

如遇到问题欢迎留言交流

网友评论

登录后评论
0/500
评论
javen205
+ 关注