1:  自我介绍

自我介绍首先描述自己的基本情况，其次是描述自己的技术亮点，做过的亮点项目或产品。如果没有做过有技术亮点的事，每天都在做增删改查功能或重复性的工作，需要好好反思下，这样下去技术上没有多少增长。如果工作中就是做这个怎么办？可以考虑利用业余时间参与开源项目或自己做一些工具或框架。

    2:  HashMap怎么解决Hash冲突的

HashMap的数据结构是：数组Node[]与链表Node中有next Node.

在put元素时，先根据key的hashCode重新计算出hash值，然后再根据hash值找出这个元素在数组中的位置，如果数组的此处已经存放了数据，那么这个元素会议链表的形式保存，新的在链头，旧的在链尾；如果数组的此处没有存放数据，则直接将该元素保存在数组的此位置上。

    3:  ConcurrentHashMap怎么解决线程安全

Segment分段锁功能，每一个Segment 都想的于小的hash table并且都有自己锁，只要修改不再同一个段上就不会引起并发问题。

 

    4:  常见的排序有没有了解过

排序方法        平均情况        最好情况        最坏情况        辅助空间        稳定性

冒泡排序         O(n^2)           O(n)              O(n^2)            O(1)                稳定

选择排序         O(n^2)          O(n^2)            O(n^2)            O(1)              不稳定

插入排序         O(n^2)           O(n)              O(n^2)            O(1)                稳定

希尔排序O(n*log(n))~O(n^2) O(n^1.3)       O(n^2)            O(1)              不稳定

堆排序          O(n*log(n))     O(n*log(n))    O(n*log(n))       O(1)              不稳定

归并排序       O(n*log(n))     O(n*log(n))    O(n*log(n))       O(n)                稳定

快速排序       O(n*log(n))     O(n*log(n))      O(n^2)            O(1)              不稳定

 

冒泡排序经过优化以后，最好时间复杂度可以达到O(n)。设置一个标志位，如果有一趟比较中没有发生任何交换，可提前结束，因此在正序情况下，时间复杂度为O(n)。

选择排序在最坏和最好情况下，都必须在剩余的序列中选择最小（大）的数，与已排好序的序列后一个位置元素做交换，依次最好和最坏时间复杂度均为O(n^2)。

插入排序是在把已排好序的序列的后一个元素插入到前面已排好序(需要选择合适的位置)的序列中，在正序情况下时间复杂度为O(n)。

堆是完全二叉树，因此树的深度一定是log(n)+1，最好和最坏时间复杂度均为O(n*log(n))。

归并排序是将大数组分为两个小数组，依次递归，相当于二叉树，深度为log(n)+1，因此最好和最坏时间复杂度都是O(n*log(n))。

快速排序在正序或逆序情况下，每次划分只得到比上一次划分少一个记录的子序列，用递归树画出来，是一棵斜树，此时需要n-1次递归，且第i次划分要经过n-i次关键字比较才能找到第i个记录，因此时间复杂度是sum_{i=1}^{n-1}(n-i)=n(n-1)/2，即O(n^2)。

    5:  一堆基本有序的数组，用哪种排序效率最高

归并排序

 

    6:  JDK1.6到JDK1.8 GC上面最大做了什么变化

在JDK8之前的HotSpot实现中，类的元数据如方法数据、方法信息（字节码，栈和变量大小）、运行时常量池、已确定的符号引用和虚方法表等被保存在永久代中，32位默认永久代的大小为64M，64位默认为85M，可以通过参数-XX:MaxPermSize进行设置，一旦类的元数据超过了永久代大小，就会抛出OOM异常。

        虚拟机团队在JDK8的HotSpot中，把永久代从Java堆中移除了，并把类的元数据直接保存在本地内存区域（堆外内存），称之为元空间。

 

GC动作发生之前，需要确定堆内存中哪些对象是存活的，一般有两种方法：引用计数法和可达性分析法。

 

1、引用计数法

 

        在对象上添加一个引用计数器，每当有一个对象引用它时，计数器加1，当使用完该对象时，计数器减1，计数器值为0的对象表示不可能再被使用。

引用计数法实现简单，判定高效，但不能解决对象之间相互引用的问题。

 

