JVM 探究（上）

死锁

　　什么是死锁？

　　　　线程A持有资源A，想要资源B。线程B持有资源B，想要资源A，如此便会死锁。

// 面对死锁你该怎么办？
// 日志
// 查看堆栈信息！ JVM 的知识
// 1、获取当前运行的java进程号   jps   -l
// 2、查看信息                  jstack 进程号
// 3、jconsole 查看对应的信息！(可视化工具！)
// ......
public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyLockThread(lockA,lockB),"T1").start();
        new Thread(new MyLockThread(lockB,lockA),"T2").start();
    }
}

class MyLockThread implements Runnable {
    private String lockA;
    private String lockB;

    public MyLockThread(String lockA,String lockB){
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName()+"lock:"+lockA+"-->get:"+lockB);
            try {
                TimeUnit.SECONDS.sleep(2L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"-->get:"+lockA);
            }
        }
    }
}

JVM虚拟机

类加载器 (class loader)

加载：查找并加载类的二进制数据

链接：

• 验证：保证被加载的类的正确性
• 准备：给类静态变量分配内存空间，赋值一个默认的初始值
• 解析：把类中的符号引用转换为直接引用　
  • 在把 .java 文件 编译为 .class 文件的时候，虚拟机并不知道所引用的地址； 助记符，符号引用；
  • 转为真正的直接引用，找到对应的直接地址！

初始化：给类的静态变量赋值正确的值

public class Test {
    private static int a = 1;
}

// 1. 加载  编译为 .class文件，通过类加载，加载到JVM

// 2. 链接
//      验证：保证 .class 文件没有问题
//      准备：给int类型分配内存空间，a=0
//      解析：符号引用转为直接引用

// 3.初始化  把 1 赋值给 a ， 此时a=1

static加载分析：

// JVM参数：
// -XX:+TraceClassLoading  // 用于追踪类的加载信息并打印出来
// 分析项目启动为什么很慢，可以用上述参数检查类加载情况(比如是不是上来就加载了很多第三方类)
// rt.jar  jdk 出厂自带的，最高级别的类加载器加载的
public class Demo2 {
    public static void main(String[] args) {
        System.out.println(MyParent2.str2);
    }
}

class MyParent1 {
    public static String str1 = "hello,str1";

    static {
        System.out.println("MyParent1...");
    }
}

class MyParent2 extends MyParent1 {
    public static String str2 = "hello,str2";

    static {
        System.out.println("MyParent2...");
    }
}

final 加载分析：

public class Demo3 {
    public static void main(String[] args) {
        // final 在编译的时候 在常量池
        // 这个代码中编译的时候，将str这个常量放在了Demo3中，
        // 此后Demo3和MyParent03并没有关系，即Demo3并不存在MyParent03调用str
//        System.out.println(MyParent03.str);

        System.out.println(MyParent03.str1);
    }
}

class MyParent03 {
    public static final String str = "hello,world";
    public static final String str1 = UUID.randomUUID().toString().substring(1,3);
    static {
        System.out.println("MyParent02...");
    }
}

类加载器(class loader)分类

1. java虚拟机自带的加载器
   1. BootStrap 根加载器 （加载系统的包，如JDK核心库中的类：rt.jar中的类文件）
   2. Ext 　　    扩展类加载器  （加载一些扩展jar包中的类）
   3. Sys/App    系统(应用类)加载器 （加载自己个人写 .java 代码）
2. 用户自己定义的加载器
   1. Classloader，只需要继承这个抽象类即可，自定义自己的类加载器 （了解即可）

public class Demo1 {
    public static void main(String[] args) {
        Object o = new Object();
        // 输出null 在这里并不代表没有，只是Java触及不到！
        // 因为根加载器是由c、c++写的
        System.out.println(o.getClass().getClassLoader());
        
        Demo1 demo1 = new Demo1();

        Class<? extends Demo1> aClass = demo1.getClass();
        // class com.coding.classloader.Demo1
        System.out.println(aClass);

        ClassLoader classLoader = aClass.getClassLoader();
        // sun.misc.Launcher$AppClassLoader@18b4aac2
        System.out.println(classLoader);

        ClassLoader classLoader2 = classLoader.getParent();
        // sun.misc.Launcher$ExtClassLoader@1540e19d
        System.out.println(classLoader2);

        ClassLoader classLoader3 = classLoader2.getParent();
        // null
        System.out.println(classLoader3);

// 思考：为什么自己写的java.lang.String 不能运行？
        
// 双亲委派机制 可以保证核心类不被自己写的类破坏
// 双亲委派机制：一层一层的让父类去加载，如果父类不能加载，在往下类推

// Demo1
// AppClassLoader   03
// ExtClassLoader   02
// BootStrap        01  最顶层加载器
    }
}

程序计数器 (Program counter) (了解即可)

　　每个线程都有一个私有的程序计数器

（重点）方法区 （别名：非堆）

　　Method Area 方法区 是Java虚拟机规范中定义的运行时数据区域，和堆(heap)一样可以在线程之间共享！

　　JDK1.7之前：

　　　　永久代：用于存储一些虚拟机加载类信息，常量，字符串，静态变量等等。。。这些东西都会放到永久代中；

　　　　永久代大小空间是有限的：如果满了，就会OOM (OutOfMemoryError：)

　　JDK1.8之后

　　　　彻底将永久代移除 HotSpot JVM ，Java Heap中或者Meta space （Native Heap）元空间；

　　　　元空间就是方法区在HotSpot JVM的实现；

　　　　方法区重要就是来存：类信息，常量，字符串，静态变量，符号引用，方法代码。。。

　　　　元空间和永久代，都是对JVM规范中方法区的实现。

　　　　元空间和永久代最大的区别：元空间并不在Java虚拟机中，使用的是本地内存

