java-jvm-jstack-线程状态
常见的线程状态:
RUNNABLE：正在执行的线程
注意：这里执行是针对jvm来说的，并非真的在cpu上执行，这要看操作系统处理器是否有机会
BLOCKED:阻塞的线程
注意：阻塞的线程一般是拿不到监视器锁（a monitor lock），比如：synchronized block/method，ReentrantLock.lock()
jstack一般显示为：
"Thread-0" prio=6 tid=0x000000000b67f800 nid=0x40d0 waiting on condition [0x000000000da7f000]
java.lang.Thread.State: TIMED_WAITING (sleeping)
at java.lang.Thread.sleep(Native Method)
at Test$1.run(Test.java:26)
- locked <0x00000007d5df43f8> (a java.util.HashMap)
"main" prio=6 tid=0x00000000021cf000 nid=0x1870 waiting for monitor entry [0x000000000262f000]
java.lang.Thread.State: BLOCKED (on object monitor)
at Test.test1(Test.java:39)
- waiting to lock <0x00000007d5df43f8> (a java.util.HashMap)
at Test.main(Test.java:7)
分析：
Thread-0：
1、拿到了锁并且没有释放：locked <0x00000007d5df43f8> (a java.util.HashMap)
2、线程调用了sleep方法，java.lang.Thread.State: TIMED_WAITING (sleeping)
main线程：
1、java.lang.Thread.State: BLOCKED (on object monitor)：因为锁被Thread-0 占用，拿不到锁( waiting for monitor entry)，进入 BLOCKED 状态
2、waiting to lock <0x00000007d5df43f8> (a java.util.HashMap)：首先锁的编号是：0x00000007d5df43f8，锁的对象是HashMap (a java.util.HashMap)
总结：
1、这种方式可以轻松分析出来 BLOCKED 的线程是被那个锁阻塞的
2、从代码的输出可以看出：线程Thread-0 持有锁，进入sleep后，不会释放锁，否则main线程的（##############） 会输出
3、echo "obase=10;ibase=16;40D0"|bc ； 输出为：16592，可以定位线程id
java 代码为：
private static void test1() throws Exception {
final Map<String, User> map = new HashMap<String, User>();
new Thread() {
@Override
public void run() {
synchronized (map) {
try {
System.out.println("***************");
System.out.println("map: " +Long.toHexString(map.hashCode()));
System.out.println("map: " +(map));
System.out.println("newThread: " +(Thread.currentThread().getId()));
System.out.println("newThread: " +Long.toHexString(Thread.currentThread().getId()));
System.out.println("newThread: " +Long.toHexString(Thread.currentThread().hashCode()));
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
Thread.sleep(10000);
System.out.println("mainThread: " +(Thread.currentThread().getId()));
System.out.println("mainThread: " +Long.toHexString(Thread.currentThread().getId()));
System.out.println("mainThread: " +Long.toHexString(Thread.currentThread().hashCode()));
synchronized (map) {
System.out.println("##############");
map.wait();
}
int i = 0;
while (true) {
map.put("value" + i, new User(i));
i++;
if (map.size() > 1000000) {
map.clear();
}
}
}
输出：
***************
map: 0
map: {}
newThread: 9
newThread: 9
newThread: 64afb650
mainThread: 1
mainThread: 1
mainThread: 138b9a72
WAITING:等待状态
一般以下三种调用：
Object.wait with no timeout
Thread.join with no timeout
LockSupport.park
jstack一般显示为：
"Thread-0" prio=6 tid=0x000000000d447000 nid=0x31b8 in Object.wait() [0x000000000da8f000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000007d5df43f8> (a java.util.HashMap)
at java.lang.Object.wait(Object.java:503)
at Test$2.run(Test.java:65)
- locked <0x00000007d5df43f8> (a java.util.HashMap)
"main" prio=6 tid=0x000000000238f000 nid=0x372c in Object.wait() [0x000000000279f000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000007d5df43f8> (a java.util.HashMap)
at java.lang.Object.wait(Object.java:503)
at Test.test2(Test.java:78)
- locked <0x00000007d5df43f8> (a java.util.HashMap)
at Test.main(Test.java:7)
分析：
1、Thread-0 和 main 线程 都是因为调用 wait() 方法 进入阻塞的
2、他们都拿到了锁：locked <0x00000007d5df43f8> (a java.util.HashMap)
3、java.lang.Thread.State: WAITING (on object monitor)：他们都在等待 对象监视器（on object monitor)的通知
4、从代码的输出可以看出：线程进入wait后，会释放锁，否则（##############） 不会输出
5、0x000000000da8f000，0x000000000279f000 的值的含义为：线程的起始栈地址
java代码：
private static void test2() throws Exception {
final Map<String, User> map = new HashMap<String, User>();
new Thread() {
@Override
public void run() {
synchronized (map) {
try {
System.out.println("***************");
System.out.println("newThread: " +Long.toHexString(Thread.currentThread().getId()));
System.out.println("newThread: " +Long.toHexString(Thread.currentThread().hashCode()));
map.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
Thread.sleep(10000);
System.out.println("mainThread: " +Long.toHexString(Thread.currentThread().getId()));
System.out.println("mainThread: " +Long.toHexString(Thread.currentThread().hashCode()));
synchronized (map) {
System.out.println("##############");
map.wait();
}
int i = 0;
while (true) {
map.put("value" + i, new User(i));
i++;
if (map.size() > 1000000) {
map.clear();
}
}
}
输出：
***************
newThread: 9
newThread: 517c804b
mainThread: 1
mainThread: 138b9a72
##############
TIMED_WAITING：等待特定时间
情况分析(Block的时候已经有说明)
Thread.sleep
Object.wait with timeout
Thread.join with timeout
LockSupport.parkNanos
LockSupport.parkUntil
jvm的线程的状态定义如下：
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
上一篇： thinkphp修改代码后如何立即生效
下一篇： CLI方式。能不能修改已经输出的内容