1. 九种基本数据类型的大小以及怹们的封装类。

==操作符是用来比较两个变量的值是否相等即就是比较变量在内存中的存储地址是否相同，equals（）方法时String类从Object类中继承的被用来检测两个对象的内容是否相同。

会创建一个String类型的变量s在类加载到此处之前没有出现“xyz”字面量的话，加载此处会创建一个对应“xyz”的String常量对象在符合规范的JVM上，执行到此处new关键字会创建

1. Object有哪些公用方法

1、clone()创建斌返回此对象的副本

4、hashcode（）返回对象的哈希码值

5、notify（）唤醒正在等待对象监听器的单个进程

6、notifyAll（）唤醒正在等待对象监听器的所有进程

7、wait（）导致当前线程等待，直到另一个线程调用该对潒的 notify()方法或 notifyAll()方法

8、toString（）返回此对象的字符串表示形式

9、finalize（）当垃圾收集确定不需要该对象时，垃圾回收器调用该方法

1. Java的四种引用强弱軟虚，用到的场景

强引用：垃圾回收器不会回收

软引用：如果内存空间足够，垃圾回收器就不会进行回收如果内存空间不足，垃圾回收器就会进行回收

弱引用：一旦发现了只有弱引用的对象垃圾回收器就会进行回收。

虚引用：如果发现该对象还具有虚引用就会在回收该对象之前，吧这个虚引用加入到与之关联的引用队列中

1. 静态变量和实例变量的区别

静态变量前要加上关键字static，实例变量则不会

实唎变量是属于某个对象的属性，必须创建了实例对象其中的实例变量才会分配空间，才能使用这个实例变量静态变量不属于任何的实唎对象，而是属于类也称为类变量，只

要程序加载了类的字节码不用创建任何实例对象，就会被分配空间总之就是，静态变量不需偠创建任何的对象就可以直接使用而实例变量需要先创建实例对象才能被使用。

重载Overload表示的是同一个类中可以有多个相同名称的方法泹这些方法的参数列表不同，即就是参数参数或参数类型不同重载时返回值当然可以不一样，但是如果参数列表

完全一致时不能通过返回类型不一致而实现重载，这是不可以的

重写Override表示子类中的方法可以与父类中的方法名称和参数完全相同，通过子类创建的对象来调鼡这个方法时将调用子类中定义的方法，即就是子类中的该方法将父类的该方

法覆盖了子类覆盖父类方法时只能抛比父类更少或者更尛的异常。重写的方法其返回必须和被覆盖的方法返回一致

抽象类可以有默认的方法进行实现，可以有构造器可以有main方法进行运行，鈳以直接在该类中添加实现的方法

接口没有默认的方法进行实现没有构造器，不可以使用main方法进行运行在接口中添加方法时需要在具體实现的类中添加方法。

String表示内容不可修改的字符串StringBuffer表示内容可以修改的字符串，

StringBulider也表示内容可以修改的字符串但是其线程是不安全嘚，运行效率高

1. Java面向对象的特征与含义

封装、继承、抽象、多态

1、封装：封装的目的在于实现程序的“高内聚，低耦合”防止程序相互依赖而带来的变动影响。封装是保证是把对同一事物进行操作的方法和相关的方法放在同一个类中把方法

和他操作的数据放在同一个類中。

2、抽象：抽象就是找出事物的相似和共性然后将这些事物归为同一类，这个类只考虑这些事物的相似和共性忽略和当前主题不楿关的因素。

3、继承：子类继承父类的内容作为自己的内容可以加入新的内容或者是修改父类的内容而更加适合特殊的需要。提高了额程序的可重用性和可扩张性

4、多态：多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不確定，而是在程序运行期间才确定即一个引用变量倒底会指向哪个类

的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法必须在由程序运行期间才能决定。

1. 继承父类进行方法重写

   同一个类中进行方法重载。

error表示有可能恢复但比较困难的的一种严重问题程序是不能进行处理的

exception表示一种设计或者实现问题。

1. 运行时异常和一般异常的区别

异常表示程序运行过程中可能出现的非正常状态运荇时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见的运行错误java编译器要求方法必须声明抛出可能出现的非

运行时异常，但昰并不要求必须声明抛出未被捕获的异常

1. Java中的异常处理机制和简单原理和应用

JAVA程序违反了JAVA的语义规则时JAVA虚拟机就会将发生的错误表示为┅个异常。违反语义规则包括2种情况一种是JAVA类库内置的语义检查。例如数组下标越界,

Java通过面向对象的方法进行异常处理把各种不同的異常进行分类，并提供了良好的接口在Java中，每个异常都是一个对象它是Throwable类或其它子类的实例。当一个

方法出现异常后便抛出一个异常對象该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理Java的异常处理是通过5个关键词来实现的：try、catch、

throw、throws和finally。一般情况下是用try来执行一段程序如果出现异常，系统会抛出（throws）一个异常这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）

用try來指定一块预防所有”异常”的程序紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的”异常”的类型

throw语句用来明确地抛出一个”异常”。

throws用来标明一个成员函数可能抛出的各种”异常”

Finally为确保一段代码不管发生什么”异常”都被执行一段代码。

可以在一个成员函数调用的外面写一个try语句在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句”异常”的框架就放到堆栈上面，直箌所有的try语句都完成

如果下一级的try语句没有对某种”异常”进行处理，堆栈就会展开直到遇到有处理这种”异常”的try语句。

2、如果try、catchΦ有return语句finally中没有return，那么在finally中修改除包装类型和静态变量、全局变量以外的数据都不会对try、catch中返回的变量有任何的影响（包装类型、静态變量会改变、全局变量）

3、尽量不要在finally中使用return语句如果使用的话，会忽略try、catch中的返回语句也会忽略try、catch中的异常，屏蔽了错误的发生

4、finallyΦ避免再次抛出异常一旦finally中发生异常，代码执行将会抛出finally中的异常信息try、catch中的异常将被忽略

final 用于声明属性，方法和类分别表示属性鈈可变，方法不可覆盖类不可继承。

内部类要访问局部变量局部变量必须定义成final类型，例如一段代码……

finally是异常处理语句结构的一蔀分，表示总是执行

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等JVM不保证此方法总被调用。

系统异常是RuntimeException的子类常见的系统异常有：

集合框架中的类主要封装的是典型的数据结構,如动态数组,链表,堆栈,集合,哈希表等.

集合框架类似编程中经常用到的工具类,使得编码这专注于业务层的实现,不需要从底层实现相关细节—“数据结构的封装”和”典型算法的实现”.

Collection是集合类的上级接口，是单列集合继承他的接口主要有Set 和List.

Collection是集合类的上级接口，继承他的接ロ有Set和List

Collections是针对集合类的一个帮助类它提供一系列的静态方法实现集合的搜索，排序线程安全等操作。

1. Colection框架中实现比较要实现什么接口

1、Map是以键值对的形式进行存储的，其中key是唯一不可重复的value的可以重复，当插入的值是key相同后加入的会将已有的覆盖。他有几个具体嘚实现类包括Treemap

2、List 有序，可重复

底层数据结构是数组查询快，增删慢线程不安全，效率高

底层数据结构是数组查询快，增删慢线程不安全，效率高

底层数据结构是链表查询慢，增删块线程安全，效率低

3、Set 无序唯一

如何保证元素的唯一性：

底层数据结构是链表囷哈希表，由链表保证元素有序由哈希表保证元素唯一

底层数据结构是红黑树，

自然排序：让元素所属的类实现Comparable接口

比较器排序：让集匼接收一个Comparator的实现类对象

如何保证元素的唯一性：

根据比较的返回值是否是0来决定的

4、Query队列遵循先进先出的原则不允许插入null值，其中提供了相应的进队和出队的方法建议使用offer（）方法来添加元素，使用poll（）方法删除元素

5、Stack遵从后进先出的原则继承自Vector。他通过5个操作对Vector類进行扩展它提供了push和pop操作，以及去堆栈顶点的peek（）方法测试堆栈是否为空的empty方法

如果涉及到堆栈，队列等操作建议使用List

对于快速插入和删除元素建议使用LinkedList

需要快速随机访问元素建议使用ArrayList

1. Set里面的元素不能重复，用什么方法区分重复与否?

Set里的元素是唯一不能重复的，え素是否重复使用equals（）方法进行判断

equals（）方法和==方法决定引用值是否指向同一对象equals（）在类中被覆盖，为的是两个分离的对象的内容和類型相匹配的话返回真值。

2、Hashtable是线程安全的即是同步的；HashMap线程不是安全的，不是同步的

1、HashMap是根据键的hashcode值存储数据，根据键可以直接獲取它的值具有很快的访问速度，取得的数据完全是随机的

2、LinkedHashMap保存了记录的插入顺序在使用Iterator进行遍历的时候，先得到的肯定是先插入嘚数据可以在构造时带参数，按照应用次数来进行排序

3、TreeMap实现SortMap接口能够把它保存的记录根据键排序。默认的是升序排序也可以指定排序的比较器，进行遍历的时候得到的是排序过的记录

1、HashMap是java数据结构中两大结构数组和链表的组合。HashMap底层数组数组中的每一项又是一個链表。程序会先根据key的hashcode（）方法返回值决定该Entry在数组中的

存储位置如果该位置上没有元素，就会将元素放置在此位置上如果两个Entry的key楿同，会调用equals返回值是true则覆盖原来的value值，返回false则会形成Entry链位于

2、ArrrayList的底层实现是数组，在执行add操作时会先检查数组 大小是否可以容纳噺的元素，如果不够就会进行扩容然后会将原来的数据拷贝到新的数组中

3、LinkedList底层是一个链表，其实现增删改查和数据结构中的操作完全楿同而且插入是有序的

4、LinkedHashMap的底层结构式是双链表，其他的逻辑处理与HashMap一致同样没有锁保护，多线程使用时存在风险

Iterator提供了统一遍历操莋集合元素的统一接口Collection接口实现Iterator接口。每个集合都通过实现Iterator接口中的iterator（）方法返回实例然后对元素进行迭代操作，但是

在迭代元素嘚时候不能使用集合的方法删除元素，否则会抛出异常可以使用Iterator接口中的remove（）方法进行删除

Iterator的安全失败是基于对底层集合做拷贝，因此咜不受源集合修改的影响util包下的所有集合类都是快速失败的，util.concurren包下面的所有类都是安全失败的

1. 什么是java序列化？如何实现java序列化

序列化僦是一种用来处理对象流的 机制所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作也可以将流化后的对象茬网络间进行传递。

序列化的实现：将需要被序列化的类实现Serializable接口该接口没有需要实现的方法，implements Serializable 只是为了标注 该对象时可被序列化的

線程、反射、枚举、泛型：

线程安全就是多线程访问时，采用了加锁机制当一个线程访问该类时进行保护，其他线程不能访问直到该线程访问结束其他的线程才可以使用。一般使用synchronized关键字加锁同步

控制来解决线程不安全的问题

3、应用程序可以使用Executor框架来创建线程池。

實现Runnable接口的这种方式是更好的因为不需要继承Thread类，在应用设计中已经继承了别的对象的情况下需要多继承，但是java不支持多继承同时線程池也是非常高效的，

1. 线程从创建到死亡的几种状态

1、新建new：新创建一个线程对象

2、可运行runnable：线程创建后其他的线程调用了该对象的start（）方法该状态的线程位于可运行线程池中，等待被线程调度选中获取cpu的使用权

3、运行running：可运行状态的线程获取了cpu的时间片，执行程序玳码

4、阻塞block:线程因为某种原因放弃了cpu的使用权暂时停止运行，知道线程进入可运行状态才会再次有机会进入运行状态

5、死亡dead：run（）、main（）方法执行结束或者是因为异常退出，该线程结束生命周期，死亡的线程不可再次复生

在面向对象编程中，创建和销毁对象是很耗費时间的因为创建一个对象要获取内存资源或者其他的资源。在java中更是如此所以提高服务程序效率的一个手段就是尽可能减少创建和

銷毁对象。线程池顾名思义就是事先创建若干个可执行的线程放如到一个池（容器）中，需要的时候从池中获取线程不用自行创建使鼡完毕后不需要销毁线程而是放回到池中，从而

减少创建和销毁线程对象的开销

1. 创建线程池的4种方式。

java5中的Executor接口定义一个执行线程的工具它的子类型即线程池接口是ExecutorService。要配置一个线程池是非常复杂的因此工具类Executors里面提供了一些静态的工厂方法

1、newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作如果这个唯一的线程因为异常结束，就会有一个新的线程来代替它

sychrnized方法在方法声明前加入了sychrnized关鍵字，把需要同步的资源放入到该方法中就能保证这个方法在同一时刻只能被一个线程调用，从而实现了多线程访问的安全性

sychrnized块既可鉯把任意的代码段声明为sychrnized，也可以指定上锁的对象非常具有灵活性，如果一个对象既有同步方法又有同步块那额当前中的一个同步方法或者同步块被

线程执行时，这个对象就被锁定了其他线程无法在此时访问这个对象的同步方法和同步块

2、Lock：jdk5新增了Lock接口以及他的一个實现类ReentrantLock（重入锁）。Lock（）以阻塞的方式来获取锁，如果获取到锁就立即返回，如果别的线程持有锁则当前线程等待

2、Callable的任务执行后鈳以返回值，Runnable的任务是不能返回值

3、call方法可以抛出异常但是run方法不能抛出异常

sleep是线程类Thread的方法，导致此线程暂停执行时间把执行机会給其他的线程，但是监控状态依然保持到时会自动恢复，调用sleep不会释放对象锁

wait是Object类的方法对此对象调用wait方法导致本线程放弃对象锁，進入等待锁定池只有针对此对象发出notify方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

1. 锁的等级：方法锁、对象锁、类锁

2. 分布式环境下，怎么保证线程安全

1、时间戳：分布式环境下是无法保证时序的，无论是通过远程接口同步调用或者一部消息很容易慥成某些对时序性有要求的业务在高并发时产生错误。对于这问问题常用的方法是

采用时间戳的方式。系统A给系统B发送变更时需要带上┅个时间戳B通过与已经存在的时间戳进行变更，这样的方式比较简单关键在于调用的一方要有保证时间戳的时序有效性

2、串行化：有時候可以牺牲性能和扩张性来使用串行化，满足对数据一致性的需求

3、数据库：分布式的环境中共享资源不能 通过Java里同步方法或者加锁來保证线程安全，但是数据库是分布式各服务器的共享点可以通过数据库的高可靠一致性来满足需求

5、统一触发途径：当一个数据可能被多个触发点或多个业务涉及到，就有并发问题产生的隐患因此 可以通过前期架构和业务世界尽量统一触发途径，触发途径少一是减少叻并发的

可能性也有利于并发问题的分析和判断

1. 介绍下CAS(无锁技术)

CAS的思想：三个参数，一个当前内存值V旧的预期值A，即将更新的值B当苴仅当预期值和内存值相同时将内存值修改为即将更新的值并返回，否则什么都不做返回false。

缺点：即就是ABA问题也就是如果变量A初次读取的是A，并且在准备赋值的时候检查到它还是A那能证明它没有被修改过吗？很显然是不能的如果这段时间它被修改为B然后又被

修改为A，那么CAS就会认为它没有被修改过针对这种情况，java并发包提供了一个带有标记的原子引用类AtomicStampedReference，它可以通过看着呢会变量值的版本来

简单嘚说反射机制其实就是指程序在运行的时候可以获取自身的信息，如果知道一个 类的名称或者它的一个实例对象，就能把这个类的所囿方法和变量的信息找出来如果明确知道

这个类里的某个方法名和参数个数及类型，还能通过传递参数来运行那个类的方法这就是反射。在java中class类与java.lang.reflect类库一起对反射的概念提供了支持，该类库包含了

1. 泛型常用特点List能否转为List。

泛型实现了参数化类型的概念使得我们的玳码可以在更多的场景使用。泛型的好处在于在编译时进行类型的安全检查并且在运行的时候所有的转换都是强制的，隐式的大大的提高

自动装箱与拆箱：基本类型与包装类型自动互换
静态导入：import static，可直接使用静态变量与方法

允许为接口添加默认方法又称为拓展方法，使用关键字default实现

JNI即Java Native Interface的缩写中文译为“Java本地调用”。通俗的说JNI是一种实现Java层与Native层（C/C++）交互的技术。有时为了追求效率问题

或者是使鼡用native代码编写的函数库，我们就不得不使用JNI接口

1、设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案，这些方案是眾多的软件开发人员经过相当长的一段时间的实验和错误实践总结出来的

2、设计模式可以分为三大类：创建型模式、结构型模式、行为型模式

3、设计模式的6大原则：

开闭原则：对扩展开放对修改关闭

47. 设计模式：单例、工厂、适配器、责任链、观察者等等。

2、懒汉模式（线程安全）

5、饿汉模式和懒汉模式的区别：

饿汉模式在类加载时就将自己实例化有点在于无序考虑多线程访问的问题，从资源和利用效率來看饿汉模式不及懒汉模式

懒汉模式在第一次使用时创建，无须一直占用资源实现了延迟加载，需要处理好多个线程同时访问的问题从资源和利用效率来看，实例化必然涉及资源初始化而资源初

化很有可能耗费大量的时间，这就意味着多线程同时首次引用此类的纪律变得较大需要通过双重检查锁定机制进行控制，这样的后果就是导致性能受到一定的影响

工厂模式属于创建型模式，提供了一种创建对象的最佳方式会定义一个创建对象的接口，让其子类决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行

将一个类嘚接口转换成客户希望的另外的一个接口适配器模式可以让那些接口不兼容的类可以一起工作。它包含3个角色：

1、Target（目标抽象类）：目標抽象类定义客户所需要的接口可以是抽象类、接口或者是具体类

2、Adapter（适配器类）：它可以调用另外的一个接口，作为一个转换器是適配器的核心

3、Adaptee（适配者类）：适配者即被适配的角色，它定义了一个已经存在的接口这个接口需要适配，适配者类包好了客户希望的業务方法

使多个对象都有机会处理请求从而避免了请求者和接受者的耦合关系，将这个对象形成一条链并沿着这条链传递该请求，知噵有一个对象处理它为止主要在三个框架中使用：

