序文
ハンドラは、私は、ほぼすべてのAndroid開発者の言うことをそこにある上ハンドラは、ハンドラを使用することを信じて、一般的に問題ありますか？ハンドラのみを使用する場合は、話には本当に何もないが、それはほとんどすべてのインタビュアーが、質問をして同じではありません深さの異なる要件を聞いて、そして今日私はハンドラにあなたが持っているものについて何かを学ぶために行くことができますでしょうハンドラです知識。
ハンドラのメッセージメカニズム
まず、私たちが見ている4つのオブジェクトがあるハンドラ、ルーパー、ThreadLocalのだけでなく、メッセージキューのは。
ハンドラ
私たちはやってするために使用されるハンドラメッセージのメカニズムを理解する必要がありますか？ハンドラは、への切り替えに他のスレッドでハンドラスレッド、これはUIスレッドではないことに注意してください。私たちは、ほとんどのハンドラのシーンを使用していますが、我々は子スレッドの実行がUIを更新する必要があるかもしれませんした後、この時間は、我々はハンドラ（のsendMessageに対処する必要が終了したときに、我々は、サブスレッド時間のかかる操作（IOまたはデータベース）にビットを行っています（）またはPOST（））スイッチは、子スレッドにUIスレッドを配置します。我々は今、このような要望を持っていると言うなら、スレッドAは、スレッドBにメッセージを送る（スレッドA、スレッドBは、メインスレッドではない）、我々はハンドラはまだ、唯一のBスレッドする必要がありますすることができ、この時間は、作成良いハンドラ缶を（子スレッドを作成する方法についてハンドラ私は以下で詳しく説明します）。だから、ないスイッチに別のスレッドへのハンドラメインスレッド（UIスレッド）が、スレッドで、それに切り替えるには、この点を明確にしてください。
ルーパー
Handler消息机制里面最核心的类，消息轮询。Handler要想切换线程（或者说发送消息），必须要先获得当前线程的Looper，然后调用Looper.loop()方法把MessageQueue里面的message轮询出来"交"给Handler来处理，至于如何“交”给Handler的，下面我会通过源码带大家分析。
ThreadLocal
ThreadLocal是Looper内部的一个，它虽然前面有个“Thread”,但其实它并不是线程，它相当于一个线程内部的存储类。刚才在讲Looper的时候我们说到，“Handler要想切换线程（或者说发送消息），必须要先获得当前线程的Looper”,那如何获得当前线程的Looper呢？正是通过ThreadLocal,它可以在不同线程之间互不干扰地存储数据。ThreadLocal里面有一个内部静态类对象ThreadLocalMap，通过其set（）和get（）方法对数据对象进行保存和读取。
MessageQueue
MessageQueue——消息队列，虽然它叫消息队列，但实际上的结构并不是一个队列，而是一种单链表的数据结构，只是使用列队的形式对数据进场做添加或者移除。MessageQueue是在Looper被创建的时候由Looper生成的。同一线程下，Handler发送的所有message都会被加入到MessageQueue里面，当Message被loop（）以后，就会从消息队列中移除。Message我没有单独拿出来，因为确实比较简单，就是消息本身，它可以携带两个int型参数，如果要传比较复杂的参数就用obj属性，what属性用来区分是哪个Handler发送的信息。
小结一下
Handler是把其他线程切换到它所在的线程，使用Handler发消息之前要先创建Looper对象，创建和读取Looper都需要使用ThreadLocal，它可以在不同线程之间互不干扰地保存数据。在创建Looper对象的同时也把MessageQueue创建好了，Handler所发的message会被添加到MessageQueue对象里面，Looper.loop()方法以后会把MessageQueue上的Message轮询出来。连接这几个对象的还有一条很重要的线，那就是线程，记住，以上的过程都要保证Handler、Looper、MessageQueue在同一线程，这样，才能保证Handler的消息机制被正确使用。
子线程创建Handler
注意：我们这里是为了让大家更好地学习Handler，所以要在子线程创建Handler，现实使用场景，很少会在子线程创建Handler
在主线程（UI线程）创建Handler，我相信所有人都会
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mainHandler = new Handler();
mainHandler.post(new Runnable() {
@Override
public void run() {
Log.e("qige_test", "thread_name=" + Thread.currentThread().getName());
}
});
}我们先按照主线程的方式在子线程创建一个Handler试一下，看看会有什么样的结果
new Thread(){
@Override
public void run() {
childHandler=new Handler();
childHandler.post(new Runnable() {
@Override
public void run() {
Log.e("qige_test","thread_name="+Thread.currentThread().getName());
}
});
}
}.start();
没错，如图所示还没有创建Looper，那么如何创建Looper呢？图中有句话已经给出了答案——Looper.prepare()，同时为了让我们发送的消息被轮询到，还必须要调用Looper.loop(); 所以在完整的在子线程创建Handler的代码如下：
new Thread(){
@Override
public void run() {
//创建Looper，同时创建MessageQueue
Looper.prepare();
childHandler=new Handler();
childHandler.post(new Runnable() {
@Override
public void run() {
Log.e("qige_test","thread_name="+Thread.currentThread().getName());
}
});
//轮询
Looper.loop();
}
}.start();这样就可以在子线程里面创建Handler了，看到这里，你可能会问，为什么我在主线程创建Handler的时候，没有调用Looper.prepare()和Looper.loop()?这个问题我们先放一下，我们先从源码角度把Handler消息机制分析一下。
从源码角度分析
先看一下创建Looper和MessageQueue的方法Looper.prepare()
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
//ThreadLocal来了
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}这里就出现了我刚才说的ThreadLocal对象。Android规定每个线程有且仅有一个Looper，所以为了防止不同的线程之间的Looper相互影响，使用ThreadLocal对象来存储Looper。
再看一眼new Looper()的源码
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}MessageQueue也出来了，创建Looper的同时创建MessageQueue。
下面我们看Handler.post()或者是Handler.sendMessage()他们本质是一样的，把消息加入到消息队列当中
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}post（）或者sendMessagexxx（）最终都会调用sendMessageAtTime(Message msg, long uptimeMillis)方法，我们直接看这个方法的源码
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
//关键代码部分
return enqueueMessage(queue, msg, uptimeMillis);
}都很简单，最后一步enqueueMessage(queue, msg, uptimeMillis);是把消息加入队列，咱们再点开看一下
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//把当前的Handler赋值给msg.target
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}关键要看的地方是 msg.target = this刚才讲Message的时候没有提，Message的target属性就是一个Handler对象，这里直接把当前的Handler对象赋值过去了。最后一行：queue.enqueueMessage(msg, uptimeMillis)是把message加入到消息队列里面，具体的实现我抓不到了，知道这句话是把message加入到MessageQueue里面就行。
下面分析* Looper.loop() 方法的关键部分源码
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
**标注1**
final MessageQueue queue = me.mQueue;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
........................
......................
**标注2**
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
....................................
...................................
try {
**标注3**
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
........................................
........................................
**标注4**
msg.recycleUnchecked();
}
}看源码的时候注意看一下标注，一个个地来讲；
- 标注1：保证了Handler、Looper和MessageQueue在同一线程
- 标注2：没有看错，就是一个无线死循环，Looper会不停地对MessageQueue进行轮询。这时候，你可能会问，这种无限死循环会不会很浪费资源？其实并不会，因为当没有message被添加到队列的时候，程序会进入阻塞状态，对资源的消耗是很小的。
- 标注3：还记得刚才讲地msg.target吧，这里 msg.target.dispatchMessage(msg);就是handler.dispatchMessage(msg),直接去看Handler的dispatchMessage(msg)方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}这里面msg.callback是个Runnable对象，也就是当我们使用handler.post(Runnable r)的方法的话，这时候就直接去调用Runnable对象里面的东西了，如果使用的是handler.sendMessagexxx（），就是去调用我们重写的handleMessage(msg)方法了。
如果调用post()方法发送消息
mainHandler.post(new Runnable() {
@Override
public void run() {
//这里会被调用
Log.e("qige_test","thread_name="+Thread.currentThread().getName());
}
});如果调用sendMessagexxx()
mainHandler.sendEmptyMessage(0);
mainHandler=new Handler(){
@Override
public void handleMessage(Message msg) {
//这里会被调用
Log.e("qige_test","what="+msg.what);
}
};我们再回到上一级源码
- 标注4， msg.recycleUnchecked();其实这里就是msg完成了它的使命，被释放了以后又放回缓存池里面去了。
以上基本就是一个完整的Handler消息机制的过程，我再带大家好好回顾一下：
1.Looper.prepare();//这一步创建了Looper和MessageQueue
2.handler.sendMessagexxxx(); // 把message添加到MessageQueue上
3.Looper.loop();//轮询消息
4.handler.dispatchMessage(msg)；//处理消息
关于在主线程创建Handler的疑问
好了，到了该解决历史遗留问题的时候了，为什么我们在主线程创建handler不需要调用Looper.prepare()和Looper.loop()呢？
这是因为，主线程已经给我们创建好了，在哪里创建好的呢？
在Java里面，有一个程序的主入口，就是静态main方法
public class Test {
//程序入口
public static void main(String... args){
}在Android里面呢，同样有这么一个main方法入口，它在ActivityThread类中。在我们App启动过程中，会调用到ActivityTread的main()方法（由于篇幅问题，该过程没有办法详细讲，后期会推文章单独说一下），下面我们直接看ActivityTread的main()方法的源码
为了方便理解，还是只看关键部分代码
public static void main(String[] args) {
....
//创建Looper和MessageQueue对象，用于处理主线程的消息
Looper.prepareMainLooper();
//创建ActivityThread对象
ActivityThread thread = new ActivityThread();
//建立Binder通道 (创建新线程)
thread.attach(false);
//消息轮询
Looper.loop();
}看到这里，我想你应该明白了为啥在主线程里创建Handler不需要调用Looper.prepare()和Looper.loop()方法了吧，因为在App启动的时候，ActivityThread已经给我们创建好了。不过，需要注意的是，我刚才在讲Looper.loop()源码的时候说过这里面会有一个无限死循环，那么程序运行到这里岂不是要永远卡在这了呢，那我们的Activity、Service都是咋执行的呢？ 看关键的源码这一句thread.attach(false),注释上其实解释的很清楚，通过Binder创建了新的线程，在这个新的线程里面运行了Activity、Service等组件，而之所以Android为什么采用这种方式，让我们留在以后再说，你只需要知道，Looper.loop()不会造成卡顿，主线程已经给我们创建好了Looper和MessageQueue对象就可以了。
なぜ、この記事を書きます
オープニング私はハンドラは、ほとんどの人が使用する、と述べたが、唯一の使用は、これらがより良い理由を知っている知っているだけでは十分ではないでしょう。多くの面接は良いが、この記事を読んで、それはインタビューの中で、あなたがより効果的になります、ハンドラに関連する質問をして喜んでいます。
あなたが理解する必要がありますだけでなく、非常によくそれを表現できるようにするには、インタビュアーがご理解を認識できるようにいくつかのものは、例えば、ハンドラメカニズムのために、このインタビューは、質問をされるでしょう。いくつかの不明な点は、おそらくライブ唯一の実用的な仕事の中でのインタビューで、あなたはそれを使用しませんでしたが、あなたはそれが何であるかを知っています。
私は、あなたが賃金より高いレベルに上昇することを確認することを学ぶという保証は皆のための細かい建築家のAndroidのチュートリアルのセットを用意し、最後の記事の最後。（以下は、ごく一部です：X1524478394の無料アクセスを簡潔に、より高度なアーキテクチャと他の映像素材が私を追加することができるためWX）
いくつかの排他的なドライグッズを共有するために、今日は何です：
コア知識ノートの①Android開発
②「アリP7」のシニアエンタープライズアーキテクトの40W +年俸をベンチマーク学習ロードマップを育てます
③面接ブティックコレクションの概要に
④高度なシステムアーキテクチャビデオのフルセット
あなたが受け取った後にAndroidのさらに強力でより簡潔にビデオを学びます！（の準備）など、BATJメーカーをしてください！今、あなたは間違ったバスに乗る以上何も、実際には、インターネットの冬言っていない、と摩耗が少なく（スキル）、そしてあなたが車の上で得れば、彼らの技術は持っている、解雇することができる方法、大企業のコストを交換する堅牢で十分ですカードは、それの取引終了の外にあります！今、市場ジュニアプログラマ、Androidの開発エンジニアスタッフの1--6年間のチュートリアルのセットをフラッディング、ボトルネックである、年は自分の昇給を壊したく後、あなたのための先進的なAndroidのシニアアーキテクトであります自分自身、そしてできるだけ早くそれを受け取ります！
[上記のHD脳図]、および私を追加することができ、[サポート] PDF技術アーキテクチャは、WX：X1524478394の無料アクセスを