Autore Topic: Esecuzioni Parallele di due AsyncTask  (Letto 2663 volte)

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Esecuzioni Parallele di due AsyncTask
« il: 16 Dicembre 2011, 18:20:06 CET »
0
Salve a tutti,
ho una curiosità da chiedervi. Sto lavorando su un'applicazione client FTP. Avrei la necessità di scaricare degli elementi da un server FTP.
Dovrei inoltre effettuare una prova di Download di uno stesso file da parte di due Thread diversi. Per questo motivo mi è venuto in mente AsyncTask. Ora però sarebbe possibile avviare "in contemporanea" due AsyncTask?
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline gnamgnam

  • Nuovo arrivato
  • *
  • Post: 35
  • Respect: +1
    • Mostra profilo
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #1 il: 17 Dicembre 2011, 11:27:38 CET »
+1
asynctask sono dei thread e penso che sia impossibile farli partire contemporaneamente ...proprio perchè sono thread dipende da quando verranno schedulati... ripensando a cio' che penso tu debba simulare ..  è il download di un file, che più utenti scaricano in parallelo ... ma logicamente se usi una sola app che ha più thread che scaricano il file sarà sempre uno alla volta dei tuoi thread che scarica il file .. forse dovresti avere la stessa app che gira su dispositivi diversi in modo che si abbia un vero parallelismo.

