java基础教程虚拟机性能分析和故障解决工具【命令行（jps、jstat、jstack)】

package jps;
import java.io.IOException;
/**
 * ❀掌握：使用 jps命令查看java进程的ID 
 * 命令：jps
 * 直接输入jps （相当于 jps -V ）
 * 
 * 
 * 
命令格式： jps[options][hostid]
第一个参数options   [-mlvV]可以任意组合使用
第二个参数：hostid
主机或者是服务器的ip，如果不指定，就默认为当前的主机或者是服务器。
注意：如果需要查看其他机器上的jvm进程，需要在待查看机器上启动jstatd。
 * 
 * jps + 
 * -q: 显示进程ID
 * -m: 显示进程ID，主类名称，以及传入main方法的参数
 * -l: 显示进程ID，主类全名【全限定名】
 * -v: 显示进程ID，主类名称，以及传入jvm的参数
 * -V: 显示进程ID，主类名称[❀]
 * @author Huangyujun
 *
 *-Xmn8m 指定年轻代内存大小
 */
public class jpsDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("jps");
        System.in.read();
    }
}

package jstat;
import java.io.IOException;
/**
 * -gc 选项：垃圾收集的堆统计信息
S0C、S1C：幸存区容量                                                                S0C：当前幸存者空间0容量（kB）    S1C：当前生存空间1的容量（kB）
S0U、S1U：❀堆内存中幸存区使用的容量                                      S0U：幸存者空间0使用大小（kB）     S1U：幸存者空间1使用大小（kB）
EC、EU：伊甸园容量   伊甸园使用的容量                              EC：当前伊甸园空间容量（kB）          EU：伊甸园空间使用大小（kB）
OC、OU：❀老年代容量、老年代使用的容量                              OC：当前的老年代容量（kB）              OU：老年代使用大小（kB）
方法区的使用情况：MC、MU：元空间容量、元空间使用的容量                   MC：元空间容量（kB）                          MU：元空间使用大小（kB）
压缩类的情况：CCSC：压缩的类空间容量（kB） CCSU：使用的压缩类空间（kB）
● 垃圾回收：●
● YGC：新生代垃圾收集事件的数量
● YGCT：新生代垃圾回收时间
● FGC：完整GC事件的数量
● FGCT：完整的垃圾收集时间
● GCT：总垃圾收集时间
==================================================
jstat -gc 线程ID 
jstat -gcutil 线程ID
■ gc 和 gcutil 区别：gc显示的是大小， gcutil 显示的是占比
===================================================
 * @author Huangyujun 
 * -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc -XX:SurvivorRatio=8 
 * -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc 
 * -Xms20M 堆的初始容量     -Xmx20M 堆的最大容量    -Xmn10M 堆中年轻（新生）代的大小
 * -XX:+UseSerialGC 指定垃圾收集器SerialGC（串型垃圾回收器）   -XX:+PrintGCDetails 打印内存中GC的行为     -verbose:gc 显示GC的情况
 * -XX:ServivorRatio=8    设置 New Generation新生代中的 Eden区与Servivor区比例是8：1
 */
public class gc_gcutil {
    //前提：配置一下vm的参数[JVM 配置]
    //GC(Allocation Failure)[DefNew: 7072k->(956k),0.0042301 secs...][Times:user=0.01 sys=0.00, real=0.01secs]...
    public static void main(String[] args) throws IOException {
        final int _1MB = 1024 * 1024;
        byte[] b1 = new byte[2 * _1MB];
        System.out.println("1...");
        System.in.read();//阻塞程序，当控制台输入回车键后继续执行
        byte[] b2 = new byte[2 * _1MB];
        System.out.println("2...");
        System.in.read();
        byte[] b3 = new byte[2 * _1MB];
        System.out.println("3...");
        System.in.read();
        byte[] a4= new byte[4*_1MB];
    }
}
/**
-gcutil 选项： 垃圾收集统计信息
    S0：幸存者空间0利用率占该空间当前容量的百分比
    S1：幸存者空间1利用率占空间当前容量的百分比
    E：Eden空间利用率占空间当前容量的百分比
    O：老年代利用率占空间当前容量的百分比
    M：元空间利用率占空间当前容量的百分比
    CCS：压缩的类空间利用率，以百分比表示
    YGC：新生代GC事件的数量
    YGCT：新生代垃圾回收时间
    FGC：完整GC事件的数量
    FGCT：完整的垃圾收集时间
    GCT：总垃圾收集时间
*/

package jstack;
import java.io.IOException;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * jstack应用
 * @author Huangyujun
 *
 */
public class jstackTest {
    public static void main(String[] args) {
        System.out.println("start");
//        test1();
//        test2();
        test3();
        System.out.println("end");
    }
    //死循环
    public static void test1() {
        while(true) {}
    } 
    //等待控制台输入
    public static void test2() {
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    } 
    //死锁【我醒来了，我的锁被你拿了，你睡了；你醒来了，你的锁被我拿了，我睡了-------我等你，你等我【等不到的人】】
    public static void test3() {
        Lock lock1 = new ReentrantLock();
        Lock lock2 = new ReentrantLock();
        new Thread(() -> {
            try {
                lock1.lock();
                Thread.sleep(100);
                lock2.lock();//需要加锁，但是加锁失败，锁被另外一个线程myThread2持有
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "myThread1").start();
        new Thread(() -> {
            try {
                lock2.lock();
                Thread.sleep(100);
                lock1.lock();//通过lock1加锁，失败，等待锁的释放，按照提示说是被myThread1持有，观察发现：myThread1中：lock1.lock(); Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "myThread2").start();
    } 
}