Java_JVM探究

标签：Java jar 探究 Program 内存 JVM java 加载

• 请你谈谈你对JVM的理解？java8虚拟机和之前的变化更新？
• 什么是OOM，什么是栈溢出StackOverflowError?怎么分析？
• JVM的常用调优参数有哪些？
• 内存快照如何抓取，怎么分析Dump文件？
• 谈谈JVM中，你对类加载器的认识？rt.jar(根加载器) ext(扩展加载器) application（应用加载器）

1.JVM的位置

2.JVM的体系结构

3.类加载器

作用：加载Class文件 new实例化一个对象

1.虚拟机自带的加载器
2.启动类（根）加载器
3.扩展类加载器
4.应用程序加载器

package com.wangzhen.pc;
public class Car {
    public static void main(String[] args) {
        //类是模板，对象是具体的
        Car car1 = new Car();
        Car car2 = new Car();
        Car car3 = new Car();

        System.out.println(car1.hashCode());
        System.out.println(car2.hashCode());
        System.out.println(car3.hashCode());

        Class aCalss1 = car1.getClass();
        Class aCalss2 = car2.getClass();
        Class aCalss3 = car3.getClass();

        System.out.println(aCalss1.hashCode());
        System.out.println(aCalss2.hashCode());
        System.out.println(aCalss3.hashCode());

        ClassLoader classLoader = aCalss1.getClassLoader();
        System.out.println(classLoader);//Application
        System.out.println(classLoader.getParent());//ExtClassLoader  \jre\lib\ext
        System.out.println(classLoader.getParent().getParent());//null java程序获取不到 rt.jar
    }
}

4.双亲委派机制

package java.lang;
public class String {
    //双亲委派机制：安全
    //1.APP-->EXT-->Boot(最终执行)
    public String  toString(){
        return "Hello";
    }

    public static void main(String[] args) {
        String s = new String();
        s.toString();
    }
}
/*
1.类加载器收到类加载的请求
2.将这个请求向上委托给父类加载器去完成，一直向上委托，直到启动类（根加载器）加载器
3.启动类加载器检查是否能够加载当前这个类，能加载就结束，使用当前的加载器，否则，抛出异常，通知子加载器进行加载
4.重复步骤3
Class Not Found
null:java调用不到C，C++
Java相比C，C++去掉了繁琐的东西，指针，内存管理
*/

5.沙箱安全机制

1.概述

Java安全模型的核心就是Java沙箱(sandbox)
什么是沙箱?
沙箱是一个限制程序运行的环境。沙箱机制就是将Java代码限定在虚拟机(JVM)特定的运行范围中，并且严格限制代码对本地系统资源访问，
通过这样的措施来保证对代码的有效隔离，防止对本地系统造成破坏。
沙箱主要限制系统资源访问，那系统资源包括什么?
CPU、内存、文件系统、网络。不同级别的沙箱对这些资源访问的限制也可以不一样。
所有的Java程序运行都可以指定沙箱，可以定制安全策略。

2.历史

在Java中将执行程序分成本地代码和远程代码两种

本地代码默认视为可信任的
而远程代码则被看作是不受信的。对于授信的本地代码,可以访问一切本地资源。
而对于非授信的远程代码在早期的Java实现中，安全依赖于沙箱 Sandbox 机制。如下图所示JDK1.0安全模型

但如此严格的安全机制也给程序的功能扩展带来障碍，比如当用户希望远程代码访问本地系统的文件时候，就无法实现。

因此在后续的Java1.1版本中，针对安全机制做了改进，增加了安全策略，允许用户指定代码对本地资源的访问权限。

在Java1.2版本中，再次改进了安全机制，增加了代码签名。
不论本地代码或是远程代码，都会按照用户的安全策略设定，
由类加载器加载到虚拟机中权限不同的运行空间，来实现差异化的代码执行权限控制。

当前最新的安全机制实现，则引入了 域(Domain) 的概念。
虚拟机会把所有代码加载到不同的系统域和应用域，系统域部分专门负责与关键资源进行交互，而各个应用域部分则通过系统域的部分代理来对各种需要的资源进行访问。
虚拟机中不同的受保护域(Protected Domain)，对应不一样的权限(Permission)。
存在于不同域中的类文件就具有了当前域的全部权限，
下图所示为最新的安全模型（jdk 1.6）

