JVM（二）JProfiler的使用+GC常用算法+JMM浅谈

6.Native

编写一个多线程类启动

package com.qingkuang.jvm;

public class Demo {
    public static void main(String[] args) {
        new Thread(()->{

        },"my thread name").start();
    }
    //native :凡是代理native 关键字的，说明java的作用范围达不到了，会去调用底层的C语言库！
    //会进入本地方法栈
    //调用本地方法接口！ JNI
    //JNI作用：扩展Java的使用融合Java
    //Java诞生的时候C、C++ 想要立足 ，就必须由调用C，C++ 的程序~
    //它在内存区域中专门开辟出来一块标记区域：Native method Start，登记native 方法
    //它会在最终至此那个的时候，加载本地方法库中的方法通过JNI

    //Java程序驱动打印机   管理系统  掌握即可 在企业及应用中较为少见。
    private native void start0();

    //调用其他接口：  Socket WebService ... http

    //球球爱心网：  ---> 输入（php） --->NodeJS--->Socket --->C++ ---> 游戏刷爱心

}

点进去看strat方法的源码

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

            try {
                this.start0();
                started = true;
            } finally {
                try {
                    if (!started) {
                        this.group.threadStartFailed(this);
                    }
                } catch (Throwable var8) {
                }

            }

        }
    }

凡是带了native关键字的，说明java的作用范围达不到，去掉底层的C语言的库

JNI：Java Nation Interface （Java本地方法接口）

凡是带了native关键子的方法就会进入本地方法栈，其他的就是Java栈；

Native Interface本地接口

本地接口的作用是融合不同的编程语言Java所用，他的初衷是融合C/C++程序，Java在诞生的时候是C/C++恒星的时候，想要立足就需要调用C、C++的程序，于是就在内存中专门开辟了一块区域处理编辑为native的带码，它的集体做法就是在Native Method Stack中登记native 方法，在（Execution Engine）执行擎执行的时候加载Native Libraies。

目前该方法使用的越来越少了，除非是于哟ing吉安有关的应用，比如通过Java驱动打印机或者Java系统管理生产设备，在企业级应用已经比较少见，因为现在的异构磷化工与间通信很发达，比如可以使用Socket通信，也可以使用WebService等等，不多做介绍！

Native Method Stack

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

7.寄存器

程序计数器：Program Counter Register

每个线程都有一个程序计数器，是线程私有的，就是一个指针，只想方法去中的方法字节码（用来存储只想一条指定的地址，业绩将要执行的代码指令），在执行引擎读取下一条执行，是一个非常小的写存款i昂教案，几乎可以忽略不计

8.方法区

Method Area方法区

方法区是被所有线程共享，所有字段和方法字节码，以及一写特殊的方法，如构造函数，接口代码也定义在此，简单的说，所有定义的方法信息都保存在该区域，此区域属于共享区间

静态吧v变量、常量、信息类（构造方法，接口定义）、运行时的常量池存在方法区中，但是实例变量存在对内存中，和方法无关。

static 、final 、Class模板、常量池

9.栈

栈：数据接口

程序 = 数据结构 + 算法：持续学习 ~

程序 = 框架 + 业务逻辑：吃饭 ~

栈：先进后出，后进先出：桶

队列：先进先出（FIFO：first input first out）

喝多了吐就是栈，吃多了拉就是队列

为什么main()方法，先执行，最后结束。

栈：栈内存，主管程序的运行；生命周期和线程同步；

线程结束，栈内存也就释放了，对于栈来说，不存在垃圾回收问题

一旦线程结束，栈就Over！

栈：8大基本类型+对象引用+实力的方法

栈运行原理：栈帧

栈满了就会报错：StackOverflowError

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

10.三种JVM

Sun公司 HotSpot Java HotSpot(TM) 64-Bit Server VM (build 25.151-b12, mixed mode)
BEA JRockit
IBM J9 vm

我们学习的都是：HotSpot

11.堆

Heap，一个JVM只有一个堆内存，堆内存的大小是可以调节的。

类加载器读取了类文件后，一般会把什么东西放在堆中呢？类，方法，常量，变量~，保存我们所有引用类型的真实对象；

堆内存中还要细分为三个区域：

新生区（伊甸园区）Young/New
养老区 Old
永久区 Perm

GC垃圾回收，主要是在伊甸园区和养老区~

假设内存满了，OOM，堆内存不够！java.OutOfMemoryError:Java heap space

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

新生区

类：诞生和成长的地方，甚至死亡；
伊甸园区，所有的对象都是在伊甸园区new出来的。
幸存者区（0，1）

