Come riprodurre AsyncTask da Android in Java codice puro

Question

Sto provando a riprodurre la stessa logica che AsyncTask di Android segue nel codice puro Java.

Per fare ciò ho creato la classe astratta AsyncTask che implementa il mio IAsynTask che fondamentalmente chiama onPreExecute, doInBackground e onPostExecute, inoltre ho creato il metodo execute dove avviene la magia.

Quindi, per utilizzarlo nel mio processo di login, ad esempio, ho creato la classe LoginTask che estende AsyncTask, ma a differenza di quanto avevo immaginato l'implementazione di onPreExecute, doInBackground e onPostExecute non sembrano obbligatori. Che cosa sto facendo di sbagliato?

Inteface:

public interface IAsyncTask { 

    public void onPreExecute(); 
    public void doInBackground(); 
    public void onPostExecute(); 

} 

Classe:

public abstract class AsyncTask implements IAsyncTask{ 

    public void onPreExecute() { 

    } 

    public void doInBackground(){ 

    } 

    public void onPostExecute() { 

    } 

    public void execute() { 

     onPreExecute(); 

     new Thread(new Runnable() { 
      @Override 
      public void run() { 

       doInBackground(); 

       Platform.runLater(new Runnable() { 
        @Override 
        public void run() { 
         onPostExecute(); 
        } 
       }); 
      } 
     }).start(); 
    } 
} 

[Modificato]

Con le mie domande su JavaFX Ho notato che molti sviluppatori più recenti si trovano ad affrontare problematiche gestione Fili. Vorrei condividere ciò che ho fatto per semplificare la mia vita sulla gestione dei thread su javafx. Ho creato una classe AsyncTask basata su AsyncTask di Android che fondamentalmente fa la stessa cosa di Android in modo umile ma efficace. È possibile trovare ulteriori informazioni su di esso su Github project

Answer 1

Mi dispiace se non ho potuto spiegare cosa esattamente volevo, ma dopo aver visto il mio codice capirete. Ho appena aggiunto un identificatore abstrac nei miei metodi e ottenuto ciò che volevo. Potrebbe sembrare un problema per principianti, ma penso che possa essere usato per semplificare alcune semplici operazioni senza gestire direttamente i thread.

Quello che ho fatto a riprodurre un semplice AsyncTask utilizzando Java e il codice JavaFX:

creare una classe AsyncTask astratta

public abstract class AsyncTask { 

    abstract void onPreExecute(); 

    abstract void doInBackground(); 

    abstract void onPostExecute(); 

    public void execute() { 

     onPreExecute(); 

     new Thread(new Runnable() { 
      @Override 
      public void run() { 

       doInBackground(); 

       //Platform.runLater is a javafx code that executes onPost in Main Thread. 
       Platform.runLater(new Runnable() { 
        @Override 
        public void run() { 
         onPostExecute(); 
        } 
       }); 
      } 
     }).start(); 
    } 
} 

estenderlo dalla nostra classe lavoratrice

public class LoginTask extends AsyncTask { 

    @Override 
    void onPreExecute() { 

     //Some code to preexecute in Main Thread 
     System.out.println("OnPreExecute - Main Thread: " + Platform.isFxApplicationThread()); 
    } 

    @Override 
    void doInBackground() { 

     //Some code to execute in background thread as internet requests 
     System.out.println("doInBackground - Main Thread: " + Platform.isFxApplicationThread()); 
    } 

    @Override 
    void onPostExecute() { 

     //Some code to execute in Main thread after background process has done, like update a view 
     System.out.println("onPostExecute - Main Thread: " + Platform.isFxApplicationThread());   
    } 

} 

Chiamarla puoi fare:

LoginTask taskTest = new LoginTask(); 
taskTest.execute(); 

e il tuo registro sarà:

OnPreExecute - Main Thread: true 
doInBackground - Main Thread: false 
onPostExecute - Main Thread: true 

Answer 2

AsyncTask è al suo interno, una discussione. È un thread che inizia in un altro thread arbitrario (ma di solito il principale), svolge il suo compito e quindi delega un'attività di post al thread che lo ha generato (come ho detto, in genere il thread principale).

Il problema che si sta verificando mentre si lavora su questo progetto è la classe Handler che gestisce (!) Questa funzionalità di delega thread che ho menzionato sopra. Handler è una caratteristica fondamentale di Android che consente la delega delle attività non-thread al thread in cui è stato creato. Per implementare una sorta di AsyncTask Java, è necessario aggiungere un'API di delega thread che in sostanza funzioni come Handler .