Android进阶——深入浅出Handler（一）

分手后的思念是犯贱 2022-06-02 10:29 162阅读 0赞

在学习Handler之前，首先要学习一些基本概念，这将对之后的学习有所帮助。

*  主线程：Main Thread,又叫UI线程（UI Thread）。Android应用执行的线程，所以叫主线程。负责分发事件到合适的UI窗口,也是应用和Android UI套件交互的线程。所以叫UI线程。
 *  ANR：应用无响应(application not responding)。如果UI线程阻塞超过几秒（现在一般是5秒），用户就会看到应用无响应的Dialog。

下面用代码来解释什么是主线程和ANR：

@Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_handler);
     //查看当前线程，
     Log.d("TAG", "current Thread's name:" +  Thread.currentThread().getName());
     
      //休眠UI线程5秒，制造ANR
            Thread thread = Thread.currentThread();
            try {
                thread.sleep(5*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    }

![ANR][]

> 参考:
> 
> [1.Processes and Threads][]
> 
> [2.What is the Android UiThread (UI thread）][2.What is the Android UiThread _UI thread]

### 初识Handler ###

首先我们通过一个Demo学习Handler的两种基本用途:

*  1.延迟执行messages或runnables
 *  2.将A线程的操作入队到B线程中

第一种用途比较好理解，比如延时finish掉启动Activity。第二种是我们在经常需要子线程中执行耗时操作，可能是读取文件或访问网络，但是我们只能在主线程中更新UI。所以使用Handler来将更新UI的操作从子线程切换到主线程中执行。

1.继承Handler类，实现handleMessage方法。一般不推荐使用非静态内部类的方式实现，会导致内存泄露。具体原因可参看我上一篇文章，[Android开发——避免内存泄露][Android]。推荐使用**静态内部类和弱引用结合**的方式来实现。如下所示。

private static class MyHandler extends Handler{
    
            //对Activity的弱引用
            private final WeakReference<HandlerActivity> mActivity;
    
            public MyHandler(HandlerActivity activity){
                mActivity = new WeakReference<HandlerActivity>(activity);
            }
    
            @Override
            public void handleMessage(Message msg) {
                HandlerActivity activity = mActivity.get();
                if(activity==null){
                    super.handleMessage(msg);
                    return;
                }
                switch (msg.what) {
                    case DOWNLOAD_FAILED:
                        Toast.makeText(activity, "下载失败", Toast.LENGTH_SHORT).show();
                        break;
                    case DOWNLOAD_SUCCESS:
                        Toast.makeText(activity, "下载成功", Toast.LENGTH_SHORT).show();
                        Bitmap bitmap = (Bitmap) msg.obj;
                        activity.imageView.setVisibility(View.VISIBLE);
                        activity.imageView.setImageBitmap(bitmap);
                        break;
                    default:
                        super.handleMessage(msg);
                        break;
                }
            }
        }
    
        private final MyHandler mHandler = new MyHandler(this);

2.使用post方法发送Runnable对象，sendMessage方法来发送Message。

下面的代码通过postDelayed执行1秒后将Button显示或隐藏的操作。在下载完图片后使用sendMessage通知UI线程更新ImageView。

//使用Handler进行延时操作
                    mHandler.postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            imageView.setVisibility(imageView.getVisibility()==View.VISIBLE?View.GONE:View.VISIBLE);
                        }
                    },1000);
                    
        //使用子线程下载图片
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            Bitmap bitmap = downloadImage();
    
                            Message msg = Message.obtain();
                            msg.obj = bitmap;
                            msg.what = bitmap==null?DOWNLOAD_FAILED:DOWNLOAD_SUCCESS;
    
                            handler.sendMessage(msg);
                        }
                    }).start();

运行效果:

![handler.gif][]

### 进一步了解Handler ###

说起Handler，就不得不提Message、MessageQueue以及Looper。搞清楚这四者之间的关系，Android开发中的Handler消息处理机制也掌握了个大概了。