2、可达性分析法

 

        通过一系列称为 “GC Roots” 的对象作为起点，从这些节点开始向下搜索，搜索路径称为 “引用链”，以下对象可作为GC Roots：

        本地变量表中引用的对象

        方法区中静态变量引用的对象

        方法区中常量引用的对象

        Native方法引用的对象

收集算法

 

垃圾收集算法主要有：标记-清除、复制和标记-整理。

 

 

 

 

1、标记-清除算法

 

对待回收的对象进行标记。

算法缺点：效率问题，标记和清除过程效率都很低；空间问题，收集之后会产生大量的内存碎片，不利于大对象的分配。

 

2、复制算法

 

复制算法将可用内存划分成大小相等的两块A和B，每次只使用其中一块，当A的内存用完了，就把存活的对象复制到B，并清空A的内存，不仅提高了标记的效率，因为只需要标记存活的对象，同时也避免了内存碎片的问题，代价是可用内存缩小为原来的一半。

 

3、标记-整理算法

 

在老年代中，对象存活率较高，复制算法的效率很低。在标记-整理算法中，标记出所有存活的对象，并移动到一端，然后直接清理边界以外的内存。

 

 

对象标记过程

 

在可达性分析过程中，为了准确找出与GC Roots相关联的对象，必须要求整个执行引擎看起来像是被冻结在某个时间点上，即暂停所有运行中的线程，不可以出现对象的引用关系还在不断变化的情况。

 

如何快速枚举GC Roots？

 

GC Roots主要在全局性的引用（常量或类静态属性）与执行上下文（本地变量表中的引用）中，很多应用仅仅方法区就上百兆，如果进行遍历查找，效率会非常低下。

 

    7:  CMS怎么进行垃圾收集的

 

CMS(Concurrent Mark Sweep)是一种以获取最短回收停顿时间为目标的收集器，工作在老年代，基于“标记-清除”算法实现，整个过程分为以下4步：

 

1. 初始标记：这个过程只是标记以下GC Roots能够直接关联的对象，但是仍然会Stop The World；
2. 并发标记：进行GC Roots Tracing的过程，可以和用户线程一起工作。
3. 重新标记：用于修正并发标记期间由于用户程序继续运行而导致标记产生变动的那部分记录，这个过程会暂停所有线程，但其停顿时间远比并发标记的时间短；
4. 并发清理：可以和用户线程一起工作。

 

CMS收集器的缺点：

 

1. 对CPU资源比较敏感，在并发阶段，虽然不会导致用户线程停顿，但是会占用一部分线程资源，降低系统的总吞吐量。
2. 无法处理浮动垃圾，在并发清理阶段，用户线程的运行依然会产生新的垃圾对象，这部分垃圾只能在下一次GC时收集。
3. CMS是基于标记-清除算法实现的，意味着收集结束后会造成大量的内存碎片，可能导致出现老年代剩余空间很大，却无法找到足够大的连续空间分配当前对象，不得不提前触发一次Full GC。

 

JDK1.5实现中，当老年代空间使用率达到68%时，就会触发CMS收集器，如果应用中老年代增长不是太快，可以通过-XX:CMSInitiatingOccupancyFraction参数提高触发百分比，从而降低内存回收次数提高系统性能。

 

JDK1.6实现中，触发CMS收集器的阈值已经提升到92%，要是CMS运行期间预留的内存无法满足用户线程需要，会出现一次”Concurrent Mode Failure”失败，这是虚拟机会启动Serial Old收集器对老年代进行垃圾收集，当然，这样应用的停顿时间就更长了，所以这个阈值也不能设置的太高，如果导致了”Concurrent Mode Failure”失败，反而会降低性能，至于如何设置这个阈值，还得长时间的对老年代空间的使用情况进行监控。

 

 

    8:  G1怎么进行垃圾收集的

G1（Garbage First）是JDK1.7提供的一个工作在新生代和老年代的收集器，基于“标记-整理”算法实现，在收集结束后可以避免内存碎片问题。

 

G1优点：

 

