jvm的内存模型中运行时常量池与Class文件结构中说的常量池是否是同一个？

老年代调整：
标记-清除(Mark - Sweep)算法
标记-压缩(Mark - Compact)算法

老年代调整参数：
-XX:PretenureSizeThreshold 控制直接升入老年代的对象大小，大于这个值的对象会直接分配在老年代中

FULL GC发生的概率比较低，发生的话操作时间特别长，严重影响程序的性能。

永久代（JDK1.8之后被废除了）
该区域中的对象不会被回收。当时简单的理解是方法区就是永久代，HotSpot虚拟机规范中是存在永久代概念的。
被元空间取代

JDK1.8之后，元空间取代永久代，元空间的本质就是本机的物理内存
OOM异常 可能分为
堆内存溢出（Java Heap space）：往往出现在FUll GC失败之后
永久代溢出（PermGen space）：一个方法中出现的内存溢出
元空间溢出（Metaspace）：分配的物理内存不足，或者数据量高于物理内存

垃圾的收集一定要分两个空间考虑：年轻代、老年代，老年代的内存空间要大于年轻待

可用GC方式：
新生代可用GC策略：
串行GC(Serial Copying)
并行回收GC(Parallel Scavenge):
复制(Copying)清理算法；
操作步骤：
在扫描和复制时均采用多线程方式处理，并行回收GC为空间较大的年轻代回收提供许多优化
优势：
在多CPU的机器上其GC耗时会比串行方式短，适合多CPU、对暂停时间要求较短的应用
并行GC(ParNew)：
复制(Copying)清理算法
操作步骤：
并行GC(ParNew)必须结合老年代，"CMS GC"一起使用。因为年轻代如果发生了"Minor GC"时，老年代也需要使用"CMS GC"同时处理，
（并行回收GC并不会做这些）

CMS(Concurrent Mark-Sweep):是以牺牲吞吐量为代价来获得最短回收停顿时间的垃圾回收器。对于要求服务器响应速度的应用上，这种垃圾回收器非常适用
老年代可用GC策略：
串行GC(Serial MSC)
算法：标记-清除-压缩（Mark-Sweep-Compact）
操作步骤：
扫描老年代中还存活的对象，并且对这些对象进行标记
遍历整个老年代的内存空间，回收所有未标记的对象内存
将所有存活对象都集中在一端，而后将所有回收对象的内存空间变为一块连续的内存空间
优缺点：串行执行的过程中为单线程，需要暂停应用并耗时较长
并行GC(Parallel MSC)
算法：标记-压缩（Mark-Compact）
操作步骤：
将老年代内存空间按照线程个数划分若干子区域；
多个线程并行对各自子区域内的存活对象进行标记
多个线程并行清除所有未标记的对象
多个线程并行将多个存活对象整理在一起，并将所有被回收的对象空间整合为一体
优缺点：
多个线程同时进行垃圾回收可以缩短应用的暂停时间，但是由于老年代的空间一般较大，所以在扫描和标记存活对象上需要花费较长时间。

与串行相比，就是多了一个多线程的支持，但是这样的暂停时间就会减少
并行GC(CMS)
算法：标记-清除（Mark-Sweep）
操作步骤：
初始标记（STW【Stop-The World】 Initial Mark）：虚拟机暂停正在执行的任务（STW）,由根对象扫描出所有的关联对象，并做出标记。此过程只会导致短暂的JVM暂停
并发标记（Concurrent Marking）：恢复所有暂停的线程对象，并且对之前标记过的对象进行扫描，取得所有跟标记对象有关联的对象
并发预处理（Concurrent Precleaning）：查找所有在并发标记阶段新进入老年代的对象（一些对象可能从新生代晋升到老年代，或者有一些对象被分配到老年代），通过重新扫描，减少下一阶段的工作
重新标记（STW Remark）：此阶段会暂停虚拟机，对在“并发标记”阶段被改变引用或新创建的对象进行标记
并发清理（Concurrent Sweeping）：恢复所有暂停的应用线程，对所有未标记的垃圾对象进行清理，并且会尽量将已回收对象的空间重新拼凑为一个整体。在此阶段收集器线程和应用程序线程并发执行
并发重置（Concurrent Reset）：重置CMS收集器的数据结构，等待下一次垃圾回收。
优缺点：
只有在第一次和重新标记阶段才会暂停整个应用，这样对应用程序所带来的影响非常的小、缺点是并发标记与回收线程会与应用线程争抢CPU资源，并且容易产生内存碎片。

常用GC策略：
运行环境 年轻代GC 老年代
单机程序（client） 串行GC(Serial Copying) 串行GC(Serial MSC)
服务器程序（Server） 并行回收GC(Parallel Scavenge) 并行GC(Parallel Mark Sweep、Parallel Compacting)

如果要向确认使用的GC处理，首先需要知道当前的主机上可以支持的处理进程数量
调参：
使用串行GC策略：-XX:+UseSerialGC
使用并行GC策略：-XX:+UseParNewGC
使用CMS：-XX:+UseConcMarkSweepGC
CMS会经历如下几个步骤：
"CMS-concurrent-mark-start"：CMS标记开始
"CMS-concurrent-mark"：表示开始进行标记，进入到了STW状态（暂停）
"CMS-concurrent-preclean-start"：预清理开始
"CMS-concurrent-sweep-start"：开始进行无用对象清理
CMS的处理适当性能会好一些，但是这所有的GC策略都是现在正在常用的策略，不过似乎都有缺陷。

