Android学習への道 (13) Handlerの詳細解説

1 はじめに

ハンドラーは Android メッセージ受け渡しメカニズムのセットであり、主にスレッド間通信に使用されます。

最も簡単な言葉で説明すると、ハンドラーは実際にはメインスレッドによって作成されたサブスレッドです。サブスレッドが実行され、メッセージが生成されます。ルーパーはメッセージを取得してハンドラーに渡します。ハンドラーはサブスレッドでメッセージを取得します。 - スレッドを 1 つずつ。

Binder/Socket はプロセス間通信に使用され、Handler メッセージ メカニズムは同じプロセス内のスレッド間通信に使用されます。

メインスレッドと通信する非同期スレッドが存在する場合はどこでも、ハンドラーが存在する必要があると言えます。

マルチスレッド アプリケーション シナリオでは、作業スレッドで更新する必要がある操作情報が UI メイン スレッドに転送されるため、作業スレッドは UI を更新し、最終的に非同期メッセージの処理を実現できます。

ハンドラー メッセージ受け渡しメカニズムを使用する主な目的は、複数のスレッドで同時に UI を更新しながらスレッドの安全性を確保することです。

2. 関連概念の説明

ハンドラー、メッセージ、メッセージキュー、ルーパー

• メッセージ: 動作または一連のアクションを表します。実行可能。各メッセージは、メッセージ キューに追加されるときに明確なターゲット ハンドラーを持ちます。
• ThreadLocal: スレッド ローカル ストレージ (略して TLS)。各スレッドには独自のプライベート ローカル ストレージ領域があり、異なるスレッドは互いの TLS 領域にアクセスできません。ThreadLocal の機能は、スレッド内にローカル変数 TLS を提供することです。この変数はスレッドのライフサイクル内で機能します。各スレッドは独自の値を持ちます (スレッド分離)
• MessageQueue (C 層と Java 層の両方で実装): 挿入および削除作業をキューの形式で提供し、その内部構造はメッセージを二重リンク リストの形式で保存します。
• ルーパー (C 層と Java 層の両方で実装): ルーパーはループを意味します。メッセージ キューからメッセージを周期的にフェッチし、処理のためにメッセージをハンドラーに渡します。ハンドラー: メッセージの実際のプロセッサであり、以下の機能があります。メッセージの取得、メッセージの送信
  、メッセージの処理、メッセージの削除およびその他の機能

Android のメッセージング メカニズム:

• Handler の sendMessage メソッドを例に挙げると、メッセージの送信後、メッセージはメッセージ キュー MessageQueue に追加されます。
• Looper は、メッセージ キューを走査し、キュー内のメッセージを対応するハンドラーに配布して処理する役割を果たします。
• メッセージはハンドラーの handleMessage メソッドで処理され、メッセージの送信と処理が完了します。

ハンドラー図:

メッセージメカニズムモデル:

• メッセージ: 送信する必要があるメッセージ。データは送信できます。
• MessageQueue: メッセージ キューですが、その内部実装ではキューは使用されません。単一リンク リストには挿入と削除に利点があるため、実際には単一リンク リスト データ構造を通じてメッセージ リストを維持します。主な機能は、メッセージ プールにメッセージを配信する (MessageQueue.enqueueMessage) ことと、メッセージ プールからメッセージを取り出す (MessageQueue.next) ことです。
• Handler: メッセージ補助クラス。その主な機能は、さまざまなメッセージ イベントをメッセージ プールに送信し (Handler.sendMessage)、対応するメッセージ イベントを処理することです (Handler.handleMessage)。
• Looper: ループ (Looper.loop) で継続的に実行し、MessageQueue からメッセージを読み取り、分散メカニズムに従ってターゲット プロセッサにメッセージを分散します。

メッセージメカニズムのアーキテクチャ

• 子スレッドが時間のかかる操作を完了した後、ハンドラーがメッセージを送信すると、MessageQueue.enqueueMessage が呼び出され、メッセージがメッセージ キューに追加されます。
• Looper.loop を通じてループが開始されると、メッセージはスレッド プールから継続的に読み取られます。つまり、MessageQueue.next が呼び出されます。
• 次に、ターゲット ハンドラー (つまり、メッセージを送信したハンドラー) のdispatchMessage メソッドを呼び出してメッセージを配信し、ハンドラーが配置されているスレッドに戻ります。ターゲット ハンドラーはメッセージを受信し、handleMessage メソッドを呼び出し、メッセージを受け取り、メッセージを処理します。

3. ハンドラーの基本的な使い方

3.1 ハンドラーの作成

ハンドラーを使用すると、遅延メッセージを送信できますが、遅延中にユーザーがアクティビティを閉じると、アクティビティが漏洩します。

このリークは、Message が Handler を保持するためであり、Java の特性により、内部クラスが外部クラスを保持するため、Activity が Handler によって保持されることになり、最終的に Activity リークにつながります。

解決策: Handler を静的な内部クラスとして定義し、アクティビティへの弱い参照を内部的に保持し、すべてのメッセージを適時に削除します。

public class HandlerActivity extends AppCompatActivity {

    private Button bt_handler_send;