1. 并行与并发：充分利用多CPU来缩短Stop The World的停顿时间；
2. 分代收集：不需要其他收集配合就可以管理整个Java堆，采用不同的方式处理新建的对象、已经存活一段时间和经历过多次GC的对象获取更好的收集效果;
3. 空间整合：与CMS的”标记-清除”算法不同，G1在运行期间不会产生内存空间碎片，有利于应用的长时间运行，且分配大对象时，不会导致由于无法申请到足够大的连续内存而提前触发一次Full GC;
4. 停顿预测：G1中可以建立可预测的停顿时间模型，能让使用者明确指定在M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒。

 

使用G1收集器时，Java堆的内存布局与其他收集器有很大区别，整个Java堆会被划分为多个大小相等的独立区域Region，新生代和老年代不再是物理隔离了，都是一部分Region（不需要连续）的集合。G1会跟踪各个Region的垃圾收集情况（回收空间大小和回收消耗的时间），维护一个优先列表，根据允许的收集时间，优先回收价值最大的Region，避免在整个Java堆上进行全区域的垃圾回收，确保了G1收集器可以在有限的时间内尽可能收集更多的垃圾。

 

不过问题来了：使用G1收集器，一个对象分配在某个Region中，可以和Java堆上任意的对象有引用关系，那么如何判定一个对象是否存活，是否需要扫描整个Java堆？其实这个问题在之前收集器中也存在，如果回收新生代的对象时，不得不同时扫描老年代的话，会大大降低Minor GC的效率。

 

针对这种情况，虚拟机提供了一个解决方案：G1收集器中Region之间的对象引用关系和其他收集器中新生代与老年代之间的对象引用关系被保存在Remenbered Set数据结构中，用来避免全堆扫描。G1中每个Region都有一个对应的Remenbered Set，当虚拟机发现程序对Reference类型的数据进行写操作时，会产生一个Write Barrier暂时中断写操作，检查Reference引用的对象是否处于相同的Region中，如果不是，则通过CardTable把相关引用信息记录到被引用对象所属Region的Remenbered Set中。

 

    9:  G1相比于CMS有哪些优势

与CMS的”标记-清除”算法不同，G1在运行期间不会产生内存空间碎片，有利于应用的长时间运行，且分配大对象时，不会导致由于无法申请到足够大的连续内存而提前触发一次Full GC;

与CMS的“标记--清理”算法不同，G1从整体来看是基于“标记整理”算法实现的收集器；从局部上来看是基于“复制”算法实现的。

    10: 哪些情况会导致Full GC

1、System.gc()方法的调用

2、老年代代空间不足

3、永生区空间不足

4、CMS GC时出现promotion failed和concurrent mode failure

5、统计得到的Minor GC晋升到旧生代的平均大小大于老年代的剩余空间

6、堆中分配很大的对象

 

    11: 新new的对象放在哪里

->堆内存是用来存放由new创建的对象和数组，即动态申请的内存都存放在堆内存

-->栈内存是用来存放在函数中定义的一些基本类型的变量和对象的引用变量

 

    12: 哪些东西放在栈区

1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制；

1. 栈：存放基本类型 的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new出来的对象）或者常量池中（字符串常量对象存放的常量池中），局部变量【注意：（方法中的局部变量使用final修饰后，放在堆中，而不是栈中）】

2.堆：存放使用new创建的对象，全局变量

3. 静态域：存放静态成员（static定义的）；

4. 常量池：字符串常量和基本类型常量（public static final）。有时，在嵌入式系统中，常量本身会和其他部分分割离开(由于版权等其他原因)，所以在这种情况下，可以选择将其放在ROM中 ；

5. 非RAM存储：硬盘等永久存储空间

 

    13: 双亲委派模型, 有什么好处

亲委派模型要求除顶层启动类加载器外其余类加载器都应该有自己的父类加载器；类加载器之间通过复用关系来复用父加载器的代码。

双亲委派模型的优点：

Java类伴随其类加载器具备了带有优先级的层次关系，确保了在各种加载环境的加载顺序。  

保证了运行的安全性，防止不可信类扮演可信任的类。

    14: wait和sleep有什么区别

 

1、这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。

sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。

 

2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

Thread.Sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。

 

3、使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 

   synchronized(x){ 

      x.notify() 

     //或者wait() 

   }

 

4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

 

    15: 线程池几个参数

 

 

