Google lehnt die Android AsyncTask-API in Android 11 ab und schlägt die Verwendung vor java.util.concurrent stattdessen. Sie können sich das Commit ansehen Hier

 *
 * @deprecated Use the standard <code>java.util.concurrent</code> or
 *   <a href="https://developer.android.com/topic/libraries/architecture/coroutines">
 *   Kotlin concurrency utilities</a> instead.
 */
@Deprecated
public abstract class AsyncTask<Params, Progress, Result> {

Wenn Sie eine ältere Codebasis mit asynchronen Aufgaben in Android pflegen, müssen Sie diese wahrscheinlich in Zukunft ändern. Meine Frage ist, was der richtige Ersatz des unten gezeigten Code-Snippets sein sollte java.util.concurrent. Es ist eine statische innere Klasse einer Aktivität. Ich suche etwas, womit es funktioniert minSdkVersion 16

private static class LongRunningTask extends AsyncTask<String, Void, MyPojo> {
        private static final String TAG = MyActivity.LongRunningTask.class.getSimpleName();
        private WeakReference<MyActivity> activityReference;

        LongRunningTask(MyActivity context) {
            activityReference = new WeakReference<>(context);
        }

        @Override
        protected MyPojo doInBackground(String... params) {
            // Some long running task
            
        }

        @Override
        protected void onPostExecute(MyPojo data) {

            MyActivity activity = activityReference.get();
            activity.progressBar.setVisibility(View.GONE);
            populateData(activity, data) ;
        }     


    }

private WeakReference<MyActivity> activityReference;

Gute Befreiung, dass es veraltet ist, weil die WeakReference<Context> war immer ein Hack und keine richtige Lösung.

Jetzt haben die Leute die Möglichkeit, ihren Code zu bereinigen.

AsyncTask<String, Void, MyPojo> 

Basierend auf diesem Code, Progress wird eigentlich nicht benötigt, und es gibt eine String Eingang + MyPojo Ausgang.

Dies ist eigentlich ganz einfach ohne Verwendung von AsyncTask zu bewerkstelligen.

public class TaskRunner {
    private final Executor executor = Executors.newSingleThreadExecutor(); // change according to your requirements
    private final Handler handler = new Handler(Looper.getMainLooper());

    public interface Callback<R> {
        void onComplete(R result);
    }

    public <R> void executeAsync(Callable<R> callable, Callback<R> callback) {
        executor.execute(() -> {
            final R result = callable.call();
            handler.post(() -> {
                callback.onComplete(result);
            });
        });
    }
}

Wie übergebe ich den String? So:

class LongRunningTask implements Callable<MyPojo> {
    private final String input;

    public LongRunningTask(String input) {
        this.input = input;
    }

    @Override
    public MyPojo call() {
        // Some long running task
        return myPojo;
    }
}

Und

// in ViewModel
taskRunner.executeAsync(new LongRunningTask(input), (data) -> {
    // MyActivity activity = activityReference.get();
    // activity.progressBar.setVisibility(View.GONE);
    // populateData(activity, data) ;

    loadingLiveData.setValue(false);
    dataLiveData.setValue(data);
});

// in Activity
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.main_activity);

    viewModel = ViewModelProviders.of(this).get(MyViewModel.class);
    viewModel.loadingLiveData.observe(this, (loading) -> {
        if(loading) {
            progressBar.setVisibility(View.VISIBLE);
        } else {
            progressBar.setVisibility(View.GONE);
        }
    });

    viewModel.dataLiveData.observe(this, (data) -> {
        populateData(data);
    }); 
}

In diesem Beispiel wurde ein Single-Thread-Pool verwendet, der sich gut für DB-Schreibvorgänge (oder serialisierte Netzwerkanforderungen) eignet. Wenn Sie jedoch etwas für DB-Lesevorgänge oder mehrere Anforderungen benötigen, können Sie die folgende Executor-Konfiguration in Betracht ziehen:

private static final Executor THREAD_POOL_EXECUTOR =
        new ThreadPoolExecutor(5, 128, 1,
                TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());

Sie können direkt verwenden Executors von java.util.concurrent Paket.

Ich habe auch danach gesucht und darin eine Lösung gefunden Android Async API ist veraltet Post.

Leider verwendet der Beitrag Kotlin, aber nach ein wenig Mühe habe ich es in Java konvertiert. Hier ist also die Lösung.

ExecutorService executor = Executors.newSingleThreadExecutor();
Handler handler = new Handler(Looper.getMainLooper());

