handler原理分析及模仿handler实现简单主/子线程通信架构

1、分析handler原理

主线程和子线程通信通常靠Handler，要实现通信，需要Handler、MessageQueue、Message、Looper
用图表示

每个Handler都有一个Looper对象，而Looper对象的生成过程是

//sThreadLocal.get() will return null unless you've called prepare()
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
public static void prepare(){
   if(sThreadLocal.get() != null) {
       throw new RuntimeException("Only one Looper may be created per thread");
   }
   sThreadLocal.set(new Looper());
}

Looper对象是保存在ThreadLocal当中。

ThreadLocal用于线程间的数据隔离，保证数据安全。

给当前线程关联一个Looper对象。
sThreadLocal.set(new Looper());

在android程序的入口ActivityThread中，默认为主线程关联了一个Looer对象，所以在调用Handler时，我们不用自己给主线程关联Looper对象，也就是Looper.prepare()

ActivityThread.java

public static void main(String[] args) {
   ...
   Looper.prepareMainLooper();
   ...
   Looper.loop() 

}

Looper.java中

public static void prepareMainLooper() {
    prepare();
    ...
}

2、模范Handler实现主/子线程通信

新建Handler.java

package com.handler;

/**
 * Created by Tony on 2017/6/11.
 */

public class Handler {

    private MessageQueue mQueue;

    //Handler的初始化在主线程中完成
    public Handler() {
        //获取主线程的Looper对象
        this.mQueue = Looper.myLooper().mQueue;
    }

    /**
     * 发送消息，压入队列
     * @param msg
     */
    public void sendMessage(Message msg) {
        msg.target = this;
        mQueue.enqueueMessage(msg);
    }

    public void dispatchMessage(Message msg) {
        handleMessage(msg);
    }

    public void handleMessage(Message msg) {
    }
}

新建Looper文件

package com.handler;

/**
 * Created by Tony on 2017/6/11.
 */

public final class Looper {

    //每一个主线程都有一个Looper对象
    //Looper对象保存在ThreadLocal，保证了线程数据的隔离
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

    //一个Looper对象对应一个消息队列
    MessageQueue mQueue;

    private Looper() {
        mQueue = new MessageQueue();
    }

    public static void prepare() {
        if (sThreadLocal.get()!=null){
            throw new RuntimeException("only one looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }

    /**
     * 获取当前线程的Looper对象
     * @return
     */
    public static Looper myLooper() {
        return sThreadLocal.get();
    }

    /**
     * 轮询消息队列
     */
    public static void loop() {
        Looper me = myLooper();
        if (me == null) {
            throw  new RuntimeException("");
        }

        MessageQueue queue = me.mQueue;
        for (;;) {
            Message msg = queue.next();
            if (msg == null) {
                continue;
            }
            //转发给Handler
            msg.target.dispatchMessage(msg);

        }
    }

}

新建MessageQueue

package com.handler;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by Tony on 2017/6/11.
 */

public class MessageQueue {

    /**
     * 消息队列应该要有大小限制
     * 消息队列满了，子线程停止发送消息，阻塞
     * 消息队列为空，主线程Looper停止轮循，阻塞
     */

    //通过数组的结构存储Message对象
    Message[] items ;

    //入队与出队元素索引位置
    int putIndex;
    int takeIndex;
    //计数器
    int count;
    //互斥锁
    private Lock lock;
    //条件变量
    private Condition notEmpty;
    private Condition notFull;


    public MessageQueue() {
        this.items = new Message[50];
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition();
        this.notFull = lock.newCondition();

    }

    /**
     * 入队列（子线程运行）
     * @return
     */
    public void enqueueMessage(Message msg) {
        try {
            lock.lock();
            //消息队列满了，子线程挺好i发送消息，阻塞
            while (count == items.length)
            {
                try {
                    notFull.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            items[putIndex] = msg;
            //循环取值
            putIndex = (++putIndex == items.length) ? 0:putIndex;
            count++;
            //有新的Message对象，通知主线程
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 出队列（主线程运行）
     * @return
     */
    public Message next() {

        Message msg = null;
        try {
            //消息队列为空，主线程Looper停止轮询，阻塞
            lock.lock();
            while (count == 0) {
                try {
                    notEmpty.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            msg = items[takeIndex];//取出
            items[takeIndex] = null;//元素置空
            takeIndex = (++takeIndex == items.length) ? 0 : takeIndex;
            count--;

            //使用了一个的Message对象，通知子线程，可以继续生产
            notFull.signal();
        } finally {
            lock.unlock();
        }

这里写代码片

新建Message.java

package com.handler;

/**

 * Created by Tony on 2017/6/11.

 */

public class Message {
    Handler target;

    public int what;

    public Object obj;

    @Override

    public String toString() {

        return obj.toString();

    }

}
 return msg;

}
}

新建测试文件HandlerTest.java

package com.handler;

import java.util.UUID;

/**
 * Created by Tony on 2017/6/12.
 */

public class HandlerTest {

    public static void main(String[] args) {
        //轮询器初始化
        Looper.prepare();
        //主线程
        final Handler handler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                System.out.println(Thread.currentThread().getName() + ",received: "+msg.toString()
                );
            }
        };

        //子线程发送消息
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        Message msg = new Message();
                        msg.what = 1;
                        synchronized (UUID.class){
                            //加锁，线程安全
                            msg.obj = Thread.currentThread().getName() +",send message:"+ UUID.randomUUID().toString();
                        }
                        handler.sendMessage(msg);
                        System.out.println(msg);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

         }
                }
            }).start();
        }
        //开始轮询
        Looper.loop();
    }

}

测试结果如下：

以上用了较简单的方式实现了主线程和子线程的通信。

源码地址：
https://github.com/fsdsds/HandlerDemo