（重点）栈Stack

　　栈的优势：存取速度比堆快，仅次于寄存器；栈的数据是不可以共享的

　　程序的运行其实是压栈的过程；

　　栈中一定不存在垃圾，线程一旦结束，该栈生命周期也会结束，即和线程生命周期一致

　　栈存什么：本地变量表，基本数据类型，对象引用，，，

　　我们这个栈主要是 HotSpot （指针）

问题：你认识几种JVM？（3种）

• HotSpot　    SUN公司
• JRockit         BEA公司
• J9VM            IBM 公司

（必须要会）堆 Heap

　　Java 7之前：

　　　　Heap堆，一个JVM实例中只存在一个堆，堆的内存大小是可以调节的。

　　　　可以存的内容：类，方法，常量，保存了类型引用的真实信息；

　　　　分为三个部分：

• • • 新生区：Young
    • 养老区：Old Tenure
    • 永久区：Perm　　

　　　　　　堆内存在逻辑上分为三个部分：新生，养老，永久（JDK1.7之后，叫元空间）

　　　　　　　　　　物理上分为：新生，养老；永久代(元空间)在本地内存中，不在JVM中

　　　　　　GC 垃圾回收主要是在 新生区和养老区，又分为 普通的GC (轻量级的GC) 和 Full GC (重量级的GC)，如果堆满了，就会爆出OOM

　　新生区

　　　　新生区 就是一个类诞生，成长，消亡的地方！

　　　　新生区细分：Eden，s0 / s1，所有的类Eden被new 出来的，慢慢的当Eden 满了，程序还需要创建对象的时候，就会触发一次轻量级的GC；清理完一次垃圾之后，会将活下来的对象，会放入幸存者区，......假设清理了20次之后，出现了极其顽强的对象，有些对象突破了，15次的垃圾回收！这时候就会将这个对象送入养老区！　　运行了几个月之后，养老区满了，就会触发一次 Full GC；　　假设项目上线一年后，整个空间彻底的满了，系统就会OOM；排除OOM问题，或者重启...　　　

　　永久区

　　　　放一些JDK自身携带的Class ，interface的元数据；几乎不会被垃圾回收；

　　　　JDK1.6之前，有永久代，常量池在方法区；

　　　　JDK1.7，有永久代，但是开始尝试去永久代，常量池在堆中；

　　　　JDK1.8之后，永久代就没有了，取而代之的是元空间；常量池在元空间中；

　　养老区

　　　　15次都幸存下来的对象进入养老区，养老区满了之后，触发Full GC

　　　　默认是15次，可以修改！

　　堆内存调优（入门级）

　　　　我的环境：HotSpot 、jdk1.8；

/*
 * 默认情况：
 * maxMemory：1796.0MB    （虚拟机试图使用的最大内存量  一般是物理内存的1/4）
 * totalMemory：123.0MB   （虚拟机默认使用的内存总量   一般是物理内存的1/64）
 */
// 我们可以自定堆内存的总量
// -XX:+PrintGCDetails; // 输出详细的垃圾回收信息
// -Xmx: 最大分配的内存 1/4
// -Xmx: 初始化分配的内存大小 1/64
// VM命令 -Xmx1024m -Xms1024m -XX:+PrintGCDetails
public class HeapDemo1 {
    public static void main(String[] args) {
        // 获得堆内存的最大大小 和 初始大小
        long maxMemory = Runtime.getRuntime().maxMemory();
        long totalMemory = Runtime.getRuntime().totalMemory();

        System.out.println("maxMemory="+maxMemory+"字节、"+(maxMemory/1024/(double)1024)+"MB");
        System.out.println("totalMemory="+totalMemory+"字节、"+(totalMemory/1024/(double)1024)+"MB");
    }
}

/*
* VM命令 -Xmx1024m -Xms1024m -XX:+PrintGCDetails
*
* 分析GC日志：[PSYoungGen: 2037K->499K(2560K)] 2037K->727K(9728K), 0.0087646 secs]
*          [Times: user=0.00 sys=0.00, real=0.01 secs]
* GC类型： GC 普通的GC    Full GC 重量级的GC
* 2037K GC前的大小，499K GC后的大小，
* (2560K)当前YoungGen的total大小，0.0087646 secs GC用时，
* user 占用CPU的时间，sys OS调用等待的时间，real 应用暂停的时间
 */
public class HeapDemo2 {
    public static void main(String[] args) {
        String str = "hello,Heap";
        while (true) {
            str += str +
                    new Random().nextInt(999999999)
                    +new Random().nextInt(999999999);
        }
        // java.lang.OutOfMemoryError: Java heap space
    }
}

Dump 内存快照

　　在java程序运行的时候，想测试运行的情况，即可使用一些工具来查看；

　　　　工具：jconsole.exe；　　idea debug；　　IDEA（Jprofile性能瓶颈分析插件）　　Eclipse（MAT插件）；

/*
* Jprofiler 快速体验
* 安装 配置 激活...
*
* -Xmx8m -Xms8m -XX:+HeapDumpOnOutOfMemoryError
* */
public class HeapDemo4 {
    private byte[] bytes = new byte[1*1024*1024]; // 1MB

    public static void main(String[] args) {
        List<HeapDemo4> list = new ArrayList();

        int count = 0;

        try {
            while (true) {
                list.add(new HeapDemo4());
                count++;
            }
        } catch (Throwable e) {// error 和 Exception 平级
            System.out.println("count="+count);
            e.printStackTrace();
        }
// java.lang.OutOfMemoryError: Java heap space
    }
}

谈谈在工作中如何排查OOM？

　　　　1. 运行前的操作

　　　　2. 监控

　　通过Dump快照分析异常对象，精准定位到类。