3.组成沙箱的基本组件

1.字节码校验器(bytecode verifier) ：
确保Java类文件遵循Java语言规范。这样可以帮助Java程序实现内存保护。
但并不是所有的类文件都会经过字节码校验，比如核心类。如：new String();
2.类裝载器(class loader) :
其中类装载器在3个方面对Java沙箱起作用

• 它防止恶意代码去干涉善意的代码;
• 它守护了被信任的类库边界;
• 它将代码归入保护域,确定了代码可以进行哪些操作。
  虚拟机为不同的类加载器载入的类提供不同的命名空间。
  命名空间由一系列唯一的名称组成， 每一个被装载的类将有一个名字，
  这个命名空间是由Java虚拟机为每一个类装载器维护的，它们互相之间甚至不可见。
  类装载器采用的机制是双亲委派模式。
  1.从最内层JVM自带类加载器开始加载，外层恶意同名类得不到加载从而无法使用;
  2.由于严格通过包来区分了访问域,外层恶意的类通过内置代码也无法获得权限访问到内层类，破坏代码就自然无法生效。
• 存取控制器(access controller) :存取控制器可以控制核心API对操作系统的存取权限，而这个控制的策略设定,可以由用户指定。
• 安全管理器(security manager) : 是核心API和操作系统之间的主要接口。实现权限控制，比存取控制器优先级高。
• 安全软件包(security package) : java.security下的类和扩展包下的类，允许用户为自己的应用增加新的安全特性，包括:
  安全提供者
  消息摘要
  数字签名 keytools https
  加密
  鉴别

6.Native本地方法栈

package com.wangzhen.pc;

public class Demo {
    public static void main(String[] args) {
        new Thread().start();
    }
    //native：凡是带了native 关键字的，说明java的作用范围达不到了，会去调用底层 C 语言的库！
    //会进入本地方法栈
    //调用本地方法本地接口 JNI
    //JNI 作用：扩展Java的使用，融合不同的编程语言为Java所用！最初：C、C++
    //Java诞生的时候 C、C++横行，想要立足，必须要有调用C、C++的程序
    //它在内存区域中专门开辟了一块标记区域：Native Method Stack，登记native方法
    //在最终执行的时候，加载本地方法库中的方法通过JNI
    //Java程序驱动打印机，管理系统 Robot();掌握即可，在企业级应用中较为少见！
    private native void start0();
    