1. ThreadPoolExecutor mExecutor = new ThreadPoolExecutor(corePoolSize,// 核心线程数  
2.                         maximumPoolSize, // 最大线程数  
3.                         keepAliveTime, // 闲置线程存活时间  
4.                         TimeUnit.MILLISECONDS,// 时间单位  
5.                         new LinkedBlockingDeque<Runnable>(),// 线程队列  
6.                         Executors.defaultThreadFactory(),// 线程工厂  
7.                         new AbortPolicy()// 队列已满,而且当前线程数已经超过最大线程数时的异常处理策略  
8.                 );  

线程池任务执行流程：

1. 当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
2. 当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
3. 当workQueue已满，且maximumPoolSize>corePoolSize时，新提交任务会创建新线程执行任务
4. 当提交任务数超过maximumPoolSize时，新提交任务由RejectedExecutionHandler处理
5. 当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
6. 当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭

    16: 怎么评估线程数大小 

如果线程池中的线程在执行任务时，密集计算所占的时间比重为P(0<P<=1)，而系统一共有C个CPU，为了让CPU跑满而又不过载，线程池的大小经验公式 T = C / P。在此，T只是一个参考，考虑到P的估计并不是很准确，T的最佳估值可以上下浮动50%。

这个经验公式的原理很简单，T个线程，每个线程占用P的CPU时间，如果刚好占满C个CPU,那么必有 T * P = C。

 

假设C = 8，P = 1.0，线程池的任务完全是密集计算，那么T = 8。只要8个活动线程就能让8个CPU饱和，再多也没用了，因为CPU资源已经耗光了。

假设C = 8，P = 0.5，线程池的任务有一半是计算，有一半在等IO上，那么T = 16.考虑操作系统能灵活，合理调度sleeping/writing/running线程，那么大概16个“50%繁忙的线程”能让8个CPU忙个不停。启动更多的线程并不能提高吞吐量，反而因为增加上下文切换的开销而降低性能。

如果P < 0.2，这个公式就不适用了，T可以取一个固定值，比如 5*C。另外公式里的C不一定是CPU总数，可以是“分配给这项任务的CPU数目”，比如在8核机器上分出4个核来做一项任务，那么C=4

 

 

    17: 几个线程访问同一个东西，怎么保证安全

1、同步代码块： 

2、同步方法 

3、同步锁-锁机制lock 

一般说来，确保线程安全的方法有这几个：竞争与原子操作、同步与锁、可重入、过度优化。

 

 

    18: Spring几个特点说下

1--核心容器

核心容器提供spring框架的基本功能,核心容器的主要组件是BeanFactory, 他是工厂模式的实现. 

BeanFactory使用控制反转(IOC)模式将应用程序的配置和依赖性与实际的应用程序代码分开

2--Spring上下文

是一个配置文件,该配置文件向spring框架提供上下文信息

3--Spring AOP

通过配置管理特性,Spring AOP 模块直接将面向切面(方面)编程功能集成到spring框架中

4--spring DAO

JDBC DAO抽象层提供了有意义的已成层次结构, 可用该结构管理异常处理和不同数据库抛出的错误信息,极大的降低了异常代码数量

5--Spring ORM

spring框架插入了若干个ORM框架, 从而提供了ORM的对象工具,其中包括了Hibernate, Mybatis

6--Spring Web

web上下文模块建立在应用程序上下文模块之上,为基于web的应用程序提供上下文

7--Spring MVC

该框架是一个全功能的构建web应用程序的MVC实现. 通过策略接口,MVC框架变成高度可配置的. MVC容纳了大量视图技术. 其中包括JSP、Velocity和POI

Spring 框架的好处

spring是最大的工厂

 spring负责业务逻辑组件的框架和生成, 并管理业务逻辑组件的生命周期 

spring可以生产所有实例, 从控制器、 业务逻辑组件、 持久层组件

Spring特点

1--降低了组件之间的耦合性, 实现了软件各个层之间的解耦

2--可以使用spring容器提供的服务, 如: 事务管理, 消息服务

3--容器提供单例模式支持

4--容器提供AOP技术, 利用它很容易实现权限拦截, 运行期监控

5--容器提供了众多的辅助类, 能加快应用的开发(org.springframework.jdbc.core.JDBCTemplate 等)

6--spring对主流的应用框架提供了集成支持, 例如: hibernate,JPA, Struts, Mybatis(IBatis)

