時間遅延のあるタスクを繰り返しますか？

216

コードに変数があり、それが「ステータス」であると言います。

この変数の値に応じて、アプリケーションにテキストを表示したい。これは、特定の時間遅延で実行する必要があります。

まるで

  • ステータス変数の値を確認する

  • テキストを表示する

  • 10秒待つ

  • ステータス変数の値を確認する

  • テキストを表示する

  • 15秒待つ

等々。時間遅延は変化する可能性があり、テキストが表示されると設定されます。

私は試しましThread.sleep(time delay)たが失敗しました。これを完了するためのより良い方法はありますか？

android  android-thread 
— カルパパトゥムウェリビティゴダ
ソース
— Suragch

回答:

448

あなたは使うべきHandlerさんpostDelayed、この目的のために機能を。メインUIスレッドで指定された遅延でコードを実行するため、UIコントロールを更新できます。

private int mInterval = 5000; // 5 seconds by default, can be changed later
private Handler mHandler;

@Override
protected void onCreate(Bundle bundle) {

    // your code here

    mHandler = new Handler();
    startRepeatingTask();
}

@Override
public void onDestroy() {
    super.onDestroy();
    stopRepeatingTask();
}

Runnable mStatusChecker = new Runnable() {
    @Override 
    public void run() {
          try {
               updateStatus(); //this function can change value of mInterval.
          } finally {
               // 100% guarantee that this always happens, even if
               // your update method throws an exception
               mHandler.postDelayed(mStatusChecker, mInterval);
          }
    }
};

void startRepeatingTask() {
    mStatusChecker.run(); 
}

void stopRepeatingTask() {
    mHandler.removeCallbacks(mStatusChecker);
}
— イナザラック
ソース
1
inazarukに感謝します。うまくいきました。2 vの小さなタイプミスが見つかりました（上部にある「ハンドラー」ではなく「ハンドラー」、下部にある「removeCallbacks」では「removecallback」が削除されていません。しかし、いずれにしても、コードは私が探していたものとまったく同じでした。恩返しをするために行う非常に少なくとも、youveは私の尊敬を獲得した種類よろしくオーブリー・バークに。。。
— aubreybourke
20
素敵なプログラムですが、まったく問題なく動作します。しかし、startRepeatingTask（）はonCreateメソッド/ UIスレッドから呼び出さなければなりませんでした（これを実現するのに少し時間がかかりました！）おそらく、この点はどこかで言及されている可能性があります。よろしくお願いします
— gkris
1
あなたの答えは与え続けます。これは今日の穴から私を助けました。ありがとう。
— ディーンブレイクリー2013
アダプターのgetView（）メソッド内でRunnableを繰り返す方法はありますか？
— toobsco42 2014
1
ここでクラスをインポートするとき、何をインポートする必要がありますか？android.os.Handlerまたはjava.util.logging.Handler？
— EJチャトゥランガ2017
34

興味のある方のために、必要なすべてのものを作成するinazarukのコードを使用して作成したクラスを次に示します（UIを定期的に更新するために使用するため、UIUpdaterと呼んでいますが、好きなように呼び出すことができます）。

import android.os.Handler;
/**
 * A class used to perform periodical updates,
 * specified inside a runnable object. An update interval
 * may be specified (otherwise, the class will perform the 
 * update every 2 seconds).
 * 
 * @author Carlos Simões
 */
public class UIUpdater {
        // Create a Handler that uses the Main Looper to run in
        private Handler mHandler = new Handler(Looper.getMainLooper());

        private Runnable mStatusChecker;
        private int UPDATE_INTERVAL = 2000;

        /**
         * Creates an UIUpdater object, that can be used to
         * perform UIUpdates on a specified time interval.
         * 
         * @param uiUpdater A runnable containing the update routine.
         */
        public UIUpdater(final Runnable uiUpdater) {
            mStatusChecker = new Runnable() {
                @Override
                public void run() {
                    // Run the passed runnable
                    uiUpdater.run();
                    // Re-run it after the update interval
                    mHandler.postDelayed(this, UPDATE_INTERVAL);
                }
            };
        }

