undefect. CWE-407 — 63 sites patched across 27 ecosystems
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com Patches, unit tests, benchmarks, whitepaper, and outreach briefs. Public domain — no copyright claimed. Use freely.
This commit is contained in:
commit
0a580b313d
70422 changed files with 17213626 additions and 0 deletions
|
|
@ -0,0 +1,164 @@
|
|||
/*
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file is available under and governed by the GNU General Public
|
||||
* License version 2 only, as published by the Free Software Foundation.
|
||||
* However, the following notice accompanied the original version of this
|
||||
* file:
|
||||
*
|
||||
* Written by Doug Lea with assistance from members of JCP JSR-166
|
||||
* Expert Group and released to the public domain, as explained at
|
||||
* http://creativecommons.org/publicdomain/zero/1.0/
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 4486658 8040928 8140468
|
||||
* @summary tests ReentrantLock.lockInterruptibly.
|
||||
* Checks for responsiveness of locks to interrupts.
|
||||
*/
|
||||
|
||||
import static java.util.concurrent.TimeUnit.NANOSECONDS;
|
||||
|
||||
import java.util.concurrent.CyclicBarrier;
|
||||
import java.util.concurrent.ThreadLocalRandom;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
|
||||
public final class CancelledLockLoops {
|
||||
public static void main(String[] args) throws Exception {
|
||||
final int maxThreads = (args.length > 0) ? Integer.parseInt(args[0]) : 5;
|
||||
final int reps = 1; // increase for stress testing
|
||||
|
||||
for (int j = 0; j < reps; j++) {
|
||||
for (int i = 2; i <= maxThreads; i += (i+1) >>> 1) {
|
||||
new Loops(i).test();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static final class Loops implements Runnable {
|
||||
private final boolean print = false;
|
||||
private volatile boolean done = false;
|
||||
private int v = ThreadLocalRandom.current().nextInt();
|
||||
private int completed = 0;
|
||||
private volatile int result = 17;
|
||||
private final ReentrantLock lock = new ReentrantLock();
|
||||
private final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
|
||||
private final CyclicBarrier barrier;
|
||||
private final int nthreads;
|
||||
private volatile Throwable fail = null;
|
||||
Loops(int nthreads) {
|
||||
this.nthreads = nthreads;
|
||||
if (print) System.out.print("Threads: " + nthreads);
|
||||
barrier = new CyclicBarrier(nthreads+1, timer);
|
||||
}
|
||||
|
||||
final void test() throws Exception {
|
||||
final ThreadLocalRandom rnd = ThreadLocalRandom.current();
|
||||
Thread[] threads = new Thread[nthreads];
|
||||
for (int i = 0; i < threads.length; ++i)
|
||||
threads[i] = new Thread(this);
|
||||
for (int i = 0; i < threads.length; ++i)
|
||||
threads[i].start();
|
||||
Thread[] cancels = threads.clone();
|
||||
barrier.await();
|
||||
Thread.sleep(rnd.nextInt(5));
|
||||
for (int i = 0; i < cancels.length-2; ++i) {
|
||||
cancels[i].interrupt();
|
||||
// make sure all OK even when cancellations spaced out
|
||||
if ( (i & 3) == 0)
|
||||
Thread.sleep(1 + rnd.nextInt(5));
|
||||
}
|
||||
done = true;
|
||||
barrier.await();
|
||||
if (print) {
|
||||
long time = timer.getTime();
|
||||
double secs = (double)time / 1000000000.0;
|
||||
System.out.println("\t " + secs + "s run time");
|
||||
}
|
||||
|
||||
int c;
|
||||
lock.lock();
|
||||
try {
|
||||
c = completed;
|
||||
}
|
||||
finally {
|
||||
lock.unlock();
|
||||
}
|
||||
if (c != 2)
|
||||
throw new Error("Completed == " + c + "; expected 2");
|
||||
int r = result;
|
||||
if (r == 0) // avoid overoptimization
|
||||
System.out.println("useless result: " + r);
|
||||
if (fail != null) throw new RuntimeException(fail);
|
||||
}
|
||||
|
||||
public final void run() {
|
||||
try {
|
||||
barrier.await();
|
||||
boolean interrupted = false;
|
||||
long startTime = System.nanoTime();
|
||||
int sum = v;
|
||||
int x = 0;
|
||||
while (!done || Thread.currentThread().isInterrupted()) {
|
||||
try {
|
||||
lock.lockInterruptibly();
|
||||
}
|
||||
catch (InterruptedException ie) {
|
||||
interrupted = true;
|
||||
if (print)
|
||||
System.out.printf("interrupted after %d millis%n",
|
||||
NANOSECONDS.toMillis(System.nanoTime() - startTime));
|
||||
break;
|
||||
}
|
||||
try {
|
||||
v = x = LoopHelpers.compute1(v);
|
||||
}
|
||||
finally {
|
||||
lock.unlock();
|
||||
}
|
||||
sum += LoopHelpers.compute2(x);
|
||||
}
|
||||
if (!interrupted) {
|
||||
if (print)
|
||||
System.out.printf("completed after %d millis%n",
|
||||
NANOSECONDS.toMillis(System.nanoTime() - startTime));
|
||||
lock.lock();
|
||||
try {
|
||||
++completed;
|
||||
}
|
||||
finally {
|
||||
lock.unlock();
|
||||
}
|
||||
}
|
||||
barrier.await();
|
||||
result += sum;
|
||||
}
|
||||
catch (Throwable ex) {
|
||||
fail = ex;
|
||||
throw new RuntimeException(ex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
/*
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file is available under and governed by the GNU General Public
|
||||
* License version 2 only, as published by the Free Software Foundation.
|
||||
* However, the following notice accompanied the original version of this
|
||||
* file:
|
||||
*
|
||||
* Written by Doug Lea with assistance from members of JCP JSR-166
|
||||
* Expert Group and released to the public domain, as explained at
|
||||
* http://creativecommons.org/publicdomain/zero/1.0/
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 4486658
|
||||
* @summary Checks for missed signals by locking and unlocking each of an array of locks once per thread
|
||||
* @library /test/lib
|
||||
*/
|
||||
|
||||
import static java.util.concurrent.TimeUnit.MILLISECONDS;
|
||||
|
||||
import java.util.concurrent.CyclicBarrier;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.ThreadLocalRandom;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
import jdk.test.lib.Utils;
|
||||
|
||||
public final class LockOncePerThreadLoops {
|
||||
static final long LONG_DELAY_MS = Utils.adjustTimeout(10_000);
|
||||
static final ExecutorService pool = Executors.newCachedThreadPool();
|
||||
static boolean print = false;
|
||||
static int nlocks = 20_000;
|
||||
static int nthreads = 20;
|
||||
static int replications = 3;
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
if (args.length > 0)
|
||||
replications = Integer.parseInt(args[0]);
|
||||
|
||||
if (args.length > 1)
|
||||
nlocks = Integer.parseInt(args[1]);
|
||||
|
||||
print = true;
|
||||
|
||||
for (int i = 0; i < replications; ++i) {
|
||||
System.out.print("Iteration: " + i);
|
||||
new ReentrantLockLoop().test();
|
||||
}
|
||||
pool.shutdown();
|
||||
if (! pool.awaitTermination(LONG_DELAY_MS, MILLISECONDS))
|
||||
throw new Error();
|
||||
}
|
||||
|
||||
static final class ReentrantLockLoop implements Runnable {
|
||||
private int v = ThreadLocalRandom.current().nextInt();
|
||||
private volatile int result = 17;
|
||||
final ReentrantLock[]locks = new ReentrantLock[nlocks];
|
||||
|
||||
private final ReentrantLock lock = new ReentrantLock();
|
||||
private final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
|
||||
private final CyclicBarrier barrier;
|
||||
ReentrantLockLoop() {
|
||||
barrier = new CyclicBarrier(nthreads+1, timer);
|
||||
for (int i = 0; i < nlocks; ++i)
|
||||
locks[i] = new ReentrantLock();
|
||||
}
|
||||
|
||||
final void test() throws Exception {
|
||||
for (int i = 0; i < nthreads; ++i)
|
||||
pool.execute(this);
|
||||
barrier.await();
|
||||
barrier.await();
|
||||
if (print) {
|
||||
long time = timer.getTime();
|
||||
double secs = (double)time / 1000000000.0;
|
||||
System.out.println("\t " + secs + "s run time");
|
||||
}
|
||||
|
||||
int r = result;
|
||||
if (r == 0) // avoid overoptimization
|
||||
System.out.println("useless result: " + r);
|
||||
}
|
||||
|
||||
public final void run() {
|
||||
try {
|
||||
barrier.await();
|
||||
int sum = v;
|
||||
int x = 0;
|
||||
for (int i = 0; i < locks.length; ++i) {
|
||||
locks[i].lock();
|
||||
try {
|
||||
v = x += ~(v - i);
|
||||
}
|
||||
finally {
|
||||
locks[i].unlock();
|
||||
}
|
||||
// Once in a while, do something more expensive
|
||||
if ((~i & 255) == 0) {
|
||||
sum += LoopHelpers.compute1(LoopHelpers.compute2(x));
|
||||
}
|
||||
else
|
||||
sum += sum ^ x;
|
||||
}
|
||||
barrier.await();
|
||||
result += sum;
|
||||
}
|
||||
catch (Exception ex) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
/*
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file is available under and governed by the GNU General Public
|
||||
* License version 2 only, as published by the Free Software Foundation.
|
||||
* However, the following notice accompanied the original version of this
|
||||
* file:
|
||||
*
|
||||
* Written by Doug Lea with assistance from members of JCP JSR-166
|
||||
* Expert Group and released to the public domain, as explained at
|
||||
* http://creativecommons.org/publicdomain/zero/1.0/
|
||||
*/
|
||||
|
||||
/**
|
||||
* Misc utilities in JSR166 performance tests
|
||||
*/
|
||||
class LoopHelpers {
|
||||
|
||||
// Some mindless computation to do between synchronizations...
|
||||
|
||||
/**
|
||||
* generates 32 bit pseudo-random numbers.
|
||||
* Adapted from http://www.snippets.org
|
||||
*/
|
||||
public static int compute1(int x) {
|
||||
int lo = 16807 * (x & 0xFFFF);
|
||||
int hi = 16807 * (x >>> 16);
|
||||
lo += (hi & 0x7FFF) << 16;
|
||||
if ((lo & 0x80000000) != 0) {
|
||||
lo &= 0x7fffffff;
|
||||
++lo;
|
||||
}
|
||||
lo += hi >>> 15;
|
||||
if (lo == 0 || (lo & 0x80000000) != 0) {
|
||||
lo &= 0x7fffffff;
|
||||
++lo;
|
||||
}
|
||||
return lo;
|
||||
}
|
||||
|
||||
/**
|
||||
* Computes a linear congruential random number a random number
|
||||
* of times.
|
||||
*/
|
||||
public static int compute2(int x) {
|
||||
int loops = (x >>> 4) & 7;
|
||||
while (loops-- > 0) {
|
||||
x = (x * 2147483647) % 16807;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
public static class BarrierTimer implements Runnable {
|
||||
public volatile long startTime;
|
||||
public volatile long endTime;
|
||||
public void run() {
|
||||
long t = System.nanoTime();
|
||||
if (startTime == 0)
|
||||
startTime = t;
|
||||
else
|
||||
endTime = t;
|
||||
}
|
||||
public void clear() {
|
||||
startTime = 0;
|
||||
endTime = 0;
|
||||
}
|
||||
public long getTime() {
|
||||
return endTime - startTime;
|
||||
}
|
||||
}
|
||||
|
||||
public static String rightJustify(long n) {
|
||||
// There's probably a better way to do this...
|
||||
String field = " ";
|
||||
String num = Long.toString(n);
|
||||
if (num.length() >= field.length())
|
||||
return num;
|
||||
StringBuilder b = new StringBuilder(field);
|
||||
b.replace(b.length()-num.length(), b.length(), num);
|
||||
return b.toString();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,140 @@
|
|||
/*
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file is available under and governed by the GNU General Public
|
||||
* License version 2 only, as published by the Free Software Foundation.
|
||||
* However, the following notice accompanied the original version of this
|
||||
* file:
|
||||
*
|
||||
* Written by Doug Lea with assistance from members of JCP JSR-166
|
||||
* Expert Group and released to the public domain, as explained at
|
||||
* http://creativecommons.org/publicdomain/zero/1.0/
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 4486658
|
||||
* @summary multiple threads using a single lock
|
||||
* @library /test/lib
|
||||
*/
|
||||
|
||||
import static java.util.concurrent.TimeUnit.MILLISECONDS;
|
||||
|
||||
import java.util.concurrent.CyclicBarrier;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
import java.util.concurrent.ThreadLocalRandom;
|
||||
import jdk.test.lib.Utils;
|
||||
|
||||
public final class SimpleReentrantLockLoops {
|
||||
static final long LONG_DELAY_MS = Utils.adjustTimeout(10_000);
|
||||
static final ExecutorService pool = Executors.newCachedThreadPool();
|
||||
static boolean print = false;
|
||||
static int iters = 100_000;
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
int maxThreads = 5;
|
||||
if (args.length > 0)
|
||||
maxThreads = Integer.parseInt(args[0]);
|
||||
|
||||
print = true;
|
||||
|
||||
int reps = 2;
|
||||
for (int i = 1; i <= maxThreads; i += (i+1) >>> 1) {
|
||||
int n = reps;
|
||||
if (reps > 1) --reps;
|
||||
while (n-- > 0) {
|
||||
System.out.print("Threads: " + i);
|
||||
new ReentrantLockLoop(i).test();
|
||||
}
|
||||
}
|
||||
pool.shutdown();
|
||||
if (! pool.awaitTermination(LONG_DELAY_MS, MILLISECONDS))
|
||||
throw new Error();
|
||||
}
|
||||
|
||||
static final class ReentrantLockLoop implements Runnable {
|
||||
private int v = ThreadLocalRandom.current().nextInt();
|
||||
private volatile int result = 17;
|
||||
private final ReentrantLock lock = new ReentrantLock();
|
||||
private final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
|
||||
private final CyclicBarrier barrier;
|
||||
private final int nthreads;
|
||||
ReentrantLockLoop(int nthreads) {
|
||||
this.nthreads = nthreads;
|
||||
barrier = new CyclicBarrier(nthreads+1, timer);
|
||||
}
|
||||
|
||||
final void test() throws Exception {
|
||||
for (int i = 0; i < nthreads; ++i)
|
||||
pool.execute(this);
|
||||
barrier.await();
|
||||
barrier.await();
|
||||
if (print) {
|
||||
long time = timer.getTime();
|
||||
long tpi = time / ((long)iters * nthreads);
|
||||
System.out.print("\t" + LoopHelpers.rightJustify(tpi) + " ns per lock");
|
||||
double secs = (double)time / 1000000000.0;
|
||||
System.out.println("\t " + secs + "s run time");
|
||||
}
|
||||
|
||||
int r = result;
|
||||
if (r == 0) // avoid overoptimization
|
||||
System.out.println("useless result: " + r);
|
||||
}
|
||||
|
||||
public final void run() {
|
||||
try {
|
||||
barrier.await();
|
||||
int sum = v;
|
||||
int x = 0;
|
||||
int n = iters;
|
||||
do {
|
||||
lock.lock();
|
||||
try {
|
||||
if ((n & 255) == 0)
|
||||
v = x = LoopHelpers.compute2(LoopHelpers.compute1(v));
|
||||
else
|
||||
v = x += ~(v - n);
|
||||
}
|
||||
finally {
|
||||
lock.unlock();
|
||||
}
|
||||
// Once in a while, do something more expensive
|
||||
if ((~n & 255) == 0) {
|
||||
sum += LoopHelpers.compute1(LoopHelpers.compute2(x));
|
||||
}
|
||||
else
|
||||
sum += sum ^ x;
|
||||
} while (n-- > 0);
|
||||
barrier.await();
|
||||
result += sum;
|
||||
}
|
||||
catch (Exception ex) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,133 @@
|
|||
/*
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file is available under and governed by the GNU General Public
|
||||
* License version 2 only, as published by the Free Software Foundation.
|
||||
* However, the following notice accompanied the original version of this
|
||||
* file:
|
||||
*
|
||||
* Written by Doug Lea with assistance from members of JCP JSR-166
|
||||
* Expert Group and released to the public domain, as explained at
|
||||
* http://creativecommons.org/publicdomain/zero/1.0/
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 4486658 5031862 8140471
|
||||
* @summary Checks for responsiveness of locks to timeouts.
|
||||
* @library /test/lib
|
||||
*/
|
||||
|
||||
import static java.util.concurrent.TimeUnit.MILLISECONDS;
|
||||
|
||||
import java.util.concurrent.CyclicBarrier;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.ThreadLocalRandom;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
import jdk.test.lib.Utils;
|
||||
|
||||
public final class TimeoutLockLoops {
|
||||
static final long LONG_DELAY_MS = Utils.adjustTimeout(10_000);
|
||||
static final ExecutorService pool = Executors.newCachedThreadPool();
|
||||
static boolean print = false;
|
||||
static final long TIMEOUT = 10;
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
int maxThreads = 8;
|
||||
if (args.length > 0)
|
||||
maxThreads = Integer.parseInt(args[0]);
|
||||
|
||||
print = true;
|
||||
|
||||
for (int i = 1; i <= maxThreads; i += (i+1) >>> 1) {
|
||||
System.out.print("Threads: " + i);
|
||||
new ReentrantLockLoop(i).test();
|
||||
}
|
||||
pool.shutdown();
|
||||
if (! pool.awaitTermination(LONG_DELAY_MS, MILLISECONDS))
|
||||
throw new Error();
|
||||
}
|
||||
|
||||
static final class ReentrantLockLoop implements Runnable {
|
||||
private int v = ThreadLocalRandom.current().nextInt();
|
||||
private volatile int result = 17;
|
||||
private final ReentrantLock lock = new ReentrantLock();
|
||||
private final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
|
||||
private final CyclicBarrier barrier;
|
||||
private final int nthreads;
|
||||
private volatile Throwable fail = null;
|
||||
ReentrantLockLoop(int nthreads) {
|
||||
this.nthreads = nthreads;
|
||||
barrier = new CyclicBarrier(nthreads+1, timer);
|
||||
}
|
||||
|
||||
final void test() throws Exception {
|
||||
for (int i = 0; i < nthreads; ++i) {
|
||||
lock.lock();
|
||||
pool.execute(this);
|
||||
lock.unlock();
|
||||
}
|
||||
barrier.await();
|
||||
Thread.sleep(ThreadLocalRandom.current().nextInt(5));
|
||||
while (!lock.tryLock()); // Jam lock
|
||||
// lock.lock();
|
||||
barrier.await();
|
||||
if (print) {
|
||||
long time = timer.getTime();
|
||||
double secs = (double)time / 1000000000.0;
|
||||
System.out.println("\t " + secs + "s run time");
|
||||
}
|
||||
|
||||
int r = result;
|
||||
if (r == 0) // avoid overoptimization
|
||||
System.out.println("useless result: " + r);
|
||||
if (fail != null) throw new RuntimeException(fail);
|
||||
}
|
||||
|
||||
public final void run() {
|
||||
try {
|
||||
barrier.await();
|
||||
int sum = v;
|
||||
int x = 17;
|
||||
final ReentrantLock lock = this.lock;
|
||||
while (lock.tryLock(TIMEOUT, TimeUnit.MILLISECONDS)) {
|
||||
try {
|
||||
v = x = LoopHelpers.compute1(v);
|
||||
}
|
||||
finally {
|
||||
lock.unlock();
|
||||
}
|
||||
sum += LoopHelpers.compute2(x);
|
||||
}
|
||||
barrier.await();
|
||||
result += sum;
|
||||
}
|
||||
catch (Throwable ex) {
|
||||
fail = ex;
|
||||
throw new RuntimeException(ex);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue