Wie kann ich Code in einem Hintergrund-Thread unter Android ausführen?

Ich möchte, dass Code kontinuierlich im Hintergrund ausgeführt wird. Ich möchte es nicht in einem Dienst tun. Ist ein anderer Weg möglich?

Ich habe versucht, die ThreadKlasse in meinem anzurufen, Activityaber meine Activitybleibt für einige Zeit im Hintergrund und dann hört es auf. Die ThreadKlasse hört auch auf zu arbeiten.

class testThread implements Runnable {
        @Override
        public void run() {
            File file = new File( Environment.getExternalStorageDirectory(), "/BPCLTracker/gpsdata.txt" );
            int i = 0;

            RandomAccessFile in = null;

            try {
                in = new RandomAccessFile( file, "rw" );
            } catch (FileNotFoundException e) {
// TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
// TODO Auto-generated catch block
                e.printStackTrace();
            }
//String line =null;
            while ( true ) {
                HttpEntity entity = null;
                try {
                    if ( isInternetOn() ) {
                        while ( ( line = in.readLine() ) != null ) {

                            HttpClient client = new DefaultHttpClient();
                            String url = "some url";
                            HttpPost request = new HttpPost( url );
                            StringEntity se = new StringEntity( line );
                            se.setContentEncoding( "UTF-8" );
                            se.setContentEncoding( new BasicHeader( HTTP.CONTENT_TYPE, "application/json" ) );
                            entity = se;
                            request.setEntity( entity );
                            HttpResponse response = client.execute( request );
                            entity = response.getEntity();
                            i++;
                        }
                        if ( ( line = in.readLine() ) == null && entity != null ) {
                            file.delete();
                            testThread t = new testThread();
                            Thread t1 = new Thread( t );
                            t1.start();
                        }


                    } else {
                        Thread.sleep( 60000 );
                    } // end of else

                } catch (NullPointerException e1) {
                    e1.printStackTrace();
                } catch (InterruptedException e2) {
                    e2.printStackTrace();
                } catch (IOException e1) {
// TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }// end of while
        }// end of run

    }

Wenn du musst:

1. Code auf einem Hintergrund-Thread ausführen

2. Führen Sie Code aus, der die Benutzeroberfläche NICHT berührt / aktualisiert

3. Führen Sie (Kurz-) Code aus, dessen Fertigstellung höchstens einige Sekunden dauert

Verwenden Sie dann das folgende saubere und effiziente Muster, das AsyncTask verwendet:

AsyncTask.execute(new Runnable() {
   @Override
   public void run() {
      //TODO your background code
   }
});

Denken Sie daran, Hintergrund laufen, kontinuierlich laufen sind zwei verschiedene Aufgaben.

Für langfristige Hintergrundprozesse sind Threads mit Android nicht optimal. Hier ist jedoch der Code und Sie tun dies auf eigenes Risiko ...

Denken Sie daran, dass Service oder Thread im Hintergrund ausgeführt werden, aber unsere Aufgabe muss ausgelöst werden (immer wieder aufrufen), um Aktualisierungen zu erhalten. Wenn die Aufgabe abgeschlossen ist, müssen wir die Funktion für die nächste Aktualisierung zurückrufen.

Timer (periodischer Trigger), Alarm (Timebase-Trigger), Broadcast (Event Base Trigger) und Rekursion wecken unsere Funktionen.

public static boolean isRecursionEnable = true;

void runInBackground() {
    if (!isRecursionEnable)
        // Handle not to start multiple parallel threads
        return;

    // isRecursionEnable = false; when u want to stop
    // on exception on thread make it true again  
    new Thread(new Runnable() {
        @Override
        public void run() {
            // DO your work here
            // get the data
            if (activity_is_not_in_background) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        // update UI
                        runInBackground();
                    }
                });
            } else {
                runInBackground();
            }
        }
    }).start();
}

Verwenden des Dienstes: Wenn Sie einen Dienst starten, wird dieser gestartet, die Aufgabe ausgeführt und sich selbst beendet. nach der Ausführung der Aufgabe. Das Beenden kann auch durch eine Ausnahme verursacht werden, oder der Benutzer hat es manuell über die Einstellungen beendet. START_STICKY (Sticky Service) ist die von Android angegebene Option, dass der Dienst sich selbst neu startet, wenn der Dienst beendet wird.

Erinnern Sie sich an den Unterschied zwischen Multiprocessing und Multithreading? Der Dienst ist ein Hintergrundprozess (genau wie eine Aktivität ohne Benutzeroberfläche). So wie Sie einen Thread in der Aktivität starten, um das Laden des Hauptthreads (Aktivitätsthread) zu vermeiden, müssen Sie auch Threads (oder asynchrone Aufgaben) für den Dienst starten um eine Belastung des Dienstes zu vermeiden.

Wenn Sie in einer einzelnen Anweisung eine Aufgabe zum Ausführen eines Hintergrunds ausführen möchten, müssen Sie einen StickyService starten und den Thread im Service auf Ereignisbasis ausführen