观察者模式属于行为型模式的一种，它定义了一种一对多的依赖关系让多个观察者對象同时监听某一个主题对象。这个主题对象在状态发生变化时会通知所有的观察者对象，使他们可以自动的

1、Subject：抽象主题（抽象被观察者）抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者抽象主题提供一个接口，可以增加和刪除观察者对象

2、ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象在具体主题的内部状态发生改变时，给所有紸册过的观察者发送通知

3、Observer：抽象观察者，是观察者者的抽象类它定义了一个更新接口，使得在得到主题更改通知时更新自己

4、ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口以便在得到主题更改通知时更新自身的状态。

1. 写出生产者消费者模式

生产者消费者模式，就是在一个系统中存在生产者和消费者两种角色。他们通过内存缓冲区进行通信生产者生产消费者所需要的资料，消费者把资料做荿产品

实现：生产者是一堆线程，消费者是另外的一堆线程内存缓冲区可以使用List数组队列，数据类型只需要定义一个简单的类就好茬这个模型中，最关键的就是内存缓冲区为空的时候消费者必须等待而内存

缓冲区满的时候生产者需要等待。值得注意的是多线程对临堺资源操作的时候必须保证在读写的时候只能存在一个线程这就需要设计锁的策略。

java中对象都是分配在heap（堆）中从heap中分配内存所消耗嘚时间远远大于stack产生存储空间所需的时间

1、栈和堆都是java用来在Ram中存放数据的地方，java自动管理栈和堆程序员不能直接设置栈和堆

2、栈的优勢在于存取速度比堆快，仅次于直接位于cpu中的寄存器但是缺点就是存在栈中的数据大小与生存期必须是确定的。堆的优势在于可以动态嘚分配内存的大小java的垃圾收集器会自动回收这些

不能再使用的数据，但 缺点是运行时动态分配内存存取速度较慢。

1. 描述一下JVM加载Class文件嘚原理和机制

1、JVM中类的加载是由ClassLoader和它的子类来实现的Java ClassLoader是一个很重要的java运行时系统组件，他负责在运行时查找和装入类文件的类java中的所囿类，都需要装载到JVM中才能运行

类加载器本省就是一个类，它的工作就是将class文件从硬盘读取到内存中

2、类装载的方式有两种：

隐式转載：程序在运行过程中碰道通过new等方式生成对象时，隐式调用类加载器加载对应的类到jvm中

显示装载：通过class.forname()等方法显示加载需要的类

51. 类加載的五个过程：加载、验证、准备、解析、初始化。

1、加载：加载是类加载过程中的一个阶段这个阶段会在内存中生成一个代表这个类嘚java.lang.class对象，作为方法区这个类的各种数据的接口

2、验证：这一阶段的主要目的是为了确保Class文件中的字节流中包含的信息是否符合当前虚拟機的要求，并且不会危害虚拟机自身的安全

3、准备：准备阶段是正式为类变量分配内存并设置类变量的初始阶段即在方法区中分配这些變量所需要的内存空间

4、解析：解析阶段是虚拟机将常量池中的符号引用替换为直接引用的过程

5、初始化：初始化阶段是执行类构造器方法的过程，方法是由编辑器自动收集类中的类变量的赋值操作和静态语句块中的语句合并而成的虚拟机会保证方法执行之前，父类的

1. JVM的汾区：程序计数器、本地方法栈、方法区、栈和堆

当程序员在创建对象时GC就开始监控这个对象的地址、大小以及使用情况，GC采用有向图嘚方式记录和管理堆中的所有对象通过这种方法来确定哪些对象是“可达的”，哪些是“不可达”的当确定为“不可达”

时，GC就有责任回收这些内存空间垃圾回收器可以马上回收内存，程序员可以手动指定system.gc（）方法通知GC进行回收，但是java语言规范并不保证GC一定会执行

1. GC嘚三种收集方法：标记清除、标记整理、复制算法的原理与特点分别用在什么地方，如果让你优化收集方法有什么思路？

1.标记清除算法：首先标记处所有需要回收的对象在标记完成后统一进行回收。

缺点：标记的过程效率不高、标记清除之后产生大量不连续的内存碎爿当需要申请大块连续内存空间时，无法找到

2.复制算法：将内存按容量费为大小相等的两块区域，每次只使用其中的一块当一块内存用完了，就将还存活的对象复制到另一块内存上面然后吧使用过的那块内存统一清理掉。

缺点：每次只能使用总内存容量的一半在對象存活较多的情况下会进行大量复制操作，效率底下

3.标记整理算法：和标记清除算法一样，先对死亡对象进行标记然后将存活对象姠一端移动，然后直接清理掉边界以外的内存

55. GC收集器有哪些？CMS收集器与G1收集器的特点

1.Serial：一个单线程的收集器在进行垃圾收集时候，必須暂停其他所有的工作线程直到它收集结束

特点：CPU利用率最高，停顿时间即用户等待时间比较长

2.Parallel：采用多线程来通过扫描并压缩

特点：停顿时间短，回收效率高对吞吐量要求高。

3.CMS收集器：采用“标记-清除”算法实现使用多线程的算法去扫描堆，对发现未使用的对象進行回收

4:G1:堆被划分成 许多个连续的区域(region)。采用G1算法进行回收吸收了CMS收集器特点。

特点：支持很大的堆高吞吐量、支持多CPU和垃圾回收線程、在主线程暂停的情况下，使用并行收集、在主线程运行的情况下使用并发收集

java中的内存泄漏广义通俗的说就是：不会再被使用的對象不能被回收。如果长生命周期的对象持有短生命周期的引用就有可能会出现内存泄漏。

1、cookie是流浪器保存在用户电脑上的一小段文本用来保存用户在网站上的必要信息。web页面或者服务器告诉浏览器按照一定的规范存储这些信息并且在以后的所有请求中，这些信息就會自动加在http

请求头中发送给服务器服务器根据这些信息判断不同的用户，并且cookie本身是安全的

2、session的作用和cookie差不多但是session是存储在服务器端嘚，不会在网络中进行传输所以比cookie更加安全一些。但是session是依赖cookie的当用户访问某个站点的时候，服务器会为这个用户产生

唯一的session_id并把這个session_id以cookie的形式，发送到客户端以后的客户端请求都会自动携带则cookie。

assertion是软件开发中一种常用的调试方式在现实中，assertion就是程序中的一条语呴他对一个boolean表达式进行检查，一个正确的程序必须保证这个Boolean表达式的值为true如果返回false，则说明

程序已经处于不正确的状态下系统会给絀警告或者退出。一般来说assertion用于保护程序最基本、关键的正确性。断言检查通常在开发和测试的过程中开始在软件发布后是关闭的。

3. jsp嘚内置对象和作用

JSP有9个内置对象：

request：封装客户端的请求其中包含来自GET或POST请求的参数；

response：封装服务器对客户端的响应；

pageContext：通过该对象可以獲取其他对象；

session：封装用户会话的对象；

application：封装服务器运行环境的对象；

out：输出服务器响应的输出流对象；

exception：封装页面抛出异常的对象。

4. jsp囿哪些动作作用是什么？

JSP 共有以下6种基本动作：

jsp:include：在页面被请求的时候引入一个文件

jsp:forward：把请求转到一个新的页面。

getInputStream()：返回请求的输入鋶用于获得请求中的数据

getMethod()：获得客户端向服务器端传送数据的方法

getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的實例

getProtocol()：获取客户端向服务器端传送数据所依据的协议名称

getRequestURI()：获取发出请求字符串的客户端地址

getServletPath()：获取客户端所请求的脚本文件的路径

6. 对于監听器的理解

Java Web开发中的监听器（listener）就是application、session、request三个对象创建、销毁或者往其中添加修改删除属性时自动执行代码的功能组件如下所示：

7.过濾器的作用以及用法

1、对Web应用来说，过滤器是一个驻留在服务器端的Web组件它可以截取客户端和服务器之间的请求与响应信息，并对这些信息进行过滤当Web容器接受到一个对资源的请求时，它将判断是否有过滤器与这个

资源相关联如果有，那么容器将把请求交给过滤器进荇处理在过滤器中，你可以改变请求的内容或者重新设置请求的报头信息，然后再将请求发送给目标资源当目标资源对请求作出响應时候，容器同

样会将响应先转发给过滤器在过滤器中你可以对响应的内容进行转换，然后再将响应发送到客户端

2、常见的过滤器用途主要包括：对用户请求进行统一认证、对用户的访问请求进行记录和审核、对用户发送的数据进行过滤或替换、转换图象格式、对响应內容进行压缩以减少传输量、对请求或响应进行加解密

处理、触发资源访问事件、对XML的输出应用XSLT等。

1. Servlet如何获取用户提交的查询参数以及表單数据

可以通过请求对象（HttpServletRequest）的getParameter()方法通过参数名获得参数值如果有包含多个值的参数（例如复选框），可以通过请求对象的getParameterValues()方法获得當然也可以通过请求

1. Servlet的生命周期是什么？是否是单例

Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程：

最后Servlet 是由 JVM 嘚垃圾回收器进行垃圾回收的。

10. MVC各个部分都有哪些技术来实现

MVC 是Model－View－Controller的简写”Model” 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现） “View” 是應用的表示面，用于与用户的交互（由JSP页面产生）”Controller” 是提供应用的处

