今天我们来聊聊Android中的Handler机制
1、为什么使用Handler:
Handler是android中的一种异步消息处理机制
我们都知道,在android中子线程是不能刷新UI的,我们的解决方法是在子线程通过Handler发送消息
来更新UI界面(progressBar可以在子线程更新哦)。
我们一般的用法:
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new Thread(){
@Override
public void run() {
Message message = new Message();
message.what = 0;
handler.sendMessage(message);//发送消息
}
}.start();
}
//这里我们采用匿名内部类了,正常我们new一个对象是 new Handler();
//后面加了{}就是匿名内部类,为方便。当然你也可以创建一个class
public Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 0:
System.out.println("接受到了消息");
break;
default:
break;
}
}
};
}
这样写没有问题,但是我们eclipse会报一个警告错误:
This Handler class should be static or leaks might occur (com.example.testhandler.MainActivity.1)
提示我们最好定义为静态的,否则可能导致内存泄漏。
特别注意:Handler里面的handMessage方法是运行在主线程的,你在这个里面做耗时操作也会导致ANR异常的。
2、Handler为什么会导致内存泄漏呢?
java内存回收机制:
这个涉及到java的内存回收机制(GC)。
如果GC发现一个或一组对象为不可到达状态,则将该对象从内存中回收。
也就是说,一个对象不被任何引用所指向,则该对象会在被GC发现的时候被回收;
另外,如果一组对象中只包含互相的引用,而没有来自它们外部的引用
(例如有两个对象A和B互相持有引用,但没有任何外部对象持有指向A或B的引用),这仍然属于不可到达,同样会被GC回收。
分析Handler为什么导致
当使用内部类(包括匿名类)来创建Handler的时候,Handler对象会隐式地持有一个外部类对象
(通常是一个Activity)的引用(不然你怎么可能通过Handler来操作Activity中的View?)。
第一种情况:
Handler里面有可能会伴随着一个耗时的后台线程(例如从网络拉取图片)一起出现,
这个后台线程在任务执行完毕(例如图片下载完毕)之后,通过消息机制通知Handler,然后Handler把图片更新到界面。
如果用户在网络请求过程中关闭了Activity,正常情况下,Activity不再被使用,它就有可能在GC检查时被回收掉,但由于这时线程尚未执行完,
而该线程持有Handler的引用(不然它怎么发消息给Handler?),这个Handler又持有Activity的引用,
就导致该Activity无法被回收(即内存泄露)。直到网络请求结束(例如图片下载完毕)。
第二种情况:
如果你执行了Handler的postDelayed()方法,该方法会将你的Handler装入一个Message,并把这条Message推到MessageQueue中,
那么在你设定的delay到达之前,会有一条MessageQueue -> Message -> Handler -> Activity 的链,导致你的Activity被持有引用而无法被回收。
总结:导致内存泄漏说白了就是handler持有activity的应用,activity被finish掉了,里面的资源得不到释放,导致内存泄漏。
我们把handler定义为静态的,这个handler就不会持有activity的引用了,就不存在什么内存泄漏。
3、我们把Handler定义为静态的:
static class MyHandler extends Handler {
@Override
public void handleMessage(Message msg) {
tv.setText("hello");//必须是静态的
}
}
发现一个问题,我们在handler中所有的变量都必须是static静态的,这个我们不会将我们所用到的变量都定义为static
这个时候我们就出现了弱引用概念。
4、什么是弱引用:
WeakReference弱引用,与强引用(即我们常说的引用)相对。
它的特点是,GC在回收时会忽略掉弱引用,即就算有弱引用指向某对象,但只要该对象没有被强引用指向
(实际上多数时候还要求没有软引用,但此处软引用的概念可以忽略),该对象就会在被GC检查到时回收掉。
对于上面的代码,用户在关闭Activity之后,就算后台线程还没结束,但由于仅有一条来自Handler的弱引用指向Activity,
所以GC仍然会在检查的时候把Activity回收掉。这样,内存泄露的问题就不会出现了。
例如我们改造后的代码:
public class TestHanlderActivity extends Activity {
private TextView tv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test_hanlder);
tv = (TextView) findViewById(R.id.tv);
new Thread(){
@Override
public void run() {
Message message = new Message();
message.what = 0;
handler.sendMessage(message);//发送消息
}
}.start();
}
public Handler handler = new MyHandler(this) ;//定义handler,将activity传进去
static class MyHandler extends Handler{
final WeakReference<TestHanlderActivity> mActivity;
MyHandler(TestHanlderActivity activity){
//使用传进来的activity初始化这个弱引用
mActivity = new WeakReference<TestHanlderActivity>(activity);
}
@Override
public void handleMessage(Message msg) {
//拿到activity,
TestHanlderActivity activity = mActivity.get();
if(null != activity){
switch (msg.what) {
case 0:
//可以使用activity中的非静态的变量啦
activity.tv.setText("这个是静态的Handler");
break;
default:
break;
}
}
}
}
}
总结:
a.我们在主线程去new一个静态的Handler,不管我们new多少个,都是指向同一个Handler。因为static内存中只保留一份。
如果我们不定义static,你每次new一个Handler就会在堆内存中创建一个对象,也是耗费内存的。
b.我们一个线程中只能有一个Looper和一个MessageQueue,所以不管你new多少个handler,都是把消息发送到同一个MessageQueue消息队列中
Looper也只是从这个消息队列中取消息。
到这里我们完美解决了handler使用的问题。下面我们从源码分析下Handler的运行机制
5、源码分析Handler的运行机制:
a.应用的入口函数
以前一直都说Activity的人口是onCreate方法。其实Android上一个应用的入口,应该是ActivityThread。和普通的Java类一样,入口是一个main方法。
public static final void main(String[] args) {
SamplingProfilerIntegration.start();
……
Looper.prepareMainLooper();
if (sMainThreadHandler == null) {
sMainThreadHandler = new Handler();
}
ActivityThread thread = new ActivityThread();
thread.attach(false);
……
Looper.loop();
……
thread.detach();
……
Slog.i(TAG, "Main thread of " + name + " is now exiting");
}
我们的应用入口,先调用了下prepareMainLooper,然后就调用了Looper.loop()进入了无限循环。
所以只要我们应用不关闭,Looper就会一直从消息队列中拿消息来处理。
这个是运行在主线程中的,别人可能会疑惑,为什么什么在主线程中loop不会导致主线程阻塞呢?
你想一下,如果主线程没有loop,执行完就完了,你的应用不就挂了吗,又何来阻塞一说。
b.主线程中默认就创建了个Looper 和MessageQueue
那么我们创建了Handler做了什么呢?
我们new Handler(); 调用了Handler的无参构造方法
android.os.Handler.class里面的代码:(我查看的是API19 android4.4)
Handler中的源码
/**
* Default constructor associates this handler with the queue for the
* current thread.
*
* If there isn't one, this handler won't be able to receive messages.
*/
public Handler() {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
mLooper = Looper.myLooper();//这里我们拿到Looper对象,赋值给了final Looper mLooper; 就相当于我们拿到了主线程的Looper
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;//我们拿到Looper中的消息队列 final MessageQueue mQueue;
mCallback = null;//我们没有传Callback
}
mLooper = Looper.myLooper();我们看看干了什么
android.os.Looper源码:
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
//sThreadLocal是一个ThreadLocal对象,可以在一个线程中存储变量。(我们可以理解一个线程的局部变量,里面保存了Looper)
final MessageQueue mQueue;
public static Looper myLooper() {
return sThreadLocal.get();//拿到Looper对象
}
c.我们进入应用就会调用prepare方法
private Looper() {
mQueue = new MessageQueue();
mRun = true;
mThread = Thread.currentThread();
}
在构造方法中,创建了一个MessageQueue(消息队列)。
public static void prepareMainLooper() {
prepare();
setMainLooper(myLooper());
myLooper().mQueue.mQuitAllowed = false;
}
public static void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}
我们看loop()方法:
public static void loop() {
Looper me = myLooper();//拿到存储的Looper实例,如果me为null则抛出异常,也就是说looper方法必须在prepare方法之后运行
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
MessageQueue queue = me.mQueue;//拿到该looper实例中的mQueue(消息队列)
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
while (true) {//就进入了我们所说的无限循环
Message msg = queue.next(); // might block
if (msg != null) {
if (msg.target == null) {
// No target is a magic identifier for the quit message.
return;
}
long wallStart = 0;
long threadStart = 0;
// This must be in a local variable, in case a UI event sets the logger
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
wallStart = SystemClock.currentTimeMicro();
threadStart = SystemClock.currentThreadTimeMicro();
}
msg.target.dispatchMessage(msg);//把消息交给msg的target的dispatchMessage方法去处理
if (logging != null) {
long wallTime = SystemClock.currentTimeMicro() - wallStart;
long threadTime = SystemClock.currentThreadTimeMicro() - threadStart;
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
if (logging instanceof Profiler) {
((Profiler) logging).profile(msg, wallStart, wallTime,
threadStart, threadTime);
}
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycle();//释放消息占据的资源
}
}
}
所以:loop()方法,不断从MessageQueue中去取消息,交给消息的target属性的dispatchMessage去处理。
我们看看怎么取的消息:Message msg = queue.next(); // might block
这个代码在MessageQueue中:
Message next() {
for (;;) {
Message prevMsg = null;
Message msg = mMessages;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;//这个的目的就是为了释放上一个message的引用便于垃圾回收
return msg;
}
}
示意图
d.现在我们看看handler.sendMessage(message);//发送消息
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this;
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
我们可以看到最终调用到了sent = queue.enqueueMessage(msg, uptimeMillis);
把消息放到消息队列中.
final boolean enqueueMessage(Message msg, long when) {
if (msg.isInUse()) {
throw new AndroidRuntimeException(msg
+ " This message is already in use.");
}
if (msg.target == null && !mQuitAllowed) {
throw new RuntimeException("Main thread not allowed to quit");
}
final boolean needWake;
synchronized (this) {
if (mQuiting) {
RuntimeException e = new RuntimeException(
msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
return false;
} else if (msg.target == null) {
mQuiting = true;
}
msg.when = when;
//Log.d("MessageQueue", "Enqueing: " + msg);
Message p = mMessages;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked; // new head, might need to wake up
} else {
Message prev = null;
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
msg.next = prev.next;
prev.next = msg;
needWake = false; // still waiting on head, no need to wake up
}
}
if (needWake) {
nativeWake(mPtr);
}
return true;
}
主要是这个代码把消息放到消息队列中
Message p = mMessages;
msg.next = p;
mMessages = msg;
我们画图示意一下
为什么要Message p = mMessages; 然后再把p赋值给msg.next呢?
经过我自己代码测试,p和mMessages都是个内存地址,一样的。只是可能为了在后面用到方便点,不用写这么长吧。
msg.next = mMessages;
mMessages = msg;
//效果是一样
msg.target = this;//关键的一句代码,把msg的target设置为当前的handler,在loop中我们就回调对应的handler的handMessage方法。
6、handler在子线程中使用:
我们在子线程中使用Handler可以,但是你必须手动调用prepare和loop方法
因为主线程在main函数调用了,所以不需要。
class MyThread extends Thread {
public Handler mHandler;
@Override
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
System.out.println("hello handler");
}
};
System.out.println("即将开启loop");
for (int i = 0; i < 10; i++) {
System.out.println(i + "");
}
Looper.loop();
System.out.println("已经开启loop");
}
}
特别注意:
你在loop之后的代码是不会执行到了,因为loop了,就相当你的子进程一直阻塞在这里了。
所以我们一般没必要在子线程中取定义Handler
没有什么应用场景。
一个网上摘下的Handler流程图
发消息
主线程处理消息