    private static class MyHandler extends Handler {

        //弱引用持有HandlerActivity , GC 回收时会被回收掉
        private WeakReference<HandlerActivity> weakReference;

        public MyHandler(HandlerActivity activity) {
            this.weakReference = new WeakReference(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            HandlerActivity activity = weakReference.get();
            super.handleMessage(msg);
            if (null != activity) {
                //执行业务逻辑
                Toast.makeText(activity,"handleMessage",Toast.LENGTH_SHORT).show();
            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.HandlerActivity);

        //创建 Handler
        final MyHandler handler = new MyHandler(this);

        bt_handler_send = findViewById(R.id.bt_handler_send);
        bt_handler_send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //使用 handler 发送空消息
                        handler.sendEmptyMessage(0);

                    }
                }).start();
            }
        });
    }
    
    @Override
    protected void onDestroy() {
        //移除所有回调及消息
        myHandler.removeCallbacksAndMessages(null);
        super.onDestroy();
    }
}

3.2 メッセージの取得

メッセージを取得するにはおそらくいくつかの方法があります。

Message message = myHandler.obtainMessage(); 		   //通过 Handler 实例获取
Message message1 = Message.obtain();   			      //通过 Message 获取
Message message2 = new Message();      				 //直接创建新的 Message 实例

ソースコードを見ると、HandlerのobtainMessage()メソッドがMessageのobtain()メソッドも呼び出していることがわかります。

public final Message obtainMessage()
{
    return Message.obtain(this);
}

Messageの取得メソッドを参照することで

public static Message obtain(Handler h) {
        //调用下面的方法获取 Message
        Message m = obtain();
        //将当前 Handler 指定给 message 的 target ，用来区分是哪个 Handler 的消息
        m.target = h;

        return m;
    }
    
//从消息池中拿取 Message，如果有则返回，否则创建新的 Message
public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

コストを節約するために、Message を使用する場合は再利用するようにし、最初の 2 つの方法を使用してメッセージを作成します。

3.3 ハンドラーがメッセージを送信する

Handler は、send() シリーズや post() シリーズなど、メッセージを送信するための一連のメソッドを提供します。post メソッドは Runnalbe オブジェクトを渡す必要があります。post メソッドのソース コードを見てみましょう。

    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

ただし、どのメソッドを呼び出しても、最終的には MessageQueue.enqueueMessage(Message,long) メソッドに到達します。
例として sendEmptyMessage(int) メソッドを取り上げます。

//Handler
sendEmptyMessage(int)
  -> sendEmptyMessageDelayed(int,int)
    -> sendMessageAtTime(Message,long)
      -> enqueueMessage(MessageQueue,Message,long)
  			-> queue.enqueueMessage(Message, long);

ここから、キューへのメッセージの出入りを担当するメッセージ キュー MessageQueue を見つけることができます。

4. 2 つのインスタンス (メインスレッド - 子スレッド)

4.1 サブスレッドからメインスレッドへ

まず、静的内部クラスを MainActivity に追加し、その handleMessage メソッドをオーバーライドします。

private static class MyHandler extends Handler {
        private final WeakReference<MainActivity> mTarget;

        public MyHandler(MainActivity activity) {
            mTarget = new WeakReference<MainActivity>(activity);
        }

        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            HandlerActivity activity = weakReference.get();
            super.handleMessage(msg);
            if (null != activity) {
                //执行业务逻辑
                if (msg.what == 0) {
                	Log.e("myhandler", "change textview");
                	MainActivity ma = mTarget.get();
	                ma.textView.setText("hahah");
            	}
                Toast.makeText(activity,"handleMessage",Toast.LENGTH_SHORT).show();
            }
        
        }
 }

次に、MyHandler タイプのプライベート プロパティを作成します。

private Handler handler1 = new MyHandler(this);

最後に、onCreate コールバックでメッセージを送受信するためのスレッドを作成します。

new Thread(new Runnable() {
            @Override
            public void run() {
                handler1.sendEmptyMessage(0);
            }
        }).start();

結論は：

• ハンドラー サブクラス オブジェクトは通常、両方のスレッドでアクセスできるようにメイン スレッドで作成されます。Handler クラスのサブクラス MyHandler を作成し、送信されたメッセージの受信と処理に使用される handlerMessage メソッドをオーバーライドしました。次に、子スレッドを作成し、その中で MyHandler オブジェクトを使用して sendEmptyMessage メソッドを呼び出し、空のメッセージを送信しました。その後、このデータをメインスレッドで受信できます。

4.2 メインスレッドから子スレッドへ

まず、MyHandler クラスを作成します。

private static class MyHandler extends Handler {

        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            if (msg.what == 0) {
                Log.e("child thread", "receive msg from main thread");
            }
        }
    }

Handler 型のプライベート変数を宣言し、デフォルトで null に初期化します。

private Handler handler1;

子スレッドを作成し、ハンドラーが新しく作成された MyHandler オブジェクトを指すようにします。

new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                handler1 = new MyHandler();
                Looper.loop();
                Log.e("child thread", "child thread end");
            }
        }).start();

メインスレッドから子スレッドにメッセージを送信します。

