Android基础夯实

jiffes 2019-01-15

展开全文

概述

对于刚入门的同学来说，往往都会对Handler比较迷茫，到底Handler是个什么样的东西。当然，可能对于一些有工作经验的工程师来说，他们也不一定能很准确地描述，我们来看下API的介绍。

Handler是用来结合线程的消息队列来发送、处理“Message对象”和“Runnable对象”的工具。每一个Handler实例之后会关联一个线程和该线程的消息队列。当你创建一个Handler的时候，从这时开始，它就会自动关联到所在的线程/消息队列，然后它就会陆续把Message/Runnalbe分发到消息队列，并在它们出队的时候处理掉。

从官方文档中，我们不难找出其中的关键词，就是“线程”。我们都知道，一个涉及到网络操作，耗时操作等的Android应用，都离不开多线程操作，然而，如果这时我们允许并发更新UI，那么最终导致控件的状态都是不可确定的。所以，我们可以通过对控件进行加锁，在不需要用时解锁，这是一个解决方案之一，但最后很容易造成线程阻塞，效率会非常差。所以，谷歌采用了只允许在主线程更新UI，所以作为线程通信桥梁的Handler也就应运而生了。

Looper、MessageQueue、Message、Handler的关系

讲到Handler，肯定离不开Looper、MessageQueue、Message这三者和Handler之间的关系，下面简略地带过，详细自己可以查阅相关资料，或者查看源码，这样更方便大家深入学习。

Looper

每一个线程只有一个Looper，每个线程在初始化Looper之后，然后Looper会维护好该线程的消息队列，用来存放Handler发送的Message，并处理消息队列出队的Message。它的特点是它跟它的线程是绑定的，处理消息也是在Looper所在的线程去处理，所以当我们在主线程创建Handler时，它就会跟主线程唯一的Looper绑定，从而我们使用Handler在子线程发消息时，最终也是在主线程处理，达到了异步的效果。

那么就会有人问，为什么我们使用Handler的时候从来都不需要创建Looper呢？这是因为在主线程中，ActivityThread默认会把Looper初始化好，prepare以后，当前线程就会变成一个Looper线程。

MessageQueue

MessageQueue是一个消息队列，用来存放Handler发送的消息。每个线程最多只有一个MessageQueue。MessageQueue通常都是由Looper来管理，而主线程创建时，会创建一个默认的Looper对象，而Looper对象的创建，将自动创建一个MessageQueue。其他非主线程，不会自动创建Looper。

Message

消息对象，就是MessageQueue里面存放的对象，一个MessageQueu可以包括多个Message。当我们需要发送一个Message时，我们一般不建议使用new Message()的形式来创建，更推荐使用Message.obtain()来获取Message实例，因为在Message类里面定义了一个消息池，当消息池里存在未使用的消息时，便返回，如果没有未使用的消息，则通过new的方式创建返回，所以使用Message.obtain()的方式来获取实例可以大大减少当有大量Message对象而产生的垃圾回收问题。

四者关系总体如下（如有不对的地方，谢谢指出）

Handler的主要用途

推送未来某个时间点将要执行的Message或者Runnable到消息队列。
在子线程把需要在另一个线程执行的操作加入到消息队列中去。

废话不多说，通过举例来说明Handler的两个主要用途。

1. 推送未来某个时间点将要执行的Message或者Runnable到消息队列

实例：通过Handler配合Message或者Runnable实现倒计时

首先看一下效果图

方法一，通过Handler + Message的方式实现倒计时。代码如下：

public class MainActivity extends AppCompatActivity {
    private ActivityMainBinding mBinding;

    private Handler mHandler ;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);

        //设置监听事件
        mBinding.clickBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //通过Handler + Message的方式实现倒计时
                for (int i = 1; i <= 10; i++) {
                    Message message = Message.obtain(mHandler);
                    message.what = 10 - i;
                    mHandler.sendMessageDelayed(message, 1000 * i); //通过延迟发送消息，每隔一秒发送一条消息
                }
            }
        });

        mHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                mBinding.time.setText(msg.what + "");   //在handleMessage中处理消息队列中的消息
            }
        };
    }
}

其实代码不用怎么解释，都比较通俗易懂，但是这里用到了DataBiding，可能没用过的同学看起来有点奇怪，但其实反而简略了代码，有一定基础的同学看起来都不会有太大压力，所以不做太多解释。通过这个小程序，作者希望大家可以了解到Handler的一个作用就是，在主线程中，可以通过Handler来处理一些有顺序的操作，让它们在固定的时间点被执行。

方法二，通过Handler + Runnable的方式实现倒计时。代码如下：

