Android_Handler机制

最新推荐文章于 2024-06-22 14:45:24 发布

杨迈1949

最新推荐文章于 2024-06-22 14:45:24 发布

阅读量563

点赞数

分类专栏： Android 文章标签： android

本文链接：https://blog.csdn.net/y22222ly/article/details/49002211

版权

Android 专栏收录该内容

31 篇文章 1 订阅

订阅专栏

在安卓中，在不同的线程间通信，可是使用Handler来轻松实现，本文就详细的介绍Handler处理消息的原理。

1,Message

讲Handler机制，我们就不得不涉及到一个很重要的对象Message,Handler使用Message对象作为传输对象，所以Message对象中，可以携带一些对象，直接在另一个线程(handler对象所绑定的线程)中去处理。一个典型的案例就是我们在获取网络图片时必须单开线程，而后通过Handler发送一个Message通知UI线程去更新图片，这里就可以将得到的bitmap作为对象放在Message中，在UI线程中去得到这个bitmap，然后显示在ImageView控件上。

public class MainActivity extends Activity {

    String m_image_url = "https://ss0.bdstatic.com/5aV1bjqh_Q23odCf/static/superplus/img/logo_white_ee663702.png";

    private Handler m_handler;
    private ImageView m_imageView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        m_imageView = (ImageView) findViewById(R.id.imageview_temp);

        //在UI线程中new Handler()这样，处理消息时，也会在主线程中
        m_handler = new Handler(new Handler.Callback() {
            @Override
            public boolean handleMessage(Message msg) {
                if (msg.what == 0x11) {
                    //获得非UI线程传递过来的Bitmap
                    Bitmap bitmap = (Bitmap) msg.obj;
                    if (m_image_url != null) {
                        m_imageView.setImageBitmap(bitmap);
                    }
                }
                return true;//表示拦截消息事件，不会下发到handler的handerMessage()了
            }
        });
    }

    //按钮的触发事件
    public void click_fetch_image(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
//                    请求网络，注意添加网络权限
                    URL url = new URL(m_image_url);
                    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                    connection.setDoInput(true);
                    connection.connect();
                    InputStream inputStream = connection.getInputStream();
                    Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                    if (bitmap != null) {
//                        得到一个Message对象的方法,官方推荐1,2方法
//                        1 new Message();2 Message.obtain();3 handler.obtainMessage();
//                        Message message = Message.obtain();
                        Message message = m_handler.obtainMessage();
//                        设置message传递的信息
//                        2个int类型 message.arg1 .arg2 一个obj类型 message.obj
                        message.what = 0x11;
                        message.obj = bitmap;
//                        发送消息给指定的handler
//                        1 通过Message自己发送
                        message.setTarget(m_handler);
                        message.sendToTarget();
//                        2 通过Handler发送
//                        m_handler.sendMessage(message);
                        Log.d("", "子线程消息发送成功！");
                    }else {
                        Log.d("", "网络图片返回为null");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

代码中已经讲得很清楚怎么去获取一个Message对象，如果给利用message传递参数，如何将一个通过handler发送message.当然messge还有一些其他知识点，这里就先不讲。

2，Looper

第二个重要的类，当然是Looper了。
Looper其实就是一个在线程的处理MessageQueue的一个类，注意这里的线程是任意线程，不要被UI线程中存在looper就以为它只能在UI线程中存在，只是当运行应用时，系统会默认的在UI线程中去创建Looper而已。一个线程中只能有一个looper去处理消息(其实是分发消息给handler去处理)。想要在子线程中使用handler机制，就必须在子线程中创建looper对象。
一个典型的实例如下：

class LooperThread extends Thread {
      public Handler mHandler;

      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

跟进Looper源码中看到Lopper.prapare()最终调用了

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

它的私有构造方法，去创建一个MessageQueue，并绑定当前线程，此时我们线程中就有了looper对象了(或许应该反过来)。

看下looper.loop()做了哪些事情：

    /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        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;
            }

            // 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);
            }

            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();
        }
    }

在第6行，得到当前线程的looper
第10行，得到消息队列，
从第17行开始是一个执行死循环，
18行从消息队列里获得消息，
31行调用handler(message.target就是message绑定的handler)的dispatchMessage()方法，对msg处理message消息

3,Handler

终于言归正传了,因为一般我们都是在UI线程中使用Handler所以这里只讲UI线程中的Handler的用法。