    //调用其他接口的方法： socket、WebService、http
}

    public synchronized void start() {
        
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
    //这个Thread是一个类，这个方法定义在这里是不是很诡异！看这个关键字native；
    private native void start0();

凡是带了native关键字的，说明java的作用范围达不到了，会去调用底层c语言的库！
**JNI：Java Native Interface（Java本地方法接口） **
凡是带了native关键字的方法就会进入本地方法栈，其他的就是Java栈；
**Native Interface **本地接口
本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++程序，Java在诞生的时候
是C/C++横行的时候，想要立足，必须有调用C、C++的程序，于是就在内存中专门开辟了一块区域处理标记
为native的代码，它的具体做法是在 Native Method Stack中登记native方法，在（Execution Engine）
执行引擎执行的时候加载Native Libraies。

目前该方法使用的越来越少，除非是与硬件有关的应用，比如通过Java程序驱动打印机或者Java系统管理
生产设备，在企业级应用中已经比较少见。因为现在的异构领域间通信很发达，比如可以使用Socket通信，也
可以使用Web Service等等，不多做介绍！

Native Method Stack
它的具体做法是Native Method Stack中登记native方法，在（Execution Engine）执行引擎执行的时候
加载 Native Libraies.[本地库]

7.PC寄存器

程序计数器：Program Counter Register
每个线程都有一个程序计数器，是线程私有的，就是一个指针，指向方法区中的方法字节码（用来存储指向一条指令的地址，
就是将要执行的指令代码），在执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不计！

8.方法区

Method Area 方法区
方法区是被所有线程共享，所有字段和方法字节码，以及一些特殊方法，如构造函数，接口代码也在此定义，
简单说，所有定义的方法的信息都保存在该区域，此区域属于共享区间；
静态变量、常量、类信息（构造方法、接口定义）、运行时的常量池存在方法区中，但是实例变量
存在堆内存中和方法区无关。
static final Class模板，常量池

9.栈：数据结构

程序 = 算法 + 数据结构
程序 = 框架 + 业务逻辑
栈 ： 先进后出，后进先出（喝多了吐是栈）
队列：先进先出（FIFO：first in first out）（吃多了拉就是队列）
栈管理运行
内存原型理解：
为什么main()先执行，最后结束
栈：栈内存，主管程序的运行，生命周期和线程同步；
线程结束，栈内存也就释放，对于栈来说，不存在垃圾回收问题
一旦线程结束，栈就Over！
栈：8大基本类型 + 对象引用 + 实例的方法
栈运行原理：栈帧
栈满了：StackOverflowError

栈 + 堆 + 方法区：交互关系

画出一个对象实例化的过程在内存中

10.三种JVM

• Sun公司 HotSpot Java HotSpot(TM) Client VM (build 25.333-b02, mixed mode, sharing)
• BEA JRockit
• IBM J9VM
  我们学习都是：HotSpot

11.堆

Heap，一个JVM只有一个堆内存。堆内存的大小是可以调节的。
类加载器读取了类文件后，一般会把什么东西放到堆中？类，方法，常量，变量，保存我们所有引用类型的真实对象；
堆内存中还要细分为三个区域：

• 新生区（young / new）
• 养年区(old)
• 永久区(Perm)
  
  GC垃圾回收，主要是在伊甸园区和养老区
  假设内存满了，OOM，堆内存不够！java.lang.OutOfMemoryError: Java heap space

package com.wangzhen.pc;

import java.util.Random;

public class Hello {
    public static void main(String[] args) {
        String str = "JVM";
        while (true){
            str += str + new Random().nextInt(888888888) + new Random().nextInt(999999999);
        }
    }
}

在JDK8以后，永久存储区改了个名字（元空间）

经过研究，99%的对象都是临时对象！
永久区：
这个区域常驻内存，用来存放JDK自身携带的Class对象。Interface元数据，存储的是Java运行时的一些环境
或类信息，这个区域不存在垃圾回收！关闭VM虚拟机就会释放这个区域的内存
一个启动类，加载了大量的第三方jar包。Tomcat部署了太多的应用，大量动态生成的反射类。不断的被加载，直达
内存满，就会出现OOM；
jdk1.6之前：永久代，常量池是在方法区；
jdk1.7:永久代，但是慢慢退化了，去永久代，常量池在堆中
jdk1.8之后：无永久代，常量池在元空间

逻辑上存在，物理上不存在
在一个项目中，突然出现了OOM故障，那么该如何排除，研究为什么出错

• 能够看到代码第几行出错：内存快照分析工具，MAT JProfiler
• Debug，一行行代码分析
  MAT JProfiler作用：
• 分析Dump内存文件，快速定位内存泄漏
• 获得堆中的数据
• 获得大的对象

package com.wangzhen.pc;

public class Demo02 {
    public static void main(String[] args) {
        //返回虚拟机试图使用的最大内存
        long max = Runtime.getRuntime().maxMemory();// 字节 1024*1024
        //返回JVM的初始化总内存
        long total = Runtime.getRuntime().totalMemory();

        System.out.println("max=" + max + "字节\t" + (max/(double)1024/1024) + "MB");
        System.out.println("total=" + total + "字节\t" + (total/(double)1024/1024) + "MB");
        //默认情况下：分配的最大内存 是电脑内存的1/4,而初始化的内存是电脑内存的：1/64

        /*OOM:
        * 1.尝试扩大堆内存看结果
        * 2.分析内存，看一下哪个地方出现了问题（专业工具）
        * */
        //-Xms1024m -Xms1024m -XX:+PrintGCDetails
        //314560K（新生代） + 699072K（老年代） = 989.875MB
    }
}

package com.wangzhen.pc;

import java.util.Random;

public class Hello {
    public static void main(String[] args) {
        String str = "JVM";
        while (true){
            str += str + new Random().nextInt(888888888) + new Random().nextInt(999999999);
        }
    }
}
//添加调优参数，把堆内存调大
//-Xms1024m -Xms1024m -XX:+PrintGCDetails

"D:\Program Files\Java\jdk1.8.0_333\bin\java" -Xms1024m -Xms1024m -XX:+PrintGCDetails -Didea.launcher.port=7535 "-Didea.launcher.bin.path=D:\Program Files\JetBrains\IntelliJ IDEA 2016.3.8\bin" -Dfile.encoding=UTF-8 -classpath "D:\Program Files\Java\jdk1.8.0_333\jre\lib\charsets.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\deploy.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\access-bridge.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\cldrdata.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\dnsns.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\jaccess.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\jfxrt.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\localedata.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\nashorn.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\sunec.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\sunjce_provider.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\sunmscapi.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\sunpkcs11.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\ext\zipfs.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\javaws.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\jce.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\jfr.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\jfxswt.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\jsse.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\management-agent.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\plugin.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\resources.jar;D:\Program Files\Java\jdk1.8.0_333\jre\lib\rt.jar;F:\JavaStudy\JUC\target\classes;C:\Users\Administrator.WINMICR-VMR5ICF\.m2\repository\org\projectlombok\lombok\1.18.8\lombok-1.18.8.jar;D:\Program Files\JetBrains\IntelliJ IDEA 2016.3.8\lib\idea_rt.jar" com.intellij.rt.execution.application.AppMain com.wangzhen.pc.Hello
[GC (Allocation Failure) [DefNew: 258051K->21031K(314560K), 0.0446337 secs] 258051K->61990K(1013632K), 0.1200069 secs] [Times: user=0.02 sys=0.02, real=0.12 secs] 
[GC (Allocation Failure) [DefNew: 272197K->0K(314560K), 0.1078455 secs] 313156K->164384K(1013632K), 0.1078899 secs] [Times: user=0.06 sys=0.03, real=0.11 secs] 
[GC (Allocation Failure) [DefNew: 250910K->0K(314560K), 0.0623065 secs] 415294K->246303K(1013632K), 0.0623608 secs] [Times: user=0.00 sys=0.06, real=0.06 secs] 
[GC (Allocation Failure) [DefNew: 250703K->0K(314560K), 0.0005499 secs] 824680K->573976K(1013632K), 0.0741506 secs] [Times: user=0.00 sys=0.00, real=0.07 secs] 
[GC (Allocation Failure) [DefNew (promotion failed) : 169010K->169010K(314560K), 0.0004524 secs][Tenured: 573976K->164383K(699072K), 0.0406255 secs] 742987K->164383K(1013632K), [Metaspace: 2134K->2134K(4480K)], 0.4982358 secs] [Times: user=0.05 sys=0.00, real=0.50 secs] 
[GC (Allocation Failure) [DefNew: 169429K->0K(314560K), 0.0004447 secs][Tenured: 492057K->492057K(699072K), 0.0021228 secs] 661487K->492057K(1013632K), [Metaspace: 2135K->2135K(4480K)], 0.0026278 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [TenuredException in thread "main" : 492057K->492040K(699072K), 0.0778026 secs] 492057K->492040K(1013632K), [Metaspace: 2135K->2135K(4480K)], 0.0778402 secs] [Times: user=0.08 sys=0.00, real=0.08 secs] 
java.lang.OutOfMemoryError: Java heap space
	at java.util.Arrays.copyOf(Arrays.java:3332)
	at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:124)
	at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:674)
	at java.lang.StringBuilder.append(StringBuilder.java:214)
	at com.wangzhen.pc.Hello.main(Hello.java:9)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
