《摩根面试准备要点(Java).docx》由会员分享，可在线阅读，更多相关《摩根面试准备要点(Java).docx（73页珍藏版）》请在三一办公上搜索。
1、摩根面试准备要点1. JVM架构(Vincent) 主要包括两个子系统和两个组件： Class loader(类装载器) 子系统，Execution engine(执行引擎) 子系统；Runtime data area (运行时数据区域)组件， Native interface(本地接口)组件。 Class loader子系统的作用 ：根据给定的全限定名类名(如 java.lang.Object)来装载class文件的内容到 Runtime data area中的method area(方法区域)。Javsa程序员可以extends java.lang.ClassLoader类来写自己的Cla
2、ss loader。 Execution engine子系统的作用 ：执行classes中的指令。任何JVM specification实现(JDK)的核心是Execution engine， 换句话说：Sun 的JDK 和IBM的JDK好坏主要取决于他们各自实现的Execution engine的好坏。每个运行中的线程都有一个Execution engine的实例。 Native interface组件 ：与native libraries交互，是其它编程语言交互的接口。 Runtime data area 组件：这个组件就是JVM中的内存。 下面对这个部分进行详细介绍。 Runtime d
3、ata area的整体架构图Runtime data area 主要包括五个部分：Heap (堆), Method Area(方法区域), Java Stack(java的栈), Program Counter(程序计数器), Native method stack(本地方法栈)。Heap 和Method Area是被所有线程的共享使用的；而Java stack, Program counter 和Native method stack是以线程为粒度的，每个线程独自拥有。 Heap Java程序在运行时创建的所有类实或数组都放在同一个堆中。而一个Java虚拟实例中只存在一个堆空间，因此所有线程
4、都将共享这个堆。每一个java程序独占一个JVM实例，因而每个java程序都有它自己的堆空间，它们不会彼此干扰。但是同一java程序的多个线程都共享着同一个堆空间，就得考虑多线程访问对象（堆数据）的同步问题。 （这里可能出现的异常java.lang.OutOfMemoryError: Java heap space） Method area 在Java虚拟机中，被装载的class的信息存储在Method area的内存中。当虚拟机装载某个类型时，它使用类装载器定位相应的class文件，然后读入这个class文件内容并把它传输到虚拟机中。紧接着虚拟机提取其中的类型信息，并将这些信息存储到方法区。
5、该类型中的类（静态）变量同样也存储在方法区中。与Heap 一样，method area是多线程共享的，因此要考虑多线程访问的同步问题。比如，假设同时两个线程都企图访问一个名为Lava的类，而这个类还没有内装载入虚拟机，那么，这时应该只有一个线程去装载它，而另一个线程则只能等待。 （这里可能出现的异常java.lang.OutOfMemoryError: PermGen full）Java stack Java stack以帧为单位保存线程的运行状态。虚拟机只会直接对Java stack执行两种操作：以帧为单位的压栈或出栈。每当线程调用一个方法的时候，就对当前状态作为一个帧保存到java sta
6、ck中(压栈)；当一个方法调用返回时，从java stack弹出一个帧(出栈)。栈的大小是有一定的限制，这个可能出现StackOverFlow问题。 下面的程序可以说明这个问题。public class TestStackOverFlow public static void main(String args) Recursive r = new Recursive();r.doit(10000);/ Exception in thread main java.lang.StackOverflowErrorclass Recursive public int doit(int t) if (t
7、 = 1) return 1;return t + doit(t - 1);Program counter 每个运行中的Java程序，每一个线程都有它自己的PC寄存器，也是该线程启动时创建的。PC寄存器的内容总是指向下一条将被执行指令的地址;，这里的地址可以是一个本地指针，也可以是在方法区中相对应于该方法起始指令的偏移量。 Native method stack 对于一个运行中的Java程序而言，它还能会用到一些跟本地方法相关的数据区。当某个线程调用一个本地方法时，它就进入了一个全新的并且不再受虚拟机限制的世界。本地方法可以通过本地方法接口来访问虚拟机的运行时数据区，不止与此，它还可以做任何它
8、想做的事情。比如，可以调用寄存器，或在操作系统中分配内存等。总之，本地方法具有和JVM相同的能力和权限。 (这里出现JVM无法控制的内存溢出问题native heap OutOfMemory ) 2. CLassLoader (Vincent)Java的可执行文件不同于C/C+，Java编译器只产生中间字节码文件(.class文件)，由Java虚拟机（java.exe）解释执行。Java发布的程序（JAR包）也多半是一堆class文件，运行时由ClassLoader加载到Java虚拟机中执行。ClassLoader是Java虚拟机的主要组成部分，由Java语言编写，用户可以实现自定义的Clas
9、sLoader来完成特定的功能。下面我们用例子说明ClassLoader。 JVM规范定义了两种类型的ClassLoader：Bootstrap ClassLoader和User-defined ClassLoader。 JVM在运行时会产生三个ClassLoader:Bootstrap ClassLoader、Extension ClassLoader和AppClassLoader。Bootstrap是用C+编写的，我们在Java中看不到它，是null,是JVM自带的类装载器，用来装载核心类库，如java.lang.*等。AppClassLoader的Parent是ExtClassLoade
10、r，而ExtClassLoader的Parent为Bootstrap ClassLoader。 3. java中，什么叫不可更改的类（immutable class）（Kevin Tam）从字面意思来理解就是不会发生变化的类，那么是什么不会发生变化呢，其实就是类的状态，也就是不变类的实例一旦被创建，其状态就不会发生变化，举个例子：如果人是一个class，那么我们中的每一个都是人这个类的具体的instance，如果人这个类只有一个状态就是生身父母，那么它就是一个不变类，因为每一个人在出生的那一刹那，生身父母就已经被设置了值，而且终生都不会发生变化。 不变类有什么好处呢？1） 不变类是线程安全的，
11、由于不变类的状态在创建以后不再发生变化，所以它可以在线程之间共享，而不需要同步。2） 不变类的instance可以被reuse创建类的实例需要耗费CPU的时间，当这个实例不再被引用时，将会被垃圾回收掉，这时候，又需要耗费CPU的时间。对于不变类而言，一个好处就是可以将常用的实例进行缓存，从而减少了对象的创建。举个例子，对于布尔型，最常用的便是true and false。JDK中的Boolean类就是一个不变类，并且对这两个实例进行了缓冲。public final class Boolean implements java.io.Serializable/* * The Boolean obj
12、ect corresponding to the primitive * value true. */public static final Boolean TRUE = new Boolean(true); /* * The Boolean object corresponding to the primitive * value false. */public static final Boolean FALSE = new Boolean(false);/ 这个方法不会创建新的对象，而是重用已经创建好的instance public static Boolean valueOf(bool
13、ean b) return (b ? TRUE : FALSE); 3） 不变类的某些方法可以缓存计算的结果hashCode这个方法来自于Object这个类，这个方法用来返回对象的hashCode,主要用于将对象放置到hashtable中时，来确定这个对象的存储位置。对于一个不变类的实例，它的hashCode也是不变的，所以就可以缓存这个计算的结果，来提高性能，避免不必要的运算，JDK中的String类就是一个例子。public final class String /* Cache the hash code for the string */private int hash; / Defa
14、ult to 0 public int hashCode() int h = hash;if (h = 0) / compute the value hash = h; / cache the value return h; 在JDK中， String, the primitive wrapper classes, and BigInteger and BigDecimal都是不变类。如果一个类是不变类，这个类是不是就不能有改变状态的方法呢？答案当然是否定的，String是一个不变类，仍然有replace，replaceAll这样的方法，而String仍然是一个不变类，那是因为在这些改变状态的
15、方法中，每次都是新创建一个String对象。如果大家理解了不变类，那也就不难理解为什么在做String的concatenate时，应当用StringBuffer而不是用+的操作符。如何正确使用String呢?1） 不要用new去创建String对象。如果使用new去创建String，那么每次都会创建一个新对象。public static void main(String args) String A1 = A; String A2 = A; / It wont create a new object checkInstance(A1, A2); / Result: They are same
16、instances String B1 = new String(A); / create a new object String B2 = new String(A); / creat a new object checkInstance(B1, B2); / Result: They are different instances private static void checkInstance(String a1, String a2) if (a1 = a2) System.out.println(They are same instances); else System.out.p
17、rintln(They are different instances); 2） 应当用StringBuffer来做连接操作因为String是一个不变类，那么在做连接操作时，就会创建临时对象来保存中间的运算结果，而StringBuffer是一个mutable class,这样就不需要创建临时的对象来保存结果，从而提高了性能。4. JAVA Garbage Collection (Vincent)垃圾分代回收算法（Generational Collecting） 基于对对象生命周期分析后得出的垃圾回收算法。把对象分为年青代、年老代、持久代，对不同生命周期的对象使用不同的算法（上述方式中的一个）进
18、行回收。现在的垃圾回收器（从J2SE1.2开始）都是使用此算法的。 如上图所示，为Java堆中的各代分布。 1. Young（年轻代）JVM specification中的 Heap的一部份 年轻代分三个区。一个Eden区，两个Survivor区。大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当这个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor去也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制年老区(Tenured);。需要注意，Survivor的两个
19、区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来 对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor去过来的对象。而且，Survivor区总有一个是空的。 2. Tenured（年老代）JVM specification中的 Heap的一部份 年老代存放从年轻代存活的对象。一般来说年老代存放的都是生命期较长的对象。 3. Perm（持久代） JVM specification中的 Method area 用于存放静态文件，如今Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hib
20、ernate等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=进行设置。采用分区管理机制的JVM将JVM所管理的所有内存资源分为2个大的部分。永久存储区（Permanent Space）和堆空间（The Heap Space）。其中堆空间又分为新生区（Young (New) generation space）和养老区（Tenure (Old) generation space），新生区又分为伊甸园（Eden space），幸存者0区（Survivor 0 space）和幸存者1区（Survivor 1 space）。具体分区
21、如下图： 那JVM他的这些分区各有什么用途，请看下面的解说。 永久存储区（Permanent Space）：永久存储区是JVM的驻留内存，用于存放JDK自身所携带的Class,Interface的元数据，应用服务器允许必须的Class,Interface的元数据和Java程序运行时需要的Class和Interface的元数据。被装载进此区域的数据是不会被垃圾回收器回收掉的，关闭JVM时，释放此区域所控制的内存。 堆空间（The Heap Space）：是JAVA对象生死存亡的地区，JAVA对象的出生，成长，死亡都在这个区域完成。堆空间又分别按JAVA对象的创建和年龄特征分为养老区和新生区。 新
22、生区（Young (New) generation space）：新生区的作用包括JAVA对象的创建和从JAVA对象中筛选出能进入养老区的JAVA对象。 伊甸园（Eden space）：JAVA对空间中的所有对象在此出生，该区的名字因此而得名。也即是说当你的JAVA程序运行时，需要创建新的对象，JVM将在该区为你创建一个指定的对象供程序使用。创建对象的依据即是永久存储区中的元数据。 幸存者0区（Survivor 0 space）和幸存者1区（Survivor1 space）：当伊甸园的空间用完时，程序又需要创建对象；此时JVM的垃圾回收器将对伊甸园区进行垃圾回收，将伊甸园区中的不再被其他对象所
23、引用的对象进行销毁工作。同时将伊甸园中的还有其他对象引用的对象移动到幸存者0区。幸存者0区就是用于存放伊甸园垃圾回收时所幸存下来的JAVA对象。当将伊甸园中的还有其他对象引用的对象移动到幸存者0区时，如果幸存者0区也没有空间来存放这些对象时，JVM的垃圾回收器将对幸存者0区进行垃圾回收处理，将幸存者0区中不在有其他对象引用的JAVA对象进行销毁，将幸存者0区中还有其他对象引用的对象移动到幸存者1区。幸存者1区的作用就是用于存放幸存者0区垃圾回收处理所幸存下来的JAVA对象。 养老区（Tenure (Old) generation space）：用于保存从新生区筛选出来的JAVA对象。 上面我们
24、看了JVM的内存分区管理，现在我们来看JVM的垃圾回收工作是怎样运作的。首先当启动J2EE应用服务器时，JVM随之启动，并将JDK的类和接口，应用服务器运行时需要的类和接口以及J2EE应用的类和接口定义文件也及编译后的Class文件或JAR包中的Class文件装载到JVM的永久存储区。在伊甸园中创建JVM，应用服务器运行时必须的JAVA对象，创建J2EE应用启动时必须创建的JAVA对象；J2EE应用启动完毕，可对外提供服务。 JVM在伊甸园区根据用户的每次请求创建相应的JAVA对象，当伊甸园的空间不足以用来创建新JAVA对象的时候，JVM的垃圾回收器执行对伊甸园区的垃圾回收工作，销毁那些不再被
25、其他对象引用的JAVA对象（如果该对象仅仅被一个没有其他对象引用的对象引用的话，此对象也被归为没有存在的必要，依此类推），并将那些被其他对象所引用的JAVA对象移动到幸存者0区。 如果幸存者0区有足够控件存放则直接放到幸存者0区；如果幸存者0区没有足够空间存放，则JVM的垃圾回收器执行对幸存者0区的垃圾回收工作，销毁那些不再被其他对象引用的JAVA对象（如果该对象仅仅被一个没有其他对象引用的对象引用的话，此对象也被归为没有存在的必要，依此类推），并将那些被其他对象所引用的JAVA对象移动到幸存者1区。 如果幸存者1区有足够控件存放则直接放到幸存者1区；如果幸存者0区没有足够空间存放，则JVM的
26、垃圾回收器执行对幸存者0区的垃圾回收工作，销毁那些不再被其他对象引用的JAVA对象（如果该对象仅仅被一个没有其他对象引用的对象引用的话，此对象也被归为没有存在的必要，依此类推），并将那些被其他对象所引用的JAVA对象移动到养老区。 如果养老区有足够控件存放则直接放到养老区；如果养老区没有足够空间存放，则JVM的垃圾回收器执行对养老区区的垃圾回收工作，销毁那些不再被其他对象引用的JAVA对象（如果该对象仅仅被一个没有其他对象引用的对象引用的话，此对象也被归为没有存在的必要，依此类推），并保留那些被其他对象所引用的JAVA对象。如果到最后养老区，幸存者1区，幸存者0区和伊甸园区都没有空间的话，则J
27、VM会报告“JVM堆空间溢出（java.lang.OutOfMemoryError: Java heap space）”，也即是在堆空间没有空间来创建对象。 这就是JVM的内存分区管理，相比不分区来说；一般情况下，垃圾回收的速度要快很多；因为在没有必要的时候不用扫描整片内存而节省了大量时间。 通常大家还会遇到另外一种内存溢出错误“永久存储区溢出（java.lang.OutOfMemoryError: Java Permanent Space）”。所有的垃圾收集算法都面临同一个问题，那就是找出应用程序不可到达的内存块，将其释放，这里面得不可到达主要是指应用程序已经没有内存块的引用了，而在JAVA
28、中，某个对象对应用程序是可到达的是指：这个对象被根（根主要是指类的静态变量，或者活跃在所有线程栈的对象的引用）引用或者对象被另一个可到达的对象引用。ReferenceCounting(引用计数） 引用计数是最简单直接的一种方式，这种方式在每一个对象中增加一个引用的计数，这个计数代表当前程序有多少个引用引用了此对象，如果此对象的引用计数变为0，那么此对象就可以作为垃圾收集器的目标对象来收集。优点：简单，直接，不需要暂停整个应用缺点：1.需要编译器的配合，编译器要生成特殊的指令来进行引用计数的操作，比如每次将对象赋值给新的引用，或者者对象的引用超出了作用域等。2.不能处理循环引用的问题跟踪收集器
29、跟踪收集器首先要暂停整个应用程序，然后开始从根对象扫描整个堆，判断扫描的对象是否有对象引用，这里面有三个问题需要搞清楚：1如果每次扫描整个堆，那么势必让GC的时间变长，从而影响了应用本身的执行。因此在JVM里面采用了分代收集，在新生代收集的时候minorgc只需要扫描新生代，而不需要扫描老生代。2JVM采用了分代收集以后，minorgc只扫描新生代，但是minorgc怎么判断是否有老生代的对象引用了新生代的对象，JVM采用了卡片标记的策略，卡片标记将老生代分成了一块一块的，划分以后的每一个块就叫做一个卡片，JVM采用卡表维护了每一个块的状态，当JAVA程序运行的时候，如果发现老生代对象引用或者
30、释放了新生代对象的引用，那么就JVM就将卡表的状态设置为脏状态，这样每次minorgc的时候就会只扫描被标记为脏状态的卡片，而不需要扫描整个堆。具体如下图：3GC在收集一个对象的时候会判断是否有引用指向对象，在JAVA中的引用主要有四种：Strongreference,Softreference,Weakreference,Phantomreference.StrongReference强引用是JAVA中默认采用的一种方式，我们平时创建的引用都属于强引用。如果一个对象没有强引用，那么对象就会被回收。publicvoidtestStrongReference()Objectreferent=ne
31、wObject();ObjectstrongReference=referent;referent=null;System.gc();assertNotNull(strongReference);SoftReference软引用的对象在GC的时候不会被回收，只有当内存不够用的时候才会真正的回收，因此软引用适合缓存的场合，这样使得缓存中的对象可以尽量的再内存中待长久一点。PublicvoidtestSoftReference()Stringstr=test;SoftReferencesoftreference=newSoftReference(str);str=null;System.gc();
32、assertNotNull(softreference.get();Weakreference弱引用有利于对象更快的被回收，假如一个对象没有强引用只有弱引用，那么在GC后，这个对象肯定会被回收。PublicvoidtestWeakReference()Stringstr=test;WeakReferenceweakReference=newWeakReference(str);str=null;System.gc();assertNull(weakReference.get();PhantomreferenceMark-SweepCollector(标记-清除收集器） 标记清除收集器最早由Li
33、sp的发明人于1960年提出，标记清除收集器停止所有的工作，从根扫描每个活跃的对象，然后标记扫描过的对象，标记完成以后，清除那些没有被标记的对象。优点：1解决循环引用的问题2不需要编译器的配合，从而就不执行额外的指令缺点：1每个活跃的对象都要进行扫描，收集暂停的时间比较长。CopyingCollector(复制收集器） 复制收集器将内存分为两块一样大小空间，某一个时刻，只有一个空间处于活跃的状态，当活跃的空间满的时候，GC就会将活跃的对象复制到未使用的空间中去，原来不活跃的空间就变为了活跃的空间。复制收集器具体过程可以参考下图：优点：1只扫描可以到达的对象，不需要扫描所有的对象，从而减少了应用
34、暂停的时间缺点：1需要额外的空间消耗，某一个时刻，总是有一块内存处于未使用状态2复制对象需要一定的开销Mark-CompactCollector(标记-整理收集器） 标记整理收集器汲取了标记清除和复制收集器的优点，它分两个阶段执行，在第一个阶段，首先扫描所有活跃的对象，并标记所有活跃的对象，第二个阶段首先清除未标记的对象，然后将活跃的的对象复制到堆得底部。标记整理收集器的过程示意图请参考下图：Mark-compact策略极大的减少了内存碎片，并且不需要像CopyCollector一样需要两倍的空间。JVM的垃圾收集策略 GC的执行时要耗费一定的CPU资源和时间的，因此在JDK1.2以后，JVM
35、引入了分代收集的策略，其中对新生代采用Mark-Compact策略，而对老生代采用了“Mark-Sweep的策略。其中新生代的垃圾收集器命名为“minorgc”，老生代的GC命名为FullGc或者MajorGC.其中用System.gc()强制执行的是FullGc.5. Spring IOC and AOP(Minjin)IoC和AOP都是Spring的核心思想 当然，最为一个框架级的轻量组件，大量的配置文件是不可缺少的，但是核心是要把这些配置文件，配置节组装起来，并将核心代码编写为完全业务无关的。我们看看Spring是怎么做的。 首先，IoC，控制反转。Spring 开发的基本思想：面向接口
36、的编程模式。框架做的越多，应该越能发现接口在其中起到的作用，而Spring将这种想法，开始贯彻到业务的开发中了。Bean 的Set方法使用接口作为参数，保证其扩展性，实现依赖关系的松偶尔。所谓的控制反转，作为中文更好理解的一个翻译应该是依赖注入，把依赖的类采用接口的方式，利用Set函数，传入Bean的内部，实现与外界的解耦合。这种注入也可作用于构造函数。 其次，AOP，面向切面的编程方式，我觉得更通俗的说法应该是对容器内的Bean进行方法干涉。被容器中创建的类，看起来执行一个普通的函数调用，因为被容器预处理，而会在方法执行前/后进行一些其他的、可配置的操作。当然，这种方法也同样是面向接口的，或
37、者直接使用反射的。利用java.lang.reflect.InvocationHandler接口可以达到这种干涉的效果。下面是转载的一个简单示例。 Java代码 importjava.lang.reflect.InvocationHandler; importjava.lang.reflect.Method; importjava.lang.reflect.Proxy; publicclassDynaProxyHelloimplementsInvocationHandler privateObjectproxy; privateObjectdelegate; publicObjectbind(
38、Objectdelegate,Objectproxy) this.proxy=proxy; this.delegate=delegate; returnProxy.newProxyInstance( this.delegate.getClass().getClassLoader(),this.delegate .getClass().getInterfaces(),this); publicObjectinvoke(Objectproxy,Methodmethod,Objectargs) throwsThrowable Objectresult=null; try /反射得到操作者的实例 Cl
39、assclazz=this.proxy.getClass(); /反射得到操作者的Start方法 Methodstart=clazz.getDeclaredMethod(start, newClassMethod.class); /反射执行start方法 start.invoke(this.proxy,newObjectmethod); /执行要处理对象的原本方法 result=method.invoke(this.delegate,args); /反射得到操作者的end方法 Methodend=clazz.getDeclaredMethod(end, newClassMethod.class
40、); /反射执行end方法 end.invoke(this.proxy,newObjectmethod); catch(Exceptione) e.printStackTrace(); returnresult; publicclassTest publicstaticvoidmain(Stringargs) IHellohello=(IHello)newDynaProxyHello().bind(newHello(),newLoggerOperation(); hello.sayGoogBye(DoubleJ); hello.sayHello(DoubleJ); import java.la
41、ng.reflect.InvocationHandler; 2. 4 import java.lang.reflect.Method; 3. 5 import java.lang.reflect.Proxy; 4. 6 5. 7 public class DynaProxyHello implements InvocationHandler 6. 8 7.11 private Object proxy; 8.12 9.15 private Object delegate; 10.16 11.17 12.24 public Object bind(Object delegate,Object p
42、roxy) 13.25 14.26 this.proxy = proxy; 15.27 this.delegate = delegate; 16.28 return Proxy.newProxyInstance( 17.29 this.delegate.getClass().getClassLoader(), this.delegate 18.30 .getClass().getInterfaces(), this); 19.31 20.32 21.36 public Object invoke(Object proxy, Method method, Object args) 22.37 t
43、hrows Throwable 23.38 Object result = null; 24.39 try 25.40 /反射得到操作者的实例 26.41 Class clazz = this.proxy.getClass(); 27.42 /反射得到操作者的Start方法 28.43 Method start = clazz.getDeclaredMethod(start, 29.44 new Class Method.class ); 30.45 /反射执行start方法 31.46 start.invoke(this.proxy, new Object method ); 32.47 /执行要处理对象的原本方法 result = method.in