创建一个Handler

先创建一个Handler，我们一般声明的时候就创建，或者在Activity的onCreate()中创建：

Handler handler = new Handler();//这个handler就不具有处理消息的能力
Handler handler= new Handler(new Handler.Callback() {//这个handler可以处理消息,callback方式
            @Override
            public boolean handleMessage(Message msg) {
                //use msg code
                return true;
            }
        });
Handler handler= new Handler(){//这个handler可以处理消息,匿名内部类方式
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
            }
        };

Handler的两个最大的用处就是1，在另一个线程中发送message，或者runnable将他们入队(MessageQueue)；2，处理message或者runnable。

使用handler发送消息

1，Message方式
前面讲Message时，讲过了，就是调用m_handler.sendMessage()方法发送消息
2，Runnable方式
如果不需要传递数据给另一个线程，只需要通知handler线程执行某个方法，比如切换一个Button的状态，这时候，就应该用Runnable方式：

        new Handler().post(new Runnable() {
            @Override
            public void run() {
                //handler所在线程执行的代码
                //code
            }
        });

前面去面试一家公司，面试官问我：handler发送消息的Message和Runnable方式有什么区别?苦逼的我当时没研究过handler源码，没答上来。
现在分析一下，就应该去看一下这个post()方法怎么去处理这个Runnable的，先看一下handler的post()方法

    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

看到这个方法名，就有点懂了，其实还是去发送了个Message消息，因为这个sendMessageDelayed()的第一个参数是一个Message对象，下面跟进getPostMessage()

    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

看到这里就明白了，当使用Runnable形式发送消息时，也是发送一个Message对象，只是记录在了message.callback中。

使用Handler处理消息

在处理之前，先看一下，handler把是如何把消息发送出去，然后消息又回到handler中去处理的

    Class Handler

    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

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

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        /** mQueue为Looper中的MessageQueue */
        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);
    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    /** 设置当前消息的handler对象 */
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        /** messageQueue将msg加入队列 */
        return queue.enqueueMessage(msg, uptimeMillis);
    }

Class MessageQueue

boolean enqueueMessage(Message msg, long when) {
        /** 没有找到发送者(handler) */
        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加入队列 */
                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;
    }

通过分析Handler和MessageQueue的源码，可以发现，Handler发送一条消息之后，是加入到Looper的MessageQueue中的，这样Looper.loop()就能实时的从MessageQueue中去获得消息了，通过调用msg.target.dispatchMessage(msg);将当前的msg消息发送给原来的发送者target来处理。
现在message又回到了Handler中，分析一下handler.dispatchMessage()：

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
        /** 表明使用Runnable方式发送 */
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    /** 如果存在callback拦截消息 ，并返回true */
                    return;
                }
            }
            /** 这就是我们常重写的handlerMessage() */
            handleMessage(msg);
        }
    }

到这里，就恍然大悟了，msg已经到我们的handlerMessage()碗里来了。不过还是要看一下handlerCallBack(）是怎么处理Runnable的

    private static void handleCallback(Message message) {
        message.callback.run();
    }

很简单的一行代码，就是去跑一个run()方法，而不是start()。
这里分析一下，线程中绑定的是Looper对象，也就是说当前线程一直有一个looper在轮询消息，当looper轮询到一条消息时，就通知handler去处理，注意这是在同一个线程中，也就是looper所在的线程中。handler如果去调用一个实现runnable接口的start(）方法岂不是又新开启了一个线程了，所以这里直接调用了run()方法，在当前线程就执行就行了。

4,使用Handler完成定时任务

Handler除了上面提到的基本用法外，还有一个常用功能就是在UI线程执行一个定时的任务，比如让一个TextView自增长。

    private Handler m_handler;

    public void click_start(View view) {
        m_handler = new Handler();
        //发送一个runnable，延迟一秒执行
        m_handler.postDelayed(m_runnable, 1000);
    }

    public void click_cancel(View view){
        //从消息队列中移除runnable
        m_handler.removeCallbacks(m_runnable);
    }

    Runnable m_runnable = new Runnable() {
        int i = 1;
        @Override
        public void run() {
            m_increment_textview.setText("" + i++);
            //在run()中又去发送一个runnable,就是一个循环调用的过程
            m_handler.postDelayed(this, 1000);
        }
    };