Starte AsyncTask aus einem anderen AsyncTask doInBackground()

Laut dem post weiter unten können Sie tun Aktivität.runOnUiThread() zum ausführen einer Runnable auf dem main-Thread (aus einem anderen thread).

• Ausführen von code in der main-thread aus einem anderen thread

Also theoretisch könnte man dies tun:

• Führen Sie die Async-Task
• tun Aktivität.runOnUiThread(Runnable) in Ihren AsyncTask und starten Sie eine neue AsyncTask aus dem inneren dieser Thread

Wie der name schon sagt-Aktivität.runOnUiThread() führt den Thread auf der main-thread

Aber es ist eine Art hacky.

Code sollte in etwa so Aussehen: (nicht test)

//first task
    (new AsyncTask<String, String, String>() {

        @Override
        protected String doInBackground(String... params) {
            ParentActitity.this.runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    //second async stared within a asynctask but on the main thread
                    (new AsyncTask<String, String, String>() {

                        @Override
                        protected String doInBackground(String... params) {
                            //TODO Auto-generated method stub
                            return null;
                        }

                    }).execute();

                }
            });
            return null;
        }

    }).execute();

Diese verschachtelte Beispiel ist kein guter Stil in der Produktion verwenden, weil (IMHO) seine Nähe nicht lesbar.

Zusätzliche Hinweise:

Aktivität.runOnUiThread(Runnable) ist nicht statische! Thats, warum mein Beispiel verwendet ParentActivity(.diese).runOnUiThread(Runnable).

Können Sie es nicht in doInBackground() aber man kann von onProgressUpdate() zum Beispiel, da läuft es auf dem UI-thread. Nur Bedenken Sie, dass nach 3.0 werden Sie setzen auf der gleichen Warteschlange und wird nicht parallel ausgeführt werden, siehe executeOnExecutor

Im Grunde Probe, die ich geschrieben habe;

public class MainActivity extends Activity {

View view;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    view = new View(this);
    setContentView(view);

    view.setBackgroundColor(Color.RED);

    new FirstTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, null);
}

private class FirstTask extends AsyncTask<Void, Void, Void>
{
    @Override
    protected Void doInBackground(Void... params) {

        new SecondTask().execute();
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
        }
        Log.e("task","first");
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        view.setBackgroundColor(Color.GREEN);   
    }

}

private class SecondTask extends AsyncTask<Void, Void, Void>
{
    @Override
    protected Void doInBackground(Void... params) {
        Log.e("task","second");
        return null;
    }
}

}

ist es nicht besser, diese paar inet Aktionen und beteiligt Sie durch starten Sie einen separaten Thread, behandelt dieser Teil der Daten-management ?
google überall gesagt ist es Muster, die, wenn u look am nächsten-Sie alle sind abgeleitet von der einfachen Klassen... diese API lässt android wie ein spider-web-callback mit Rückruf... Versuchen Sie zu verstehen, die Grundlagen von java und es wird nicht schwer sein, zu schreiben, ein Stück, guten code. Dienstleistungen/content Resolver/Empfänger/Lader begrenzt sind irgendwie... Threads sind fast in der Lage, etwas zu erreichen, was u wollen...

Meisten von Euch verwendet den code, ohne zu denken, und nicht einmal versuchen zu verstehen, wie es funktioniert, und zu verstehen, was die Programmier-Taste. Ich versuche, nicht zu verwenden code, dessen Grundlagen ich weiß nicht. Und wenn ich muss, ich studierte es gründlich. Ich verwendet Java für die schwarze Magie jetzt denke ich, es ist, Datenfluss, EIN-> B-> C, etc .. gute STRÖMUNG ist wichtig.

EDIT:

ja, ich habe die Lösung für Sie-problem

gibt es viele Möglichkeiten, um zu erreichen, dass das, was u wollen, aber es ist nicht meine Antwort auf Schriftsteller-code für Sie

• können Sie IntentService Klasse es hat einen built-in Warteschlange --- benutzen Sie einfach ein separates startService () - Aufrufe für jede übertragung.

• können Sie Thread - meine bevorzugte Art

• können Sie Service

• können Sie AsyncTaskLoader

• aber nicht verwenden ASYNC TASK, wenn u brauchen Feuer mehr als ZWEI miteinander verbunden und auf EINMAL Sie alle auf MODERNEN HANDYS LÄUFT, wie die WARTESCHLANGE auf einem einzigen thread (ps. Sie können führen Sie auf EXECUOR als workaround)

Seit JAVA 1.5 Aufgaben sind getrennt von threads
- es wurde Hinzugefügt,

was du meinst mit custom thread

THREAD (wie wir sprechen) ist keine THREAD-KLASSE-OBJEKT, aber es ist eine AUFGABE definiert, in die run () - Methode der THREAD-KLASSE, so dass jede KLASSE, ABGELEITET von THREAD NOCH STARTET THREAD (aka TASK)

    public synchronized void start() {
        checkNotStarted();

        hasBeenStarted = true;
        /** 
         * look at this line i'ts rerouting run() code of youre thread class  
         * to native method from there thread is created in pure C code 
         */
        nativeCreate(this, stackSize, daemon);
    }

wie dies zum Beispiel in POSIX :

int  pthread_create(pthread_t  *  thread, pthread_attr_t * attr, void *
   (*start_routine)(void *), void * arg);

ab diesem Punkt können wir reden MULTITASKING, wenn OS ist die Durchführung mehrerer Aufgaben über einen bestimmten Zeitraum, indem Sie ausführt, die gleichzeitig

seit JAVA 1.5 ther ist ein Executor interface, die bietet eine Möglichkeit der Entkopplung der Aufgabe, Veröffentlichungen aus der mechanik, wie jede Aufgabe ausgeführt werden, einschließlich der Einzelheiten der thread nutzen, Terminierung, etc. Testamentsvollstrecker ist in der Regel verwendet, anstatt explizit erstellen von threads. Sie haben viele Vollzieher einer von Ihnen ist: ThreadPerTaskExecutor

class ThreadPerTaskExecutor implements Executor {
      public void execute(Runnable r) {
          new Thread(r).start();
      }
  }

Diesem executor erzeugt einen neuen thread für jede Aufgabe.

immer wieder zu AsyncTask:

AsyncTaskM<P, P, R>.executeOnExecutor(Executor,P);

ermöglichen, mehrere Aufgaben laufen parallel auf einen pool von threads verwaltet, die von AsyncTask, aber Sie können auch Ihre eigenen Vollstrecker für custombehavior.

und ja, wenn Sie nicht das Gefühl bis zu es und nicht genug wissen beeter, um jemand anderes zu tun es 🙂

Ich hoffe, dass dieser Zusatz ändern Ihre Meinung über Ihre Abstimmung.