我终于读懂了Handler（二)
接上篇 我终于读懂了Handler（一）
经过上一篇的阅读，相信你对handler已经有了一定的理解。本篇就开始进行实践
1. 多个handler在多线程中的应用
public class HandlerTestActivity extends AppCompatActivity {
private static final String TAG = "HandlerTestActivity";
private Handler mHandler;
private Handler mHandler1;
private MyThread mThread1;
private Handler mHandler2;
private MyThread mThread2;
class MyThread extends Thread {
private Looper mLooper;
@Override
public void run() {
super.run();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Looper.loop();
}
public Looper getLooper() {
if (!isAlive()) {
return null;
}
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mThread1 = new MyThread();
mThread1.start();
mThread2 = new MyThread();
mThread2.start();
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.d(TAG,"get Message =="+msg.what);
}
};
new Thread(() -> mHandler.sendEmptyMessage(10)).start();
mHandler.sendEmptyMessage(0);
mHandler1 = new Handler(mThread1.getLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.d(TAG,"get Message =="+msg.what);
}
};
mHandler1.sendEmptyMessage(1);
mHandler2 = new Handler(mThread2.getLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.d(TAG,"get Message =="+msg.what);
}
};
mHandler2.sendEmptyMessage(2);
}
}
输出结果：
这里我们实验了多个线程之间发送消息的情况。
- Handler默认实例化和Handler指定Looper对象实例化的比较
- handler在主线程发送消息和在子线程发送消息的比较
- 上一篇中我们也举过一下在子线程实例化Handler对象的例子。
这样我们对Handler的理解应该更加清晰了吧！这里我们探究一下多线程中为何要像上面例子一样实现。
1.1 指定Looper对象
首先我们要明白一点，在上面的例子中可不可以不指定Looper对象（也就是说61行mThread1.getLooper()可不可以没有）。 答案是：可以。 即使我们加一行代码new Thread(() -> mHandler1.sendEmptyMessage(12)).start();handler1在子线程中发送消息它还是可以收到,既然这样我们是不是不需要指定Looper对象？
如果我们没有指定Looper对象，那么我们就是用的主线程的Looper；现在我们指定了mThread1.getLooper()，mHandler1中用的就是Thread1中的Looper对象。在这里当然看不出会出什么问题，但是如果我们的Handler1是在子线程进行实例化的，那么我们就一定要指定Looper对象了，不然发送消息的时候程序怎么知道你要存到哪个线程的消息队列呢。
1.2 getLooper（）
mThread1.getLooper()时MyThread的run方法执行了，Looper.prepare可能还没执行，所以在getLooper方法里面用wait等待，当Looper.prepare()执行了再notifyAll，这里加了把锁保证了线程安全。
一般情况下我们使用默认的Handler实例化完全可以满足我们的日常开发需求。而上面MyThread类的创建完全是为了让我们在子线程中实例化handler进行的封装，而且是比较简陋的封装，Android系统为我们提供了更好的——HandlerThread。
2. HandlerThread的引入
HandlerThread比上面的MyThread考虑的更全面，而且它是核心类库自带的，我们直接用就行。
public class HandlerThreadActivity extends AppCompatActivity {
private static final String TAG = "HandlerThreadActivity";
private HandlerThread mHandlerThread;
private HandlerThread mHandlerThread1;
private HandlerThread mHandlerThread2;
private Handler mHandler;
private Handler mHandler1;
private Handler mHandler2;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mHandlerThread = new HandlerThread("handler-thread");
mHandlerThread.start();
mHandlerThread1 = new HandlerThread("handler-thread1");
mHandlerThread1.start();
mHandlerThread2 = new HandlerThread("handler-thread2");
mHandlerThread2.start();
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.d(TAG,"get Message ==="+msg.what);
}
};
new Thread(()-> {
mHandler1 = new Handler(mHandlerThread1.getLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.d(TAG,"get Message ==="+msg.what);
}
};
mHandler.sendEmptyMessage(0);
mHandler1.sendEmptyMessage(1);
}).start();
new Thread(()-> {
mHandler2 = new Handler(mHandlerThread2.getLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.d(TAG,"get Message ==="+msg.what);
}
};
mHandler2.sendEmptyMessage(10);
}).start();
}
@Override
protected void onResume() {
super.onResume();
mHandler2.sendEmptyMessage(2);
}
}
输出结果：
这里简单的使用了一下，着重了多线程中实例化Handler的情况。
第38行我们就使用了上篇中的例子，同时也是子线程做耗时操作，然后向主线程发送消息的例子，这里我们发了一个空消息，所以不需要构造消息对象。
第30行我们创建了一个线程（这里命名为子线程1），第43行我们又创建了一个线程（这里命名为子线程2），本来想让举个这两个子线程间通信的例子。但是我如果从子线程2向子线程1发送消息的话mHandler2.sendEmptyMessage(1000),有可能子线程1还未创建，所以就没举子线程间通信的例子。但是我们应该明白handler在线程间通信的优越性和它的可行性。