public class MainActivity extends AppCompatActivity {
    private ActivityMainBinding mBinding;
    private Handler mHandler = new Handler();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);

        //设置监听事件
        mBinding.clickBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                for (int i = 1; i <= 10; i++) {
                    final int fadedSecond = i;
                    //每延迟一秒，发送一个Runnable对象
                    mHandler.postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            mBinding.time.setText((10 - fadedSecond) + "");
                        }
                    }, 1000 * i);
                }
            }
        });
    }
}

方法二也是通过代码让大家加深Handler处理有序事件的用途，之所以分开Runnable和Message两种方法来实现，是因为很多人都搞不清楚为什么Handler可以推送Runnable和Message两种对象。其实，无论Handler将Runnable还是Message加入MessageQueue，最终都只是将Message加入到MessageQueue。只要大家看一下源码就可以知道，Handler的post Runnable对象这个方法只是对post Message进行了一层封装，所以最终我们都是通过Handler推送了一个Message罢了，至于为什么会分开两种方法，下文会给大家详说究竟。下面再来看看Handler的第二个主要用途。

2. 在子线程把需要在另一个线程执行的操作加入到消息队列中去

实例：通过Handler + Message来实现子线程加载图片，在UI线程显示图片

效果图如下

代码如下(布局代码也不放出来了)


public class ThreadActivity extends AppCompatActivity implements View.OnClickListener {
    private ActivityThreadBinding mBinding = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding = DataBindingUtil.setContentView(this, R.layout.activity_thread);
        // 设置点击事件
        mBinding.clickBtn.setOnClickListener(this);
        mBinding.resetBtn.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            // 响应load按钮
            case R.id.clickBtn:
                // 开启一个线程
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        // 在Runnable中进行网络读取操作，返回bitmap
                        final Bitmap bitmap = loadPicFromInternet();
                        // 在子线程中实例化Handler同样是可以的，只要在构造函数的参数中传入主线程的Looper即可
                        Handler handler = new Handler(Looper.getMainLooper());
                        // 通过Handler的post Runnable到UI线程的MessageQueue中去即可
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                // 在MessageQueue出队该Runnable时进行的操作
                                mBinding.photo.setImageBitmap(bitmap);
                            }
                        });
                    }
                }).start();
                break;
            case R.id.resetBtn:
                mBinding.photo.setImageBitmap(BitmapFactory.decodeResource(getResources(), R.mipmap.default_pic));
                break;
        }
    }

    /***
     * HttpUrlConnection加载图片，不多说
     * @return
     */
    public Bitmap loadPicFromInternet() {
        Bitmap bitmap = null;
        int respondCode = 0;
        InputStream is = null;
        try {
            URL url = new URL("https://ss2./70cFvnSh_Q1YnxGkpoWK1HF6hhy/it/u=1421494343,3838991329&fm=23&gp=0.jpg");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setConnectTimeout(10 * 1000);
            connection.setReadTimeout(5 * 1000);
            connection.connect();
            respondCode = connection.getResponseCode();
            if (respondCode == 200) {
                is = connection.getInputStream();
                bitmap = BitmapFactory.decodeStream(is);
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
            Toast.makeText(getApplicationContext(), "访问失败", Toast.LENGTH_SHORT).show();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return bitmap;
    }
}

Handler推送Message和Runnable的区别

在上文我们通过用Handler推送Message和Runnable实现相同的倒计时效果，这里我们就说一下Post(Runnable)和SendMessage(Message)的区别。

首先我们看看post方法和sendMessage方法的源码：

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

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

可见，两个方法都是通过调用sendMessageDelayed方法实现的，所以可以知道它们的底层逻辑是一致的。

但是，post方法的底层调用sendMessageDelayed的时候，却是通过getPostMessage(r)来将Runnable对象来转为Message，我们点进方getPostMessage()法可以看到：

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

其实，最终runnable最终也是转化为一个Message，而这个Message只有一个被赋值的成员变量，就是Runnable的回调函数，也就是说，这个Message在进入MessageQueue之后，它只是一个“动作”，即我们Runnbale的run方法里面的操作。

要知道，我们的Message类可是有很多参数的，所以你可以理解为它是一个非常丰富的JavaBean，可以看看它的成员变量：

public int what;
public int arg1;
public int arg2;
public Object obj;
...

那么讲到这里，大家也应该有所理解为什么Google工程师为什么会封装这两种方法，我总结如为：为了更方便开发者根据不同需要进行调用。当我们需要传输很多数据时，我们可以使用sendMessage来实现，因为通过给Message的不同成员变量赋值可以封装成数据非常丰富的对象，从而进行传输；当我们只需要进行一个动作时，直接使用Runnable，在run方法中实现动作内容即可。当然我们也可以通过Message.obtain(Handler h, Runnable callback)来传入callback接口，但这样看起来就没有post(Ruannable callback)那么直观。

API

API是我们学习最好的文档，所以我也简要跟大家学习一下，其实大家认真看我上面的介绍加上自己亲手实践，Handler的API大家都可以随便翻阅了。

构造函数

Handler()
Handler(Handler.Callback callback)：传入一个实现的Handler.Callback接口，接口只需要实现handleMessage方法。
Handler(Looper looper)：将Handler关联到任意一个线程的Looper，在实现子线程之间通信可以用到。
Handler(Looper looper, Handler.Callback callback)

主要方法

void dispatchMessage (Message msg)

一般情况下不会使用，因为它的底层实现其实是作为处理系统消息的一个方法，如果真要用，效果和sendMessage(Message m)效果一样。

    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            // 如果有Runnbale，则直接执行它的run方法
            handleCallback(msg);
        } else {
            //如果有实现自己的callback接口
            if (mCallback != null) {
                //执行callback的handleMessage方法
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //否则执行自身的handleMessage方法
            handleMessage(msg);
        }
    }
    
    private static void handleCallback(Message message) {
        message.callback.run();
    }