while (handler1 == null) {

        }

        handler1.sendEmptyMessage(0);
        handler1.getLooper().quitSafely();

5. ハンドラー機構の原理

5.1 ハンドラー原理の概要

通常のスレッドにはルーパーがありません。ルーパー オブジェクトが必要な場合は、最初に Looper.prepare メソッドを呼び出す必要があり、スレッドはルーパーを 1 つだけ持つことができます。

ハンドラーはクロススレッド通信をどのように完了するのでしょうか?

• Android は Linux でパイプ通信を使用します

• パイプについてですが、簡単に言うとパイプはファイルです
• パイプの両端には 2 つのオープン ファイル記述子があります。これら 2 つのオープン ファイル記述子は同じファイルに対応します。1 つは読み取りに使用され、もう 1 つは書き込みに使用されます。

• メッセージキューの作成時

• JNI 関数を呼び出して、NativeMessageQueue オブジェクトを初期化します。NativeMessageQueue は Looper オブジェクトを初期化します
• Looper の機能は、Java 層のメッセージキューにメッセージがない場合に、Android アプリケーションのメインスレッドを待機状態にし、Java 層のメッセージキューに新しいメッセージが来ると、そのスレッドを起動します。 Android アプリケーションのメインスレッド。このニュースを処理するには

• ハンドラーはsendMessage()を介してMessageQueueキューにメッセージを送信します
• Looper は、loop() を通じてトリガー条件を満たすメッセージを継続的に抽出し、処理のためにターゲットにメッセージを渡します。
• dispatchMessage() の後、対応する処理のためにハンドラーの handleMessage() に戻されます。
• MessageQueue にメッセージを追加するときに、パイプに文字を書き込むと、ループ スレッドが起動される場合があります。MessageQueue にメッセージがなく、アイドル状態にある場合は、よく使用される IdelHandler インターフェイスのメソッドが実行されます。いくつかの掃除作業をするために。

5.2 ハンドラーとパイプライン通信

パイプは本質的にファイルですが、通常のファイルとは異なります。パイプ バッファ サイズは通常 1 ページ、つまり 4K バイトです。パイプラインは読み取り側と書き込み側に分かれています。読み取り側はパイプからデータを取得し、データが空の場合はブロックします。書き込み側はパイプにデータを書き込み、パイプ バッファーがいっぱいになるとブロックします。

• Handler メカニズムでは、Looper.loop メソッドがループ内で Message を継続的に処理し、Message msg = queue.next(); メソッドを通じてメッセージが取得され、次のメッセージが取得されます。このメソッドは、ネイティブ メソッドであるnativePollOnce() メソッドを呼び出し、JNI 呼び出しを通じてネイティブ層に入ります。ネイティブ層のコードではパイプライン メカニズムが使用されます。
• メモリはスレッド間で共有されることがわかっていますが、両方のスレッドが利用できるメモリは同じ領域であり、両方のスレッドが直接アクセスする権利を持っているため、ハンドラ通信を通じて、メッセージ プールの内容をあるスレッドから別のスレッドにコピーする必要はありません。もちろん、プライベート領域 ThreadLocal というスレッドもあります (ここでは説明しません)。メモリをコピーする必要がないので、パイプラインの役割は何ですか?
• ハンドラー メカニズムにおけるパイプラインの役割は、スレッド A がメッセージを準備してメッセージ プールに入れるときに、そのメッセージを処理するように別のスレッド B に通知する必要があることです。スレッド A は、パイプの書き込み端にデータ 1 を書き込みます (古い Android バージョンでは、文字 W が書き込まれます)。パイプにデータがあると、スレッド B を起動してメッセージを処理します。パイプラインの主な仕事は、コア機能である別のスレッドに通知することです。

バインダーではなくパイプラインを使用する理由は何ですか?

• メモリの観点から: Binder は通信プロセス中にメモリ コピーも必要としますが、ハンドラ メカニズム内のメッセージは同じメモリ内にあるため、コピーする必要はまったくありません。ハンドラーに必要なのは、データが利用可能であることを別のスレッドに伝えることだけです。
• CPU の観点から見ると、バインダー通信の基礎となるドライバーにもバインダー スレッド プールが必要ですが、各通信にはバインダー スレッドの作成とメモリ割り当てが含まれるため、CPU リソースが無駄になります。

5.3 ハンドラ例の詳細説明

ハンドラーは、Android メッセージング メカニズムの上位層インターフェイスです。ハンドラーを使用するプロセスは非常に簡単で、ハンドラーが配置されているスレッドにタスクを簡単に切り替えて実行できます。通常、Handler の使用シナリオは UI を更新することです。

以下は、メッセージ メカニズムを使用する簡単な例です。

public class Activity extends android.app.Activity {
	private Handler mHandler = new Handler(){
		@Override
		public void handleMessage(Message msg) {
			super.handleMessage(msg);
			System.out.println(msg.what);
		}
	};
	@Override
	public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
		super.onCreate(savedInstanceState, persistentState);
		setContentView(R.layout.activity_main);
		new Thread(new Runnable() {
			@Override
			public void run() {
				...............耗时操作
				Message message = Message.obtain();
				message.what = 1;
				mHandler.sendMessage(message);
			}
		}).start();
	}
}