7--Spring属于低侵入式设计, 代码污染度极低

8--独立于各种应用服务器

9--spring的DI机制降低了业务对象替换的复杂性

10--spring的高度开发性, 并不强制应用完全依赖于spring, 开发者可以自由选择spring的部分或者全部

    19: CGLib有没有了解过

CGlib是什么？ 

CGlib是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。 

当然这些实际的功能是asm所提供的，asm又是什么？Java字节码操控框架，具体是什么大家可以上网查一查，毕竟我们这里所要讨论的是cglib， 

cglib就是封装了asm，简化了asm的操作，实现了在运行期动态生成新的class。 

可能大家还感觉不到它的强大，现在就告诉你。 

实际上CGlib为spring aop提供了底层的一种实现;为hibernate使用cglib动态生成VO/PO (接口层对象)。 

CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。

 

CGLIB原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。

CGLIB底层：使用字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

CGLIB缺点：对于final方法，无法进行代理。

 

 

    20: Spring支持哪几种切片

1.前置增强：org.springframework.aop.BeforeAdvice代表前置增强，因为Spring只支持

方法级的增强，所以MethodBeforeAdvice是目前可的的前置增强，表示在目标方法执行前

实施增强，而BeforeAdvice是为了将来版本扩展需要而定义的；

2.后置增强：org.springframework.aop.AfterReturningAdvice代表后增强，表示在目标

方法执行后实施增强；

3.环绕增强：org.aopalliance.intercept.MethodInterceptor代表环绕增强，表示在目标

方法执行前后实施增强；

4：异常抛出增强：org.springframework.aop.ThrowsAdvice代表抛出异常增强，表示在目

标方法抛出异常后实施增强；

5.引介增强：org.springframework.aop.InteoductionInterceptor代表引介增强，表示在

目标类中添加一些新的方法和属性；

这些增强接口都有一些方法，通过实现这些接口方法，在接口方法中这义横切逻辑，就可以

将它们织入到目标类的方法的相应连接点的位置。

    21: SpringBoot和Spring有什么区别

Spring Boot是最近这几年才火起来的，那么它到底与Spring有啥区别呢？

想了解区别，其实就是Spring Boot提供了哪些特征：

1. Spring Boot可以建立独立的Spring应用程序；
2. 内嵌了如Tomcat，Jetty和Undertow这样的容器，也就是说可以直接跑起来，用不着再做部署工作了。
3. 无需再像Spring那样搞一堆繁琐的xml文件的配置；
4. 可以自动配置Spring；
5. 提供了一些现有的功能，如量度工具，表单数据验证以及一些外部配置这样的一些第三方功能；
6. 提供的POM可以简化Maven的配置；

    22: SpringBoot和Spring启动有什么区别

1、IDEA启动 SpringBootApplication

2、命令行启动首先将命令行位置跳转到当前项目的根目录下，再输入“mvn spring-boot:run”命令，初次操作maven需要下载插件等待几分钟。

3、命令行编译为jar启动首先命令行在当前项目根目录运行编译命令“mvn install”，之后跳转到当前项目的target文件夹下（cd target）多出两个文件

 

 

spring

1. 首先，对于一个web应用，其部署在web容器中，web容器提供其一个全局的上下文环境，这个上下文就是ServletContext，其为后面的spring IoC容器提供宿主环境；
2. 其次，在web.xml中会提供有contextLoaderListener。在web容器启动时，会触发容器初始化事件，此时contextLoaderListener会监听到这个事件，其contextInitialized方法会被调用，在这个方法中，spring会初始化一个启动上下文，这个上下文被称为根上下文，即WebApplicationContext，这是一个接口类，确切的说，其实际的实现类是XmlWebApplicationContext。这个就是spring的IoC容器，其对应的Bean定义的配置由web.xml中的context-param标签指定。在这个IoC容器初始化完毕后，spring以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE为属性Key，将其存储到ServletContext中，便于获取；
3. 再次，contextLoaderListener监听器初始化完毕后，开始初始化web.xml中配置的Servlet，这个servlet可以配置多个，以最常见的DispatcherServlet为例，这个servlet实际上是一个标准的前端控制器，用以转发、匹配、处理每个servlet请求。DispatcherServlet上下文在初始化的时候会建立自己的IoC上下文，用以持有spring mvc相关的bean。在建立DispatcherServlet自己的IoC上下文时，会利用WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE先从ServletContext中获取之前的根上下文(即WebApplicationContext)作为自己上下文的parent上下文。有了这个parent上下文之后，再初始化自己持有的上下文。这个DispatcherServlet初始化自己上下文的工作在其initStrategies方法中可以看到，大概的工作就是初始化处理器映射、视图解析等。这个servlet自己持有的上下文默认实现类也是mlWebApplicationContext。初始化完毕后，spring以与servlet的名字相关(此处不是简单的以servlet名为Key，而是通过一些转换，具体可自行查看源码)的属性为属性Key，也将其存到ServletContext中，以便后续使用。这样每个servlet就持有自己的上下文，即拥有自己独立的bean空间，同时各个servlet共享相同的bean，即根上下文(第2步中初始化的上下文)定义的那些bean。

 

    23: Spring启动生命周期 

 

 

    24: Spring注解@Resource和@Autowired区别对比  => 优先级不一样

1、@Autowired与@Resource都可以用来装配bean. 都可以写在字段上,或写在setter方法上。 

2、@Autowired默认按类型装配（这个注解属于Spring），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用，如下： 

@Autowired() @Qualifier("baseDao")     

private BaseDao baseDao;    

 3、@Resource（这个注解属于J2EE），默认按照名称进行装配，名称可以通过name属性进行指定， 

如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。 当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

@Resource(name="baseDao")     

private BaseDao baseDao;    

 

我喜欢用 @Resource注解在字段上，且这个注解是属于J2EE的，减少了与spring的耦合。最重要的这样代码看起就比较优雅。

 

 

    25: spring @service @controller @componet 三者区别

@controller用来定义控制层的组件 

         @service用来定义业务层的组件

         @repository用来定义持久层的组件

         @ component用来定义不在上述范围内的一般性组件

上面组件的名称默认是类名的首字母小写，如果要重命名，则这样@controller("beanName")

当在spring中配置了<context:annotation-config/> 和<context:component-scan base-package="*">时，上述四种注解的组件都会由spring容器来创建为bean并由自己来管理.

 

那么创建了上面这些组件后，又是如何来注入的呢，这时就由@autowired来配置了。

只需要在private的属性上加上@autowired就可以自动把接口属性的实现类的bean注入，注意不需要setter,getter方法

 

上面如果一个接口属性有两个实现类，怎么办，这时就要用@qualifier来特别说明要注入哪个bean了。

    26: Http和Https协议有什么区别，证书了解不

HTTPS和HTTP的区别：

https协议需要到ca申请证书，一般免费证书很少，需要交费。

http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议

http和https使用的是完全不同的连接方式用的端口也不一样,前者是80,后者是443。

http的连接很简单,是无状态的

HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议 要比http协议安全

 

通俗来讲：

HTTPS是经过加密的，在通信过程中，他人无法截获你们之间的通信信息。

需要证书才能访问

是一串身份信息按照指定的格式排列后，包含证书颁发机构进行数字签名的数据。常见的数字证书格式X.509 V3，存储到文件上一般一种为不含私钥的DER格式，以cer或者crt为文件后缀名，另一种为包含私钥的PKCS格式，以pfx或者p12为后缀。

数字证书中包括（不是全部）：

（1）数字证书持有者身份信息 网站就包括所对应的URL或IP

（2）该证书拥有者对应的该证书公钥

（3）证书颁发者信息

（4）证书颁发者用私钥对证书持有者身份信息和公钥的签名 使用的摘要和签名算法

 

    27: 介绍下Redis设计实现

Redis是基于内存、可持久化的日志型、Key-Value数据库 高性能存储系统，

 

  

 

    28: Redis的细节源码看过没有

1. 支持5种数据结构

支持strings, hashes, lists, sets, sorted sets 

string是很好的存储方式，用来做计数存储。sets用于建立索引库非常棒；

2. K-V 存储 vs K-V 缓存

新浪微博目前使用的98%都是持久化的应用，2%的是缓存，用到了600+服务器 

Redis中持久化的应用和非持久化的方式不会差别很大： 

非持久化的为8-9万tps，那么持久化在7-8万tps左右； 