老年区

真理：经过研究，99%的对象都是临时对象。

永久区

这个区域长治内存的。用来存放JDK自带的Class对象。Interface元数据，存储的是java运行时的一些环境或类信息，这个区域不存在垃圾回收！关闭虚拟机就会释放这个区域的内存~

一个启动类，加载了大量的第三方jar包。tomcat不受了太多的应用，大量动态生成的反射类。不断地被加载。直到内存满，就会出现OOM；

jdk1.6之前：永久代：常量池是在方法区；
jdk1.7 ：永久代，但是慢慢的退化了，去永久代，常量池在堆中。
jdk1.8之后：无永久代，常量池在原空间。

原空间：逻辑上存在，物理上可能不存在

内存过大，修改参数为M

OMM:

1.尝试扩大堆内存，看结果。

2.分析内存，看一下那个地方出现了问题。（专业工具）

305664K+699392K = 1005056K = 981.5M

E:\java\jdk8\bin\java.exe -Xms8m -Xmx8m -XX:+PrintGCDetails "-javaagent:F:\IDEAFree\IntelliJ IDEA 2019.2.3\lib\idea_rt.jar=59045:F:\IDEAFree\IntelliJ IDEA 2019.2.3\bin" -Dfile.encoding=UTF-8 -classpath E:\java\jdk8\jre\lib\charsets.jar;E:\java\jdk8\jre\lib\deploy.jar;E:\java\jdk8\jre\lib\ext\access-bridge-64.jar;E:\java\jdk8\jre\lib\ext\cldrdata.jar;E:\java\jdk8\jre\lib\ext\dnsns.jar;E:\java\jdk8\jre\lib\ext\jaccess.jar;E:\java\jdk8\jre\lib\ext\jfxrt.jar;E:\java\jdk8\jre\lib\ext\localedata.jar;E:\java\jdk8\jre\lib\ext\nashorn.jar;E:\java\jdk8\jre\lib\ext\sunec.jar;E:\java\jdk8\jre\lib\ext\sunjce_provider.jar;E:\java\jdk8\jre\lib\ext\sunmscapi.jar;E:\java\jdk8\jre\lib\ext\sunpkcs11.jar;E:\java\jdk8\jre\lib\ext\zipfs.jar;E:\java\jdk8\jre\lib\javaws.jar;E:\java\jdk8\jre\lib\jce.jar;E:\java\jdk8\jre\lib\jfr.jar;E:\java\jdk8\jre\lib\jfxswt.jar;E:\java\jdk8\jre\lib\jsse.jar;E:\java\jdk8\jre\lib\management-agent.jar;E:\java\jdk8\jre\lib\plugin.jar;E:\java\jdk8\jre\lib\resources.jar;E:\java\jdk8\jre\lib\rt.jar;F:\untitled\out\production\untitled com.company.lession04.Test01.Demo
[GC (Allocation Failure) [PSYoungGen: 1536K->488K(2048K)] 1536K->656K(7680K), 0.1638537 secs] [Times: user=0.00 sys=0.00, real=0.24 secs] 
[GC (Allocation Failure) [PSYoungGen: 1833K->488K(2048K)] 2001K->892K(7680K), 0.0031472 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 1859K->456K(2048K)] 2263K->1820K(7680K), 0.0048897 secs] [Times: user=0.05 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 1636K->456K(2048K)] 3000K->2203K(7680K), 0.0019816 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 1637K->456K(2048K)] 4921K->3739K(7680K), 0.0008036 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 1253K->424K(2048K)] 4537K->4475K(7680K), 0.0012308 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Ergonomics) [PSYoungGen: 1221K->0K(2048K)] [ParOldGen: 5587K->2964K(5632K)] 6809K->2964K(7680K), [Metaspace: 3481K->3481K(1056768K)], 0.0114885 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 0K->0K(2048K)] 2964K->2964K(7680K), 0.0006513 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 0K->0K(2048K)] [ParOldGen: 2964K->2944K(5632K)] 2964K->2944K(7680K), [Metaspace: 3481K->3481K(1056768K)], 0.0141595 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
Exception in thread "main" 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:208)
	at com.company.lession04.Test01.Demo.main(Demo.java:10)
