1、handler使用
子线程与主线程通信：
public class HandlerActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 方式1(其内部也是调用等sendMessage):
CustomHandler handler = new CustomHandler(this);
new Thread(new Runnable() {
@Override
public void run() {
//耗时操作 ***
//完成耗时操作切换到主线程
handler.post(new Runnable() {
@Override
public void run() {
//更新UI
}
});
}
});
// 方式2 ：
new Thread(new Runnable() {
@Override
public void run() {
Message message = handler.obtainMessage();
message.obj = "123";
message.what = 3;
//通过这个方法,可以将消息设置为异步消息
message.setAsynchronous(true);
handler.sendMessage(message);
}
});
}
//静态类Handler来避免内存泄漏,但是由于静态类不能直接持有Activity的引用,所以可以用弱引用来解决
private static class CustomHandler extends Handler{
WeakReference<Activity> activityWeakReference;
CustomHandler(Activity activity) {
activityWeakReference = new WeakReference<>(activity);
}
@Override
public void handleMessage(Message msg) {
Activity thisA = activityWeakReference.get();
}
}
}
//post使用示例:
new Thread(new Runnable() {
@Override
public void run() {
/**
耗时操作
*/
handler.post(new Runnable() {
@Override
public void run() {
/**
更新UI
*/
}
});
}
}).start();
从子线程切换到主线程的三种方式:
final Handler handler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
// 素描算法处理 耗时操作
final Bitmap bitmap1 = SketchUtil.testGaussBlur(finalBitmap,1,1);
final Bitmap bitmap2 = SketchUtil.testGaussBlur(finalBitmap,10,10);
final Bitmap bitmap3 = SketchUtil.testGaussBlur(finalBitmap,20,20);
// 三种切回主线程更新UI的方法
imageView.post(new Runnable() {
@Override
public void run() {
imageView.setImageBitmap(bitmap1); // 素描图
}
});
runOnUiThread(new Runnable() {
@Override
public void run() {
orignView.setImageBitmap(bitmap2); // 素描图
}
});
handler.post(new Runnable() {
@Override
public void run() {
threeView.setImageBitmap(bitmap3); // 素描图
}
});
}
}).start();
通常我们在主线程中创建一个Handler，
然后重写该Handler的handlerMessage方法，可以看到该方法传入了一个参数Message，
该参数就是我们从其他线程传递过来的信息。
我们在来看下子线程中如何传递的信息，子线程通过Handler的obtainMessage()方法获取到一个Message实例，
我们来看看Message的几个属性：
- Message.what------------------>用来标识信息的int值，通过该值主线程能判断出来自不同地方的信息来源
- Message.arg1/Message.arg2----->Message初始定义的用来传递int类型值的两个变量
- Message.obj------------------->用来传递任何实例化对象
最后通过sendMessage将Message发送出去。
Handler所在的线程通过handlerMessage方法就能收到具体的信息了，如何判断信息的来源呢？当然是通过what值啦。
主线程的Looper以及Loop.prepare()是在ActivityThread中创建的
子线程与子线程通信：
private Handler handler;
private void handlerDemoByTwoWorkThread() {
Thread hanMeiMeiThread = new Thread() {
@Override
public void run() {
Looper.prepare();
handler = new Handler() {
@Override
public void handleMessage(Message msg) {
Log.d(TAG, "hanMeiMei receiver message: " + ((String) msg.obj));
Toast.makeText(MainActivity.this, ((String) msg.obj), Toast.LENGTH_SHORT).show();
}
};
Looper.loop();
}
};
Thread liLeiThread = new Thread() {
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message message = handler.obtainMessage();
message.obj = "Hi MeiMei";
handler.sendMessage(message);
}
};
hanMeiMeiThread.setName("韩梅梅 Thread");
hanMeiMeiThread.start();
liLeiThread.setName("李雷 Thread");
liLeiThread.start();
}
关键类
- Handler：负责发送及处理消息
- Looper：负责不断的从消息队列中取消息，并发送本条消息的Handler
- Message：消息本身，携带数据
- MessageQueue：负责存储消息
Looper.prepare()
子线程创建Handler前一定要执行此方法来创建Looper
原理
- Handler.sendMessage/post(Runnable) 发送消息
- MessageQueue.equeueMessage将消息放入消息队列中(消息队列是一个链表结构)
- 收消息处理消息的线程是子线程的话，需要Looper.prepare()、Looper.loop()这两个方法
- Looper通过loop()方法不停的从MessageQueue中取消息 -- for(;;)
- 如果有消息，通过message的target调用dispatchMessage去分发消息
- 如果是post，则直接调用handlerCallBack方法，在run中处理。如果是sendMessage，则调用handleMessage来处理消息
注意 :
Looper.loop() 中有一个for(;;)循环来调用MessageQueue.next()
MessageQueue.next()中也有一个for(;;)循环,这当中涉及到一个阻塞的问题
延时消息如何处理的
- 在通过Looper的loop()方法取消息时，会调用到MessageQueue的next()方法中，该方法会阻塞线程
- 延时消息在发送时会将延时的时间，加上当前的自启动以来的时间(SystemClock.uptimeMillis)作为时间点传到MessageQueue的equeueMessage中
- equeueMessage中进行判断
1、如果消息链表为空就创建一个消息链表，将消息放到头部；如果消息链表不为空，则判断消息的时间点是否小于当前消息的时间点，如果小于，那么唤醒当前阻塞的线程，并把这个消息放到消息链表的头部。
2、如果当前线程正在阻塞且消息的时间点大于消息链表中的消息的时间点，那么MessageQueue中比当前添加进来的Message需要发送的时间点大的位置，将Message插入到其前边
Android中为什么主线程不会因为Looper.loop()里的死循环卡死？
- 对于线程既然是一段可执行的代码，当可执行代码执行完成后，线程生命周期便该终止了，线程退出。而对于主线程，我们是绝不希望会被运行一段时间，自己就退出，那么如何保证能一直存活呢？简单做法就是可执行代码是能一直执行下去的，死循环便能保证不会被退出。
binder线程和主线程的关系:
在ActivityThread中,有个main()方法,这里创建到MainLooper和binder线程:
public static void main(String[] args) {
....
//创建Looper和MessageQueue对象，用于处理主线程的消息
Looper.prepareMainLooper();
//创建ActivityThread对象
ActivityThread thread = new ActivityThread();
//建立Binder通道 (创建新线程)
thread.attach(false);
Looper.loop(); //消息循环运行
throw new RuntimeException("Main thread loop unexpectedly exited");
}
thread.attach(false)；便会创建一个Binder线程.该Binder线程通过Handler将Message发送给主线程
ActivityThread是继承自Thread吗?
不是,ActivityThread并没有真正继承Thread类，只是往往运行在主线程，该人以线程的感觉，其实承载ActivityThread的主线程就是由Zygote fork而创建的进程。
为什么主线程一直开着确并没有特别消耗CPU资源:
Linux pipe/epoll机制
1、首先明确一点,线程有一个阻塞状态,当线程处于阻塞状态时,会释放CPU资源
2、在主线程进入循环之前,会创建一个Linux的Pipe管道,这个管道的作用就是让我们的消息队列是空的时候,可以进入等待状态(阻塞状态),并且有消息的时候再唤醒主线程
3、这个往Pipe管道中塞消息并且再唤醒主线程的机制就时epoll机制,调用的是epoll.wait方法
Activity的生命周期是怎么实现在死循环体外能够执行起来的？
- ActivityThread的内部类H继承于Handler，通过handler消息机制，简单说Handler机制用于同一个进程的线程间通信。Activity的生命周期都是依靠主线程的Looper.loop，当收到不同Message时则采用相应措施：在H.handleMessage(msg)方法中，根据接收到不同的msg，执行相应的生命周期。
比如收到msg=H.LAUNCH_ACTIVITY，则调用ActivityThread.handleLaunchActivity()方法，最终会通过反射机制，创建Activity实例，然后再执行Activity.onCreate()等方法； 再比如收到msg=H.PAUSE_ACTIVITY，则调用ActivityThread.handlePauseActivity()方法，最终会执行Activity.onPause()等方法
主线程的死循环一直运行是不是特别消耗CPU资源呢？
- 简单说就是在主线程的MessageQueue没有消息时，便阻塞在loop的queue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生
Handler怎么实现线程切换的
- 通过MessageQueue作为一个中间介质
- 主线程中的Looper不停的从MessageQueue中取消息，取到消息后分发到主线程的handlerMessage/callback中
- 子线程通过sendMessage向MessageQueue中存消息
一个线程可以创建多个Handler吗
一个线程可以创建多个Handler，但只能创建一个Looper，一个MessageQueue。Handler跟Looper之间没有对应关系。
多个handler时,谁发消息谁处理消息
Handler是怎么知道如何把消息发回到callback中还是handleMessage中?
Handler中有个dispatchMessage方法,在这里面判断msg.callback是否为空,不为空就发到runCallBack中,为空就发到handleMessage中
为什么一个线程只能创建一个looper
Looper的prepare方法中明确有判断，如果存在looper并且再次调用prepare时，会抛出RuntimeException
handler 的同步屏障机制
1、屏障消息和普通消息的区别是屏障消息没有tartget。
2、设置(postSyncBarrier)和移除(removeSyncBarrier)同步屏障消息的方法在MessageQueue中,且是私有的,设置的话需要通过反射调用
View.post()中的Handler机制
Handler 内存泄漏原因？为什么其他的内部类没有说过有这个问题？
泄漏链:Looper中持有MessageQueue的引用、MessageQueue中持有Message的引用,message持有handler的引用,而handler又持有外部类的引用、当外部类被销毁时,因为Looper是一直存在的,所以会泄漏
任何一个内部类,只要它持有外部类的引用,那么当内部类进行耗时操作,然后外部类被销毁后,都会导致内存泄漏,原因是内部类持有外部类的引用无法释放
为何主线程可以new Handler？如果想要在子线程中new Handler要做些什么准备？
通过Looper.prepare创建Looper
通过Looper.loop()让它循环取消息
子线程中维护的Looper，消息队列无消息的时候的处理方案是什么?有什么用？
既然可以存在多个Handler往MessageQueue中添加数据(发消息时各个Handler可能处于不同线程)，那它内部是如何确保线程安全的？
MessageQueue的放消息和取消息都是通过加锁来保证线程安全的
我们使用Message时应该如何创建它？
handler.obtainMessage();
handler.obtainMessage()和new Message有什么区别
obtainmessage（）是从消息池中拿来一个msg 不需要另开辟空间new
Message.what什么情况下为0
1、创建一个message但是不指定what的情况下
2、通过handler.post一个runnable时, runnable会被封装为一个message, 里面的what为0
什么是HandlerThread
一个线程如何安全退出Handler
可以通过 Looper.quiet
Looper的quit方法和quitSafely方法
1、都是退出handler、都不再接收新消息
2、quit直接清空messageQueue中的所有消息
3、quitSafely只清空messageQueue中的所有延时消息
IdleHandler （闲时机制）
Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
@Override
public boolean queueIdle() { // 消息处理完成时的回调
return false;
}
});
IdleHandler是一个回调接口，可以通过MessageQueue的addIdleHandler添加实现类。当MessageQueue中的任务暂时处理完了（没有新任务或者下一个任务延时在之后），这个时候会回调这个接口，返回false，那么就会移除它，返回true就会在下次message处理完了的时候继续回调。
