Bonjour,

j'ai dans le code de ma boite de nombreuses fois le même type de code concernant java.util.concurrent.ExecutorService.

du coup pour me simplifier la vie j'ai écris ce petit DSL. qui permet de lancer et synchroniser les threads de cette façon:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
Boolean res = Executor.newExecutor(listRunnables)
   .awaitTermination(5, TimeUnit.SECONDS)
   .onTermination(() -> {
      System.out.println("termination");
    })
   .onTimeout(() -> {
      System.out.println("timeout");
   })
   .interuptOnTimeout()
   .execute();
la classe.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
package fr.ouranos.util;
 
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
/**
 * Executor DSL for ExecutorService.<br />
 * create execute and wait termination.<br />
 *<pre>       Boolean res = Executor.newExecutor(listRunnables)
 *       .awaitTermination(5, TimeUnit.SECONDS)
 *       .onTermination(() -> {
 *          System.out.println("termination");
 *        })
 *       .onTimeout(() -> {
 *          System.out.println("timeout");
 *       })
 *       .interuptOnTimeout()
 *       .execute();
 *</pre>
 * if "awaitTermination" is not set, "execute" launch all runnable and return true without waiting ends.<br />
 * if "awaitTermination" is set, "execute" launch all runnable, wait the ends, and return true if all runnable are end, or false on timeout<br />
 * if "onTermination" is set, "onTermination" is executed when all runnable are ends.<br />
 * if "onTimeout" is set, "onTimeout" is executed when the timeout is reached.<br />
 * if "interuptOnTimeout" all runnables are stoped when the timeout is reached.<br />
 * if "interuptOnTimeout" is not set, all runnables continues after the timeout is reached.<br />
 */
public class Executor
{
 
   /**
    * create executor for a Runnable List
    * @param listRunnable
    * @return new Executor
    */
   public static Executor newExecutor(List<Runnable> listRunnable){
      return new Executor(listRunnable);
   }
 
   /**
    * create executor for one Runnable
    * @param runnable
    * @return new Executor
    */
   public static Executor newExecutor(Runnable runnable){
      return new Executor(runnable);
   }
 
   private List<Runnable> listRunnable;
   private long timeout = 0;
   private TimeUnit unit = null;
   private Action onTermination;
   private Action onTimeout;
   private Boolean interupt = Boolean.FALSE;
 
   private Executor(List<Runnable> listRunnable){
      this.listRunnable = listRunnable;
   }
 
   private Executor(Runnable runnable){
      this.listRunnable = Collections.singletonList(runnable);
   }
 
   /**
    * add await option<br />
    * if "awaitTermination" is not set, "execute" launch all runnable and return true without waiting ends.<br />
    * if "awaitTermination" is set, "execute" launch all runnable, wait the ends, and return true if all runnable are end, or false on timeout.
    * @param timeout
    * @param unit
    * @return this
    */
   public Executor awaitTermination(long timeout, TimeUnit unit){
      this.timeout = timeout;
      this.unit = unit;
      return this;
   }
 
   /**
    * add termination event handler<br />
    * if "onTermination" is set, "onTermination" is executed when all runnable are ends.
    * @param onTermination
    * @return this
    */
   public Executor onTermination(Action onTermination){
      this.onTermination = onTermination;
      return this;
   }
 
   /**
    * add timeout event handler<br />
    * if "onTimeout" is set, "onTimeout" is executed when the timeout is reached.
    * @param onTimeout
    * @return this
    */
   public Executor onTimeout(Action onTimeout){
      this.onTimeout= onTimeout;
      return this;
   }
 
   /**
    * set interupt option<br .>
    * Stop all runnables when the timeout is reached.<br />
    * if "interuptOnTimeout" is not set, all runnables continues after the timeout is reached.<br />
    * @return this
    */
   public Executor interuptOnTimeout(){
      this.interupt  = Boolean.TRUE;
      return this;
   }
 