void dump (Printer pw, String prefix)

主要Debug时使用的一个方法，dump函数只是使用了Printer对象进行了打印，打印出Handler以及Looper和Queue中的一些信息，源码如下：

    public final void dump(Printer pw, String prefix) {
        pw.println(prefix + this + " @ " + SystemClock.uptimeMillis());
        // 如果Looper为空，输出Looper没有初始化
        if (mLooper == null) {
            pw.println(prefix + "looper uninitialized");
        } else {
            // 否则调用Looper的dump方法，Looper的dump方法也是
            mLooper.dump(pw, prefix + "  ");
        }
    }

通过测试用例大家会了解得更清晰：

        //测试代码
        Printer pw = new LogPrinter(Log.ERROR, "MyTag");
        mHandler.dump(pw, "prefix");

结果：

Looper getLooper ()

拿到Handler相关联的Looper

String getMessageName (Message message)

获取Message的名字，默认名字为message.what的值。

void handleMessage (Message msg)

处理消息。

boolean hasMessages (int what)

判断是否有Message的what值为参数what。

boolean hasMessages (int what, Object object)

判断是否有Message的what值为参数what，obj值为参数object。

Message obtainMessage (int what, Object obj)

从消息池中拿到一个消息并赋值what和obj，其他重载函数同理。

boolean post (Runnable r)

将Runnable对象加入MessageQueue。

boolean post (Runnable r)

将Runnbale加入到消息队列的队首。但是官方不推荐这么做，因为很容易打乱队列顺序。

boolean postAtTime (Runnable r, Object token, long uptimeMillis)

在某个时间点执行Runnable r。

boolean postDelayed (Runnable r, long delayMillis)

当前时间延迟delayMillis个毫秒后执行Runnable r。

void removeCallbacks (Runnable r, Object token)

移除MessageQueue中的所有Runnable对象。

void removeCallbacksAndMessages (Object token)

移除MessageQueue中的所有Runnable和Message对象。

void removeMessages (int what)

移除所有what值得Message对象。

boolean sendEmptyMessage (int what)

直接拿到一个空的消息，并赋值what，然后发送到MessageQueue。

boolean sendMessageDelayed (Message msg, long delayMillis)

在延迟delayMillis毫秒之后发送一个Message到MessageQueue。

Handler引发的内存泄漏

在上面的例子中，为了展示方便，我都没有考虑内存泄漏的情况，但是在实际开发中，如果不考虑代码的安全性的话，尤其当一个项目到达了一定的规模之后，那么对于代码的维护和系统的调试都是非常困难的。而Handler的内存泄漏在Android中也是一个非常经典的案例。

详细可以参考：How to Leak a Context: Handlers & Inner Classes

或参考翻译文：Android中Handler引起的内存泄露

通常我们都会在一个Activity内部定义一个Handler的内部类：

public class MainActivity extends AppCompatActivity {

    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
                 ...
            }
        }
    };
    
        @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);


        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                ...
            }
        }, 1000000);

    }
}

（1）外部类Activity中定义了一个非静态内部类Handler，非静态内部类默认持有对外部类的引用。如果外部Activity突然关闭了，但是MessageQueue中的消息还没处理完，那么Handler就会一直持有对外部Activty的引用，垃圾回收器无法回收Activity，从而导致内存泄漏。