Heap
 def new generation   total 314560K, used 10912K [0x07e00000, 0x1d350000, 0x1d350000)
  eden space 279616K,   3% used [0x07e00000, 0x088a83b8, 0x18f10000)
  from space 34944K,   0% used [0x18f10000, 0x18f10000, 0x1b130000)
  to   space 34944K,   0% used [0x1b130000, 0x1b130000, 0x1d350000)
 tenured generation   total 699072K, used 492040K [0x1d350000, 0x47e00000, 0x47e00000)
   the space 699072K,  70% used [0x1d350000, 0x3b3d23d0, 0x3b3d2400, 0x47e00000)
 Metaspace       used 2157K, capacity 2248K, committed 2368K, reserved 4480K

12.堆内存调优

package com.wangzhen.pc;

import java.util.ArrayList;
// -Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError
//-Xms 设置初始化内存分配大小 1/64
//-Xmx 设置最大分配内存，默认1/4
//-XX:+PrintGCDetails  打印GC垃圾回收信息
//-XX:+HeapDumpOnOutOfMemoryError  OOM Dump
public class Demo03 {
    byte[] array = new byte[1*1024*1024];// 1M

    public static void main(String[] args) {
        ArrayList<Demo03> list = new ArrayList<>();
        int count = 0;
        try {
            while (true){
                list.add(new Demo03());//问题所在
                count++;
            }
        } catch (Error e) {
            e.printStackTrace();
            System.out.println("count:" + count);
        }
     /*
     * Throwable
     *  1.Exception
     *  2.Error
     * -Xms1m -Xms8m -XX:+HeapDumpOnOutOfMemoryError
     * */
    }
}

