jvm内存分为 堆 和 非堆

堆又分为：

1.老年代

Old Gen:年轻代的对象如果能够挺过数次收集，就会进入老人区

2.新生代

Eden Space（伊甸园）:一个Eden，所有新建对象都会存在于该区

Survivor Space(幸存者区):两个Survivor区，用来实施复制算法

3.持久代

permanent:装载Class信息等基础数据，默认64M,一般情况下，持久代是不会进行GC的

-XX:MaxPermSize=

-Xms 是堆的初始内存

-Xmx 是堆的最大内存

-Xmn 年轻代大小

-Xss 每个线程的堆栈大小

通过java -X 命令可查看

java –Xms128m –Xmx128m 

非堆分为

Metaspace

Code Cache

Compressed Class Space

　　　　　String sourcePath = "C:/Users/"+System.getProperties().getProperty("user.name")+"/Desktop";

        JavaFile javaFile = JavaFile.builder("proxy", typeSpecBuilder.build()).build();

        // 为了看的更清楚，我将源码文件生成到桌面

        javaFile.writeTo(new File(sourcePath));

        // 编译

        JavaCompiler.compile(new File(sourcePath + "/proxy/Proxy.java"));

        // 使用反射load到内存

        URLClassLoader classLoader = new URLClassLoader(new URL[] { new URL("file:C:\\Users\\"+System.getProperties().getProperty("user.name")+"\\Desktop\\") });

        Object obj = null;

        //Classloader：类加载器，你可以使用自定义的类加载器，我们的实现版本为了简化，直接在代码中写死了Classloader。

        Class clazz1 = classLoader.loadClass("proxy.Proxy");

        System.out.println(clazz1);

        System.out.println(clazz1.getDeclaredConstructors().getClass());

        //将生成的TimeProxy编译成class 使用类加载器加载进内存中 再通过反射或者该类的构造器

        //再通过构造器将其代理类 TimeProxy 构造出来

        //NoSuchException  打印classz信息 发现 刚开始创建类 没有使用public

        Constructor constructor = clazz1.getConstructor(InvocationHandler.class);

        System.out.println("constructor" + constructor);

        obj = constructor.newInstance(handler);

初始化还有很多规则,比如使用数组定义来引用类, 不会触发该类的初始化, DemoTest[] a = new DemoTest[10]，假如DemoTest里有类变量,静态块，则不会初始化

public class ClassLoadTest {

    public static void main(String[] args) {

        SuperCla[]  a = new SuperCla[11];

     }

}

class SuperCla{

static {

        System.out.println("xxxxx");

    }

}
执行结果是不输出任何结果
例如子类引用定义在父类的静态变量,则不会触发子类的初始化
例如编译阶段就有常量属性的,就是那种final static ,就不会触发类的初始化, 因为直接从常量池中取

public class ClassLoadTest {

    public static void main(String[] args) {

     }

    static {

        System.out.println("1");

    }

    static ClassLoadTest a = new ClassLoadTest();

    static {

        System.out.println("2");

    }

    {

        System.out.println("6");

    }

    ClassLoadTest(){

        System.out.println("3");

        System.out.println("b=" + b + ",c =" + c + ",d = " + d+ ",e=" + e);

    }

    int b = 100;

    static int c = 200;

    static final int d = 300;

    static int e = 400;

    static void func() {

        System.out.println("第二次c=" + c );

        System.out.println("4");

    }

}

1
6
3
b=100,c =0,d = 300,e=0
2

intern用来返回常量池中的某字符串，如果常量池中已经存在该字符串，则直接返回常量池中该对象的引用。

否则，在常量池中加入该对象，然后 返回引用。

原文举例：

Now lets understand how Java handles these strings. When you create two string literals:

String name1 = "Ram"; 

String name2 = "Ram";

In this case, JVM searches String constant pool for value "Ram", and if it does not find it there

then it allocates a new memory space and store value "Ram" and return its reference to name1.

Similarly, for name2 it checks String constant pool for value "Ram" but this time it find "Ram"

there so it does nothing simply return the reference to name2 variable.

The way how java handles only one copy of distinct string is called String interning.

举例

String s1 = new String("aaa").intern();

String s2 = "aaa";

System.out.println(s1 == s2);    // true

栈的使用是比如 线程执行test方法,就会创建test的栈帧,并将此栈帧压栈,发现inner()方法,又创建一个栈帧,压栈, 等inner()

方法执行完毕,则将inner()出栈,在将test()出栈

public class A {

        void test() {

                inner();

        }

        void inner(){

        }

那么只能是用一个 每个线程独有的 程序计算器 来记住A线程---位置3 ,这个也很好理解这个占用内存大小是固定的

public void test();

    Code:

       0: new           #17                 // class java/lang/String

       3: dup

       4: ldc           #19                 // String 1

       6: invokespecial #21                 // Method java/lang/String."<init>":

       (Ljava/lang/String;)V

       9: astore_1

      10: aload_1

      11: invokevirtual #24  

-Xms20m --jvm堆的最小值

-Xmx20m --jvm堆的最大值

-XX:+PrintGCTimeStamps -- 打印出GC的时间信息

-XX:+PrintGCDetails  --打印出GC的详细信息

-verbose:gc --开启gc日志

-Xloggc:d:/gc.log -- gc日志的存放位置

-Xmn10M -- 新生代内存区域的大小  

-XX:SurvivorRatio=8 --新生代内存区域中Eden和Survivor的比例

Java不使用的引用计数算法

：当对象有个地方引用它,计数器+1, 引用失效计数器-1, 计数器为0则判定为不可使用对象