总结：
实际开发之中对于GC的策略不建议手动修改，默认的一版比较好

G1收集器：
对Java服务器而言，如何去选择一个合适的配置呢？ 默认情况下，Java会为每一个线程分配1M的内存空间。如果现在电脑有32G的内存，最大可以分配30G的内存空间（理论）
理论上可以处理 30* 1024 个用户请求,所以一般的服务器处理个5000——10000基本上也就够了

G1的实现方案相当于将所有的子内存区域合并在一起，也不在进行任何的区分，这样就相当于所有的内存的区域都可以按照统一的方式进行统一规划处理
G1的最大特点就是避免了全内存扫描

G1在标记和清理的时候是按照区域完成的，这样不影响其他的区域的执行，除此之外，使用的形式和之前的CMS都是类似的操作方式。
调参使用G1收集器：-Xmx10m -Xms10m -XX:+PrintGCDetails -XX:+UseG1GC

G1的垃圾收集比传统的GC要快一些

引用类型概述：
对于垃圾的产生与回收的处理之中，要想进行更好的控制，就必须清楚的掌握JAVA中的四种引用方式：
1.强引用（Strong Reference）：即使进行了多次GC的回收，即使JVM的内存真的已经不够用了，最终不得以抛出了OOM错误，那么该引用继续抢占
2.软引用（Soft Reference）：当内存空间不足时，可以回收此内存空间。如果充足则不回收，可以用其完成一些缓存的处理操作开发
3.弱引用（Weak Reference）：不管内存是否紧张，只要一出现GC处理，则立即回收
4.幽灵引用（Phantom Reference）：和没有引用是一样的

强引用：
即使出现GC，即使内存不足，该引用的数据也不会被回收
强引用不是造成OOM的关键因素，正常来讲，你每一个用户（线程）操作完成后该对象都很容易进行回收。
软引用：
当内存空间不足时才进行GC的空间释放，但是如果想使用软引用必须单独使用特殊的处理类：
import java.lang.ref.SoftReference;
public class SoftReferenceTest {
public static void main(String[] args) {
String str = "www.cwnu.com";
//加入到软引用之中
SoftReference stringReference = new SoftReference(str);
//类似强引用端口连接
str = null;
//因为软引用空间还很富裕，所以不会释放
System.gc();
System.out.println(stringReference.get());

}
}
在开发中，可以利用软引用实现高速缓存组件
弱引用：
最大的特点：一旦发生GC操作，则保存的内容则立即释放
import java.lang.ref.WeakReference;
public class WeakReferenceTest {
public static void main(String[] args) {
String a = new String("www.cwnu.com");
WeakReference reference = new WeakReference(a);
a = null;
System.gc();
System.out.println(reference.get());
}
}
在我们类集里面有一个与弱引用功能相似的Map集合，WeakHashMap，它属于弱引用的一个实现
import java.util.*;
public class WeakReferenceTest {
public static void main(String[] args) {
Map map = new WeakHashMap();
map.put(new Integer(1),new String("a"));
map.put(new Integer(2),new String("b"));
System.gc();
System.out.println(map);
}
}
使用WeakHashMap好处是保存一些共享数据，如果长时间不使用则可以清空

引用队列：
如果要想清楚引用队列，则首先必须知道对象的引用的强度，如果说按照现在的理解来讲： 强引用 > 软引用 > 弱引用。

引用队列里面所保存的就是一个要准备被回收的对象的信息
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

public class ReferenceQueueTest {
public static void main(String[] args) throws Exception{
String str = new String("www.cwnu.com");

ReferenceQueue queue = new ReferenceQueue();
WeakReference weak = new WeakReference(str,queue);
str = null;
System.out.println(weak.isEnqueued());
System.gc();
Thread.sleep(500);
System.out.println(weak.isEnqueued());
//观察队列是否有内容
System.out.println(queue.poll());
}
}
幽灵引用（虚引用）：
幽灵引用指的是什么都不保存，但是又看起来保存了似得。
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class PhantomReferenceTest {
public static void main(String[] args) throws Exception{
String str = new String("www.cwnu.com");

ReferenceQueue queue = new ReferenceQueue();
PhantomReference ps = new PhantomReference(str,queue);
str = null;
System.out.println(ps.isEnqueued());
System.gc();
Thread.sleep(500);
System.out.println(ps.isEnqueued());
//观察队列是否有内容
System.out.println(queue.poll());
}
}

幽灵引用直接把保存的内容保存在引用队列之中

关于逃逸分析：
在平时开发过程中就要可尽可能的控制变量的作用范围了，变量范围越小越好

建议去刷题，我运气好，简单的算法让我碰到了，一些快排，堆排，二叉树相关的，链表反转，成环，环节点，跳楼梯等常规的简单算法建议刷刷，双指针，dp，递归这些还是多找找感觉，大数据内存有限的场景的统计，有时间一些middle可以去试试，手写红黑树你要是可以，那我估计算法你稳了

堆栈相关：
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.
2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）
3. 堆：存放所有new出来的对象。
4. 静态域：存放静态成员（static定义的）
5. 常量池：存放字符串常量和基本类型常量（public static final）。
6. 非RAM存储：硬盘等永久存储空间