Einführung in diesen Abschnitt
In den beiden vorherigen Abschnitten haben wir die beiden Ereignisbehandlungsmechanismen in Android untersucht, und dies sind die einzigen beiden Arten von Ereignisreaktionen. In diesem Abschnitt wird Handler erläutert, der für die Nachrichtenübermittlung zwischen UI-Komponenten in einer Activity verwendet wird. Viele Freunde wissen vielleicht, dass Android aus Gründen der Thread-Sicherheit nicht zulässt, dass wir die UI außerhalb des UI-Threads bedienen. Oftmals, wenn wir die Oberfläche aktualisieren müssen, müssen wir UI-Komponenten über Handler benachrichtigen, damit sie aktualisiert werden! Zusätzlich zur Verwendung von Handler für Schnittstellenaktualisierungen können wir auch runOnUiThread() zum Aktualisieren verwenden oder sogar fortgeschrittenere Event-Busse. Natürlich behandeln wir hier nur Handler: was Handler ist, seinen Ausführungsablauf, zugehörige Methoden und den Unterschied zwischen der Verwendung von Handler in einem untergeordneten Thread und im Hauptthread!
1. Lern-Roadmap:

2. Einführung in die Handler-Klasse:

3. Ausführungs-Flussdiagramm von Handler:

Analyse des Flussdiagramms: Verwandte Begriffe
- UI-Thread: Dies ist unser Hauptthread. Wenn das System den UI-Thread erstellt, initialisiert es ein Looper-Objekt und erstellt außerdem eine zugehörige MessageQueue.
- Handler: Seine Funktion besteht darin, Nachrichten zu senden und zu verarbeiten. Wenn der Handler normal funktionieren soll, muss im aktuellen Thread ein Looper-Objekt vorhanden sein.
- Message: Das Message-Objekt, das Handler empfängt und verarbeitet.
- MessageQueue: Eine Nachrichtenwarteschlange, die Message in FIFO-Reihenfolge verwaltet. Beim Initialisieren eines Looper-Objekts wird eine zugehörige MessageQueue erstellt.
- Looper: Jeder Thread kann nur einen Looper haben, der die MessageQueue verwaltet, kontinuierlich Message daraus entnimmt und sie zur Verarbeitung an den entsprechenden Handler verteilt!
Einfach gesagt:
Wenn unser Child-Thread UI-Komponenten in einer Activity ändern möchte, können wir ein neues Handler-Objekt erstellen und über dieses Objekt eine Nachricht an den Main-Thread senden. Die gesendete Nachricht wartet zunächst in der MessageQueue des Main-Threads; Looper entnimmt sie in FIFO-Reihenfolge und verteilt sie dann anhand des `what`-Attributs des Nachrichtenobjekts zur Verarbeitung an den entsprechenden Handler.
4. Zugehörige Methoden von Handler:
- void handleMessage(Message msg): Die Methode zur Verarbeitung von Nachrichten, normalerweise zum Überschreiben vorgesehen!
- sendEmptyMessage(int what): Sendet eine leere Nachricht
- sendEmptyMessageDelayed(int what, long delayMillis): Sendet eine leere Nachricht nach einer angegebenen Verzögerung in Millisekunden
- sendMessage(Message msg): Sendet sofort eine Nachricht
- sendMessageDelayed(Message msg): Sendet eine Nachricht nach einer angegebenen Verzögerung in Millisekunden
- final boolean hasMessage(int what): Prüft, ob die Nachrichtenwarteschlange eine Nachricht enthält, deren `what`-Attribut der angegebene Wert ist. Wenn der Parameter (int what, Object object) lautet: Prüft zusätzlich zum `what`-Attribut auch, ob das Object-Attribut mit dem angegebenen Objekt übereinstimmt.
5. Verwendungsbeispiele für Handler:
1) Im Main-Thread geschriebener Handler
Im Main-Thread können wir, da das System bereits ein Looper-Objekt initialisiert hat, direkt ein Handler-Objekt erstellen und dann Nachrichten senden und verarbeiten!
Codebeispiel:Ein einfaches Programm, das Bilder regelmäßig wechselt. Es verwendet einen Timer, um den von der ImageView angezeigten Inhalt periodisch zu ändern, wodurch eine Frame-Animation entsteht.
Effekt bei der Ausführung:

Implementierungscode:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/RelativeLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
tools:context="com.jay.example.handlerdemo1.MainActivity" >
<ImageView
android:id="@+id/imgchange"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true" />
</RelativeLayout>
MainActivity.java:
public class MainActivity extends Activity {
//定义切换的图片的数组id
int imgids[] = new int[]{
R.drawable.s_1, R.drawable.s_2,R.drawable.s_3,
R.drawable.s_4,R.drawable.s_5,R.drawable.s_6,
R.drawable.s_7,R.drawable.s_8
};
int imgstart = 0;
final Handler myHandler = new Handler()
{
@Override
//重写handleMessage方法,根据msg中what的值判断是否执行后续操作
public void handleMessage(Message msg) {
if(msg.what == 0x123)
{
imgchange.setImageResource(imgids[imgstart++ % 8]);
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final ImageView imgchange = (ImageView) findViewById(R.id.imgchange);
//使用定时器,每隔200毫秒让handler发送一个空信息
new Timer().schedule(new TimerTask() {
@Override
public void run() {
myHandler.sendEmptyMessage(0x123);
}
}, 0,200);
}
}
2) Handler in einem Child-Thread geschrieben
Wenn der Handler in einem Child-Thread geschrieben wird, müssen wir selbst ein Looper-Objekt erstellen! Der Erstellungsprozess ist wie folgt:
1 )Rufen Sie die Methode Looper.prepare() direkt auf, um ein Looper-Objekt für den aktuellen Thread zu erstellen; ihr Konstruktor erstellt eine passende MessageQueue.2 )Erstellen Sie ein Handler-Objekt und überschreiben Sie die Methode handleMessage(), um Nachrichten von anderen Threads zu verarbeiten.3 )Rufen Sie die Methode Looper.loop() auf, um den Looper zu starten.
Verwendungsbeispiel: Geben Sie eine Zahl ein, berechnen Sie und geben Sie alle Primzahlen innerhalb dieses Bereichs per Toast aus.
Implementierungscode:main.xml:
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<EditText
android:id="@+id/etNum"
android:inputType="number"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="请输入上限"/>
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:onClick="cal"
android:text="计算"/>
</LinearLayout>
MainActivity.java:
public class CalPrime extends Activity
{
static final String UPPER_NUM = "upper";
EditText etNum;
CalThread calThread;
// 定义一个线程类
class CalThread extends Thread
{
public Handler mHandler;
public void run()
{
Looper.prepare();
mHandler = new Handler()
{
// 定义处理消息的方法
@Override
public void handleMessage(Message msg)
{
if(msg.what == 0x123)
{
int upper = msg.getData().getInt(UPPER_NUM);
List<Integer> nums = new ArrayList<Integer>();
// 计算从2开始、到upper的所有质数
outer:
for (int i = 2 ; i <= upper ; i++)
{
// 用i处于从2开始、到i的平方根的所有数
for (int j = 2 ; j <= Math.sqrt(i) ; j++)
{
// 如果可以整除,表明这个数不是质数
if(i != 2 && i % j == 0)
{
continue outer;
}
}
nums.add(i);
}
// 使用Toast显示统计出来的所有质数
Toast.makeText(CalPrime.this , nums.toString()
, Toast.LENGTH_LONG).show();
}
}
};
Looper.loop();
}
}
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
etNum = (EditText)findViewById(R.id.etNum);
calThread = new CalThread();
// 启动新线程
calThread.start();
}
// 为按钮的点击事件提供事件处理函数
public void cal(View source)
{
// 创建消息
Message msg = new Message();
msg.what = 0x123;
Bundle bundle = new Bundle();
bundle.putInt(UPPER_NUM ,
Integer.parseInt(etNum.getText().toString()));
msg.setData(bundle);
// 向新线程中的Handler发送消息
calThread.mHandler.sendMessage(msg);
}
}
PS: Dieses Beispiel stammt aus „Crazy Android“ ~
Zusammenfassung dieses Abschnitts
In diesem Abschnitt wird die Handler-Nachrichtenübermittlung in Android kurz analysiert. Wir müssen die Konzepte Handler, Message, MessageQueue und Looper klar unterscheiden sowie den Unterschied zwischen dem Schreiben des Handlers im Hauptthread und in einem Child-Thread!