別の例: メインスレッドから子スレッドにメッセージを送信するにはどうすればよいですか? (このような適用シナリオはまれですが)

Thread thread = new Thread(){
            @Override
            public void run() {
                super.run();
                //初始化Looper,一定要写在Handler初始化之前
                Looper.prepare();
                //在子线程内部初始化handler即可，发送消息的代码可在主线程任意地方发送
                handler=new Handler(){
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                      //所有的事情处理完成后要退出looper，即终止Looper循环
                        //这两个方法都可以，有关这两个方法的区别自行寻找答案
                        handler.getLooper().quit();
                        handler.getLooper().quitSafely();
                    }
                };
              
                //启动Looper循环，否则Handler无法收到消息
                Looper.loop();
            }
        };
        thread.start();
    //在主线程中发送消息
    handler.sendMessage();

まずコードの最初の行 Looper.prepare(); を説明し、まずハンドラー構築メソッドを見てみましょう。

//空参的构造方法，这个方法调用了两个参数的构造方法
  public Handler() {
        this(null, false);
    }

//两个参数的构造方法
public Handler(Callback callback, boolean async) {
        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 = callback;
        mAsynchronous = async;
    }

• Looper は Handler の構築メソッドで検証されます。Looper が空の場合は、null ポインター例外がスローされます。
• また、ハンドラーは構築メソッドで 1 つのことを行い、そのグローバル メッセージ キュー オブジェクト (mQueue) の 1 つを Looper のメッセージ キューにポイントします。つまり、構築メソッド mQueue = mLooper.mQueue; のこのコード行です。

コードの 2 行目は Hanlder を初期化し、HandleMessage() メソッドをオーバーライドします。

次に、Looper.loop() メソッドが呼び出されます。これについては後で説明します。

まず、コードの最後の行の main 関数 handler.sendMessage(message) を見てみましょう。

まず、このコード行以降のコード実行フローを見てみましょう。

sendMessage() の後、コードは最後に、図に示すいくつかのメソッドを通じて MessageQueue の enqueueMessage() メソッドを実行します。

boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        synchronized (this) {
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }
            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

• MessageQueue は一方向のリスト構造であり、MessageQueue の enqueueMessage() メソッドが行う主な処理は、ハンドラーによって送信されたメッセージをリストに挿入することです。
• handler.senMessage() メソッドが呼び出されるときの最終結果は、メッセージをメッセージ キューに挿入することだけです。

メッセージの送信作業は完了しましたが、Looper はいつメッセージを受信しましたか? 見てみましょう:

public static void loop() {
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            try {
                msg.target.dispatchMessage(msg);
            } 
        }
    }

• これは無限ループです
• このループの目的は、MessageQueue からメッセージを取得することです。
• メッセージを取得するメソッドは MessageQueue.next() メソッドです。
• メッセージを取得した後、message.target オブジェクトのdispatchMessage() メソッドを呼び出してメッセージを配布します。
• ループを終了する条件は、MessageQueue.next() メソッドが null を返すことです。

これを見ると、当然、どのオブジェクトが message.target. なのかを考えるはずです。dispatchMessage は何をするのでしょうか?

public final class Message implements Parcelable {
 /*package*/ int flags;

    /*package*/ long when;

    /*package*/ Bundle data;

    /*package*/ Handler target;

    /*package*/ Runnable callback;

    // sometimes we store linked lists of these things
    /*package*/ Message next;
}

• Looper は MessageQueue からメッセージを取得した後、Handler のdispatchMessage() メソッドを呼び出します。
  ここでは、このターゲットがどの Handler を指しているのかを尋ねざるを得ません。前の enqueueMessage を見てみましょう。

//Handler的方法
 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

• コードの最初の行では、メッセージの target 属性を、メッセージを送信するハンドラー自体に割り当てます。
• Looper はメッセージを取得した後、メッセージを送信したハンドラーのdispatchMessage() メソッドを呼び出し、メッセージ自体をパラメーターとして返します。この時点で、コードの実行ロジックはハンドラーに戻ります。

次に、ハンドラーのdispatchMessage()メソッドを見てください。