#### Message ####

Message：包含描述和任意数据对象的消息，用于发送给Handler。

//获取Message实例的方式
    Message msg1 = Message.obtain();
    //或
    Message msg2 = Handler.obtainMessage();

学到这里，可能有人会有疑问。不是可通过Handler发送Runnable对象的吗？为什么这里只提Message了呢？

好问题，让我们来查看post类方法的源码。

public final boolean postDelayed(Runnable r, long delayMillis)
        {
            return sendMessageDelayed(getPostMessage(r), delayMillis);
        }
     
       private static Message getPostMessage(Runnable r) {
            Message m = Message.obtain();
            m.callback = r;
            return m;
        }

在postDelayed()方法内部，将Runnable对象通过getPostMessage()方法包装成了一个Message对象。这样就回答了我们之前的疑问。对于Handler，不管是使用的是post类方法还是send类方法，发送出去的都是Message对象。

public final class Message implements Parcelable {
        
        public int what;
        public int arg1; 
        public int arg2;
        public Object obj;
        ...
        }

Message类中有这几个成员变量描述消息，其中what是我们定义的消息码，为了让接收者能知道消息是关于什么的。arg1和arg2用于发送一些integer类型的值。obj用于传输任意类型的值。

### MessageQueue ###

MessageQueue：顾名思义，消息队列。内部存储着一组消息。对外提供了插入和删除的操作。MessageQueue内部是以单链表的数据结构来存储消息列表的。

获取MessageQueue实例使用Looper.myQueue()方法。

查看源码中的enqueueMessage()方法能看出MessageQueue是用单链表的数据结构来存储消息的。

//插入Message操作
    boolean enqueueMessage(Message msg, long when) {
            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(TAG, 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.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 (;;) {
                        //从这里可看出MessageQueue内部是以单链表的数据结构来存储消息的
                        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;
        }

### Looper ###

Looper:主要用于给一个线程轮询消息的。线程默认没有Looper,在创建Handler对象前，我们需要为线程创建Looper。

使用Looper.prepare()方法创建Looper，使用Looper.loop()方法运行消息队列。

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

这里就有疑问了，之前我们在主线程中，创建Handler之前并没有创建Looper。这是为什么呢？查看[Main Thread源码][Main Thread]（也就是ActivityThread）。

public static void main(String[] args) {
            ...
            //初始化Looper
            Looper.prepareMainLooper();
    
            ActivityThread thread = new ActivityThread();
            thread.attach(false);
    
            if (sMainThreadHandler == null) {
                sMainThreadHandler = thread.getHandler();
            }
    
            if (false) {
                Looper.myLooper().setMessageLogging(new
                        LogPrinter(Log.DEBUG, "ActivityThread"));
            }
    
            // End of event ActivityThreadMain.
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            Looper.loop();
    
            throw new RuntimeException("Main thread loop unexpectedly exited");
        }
    }

在ActivityThread的main方法中，初始化了Looper。这就是为什么我们在主线程中不需要创建Looper的原因。

好，今天的学习就到这。下次将继续学习Handler、Message和Message之间的关系。

转贴 https://www.cnblogs.com/JohnTsai/p/5259869.html

[ANR]: http://7xr1jz.com1.z0.glb.clouddn.com/QQ20160309-0%402x.png
[1.Processes and Threads]: http://developer.android.com/guide/components/processes-and-threads.html#Threads
[2.What is the Android UiThread _UI thread]: http://stackoverflow.com/questions/3652560/what-is-the-android-uithread-ui-thread
[Android]: http://www.cnblogs.com/JohnTsai/p/5256295.html
[handler.gif]: http://7xr1jz.com1.z0.glb.clouddn.com/handler.gif
[Main Thread]: https://github.com/android/platform_frameworks_base/blob/master/core/java/android/app/ActivityThread.java