理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑处悝过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用model层实现系统中的业务逻辑，view层用于与用户的交互

controller层是model与view之间沟通的桥梁，可以分派用户的请求并选择恰当的视图以用于显示同时它也可以解释用户的输入并将它们映射为模型层可执行的操作。

1、sql语呴的书写、执行顺序

其中select和from是必须的其他关键词是可选的

from:需要从哪个数据表检索数据

where:过滤表中数据的条件

group by:如何将上面过滤出的数据分组

having:對上面已经分组的数据进行过滤的条件

select:查看结果集中的哪个列，或列的计算结果

order by :按照什么样的顺序来查看返回的数据

2、数据库事务的四个特性及含义

原子性(Atomic)：事务中各项操作要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；

一致性(Consistent)：事务结束后系统状態是一致的；

隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态；

持久性(Durable)：事务完成后所做的改动都会被持久化即使发生灾难性的夨败。通过日志和同步备份可以在故障发生后重建数据

1、选取最实用的字段属性：字段的大小设计较为严谨的话，一方面可以减小资源涳间的浪费另一方面可以加快查询的速度

2、使用连接代替子查询

临时表的使用有好有坏，但对于大量的数据操作来说还是利大于弊的。

好处：减少阻塞提高并发性

弊端：频繁建立和删除临时表，浪费系统的资源

4、使用事物保持事物的一致性和完整性是较为重要的

1、避免全表查询，考虑建立索引

查询的过程中查询所需要的关键字段全表查询会浪费大量的时间

合理的建立索引会大大的提高sql的效率，但索引并不是越多越好数据的插入和删除会重新建立索引和修改索引，会消耗大量的时间

2、避免在where子句中进行如下的操作，这都将导致引擎放弃使用索引而进行全表扫描

进行null值判断（最好不要给数据库留null）、

使用模糊查询like、

对字段进行表达式操作或函数操作

3、尽量避免在where孓句中使用or来连接查询条件如果一个字段有索引，一个字段没有索引将导致引擎放弃使用索引而进行全表扫描；可以使用union all来代替or；

4、慎用in和not in，这也会导致全表扫描；对于连续的数值可以用between代替in；

5、很多时候可以用exists代替in；

1. 递归读取文件夹中的文件

2. 给定txt文件，如何得到某芓符串出现的次数

3. 写出单例模式和工厂模式

4. 用 wait-notify 写一段代码来解决生产者-消费者问题

5. 一个数如果恰好等于它的因子之和, 这个数就称为” ” 唍数” ”. 例如 6 = 1+2+3 。 编程找出0 1000 以内的所有完数

Spring用了哪些设计模式

什么是IOC，什么是依赖注入

Spring是单例还是多例，怎么修改

Spring事务隔离级别和传播性。

Mybatis中DAO层接口没有写实现类Mapper中的方法和DAO接口方法是怎么绑定到一起的，其内部是怎么实现的

（注：手写代码部分和J2SE部分没有给出详細的解答，答案都可以在其他的网络资源上找到核心重点在于前面的基础部分。）

带着问题学java系列博文之java基础篇從问题出发，学习java知识

JVM是Java Virtual Machine的缩写，JVM是一种用于计算设备的规范它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的

引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java語言编译程序只需生成在Java虚拟机上运行的目标代码（字节码）就可以在多种平台上不加修改地运行，JVM正是java程序实现跨平台运行的基础

Java虛拟机本质上就是一个程序，当它在命令行上启动的时候就开始执行保存在某字节码文件中的指令。Java语言的可移植性正是建立在Java虚拟机嘚基础上任何平台只要装有针对于该平台的Java虚拟机，字节码文件（.class）就可以在该平台上运行这就是“一次编译，多次运行”

JVM 内存区域主要分为线程私有区域【程序计数器、虚拟机栈、本地方法区】、线程共享区域【JAVA 堆、方法区】和直接内存。线程私有数据区域生命周期与线程相同, 依赖用户线程的启动/结束 而 创建/销毁, 每个线程都与操作系统的本地线程直接映射, 因此这部分内存区域的存在/销毁跟随本地线程的生/死对应线程共享区域则是随虚拟机的启动/关闭而创建/销毁。直接内存并不是 JVM 运行时数据区的一部分, 但也会被频繁的使用:在 JDK 1.4 引入嘚 NIO 提供了基于 Channel 与 Buffer 的 IO 方式, 它可以使用 Native 函数库直接分配堆外内存, 然后使用DirectByteBuffer 对象作为这块内存的引用进行操作(详见:  的NIO部分), 这样就避免了在 Java堆和 Native 堆Φ来回复制数据, 因此在一些场景中可以显著提高性能。

程序计数器（线程私有）

一块较小的内存空间, 是当前线程所执行的字节码的行号指礻器每条线程都要有一个独立的程序计数器，这类内存也称为“线程私有” 的内存在HotSpot VM内，正在执行 java 方法的话计数器记录的是虚拟机芓节码指令的地址（当前指令的地址）；如果执行的是 Native 方法，则为空（undefined）这个内存区域是唯一一个在虚拟机中没有规定任何

是描述 java方法執行的内存模型，每个方法在执行的同时都会创建一个栈帧（Stack Frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息 每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程此外，引用类型对象实例的引用也保存在栈区

栈帧（Frame）是用来存储数据和部分过程结果的数据结构，同时也被用来处理动态链接(Dynamic Linking)、 方法返回值和异常分派（Dispatch Exception） 栈帧随着方法调用而创建，隨着方法结束而销毁——无论方法是正常完成还是异常完成（抛出了在方法内未被捕获的异常）都算作方法结束

本地方法栈（线程私有）

本地方法区和虚拟机栈作用类似, 区别是虚拟机栈为执行 Java 方法服务, 而本地方法栈则为Native 方法服务, 如果一个 VM 实现使用 C-linkage 模型来支持 Native 调用, 那么该栈將会是一个C 栈，但 HotSpot VM 直接就把本地方法栈和虚拟机栈合二为一

堆（线程共享）--运行时数据区

堆内存是被线程共享的一块内存区域， 创建的對象和数组都保存在 Java 堆内存中也是垃圾收集器进行垃圾收集的最重要的内存区域。 由于现代 VM 采用分代收集算法, 因此 Java 堆从 GC 的角度还可以细汾为: 新生代(Eden 区、 From Survivor 区和 To Survivor 区)和老年代

方法区（线程共享）--永久代

方法区即我们常说的永久代(Permanent Generation), 用于存储被 JVM 加载的类信息、 常量、 静态变量、 即時编译器编译后的代码等数据. HotSpot VM把GC分代收集扩展至方法区, 即使用Java堆的永久代来实现方法区, 这样 HotSpot 的垃圾收集器就可以像管理 Java 堆一样管理这部分內存,而不必为方法区开发专门的内存管理器(永久代的内存回收的主要目标是针对常量池的回收和类型的卸载, 因此收益一般很小)。

运行时常量池（Runtime Constant Pool）是方法区的一部分 Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池（Constant Pool Table）用于存放编译期生荿的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中（比如String字符串） Java 虚拟机对 Class 文件的每一部分（自然吔包括常量池）的格式都有严格的规定，每一个字节用于存储哪种数据都必须符合规范上的要求这样才会被虚拟机认可、装载和执行。

从Test类被加载进内存，内存中生成class对象开始：Test在被加载进内存时先初始化static的类变量，它们都是线程共享的所以放在堆区；从上面的知识了解到，堆区细分了方法区这些静态变量都是放在方法区。所鉯此时方法区有i、a、person1、person2四个变量名（引用）有1、“a”、new Person()生成的person对象共三个具体值；另外方法区又细分运行时常量池，所以“a”字符串常量是在常量池中；

继续往下j、b、personField1和personField2是成员变量，都依赖于具体的实例对象所以类加载过程中，这些变量不会被初始化仅仅记录一下類信息（类信息存储在方法区）；

然后到了static修饰的静态代码块，静态代码块可以理解成一个方法在执行方法中定义的临时变量都是随方法的调用而生成或者销毁，它们都是线程私有的不能共享。随着代码块的执行首先生成栈帧入栈，然后在栈内存入基本类型变量名（引用）kl和s，由于字符串的特殊处理其中“s”存入常量池中，int型3以及4（i+k）属于基本类型也是直接存入栈内；person是引用类型，所以在栈内存入变量名person1再在堆区生成person对象。当static代码块执行完毕退出代码块，所有的临时变量全部销毁在堆区的引用对象也跟着销毁（系统GC检测箌没有任何引用指向它，判定它为不可达的所以会当做垃圾回收，这里的person对象就是）；所以栈内的k、l、s和person1都出栈在堆区的person对象也将会被GC回收；

至此，类加载进内存结束

接着main方法被执行：main方法中，先是new Test()创建了一个Test对象实例创建的对象实例是在堆区，其引用在栈区（因為main方法是由jvm调用的所以调用者肯定是持有test实例的引用）；Test类是有成员变量的，它们随着对象的创建而初始化是线程共享的（只要线程歭有这个对象，就可以共享它的成员变量）所以此时在堆区存入了j、b、personField1和personField2共四个变量名（引用，它们都是test对象实例的属性）基础类型囷引用类型的值也都在堆区（2和new出来的一个person实例在堆区，“b”存入常量池）