/**
    *handler的方法
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

私たちがよく知っている方法がここにあることがわかりますか? —handleMessage() メソッドは、メッセージを処理するときのロジックでもあります。

最後に、システムがどのように機能するかを示す概略図を次に示します。

6. ハンドラーの使い方（AndroidとJavaの違い）

6.1 UI インターフェイスを更新する

Javaの使用:

new Thread( new Runnable() {     
    public void run() {     
         myView.invalidate();    
     }            
}).start();

機能を実装し、UI インターフェイスを更新できます。しかし、これはシングルスレッド モデルに違反するため機能しません。Android UI 操作はスレッドセーフではなく、これらの操作は UI スレッドで実行する必要があります。

スレッド+ハンドラー:
ハンドラーは、受信したメッセージに基づいて UI の更新を処理します。Thread スレッドは、UI に更新を通知するためにハンドラー メッセージを送信します。

Handler myHandler = new Handler() {  
          public void handleMessage(Message msg) {   
               switch (msg.what) {   
                    case TestHandler.GUIUPDATEIDENTIFIER:   
                         myBounceView.invalidate();  
                         break;   
               }   
               super.handleMessage(msg);   
          }   
     }; 

class myThread implements Runnable {   
          public void run() {  
               while (!Thread.currentThread().isInterrupted()) {    
                       
                    Message message = new Message();   
                    message.what = TestHandler.GUIUPDATEIDENTIFIER;   
                      
                    TestHandler.this.myHandler.sendMessage(message);   
                    try {   
                         Thread.sleep(100);    
                    } catch (InterruptedException e) {   
                         Thread.currentThread().interrupt();   
                    }   
               }   
          }   
     }   

6.2 タイマ（遅延動作）

Java を使用する:
Java に付属の TimerTask クラスを使用します。TimerTask は Thread よりもリソースの消費が少なくなります。import java.util.Timer; および import java.util.TimerTask; を導入します。

public class JavaTimer extends Activity {  
  
    Timer timer = new Timer();  
    TimerTask task = new TimerTask(){   
        public void run() {  
            setTitle("hear me?");  
        }            
    };  

    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
       
         timer.schedule(task, 10000);   // 延迟delay毫秒后，执行一次task。

    }  
}

タイマータスク + ハンドラー：

public class TestTimer extends Activity {  
  
    Timer timer = new Timer();  
    Handler handler = new Handler(){   
        public void handleMessage(Message msg) {  
            switch (msg.what) {      
            case 1:      
                setTitle("hear me?");  
                break;      
            }      
            super.handleMessage(msg);  
        }  
          
    };  

    TimerTask task = new TimerTask(){    
        public void run() {  
            Message message = new Message();      
            message.what = 1;      
            handler.sendMessage(message);    
        }            
    };  

    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
    
        timer.schedule(task, 10000);   // 延迟delay毫秒后，执行一次task。
    }  
}  

6.3 UIを定期的に更新する

実行可能 + Handler.postDelayed(実行可能,時間)：

   private Handler handler = new Handler();  
  
    private Runnable myRunnable= new Runnable() {    
        public void run() {  
            if (run) {  
                handler.postDelayed(this, 1000);  
                count++;  
            }  
            tvCounter.setText("Count: " + count);  

        }  
    }; 

そしてそれを他の場所で呼び出します

handler.post(myRunnable);
handler.post(myRunnable,time);

6.4 ハンドラーは遅延実行を実装します

ハンドラーは実行可能ファイルを実行するために 2 秒遅延します

Handler handler=new Handler();
Runnable runnable=new Runnable() {
 @Override
	public void run() {
		// TODO Auto-generated method stub
		if(xsLayout.getVisibility()==View.VISIBLE){
			xsLayout.setVisibility(View.GONE);
		}
	}
};
handler.postDelayed(runnable, 2000);

実行可能ファイルが実行される前に、このスケジュールされたタスクをキャンセルします

handler.removeCallbacks(runnable);

7. まとめ

7.1 概要

Handler の背後には Looper と MessageQueue があり、これら 3 つは連携して明確な役割分担を行っています。

• Looper: 関連するスレッドとメッセージの配布を担当し、このスレッドの MessageQueue からメッセージを取得してハンドラーに配布します。
• MessageQueue: メッセージの保存と管理、およびハンドラーによって送信されたメッセージの管理を担当するキューです。
• ハンドラー: メッセージの送信と処理、開発者への対応、API の提供、実装の詳細の背後への隠蔽を担当します。

Handler によって送信されたメッセージは MessageQueue によって保存および管理され、Loopler はメッセージを handleMessage() にコールバックする役割を果たします。

スレッドの変換は Looper によって完了し、handleMessage() が配置されるスレッドは、Looper.loop() の呼び出し元が配置されるスレッドによって決まります。

7.2 注意事項

(1) スレッドにはハンドラーがいくつありますか?

• 開発プロセス中に、複数の (通常は複数の) ハンドラーが作成されます。

(2) スレッドにはルーパーがいくつありますか? どのように保証しますか？

• ルーパーは1台のみ
• Looper の構築はプライベートであり、その prepare() メソッドを通じてのみ構築できます。Looper の prepare() メソッドが呼び出されるとき、ThreadLocal の get() メソッドが呼び出され、Looper が ThreadLocalMap? に設定されているかどうかを確認します。
• 存在する場合は、各スレッドが Looper を 1 つだけ持つことができることを示す例外がスローされます。存在しない場合は、新しい Looper オブジェクトが ThreadLocalMap に設定されます。
• これにより、ThreadLocalMap と Looper の間の 1 対 1 の対応が保証されます。つまり、1 つの ThreadLocalMap は 1 つの Looper にのみ対応します。ここでの ThreadLocalMap は Thread 内のグローバル変数であり、1 つだけ存在するため、Thread 内に Looper が 1 つだけ存在することが保証されます。

(3) ハンドラーのメモリリークの原因は何ですか?

• 内部クラスは外部オブジェクトへの参照を保持します。
• ハンドラーの原則: ハンドラーは遅延メッセージを送信できるため、メッセージが実行された後に同じハンドラーによって確実に受信されるようにするために、送信されたメッセージはハンドラーへの参照を保持します。この参照はメッセージのターゲット フィールドに保存されます。 sendMessage() メソッドは最終的に enqueueMessage() を呼び出し、 enqueueMessage() でこれがメッセージのターゲット フィールドに割り当てられます。
• そのため、MessageはHandlerへの参照を保持し、HandlerはActivityへの参照を保持することになるため、Messageが処理される前にActivityが破棄されるとメモリリークが発生します。
• どうやって対処すればいいのでしょうか？ハンドラー オブジェクトは静的を使用して変更できます。

(4) メインスレッドが新しいハンドラーを作成できるのはなぜですか? 子スレッドで新しいハンドラーを使用したい場合は、どのような準備を行う必要がありますか?

• ActivityThread の main() はすでに Looper で prepare() 操作を実行しているため、メイン スレッドで直接新しいハンドラーを作成できます。

• android-28 の SystemServer クラス:
• main メソッドは Android アプリケーション全体への入り口です。Looper.prepare() は子スレッドで呼び出され、Looper オブジェクトを作成し、そのオブジェクトを現在のスレッドの ThreadLocal に保存します。各スレッドには ThreadLocal があります。他のスレッドからの分離を実現するローカル コピー変数メカニズムを提供します。この変数は、このスレッドのライフ サイクル内でのみ機能するため、同じスレッド内の複数のメソッド間でのパブリック変数転送の複雑さを軽減できます。Looper.loop() メソッドは、msg.target.dispatchMassage() メソッドを通じて、メッセージ キュー内のメッセージを取り出し、指定されたハンドラーにメッセージを送信します。

    /**
     * The main entry point from zygote.
     */
    public static void main(String[] args) {
        new SystemServer().run();
    }


    private void run() {
        ......
        Looper.prepareMainLooper();
        ......
    }

