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,422 @@
|
|||
/*
|
||||
* Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 4530538
|
||||
* @summary Basic unit test of the synchronization statistics support:
|
||||
* @author Mandy Chung
|
||||
* @author Jaroslav Bachorik
|
||||
*
|
||||
* @run main/othervm SynchronizationStatistics
|
||||
*/
|
||||
|
||||
import java.lang.management.*;
|
||||
import java.util.concurrent.Phaser;
|
||||
import java.util.function.Supplier;
|
||||
|
||||
public class SynchronizationStatistics {
|
||||
private static class LockerThread extends Thread {
|
||||
public LockerThread(Runnable r) {
|
||||
super(r, "LockerThread");
|
||||
}
|
||||
}
|
||||
|
||||
private static final ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
|
||||
|
||||
private static final boolean blockedTimeCheck =
|
||||
mbean.isThreadContentionMonitoringSupported();
|
||||
|
||||
|
||||
public static void main(String args[]) throws Exception {
|
||||
if (blockedTimeCheck) {
|
||||
mbean.setThreadContentionMonitoringEnabled(true);
|
||||
}
|
||||
|
||||
if (!mbean.isThreadContentionMonitoringEnabled()) {
|
||||
throw new RuntimeException("TEST FAILED: " +
|
||||
"Thread Contention Monitoring is not enabled");
|
||||
}
|
||||
|
||||
testBlockingOnSimpleMonitor();
|
||||
testBlockingOnNestedMonitor();
|
||||
testWaitingOnSimpleMonitor();
|
||||
testMultiWaitingOnSimpleMonitor();
|
||||
testWaitingOnNestedMonitor();
|
||||
|
||||
System.out.println("Test passed.");
|
||||
}
|
||||
|
||||
private static LockerThread newLockerThread(Runnable r) {
|
||||
LockerThread t = new LockerThread(r);
|
||||
t.setDaemon(true);
|
||||
return t;
|
||||
}
|
||||
|
||||
private static void waitForThreadState(Thread t, Thread.State state) throws InterruptedException {
|
||||
while (t.getState() != state) {
|
||||
Thread.sleep(3);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests that blocking on a single monitor properly increases the
|
||||
* blocked count at least by 1. Also asserts that the correct lock name is provided.
|
||||
*/
|
||||
private static void testBlockingOnSimpleMonitor() throws Exception {
|
||||
System.out.println("testBlockingOnSimpleMonitor");
|
||||
final Object lock1 = new Object();
|
||||
System.out.println("Lock1 = " + lock1);
|
||||
|
||||
final Phaser p = new Phaser(2);
|
||||
LockerThread lt = newLockerThread(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
p.arriveAndAwaitAdvance(); // phase[1]
|
||||
synchronized(lock1) {
|
||||
System.out.println("[LockerThread obtained Lock1]");
|
||||
p.arriveAndAwaitAdvance(); // phase[2]
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[3]
|
||||
}
|
||||
});
|
||||
|
||||
lt.start();
|
||||
long tid = lt.getId();
|
||||
ThreadInfo ti = mbean.getThreadInfo(tid);
|
||||
String lockName = null;
|
||||
synchronized(lock1) {
|
||||
p.arriveAndAwaitAdvance(); // phase[1]
|
||||
waitForThreadState(lt, Thread.State.BLOCKED);
|
||||
do {
|
||||
lockName = mbean.getThreadInfo(tid).getLockName();
|
||||
} while (lockName == null);
|
||||
}
|
||||
|
||||
p.arriveAndAwaitAdvance(); // phase[2]
|
||||
testBlocked(ti, () -> mbean.getThreadInfo(tid), lockName, lock1);
|
||||
p.arriveAndDeregister(); // phase[3]
|
||||
|
||||
lt.join();
|
||||
|
||||
printok();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests that blocking on a nested monitor properly increases the
|
||||
* blocked count at least by 1 - it is not affected by the nesting depth.
|
||||
* Also asserts that the correct lock name is provided.
|
||||
*/
|
||||
private static void testBlockingOnNestedMonitor() throws Exception {
|
||||
System.out.println("testBlockingOnNestedMonitor");
|
||||
final Object lock1 = new Object();
|
||||
final Object lock2 = new Object();
|
||||
|
||||
System.out.println("Lock1 = " + lock1);
|
||||
System.out.println("Lock2 = " + lock2);
|
||||
|
||||
final Phaser p = new Phaser(2);
|
||||
LockerThread lt = newLockerThread(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
p.arriveAndAwaitAdvance(); // phase[1]
|
||||
synchronized(lock1) {
|
||||
System.out.println("[LockerThread obtained Lock1]");
|
||||
p.arriveAndAwaitAdvance(); // phase[2]
|
||||
p.arriveAndAwaitAdvance(); // phase[3]
|
||||
synchronized(lock2) {
|
||||
System.out.println("[LockerThread obtained Lock2]");
|
||||
p.arriveAndAwaitAdvance(); // phase[4]
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[5]
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
lt.start();
|
||||
long tid = lt.getId();
|
||||
ThreadInfo ti = mbean.getThreadInfo(tid);
|
||||
String lockName = null;
|
||||
synchronized(lock1) {
|
||||
p.arriveAndAwaitAdvance(); // phase[1]
|
||||
waitForThreadState(lt, Thread.State.BLOCKED);
|
||||
do {
|
||||
lockName = mbean.getThreadInfo(tid).getLockName();
|
||||
} while (lockName == null);
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[2]
|
||||
|
||||
ti = testBlocked(ti, () -> mbean.getThreadInfo(tid), lockName, lock1);
|
||||
|
||||
synchronized(lock2) {
|
||||
p.arriveAndAwaitAdvance(); // phase [3]
|
||||
waitForThreadState(lt, Thread.State.BLOCKED);
|
||||
do {
|
||||
lockName = mbean.getThreadInfo(tid).getLockName();
|
||||
} while (lockName == null);
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase [4]
|
||||
testBlocked(ti, () -> mbean.getThreadInfo(tid), lockName, lock2);
|
||||
p.arriveAndDeregister();
|
||||
|
||||
lt.join();
|
||||
|
||||
printok();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests that waiting on a single monitor properly increases the waited
|
||||
* count by 1 and the waited time by a positive number.
|
||||
*/
|
||||
private static void testWaitingOnSimpleMonitor() throws Exception {
|
||||
System.out.println("testWaitingOnSimpleMonitor");
|
||||
final Object lock1 = new Object();
|
||||
final Phaser p = new Phaser(2);
|
||||
LockerThread lt = newLockerThread(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
p.arriveAndAwaitAdvance(); // phase[1]
|
||||
synchronized(lock1) {
|
||||
System.out.println("[LockerThread obtained Lock1]");
|
||||
try {
|
||||
lock1.wait(300);
|
||||
} catch (InterruptedException ex) {
|
||||
// ignore
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[2]
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[3]
|
||||
}
|
||||
});
|
||||
|
||||
lt.start();
|
||||
ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
|
||||
synchronized(lock1) {
|
||||
p.arriveAndAwaitAdvance(); // phase[1]
|
||||
waitForThreadState(lt, Thread.State.BLOCKED);
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[2]
|
||||
|
||||
testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 1);
|
||||
p.arriveAndDeregister(); // phase[3]
|
||||
|
||||
lt.join();
|
||||
|
||||
printok();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests that waiting multiple times on the same monitor subsequently
|
||||
* increases the waited count by the number of subsequent calls and the
|
||||
* waited time by a positive number.
|
||||
*/
|
||||
private static void testMultiWaitingOnSimpleMonitor() throws Exception {
|
||||
System.out.println("testWaitingOnMultipleMonitors");
|
||||
final Object lock1 = new Object();
|
||||
|
||||
final Phaser p = new Phaser(2);
|
||||
LockerThread lt = newLockerThread(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
p.arriveAndAwaitAdvance(); // phase[1]
|
||||
synchronized(lock1) {
|
||||
System.out.println("[LockerThread obtained Lock1]");
|
||||
for (int i = 0; i < 3; i++) {
|
||||
try {
|
||||
lock1.wait(300);
|
||||
} catch (InterruptedException ex) {
|
||||
// ignore
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[2-4]
|
||||
}
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[5]
|
||||
}
|
||||
});
|
||||
|
||||
lt.start();
|
||||
ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
|
||||
synchronized(lock1) {
|
||||
p.arriveAndAwaitAdvance(); //phase[1]
|
||||
waitForThreadState(lt, Thread.State.BLOCKED);
|
||||
}
|
||||
int phase = p.getPhase();
|
||||
while ((p.arriveAndAwaitAdvance() - phase) < 3); // phase[2-4]
|
||||
|
||||
testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 3);
|
||||
p.arriveAndDeregister(); // phase[5]
|
||||
|
||||
lt.join();
|
||||
|
||||
printok();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests that waiting on monitors places in nested synchronized blocks
|
||||
* properly increases the waited count by the number of times the "lock.wait()"
|
||||
* was invoked and the waited time by a positive number.
|
||||
*/
|
||||
private static void testWaitingOnNestedMonitor() throws Exception {
|
||||
System.out.println("testWaitingOnNestedMonitor");
|
||||
final Object lock1 = new Object();
|
||||
final Object lock2 = new Object();
|
||||
final Object lock3 = new Object();
|
||||
|
||||
final Phaser p = new Phaser(2);
|
||||
LockerThread lt = newLockerThread(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
p.arriveAndAwaitAdvance(); // phase[1]
|
||||
synchronized(lock1) {
|
||||
System.out.println("[LockerThread obtained Lock1]");
|
||||
try {
|
||||
lock1.wait(300);
|
||||
} catch (InterruptedException ex) {
|
||||
// ignore
|
||||
}
|
||||
|
||||
p.arriveAndAwaitAdvance(); // phase[2]
|
||||
synchronized(lock2) {
|
||||
System.out.println("[LockerThread obtained Lock2]");
|
||||
try {
|
||||
lock2.wait(300);
|
||||
} catch (InterruptedException ex) {
|
||||
// ignore
|
||||
}
|
||||
|
||||
p.arriveAndAwaitAdvance(); // phase[3]
|
||||
synchronized(lock3) {
|
||||
System.out.println("[LockerThread obtained Lock3]");
|
||||
try {
|
||||
lock3.wait(300);
|
||||
} catch (InterruptedException ex) {
|
||||
// ignore
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[4]
|
||||
}
|
||||
}
|
||||
}
|
||||
p.arriveAndAwaitAdvance(); // phase[5]
|
||||
}
|
||||
});
|
||||
|
||||
lt.start();
|
||||
ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
|
||||
synchronized(lock1) {
|
||||
p.arriveAndAwaitAdvance(); // phase[1]
|
||||
waitForThreadState(lt, Thread.State.BLOCKED);
|
||||
}
|
||||
|
||||
synchronized(lock2) {
|
||||
p.arriveAndAwaitAdvance(); // phase[2]
|
||||
waitForThreadState(lt, Thread.State.BLOCKED);
|
||||
}
|
||||
|
||||
synchronized(lock3) {
|
||||
p.arriveAndAwaitAdvance(); // phase[3]
|
||||
waitForThreadState(lt, Thread.State.BLOCKED);
|
||||
}
|
||||
|
||||
p.arriveAndAwaitAdvance(); // phase[4]
|
||||
testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 3);
|
||||
p.arriveAndDeregister(); // phase[5]
|
||||
|
||||
lt.join();
|
||||
printok();
|
||||
}
|
||||
|
||||
private static void printok() {
|
||||
System.out.println("OK\n");
|
||||
}
|
||||
|
||||
private static void testWaited(ThreadInfo ti1, Supplier<ThreadInfo> ti2, int waited)
|
||||
throws InterruptedException {
|
||||
boolean error;
|
||||
do {
|
||||
error = false;
|
||||
ThreadInfo ti = ti2.get();
|
||||
long waitCntDiff = ti.getWaitedCount() - ti1.getWaitedCount();
|
||||
long waitTimeDiff = ti.getWaitedTime() - ti1.getWaitedTime();
|
||||
if (waitCntDiff < waited) {
|
||||
System.err.println(
|
||||
"Unexpected diff in waited count. Expecting at least "
|
||||
+ waited + " , got " + waitCntDiff
|
||||
);
|
||||
error = true;
|
||||
}
|
||||
if (waitTimeDiff <= 0) {
|
||||
System.err.println(
|
||||
"Unexpected diff in waited time. Expecting increasing " +
|
||||
"value, got " + waitTimeDiff + "ms"
|
||||
);
|
||||
error = true;
|
||||
}
|
||||
if (error) {
|
||||
System.err.println("Retrying in 20ms ...");
|
||||
Thread.sleep(20);
|
||||
}
|
||||
} while (error);
|
||||
}
|
||||
|
||||
private static ThreadInfo testBlocked(ThreadInfo ti1, Supplier<ThreadInfo> ti2,
|
||||
String lockName, final Object lock)
|
||||
throws InterruptedException {
|
||||
boolean error;
|
||||
ThreadInfo ti = null;
|
||||
do {
|
||||
error = false;
|
||||
ti = ti2.get();
|
||||
long blkCntDiff = ti.getBlockedCount() - ti1.getBlockedCount();
|
||||
long blkTimeDiff = ti.getBlockedTime() - ti1.getBlockedTime();
|
||||
|
||||
System.out.println("testBlocked: [" + blkCntDiff + ", " + blkTimeDiff + ", " + lockName + "]");
|
||||
|
||||
if (blkCntDiff < 1) {
|
||||
System.err.println(
|
||||
"Unexpected diff in blocked count. Expecting at least 1, " +
|
||||
"got " + blkCntDiff
|
||||
);
|
||||
error = true;
|
||||
}
|
||||
if (blkTimeDiff < 0) {
|
||||
System.err.println(
|
||||
"Unexpected diff in blocked time. Expecting a positive " +
|
||||
"number, got " + blkTimeDiff
|
||||
);
|
||||
error = true;
|
||||
}
|
||||
if (!lockName.equals(lock.toString())) {
|
||||
System.err.println(
|
||||
"Unexpected blocked monitor name. Expecting " +
|
||||
lock.toString() + ", got " + lockName
|
||||
);
|
||||
error = true;
|
||||
}
|
||||
if (error) {
|
||||
System.err.println("Retrying in 20ms ...");
|
||||
Thread.sleep(20);
|
||||
}
|
||||
} while (error);
|
||||
return ti;
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue