jps

需要用到j(luò)ps來顯示相關(guān)詳細(xì)信息。

命令格式：jps [options ] [ hostid ]
[options]選項(xiàng) ：
-l：輸出啟動(dòng)jar的完全路徑名
-m：輸出main method的參數(shù)
-v：輸出jvm參數(shù)
https://blog.csdn.net/wisgood/article/details/38942449

CPU占用率過大

1.top命令查看當(dāng)前CPU情況

top -H -p2023
說明： -H 指顯示線程，-p 是指定進(jìn)程

2.可以看到CPU占用較高的線程，記下PID （ 此處的PID即為線程ID標(biāo)識(shí)） ，將其從十進(jìn)制轉(zhuǎn)成十六進(jìn)制表示

3.通過jstack命令獲取當(dāng)前進(jìn)程的所有線程棧，可暫時(shí)保存到一個(gè)文件tempfile.txt中：

jstack -l 2023 > tempfile.txt
2023是進(jìn)程id 

4.在tempfile.txt中查找nid=0x7f1（2023的十六進(jìn)制）的線程

https://my.oschina.net/shipley/blog/520062
如何使用jstack分析線程狀態(tài) - 簡(jiǎn)書

頻繁 Full GC

thread dump鎖分析

下面對(duì)比一下synchronized和java.util.concurrent的區(qū)別

synchronized方式

[得到鎖]
state：RUNNABLE locked
[被阻塞]
state：BLOCKED waiting to lock
[調(diào)用wait]
state：WAITING waiting on
如何使用jstack分析線程狀態(tài) - 簡(jiǎn)書

java.util.concurrent方式

[得到鎖]
顯示waiting on condition和Locked ownable synchronizers
[被阻塞]
state：WAITING(parking) parking to wait for
[調(diào)用await]
state：WAITING parking to wait for
Java thread dump: Difference between “waiting to lock” and “parking to wait for”?

進(jìn)一步可以參考關(guān)于兩者區(qū)別。下面用例子來展示加鎖后兩者區(qū)別，都分別加了兩次鎖（加兩次鎖的原因是為更好展示stack）：

package com.tom;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class LockTest {

    Lock lock1 = new ReentrantLock(true);
    Lock lock2 = new ReentrantLock(true);
    Condition condition = lock1.newCondition();
    Object objLock = new Object();

    @Test
    public void test() {
        reentrantLock();
        sync();

        try {
            Thread.sleep(100000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    void reentrantLock() {
        Thread th = new Thread(new Runnable() {
            public void run() {

                lock1.lock();
                try {
                    lock2.lock();

                    try {
                        try {
                            Thread.sleep(100000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } finally {
                        lock2.unlock();
                    }
                } finally {
                    lock1.unlock();
                }

            }
        }, "reentrantLock");
        th.start();
    }

    void sync() {
        Thread th = new Thread(new Runnable() {
            public void run() {

                // 這個(gè)代碼是測(cè)試dump從哪開始記錄
                int i = 0;

                // 加鎖
                doSync1();
            }
        }, "Sync");
        th.start();
    }

    synchronized void doSync1() {
        doSync2();
    }

    void doSync2() {
        synchronized (objLock) {
            try {
                objLock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

線程stack

"Sync" #14 prio=5 os_prio=0 tid=0x000000001de3e800 nid=0x147f48 in Object.wait() [0x000000001e7be000]
   java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x0000000781025470> (a java.lang.Object)    // 調(diào)用wait()后
    at java.lang.Object.wait(Object.java:502)
    at com.tom.LockTest.doSync2(LockTest.java:77)
    - locked <0x0000000781025470> (a java.lang.Object)  // 第2次加鎖
    at com.tom.LockTest.doSync1(LockTest.java:71)
    - locked <0x00000007810253d8> (a com.tom.LockTest)  // 第1次加鎖
    at com.tom.LockTest$2.run(LockTest.java:64)
    at java.lang.Thread.run(Thread.java:745)

   Locked ownable synchronizers:
    - None

"reentrantLock" #13 prio=5 os_prio=0 tid=0x000000001dcc0800 nid=0x148a70 waiting on condition [0x000000001ccfe000]   // 可以看到這里是condition
   java.lang.Thread.State: TIMED_WAITING (sleeping)
    at java.lang.Thread.sleep(Native Method)
    at com.tom.LockTest$1.run(LockTest.java:40)
    at java.lang.Thread.run(Thread.java:745)

   Locked ownable synchronizers:   // 2次加鎖，所以持有2個(gè)鎖
    - <0x0000000781025408> (a java.util.concurrent.locks.ReentrantLock$FairSync)
    - <0x0000000781025438> (a java.util.concurrent.locks.ReentrantLock$FairSync)

關(guān)于synchronized的線程stack要說明的是：
線程stack只顯示直接調(diào)用synchronized的方法名，擁有synchronized的方法并不顯示。拿上面的代碼舉例，doSync1調(diào)用方法doSync2，doSync2含有同步代碼塊，那么stack只會(huì)顯示：

- locked <0x0000000781025470> (a java.lang.Object)  // 第2次加鎖
at com.tom.LockTest.doSync1(LockTest.java:71)

不會(huì)顯示doSync2

FAQ

Q：synchronized加鎖后再調(diào)用wait，線程stack是否會(huì)顯示當(dāng)前已解鎖
A：不會(huì)。雖然事實(shí)上這時(shí)該線程已解鎖，但是stack顯示的該線程先持久對(duì)象鎖，然后waiting on該鎖（stack顯示的是線程對(duì)鎖的類似操作歷史）

其他命令

ulimit -a查看我們系統(tǒng)的所有限制
https://blog.csdn.net/gatieme/article/details/51058797