Heap
 PSYoungGen      total 2048K, used 91K [0x00000000ffd80000, 0x0000000100000000, 0x0000000100000000)
  eden space 1536K, 5% used [0x00000000ffd80000,0x00000000ffd96f90,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 5632K, used 2944K [0x00000000ff800000, 0x00000000ffd80000, 0x00000000ffd80000)
  object space 5632K, 52% used [0x00000000ff800000,0x00000000ffae0218,0x00000000ffd80000)
 Metaspace       used 3513K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 384K, capacity 388K, committed 512K, reserved 1048576K

Process finished with exit code 1

在一个项目中，突然出现了OOM故障，那么该如何排除~研究为什么出错

能够看待代码第几行出错：内存快照分析工具，MAT，Jprofiler
Debug，一行行分析代码！

MAT，Jprofiler作用：

分析Dump内存文件，快速定位内存泄露；
获得堆中的数据
获得大的对象~
...

package com.company.lession04.Test01;

import java.util.ArrayList;

//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 = count+1;
            }

        }catch (Exception e){
            System.out.println("count"+count);
            e.printStackTrace();

        }

        //Throwable
            //Exception
            //error



    }

}

1.首先定位到最大对象发现char[]有问题。

2.查看线程，看main方法，定位到出错的行数。

发现这两个线程有问题，行数也被定位了。

命令：Dump:-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError

修改错误的名字即可。

Xms：设置初始化内存分配大小。默认1/64

Xmx：设置最大分配内存。默认i/4

-XX:+PrintGCDetails 打印GC垃圾回收信息。

栈里面没有垃圾，只有推里面会有垃圾。

GC：垃圾回收

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

新生代
幸存区（from，to ）
老年区

GC两种类型：轻GC（普通的GC），重GC（全局GC）

题目：

JVM的内存模型和分区~详细到每个区放什么？
堆里面的分区有哪些?Eden,from,to,老年区，说说他们的特点
GC的算法有哪些？标记清除法，标记压缩，复制算法，引用计数器，怎么用？
轻GC和重GC分别在什么是后发生？

引用计数法：

C对象会被清除。

复制算法：

1.伊甸园区到to区，from到to区（清理完毕后，to区与伊甸园区是空的）

2.一部分存活下来的去到养老区，死掉的直接被回收。

好处：没有内存的碎片
坏处：浪费了内存空间：多了一半的空间永远是空的to区。（一个幸存区的空间~）假设对象100%存活（极端情况）OOM

复制算法最佳使用场景，对象存货度较低的时候：新生区~

标记清楚算法

扫描这些对象，对活着的对象进行标记。

清楚：对没有进行标记的对象进行清除。

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

标记压缩

压缩：防止内存碎片产生，再次扫描，向一段移动存活的对象。多了一个移动成本。

标记清除压缩。

1.先标记清除几次，再压缩。

总结

内存效率：复制算法 > 标记清除算法 > 标记压缩算法（时间复杂度）

内存整齐度：复制算法 = 标记压缩算法 > 标记清除算法

内存利用率：标记压缩算法 = 标记清除算法 > 复制算法

思考一个问题：难道没有最优的算法吗？

答案：没有最好的算法，只有最合适的算法--------->GC：分代收集算法。

年轻代：

存活率底
复制算法！

老年代：

区域大，存活率高
标记清除（内存碎片不是太多）+标记压缩混合实现

一天时间学JVM，不现实，要探究，就必须下去花时间多看面试题，以及《深入理解JVM》

但是我们可以掌握一个学习JVM的方法~

JMM

什么是JMM？

JMM：Java Memory Model
它干嘛的？：官方，其他人的博客，对应的视频！

作用：缓存一致性协议，用于定义数据读写的规则（遵守，找到这个规则）。

JMM定义了线程工作内存和主内存之间的抽象关系：线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory）

解决共享对象可见性这个问题：volilate

它该如何学习？

JMM是一个抽象的概念，理论

主内存与工作内存八种操作指令：
- lock（锁定）：作用于主内存的变量，它把一个变量标识为一条线程独占的状态；
- unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；
- read（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用；
- load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中；
- use（使用）：作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作；
- assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作；
- store（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后的write操作使用；
- write（写入）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中；
如果要把一个变量从主内存拷贝到工作内存，那就要按顺序执行read和load操作，如果要把变量从工作内存同步回主内存，就要按顺序执行store和write操作。注意Java内存模型只要求上述两个操作必须按顺序执行，但不要求是连续执行。也就是说read与load之间、store与write之间是可插入其他指令的，如对主内存中的变量a、b进行访问时，一种可能出现的顺序是read a、read b、load b、load a。除此之外，Java内存模型还规定了在执行上述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操作）；

posted @ 2022-02-07 10:29 轻狂书生han 阅读(511) 评论(0) 收藏举报

刷新页面返回顶部

轻狂书生han