性能优化 - 内存泄漏、内存溢出、cpu 占用高、死锁、栈溢出、FullGC 频繁检测手段 - 总结与分享

# 先掌控全局，分别获取执行中的程序进程情况、显示内存的使用情况、查看磁盘剩余空间top free df 
# 获取java进程的PIDjps 或者ps -ef|grep java

jinfo [option] pid

jmap -histo[:live] <pid> [ > ./xx.log]

jmap -heap <pid>

jmap -dump:live,format=b,file=heap.hprof <pid>

# 在IDE中VM option中添加了以下环境变量，程序OOM后生成文件，后缀名为hprof-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./

top

top -Hp <pid>

printf "%x\n" <tid>;

jstack <pid> | grep -A10 <16进制tid>

jstack <pid> > jstack.log 

jstat -gc <pid> [1000 10]

S0C：第一个幸存区的大小（From Survivor区），以下几个容量的单位都是KB S1C：第二个幸存区的大小 （To Survivor区）S0U：第一个幸存区的使用大小S1U：第二个幸存区的使用大小 EC：伊甸园区的大小 （Eden区）EU：伊甸园区的使用大小OC：老年代大小 OU：老年代使用大小 MC：方法区大小（元空间）MU：方法区使用大小 CCSC：压缩类空间大小 CCSU：压缩类空间使用大小 YGC：年轻代垃圾回收次数 YGCT：年轻代垃圾回收消耗时间，单位s FGC：老年代垃圾回收次数 FGCT：老年代垃圾回收消耗时间，单位s GCT：垃圾回收消耗总时间，单位s

各内存区域大小是否合理；观察Eden区的对象增长，如每秒有多少对象创建；每次YoungGC后有多少对象存活下来、有多少对象进入了老年代；YoungGC的耗时；FullGC触发频率及耗时；

# 例如，当程序名为StaticTest时java -jar arthas-boot.jar  `ps -ef|grep StaticTest |grep -v grep|awk '{print $2}'`jstat -gc `jps|grep StaticTest |grep -v grep|awk '{print $1}'` 500 1000jvisualvm --openpid `ps -ef|grep StaticTest |grep -v grep|awk '{print $2}'`

import java.util.ArrayList;import java.util.List;
public class StaticTest {    public static List<Double> list = new ArrayList<>(); //静态集合
    public void populateList() {        for (int i = 0; i < 10000000; i++) {            list.add(Math.random());        }        System.out.println("Debug Point 2");    }
    public static void main(String[] args) throws InterruptedException {        Thread.sleep(10000);        System.out.println("Debug Point 1");        new StaticTest().populateList();        System.out.println("Debug Point 3");        Thread.sleep(10000);        System.gc(); //有修改，在此处显示触发Full GC        Thread.sleep(Integer.MAX_VALUE);    }}

#查看jvm默认具体参数java -XX:+PrintCommandLineFlags -version java -XX:+PrintGCDetails -version

import java.util.ArrayList;import java.util.List;
/** * JVM参数默认 * @author luke * @date 2022/11/11 */public class StaticTest {    public static List<Integer> list = new ArrayList<>(100000000);    public void populateList() throws InterruptedException {        for (int i = 1; i <= 100000000; i++) {            list.add(i);            if(i % 100000 == 0){                Thread.sleep(1000);                //System.out.println(list.size());            }        }        System.out.println("running......");    }    public static void main(String[] args) throws InterruptedException {        System.out.println("before......");        new StaticTest().populateList();        System.out.println("after......");    }}// 代码最终因内存泄露，回收不了可用空间而OOM。// Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded

jstat -gc `ps -ef|grep StaticTest |grep -v grep|awk '{print $2}'` 500 1000jvisualvm --openpid `ps -ef|grep StaticTest |grep -v grep|awk '{print $2}'`

import java.io.File;import java.io.IOException;
/** * @author luke * @date 2022/10/27 */public class FileTest {    public static void main(String[] args) throws IOException {        File f = new File("C:\\Users\\lzyxx\\Desktop\\a.txt");        System.out.println(f.exists());        System.out.println(f.isDirectory());    }}

import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicInteger;
/** * 线程池通过submit方式提交任务，会把Runnable封装成FutureTask。 * 直接导致了Runnable重写的toString方法在afterExecute统计的时候没有起到我们想要的作用(重写toString以用于统计任务数)， * 最终导致几乎每一个任务（除非hashCode相同）就按照一类任务进行统计。所以这个metricsMap会越来越大，调用metrics接口的时候，会把该map转成一个字符返回。 * 改成execute方式提交任务即可 */public class GCTest {    /**     * 统计各类任务已经执行的数量, 此处为了简化代码，只用map来代替metrics统计     */    private static final Map<String, AtomicInteger> metricsMap = new ConcurrentHashMap<>();
    public static void main(String[] args) throws InterruptedException {        ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 10, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>()) {            @Override            protected void afterExecute(Runnable r, Throwable t) {                super.afterExecute(r, t);                metricsMap.compute(r.toString(), (s, atomicInteger) -> new AtomicInteger(atomicInteger == null ? 1 : atomicInteger.incrementAndGet()));            }        };        /**         * 线程池执行两类任务         */        for (int i = 0; i < 500; i++) {            executor.submit(new SimpleRunnable()); // 错误方式            executor.submit(new SimpleRunnable2());//            executor.execute(new SimpleRunnable()); // 正确方式//            executor.execute(new SimpleRunnable2());        }        executor.shutdown();        executor.awaitTermination(1, TimeUnit.DAYS);        System.out.println(metricsMap);    }    static class SimpleRunnable implements Runnable{        @Override        public void run() {}        @Override        public String toString(){            return this.getClass().getSimpleName();        }    }
    static class SimpleRunnable2 implements Runnable{        @Override        public void run() {}        @Override        public String toString(){            return this.getClass().getSimpleName();        }    }}

import java.lang.reflect.Field;
/** * jvm运行参数 -Xmx1m -Xms1m -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./ * * 使用以下命令观察：jstat -gc `ps -ef|grep MemoryLeakExample |grep -v grep|awk '{print $2}'` 1000 1000 */public class MemoryLeakExample{
    public static int i = 0;
    public static void main(String[] args) throws Exception{        while (true){            ThreadLocal<Object> threadLocal = new ThreadLocal<>();            try {                objectThreadLocal.set(new byte[10 * 1024]);                printEntriesSize();                Thread.sleep(100);                i++;            }catch (Throwable e){                System.out.println(i);                throw e;            }finally {                //threadLocal.remove(); // 正确使用            }        }    }
    /**     * 打印ThreadLocal.entry的个数     */    public static void printEntriesSize() throws NoSuchFieldException, IllegalAccessException{        Thread thread = Thread.currentThread();        Class<? extends Thread> aClass = thread.getClass();        Field threadLocals = aClass.getDeclaredField("threadLocals");        threadLocals.setAccessible(true);        Object threadLocalMap  = threadLocals.get(thread);        Class<?> tlmClass = threadLocalMap.getClass();        Field entriesSize = tlmClass.getDeclaredField("size");        entriesSize.setAccessible(true);        System.out.println(entriesSize.get(threadLocalMap));    }}

try {    threadLocal.set(System.nanoTime());    //... further processing} finally {    threadLocal.remove();}

public class OuterClass {    class InnerClass {    }    static class StaticClass {    }}