WEBVTT

00:00.200 --> 00:07.940
Operationen in der Raumdatenbank wie Einfügungen, Aktualisierungen und Abfragen sollten nicht auf dem Haupt-Thread der Benutzeroberfläche

00:07.940 --> 00:15.410
ausgeführt werden, da sie die Benutzeroberfläche blockieren können, was dazu führen kann, dass die Anwendung nicht mehr reagiert.

00:15.440 --> 00:21.360
Wir müssen diese Datenbankoperationen in Hintergrund-Threads auslagern.

00:21.380 --> 00:29.270
Auf diese Weise halten Sie den UI-Thread frei, um Benutzerinteraktionen zu verarbeiten und sicherzustellen, dass Ihre Anwendung reaktionsfähig

00:29.270 --> 00:30.230
bleibt.

00:30.230 --> 00:36.830
Wenn wir zu den Kotlin-Abschnitten übergehen, werden wir die Coroutines verwenden, die diese Operationen im Hintergrund ausführen

00:36.830 --> 00:37.700
werden.

00:37.700 --> 00:46.310
In Java müssen wir jedoch Handler und Executor Service verwenden, um die Methoden im Hintergrund auszuführen.

00:46.310 --> 00:48.950
Ich kann also nicht so schreiben.

00:48.980 --> 00:55.790
Fügen Sie einen Kontakt hinzu und rufen Sie die Insert-Methode der Kontakt-Dao direkt auf, da dies im Haupt-UI-Thread

00:55.790 --> 01:04.830
ausgeführt wird, was Probleme für unsere Anwendung verursacht und dazu führt, dass die A- und R-Anwendung nicht reagiert oder möglicherweise abstürzt.

01:04.830 --> 01:12.900
Um also mögliche Fehler zu vermeiden, müssen wir Handler und die Ausführungsdienste verwenden, um diese Aufgabe oder

01:12.900 --> 01:14.970
diesen Vorgang auszuführen.

01:14.970 --> 01:23.700
Im Hintergrund werde ich den Executor-Dienst verwenden, ich werde ihn Executor nennen und mit der Tastenkombination Alt+Entry

01:23.700 --> 01:32.340
diese Klasse importieren, die mit Executor dot new single thread executer und Executor-Dienst gleichzusetzen ist.

01:32.340 --> 01:39.690
Normalerweise wird ein Thread-Pool-Executor verwendet, um diese Datenbankoperationen auf Hintergrund-Threads zu verlagern.

01:39.690 --> 01:46.680
Auf diese Weise halten Sie den UI-Thread frei, um Benutzerinteraktionen zu verarbeiten, und stellen sicher, dass Ihre

01:46.680 --> 01:54.450
Anwendung reaktionsfähig bleibt, da ein Single-Thread-Executor erstellt wird, d. h., dass Datenbankoperationen sequentiell in

01:54.450 --> 01:57.540
einem Hintergrund-Thread ausgeführt werden.

01:57.540 --> 02:03.060
Dies kann dazu beitragen, Gleichzeitigkeitsprobleme beim Datenbankzugriff zu vermeiden.

02:03.060 --> 02:11.400
Der zweite Schritt besteht darin, den Handler mit der Tastenkombination Alt+Enter zu importieren und darauf zu achten,

02:11.400 --> 02:16.050
dass der Handler aus dem OS-Paket dem neuen Handler entspricht.

02:16.050 --> 02:21.810
Und hier muss ich den Looper-Punkt verwenden, also den Hauptlooper.

02:21.810 --> 02:29.250
Warum wir Handler verwenden, während Datenbankoperationen im Hintergrund ablaufen, müssen Sie oft die Benutzeroberfläche mit den Ergebnissen

02:29.280 --> 02:32.010
dieser Operationen aktualisieren.

02:32.010 --> 02:39.360
Aktualisierungen der Benutzeroberfläche müssen jedoch im Haupt-Thread der Benutzeroberfläche durchgeführt werden, um Probleme mit der Ansicht zu vermeiden.

02:39.360 --> 02:49.410
Der Handler mit Looper dot get main Looper-Methode wird verwendet, um Aufgaben an die Nachrichtenwarteschlange des Haupt-UI-Threads zu senden.

02:49.410 --> 02:59.130
Dadurch wird sichergestellt, dass jeglicher UI-bezogener Code, wie z. B. die Aktualisierung von Textansichten oder Recycler-Ansichten, auf dem Hauptthread ausgeführt

02:59.130 --> 03:00.120
wird.

03:00.120 --> 03:03.870
Wir müssen also den Kontext hinzufügen im Hintergrund ausführen.

03:03.870 --> 03:06.360
Ich verwende also den Executor-Dienst.

03:06.360 --> 03:11.640
Ich muss die Benutzeroberfläche, die Textansichten oder die Recycleransicht aktualisieren.

