Android 在一定的时间内运行一个方法

因此，我有一个名为

PredictionEngine（int）

的方法，我希望在每次运行之间以一定的时间延迟运行一定数量的时间。方法如下：

private void PredictionEngine(int delay) throws Exception {

    final Handler handler = new Handler();
    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            enableStrictMode();
            String val = null;
            try {
                if (tHighPass == 0 && tLowPass == 0 && tKalman == 1) {
                    //Magic
                } else {
                    //Magic
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
            enableStrictMode();
            new DropboxTask(side_output, "Result", val).execute();
        }
    }, delay);
}

很明显，我正在主线程中运行一个网络操作，因为这是一个研究应用程序，没有客户会使用它

我希望整个函数以一定的延迟运行100次，比如说2秒。最初的想法是这样做：

for(loop 100 times){
     PredictionEngine(int)
     Thread.sleep(2000); //sorry for StackOverflow programming.
}

但是我不想阻塞主线程，因为我正在那里读取一些传感器数据。任何相同的想法都会非常有用

---

谢谢。

在创建处理程序时，您可以提供一个循环器作为构造函数参数之一，该参数基于不同的线程，然后是主线程：

HandlerThread thread = new HandlerThread("Thread name", android.os.Process.THREAD_PRIORITY_BACKGROUND);
thread.start();
Looper looper = thread.getLooper();
Handler handler = new MyHandler(looper);

MyHandler接收的消息将在一个单独的线程上处理，使UI线程免受干扰

要定期循环执行任务，请使用以下方法：

for (int i=0; i<100; i++){
   handler.postDelayed(new Runnable(){
        ...
        ...
        ...
    }, i*delay);
 }

---

创建处理程序时，可以提供一个循环器作为构造函数参数之一，该参数基于不同的线程，然后是主线程：

HandlerThread thread = new HandlerThread("Thread name", android.os.Process.THREAD_PRIORITY_BACKGROUND);
thread.start();
Looper looper = thread.getLooper();
Handler handler = new MyHandler(looper);

MyHandler接收的消息将在一个单独的线程上处理，使UI线程免受干扰

要定期循环执行任务，请使用以下方法：

for (int i=0; i<100; i++){
   handler.postDelayed(new Runnable(){
        ...
        ...
        ...
    }, i*delay);
 }

---

解决这个问题的最佳方法是使用rxJava库，因为它允许创建、修改和使用事件流。您可以在几行代码中实现所有内容并对其进行修改，这样操作也可以在后台执行

Observable.interval(1, TimeUnit.SECONDS)
                .take(100)
                // switch execution into main thread
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(t -> {
                    doSomethingOnMainThread();
                });

---

另一方面，还有另一种解决方案-您可以使用处理程序，它通常用于线程通信。它有方法.postdayed（），允许您推迟任务的执行。Handler可以方便地与HandlerThread一起使用。但是，rxJava是解决问题的更方便、更简单的方法。

解决这个问题的最佳方法是使用rxJava库，因为它允许创建、修改和使用事件流。您可以在几行代码中实现所有内容并对其进行修改，这样操作也可以在后台执行

Observable.interval(1, TimeUnit.SECONDS)
                .take(100)
                // switch execution into main thread
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(t -> {
                    doSomethingOnMainThread();
                });

---

另一方面，还有另一种解决方案-您可以使用处理程序，它通常用于线程通信。它有方法.postdayed（），允许您推迟任务的执行。Handler可以方便地与HandlerThread一起使用。但是，rxJava是一种更方便、更简单的解决问题的方法。

我尝试在不阻塞主线程的情况下解决以下问题 我创建了用于循环的工作线程，并且仍然在主线程上运行predictionEngine（）

MyThread t = new MyThread(2000, 3000); // delay and sleep
t.startExecution();

辅助线程类如下所示

class MyThread extends Thread{
    private int delay;
    long sleep;

    MyThread(int delay, long sleep){
        this.delay = delay;
        this.sleep = sleep;
    }

    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            try {
                MainActivity.this.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        predictEngine(delay);
                    }
                });
                Log.i("Mtali","About to pause loop before next predict");
                sleep(sleep);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    void startExecution(){
        start();
    }
}

类MyThread扩展线程{
私有整数延迟；
长眠；
MyThread（整数延迟、长睡眠）{
延迟=延迟；
这个。睡眠=睡眠；
}
@凌驾
公开募捐{
对于（int i=0；i<100；i++）{
试一试{
MainActivity.this.runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
预测引擎（延迟）；
}
});
i（“Mtali”，“即将在下一次预测之前暂停循环”）；
睡眠；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
void startExecution（）{
start（）；
}
}

---

跳这个有帮助

我试图在不阻塞主线程的情况下解决以下问题 我创建了用于循环的工作线程，并且仍然在主线程上运行predictionEngine（）

MyThread t = new MyThread(2000, 3000); // delay and sleep
t.startExecution();

辅助线程类如下所示

class MyThread extends Thread{
    private int delay;
    long sleep;

    MyThread(int delay, long sleep){
        this.delay = delay;
        this.sleep = sleep;
    }

    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            try {
                MainActivity.this.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        predictEngine(delay);
                    }
                });
                Log.i("Mtali","About to pause loop before next predict");
                sleep(sleep);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    void startExecution(){
        start();
    }
}

类MyThread扩展线程{
私有整数延迟；
长眠；
MyThread（整数延迟、长睡眠）{
延迟=延迟；
这个。睡眠=睡眠；
}
@凌驾
公开募捐{
对于（int i=0；i<100；i++）{
试一试{
MainActivity.this.runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
预测引擎（延迟）；
}
});
i（“Mtali”，“即将在下一次预测之前暂停循环”）；
睡眠；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
void startExecution（）{
start（）；
}
}

---

跳这个有帮助

在添加的库和所有中，它表示找不到

AndroidSchedulers

class。我遗漏了什么？对于AndroidScheduler，您还应该使用rxAndroid:compile'io.reactivex:rxjava:1.0.13'compile'io.reactivex:rxAndroid:0.25.0'在添加的库和所有库中，它表示找不到

AndroidScheduler

类。我缺少什么？对于AndroidScheduler，您还应该使用rxAndroid:compile'io.reactivex:rxjava:1.0.13'compile'io.reactivex:rxAndroid:0.25.0'