 缺点：无法解决对象互相 循环引用

public class Test {

    public Test test; 

    public static void main(String[] args){

        Test t1 = new Test();

        Test t2 = new Test();

        t1.test = t2;

        t2.test = t1;

        System.gc();

    }

}
2.可达性分析算法(根搜索算法)：

这个算法的基本思想是通过一系列称为“GC Roots”的对象作为起始点，

从这些节点向下搜索，搜索所走过的路径称为引用链，

当一个对象到GC Roots没有任何引用链（即GC Roots到对象不可达）时，则证明此对象是不可用的。

在Java语言中，可以作为GCRoots的对象包括下面几种：

(1). 虚拟机栈（栈帧中的局部变量区，也叫做局部变量表）中引用的对象。

(2). 方法区中的类静态属性引用的对象。

(3). 方法区中常量引用的对象。

(4). 本地方法栈中JNI(Native方法)引用的对象。

package testGc;

/*

 * 此代码演示了两点：

 * 1.对象可以再被GC时自我拯救

 * 2.这种自救的机会只有一次，因为一个对象的finalize()方法最多只会被系统自动调用一次

 * */

public class FinalizeEscapeGC {

    public String name;

    public static FinalizeEscapeGC SAVE_HOOK = null;

    public FinalizeEscapeGC(String name) {

        this.name = name;

    }

    public void isAlive() {

        System.out.println("yes, i am still alive :)");

    }

    //如果判断为该对象不可达 

    //第一次标记 

    //对象没有覆盖finalize方法或者该finalize方法是否已经被虚拟机执行过了

    //则均视作不必要执行该对象的finalize方法，即该对象将会被回收

    //此FinalizeEscapeGC对象覆盖了finalize()  且该finalize方法并没有被执行过

    //这个对象会被放置在一个叫F-Queue的队列中

    //之后会由虚拟机自动建立的、优先级低的Finalizer线程去执行

    //第二次标记

    //关联上了GCRoots引用链则该对象将从“即将回收”的集合中移除

    //否则会被回收

    //只能第一次执行的时候可以拯救自己一次 不被回收

    @Override

    protected void finalize() throws Throwable {

        super.finalize();

        System.out.println("finalize method executed!");

        System.out.println(this);

        FinalizeEscapeGC.SAVE_HOOK = this;

        //关联上了GCRoots引用链

        //把this关键字赋值给其他变量

        //方法区中的类静态属性引用的对象

    }

    @Override

    public String toString() {

        return name;

    }

    public static void main(String[] args) throws InterruptedException {

        SAVE_HOOK = new FinalizeEscapeGC("leesf");

        System.out.println(SAVE_HOOK);

        // 对象第一次拯救自己

        SAVE_HOOK = null;

        System.out.println(SAVE_HOOK);

        // 两次标记  1.重写了finalize方法且没有执行过 放队列

        // 2.队列中坚持是不是有 关联上引用链  有即可以拯救自己一次

        System.gc();

        // 因为finalize方法优先级很低，所以暂停0.5秒以等待它

        Thread.sleep(500);

        if (SAVE_HOOK != null) {

            SAVE_HOOK.isAlive();

        } else {

            System.out.println("no, i am dead : (");

        }

        // 下面这段代码与上面的完全相同,但是这一次自救却失败了

        // 一个对象的finalize方法只会被调用一次

        SAVE_HOOK = null;

        System.gc();

        // 因为finalize方法优先级很低，所以暂停0.5秒以等待它

        Thread.sleep(500);

        if (SAVE_HOOK != null) {

            SAVE_HOOK.isAlive();

        } else {

            System.out.println("no, i am dead : (");

        }

    }

}

1、标记-清除（Mark-Sweep）算法

首先标记出所有需要回收的对象，标记完成后统一回收所有被标记的对象

效率低

2、复制（Copying）算法

它将可用的内存分为两块，每次只用其中一块，当这一块内存用完了

就将还存活着的对象复制到另外一块上面，然后再把已经使用过的内存空间一次性清理掉

分代收集算法就把内存划分为几块, 通常在新生代用复制算法

【新生代

Eden Space（伊甸园）:一个Eden，所有新建对象都会存在于该区

Survivor Space(幸存者区):两个Survivor区，用来实施复制算法】

如果采取1:1, 那非常不划算,意味着可用内存只能用一半,通常新生代的内存 Eden + Survivor 占90%, Survivor空闲占10%,

回收就 先复制  eden和survivor活着的对象到  Survivor, 再清理调eden 和 survivor

(HotSpot虚拟机默认Eden区和Survivor区的比例为8:1)

3、标记-整理（Mark-Compact）算法

分代收集算法就把内存划分为几块, 通常在老年代用标记整理法

因为老年代通常都是不易被回收的对象, 采用复制算法非常不划算, 存活90%, 复制后还是90%

让所有存活对象都向一端移动，然后直接清理掉边界以外的内存

4、分代收集算法

以上内容的结合, 根据对象的生命周期,内存划分 新生代, 老年代,

大批对象死去、少量对象存活的（新生代），使用复制算法

对象存活率高、没有额外空间进行分配担保的（老年代）采用其他两个方法</pre><figure><hr/></figure><h2>五.JVM性能调优</h2><pre class="prism-token token language-js">通过上面的一些理论, 具体的实践还是在项目中就具体情况进行分析, 当然99%的oom 都是代码问题导致的,

比如打印日志占用的内存空间不足,

比如某个线程产生大量对象缺没有被释放

少量是设置原因,比如最大堆内存设置的太小,

比如卡顿是因为频繁发生FUll GC, 那么如何调整老年代和新生代的大小