03:11.640 --> 03:19.890
Deshalb verwende ich den Handler mit Looper, indem ich einen Executor Service mit dem Handler kombiniere.

03:19.890 --> 03:25.140
Dies ist für Datenbankoperationen im Hintergrund und Handler für UI-Updates.

03:25.140 --> 03:33.870
Sie erzielen viele Vorteile, wie z. B. Thread-Trennung, Synchronisierung und reaktionsschnelle UI-Thread-Trennung im Hintergrund. Datenbankoperationen

03:33.870 --> 03:40.980
werden von UI-Aktualisierungen getrennt, wodurch UI-Blockierungen und Fehler durch eine nicht reagierende Anwendung verhindert

03:40.980 --> 03:42.420
werden.

03:42.420 --> 03:43.560
Synchronisierung.

03:43.560 --> 03:50.760
Der gleichzeitige Zugriff auf die Datenbank wird vom Ausführungsdienst verwaltet, wodurch sichergestellt wird, dass die Datenbankoperationen

03:50.760 --> 03:55.260
sequentiell ablaufen und Wettlaufbedingungen vermieden werden.

03:55.260 --> 04:03.630
Responsive UI-Updates werden auf dem Haupt-Thread mit Hilfe des Handlers durchgeführt, um eine responsive Benutzeroberfläche zu gewährleisten.

04:03.630 --> 04:11.100
Ich muss den Executor verwenden, um diese Methode im Hintergrund auszuführen, und ich werde den Handler verwenden, um die Benutzeroberfläche zu aktualisieren.

04:11.130 --> 04:16.230
Dazu muss ich die Executor-Dot-Execute-Methode verwenden.

04:16.230 --> 04:21.690
Und hier muss ich eine neue Runnable verwenden und wie Sie sehen können, habe ich sie überschrieben.

04:21.690 --> 04:23.280
Die Laufmethode.

04:23.280 --> 04:27.090
Ich muss diese Methode hier in den Lauf verschieben.

04:27.090 --> 04:33.390
Die Methode Runnable ist eine Schnittstelle, die eine auszuführende Aufgabe definiert.

04:33.420 --> 04:35.400
Normalerweise in einem separaten Thema.

04:35.400 --> 04:40.500
Sie stellt eine Arbeitseinheit dar, die synchron ausgeführt werden kann.

04:40.500 --> 04:48.810
Runnable-Objekte werden häufig mit Thread-bezogenen APIs verwendet, einschließlich des Executer-Dienstes zur Durchführung

04:48.810 --> 04:58.170
von Hintergrundaufgaben, und die runnable-Schnittstelle definiert eine einzelne Methode void run, die ausgeführt wird, wenn die runnable

04:58.170 --> 04:59.580
Aufgabe ist.

04:59.770 --> 05:00.670
Ausgeführt.

05:00.670 --> 05:08.280
Runnable-Objekte werden verwendet, um Code zu kapseln, der asynchron in einem separaten Thread ausgeführt werden

05:08.290 --> 05:16.750
soll. Indem Sie ein Runnable an einen Executor-Dienst übergeben, delegieren Sie die Ausführung dieser Aufgabe an den vom Executor

05:16.750 --> 05:18.550
verwalteten Thread.

05:18.550 --> 05:26.470
Um diesen Code im Hintergrund auszuführen, müssen wir also einen Executor erstellen, der für Datenbankoperationen im Hintergrund

05:26.470 --> 05:29.800
verwendet wird, den Executor-Dienst.

05:29.800 --> 05:38.140
Dann müssen wir den Handler für die Aktualisierung der Benutzeroberfläche verwenden, und die Verknüpfung dieses Executors mit runnable

05:38.140 --> 05:46.120
wird verwendet, um die Run-Methode bereitzustellen, die diesen Code asynchron auf einem separaten Thread ausführen wird.

05:46.120 --> 05:51.550
So führen wir in Java Hintergrundaufgaben aus.

05:51.550 --> 05:55.780
Ich werde das Gleiche mit den anderen Methoden tun.

05:55.780 --> 06:05.720
Ich verschiebe diesen Code und muss ihn im Repository-Konstruktor initialisieren und ihn öffentlich machen, um ihn

06:05.720 --> 06:12.860
in den anderen Methoden zu verwenden und die Duplizierung von Code zu verhindern.

06:12.860 --> 06:18.950
Also hier Executor und ich muss diese Handler und Handler zu schneiden.

06:18.980 --> 06:27.350
Okay, das ist aus dem Repository-Konstruktor und ich werde den Executor in den anderen Methoden wie Kontakt löschen

06:27.350 --> 06:28.520
verwenden.

06:28.520 --> 06:36.830
Hier, Executor, muss ich also ein neues Runnable bereitstellen, und innerhalb der Ausführung muss ich diese Methode verschieben und

06:36.830 --> 06:38.630
im Hintergrund ausführen.