executor.execute(new Runnable() {
    @Override
    public void run() {

        //Background work here

        handler.post(new Runnable() {
            @Override
            public void run() {
                //UI Thread work here
            }
        });
    }
});

Ziemlich einfach oder? Sie können es etwas mehr vereinfachen, wenn Sie Java 8 in Ihrem Projekt verwenden.

ExecutorService executor = Executors.newSingleThreadExecutor();
Handler handler = new Handler(Looper.getMainLooper());

executor.execute(() -> {
    //Background work here
    handler.post(() -> {
        //UI Thread work here
    });
});

Dennoch kann es die Kotlin-Begriffe der Prägnanz des Codes nicht schlagen, aber besser als die vorherige Java-Version.

Ich hoffe, das wird Ihnen helfen. Danke

Eine der einfachsten Alternativen ist die Verwendung Thread

new Thread(new Runnable() {
    @Override
    public void run() {
        // do your stuff
        runOnUiThread(new Runnable() {
            public void run() {
                // do onPostExecute stuff
            }
        });
    }
}).start();

Wenn Ihr Projekt unterstützt JAVA8können Sie verwenden lambda:

new Thread(() -> {
    // do background stuff here
    runOnUiThread(()->{
        // OnPostExecute stuff here
    });
}).start();

Entsprechend der Android-Dokumentation AsyncTask war veraltet API-Level 30 und es wird empfohlen, die zu verwenden Standard java.util.concurrent oder Kotlin-Parallelitätsdienstprogramme stattdessen.

Mit letzterem kann es ziemlich einfach erreicht werden:

1. Erstellen Sie eine generische Erweiterungsfunktion an CoroutineScope:

    fun <R> CoroutineScope.executeAsyncTask(
            onPreExecute: () -> Unit,
            doInBackground: () -> R,
            onPostExecute: (R) -> Unit
    ) = launch {
        onPreExecute() // runs in Main Thread
        val result = withContext(Dispatchers.IO) { 
            doInBackground() // runs in background thread without blocking the Main Thread
        }
        onPostExecute(result) // runs in Main Thread
    } 
   

2. Verwenden Sie die Funktion mit jedem CoroutineScope:

   • Im ViewModel:

     class MyViewModel : ViewModel() {
     
         fun someFun() {
             viewModelScope.executeAsyncTask(onPreExecute = {
                 // ... runs in Main Thread
             }, doInBackground = {
                 // ... runs in Worker(Background) Thread
                 "Result" // send data to "onPostExecute"
             }, onPostExecute = {
                 // runs in Main Thread
                 // ... here "it" is the data returned from "doInBackground"
             })
         }
     }
     

   • Im Activity oder Fragment:

     lifecycleScope.executeAsyncTask(onPreExecute = {
         // ... runs in Main Thread
     }, doInBackground = {
         // ... runs in Worker(Background) Thread
         "Result" // send data to "onPostExecute"
     }, onPostExecute = {
         // runs in Main Thread
         // ... here "it" is the data returned from "doInBackground"
     })
     

   Benutzen viewModelScope oder lifecycleScope fügen Sie die nächste(n) Zeile(n) zu den Abhängigkeiten der App hinzu build.gradle Datei:

   implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$LIFECYCLE_VERSION" // for viewModelScope
   implementation "androidx.lifecycle:lifecycle-runtime-ktx:$LIFECYCLE_VERSION" // for lifecycleScope
   

   Zum Zeitpunkt des Schreibens final LIFECYCLE_VERSION = "2.3.0-alpha05"

AKTUALISIEREN:

Außerdem können wir die Fortschrittsaktualisierung mit implementieren onProgressUpdate Funktion:

fun <P, R> CoroutineScope.executeAsyncTask(
        onPreExecute: () -> Unit,
        doInBackground: suspend (suspend (P) -> Unit) -> R,
        onPostExecute: (R) -> Unit,
        onProgressUpdate: (P) -> Unit
) = launch {
    onPreExecute()

    val result = withContext(Dispatchers.IO) {
        doInBackground {
            withContext(Dispatchers.Main) { onProgressUpdate(it) }
        }
    }
    onPostExecute(result)
}

Beliebig verwenden CoroutineScope (siehe Implementierungen oben) können wir es nennen:

someScope.executeAsyncTask(
    onPreExecute = {
        // ... runs in Main Thread
    }, doInBackground = { publishProgress: suspend (progress: Int) -> Unit ->
        
        // ... runs in Background Thread

        // simulate progress update
        publishProgress(50) // call `publishProgress` to update progress, `onProgressUpdate` will be called
        delay(1000)
        publishProgress(100)

        
        "Result" // send data to "onPostExecute"
    }, onPostExecute = {
        // runs in Main Thread
        // ... here "it" is a data returned from "doInBackground"
    }, onProgressUpdate = {
        // runs in Main Thread
        // ... here "it" contains progress
    }
)

Verwenden Sie diese Klasse, um eine Hintergrundaufgabe im Hintergrundthread dieser Klasse auszuführen Funktioniert für alle Android-API-Versionen, einschließlich Android 11 Auch dieser Code ist die gleiche Arbeit wie AsyncTask mit doInBackground und onPostExecute Methoden

public abstract class BackgroundTask {

    private Activity activity;
    public BackgroundTask(Activity activity) {
        this.activity = activity;
    }

    private void startBackground() {
        new Thread(new Runnable() {
            public void run() {

                doInBackground();
                activity.runOnUiThread(new Runnable() {
                    public void run() {

                        onPostExecute();
                    }
                });
            }
        }).start();
    }
    public void execute(){
        startBackground();
    }

    public abstract void doInBackground();
    public abstract void onPostExecute();

}

Nachdem Sie die obige Klasse kopiert haben, können Sie sie dann damit verwenden:

new BackgroundTask(MainActivity.this) {
        @Override
        public void doInBackground() {

            //put you background code
            //same like doingBackground
            //Background Thread
        }

        @Override
        public void onPostExecute() {

            //hear is result part same
            //same like post execute
            //UI Thread(update your UI widget)
        }
    }.execute();

Hier habe ich eine Alternative für AsyncTask mit Coroutinen erstellt, die genauso wie AsyncTask verwendet werden kann, ohne viel Codebasis in Ihrem Projekt zu ändern.

1. Erstellen Sie eine neue abstrakte Klasse AsyncTaskCoroutine, die Eingabeparameter- und Ausgabeparameter-Datentypen verwendet. Diese Parameter sind natürlich optional 🙂

    import kotlinx.coroutines.Dispatchers
    import kotlinx.coroutines.GlobalScope
    import kotlinx.coroutines.async
    import kotlinx.coroutines.launch
   
    abstract class AsyncTaskCoroutine<I, O> {
        var result: O? = null
        //private var result: O
        open fun onPreExecute() {}
   
        open fun onPostExecute(result: O?) {}
        abstract fun doInBackground(vararg params: I): O
   
        fun <T> execute(vararg input: I) {
            GlobalScope.launch(Dispatchers.Main) {
                onPreExecute()
                callAsync(*input)
            }
        }
   
        private suspend fun callAsync(vararg input: I) {
            GlobalScope.async(Dispatchers.IO) {
                result = doInBackground(*input)
            }.await()
            GlobalScope.launch(Dispatchers.Main) {
   
                onPostExecute(result)
   
   
            }
        }
    }
   

2 . Innerhalb der Aktivität verwenden Sie dies jetzt genauso wie Ihre alte AsycnTask

 new AsyncTaskCoroutine() {
                @Override
                public Object doInBackground(Object[] params) {
                    return null;
                }
    
                @Override
                public void onPostExecute(@Nullable Object result) {
    
                }
    
                @Override
                public void onPreExecute() {
    
                }
            }.execute();

3. Falls Sie Pass-Parameter senden müssen

     new AsyncTaskCoroutine<Integer, Boolean>() {
   
        @Override
        public Boolean doInBackground(Integer... params) {
            return null;
        }
   
        @Override
        public void onPostExecute(@Nullable Boolean result) {
   
        }
   
        @Override
        public void onPreExecute() {
   
        }
    }.execute();
   

Android veraltet AsyncTask API in Android 11, um zunächst einen Teil der Probleme zu beseitigen.

Also, was ist jetzt?

• Fäden
• Vollstrecker
• RxJava
• Hörbare Zukunft
• Coroutinen 🔥

Warum Coroutinen?

Coroutinen sind die Kotlin-Methode zur asynchronen Programmierung. Die Compiler-Unterstützung ist seit Kotlin 1.3 stabil, zusammen mit a
kotlinx.coroutines Bücherei –

• Strukturierte Parallelität
• Nicht blockierender, sequentieller Code
• Stornierungsausbreitung
• Natürliche Ausnahmebehandlung