Qual è la differenza tra Handler, Runnable e Thread?

Qual è la differenza tra Handler, Runnable e Thread?

Mentre lavoravo con Android, e ho bisogno di qualcosa da eseguire in background. Io uso Threads per eseguirlo. Di solito scriverei una class che estende Thread e implementa il metodo run.

Ho anche visto alcuni esempi di impianti eseguibili e passabili in Threads.

Tuttavia sono ancora confuso. Qualcuno può darmi una spiegazione chiara?

  1. Qual è il punto di Runnable se si può scrivere il codice di background nel metodo di esecuzione di Thread?
  2. Come viene utilizzato il gestore all’interno del thread e perché è necessario utilizzarlo.
  3. Android ha un’altra cosa chiamata runOnUiThread, come la usiamo? So che è usato per aggiornare l’interfaccia utente.

    Perché usare Runnable over Thread?

    • Runnable separa il codice che deve essere eseguito in modo asincrono, da come viene eseguito il codice. Ciò mantiene flessibile il tuo codice. Ad esempio, il codice asincrono in un eseguibile può essere eseguito su un threadpool o su un thread dedicato.

      A Thread ha dichiarato che il tuo runnable probabilmente non ha bisogno di accedere a. Avere accesso a più stati del necessario è un design scadente.

      I thread occupano molta memoria. La creazione di un nuovo thread per ogni piccola azione richiede tempo di elaborazione per allocare e deallocare questa memoria.

    Cosa sta facendo runOnUiThread?

    • RunOnUiThread di Android mette in coda un Runnable da eseguire sul thread dell’interfaccia utente. Questo è importante perché non devi mai aggiornare l’interfaccia utente da più thread. runOnUiThread utilizza un Handler .

      Tieni presente che se la coda del thread dell’interfaccia utente è piena o se gli elementi che richiedono un’esecuzione sono lunghi, potrebbe trascorrere qualche tempo prima dell’esecuzione effettiva del Runnable coda.

    Cos’è un gestore?

    • Un gestore consente di pubblicare i runnables da eseguire su un thread specifico. Dietro le quinte, runOnUi Thread accoda il tuo Runnable con l’Ui Handler di Android in modo che il tuo runnable possa essere eseguito in sicurezza sul thread dell’interfaccia utente.

    1. Perché eseguire?

    Runnable è solo un’interfaccia di cui hai bisogno per istanziare un thread per contenerlo. Mentre thread contiene già la possibilità di generare un thread. Se estendi il thread non puoi estendere altro (Java non supporta l’ereditarietà multipla). Puoi avere più interfacce su una class, quindi potresti eseguire Runnable.

    Inoltre, quando si estende la class Thread, ciascun thread crea un object univoco e si associa ad esso. Quando implementi Runnable, condivide lo stesso object su più thread.

    2. Perché usare il gestore e cos’è?

    Handler è scritto in Java (usa internamente un Thread), quindi tutto ciò che puoi fare con Handler, puoi ottenere usando anche un Thread.

    Quindi perché dovresti usare Handler? La ragione è come sotto

    • Handler consente di inviare ed elaborare oggetti Message e Runnable associati a MessageQueue di un thread. Per dirla in termini semplici, il gestore semplifica il tuo lavoro.

    • Android ha due regole principali per la gestione dei thread:

    • Non bloccare il thread dell’interfaccia utente

    • Non accedere al kit di strumenti dell’interfaccia utente Android dall’esterno del thread dell’interfaccia utente

    Per bind le 2 regole sopra indicate, in Android abbiamo 3 metodi incorporati che possono gestire la situazione quando una delle tue classi di attività viene eseguita o chiamata da un thread diverso.

    Possiamo quindi pianificare gli aggiornamenti dell’interfaccia utente da eseguire sul thread dell’interfaccia utente con i seguenti tre metodi. L’attività o la vista funziona come gestore (più sui gestori di seguito) e pianifica il tuo runnable sul thread dell’interfaccia utente:

    1. Activity.runOnUiThread (Runnable)
      1. View.post (Runnable)
      2. View.postDelayed (Runnable, long) // (long = tempo di pianificazione)

    3. Che cos’è il thread UI?

    Il thread dell’interfaccia utente è il thread principale in cui vengono visualizzati gli elementi dell’interfaccia utente come View e Activity. Qualsiasi operazione che richiede tempo non dovrebbe accadere nel thread dell’interfaccia utente. L’applicazione predefinita viene eseguita in UI Thread. Non devi fare nulla di speciale per usare il thread UI.

    Handler, Runnable e Thread funzionano davvero insieme, non penso che dovresti confrontarli.

    handler

    consente di inviare messaggi tra due thread in modo sicuro, il che significa che l’invio di thread inserisce il messaggio nella coda di thread di destinazione e questa coda di destinazione elaborerà questo messaggio nel momento appropriato.

    Runnable

    questa è un’interfaccia che si implementa, in fase di implementazione si inserisce la logica che si desidera eseguire su alcuni thread. In realtà puoi usare Runnable anche in posti non correlati al thread. Un sacco di apis Java in realtà usano Runnable, non solo Thread. Puoi pubblicare Runnable usando il gestore o puoi usarlo con gli executors. I runnables sono belli perché li puoi implementare in una forma di implementazione anonima.

    UniThread

    hai inteso il thread dell’interfaccia utente? La maggior parte delle interfacce utente implementa il suo funzionamento in thread singolo, tutti gli elementi dell’interfaccia utente: windows / widget comunicano usando i messaggi (proprio come in Handler). Vale a dire. utente preme il pulsante, questo avvia un messaggio con le informazioni che il pulsante è stato premuto, viene inviato al thread dell’interfaccia utente e infine consegnato al listener.

    In Android è vietato (risultati in eccezione) modificare gli elementi dell’interfaccia utente da un thread non dell’interfaccia utente, questo ha senso: se lo si modificherà da un altro thread, ciò potrebbe accadere mentre il thread dell’interfaccia utente sta apportando alcune modifiche allo stesso widget, determinando un comportamento non definito .

    Qual è il punto di Runnable se si può scrivere il codice di background nel metodo di esecuzione di Thread?

    Runnable è un’interfaccia utilizzata per creare una nuova class thread simile alla class thread creata estendendo la class java.lang.Thread . L’unica differenza è che l’interfaccia Runnable consente alla class di estendere l’altra class (se necessario) per sovrascrivere / ereditare la funzionalità di alcune classi. L’estensione della class java.lang.Thread revocherà questa capacità.

    Inoltre, l’interfaccia Runnable rappresenta un’attività che può essere eseguita sia da Thread semplice che da Executor o qualsiasi altro mezzo. la separazione logica di Task come Runnable che Thread è una buona decisione di progettazione.

    Per saperne di più: http://javarevisited.blogspot.com/2012/01/difference-thread-vs-runnable-interface.html#ixzz2qgjDYJhT

    Io uso Threads per eseguirlo. Di solito scriverei una class che estende Thread e implementa il metodo run.

    1. Qual è il punto di Runnable se si può scrivere il codice di background nel metodo di esecuzione di Thread?

    Usare Runnable e creare un thread da Runnable è una pratica generale.

    Dal tutorial di oracle sulla concorrenza relativo all’uso del Thread Vs Runnable :

    L’object eseguibile è più generale, poiché l’object Runnable può creare una sottoclass di una class diversa da Thread.

    2.Come viene utilizzato il gestore interno del thread e perché è necessario utilizzarlo.

    È un argomento vasto da spiegare. In termini più semplici dal sito di documentazione ufficiale:

    1. Handler consente di inviare ed elaborare oggetti Message e Runnable associati a MessageQueue un thread. Ogni istanza di Handler è associata a un singolo thread e alla coda di messaggi di quel thread.

    2. Quando crei un nuovo Handler , viene associato alla coda thread / messaggi del thread che lo sta creando, da quel momento in poi invierà messaggi e runnables a quella coda di messaggi e li eseguirà non appena escono dal messaggio coda.

    3. Ci sono due usi principali per un Handler : (1) per pianificare i messaggi e le runnables da eseguire come un certo punto nel futuro; e (2) per accodare un’azione da eseguire su un thread diverso rispetto al proprio

    4. Quando viene creato un processo per l’applicazione, il suo thread principale è dedicato all’esecuzione di una coda di messaggi che si occupa della gestione degli oggetti dell’applicazione di livello superiore (attività, ricevitori broadcast, ecc.) E delle windows che creano. È ansible creare i propri thread e comunicare nuovamente con il thread dell’applicazione principale tramite un gestore. Questo viene fatto chiamando lo stesso metodo post o sendMessage come prima, ma dal tuo nuovo thread. Il Runnable o il Messaggio dato verrà quindi pianificato nella coda dei messaggi del Gestore ed elaborato quando appropriato.

    Questa foto dell’articolo di Anishar Ali di blog.mindorks.com spiega chiaramente i concetti.

    inserisci la descrizione dell'immagine qui

    3.Android ha un’altra cosa chiamata runOnUiThread, come la usiamo? So che è usato per aggiornare l’interfaccia utente.

    Puoi trovare maggiori dettagli esaminando l’implementazione di runOnUiThread

     /** * Runs the specified action on the UI thread. If the current thread is the UI * thread, then the action is executed immediately. If the current thread is * not the UI thread, the action is posted to the event queue of the UI thread. * * @param action the action to run on the UI thread */ public final void runOnUiThread(Runnable action) { if (Thread.currentThread() != mUiThread) { mHandler.post(action); } else { action.run(); } } 

    Fare riferimento al seguente post per esempio il codice di utilizzo del Handler .

    Android: toast in una discussione