Question

我的代码中有一个变量，说它是“状态”。

我想根据此变量值在应用程序中显示一些文本。这必须在特定的时间延迟下完成。

就像是，

检查状态变量值
显示一些文字
等待10秒
检查状态变量值
显示一些文字
等待15秒

等等。时间延迟可能会有所不同，一旦显示文本就会设置。

我尝试了Thread.sleep(time delay)但失败了。有没有更好的方法来完成这项工作？

Answer 1

为此，您应该使用Handler的{{1}}功能。它将在主UI线程上以指定的延迟运行您的代码，因此您将能够更新UI控件。

postDelayed

Answer 2

对于任何感兴趣的人，这是我使用inazaruk代码创建的一个类，它创建了所需的一切（我称之为UIUpdater，因为我用它来定期更新UI，但你可以随意调用它）：

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（）内，以便根据活动可见性启动和停止更新。

Answer 3

我认为新的热点是使用ScheduledThreadPoolExecutor。像这样：

private final ScheduledThreadPoolExecutor executor_ = 
        new ScheduledThreadPoolExecutor(1);
this.executor_.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
    update();
    }
}, 0L, kPeriod, kTimeUnit);

Answer 4

计时器工作正常。在这里，我使用Timer在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);

Answer 5

计时器是另一种完成工作的方法，但如果您正在使用UI，请务必添加runOnUiThread。

    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秒倒计时的示例：

For Details

Answer 6

尝试以下示例，它有效!!!

在onCreate（）方法中使用[Handler]，该方法使用postDelayed（）方法将Runnable添加到消息队列中，在给定的示例中经过指定的时间量0后运行。 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);
        }
};

Answer 7

您可以使用处理程序发布可运行代码。这里概述了这种技术：https://guides.codepath.com/android/Repeating-Periodic-Tasks

Answer 8

在我的情况下，如果其中一个条件成立，我必须执行一个过程：如果先前的过程已完成或已经过了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。如果不是，则递增变量次数，并在一秒钟后执行处理程序。它维持一个循环，直到读取process1或者时间为5.当时间为5时，表示传递了5秒，并且每秒执行process1.isRead（）的if子句。

Answer 9

在Handler的帮助下以Android的方式执行此操作。

声明一个内部处理程序类，其中does not leak Memory位于您的Activity / Fragment类

中

/**
     * 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) {
                // ...
            }
        }
    }

声明一个runnable，它将在您的Activity / Fragment类中执行重复性任务

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

         //DO YOUR THINGS
        }
    };

在Activity / Fragment中初始化Handler对象（此处FlashActivity是我的活动类）

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

在修复时间间隔后重复任务

taskHandler.postDelayed（repeatativeTaskRunnable，DELAY_MILLIS）;

停止重复任务

taskHandler .removeCallbacks（repeatativeTaskRunnable）;

更新：在Kotlin：

    //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);
    }

Answer 10

Based on the above post concerning the ScheduledThreadPoolExecutor, I came up with a utility that suited my needs (wanted to fire a method every 3 seconds):

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);
    }
}

Answer 11

使用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)

更多信息：Here

Answer 12

对于使用Kotlin的用户，inazaruk's answer将无法工作，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并在应用程序生存期内进行更改将为您完成工作。 / p>

有时间延迟重复一项任务？

12 个答案:

更新：在Kotlin：