Android学习笔记18-聊聊Handler

今天我们来聊聊Android中的Handler机制
1、为什么使用Handler：

Handler是android中的一种异步消息处理机制我们都知道，在android中子线程是不能刷新UI的，我们的解决方法是在子线程通过Handler发送消息来更新UI界面（progressBar可以在子线程更新哦）。我们一般的用法：

        public class MainActivity extends Activity {            @Override            protected void onCreate(Bundle savedInstanceState) {                super.onCreate(savedInstanceState);                setContentView(R.layout.activity_main);                new Thread(){                    @Override                    public void run() {                        Message message = new Message();                        message.what = 0;                        handler.sendMessage(message);//发送消息                    }                }.start();            }            //这里我们采用匿名内部类了，正常我们new一个对象是 new Handler();            //后面加了{}就是匿名内部类，为方便。当然你也可以创建一个class            public Handler handler = new Handler(){                @Override                public void handleMessage(Message msg) {                    switch (msg.what) {                    case 0:                        System.out.println("接受到了消息");                        break;                    default:                        break;                    }                }            };        }

这样写没有问题，但是我们eclipse会报一个警告错误：This Handler class should be static or leaks might occur (com.example.testhandler.MainActivity.1)提示我们最好定义为静态的，否则可能导致内存泄漏。

特别注意：Handler里面的handMessage方法是运行在主线程的，你在这个里面做耗时操作也会导致ANR异常的。

2、Handler为什么会导致内存泄漏呢？

java内存回收机制：    这个涉及到java的内存回收机制（GC）。    如果GC发现一个或一组对象为不可到达状态，则将该对象从内存中回收。    也就是说，一个对象不被任何引用所指向，则该对象会在被GC发现的时候被回收；    另外，如果一组对象中只包含互相的引用，而没有来自它们外部的引用    （例如有两个对象A和B互相持有引用，但没有任何外部对象持有指向A或B的引用），这仍然属于不可到达，同样会被GC回收。分析Handler为什么导致    当使用内部类（包括匿名类）来创建Handler的时候，Handler对象会隐式地持有一个外部类对象    （通常是一个Activity）的引用（不然你怎么可能通过Handler来操作Activity中的View？）。第一种情况：    Handler里面有可能会伴随着一个耗时的后台线程（例如从网络拉取图片）一起出现，    这个后台线程在任务执行完毕（例如图片下载完毕）之后，通过消息机制通知Handler，然后Handler把图片更新到界面。    如果用户在网络请求过程中关闭了Activity，正常情况下，Activity不再被使用，它就有可能在GC检查时被回收掉，但由于这时线程尚未执行完，    而该线程持有Handler的引用（不然它怎么发消息给Handler？），这个Handler又持有Activity的引用，    就导致该Activity无法被回收（即内存泄露）。直到网络请求结束（例如图片下载完毕）。第二种情况：    如果你执行了Handler的postDelayed()方法，该方法会将你的Handler装入一个Message，并把这条Message推到MessageQueue中，    那么在你设定的delay到达之前，会有一条MessageQueue -> Message -> Handler -> Activity 的链，导致你的Activity被持有引用而无法被回收。总结:导致内存泄漏说白了就是handler持有activity的应用，activity被finish掉了，里面的资源得不到释放，导致内存泄漏。我们把handler定义为静态的，这个handler就不会持有activity的引用了，就不存在什么内存泄漏。

3、我们把Handler定义为静态的：

    static class MyHandler extends Handler {          @Override          public void handleMessage(Message msg) {              tv.setText("hello");//必须是静态的        }      } 

发现一个问题，我们在handler中所有的变量都必须是static静态的，这个我们不会将我们所用到的变量都定义为static这个时候我们就出现了弱引用概念。

4、什么是弱引用：

WeakReference弱引用，与强引用（即我们常说的引用）相对。它的特点是，GC在回收时会忽略掉弱引用，即就算有弱引用指向某对象，但只要该对象没有被强引用指向（实际上多数时候还要求没有软引用，但此处软引用的概念可以忽略），该对象就会在被GC检查到时回收掉。对于上面的代码，用户在关闭Activity之后，就算后台线程还没结束，但由于仅有一条来自Handler的弱引用指向Activity，所以GC仍然会在检查的时候把Activity回收掉。这样，内存泄露的问题就不会出现了。例如我们改造后的代码：

        public class TestHanlderActivity extends Activity {            private TextView tv;            @Override            protected void onCreate(Bundle savedInstanceState) {                super.onCreate(savedInstanceState);                setContentView(R.layout.activity_test_hanlder);                tv = (TextView) findViewById(R.id.tv);                new Thread(){                    @Override                    public void run() {                        Message message = new Message();                        message.what = 0;                        handler.sendMessage(message);//发送消息                    }                }.start();            }            public Handler handler = new MyHandler(this) ;//定义handler，将activity传进去            static class MyHandler extends Handler{                final WeakReference<TestHanlderActivity> mActivity;                MyHandler(TestHanlderActivity activity){                    //使用传进来的activity初始化这个弱引用                    mActivity = new WeakReference<TestHanlderActivity>(activity);                }                @Override                public void handleMessage(Message msg) {                    //拿到activity，                    TestHanlderActivity activity = mActivity.get();                    if(null != activity){                        switch (msg.what) {                        case 0:                            //可以使用activity中的非静态的变量啦                            activity.tv.setText("这个是静态的Handler");                            break;                        default:                            break;                        }                    }                }            }        }

总结：    a.我们在主线程去new一个静态的Handler，不管我们new多少个，都是指向同一个Handler。因为static内存中只保留一份。        如果我们不定义static，你每次new一个Handler就会在堆内存中创建一个对象，也是耗费内存的。    b.我们一个线程中只能有一个Looper和一个MessageQueue，所以不管你new多少个handler，都是把消息发送到同一个MessageQueue消息队列中        Looper也只是从这个消息队列中取消息。到这里我们完美解决了handler使用的问题。下面我们从源码分析下Handler的运行机制

5、源码分析Handler的运行机制：

a.应用的入口函数以前一直都说Activity的人口是onCreate方法。其实Android上一个应用的入口，应该是ActivityThread。和普通的Java类一样，入口是一个main方法。

    public static final void main(String[] args) {        SamplingProfilerIntegration.start();       ……        Looper.prepareMainLooper();        if (sMainThreadHandler == null) {            sMainThreadHandler = new Handler();        }        ActivityThread thread = new ActivityThread();        thread.attach(false);       ……        Looper.loop();       ……        thread.detach();        ……        Slog.i(TAG, "Main thread of " + name + " is now exiting");    }

我们的应用入口，先调用了下prepareMainLooper，然后就调用了Looper.loop()进入了无限循环。所以只要我们应用不关闭，Looper就会一直从消息队列中拿消息来处理。这个是运行在主线程中的，别人可能会疑惑，为什么什么在主线程中loop不会导致主线程阻塞呢？    你想一下，如果主线程没有loop，执行完就完了，你的应用不就挂了吗，又何来阻塞一说。b.主线程中默认就创建了个Looper 和MessageQueue    那么我们创建了Handler做了什么呢？    我们new Handler(); 调用了Handler的无参构造方法    android.os.Handler.class里面的代码：（我查看的是API19 android4.4）    Handler中的源码

            /**             * Default constructor associates this handler with the queue for the             * current thread.             *             * If there isn't one, this handler won't be able to receive messages.             */            public Handler() {                if (FIND_POTENTIAL_LEAKS) {                    final Class<? extends Handler> klass = getClass();                    if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&                            (klass.getModifiers() & Modifier.STATIC) == 0) {                        Log.w(TAG, "The following Handler class should be static or leaks might occur: " +                            klass.getCanonicalName());                    }                }                mLooper = Looper.myLooper();//这里我们拿到Looper对象，赋值给了final Looper mLooper; 就相当于我们拿到了主线程的Looper                if (mLooper == null) {                    throw new RuntimeException(                        "Can't create handler inside thread that has not called Looper.prepare()");                }                mQueue = mLooper.mQueue;//我们拿到Looper中的消息队列 final MessageQueue mQueue;                mCallback = null;//我们没有传Callback            }

    mLooper = Looper.myLooper();我们看看干了什么    android.os.Looper源码：

            static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();            //sThreadLocal是一个ThreadLocal对象，可以在一个线程中存储变量。（我们可以理解一个线程的局部变量，里面保存了Looper）            final MessageQueue mQueue;            public static Looper myLooper() {                return sThreadLocal.get();//拿到Looper对象            }

c.我们进入应用就会调用prepare方法

        private Looper() {            mQueue = new MessageQueue();            mRun = true;            mThread = Thread.currentThread();        }

    在构造方法中，创建了一个MessageQueue（消息队列）。

        public static void prepareMainLooper() {            prepare();            setMainLooper(myLooper());            myLooper().mQueue.mQuitAllowed = false;        }        public static void prepare() {            if (sThreadLocal.get() != null) {                throw new RuntimeException("Only one Looper may be created per thread");            }            sThreadLocal.set(new Looper());        }

    我们看loop()方法：

        public static void loop() {            Looper me = myLooper();//拿到存储的Looper实例，如果me为null则抛出异常，也就是说looper方法必须在prepare方法之后运行            if (me == null) {                throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");            }            MessageQueue queue = me.mQueue;//拿到该looper实例中的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();            while (true) {//就进入了我们所说的无限循环                Message msg = queue.next(); // might block                if (msg != null) {                    if (msg.target == null) {                        // No target is a magic identifier for the quit message.                        return;                    }                    long wallStart = 0;                    long threadStart = 0;                    // 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);                        wallStart = SystemClock.currentTimeMicro();                        threadStart = SystemClock.currentThreadTimeMicro();                    }                    msg.target.dispatchMessage(msg);//把消息交给msg的target的dispatchMessage方法去处理                    if (logging != null) {                        long wallTime = SystemClock.currentTimeMicro() - wallStart;                        long threadTime = SystemClock.currentThreadTimeMicro() - threadStart;                        logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);                        if (logging instanceof Profiler) {                            ((Profiler) logging).profile(msg, wallStart, wallTime,                                    threadStart, threadTime);                        }                    }                    // 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.recycle();//释放消息占据的资源                }            }        }

    所以：loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。我们看看怎么取的消息：Message msg = queue.next(); // might block这个代码在MessageQueue中：

        Message next() {          for (;;) {            Message prevMsg = null;            Message msg = mMessages;            if (prevMsg != null) {                  prevMsg.next = msg.next;            } else {                  mMessages = msg.next;            }            msg.next = null;//这个的目的就是为了释放上一个message的引用便于垃圾回收            return msg;          }        }

示意图

d.现在我们看看handler.sendMessage(message);//发送消息

        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)        {            boolean sent = false;            MessageQueue queue = mQueue;            if (queue != null) {                msg.target = this;                sent = queue.enqueueMessage(msg, uptimeMillis);            }            else {                RuntimeException e = new RuntimeException(                    this + " sendMessageAtTime() called with no mQueue");                Log.w("Looper", e.getMessage(), e);            }            return sent;        }

    我们可以看到最终调用到了sent = queue.enqueueMessage(msg, uptimeMillis);    把消息放到消息队列中.

         final boolean enqueueMessage(Message msg, long when) {            if (msg.isInUse()) {                throw new AndroidRuntimeException(msg                        + " This message is already in use.");            }            if (msg.target == null && !mQuitAllowed) {                throw new RuntimeException("Main thread not allowed to quit");            }            final boolean needWake;            synchronized (this) {                if (mQuiting) {                    RuntimeException e = new RuntimeException(                        msg.target + " sending message to a Handler on a dead thread");                    Log.w("MessageQueue", e.getMessage(), e);                    return false;                } else if (msg.target == null) {                    mQuiting = true;                }                msg.when = when;                //Log.d("MessageQueue", "Enqueing: " + msg);                Message p = mMessages;                if (p == null || when == 0 || when < p.when) {                    msg.next = p;                    mMessages = msg;                    needWake = mBlocked; // new head, might need to wake up                } else {                    Message prev = null;                    while (p != null && p.when <= when) {                        prev = p;                        p = p.next;                    }                    msg.next = prev.next;                    prev.next = msg;                    needWake = false; // still waiting on head, no need to wake up                }            }            if (needWake) {                nativeWake(mPtr);            }            return true;        }

    主要是这个代码把消息放到消息队列中    Message p = mMessages;    msg.next = p;    mMessages = msg;    我们画图示意一下    为什么要Message p = mMessages; 然后再把p赋值给msg.next呢？    经过我自己代码测试，p和mMessages都是个内存地址，一样的。只是可能为了在后面用到方便点，不用写这么长吧。    msg.next = mMessages;    mMessages = msg;    //效果是一样

    msg.target = this;//关键的一句代码，把msg的target设置为当前的handler，在loop中我们就回调对应的handler的handMessage方法。

6、handler在子线程中使用：

我们在子线程中使用Handler可以，但是你必须手动调用prepare和loop方法因为主线程在main函数调用了，所以不需要。

    class MyThread extends Thread {        public Handler mHandler;        @Override        public void run() {            Looper.prepare();            mHandler = new Handler() {                public void handleMessage(Message msg) {                    System.out.println("hello handler");                }            };            System.out.println("即将开启loop");            for (int i = 0; i < 10; i++) {                System.out.println(i + "");            }            Looper.loop();            System.out.println("已经开启loop");        }    }

特别注意：你在loop之后的代码是不会执行到了，因为loop了，就相当你的子进程一直阻塞在这里了。所以我们一般没必要在子线程中取定义Handler没有什么应用场景。

一个网上摘下的Handler流程图
发消息

主线程处理消息