Android Handler机制简单分析

Android Handler机制简单分析

what?

why?

阻塞

how?

......
public class MainActivity extends AppCompatActivity {

private static final int MSG_DOWNLOAD_TASK = 1;
private TextView tv_progress;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv_progress = findViewById(R.id.tv_progress);
}

private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case MSG_DOWNLOAD_TASK:
int progress = (int) msg.obj;
tv_progress.setText(progress + "");
break;
}
}
};

/**
* UI上的Button按钮点击事件
* 模拟执行下载任务
*
* @param view
*/
private void download(View view) {
new Thread(new Runnable() {
@Override
public void run() {
int progress = 0;
try {
while (progress >= 100) {
Message msg = Message.obtain();
msg.what = MSG_DOWNLOAD_TASK;
msg.obj = progress;
mHandler.sendMessage(msg);

/**
* 模拟下载进度回调中...
*/
Thread.sleep(1000);
progress++;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}

analyze

1.

mHandler = new Handler() {... }

初始化Handler

>>> 下文所有源码均源于Android8.0，为了简练，只保留核心代码 <<<

public Handler() {
this(null, false);//走的是下面的双参构造方法
}

public Handler(Callback callback, boolean async) {
......
mLooper = Looper.myLooper();//把当前线程中Looper对象引用交给Handler
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
//不能在此线程中创建handler，因为还没有调用过Looper.prepare()
}
mQueue = mLooper.mQueue;//从Looper对象取出MessageQueue对象给Handler
mCallback = callback;//null值
mAsynchronous = async;//false
}

......
public final class ActivityThread {
......
public static void main(String[] args) {//app程序入口
......
//1.其实本质还是走Looper.prepare()，见下面Looper类相关代码便知
Looper.prepareMainLooper();
......
if (sMainThreadHandler == null) {
//2.获取的是Handle子类H对象引用，在H中添加了处理各种消息的业务（不理解没关系，反正就是创建个Handler子类的对象）
sMainThreadHandler = thread.getHandler();
}
......
//3.轮询消息
Looper.loop();

throw new RuntimeException("Main thread loop unexpectedly exited");
}
}

......
public final class Looper {
......
public static void prepareMainLooper() {
//带参的Looper.prepare(quitAllowed)方法
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {

throw new IllegalStateException("The main Looper has already been prepared.");
//已存在Looper对象了，不要再创建了
}
sMainLooper = myLooper();
}
}

private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {

throw new RuntimeException("Only one Looper may be created per thread");
//每个线程只能创建一个Looper对象，其实还是在说已存在Looper对象了，不要再创建了
}
//这里创建了久违的Looper对象
sThreadLocal.set(new Looper(quitAllowed));
}
--------------顺便看看Looper.prepare()在干什么--------------------

public static void prepare() {
/**
*本质是走上面的带参的prepare(quitAllowed)方法
*不要太在意quitAllowed参数，反正是传给Looper对象用的
*/
prepare(true);
}
}

2.

Message msg = Message.obtain()....mHandler.sendMessage(msg);

子线程中通过mHandler对象发送消息

Message.obtain()

/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*个人翻译：从全局池返回一个新Message实例（可能是新创建的，也可能是从全局池中c重新复用的）。
*允许我们在多数情况下避免分配（创建）过多的新对象
*/
public static Message obtain() {
synchronized (sPoolSync) {//同步锁访问机制
if (sPool != null) {//池不为null，复用已存在的对象
Message m = sPool;//从池中取出Message对象（很明显这个池也是Message类的对象）
sPool = m.next;
/**
*结合上面可以知道这个池其实是由多个Message对象组成的链表结构（不知道链表？找度娘...）
*每次复用的都是表头的Message对象
*表头被取走（复用）后，紧连着表头的另一个Message对象成为新的表头，以此类推
*先不要想这个链表是怎么添加Message对象的，也不要着急看Message类全部源码，因为不是本文重点
*/
m.next = null;//对即将复用的表头（Message对象）进行脱链，从此自由啦！
m.flags = 0; // clear in-use flag (清除“在使用中的”的标记，恢复初始状态以便复用)
sPoolSize--;//复用后，链表长度减1
return m;//返回表头（复用表头）
}
}
return new Message();//池为null时直接创建新Message对象
}

new Message()

/**
* Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
* 个人翻译:构造器（但是推荐的方式是调用"Message.obtain()"）
*/
public Message() {
}