new Runnable() ma nessun nuovo thread?

Question

sto cercando di capire il codice here, in particolare la classe anonima

private Runnable mUpdateTimeTask = new Runnable() { 
public void run() { 
    final long start = mStartTime; 
    long millis = SystemClock.uptimeMillis() - start; 
    int seconds = (int) (millis/1000); 
    int minutes = seconds/60; 
    seconds  = seconds % 60; 

    if (seconds < 10) { 
     mTimeLabel.setText("" + minutes + ":0" + seconds); 
    } else { 
     mTimeLabel.setText("" + minutes + ":" + seconds);    
    } 

    mHandler.postAtTime(this, 
      start + (((minutes * 60) + seconds + 1) * 1000)); 
    } 
}; 

L'articolo dice

The Handler esegue il codice di aggiornamento come una parte del tuo thread principale, evitando il sovraccarico di una seconda discussione ..

Non dovrebbe creare una nuova classe Runnable creare un nuovo secondo thread? Qual è lo scopo della classe Runnable qui oltre a essere in grado di passare una classe Runnable a postAtTime?

Grazie

Answer 1

Runnable viene spesso utilizzato per fornire il codice che un thread dovrebbe funzionare, ma Runnable sé ha nulla a che fare con fili. È solo un oggetto con un metodo run().

In Android, la classe Handler può essere utilizzata per chiedere al framework di eseguire del codice in un secondo momento sullo stesso thread, anziché su uno diverso. Runnable viene utilizzato per fornire il codice che deve essere eseguito in un secondo momento.

Answer 2

Runnable è solo un'interfaccia, che fornisce l'esecuzione del metodo. I thread sono implementazioni e usano Runnable per chiamare il metodo run().

Answer 3

Se si desidera creare un nuovo Thread ... si può fare qualcosa di simile ...

Thread t = new Thread(new Runnable() { public void run() { 
    // your code goes here... 
}}); 

Answer 4

L'interfaccia Runnable è un altro modo in cui è possibile implementare multi-threading diversa estensione del Thread classe dovuta al fatto che Java consente di estendere solo una classe.

È possibile comunque utilizzare il new Thread(Runnable runnable) costruttore, qualcosa di simile:

private Thread thread = new Thread(new Runnable() { 
public void run() { 
    final long start = mStartTime; 
    long millis = SystemClock.uptimeMillis() - start; 
    int seconds = (int) (millis/1000); 
    int minutes = seconds/60; 
    seconds  = seconds % 60; 

    if (seconds < 10) { 
     mTimeLabel.setText("" + minutes + ":0" + seconds); 
    } else { 
     mTimeLabel.setText("" + minutes + ":" + seconds);    
    } 

    mHandler.postAtTime(this, 
      start + (((minutes * 60) + seconds + 1) * 1000)); 
    } 
}); 

thread.start(); 

Answer 5

È possibile creare un thread proprio come questo:

Thread thread = new Thread(new Runnable() { 
        public void run() { 

         } 
        }); 
       thread.start(); 

Inoltre, è possibile utilizzare Runnable, Asyntask, Timer , TimerTaks e AlarmManager per l'esecuzione di thread.

Answer 6

strada più semplice è sufficiente passare argomento e creare un'istanza e chiamare filo filo metodo

chiamata utilizzando creare un oggetto filo e inviare un oggetto di classe eseguibile con il parametro o senza indicazione degli e inizio metodo dell'oggetto thread.

Nelle mie condizioni sto inviando il parametro e userò il metodo run.

nuovo Thread (nuovo FCMThreadController ("2", null, "3", "1")).inizio(); .

O

nuova discussione (nuova FCMThreadController()) start();

public class FCMThreadController implements Runnable { 
private String type; 
private List<UserDeviceModel> devices; 
private String message; 
private String id; 


    public FCMThreadController(String type, List<UserDeviceModel> devices, String message, String id) { 

     this.type = type; 
     this.devices = devices; 
     this.message = message; 
     this.id = id; 
    } 



    public FCMThreadController() { 

    } 

    @Override 
    public void run() { 
     // TODO Auto-generated method stub 

    } 



} 

Answer 7

Un thread è qualcosa di simile qualche ramo. Multi-branched significa quando ci sono almeno due rami. Se i rami sono ridotti, il minimo rimane uno. Questo è come se i rami fossero rimossi, ma in generale non lo consideriamo un ramo.

Analogamente quando ci sono almeno due thread, lo chiamiamo programma multi-thread. Se i fili sono ridotti, il minimo rimane uno. Ciao programma è un programma a thread singolo, ma nessuno ha bisogno di sapere multi-threading per scrivere o eseguirlo.

In parole semplici quando non si dice che un programma abbia thread, significa che il programma non è un programma multi-thread, più nel vero senso è un programma a thread singolo, in cui PUOI mettere il tuo codice come se fosse multi-thread.

Di seguito viene fornito un codice inutile, ma sarà sufficiente eliminare alcune confusioni relative a Runnable. Stamperà "Hello World".

class NamedRunnable implements Runnable { 

    public void run() { // The run method prints a message to standard output. 
     System.out.println("Hello World"); 
    } 

    public static void main(String[]arg){ 
     NamedRunnable namedRunnable = new NamedRunnable(); 
     namedRunnable.run(); 
    } 
} 

Answer 8

Non dovrebbe creare una nuova classe Runnable fare un nuovo secondo thread?

No. nuovo Runnable non crea il secondo Thread.

Qual è lo scopo della classe Runnable qui oltre a essere in grado di passare una classe Runnable a postAtTime?

Runnable viene inviato a Handler. Questa attività viene eseguita nella discussione, che è associata a Handler.

Se Handler è associato a filettatura UI, Runnable viene eseguito nella filettatura dell'interfaccia utente.

Se Handler è associato con altri HandlerThread, piste Runnable in HandlerThread

---

esplicitamente Handler associato al tuo MainThread (thread UI), scrivere sotto il codice.

Handler mHandler = new Handler(Looper.getMainLooper(); 

Se si scrive come segue, utilizza HandlerThread Looper.

HandlerThread handlerThread = new HandlerThread("HandlerThread"); 
handlerThread.start(); 
Handler requestHandler = new Handler(handlerThread.getLooper()); 

---