ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/loops/CancelledProducerConsumerLoops.java
(Generate patch)

Comparing jsr166/src/test/loops/CancelledProducerConsumerLoops.java (file contents):
Revision 1.2 by dl, Mon Nov 28 15:40:56 2005 UTC vs.
Revision 1.9 by jsr166, Wed Sep 1 07:47:27 2010 UTC

# Line 1 | Line 1
1   /*
2 – * @test %I% %E%
3 – * @bug 4486658
4 – * @compile -source 1.5 CancelledProducerConsumerLoops.java
5 – * @run main/timeout=7000 CancelledProducerConsumerLoops
6 – * @summary Checks for responsiveness of blocking queues to cancellation.
7 – * Runs under the assumption that ITERS computations require more than
8 – * TIMEOUT msecs to complete.
9 – */
10 – /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3 < * Expert Group and released to the public domain. Use, modify, and
4 < * redistribute this code in any way without acknowledgement.
3 > * Expert Group and released to the public domain, as explained at
4 > * http://creativecommons.org/licenses/publicdomain
5   */
15 –
6   import java.util.concurrent.*;
7  
8   public class CancelledProducerConsumerLoops {
9      static final int CAPACITY =      100;
10 <    static final long TIMEOUT = 100;
10 >    static final long TIMEOUT = 100;
11  
12      static final ExecutorService pool = Executors.newCachedThreadPool();
13      static boolean print = false;
# Line 26 | Line 16 | public class CancelledProducerConsumerLo
16          int maxPairs = 8;
17          int iters = 1000000;
18  
19 <        if (args.length > 0)
19 >        if (args.length > 0)
20              maxPairs = Integer.parseInt(args[0]);
21  
22          print = true;
23 <        
23 >
24          for (int i = 1; i <= maxPairs; i += (i+1) >>> 1) {
25              System.out.println("Pairs:" + i);
26              try {
27                  oneTest(i, iters);
28              }
29 <            catch(BrokenBarrierException bb) {
29 >            catch (BrokenBarrierException bb) {
30                  // OK, ignore
31              }
32              Thread.sleep(100);
# Line 49 | Line 39 | public class CancelledProducerConsumerLo
39          CyclicBarrier barrier = new CyclicBarrier(npairs * 2 + 1, timer);
40          Future[] prods = new Future[npairs];
41          Future[] cons = new Future[npairs];
42 <        
42 >
43          for (int i = 0; i < npairs; ++i) {
44              prods[i] = pool.submit(new Producer(q, barrier, iters));
45              cons[i] = pool.submit(new Consumer(q, barrier, iters));
# Line 82 | Line 72 | public class CancelledProducerConsumerLo
72          long endTime = System.nanoTime();
73          long time = endTime - timer.startTime;
74          if (print) {
75 <            double secs = (double)(time) / 1000000000.0;
75 >            double secs = (double) time / 1000000000.0;
76              System.out.println("\t " + secs + "s run time");
77          }
78      }
# Line 97 | Line 87 | public class CancelledProducerConsumerLo
87              System.out.print("LinkedBlockingQueue     ");
88          oneRun(new LinkedBlockingQueue<Integer>(CAPACITY), pairs, iters);
89  
90 +        if (print)
91 +            System.out.print("LinkedTransferQueue     ");
92 +        oneRun(new LinkedTransferQueue<Integer>(), pairs, iters);
93  
94          if (print)
95              System.out.print("SynchronousQueue        ");
# Line 107 | Line 100 | public class CancelledProducerConsumerLo
100              System.out.print("SynchronousQueue(fair)  ");
101          oneRun(new SynchronousQueue<Integer>(true), pairs, iters / 8);
102  
103 +        /* Can legitimately run out of memory before cancellation
104          if (print)
105              System.out.print("PriorityBlockingQueue   ");
106          oneRun(new PriorityBlockingQueue<Integer>(ITERS / 2 * pairs), pairs, iters / 4);
107 +        */
108      }
109 <    
109 >
110      static abstract class Stage implements Callable {
111          final BlockingQueue<Integer> queue;
112          final CyclicBarrier barrier;
113          final int iters;
114 <        Stage (BlockingQueue<Integer> q, CyclicBarrier b, int iters) {
115 <            queue = q;
114 >        Stage(BlockingQueue<Integer> q, CyclicBarrier b, int iters) {
115 >            queue = q;
116              barrier = b;
117              this.iters = iters;
118          }
# Line 143 | Line 138 | public class CancelledProducerConsumerLo
138      }
139  
140      static class Consumer extends Stage {
141 <        Consumer(BlockingQueue<Integer> q, CyclicBarrier b, int iters) {
141 >        Consumer(BlockingQueue<Integer> q, CyclicBarrier b, int iters) {
142              super(q, b, iters);
143          }
144  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines