1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
/*
* Copyright (c) 2007, 2018, 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.
*/
package nsk.monitoring.share.thread;
import nsk.share.log.Log;
import java.lang.management.ThreadInfo;
import java.lang.management.MonitorInfo;
import java.lang.management.LockInfo;
import nsk.share.TestBug;
import nsk.share.test.LocalRandom;
import nsk.monitoring.share.Monitoring;
/**
* BlockedThread is RecursiveMonitoringThread that blocks on entering
* synchronized section.
*/
public class BlockedThread extends RecursiveMonitoringThread {
private LockerThread lockerThread;
protected Object lock;
protected Object readyLock = new Object();
protected volatile boolean ready = false;
private static final String[] expectedMethods = {
"nsk.monitoring.share.thread.BlockedThread.runInside"
};
public BlockedThread(Log log, RunType recursionType, int maxDepth, LockerThread lockerThread) {
super(log, recursionType, maxDepth);
this.lockerThread = lockerThread;
this.lock = lockerThread.getLock();
}
public void checkThreadInfo(ThreadInfo info) {
super.checkThreadInfo(info);
verify(info.getThreadState() == Thread.State.BLOCKED, "ThreadInfo.getThreadState() = " + info.getThreadState() + " != " + Thread.State.BLOCKED);
verify(info.getBlockedTime() == 0 || info.getBlockedTime() == -1, "ThreadInfo.getBlockedTime() == " + info.getBlockedTime());
verify(info.getBlockedCount() >= 1, "ThreadInfo.getBlockedCount() = " + info.getBlockedCount() + " != " + 1);
verify(info.getWaitedTime() == 0 || info.getWaitedTime() == -1, "ThreadInfo.getWaitedTime() == " + info.getWaitedTime());
verify(info.getWaitedCount() == 0, "ThreadInfo.getWaitedCount() = " + info.getWaitedCount() + " != " + 0);
checkLockInfo(info.getLockInfo(), lock);
verify(info.getLockName().equals(info.getLockInfo().toString()), "ThreadInfo.getLockName() = " + info.getLockName() + " != lock.toString() = " + lock.toString());
verify(info.getLockOwnerId() == lockerThread.getId(), "ThreadInfo.getLockOwnerId() = " + info.getLockOwnerId() + " != this.getId() = " + this.getId());
verify(info.getLockOwnerName().equals(lockerThread.getName()), "ThreadInfo.getLockOwnerName() = " + info.getLockOwnerName() + " != lockerThread.getName() = " + lockerThread.getName());
checkMonitorInfo(info.getLockedMonitors(), null);
checkSynchronizers(info.getLockedSynchronizers(), null);
}
private void checkStackTrace(MonitorInfo[] minfo, StackTraceElement[] elements) {
verify(minfo.length == 1, "ThreadInfo.getLockedMonitors() is of length " + minfo.length);
MonitorInfo minfo1 = minfo[0];
verify(minfo1.getLockedStackDepth() == elements.length, "MonitorInfo.getLockedStackDepth() = " + minfo1.getLockedStackDepth() + " != elements.length = " + elements.length);
verify(minfo1.getLockedStackFrame().equals(elements[elements.length - 1]), "MonitorInfo.getLockedStackFrame() = " + minfo1.getLockedStackFrame() + " is different from last element " + elements[elements.length - 1]);
checkLockInfo(minfo1, lock);
}
public void waitState() {
synchronized (readyLock) {
while (!ready) {
try {
readyLock.wait();
} catch (InterruptedException e) {
log.warn(e);
}
}
}
waitThreadState(Thread.State.BLOCKED);
}
public void finish() {
ready = false;
synchronized (lock) {
lock.notify();
}
}
protected void runInside() {
synchronized (readyLock) {
ready = true;
readyLock.notifyAll();
}
do {
synchronized (lock) {
System.out.println("BlockedThread acquired lock");
// Actually, this thread will reach here after LockerThread.finish() is called,
// but before finish() is called. But it does not matter, because check(ThreadInfo)
// was already called.
}
System.out.println("BlockedThread relinquished lock");
} while (ready);
}
protected boolean isStackTraceElementExpected(StackTraceElement element) {
return super.isStackTraceElementExpected(element) || checkStackTraceElement(element, expectedMethods);
}
}
|