        /**
         * The same as the default constructor, but specifying the
         * intended update interval.
         * 
         * @param uiUpdater A runnable containing the update routine.
         * @param interval  The interval over which the routine
         *                  should run (milliseconds).
         */
        public UIUpdater(Runnable uiUpdater, int interval){
            UPDATE_INTERVAL = interval;
            this(uiUpdater);
        }

        /**
         * Starts the periodical update routine (mStatusChecker 
         * adds the callback to the handler).
         */
        public synchronized void startUpdates(){
            mStatusChecker.run();
        }

        /**
         * Stops the periodical update routine from running,
         * by removing the callback.
         */
        public synchronized void stopUpdates(){
            mHandler.removeCallbacks(mStatusChecker);
        }
}

次に、クラス内にUIUpdaterオブジェクトを作成し、次のように使用できます。

...
mUIUpdater = new UIUpdater(new Runnable() {
         @Override 
         public void run() {
            // do stuff ...
         }
    });

// Start updates
mUIUpdater.startUpdates();

// Stop updates
mUIUpdater.stopUpdates();
...

これをアクティビティアップデーターとして使用する場合は、開始呼び出しをonResume（）メソッド内に配置し、停止呼び出しをonPause（）内に配置して、更新がアクティビティの可視性に従って開始および停止するようにします。

— ラヴェミール
ソース
1
編集済み：の 前にあるUPDATE_INTERVAL = interval;必要があります（の値 が使用され、パラメーターとして渡されるものである必要があるため）。また、可能な場合はコードで80文字を超える幅を避けてください（ほとんどの場合、;） this(uiUpdater);UIUpdater(Runnable uiUpdater, int interval)UPDATE_INTERVALinterval;
— Mr_and_Mrs_D
5
このクラスには多くの問題があります。そもそも、GUIを更新できるように、メインスレッドでインスタンス化する必要があります。これを解決するには、メインルーパーをハンドラーコンストラクターに渡しますnew Handler(Looper.getMainLooper())。第二に、引数を検証しないため、nullのRunnableと負の間隔を飲み込みます。最後に、uiUpdater.run()行で費やされた時間は考慮されず、そのメソッドによってスローされる可能性のある例外も処理されません。また、スレッドセーフではないためstart、stopメソッドを作成して同期する必要があります。
— ミスタースミス
2
コードをテストするためのEclipseがないため、引数の検証部分まで編集しました。フィードバックをお寄せいただきありがとうございます！これはあなたが意味したことですか？startUpdatesとstopUpdatesを同期し、Handlerコントラクター内にLooper.getMainLooper（）呼び出しを配置し​​ます（フィールド宣言から直接呼び出すことができます）
— ravemir
2
私はこれを得ます：error: call to this must be first statement in constructor多分簡単な修正があります。
— msysmilu 2015
4
インポートの賛成投票-Javaで何気なくプログラミングしているときにHandlerがどこから来るのかを理解するのに時間がかかる
— Roman Susi
23

新しいホットネスは、ScheduledThreadPoolExecutorを使用することです。そのようです：

private final ScheduledThreadPoolExecutor executor_ = 
        new ScheduledThreadPoolExecutor(1);
this.executor_.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
    update();
    }
}, 0L, kPeriod, kTimeUnit);
— ネルス・ベックマン
ソース
Executors.newSingleThreadScheduledExecutor()ここで別のオプションにすることができます。
— グルシャン、2015年
13

タイマーは正常に動作します。ここでは、タイマーを使用して1.5秒後にテキストを検索し、UIを更新しています。お役に立てば幸いです。

private Timer _timer = new Timer();

_timer.schedule(new TimerTask() {
    @Override
    public void run() {
        // use runOnUiThread(Runnable action)
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                search();
            }
        });
    }
}, timeInterval);
— カイ・ワン
ソース
インターバル時間はどこに置いたの？
— Nathiel Barros 2017
1
こんにちはNathiel投稿を更新しました。お役に立てれば幸いです。インターバル時間は、Timer.schedule（）の2番目のパラメーターです。
— Kai Wang
7

それには3つの方法があります。

ScheduledThreadPoolExecutorを使用する

スレッドのプールが必要ないため、少しやりすぎ

   //----------------------SCHEDULER-------------------------
    private final ScheduledThreadPoolExecutor executor_ =
            new ScheduledThreadPoolExecutor(1);
     ScheduledFuture<?> schedulerFuture;
   public void  startScheduler() {
       schedulerFuture=  executor_.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                //DO YOUR THINGS
                pageIndexSwitcher.setVisibility(View.GONE);
            }
        }, 0L, 5*MILLI_SEC,  TimeUnit.MILLISECONDS);
    }


    public void  stopScheduler() {
        pageIndexSwitcher.setVisibility(View.VISIBLE);
        schedulerFuture.cancel(false);
        startScheduler();
    }

タイマータスクを使用する

古いAndroidスタイル

    //----------------------TIMER  TASK-------------------------

    private Timer carousalTimer;
    private void startTimer() {
        carousalTimer = new Timer(); // At this line a new Thread will be created
        carousalTimer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                //DO YOUR THINGS
                pageIndexSwitcher.setVisibility(INVISIBLE);
            }
        }, 0, 5 * MILLI_SEC); // delay
    }

    void stopTimer() {
        carousalTimer.cancel();
    }

ハンドラーとランナブルを使用する

モダンなAndroidスタイル

    //----------------------HANDLER-------------------------

    private Handler taskHandler = new android.os.Handler();

    private Runnable repeatativeTaskRunnable = new Runnable() {
        public void run() {
            //DO YOUR THINGS
        }
    };

   void startHandler() {
        taskHandler.postDelayed(repeatativeTaskRunnable, 5 * MILLI_SEC);
    }

    void stopHandler() {
        taskHandler.removeCallbacks(repeatativeTaskRunnable);
    }

アクティビティ/コンテキストを持つ非リークハンドラー

Activity / Fragmentクラスでメモリリークしない内部Handlerクラスを宣言します

/**
     * Instances of static inner classes do not hold an implicit
     * reference to their outer class.
     */
    private static class NonLeakyHandler extends Handler {
        private final WeakReference<FlashActivity> mActivity;

        public NonLeakyHandler(FlashActivity activity) {
            mActivity = new WeakReference<FlashActivity>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            FlashActivity activity = mActivity.get();
            if (activity != null) {
                // ...
            }
        }
    }

Activity / Fragmentクラスで反復的なタスクを実行するrunnableを宣言します

   private Runnable repeatativeTaskRunnable = new Runnable() {
        public void run() {
            new Handler(getMainLooper()).post(new Runnable() {
                @Override
                public void run() {

         //DO YOUR THINGS
        }
    };

アクティビティ/フラグメントのハンドラーオブジェクトを初期化します（ここでFlashActivityは私のアクティビティクラスです）

//Task Handler
private Handler taskHandler = new NonLeakyHandler(FlashActivity.this);

修正時間間隔の後にタスクを繰り返すには

taskHandler.postDelayed（repeatativeTaskRunnable、DELAY_MILLIS）;

タスクの繰り返しを停止するには

taskHandler .removeCallbacks（repeatativeTaskRunnable）;

更新：コトリンでは：

    //update interval for widget
    override val UPDATE_INTERVAL = 1000L

    //Handler to repeat update
    private val updateWidgetHandler = Handler()

    //runnable to update widget
    private var updateWidgetRunnable: Runnable = Runnable {
        run {
            //Update UI
            updateWidget()
            // Re-run it after the update interval
            updateWidgetHandler.postDelayed(updateWidgetRunnable, UPDATE_INTERVAL)
        }

    }

 // SATART updating in foreground
 override fun onResume() {
        super.onResume()
        updateWidgetHandler.postDelayed(updateWidgetRunnable, UPDATE_INTERVAL)
    }


    // REMOVE callback if app in background
    override fun onPause() {
        super.onPause()
        updateWidgetHandler.removeCallbacks(updateWidgetRunnable);
    }
— Hitesh Sahu
ソース
6

タイマーは作業を行う別の方法runOnUiThreadですが、UIを使用している場合は追加しないでください。

    import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Timer;
import java.util.TimerTask;

import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.TextView;
import android.app.Activity;

public class MainActivity extends Activity {

 CheckBox optSingleShot;
 Button btnStart, btnCancel;
 TextView textCounter;

 Timer timer;
 MyTimerTask myTimerTask;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  optSingleShot = (CheckBox)findViewById(R.id.singleshot);
  btnStart = (Button)findViewById(R.id.start);
  btnCancel = (Button)findViewById(R.id.cancel);
  textCounter = (TextView)findViewById(R.id.counter);

  btnStart.setOnClickListener(new OnClickListener(){

   @Override
   public void onClick(View arg0) {

    if(timer != null){
     timer.cancel();
    }

    //re-schedule timer here
    //otherwise, IllegalStateException of
    //"TimerTask is scheduled already" 
    //will be thrown
    timer = new Timer();
    myTimerTask = new MyTimerTask();

    if(optSingleShot.isChecked()){
     //singleshot delay 1000 ms
     timer.schedule(myTimerTask, 1000);
    }else{
     //delay 1000ms, repeat in 5000ms
     timer.schedule(myTimerTask, 1000, 5000);
    }
   }});

  btnCancel.setOnClickListener(new OnClickListener(){

   @Override
   public void onClick(View v) {
    if (timer!=null){
     timer.cancel();
     timer = null;
    }
   }
  });

 }

 class MyTimerTask extends TimerTask {

  @Override
  public void run() {
   Calendar calendar = Calendar.getInstance();
   SimpleDateFormat simpleDateFormat = 
     new SimpleDateFormat("dd:MMMM:yyyy HH:mm:ss a");
   final String strDate = simpleDateFormat.format(calendar.getTime());

   runOnUiThread(new Runnable(){

    @Override
    public void run() {
     textCounter.setText(strDate);
    }});
  }

 }

}

そしてxmlは...

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:orientation="vertical"
tools:context=".MainActivity" >

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center_horizontal"
    android:autoLink="web"
    android:text="http://android-er.blogspot.com/"
    android:textStyle="bold" />
<CheckBox 
    android:id="@+id/singleshot"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Single Shot"/>

CountDownTimerを使用する別の方法

new CountDownTimer(30000, 1000) {

     public void onTick(long millisUntilFinished) {
         mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
     }

     public void onFinish() {
         mTextField.setText("done!");
     }
  }.start();

途中の間隔で定期的に通知して、未来の時間までカウントダウンをスケジュールします。テキストフィールドに30秒のカウントダウンを表示する例：

詳細については

— ザル・エ・アメール
ソース
1
ハンドラーはタイマーよりも優先されます。タイマーvsハンドラーを
— Suragch
4

次の例を試してみてください!!!

指定された時間の経過後にRunnableをメッセージキューに追加するpostDelayed（）メソッドを使用するonCreate（）メソッドで[ハンドラ]を使用します。1

このコードを参照してください： 




public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
       setContentView(R.layout.main);
    //------------------
    //------------------
    android.os.Handler customHandler = new android.os.Handler();
            customHandler.postDelayed(updateTimerThread, 0);
}

private Runnable updateTimerThread = new Runnable()
{
        public void run()
        {
            //write here whaterver you want to repeat
            customHandler.postDelayed(this, 1000);
        }
};

— ガザルパテル
ソース
4

上記のScheduledThreadPoolExecutorに関する投稿に基づいて、自分のニーズに合ったユーティリティを思いつきました（3秒ごとにメソッドを起動したい）。

class MyActivity {
    private ScheduledThreadPoolExecutor mDialogDaemon;

    private void initDebugButtons() {
        Button btnSpawnDialogs = (Button)findViewById(R.id.btn_spawn_dialogs);
        btnSpawnDialogs.setVisibility(View.VISIBLE);
        btnSpawnDialogs.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View view) {
                spawnDialogs();
            }
        });
    }

    private void spawnDialogs() {
        if (mDialogDaemon != null) {
            mDialogDaemon.shutdown();
            mDialogDaemon = null;
        }
        mDialogDaemon = new ScheduledThreadPoolExecutor(1);
        // This process will execute immediately, then execute every 3 seconds.
        mDialogDaemon.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        // Do something worthwhile
                    }
                });
            }
        }, 0L, 3000L, TimeUnit.MILLISECONDS);
    }
}
— こんにちは
ソース
4