• 子スレッドで新しいハンドラーを作成する場合は、Looper の prepare() メソッドを手動で呼び出して Looper を初期化し、次に Looper のloop() メソッドを呼び出して Looper を実行する必要があります。

      new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();			//初始化Looper
                new Handler(){
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                    }
                };
                Looper.loop();
            }
        })

(5) 子スレッドで保持されているルーパー、メッセージキューにメッセージがない場合の解決策は何ですか?

• 処理されない場合、スレッドはブロックされます。解決策は、Looper の quitSafely(); を呼び出すことです。
• quitSafely() は、MessageQueue の quit() メソッドを呼び出し、すべてのメッセージをクリアし、nativeWake() メソッドを呼び出して、以前にブロックされたネイティブ PollOnce() をウェイクアップします。これにより、next() メソッドの for ループが引き続き実行されます。そして、メッセージが null の後にあることが判明すると、ループが終了し、Looper が終了します。これにより、メモリとスレッドが解放されます。

(6) 内部的にスレッドの安全性を確保するにはどうすればよいですか?

• MessageQueue にデータを追加する複数のハンドラーが存在する可能性があります (メッセージの送信時に各ハンドラーが別のスレッドに存在する可能性があります)。メッセージを追加するメソッド
  enqueueMessage() は synchronize によって変更され、メッセージをフェッチするメソッドは次のように変更されます。 () も同期によって変更されます。
• ハンドラーの遅延メッセージ時間は正確ですか?
  上記ロック動作のため、時刻の正確性を完全に保証するものではありません。

(7) メッセージを使用する場合はどのように作成すればよいですか?

• Messageのobtain()メソッドを使用して作成されているため、直接新規作成するとメモリジッターが発生しやすくなります。
• メモリ ジッターは、頻繁な新しいオブジェクトと gc による頻繁なガベージ コレクションによって発生します。オブジェクトは別の場所に保持され、時間内にリサイクルできない可能性があるため、メモリ使用量はますます高くなります。
• get() を使用してメモリを再利用すると、メモリ ジッターを回避できます。内部的にはリンクリスト構造のメッセージプールを保持しており、obtain()を呼び出すとテーブルの先頭にあるメッセージが再利用され、次のメッセージが指し示されます。ヘッダーに再利用可能なメッセージがない場合、新しいオブジェクトが作成されます。このオブジェクト プールの最大長は 50 です。

(8) Handler の postDelay を使用した後、メッセージ キューはどうなりますか?

• このときメッセージキューが空の場合はメッセージは実行されず、メッセージの待ち時間が計算され、待ち時間が経過すると実行が継続されます。

(9) Looper の無限ループによってアプリケーションがフリーズしないのはなぜですか?

• スタックは ANR です。理由は 2 つあります。

• 1. 5 秒以内に入力イベント (キーを押す、タッチなど) に対する応答がありません。
• 2. BroadcastReceiver は 10 秒以内に実行を完了しませんでした。

• 実際、すべてのアクティビティとサービスは、loop() 関数内で実行され、メッセージの形式で存在するため、メッセージが生成されない場合、ルーパーはブロックされ (ブロックされ)、メインスレッドはスリープ状態になります。入力イベントまたは、ルーパーがイベントに応答するメッセージを追加した後にメインスレッドが起動されるため、ANR は発生しません。
• 簡単に言えば、ルーパーのブロックはイベント入力がないことを示し、ANR はイベントが応答しないことによって引き起こされるため、ルーパーの無限ループによってアプリケーションがフリーズすることはありません。

