6

我有一个问题要解决。在其中我需要在每次请求执行时运行可运行对象列表，但会有一些延迟。

说前任我有一个如下列表

List<MyReqObject> myReqObjects=new ArrayList<MyReqObject>();

我已经创建了一个具有 X 线程数的执行程序，如下所示

ExecutorService execute=Executors.newFixedThreadPool(X)

现在使用 execute.invokeAl(myReqObjects);我试图调用所有这些请求......

但我应该在这些之间有所延迟。为了实现这一点，我尝试了

ScheduledExecutorService scheduler =Executors.newScheduledThreadPool(1);
scheduler.scheduleAtFixedRate(myObject, 2, 7, SECONDS);

但在这里我不能发送列表作为参数，所以我可以执行相同的请求 7 秒，延迟 2 秒......

那么有没有办法解决我的问题请建议我

4

3 回答 3

1

创建一个定时器：

Timer timer = new Timer();

如果您需要运行一次：

timer.schedule(new TimerTask() {
   @Override
   public void run() {
   // Your code here
   }
}, 2*1000);

重复运行：

 timer.scheduleAtFixedRate(new TimerTask() {
   @Override
   public void run() {
   // Your code here
   }
}, 2*1000);

在此处查看 Timer 和 TimerTask 的一些编码示例

于 2013-03-14T09:02:52.560 回答
0

一个问题。这些 Runnables 是否需要在其前一个可运行对象完成后 N 秒或前一个被调度后 N 秒执行。

如果是后者，您可以连续安排和增加时间计数器。

int timeToWait = 2000;

ScheduledExecutorService scheduler =Executors.newScheduledThreadPool(1);
scheduler.scheduleAtFixedRate(myObject, 2, 7, SECONDS); 
for(int i = 1; i <= runnables.size(); i++){
   scheduler.schedule(r, timeToWait * i, TimeUnit.MILLISECONDS);
}

前者有点棘手。你需要有可运行的计划它

final int timeToWait = 2000;
class SchedulingRunnable implements Runnable{
   private final Iterator<Runnable> runnables;
   private final ScheduledExecutorService scheduler

   public SchedulingRunnable(Iterator<Runnable> rs, ScheduledExecutorService es){..}

   public void run(){
      runnables.next().run(); //assuming runnables.hasNext()
      if(runnables.hasNext()){
          scheduler.schedule(this, timeToWait, TimeUnit.MILLISECONDS);
      }
   } 
}
ScheduledExecutorService scheduler =Executors.newScheduledThreadPool(1);
scheduler.schedule(new SchedulingRunnable(runnables.iterator(),schedule), timeToWait, TimeUnit.MILLISECONDS);

这个例子有一个包装器 Runnable 执行下一个可用的run，然后在指定的等待时间之后安排下一个可用的。

于 2013-03-14T12:18:05.337 回答
0

您可以制作一个 Runnable，它是您的 Runnable 列表的包装器，并跟踪发送的内容。然后将单个 Runnable 作为调度程序的对象。

public class RunnableList implements Runnable {

    private List<Runnable> runList = Collections.synchronizedList(
                                                  new ArrayList<Runnable>());

    public void addRunnable(Runnable r) {
        runList.add(r);
    }

    @Override
    public void run() {
        if(!runList.isEmpty()) {
            runList.remove(0).run();
        }
    }   
}

本质上是一个集合对象，它本身就是一个 Runnable。请注意，如果你走 Executor 路线，你会用 Callable 做类似的事情。

于 2013-03-14T12:01:17.767 回答