JVM在进行GC时，并不是对这三个区域统一回收。大部分时候，回收的都是新生代

• 新生区
• 幸存区
• 老年区
  GC两种类：轻GC（普通的GC），重GC（全局GC）
  GC题目：
• JVM的内存模型和分区，详细到每个分区放什么？
• 堆里面的分区有哪些？Eden，from，to ,老年区，说说他们的特点！
• GC的算法有哪些》标记清除法，标记整理（标记压缩），复制算法，引用计数器，怎么用的？

13.GC

1.常用算法


复制算法：
好处：没有内存碎片
坏处:浪费了内存空间，多了一半空间永远是to空间，假设对象100%存活（极端情况）
复制算法最佳使用场景：对象存活度较低的时候：新生区
标记清除算法：

优点：不需要额外的空间
缺点：两次扫描，严重浪费时间，会产生内存碎片。
标记压缩：

总结：
内存效率：复制算法 > 标记清除算法 > 标记压缩算法（时间复杂度）
内存整齐度：复制算法 = 标记压缩算法 > 标记清除算法
内存利用率：标记压缩算法 = 标记清除算法 > 复制算法

思考问题：难道没有一个最优算法？
答案：没有最好的算法，只有最合适的。
GC：分代收集算法
年轻代：

• 存活率低
• 复制算法
  老年代：
• 区域大：存活率高
• 标记清除法（内存碎片不是太多） + 标记压缩算法 混合实现

JVM深究需花时间，多看面试题及《深入理解JVM》
掌握学习JVM的方法

14.JMM（Java Memory Model）

1.什么是JMM？
JMM：（Java Memory Model）缩写
2.它是干嘛的？通过百度，官方介绍和他人博客了解
作用：缓存一致性协议，用于定义数据读写的规则！
JMM定义了线程工作内存和主内存之间的抽象关系：线程之间的共享变量存储在主内存
（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory）

解决共享对象一致性这个问题：volilate
3.如何学习JMM
JMM:抽象的概念，理论
主内存与工作内存八种操作指令：

• lock（锁定）：作用于主内存的变量，它把一个变量标识为一条线程独占的状态；
• unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；
• read（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用；
• load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中；
• use（使用）：作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作；
• assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作；
• store（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后的write操作使用；
• write（写入）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中；
  存模型还规定了在执行上述8种基本操作时必须满足如下规则：
• 不允许read和load、store和write操作之一单独出现，即不允许一个变量从主内存读取了但工作内存不接受，或者工作内存发起回写了但主内存不接受的情况出现；
• 不允许一个线程丢弃它最近的assign操作，即变量在工作内存中改变了之后必须把该变化同步回主内存；
• 不允许一个线程无原因地（没有发生过任何assign操作）把数据从线程的工作内存同步回主内存中；
• 一个新的变量只能在主内存中“诞生”，不允许在工作内存中直接使用一个未被初始化（load或 assign）的变量，换句话说就是对一个变量实施use、store操作之前，必须先执行assign和load操作；
• 一个变量在同一个时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执 行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁；
• 如果对一个变量执行lock操作，那将会清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新执行load或assign操作以初始化变量的值；
• 如果一个变量事先没有被lock操作锁定，那就不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定的变量；
• 对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store、write操作）；

volilate关键字

15.总结

学习新东西是常态：

• netty
• SpringClound Alibaba
• SSO单点登录及Linux安装

学习方法：1.百度 2.思维导图
单店登录：SSO
VM CentOS7

标签：Java,jar,探究,Program,内存,JVM,java,加载
From： https://www.cnblogs.com/wangzhen1991/p/16838382.html