Android 多线程——Handler的基本使用

一、Handler的基本使用

1、创建 Handler

Handler 允许我们发送延时消息，如果在延时期间用户关闭了 Activity，那么该 Activity 会泄露。

这个泄露是因为 Message 会持有 Handler，而又因为 Java 的特性，内部类会持有外部类，使得 Activity 会被 Handler 持有，这样最终就导致 Activity 泄露。

解决方案：将 Handler 定义成静态的内部类，在内部持有 Activity 的弱引用，并及时移除所有消息。

public class HandlerActivity extends AppCompatActivity {


    private Button bt_handler_send;


    private static class MyHandler extends Handler {


        //弱引用持有HandlerActivity , GC 回收时会被回收掉
        private WeakReference<HandlerActivity> weakReference;


        public MyHandler(HandlerActivity activity) {
            this.weakReference = new WeakReference(activity);
        }


        @Override
        public void handleMessage(Message msg) {
            HandlerActivity activity = weakReference.get();
            super.handleMessage(msg);
            if (null != activity) {
                //执行业务逻辑
                Toast.makeText(activity,"handleMessage",Toast.LENGTH_SHORT).show();
            }
        }
    }


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


        //创建 Handler
        final MyHandler handler = new MyHandler(this);


        bt_handler_send = findViewById(R.id.bt_handler_send);
        bt_handler_send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //使用 handler 发送空消息
                        handler.sendEmptyMessage(0);


                    }
                }).start();
            }
        });
    }
    
    @Override
    protected void onDestroy() {
        //移除所有回调及消息
        myHandler.removeCallbacksAndMessages(null);
        super.onDestroy();
    }
}

        我们处理可以通过继承的方式创建Handler外还可以通过new的方式创建：

Handler handler = new Handler(Looper.myLooper()) {

    @Override
    public void handleMessage(@NonNull Message msg) {
    }
};

2、Message获取

获取 Message 大概有如下几种方式：

Message message = myHandler.obtainMessage(); //通过 Handler 实例获取

Message message1 = Message.obtain(); //通过 Message 获取

Message message2 = new Message(); //直接创建新的 Message 实例

通过查看源码可知，Handler 的 obtainMessage() 方法也是调用了 Message 的 obtain() 方法

public final Message obtainMessage()
{
    return Message.obtain(this);
}

通过查看 Message 的 obtain 方法

public static Message obtain(Handler h) {
        //调用下面的方法获取 Message
        Message m = obtain();
        //将当前 Handler 指定给 message 的 target ，用来区分是哪个 Handler 的消息
        m.target = h;


        return m;
}
    
//从消息池中拿取 Message，如果有则返回，否则创建新的 Message
public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
}

为了节省开销，我们在使用的时候尽量复用 Message，使用前两种方式进行创建。

3、Handler发送消息

Handler 提供了一些列的方法让我们来发送消息，如 send()系列 post()系列,post方法需要传入一个Runnalbe对象 ,我们来看看post方法源码

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

不过不管我们调用什么方法，最终都会走到 MessageQueue.enqueueMessage(Message,long) 方法。 以 sendEmptyMessage(int) 方法为例： 

//Handler
sendEmptyMessage(int)
  -> sendEmptyMessageDelayed(int,int)
    -> sendMessageAtTime(Message,long)
      -> enqueueMessage(MessageQueue,Message,long)
  			-> queue.enqueueMessage(Message, long);

从中可以发现 MessageQueue 这个消息队列，负责消息的入队，出队。

二、Handler的使用实例

1、子线程向主线程

首先我们在MainActivity中添加一个静态内部类，并重写其handleMessage方法。

private static class MyHandler extends Handler {
        private final WeakReference<MainActivity> mTarget;


        public MyHandler(MainActivity activity) {
            mTarget = new WeakReference<MainActivity>(activity);
        }


        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            HandlerActivity activity = weakReference.get();
            super.handleMessage(msg);
            if (null != activity) {
                //执行业务逻辑
                if (msg.what == 0) {
                	Log.e("myhandler", "change textview");
                	MainActivity ma = mTarget.get();
	                ma.textView.setText("hahah");
            	}
                Toast.makeText(activity,"handleMessage",Toast.LENGTH_SHORT).show();
            }
        
        }
 }

然后创建一个类型为MyHandler的私有属性：

private Handler handler1 = new MyHandler(this);

最后在onCreate回调中创建一个线程，用于发送消息：

new Thread(new Runnable() {
            @Override
            public void run() {
                handler1.sendEmptyMessage(0);
            }
        }).start();

总结一下：

Handler的子类对象一般是在主线程中进行创建，以便在两个线程中都能访问。我们创建了Handler类的子类MyHandler，并重写了handlerMessage方法，这个方法是当使用接收处理发送的消息的。然后我们创建了一个子线程，在子线程中我们使用MyHandler的对象调用sendEmptyMessage方法发送了一个空的Message。然后我们就能在主线程中接收到这个数据。

2、主线程发送消息到子线程（虽然这种应用场景很少）

首先创建一个MyHandler类。

private static class MyHandler extends Handler {


    @Override
    public void handleMessage(@NonNull Message msg) {
        super.handleMessage(msg);
        if (msg.what == 0) {
            Log.e("child thread", "receive msg from main thread");
        }
    }
}

声明一个Handler类型的私有变量，进行默认初始化为null。

private Handler handler1;

创建子线程，使handler指向新创建的MyHandler对象。

new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                handler1 = new MyHandler();
                Looper.loop();
                Log.e("child thread", "child thread end");
            }
        }).start();

在主线程中向子线程中发送消息

while (handler1 == null) {

}
handler1.sendEmptyMessage(0);
handler1.getLooper().quitSafely();