Voleva un modo più efficiente per la pausa del ciclo

È ansible riscrivere questo codice per lavorare meglio con il processre? Ho una class che esegue alcuni compiti con periodicità fissa in un thread separato. A volte questo process può essere interrotto e ripreso. Attualmente sto usando una bandiera per pausa, funziona bene, ma il ciclo in questo modo carica ancora il processre quando il process è in pausa. È ansible risolvere questo problema?

private boolean mIsCanceled = false; private boolean mIsPaused = true; // TODO more efficient for processr way of pausing is required private final Thread mTimerThread = new Thread(new Runnable() { @Override public void run() { while(!mIsCanceled){ try { Thread.sleep(UPDATE_PERIOD); } catch (InterruptedException e) { e.printStackTrace(); } if (!mIsPaused){ doStep(); } } } }); public MyClass(){ mTimerThread.start(); } private void pause(){ mIsPaused = true; } private void resume(){ mIsPaused = false; } private void doStep(){ // Some code } 

Ti preghiamo solo di fornire un'implementazione alternativa del mio codice.

  • Accuratezza dell'accelerometro di Android (navigazione inerziale)
  • getSpeechRate ()? (o come indicare quale tariffa TTS è attualmente impostata)
  • Passaggio di un'image a un'altra attività
  • Scheda ActionBar impilata con visualizzazione personalizzata non visualizzata correttamente
  • Imansible call getSupportFragmentManager () dall'attività
  • OutputStreamWriter non si aggiunge
  • PS L'ambiente è Android OS 2.2+

  • Icona di notifica con il nuovo sistema Firebase Cloud Messaging
  • Dropbox Condivisione dell'archivio del file
  • Nessun errore ancora che Android Studio dice "non sono stati trovati test"
  • Linker Android: indefinito riferimento a bsd_signal
  • Come posso pubblicare per riprodurre l'apps x86 e ARM dell'applicazione cordova-crosswalk?
  • Come aggiungere arrays a corpo okhttp (POST)
  • 4 Solutions collect form web for “Voleva un modo più efficiente per la pausa del ciclo”

    Gli strumenti disponibili sono:

    wait / notify – stiamo cercando di allontanarsi da questo sistema arcaico.

    Semaphore s – una volta che il tuo thread lo ha afferrato, lo tieni fino a quando non lo blocca, quindi bloccandolo. Ciò significa che non è ansible interrompere il proprio thread.

    CyclicBarrier – deve essere creato nuovamente each volta che viene utilizzato.

    ReadWriteLock – il mio preferito. Puoi disporre di tanti thread che ti fanno pausa e ti riprenderai solo quando tutti hanno chiamato il resume . Puoi anche soffermarvi se vuoi.

     import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * PauseableThread is a Thread with pause/resume and cancel methods. * * The meat of the process must implement `step`. * * You can either extend this and implement `step` or use the factory. * * Note that I cannot extend Thread because my resume will clash with Thread's deprecated one. * * Usage: Either write a `Stepper` and run it in a `PausableThread` or extend `PausableThread` and call `blockIfPaused()` at appropriate points. */ public abstract class PauseableThread implements Runnable { // The lock. // We'll hold a read lock on it to pause the thread. // The thread will momentarily grab a write lock on it to pause. // This way you can have multiple pausers using normal locks. private final ReadWriteLock pause = new ReentrantReadWriteLock(); // Flag to cancel the wholeprocess. private volatile boolean cancelled = false; // The exception that caused it to finish. private Exception thrown = null; @Override // The core run mechanism. public void run() { try { while (!cancelled) { // Block here if we're paused. blockIfPaused(); // Do my work. step(); } } catch (Exception ex) { // Just fall out when exception is thrown. thrown = ex; } } // Block if pause has been called without a matching resume. private void blockIfPaused() throws InterruptedException { try { // Grab a write lock. Will block if a read lock has been taken. pause.writeLock().lockInterruptibly(); } finally { // Release the lock immediately to avoid blocking when pause is called. pause.writeLock().unlock(); } } // Pause the work. NB: MUST be balanced by a resume. public void pause() { // We can wait for a lock here. pause.readLock().lock(); } // Resume the work. NB: MUST be balanced by a pause. public void resume() { // Release the lock. pause.readLock().unlock(); } // Stop. public void cancel() { // Stop everything. cancelled = true; } // start - like a thread. public void start() { // Wrap it in a thread. new Thread(this).start(); } // Get the exceptuion that was thrown to stop the thread or null if the thread was cancelled. public Exception getThrown() { return thrown; } // Create this method to do stuff. // Calls to this method will stop when pause is called. // Any thrown exception stops the whole process. public abstract void step() throws Exception; // Factory to wrap a Stepper in a PauseableThread public static PauseableThread make(Stepper stepper) { StepperThread pauseableStepper = new StepperThread(stepper); // That's the thread they can pause/resume. return pauseableStepper; } // One of these must be used. public interface Stepper { // A Stepper has a step method. // Any exception thrown causes the enclosing thread to stop. public void step() throws Exception; } // Holder for a Stepper. private static class StepperThread extends PauseableThread { private final Stepper stepper; StepperThread(Stepper stepper) { this.stepper = stepper; } @Override public void step() throws Exception { stepper.step(); } } // My test counter. static int n = 0; // Test/demo. public static void main(String[] args) throws InterruptedException { try { // Simple stepper that just increments n. Stepper s = new Stepper() { @Override public void step() throws Exception { n += 1; Thread.sleep(10); } }; PauseableThread t = PauseableThread.make(s); // Start it up. t.start(); Thread.sleep(1000); t.pause(); System.out.println("Paused: " + n); Thread.sleep(1000); System.out.println("Resuminng: " + n); t.resume(); Thread.sleep(1000); t.cancel(); } catch (Exception e) { } } } 

    Modifica: il codice modificato per essere di uso più generale.

    Le tue migliori opzioni sono utilizzare l'attesa () / notify () o semplicemente passare a ScheduledExecutorService

    L'attesa () / notify () può essere difficile. Consiglio vivamente "Concorrenza Java in pratica" per saperne di più sul threading.

    Credo che il modo migliore sarebbe quello di utilizzare Thread.wait attendere il thread di attesa invece di dormire e utilizzare Thread.notify nel thread che stai aspettando. Maggiori informazioni qui: http://www.javamex.com/tutorials/synchronization_wait_notify.shtml

    È ansible migliorare l'efficienza drastica utilizzando un monitor invece di dormire il thread. Basta creare blocchi nel codice con una parola chiave sincronizzata. E un object finale che agisce sul monitor. Guarda più punti nell'API sui monitor.

    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.