planifier une tâche après un délai dans le service d'exécution

Question

Je souhaite qu'une tâche soit exécutée après un délai de 3 secondes et que ma tâche prenne 2 secondes pour se terminer.

La sortie je reçois est montrant intervalle de 5 secondes

Remarque: La classe Student implémente l'interface appelable je les requêtes suivantes

1. Pourquoi il y a délai de 5 secondes à venir.Comment faire un retard de 3 secondes Pourquoi thread 1 est montré dans la deuxième exécution, il devrait être thread deux

La sortie je reçois est

The time is : Sat Nov 26 15:08:02 IST 2016 

Doing a task during : prerna - Time - Sat Nov 26 15:08:06 IST 2016 
pool-1-thread-1 Helloprerna 
Doing a task during : abc - Time - Sat Nov 26 15:08:11 IST 2016 
pool-1-thread-1 Helloabc 
Doing a task during : def - Time - Sat Nov 26 15:08:16 IST 2016 
pool-1-thread-2 Hellodef 
Doing a task during : xyz - Time - Sat Nov 26 15:08:21 IST 2016 
pool-1-thread-1 Helloxyz 
Doing a task during : ritu - Time - Sat Nov 26 15:08:26 IST 2016 
pool-1-thread-3 Helloritu 
Doing a task during : babita - Time - Sat Nov 26 15:08:31 IST 2016 
pool-1-thread-2 Hellobabita 

Le code:

private String display(String name2) { 

    try { 
     // System.out.println(Thread.currentThread().getName()); 
     name2=Thread.currentThread().getName()+" Hello"+ name; 
     System.out.println("Doing a task during : " + name + " - Time - " + new Date()); 
     Thread.sleep(000); 
    } catch (InterruptedException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    return name2; 
} 


@Override 
public String call() throws Exception { 
    // TODO Auto-generated method stub 
    if (name == "archana") { 

     throw new Exception(); 
    } 
     /*} catch (Exception e) { 
      // TODO Auto-generated catch block 
     // e.printStackTrace(); 
     }finally{ 
      return "error"; 
     }*/ 

    return display(name); 
} 

public class ExecutorScheduleDemo { 

    public static void main(String args[]) throws InterruptedException{ 
     ScheduledExecutorService executor= Executors.newScheduledThreadPool(5); 
     ArrayList<Student> list = new ArrayList<Student>(); 

     list.add(new Student("prerna")); 
     list.add(new Student("abc")); 
     //list.add(new Student("archana")); 
     list.add(new Student("def")); 
     list.add(new Student("xyz")); 
     list.add(new Student("ritu")); 
     list.add(new Student("babita")); 
     System.out.println("The time is : " + new Date()); 
     List<Future<String>> resultList= new ArrayList<Future<String>>(); 
     for(Student s:list){ 
      Future<String> f=executor.schedule(s, 3, TimeUnit.SECONDS); 

      try { 
       System.out.println(f.get()); 
      } catch (ExecutionException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } 
     } 
    } 
} 

Answer 1

Pour terminer la réponse de eeedev, puisque votre objet semble être un Callable:

Vous pouvez simplement créer une nouvelle FutureTask en passant votre Callable au constructeur, comme décrit dans le oracle docs

Notez que Le paramètre de type FutureTask doit être identique à celui du Callable.

Exemple:

class Main { 

    public static void main(String[] args) { 
     Foo foo = new Foo(); 
     FutureTask<String> fooFutureTask = new FutureTask<>(foo); 
    } 
} 

class Foo implements Callable<String> { 

    @Override 
    public String call() throws Exception { 
     return "Calling"; 
    } 
} 

Vous pouvez ensuite planifier votre nouvelle FutureTask pour l'exécution comme décrit par eeedev.

Answer 2

Utilisation scheduleAtFixedRate(Runnable, long initialDelay, long period, TimeUnit timeunit) au lieu de schedule(Runnable task, long delay, TimeUnit timeunit).

scheduleAtFixedRate (Runnable, long initialDelay, long period, TimeUnit timeunit)
crée et exécute une action périodique qui devient actif en premier après le délai initial donné, et ensuite avec la période donnée; c'est-à-dire que les exécutions commenceront après initialDelay puis initialDelay+period, puis initialDelay + 2 * period, et ainsi de suite. Si une exécution de la tâche rencontre une exception, les exécutions suivantes sont supprimées. Sinon, la tâche ne prendra fin que par l'annulation ou la résiliation de l'exécuteur. Si l'exécution de cette tâche prend plus de temps que sa période, alors les exécutions suivantes peuvent commencer en retard, mais ne seront pas exécutées simultanément. prochaine exécution.