私の場合、前のプロセスが完了した場合、または5秒が経過した場合、次のいずれかの条件に該当する場合、プロセスを実行する必要がありました。だから、私は次のことをしてかなりうまくいきました：

private Runnable mStatusChecker;
private Handler mHandler;

class {
method() {
  mStatusChecker = new Runnable() {
            int times = 0;
            @Override
            public void run() {
                if (times < 5) {
                    if (process1.isRead()) {
                        executeProcess2();
                    } else {
                        times++;
                        mHandler.postDelayed(mStatusChecker, 1000);
                    }
                } else {
                    executeProcess2();
                }
            }
        };

        mHandler = new Handler();
        startRepeatingTask();
}

    void startRepeatingTask() {
       mStatusChecker.run();
    }

    void stopRepeatingTask() {
        mHandler.removeCallbacks(mStatusChecker);
    }


}

process1が読み込まれると、process2が実行されます。そうでない場合は、変数の時間をインクリメントし、1秒後にハンドラーを実行します。これは、process1が読み取られるかtimesが5になるまでループを維持します。timesが5の場合、5秒が経過し、毎秒、process1.isRead（）のif句が実行されます。

— jvdecamargo
ソース
1

kotlinとそのコルーチンを使用するのは非常に簡単です。まず、次のようにクラスでジョブを宣言します（viewModelでより良い）。

private var repeatableJob: Job? = null

次に、作成して開始する場合は、次のようにします。

repeatableJob = viewModelScope.launch {
    while (isActive) {
         delay(5_000)
         loadAlbums(iImageAPI, titleHeader, true)
    }
}
repeatableJob?.start()

そして、あなたがそれを終えたいなら：

repeatableJob?.cancel()

PS：viewModelScopeビューモデルでのみ使用できます。次のような他のコルーチンスコープを使用できます。withContext(Dispatchers.IO)

詳細：こちら

— アミン・ケシャバルジアン
ソース
0

Kotlinを使用している人にとって、inazarukの答えは機能せず、IDEは変数を初期化する必要があるため、のpostDelayed内部を使用する代わりRunnableに、別のメソッドで使用します。

  • Runnableこのように初期化してください：

    private var myRunnable = Runnable {
    //Do some work
    //Magic happens here ↓
    runDelayedHandler(1000)   }

  • 次のrunDelayedHandlerようにメソッドを初期化します。

     private fun runDelayedHandler(timeToWait : Long) {
    if (!keepRunning) {
        //Stop your handler
        handler.removeCallbacksAndMessages(null)
        //Do something here, this acts like onHandlerStop
    }
    else {
        //Keep it running
        handler.postDelayed(myRunnable, timeToWait)
    }
}

  • ご覧のとおり、このアプローチにより、タスクの存続期間を制御できるようになりkeepRunning、アプリケーションの存続期間中にタスクを追跡および変更することで、ジョブが実行されます。

— タミム・アッタフィ
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.