5分钟完全理解android handler

Handler机制简介

Handler是android中最重要组成部分之一，Handler机制可以看做是一个消息阻塞队列，APP启动后很快就进入死循环（while循环），不断的读取消息队列中的消息，每个线程最多只有一个消息队列，没有消息时就阻塞，有就立马执行。所有消息排队执行，因为是一个线程，所以同时只能执行一个消息。android的view绘制，事件响应（点击，触摸屏幕等）都是把消息发送到了主线程的消息队列，等待android APP的执行（这点可以通过手动抛出异常查看错误堆栈来验证）。包括自己在主线程new 的handler最终也是把消息插入到了主线程消息队列中。从以上来看android主线程大部分时间是空闲的。当点击屏幕后手机能立马响应也可以看出android主线程大部分时间是空闲的。虽然主线程要处理的事情狠多，很杂，很琐碎（view布局、绘制，事件分发等等），但处理时间都很短暂，可以保证很快处理完毕，然后等待下一个消息的到来。android handler机制简可以实现所有view相关的操作都在主线程进行，从而避免了使用 锁 。具体实现代码 如下。

java工程实现Handler机制代码

下面的代码跟android的handler机制主要原理完全一致，但不依赖android系统。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125

import com.handler.Handler; import com.handler.Looper; import com.handler.Message; public class Main { public static void main(String[] args) { new Main().start(); } private void start(){ //创建该线程唯一的消息队列，线程安全的阻塞队列 Looper.prepare(); onCreate(); //死循环，阻塞式，执行下面代码后主线程就会去获取消息队列里的消息，没有消息时就阻塞，有就执行。执行Looper.loop前即使消息队列里有消息，消息也不会执行，因为主线程还没有去检查消息队列。 Looper.loop(); //下面 的代码通常不会执行，除非手动让主线程消息队列退出。退出主线程消息队列后android的view布局、绘制，事件分发就不执行了，所以android APP也没必要继续执行了，所以android采用了抛出异常的方式结束APP。 System.out.println( "exit........"); throw new RuntimeException( "Main thread loop unexpectedly exited"); } private void onCreate() { // // 下面的操作相当于运行在android的UI线程中 // final Thread thread = Thread.currentThread(); System.out.println( "main thread=" + thread); Handler handler = new Handler() { @Override public void handleMessage(Message msg) { //若thread == Thread.currentThread()，则证明已经运行在主线程中了 System.out.println( "current thread is main thread? " + (thread == Thread.currentThread())); System.out.println(msg); System.out.println(); } }; // 测试1 主线程创建handler，子线程使用该handler发送消息 new Thread() { public void run() { try { //模拟耗时操作 Thread.sleep( 1000 * 2); } catch (InterruptedException e) { } Message message = new Message(); message.obj = "new Thread" + Thread.currentThread(); message.what = ( int) System.currentTimeMillis(); //在子线程中发送消息 handler.sendMessage(message); try { Thread.sleep( 1000 * 2); } catch (InterruptedException e) { } message = new Message(); message.obj = "hanler...waht==1" ; message.what = 1; //在子线程中发送消息 handler.sendMessage(message); message = new Message(); message.obj = "hanler...waht==2" ; message.what = 2; //在子线程中发送消息 handler.sendMessage(message); message = new Message(); message.obj = "hanler...waht==3" ; message.what = 3; //在子线程中发送消息 handler.sendMessage(message); }; }.start(); // 测试2 在thread内部创建handler，结果会抛出异常 new Thread() { public void run() { try { sleep( 1000 * 3); } catch (InterruptedException e) { } /* * 在线程内部使用默认构造函数创建handler会抛出异常。 * android中也可以在子线程中创建Handler，但要在初始化时传入Looper， * Looper.getMainLooper()获取到的就是主线程的Looper，所以可以这样创建 * * new Handler(Looper.getMainLooper()){ @Override public void handleMessage(Message msg) { //运行在主线程中 } }; */ Handler h = new Handler() { public void handleMessage(Message msg) { System.out.println( "haneler msg...." + msg); }; }; Message message = new Message(); message.obj = "handler in new Thread"; message.what = ( int) System.currentTimeMillis(); //在子线程中发送消息 h.sendMessage(message); }; }.start(); // // 上面的操作相当于运行在android的UI线程中 // } }

运行结果

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

main thread=Thread[main,5,main] current thread is main thread? true what=18175614 obj=new ThreadThread[Thread-0,5,main] Exception in thread "Thread-1" java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare() at com.handler.Handler.<init>(Handler.java:14) at Main$3$1.<init>(Main.java:103) at Main$3.run(Main.java:103) current thread is main thread? true what=1 obj=hanler...waht==1 current thread is main thread? true what=2 obj=hanler...waht==2 current thread is main thread? true what=3 obj=hanler...waht==3

Handler代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

package com.handler; public class Handler { private MessageQueue messageQueue; public Handler() { Looper looper=Looper.myLooper(); if (looper== null) { throw new RuntimeException( "Can't create handler inside thread that has not called Looper.prepare()"); } this.messageQueue=looper.messageQueue; } public void sendMessage(Message msg) { //Looper循环中发现message后，调用message.targer就得到了当前handler，使用taget.handleMessage //就把消息转发给了发送message时的handler的handleMessage函数 msg.target= this; messageQueue.enqueueMessage(msg); } public void handleMessage(Message msg) { } }

Looper代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

package com.handler; public class Looper { private static final ThreadLocal<Looper> threadLocal= new ThreadLocal<>(); /** * 存储Message的队列，阻塞式，没有消息则一直等待 */ final MessageQueue messageQueue; private Looper() { messageQueue= new MessageQueue(); } /**为该线程创建Looper， * 若该线程已经有Looper了则不需要再次调用prepare */ public static void prepare() { if (threadLocal.get() != null) { throw new RuntimeException( "Only one Looper may be created per thread"); } threadLocal.set( new Looper() ); } public static void loop() { Looper looper=myLooper(); if (looper == null) { throw new RuntimeException( "No Looper; Looper.prepare() wasn't called on this thread."); } MessageQueue messageQueue=looper.messageQueue; for(;;){ Message message=messageQueue.next(); message.target.handleMessage(message); } } /** * 获取当先线程的Looper * @return */ public static Looper myLooper() { return threadLocal.get(); } }

MessageQueued代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

package com.handler; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; public class MessageQueue { private BlockingQueue<Message>blockingQueue= new LinkedBlockingQueue<>(); /** * 阻塞式，没有消息则一直等待 * @return */ public Message next() { try { return blockingQueue.take(); } catch (InterruptedException e) { throw new RuntimeException(); } } /** * 插入到消息队列尾部 * @param message */ void enqueueMessage(Message message) { try { blockingQueue.put(message); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }

ThreadLocal简单实现

ThreadLocal内部原理和下面实现方式不同，但达到的效果是相同的，本篇主要介绍Handler机制，简化了ThreadLocal

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

package com.handler; import java.util.HashMap; import java.util.Map; /** * ThreadLocal简单实现 * @author Young * * @param <T> */ public class ThreadLocal<T> { private Map<Thread,T>map; public ThreadLocal() { map= new HashMap<>(); } public void set(T obj) { map.put(Thread.currentThread(),obj); } public T get() { return map.get(Thread.currentThread()); } }

Message代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

package com.handler; public class Message { Handler target; public Object obj; public int what; @Override public String toString() { return "what="+what+ " obj="+obj.toString(); } }

以上就是android Handler机制原理代码了。

android还提供了HandlerThread，其实是对Handler和Thread的封装。

先看一下HandlerThread使用方式

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

Handler myHandler; new HandlerThread( "Compress-Thread") { @Override protected void onLooperPrepared() { super.onLooperPrepared(); myHandler = new Handler(); myHandler.post( new Runnable(){ @Override public void run() { //在HandlerThread线程执行 } }); } }.start(); //不要在这使用myHandler发送消息，因为myHandler是在onLooperPrepared中创建的，onLooperPrepared又是运行在HandlerThread线程的，所以刚执行到这时HandlerThread线程可能还没有创建完，onLooperPrepared也就不会执行，myHandler自然是null

每次new HandlerThread都会创建一个新线程，当我们使用myHandler发送消息时消息就会在HandlerThread线程执行。HandlerThread线程内部也是一个死循环，通常不会退出，当通过myHandler为其发送消息时就会从阻塞中醒来执行消息，执行完消息队列里的消息后就又阻塞。HandlerThread可以排队执行消息，保证能按加入消息的先后顺序执行。比如我们需要压缩很多图片时，就可以使用HandlerThread，主线程直接把图片通过myHandler发送到HandlerThread，HandlerThread就可以执行图片压缩，所有压缩任务都按添加顺序依次执行。

来自我的博客

http://blog.csdn.net/qingchunweiliang/article/details/50448365