Ich möchte, dass Code kontinuierlich im Hintergrund ausgeführt wird. Ich möchte es nicht in einem Dienst tun. Ist ein anderer Weg möglich?

Der wahrscheinlichste Mechanismus, den Sie suchen, ist AsyncTask. Es ist direkt für die Durchführung eines Hintergrundprozesses für einen Hintergrund-Thread vorgesehen. Der Hauptvorteil besteht auch darin, dass einige Methoden angeboten werden, die auf dem Hauptthread (UI) ausgeführt werden und die Aktualisierung Ihrer Benutzeroberfläche ermöglichen, wenn Sie den Benutzer über Fortschritte bei der Aufgabe informieren oder die Benutzeroberfläche mit Daten aktualisieren möchten, die aus dem Hintergrundprozess abgerufen wurden.

Wenn Sie nicht wissen, wie Sie hier anfangen sollen, finden Sie hier ein nettes Tutorial:

• AsyncTask verstehen - einmal und für immer

Hinweis: Auch besteht die Möglichkeit , auf den Einsatz IntentServicemit ResultReceiver, die auch funktioniert.

Einfacher 3-Liner

Ein einfacher Weg, dies zu tun, den ich als Kommentar von @awardak in Brandon Rudes Antwort gefunden habe :

new Thread( new Runnable() { @Override public void run() { 
  // Run whatever background code you want here.
} } ).start();

Ich bin mir nicht sicher, ob oder wie dies besser ist als zu verwenden, AsyncTask.executeaber es scheint für uns zu funktionieren. Kommentare zum Unterschied sind willkommen.

Danke, @awardak !

Eine Alternative zu AsyncTask ist Robospice. https://github.com/octo-online/robospice .

Einige der Merkmale von Robospice.

1. führt asynchrone (in einem AndroidService-Hintergrund) Netzwerkanforderungen aus (z. B. REST-Anforderungen mit Spring Android). Benachrichtigen Sie Ihre App im UI-Thread, wenn das Ergebnis fertig ist.

2.ist stark getippt! Sie stellen Ihre Anfragen mit POJOs und erhalten POJOs als Anforderungsergebnisse.

3.Erzwingen Sie keine Einschränkungen, weder für POJOs, die für Anforderungen verwendet werden, noch für Aktivitätsklassen, die Sie in Ihren Projekten verwenden.

4.caches Ergebnisse (in Json mit Jackson und Gson oder Xml oder Flat-Text-Dateien oder Binärdateien, sogar mit ORM Lite).

5. Benachrichtigt Ihre Aktivitäten (oder einen anderen Kontext) über das Ergebnis der Netzwerkanforderung, wenn und nur wenn sie noch aktiv sind

6. Kein Android-Verlust, wie bei Android Loadern, im Gegensatz zu Android AsyncTasks benachrichtigt Ihre Aktivitäten in ihrem UI-Thread.

7. verwendet ein einfaches, aber robustes Ausnahmebehandlungsmodell.

Beispiele für den Anfang. https://github.com/octo-online/RoboSpice-samples .

Ein Beispiel für Robospice unter https://play.google.com/store/apps/details?id=com.octo.android.robospice.motivations&feature=search_result .

class Background implements Runnable {
    private CountDownLatch latch = new CountDownLatch(1);
    private  Handler handler;

    Background() {
        Thread thread = new Thread(this);
        thread.start();
        try {
            latch.await();
        } catch (InterruptedException e) {
           /// e.printStackTrace();
        }
    }

    @Override
    public void run() {
        Looper.prepare();
        handler = new Handler();
        latch.countDown();
        Looper.loop();
    }

    public Handler getHandler() {
        return handler;
    }
}

Wenn Sie einen Thread prädiotisch mit verschiedenen Codes ausführen müssen, ist hier ein Beispiel:

Hörer:

public interface ESLThreadListener {

    public List onBackground();

    public void onPostExecute(List list);

}

Thread-Klasse

public class ESLThread extends AsyncTask<Void, Void, List> {


    private ESLThreadListener mListener;

    public ESLThread() {

        if(mListener != null){

            mListener.onBackground();
        }
    }

    @Override
    protected List doInBackground(Void... params) {

        if(mListener != null){

            List list = mListener.onBackground();

            return list;
        }

        return null;
    }

    @Override
    protected void onPostExecute(List t) {
        if(mListener != null){

            if ( t != null) {
                mListener.onPostExecute(t);
            }
        }

    }


    public void setListener(ESLThreadListener mListener){

        this.mListener = mListener;
    }
}

Führen Sie verschiedene Codes aus:

  ESLThread thread = new ESLThread();
                        thread.setListener(new ESLThreadListener() {
                            @Override
                            public List onBackground() {
                                List<EntityShoppingListItems>  data = RoomDB.getDatabase(context).sliDAO().getSL(fId);

                                return data;

                            }

                            @Override
                            public void onPostExecute(List t) {

                                List<EntityShoppingListItems> data = (List<EntityShoppingListItems>)t;
                                adapter.setList(data);
                            }
                        });

                        thread.execute();