6.3 次へ

導入

Android システムでは、時間のかかる操作を実行した後、別のサブスレッドを起動して実行する必要があり、スレッドの実行後、スレッドは自動的に破棄されます。プロジェクト内で時間のかかる操作を頻繁に実行したり、スレッドを頻繁に開始して破棄したりすると、間違いなく大量のパフォーマンスが消費されることを想像してください。

HandlerThread は Google によってカプセル化されており、スレッドを複数回開始することなく、時間のかかる複数の操作を実行するために使用できます。Handler と Looper を使用して実装されます。

HanderThread は実際にはスレッドです

使い方？

//创建实例对象,该参数表示线程的名字
HandlerThread handlerThread = new HandlerThread("myHandlerThread");

//启动我们创建的HandlerThread线程
handlerThread.start();

//怎样将Handler与线程对象绑定在一起
mThreadHandler = new Handler(mHandlerThread.getLooper()) {
	@Override
	public void handleMessage(Message msg) {
		//发生myHandlerThread线程中
		checkForUpdate();
		if(isUpdate){
			mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
		}
	}
};

例を見てみましょう

public class MainActivity extends AppCompatActivity {
	private static final int MSG_UPDATE_INFO = 0x100;
	Handler mMainHandler = new Handler();
	private TextView mTv;
	private Handler mThreadHandler;
	private HandlerThread mHandlerThread;
	private boolean isUpdate = true;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		mTv = (TextView) findViewById(R.id.tv);
		initHandlerThread();
	}
	private void initHandlerThread() {
		mHandlerThread = new HandlerThread("xujun");
		mHandlerThread.start();
		mThreadHandler = new Handler(mHandlerThread.getLooper()){
			@Override
			public void handleMessage(Message msg) {
				checkForUpdate();
				if (isUpdate) {
					mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
				}
			}
		};
	}
	