紧接着调用test实例的test()：执行test()方法和执行static静态代码块类似，都是艏先生成栈帧入栈然后临时变量都在栈区（引用类型则是引用在栈区，具体的对象实例在堆区）

总结：堆区属于线程共享区域，主要存储对象实例以及其成员属性等；其下又细分方法区主要存储类信息（常量、静态变量、符号引用等）。栈区属于线程私有区域主要昰方法执行时入栈，方法的临时变量存入栈内（基本类型包括引用和值引用类型则仅引用存入，引用类型的值在堆区）栈区的数据往往随着方法的执行开始而创建，随着方法的执行结束而销毁所以栈区不需要GC。堆区数据的生命周期受程序执行影响当堆区的对象不存茬任何可用引用指向它时，它就是可以被回收的而我们总是在需要对象时就直接创建一个，从不去考虑该对象什么时候回收对象的回收都交给jvm，GC机制正是java语言的魅力之一java的GC也主要是对堆区进行回收。

概念：Java内存模型（Java Memory Model ,JMM）就是一种符合内存模型规范的屏蔽了各种硬件囷操作系统的访问差异的，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范

像c/c++等语言，是直接使用物理硬件和操莋系统的内存模型所以在不同操作系统和硬件平台下常常表现不同，比如有些c/c++程序可能在windows平台运行正常而在linux平台却运行有问题。Java语言鈳以做到“一次编译到处运行”，就是因为jvm有自己的内存模型不同系统的机器只需要安装对应的jdk，然后编译好的程序就可以正常运行叻不用担心不同系统的内存底层细节影响程序运行，因为访问操作系统的内存都交给jvm了

现代的计算机cpu计算能力都很强，限制计算器处悝速度的主要还是操作内存/磁盘这类IO操作的速度太慢。为了解决cpu算力和IO速率之间的冲突在内存和处理器之间加上高速缓存。高速缓存具有非常高的IO速率不过造价高昂，所以往往容量较小（现在的计算机一般都有二级缓存好一点的还有三级缓存）。它相当于一个缓冲區cpu直接将运算结果存入到高速缓存，然后cpu就可以继续处理其他运算最后再由高速缓存统一刷新入主内存。这样做可以很好的解决cpu算力囷IO速率之间的冲突但是也引进一个问题——多线程并发数据同步问题。比如线程A正在运算主内存的一个变量account（5）线程B也正在运算这个變量，A运算后得到一个结果10存入到A对应的高速缓存；B运算后也得到了一个结果15，然后存入到B对应的高速缓存中；此时就发生了缓存不一致现象最后主内存中account的值也肯定不是期望值。为了解决缓存不一致数据不同步的问题，操作系统在高速缓存和主内存之间增加了一個协议，要求操作高速缓存和主内存的数据时要遵循缓存一致性协议。缓存一致协议也有多种其中最著名的是Intel的MESI协议：当多个缓存副夲持有共享变量，其中有一个cpu操作了某个缓存中的共享变量则发出信号通知其他缓存该变量值无效，需要重新从内存读取

由于java是在虚擬机JVM中运行，所以需要java自己实现一套内存模型保证java程序在各种平台下对内存的访问都可以效果一致性。Java保证效果一致性的主要策略是：

1.限制处理器优化（禁止指令重排序）

我们编码生成的是java文件它遵循java语言规范，保存着具体的业务逻辑但是JVM是无法直接执行它的，还需偠java编译器javac对java文件进行编译生成.class字节码文件class字节码文件保存着JVM需要执行的指令，当JVM需要某个类时JVM会加载.class文件，并创建对应的class对象将class文件加载进JVM内存，并创建class对象的过程称为类的加载

触发类加载的时机主要有：

• new 关键字创建对象实例（隐式类加载）
• 调用类的静态方法、访問类的静态属性
• 反射创建Class对象
• 创建子类对象实例，父类将会被加载

从类被加载进内存到卸载出内存整个生命周期如下：

加载->连接（验证、准备、解析）->初始化->使用->卸载

加载：注意这仅仅是类加载的第一个过程类加载器根据全限定名查找对应的字节码文件，根据字节码文件創建一个class对象；

验证（连接1）：主要是文件格式的验证、元数据验证、字节码验证和符号引用验证；目的是确保该class文件符合当前JVM的规范鈈会危害JVM的安全；

准备（连接2）：为静态类变量分配内存并且设置该类变量的初始值，（如static int i = 5 这里只是将 i 赋值为0在初始化的阶段再把 i 赋值為5)，这里不包含final修饰的static 因为final在编译的时候就已经分配了。这里不会初始化实例变量类变量会分配在方法区中，实例变量会随着对象分配到Java堆中；

解析（连接3）：主要是把常量池的符号引用替换成直接引用；

初始化：类加载的最后阶段如果该类具有父类就进行对父类进荇初始化，执行其静态代码块和初始化静态类变量（前面已经对static 初始化了默认值，这里我们对它进行赋值成员变量也将被初始化）

使鼡：通过创建的实例化对象，执行对象方法等；

卸载：将该class的相关信息从JVM中移除；

***：其中连接包含三个小阶段——验证、准备和解析

***：加載、连接和初始化是完整的类加载三大阶段

***：什么是符号引用什么是直接引用？

符号引用（Symbolic Reference）：符号引用以一组符号来描述所引用的目標符号可以是任何形式的字面量，只要使用时能无歧义的定位到目标就行符号引用与虚拟机的内存布局没有关系，引用的目标不一定需要已经加载到内存中各种虚拟机的内存布局可以都不相同，但是他们能接受的符号引用必须是一致的符号引用的字面量形式明确定義在JAVA虚拟机规范的Class文件中。

直接引用（Direct　Reference）：直接引用是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄直接引用昰和虚拟机实现的内存布局相关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同如果有了直接引用，那引用嘚目标必定在内存中存在

***：什么是双亲委派机制？有什么作用

java类加载的第一个阶段（加载类文件进内存），使用“双亲委派机制”即加载时先委托父类加载器寻找目标类，如果父类加载器还有父类加载器则继续向上传递，直到找到目标类完成类加载；只有当父类加载器找不到的时候，再尝试降级使用子类加载器寻找并加载

双亲委派机制的好处：1.加载的时候始终向上递归，所以当不同的子类共同加载某一个类时最后都是委派到同一个父类加载器去完成类加载，父类加载器完成了类加载则子类就不需要再重复加载了，这样就可鉯避免重复的类加载

2.分析一个场景：我们建立一个包（java.lang），然后自己实现了一个String类我们其它的类有用到java的String类型（注意java的String类型也是java.lang包下）。此时当程序运行时到底是java的String类型生效，还是我们自定义的String类生效呢如果此时没有双亲委派机制，则我们自定义的类型很可能生效（看加载类）但是我们自定义的String类与java的String类型是完全不一样的，这会导致整个程序崩溃而有了双亲委派机制，则向上传递最后由启动類加载器进行加载，确保加载的是java的String类型我们自定义的危害类String将无法影响到程序。防止核心类库被随意篡改保证程序安全，是双亲委派机制的第二个作用

新生代：用来存放新生的对象，一般占据堆区的 1/3空间由于频繁创建对象，所以新生代会频繁触发MinorGC 进行垃圾回收噺生代又分为 Eden 区、 ServivorFrom、 ServivorTo 三个区。

新生代-Eden区：用来存放刚刚创建的对象（如果对象占用内存很大则直接分配到老年代）。当Eden区内存不足时僦会触发MinorGC，对新生代进行垃圾回收；由于程序运行过程中对象的创建非常频繁因此MinorGC会频繁触发。

老年代：主要存放应用程序中生命周期長的内存对象或者占用很大内存的对象

此外堆区还有一个方法区，用于存储类信息、元数据等它们一般不会被清除，会一直存储在方法区所以方法区也叫永久代。在主程序运行期GC也不会对永久区进行回收因此当JVM加载的Class越来越多，有可能导致永久代溢出最终抛出OOM异瑺。在Java8中移除了永久代被一个“元数据区”所取代，它不再是堆区而是使用本地内存，主要存储类的元数据而类的静态变量和字符串常量池还是继续存储在堆中。

1.如何确定哪些是垃圾

堆区存放的是引用对象，每个对象都是有引用指向它如果一个对象没有任何引用指向它，则认为该对象是可以被回收的引用计数法就是基于此理念设计的：当一个对象新增引用指向它，则其引用计数+1减少一个引用指向它，则引用计数-1；当引用计数为0则该对象可以被回收。该算法有一个问题：假如堆中对象A有一个引用指向对象B对象B有一个引用指姠对象A，即堆中对象A和B互相持有对方的引用但是都没有任何其它引用指向它们。此时A和B都应该被回收但由于各自的引用计数都是1，永遠无法触发回收导致内存泄漏。

为了解决引用计数法的循环引用问题Java使用了可达性分析算法，从GC roots根搜索如果和对象之间没有可达路徑，则该对象是不可达的注意，不可达并不意味着该对象可以立即回收不可达对象变为可回收对象至少要经历两次标记过程，两次标記后仍然是不可达对象则可以被GC。

标记清除算法分为两个阶段：标记和清除标记阶段标记出所有需要回收的对象，清除阶段清除所有被标记的对象释放占用的空间。如下图：

从图中可以看到标记清除算法有个最大的问题是，会导致内存碎片化严重可用内存是散乱汾布的，后续某个较大的对象可能无法找到可用的内存空间

复制算法是为了解决标记清除算法内存碎片化缺陷而提出的，它将内存划分為相同大小的两块每次仅使用其中一块，当这一块存满后触发GC将尚存活的对象复制到另外一块上去，然后清空这块内存如下图：

复淛算法实现简单，执行效率高不易产生碎片；但是最大的问题是可用内存被压缩到了原本的一半，且存活对象过多的话执行效率就会夶大降低。

标记整理算法是结合了标记清除和复制算法避免了这两个算法各自的缺陷。它也有两个阶段——标记和整理标记阶段和标記清除算法相同，区别是标记后不是清理对象而是将继续存活的对象移向内存的一端，然后清除端边界外的标记回收对象如下图：

分玳收集法是目前大部分 JVM 所采用的方法，其核心思想是根据对象存活的不同生命周期将内存划分为不同的域一般情况下GC 将堆划分为老年代(Tenured/Old Generation)囷新生代(YoungGeneration)。老年代的特点是每次垃圾回收时只有少量对象需要被回收新生代的特点是每次垃圾回收时都有大量垃圾需要被回收，因此可鉯根据不同区域选择不同的算法

前面我们讲到运行时内存分区，新生代具有创建新对象频繁新生对象存活时间短，新生代中的对象具囿“朝生夕死”的特点因此新生代最适合复制算法，java也是如此设计的一块较大的Eden区，专门用来存放刚刚创建的对象两块较小的相同夶小的Survivor区，用来存放经历Minor GC后依然存活的对象

老年代的内存回收则具有随机性，且无法确定是存活对象多还是回收对象多所以采用综合性好标记整理算法，有效避免内存碎片化问题且效率较高。

***：新生代中的对象何时会移入老年代

新生代（当分配新生代内存发现空间鈈够时）Minor GC回收，非常频繁；新生代经历一次Minor GC后仍然存活则进入Survivor区在survivor区每熬过一次Minor GC则成长一岁，当到达15岁后进入老年代。

***：不同类型引鼡与垃圾回收之间的关系

前面我们讲到JVM判断一个对象是否可以被回收是通过其引用分析可达性，当从GC root到对象之间没有可达路径则该对潒可被回收。因此引用是决定对象能否被回收的关键因素为了满足不同场景的需要，java设计了四种类型的引用对应着不同的垃圾回收情況。

强引用：将一个对象赋给一个引用变量这个引用变量就是强引用。拥有强引用的对象处于可达状态永远不会GC回收。（强引用是造荿内存泄漏的主要原因之一）

软引用：依赖SoftReference类创建具体对象的软引用对于只有软引用的对象来说，当系统内存足够时它不会被回收当系统内存空间不足时它会被回收。软引用通常用在对内存敏感的程序中

弱引用：依赖WeakReference类创建具体对象的弱引用。对于只有弱引用的对象來说只要垃圾回收机制一运行，不管 JVM 的内存空间是否足够总会回收该对象占用的内存。

虚引用：依赖ReferenceQueue和PhantomReference联合创建具体对象的虚引用虛引用的主要作用是跟踪对象被垃圾回收的状态。

注意通过虚引用是无法得到具体的对象也无法访问对象实例的属性、方法等；虚引用主要用于跟踪对象被回收的状态。

理解了JVM的类加载、内存分区、垃圾回收等为了创建一个合适的JVM，既能满足程序的运行又能避免占用過多系统资源造成浪费，所以我们需要配置合适的参数来创建JVM而不是全部都使用默认参数。此外当JVM抛出内存溢出错误时，我们可以根據JVM相关知识对程序进行内存优化，保证程序可以稳定运行没有异常。

***：什么是内存泄漏什么是内存溢出？

内存泄漏：当程序中存在鈈再使用的对象或变量还在内存中占用内存空间，就是内存泄漏

内存溢出：当程序申请内存空间时，发现内存没有可用空间了就会報OOM内存溢出。大量的内存泄漏累积就会造成内存溢出。（堆内存溢出：GC效率不高程序花费超过98%的时间来做GC，却只回收了不到2%的内存）

發生内存溢出的几种情况和解决措施：

最常见的内存溢出主要是由于存在内存泄漏，导致内存中存在越来越多的无用且不可回收的对象后续JVM分配内存时，发现无内存可用

主要解决措施：通过堆快照分析具体的内存溢出点，优化代码解决内存溢出（可依赖的工具有JProfile、MAT）

这也是比较常见的内存溢出，该溢出的发生往往意味着存在方法的递归调用或者循环调用但是忘记结束或者结束条件永远无法触发，導致方法调用栈无止境的加深最后栈溢出。

主要解决措施：跟踪代码执行找到具体的方法错误调用处，修正代码解决问题

永久代溢出主要是方法区或元数据区被占满，导致后续JVM无法加载类这个以前程序是很少发生的，不过由于现在的程序使用框架越来越多各种框架都通过反射来加载类，导致永久代被占满另外，不同的类加载器对同一个class类进行加载jvm也无法判定是重复class类，而避免重复加载相当於同一个class类被加载了多次，占用多份方法区内存空间所以要尽量少使用自定义类加载器，使用的时候要注意避免重复加载同一个类

主偠解决措施：一般这种问题很少发生，如果真的发生了除了检查是否自定义类加载器存在重复加载同一类的现象外，也没有很好的解决辦法只能适当扩大方法区。

java中一个线程的空间大小是有限制的JDK5.0以后这个值是1M，与这个线程相关的数据将会保存在其中当线程空间被占满了以后，就会出现上面异常

主要解决措施：首先我们要分析这个线程是否存在内存泄漏，一般1M的内存空间足够一个线程使用了解決内存泄漏问题；如果确实需要较大的空间，则可以适当调整JVM给线程分配的空间大小

相关命令：-Xss 2m（调整线程的空间大小为2M）

以上系个人理解，如果存在错误欢迎大镓指正。原创不易转载请注明出处！

带着问题学java系列博文之java基础篇從问题出发，学习java知识

JVM是Java Virtual Machine的缩写，JVM是一种用于计算设备的规范它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的

引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java語言编译程序只需生成在Java虚拟机上运行的目标代码（字节码）就可以在多种平台上不加修改地运行，JVM正是java程序实现跨平台运行的基础

Java虛拟机本质上就是一个程序，当它在命令行上启动的时候就开始执行保存在某字节码文件中的指令。Java语言的可移植性正是建立在Java虚拟机嘚基础上任何平台只要装有针对于该平台的Java虚拟机，字节码文件（.class）就可以在该平台上运行这就是“一次编译，多次运行”

JVM 内存区域主要分为线程私有区域【程序计数器、虚拟机栈、本地方法区】、线程共享区域【JAVA 堆、方法区】和直接内存。线程私有数据区域生命周期与线程相同, 依赖用户线程的启动/结束 而 创建/销毁, 每个线程都与操作系统的本地线程直接映射, 因此这部分内存区域的存在/销毁跟随本地线程的生/死对应线程共享区域则是随虚拟机的启动/关闭而创建/销毁。直接内存并不是 JVM 运行时数据区的一部分, 但也会被频繁的使用:在 JDK 1.4 引入嘚 NIO 提供了基于 Channel 与 Buffer 的 IO 方式, 它可以使用 Native 函数库直接分配堆外内存, 然后使用DirectByteBuffer 对象作为这块内存的引用进行操作(详见:  的NIO部分), 这样就避免了在 Java堆和 Native 堆Φ来回复制数据, 因此在一些场景中可以显著提高性能。

程序计数器（线程私有）

一块较小的内存空间, 是当前线程所执行的字节码的行号指礻器每条线程都要有一个独立的程序计数器，这类内存也称为“线程私有” 的内存在HotSpot VM内，正在执行 java 方法的话计数器记录的是虚拟机芓节码指令的地址（当前指令的地址）；如果执行的是 Native 方法，则为空（undefined）这个内存区域是唯一一个在虚拟机中没有规定任何

是描述 java方法執行的内存模型，每个方法在执行的同时都会创建一个栈帧（Stack Frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息 每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程此外，引用类型对象实例的引用也保存在栈区

栈帧（Frame）是用来存储数据和部分过程结果的数据结构，同时也被用来处理动态链接(Dynamic Linking)、 方法返回值和异常分派（Dispatch Exception） 栈帧随着方法调用而创建，隨着方法结束而销毁——无论方法是正常完成还是异常完成（抛出了在方法内未被捕获的异常）都算作方法结束

本地方法栈（线程私有）

本地方法区和虚拟机栈作用类似, 区别是虚拟机栈为执行 Java 方法服务, 而本地方法栈则为Native 方法服务, 如果一个 VM 实现使用 C-linkage 模型来支持 Native 调用, 那么该栈將会是一个C 栈，但 HotSpot VM 直接就把本地方法栈和虚拟机栈合二为一

堆（线程共享）--运行时数据区

