JAVA 面试整理

川长思鸟来 2022-03-17 12:22 201阅读 0赞

> 一. 基础知识：

##### 1）集合类：List和Set比较，各自的子类比较（ArrayList，Vector，LinkedList；HashSet，TreeSet）； #####

##### 2）HashMap的底层实现，之后会问ConcurrentHashMap的底层实现； #####

[https://www.cnblogs.com/chengxiao/p/6059914.html][https_www.cnblogs.com_chengxiao_p_6059914.html]

简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。

##### 3）如何实现HashMap顺序存储：可以参考LinkedHashMap的底层实现； #####

##### 4）HashTable和ConcurrentHashMap的区别； #####

##### 5）String,StringBuffer和StringBuilder的区别； #####

运行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String  
　　String最慢的原因：  
　　String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建 之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。  
总结：  
String：适用于少量的字符串操作的情况  
　　StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况（线程不安全）  
　　StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况（线程安全）

##### 6）Object的方法有哪些：比如有wait方法，为什么会有； #####

1．clone方法  
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。  
2．getClass方法  
final方法，获得运行时类型。  
3．toString方法  
该方法用得比较多，一般子类都有覆盖。  
4．finalize方法  
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。  
5．equals方法  
该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。  
6．hashCode方法  
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。  
一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。  
7．wait方法  
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。  
调用该方法后当前线程进入睡眠状态，直到以下事件发生。  
（1）其他线程调用了该对象的notify方法。  
（2）其他线程调用了该对象的notifyAll方法。  
（3）其他线程调用了interrupt中断该线程。  
（4）时间间隔到了。  
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。  
8．notify方法  
该方法唤醒在该对象上等待的某个线程。  
9．notifyAll方法  
该方法唤醒在该对象上等待的所有线程。

##### 7）wait和sleep的区别，必须理解； #####

sleep是线程被调用时，占着cpu去睡觉，其他线程不能占用cpu，os认为该线程正在工作，不会让出系统资源，wait是进入等待池等待，让出系统资源，其他线程可以占用cpu，一般wait不会加时间限制，因为如果wait的线程运行资源不够，再出来也没用，要等待其他线程调用notifyall方法唤醒等待池中的所有线程，才会在进入就绪序列等待os分配系统资源，  
sleep是静态方法，是谁掉的谁去睡觉，就算是在main线程里调用了线程b的sleep方法，实际上还是main去睡觉，想让线程b去睡觉要在b的代码中掉sleep  
sleep(100L)是占用cpu，线程休眠100毫秒，其他进程不能再占用cpu资源，wait（100L）是进入等待池中等待，交出cpu等系统资源供其他进程使用，在这100毫秒中，该线程可以被其他线程notify，但不同的是其他在等待池中的线程不被notify不会出来，但这个线程在等待100毫秒后会自动进入就绪队列等待系统分配资源，换句话说，sleep（100）在100毫秒后肯定会运行，但wait在100毫秒后还有等待os调用分配资源，所以wait100的停止运行时间是不确定的，但至少是100毫秒。

##### 8）JVM的内存结构，JVM的算法； #####

[https://www.cnblogs.com/ityouknow/p/5610232.html][https_www.cnblogs.com_ityouknow_p_5610232.html]  
JVM内存结构主要有三大块：堆内存、方法区和栈。堆内存是JVM中最大的一块由年轻代和老年代组成，而年轻代内存又被分成三部分，Eden空间、From Survivor空间、To Survivor空间,默认情况下年轻代按照8:1:1的比例来分配；  
方法区存储类信息、常量、静态变量等数据，是线程共享的区域，为与Java堆区分，方法区还有一个别名Non-Heap(非堆)；栈又分为java虚拟机栈和本地方法栈主要用于方法的执行。  
Java堆（Heap）  
对于大多数应用来说，Java堆（Java Heap）是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。  
Java堆是垃圾收集器管理的主要区域，因此很多时候也被称做“GC堆”。如果从内存回收的角度看，由于现在收集器基本都是采用的分代收集算法，所以Java堆中还可以细分为：新生代和老年代；再细致一点的有Eden空间、From Survivor空间、To Survivor空间等。  
根据Java虚拟机规范的规定，Java堆可以处于物理上不连续的内存空间中，只要逻辑上是连续的即可，就像我们的磁盘空间一样。在实现时，既可以实现成固定大小的，也可以是可扩展的，不过当前主流的虚拟机都是按照可扩展来实现的（通过-Xmx和-Xms控制）。  
如果在堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError异常。  
方法区（Method Area）  
方法区（Method Area）与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做Non-Heap（非堆），目的应该是与Java堆区分开来。  
对于习惯在HotSpot虚拟机上开发和部署程序的开发者来说，很多人愿意把方法区称为“永久代”（Permanent Generation），本质上两者并不等价，仅仅是因为HotSpot虚拟机的设计团队选择把GC分代收集扩展至方法区，或者说使用永久代来实现方法区而已。  
Java虚拟机规范对这个区域的限制非常宽松，除了和Java堆一样不需要连续的内存和可以选择固定大小或者可扩展外，还可以选择不实现垃圾收集。相对而言，垃圾收集行为在这个区域是比较少出现的，但并非数据进入了方法区就如永久代的名字一样“永久”存在了。这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载，一般来说这个区域的回收“成绩”比较难以令人满意，尤其是类型的卸载，条件相当苛刻，但是这部分区域的回收确实是有必要的。  
根据Java虚拟机规范的规定，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常。  
程序计数器（Program Counter Register）  
程序计数器（Program Counter Register）是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现），字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。  
由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器（对于多核处理器来说是一个内核）只会执行一条线程中的指令。因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间的计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。  
如果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是Natvie方法，这个计数器值则为空（Undefined）。  
此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。  
JVM栈（JVM Stacks）  
与程序计数器一样，Java虚拟机栈（Java Virtual Machine Stacks）也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型：每个方法被执行的时候都会同时创建一个栈帧（Stack Frame）用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。  
局部变量表存放了编译期可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，根据不同的虚拟机实现，它可能是一个指向对象起始地址的引用指针，也可能指向一个代表对象的句柄或者其他与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。  
其中64位长度的long和double类型的数据会占用2个局部变量空间（Slot），其余的数据类型只占用1个。局部变量表所需的内存空间在编译期间完成分配，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是完全确定的，在方法运行期间不会改变局部变量表的大小。  
在Java虚拟机规范中，对这个区域规定了两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；如果虚拟机栈可以动态扩展（当前大部分的Java虚拟机都可动态扩展，只不过Java虚拟机规范中也允许固定长度的虚拟机栈），当扩展时无法申请到足够的内存时会抛出OutOfMemoryError异常。  
本地方法栈（Native Method Stacks）  
本地方法栈（Native Method Stacks）与虚拟机栈所发挥的作用是非常相似的，其区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则是为虚拟机使用到的Native方法服务。虚拟机规范中对本地方法栈中的方法使用的语言、使用方式与数据结构并没有强制规定，因此具体的虚拟机可以自由实现它。甚至有的虚拟机（譬如Sun HotSpot虚拟机）直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一样，本地方法栈区域也会抛出StackOverflowError和OutOfMemoryError异常。

##### 9）强引用，软引用和弱引用的区别； #####

1．强引用  
以前我们使用的大部分引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。  
2、软引用（SoftReference）  
如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。  
3．弱引用（WeakReference）  
如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。  
4．虚引用（PhantomReference）  
“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。  
特别注意，在实际程序设计中一般很少使用弱引用与虚引用，使用软用的情况较多，这是因为软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生。

##### 10）数组在内存中如何分配； #####

##### 11）用过哪些设计模式，手写一个（除单例）； #####

工厂模式  
单例模式  
工厂方法模式  
代理设计模式  
模板方法模式

##### 12）springmvc的核心是什么，请求的流程是怎么处理的，控制反转怎么实现的； #####

AOP（面向切片）:  
1 首先用户发送请求到前端控制器DispatcherServlet，也是springmvc的核心控制器，前端控制器收到请求后自己 不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；  
2 DispatcherServlet调用HandlerMapping，HandlerMapping将会把请求映射为HandlerExecutionChain对象（包 含一个Handler处理器对象，也就是Controller层，多个 HandlerInterceptor拦截器）返回给DispatcherServlet；  
3 DispatcherServlet根据得到的Handler，调用合适的HandlerAdapter，HandlerAdapter将会把处理器（Handler） 包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器。  
4 HandlerAdapter会根据适配的结果调用真正的处理器(Handler)完成请求处理，并向DispatcherServlet返回一个ModelAndView对象。  
5 根据返回的ModelAndView选择一个适合的ViewResolver（视图解析器）返回给DispatcherServlet  
6 ViewResolver根据view 和 model 渲染视图  
7 将渲染结果返回给客户端。  
IOC（控制反转）:  
控制反转如何实现：  
我们每次使用spring框架都要配置xml文件，这个xml配置了bean的id和class。  
spring中默认的bean为单实例模式，通过bean的class引用反射机制可以创建这个实例。  
因此，spring框架通过反射替我们创建好了实例并且替我们维护他们。  
A需要引用B类，spring框架就会通过xml把B实例的引用传给了A的成员变量。

##### 13）spring里面的aop的原理是什么； #####

[https://www.jianshu.com/p/22e39a3ed932][https_www.jianshu.com_p_22e39a3ed932]  
Spring AOP的底层都是通过代理来实现的  
一种是基于JDK的动态代理  
一种是基于CgLIB的动态代理  
SpringMVC中的常用注解及其作用  
@RequestMapping 请求和方法映射  
@RequestBody 接收客户端传入的Json数据  
@ResponseBody 返回客户端Json数据  
@Controller 标识控制层  
@Service 标识业务层  
@Repository 标识数据层  
@Component 把Bean添加到Spring容器中  
@Autowired 按照类型自动注入  
@Resource 自定义注入，可以按照类型注入，也可以按照名字注入  
@PathVariable RESTful风格时使用获取参数  
@Param 表单参数和方法形参不一样时使用

##### 14）mybatis如何处理结果集：反射，建议看看源码； #####

##### 15）java的多态表现在哪里； #####

方法重载：同一个类中，方法名相同，参数列表不同的2个或多个方法构成方法的重载。  
方法覆盖：子类重新实现了父类中的方法。

##### 16）接口有什么用； #####

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。  
接口作用如下：  
1、丰富Java面向对象的思想：在Java语言中， abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。  
2、提供简单、规范性：如果一个项目比较庞大，那么就需要一个能理清所有业务的架构师来定义一些主要的接口，这些接口不仅告诉开发人员你需要实现那些业务，而且也将命名规范限制住了（防止一些开发人员随便命名导致别的程序员无法看明白）。  
3、提高维护、拓展性：比如你要做一个画板程序，其中里面有一个面板类，主要负责绘画功能，然后你就这样定义了这个类，可是在不久将来，你突然发现这个类满足不了你了，然后你又要重新设计这个类，更糟糕是你可能要放弃这个类，那么其他地方可能有引用他，这样修改起来很麻烦，如果你一开始定义一个接口，把绘制功能放在接口里，然后定义类时实现这个接口，然后你只要用这个接口去引用实现它的类就行了，以后要换的话只不过是引用另一个类而已，这样就达到维护、拓展的方便性。  
4、增强安全、严密性：接口是实现软件松耦合的重要手段，它描叙了系统对外的所有服务，而不涉及任何具体的实现细节。这样就比较安全、严密一些(一般软件服务商考虑的比较多)。

##### 17）说说http,https协议； #####

Http协议与https协议区别：  
1：https协议需要到ca申请证书，一般免费的证书比较少，一般都需要交费  
2：http是超文本传输，信息是文明 传输，https则具备有安全性的ssl加密传输协议。  
3：http和https使用的是完全不同的连接方式用的端口 也不一样，前者是80后者是443  
4：http的连接很简单，是无状态的。  
5：https协议是 有ssl+http协议构建的可进行加密传输，身份认证的网络协议，要比http协议安全  
故：http+加密+认证+完整性保护=https  
为什么用http比https多：  
其中一个主要原因是，因为与纯文本通信相比，加密通信会消耗更多的cup以及内存资源。除此，要进行https通信，证书是必不可少的。而是用证书必须向认证机构（CA）购买。

##### 18）tcp/ip协议簇； #####

##### 19）osi五层网络协议； #####

1、物理层：  
主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。 　　  
2、数据链路层：  
定义了如何让格式化数据以进行传输，以及如何让控制对物理介质的访问。这一层通常还提供错误检测和纠正，以确保数据的可靠传输。 　　  
3、网络层：  
在位于不同地理位置的网络中的两个主机系统之间提供连接和路径选择。Internet的发展使得从世界各站点访问信息的用户数大大增加，而网络层正是管理这种连接的层。 　　  
4、运输层：  
定义了一些传输数据的协议和端口号（WWW端口80等），如：  
TCP（transmission control protocol –传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据）  
UDP（user datagram protocol–用户数据报协议，与TCP特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如QQ聊天数据就是通过这种方式传输的）。 主要是将从下层接收的数据进行分段和传输，到达目的地址后再进行重组。常常把这一层数据叫做段。 　　  
5、会话层：  
通过运输层（端口号：传输端口与接收端口）建立数据传输的通路。主要在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是IP也可以是MAC或者是主机名） 　　  
6、表示层：  
可确保一个系统的应用层所发送的信息可以被另一个系统的应用层读取。例如，PC程序与另一台计算机进行通信，其中一台计算机使用扩展二一十进制交换码（EBCDIC），而另一台则使用美国信息交换标准码（ASCII）来表示相同的字符。如有必要，表示层会通过使用一种通格式来实现多种数据格式之间的转换。 　　  
7、应用层：  
是最靠近用户的OSI层。这一层为用户的应用程序（例如电子邮件、文件传输和终端仿真）提供网络服务。

##### 20）tcp，udp区别； #####

TCP的优点： 可靠，稳定 TCP的可靠体现在TCP在传递数据之前，会有三次握手来建立连接，而且在数据传递时，有确认、窗口、重传、拥塞控制机制，在数据传完后，还会断开连接用来节约系统资源。 TCP的缺点： 慢，效率低，占用系统资源高，易被攻击 TCP在传递数据之前，要先建连接，这会消耗时间，而且在数据传递时，确认机制、重传机制、拥塞控制机制等都会消耗大量的时间，而且要在每台设备上维护所有的传输连接，事实上，每个连接都会占用系统的CPU、内存等硬件资源。 而且，因为TCP有确认机制、三次握手机制，这些也导致TCP容易被人利用，实现DOS、DDOS、CC等攻击。  
UDP的优点： 快，比TCP稍安全 UDP没有TCP的握手、确认、窗口、重传、拥塞控制等机制，UDP是一个无状态的传输协议，所以它在传递数据时非常快。没有TCP的这些机制，UDP较TCP被攻击者利用的漏洞就要少一些。但UDP也是无法避免攻击的，比如：UDP Flood攻击…… UDP的缺点： 不可靠，不稳定 因为UDP没有TCP那些可靠的机制，在数据传递时，如果网络质量不好，就会很容易丢包。 基于上面的优缺点，那么： 什么时候应该使用TCP： 当对网络通讯质量有要求的时候，比如：整个数据要准确无误的传递给对方，这往往用于一些要求可靠的应用，比如HTTP、HTTPS、FTP等传输文件的协议，POP、SMTP等邮件传输的协议。 在日常生活中，常见使用TCP协议的应用如下： 浏览器，用的HTTP FlashFXP，用的FTP Outlook，用的POP、SMTP Putty，用的Telnet、SSH QQ文件传输 ………… 什么时候应该使用UDP： 当对网络通讯质量要求不高的时候，要求网络通讯速度能尽量的快，这时就可以使用UDP。 比如，日常生活中，常见使用UDP协议的应用如下： QQ语音 QQ视频 TFTP ……  
有些应用场景对可靠性要求不高会用到UPD，比如长视频，要求速率

TCP与UDP区别总结：  
1、TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接  
2、TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付  
3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的  
UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）  
4、每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信  
5、TCP首部开销20字节;UDP的首部开销小，只有8个字节  
6、TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道

##### 21）用过哪些加密算法：对称加密，非对称加密算法； #####

对称加密：双方使用的同一个密钥，既可以加密又可以解密，这种加密方法称为对称加密，也称为单密钥加密。  
优点：速度快，对称性加密通常在消息发送方需要加密大量数据时使用，算法公开、计算量小、加密速度快、加密效率高。  
缺点：在数据传送前，发送方和接收方必须商定好秘钥，然后 使双方都能保存好秘钥。其次如果一方的秘钥被泄露，那么加密信息也就不安全了。另外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的唯一秘 钥，这会使得收、发双方所拥有的钥匙数量巨大，密钥管理成为双方的负担。  
在对称加密算法中常用的算法有：DES、AES等。  
AES：密钥的长度可以为128、192和256位，也就是16个字节、24个字节和32个字节  
DES：密钥的长度64位，8个字节。  
非对称加密：一对密钥由公钥和私钥组成（可以使用很多对密钥）。私钥解密公钥加密数据，公钥解密私钥加密数据（私钥公钥可以互相加密解密）。  
私钥只能由一方保管，不能外泄。公钥可以交给任何请求方。  
在非对称加密算法中常用的算法有：  
RSA、Elgamal、背包算法、Rabin、Diffie-Hellman、ECC（椭圆曲线加密算法）。  
使用最广泛的是RSA算法，Elgamal是另一种常用的非对称加密算法。  
缺点：速度较慢  
优点：安全

常见加密算法 ：  
DES（Data Encryption Standard）：数据加密标准，速度较快，适用于加密大量数据的场合；  
3DES（Triple DES）：是基于DES，对一块数据用三个不同的密钥进行三次加密，强度更高；  
RC2和 RC4：用变长密钥对大量数据进行加密，比 DES 快；  
IDEA（International Data Encryption Algorithm）国际数据加密算法：使用 128 位密钥提供非常强的安全性；  
RSA：由 RSA 公司发明，是一个支持变长密钥的公共密钥算法，需要加密的文件块的长度也是可变的；  
DSA（Digital Signature Algorithm）：数字签名算法，是一种标准的 DSS（数字签名标准）；  
AES（Advanced Encryption Standard）：高级加密标准，是下一代的加密算法标准，速度快，安全级别高，目前 AES 标准的一个实现是 Rijndael 算法；  
BLOWFISH，它使用变长的密钥，长度可达448位，运行速度很快；

##### 22）说说tcp三次握手，四次挥手； #####

三次握手流程　  
1、第一次握手：客户端向服务器端发送连接请求包SYN=1（seq=x），等待服务器回应；  
2、第二次握手：服务器端收到请求包后，将客户端的请求包SYN=1（seq=x）放入到自己的未连接队列，此时服务器需要发送两个包给客户端:  
　　（1）向客户端发送确认自己收到其连接请求的确认包ACK=1（ack=x+1），向客户端表明已知道了其连接请求  
　　（2）向客户端发送连接询问请求包SYN=1（seq=y），询问客户端是否已经准备好建立连接，进行数据通信；  
此时服务器进入SYN\_RECV状态。  
3、第三次握手：客户端收到服务器的包后，知道服务器同意建立连接；向服务器发送连接建立的确认包ACK=1（ack=y+1），回应服务器的SYN（seq=y）告诉服务器，我们之间已经建立了连接，可以进行数据通信。  
ACK=1（ack=y+1）包发送完毕，服务器收到后，此时服务器与客户端进入ESTABLISHED状态，开始进行数据传送。  
为什么要三次握手？  
握手的过程实际上是在通知对方自己的初始化序号(Initial Sequence Number)，简称ISN，也就是上图中的x和y。x和y会被当作之后传输数据的一个依据，以保证TCP报文在传输过程中不会混乱。  
解决两个问题：  
1、避免连接请求的数据包丢失  
假设连接途中，客户端网络不稳定出现丢包，服务端根据seq=x来确定客户端请求到第几个包。然后告诉客户端你从第seq=x个包开始发送给我，之前的不用发送了，我这里有记录了。  
2、数据传输过程因为网络并发量很大在某结点被阻塞  
传输过程因为网络并发量很大在某结点被阻塞了，Server端将先后收到2次请求，并持续等待两个Client请求向他发送数据，但是Cient端实际上只有一次请求，而Server端却有2个响应，极端的情况可能由于Client端多次重新发送请求数据而导致Server端最后建立了N多个响应在等待，因而造成极大的资源浪费！  
三次握手的seq与ack确定了包的顺序。客户端每次请求时，询问服务端说这是第一号包，服务端收到后告诉客服端下次你给我的只能是二号包（别的都不要），同时给返回到客户端的包作标记：这是我返回给你的一号包。这样，出现阻塞时，根据包的序号就知道要响应的是几号包。

(1)Client向Server发送断开连接请求的报文段，seq=m(m为Client最后一次向Server发送报文段的最后一个字节序号加1)，Client进入FIN-WAIT-1状态。  
(2)Server收到断开报文段后，向Client发送确认报文段，seq=n(n为Server最后一次向Client发送报文段的最后一个字节序号加1)，ack=m+1，Server进入CLOSE-WAIT状态。此时这个TCP连接处于半开半闭状态，Server发送数据的话，Client仍然可以接收到。  
(3)Server向Client发送断开确认报文段，seq=u(u为半开半闭状态下Server最后一次向Client发送报文段的最后一个字节序号加1)，ack=m+1，Server进入LAST-ACK状态。  
(4)Client收到Server的断开确认报文段后，向Server发送确认断开报文，seq=m+1，ack=u+1，Client进入TIME-WAIT状态。  
(5)Server收到Client的确认断开报文，进入CLOSED状态，断开了TCP连接。  
(6)Client在TIME-WAIT状态等待一段时间(时间为2\*MSL((Maximum Segment Life))，确认Client向Server发送的最后一次断开确认到达(如果没有到达，Server会重发步骤(3)中的断开确认报文段给Client，告诉Client你的最后一次确认断开没有收到)。如果Client在TIME-WAIT过程中没有再次收到Server的报文段，就进入CLOSES状态。TCP连接至此断开。  
为什么要四次挥手？  
tcp关闭连接需要四次握手原因：TCP连接是全双工通道，需要双向关闭。  
client向server发送关闭请求，表示client不再发送数据，server响应。此时server端仍然可以向client发送数据，待server端发送数据结束后，就向client发送关闭请求，然后client确认。

##### 23）cookie和session的区别，分布式环境怎么保存用户状态； #####

1、session保存在服务器，客户端不知道其中的信息；cookie保存在客户端，服务器能够知道其中的信息。  
2、session中保存的是对象，cookie中保存的是字符串。  
3、session不能区分路径，同一个用户在访问一个网站期间，所有的session在任何一个地方都可以访问到。而cookie中如果设置了路径参数，那么同一个网站中不同路径下的cookie互相是访问不到的。  
4、session需要借助cookie才能正常。如果客户端完全禁止cookie，session将失效。  
分布式Session的几种实现方式  
1 .基于数据库的Session共享  
2 .基于NFS共享文件系统  
3 .基于memcached 的session，如何保证 memcached 本身的高可用性？  
4 . 基于resin/tomcat web容器本身的session复制机制  
5 . 基于TT/Redis 或 jbosscache 进行 session 共享。  
6 . 基于cookie 进行session共享

##### 24）git，svn区别； #####

Git优点：  
1、分布式，每个参与开发的人的电脑上都有一个完整的仓库，不担心硬盘出问题；  
2、在不联网的情况下，照样可以提交到本地仓库，可以查看以往的所有log，等到有网的时候，push到远程即可；  
3、非常强大的分支管理功能。  
4、Git的内容的完整性要优于SVN: GIT的内容存储使用的是SHA-1哈希算法。这能确保代码内容的完整性，确保在遇到磁盘故障和网络问题时降低对版本库的破坏。  
Git缺点：  
权限管理不是很方便，需要安装插件gitolite，配置有点麻烦，或者直接使用gitlab管理。  
SVN优点  
1、较好的权限管理功能，可以精确控制每个目录的权限；  
2、使用相对git要简单一点。  
SVN缺点  
1、集中式，如果中心服务器出现问题，所有人都不能正常干活，恢复也很麻烦，因为SVN记录的是每次改动的差异，不是完整文件；  
2、分支功能没有git强大；  
3、速度没有git快，如果有五个分支，是把五个分支的文件全部拷下来；  
4、必须联网才能commit。

##### 25）请写一段栈溢出、堆溢出的代码； #####

首先要搞清楚堆栈里放的什么东西：  
栈存储运行时声明的变量——对象引用（或基础类型, primitive）内存空间，堆分配每一个对象内容（实例）内存空间。  
一个变量可以先后指向多个对象实例；数组、链表等可以存放对多个实例对象内容的引用关系。没有引用关系的对象内容按说被虚拟机回收（recycled，destroy，在C++叫delete，在C叫free）。 栈的实现是先入后出的， 相似的集装箱那种货舱。 堆是随机存放的， 相似于现在的停车场。 记得曾经，有一本游戏的外国书， 说游戏要分配好栈空间和堆空间； 在开始时候分配固定容量的空间， 有不同的自顶向下和从下向上的地址空间分配。  
stackoverflow ， 总是在无限递归调用时候可以看见（google也经常有同名网站的结果）。  
堆内存满， 可以通过无限new实现。

在JAVA中，可以使用关键字new来创建Java对象。例如，  
ArrayList list = new ArrayList();  
实际上，在创建完上面的一个对象后，在JVM中，会把new出来的对象存放在堆内存中，  
同时，在方法栈中存放着对象的引用关系。  
如果想要堆溢出，比较简单，可以循环创建对象或大的对象；  
如果想要栈溢出，可以递归调用方法，这样随着栈深度的增加，JVM 维持着一条长长的方法调用轨迹，  
直到内存不够分配，产生栈溢出。  
因此，可以使用下面简单的代码实现堆溢出和栈溢出。

另外，Java虚拟机的堆大小如何设置：命令行  
　java –Xms128m //JVM占用最小内存  
–Xmx512m //JVM占用最大内存  
–XX:PermSize=64m //最小堆大小  
–XX:MaxPermSize=128m //最大堆大小

##### 26）ThreadLocal可以用来共享数据吗； #####

ThreadLocal说明：Threadlocal是用来解决线程安全问题的。每个线程持有一个隐含的Thread-local变量的引用，Threadlocal 是存在于线程栈中的。只要线程是活的，那么ThreadLocal的实例就是可以获得的，当线程死了，所有线程所持有的Thread-local的实例成为垃圾回收的目标。所以不需要担心ThreadLocal变量销毁的问题。

> 二. IO:

##### 1）bio，nio，aio的区别； #####

Java BIO ： 同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。  
Java NIO ： 同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。  
Java AIO： 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。  
NIO比BIO的改善之处是把一些无效的连接挡在了启动线程之前，减少了这部分资源的浪费（因为我们都知道每创建一个线程，就要为这个线程分配一定的内存空间）  
AIO比NIO的进一步改善之处是将一些暂时可能无效的请求挡在了启动线程之前，比如在NIO的处理方式中，当一个请求来的话，开启线程进行处理，但这个请求所需要的资源还没有就绪，此时必须等待后端的应用资源，这时线程就被阻塞了。  
适用场景分析：  
BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解，如之前在Apache中使用。  
NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持，如在 Nginx，Netty中使用。  
AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持，在成长中，Netty曾经使用过，后来放弃。

##### 2）nio框架：dubbo的实现原理； #####

client一个线程调用远程接口，生成一个唯一的ID（比如一段随机字符串，UUID等），Dubbo是使用AtomicLong从0开始累计数字的  
将打包的方法调用信息（如调用的接口名称，方法名称，参数值列表等），和处理结果的回调对象callback，全部封装在一起，组成一个对象object  
向专门存放调用信息的全局ConcurrentHashMap里面put(ID, object)  
将ID和打包的方法调用信息封装成一对象connRequest，使用IoSession.write(connRequest)异步发送出去  
当前线程再使用callback的get()方法试图获取远程返回的结果，在get()内部，则使用synchronized获取回调对象callback的锁， 再先检测是否已经获取到结果，如果没有，然后调用callback的wait()方法，释放callback上的锁，让当前线程处于等待状态。  
服务端接收到请求并处理后，将结果（此结果中包含了前面的ID，即回传）发送给客户端，客户端socket连接上专门监听消息的线程收到消息，分析结果，取到ID，再从前面的ConcurrentHashMap里面get(ID)，从而找到callback，将方法调用结果设置到callback对象里。  
监听线程接着使用synchronized获取回调对象callback的锁（因为前面调用过wait()，那个线程已释放callback的锁了），再notifyAll()，唤醒前面处于等待状态的线程继续执行（callback的get()方法继续执行就能拿到调用结果了），至此，整个过程结束。

##### 3）京东内部的jsf是使用的什么协议通讯：可参见dubbo的协议； #####

> 三. 算法：

[https://blog.csdn.net/qq\_38254897/article/details/85717345][https_blog.csdn.net_qq_38254897_article_details_85717345]

##### 1）java中常说的堆和栈，分别是什么数据结构；另外，为什么要分为堆和栈来存储数据。 #####

栈是一种具有后进先出性质的数据结构，也就是说后存放的先取，先存放的后取。  
堆是一种经过排序的树形数据结构，每个结点都有一个值。通常我们所说的堆的数据结构，是指二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。由于堆的这个特性，常用来实现优先队列，堆的存取是随意的。  
为什么要划分堆和栈  
1、从软件设计的角度看，栈代表了处理逻辑，而堆代表了数据。这样分开，使得处理逻辑更为清晰。  
2、堆与栈的分离，使得堆中的内容可以被多个栈共享。一方面这种共享提供了一种有效的数据交互方式(如：共享内存)，另一方面，堆中的共享常量和缓存可以被所有栈访问，节省了空间。  
3、栈因为运行时的需要，比如保存系统运行的上下文，需要进行地址段的划分。由于栈只能向上增长，因此就会限制住栈存储内容的能力。而堆不同，堆中的对象是可以根据需要动态增长的，因此栈和堆的拆分，使得动态增长成为可能，相应栈中只需记录堆中的一个地址即可。  
4、体现了Java面向对象这一核心特点（也可以继续说一些自己的理解）。

每一个JVM实例都为每个新创建的线程分配一个栈，而多个线程共享唯一一个堆区，也就是说,对于一个Java程序来说，它的运行就是通过对栈的操作来完成的。栈以帧为单位保存线程的状态。JVM对栈只进行两种操作:以帧为单位的压栈和出栈操作。当某个线程正在执行某个方法时，我们就称此线程为当前方法，而当前方法使用的帧称为当前帧。当线程要调用一个Java方法时，JVM就会先在线程的Java栈里新压入一个帧。这个帧自然成为了当前帧。在此方法执行期间，这个帧将用来保存方法的形参，局部变量，中间计算过程和其他数据……这个帧在这里和编译原理中的活动纪录的概念是差不多的。

为什么要用线程池  
那先要明白什么是线程池  
线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程。  
使用线程池的好处  
1、线程池改进了一个应用程序的响应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。  
2、线程池节省了CLR 为每个短生存周期任务创建一个完整的线程的开销并可以在任务完成后回收资源。  
3、线程池根据当前在系统中运行的进程来优化线程时间片。  
4、线程池允许我们开启多个任务而不用为每个线程设置属性。  
5、线程池允许我们为正在执行的任务的程序参数传递一个包含状态信息的对象引用。  
6、线程池可以用来解决处理一个特定请求最大线程数量限制问题。

##### 2）TreeMap如何插入数据：二叉树的左旋，右旋，双旋； #####

TreeMap特点  
1、每个节点都只能是红色或者黑色  
2、根节点是黑色  
3、每个叶节点（NIL节点，空节点）是黑色的。  
4、如果一个结点是红的，则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。  
5、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。  
对于排序二叉树的创建，其添加节点的过程如下：  
1、以根节点为初始节点进行检索。  
2、与当前节点进行比对，若新增节点值较大，则以当前节点的右子节点作为新的当前节点。否则以当前节点的左子节点作为新的当前节点。  
3、循环递归2步骤知道检索出合适的叶子节点为止。  
4、将新增节点与3步骤中找到的节点进行比对，如果新增节点较大，则添加为右子节点；否则添加为左子节点。  
左旋：rotateLeft() （右旋反之）  
所谓左旋转，就是将新增节点（N）当做其父节点（P），将其父节点P当做新增节点（N）的左子节点。即：G.left —> N ,N.left —> P。  
左旋

右旋

双旋（先左旋后右旋）

##### 3）一个排序之后的数组，插入数据，可以使用什么方法？答：二分法；问：时间复杂度是多少？ #####

算法：二分法查找适用于数据量较大时，但是数据需要先排好顺序。主要思想是：（设查找的数组区间为array\[low, high\]）  
（1）确定该区间的中间位置K（2）将查找的值T与array\[k\]比较。若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。区域确定如下：a.array\[k\]>T 由数组的有序性可知array\[k,k+1,……,high\]>T;故新的区间为array\[low,……，K-1\]b.array\[k\]<T 类似上面查找区间为array\[k+1,……，high\]。每一次查找与中间值比较，可以确定是否查找成功，不成功当前查找区间将缩小一半，递归查找即可。时间复杂度为:O(log2n)。  
时间复杂度  
1.最坏情况查找最后一个元素（或者第一个元素）Master定理T(n)=T(n/2)+O(1)所以T(n)=O(log2n)  
2.最好情况查找中间元素O(1)查找的元素即为中间元素（奇数长度数列的正中间，偶数长度数列的中间靠左的元素）  
空间复杂度  
S(n)=n

##### 4）平衡二叉树的时间复杂度； #####

平衡二叉树的时间复杂度是log(n)，如果二叉树的元素个数为n，那么不管是对树进行插入节点、查找、删除节点都是log(n)次循环调用就可以了。它的时间复杂度相对于其他数据结构如数组等是最优的。

##### 5）Hash算法和二叉树算法分别什么时候用； #####

##### 6）图的广度优先算法和深度优先算法：详见jvm中垃圾回收实现； #####

[https://www.cnblogs.com/Leo\_wl/p/6251022.html][https_www.cnblogs.com_Leo_wl_p_6251022.html]  
从图的某个顶点出发，访问图中的所有顶点，且使每个顶点仅被访问一次。这一过程叫做图的遍历。  
　　　　深度优先搜索的思想：  
　　　　　　①访问顶点v；  
　　　　　　②依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；  
　　　　　　③若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。  
　　　　比如：

在这里为了区分已经访问过的节点和没有访问过的节点，我们引入一个一维数组bool visited\[MaxVnum\]用来表示与下标对应的顶点是否被访问过，  
流程：  
☐ 首先输出 V1，标记V1的flag=true;  
☐ 获得V1的邻接边 \[V2 V3\],取出V2，标记V2的flag=true;  
☐ 获得V2的邻接边\[V1 V4 V5\],过滤掉已经flag的，取出V4，标记V4的flag=true;  
☐ 获得V4的邻接边\[V2 V8\],过滤掉已经flag的，取出V8，标记V8的flag=true;  
☐ 获得V8的邻接边\[V4 V5\],过滤掉已经flag的，取出V5，标记V5的flag=true;  
☐ 此时发现V5的所有邻接边都已经被flag了，所以需要回溯。（左边黑色虚线，回溯到V1，回溯就是下层递归结束往回返）  
☐

☐ 回溯到V1，在前面取出的是V2，现在取出V3，标记V3的flag=true;  
☐ 获得V3的邻接边\[V1 V6 V7\]，过滤掉已经flag的,取出V6，标记V6的flag=true;  
☐ 获得V6的邻接边\[V3 V7\],过滤掉已经flag的,取出V7，标记V7的flag=true;  
☐ 此时发现V7的所有邻接边都已经被flag了，所以需要回溯。（右边黑色虚线，回溯到V1，回溯就是下层递归结束往回返）

所谓广度，就是一层一层的，向下遍历，层层堵截，还是这幅图，我们如果要是广度优先遍历的话，我们的结果是V1 V2 V3 V4 V5 V6 V7 V8。

广度优先搜索的思想：  
　　① 访问顶点vi ；  
　　② 访问vi 的所有未被访问的邻接点w1 ,w2 , …wk ；  
　　③ 依次从这些邻接点（在步骤②中访问的顶点）出发，访问它们的所有未被访问的邻接点; 依此类推，直到图中所有访问过的顶点的邻接点都被访问；  
说明：  
为实现③，需要保存在步骤②中访问的顶点，而且访问这些顶点的邻接点的顺序为：先保存的顶点，其邻接点先被访问。 这里我们就想到了用标准模板库中的queue队列来实现这种先进现出的服务。  
老规矩我们还是走一边流程：  
说明：　  
☐将V1加入队列，取出V1，并标记为true(即已经访问)，将其邻接点加进入队列，则 < —\[V2 V3\]　  
☐取出V2，并标记为true(即已经访问)，将其未访问过的邻接点加进入队列，则 <—\[V3 V4 V5\]  
☐取出V3，并标记为true(即已经访问)，将其未访问过的邻接点加进入队列，则 <—\[V4 V5 V6 V7\]  
☐取出V4，并标记为true(即已经访问)，将其未访问过的邻接点加进入队列，则 <—\[V5 V6 V7 V8\]  
☐取出V5，并标记为true(即已经访问)，因为其邻接点已经加入队列，则 <—\[V6 V7 V8\]  
☐取出V6，并标记为true(即已经访问)，将其未访问过的邻接点加进入队列，则 <—\[V7 V8\]  
☐取出V7，并标记为true(即已经访问)，将其未访问过的邻接点加进入队列，则 <—\[V8\]  
☐取出V8，并标记为true(即已经访问)，将其未访问过的邻接点加进入队列，则 <—\[\]

> 四. 多线程相关：

##### 1）说说阻塞队列的实现：可以参考ArrayBlockingQueue的底层实现（锁和同步都行）； #####

阻塞队列，重点在于阻塞二字，意思就是支持阻塞插入和阻塞移除的队列。  
阻塞插入：当队列中的元素满了，插入操作线程将阻塞直至队列有空闲空间;  
阻塞移除：当队列中的元素为空，就是指没有元素时，移除操作线程将阻塞直至队列不为空;  
从队细容量的角度划分，队列可分为有界和无界两种，从这个角度来说，对于无界队列，插入的阻塞操作是不会发生了。  
1.ArrayBlockingQueue  
基于数组实现的有界阻塞队列，先进先出（first-in-first-out，简称FIFO）的方式排序，默认情况下不保证线程公平性的访问队列，意思就是说，线程A先阻塞，并不意味着线程A就可以先访问到元素，都是随机的竞争访问。看看下ArrayBlockingQueue的默认构造器就一目了然了

##### 2）进程通讯的方式：消息队列，共享内存，信号量，socket通讯等； #####

消息队列  
共享内存  
共享内存是System V版本的最后一个进程间通信方式。共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常为同一段物理内存。进程可以将同一段物理内存连接到他们自己的地址空间中，所有的进程都可以访问共享内存中的地址。如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。  
特别提醒：共享内存并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前，并无自动机制可以阻止第二个进程开始对它进行读取，所以我们通常需要用其他的机制来同步对共享内存的访问，例如信号量。

信号量  
信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。确认这些信号量VI引用的是初始创建的信号量。  
以一个停车场的运作为例。简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆直接进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入外面的一辆进去，如果又离开两辆，则又可以放入两辆，如此往复。  
在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。  
socket通讯  
什么是TCP/IP、UDP？  
TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，是一个工业标准的协议集，它是为广域网（WANs）设计的。  
UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是属于TCP/IP协议族中的一种。  
这里有一张图，表明了这些协议的关系。

TCP/IP协议族包括运输层、网络层、链路层。现在你知道TCP/IP与UDP的关系了吧。  
Socket在哪里呢？  
在图1中，我们没有看到Socket的影子，那么它到底在哪里呢？还是用图来说话，一目了然。

原来Socket在这里。  
Socket是什么呢？  
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。  
你会使用它们吗？  
前人已经给我们做了好多的事了，网络间的通信也就简单了许多，但毕竟还是有挺多工作要做的。以前听到Socket编程，觉得它是比较高深的编程知识，但是只要弄清Socket编程的工作原理，神秘的面纱也就揭开了。  
一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。 生活中的场景就解释了这工作原理，也许TCP/IP协议族就是诞生于生活中，这也不一定。

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。  
[https://www.cnblogs.com/wangcq/p/3520400.html][https_www.cnblogs.com_wangcq_p_3520400.html]

##### 3）用过并发包的哪些类； #####

1、ConcurrentHashMap  
ConcurrentHashMap其实就是线程安全版本的hashMap。前面我们知道HashMap是以链表的形式存放hash冲突的数据，以数组形式存放HashEntry等hash出来不一致的数据。为了保证容器的数据一致性，需要加锁。HashMap的实现方式是，只有put和remove的时候会引发数据的不一致，那为了保证数据的一致性，我在put和remove的时候进行加锁操作。但是随之而来的是性能问题，因为key-value形式的数据，读写频繁是很正常的，也就意味着我有大量数据做读写操作时会引发长时间的等待。为了解决这个问题，Java并发包问我们提供了新的思路。在每一个HashEntry上加一把锁，对于hash冲突的数据，因为采用链表存储，公用一把锁。这样我才在做不同hash数值的数据时，则是在不同的锁环境下执行，基本上是互不干扰的。在最好情况下，可以保证16个线程同时进行无阻塞的操作（HashMap的默认HashEntry是16，亦即默认的数组大小是16）。  
那ConcurrentHashMap是如何保证数据操作的一致性呢？对于数据元素的大小，ConcurrentHashMap将对应数组（HashEntry的长度）的变量为voliate类型的，也就是任何HashEntry发生变更，所有的地方都会知道数据的大小。对于元素，如何保证我取出的元素的next不发生变更呢？（HashEntry中的数据采用链表存储，当读取数据的时候可能又发生了变更），这一点，ConcurrentHashMap采取了最简单的做法，hash值、key和next取出后都为final类型的，其next等数据永远不会发生变更。  
另外ConcurrentHashMap采用的锁结构是将读和写分开的，大大的提升了性能，下面我们来看一下两者之间的性能差。  
2、CopyOnWriteArrayList  
同样的，CopyOnWriteArrayList是线程安全版本的ArrayList。和ArrayList不同的是，CopyOnWriteArrayList默认是创建了一个大小为0的容器。通过ReentrantLock来保证线程安全。CopyOnWriteArrayList其实每次增加的时候，需要新创建一个比原来容量+1大小的数组，然后拷贝原来的元素到新的数组中，同时将新插入的元素放在最末端。然后切换引用。  
针对CopyOnWriteArrayList，因为每次做插入和删除操作，都需要重新开辟空间和复制数组元素，因此对于插入和删除元素，CopyOnWriteArrayList的性能远远不如ArrayList，但是每次读取的时候，CopyOnWriteArrayList在不加锁的情况下直接锁定数据，会快很多（但是可能会引发脏读），对于迭代，CopyOnWriteArrayList会生成一个快照数组，因此当迭代过程中出现变化，快照数据没有变更，因此读到的数据也是不会变化的。在读多写少的环境下，CopyOnWriteArrayList的性能还是不错的。  
3、CopyOnWriteArraySet  
CopyOnWriteArraySet是基于CopyOnWriteArrayList实现的。但是CopyOnWriteArraySet鉴于不能插入重复数据，因此每次add的时候都要遍历数据，性能略低于CopyOnWriteArrayList。  
4、ArrayBlockingQueue  
ArrayBlockingQueue是基于数组实现的一个线程安全的队列服务，其相关的功能前面我们已经用到过了，这里就不多提了。  
5、Atomic类，如AtomicInteger、AtomicBoolean

##### 4）什么地方用了多线程； #####

1, 多线程的作用:可以解决负载均衡问题,充分利用CPU的资源,为了提高Cpu的使用,采用多线程的方法去同时完成几件事情而互不干扰  
2. 大多数的情况下, 使用多线程 主要是需要处理大量的IO操作或处理的情况需要花大量的时间等;

##### 5）Excutors可以产生哪些线程池； #####

Java通过Executors提供五种线程池，都是直接或间接继承自ThreadPoolExcecutor 线程池类，他们都有特殊功能，如果不是必须用这几个特殊的线程池类，也可以直接new ThreadPoolExcecutor() 线程池来干活，  
这五个特殊的线程池分别为：  
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。  
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。  
newScheduledThreadPool 创建一个定长线程池，支持定时（scheduleWithFixedDelay（）函数的initdelay 参数）及周期（delay 参数）任务执行。  
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。  
newSingleThreadScheduledExecutor 创建一个单线程化的支持定时的线程池，可以用一个线程周期性执行任务(比如周期7天，一次任务才用1小时,使用多线程就会浪费资源

##### 6）为什么要用线程池； #####

1、什么是线程池： java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池  
多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。  
假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。  
如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。  
一个线程池包括以下四个基本组成部分：  
1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；  
2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；  
3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；  
4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。  
线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

##### 7）volatile关键字的用法： #####

volatile关键字的作用是，强制变量每次都读取公共内存，这样，一旦有线程改变变量的值，其他线程马上就能发现。这就是定义里，所有线程可见的含义。

> 五. 数据库相关（mysql）：

##### 1）msyql优化经验： #####

1.尽量用select元素 不要用select \*  
2.不要 ORDER BY RAND()  
3.永远为每张表设置一个ID  
4.少用like 多用=  
5.固定长度的表会更快  
6.表分割：垂直分割和水平分割  
7.采用redis  
8.知道数据条数的时候用Limit  
9.使用enum而不是varchar  
10.尽可能的使用not null，保持数据没有Null值

1、对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。  
2、应尽量避免在 where 子句中使用!=或<>操作符，否则引擎将放弃使用索引而进行全表扫描。  
3、尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。  
4、任何地方都不要使用 select \* from t ，用具体的字段列表代替“\*”，不要返回用不到的任何字段。  
5、避免频繁创建和删除临时表，以减少系统表资源的消耗。诸如此类，等等等等…

##### 2）mysql的语句优化，使用什么工具； #####

##### 3）mysql的索引分类：B+，hash；什么情况用什么索引； #####

B+树是一个平衡的多叉树。B+树从根节点到叶子节点的搜索效率基本相当，不会出现大幅波动。  
哈希索引采用一定的哈希算法，把键值换成新的哈希值，检索时不需要类似B+树那样从根节点逐级查找，只需一次哈希算法即可立刻定位到相应的位置。  
两者的区别：

哈希索引的优势：  
（1）等值查询。哈希索引具有绝对优势（前提是：没有大量重复键值，如果大量重复键值时，哈希索引的效率很低，因为存在所谓的哈希碰撞问题。）  
哈希索引不适用的场景：  
（1）不支持范围查询  
（2）不支持索引完成排序  
（3）不支持联合索引的最左前缀匹配规则  
MySQL中，只有HEAP/MEMORY引擎才显示支持哈希索引。而常用的InnoDB引擎中默认使用的是B+树索引，它会实时监控表上索引的使用情况，如果认为建立哈希索引可以提高查询效率，则自动在内存中的“自适应哈希索引缓冲区”建立哈希索引（在InnoDB中默认开启自适应哈希索引），通过观察搜索模式，MySQL会利用index key的前缀建立哈希索引，如果一个表几乎大部分都在缓冲池中，那么建立一个哈希索引能够加快等值查询。

Hash索引结构的特殊性，其检索效率非常高，索引的检索可以一次定位，不像B+树索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，那为什么大家不都用Hash索引而还要使用B+树索引呢？

1.  Hash索引仅仅能满足"=",“IN"和”<=>"查询，不能使用范围查询。因为经过相应的Hash算法处理之后的Hash值的大小关系，并不能保证和Hash运算前完全一样；
2.  Hash索引无法被用来避免数据的排序操作。因为Hash值的大小关系并不一定和Hash运算前的键值完全一样；
3.  Hash索引不能利用部分索引键查询。对于组合索引，Hash索引在计算Hash值的时候是组合索引键合并后再一起计算Hash值，而不是单独计算Hash值，所以通过组合索引的前面一个或几个索引键进行查询的时候，Hash索引也无法被利用；
4.  Hash索引在任何时候都不能避免表扫描。由于不同索引键存在相同Hash值，所以即使取满足某个Hash键值的数据的记录条数，也无法从Hash索引中直接完成查询，还是要回表查询数据；
5.  Hash索引遇到大量Hash值相等的情况后性能并不一定就会比B+树索引高。

##### 4）mysql的存储引擎有哪些，区别是什么； #####

[https://blog.csdn.net/zhangyuan19880606/article/details/51217952][https_blog.csdn.net_zhangyuan19880606_article_details_51217952]  
如果要提供提交、回滚、崩溃恢复能力的事物安全（ACID兼容）能力，并要求实现并发控制，InnoDB是一个好的选择  
如果数据表主要用来插入和查询记录，则MyISAM引擎能提供较高的处理效率  
如果只是临时存放数据，数据量不大，并且不需要较高的数据安全性，可以选择将数据保存在内存中的Memory引擎，MySQL中使用该引擎作为临时表，存放查询的中间结果  
如果只有INSERT和SELECT操作，可以选择Archive，Archive支持高并发的插入操作，但是本身不是事务安全的。Archive非常适合存储归档数据，如记录日志信息可以使用Archive  
使用哪一种引擎需要灵活选择，一个数据库中多个表可以使用不同引擎以满足各种性能和实际需求，使用合适的存储引擎，将会提高整个数据库的性能

##### 5）说说事务的特性和隔离级别； #####

1.事务的特性ACID  
1）原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。  
2）一致性（Consistency）一个事务中，事务前后数据的完整性必须保持一致。  
3）隔离性（Isolation）多个事务，事务的隔离性是指多个用户并发访问数据库时， 一个用户的 事务不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离。  
4）持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变 就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。  
2.并发访问问题----由隔离性引起  
如果不考虑隔离性，事务存在3中并发访问问题。  
1）脏读：B事务读取到了A事务尚未提交的数据 ------ 要求B事务要读取A事 务提交的数据  
2）不可重复读：一个事务中两次读取的数据的内容不一致 ----- 要求的是一个事务中多次读取时数据是一致的 — unpdate  
3）幻读/虚读：一个事务中两次读取的数据的数量不一致 ----- 要求在一个事务多次读取的数据的数量是一致的 --insert delete  
3.事务的隔离级别  
1）read uncommitted : 读取尚未提交的数据 ：哪个问题都不能解决  
2）read committed：读取已经提交的数据 ：可以解决脏读 ---- oracle、sql server、postgresql 默认的  
3）repeatable read：重读读取：可以解决脏读 和 不可重复读 —mysql默认的  
4）serializable：串行化：可以解决 脏读 不可重复读 和 虚读—相当于锁表  
4.总结/概念  
事务的特性：ACID  
并发问题：脏读、不可重读、虚读\\幻读  
解决并发：设置隔离级别  
read uncommitted  
read committed （oracle、sql server、postgresql 默认的）  
repeatable read （mysql默认）  
serialazable  
隔离级别的性能：  
read uncommitted>read committed>repeatable read>serialazable  
安全性：  
read uncommitted<read committed<repeatable read<serialazable

##### 6）悲观锁和乐观锁的区别，怎么实现； #####

悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。  
乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write\_condition机制的其实都是提供的乐观锁。  
两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下，即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果经常产生冲突，上层应用会不断的进行retry，这样反倒是降低了性能，所以这种情况下用悲观锁就比较合适

> 六. mq(消息队列)：

MQ的基本概念：

1.  队列管理器  
    队列管理器是MQ系统中最上层的一个概念，由它为我们提供基于队列的消息服务。
2.  消息  
    在MQ中，我们把应用程序交由MQ传输的数据定义为消息，我们可以定义消息的内容并对消息进行广义的理解，比如：用户的各种类型的数据文件，某个应用向其它应用发出的处理请求等都可以作为消息。消息有两部分组成：  
    消息描述符(Message Discription或Message Header)，描述消息的特征，如：消息的优先级、生命周期、消息Id等；  
    消息体(Message Body)，即用户数据部分。在MQ中，消息分为两种类型，非永久性(non-persistent)消息和永久性(persistent)消息，非永久性消息是存储在内存中的，它是为了提高性能而设计的，当系统掉电或MQ队列管理器重新启动时，将不可恢复。当用户对消息的可靠性要求不高，而侧重系统的性能表现时，可以采用该种类型的消息，如：当发布股票信息时，由于股票信息是不断更新的，我们可能每若干秒就会发布一次，新的消息会不断覆盖旧的消息。永久性消息是存储在硬盘上，并且纪录数据日志的，它具有高可靠性，在网络和系统发生故障等情况下都能确保消息不丢、不重。  
    此外，在MQ中，还有逻辑消息和物理消息的概念。利用逻辑消息和物理消息，我们可以将大消息进行分段处理，也可以将若干个本身完整的消息在应用逻辑上归为一组进行处理。
3.  队列  
    队列是消息的安全存放地，队列存储消息直到它被应用程序处理。  
    消息队列以下述方式工作：  
    a) 程序A形成对消息队列系统的调用，此调用告知消息队列系统，消息准备好了投向程序B；  
    b) 消息队列系统发送此消息到程序B驻留处的系统，并将它放到程序B的队列中；  
    c) 适当时间后，程序B从它的队列中读此消息，并处理此信息。
4.  通道  
    通道是MQ系统中队列管理器之间传递消息的管道，它是建立在物理的网络连接之上的一个逻辑概念，也是MQ产品的精华。  
    在MQ中，主要有三大类通道类型，即消息通道，MQI通道和Cluster通道。消息通道是用于在MQ的服务器和服务器之间传输消息的，需要强调指出的是，该通道是单向的，它又有发送(sender), 接收(receive), 请求者(requestor), 服务者(server)等不同类型，供用户在不同情况下使用。MQI通道是MQ Client和MQI通道是MQ Client和MQ Server之间通讯和传输消息用的，与消息通道不同，它的传输是双向的。群集(Cluster)通道是位于同一个MQ 群集内部的队列管理器之间通讯使用的。

mq为了解决什么问题？  
1、异步通信  
有些业务不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。  
2、解耦  
降低工程间的强依赖程度，针对异构系统进行适配。在项目启动之初来预测将来项目会碰到什么需求，是极其困难的。通过消息系统在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口，当应用发生变化时，可以独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束  
3冗余  
有些情况下，处理数据的过程会失败。除非数据被持久化，否则将造成丢失。消息队列把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。许多消息队列所采用的"插入-获取-删除"范式中，在把一个消息从队列中删除之前，需要你的处理系统明确的指出该消息已经被处理完毕，从而确保你的数据被安全的保存直到你使用完毕。  
4、扩展性  
因为消息队列解耦了你的处理过程，所以增大消息入队和处理的频率是很容易的，只要另外增加处理过程即可。不需要改变代码、不需要调节参数。便于分布式扩容  
5、过载保护  
在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量无法提取预知；如果以为了能处理这类瞬间峰值访问为标准来投入资源随时待命无疑是巨大的浪费。使用消息队列能够使关键组件顶住突发的访问压力，而不会因为突发的超负荷的请求而完全崩溃  
6、可恢复性  
系统的一部分组件失效时，不会影响到整个系统。消息队列降低了进程间的耦合度，所以即使一个处理消息的进程挂掉，加入队列中的消息仍然可以在系统恢复后被处理。  
7、顺序保证  
在大多使用场景下，数据处理的顺序都很重要。大部分消息队列本来就是排序的，并且能保证数据会按照特定的顺序来处理。  
8、缓冲  
在任何重要的系统中，都会有需要不同的处理时间的元素。消息队列通过一个缓冲层来帮助任务最高效率的执行，该缓冲有助于控制和优化数据流经过系统的速度。以调节系统响应时间。  
9数据流处理  
分布式系统产生的海量数据流，如：业务日志、监控数据、用户行为等，针对这些数据流进行实时或批量采集汇总，然后进行大数据分析是当前互联网的必备技术，通过消息队列完成此类数据收集是最好的选择

##### 1）mq的原理是什么：有点大。。都可以说； #####

##### 2）mq如何保证实时性； #####

内部会为每条消息生成一个全局唯一、与业务无关的消息id，当接收到消息时，会先根据该id判断消息是否重复发送，再决定是否接收该消息。

##### 3）mq的持久化是怎么做的； #####

> 七. nosql相关（主要是redis）:

##### 1）redis和memcache的区别； #####

1、Redis和Memcache都是将数据存放在内存中，都是内存数据库。不过memcache还可用于缓存其他东西，例如图片、视频等等；  
2、Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储；  
3、虚拟内存–Redis当物理内存用完时，可以将一些很久没用到的value 交换到磁盘；  
4、过期策略–memcache在set时就指定，例如set key1 0 0 8,即永不过期。Redis可以通过例如expire 设定，例如expire name 10；  
5、分布式–设定memcache集群，利用magent做一主多从;redis可以做一主多从。都可以一主一从；  
6、存储数据安全–memcache挂掉后，数据没了；redis可以定期保存到磁盘（持久化）；  
7、灾难恢复–memcache挂掉后，数据不可恢复; redis数据丢失后可以通过aof恢复；  
8、Redis支持数据的备份，即master-slave模式的数据备份；  
9、应用场景不一样：Redis出来作为NoSQL数据库使用外，还能用做消息队列、数据堆栈和数据缓存等；Memcached适合于缓存SQL语句、数据集、用户临时性数据、延迟查询数据和session等。

##### 2）用redis做过什么； #####

Redis 是什么？  
通常而言目前的数据库分类有几种，包括 SQL/NSQL,，关系数据库，键值数据库等等 等，分类的标准也不以，Redis本质上也是一种键值数据库的，但它在保持键值数据库简单快捷特点的同时，又吸收了部分关系数据库的优点。从而使它的位置处于关系数据库和键值数 据库之间。Redis不仅能保存Strings类型的数据，还能保存Lists类型（有序）和Sets类型（无序）的数据，而且还能完成排序（SORT） 等高级功能，在实现INCR，SETNX等功能的时候，保证了其操作的原子性，除此以外，还支持主从复制等功能。  
2 Redis用来做什么？  
通常局限点来说，Redis也以消息队列的形式存在，作为内嵌的List存在，满足实时的高并发需求。而通常在一个电商类型的数据处理过程之中，有关商品，热销，推荐排序的队列，通常存放在Redis之中，期间也包扩Storm对于Redis列表的读取和更新。  
3 Redis的优点  
性能极高 – Redis能支持超过 100K+ 每秒的读写频率。  
丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。  
原子 – Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行。  
丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。  
4 Redis的缺点  
是数据库容量受到物理内存的限制,不能用作海量数据的高性能读写,因此Redis适合的场景主要局限在较小数据量的高性能操作和运算上。  
总结： Redis受限于特定的场景，专注于特定的领域之下，速度相当之快，目前还未找到能替代使用产品。

##### 3）redis是如何持久化的：rdb和aof； #####

1、前言  
最近在项目中使用到Redis做缓存，方便多个业务进程之间共享数据。由于Redis的数据都存放在内存中，如果没有配置持久化，redis重启后数据就全丢失了，于是需要开启redis的持久化功能，将数据保存到磁盘上，当redis重启后，可以从磁盘中恢复数据。redis提供两种方式进行持久化，一种是RDB持久化（原理是将Reids在内存中的数据库记录定时dump到磁盘上的RDB持久化），另外一种是AOF持久化（原理是将Reids的操作日志以追加的方式写入文件）。那么这两种持久化方式有什么区别呢，改如何选择呢？网上看了大多数都是介绍这两种方式怎么配置，怎么使用，就是没有介绍二者的区别，在什么应用场景下使用。  
2、二者的区别  
RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘，实际操作过程是fork一个子进程，先将数据集写入临时文件，写入成功后，再替换之前的文件，用二进制压缩存储。

AOF持久化以日志的形式记录服务器所处理的每一个写、删除操作，查询操作不会记录，以文本的方式记录，可以打开文件看到详细的操作记录。

3、二者优缺点  
RDB存在哪些优势呢？  
1). 一旦采用该方式，那么你的整个Redis数据库将只包含一个文件，这对于文件备份而言是非常完美的。比如，你可能打算每个小时归档一次最近24小时的数据，同时还要每天归档一次最近30天的数据。通过这样的备份策略，一旦系统出现灾难性故障，我们可以非常容易的进行恢复。  
2). 对于灾难恢复而言，RDB是非常不错的选择。因为我们可以非常轻松的将一个单独的文件压缩后再转移到其它存储介质上。  
3). 性能最大化。对于Redis的服务进程而言，在开始持久化时，它唯一需要做的只是fork出子进程，之后再由子进程完成这些持久化的工作，这样就可以极大的避免服务进程执行IO操作了。  
4). 相比于AOF机制，如果数据集很大，RDB的启动效率会更高。  
RDB又存在哪些劣势呢？  
1). 如果你想保证数据的高可用性，即最大限度的避免数据丢失，那么RDB将不是一个很好的选择。因为系统一旦在定时持久化之前出现宕机现象，此前没有来得及写入磁盘的数据都将丢失。  
2). 由于RDB是通过fork子进程来协助完成数据持久化工作的，因此，如果当数据集较大时，可能会导致整个服务器停止服务几百毫秒，甚至是1秒钟。  
AOF的优势有哪些呢？  
1). 该机制可以带来更高的数据安全性，即数据持久性。Redis中提供了3中同步策略，即每秒同步、每修改同步和不同步。事实上，每秒同步也是异步完成的，其效率也是非常高的，所差的是一旦系统出现宕机现象，那么这一秒钟之内修改的数据将会丢失。而每修改同步，我们可以将其视为同步持久化，即每次发生的数据变化都会被立即记录到磁盘中。可以预见，这种方式在效率上是最低的。至于无同步，无需多言，我想大家都能正确的理解它。  
2). 由于该机制对日志文件的写入操作采用的是append模式，因此在写入过程中即使出现宕机现象，也不会破坏日志文件中已经存在的内容。然而如果我们本次操作只是写入了一半数据就出现了系统崩溃问题，不用担心，在Redis下一次启动之前，我们可以通过redis-check-aof工具来帮助我们解决数据一致性的问题。  
3). 如果日志过大，Redis可以自动启用rewrite机制。即Redis以append模式不断的将修改数据写入到老的磁盘文件中，同时Redis还会创建一个新的文件用于记录此期间有哪些修改命令被执行。因此在进行rewrite切换时可以更好的保证数据安全性。  
4). AOF包含一个格式清晰、易于理解的日志文件用于记录所有的修改操作。事实上，我们也可以通过该文件完成数据的重建。  
AOF的劣势有哪些呢？  
1). 对于相同数量的数据集而言，AOF文件通常要大于RDB文件。RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。  
2). 根据同步策略的不同，AOF在运行效率上往往会慢于RDB。总之，每秒同步策略的效率是比较高的，同步禁用策略的效率和RDB一样高效。  
二者选择的标准，就是看系统是愿意牺牲一些性能，换取更高的缓存一致性（aof），还是愿意写操作频繁的时候，不启用备份来换取更高的性能，待手动运行save的时候，再做备份（rdb）。rdb这个就更有些 eventually consistent的意思了。  
4、常用配置  
RDB持久化配置  
Redis会将数据集的快照dump到dump.rdb文件中。此外，我们也可以通过配置文件来修改Redis服务器dump快照的频率，在打开6379.conf文件之后，我们搜索save，可以看到下面的配置信息：  
save 900 1 \#在900秒(15分钟)之后，如果至少有1个key发生变化，则dump内存快照。  
save 300 10 \#在300秒(5分钟)之后，如果至少有10个key发生变化，则dump内存快照。  
save 60 10000 \#在60秒(1分钟)之后，如果至少有10000个key发生变化，则dump内存快照。  
AOF持久化配置  
在Redis的配置文件中存在三种同步方式，它们分别是：  
appendfsync always \#每次有数据修改发生时都会写入AOF文件。  
appendfsync everysec \#每秒钟同步一次，该策略为AOF的缺省策略。  
appendfsync no \#从不同步。高效但是数据不会被持久化。

##### 4）redis集群如何同步； #####

##### 5）redis的数据添加过程是怎样的：哈希槽； #####

Redis 集群中内置了 16384 个哈希槽，当需要在 Redis 集群中放置一个 key-value  
时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 取模，  
这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，redis 会根据节点数量大  
致均等的将哈希槽映射到不同的节点。  
Redis 集群没有使用一致性hash, 而是引入了哈希槽的概念。  
Redis 集群有16384个哈希槽,每个key通过CRC16校验后对16384取模来决定放置哪个槽.集群的每个节点负责一部分hash槽。这种结构很容易添加或者删除节点，并且无论是添加删除或者修改某一个节点，都不会造成集群不可用的状态。  
使用哈希槽的好处就在于可以方便的添加或移除节点。  
当需要增加节点时，只需要把其他节点的某些哈希槽挪到新节点就可以了；  
当需要移除节点时，只需要把移除节点上的哈希槽挪到其他节点就行了；  
在这一点上，我们以后新增或移除节点的时候不用先停掉所有的 redis 服务。

##### 6）redis的淘汰策略有哪些； #####

1.  volatile-lru：从已设置过期时间的数据集（server.db\[i\].expires）中挑选最近最少使用的数据淘汰；
2.  volatile-ttl：从已设置过期时间的数据集（server.db\[i\].expires）中挑选将要过期的数据淘汰；
3.  volatile-random：从已设置过期时间的数据集（server.db\[i\].expires）中任意选择数据淘汰 ；
4.  allkeys-lru：从数据集（server.db\[i\].dict）中挑选最近最少使用的数据淘汰；
5.  allkeys-random：从数据集（server.db\[i\].dict）中任意选择数据淘汰；
6.  no-enviction（驱逐）：禁止驱逐数据。

