Heim > Artikel > Backend-Entwicklung > Detailliertes Android-Beispiel für den HandlerThread-Quellcode
Der Artikel, den ich Ihnen heute präsentiere, besteht darin, die Verwendung und die Schritte von HandlerThread in Android anhand von Beispielcode zu analysieren. Freunde, die ihn benötigen, können darauf verweisen.
HandlerThread-Einführung:
Wir wissen, dass der Thread-Thread ein einmaliges Verbraucherprodukt ist. Wenn der Thread-Thread eine zeitaufwändige Aufgabe abschließt, wird der Thread automatisch zerstört. Wenn ich zu diesem Zeitpunkt eine weitere zeitaufwändige Aufgabe ausführen muss, müssen wir den Thread neu erstellen, um die zeitaufwändige Aufgabe auszuführen. Allerdings gibt es ein Leistungsproblem: Das mehrmalige Erstellen und Zerstören von Threads verbraucht
Systemressourcen. Um dieses Problem zu verstehen, können wir einen Looper-Thread selbst erstellen. Wenn eine zeitaufwändige Aufgabe in den Schleifenthread gestellt wird, führt der Thread die
-Zeit aus Der Schleifenthread befindet sich im Wartezustand, bis die nächste neue zeitaufwändige Aufgabe eingefügt wird. Dies vermeidet
Leistungsprobleme, die durch das mehrfache Erstellen von Thread-Threads verursacht werden. Vielleicht können Sie selbst einen Loop-Thread erstellen, aber ich kann Ihnen gute Neuigkeiten sagen. Es gibt tatsächlich ein Loop-Thread-Framework im Aandroid SDK
. An diesem Punkt müssen Sie nur noch beherrschen, wie man es benutzt, und das war's! Natürlich ist es heute unser Protagonist HandlerThread! Als nächstes lasst HandlerThread kommen, Applaus~~
Die übergeordnete Klasse von HandlerThread ist Thread, also ist HandlerThread eigentlich ein Thread, aber es hilft Ihnen, eine Looper-Schleife intern zu implementieren. Lassen Sie uns
zunächst verstehen, wie man Handler verwendet!
HandlerThread-Verwendungsschritte:
1. Erstellen Sie ein Instanzobjekt
HandlerThread handlerThread = new HandlerThread("handlerThread");
Die oben genannten Parameter können beliebige Zeichenkette
2. Starten Sie den HandlerThread-Thread
handlerThread.start();
An diesem Punkt haben wir den Aufbau eines Schleifenthreads abgeschlossen. Sie fragen sich vielleicht: Wie füge ich eine zeitaufwändige asynchrone Aufgabe zur Ausführung in den HandlerThread-Thread ein? Natürlich gibt es einen Weg, schauen wir uns den dritten Teil an.
Handler subHandler = new Handler(handlerThread.getLooper(), new Handler.Callback() { @Override public boolean handleMessage(Message msg) { //实现自己的消息处理 return true; } });
Der dritte Schritt besteht darin, ein Handler-Objekt zu erstellen und das Looper-Objekt im obigen HandlerThread zu verwenden als Handler-Parameter und schreiben Sie dann die
Nachricht senden
zur Ausführung an den Thread HandlerThread-Instanz:package com.example.handlerthread; import android.app.Activity; import android.os.Bundle; import android.os.Handler; import android.os.HandlerThread; import android.os.Message; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.TextView; public class MainActivity extends Activity { private Handler mSubHandler; private TextView textView; private Button button; private Handler.Callback mSubCallback = new Handler.Callback() { //该接口的实现就是处理异步耗时任务的,因此该方法执行在子线程中 @Override public boolean handleMessage(Message msg) { switch (msg.what) { case 0: Message msg1 = new Message(); msg1.what = 0; msg1.obj = java.lang.System.currentTimeMillis(); mUIHandler.sendMessage(msg1); break; default: break; } return false; } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); textView = (TextView) findViewById(R.id.textView); button = (Button) findViewById(R.id.button); HandlerThread workHandle = new HandlerThread("workHandleThread"); workHandle.start(); mSubHandler = new Handler(workHandle.getLooper(), mSubCallback); button.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { //投放异步耗时任务到HandlerThread中 mSubHandler.sendEmptyMessage(0); } }); } }
HandlerThread-Quellcode-Analyse
HandlerThread
Konstruktionsmethode
/** * Handy class for starting a new thread that has a looper. The looper can then be * used to create handler classes. Note that start() must still be called. */ public class HandlerThread extends Thread { //线程优先级 int mPriority; //当前线程id int mTid = -1; //当前线程持有的Looper对象 Looper mLooper; //构造方法 public HandlerThread(String name) { //调用父类默认的方法创建线程 super(name); mPriority = Process.THREAD_PRIORITY_DEFAULT; } //带优先级参数的构造方法 public HandlerThread(String name, int priority) { super(name); mPriority = priority; } ............... }
Analyse: Am Anfang dieser Klasse steht eine Beschreibung: Diese Klasse wird verwendet, um einen Thread mit einer Looper-Schleife zu erstellen, und Das Looper-Objekt wird zum Erstellen eines Handler-Objekts verwendet. Beachten Sie, dass Sie die start()-Methode aufrufen müssen, um den Thread zu starten, bevor Sie das Handler-Objekt erstellen. Vielleicht haben einige Leute hier Fragen? Warum müssen wir die Methode start() aufrufen, bevor wir einen Handler erstellen können? Wir werden dies später beantworten.
public class HandlerThread extends Thread { /** * Call back method that can be explicitly overridden if needed to execute some * setup before Looper loops. */ protected void onLooperPrepared() { } @Override public void run() { //获得当前线程的id mTid = Process.myTid(); //准备循环条件 Looper.prepare(); //持有锁机制来获得当前线程的Looper对象 synchronized (this) { mLooper = Looper.myLooper(); //发出通知,当前线程已经创建mLooper对象成功,这里主要是通知getLooper方法中的wait notifyAll(); } //设置当前线程的优先级 Process.setThreadPriority(mPriority); //该方法实现体是空的,子类可以实现该方法,作用就是在线程循环之前做一些准备工作,当然子类也可以不实现。 onLooperPrepared(); //启动loop Looper.loop(); mTid = -1; } }
, dass die onLooperPrepared-Methode vor dem Starten der Schleife in der run-Methode aufgerufen wird. Die Implementierung dieser Methode ist leer und Benutzer können diese Methode in Unterklassen implementieren. Der Zweck dieser Methode besteht darin,
getLooper ruft das Looper-Objekt des aktuellen Threads ab
/** * This method returns the Looper associated with this thread. If this thread not been started * or for any reason is isAlive() returns false, this method will return null. If this thread * has been started, this method will block until the looper has been initialized. * @return The looper. */ public Looper getLooper() { //如果线程不是存活的,则直接返回null if (!isAlive()) { return null; } // If the thread has been started, wait until the looper has been created. //如果线程已经启动,但是Looper还未创建的话,就等待,知道Looper创建成功 synchronized (this) { while (isAlive() && mLooper == null) { try { wait(); } catch (InterruptedException e) { } } } return mLooper; }
Analyse: Tatsächlich wurde der englische Kommentar am Anfang der Methode sehr klar erklärt: Die Hauptfunktion dieser Methode besteht darin, das mLooper-Objekt im aktuellen HandlerThread-Thread abzurufen.
Bestimmen Sie zunächst, ob der aktuelle Thread aktiv ist. Wenn er nicht aktiv ist, wird direkt null zurückgegeben. Zweitens: Wenn der aktuelle Thread überlebt, stellen Sie fest, ob die Mitgliedsvariable mLooper des Threads null ist. Wenn sie
总结:在获得mLooper对象的时候存在一个同步的问题,只有当线程创建成功并且Looper对象也创建成功之后才能获得mLooper的值。这里等待方法wait和run方法中的notifyAll方法共同完成同步问题。
quit结束当前线程的循环
/** * Quits the handler thread's looper. * <p> * Causes the handler thread's looper to terminate without processing any * more messages in the message queue. * </p><p> * Any attempt to post messages to the queue after the looper is asked to quit will fail. * For example, the {@link Handler#sendMessage(Message)} method will return false. * </p><p class="note"> * Using this method may be unsafe because some messages may not be delivered * before the looper terminates. Consider using {@link #quitSafely} instead to ensure * that all pending work is completed in an orderly manner. * </p> * * @return True if the looper looper has been asked to quit or false if the * thread had not yet started running. * * @see #quitSafely */ 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; }
分析:以上有两种让当前线程退出循环的方法,一种是安全的,一中是不安全的。至于两者有什么区别? quitSafely方法效率比quit方法标率低一点,但是安全。具体选择哪种就要看具体项目了。
总结:
1.HandlerThread适用于构建循环线程。
2.在创建Handler作为HandlerThread线程消息执行者的时候必须调用start方法之后,因为创建Handler需要的Looper参数是从HandlerThread类中获得,而Looper对象的赋值又是在HandlerThread的run方法中创建。
相信看了这些案例你已经掌握了方法,更多精彩请关注php中文网其它相关文章!
相关阅读:
Das obige ist der detaillierte Inhalt vonDetailliertes Android-Beispiel für den HandlerThread-Quellcode. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!