MessageQueue代码:http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/os/MessageQueue.java/?v=source

Handler代码:

http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/os/Handler.java/?v=source

Looper代码:

http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/os/Looper.java/?v=source

为什么有handler,handler的主要作用是什么?

首先android UI主线程不能进行大量的耗时操作,否则会产生ANR以及不好的UI体验,因此必须通过异步的方式处理耗时的操作,避免耗时的操作阻塞UI主线程。

handler的主要作用是什么呢,主要负责多个线程之间的信息通信,比如子线程中中耗时操作返回结果需要在UI线程进行展示,这时候就需要通过handler来将消息传递到UI线程并刷新UI内容。

handler的消息机制主要牵扯三方面:

  1. 消息发送者;
  2. 消息队列;
  3. 消息处理循环操作。

handler发消息有两种方式:

  1. send
    1. sendEmptyMessage(int),发送一个空的消息;
    2. sendMessage(Message),发送消息,消息中可以携带参数;
    3. sendMessageAtTime(Message, long),未来某一时间点发送消息;
    4. sendMessageDelayed(Message, long),延时Nms发送消息。
  2. post
    1. post(Runnable),提交计划任务马上执行;
    2. postAtTime(Runnable, long),提交计划任务在未来的时间点执行;
    3. postDelayed(Runnable, long),提交计划任务延时Nms执行。

messageQueue:消息队列,对外提供插入和删除的工作,内部存储结构为单链表结构。

messageQueue的两个主要方法:

  1. enqueueMessage:向消息队列中插入元素;
  2. next:从消息队列中取出元素,是个无线循环的方法,无消息,阻塞,有消息,返回消息并从消息队列中将消息移除。

looper:用来构建轮训消息队列系统。

线程默认没有looper,使用handler就必须为线程创建looper。

  1. Looper.prepare()创建Looper;
  2. Looper.loop()开启消息循环;
  3. Looper.prepareMainLooper()主线程创建looper;
  4. quit:直接退出Looper;
  5. quitSafely:设定退出标志,已有消息处理完以后才会退出。

消息发送:post方式发送消息的方式最后调用的还是sendMessage方式:

 public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean More ...sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}

往下走:

 public final boolean More ...sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

最后走到这里:

public boolean More ...sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}

调用 enqueueMessage 在消息队列中插入一条消息,在 enqueueMessage总中,会把 msg.target 设置为当前的Handler 对象。

private boolean More ...enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}

如下将消息插入消息队列中去。并且可以很明显看出消息队列是线性链表结构。

boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
} synchronized (this) {
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
msg.recycle();
return false;
} msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
} // We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}

每个线程只能运行一个looper对象,创建 Looper 的时候,内部会创建一个消息队列MessageQueue;并且looper在线程里面必须先prepare(),再loop来对消息队列messageQueue来进行遍历循环操作。

public static void loop() {
final Looper me = myLooper();
//如果looper对象是空的,就提示必须在当前线程通过looper.prepare()来进行创建
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//如果looper不为null,就取出消息队列
final MessageQueue queue = me.mQueue; Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
//遍历消息队列
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
//没有消息中断操作,跳出循环
return;
} //----------------队列不为null的操作----------------
// This must be in a local variable, in case a UI event sets the logger
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
//----------------队列不为null,分发数据出去----------------
msg.target.dispatchMessage(msg);
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
} // Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
} msg.recycleUnchecked();
}
}

循环遍历并分发消息出去msg.target.dispatchMessage(msg),切换到创建handler所使用的looper中执行,也就是说将逻辑切换到主线程去:

/**
* Handle system messages here.
*首先,如果消息的 callback 不是空,便调用 handleCallback 处理。否则判断 Handler 的 mCallback 是否为空,不为空则调用它的 handleMessage方法。如果仍然为空,才调用 Handler 自身的 handleMessage,也就是我们创建 Handler 时重写的方法
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//回调handler的handleMessage(msg)方法,从而接收数据
handleMessage(msg);
}
}

额,先写到这,明天继续更新。

hander的相关问题的延伸:

handler在实际开发中常见的问题就是内存泄漏的问题了:

常见的写法:

 private Handler   handler    = new Handler() {
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case UPDATE_TEXTVIEW:
updateTextView();
break; default:
break;
}
}
};

1,在Java中,非静态的内部类和匿名内部类都会隐式地持有其外部类的引用,静态的内部类不会持有外部类的引用,通过将类声明为静态的,解决持有外部类引用的问题;

2,android主线程有looper,looper处理MessageQueue消息队列数据的进进出出,Message添加到消息队列中的时候Message(排队的Message)会持有当前Handler引用,处理消息,并在ui界面上进行结果展示或者toast()或者dialog对话框弹出,就会产生MessageQueue 到 Message 到 Handler 到 Activity的引用链。

为了解决静态内部类无法操作外部类的内容,将activity作为弱引用引入,这样就就可以避免引用的问题,有可以对外部类的方法进行调用。

那么如何解决呢?

private Handler   handler    = new MyHandler( BackPasswordActivity.this );

    private class MyHandler extends Handler {
private WeakReference<Activity> mActivity; public MyHandler(BackPasswordActivity activity) {
mActivity = new WeakReference<Activity>( activity );
} @Override public void handleMessage(Message msg) {
super.handleMessage( msg );
MainActivity activity = (MainActivity) mActivity.get();
if (activity != null) updateTextView();
}
}

还有一种解决方式:WeakHandler

开源库地址:https://github.com/badoo/android-weak-handler

实际项目中使用:

1,引入:compile 'com.badoo.mobile:android-weak-handler:1.1',当然也可以代码引入,就一个类;

2,代码中的使用:

声明以及在主线程中接收消息,注意和我们的handler的写法的不同:

 WeakHandler myHandler = new WeakHandler(new Handler.Callback() {
@Override public boolean handleMessage(Message msg) {
switch (msg.what) {
case 1:
//UI操作
if (!StringUtil.isEmpty(tradeNo)) {
rechargeStatus();
}
break;
default:
break;
}
return false;
}
});

发送消息:

    Message message = new Message();
message.what = 1;
myHandler.sendMessage(message); //发送message

handler消息机制的更多相关文章

  1. Android消息传递之Handler消息机制

    前言: 无论是现在所做的项目还是以前的项目中,都会遇见线程之间通信.组件之间通信,目前统一采用EventBus来做处理,在总结学习EventBus之前,觉得还是需要学习总结一下最初的实现方式,也算是不 ...

  2. Handler消息机制与Binder IPC机制完全解析

    1.Handler消息机制 序列 文章 0 Android消息机制-Handler(framework篇) 1 Android消息机制-Handler(native篇) 2 Android消息机制-H ...

  3. Handler消息机制实现更新主UI

    如下实现的是简单的更新主UI的方法,用Handler消息机制 将textview的内容每隔一秒实现num++ /* * handler消息机制 * asynctask异步任务 *  * httpcli ...

  4. Android Handler消息机制不完全解析

    1.Handler的作用 Android开发中,我们经常使用Handler进行页面的更新.例如我们需要在一个下载任务完成后,去更新我们的UI效果,因为AndroidUI操作不是线程安全的,也就意味着我 ...

  5. 源码篇——Handler消息机制

    Handler消息机制 Message 消息 Message.obtain() Message msg = new Message() Handler new Handler(){ handlerMe ...

  6. Handler消息机制的一些原理(直接用code讲解)——Android开发

    package com.example.handlertest; import android.os.Bundle; import android.os.Handler; import android ...

  7. Android Handler消息机制源码解析

    好记性不如烂笔头,今天来分析一下Handler的源码实现 Handler机制是Android系统的基础,是多线程之间切换的基础.下面我们分析一下Handler的源码实现. Handler消息机制有4个 ...

  8. 深入理解 Handler 消息机制

    记得很多年前的一次面试中,面试官问了这么一个问题,你在项目中一般如何实现线程切换? 他的本意应该是考察 RxJava 的使用,只是我的答案是 Handler,他也就没有再追问下去了.在早期 Andro ...

  9. 【Android】Handler消息机制

    Handler消息机制主要涉及Looper.Handler.MessageQueue.Message.其中,Looper主要负责获取消息,Handler负责发送消息及处理消息,MessageQueue ...

  10. handler消息机制入门

    handler消息机制入门 为什么要用handle? 我们在网络上读取图片信息时,是不能把耗时操作放在主线程里面的,当我们在子线程中获取到了图片的消息的时候,我们就需要把这个数据传给主线程. 而直接使 ...

随机推荐

  1. .Net多线程编程—同步机制

    1.简介 新的轻量级同步原语:Barrier,CountdownEvent,ManualResetEventSlim,SemaphoreSlim,SpinLock,SpinWait.轻量级同步原语只能 ...

  2. List中函数用法 First,FirstOrDefault,Single,SingleOrDefault的区别

    操作符 如果源序列是空的 源序列只包含一个元素 源序列包含多个元素 First 抛异常 返回该元素 返回第一个元素 FirstOrDefault 返回default(TSource) 返回该元素 返回 ...

  3. java中的ArrayList 、List、LinkedList、Collection关系详解

    一.基础介绍(Set.List.Map) Set(集):集合中的元素不按特定方式排序,并且没有重复对象.他的有些实现类能对集合中的对象按特定方式排序. List(列表):集合中的元素按索引位置排序,可 ...

  4. oracle ebs 分类账与法人主体对应关系

    --ebs 分类账与法人主体对应关系 SELECT A.SET_OF_BOOKS_ID LEDGER_ID, GL.NAME LEDGER_NAME, GL.CURRENCY_CODE, FFV.FL ...

  5. python绝技 — 嗅探FTP登录口令

    代码: #!/usr/bin/python #--*--coding=utf-8--*-- import optparse from scapy.all import * def ftpsniff(p ...

  6. ie7,IE8不支持document.getElmentsByClassName的问题

    if (!document.getElementsByClassName) { document.getElementsByClassName = function(className, elemen ...

  7. 【锋利的Jquery】读书笔记四

    jquery中的事件及动画 一.事件 页面加载 $(document).ready(function(){xxxxx}) 简写 $(function(){ //do something }) 元素绑定 ...

  8. 跨线程传递栈变量带来异常指针Crash

    在手Q动漫的一份古老的代码中,现网发现少数crash,错误代码示例: char str[100] = "hello"; dispatch_async(dispatch_get_ma ...

  9. Python基础之字符串

    字符串内置处理函数 1.capitalize() 描述: 将字符串的第一个字母变成大写,其他字母变小写. 示例: a= "hello world" print (a.capital ...

  10. 在虚拟机上配置linux lab的相关经验

    最近一直在研究怎样在嵌入式开发板上移植linux嵌入式系统,但是不太想花费太多钱购买开发板.然后在网上搜索相关的arm模拟器.有qemu,skyeye,armulator等,在按照网上教程一步一步实践 ...