public static void main(String[] args) {
// Create a thread pool with two threads
ExecutorService executor = Executors.newFixedThreadPool(2);
System.out.println("Thread 1\t\tThread 2\t\tBalance");
executor.execute(new DepositTask());
executor.execute(new WithDrawTask());
executor.shutdown();
}
public final class CancelledFutureLoops {
static final ExecutorService pool = Executors.newCachedThreadPool();
static final LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
static boolean print = false;
static final int ITERS = 1000000;
static final long TIMEOUT = 100;
public static void main(String[] args) throws Exception {
int maxThreads = 5;
if (args.length > 0) maxThreads = Integer.parseInt(args[0]);
print = true;
for (int i = 2; i <= maxThreads; i += (i + 1) >>> 1) {
System.out.print("Threads: " + i);
try {
new FutureLoop(i).test();
} catch (BrokenBarrierException bb) {
// OK; ignore
} catch (ExecutionException ee) {
// OK; ignore
}
Thread.sleep(TIMEOUT);
}
pool.shutdown();
if (!pool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS)) throw new Error();
}
static final class FutureLoop implements Callable {
private int v = rng.next();
private final ReentrantLock lock = new ReentrantLock();
private final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
private final CyclicBarrier barrier;
private final int nthreads;
FutureLoop(int nthreads) {
this.nthreads = nthreads;
barrier = new CyclicBarrier(nthreads + 1, timer);
}
final void test() throws Exception {
Future[] futures = new Future[nthreads];
for (int i = 0; i < nthreads; ++i) futures[i] = pool.submit(this);
barrier.await();
Thread.sleep(TIMEOUT);
boolean tooLate = false;
for (int i = 1; i < nthreads; ++i) {
if (!futures[i].cancel(true)) tooLate = true;
// Unbunch some of the cancels
if ((i & 3) == 0) Thread.sleep(1 + rng.next() % 10);
}
Object f0 = futures[0].get();
if (!tooLate) {
for (int i = 1; i < nthreads; ++i) {
if (!futures[i].isDone() || !futures[i].isCancelled())
throw new Error("Only one thread should complete");
}
} else System.out.print("(cancelled too late) ");
long endTime = System.nanoTime();
long time = endTime - timer.startTime;
if (print) {
double secs = (double) (time) / 1000000000.0;
System.out.println("\t " + secs + "s run time");
}
}
public final Object call() throws Exception {
barrier.await();
int sum = v;
int x = 0;
int n = ITERS;
while (n-- > 0) {
lock.lockInterruptibly();
try {
v = x = LoopHelpers.compute1(v);
} finally {
lock.unlock();
}
sum += LoopHelpers.compute2(LoopHelpers.compute2(x));
}
return new Integer(sum);
}
}
}
public class TimedAcquireLeak {
static String javahome() {
String jh = System.getProperty("java.home");
return (jh.endsWith("jre")) ? jh.substring(0, jh.length() - 4) : jh;
}
static final File bin = new File(javahome(), "bin");
static String javaProgramPath(String programName) {
return new File(bin, programName).getPath();
}
static final String java = javaProgramPath("java");
static final String jmap = javaProgramPath("jmap");
static final String jps = javaProgramPath("jps");
static String outputOf(Reader r) throws IOException {
final StringBuilder sb = new StringBuilder();
final char[] buf = new char[1024];
int n;
while ((n = r.read(buf)) > 0) sb.append(buf, 0, n);
return sb.toString();
}
static String outputOf(InputStream is) throws IOException {
return outputOf(new InputStreamReader(is, "UTF-8"));
}
static final ExecutorService drainers = Executors.newFixedThreadPool(12);
static Future<String> futureOutputOf(final InputStream is) {
return drainers.submit(
new Callable<String>() {
public String call() throws IOException {
return outputOf(is);
}
});
}
static String outputOf(final Process p) {
try {
Future<String> outputFuture = futureOutputOf(p.getInputStream());
Future<String> errorFuture = futureOutputOf(p.getErrorStream());
final String output = outputFuture.get();
final String error = errorFuture.get();
// Check for successful process completion
equal(error, "");
equal(p.waitFor(), 0);
equal(p.exitValue(), 0);
return output;
} catch (Throwable t) {
unexpected(t);
throw new Error(t);
}
}
static String commandOutputOf(String... cmd) {
try {
return outputOf(new ProcessBuilder(cmd).start());
} catch (Throwable t) {
unexpected(t);
throw new Error(t);
}
}
// To be called exactly twice by the parent process
static <T> T rendezvousParent(Process p, Callable<T> callable) throws Throwable {
p.getInputStream().read();
T result = callable.call();
OutputStream os = p.getOutputStream();
os.write((byte) '\n');
os.flush();
return result;
}
// To be called exactly twice by the child process
public static void rendezvousChild() {
try {
for (int i = 0; i < 100; i++) {
System.gc();
System.runFinalization();
Thread.sleep(50);
}
System.out.write((byte) '\n');
System.out.flush();
System.in.read();
} catch (Throwable t) {
throw new Error(t);
}
}
static String match(String s, String regex, int group) {
Matcher matcher = Pattern.compile(regex).matcher(s);
matcher.find();
return matcher.group(group);
}
static int objectsInUse(final Process child, final String childPid, final String className) {
final String regex = "(?m)^ *[0-9]+: +([0-9]+) +[0-9]+ +\\Q" + className + "\\E$";
final Callable<Integer> objectsInUse =
new Callable<Integer>() {
public Integer call() {
Integer i =
Integer.parseInt(match(commandOutputOf(jmap, "-histo:live", childPid), regex, 1));
if (i > 100)
System.out.print(commandOutputOf(jmap, "-dump:file=dump,format=b", childPid));
return i;
}
};
try {
return rendezvousParent(child, objectsInUse);
} catch (Throwable t) {
unexpected(t);
return -1;
}
}
static void realMain(String[] args) throws Throwable {
// jmap doesn't work on Windows
if (System.getProperty("os.name").startsWith("Windows")) return;
final String childClassName = Job.class.getName();
final String classToCheckForLeaks = Job.classToCheckForLeaks();
final String uniqueID = String.valueOf(new Random().nextInt(Integer.MAX_VALUE));
final String[] jobCmd = {
java,
"-Xmx8m",
"-classpath",
System.getProperty("test.classes", "."),
childClassName,
uniqueID
};
final Process p = new ProcessBuilder(jobCmd).start();
final String childPid =
match(
commandOutputOf(jps, "-m"),
"(?m)^ *([0-9]+) +\\Q" + childClassName + "\\E *" + uniqueID + "$",
1);
final int n0 = objectsInUse(p, childPid, classToCheckForLeaks);
final int n1 = objectsInUse(p, childPid, classToCheckForLeaks);
equal(p.waitFor(), 0);
equal(p.exitValue(), 0);
failed += p.exitValue();
// Check that no objects were leaked.
System.out.printf("%d -> %d%n", n0, n1);
check(Math.abs(n1 - n0) < 2); // Almost always n0 == n1
check(n1 < 20);
drainers.shutdown();
}
// ----------------------------------------------------------------
// The main class of the child process.
// Job's job is to:
// - provide the name of a class to check for leaks.
// - call rendezvousChild exactly twice, while quiescent.
// - in between calls to rendezvousChild, run code that may leak.
// ----------------------------------------------------------------
public static class Job {
static String classToCheckForLeaks() {
return "java.util.concurrent.locks.AbstractQueuedSynchronizer$Node";
}
public static void main(String[] args) throws Throwable {
final ReentrantLock lock = new ReentrantLock();
lock.lock();
final ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();
final ReentrantReadWriteLock.ReadLock readLock = rwlock.readLock();
final ReentrantReadWriteLock.WriteLock writeLock = rwlock.writeLock();
rwlock.writeLock().lock();
final BlockingQueue<Object> q = new LinkedBlockingQueue<Object>();
final Semaphore fairSem = new Semaphore(0, true);
final Semaphore unfairSem = new Semaphore(0, false);
// final int threads =
// rnd.nextInt(Runtime.getRuntime().availableProcessors() + 1) + 1;
final int threads = 3;
// On Linux, this test runs very slowly for some reason,
// so use a smaller number of iterations.
// Solaris can handle 1 << 18.
// On the other hand, jmap is much slower on Solaris...
final int iterations = 1 << 8;
final CyclicBarrier cb = new CyclicBarrier(threads + 1);
for (int i = 0; i < threads; i++)
new Thread() {
public void run() {
try {
final Random rnd = new Random();
for (int j = 0; j < iterations; j++) {
if (j == iterations / 10 || j == iterations - 1) {
cb.await(); // Quiesce
cb.await(); // Resume
}
// int t = rnd.nextInt(2000);
int t = rnd.nextInt(900);
check(!lock.tryLock(t, NANOSECONDS));
check(!readLock.tryLock(t, NANOSECONDS));
check(!writeLock.tryLock(t, NANOSECONDS));
equal(null, q.poll(t, NANOSECONDS));
check(!fairSem.tryAcquire(t, NANOSECONDS));
check(!unfairSem.tryAcquire(t, NANOSECONDS));
}
} catch (Throwable t) {
unexpected(t);
}
}
}.start();
cb.await(); // Quiesce
rendezvousChild(); // Measure
cb.await(); // Resume
cb.await(); // Quiesce
rendezvousChild(); // Measure
cb.await(); // Resume
System.exit(failed);
}
// If something goes wrong, we might never see it, since IO
// streams are connected to the parent. So we need a special
// purpose print method to debug Jobs.
static void debugPrintf(String format, Object... args) {
try {
new PrintStream(new FileOutputStream("/dev/tty")).printf(format, args);
} catch (Throwable t) {
throw new Error(t);
}
}
}
// --------------------- Infrastructure ---------------------------
static volatile int passed = 0, failed = 0;
static void pass() {
passed++;
}
static void fail() {
failed++;
Thread.dumpStack();
}
static void fail(String msg) {
System.out.println(msg);
fail();
}
static void unexpected(Throwable t) {
failed++;
t.printStackTrace();
}
static void check(boolean cond) {
if (cond) pass();
else fail();
}
static void check(boolean cond, String m) {
if (cond) pass();
else fail(m);
}
static void equal(Object x, Object y) {
if (x == null ? y == null : x.equals(y)) pass();
else fail(x + " not equal to " + y);
}
public static void main(String[] args) throws Throwable {
try {
realMain(args);
} catch (Throwable t) {
unexpected(t);
}
System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
if (failed > 0) throw new AssertionError("Some tests failed");
}
}