Thread.sleep() vs handler.postDelay(), um Netzwerkanruf alle 30 Sekunden auszuführen

Question

Ich möchte alle 30 Sekunden einen Netzwerkanruf durchführen, um einige Messwerte zum Server zu übertragen. Momentan mache ich es mit thread.sleep(). Ich habe Artikel gefunden, die sagen, dass thread.sleep() einige Nachteile hat. Ich muss wissen, ob ich es richtig mache? oder Ersetzen den Thread mit Handler wird meinen Code verbessern?

public static void startSending(final Context con) { 
    if (running) return; 
    running = true; 
    threadToSendUXMetrics = new Thread(new Runnable() { 

     @Override 
     public void run() { 
      do { 
       try { 
        Thread.sleep(AugmedixConstants.glassLogsPushInterval); 
       } catch (InterruptedException e) { 
        mLogger.error(interrupt_exception + e.getMessage()); 
       } 
       // to do to send each time, should have some sleep code 
       if (AugmedixConstants.WEBAPP_URL.equals(AugmedixConstants.EMPTY_STRING)||!StatsNetworkChecker.checkIsConnected(con)) { 
        Utility.populateNetworkStat(); 
        mLogger.error(may_be_provider_not_login_yet); 
       } else 
        sendUXMetrics(); 

      } while (running); 

      if (!uxMetricsQueue.isEmpty()) sendUXMetrics(); 

     } 
    }); 
    threadToSendUXMetrics.start(); 
} 

Answer 1

Wenn Du nur ein Thread im Netzwerk verwendet wird, dann Nutzung der thread.sleep() ist in Ordnung. Wenn mehrere Threads synchronisiert sind, blockiert der Befehl thread.sleep() alle anderen Threads, die derzeit ausgeführt werden. Gemäß den Angaben, die Sie angegeben haben, ist nur ein Thread vorhanden, der keine anderen aktiven Threads blockiert, die synchron laufen. Daher sollte die Verwendung von thread.sleep() kein Problem darstellen.

Answer 2

Verwenden Sie Handler.postDelayed, um Aufgaben zu planen, wenn Sie in UI-Thread arbeiten, und Thread.sleep, wenn Sie im Hintergrundthread arbeiten.

Anscheinend senden Sie einige Daten über das Netzwerk, Sie müssen es im Hintergrund Thread tun, daher Thread.sleep wird empfohlen.

Answer 3

einfach:

• Thread.sleep(millisSeconds): Mit dieser Methode können Sie nur im Hintergrund Aufgaben erfordern, zum Beispiel in AsyncTask::doInBackground(), können Sie zu verzögern Aktionen danach rufen. EMPFOHLENE ANRUFUNG DIESES VERFAHRENS IM HINTERGRUNDGEWINDE.
• Handler().postDelayed({METHOD}, millisSeconds): Bei dieser Instanz wird METHOD ausgelöst, nachdem millisSeconds deklariert wurde.

Aber, um einfachen Griff Lebenszyklus von Handler(), benötigen Sie eine Handler() Instanz zu erklären, mit einer Runnable Instanz. Wenn beispielsweise Ihre Activity angehalten hat oder Sie diese Methode nicht mehr erneut aufrufen müssen, können Sie den Rückruf von Handler() entfernen. Im Folgenden finden Beispiel:

public class MainActivity extends Activity { 

    private Handler mHandler = Handler(); 

    public void onStart(...) { 
     super.onStart(...) 
     this.mHandler.postDelayed(this.foo, 1000) 
    } 

    public void onPaused(...) { 
     this.mHandler.removeCallback(this.foo) 
     super.onPaused(...) 
    } 

    private Runnable foo = new Runnable() { 
     @Override 
     public void run() { 
     // your code will call after 1 second when activity start 
     // end remove callback when activity paused 

     // continue call... 
     mHandler.postDelayed(foo, 1000) 
     } 
    } 

} 

Der obige Code nur als Referenz, ich von Hand eingeben, da keine IDE kopieren schreiben dann Paste.