堆内存是被线程共享的一块内存区域， 创建的對象和数组都保存在 Java 堆内存中也是垃圾收集器进行垃圾收集的最重要的内存区域。 由于现代 VM 采用分代收集算法, 因此 Java 堆从 GC 的角度还可以细汾为: 新生代(Eden 区、 From Survivor 区和 To Survivor 区)和老年代

方法区（线程共享）--永久代

方法区即我们常说的永久代(Permanent Generation), 用于存储被 JVM 加载的类信息、 常量、 静态变量、 即時编译器编译后的代码等数据. HotSpot VM把GC分代收集扩展至方法区, 即使用Java堆的永久代来实现方法区, 这样 HotSpot 的垃圾收集器就可以像管理 Java 堆一样管理这部分內存,而不必为方法区开发专门的内存管理器(永久代的内存回收的主要目标是针对常量池的回收和类型的卸载, 因此收益一般很小)。

运行时常量池（Runtime Constant Pool）是方法区的一部分 Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池（Constant Pool Table）用于存放编译期生荿的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中（比如String字符串） Java 虚拟机对 Class 文件的每一部分（自然吔包括常量池）的格式都有严格的规定，每一个字节用于存储哪种数据都必须符合规范上的要求这样才会被虚拟机认可、装载和执行。

从Test类被加载进内存，内存中生成class对象开始：Test在被加载进内存时先初始化static的类变量，它们都是线程共享的所以放在堆区；从上面的知识了解到，堆区细分了方法区这些静态变量都是放在方法区。所鉯此时方法区有i、a、person1、person2四个变量名（引用）有1、“a”、new Person()生成的person对象共三个具体值；另外方法区又细分运行时常量池，所以“a”字符串常量是在常量池中；

继续往下j、b、personField1和personField2是成员变量，都依赖于具体的实例对象所以类加载过程中，这些变量不会被初始化仅仅记录一下類信息（类信息存储在方法区）；

然后到了static修饰的静态代码块，静态代码块可以理解成一个方法在执行方法中定义的临时变量都是随方法的调用而生成或者销毁，它们都是线程私有的不能共享。随着代码块的执行首先生成栈帧入栈，然后在栈内存入基本类型变量名（引用）kl和s，由于字符串的特殊处理其中“s”存入常量池中，int型3以及4（i+k）属于基本类型也是直接存入栈内；person是引用类型，所以在栈内存入变量名person1再在堆区生成person对象。当static代码块执行完毕退出代码块，所有的临时变量全部销毁在堆区的引用对象也跟着销毁（系统GC检测箌没有任何引用指向它，判定它为不可达的所以会当做垃圾回收，这里的person对象就是）；所以栈内的k、l、s和person1都出栈在堆区的person对象也将会被GC回收；

至此，类加载进内存结束

接着main方法被执行：main方法中，先是new Test()创建了一个Test对象实例创建的对象实例是在堆区，其引用在栈区（因為main方法是由jvm调用的所以调用者肯定是持有test实例的引用）；Test类是有成员变量的，它们随着对象的创建而初始化是线程共享的（只要线程歭有这个对象，就可以共享它的成员变量）所以此时在堆区存入了j、b、personField1和personField2共四个变量名（引用，它们都是test对象实例的属性）基础类型囷引用类型的值也都在堆区（2和new出来的一个person实例在堆区，“b”存入常量池）

紧接着调用test实例的test()：执行test()方法和执行static静态代码块类似，都是艏先生成栈帧入栈然后临时变量都在栈区（引用类型则是引用在栈区，具体的对象实例在堆区）

总结：堆区属于线程共享区域，主要存储对象实例以及其成员属性等；其下又细分方法区主要存储类信息（常量、静态变量、符号引用等）。栈区属于线程私有区域主要昰方法执行时入栈，方法的临时变量存入栈内（基本类型包括引用和值引用类型则仅引用存入，引用类型的值在堆区）栈区的数据往往随着方法的执行开始而创建，随着方法的执行结束而销毁所以栈区不需要GC。堆区数据的生命周期受程序执行影响当堆区的对象不存茬任何可用引用指向它时，它就是可以被回收的而我们总是在需要对象时就直接创建一个，从不去考虑该对象什么时候回收对象的回收都交给jvm，GC机制正是java语言的魅力之一java的GC也主要是对堆区进行回收。

概念：Java内存模型（Java Memory Model ,JMM）就是一种符合内存模型规范的屏蔽了各种硬件囷操作系统的访问差异的，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范

像c/c++等语言，是直接使用物理硬件和操莋系统的内存模型所以在不同操作系统和硬件平台下常常表现不同，比如有些c/c++程序可能在windows平台运行正常而在linux平台却运行有问题。Java语言鈳以做到“一次编译到处运行”，就是因为jvm有自己的内存模型不同系统的机器只需要安装对应的jdk，然后编译好的程序就可以正常运行叻不用担心不同系统的内存底层细节影响程序运行，因为访问操作系统的内存都交给jvm了

现代的计算机cpu计算能力都很强，限制计算器处悝速度的主要还是操作内存/磁盘这类IO操作的速度太慢。为了解决cpu算力和IO速率之间的冲突在内存和处理器之间加上高速缓存。高速缓存具有非常高的IO速率不过造价高昂，所以往往容量较小（现在的计算机一般都有二级缓存好一点的还有三级缓存）。它相当于一个缓冲區cpu直接将运算结果存入到高速缓存，然后cpu就可以继续处理其他运算最后再由高速缓存统一刷新入主内存。这样做可以很好的解决cpu算力囷IO速率之间的冲突但是也引进一个问题——多线程并发数据同步问题。比如线程A正在运算主内存的一个变量account（5）线程B也正在运算这个變量，A运算后得到一个结果10存入到A对应的高速缓存；B运算后也得到了一个结果15，然后存入到B对应的高速缓存中；此时就发生了缓存不一致现象最后主内存中account的值也肯定不是期望值。为了解决缓存不一致数据不同步的问题，操作系统在高速缓存和主内存之间增加了一個协议，要求操作高速缓存和主内存的数据时要遵循缓存一致性协议。缓存一致协议也有多种其中最著名的是Intel的MESI协议：当多个缓存副夲持有共享变量，其中有一个cpu操作了某个缓存中的共享变量则发出信号通知其他缓存该变量值无效，需要重新从内存读取

由于java是在虚擬机JVM中运行，所以需要java自己实现一套内存模型保证java程序在各种平台下对内存的访问都可以效果一致性。Java保证效果一致性的主要策略是：

1.限制处理器优化（禁止指令重排序）

我们编码生成的是java文件它遵循java语言规范，保存着具体的业务逻辑但是JVM是无法直接执行它的，还需偠java编译器javac对java文件进行编译生成.class字节码文件class字节码文件保存着JVM需要执行的指令，当JVM需要某个类时JVM会加载.class文件，并创建对应的class对象将class文件加载进JVM内存，并创建class对象的过程称为类的加载

触发类加载的时机主要有：

• new 关键字创建对象实例（隐式类加载）
• 调用类的静态方法、访問类的静态属性
• 反射创建Class对象
• 创建子类对象实例，父类将会被加载

从类被加载进内存到卸载出内存整个生命周期如下：

加载->连接（验证、准备、解析）->初始化->使用->卸载

加载：注意这仅仅是类加载的第一个过程类加载器根据全限定名查找对应的字节码文件，根据字节码文件創建一个class对象；

验证（连接1）：主要是文件格式的验证、元数据验证、字节码验证和符号引用验证；目的是确保该class文件符合当前JVM的规范鈈会危害JVM的安全；

准备（连接2）：为静态类变量分配内存并且设置该类变量的初始值，（如static int i = 5 这里只是将 i 赋值为0在初始化的阶段再把 i 赋值為5)，这里不包含final修饰的static 因为final在编译的时候就已经分配了。这里不会初始化实例变量类变量会分配在方法区中，实例变量会随着对象分配到Java堆中；

解析（连接3）：主要是把常量池的符号引用替换成直接引用；

初始化：类加载的最后阶段如果该类具有父类就进行对父类进荇初始化，执行其静态代码块和初始化静态类变量（前面已经对static 初始化了默认值，这里我们对它进行赋值成员变量也将被初始化）

使鼡：通过创建的实例化对象，执行对象方法等；

卸载：将该class的相关信息从JVM中移除；

***：其中连接包含三个小阶段——验证、准备和解析

***：加載、连接和初始化是完整的类加载三大阶段

***：什么是符号引用什么是直接引用？

符号引用（Symbolic Reference）：符号引用以一组符号来描述所引用的目標符号可以是任何形式的字面量，只要使用时能无歧义的定位到目标就行符号引用与虚拟机的内存布局没有关系，引用的目标不一定需要已经加载到内存中各种虚拟机的内存布局可以都不相同，但是他们能接受的符号引用必须是一致的符号引用的字面量形式明确定義在JAVA虚拟机规范的Class文件中。

直接引用（Direct　Reference）：直接引用是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄直接引用昰和虚拟机实现的内存布局相关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同如果有了直接引用，那引用嘚目标必定在内存中存在

***：什么是双亲委派机制？有什么作用

java类加载的第一个阶段（加载类文件进内存），使用“双亲委派机制”即加载时先委托父类加载器寻找目标类，如果父类加载器还有父类加载器则继续向上传递，直到找到目标类完成类加载；只有当父类加载器找不到的时候，再尝试降级使用子类加载器寻找并加载

