Wykonywanie listy runów z luką czasową

Question

Mam problem do rozwiązania. w którym muszę uruchomić listę uruchamianych obiektów z pewnym opóźnieniem przy każdym uruchomieniu żądania.

powiedzieć ex Mam listę jak poniżej

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

i ja stworzyliśmy wykonawcę z X liczba wątków jak poniżej

ExecutorService execute=Executors.newFixedThreadPool(X) 

teraz używając execute.invokeAl(myReqObjects); ja się próbuje wywołać wszystko żąda ...

, ale powinienem mieć opóźnienie między tymi. do osiągnięcia tego próbowałem

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

ale tutaj nie mogę wysłać listy jako argumentu, więc mogę wykonać sam wniosek o 7 sekund z opóźnieniem 2 sekund ...

więc czy jest jakiś sposób aby rozwiązać mój problem proszę sugerować mi

Answer 1

utworzyć timer:

Timer timer = new Timer(); 

jeśli trzeba uruchomić go raz a następnie:

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

uruchomić wielokrotnie:

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

zobaczyć kilka przykładów kodu dla timer i TimerTask here

Answer 2

Można zrobić Runnable, który jest nakładką na liście Runnables i śledzi to, co jest wysłane. Następnie podaj ten pojedynczy Runnable jako obiekt dla programu planującego.

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

Zasadniczo przedmiotem kolekcja, która sama jest Runnable. Zauważ, że jeśli przejdziesz trasą Executora, zrobiłbyś to samo z Callable.

Answer 3

Jedno pytanie. Czy te Runnable muszą zostać wykonane N sekund po jego poprzednia operacja została ukończona lub N sekund po zaplanowaniu poprzedniego.

Jeśli to drugie, można w sposób ciągły planować i zwiększać licznik czasu.

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

Pierwszy z nich jest nieco trudniejszy. trzeba by mieć runnable harmonogram to

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

Ten przykład ma wrapper Runnable wykonać kolejną dostępną run a następnie zaplanować następny dostępny po tym z określonym czasie oczekiwania.