   /**
    * execute all runnables with options.
    * @return true if "awaitTermination" is not set, true if all runnable are end, false if the timeout is reached.
    * @throws InterruptedException
    */
   public Boolean execute() throws InterruptedException {
      Boolean result = Boolean.FALSE;
      if (0 == listRunnable.size()) {
         result = Boolean.TRUE;
      } else {
         final ExecutorService executor = Executors.newFixedThreadPool(listRunnable.size());
         for(final Runnable r : listRunnable){
            executor.execute(r);
         }
 
         executor.shutdown();
         if(null != unit) {
            if (executor.awaitTermination(timeout, unit)) {
               if (null != onTermination) {
                  onTermination.invoke();
               }
               result = Boolean.TRUE;
            } else {
               if (interupt) {
                  executor.shutdownNow();
               }
               if (null != onTimeout) {
                  onTimeout.invoke();
               }
            }
         }else {
            result = Boolean.TRUE;
         }
      }
 
      return result;
   }
 
   @FunctionalInterface
   public interface Action {
 
      void invoke();
   }
}
et la classe de tests qui va avec
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
package fr.ouranos.util;
 
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
 
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
 
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class ExecutorTest
{
   Logger LOGGER = LoggerFactory.getLogger(ExecutorTest.class);
   private Runnable longRunnable;
   private List<Runnable>  listRunnables;
 
   @Before
   public void init() throws Exception{
      //runnable sleeping 100 miliseconds
      longRunnable = new Runnable()
      {
         @Override
         public void run(){
            System.out.println("run");
            try{
               Thread.sleep(100);
            }catch(InterruptedException e){
               System.err.println(e.getMessage());
               return;
            }
         }
      };
      //list of runnables without sleeping.
      listRunnables = Collections.singletonList(new Runnable()
      {
         @Override
         public void run(){
            System.out.println("run");
         }
      });
   }
 
   /*
    * execute empty runnables list
    */
   @Test
   public void executeEmpty() throws Exception{
      Boolean res = Executor.newExecutor(Collections.emptyList())
         .awaitTermination(5, TimeUnit.SECONDS)
         .execute();
 
      assertTrue("runnables", res);
   }
 
   /*
    * execute runnables without wait
    */
   @Test
   public void executeNoWait() throws Exception{
      Boolean res = Executor.newExecutor(Collections.emptyList())
         .execute();
 
      assertTrue("runnables", res);
   }
 
   /*
    * execute runnables and wait ends
    * and then print "termination"
    */
   @Test
   public void executeOneTermination() throws Exception{
      Boolean res = Executor.newExecutor(listRunnables)
         .awaitTermination(5, TimeUnit.SECONDS)
         .onTermination(() -> {
            System.out.println("termination");
         })
         .execute();
 
      assertTrue("runnables", res);
   }
 
   /*
    * execute runnables and wait ends
    */
   @Test
   public void executeOne() throws Exception{
      Boolean res = Executor.newExecutor(listRunnables)
         .awaitTermination(5, TimeUnit.SECONDS)
         .execute();
 
      assertTrue("runnables", res);
   }
 
   /*
    * execute runnables and wait 10 microseconds
    * then print "timeout"
    */
   @Test
   public void executeOneOnTimeout() throws Exception{
      Boolean res = Executor.newExecutor(longRunnable)
         .awaitTermination(10, TimeUnit.MICROSECONDS)
         .onTimeout(() -> {
            System.out.println("timeout");
         })
         .execute();
 
      assertFalse("runnables", res);
   }
 
   /*
    * execute runnables and wait 10 microseconds (tiemout)
    */
   @Test
   public void executeOneTimeout() throws Exception{
      Boolean res = Executor.newExecutor(longRunnable)
         .awaitTermination(10, TimeUnit.MICROSECONDS)
         .execute();
      assertFalse("runnables", res);
   }
 
   /*
    * execute runnables and wait 10 microseconds
    * then print "timeout" and interupt all runnables
    */
   @Test
   public void executeInteruptOnTimeout() throws Exception{
      Boolean res = Executor.newExecutor(longRunnable)
         .awaitTermination(10, TimeUnit.MICROSECONDS)
         .onTimeout(() -> {
            System.out.println("timeout");
         })
         .interuptOnTimeout()
         .execute();
 
      assertFalse("runnables", res);
   }
 
   /*
    * execute runnables and wait 10 microseconds
    * then interupt all runnable
    */
   @Test
   public void executeInteruptTimeout() throws Exception{
      Boolean res = Executor.newExecutor(longRunnable)
         .awaitTermination(10, TimeUnit.MICROSECONDS)
         .interuptOnTimeout()
         .execute();
      assertFalse("runnables", res);
   }
}
A+JYT