(2) 如上代码，在postDelayed中，我们在参数中传入一个非静态内部类Runnable，这同样会造成内存泄漏，假如此时关闭了Activity，那么垃圾回收器在接下来的1000000ms内都无法回收Activity，造成内存泄漏。

解决方案：

(1) 将非静态内部类Handler和Runnable转为静态内部类，因为非静态内部类(匿名内部类)都会默认持有对外部类的强引用。

(2) 改成静态内部类后，对外部类的引用设为弱引用，因为在垃圾回收时，会自动将弱引用的对象回收。

避免内存泄漏的例子：

public class HandlerActivity extends AppCompatActivity {

    private final MyHandler mHandler = new MyHandler(this);

    private static final Runnable mRunnable = new Runnable() {
        @Override
        public void run() {
            // 操作
        }
    };


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_fourth);

        mHandler.postDelayed(mRunnable, 1000*10);
        
        finish();   
    }


    private static class MyHandler extends Handler {
        WeakReference<HandlerActivity> mWeakActivity;

        public MyHandler(HandlerActivity activity) {
            this.mWeakActivity = new WeakReference<HandlerActivity>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            final HandlerActivity mActivity = mWeakActivity.get();
            if (mActivity != null) {
                // 处理消息
            }
        }
    }

}

HandlerThread

思考一下，假如我们需要同时下载A和B，下载A需要6s，下载B需要5s，在它们下载完成后Toast信息出来即可，此时HandlerThread便是一种解决方式之一。那么HandlerThread到底是什么？

HandlerThread就是一种线程。
HandlerThread和普通的Thread之间的区别就是HandlerThread在创建的时候会提供自己该线程的Looper对象。

所以，如果大家了解清楚了我前面所讲的Looper、Message、Handler、MessageQueue的关系的话，这里就很清楚HandlerThread是什么东西了。大家都知道，我们在Actvity创建时系统会自动帮我们初始化好主线程的Looper，然后这个Looper就会管理主线程的消息队列。但是在我们创建子线程时，系统并不会帮我们创建子线程的Looper，需要我们自己手动创建，如下：

    new Thread(){
        @Override
        public void run() {
            super.run();
            Looper.prepare();
            Handler mHandler = new Handler(Looper.myLooper());
            Looper.loop();
        }
    }.start();

所以HandlerThread就在内部帮我们封装了Looper的创建过程，从源码可以看到，HandlerThread集成于Thread，然后覆写run方法，进行Looper的创建，从而通过getLooper方法暴露出该线程的Looper对象

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;
    
    ...
    
    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }
    
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        
        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }
    
    ...
}

所以通过HandlerThread，我们可以轻松创建一个包含了Looper的子线程：

final HandlerThread mHandlerThread = new HandlerThread("HandlerThread");

mHandlerThread.start();

Handler mHandler = new Handler(mHandlerThread.getLooper());

使用HandlerThread同时下载A和B的Demo：

代码：

public class HandlerThreadActivity extends AppCompatActivity {
    private TextView tv_A, tv_B;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_thread);

        tv_A = (TextView) findViewById(R.id.txt_dlA);
        tv_B = (TextView) findViewById(R.id.txt_dlB);

        final Handler mainHandler = new Handler();

        final HandlerThread downloadAThread = new HandlerThread("downloadAThread");
        downloadAThread.start();
        Handler downloadAHandler = new Handler(downloadAThread.getLooper());

        // 通过postDelayed模拟耗时操作
        downloadAHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(getApplicationContext(), "下载A完成", Toast.LENGTH_SHORT).show();
                mainHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        tv_A.setText("A任务已经下载完成");
                    }
                });
            }
        }, 1000 * 5);


        final HandlerThread downloadBThread = new HandlerThread("downloadBThread");
        downloadBThread.start();
        Handler downloadBHandler = new Handler(downloadBThread.getLooper());

        // 通过postDelayed模拟耗时操作
        downloadBHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(getApplicationContext(), "下载B完成", Toast.LENGTH_SHORT).show();
                mainHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        tv_B.setText("B任务已经下载完成");
                    }
                });

            }
        }, 1000 * 7);
    }
}

总结

由于Android的UI更新只能在主线程，所以Handler是Android中一套非常重要的更新UI线程机制，虽然在很多框架的帮助下我们可以减少了很多Handler的代码编写，但实际上很多框架的底层实现都是通过Handler来更新UI的，所以可见掌握好Handler对我们来说是多么重要，所以这也是很多面试官在面试中的高频考点之一。虽然Handler对开发者来说是一个非常方便的存在，但是我们也不能否认它也是存在缺点的，如处理不当，Handler所造成的的内存泄漏对开发者来说也是一个非常头疼的难题。