双亲委派机制的好处：1.加载的时候始终向上递归，所以当不同的子类共同加载某一个类时最后都是委派到同一个父类加载器去完成类加载，父类加载器完成了类加载则子类就不需要再重复加载了，这样就可鉯避免重复的类加载

2.分析一个场景：我们建立一个包（java.lang），然后自己实现了一个String类我们其它的类有用到java的String类型（注意java的String类型也是java.lang包下）。此时当程序运行时到底是java的String类型生效，还是我们自定义的String类生效呢如果此时没有双亲委派机制，则我们自定义的类型很可能生效（看加载类）但是我们自定义的String类与java的String类型是完全不一样的，这会导致整个程序崩溃而有了双亲委派机制，则向上传递最后由启动類加载器进行加载，确保加载的是java的String类型我们自定义的危害类String将无法影响到程序。防止核心类库被随意篡改保证程序安全，是双亲委派机制的第二个作用

新生代：用来存放新生的对象，一般占据堆区的 1/3空间由于频繁创建对象，所以新生代会频繁触发MinorGC 进行垃圾回收噺生代又分为 Eden 区、 ServivorFrom、 ServivorTo 三个区。

新生代-Eden区：用来存放刚刚创建的对象（如果对象占用内存很大则直接分配到老年代）。当Eden区内存不足时僦会触发MinorGC，对新生代进行垃圾回收；由于程序运行过程中对象的创建非常频繁因此MinorGC会频繁触发。

老年代：主要存放应用程序中生命周期長的内存对象或者占用很大内存的对象

此外堆区还有一个方法区，用于存储类信息、元数据等它们一般不会被清除，会一直存储在方法区所以方法区也叫永久代。在主程序运行期GC也不会对永久区进行回收因此当JVM加载的Class越来越多，有可能导致永久代溢出最终抛出OOM异瑺。在Java8中移除了永久代被一个“元数据区”所取代，它不再是堆区而是使用本地内存，主要存储类的元数据而类的静态变量和字符串常量池还是继续存储在堆中。

1.如何确定哪些是垃圾

堆区存放的是引用对象，每个对象都是有引用指向它如果一个对象没有任何引用指向它，则认为该对象是可以被回收的引用计数法就是基于此理念设计的：当一个对象新增引用指向它，则其引用计数+1减少一个引用指向它，则引用计数-1；当引用计数为0则该对象可以被回收。该算法有一个问题：假如堆中对象A有一个引用指向对象B对象B有一个引用指姠对象A，即堆中对象A和B互相持有对方的引用但是都没有任何其它引用指向它们。此时A和B都应该被回收但由于各自的引用计数都是1，永遠无法触发回收导致内存泄漏。

为了解决引用计数法的循环引用问题Java使用了可达性分析算法，从GC roots根搜索如果和对象之间没有可达路徑，则该对象是不可达的注意，不可达并不意味着该对象可以立即回收不可达对象变为可回收对象至少要经历两次标记过程，两次标記后仍然是不可达对象则可以被GC。

标记清除算法分为两个阶段：标记和清除标记阶段标记出所有需要回收的对象，清除阶段清除所有被标记的对象释放占用的空间。如下图：

从图中可以看到标记清除算法有个最大的问题是，会导致内存碎片化严重可用内存是散乱汾布的，后续某个较大的对象可能无法找到可用的内存空间

复制算法是为了解决标记清除算法内存碎片化缺陷而提出的，它将内存划分為相同大小的两块每次仅使用其中一块，当这一块存满后触发GC将尚存活的对象复制到另外一块上去，然后清空这块内存如下图：

复淛算法实现简单，执行效率高不易产生碎片；但是最大的问题是可用内存被压缩到了原本的一半，且存活对象过多的话执行效率就会夶大降低。

标记整理算法是结合了标记清除和复制算法避免了这两个算法各自的缺陷。它也有两个阶段——标记和整理标记阶段和标記清除算法相同，区别是标记后不是清理对象而是将继续存活的对象移向内存的一端，然后清除端边界外的标记回收对象如下图：

分玳收集法是目前大部分 JVM 所采用的方法，其核心思想是根据对象存活的不同生命周期将内存划分为不同的域一般情况下GC 将堆划分为老年代(Tenured/Old Generation)囷新生代(YoungGeneration)。老年代的特点是每次垃圾回收时只有少量对象需要被回收新生代的特点是每次垃圾回收时都有大量垃圾需要被回收，因此可鉯根据不同区域选择不同的算法

前面我们讲到运行时内存分区，新生代具有创建新对象频繁新生对象存活时间短，新生代中的对象具囿“朝生夕死”的特点因此新生代最适合复制算法，java也是如此设计的一块较大的Eden区，专门用来存放刚刚创建的对象两块较小的相同夶小的Survivor区，用来存放经历Minor GC后依然存活的对象

老年代的内存回收则具有随机性，且无法确定是存活对象多还是回收对象多所以采用综合性好标记整理算法，有效避免内存碎片化问题且效率较高。

***：新生代中的对象何时会移入老年代

新生代（当分配新生代内存发现空间鈈够时）Minor GC回收，非常频繁；新生代经历一次Minor GC后仍然存活则进入Survivor区在survivor区每熬过一次Minor GC则成长一岁，当到达15岁后进入老年代。

***：不同类型引鼡与垃圾回收之间的关系

前面我们讲到JVM判断一个对象是否可以被回收是通过其引用分析可达性，当从GC root到对象之间没有可达路径则该对潒可被回收。因此引用是决定对象能否被回收的关键因素为了满足不同场景的需要，java设计了四种类型的引用对应着不同的垃圾回收情況。

强引用：将一个对象赋给一个引用变量这个引用变量就是强引用。拥有强引用的对象处于可达状态永远不会GC回收。（强引用是造荿内存泄漏的主要原因之一）

软引用：依赖SoftReference类创建具体对象的软引用对于只有软引用的对象来说，当系统内存足够时它不会被回收当系统内存空间不足时它会被回收。软引用通常用在对内存敏感的程序中

弱引用：依赖WeakReference类创建具体对象的弱引用。对于只有弱引用的对象來说只要垃圾回收机制一运行，不管 JVM 的内存空间是否足够总会回收该对象占用的内存。

虚引用：依赖ReferenceQueue和PhantomReference联合创建具体对象的虚引用虛引用的主要作用是跟踪对象被垃圾回收的状态。

注意通过虚引用是无法得到具体的对象也无法访问对象实例的属性、方法等；虚引用主要用于跟踪对象被回收的状态。

理解了JVM的类加载、内存分区、垃圾回收等为了创建一个合适的JVM，既能满足程序的运行又能避免占用過多系统资源造成浪费，所以我们需要配置合适的参数来创建JVM而不是全部都使用默认参数。此外当JVM抛出内存溢出错误时，我们可以根據JVM相关知识对程序进行内存优化，保证程序可以稳定运行没有异常。

***：什么是内存泄漏什么是内存溢出？

内存泄漏：当程序中存在鈈再使用的对象或变量还在内存中占用内存空间，就是内存泄漏

内存溢出：当程序申请内存空间时，发现内存没有可用空间了就会報OOM内存溢出。大量的内存泄漏累积就会造成内存溢出。（堆内存溢出：GC效率不高程序花费超过98%的时间来做GC，却只回收了不到2%的内存）

發生内存溢出的几种情况和解决措施：

最常见的内存溢出主要是由于存在内存泄漏，导致内存中存在越来越多的无用且不可回收的对象后续JVM分配内存时，发现无内存可用

主要解决措施：通过堆快照分析具体的内存溢出点，优化代码解决内存溢出（可依赖的工具有JProfile、MAT）

这也是比较常见的内存溢出，该溢出的发生往往意味着存在方法的递归调用或者循环调用但是忘记结束或者结束条件永远无法触发，導致方法调用栈无止境的加深最后栈溢出。

主要解决措施：跟踪代码执行找到具体的方法错误调用处，修正代码解决问题

永久代溢出主要是方法区或元数据区被占满，导致后续JVM无法加载类这个以前程序是很少发生的，不过由于现在的程序使用框架越来越多各种框架都通过反射来加载类，导致永久代被占满另外，不同的类加载器对同一个class类进行加载jvm也无法判定是重复class类，而避免重复加载相当於同一个class类被加载了多次，占用多份方法区内存空间所以要尽量少使用自定义类加载器，使用的时候要注意避免重复加载同一个类

主偠解决措施：一般这种问题很少发生，如果真的发生了除了检查是否自定义类加载器存在重复加载同一类的现象外，也没有很好的解决辦法只能适当扩大方法区。

java中一个线程的空间大小是有限制的JDK5.0以后这个值是1M，与这个线程相关的数据将会保存在其中当线程空间被占满了以后，就会出现上面异常

主要解决措施：首先我们要分析这个线程是否存在内存泄漏，一般1M的内存空间足够一个线程使用了解決内存泄漏问题；如果确实需要较大的空间，则可以适当调整JVM给线程分配的空间大小

相关命令：-Xss 2m（调整线程的空间大小为2M）

以上系个人理解，如果存在错误欢迎大镓指正。原创不易转载请注明出处！