Android Runnable Tutorial und Beispiele

Android Runnable Tutorial und Beispiele

In dieser Klasse lernen wir die Runnable Schnittstelle kennen und sehen Beispiele für ihre Verwendung.

Was ist Runnable?

*In Java ist die Schnittstelle Runnable im Grunde eine Abstraktion für einen ausführbaren Befehl.

Wir haben über die [Klasse Thread] (https://camposha.info/android/thread) als Low-Level-Konstrukt für Gleichzeitigkeit in Java und Android gesprochen.

Nun, ein weiterer Baustein ist Runnable, eine Schnittstelle, die aus der Java-API stammt und dazu gedacht ist, Code zu spezifizieren und zu kapseln, der von einer Java Thread-Instanz oder einer anderen Klasse, die diese Runnable behandelt, ausgeführt werden soll.

Es ist eine Schnittstelle und ist im Paket java.lang definiert und hat eine abstrakte Methode namens run(), die wir implementieren müssen.

package java.lang;
public interface Runnable{
    public abstract void run();
}

Verwendung

Die Schnittstelle Runnable wird ausgiebig genutzt, um Code in Threads auszuführen.
Die Runnable-Schnittstelle hat eine abstrakte Methode namens run():

public abstract void run ()

Normalerweise implementieren Sie diese Methode immer dann, wenn Ihre Klasse die Runnable-Schnittstelle implementiert.
Die Methode wird dann aufgerufen, um die Ausführung des aktiven Teils des Codes der Klasse zu starten.

Nehmen wir an, wir wollen Runnable als unseren Threading-Mechanismus verwenden. Nun, zuerst implementieren wir die Schnittstelle. Dann stellen Sie die Implementierung für die Methode run() zur Verfügung:

public class MyRunnable implements Runnable {
    public void run(){
        Log.d("Generic","Running in the Thread " +
        Thread.currentThread().getId());
    }
}

Damit kann unsere Runnable-Unterklasse nun an Thread übergeben werden und wird unabhängig in der konkurrierenden Ausführungslinie ausgeführt:

    Thread thread = new Thread(new MyRunnable());
    thread.start();

Im folgenden Code haben wir die Subklasse Runnable grundsätzlich so angelegt, dass sie
die Methode run() implementiert und von einem Thread übergeben und ausgeführt werden kann:

Runnable Schnittstelle Indirekte Unterklassen

Runnable hat eine Menge davon, so dass wir nur ein paar häufig verwendete auflisten:

Lassen Sie uns nun einige Beispiele sehen:

Android Runnable Beispiel Schritt für Schritt

Dies ist ein Beispiel für Android. Android verwendet offensichtlich Java und die Runnable-Schnittstelle existiert seit API-Level 1.

Wir können ein Runnable mit einem Service wie folgt verwenden:

public class MyService extends Service implements Runnable{}

Das zwingt uns dann, die abstrakte Methode run() innerhalb dieser Klasse zu implementieren:

 @Override
    public void run() {
    }

Und da dies ein Service ist, müssen wir auch eine andere abstrakte Methode für Service namens onBind() überschreiben

 @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

Service ist eine Android-Komponente, die Lifecycle-Callbacks hat. Einer von ihnen ist onCreate(), eine Methode, die jedes Mal ausgelöst wird, wenn ein Service erstellt wird.

Für uns bedeutet das, dass wir jedes Mal, wenn das passiert, einen "Thread" erstellen und ihn starten wollen:

@Override
    public void onCreate() {
        super.onCreate();
        Thread myThead=new Thread(this);
        myThead.start();
    }

Wenn ich dann alle 1 Sekunde einige Nachrichten protokollieren möchte, füge ich den folgenden Code innerhalb der Methode run() ein:

        while (true)
        {
            try{

                Log.i(MY_TAG,"Distance in Light Years : "+spaceship_distance);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

Dann fügen Sie als Instanzvariablen das Folgende über Ihrer onCreate() Methode hinzu:

public static String MY_TAG="MY_SERVICE";
private int spaceship_distance=0;

Nun, das ist ein Beispiel für die Verwendung von Runnable mit Android. Wenn Sie daran interessiert sind, dass der Service tatsächlich läuft: dann tun Sie folgendes:

1. Registrieren Sie den Service im Manifest:

```java

```

Stellen Sie sicher, dass Sie Ihren <code>Service</code>-Namen anstelle von <code>MyService</code> angeben.</code></pre>
<ol start="2">
<li>Starte den <code>Service</code> in der <code>MainActivity</code>:</li>
</ol>
<!-- 12 -->
<pre><code>&#x60;&#x60;&#x60;java
Intent i=new Intent(this,MyService.class);
startService(i);
```

Und das war's, ein Beispiel für eine android Runnable Schnittstelle mit Services.

Beachten Sie, dass manchmal Runnable auf diese Weise verwendet wird:

    @Override
    public void onCreate() {
        super.onCreate();

        new Thread(new Runnable() {
            @Override
            public void run() {
                ArrayList<Song> songs = scanSongs(ScanMusicService.this);
                LogUtils.d(songs);
                ToastUtils.showLongToast(songs.toString());
            }
        }).start();

    }

Runnable Quick Samples

(a). Wie man einen HTTP GET mit HttpURLConnection und Runnable durchführt

HttpURLConnection ist unsere Netzwerkklasse und ermöglicht es uns, unsere HTTP GET Anfrage auszuführen.

Auf der anderen Seite ist Runnable unsere Schnittstelle, die es uns erlaubt, unsere HTTP GET-Anfrage im Hintergrund-Thread auszuführen.

Sie beginnen also mit der Implementierung der Schnittstelle Runnable, was Sie zwingt, die Methode run() zu überschreiben.

Innerhalb dieser run()-Methode führen wir unseren HTTP GET aus:

public class UrlRequest implements Runnable {
    ......
 @Override
    public void run() {
        try {
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            InputStream stream = connection.getInputStream();
            int responseCode = connection.getResponseCode();
            ByteArrayOutputStream responseBody = new ByteArrayOutputStream();
            byte buffer[] = new byte[1024];
            int bytesRead = 0;
            while ((bytesRead = stream.read(buffer)) > 0) {
                responseBody.write(buffer, 0, bytesRead);
            }
            listener.onReceivedBody(responseCode, responseBody.toByteArray());
        }
        catch (Exception e) {
            listener.onError(e);
        }
    }
}

Hier ist die vollständige Klasse:

import android.support.annotation.NonNull;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class UrlRequest implements Runnable {

    public interface Listener {

        void onReceivedBody(int responseCode, byte body[]);
        void onError(Exception e);
    }

    public interface RequestFactory {

        @NonNull
        UrlRequest makeRequest(URL url, Listener listener);
    }
    private static RequestFactory factory = new RequestFactory() {
        @NonNull
        @Override
        public UrlRequest makeRequest(URL url, Listener listener) {
            return new UrlRequest(url, listener);
        }
    };

    private URL url;
    private Listener listener;

    public static UrlRequest makeRequest(URL url, Listener listener) {
        return factory.makeRequest(url, listener);
    }

    public static void setFactory(RequestFactory newFactory) {
        factory = newFactory;
    }

    public UrlRequest(URL url, Listener listener) {
        this.url = url;
        this.listener = listener;
    }

    @Override
    public void run() {
        try {
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            InputStream stream = connection.getInputStream();
            int responseCode = connection.getResponseCode();
            ByteArrayOutputStream responseBody = new ByteArrayOutputStream();
            byte buffer[] = new byte[1024];
            int bytesRead = 0;
            while ((bytesRead = stream.read(buffer)) > 0) {
                responseBody.write(buffer, 0, bytesRead);
            }
            listener.onReceivedBody(responseCode, responseBody.toByteArray());
        }
        catch (Exception e) {
            listener.onError(e);
        }
    }
}