Offline Ricky`

  • Amministratore
  • Utente storico
  • *****
  • Post: 3489
  • Respect: +506
    • Github
    • Google+
    • rciovati
    • Mostra profilo
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #2 il: 17 Dicembre 2011, 12:39:12 CET »
+1
Per il download di un file ti conviene usare un apposito Service piuttosto che un AsyncTask che girerebbe vincolato all'Activity che l'ha creato.
Io, comunque, se fossi in te, valuterei di utilizzare un IntentService perchè automaticamente esegue un task alla volta accodando quelli che gli arrivano. In questo modo avresti la possibilità di fare un download alla volta e gestire "gratis" una coda di download.

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #3 il: 17 Dicembre 2011, 13:15:22 CET »
0
Vi ringrazio il supporto e i suggerimenti che mi avete dato.
In realtà quello che devo fare è per me sconosciuto. Perchè mi è stato esplicitamente richiesto (se fosse possibile) di generare due thread su un'applicazione che scaricano lo stesso file.
Quindi nel caso potrei anche utilizzare un Service, anche se vorrei la barra di scaricamento visualizzata sul display.
Ho letto queste righe:  http://developer.android.com/reference/android/os/AsyncTask.html#THREAD_POOL_EXECUTOR
si parla di eseguire task paralleli se non sbaglio.

Una domanda per chi ne sa qualcosa. Ho il server FTP che naturalmente mi indica la velocità di download corrente, il tempo rimanente di download e la velocità media di download. Avete un'idea di come sapere lato client a che velocità si sta scaricando???
Grazie dell'attenzione
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #4 il: 21 Dicembre 2011, 10:47:51 CET »
0
Ho fatto un tentativo per verificare se effettivamente chiamando più AsyncTask venivano eseguiti in parallelo. La risposta sembra essere positiva. Questo è il pezzo di codice che richiama il tutto. Nel debug ho appurato che le immagini venivano scaricate in maniera schedulare (i thread alternavano le loro esecuzioni). Quindi esiste il parallelismo nell'AsyncTask.
L'unica pecca è che la progress dialog funziona solo per un thread, mentre per le altre non viene proprio considerato.
Allora perchè nel mio client FTP ho eccezioni su eccezioni?
Codice (Java): [Seleziona]
public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        startBtn = (Button)findViewById(R.id.startBtn);
        startBtn.setOnClickListener(new OnClickListener(){
            public void onClick(View v) {
                startDownload();
            }
        });
    }

/* Semplice metodo che crea nuovi AsyncTask e li esegue */
    private void startDownload() {
        String url1 = "http://farm1.static.flickr.com/114/298125983_0e4bf66782_b.jpg";
        String url2 = "http://img.archiexpo.it/images_ae/photo-m2/sedie-design-pop-59102.jpg";
        String url3 = "http://www.onstageweb.com/wp-content/uploads/2011/12/Tiziano-Ferro-L-Amore-E-Una-Cosa-Semplice-Cover.jpeg";
        downloadFileAsync1 = new DownloadFileAsync();
        downloadFileAsync2 = new DownloadFileAsync();
        downloadFileAsync3 = new DownloadFileAsync();
        downloadFileAsync1.execute(url1);
        downloadFileAsync2.execute(url2);
        downloadFileAsync3.execute(url3);
    }
   
    /* Metodo di creazione della dialog di caricamento */
    @Override
    protected Dialog onCreateDialog(int id) {
        switch (id) {
            case DIALOG_DOWNLOAD_PROGRESS:
                mProgressDialog = new ProgressDialog(this);
                mProgressDialog.setMessage("Downloading in Progress...");
                mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
                mProgressDialog.setCancelable(false);
                mProgressDialog.show();
                return mProgressDialog;
            default:
                return null;
        }
    }
   
    /* Classe interna che estende AsyncTask per utilizzarne le funzionalità */
    private class DownloadFileAsync extends AsyncTask<String, String, String> {
       
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            showDialog(DIALOG_DOWNLOAD_PROGRESS);
        }

        @Override
        protected String doInBackground(String... aurl) {
            int count;

            try {
                URL url = new URL(aurl[0]);
                URLConnection conexion = url.openConnection();
                conexion.connect();
                int lenghtOfFile = conexion.getContentLength();
                Log.d("ANDRO_ASYNC", "Lenght of file: " + lenghtOfFile);
                InputStream input = new BufferedInputStream(url.openStream());
                OutputStream output = new FileOutputStream("/sdcard/"+aurl[0].substring(5, 10));
                byte data[] = new byte[1024];
                long total = 0;
                Log.i("AND SYNC", "nome file: " + aurl[0]);
                while ((count = input.read(data)) != -1) {
                    total += count;
                    publishProgress(""+(int)((total*100)/lenghtOfFile));
                    Log.d("Andro_Async", aurl[0].substring(0, 15)+" "+(int)((total*100)/lenghtOfFile) );
                    output.write(data, 0, count);
                }
                output.flush();
                output.close();
                input.close();
               
            } catch (Exception e) { e.printStackTrace(); }
            return null;

        }
        protected void onProgressUpdate(String... progress) {
             //Log.d("ANDRO_ASYNC",progress[0]);
             mProgressDialog.setProgress(Integer.parseInt(progress[0]));
        }

        @Override
        protected void onPostExecute(String unused) {
            dismissDialog(DIALOG_DOWNLOAD_PROGRESS);
        }
    }

Questa per chi non credesse è la prova:
La prima immagine era piccola e l'ha scaricata subito. Queste due si alternano a ritmi irregolari. Il numero rappresenta la percentuale di quanto ha scaricato fino a quel momento.
N.B: l'esecuzione parallela fino a 5 AsyncTask è resa possibile solo da Android 1.6 (DONUT) fino a Android 2.3 (GINGERBREAD). Le altre versioni di Android permettono solo l'accodamento degli AsyncTask.
Codice: [Seleziona]

12-21 09:33:56.643: D/Andro_Async(404): http://www.onst 14
12-21 09:33:56.643: D/Andro_Async(404): http://farm1.st 73
12-21 09:33:56.643: D/Andro_Async(404): http://www.onst 14
12-21 09:33:56.653: D/Andro_Async(404): http://farm1.st 73
12-21 09:33:56.653: D/Andro_Async(404): http://www.onst 14
12-21 09:33:56.653: D/Andro_Async(404): http://farm1.st 73
12-21 09:33:56.653: D/Andro_Async(404): http://farm1.st 73
12-21 09:33:56.653: D/Andro_Async(404): http://www.onst 14
12-21 09:33:56.663: D/Andro_Async(404): http://www.onst 15
12-21 09:33:56.663: D/Andro_Async(404): http://farm1.st 74
12-21 09:33:56.673: D/Andro_Async(404): http://farm1.st 74
12-21 09:33:56.673: D/Andro_Async(404): http://farm1.st 74

« Ultima modifica: 21 Dicembre 2011, 12:01:00 CET da alexAndroid »
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #5 il: 17 Gennaio 2012, 16:44:51 CET »
0
Ripropongo alla vostra attenzione questa sezione che potrebbe interessare a qualcuno.
Ho personalmente appurato che possono essere lanciate più istanze di AsyncTask e che esse vengono eseguite in maniera parallela. Questo nel caso in cui effettuo delle operazioni con il protocollo HTTP (vedi post precedente).

Ma nel contesto di FTP perchè più AsyncTask sequenziali funzionano, mentre se provo a lanciarli tutti insieme non funzionano, generando sempre delle eccezioni?
Riepilogo sulle soluzioni usate:
  • Server FTP: TYPSoft FTP Server
  • Android Version: Froyo 2.2
  • Uso di FTPClient da org.apache.commons.net.ftp.FTPClient

Questa è una parte di codice per rendervi più chiaro lo scenario
Codice (Java): [Seleziona]
protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.ftp_manage);
                connect("Credenziali di accesso");
                startDownload("NomeDelFileSulServer");
}

private void startDownload(String fileName) {
                // Creo un nuovo task di AsyncTask.
        downloadFileAsync1 = new DownloadFileAsync();
        downloadFileAsync2 = new DownloadFileAsync();
              // Eseguo gli AsyncTask appena creati scaricando dal server FTP il file fileName due volte.
        downloadFileAsync1.execute(fileName);
        downloadFileAsync2.execute(fileName);
    }

/** Classe interna che estende una classe AsyncTask per poter essere utilizzata
         * @author alex
         */

        class DownloadFileAsync extends AsyncTask<String, String, String> {
               
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            showDialog(DIALOG_DOWNLOAD_PROGRESS);
        }

        @Override
        protected String doInBackground(String... params) {
            int count;
            String desFilePath = destinationFolder.getPath()+"/"+ params[0] ;
            Log.i("ASYNC", "Percorso destinazione: " + desFilePath);
            Log.i(APPNAME, "Lunghezza del file: "+fileLength1+" Nome File: ."+params[0]+".");
           
            try {
                    Log.i(APPNAME, "Prima di InputStream: "+ clientFTP.getFtp().getReplyString());
                    FileOutputStream outputStream = new FileOutputStream(desFilePath);
                    InputStream inputStream = clientFTP.getFtp().retrieveFileStream(params[0]);
                    Log.i(APPNAME, "Dopo InputStream " + clientFTP.getFtp().getReplyString() );
                   if (inputStream == null) { // Se l'inputStream è vuoto allora ritorna al chiamante
                      Log.i(APPNAME, "Non è possibile recuperare il file: " + params[0] );
                      return null;
                }
                 
                byte data[] = new byte[1024];
                long total = 0;
                while ((count = inputStream.read(data)) != -1) {
                    total += count;
                    publishProgress(""+(int)((total*100) / fileLength1));
                    outputStream.write(data, 0, count);
                }
                outputStream.flush();
                outputStream.close();
                inputStream.close();
                 
            } catch(FileNotFoundException e1) {
                 Log.d(APPNAME, "Errore: file non trovato");
                 e1.printStackTrace(); e1.getMessage(); e1.getCause();
            } catch(CopyStreamException e2) {
                 Log.d(APPNAME, "Errore nel trasferimento file");
                 e2.printStackTrace();
            } catch (IOException e3) {
                Log.d(APPNAME, "Errore: Download fallito");
                Log.d(APPNAME, "La causa del fallimento è:");
                e3.getCause();
                Log.d(APPNAME, "stackTrace dell'eccezione: ");
                e3.printStackTrace();
              }
            finally {
                   try {
                           if (clientFTP.getFtp() != null) {
                                   Log.i(APPNAME, "Prima PendingCommand " + clientFTP.getFtp().getReplyString() );
                                   clientFTP.getFtp().completePendingCommand();
                                   Log.i(APPNAME, "Dopo PendingCommand " + clientFTP.getFtp().getReplyString() );
                           }
                    } catch (IOException e4) {
                                  Log.d(APPNAME, "Errore in completePendingCommand()");
                                  e4.printStackTrace();
                    }
            }
            return null;
        }
       
        protected void onProgressUpdate(String... progress) {
                int progresso = Integer.parseInt(progress[0]);
            mProgressDialog.setProgress(progresso);
            mProgressDialog.setMessage("Scaricati: " + (progresso*fileLength1)/100 + " / " +
                        fileLength1 +"\n velocità: ");
       }  

       @Override
       protected void onPostExecute(String unused) {
           dismissDialog(DIALOG_DOWNLOAD_PROGRESS);
           Log.i("Andro_Async","AsyncTask1: "+ downloadFileAsync1.getStatus()+".");
           Log.i("Andro_Async","AsyncTask2: "+ downloadFileAsync2.getStatus()+".");
           
       }
   }

Mentre questo è il LOGCAT che ne viene fuori da una generica esecuzione dell'applicazione:
Codice: [Seleziona]
01-17 16:43:06.321: I/ASYNC(5836): Percorso destinazione: /mnt/sdcard/FTPClient/b
01-17 16:43:06.321: I/FTPManageActivity(5836): Lunghezza del file: 13739 Nome File: .b.
01-17 16:43:06.321: I/ASYNC(5836): Percorso destinazione: /mnt/sdcard/FTPClient/a
01-17 16:43:06.331: I/FTPManageActivity(5836): Lunghezza del file: 13739 Nome File: .a.
01-17 16:43:06.331: I/FTPManageActivity(5836): Local Port: 38923
01-17 16:43:06.331: I/FTPManageActivity(5836): Local Port: 38923
01-17 16:43:06.331: I/FTPManageActivity(5836): Passive Port: 59049
01-17 16:43:06.331: I/FTPManageActivity(5836): Remote Port: 3000
01-17 16:43:06.331: I/FTPManageActivity(5836): Passive Port: 59049
01-17 16:43:06.331: I/FTPManageActivity(5836): Remote Port: 3000
01-17 16:43:06.331: I/FTPManageActivity(5836): DataConnectionMode: 2
01-17 16:43:06.341: I/FTPManageActivity(5836): DataConnectionMode: 2
01-17 16:43:06.341: I/FTPManageActivity(5836): Prima di InputStream: 226 Transfer complete.
01-17 16:43:06.341: I/FTPManageActivity(5836): Prima di InputStream: 226 Transfer complete.
01-17 16:43:06.461: D/FTPManageActivity(5836): Errore: Download fallito
01-17 16:43:06.461: D/FTPManageActivity(5836): La causa del fallimento è:
01-17 16:43:06.461: D/FTPManageActivity(5836): stackTrace dell'eccezione:
01-17 16:43:06.461: W/System.err(5836): java.net.ConnectException: /192.168.1.60:52405 - Connection refused
01-17 16:43:06.461: W/System.err(5836):         at org.apache.harmony.luni.net.PlainSocketImpl.connect(PlainSocketImpl.java:254)
01-17 16:43:06.461: W/System.err(5836):         at org.apache.harmony.luni.net.PlainSocketImpl.connect(PlainSocketImpl.java:219)
01-17 16:43:06.461: W/System.err(5836):         at java.net.Socket.startupSocket(Socket.java:800)
01-17 16:43:06.461: W/System.err(5836):         at java.net.Socket.tryAllAddresses(Socket.java:194)
01-17 16:43:06.471: W/System.err(5836):         at java.net.Socket.<init>(Socket.java:258)
01-17 16:43:06.481: I/FTPManageActivity(5836): Dopo InputStream 150 Opening data connection for b.
01-17 16:43:06.481: W/System.err(5836):         at java.net.Socket.<init>(Socket.java:222)
01-17 16:43:06.491: W/System.err(5836):         at javax.net.DefaultSocketFactory.createSocket(DefaultSocketFactory.java:41)
01-17 16:43:06.491: W/System.err(5836):         at org.apache.commons.net.ftp.FTPClient._openDataConnection_(FTPClient.java:502)
01-17 16:43:06.491: W/System.err(5836):         at org.apache.commons.net.ftp.FTPClient.retrieveFileStream(FTPClient.java:1333)
01-17 16:43:06.491: W/System.err(5836):         at prova.ftp.FtpManageActivity$DownloadFileAsync.doInBackground(FtpManageActivity.java:336)
01-17 16:43:06.491: W/System.err(5836):         at prova.ftp.FtpManageActivity$DownloadFileAsync.doInBackground(FtpManageActivity.java:1)
01-17 16:43:06.491: W/System.err(5836):         at android.os.AsyncTask$2.call(AsyncTask.java:185)
01-17 16:43:06.511: W/System.err(5836):         at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:305)
01-17 16:43:06.521: W/System.err(5836):         at java.util.concurrent.FutureTask.run(FutureTask.java:137)
01-17 16:43:06.531: W/System.err(5836):         at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1068)
01-17 16:43:06.561: W/System.err(5836):         at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:561)
01-17 16:43:06.581: W/System.err(5836):         at java.lang.Thread.run(Thread.java:1096)
01-17 16:43:06.601: I/FTPManageActivity(5836): Prima PendingCommand 150 Opening data connection for b.
01-17 16:43:06.631: I/FTPManageActivity(5836): Dopo PendingCommand 226 Transfer complete.
01-17 16:43:06.651: I/FTPManageActivity(5836): Prima PendingCommand 226 Transfer complete.
01-17 16:43:06.761: I/Andro_Async(5836): AsyncTask1: RUNNING.
01-17 16:43:06.761: I/Andro_Async(5836): AsyncTask2: RUNNING.

Grazie a chi potesse darmi una mano
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline bradipao

  • Moderatore globale
  • Utente storico
  • *****
  • Post: 4043
  • keep it simple
  • Respect: +567
    • Github
    • Google+
    • bradipao
    • Mostra profilo
  • Dispositivo Android:
    Nexus 5
  • Play Store ID:
    Bradipao
  • Sistema operativo:
    W7
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #6 il: 17 Gennaio 2012, 17:06:49 CET »
0
Non conosco minimamente il client che usi, ma se dovessi tirare ad indovinare, secondo me org.apache.commons.net.ftp.FTPClient non è thread-safe.
NON rispondo a domande nei messaggi privati
Bradipao @ Play Store

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #7 il: 17 Gennaio 2012, 17:09:50 CET »
0
Non ti stupire, ma cosa implica che non è Thread-Safe???
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline bradipao

  • Moderatore globale
  • Utente storico
  • *****
  • Post: 4043
  • keep it simple
  • Respect: +567
    • Github
    • Google+
    • bradipao
    • Mostra profilo
  • Dispositivo Android:
    Nexus 5
  • Play Store ID:
    Bradipao
  • Sistema operativo:
    W7
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #8 il: 17 Gennaio 2012, 17:16:12 CET »
+1
Non ti stupire, ma cosa implica che non è Thread-Safe???

Significa sostanzialmente che l'oggetto non è predisposto per essere usato contemporaneamente in più thread, ma solo in uno alla volta.

E' una caratteristica che viene sempre evidenziata nella documentazione delle librerie, quindi se fai qualche ricerca nel manuale dell'oggetto lo trovi.
NON rispondo a domande nei messaggi privati
Bradipao @ Play Store

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #9 il: 17 Gennaio 2012, 17:22:59 CET »
0
Ti ringrazio per avermi reso noto delle conseguenze del termine Thread-Safe.
La classe FTPClient è sottoclasse di:
-java.lang.Object
  -extended by org.apache.commons.net.SocketClient
      -extended by org.apache.commons.net.ftp.FTP
          -extended by org.apache.commons.net.ftp.FTPClient
Ed in nessun punto della documentazione di tali classi compare la parola "Thread" oppure "safe".

Perciò si può dedurre che lo sia?!?
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline bradipao

  • Moderatore globale
  • Utente storico
  • *****
  • Post: 4043
  • keep it simple
  • Respect: +567
    • Github
    • Google+
    • bradipao
    • Mostra profilo
  • Dispositivo Android:
    Nexus 5
  • Play Store ID:
    Bradipao
  • Sistema operativo:
    W7
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #10 il: 17 Gennaio 2012, 17:33:21 CET »
+1
Ho trovato questo, vedi se si applica al tuo caso:

Citazione
Q: Are the Commons-Net classes thread-safe? For example, can you have multiple instances of FTPClient, each with its own thread running inside?

A: Multiple instances of FTPClient can be used to connect to multiple (or the same) FTP server and concurrently retrieve files. If you want to share a single FTPClient instance between multiple threads, you must serialize access to the object with critical sections.

Net/FrequentlyAskedQuestions - Commons Wiki
NON rispondo a domande nei messaggi privati
Bradipao @ Play Store

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #11 il: 17 Gennaio 2012, 17:56:06 CET »
0
Sembra fare proprio al caso mio:
Se voglio condividere una singola istanza FTPClient fra diversi threads, è necessario serializzare l'accesso agli oggetti con delle sezioni critiche.
Mmm dato che non è in mia conoscenza serializzare l'accesso ad oggetti con sezioni critiche, proverò intanto ad istanziare due oggetti FTPClient.
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #12 il: 17 Gennaio 2012, 18:24:32 CET »
0
Preso dalla curiosità ho visto questo link:
 http://java.html.it/faq/leggi/372/quando-viene-utilizzata-la-parola-riservata-synchronized/
Allorchè ho pensato di utilizzare la parola riservata synchronized ai metodi di AsyncTask doInBackground e OnProgressUpdate.
Risultato è lo STALLO più totale. L'applicazione è bloccata O.o  :-o
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline bradipao

  • Moderatore globale
  • Utente storico
  • *****
  • Post: 4043
  • keep it simple
  • Respect: +567
    • Github
    • Google+
    • bradipao
    • Mostra profilo
  • Dispositivo Android:
    Nexus 5
  • Play Store ID:
    Bradipao
  • Sistema operativo:
    W7
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #13 il: 17 Gennaio 2012, 18:36:38 CET »
+1
Non devi sincronizzare gli asynctask, devi semplicemente farti una coda degli oggetti da scaricare e farli scaricare ad un unico client uno alla volta... questo é serializzare.

Altrimenti dicono di istanziare due client.
NON rispondo a domande nei messaggi privati
Bradipao @ Play Store

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Esecuzioni Parallele di due AsyncTask
« Risposta #14 il: 18 Gennaio 2012, 18:11:42 CET »
0
Perfetto!!!
Utilizzando due istanze diverse di FTPClient e modificando un pò il codice (specie gli AsyncTask a cui devo far capire se il file attualmente in download appartiene al primo o al secondo FTPClient) sono riuscito ad ottenere  l'esecuzione parallela di due AsyncTask che lavorano a livello di FTP.
Grazie Infinite dell'aiuto bradipao.

P.S: setto il post come risolto, ma vorrei in definitiva istanziare un unico FTPClient utilizzando due AsyncTask.
« Ultima modifica: 18 Gennaio 2012, 18:13:40 CET da alexAndroid »
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.