当使用持久化时，需要考虑到持久化和写性能的配比，也就是要考虑redis使用的内存大小和硬盘写的速率的比例计算；

3. 社区活跃

Redis目前有3万多行代码, 代码写的精简，有很多巧妙的实现，作者有技术洁癖 

Redis的社区活跃度很高，这是衡量开源软件质量的重要指标，开源软件的初期一般都没有商业技术服务支持，如果没有活跃社区做支撑，一旦发生问题都无处求救；

Redis基本原理

redis持久化(aof) append online file： 

写log(aof), 到一定程度再和内存合并. 追加再追加, 顺序写磁盘, 对性能影响非常小

1. 单实例单进程

Redis使用的是单进程，所以在配置时，一个实例只会用到一个CPU； 

在配置时，如果需要让CPU使用率最大化，可以配置Redis实例数对应CPU数, Redis实例数对应端口数(8核Cpu, 8个实例, 8个端口), 以提高并发: 

单机测试时, 单条数据在200字节, 测试的结果为8~9万tps；

2. Replication

过程: 数据写到master–>master存储到slave的rdb中–>slave加载rdb到内存。 

存储点(save point): 当网络中断了, 连上之后, 继续传. 

Master-slave下第一次同步是全传，后面是增量同步；、

3. 数据一致性

长期运行后多个结点之间存在不一致的可能性； 

开发两个工具程序： 

1.对于数据量大的数据，会周期性的全量检查； 

2.实时的检查增量数据，是否具有一致性；

对于主库未及时同步从库导致的不一致，称之为延时问题； 

对于一致性要求不是那么严格的场景，我们只需要要保证最终一致性即可； 

对于延时问题，需要根据业务场景特点分析，从应用层面增加策略来解决这个问题； 

例如： 

1.新注册的用户，必须先查询主库； 

2.注册成功之后，需要等待3s之后跳转，后台此时就是在做数据同步。

    29: Redis分布式缓存

1.架构设计

由于redis是单点，项目中需要使用，必须自己实现分布式。基本架构图如下所示：

 

 

2.分布式实现

通过key做一致性哈希，实现key对应redis结点的分布。

一致性哈希的实现：

l        hash值计算：通过支持MD5与MurmurHash两种计算方式，默认是采用MurmurHash，高效的hash计算。

l        一致性的实现：通过java的TreeMap来模拟环状结构，实现均匀分布

3.client的选择

对于jedis修改的主要是分区模块的修改，使其支持了跟据BufferKey进行分区，跟据不同的redis结点信息，可以初始化不同的ShardInfo，同时也修改了JedisPool的底层实现，使其连接pool池支持跟据key,value的构造方法，跟据不同ShardInfos，创建不同的jedis连接客户端，达到分区的效果，供应用层调用

4.模块的说明

l        脏数据处理模块，处理失败执行的缓存操作。

l        屏蔽监控模块，对于jedis操作的异常监控，当某结点出现异常可控制redis结点的切除等操作。

整个分布式模块通过hornetq，来切除异常redis结点。对于新结点的增加，也可以通过reload方法实现增加。（此模块对于新增结点也可以很方便实现）

对于以上分布式架构的实现满足了项目的需求。另外使用中对于一些比较重要用途的缓存数据可以单独设置一些redis结点，设定特定的优先级。另外对于缓存接口的设计，也可以跟据需求，实现基本接口与一些特殊逻辑接口。对于cas相关操作，以及一些事物操作可以通过其watch机制来实现。（参考我以前写的redis事物介绍）

    30: 线程在频繁的Full GC 怎么排查

我们知道Full GC的触发条件大致情况有以下几种情况： 

1. 程序执行了System.gc() //建议jvm执行fullgc，并不一定会执行 

2. 执行了jmap -histo:live pid命令 //这个会立即触发fullgc 

3. 在执行minor gc的时候进行的一系列检查

a、执行Minor GC的时候，JVM会检查老年代中最大连续可用空间是否大于了当前新生代所有对象的总大小。 b、如果大于，则直接执行Minor GC（这个时候执行是没有风险的）。 c、如果小于了，JVM会检查是否开启了空间分配担保机制，如果没有开启则直接改为执行Full GC。 d、如果开启了，则JVM会检查老年代中最大连续可用空间是否大于了历次晋升到老年代中的平均大小，如果小于则执行改为执行Full GC。 e、如果大于则会执行Minor GC，如果Minor GC执行失败则会执行Full GC

