CancelledFutureLoops.java revision 0:37a05a11f281 
1/*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This code is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
11 * version 2 for more details (a copy is included in the LICENSE file that
12 * accompanied this code).
13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
19 * CA 95054 USA or visit www.sun.com if you need additional information or
20 * have any questions.
21 */
22
23/*
24 * This file is available under and governed by the GNU General Public
25 * License version 2 only, as published by the Free Software Foundation.
26 * However, the following notice accompanied the original version of this
27 * file:
28 *
29 * Written by Doug Lea with assistance from members of JCP JSR-166
30 * Expert Group and released to the public domain, as explained at
31 * http://creativecommons.org/licenses/publicdomain
32 */
33
34/*
35 * @test
36 * @bug 4486658
37 * @compile -source 1.5 CancelledFutureLoops.java
38 * @run main/timeout=2000 CancelledFutureLoops
39 * @summary Checks for responsiveness of futures to cancellation.
40 * Runs under the assumption that ITERS computations require more than
41 * TIMEOUT msecs to complete.
42 */
43
44import java.util.concurrent.*;
45import java.util.concurrent.locks.*;
46import java.util.*;
47
48public final class CancelledFutureLoops {
49    static final ExecutorService pool = Executors.newCachedThreadPool();
50    static final LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
51    static boolean print = false;
52    static final int ITERS = 1000000;
53    static final long TIMEOUT = 100;
54
55    public static void main(String[] args) throws Exception {
56        int maxThreads = 5;
57        if (args.length > 0)
58            maxThreads = Integer.parseInt(args[0]);
59
60        print = true;
61
62        for (int i = 2; i <= maxThreads; i += (i+1) >>> 1) {
63            System.out.print("Threads: " + i);
64            try {
65                new FutureLoop(i).test();
66            }
67            catch(BrokenBarrierException bb) {
68                // OK; ignore
69            }
70            catch(ExecutionException ee) {
71                // OK; ignore
72            }
73            Thread.sleep(TIMEOUT);
74        }
75        pool.shutdown();
76        if (! pool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS))
77            throw new Error();
78    }
79
80    static final class FutureLoop implements Callable {
81        private int v = rng.next();
82        private final ReentrantLock lock = new ReentrantLock();
83        private final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
84        private final CyclicBarrier barrier;
85        private final int nthreads;
86        FutureLoop(int nthreads) {
87            this.nthreads = nthreads;
88            barrier = new CyclicBarrier(nthreads+1, timer);
89        }
90
91        final void test() throws Exception {
92            Future[] futures = new Future[nthreads];
93            for (int i = 0; i < nthreads; ++i)
94                futures[i] = pool.submit(this);
95
96            barrier.await();
97            Thread.sleep(TIMEOUT);
98            boolean tooLate = false;
99            for (int i = 1; i < nthreads; ++i) {
100                if (!futures[i].cancel(true))
101                    tooLate = true;
102                // Unbunch some of the cancels
103                if ( (i & 3) == 0)
104                    Thread.sleep(1 + rng.next() % 10);
105            }
106
107            Object f0 = futures[0].get();
108            if (!tooLate) {
109                for (int i = 1; i < nthreads; ++i) {
110                    if (!futures[i].isDone() || !futures[i].isCancelled())
111                        throw new Error("Only one thread should complete");
112                }
113            }
114            else
115                System.out.print("(cancelled too late) ");
116
117            long endTime = System.nanoTime();
118            long time = endTime - timer.startTime;
119            if (print) {
120                double secs = (double)(time) / 1000000000.0;
121                System.out.println("\t " + secs + "s run time");
122            }
123
124        }
125
126        public final Object call() throws Exception {
127            barrier.await();
128            int sum = v;
129            int x = 0;
130            int n = ITERS;
131            while (n-- > 0) {
132                lock.lockInterruptibly();
133                try {
134                    v = x = LoopHelpers.compute1(v);
135                }
136                finally {
137                    lock.unlock();
138                }
139                sum += LoopHelpers.compute2(LoopHelpers.compute2(x));
140            }
141            return new Integer(sum);
142        }
143    }
144
145}
146