##### 7）redis有哪些数据结构； #####

1.string类型（string是redis最基本的类型，而且string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象）  
2.List类型（Lists 就是链表）  
3.Sets（Sets 就是一个集合，集合的概念就是一堆不重复值的组合。利用Redis提供的Sets数据结构，可以存储一些集合性的数据。）  
4.Sorted Sets（和set一样sorted set也是string类型元素的集合，不同的是每个元素都会关联一个double类型的score。）  
5.Hashs（hash 是一个键值对集合，是一个 string 类型的 key和 value 的映射表，key 还是key，但是value是一个键值对（key-value）。类比于 Java里面的 Map<String,Map<String,Object>> 集合。）

> 八. zookeeper:

##### 1）zookeeper是什么； #####

ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，它是集群的管理者，监视着集群中各个节点的状态根据节点提交的反馈进行下一步合理操作。最终，将简单易用的接口和性能高效、功能稳定的系统提供给用户

##### 2）zookeeper哪里用到； #####

##### 3）zookeeper的选主过程； #####

##### 4）zookeeper集群之间如何通讯； #####

##### 5）你们的zookeeper的节点加密是用的什么方式； #####

##### 6）分布式锁的实现过程； #####

> 九. linux相关：

##### 1）linux常用的命令有哪些； #####

[https://www.cnblogs.com/yjd\_hycf\_space/p/7730690.html][https_www.cnblogs.com_yjd_hycf_space_p_7730690.html]  
[https://blog.csdn.net/chajinglong/article/details/59539982][https_blog.csdn.net_chajinglong_article_details_59539982]  
1、cd命令  
这是一个非常基本，也是大家经常需要使用的命令，它用于切换当前目录，它的参数是要切换到的目录的路径，可以是绝对路径，也可以是相对路径  
2、ls命令  
这是一个非常有用的查看文件与目录的命令，list之意，它的参数非常多，下面就列出一些我常用的参数吧，如下：  
3、grep命令  
该命令常用于分析一行的信息，若当中有我们所需要的信息，就将该行显示出来，该命令通常与管道命令一起使用，用于对一些命令的输出进行筛选加工等等，它的简单语法为  
4、find命令  
find是一个基于查找的功能非常强大的命令，相对而言，它的使用也相对较为复杂，参数也比较多，所以在这里将给把它们分类列出，它的基本语法如下：  
5、cp命令  
该命令用于复制文件，copy之意，它还可以把多个文件一次性地复制到一个目录下，它的常用参数如下：  
6、mv命令  
该命令用于移动文件、目录或更名，move之意，它的常用参数如下：  
7、rm命令  
该命令用于删除文件或目录，remove之间，它的常用参数如下  
8、ps命令  
该命令用于将某个时间点的进程运行情况选取下来并输出，process之意  
9、kill命令  
该命令用于向某个工作（%jobnumber）或者是某个PID（数字）传送一个信号，它通常与ps和jobs命令一起使用，(kill pid)  
10、killall命令  
该命令用于向一个命令启动的进程发送一个信号  
11、file命令  
该命令用于判断接在file命令后的文件的基本数据，因为在Linux下文件的类型并不是以后缀为分的，所以这个命令对我们来说就很有用了  
12、tar命令  
该命令用于对文件进行打包，默认情况并不会压缩，如果指定了相应的参数，它还会调用相应的压缩程序（如gzip和bzip等）进行压缩和解压  
13、cat命令  
该命令用于查看文本文件的内容，后接要查看的文件名，通常可用管道与more和less一起使用，从而可以一页页地查看数据  
14、chgrp命令  
该命令用于改变文件所属用户组，它的使用非常简单  
15、chown命令  
该命令用于改变文件的所有者，与chgrp命令的使用方法相同，只是修改的文件属性不同  
16、chmod命令  
该命令用于改变文件的权限  
18、vim命令  
该命令主要用于文本编辑，它接一个或多个文件名作为参数，如果文件存在就打开，如果文件不存在就以该文件名创建一个文件。  
19、gcc命令  
对于一个用Linux开发C程序的人来说，这个命令就非常重要了，它用于把C语言的源程序文件，编译成可执行程序，由于g++的很多参数跟它非常相似  
20、time命令  
该命令用于测算一个命令（即程序）的执行时间。它的使用非常简单，就像平时输入命令一样，不过在命令的前面加入一个time即可，  
2）如何获取java进程的pid；  
ps -ef | grep java  
3）如何获取某个进程的网络端口号；  
netstat -nap | grep 端口

##### 4）如何实时打印日志； #####

使用tail  
1．命令格式;  
tail\[必要参数\]\[选择参数\]\[文件\]  
2．命令功能：  
用于显示指定文件末尾内容，不指定文件时，作为输入信息进行处理。常用查看日志文件。  
3．命令参数：  
\-f 循环读取  
\-q 不显示处理信息  
\-v 显示详细的处理信息  
\-c<数目> 显示的字节数  
\-n<行数> 显示行数  
–pid=PID 与-f合用,表示在进程ID,PID死掉之后结束.  
\-q, –quiet, –silent 从不输出给出文件名的首部  
\-s, –sleep-interval=S 与-f合用,表示在每次反复的间隔休眠S秒  
4．使用实例：  
实例1：显示文件末尾内容  
命令：  
tail -n 5 log2014.log  
输出：  
\[root@localhost test\]\# tail -n 5 log2014.log  
2014-09  
2014-10  
2014-11  
2014-12

# 大概整了下 ，不是很齐全。 有引用的地方看原理比较好，祝大家面试顺利！ #

[https_www.cnblogs.com_chengxiao_p_6059914.html]: https://www.cnblogs.com/chengxiao/p/6059914.html
[https_www.cnblogs.com_ityouknow_p_5610232.html]: https://www.cnblogs.com/ityouknow/p/5610232.html
[https_www.jianshu.com_p_22e39a3ed932]: https://www.jianshu.com/p/22e39a3ed932
[https_blog.csdn.net_qq_38254897_article_details_85717345]: https://blog.csdn.net/qq_38254897/article/details/85717345
[https_www.cnblogs.com_Leo_wl_p_6251022.html]: https://www.cnblogs.com/Leo_wl/p/6251022.html
[https_www.cnblogs.com_wangcq_p_3520400.html]: https://www.cnblogs.com/wangcq/p/3520400.html
[https_blog.csdn.net_zhangyuan19880606_article_details_51217952]: https://blog.csdn.net/zhangyuan19880606/article/details/51217952
[https_www.cnblogs.com_yjd_hycf_space_p_7730690.html]: https://www.cnblogs.com/yjd_hycf_space/p/7730690.html
[https_blog.csdn.net_chajinglong_article_details_59539982]: https://blog.csdn.net/chajinglong/article/details/59539982