浅析Handler、Looper机制。通过自定义Handler、Looper，让你有更直观的了观！

转载请注明出处：http://blog.csdn.net/liu470368500/article/details/40625333

Handler、Looper。面试的时候被问到的机率非常高的一个问题。当然。我说的是像我们这样的初级。。。一般讲解Handler、Looper机制的都是通过源码去讲解。这里我来通过自定义Handler、Looper。让各位看官能有个更直观的了解。相信有了这篇博文的基础。再看Handler、Looper的源码。理解起来就更容易了。

为了与安卓原生的相接轨。这里自定义的Handler-Looper使用的逻辑基本与系统原生的相一致。

先贴MyHanlder代码：

/**
 * 自定义Handler
 *
 * @author lzh
 *
 */
public class MyHandler {
    // 用于进行线程间通信的阻塞队列
    private BlockingQueue<MyMessage> mQueue;
    // 处理消息的回调
    private CallBack callBack;

    public MyHandler(CallBack callBack) {
        super();
        MyLooper looper = MyLooper.myLooper();
        if (looper == null) {
            throw new RuntimeException(
                    "在新开的线程中。创建MyHandler对象需要先调用MyLooper.prepare()方法。");
        }
        mQueue = looper.mQueue;
        this.callBack = callBack;
    }

    /**
     * 消息接收的回调
     *
     * @author Administrator
     *
     */
    public interface CallBack {
        /**
         * 处理消息
         *
         * @param msg
         */
        void handleMessage(MyMessage msg);
    }

    /**
     * 发送消息
     *
     * @param msg
     */
    public void sendMessage(MyMessage msg) {
        msg.target = this;
        try {
            mQueue.put(msg);
        } catch (InterruptedException e) {
        }
    }

    /**
     * 派发消息
     *
     * @param msg
     */
    public void dispatchMessage(MyMessage msg) {
        callBack.handleMessage(msg);
    }

}

再看MyLooper的代码：

public class MyLooper {

    private static ThreadLocal<MyLooper> sThreadLocal = new ThreadLocal<MyLooper>();
    private static MyLooper myLooper;
    /** 一个线程对应一个阻塞队列。 */
    public BlockingQueue<MyMessage> mQueue = null;

    private MyLooper() {
        super();
        mQueue = new LinkedBlockingQueue<MyMessage>();
    }

    /**
     * 为本线程准备对应的MyLooper对象
     */
    public static void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException(
                    "Only one MyLooper may be created per thread");
        }
        sThreadLocal.set(new MyLooper());
    }

    /**
     * 获取当前线程相对应的Looper对象
     *
     * @return 当未调用prepare()方法时。ThreadLocal.get()方法返回的为null;
     */
    public static MyLooper myLooper() {
        return sThreadLocal.get();
    }

    /**
     * 这里启动消息循环
     */
    public static void loop() {
        while (true) {
            try {
                myLooper = myLooper();
                BlockingQueue<MyMessage> mQueue = myLooper.mQueue;
                // take()方法是个阻塞方法。线程运行到此会阻塞住。以准备接收发过来的消息
                MyMessage msg = mQueue.take();
                msg.target.dispatchMessage(msg);
            } catch (InterruptedException e) {
                // 当线程关闭的时候会出现此异常。此时退出循环
                return;
            }
        }
    }

}

本来安卓原生中使用的是MessageQueue。但是却死活创建不出来。这里只有使用BlockQueue代替了。

当中的ThreadLocal可能有部分朋友有点陌生。这是线程局部变量。它的set方法和get()方法比较有意思。是和线程相关的。你在哪个线程里面set变量进去。你在哪个线程里面get()出来的就是哪个。所以在MyLooper中得先调用prepare()方法。先将与此线程相关的MyLooper实例创建出来加入进去。这样便能保存一个线程只有一个Looper。相应的也只有一个阻塞队列。

接下来看MyMessage代码：

public class MyMessage {
    public int msg1;
    public int msg2;
    public int what;
    public Object obj;
    public MyHandler target;
    public Runnable runnable;

}

原生的Message由于是final标记的。而Message里面存的Handler对象又比较重要。得要依靠它来指定最终的消息应该发送给哪个Handler来接收。所以。这个也自定义了。

下面开始来测试。由于安卓不允许在UI线程中有阻塞操作。所以这里我们使用SurfaceView在子线程中画图来测试是否可进行线程间通信。

/**
 * 测试自定义的Handler与Looper的测试工程，由于内部有阻塞队列。而安卓的机制是不允许此类的阻塞行为在主线程中出现。
 * 所以此处用SurfaceView在子线程中进行测试
 *
 * @author Administrator
 *
 */
public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new MySurfaceView(this));
    }

    class MySurfaceView extends SurfaceView implements SurfaceHolder.Callback,
            CallBack {
        private static final String TAG = "MySurfaceView";
        private SurfaceHolder mHolder;
        Thread mThread;
        MyHandlerCreateRunnable mRunnable;
        private Paint mPaint;
        private MyHandler handler = null;

        public MySurfaceView(Context context) {
            super(context);
            // 初始化holder：
            mHolder = getHolder();
            mHolder.addCallback(this);
            mRunnable = new MyHandlerCreateRunnable();

            mPaint = new Paint();
            mPaint.setColor(Color.BLACK);
            mPaint.setAntiAlias(true);
            mPaint.setTextAlign(Align.CENTER);
            mPaint.setTextSize(45);
            new Thread(mRunnable).start();
        }

        public MySurfaceView(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
        }

        public MySurfaceView(Context context, AttributeSet attrs) {
            super(context, attrs);
        }

        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            Log.d(TAG, "==surfaceCreated==");
            // mQueue = new LinkedBlockingQueue<String>();
            new Thread(new MyTimerRunnable()).start();
        }

        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width,
                int height) {
            Log.d(TAG, "==surfaceChanged==");
        }

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            Log.d(TAG, "==surfaceDestroyed==");
        }

        @Override
        public void handleMessage(MyMessage msg) {
            synchronized (mHolder) {
                Canvas mCanvas = null;
                System.out.println("==lockCanvas==");
                mCanvas = mHolder.lockCanvas();// 锁定画布。之后就可以在此画布上画图了。
                String content = (String) msg.obj;
                mCanvas.drawColor(Color.WHITE);
                mCanvas.drawText(content, 100, 400, mPaint);
                mHolder.unlockCanvasAndPost(mCanvas);//
            }
        }

        /**
         * 定时发送消息的线程
         *
         * @author Administrator
         *
         */
        class MyTimerRunnable implements Runnable {
            int index = 0;

            @Override
            public void run() {
                while (true) {
                    MyMessage msg = new MyMessage();
                    msg.obj = "这是第" + index + "个";
                    index++;
                    handler.sendMessage(msg);
                    if (index >= 50) {
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }

        }

        /**
         * 创建MyHandler的线程
         *
         * @author Administrator
         *
         */
        class MyHandlerCreateRunnable implements Runnable {

            @Override
            public void run() {
                MyLooper.prepare();
                handler = new MyHandler(MySurfaceView.this);
                MyLooper.loop();
            }

        }

    }

}

好了。代码都贴完了。现在结合到一块来看。在MyHandlerCreateRunnable中。我们对调用了MyLooper.prepare()方法对当前线程进行了线程局部变量保存。再创建出MyHandler对象。最后让消息循环启动。这时。在此线程中如果没有消息到来。就会在MyLooper的loop()方法中。被阻塞队列的take()方法所阻塞。直到有消息到来。

然后我们在MyTimerRunnable中。对消息进行创建。并使用在MyHandlerCreateRunnable线程中创建的handler对象。对消息进行发送。为了方便。下面贴出局部代码继续分析

/**
     * 发送消息
     *
     * @param msg
     */
    public void sendMessage(MyMessage msg) {
        msg.target = this;
        try {
            mQueue.put(msg);
        } catch (InterruptedException e) {
        }
    }

在此handler的sendMessage方法处。将MyHandler自身作为msg对象的一个成员变量赋值。再将些消息存放入此消息队列中。放入之后。MyLooper.loop()方法中的take()方法就会获取到些msg对象并解除阻塞。继续运行。

/**
     * 这里启动消息循环
     */
    public static void loop() {
        while (true) {
            try {
                myLooper = myLooper();
                BlockingQueue<MyMessage> mQueue = myLooper.mQueue;
                // take()方法是个阻塞方法。线程运行到此会阻塞住。以准备接收发过来的消息
                MyMessage msg = mQueue.take();
                msg.target.dispatchMessage(msg);
            } catch (InterruptedException e) {
                // 当线程关闭的时候会出现此异常。此时退出循环
                return;
            }
        }
    }

运行之后可以看到。通过调用msg.target.dispatchMessage(msg)方法将此message发送给之前我们用来发送消息的MyHandler对象。

/**
     * 派发消息
     *
     * @param msg
     */
    public void dispatchMessage(MyMessage msg) {
        callBack.handleMessage(msg);
    }

接着立马就将此消息对象发送给了自己定义的回调方法中。也就是我们handler用来处理消息的回调方法。handleMessage。

所以。搞了半天。真正用来对线程间进行通信的其实就是一个阻塞队列。。。相信这个结论够简洁明了。。。这是几乎完全仿照安卓原生的handler-looper逻辑来写的。所以。如果你理解了这篇博客。相信更进一步的看Handler-Looper源码会通畅不少。。。

下面提供demo下载。

点击下载demo