/**
* 模拟从服务器解析数据
*/
	private void checkForUpdate() {
		try {
			//模拟耗时
			Thread.sleep(1200);
			mMainHandler.post(new Runnable() {
				@Override
				public void run() {
					String result = "实时更新中，当前股票行情：<fontcolor='red'>%d</font>";
					result = String.format(result, (int) (Math.random() * 5000 + 1000));
					mTv.setText(Html.fromHtml(result));
				}	
			});
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	protected void onResume() {
		isUpdate = true;
		super.onResume();
		mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
	}
	@Override
	protected void onPause() {
		super.onPause();
		isUpdate = false;
		mThreadHandler.removeMessages(MSG_UPDATE_INFO);
	}
@Override
	protected void onDestroy() {
		super.onDestroy();
		mHandlerThread.quit();
		mMainHandler.removeCallbacksAndMessages(null);
	}
}

上記のテスト コードを実行すると、次のレンダリングが表示されます (この例は適切ではありません。主な使用シナリオは、handleMessage で時間のかかる操作を実行することです)。

ソースコードを見てください

sdk23 に基づくと、コードは 100 行を超えるだけであることがわかります。

public class HandlerThread extends Thread {
	int mPriority;
	int mTid = -1;
	Looper mLooper;
	public HandlerThread(String name) {
		super(name);
		mPriority = Process.THREAD_PRIORITY_DEFAULT;
	}
	public HandlerThread(String name, int priority) {
		super(name);
		mPriority = priority;
	}
/**
* Call back method that can be explicitly overridden if nee
ded to execute some
* setup before Looper loops.
*/
	protected void onLooperPrepared() {
	}
	
	@Override
	public void run() {
		mTid = Process.myTid();
		Looper.prepare();
		//持有锁机制来获得当前线程的Looper对象
		synchronized (this) {
			mLooper = Looper.myLooper();
			//发出通知，当前线程已经创建mLooper对象成功，这里主要是通知getLooper方法中的wait
			notifyAll();
		}
		//设置线程的优先级别
		Process.setThreadPriority(mPriority);
		//这里默认是空方法的实现，我们可以重写这个方法来做一些线程开始之前的准备，方便扩展
		onLooperPrepared();
		Looper.loop();
		mTid = -1;
	}
	
	public Looper getLooper() {
		if (!isAlive()) {
		return null;
		}
		// 直到线程创建完Looper之后才能获得Looper对象，Looper未创建成功，阻塞
		synchronized (this) {
			while (isAlive() && mLooper == null) {
				try {
					wait();
				} catch (InterruptedException e) {
				}
			}
		}
		return mLooper;
	}
	
	public boolean quit() {
		Looper looper = getLooper();
		if (looper != null) {
			looper.quit();
			return true;
		}
		return false;
	}
	
	public boolean quitSafely() {
		Looper looper = getLooper();
		if (looper != null) {
			looper.quitSafely();
			return true;
		}
		return false;
	}
/**
* Returns the identifier of this thread. See Process.myTid(
).
*/
	public int getThreadId() {
		return mTid;
	}
}

(1) まずはコンストラクタを見てみましょう

	public HandlerThread(String name) {
		super(name);
		mPriority = Process.THREAD_PRIORITY_DEFAULT;
	}
	public HandlerThread(String name, int priority) {
		super(name);
		mPriority = priority;
	}

1 つのパラメータと 2 つのパラメータ。name は現在のスレッドの名前を表し、priority はスレッドの優先レベルを表します。

(2) run() メソッドを見てみましょう
run メソッドでは、Looper を初期化し、スレッドの優先レベルを設定することがわかります。

	public void run() {
		mTid = Process.myTid();
		Looper.prepare();
		//持有锁机制来获得当前线程的Looper对象
		synchronized (this) {
			mLooper = Looper.myLooper();
			//发出通知，当前线程已经创建mLooper对象成功，这里主要是通知getLooper方法中的wait
			notifyAll();
		}
		//设置线程的优先级别
		Process.setThreadPriority(mPriority);
		//这里默认是空方法的实现，我们可以重写这个方法来做一些线程开始之前的准备，方便扩展
		onLooperPrepared();
		Looper.loop();
		mTid = -1;
	}

前に、HandlerThread を使用する場合は start() メソッドを呼び出す必要があると述べました。そうすれば、HandlerThread とハンドラーをバインドできるようになります。

• その理由は、ルーパーの初期化を run() メソッドで開始するだけであり、HandlerThread の start() メソッドを呼び出すと、スレッドがスケジューリングのために仮想マシンに渡され、仮想マシンが自動的に呼び出しを行うためです。実行メソッド。

ロック機構とnotifyAll()を使用する理由:

• getLooper() メソッドから理由を知ることができます。

	public Looper getLooper() {
		if (!isAlive()) {
			return null;
		}
	// 直到线程创建完Looper之后才能获得Looper对象，Looper未创建成功，阻塞
	synchronized (this) {
		while (isAlive() && mLooper == null) {
			try {
				wait();
			} catch (InterruptedException e) {
			}
		}
	}
	return mLooper;
}

概要: mLooper オブジェクトの取得時に同期の問題が発生しました。mLooper の値は、スレッドが正常に作成され、Looper オブジェクトも正常に作成された場合にのみ取得できます。ここでは、wait メソッド wait と run メソッド内の notificationAll メソッドが共同で同期の問題を完了します。

(3) 次にquitメソッドとquitSafeメソッドを見てみましょう。

	public boolean quit() {
		Looper looper = getLooper();
		if (looper != null) {
			looper.quit();
			return true;
		}
		return false;
	}
	
	public boolean quitSafely() {
		Looper looper = getLooper();
		if (looper != null) {
			looper.quitSafely();
			return true;
		}
		return false;
	}

これら 2 つのメソッドを追跡することは簡単で、最終的に MessageQueue の quit(booleansafe) メソッドを呼び出すのは 2 つのメソッドだけであることがわかります。

void quit(boolean safe) {
	if (!mQuitAllowed) {
		throw new IllegalStateException("Main thread not allowedto quit.");
	}
	synchronized (this) {
		if (mQuitting) {
			return;
		}
		mQuitting = true;
		//安全退出调用这个方法
		if (safe) {
			removeAllFutureMessagesLocked();
		} else {//不安全退出调用这个方法
			removeAllMessagesLocked();
		}
		// We can assume mPtr != 0 because mQuitting was previously false.
		nativeWake(mPtr);
	}
}

安全でない場合は、removeAllMessagesLocked(); が呼び出されます。このメソッドがどのように処理されるかを見てみましょう。このメソッドは実際にメッセージのリンク リストを走査し、すべてのメッセージのコールバックを削除し、それらを null にリセットします。

private void removeAllMessagesLocked() {
	Message p = mMessages;
	while (p != null) {
		Message n = p.next;
		p.recycleUnchecked();
		p = n;
	}
	mMessages = null;
}

安全に RemoveAllFutureMessagesLocked() を呼び出します。このメソッドは、現在のメッセージ キューが Message.when プロパティに基づいてメッセージを処理しているかどうかを判断します。処理中のメッセージがない場合は、すべてのコールバックが直接削除されます。処理中のメッセージがある場合は、メッセージが処理されるまで待ちます。処理後、ループを終了します。したがって、quitSafe() は安全ですが、quit() メソッドは安全ではありません。これは、quit メソッドは、メッセージが処理されているかどうかに関係なく、すべてのコールバックを直接削除するためです。

private void removeAllFutureMessagesLocked() {
	final long now = SystemClock.uptimeMillis();
	Message p = mMessages;
	if (p != null) {
		//判断当前队列中的消息是否正在处理这个消息，没有的话，直接移除所有回调
		if (p.when > now) {
			removeAllMessagesLocked();
		} else {
			//正在处理的话，等待该消息处理处理完毕再退出该循环
			Message n;
			for (;;) {
				n = p.next;
				if (n == null) {
					return;
				}
				if (n.when > now) {
					break;
				}
				p = n;
			}
			p.next = null;
			do {
				p = n;
				n = p.next;
				p.recycleUnchecked();
			} while (n != null);
		}
	}
}