a、使用了大对象 //大对象会直接进入老年代

b、在程序中长期持有了对象的引用 //对象年龄达到指定阈值也会进入老年代

对于我们的情况，可以初步排除a，b两种情况，最有可能是d和e这两种情况。为了进一步排查原因，我们在线上开启了 -XX:+HeapDumpBeforeFullGC。

JVM在执行dump操作的时候是会发生stop the word事件的，也就是说此时所有的用户线程都会暂停运行。 为了在此期间也能对外正常提供服务，建议采用分布式部署，并采用合适的负载均衡算法

 

 

1）FULL GC前后Java堆大小有变化；经研究发现是由于Java应用JVM参数XMS设置为默认值，在我们的系统环境下，Hotspot的Xms默认值为50M（-Xms默认是物理内存的1/64）；每次GC时，JVM会根据各种条件调节Java堆的大小，Java堆的取值范围为[Xms, Xmx]。根据以上分析，修改Xms值与Xmx相等，这样就不会因为所使用的Java堆不够用而进行调节，经过测试后发现FULL GC次数从四位数减少至个位数。

 

2）关键词“System”让我想到了System.gc调用，System.gc调用只是建议JVM执行年老代GC，而年老代GC触发FULL GC，JVM会根据系统条件决定是否执行FULL GC，正因为系统条件不好判断，所以很难构造System.gc调用触发FULL GC，几经周折终于成功，当System.gc触发FULL  GC时都会有关键词“（System）”，而　JVM自动触发的FULL GC却不带关键词“（System）”，可以断定是Java应用存在“System.gc”代码。经过本次测试我也发现System.gc的真正含义，通俗言之，“System.gc” 就是FULL GC触发的最后一根稻草。 

 

从本次分析中，我们可以得出如下的经验： 

1）Java应用的jvm参数Xms与Xmx保持一致，避免因所使用的Java堆内存不够导致频繁full gc以及full gc中因动态调节Java堆大小而耗费延长其周期。 

2）建议不要调用System.gc或者Runtime.getRuntime().gc，否则本次调用可能会成为“压死骆驼的最后一根稻草”。当然我们可以通过设置jvm参数禁止这种调用生效，但是除非特别有把握该参数有必要添加，否则不推荐这么设置。

    31: JVM一些工具，jps, jmap

 -v 输出传递给JVM的参数

$> jps -v

23789 BossMain

28802 Jps -Denv.class.path=/data/aoxj/bossbi/twsecurity/java/trustwork140.jar:/data/aoxj/bossbi/twsecurity/java/:/data/aoxj/bossbi/twsecurity/java/twcmcc.jar:/data/aoxj/jdk15/lib/rt.jar:/data/aoxj/jdk15/lib/tools.jar -Dapplication.home=/data/aoxj/jdk15 -Xms8m

23651 Resin -Xss1m -Dresin.home=/data/aoxj/resin -Dserver.root=/data/aoxj/resin -Djava.util.logging.manager=com.caucho.log.LogManagerImpl -Djavax.management.builder.initial=com.caucho.jmx.MBeanServerBuilderImpl

 

jmap

JVM Memory Map命令用于生成heap dump文件，如果不使用这个命令，还可以使用-XX:+HeapDumpOnOutOfMemoryError参数来让虚拟机出现OOM的时候自动生成dump文件。 jmap不仅能生成dump文件，还可以查询finalize执行队列、Java堆和永久代的详细信息，如当前使用率、当前使用的是哪种收集器等。【内存分析】

  

32: 海量日志数据，提取出某日访问百度次数最多的那个IP？

IP的数目还是有限的，最多2^32个，所以可以考虑使用hash将ip直接存入内存，然后进行统计。

　　 首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。注意到IP是32位的，最多有个2^32个IP。同样可以采用映射的方法，比如模1000，把整个大文件映射为1000个小文件，再找出每个小文中出现频率最大的IP（可以采用hash_map进行频率统计，然后再找出频率最大的几个）及相应的频率。然后再在这1000个最大的IP中，找出那个频率最大的IP，即为所求。  

    33:  Java的内存模型

Java内存模