[cvs] / jsr166 / src / test / tck / ThreadPoolExecutorSubclassTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.99, Mon May 29 22:44:27 2017 UTC revision 1.100, Mon Jul 17 22:27:31 2017 UTC
# Line 23  Line 23 
23  import java.util.concurrent.Future;  import java.util.concurrent.Future;
24  import java.util.concurrent.FutureTask;  import java.util.concurrent.FutureTask;
25  import java.util.concurrent.LinkedBlockingQueue;  import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.RejectedExecutionException;  
26  import java.util.concurrent.RejectedExecutionHandler;  import java.util.concurrent.RejectedExecutionHandler;
27  import java.util.concurrent.RunnableFuture;  import java.util.concurrent.RunnableFuture;
28  import java.util.concurrent.SynchronousQueue;  import java.util.concurrent.SynchronousQueue;
29  import java.util.concurrent.ThreadFactory;  import java.util.concurrent.ThreadFactory;
30    import java.util.concurrent.ThreadLocalRandom;
31  import java.util.concurrent.ThreadPoolExecutor;  import java.util.concurrent.ThreadPoolExecutor;
32  import java.util.concurrent.TimeoutException;  import java.util.concurrent.TimeoutException;
33  import java.util.concurrent.TimeUnit;  import java.util.concurrent.TimeUnit;
# Line 1131  Line 1131 
1131      }      }
1132    
1133      /**      /**
1134       * execute throws RejectedExecutionException if saturated.       * Submitted tasks are rejected when saturated or shutdown
1135       */       */
1136      public void testSaturatedExecute() {      public void testSubmittedTasksRejectedWhenSaturatedOrShutdown() throws InterruptedException {
         final CountDownLatch done = new CountDownLatch(1);  
1137          final ThreadPoolExecutor p =          final ThreadPoolExecutor p =
1138              new CustomTPE(1, 1,              new CustomTPE(1, 1,
1139                            LONG_DELAY_MS, MILLISECONDS,                            LONG_DELAY_MS, MILLISECONDS,
1140                            new ArrayBlockingQueue<Runnable>(1));                            new ArrayBlockingQueue<Runnable>(1));
1141          try (PoolCleaner cleaner = cleaner(p, done)) {          final int saturatedSize = saturatedSize(p);
1142              Runnable task = new CheckedRunnable() {          final ThreadLocalRandom rnd = ThreadLocalRandom.current();
1143                  public void realRun() throws InterruptedException {          final CountDownLatch threadsStarted = new CountDownLatch(p.getMaximumPoolSize());
1144                      await(done);          final CountDownLatch done = new CountDownLatch(1);
1145            final Runnable r = () -> {
1146                threadsStarted.countDown();
1147                for (;;) {
1148                    try {
1149                        done.await();
1150                        return;
1151                    } catch (InterruptedException shutdownNowDeliberatelyIgnored) {}
1152                  }};                  }};
1153              for (int i = 0; i < 2; ++i)          final Callable<Boolean> c = () -> {
1154                  p.execute(task);              threadsStarted.countDown();
1155              for (int i = 0; i < 2; ++i) {              for (;;) {
1156                  try {                  try {
1157                      p.execute(task);                      done.await();
1158                      shouldThrow();                      return Boolean.TRUE;
1159                  } catch (RejectedExecutionException success) {}                  } catch (InterruptedException shutdownNowDeliberatelyIgnored) {}
1160                  assertTrue(p.getTaskCount() <= 2);              }};
1161              }          final boolean shutdownNow = rnd.nextBoolean();
         }  
     }  
1162    
     /**  
      * executor using CallerRunsPolicy runs task if saturated.  
      */  
     public void testSaturatedExecute2() {  
         final CountDownLatch done = new CountDownLatch(1);  
         final ThreadPoolExecutor p =  
             new CustomTPE(1, 1,  
                           LONG_DELAY_MS, MILLISECONDS,  
                           new ArrayBlockingQueue<Runnable>(1),  
                           new CustomTPE.CallerRunsPolicy());  
1163          try (PoolCleaner cleaner = cleaner(p, done)) {          try (PoolCleaner cleaner = cleaner(p, done)) {
1164              Runnable blocker = new CheckedRunnable() {              // saturate
1165                  public void realRun() throws InterruptedException {              for (int i = saturatedSize; i--> 0; ) {
1166                      await(done);                  switch (rnd.nextInt(4)) {
1167                  }};                  case 0: p.execute(r); break;
1168              p.execute(blocker);                  case 1: assertFalse(p.submit(r).isDone()); break;
1169              TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];                  case 2: assertFalse(p.submit(r, Boolean.TRUE).isDone()); break;
1170              for (int i = 0; i < tasks.length; i++)                  case 3: assertFalse(p.submit(c).isDone()); break;
                 tasks[i] = new TrackedNoOpRunnable();  
             for (int i = 0; i < tasks.length; i++)  
                 p.execute(tasks[i]);  
             for (int i = 1; i < tasks.length; i++)  
                 assertTrue(tasks[i].done);  
             assertFalse(tasks[0].done); // waiting in queue  
1171          }          }
1172      }      }
1173    
1174      /**              await(threadsStarted);
1175       * executor using DiscardPolicy drops task if saturated.              assertTaskSubmissionsAreRejected(p);
      */  
     public void testSaturatedExecute3() {  
         final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];  
         for (int i = 0; i < tasks.length; ++i)  
             tasks[i] = new TrackedNoOpRunnable();  
         final CountDownLatch done = new CountDownLatch(1);  
         final ThreadPoolExecutor p =  
             new CustomTPE(1, 1,  
                           LONG_DELAY_MS, MILLISECONDS,  
                           new ArrayBlockingQueue<Runnable>(1),  
                           new CustomTPE.DiscardPolicy());  
         try (PoolCleaner cleaner = cleaner(p, done)) {  
             p.execute(awaiter(done));  
1176    
1177              for (TrackedNoOpRunnable task : tasks)              if (shutdownNow)
1178                  p.execute(task);                  p.shutdownNow();
1179              for (int i = 1; i < tasks.length; i++)              else
1180                  assertFalse(tasks[i].done);                  p.shutdown();
1181                // Pool is shutdown, but not yet terminated
1182                assertTaskSubmissionsAreRejected(p);
1183                assertFalse(p.isTerminated());
1184    
1185                done.countDown();   // release blocking tasks
1186                assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
1187    
1188                assertTaskSubmissionsAreRejected(p);
1189          }          }
1190          for (int i = 1; i < tasks.length; i++)          assertEquals(saturatedSize(p)
1191              assertFalse(tasks[i].done);                       - (shutdownNow ? p.getQueue().remainingCapacity() : 0),
1192          assertTrue(tasks[0].done); // was waiting in queue                       p.getCompletedTaskCount());
1193      }      }
1194    
1195      /**      /**
1196       * executor using DiscardOldestPolicy drops oldest task if saturated.       * executor using DiscardOldestPolicy drops oldest task if saturated.
1197       */       */
1198      public void testSaturatedExecute4() {      public void testSaturatedExecute_DiscardOldestPolicy() {
1199          final CountDownLatch done = new CountDownLatch(1);          final CountDownLatch done = new CountDownLatch(1);
1200          LatchAwaiter r1 = awaiter(done);          LatchAwaiter r1 = awaiter(done);
1201          LatchAwaiter r2 = awaiter(done);          LatchAwaiter r2 = awaiter(done);
# Line 1221  Line 1204 
1204              new CustomTPE(1, 1,              new CustomTPE(1, 1,
1205                            LONG_DELAY_MS, MILLISECONDS,                            LONG_DELAY_MS, MILLISECONDS,
1206                            new ArrayBlockingQueue<Runnable>(1),                            new ArrayBlockingQueue<Runnable>(1),
1207                            new CustomTPE.DiscardOldestPolicy());                            new ThreadPoolExecutor.DiscardOldestPolicy());
1208          try (PoolCleaner cleaner = cleaner(p, done)) {          try (PoolCleaner cleaner = cleaner(p, done)) {
1209              assertEquals(LatchAwaiter.NEW, r1.state);              assertEquals(LatchAwaiter.NEW, r1.state);
1210              assertEquals(LatchAwaiter.NEW, r2.state);              assertEquals(LatchAwaiter.NEW, r2.state);
# Line 1239  Line 1222 
1222      }      }
1223    
1224      /**      /**
      * execute throws RejectedExecutionException if shutdown  
      */  
     public void testRejectedExecutionExceptionOnShutdown() {  
         final ThreadPoolExecutor p =  
             new CustomTPE(1, 1,  
                           LONG_DELAY_MS, MILLISECONDS,  
                           new ArrayBlockingQueue<Runnable>(1));  
         try { p.shutdown(); } catch (SecurityException ok) { return; }  
         try (PoolCleaner cleaner = cleaner(p)) {  
             try {  
                 p.execute(new NoOpRunnable());  
                 shouldThrow();  
             } catch (RejectedExecutionException success) {}  
         }  
     }  
   
     /**  
      * execute using CallerRunsPolicy drops task on shutdown  
      */  
     public void testCallerRunsOnShutdown() {  
         final ThreadPoolExecutor p =  
             new CustomTPE(1, 1,  
                           LONG_DELAY_MS, MILLISECONDS,  
                           new ArrayBlockingQueue<Runnable>(1),  
                           new CustomTPE.CallerRunsPolicy());  
         try { p.shutdown(); } catch (SecurityException ok) { return; }  
         try (PoolCleaner cleaner = cleaner(p)) {  
             TrackedNoOpRunnable r = new TrackedNoOpRunnable();  
             p.execute(r);  
             assertFalse(r.done);  
         }  
     }  
   
     /**  
      * execute using DiscardPolicy drops task on shutdown  
      */  
     public void testDiscardOnShutdown() {  
         final ThreadPoolExecutor p =  
             new CustomTPE(1, 1,  
                           LONG_DELAY_MS, MILLISECONDS,  
                           new ArrayBlockingQueue<Runnable>(1),  
                           new CustomTPE.DiscardPolicy());  
         try { p.shutdown(); } catch (SecurityException ok) { return; }  
         try (PoolCleaner cleaner = cleaner(p)) {  
             TrackedNoOpRunnable r = new TrackedNoOpRunnable();  
             p.execute(r);  
             assertFalse(r.done);  
         }  
     }  
   
     /**  
1225       * execute using DiscardOldestPolicy drops task on shutdown       * execute using DiscardOldestPolicy drops task on shutdown
1226       */       */
1227      public void testDiscardOldestOnShutdown() {      public void testDiscardOldestOnShutdown() {
# Line 1297  Line 1229 
1229              new CustomTPE(1, 1,              new CustomTPE(1, 1,
1230                            LONG_DELAY_MS, MILLISECONDS,                            LONG_DELAY_MS, MILLISECONDS,
1231                            new ArrayBlockingQueue<Runnable>(1),                            new ArrayBlockingQueue<Runnable>(1),
1232                            new CustomTPE.DiscardOldestPolicy());                            new ThreadPoolExecutor.DiscardOldestPolicy());
1233    
1234          try { p.shutdown(); } catch (SecurityException ok) { return; }          try { p.shutdown(); } catch (SecurityException ok) { return; }
1235          try (PoolCleaner cleaner = cleaner(p)) {          try (PoolCleaner cleaner = cleaner(p)) {
# Line 1308  Line 1240 
1240      }      }
1241    
1242      /**      /**
1243       * execute(null) throws NPE       * Submitting null tasks throws NullPointerException
1244       */       */
1245      public void testExecuteNull() {      public void testNullTaskSubmission() {
1246          final ThreadPoolExecutor p =          final ThreadPoolExecutor p =
1247              new CustomTPE(1, 2,              new CustomTPE(1, 2,
1248                            1L, SECONDS,                            1L, SECONDS,
1249                            new ArrayBlockingQueue<Runnable>(10));                            new ArrayBlockingQueue<Runnable>(10));
1250          try (PoolCleaner cleaner = cleaner(p)) {          try (PoolCleaner cleaner = cleaner(p)) {
1251              try {              assertNullTaskSubmissionThrowsNullPointerException(p);
                 p.execute(null);  
                 shouldThrow();  
             } catch (NullPointerException success) {}  
1252          }          }
1253      }      }
1254    

Legend:
Removed from v.1.99  
changed lines
  Added in v.1.100

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8