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

    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步：

 

 

CMS收集器的缺点：

 

 

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优点：

 

 

使用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: 线程池几个参数

 

 

线程池任务执行流程：

    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提供了哪些特征：

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

1、IDEA启动 SpringBootApplication

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

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

 

 

spring

 

    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，即为所求。  

   

• HashMap 的基本组成成员

1. /** 
2.  * The table, resized as necessary. Length MUST Always be a power of two. 
3.  */  
4. transient Entry[] table;  
5.   
6. static class Entry<K,V> implements Map.Entry<K,V> {  
7.     final K key;  
8.     V value;  
9.     Entry<K,V> next;  
10.     final int hash;  
11.     ……  
12. }  

• put 方法的具体实现

1. public V put(K key, V value) {  
2.     // HashMap允许存放null键和null值。  
3.     // 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。  
4.     if (key == null)  
5.         return putForNullKey(value);  
6.     // 根据key的keyCode重新计算hash值。  
7.     int hash = hash(key.hashCode());  
8.     // 搜索指定hash值在对应table中的索引。  
9.     int i = indexFor(hash, table.length);  
10.     // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。  
11.     for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
12.         Object k;  
13.         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
14.             V oldValue = e.value;  
15.             e.value = value;  
16.             e.recordAccess(this);  
17.             return oldValue;  
18.         }  
19.     }  
20.     // 如果i索引处的Entry为null，表明此处还没有Entry。  
21.     modCount++;  
22.     // 将key、value添加到i索引处。  
23.     addEntry(hash, key, value, i);  
24.     return null;  
25. }  

• remove 方法的具体实现。

• 为什么时HashMap的容量总是2的n次方？

• 其他一些基本方法的基本介绍

• 什么是红黑树

  1、基于连接与无连接

  2、TCP要求系统资源较多，UDP较少； 

  3、UDP程序结构较简单 

  4、流模式（TCP）与数据报模式(UDP); 

  5、TCP保证数据正确性，UDP可能丢包 

  6、TCP保证数据顺序，UDP不保证 

 

 

简单说，让双方都证实对方能发收。

知道对方能收是因为收到对方的因为收到而发的回应。

具体：

1：A发，B收， B知道A能发

2：B发，A收， A知道B能发收

3：A发，B收， B知道A能收

 

一个线程从被提交（submit）到执行共经历以下流程：

• 线程池判断核心线程池里是的线程是否都在执行任务，如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下一个流程
• 线程池判断工作队列是否已满。如果工作队列没有满，则将新提交的任务储存在这个工作队列里。如果工作队列满了，则进入下一个流程。
• 线程池判断其内部线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已满了，则交给饱和策略来处理这个任务。

 

任务拒接策略？

 有4种内置的实现策略和一个用户自定义拒绝策略。

AbortPolicy       为java线程池默认的阻塞策略，不执行此任务，而且直接抛出一个运行时异常，切记ThreadPoolExecutor.execute需要try catch，否则程序会直接退出。 

DiscardPolicy        直接抛弃，任务不执行，空方法 。

DiscardOldestPolicy   从队 列里面抛弃head的一个任务，并再次execute 此task。

CallerRunsPolicy        在调用execute的线程里面执行此command，会阻塞入口 。 

用户自定义拒绝策略   实现RejectedExecutionHandler，并自己定义策略模式。

 

再次需要注意的是，ThreadPoolExecutor.submit（） 函数，此方法内部调用的execute方法，并把execute执行完后的结果给返回，但如果任务并没有执行的话（被拒绝了），则submit返回的future.get()会一直等到。

future 内部其实还是一个runnable，并把command给封装了下，当command执行完后，future会返回一个值。

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

 

1) 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

2) 线程的划分尺度小于进程，使得多线程程序的并发性高。

3) 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

4) 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

5) 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

  1、ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 （LinkedList是双向链表，有next也有previous）

  2、对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 

  3、对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 

 

HashMap的key和value都允许为空，treeMap的value允许为空。

•  有几种实现方式 ？

        5种  

1.饿汉模式(调用效率高，但是不能延时加载)：

2.懒汉模式(调用效率不高，但是能延时加载)：

3.双重检测锁模式（由于JVM底层模型原因，偶尔会出问题，不建议使用）：

4.静态内部类式（线程安全，调用效率高，可以延时加载）：

5.枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用）：

如何选用：

-单例对象 占用资源少，不需要延时加载，枚举 好于 饿汉

-单例对象 占用资源多，需要延时加载，静态内部类 好于 懒汉式 

 

• 单例模线程安全吗？  

  不安全 。

• 一般如何保证它线程安全 ？  

      double-check 双重检查锁定  。

• 修饰符 volatile  有什么作用 ？

        能保证被它修饰的成员变量可以被多个线程正确的处理。Volatile是轻量级的synchronized，它在多处理器开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。它在某些情况下比synchronized的开销更小

 

 

 

   不是有序的.

 

• 有没有有顺序的Map实现类？ 

有TreeMap和LinkedHashMap。

 

• TreeMap和LinkedHashMap是如何保证它的顺序的？

          LinkedHashMap 是根据元素增加或者访问的先后顺序进行排序，而 TreeMap是基于元素的固有顺序 (由 Comparator 或者 Comparable 确定)。

                                 

 

• 哪个的有序实现比较好？

      TreeMap TreeMap则实现了 SortedMap 接口。          

• 你觉得还有没有比它更好或者更高效的实现方式？

           参照TreeMap的value排序，我们一样的也可以实现HashMap的排序。

 

 

栅栏（Java的并发包中的CyclicBarrier）  CountDownLatch  CyclicBarrier  Semaphore

• CountDownLatch (N个线程数量count减为0 主程序或一组程序开始执行)

        CountDownLatch是一个计数器闭锁，主要的功能就是通过await()方法来阻塞住当前线程，然后等待计数器减少到0了，再唤起这些线程继续执行。 

        这个类里主要有两个方法，一个是向下减计数器的方法:countdown()，如果取得当前的状态为0,说明这个锁已经结束，直接返回false;

        如果没有结束，然后去设置计数器减1,如果compareAndSetState不成功，则继续循环执行。 而其中的一直等待计数器归零的方法是await()。 

• CyclicBarrier(N个线程，他们之间任何一个没有完成，所有的线程都必须等待) 

        CyclicBarrier是加计数方式，计数达到构造方法中参数指定的值时释放所有等待的线程。

• Semaphore(Semaphore 是只允许一定数量的线程同时执行一段任务。)

你知道它的实现原理吗？

继续问，你还知道其它的实现方式吗？

 

继续问，你觉得这些方式里哪个方式更好？

 

如果让你来写的话，你觉得还有比它更好的实现方式吗？

 

• NIO模型 其中的selector 职责和实现原理

传统的socket IO中，需要为每个连接创建一个线程，当并发的连接数量非常巨大时，线程所占用的栈内存和CPU线程切换的开销将非常巨大。使用NIO，不再需要为每个线程创建单独的线程，可以用一个含有限数量线程的线程池，甚至一个线程来为任意数量的连接服务。由于线程数量小于连接数量，所以每个线程进行IO操作时就不能阻塞，如果阻塞的话，有些连接就得不到处理，NIO提供了这种非阻塞的能力。

1、增加了一个角色，要有一个专门负责收集客人需求的人。NIO里对应的就是Selector。

2、由阻塞服务方式改为非阻塞服务了，客人吃着的时候服务员不用一直侯在客人旁边了。传统的IO操作，比如read()，当没有数据可读的时候，线程一直阻塞被占用，直到数据到来。NIO中没有数据可读时，read()会立即返回0，线程不会阻塞。

     NIO中，客户端创建一个连接后，先要将连接注册到Selector，相当于客人进入餐厅后，告诉前台你要用餐，前台会告诉你你的桌号是几号，然后你就可能到那张桌子坐下了，SelectionKey就是桌号。当某一桌需要服务时，前台就记录哪一桌需要什么服务，比如1号桌要点菜，2号桌要结帐，服务员从前台取一条记录，根据记录提供服务，完了再来取下一条。这样服务的时间就被最有效的利用起来了。

• NIO的核心是什么 （Selector）

Selector类是NIO的核心类，Selector能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的响应处理。这样一来，只是用一个单线程就可以管理多个通道，也就是管理多个连接。这样使得只有在连接真正有读写事件发生时，才会调用函数来进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，并且避免了多线程之间的上下文切换导致的开销。

 

    

着重说一下虚拟机栈中的局部变量表，里面存放了三个信息：

• 各种基本数据类型（boolean、byte、char、short、int、float、long、double）
• 对象引用（reference）
• returnAddress地址

• 为什么新生代要分出两个survivor区？

• java中垃圾回收机制？

 

• 垃圾回收算法概述

把堆均分成两个大小相同的区域，只使用其中的一个区域，直到该区域消耗完。此时垃圾回收器终端程序的执行，通过遍历把所有活动的对象复制到另一个区域，复制过程中它们是紧挨着布置的，这样也可以达到消除内存碎片的目的。复制结束后程序会继续运行，直到该区域被用完。 

但是，这种方法有两个缺陷:

对于指定大小的堆，需要两倍大小的内存空间，

需要中断正在执行的程序，降低了执行效率

•     垃圾回收器有哪些？

1. 减少new对象。每次new对象之后，都要开辟新的内存空间。这些对象不被引用之后，还要回收掉。因此，如果最大限度地合理重用对象，或者使用基本数据类型替代对象，都有助于节省内存；
2. 多使用局部变量，减少使用静态变量。局部变量被创建在栈中，存取速度快。静态变量则是在堆内存；
3. 避免使用finalize，该方法会给GC增添很大的负担；
4. 如果是单线程，尽量使用非多线程安全的，因为线程安全来自于同步机制，同步机制会降低性能。例如，单线程程序，能使用HashMap，就不要用HashTable。同理，尽量减少使用synchronized
5. 用移位符号替代乘除号。eg：a*8应该写作a<<3
6. 对于经常反复使用的对象使用缓存；
7. 尽量使用基本类型而不是包装类型，尽量使用一维数组而不是二维数组；
8. 尽量使用final修饰符，final表示不可修改，访问效率高
9. 单线程情况下（或者是针对于局部变量），字符串尽量使用StringBuilder，比StringBuffer要快；
10. String为什么慢？因为String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象。如果不能保证线程安全，尽量使用StringBuffer来连接字符串。这里需要注意的是，StringBuffer的默认缓存容量是16个字符，如果超过16，apend方法调用私有的expandCapacity()方法，来保证足够的缓存容量。因此，如果可以预设StringBuffer的容量，避免append再去扩展容量。如果可以保证线程安全，就是用StringBuilder。

 

删除元素请使用Iterator方式，如果并发操作，需要对Iterator对象加锁。

 

 

     子 List 的元素和原 List 中的后一部分是重合的, 而子 List 还在遍历过程中时, 向原 List 中新增元素, 这样给子 List 的遍历过程造成了干扰甚至困扰, 于是就抛出了并发修改异常将会抛出java.util.ConcurrentModificationException

 

 

15、表单、AJAX提交必须执行CSRF安全过滤。

16、URL外部重定向传入的目标地址必须执行白名单过滤。

 

•  控制反转（Inversion of Control，英文缩写为IOC）;

    ioc就是典型的工厂模式，通过sessionfactory去注入实例。依赖注入    。

  自己实现用什么方式？    反射原理  

其实就是通过解析xml文件，通过反射创建出我们所需要的bean，再将这些bean挨个放到集合中，然后对外提供一个getBean()方法，以便我们获得这bean。

通俗来讲就如同婚姻介绍所，只需要告诉它找个什么样的女朋友，然后婚介就会按照我们的要求，提供一个mm，如果婚介给我们的人选不符合要求，我们就会抛出异常。

 

•  面向切面编程（Aspect Oriented Programming，英文缩写为AOP）

    AOP就是典型的代理模式的体现。 实现拦截器  日志 统一权限校验 。

    spring的IoC容器是spring的核心，spring AOP是spring框架的重要组成部分。

    

 实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码.简单点解释，比方说你想在你的biz层所有类中都加上一个打印‘你好’的功能,这时就可以用aop思想来做.你先写个类写个类方法，方法经实现打印‘你好’,然后Ioc这个类 ref＝“biz.*”让每个类都注入即可实现。

 

丢失更新  用户A把6改成2  用户B把2改成6  则用户A丢失了更新

脏读问题  用户A,B 看到的都是6  用户B把6改为2  则用户A读的值仍然是6

 

 

悲观  屏蔽一切违反数据操作完整性

乐观  只是在提交的时候检查是否违反数据完整性

 

• 复杂sql避免模糊匹配
• 索引问题 唯一索引  和普通索引
• 复杂操作
• 在可以使用UNION ALL的语句里，使用了UNION  
• 字段长度小于5000用varchar，超过用TEXT，独立一张表，用主键来对应。
• 在varchar字段上建立索引时，必须指定索引长度，没必要对全字段建立索引。

 

1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id#，如果传入的值是111,那么解析成sql时的值为order by "111", 如果传入的值是id，则解析成的sql为order by "id". 

        2. $将传入的数据直接显示生成在sql中。如：order by $user_id$，如果传入的值是111,那么解析成sql时的值为order by user_id,  如果传入的值是id，则解析成的sql为order by id. 

        3. #方式能够很大程度防止sql注入。 

        4.$方式无法防止Sql注入。 

        5.$方式一般用于传入数据库对象，例如传入表名.  

        6.一般能用#的就别用$. 

 

 

 

 

 

     HashMap和Hashtable都实现了Map接口，因此很多特性非常相似。但是，他们有以下不同点：

     HashMap允许键和值是null，而Hashtable不允许键或者值是null。

     Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。

     HashMap提供了可供应用迭代的键的集合，因此，HashMap是快速失败的。另一方面，Hashtable提供了对键的列举(Enumeration)。

     一般认为Hashtable是一个遗留的类。

 

 

 

 

ArrayList和LinkedList都实现了List接口，他们有以下的不同点：

 

ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。

 

相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。

 

LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。

 

也可以参考ArrayList vs. LinkedList。 

•     数据库事务的几个特性：

•     数据库事务怎么保证一致性？

•     数据库隔离级别：

•     synchronized和lock区别：

1. Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2. synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
3. Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4. 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5. Lock可以提高多个线程进行读操作的效率。
6. 在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

•     可重入锁与非可重入锁的区别：

AOP 全称 Aspect Oriented Programming，面向切面编程，和 OOP 一样也是一种编程思想。AOP 出现的原因是为了解决 OOP 在处理 侵入性业务上的不足。

代理模式分为静态代理和动态代理两种。

静态代理：通常用于对原有业务逻辑的扩充。创建一个代理类实现和方法相同的方法，通过让代理类持有真实对象，然后在原代码中调用代理类方法，来达到添加我们需要业务逻辑的目的。

动态代理：动态代理底层是使用反射实现的，是在程序运行期间动态的创建接口的实现。

 

1. 速度更快 – 红黑树 

HashMap中的红黑树

HashMap中链长度大于8时采取红黑树的结构存储。

红黑树，除了添加，效率高于链表结构。

2. 代码更少 – Lambda 

• Lambda表达式的基础语法：Java8引入了一个新的操作符“->”，该操作符成为箭头操作符或者Lambda操作符，箭头操作符将Lambda表达式拆分成两部分
• 左侧：Lambda表达式的参数列表 
• 右侧：Lambda表达式中所需执行的功能，即Lambda体。

3. 强大的Stream API – Stream 

一系列流水线式的中间操作。

流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

注意： 

①Stream自己不会存储元素。 

②Stream不会改变源对象。相反，会返回持有新结果的新Stream。 

③Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

 

4. 便于并行 – Parallel 

5. 最大化减少空指针异常 – Optional

6、ConcurrentHashMap

• Jdk1.7时隔壁级别CocnurrentLevel（锁分段机制）默认为16。
• JDK1.8采取了CAS算法
• Jdk1.8没有永久区，取而代之的是MetaSpace元空间，用的是物理内存。

• 强引用

• 软引用(SoftReference)、

• 弱引用（WeakReference）

• 虚引用（PhantomReference）

Netty 是一个基于NIO的客户、服务器端编程框架。

Netty是什么？

1）本质：JBoss做的一个Jar包

2）目的：快速开发高性能、高可靠性的网络服务器和客户端程序

3）优点：提供异步的、事件驱动的网络应用程序框架和工具

通俗的说：一个好使的处理Socket的东东

• Redis有哪些数据结构？

• 使用过Redis分布式锁么，它是什么回事？

• 如果在setnx之后执行expire之前进程意外crash或者要重启维护了，那会怎么样？

• 假如Redis里面有1亿个key，其中有10w个key是以某个固定的已知的前缀开头的，如果将它们全部找出来？

•     如果这个redis正在给线上的业务提供服务，那使用keys指令会有什么问题？

• 使用过Redis做异步队列么，你是怎么用的？

• 可不可以不用sleep呢？

• 能不能生产一次消费多次呢？

•     pub/sub有什么缺点？

• redis如何实现延时队列？

• 如果有大量的key需要设置同一时间过期，一般需要注意什么？

• Redis如何做持久化的？

• 如果突然机器掉电会怎样？

• bgsave的原理是什么？

• Pipeline有什么好处，为什么要用pipeline？

• Redis的同步机制了解么？

• 是否使用过Redis集群，集群的原理是什么？

二者的不同之处：

Exception：

1．可以是可被控制(checked) 或不可控制的(unchecked) 

2．表示一个由程序员导致的错误 

3．应该在应用程序级被处理

 

Error：

1．总是不可控制的(unchecked) 

2．经常用来用于表示系统错误或低层资源的错误 

3．如何可能的话，应该在系统级被捕捉

定义一个模板结构，将具体内容延迟到子类去实现。

解决的问题

• 提高代码复用性 

将相同部分的代码放在抽象的父类中，而将不同的代码放入不同的子类中

• 实现了反向控制 

通过一个父类调用其子类的操作，通过对子类的具体实现扩展不同的行为，实现了反向控制 & 符合“开闭原则”

它是Java世界里最基础的设计原则，它指导我们如何建立一个稳定的、灵活的系统。开闭原则的定义是：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是，对于修改是封闭的。

AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减。

int value使用了volatile关键字，volatile在这里可以做到的作用是使得多个线程可以共享变量

CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。

CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。

CAS的缺点：

1.CPU开销较大

在并发量比较高的情况下，如果许多线程反复尝试更新某一个变量，却又一直更新不成功，循环往复，会给CPU带来很大的压力。

2.不能保证代码块的原子性

CAS机制所保证的只是一个变量的原子性操作，而不能保证整个代码块的原子性。比如需要保证3个变量共同进行原子性的更新，就不得不使用Synchronized了。

3.ABA问题

这是CAS机制最大的问题所在。

• 什么是ABA问题？

 引用原书的话：如果在算法中的节点可以被循环使用，那么在使用“比较并交换”指令就可能出现这种问题，在CAS操作中将判断“V的值是否仍然为A？”，并且如果是的话就继续执行更新操作，在某些算法中，如果V的值首先由A变为B，再由B变为A，那么CAS将会操作成功。

• 怎么避免ABA问题？

Java中提供了AtomicStampedReference和AtomicMarkableReference来解决ABA问题。