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 < sein 🎜> Zeichenkette

, die Funktion des Parameters besteht hauptsächlich darin, den Namen des aktuellen Threads zu markieren.

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.

3. Erstellen Sie einen Schleifennachrichtenverarbeitungsmechanismus

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

handlerMessage-Methode in der Callback-Schnittstellenklasse des Handlers neu, um zeitaufwändige Aufgaben zu erledigen.

Zusammenfassung: Die Reihenfolge der oben genannten drei Schritte darf nicht durcheinander gebracht werden und muss strikt eingehalten werden. An dieser Stelle können wir subHandler aufrufen, um zeitaufwändige Aufgaben in Form von

Nachricht senden

zur Ausführung an den Thread

HandlerThread zu senden. Die Implikation ist, dass die handlerMessage-Methode in der Callback-Schnittstellenklasse in subHandler tatsächlich im Arbeitsthread ausgeführt wird.

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.

Die obigen Codekommentare sind sehr klar. Die HandlerThread-Klasse hat zwei Konstruktoren. Der Unterschied besteht darin, den Prioritätsparameter des aktuellen Threads festzulegen. Sie können die Priorität

entsprechend Ihrer eigenen Situation festlegen oder die Standardpriorität verwenden.

HandlerThrads Ausführungsmethode

Analyse: Die Kommentare im obigen Code wurden klar geschrieben und die Hauptfunktion der obigen Ausführungsmethode ist Zum Aufrufen von Looper.prepare und Looper.loop wird ein Schleifenthread erstellt. Es ist erwähnenswert

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,

einige Initialisierungsarbeiten vor der Thread-Schleife durchzuführen. Abhängig von Ihren Anforderungen müssen Sie diese Methode natürlich nicht implementieren. Es ist auch ersichtlich, dass Google-Ingenieure beim Schreiben des Codes auch die Skalierbarkeit des Codes berücksichtigen. Großartig!

Andere Methoden von HandlerThread

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

null ist, bedeutet dies, dass der aktuelle Thread erfolgreich erstellt wurde, das Looper-Objekt jedoch noch nicht. Daher wird hier die Wartemethode aufgerufen. Wenn die notifyAll-Methode in der Ausführungsmethode aufgerufen wird, benachrichtigt

die Wartemethode, dass der aktuelle Thread auf das Ende warten soll, und springt aus der Schleife und erhält den Wert des mLooper-Objekts.

总结：在获得mLooper对象的时候存在一个同步的问题，只有当线程创建成功并且Looper对象也创建成功之后才能获得mLooper的值。这里等待方法wait和run方法中的notifyAll方法共同完成同步问题。

quit结束当前线程的循环

/**
   * Quits the handler thread's looper.
   * <p>
   * Causes the handler thread&#39;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中文网其它相关文章！

相关阅读：

php如何实现栈数据结构以及括号匹配算法的代码示例详解

php中最简单的字符串匹配算法，php匹配算法_PHP教程

最简单的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!