『壹』 android 系統運行機制 【Looper】【Choreographer】篇
目錄：
1 MessageQueue next()
2 Vsync
3 Choreographer doFrame
4 input
系統是一個無限循環的模型， Android也不例外，進程被創建後就陷入了無限循環的狀態
系統運行最重要的兩個概念：輸入，輸出。
Android 中輸入 輸出 的往復循環都是在 looper 中消息機制驅動下完成的
looper 的循環中， messageQueue next 取消息進行處理， 處理輸入事件， 進行輸出， 完成和用戶交互
應用生命周期內會不斷 產生 message 到 messageQueue 中， 有： java層 也有 native層
其中最核心的方法就是 messageQueue 的 next 方法， 其中會先處理 java 層消息， 當 java 層沒有消息時候， 會執行 nativePollOnce 來處理 native 的消息 以及監聽 fd 各種事件
從硬體來看， 屏幕不會一直刷新， 屏幕的刷新只需要符合人眼的視覺停留機制
24Hz ， 連續刷新每一幀， 人眼就會認為畫面是流暢的
所以我們只需要配合上這個頻率， 在需要更新 UI 的時候執行繪制操作
如何以這個頻率進行繪制每一幀： Android 的方案是 Vsync 信號驅動。
Vsync 信號的頻率就是 24Hz ， 也就是每隔 16.6667 ms 發送一次 Vsync 信號提示系統合成一幀。
監聽屏幕刷新來發送 Vsync 信號的能力，應用層 是做不到的， 系統是通過 jni 回調到 Choreographer 中的 Vsync 監聽， 將這個重要信號從 native 傳遞到 java 層。
總體來說 輸入事件獲取 Vsync信號獲取 都是先由 native 捕獲事件 然後 jni 到 java 層實現業務邏輯
執行的是 messageQueue 中的關鍵方法： next
next 主要的邏輯分為： java 部分 和 native 部分
java 上主要是取java層的 messageQueue msg 執行， 無 msg 就 idleHandler
java層 無 msg 會執行 native 的 pollOnce@Looper
native looper 中 fd 監聽封裝為 requestQueue， epoll_wait 將 fd 中的事件和對應 request 封裝為 response 處理， 處理的時候會調用 fd 對應的 callback 的 handleEvent
native 層 pollOnce 主要做的事情是：
vsync 信號，輸入事件， 都是通過這樣的機制完成的。
epoll_wait 機制 拿到的 event ， 都在 response pollOnce pollInner 處理了
這里的 dispatchVsync 從 native 回到 java 層
native：
java：
收到 Vsync 信號後， Choreographer 執行 doFrame
應用層重要的工作幾乎都在 doFrame 中
首先看下 doFrame 執行了什麼：
UI 線程的核心工作就在這幾個方法中：
上述執行 callback 的過程就對應了圖片中 依次處理 input animation traversal 這幾個關鍵過程
執行的周期是 16.6ms， 實際可能因為一些 delay 造成一些延遲、丟幀
input 事件的整體邏輯和 vsync 類似
native handleEvent ，在 NativeInputEventReceiver 中處理事件， 區分不同事件會通過 JNI
走到 java 層，WindowInputEventReceiver 然後進行分發消費
native :
java:
input事件的處理流程：
輸入event deliverInputEvent
deliver的 input 事件會來到 InputStage
InputStage 是一個責任鏈， 會分發消費這些 InputEvent
下面以滑動一下 recyclerView 為例子， 整體邏輯如下：
vsync 信號到來， 執行 doFrame，執行到 input 階段
touchEvent 消費， recyclerView layout 一些 ViewHolder
scroll 中 fill 結束，會執行 一個 recyclerView viewProperty 變化， 觸發了invalidate
invalidate 會走硬體加速， 一直到達 ViewRootImpl ， 從而將 Traversal 的 callback post choreographer執行到 traversal 階段就會執行
ViewRootImpl 執行 performTraversal ， 會根據目前是否需要重新layout ， 然後執行layout， draw 等流程
整個 input 到 traversal 結束，硬體繪制後， sync 任務到 GPU ， 然後合成一幀。
交給 SurfaceFlinger 來顯示。
SurfaceFlinger 是系統進程， 每一個應用進程是一個 client 端， 通過 IPC 機制，client 將圖像顯示工作交給 SurfaceFlinger
launch 一個 app：
『貳』 Android之Looper使用
Looper是Android中的一個類，用於為線程提供消息循環。在Android中，主線程已經默認開啟了一個Looper，因此可以直接使用Handler來發送消息。但是對於其他線程，如果需要使用Handler來發送消息，就需要先創建一個Looper。
以下是使用Looper的步驟：
1. 在子線程中創建一個Looper對象，並調用Looper的prepare()方法和Looper的loop()方法，這樣就可以為該線程創建一個消息循環。
```java
public class MyThread extends Thread {
public Handler mHandler;
public void run() {
// 創建Looper對象
Looper.prepare();
// 創建Handler對象
mHandler = new Handler() {
public void handleMessage(Message msg) {
// 處理消息
}
};
// 進入消息循環
Looper.loop();
}
}
```
2. 在主線程或其他線程中，可以通過Handler向該線程發送消息。
```java
MyThread thread = new MyThread();
thread.start();
// 向子線程發送消息
thread.mHandler.sendEmptyMessage(1);
```
在使用完Looper之後，需要調用Looper的quit()方法來退出消息循環。
```java
Looper.myLooper().quit();
```
需要注意的是，Looper是一個輪詢消息隊列的無限循環，如果沒有消息需要處理，會一直阻塞在loop()方法處，因此需要謹慎使用，避免出現死循環或內存泄漏等問題。
『叄』 android中looper的實現原理，為什麼調用looper.prepare就在當前線程關聯了一個lo
實際上：消息發送和計劃任務提交之後，它們都會進入某線程的消息隊列中，我們可以把這個線程稱之為目標線程。不論是主線程還是子線程都可以成為目標線程。上例中之所以在主線程中處理消息，是因為我們要更新UI，按照android中的規定我們必須由主線程更新UI。所以我們讓主線程成為了目標線程。
那麼如何控制讓某個線程成為目標線程呢？
這就引出了Looper的概念。Android系統中實現了消息循環機制，Android的消息循環是針對線程的，每個線程都可以有自己的消息隊列和消息循環。Android系統中的通過Looper幫助線程維護著一個消息隊列和消息循環。通過Looper.myLooper()得到當前線程的Looper對象，通過Looper.getMainLooper()得到當前進程的主線程的Looper對象。
前面提到每個線程都可以有自己的消息隊列和消息循環，然而我們自己創建的線程默認是沒有消息隊列和消息循環的（及Looper），要想讓一個線程具有消息處理機制我們應該在線程中先調用Looper.prepare()來創建一個Looper對象，然後調用Looper.loop()進入消息循環。如上面的源碼所示。
當我們用Handler的構造方法創建Handler對象時，指定handler對象與哪個具有消息處理機制的線程（具有Looper的線程）相關聯，這個線程就成了目標線程，可以接受消息和計劃任務了。Handler中的構造方法如下：
[java] view
plainprint?
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();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = null;
}
public Handler(Looper looper) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = null;
}
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();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = null;
}
public Handler(Looper looper) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = null;
}
在上述的計時器的例子中，之所以可以在主線程中處理消息而我們自己並沒有調用Looper.prepare()等方法，是因為Android系統在Activity啟動時為其創建一個消息隊列和消息循環，當我們用無參的Handler構造方法創建對象時又用了當前線程的Looper對象，及將handler與主線程中的Looper對象進行了關聯。
android中是使用Looper機制來完成消息循環的，但每次創建線程時都先初始化Looper比較麻煩，因此Android為我們提供了一個HandlerThread類，他封裝了Looper對象，是我們不用關心Looper的開啟和釋放問題。
不管是主線程還是其他線程只要有Looper的線程，別的線程就可以向這個線程的消息隊列中發送消息和任務。
我們使用HandlerThread類代替上一篇文章中的子線程，並用HandlerThread類中的Looper對象構造Handler，則接受消息的目標線程就不是主線程了，而是HandlerThread線程。代碼如下：
[java] view
plainprint?
public class clockActivity extends Activity {
/** Called when the activity is first created. */
private String TAG="clockActivity";
private Button endButton;
private TextView textView;
private int timer=0;
private boolean isRunning=true;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
endButton=(Button)findViewById(R.id.endBtn);
textView=(TextView)findViewById(R.id.textview);
endButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
isRunning=false;
}
});
HandlerThread thread=new HandlerThread("myThread");
handler=new Handler(thread.getLooper());//與HandlerThread中的Looper對象關聯
thread.start();
Runnable r=new Runnable(){
@Override
public void run() {
// TODO Auto-generated method stub
if(isRunning){
textView.setText("走了"+timer+"秒");
timer++;
handler.postDelayed(this, 1000);//提交任務r，延時1秒執行
}
}
};
handler.postDelayed(r, 1000);
}
}
public class clockActivity extends Activity {
/** Called when the activity is first created. */
private String TAG="clockActivity";
private Button endButton;
private TextView textView;
private int timer=0;
private boolean isRunning=true;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
endButton=(Button)findViewById(R.id.endBtn);
textView=(TextView)findViewById(R.id.textview);
endButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
isRunning=false;
}
});
HandlerThread thread=new HandlerThread("myThread");
handler=new Handler(thread.getLooper());//與HandlerThread中的Looper對象關聯
thread.start();
Runnable r=new Runnable(){
@Override
public void run() {
// TODO Auto-generated method stub
if(isRunning){
textView.setText("走了"+timer+"秒");
timer++;
handler.postDelayed(this, 1000);//提交任務r，延時1秒執行
}
}
};
handler.postDelayed(r, 1000);
}
}
此時處理任務會在handlerThread線程中完成。當然這個例子會出線異常：依然是因為在非主線程中更新了UI。這樣做只是為了大家能夠理解這種機制。
深入理解Android消息處理機制對於應用程序開發非常重要，也可以讓我們對線程同步有更加深刻的認識，希望這篇文章可以對朋友們有所幫助。