2019年武汉中高级java开发工程师面试题总结

深碍√TFBOYSˉ_ 2022-03-21 13:20 2635阅读 0赞

**目录**

一、前言

二、java基础

1、基本数据类型

1.1  java基本数据类型及长度

1.2 java中的位运算

1.3 给出两个int类型的整数 a和 b, 求他们的和，要求使用位运算去做。

1.4  a+=b 和a=a+b 有什么区别？

1.5  3\*0.1 == 0.3 将会返回什么？true 还是 false？

1.6 接口和抽象类的区别

1.7 什么是不可变对象，什么是可变对象？

1.8 如何编写一个不可变对象？

1.9 final的用法

1.10 java当中的四种引用

1.11  Object中有哪些方法?

1.12 常用的运行时异常

1.13 jdk1.8新特性

1.14 运行时数据区包括哪几部分

1.15 GC要回收哪些区域?

1.16 如何判断对象是否存活?

1.17 常用的垃圾回收算法

1.18  常见的垃圾收集器

1.19  GC什么时候被触发的 ？

1.20 jvm查看gc命令

1.21 类加载为什么要使用双亲委派模式，有没有什么场景是打破了这个模式？

1.22  类的实例化顺序？

1.23 java内存模型

1.21 内存泄漏与内存溢出区别，产生原因？

1.22 如何解决内存溢出？

2、集合框架

2.1 HashMap和HashTable有何不同？

2.2  ArrayList和Vector有何异同点？

2.3 ArrayList和LinkedList有何区别？

2.4 发生hash碰撞的原因

2.5    解决冲突的办法

2.6 经常使用的构造散列函数的方法

2.7 HsahMap的put过程

2.8 HashMap 的get过程

2.9 ConcurrentHashMap 的put过程

2.10  ConcurrentHashMap的get过程

2.11 不安全使用HashMap会导致的安全问题？

3、多线程

3.1 现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？

3.2 什么是线程

3.3 线程和进程有什么区别？

3.4 Java中Runnable和Callable有什么不同？

3.5 Java中CountDownLatch 和CyclicBarrier 有什么不同？

3.6 线程运行的多种状态

3.7 Java中的volatile 变量是什么？

3.8 volatile的原理和实现机制

3.9 使用volatile关键字的场景

3.10 如何终止一个线程

3.11 生产者消费者模型

3.12 什么是ThreadLocal变量？

3.13 什么是FutureTask？

3.14 Java中interrupt 、interrupted 和 isInterruptedd方法的区别？

3.15 Java中的同步集合与并发集合有什么区别？

3.16 常用的线程池

3.17 sleep和wait的区别?

3.18  fail-fast和fail-safe机制

3.19 JVM性能调优监控工具jps、jstack、jmap、jhat、jstat、hprof使用

3.20  Java中的同步集合与并发集合有什么区别

3.21 Java中synchronized 和 ReentrantLock 有什么不同

3.22 Java中的fork join框架是什么？

3.23 Java中的锁机制  偏向锁 & 轻量级锁 & 重量级锁各自优缺点及场景

3.24 synchronized修饰代码块、普通方法、静态方法有什么区别。

3.25 synchronized 和 lock 有什么区别？

3.26 什么是CAS?

3.27 Synchronized 和 CAS

3.28 java中原子操作

4、JavaWeb

4.1 Http中Get和Post的区别

4.2 tomcat的优化

（1）tomcat内存优化

4.3 Sevlet生命周期

4.4 forward()和redirect()的区别

4.5 jsp中的九大内置对象

4.6 jsp中的四个域对象

4.7 Jsp与servlet的区别

4.8 TCP与UDP的区别

4.9 tcp/udp协议在网络模型

4.10 说说你熟悉的响应码

5 linux常用命令

5.1 基本命令

5.2 创建文件

5.3 移动文件、修改文件名

5.4 拷贝文件

5.5 查看文本内容

5.6 打包/解包

5.7 压缩/解压

5.8 归档并压缩/解压

5.9 网络服务启动与停止

6 mysql

6.1 乐观锁与悲观锁的区别？

6.2 事务的特性

6.3 不考虑事务的隔离性引发的一系列安全问题

6.4 mysql常用的数据库引擎

6.5 jdbc中Statement与Preparestament的区别

6.6 sql优化

6.7 分表分库

6.8 oracle数据库的分页

6.9 mysql索引的分类

6.10 创建索引的原则

6.11 mysql索引的工作原理

6.12 复制基本原理流程

6.13 MySQL复制的线程有几个及之间的关联

6.14 MySQL如何保证复制过程中数据一致性及减少数据同步延时

6.15 数据库主库和从库不一致,怎么解决？

6.16 MySQL存储引擎MyISAM与InnoDB区别

6.17 索引如何提高查询效率？

7 redis

7.1 redis的数据结构

7.2 redis的持久化机制

7.3 mySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据

7.4 redis常见性能问题和解决方案

7.5 redis的并发竞争问题如何解决?

7.6 redis事务的命令

7.7 redis事务的特征

7.8 redis集群搭建

8 SpringMVC

8.1 springMVC的运行流程

8.2 mvc模式

9 Spring

9.1 什么是IOC，以及其原理？

9.2 IOC和DI的区别？

9.3 什么是aop

9.4 SpringBean实例化方式

9.5 springBean的生命周期

9.6 Spring的事物管理

9.7 Spring事物的隔离级别和传播行为

9.8 BeanFactory和ApplicationContext有什么区别？

9.9 Spring Bean的作用域之间有什么区别？

9.10 JDK动态代理和Gglib动态代理的区别

9.11 BeanFactory与FactoryBean的区别

9.12 spring在bean的创建过程中解决循环依赖

9.13 @Transactional使用

9.14 获取spring容器的常用的4种方式

9.15 Spring支持三种依赖注入方式

10 Mybatis

10.1 mybatis的原理

10.2 \#\{\}和$\{\}的区别是什么？

10.3 通常一个Xml映射文件，都会写一个Mapper接口与之对应，请问，这个Mapper接口的工作原理是什么？Mapper接口里的方法，参数不同时，方法能重载吗？

10.4 Mybatis分页插件的原理是什么？

10.5 简述Mybatis的插件运行原理，以及如何编写一个插件

10.6 mybatis是否支持延迟加载？如果支持，它的实现原理是什么？

10.7 Mybatis都有哪些Executor执行器？它们之间的区别是什么？

10.8 mybatis缓存

11 springBoot

11.1 什么是 Spring Boot？

11.2 Spring Boot 的核心配置文件有哪几个？它们的区别是什么？

11.3 Spring Boot 的配置文件有哪几种格式？它们有什么区别？

11.4 Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？

11.5 开启 Spring Boot 特性有哪几种方式？

11.6 Spring Boot 需要独立的容器运行吗？

11.7 运行 Spring Boot 有哪几种方式？

11.8 Spring Boot 自动配置原理是什么？

11.9 如何在 Spring Boot 启动的时候运行一些特定的代码？

11.10 Spring Boot 有哪几种读取配置的方式？

11.11 Spring Boot 支持哪些日志框架？推荐和默认的日志框架是哪个？

11.12 SpringBoot 实现热部署有哪几种方式？

11.13 你如何理解 Spring Boot 配置加载顺序？

11.14 Spring Boot 2.X 有什么新特性？与 1.X 有什么区别？

12 微服务

12.1 SpringCloud和Dubbo有哪些区别？

2. SpringBoot和SpringCloud,请你谈谈对他们的理解？

3. 什么是服务熔断？什么是服务降级？

4. Eureka和zookeeper都可以提供服务注册与发现的功能，请说说两个的区别？

--------------------

### 一、前言 ###

楼主本人目前在武汉工作，才刚放假，已经在准备下家公司面试。把自己面试准备的东西做个记录，以驱使自己进步。

# 二、java基础 #

## 1、基本数据类型  ##

###   1.1  java基本数据类型及长度 ###

四种整数类型  2种浮点型  1种字符类型 一种布尔类型(boolean)

整数类型

Java各数据类型有固定的表数范围和字段长度，其不受操作系统影响，保证了Java的可移植性。

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;"><strong>类型</strong></td> 
   <td style="vertical-align:top;"><strong>占存储空间</strong></td> 
   <td style="vertical-align:top;"><strong>表数范围</strong></td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">byte</td> 
   <td style="vertical-align:top;">1字节</td> 
   <td style="vertical-align:top;">-&nbsp;<img alt="2^{7}" src="https://private.codecogs.com/gif.latex?2%5E%7B7%7D">~<img alt="2^{7}" src="https://private.codecogs.com/gif.latex?2%5E%7B7%7D">-1(-128~127&nbsp; )</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">short</td> 
   <td style="vertical-align:top;">2字节</td> 
   <td style="vertical-align:top;">-<img alt="2^{15}" src="https://private.codecogs.com/gif.latex?2%5E%7B15%7D">~<img alt="2^{15}" src="https://private.codecogs.com/gif.latex?2%5E%7B15%7D">-1</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">int</td> 
   <td style="vertical-align:top;">4字节</td> 
   <td style="vertical-align:top;">-<img alt="2^{31}" src="https://private.codecogs.com/gif.latex?2%5E%7B31%7D">~<img alt="2^{31}" src="https://private.codecogs.com/gif.latex?2%5E%7B31%7D">-1</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">long</td> 
   <td style="vertical-align:top;">8字节</td> 
   <td style="vertical-align:top;">-<img alt="2^{63}" src="https://private.codecogs.com/gif.latex?2%5E%7B63%7D">~<img alt="2^{63}" src="https://private.codecogs.com/gif.latex?2%5E%7B63%7D">-1</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">char</td> 
   <td style="vertical-align:top;">2个字节</td> 
   <td style="vertical-align:top;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">float</td> 
   <td style="vertical-align:top;">4个字节</td> 
   <td style="vertical-align:top;">-3.403E38~3.403E38</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">double</td> 
   <td style="vertical-align:top;">8个字节</td> 
   <td style="vertical-align:top;">-17.98E308~17.98E308</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">boolean</td> 
   <td style="vertical-align:top;">1个bit位</td> 
   <td style="vertical-align:top;">&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

浮点数在现实中是连续的，在计算机数据结构中是离散的，计算机内部表示浮点数是有误差的。

###   1.2 java中的位运算 ###

<table> 
 <tbody> 
  <tr> 
   <td style="width:115px;">位运算符</td> 
   <td>作用</td> 
  </tr> 
  <tr> 
   <td style="width:115px;">&amp;</td> 
   <td>两个数操作的位都为1结果为1，否则为0</td> 
  </tr> 
  <tr> 
   <td style="width:115px;">|</td> 
   <td>两个数操作的位只要有一个为1结果就位为1，否则为0</td> 
  </tr> 
  <tr> 
   <td style="width:115px;">~</td> 
   <td>参加运算的数，换算为二进制(0、1)后，进行取反运算。每个位上都取相反值，1变成0，0变成1</td> 
  </tr> 
  <tr> 
   <td style="width:115px;">^</td> 
   <td>参加运算的两个数，换算为二进制(0、1)后，进行异或运算。只有当相应位上的数字不相同时，该为才取1，若相同，即为0。</td> 
  </tr> 
  <tr> 
   <td style="width:115px;">&lt;&lt;</td> 
   <td>参加运算的数，换算为二进制(0、1)后，进行左移运算，将这个数各二进制位全部向左移动若干位</td> 
  </tr> 
  <tr> 
   <td style="width:115px;">&gt;&gt;</td> 
   <td>参加运算的数，换算为二进制(0、1)后，进行右移运算，将这个数各二进制位全部向右移动若干位</td> 
  </tr> 
  <tr> 
   <td style="width:115px;">&gt;&gt;&gt;</td> 
   <td>参加运算的数，换算为二进制(0、1)后，进行右移运算，将这个数各二进制位全部向右移动若干位，无符号右移，忽略符号位，空位都以0补齐</td> 
  </tr> 
 </tbody> 
</table>

###   1.3 给出两个int类型的整数 a和 b, 求他们的和，要求使用位运算去做。 ###

// 主要利用异或运算来完成
    // 异或运算有一个别名叫做：不进位加法
    // 那么a ^ b就是a和b相加之后，该进位的地方不进位的结果
    // 然后下面考虑哪些地方要进位，自然是a和b里都是1的地方
    // a & b就是a和b里都是1的那些位置，a & b << 1 就是进位
    // 之后的结果。所以：a + b = (a ^ b) + (a & b << 1)
    // 令a' = a ^ b, b' = (a & b) << 1
    // 可以知道，这个过程是在模拟加法的运算过程，进位不可能
    // 一直持续，所以b最终会变为0。因此重复做上述操作就可以
    // 求得a + b的值。
    while (b != 0) {
        int _a = a ^ b;
        int _b = (a & b) << 1;
        a = _a;
        b = _b;
    }
    return a;

###  1.4  a+=b 和a=a+b 有什么区别？ ###

\+= 隐式的将加操作的结果类型强制转换为持有结果的类型。如果两这个整型相加，如 byte、short 或者 int，首先会将它们提升到 int 类型，然后在执行加法操作。

如下代码：

byte a = 20;
    byte b = 19;
    b+=a;
    b=b+a;//Type mismatch: cannot convert from int to byte

b=b+a报错：不能把int转换成byte

### 1.5  **3\*0.1 == 0.3 将会返回什么？true 还是 false？** ###

**false**, java中小数 float和double类型一个占32位 一个64位其实不论是float还是double在存储方式上都是遵从IEEE的规范的，float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。

无论是单精度还是双精度在存储中都分为三个部分：

float表示

1.  符号位(Sign) : 0代表正，1代表为负
2.  指数位（Exponent）:用于存储科学计数法中的指数数据，并且采用移位存储
3.  尾数部分（Mantissa）：尾数部分

![aHR0cHM6Ly9pbWFnZXMuY25ibG9ncy5jb20vY25ibG9nc19jb20vamlsbHpoYW5nL1dpbmRvd3NMaXZlV3JpdGVyL2Zsb2F0X0E5MTkvY2xpcF9pbWFnZTAwMSU1QjMlNURfMi5naWY][]

double表示：

![doubleç±»åæ°æ®çåå¨æ¹å¼][double]

float和double会损失精度

### 1.6 接口和抽象类的区别 ###

<table> 
 <tbody> 
  <tr> 
   <td style="width:87px;">&nbsp;</td> 
   <td style="width:220px;">抽象类</td> 
   <td style="width:542px;">接口</td> 
  </tr> 
  <tr> 
   <td>构造器</td> 
   <td>抽象类中可以有构造器,</td> 
   <td>接口中不能</td> 
  </tr> 
  <tr> 
   <td style="width:87px;">成员变量</td> 
   <td style="width:220px;">&nbsp;</td> 
   <td style="width:542px;">public static final</td> 
  </tr> 
  <tr> 
   <td colspan="1" style="width:87px;">方法</td> 
   <td colspan="1" style="width:220px;">&nbsp;</td> 
   <td style="width:542px;"> <p>&nbsp;public abstract (都可以省略)</p> </td> 
  </tr> 
  <tr> 
   <td style="width:542px;"> <p>&nbsp;public default&nbsp; &nbsp;（public 可以省略）1.8新特性</p> </td> 
  </tr> 
  <tr> 
   <td style="width:542px;"> <p>&nbsp;&nbsp;public static&nbsp; &nbsp; &nbsp; （public可以省略）1.8新特性</p> </td> 
  </tr> 
  <tr> 
   <td style="width:542px;"> <p>private&nbsp; &nbsp; &nbsp;1.9新特性</p> </td> 
  </tr> 
 </tbody> 
</table>

###  1.7 什么是不可变对象，什么是可变对象？ ###

不可变对象(Immutable Objects)：

即对象一旦被创建它的状态（对象的数据，也即对象属性值）就不能改变，任何对它的改变都应该产生一个新的对象。如String、基本类型的包装类、BigInteger和BigDecimal等。

可变对象(Mutable Objects)：

相对于不可变类，可变类创建实例后可以改变其成员变量值，开发中创建的大部分类都属于可变类。

### 1.8 如何编写一个不可变对象？ ###

A. 确保类不能被继承：

将类声明为final, 或者使用静态工厂并声明构造器为private。如果类可以被继承会破坏类的不可变性机制，只要继承类覆盖父类的方法并且继承类可以改变成员变量值，那么一旦子类以父类的形式出现时，不能保证当前类是否可变

B. 使用private和final修饰符来修饰该类的属性

C. 不要提供任何可以修改对象状态的方法（不仅仅是set方法, 还有任何其它可以改变状态的方法）

不可变对象的优点：

\* 构造、测试和使用都很简单

\* 不可变对象是线程安全的，在线程之间可以相互共享，不需要利用特殊机制来保证同步问题，因为对象的值无法改变。可以降低并发错误的可能性，因为不需要用一些锁机制等保证内存一致性问题也减少了同步开销。

\* 不可变对象可以被重复使用，可以将它们缓存起来重复使用，就像字符串字面量和整型数字一样。可以使用静态工厂方法来提供类似于valueOf()这样的方法，它可以从缓存中返回一个已经存在的Immutable对象，而不是重新创建一个。

### 1.9 final的用法 ###

1.被final修饰的类不可以被继承

2.被final修饰的方法不可以被重写

3.被final修饰的方法，JVM会尝试将其内联，以提高运行效率   
4.被final修饰的变量不可以被改变。如果修饰引用，那么表示引用不可变，引用指向的内容可变  
5.被final修饰的常量，在编译阶段会存入常量池中。

回答出编译器对final域要遵守的两个重排序规则更好：  
1.在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。  
2.初次读一个包含final域的对象的引用，与随后初次读这个final域,这两个操作之间不能重排序。

### 1.10 java当中的四种引用 ###

强引用，软引用，弱引用，虚引用。不同的引用类型主要体现在GC上:

1.  强引用（Strong Reference）：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
2.  软引用（Soft Reference）：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。
3.  弱引用（Weak Reference）：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象。
4.  虚引用（Phantom Reference）：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。

### 1.11  Object中有哪些方法? ###

1. getClass()

public final native Class<?> getClass();

getClass() 返回此 `Object` 的运行时类

2. hashCode()

public native int hashCode();

hashCode() 返回该对象的哈希码值

hashCode的常规协定是：

*  在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
 *  如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 `hashCode` 方法都必须生成相同的整数结果。
 *  如果根据 `equals(java.lang.Object)` 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法*不* 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

3. equals(Object obj)

public boolean equals(Object obj) {
            return (this == obj);
        }

equals(Object obj)指示其他某个对象是否与此对象“相等”。

4. clone()

protected native Object clone()

clone()创建并返回此对象的一个副本。克隆分为深度克隆和浅度克隆，Object的克隆为浅度克隆。

浅度克隆：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

深度克隆：被复制对象的所有变量都含有与原来的对象相同的值，而那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

5. toString()

public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

6. finalize()

protected void finalize()

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 `finalize` 方法，以配置系统资源或执行其他清除。

7. notify()、notifyAll ()

唤醒在此对象监视器上等待的单个/多个线程

8、wait()、wait(long timeout)、wait(long timeout, int nanos)

当前线程等待

### 1.12 常用的运行时异常 ###

1、ClassCastException:类型转换异常

2、ConcurrentModificationException：并发修改异常

3、ArrayIndexOutOfBoundsException:数组角标越界

4、UnsupportedOperationException：不支持的操作异常

Arrays.asList() 方法把数组转换集合，在对集合进行修改时会抛出此异常。

5、NullPointerException

6、NumberFormatException

7、java.lang.IllegalMonitorStateException

### 1.13 jdk1.8新特性 ###

1、Lambda 表达式，允许像对象一样传递匿名函数

*  Lambda表达式的省略规则*

*            1、参数的类型可以省略，但是只能省略所有类型或者都不省略*

*           2、如果参数有且仅有一个（）可以省略*

*           3、如果大括号内的语句有且仅有一个，那么无论有没有返回值  return    \{\}和；都可以省略*

2、Stream API，充分利用现代多核 CPU，可以写出很简洁的代码

流的获取方式：

①通过Collection直接掉用stream()方法

②通过数组：Arrays.stream();或者Stream.of()

java.util.stream.Stream 的of方法源码其无法把基本数据类型的数组转换成流

public static<T> Stream<T> of(T t) {
            return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
        }

常用方法

*  filter()
 *  count()
 *  limit()
 *  skip()
 *  map()
 *  concat()
 *  forEach()
 *  collect()

3、Date 与 Time API，最终，有一个稳定、简单的日期和时间库可供你使用

4、接口更新，现在，接口中可以有静态、默认方法。

### 1.14 **运行时数据区包括哪几部分** ###

Java运行时数据区分为下面几个内存区域：

![20190214111733829.png][]

每当创建一个线程，JVM就会为该线程创建对应的Java栈，在这个Java栈中又会包含多个栈帧(Stack Frame)，这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量、操作栈和方法返回值等信息。下图是栈帧结构

![format_png][]

堆是JVM所管理的内存中国最大的一块，是被所有Java线程锁共享的，不是线程安全的，在JVM启动时创建。堆是存储Java对象的地方，这一点Java虚拟机规范中描述是：所有的对象实例以及数组都要在堆上分配。Java堆是GC管理的主要区域，从内存回收的角度来看，由于现在GC基本都采用分代收集算法，所以Java堆还可以细分为：新生代和老年代；新生代再细致一点有Eden空间、From Survivor空间、To Survivor空间等。

方法区存放了要加载的类的信息（名称、修饰符等）、类中的静态常量、类中定义为final类型的常量、类中的Field信息、类中的方法信息，当在程序中通过Class对象的getName.isInterface等方法来获取信息时，这些数据都来源于方法区。方法区是被Java线程锁共享的，不像Java堆中其他部分一样会频繁被GC回收，它存储的信息相对比较稳定，在一定条件下会被GC。

本地方法栈和Java栈所发挥的作用非常相似，区别不过是Java栈为JVM执行Java方法服务，而本地方法栈为JVM执行Native方法服务

上述区域只有 堆和方法区是被所有线程共享的，存在线程安全问题。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70][]

*  PC寄存器/程序计数器
 *  栈
 *  堆
 *  方法区
 *  本地方法栈

### 1.15 GC**要回收哪些区域?** ###

在JVM内存模型中，有三个是不需要进行垃圾回收的：程序计数器、JVM栈、本地方法栈。因为它们的生命周期是和线程同步的，随着线程的销毁，它们占用的内存会自动释放，所以只有方法区和堆需要进行GC

###  1.16 **如何判断对象是否存活?** ###

**引用计数法**

给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器

值就减1；任何时刻计数器为0的对象就是不可能再被使用的。

**可达性分析算法（根搜索算法）**

过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为

引用链(Reference Chain)，当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的

在Java语言中，可作为GC Roots的对象包括下面几种：

*  虚拟机栈（栈帧中的本地变量表）中引用的对象。
 *  方法区中类静态属性引用的对象。
 *  方法区中常量引用的对象。
 *  本地方法栈中JNI（即一般说的Native方法）引用的对象。

### 1.17 **常用的垃圾回收算法**   ###

**标记-清除算法**

标记-清除算法采用从根集合（GC Roots）进行扫描，对存活的对象进行标记，标记完毕后，再扫描整个空间中未被标记的对象，进行回收，此算法一般没有虚拟机采用。

**复制算法**   
将内存分成两块容量大小相等的区域，每次只使用其中一块，当这一块内存用完了，就将所有存活对象复制到另一块内存空间，然后清除前一块内存空间。这样一来就不容易出现内存碎片的问题。

**标记-整理算法**   
思想：在完成标记之后，它不是直接清理可回收对象，而是将存活对象都向一端移动，然后清理掉端边界以外的内存。   
不会产生内存碎片，但是依旧移动对象的成本

**分代收集算法**

分代收集算法是目前大部分JVM的垃圾收集器采用的算法。它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域。一般情况下将堆区划分为老年代（Tenured Generation）和新生代（Young Generation）,在堆区之外还有一个代就是永久代（Permanet Generation）。老年代的特点是每次垃圾收集时只有少量对象需要被回收，而新生代的特点是每次垃圾回收时都有大量的对象需要被回收，那么就可以根据不同代的特点采取最适合的收集算法

### **1.18  常见的垃圾收集器**  ###

Serial收集器（复制算法)   
新生代单线程收集器，标记和清理都是单线程，优点是简单高效。是client级别默认的GC方式，可以通过-XX:+UseSerialGC来强制指定。   
Serial Old收集器(标记-整理算法)   
老年代单线程收集器，Serial收集器的老年代版本。   
ParNew收集器(停止-复制算法)　   
新生代收集器，可以认为是Serial收集器的多线程版本,在多核CPU环境下有着比Serial更好的表现。   
Parallel Scavenge收集器(停止-复制算法)　   
并行收集器，追求高吞吐量，高效利用CPU。吞吐量一般为99%， 吞吐量= 用户线程时间/(用户线程时间+GC线程时间)。适合后台应用等对交互相应要求不高的场景。是server级别默认采用的GC方式，可用-XX:+UseParallelGC来强制指定，用-XX:ParallelGCThreads=4来指定线程数。   
Parallel Old收集器(停止-复制算法)   
Parallel Scavenge收集器的老年代版本，并行收集器，吞吐量优先。   
CMS(Concurrent Mark Sweep)收集器（标记-清理算法）   
高并发、低停顿，追求最短GC回收停顿时间，cpu占用比较高，响应时间快，停顿时间短，多核cpu 追求高响应时间的选择。

垃圾回收器从线程运行情况分类有三种

1.  串行回收，Serial回收器，单线程回收，全程stw；
2.  并行回收，名称以Parallel开头的回收器，多线程回收，全程stw；
3.  并发回收，cms与G1，多线程分阶段回收，只有某阶段会stw；

CMS收集器基于“标记-清除”算法实现，

优点：并发收集、低停顿

缺点：无法处理浮动垃圾导致Full GC产生容易出现大量空间碎片

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

1、并行于并发：G1能充分利用CPU、多核环境下的硬件优势，使用多个CPU（CPU或者CPU核心）来缩短stop-The-World停顿时间。

2、分代收集

3、建立可预测的停顿时间模型

### 1.19  GC什么时候被触发的 ？ ###

由于对象进行了分代处理，因此垃圾回收区域、时间也不一样。GC有两种类型：Minor GC和Full GC

一般情况下，当新对象生成，并且在Eden申请空间失败时，就会触发Minor GC，对Eden区域进行GC，清除非存活对象，并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。

Full GC   
对整个堆进行整理，包括Young、Tenured和Perm。Full GC因为需要对整个堆进行回收，所以比Scavenge GC要慢，因此应该尽可能减少Full GC的次数。在对JVM调优的过程中，很大一部分工作就是对于Full GC的调节。有如下原因可能导致Full GC：   
a) 年老代（Tenured）被写满；   
b) 持久代（Perm）被写满；   
c) System.gc()被显示调用；   
d) 上一次GC之后Heap的各域分配策略动态变化

### **1.20 jvm查看gc命令**   ###

jstat -gc 12538 5000   
即会每5秒一次显示进程号为12538的java进成的GC情况

### **1.21 类加载为什么要使用双亲委派模式，有没有什么场景是打破了这个模式？**  ###

在Java中判断两个类是否是同一个类，不仅仅是类的全限定名称相同，还需要加载它们的类加载器相同。使用双亲委派模式，加载Object类时会始终使用启动类加载器进行加载，而不会使用自定义类加载器，如果不使用双亲委派模式的话程序会混乱不堪。

JNDI服务打破了双亲委派模式。按照双亲委派模式，启动类加载器会加载JNDI，此时启动类加载器找到无法对各厂商具体实现，引入了ThreadContextClassLoader，父加载器会请求子加载器对其进行加载。

###    **1.22  类的实例化顺序？**  ###

大致的顺序是，先静态方法、再构造方法，先父类后子类。

（1）父类静态成员和静态初始化块，按代码顺序；

（2）子类静态成员和静态初始化块，按代码顺序；

（3）父类实例成员和实例初始化块，按代码顺序；

（4）父类构造方法；

（5）子类实例成员和实例初始化块，按代码顺序；

（6）子类构造方法。

### 1.23 java内存模型 ###

Java内存模型是围绕着并发编程中原子性、可见性、有序性这三个特征来建立的，那我们依次看一下这三个特征：

**原子性（Atomicity）**：一个操作不能被打断，要么全部执行完毕，要么不执行。在这点上有点类似于事务操作，要么全部执行成功，要么回退到执行该操作之前的状态。

基本类型数据的访问大都是原子操作，long 和double类型的变量是64位，但是在32位JVM中，32位的JVM会将64位数据的读写操作分为2次32位的读写操作来进行，这就导致了long、double类型的变量在32位虚拟机中是非原子操作，数据有可能会被破坏，也就意味着多个线程在并发访问的时候是线程非安全的。

**可见性：**一个线程对共享变量做了修改之后，其他的线程立即能够看到（感知到）该变量这种修改（变化）。

Java内存模型是通过将在工作内存中的变量修改后的值同步到主内存，在读取变量前从主内存刷新最新值到工作内存中，这种依赖主内存的方式来实现可见性的。

无论是普通变量还是volatile变量都是如此，区别在于：volatile的特殊规则保证了volatile变量值修改后的新值立刻同步到主内存，每次使用volatile变量前立即从主内存中刷新，因此volatile保证了多线程之间的操作变量的可见性，而普通变量则不能保证这一点。

除了volatile关键字能实现可见性之外，还有synchronized,Lock，final也是可以的。

使用synchronized关键字，在同步方法/同步块开始时（Monitor Enter）,使用共享变量时会从主内存中刷新变量值到工作内存中（即从主内存中读取最新值到线程私有的工作内存中），在同步方法/同步块结束时(Monitor Exit),会将工作内存中的变量值同步到主内存中去（即将线程私有的工作内存中的值写入到主内存进行同步）。

使用Lock接口的最常用的实现ReentrantLock(重入锁)来实现可见性：当我们在方法的开始位置执行lock.lock()方法，这和synchronized开始位置（Monitor Enter）有相同的语义，即使用共享变量时会从主内存中刷新变量值到工作内存中（即从主内存中读取最新值到线程私有的工作内存中），在方法的最后finally块里执行lock.unlock()方法，和synchronized结束位置（Monitor Exit）有相同的语义,即会将工作内存中的变量值同步到主内存中去（即将线程私有的工作内存中的值写入到主内存进行同步）。

final关键字的可见性是指：被final修饰的变量，在构造函数数一旦初始化完成，并且在构造函数中并没有把“this”的引用传递出去（“this”引用逃逸是很危险的，其他的线程很可能通过该引用访问到只“初始化一半”的对象），那么其他线程就可以看到final变量的值。

**　　有序性：**对于一个线程的代码而言，我们总是以为代码的执行是从前往后的，依次执行的。这么说不能说完全不对，在单线程程序里，确实会这样执行；但是在多线程并发时，程序的执行就有可能出现乱序。用一句话可以总结为：在本线程内观察，操作都是有序的；如果在一个线程中观察另外一个线程，所有的操作都是无序的。前半句是指“线程内表现为串行语义（WithIn Thread As-if-Serial Semantics）”,后半句是指“指令重排”现象和“工作内存和主内存同步延迟”现象。

Java提供了两个关键字volatile和synchronized来保证多线程之间操作的有序性,volatile关键字本身通过加入内存屏障来禁止指令的重排序，而synchronized关键字通过一个变量在同一时间只允许有一个线程对其进行加锁的规则来实现，

在单线程程序中，不会发生“指令重排”和“工作内存和主内存同步延迟”现象，只在多线程程序中出现。

## ##

### 1.21 内存泄漏与内存溢出区别，产生原因？ ###

内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用

内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间

内存溢出的原因：

1.内存中加载的数据量过于庞大，如一次从数据库取出过多数据；  
2.集合类中有对对象的引用，使用完后未清空，使得JVM不能回收；  
3.代码中存在死循环或循环产生过多重复的对象实体

4.启动参数内存值设定的过小

###  1.22 如何解决内存溢出？ ###

（1）[用jmap生成堆信息][jmap]

jmap -dump:format=b,file=dumpFileName pid

![20190305100157130.png][]

（2）将文件导入Visual VM中进行分析

## 2、集合框架 ##

### 2.1 **HashMap和HashTable有何不同？** ###

（1）HashMap允许key和value为null，而HashTable不允许。

（2）HashTable是同步的，而HashMap不是。所以HashMap适合单线程环境，HashTable适合多线程环境。

（3）在Java1.4中引入了LinkedHashMap，HashMap的一个子类，假如你想要遍历顺序，你很容易从HashMap转向LinkedHashMap，但是HashTable不是这样的，它的顺序是不可预知的。

（4）HashMap提供对key的Set进行遍历，因此它是fail-fast的，但HashTable提供对key的Enumeration进行遍历，它不支持fail-fast。

（5）HashTable被认为是个遗留的类，如果你寻求在迭代的时候修改Map，你应该使用CocurrentHashMap。

### 2.2  **ArrayList和Vector有何异同点？** ###

ArrayList和Vector在很多时候都很类似。

（1）两者都是基于索引的，内部由一个数组支持。

（2）两者维护插入的顺序，我们可以根据插入顺序来获取元素。

（3）ArrayList和Vector的迭代器实现都是fail-fast的。

（4）ArrayList和Vector两者允许null值，也可以使用索引值对元素进行随机访问。

以下是ArrayList和Vector的不同点。

（1）Vector是同步的，而ArrayList不是。然而，如果你寻求在迭代的时候对列表进行改变，你应该使用CopyOnWriteArrayList。

（2）ArrayList比Vector快，它因为有同步，不会过载。

（3）ArrayList更加通用，因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。

### 2.3 **ArrayList和LinkedList有何区别？** ###

ArrayList和LinkedList两者都实现了List接口，但是它们之间有些不同。

（1）ArrayList是由Array所支持的基于一个索引的数据结构，所以它提供对元素的随机访问，复杂度为O(1)，但LinkedList存储一系列的节点数据，每个节点都与前一个和下一个节点相连接。所以，尽管有使用索引获取元素的方法，内部实现是从起始点开始遍历，遍历到索引的节点然后返回元素，时间复杂度为O(n)，比ArrayList要慢。

（2）与ArrayList相比，在LinkedList中插入、添加和删除一个元素会更快，因为在一个元素被插入到中间的时候，不会涉及改变数组的大小，或更新索引。

（3）LinkedList比ArrayList消耗更多的内存，因为LinkedList中的每个节点存储了前后节点的引用。

### 2.4 发生hash碰撞的原因 ###

（1）散列函数，一个好的散列函数的值应尽可能平均分布。  
（2）处理冲突方法。  
（3）负载因子的大小。

### 2.5    解决冲突的办法 ###

（1）线性探查法：冲突后，线性向前试探，找到近期的一个空位置。缺点是会出现堆积现象。存取时，可能不是同义词的词也位于探查序列，影响效率。  
     （2）双散列函数法：在位置d冲突后，再次使用还有一个散列函数产生一个与散列表桶容量m互质的数c，依次试探(d+n\*c)%m，使探查序列跳跃式分布。

### 2.6 **经常使用的构造散列函数的方法** ###

**1. 直接寻址法：**取key或key的某个线性函数值为散列地址。即H(key)=key或H(key) = a•key + b，当中a和b为常数（这样的散列函数叫做自身函数）

**2. 数字分析法：**分析一组数据，比方一组员工的出生年月日，这时我们发现出生年月日的前几位数字大体同样，这样的话，出现冲突的几率就会非常大，可是我们发现年月日的后几位表示月份和详细日期的数字区别非常大，假设用后面的数字来构成散列地址，则冲突的几率会明显减少。因此数字分析法就是找出数字的规律，尽可能利用这些数据来构造冲突几率较低的散列地址。

**3. 平方取中法：**取key平方后的中间几位作为散列地址。

**4. 折叠法：**将key切割成位数同样的几部分，最后一部分位数能够不同，然后取这几部分的叠加和（去除进位）作为散列地址。

**5. 随机数法：**选择一随机函数，取key的随机值作为散列地址，通经常使用于key长度不同的场合。

**6. 除留余数法：**取key被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p, p<=m。不仅能够对key直接取模，也可在折叠、平方取中等运算之后取模。对p的选择非常重要，一般取素数或m，若p选的不好，容易产生同义词。

### 2.7 HsahMap的put过程 ###

1.  判断当前桶是否为空，空的就需要初始化（resize 中会判断是否进行初始化）。
2.  根据当前 key 的 hashcode 定位到具体的桶中并判断是否为空，为空表明没有 Hash 冲突就直接在当前位置创建一个新桶即可。
3.  如果当前桶有值（ Hash 冲突），那么就要比较当前桶中的 `key、key 的 hashcode` 与写入的 key 是否相等，相等就赋值给 `e`,在第 8 步的时候会统一进行赋值及返回。
4.  如果当前桶为红黑树，那就要按照红黑树的方式写入数据。
5.  如果是个链表，就需要将当前的 key、value 封装成一个新节点写入到当前桶的后面（形成链表）。
6.  接着判断当前链表的大小是否大于预设的阈值，大于时就要转换为红黑树。
7.  如果在遍历过程中找到 key 相同时直接退出遍历。
8.  如果 `e != null` 就相当于存在相同的 key,那就需要将值覆盖。
9.  最后判断是否需要进行扩容。

### 2.8 HashMap 的get过程 ###

1.  首先将 key hash 之后取得所定位的桶。
2.  如果桶为空则直接返回 null 。
3.  否则判断桶的第一个位置(有可能是链表、红黑树)的 key 是否为查询的 key，是就直接返回 value。
4.  如果第一个不匹配，则判断它的下一个是红黑树还是链表。
5.  红黑树就按照树的查找方式返回值。
6.  不然就按照链表的方式遍历匹配返回值。

###  2.9 ConcurrentHashMap 的put过程 ###

1.  根据 key 计算出 hashcode 。
2.  判断是否需要进行初始化。
3.  `f` 即为当前 key 定位出的 Node，如果为空表示当前位置可以写入数据，利用 CAS 尝试写入，失败则自旋保证成功。
4.  如果当前位置的 `hashcode == MOVED == -1`,则需要进行扩容。
5.  如果都不满足，则利用 synchronized 锁（锁对象为首节点）写入数据。
6.  如果数量大于 `TREEIFY_THRESHOLD` 则要转换为红黑树。

### 2.10  ConcurrentHashMap的get过程 ###

1.  根据计算出来的 hashcode 寻址，如果就在桶上那么直接返回值。
2.  如果是红黑树那就按照树的方式获取值。
3.  就不满足那就按照链表的方式遍历获取值

### 2.11 不安全使用HashMap会导致的安全问题？ ###

（1）**多线程put的时候可能导致元素丢失**

在多线程下put操作时，执行addEntry(hash, key, value, i)，如果有产生哈希碰撞，导致两个线程得到同样的bucketIndex去存储，就可能会出现覆盖丢失的情况

（2）HashMap在多线程put后可能导致get死循环

transfer(newTable)，这个操作会把当前Entry\[\] table数组的全部元素转移到新的table中。这个transfer的过程**在并发环境下会发生错误，导致数组链表中的链表形成循环链表，在后面的get操作时e = e.next操作无限循环**

## ##

## 3、多线程 ##

## 3.1 **现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？** ##

Thread t1 = new Thread(() -> System.out.println("t1执行"));
    		Thread t2 = new Thread(() -> System.out.println("t2执行"));
    		Thread t3 = new Thread(() -> System.out.println("t3执行"));
    		try {
    			// t1先启动
    			t1.start();
    			t1.join();
    			// t2
    			t2.start();
    			t2.join();
    			// t3
    			t3.start();
    			t3.join();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}

上述主要是利用join方法  等待该线程终止。主线程等待t1执行完     再开启t2线程，等待t2线程执行完再执行线程t3

join方法源码分析

public final synchronized void join(long millis)throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
    
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
    
            if (millis == 0) {
                while (isAlive()) {
                    wait(0);
                }
            } else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }

### 3.2 什么是线程 ###

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。

### 3.3 线程和进程有什么区别？ ###

线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间

### 3.4 Java中Runnable和Callable有什么不同？ ###

Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。它们的主要区别是

(1)Callable规定的方法是call()，Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下，直接启动一个线程来执行，而Callable则一般都是提交给ExecuteService来执行。

(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得

(3)call方法可以抛出异常，run方法不可以

(4)运行Callable任务可以拿到一个Future对象，c表示异步计算的结果。

### 3.5 Java中CountDownLatch 和CyclicBarrier 有什么不同？ ###

CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能，**一个线程**(或者多个)， 等待另外**N个线程**完成**某个事情**之后才能执行

CyclicBarrier通过它可以实现让一组线程等待至某个状态之后再全部同时执行，CyclicBarrier可以被重用

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">CountDownLatch</p> </td> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">CyclicBarrier</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">减计数方式</p> </td> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">加计数方式</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">计算为0时释放所有等待的线程</p> </td> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">计数达到指定值时释放所有等待线程</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">计数为0时，无法重置</p> </td> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">计数达到指定值时，计数置为0重新开始</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">调用countDown()方法计数减一，调用await()方法只进行阻塞，对计数没任何影响</p> </td> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">调用await()方法计数加1，若加1后的值不等于构造方法的值，则线程阻塞</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">不可重复利用</p> </td> 
   <td style="vertical-align:top;width:213.05pt;"> <p style="margin-left:0cm;">可重复利用</p> </td> 
  </tr> 
 </tbody> 
</table>

### 3.6 线程运行的多种状态 ###

*           ***创建***  new Thread类或者其子类对象。
 *           ***运行*** start().  具备者CPU的执行资格和CPU的执行权。
 *           ***冻结*** 释放了CPU的执行资格和CPU的执行权。比如执行到sleep(time)  wait() 导致线程冻结。
 *           ***临时阻塞状态***： 具备者CPU的执行资格，不具备CPU的执行权。
 *          ***消亡***：线程结束。run方法结束

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 1][]

### 3.7 Java中的volatile 变量是什么？ ###

volatile是一个特殊的修饰符，只有成员变量才能使用它。　当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

volatile特性一：内存可见性，即线程A对volatile变量的修改，其他线程获取的volatile变量都是最新的。

volatile特性二：可以禁止指令重排序

volatile关键字保证了操作的可见性，但是不能保证对变量的操作是原子性。

### 3.8 **volatile的原理和实现机制** ###

加入volatile关键字时，生成的汇编代码会多出一个lock前缀指令

lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

2）它会强制将对缓存的修改操作立即写入主存；

3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

### 3.9 使用volatile关键字的场景 ###

1、状态标记量

volatile boolean flag= false;
     
    // 线程1
    context = loadContext();
    flag= true;
     
    // 线程2
    while(!flag) {
        sleep();
    }
    doSomethingWithConfig(context);

2、双重检查

所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

public class Singleton {
    	private volatile static Singleton instance = null;
    
    	private Singleton() {}
    
    	public static Singleton getInstance() {
    		if (instance == null) {
    			synchronized (Singleton.class) {// 1
    				if (instance == null) {// 2
    					instance = new Singleton();// 3
    				}
    			}
    		}
    		return instance;
    	}
    }

3、独立观察（independent observation）

安全使用 volatile 的另一种简单模式是：定期 “发布” 观察结果供程序内部使用。例如，假设有一种环境传感器能够感觉环境温度。一个后台线程可能会每隔几秒读取一次该传感器，并更新包含当前文档的 volatile 变量。然后，其他线程可以读取这个变量，从而随时能够看到最新的温度值。

使用该模式的另一种应用程序就是收集程序的统计信息。下面程序 展示了身份验证机制如何记忆最近一次登录的用户的名字。将反复使用lastUser引用来发布值，以供程序的其他部分使用。

public class UserManager {
        public volatile String lastUser;
     
        public boolean authenticate(String user, String password) {
            boolean valid = passwordIsValid(user, password);
            if (valid) {
                User u = new User();
                activeUsers.add(u);
                lastUser = user;
            }
            return valid;
        }
    }

4、“volatile bean” 模式

volatile bean 模式适用于将 JavaBeans 作为“荣誉结构”使用的框架。在 volatile bean 模式中，JavaBean 被用作一组具有 getter 和/或 setter 方法 的独立属性的容器。volatile bean 模式的基本原理是：很多框架为易变数据的持有者（例如 `HttpSession`）提供了容器，但是放入这些容器中的对象必须是线程安全的。

在 volatile bean 模式中，JavaBean 的所有数据成员都是 volatile 类型的，并且 getter 和 setter 方法必须非常普通 —— 除了获取或设置相应的属性外，不能包含任何逻辑。此外，对于对象引用的数据成员，引用的对象必须是有效不可变的。（这将禁止具有数组值的属性，因为当数组引用被声明为 volatile 时，只有引用而不是数组本身具有 volatile 语义）。对于任何 volatile 变量，不变式或约束都不能包含 JavaBean 属性。下面代码示例展示了遵守 volatile bean 模式的 JavaBean：

@ThreadSafe
    public class Person {
        private volatile String firstName;
        private volatile String lastName;
        private volatile int age;
     
        public String getFirstName() { return firstName; }
        public String getLastName() { return lastName; }
        public int getAge() { return age; }
     
        public void setFirstName(String firstName) { 
            this.firstName = firstName;
        }
     
        public void setLastName(String lastName) { 
            this.lastName = lastName;
        }
     
        public void setAge(int age) { 
            this.age = age;
        }
    }

5 、开销较低的读－写锁策略

目前为止，您应该了解了 volatile 的功能还不足以实现计数器。因为++x 实际上是三种操作（读、添加、存储）的简单组合，如果多个线程凑巧试图同时对 volatile 计数器执行增量操作，那么它的更新值有可能会丢失。

然而，如果读操作远远超过写操作，您可以结合使用内部锁和 volatile 变量来减少公共代码路径的开销。清单 6 中显示的线程安全的计数器使用synchronized确保增量操作是原子的，并使用volatile 保证当前结果的可见性。如果更新不频繁的话，该方法可实现更好的性能，因为读路径的开销仅仅涉及 volatile 读操作，这通常要优于一个无竞争的锁获取的开销。

@ThreadSafe
    public class CheesyCounter {
        // Employs the cheap read-write lock trick
        // All mutative operations MUST be done with the 'this' lock held
        @GuardedBy("this") private volatile int value;
     
        public int getValue() { return value; }
     
        public synchronized int increment() {
            return value++;
        }
    }

有关volatile 查看[更多][Link 1]

### 3.10 如何终止一个线程 ###

Java提供了很丰富的API但没有为停止线程提供API。JDK 1.0本来有一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了，之后Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程，你可以用volatile 布尔变量来退出run()方法的循环或者是取消任务来中断线程。示例代码

public class StopThreadDemo implements Runnable {
    
    	private volatile boolean stopFlag = false;
    
    	@Override
    	public void run() {
    
    		while (!stopFlag) {
    			synchronized (StopThreadDemo.class) {
    				System.out.println("我好忙啊，我在做事情！");
    				try {
    					StopThreadDemo.class.wait();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    					this.stopThread();
    				}
    			}
    		}
    	}
    
    	private void stopThread() {
    		stopFlag = true;
    		System.out.println("老子把线程给停了！");
    	}
    
    	public static void main(String[] args) {
    		StopThreadDemo d = new StopThreadDemo();
    		Thread t1 = new Thread(d, "旺财");
    		Thread t2 = new Thread(d, "小强");
    		try {
    			t1.start();
    			t2.start();
    			Thread.sleep(5000);
    			t1.interrupt();// 对t1线程对象进行中断状态的清除，强制让其恢复到运行状态。
    			t2.interrupt();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    }

### 3.11 生产者消费者模型 ###

class BoundedBuffer {
       final Lock lock = new ReentrantLock();
       final Condition notFull  = lock.newCondition(); 
       final Condition notEmpty = lock.newCondition(); 
    
       final Object[] items = new Object[100];
       int putptr, takeptr, count;
    
       public void put(Object x) throws InterruptedException {
         lock.lock();
         try {
           while (count == items.length) 
             notFull.await();
           items[putptr] = x; 
           if (++putptr == items.length) putptr = 0;
           ++count;
           notEmpty.signal();
         } finally {
           lock.unlock();
         }
       }
    
       public Object take() throws InterruptedException {
         lock.lock();
         try {
           while (count == 0) 
             notEmpty.await();
           Object x = items[takeptr]; 
           if (++takeptr == items.length) takeptr = 0;
           --count;
           notFull.signal();
           return x;
         } finally {
           lock.unlock();
         }
       } 
     }

### 3.12 什么是ThreadLocal变量？ ###

ThreadLocal是线程本地的变量，只要是本线程内都可以使用，线程结束了，那么相应的线程本地变量也就跟随着线程消失了。

在Thread类里面有一个ThreadLocalMap，用于存储每一个线程的变量的引用，这个Map中的键为ThreadLocal对象，而值对应的是ThreadLocal通过set放进去的变量引用。

### 3.13 什么是FutureTask？ ###

在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法，此类提供了对 Future 的基本实现。只有当运算完成的时候结果才能取回，如果运算尚未完成get方法将会阻塞。可使用 FutureTask 包装 Callable 或 Runnable 对象。因为 FutureTask 实现了 Runnable，所以可将 FutureTask 提交给 Executor 执行

### 3.14 Java中interrupt 、interrupted 和 isInterruptedd方法的区别？ ###

interrupt 中断线程。

如果当前线程没有中断它自己（这在任何情况下都是允许的），则该线程的 `checkAccess` 方法就会被调用，这可能抛出 `SecurityException`。

如果线程在调用 `Object` 类的 `wait()`、`wait(long)` 或 `wait(long, int)` 方法，或者该类的 `join()`、`join(long)`、`join(long, int)`、`sleep(long)` 或 `sleep(long, int)` 方法过程中受阻，则其中断状态将被清除，它还将收到一个 `InterruptedException`。

如果该线程在可中断的通道上的 I/O 操作中受阻，则该通道将被关闭，该线程的中断状态将被设置并且该线程将收到一个 `ClosedByInterruptException`。

如果该线程在一个 `Selector` 中受阻，则该线程的中断状态将被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用了选择器的 `wakeup` 方法一样。

如果以前的条件都没有保存，则该线程的中断状态将被设置。

中断一个不处于活动状态的线程不需要任何作用。

interrupted() 和 isInterrupted()的主要区别是前者会将中断状态清除而后者不会。

（1）interrupted 是作用于当前线程，isInterrupted 是作用于调用该方法的线程对象所对应的线程。

（2）这两个方法最终都会调用同一个方法isInterrupted（boolean flag），只不过参数一个是true，一个是false。是前者会将中断状态清除而后者不会。

### 3.15 Java中的同步集合与并发集合有什么区别？ ###

不管是同步集合还是并发集合他们都支持线程安全，他们之间主要的区别体现在性能和可扩展性，还有他们如何实现的线程安全。同步HashMap, Hashtable, HashSet, Vector, ArrayList 相比他们并发的实现（比如：ConcurrentHashMap, CopyOnWriteArrayList, CopyOnWriteHashSet）会慢得多。造成如此慢的主要原因是锁， 同步集合会把整个Map或List锁起来，而并发集合不会。并发集合实现线程安全是通过使用先进的和成熟的技术像锁剥离。比如ConcurrentHashMap 会把整个Map 划分成几个片段，只对相关的几个片段上锁，同时允许多线程访问其他未上锁的片段。

### 3.16 常用的线程池 ###

ThreadPoolExecutor

构造方法：

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
    TimeUnit unit,BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,RejectedExecutionHandler handler)

**参数：**

`corePoolSize` \- 池中所保存的线程数，包括空闲线程。

`maximumPoolSize` \- 池中允许的最大线程数。

`keepAliveTime` \- 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。

`unit` \- keepAliveTime 参数的时间单位。

`workQueue` \- 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。

`threadFactory` \- 执行程序创建新线程时使用的工厂。

`handler` \- 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。

<table>  超出线程范围和队列容量而使执行被阻塞时所使用的处理程序  
 <tbody> 
  <tr> 
   <td style="width:226px;">策略</td> 
   <td style="width:623px;">含义</td> 
  </tr> 
  <tr> 
   <td style="width:226px;"><a rel="nofollow">ThreadPoolExecutor.AbortPolicy</a></td> 
   <td style="width:623px;">&nbsp;&nbsp;用于被拒绝任务的处理程序，它将抛出 RejectedExecutionException</td> 
  </tr> 
  <tr> 
   <td style="width:226px;"><a rel="nofollow">ThreadPoolExecutor.CallerRunsPolicy</a></td> 
   <td style="width:623px;">&nbsp;用于被拒绝任务的处理程序，它直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务。</td> 
  </tr> 
  <tr> 
   <td style="width:226px;"><a rel="nofollow">ThreadPoolExecutor.DiscardOldestPolicy</a>&nbsp;</td> 
   <td style="width:623px;">用于被拒绝任务的处理程序，它放弃最旧的未处理请求，然后重试 execute；如果执行程序已关闭，则会丢弃该任务。</td> 
  </tr> 
  <tr> 
   <td style="width:226px;"><a rel="nofollow">ThreadPoolExecutor.DiscardPolicy</a>&nbsp;</td> 
   <td style="width:623px;">用于被拒绝任务的处理程序，默认情况下它将丢弃被拒绝的任务。</td> 
  </tr> 
 </tbody> 
</table>

*  AbortPolicy 丢弃任务，抛运行时异常
 *  CallerRunsPolicy 执行任务
 *  DiscardPolicy 忽视，什么都不会发生
 *  DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务

线程池工具类 Executors 可以构造常用的线程池

<table> 
 <tbody> 
  <tr> 
   <td style="width:292px;">线程池</td> 
   <td style="width:557px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:292px;">newFixedThreadPool(int nThreads)</td> 
   <td style="width:557px;"> <pre><code> public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue&lt;Runnable&gt;());
    }</code></pre> <p>创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程</p> </td> 
  </tr> 
  <tr> 
   <td style="width:292px;">newCachedThreadPool()</td> 
   <td style="width:557px;"> <pre><code>    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue&lt;Runnable&gt;());
    }</code></pre> <p>创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们</p> </td> 
  </tr> 
  <tr> 
   <td style="width:292px;">newScheduledThreadPool(int corePoolSize)</td> 
   <td style="width:557px;"> <p>&nbsp;</p> <p>创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:292px;">newSingleThreadExecutor()</td> 
   <td style="width:557px;"> <pre><code>  public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue&lt;Runnable&gt;()));
    }
</code></pre> <p>创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程</p> </td> 
  </tr> 
 </tbody> 
</table>

### 3.17 sleep和wait的区别? ###

1.  sleep和wait都会使线程进入冻结状态，并且都会释放cpu的执行权和cpu的执行资格，不同的是sleep不会释放锁，而wait会连锁一起释放。
2.  sleep()方法可以在任何地方使用；wait()方法则只能在同步方法或同步块中使用
3.  sleep方法是Thread类中定义的方法,wait是Object中定义的方法

### 3.18  fail-fast和fail-safe机制 ###

fail-fast即快速失败机制，是java集合(Collection)中的一种错误检测机制。当在迭代集合的过程中该集合在结构上发生改变的时候，就有可能会发生fail-fast，即抛出ConcurrentModificationException异常

fail-safe 采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历

### 3.19 JVM性能调优监控工具jps、jstack、jmap、jhat、jstat、hprof使用 ###

A、 jps(Java Virtual Machine Process Status Tool)

jps主要用来输出JVM中运行的进程状态信息。语法格式如下：

jps [options] [hostid]

如果不指定hostid就默认为当前主机或服务器。

命令行参数选项说明如下：

-q 不输出类名、Jar名和传入main方法的参数
    
    -m 输出传入main方法的参数
    
    -l 输出main类或Jar的全限名
    
    -v 输出传入JVM的参数

比如下面：

![20190218151725956.png][]

B、 jstack

jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下：

jstack [option] pid
    jstack [option] executable core
    jstack [option] [server-id@]remote-hostname-or-ip

命令行参数选项说明如下：

-l long listings，会打印出额外的锁信息，在发生死锁时可以用jstack -l pid来观察锁持有情况-m mixed mode，不仅会输出Java堆栈信息，还会输出C/C++堆栈信息（比如Native方法）

jstack可以定位到线程堆栈，根据堆栈信息我们可以定位到具体代码，所以它在JVM性能调优中使用得非常多。下面我们来一个实例找出某个Java进程中最耗费CPU的Java线程并定位堆栈信息，用到的命令有ps、top、printf、jstack、grep。

查找最消耗cpu的java线程

命令：可以使用ps -Lfp pid或者ps -mp pid -o THREAD, tid, time或者top -Hp pid

![format_png 1][]

TIME列就是各个Java线程耗费的CPU时间，CPU时间最长的是线程ID为21742的线程，用

printf "%x\n" 21742

得到21742的十六进制值为54ee，下面会用到。

OK，下一步终于轮到jstack上场了，它用来输出进程21711的堆栈信息，然后根据线程ID的十六进制值grep，如下：

root@ubuntu:/# jstack 21711 | grep 54ee
    "PollIntervalRetrySchedulerThread" prio=10 tid=0x00007f950043e000 nid=0x54ee in Object.wait() [0x00007f94c6eda000

C、 jmap（Memory Map）和jhat（Java Heap Analysis Tool）

jmap用来查看堆内存使用状况，一般结合jhat使用。

jmap语法格式如下：

jmap [option] pid
    jmap [option] executable core
    jmap [option] [server-id@]remote-hostname-or-ip

D、jstat（JVM统计监测工具）

语法格式如下：

jstat [ generalOption | outputOptions vmid [interval[s|ms] [count]] ]

vmid是Java虚拟机ID，在Linux/Unix系统上一般就是进程ID。interval是采样时间间隔。count是采样数目。比如下面输出的是GC信息，采样时间间隔为250ms，采样数为4：![20190218155734807.png][]

![20160220110058880 (558Ã231)][20160220110058880 _558_231]

可以看出：

堆内存 = 年轻代 + 年老代 
    年轻代 = Eden区 + 两个Survivor区（From和To）

现在来解释各列含义：

S0C、S1C、S0U、S1U：Survivor 0/1区容量（Capacity）和使用量（Used）
    EC、EU：Eden区容量和使用量
    OC、OU：年老代容量和使用量
    MC、MU：元数据空间容量和使用量
    CCSC、CCSU
    YGC、YGT：年轻代GC次数和GC耗时
    FGC、FGCT：Full GC次数和Full GC耗时
    GCT：GC总耗时

E、hprof（Heap/CPU Profiling Tool）

hprof能够展现CPU使用率，统计堆内存使用情况。

语法格式如下：

java -agentlib:hprof[=options] ToBeProfiledClass
    java -Xrunprof[:options] ToBeProfiledClass
    javac -J-agentlib:hprof[=options] ToBeProfiledClass

###  3.20  Java中的同步集合与并发集合有什么区别 ###

不管是同步集合还是并发集合他们都支持线程安全，他们之间主要的区别体现在**性能**和**可扩展性**，还有他们如何实现的线程安全。同步HashMap, Hashtable, HashSet, Vector, ArrayList 相比他们并发的实现（比如：ConcurrentHashMap, CopyOnWriteArrayList, CopyOnWriteHashSet）会慢得多。造成如此慢的主要原因是**锁**， 同步集合会把整个Map或List锁起来，而并发集合不会。并发集合实现线程安全是通过使用先进的和成熟的技术像锁剥离。比如ConcurrentHashMap 会把整个Map 划分成几个片段，只对相关的几个片段上锁，同时允许多线程访问其他未上锁的片段。

同样的，CopyOnWriteArrayList 允许多个线程以非同步的方式读，当有线程写的时候它会将整个List复制一个副本给它。

如果在读多写少这种对并发集合有利的条件下使用并发集合，这会比使用同步集合更具有可伸缩性。

同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用且在多线程并发的时候会导致争用，阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap，不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。

### 3.21 Java中synchronized 和 ReentrantLock 有什么不同 ###

这两种方式最大区别就是对于Synchronized来说，它是java语言的关键字，是原生语法层面的互斥，需要jvm实现。而ReentrantLock它是JDK 1.5之后提供的API层面的互斥锁，需要lock()和unlock()方法配合try/finally语句块来完成。

Synchronized进过编译，会在同步块的前后分别形成monitorenter和monitorexit这个两个字节码指令。在执行monitorenter指令时，首先要尝试获取对象锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象锁，把锁的计算器加1，相应的，在执行monitorexit指令时会将锁计算器就减1，当计算器为0时，锁就被释放了。如果获取对象锁失败，那当前线程就要阻塞，直到对象锁被另一个线程释放为止。

### 3.22 Java中的fork join框架是什么？ ###

Fork/Join框架是Java 7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。Fork/Join框架要完成两件事情：

1.任务分割：首先Fork/Join框架需要把大的任务分割成足够小的子任务，如果子任务比较大的话还要对子任务进行继续分割

2.执行任务并合并结果：分割的子任务分别放到双端队列里，然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都放在另外一个队列里，启动一个线程从队列里取数据，然后合并这些数据。

在Java的Fork/Join框架中，使用两个类完成上述操作

1.ForkJoinTask:我们要使用Fork/Join框架，首先需要创建一个ForkJoin任务。该类提供了在任务中执行fork和join的机制。通常情况下我们不需要直接集成ForkJoinTask类，只需要继承它的子类，Fork/Join框架提供了两个子类：

a.RecursiveAction：用于没有返回结果的任务

b.RecursiveTask:用于有返回结果的任务

2.ForkJoinPool:ForkJoinTask需要通过ForkJoinPool来执行

任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务(工作窃取算法)。

public class CountTask extends RecursiveTask<Integer>{
    
        private static final int THREAD_HOLD = 2;
    
        private int start;
        private int end;
    
        public CountTask(int start,int end){
            this.start = start;
            this.end = end;
        }
    
        @Override
        protected Integer compute() {
            int sum = 0;
            //如果任务足够小就计算
            boolean canCompute = (end - start) <= THREAD_HOLD;
            if(canCompute){
                for(int i=start;i<=end;i++){
                    sum += i;
                }
            }else{
                int middle = (start + end) / 2;
                CountTask left = new CountTask(start,middle);
                CountTask right = new CountTask(middle+1,end);
                //执行子任务
                left.fork();
                right.fork();
                //获取子任务结果
                int lResult = left.join();
                int rResult = right.join();
                sum = lResult + rResult;
            }
            return sum;
        }
    
        public static void main(String[] args){
            ForkJoinPool pool = new ForkJoinPool();
            CountTask task = new CountTask(1,4);
            Future<Integer> result = pool.submit(task);
            try {
                System.out.println(result.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

### 3.23 Java中的锁机制  偏向锁 & 轻量级锁 & 重量级锁各自优缺点及场景 ###

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;"> <p>锁</p> </td> 
   <td style="vertical-align:top;"> <p>优点</p> </td> 
   <td style="vertical-align:top;"> <p>缺点</p> </td> 
   <td style="vertical-align:top;"> <p>适用场景</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p>偏向锁</p> </td> 
   <td style="vertical-align:top;"> <p>加锁和解锁不需要额外的消耗，和执行非同步方法比仅存在纳秒级的差距。</p> </td> 
   <td style="vertical-align:top;"> <p>如果线程间存在锁竞争，会带来额外的锁撤销的消耗。</p> </td> 
   <td style="vertical-align:top;"> <p>适用于只有一个线程访问同步块场景。</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p>轻量级锁</p> </td> 
   <td style="vertical-align:top;"> <p>竞争的线程不会阻塞，提高了程序的响应速度。</p> </td> 
   <td style="vertical-align:top;"> <p>如果始终得不到锁竞争的线程使用自旋会消耗CPU。</p> </td> 
   <td style="vertical-align:top;"> <p>追求响应时间。</p> <p>同步块执行速度非常快。</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p>重量级锁</p> </td> 
   <td style="vertical-align:top;"> <p>线程竞争不使用自旋，不会消耗CPU。</p> </td> 
   <td style="vertical-align:top;"> <p>线程阻塞，响应时间缓慢。</p> </td> 
   <td style="vertical-align:top;"> <p>追求吞吐量。</p> <p>同步块执行速度较长。</p> </td> 
  </tr> 
 </tbody> 
</table>

### 3.24 **synchronized修饰代码块、普通方法、静态方法有什么区别。**  ###

修饰代码块获取的是指定的对象监视器。

修饰普通代码块并未显示使用monitorenter指令，而是通过标志位ACC\_SYNCHRONIZED标志位来判断是否由synchronized修饰，获取的是该实例对象的监视器。

修饰静态方法同普通方法，不同的是获取的是这个类的监视器

### 3.25 **synchronized 和** **lock** **有什么区别？**  ###

1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；

2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；

3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；

4.Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）

6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

### 3.26 什么是CAS? ###

使用锁时，线程获取锁是一种悲观锁策略，即假设每一次执行临界区代码都会产生冲突，所以当前线程获取到锁的时候同时也会阻塞其他线程获取该锁。而CAS操作（又称为无锁操作）是一种乐观锁策略，它假设所有线程访问共享资源的时候不会出现冲突，既然不会出现冲突自然而然就不会阻塞其他线程的操作。因此，线程就不会出现阻塞停顿的状态。那么，如果出现冲突了怎么办？无锁操作是使用CAS(compare and swap)又叫做比较交换来鉴别线程是否出现冲突，出现冲突就重试当前操作直到没有冲突为止。

CAS比较交换的过程可以通俗的理解为CAS(V,O,N)，包含三个值分别为：V 内存地址存放的实际值；O 预期的值（旧值）；N 更新的新值

### **3.27 Synchronized 和 CAS** ###

这是两者主要的区别是Synchronized在存在线程竞争的情况下会出现线程阻塞和唤醒锁带来的性能问题，因为这是一种互斥同步（阻塞同步）。

而CAS并不是武断的间线程挂起，当CAS操作失败后会进行一定的尝试，而非进行耗时的挂起唤醒的操作，因此也叫做非阻塞同步。

CAS的问题

1.  ABA问题  
    因为CAS会检查旧值有没有变化，这里存在这样一个有意思的问题。比如一个旧值A变为了成B，然后再变成A，刚好在做CAS时检查发现旧值并没有变化依然为A，但是实际上的确发生了变化。解决方案可以沿袭数据库中常用的乐观锁方式，添加一个版本号可以解决。原来的变化路径A->B->A就变成了1A->2B->3C。为了解决ABA问题，伟大的java为我们提供了AtomicMarkableReference和AtomicStampedReference类，为我们解决了问题
2.  自旋时间过长

### 3.28 java中原子操作 ###

（1）原子更新基本类型

atomic包提高原子更新基本类型的工具类，主要有这些：

1.  AtomicBoolean：以原子更新的方式更新boolean；
2.  AtomicInteger：以原子更新的方式更新Integer;
3.  AtomicLong：以原子更新的方式更新Long

（2）原子更新数组类型

atomic包下提供能原子更新数组中元素的类有：

1.  AtomicIntegerArray：原子更新整型数组中的元素；
2.  AtomicLongArray：原子更新长整型数组中的元素；
3.  AtomicReferenceArray：原子更新引用类型数组中的元素

（3）原子更新引用类型

如果需要原子更新引用类型变量的话，为了保证线程安全，atomic也提供了相关的类：

1.  AtomicReference：原子更新引用类型；
2.  AtomicReferenceFieldUpdater：原子更新引用类型里的字段；
3.  AtomicMarkableReference：原子更新带有标记位的引用类型；

（4）原子更新字段类型

如果需要更新对象的某个字段，并在多线程的情况下，能够保证线程安全，atomic同样也提供了相应的原子操作类：

*  AtomicIntegeFieldUpdater：原子更新整型字段类；
 *  AtomicLongFieldUpdater：原子更新长整型字段类；
 *  AtomicStampedReference：原子更新引用类型，这种更新方式会带有版本号。而为什么在更新的时候会带有版本号，是为了解决CAS的ABA问题；

要想使用原子更新字段需要两步操作：

1.  原子更新字段类都是抽象类，只能通过静态方法`newUpdater`来创建一个更新器，并且需要设置想要更新的类和属性；
2.  更新类的属性必须使用`public volatile`进行修饰；

## 4、**JavaWeb** ##

### **4.1 Http中Get和Post的区别** ###

1.  GET请求，请求的数据会附加在URL之后。POST请求，请求数据在请求体中
2.  GET请求传输的数据有大小限制，POST请求没有大小限制
3.  POST的安全性比GET的高

###  4.2 **tomcat的优化** ###

### （1）tomcat内存优化 ###

Tomcat内存优化主要是对 tomcat 启动参数优化，我们可以在 tomcat 的启动脚本 catalina.sh 中设置 java\_OPTS 参数。

JAVA\_OPTS参数说明

\-server 启用jdk 的 server 版；

\-Xms java虚拟机初始化时的最小内存；

\-Xmx java虚拟机可使用的最大内存；

\-XX: PermSize 内存永久保留区域

\-XX:MaxPermSize 内存最大永久保留区域

服务器参数配置

（2）Tomcat并发优化

修改Tomcat 配置文件 server.xml 中

maxThreads 客户请求最大线程数

minSpareThreads Tomcat初始化时创建的 socket 线程数

maxSpareThreads Tomcat连接器的最大空闲 socket 线程数

enableLookups 若设为true, 则支持域名解析，可把 ip 地址解析为主机名

redirectPort 在需要基于安全通道的场合，把客户请求转发到基于SSL 的 redirectPort 端口

acceptAccount 监听端口队列最大数，满了之后客户请求会被拒绝（不能小于maxSpareThreads ）

connectionTimeout 连接超时

minProcessors 服务器创建时的最小处理线程数

maxProcessors 服务器同时最大处理线程数

URIEncoding URL统一编码

（3）Tomcat缓存优化

compression 打开压缩功能

compressionMinSize 启用压缩的输出内容大小，这里面默认为2KB

compressableMimeType 压缩类型

connectionTimeout 定义建立客户连接超时的时间. 如果为 -1, 表示不限制建立客户连接的时间

### **4.3 Sevlet生命周期** ###

1. 第一次访问servlet,servlet会被创建，并将servlet对象常驻内存，调用init方法进行初始化操作，init方法中执行一次。

2. 开启一个线程，调用service方法，用于处理来自浏览器端的请求，以后都是开启一个线程来处理浏览器端请求。

3. 当tomcat服务器正常关闭时，会调用destroy方法将servlet销毁。

注意:servlet是线程不安全的，也就是说，不建议在servlet中创建成员变量

### **4.4 forward()和redirect()的区别** ###

1.  请求转发是一个请求，而重定向是两个请求；
2.  请求转发后浏览器地址栏不会有变化，而重定向会有变化，因为重定向是两个请求；
3.  请求转发的目标只能是本应用中的资源，重定向的目标可以是其他应用；
4.  请求转发对AServlet和BServlet的请求方法是相同的，即要么都是GET，要么都是POST，因为请求转发是一个请求；
5.  重定向的第二个请求一定是GET；

### **4.5 jsp中的九大内置对象** ###

1.  page     类型是Object
2.  request   类型是HttpServletRequest
3.  response  类型是HttpServletResponse
4.  session   类型是HttpSession
5.  application  类型是ServletContext
6.  out      类型是JspWriter
7.  config    类型是ServletConfig
8.  exception   类型是Throwable
9.  pageContext  类型是PageContext

### **4.6 ****jsp中的四个域对象** ###

pageContext:它代表的是page域，但是jsp中page它的类型是Object,所以操作page域我们使用的是pageContext对象,page域就是指当前页面范围

request :它是代表整个请求链

session:整个会话

application:整个web应用

servlet中有三个域对象

HttpServletRequest  整个请求链

HttpSession 整个会话

ServletContext 整个web应用。

对于域对象它们都具有以下方法

setAttribute(String name,Object value)

getAttribute(String name)

removeAttribute(String name)

### **4.7 Jsp与servlet的区别** ###

Jsp  java server page 运行在服务器上的页面，它的本质就是一个servlet.

Jsp与servlet区别:

Jsp它的主要作用是用于显示数据。

Servlet它的主要作用是用于处理请求完成业务逻辑操作。

### **4.8 TCP与UDP的区别** ###

UDP

\* 面向无连接，数据不安全，速度快。不区分客户端与服务端。

\*TCP

\* 面向连接（三次握手），数据安全，速度略低。分为客户端和服务端。

\* 三次握手: 客户端先向服务端发起请求, 服务端响应请求, 传输数据

### **4.9 tcp/udp协议在网络模型** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 2][]

### **4.10 说说你熟悉的响应码** ###

200：请求成功，浏览器会把响应体内容（通常是html）显示在浏览器中；

404：请求的资源没有找到，说明客户端错误的请求了不存在的资源；

500：请求资源找到了，但服务器内部出现了错误；

302：重定向，当响应码为302时，表示服务器要求浏览器重新再发一个请求，服务器会发送一个响应头Location，它指定了新请求的URL地址；

## 5 linux常用命令 ##

# #

### 5.1 基本命令 ###

（1）文件夹操作

*  ls    查看目录信息

ls -l   查看详细信息，等价于  ll

ls –a         查看隐藏文件

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 3][]

*   ifconfig   查看ip地址
 *   pwd     查看当前所处目录的绝对路径
 *  Ctrl+l清屏
 *  mkdir  ./test 创建文件夹

mkdir -p a/b/c  如果要创建的文件夹的父目录不存在，则自动创建

*  rmdir   删除空文件夹  (只能删除空文件夹)
 *  rm -r  /a/b  (删除非空文件夹)

删除文件

rm filename  (rm -r  删除文件夹     rm -rf 强制删除文件或文件夹)

### 5.2 创建文件 ###

*  touch a.avi 创建一个空文件
 *  echo "itcast is the greatest IT School" > itcast.txt把“>”左边的输出放到右边的文件里去
 *  vi  blabla.txt 用文本编辑器编辑一个文件并且保存，按esc退出编辑：wq退出

Vi编辑器

linux系统中最通用的文本编辑器

vi hello.world 进入文件编辑

进去之后处于非编辑模式，此时，要按一个i进入insert模式

![20190219171435186.png][]

在insert模式下，可以跟普通文本编辑器一样编辑内容

编辑完成之后，先按Esc退出insert模式，进入非编辑模式

然后再按 ：进入底行命令模式，在底行命令中敲入wq并回车，即可保存

如果想不保存退出，底行命令就用 q!

（保存文件的另一种模式： 编辑完后按Esc退出insert模式，然后直接按快捷键保存—— shift + zz）

### 5.3 移动文件、修改文件名 ###

*  mv a/wenjian1.txt b/file1.txt   (移动文件的同时还修改了文件名)
 *  rename ./a.txt ./b.txt

### 5.4 拷贝文件 ###

*  cp  srcFile  destFile

### 5.5 查看文本内容 ###

*  cat  log.a.txt  一次性显示整个文件内容
 *  more  log.a.txt 可以分页看（翻页：空格,往回翻：b ，退出： q或者 Ctrl+C）
 *  less  log.a.txt 不仅可以分页，还可以方便地搜索，回翻等操作（翻页：空格,往回翻：↑,往下翻:↓,退出：q或者 Ctrl+C）
 *  tail -10 log.a.txt   查看文件的尾部的10行
 *  tail -f user.log   实时刷新显示文件的尾部，这条命令对于观察调试程序的运行非常重要

Ctrl+C退出

*  head -20 log.a.txt 查看文件的头部20行

（2）文件归档压缩

### **5.6 打包/****解包** ###

tar -cvf testdir.tar testdir/

参数c :表示创建一个打包文档

v：显示打包的进度

f：表示要打成的tar包的名字

tar –xvf testdir.tar

参数x：表示从一个现存的tar文件中进行解包操作

### **5.7 压缩/****解压** ###

gzip testdir.tar

gzip –d testdir.tar.gz

### **5.8 归档并压缩/****解压** ###

tar -czvf  testdir.tar.gz testdir/

tar -xzvf testdir.tar.gz  解压到当前目录下

tar -xzvf testdir.tar.gz -C Downloads/   解压到指定的Downloads目录下

zip test.txt.zip test.txt

unzip test.txt.zip

### 5.9 网络服务启动与停止 ###

*  列出系统所有应用服务状态
    
    1.  service  --status-all
 *  查看指定服务运行状态：
    
    1.  service servicename status
 *  启动服务：
    
    1.  service servicename start
 *  停止服务：
    
    1.  service servicename stop

*  列出所有服务的随机自起配置：
    
    1.  chkconfig  --list
 *  关闭服务的随机自起：
    
    1.  chkconfig servicename off
 *  开启服务的随机自起：
    
    1.  chkconfig servicename on

*  常用示例：
    
    1.  重启网络服务 service network restart
    2.  停止httpd        service httpd stop
    3.  启动 httpd      service httpd start
    4.  关闭防火墙服务  service iptables stop
    5.  关闭防火墙自动启动   chkconfig iptables off
    6.  查看端口被那个进程占用 lsof -i:端口号  netstat -lnp|grep 88

![20190219171851550.png][]

##  6 mysql ##

### **6.1 乐观锁与悲观锁的区别？** ###

悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write\_condition机制的其实都是提供的乐观锁

### **6.2 事务的特性** ###

**原子性****:(Atomicity)**

原子性:强调事务的不可分割.

**一致性****:(Consistency)**

一致性:事务在执行的前后,数据的完整性保持一致.

**隔离性****:(Isolation)**

隔离性:多个事务并发执行的时候,一个事务的执行不应该受到其他的事务的干扰.

**持久性****:(Durability)**

持久性:事务一个结束了.数据就永久的保存到数据库.

### **6.3 不考虑事务的隔离性引发的一系列安全问题** ###

**\*** **脏读      :****一个事务读到了另一个事务未提交的数据.**

**\*** **不可重复读 :****一个事务读到了另一个事务已经提交的update****的数据,****导致在一个事务中多次的查询结果不一致.**

**\*** **虚读/****幻读  :****一个事务读到了另一个事务已经提交的insert****的数据,****导致在一个事务中多次查询的结果不一致.**

**\*** **数据库中提供了事务的隔离级别用于解决三类读问题.**

**\* read uncommitted  :****未提交读.****脏读、不可重复读、虚读都是有可能发生.**

**\* read committed    :****已提交读.****避免脏读.****但是不可重复读、虚读是有可能发生.**

**\* repeatable read   :****可重复读.****避免脏读、不可重复读.****但是虚读是有可能发生.**

**\* serializable      :****串行化的.****避免脏读、不可重复读、虚读的发生.**

**\*** **安全性:serializable > repeatable read > read committed > read uncommitted**

**\*** **效率性:read uncommitted > read committed > repeatable read > serializable**

**\*\*\*\*\* MYSQL****数据库默认隔离级别:repeatable read .Oracle****数据库默认的隔离级别:read committed**

### **6.4 mysql常用的数据库引擎** ###

![20190221091906149.png][]

**InnoDB**：支持事务处理，支持外键，支持崩溃修复能力和并发控制。如果需要对事务的完整性要求比较高（比如银行），要求实现并发控制（比如售票），那选择InnoDB有很大的优势。如果需要频繁的更新、删除操作的数据库，也可以选择InnoDB，因为支持事务的提交（commit）和回滚（rollback）。

InnoDB是提供了提交，回滚和崩溃恢复能力的事物安全存储引擎，支持行锁定和外键，是mysql的默认存储引擎

**MyISAM**：插入数据快，空间和内存使用比较低。如果表主要是用于插入新记录和读出记录，那么选择MyISAM能实现处理高效率。如果应用的完整性、并发性要求比较低，也可以使用。

MyISAM不支持事物 插入和查询的处理效率高，支持索引

**MEMORY**：所有的数据都在内存中，数据的处理速度快，但是安全性不高。如果需要很快的读写速度，对数据的安全性要求较低，可以选择MEMOEY。它对表的大小有要求，不能建立太大的表。所以，这类数据库只使用在相对较小的数据库表。

### **6.5 jdbc中Statement与Preparestament的区别** ###

第一：

prepareStatement会先初始化SQL，先把这个SQL提交到数据库中进行预处理，多次使用可提高效率。

Statement不会初始化，没有预处理.

第二：

prepareStatement可以替换变量在SQL语句中可以包含?，可以用

ps=conn.prepareStatement("select* from Cust where ID=?");
    
    int sid=1001;
    
    ps.setInt(1, sid);
    
    rs = ps.executeQuery();

可以把?替换成变量。

而Statement只能用

int sid=1001;
    
    Statement stmt = conn.createStatement();
    
    ResultSet rs = stmt.executeQuery("select * from Cust where ID="+sid);

来实现。

第三：

prepareStatement会先初始化SQL，先把这个SQL提交到数据库中进行预处理，多次使用可提高效率。

Statement不会初始化，没有预处理，没次都是从0开始执行SQL

### **6.6 sql优化** ###

1.  对查询进行优化，要尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。
2.  应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，最好不要给数据库留NULL，尽可能的使用 NOT NULL填充数据库.
3.  应尽量避免在 where 子句中使用 != 或 <> 操作符，否则将引擎放弃使用索引而进行全表扫描。

4、应尽量避免在 where 子句中使用 or 来连接条件，如果一个字段有索引，一个字段没有索引，将导致引擎放弃使用索引而进行全表扫描，如：

select id from t where num=10 or Name = 'admin'

可以这样查询：

select id from t where num = 10
    
    union all
    
    select id from t where Name = 'admin'

5、in 和 not in 也要慎用，否则会导致全表扫描

6、创建适合的索引

例如我们建立了一个这样的索引（area,age,salary），那么其实相当于创建了（area,age,salary）,(area,age),(area)三个索引

7、like语句优化

SELECT id FROM A WHERE name like '%abc%'

由于abc前面用了“%”，因此该查询必然走全表查询，除非必要，否则不要在关键词前加%，优化成如下

SELECT id FROM A WHERE name like 'abc%'

8、尽量用内连接替换外链接，用外链接替换子查询。

### **6.7 分表分库** ###

1 基本思想之什么是分库分表？  
从字面上简单理解，就是把原本存储于一个库的数据分块存储到多个库上，把原本存储于一个表的数据分块存储到多个表上。  
2 基本思想之为什么要分库分表？  
  
数据库中的数据量不一定是可控的，在未进行分库分表的情况下，随着时间和业务的发展，库中的表会越来越多，表中的数据量也会越来越大，相应地，数据操作，增删改查的开销也会越来越大；另外，由于无法进行分布式式部署，而一台服务器的资源（CPU、磁盘、内存、IO等）是有限的，最终数据库所能承载的数据量、数据处理能力都将遭遇瓶颈。  
3 分库分表的实施策略。  
  
分库分表有垂直切分和水平切分两种。  
3.1 何谓垂直切分，即将表按照功能模块、关系密切程度划分出来，部署到不同的库上。例如，我们会建立定义数据库workDB、商品数据库payDB、用户数据库userDB、日志数据库logDB等，分别用于存储项目数据定义表、商品定义表、用户数据表、日志数据表等。  
3.2 何谓水平切分，当一个表中的数据量过大时，我们可以把该表的数据按照某种规则，例如userID散列，进行划分，然后存储到多个结构相同的表，和不同的库上。例如，我们的userDB中的用户数据表中，每一个表的数据量都很大，就可以把userDB切分为结构相同的多个userDB：part0DB、part1DB等，再将userDB上的用户数据表userTable，切分为很多userTable：userTable0、userTable1等，然后将这些表按照一定的规则存储到多个userDB上。  
3.3 应该使用哪一种方式来实施数据库分库分表，这要看数据库中数据量的瓶颈所在，并综合项目的业务类型进行考虑。  
如果数据库是因为表太多而造成[海量数据][Link 2]，并且项目的各项[业务逻辑][Link 3]划分清晰、低耦合，那么规则简单明了、容易实施的垂直切分必是首选。  
而如果数据库中的表并不多，但单表的数据量很大、或数据热度很高，这种情况之下就应该选择水平切分，水平切分比垂直切分要复杂一些，它将原本逻辑上属于一体的数据进行了物理分割，除了在分割时要对分割的粒度做好评估，考虑数据平均和负载平均，后期也将对项目人员及应用程序产生额外的数据管理负担。  
在现实项目中，往往是这两种情况兼而有之，这就需要做出权衡，甚至既需要垂直切分，又需要水平切分。我们的游戏项目便综合使用了垂直与水平切分，我们首先对数据库进行垂直切分，然后，再针对一部分表，通常是用户数据表，进行水平切分。

### **6.8 oracle数据库的分页** ###

select t1.*
    
      from (select rownum rw, k.*
    
    from ks_collect_pushed k
    
    where rownum < = 15) t1
    
     where rw > 5

### **6.9 mysql索引的分类** ###

**普通索引**

（1）直接创建索引

CREATE INDEX index_name ON table(column(length))

（2）修改表结构的方式添加索引

ALTER TABLE table_name ADD INDEX index_name ON (column(length))

（3）创建表的时候同时创建索引

CREATE TABLE `table` (
        `id` int(11) NOT NULL AUTO_INCREMENT ,
        `title` char(255) CHARACTER NOT NULL ,
        `content` text CHARACTER NULL ,
        `time` int(10) NULL DEFAULT NULL ,
        PRIMARY KEY (`id`),
        INDEX index_name (title(length))
    )

（4）删除索引

DROP INDEX index_name ON table

**唯一索引**

CREATE UNIQUE INDEX indexName ON table(column(length))

**主键索引**

CREATE TABLE `table` (
        `id` int(11) NOT NULL AUTO_INCREMENT ,
        `title` char(255) NOT NULL ,
        PRIMARY KEY (`id`)
    );

**联合索引**

ALTER TABLE `table` ADD INDEX name_city_age (name,city,age);

**全文索引**

（1）创建表的适合添加全文索引

（2）修改表结构添加全文索引

ALTER TABLE article ADD FULLTEXT index_content(content)

（3）直接创建索引

CREATE FULLTEXT INDEX index_content ON article(content)

### **6.10 创建索引的原则** ###

1.  索引不是越多越好，索引创建过多会影响增、删、改sql语句的性能
2.  避免对经常更新的表创建索引
3.  对用到不同值较多的列创建索引，在不同值很少的列上不要建立索引，如学生表的性别字段上，只有“男”“女”两个不同值，因此就无需建立索引
4.  当唯一性是数据本身的特征时，指定唯一索引，确保定义列数据的完整性，提高查询速度

### 6.11 mysql索引的工作原理 ###

索引是在存储引擎中实现的，而不是在服务器层中实现的。所以，每种存储引擎的索引都不一定完全相同，并不是所有的存储引擎都支持所有的索引类型。

InnoDB 索引的实现通常使用B树及其变种B+树

利用局部性原理与磁盘预读，每次新建节点时，直接申请一个页的空间，这样就保证一个节点物理上也存储在一个页里，加之计算机存储分配都是按页对齐的，就实现了一个node只需一次I/O。

## ##

### 6.12 **复制基本原理流程** ###

1. 主：binlog线程——记录下所有改变了数据库数据的语句，放进master上的binlog中；
    2. 从：io线程——在使用start slave 之后，负责从master上拉取 binlog 内容，放进 自己的relay log中；
    3. 从：sql执行线程——执行relay log中的语句；

### **6.13 MySQL复制的线程有几个及之间的关联** ###

MySQL 的复制是基于如下 3 个线程的交互（ 多线程复制里面应该是 4 类线程）：
    1. Master 上面的 binlog dump 线程，该线程负责将 master 的 binlog event 传到slave；
    2. Slave 上面的 IO 线程，该线程负责接收 Master 传过来的 binlog，并写入 relay log；
    3. Slave 上面的 SQL 线程，该线程负责读取 relay log 并执行；
    4. 如果是多线程复制， SQL 线程只做 coordinator，只负责把 relay log 中的 binlog读出来
    然后交给 worker 线程， woker 线程负责具体 binlog event 的执行；

### 6.14 **MySQL如何保证复制过程中数据一致性及减少数据同步延时** ###

1.   在 MySQL5.5 以及之前， slave 的 SQL 线程执行的 relay log 的位置只能保存在文件（ relay-log.info）里面，并且该文件默认每执行 10000 次事务做一次同步到磁盘， 这意味着 slave 意外 crash 重启时， SQL 线程执行到的位置和数据库的数据是不一致的，将导致复制报错，如果不重搭复制，则有可能会  
导致数据不一致。 MySQL 5.6 引入参数 relay\_log\_info\_repository，将该参数设置为 TABLE 时， MySQL 将 SQL 线程执行到的位置存到mysql.slave\_relay\_log\_info 表，这样更新该表的位置和 SQL 线程执行的用户事务绑定成一个事务，这样 slave 意外宕机后， slave 通过 innodb 的崩溃  
恢复可以把 SQL 线程执行到的位置和用户事务恢复到一致性的状态。  
2.    MySQL 5.6 引入 GTID 复制，每个 GTID 对应的事务在每个实例上面最多执行一次， 这极大地提高了复制的数据一致性；  
3.    MySQL 5.5 引入半同步复制， 用户安装半同步复制插件并且开启参数后，设置超时时间，可保证在超时时间内如果 binlog 不传到 slave 上面，那么用户提交事务时不会返回，直到超时后切成异步复制，但是如果切成异步之前用户线程提交时在 master 上面等待的时候，事务已经提交，该事务对 master  
上面的其他 session 是可见的，如果这时 master 宕机，那么到 slave 上面该事务又不可见了，该问题直到 5.7 才解决；  
4.  MySQL 5.7 引入无损半同步复制，引入参 rpl\_semi\_sync\_master\_wait\_point，该参数默认为 after\_sync，指的是在切成半同步之前，事务不提交，而是接收到 slave 的 ACK 确认之后才提交该事务，从此，复制真正可以做到无损的了。

### 6.15 数据库主库和从库不一致,怎么解决？ ###

在cache里记录哪些记录发生过写请求，来路由读主还是读从

可以利用一个缓存记录必须读主的数据。

![20190225090127299.png][]

如上图，当写请求发生时：

（1）写主库

（2）将哪个库，哪个表，哪个主键三个信息拼装一个key设置到cache里，这条记录的超时时间，设置为“主从同步时延”

*画外音：key的格式为“db:table:PK”，假设主从延时为1s，这个key的cache超时时间也为1s。*

![20190225090217820.png][]

如上图，当读请求发生时：

这是要读哪个库，哪个表，哪个主键的数据呢，也将这三个信息拼装一个key，到cache里去查询，如果，

（1）**cache里有这个key**，说明1s内刚发生过写请求，数据库主从同步可能还没有完成，此时就应该去主库查询

（2）**cache里没有这个key**，说明最近没有发生过写请求，此时就可以去从库查询

以此，保证读到的一定不是不一致的脏数据。

### 6.16 MySQL存储引擎MyISAM与InnoDB区别  ###

**1) 事务支持**  
MyISAM不支持事务，而InnoDB支持。

**2) 存储结构**  
MyISAM：每个MyISAM在磁盘上存储成三个文件。第一个文件的名字以表的名字开始，扩展名指出文件类型。.frm文件存储表定义。数据文件的扩展名为.MYD (MYData)。索引文件的扩展名是.MYI (MYIndex)。  
InnoDB：所有的表都保存在同一个数据文件中（也可能是多个文件，或者是独立的表空间文件），InnoDB表的大小只受限于操作系统文件的大小，一般为2GB。

**3) 存储空间**  
MyISAM：可被压缩，存储空间较小。支持三种不同的存储格式：静态表(默认，但是注意数据末尾不能有空格，会被去掉)、动态表、压缩表。  
InnoDB：需要更多的内存和存储，它会在主内存中建立其专用的缓冲池用于高速缓冲数据和索引。

**4) 可移植性、备份及恢复**  
MyISAM：数据是以文件的形式存储，所以在跨平台的数据转移中会很方便。在备份和恢复时可单独针对某个表进行操作。  
InnoDB：免费的方案可以是拷贝数据文件、备份 binlog，或者用 mysqldump，在数据量达到几十G的时候就相对痛苦了。

**5) 事务支持**  
MyISAM：强调的是性能，每次查询具有原子性,其执行数度比InnoDB类型更快，但是不提供事务支持。  
InnoDB：提供事务支持事务，外部键等高级数据库功能。 具有事务(commit)、回滚(rollback)和崩溃修复能力(crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表。

**6) AUTO\_INCREMENT**  
MyISAM：可以和其他字段一起建立联合索引。引擎的自动增长列必须是索引，如果是组合索引，自动增长可以不是第一列，他可以根据前面几列进行排序后递增。  
InnoDB：InnoDB中必须包含只有该字段的索引。引擎的自动增长列必须是索引，如果是组合索引也必须是组合索引的第一列。

**7) 表锁差异**  
MyISAM：只支持表级锁，用户在操作myisam表时，select，update，delete，insert语句都会给表自动加锁，如果加锁以后的表满足insert并发的情况下，可以在表的尾部插入新的数据。  
InnoDB：支持事务和行级锁，是innodb的最大特色。行锁大幅度提高了多用户并发操作的新能。但是InnoDB的行锁，只是在WHERE的主键是有效的，非主键的WHERE都会锁全表的。

MyISAM锁的粒度是表级，而InnoDB支持行级锁定。简单来说就是, InnoDB支持数据行锁定，而MyISAM不支持行锁定，只支持锁定整个表。即MyISAM同一个表上的读锁和写锁是互斥的，MyISAM并发读写时如果等待队列中既有读请求又有写请求，默认写请求的优先级高，即使读请求先到，所以MyISAM不适合于有大量查询和修改并存的情况，那样查询进程会长时间阻塞。因为MyISAM是锁表，所以某项读操作比较耗时会使其他写进程饿死。

**8) 全文索引**  
MyISAM：支持(FULLTEXT类型的)全文索引  
InnoDB：不支持(FULLTEXT类型的)全文索引，但是innodb可以使用sphinx插件支持全文索引，并且效果更好。

**9) 表主键**  
MyISAM：允许没有任何索引和主键的表存在，索引都是保存行的地址。  
InnoDB：如果没有设定主键或者非空唯一索引，就会自动生成一个6字节的主键(用户不可见)，数据是主索引的一部分，附加索引保存的是主索引的值。InnoDB的主键范围更大，最大是MyISAM的2倍。

**10) 表的具体行数**  
MyISAM：保存有表的总行数，如果select count(\*) from table;会直接取出出该值。  
InnoDB：没有保存表的总行数(只能遍历)，如果使用select count(\*) from table；就会遍历整个表，消耗相当大，但是在加了wehre条件后，myisam和innodb处理的方式都一样。

**11) CURD操作**  
MyISAM：如果执行大量的SELECT，MyISAM是更好的选择。  
InnoDB：如果你的数据执行大量的INSERT或UPDATE，出于性能方面的考虑，应该使用InnoDB表。DELETE 从性能上InnoDB更优，但DELETE FROM table时，InnoDB不会重新建立表，而是一行一行的删除，在innodb上如果要清空保存有大量数据的表，最好使用truncate table这个命令。

**12) 外键**  
MyISAM：不支持  
InnoDB：支持

### 6.17 **索引如何提高查询效率？** ###

Mysql的索引是一个数据结构，旨在使数据库高效的查找数据。常用的数据结构是B+Tree，每个叶子节点不但存放了索引键的相关信息还增加了指向相邻叶子节点的指针，这样就形成了带有顺序访问指针的B+Tree，做这个优化的目的是提高不同区间访问的性能。

Mysql设计利用了磁盘预读原理，将一个B+Tree节点大小设为一个页大小，在新建节点时直接申请一个页的空间，这样就能保证一个节点物理上存储在一个页里，加之计算机存储分配都是按页对齐的，这样就实现了每个Node节点只需要一次I/O操作

红黑树这种结构，h明显要深的多,性能差得多。

## 7 redis  ##

### **7.1 redis的数据结构** ###

**（1） Redis数据结构之String**

字符串类型是Redis中最为基础的数据存储类型，它在Redis中是二进制安全的，这便意味着该类型可以接受任何格式的数据，如JPEG图像数据或Json对象描述信息等。在Redis中字符串类型的Value最多可以容纳的数据长度是512M。

*  SET key value

设定该Key持有指定的字符串Value，如果该Key已经存在，则覆盖其原有值。返回值：总是返回"OK"

*  GET key

获取指定Key的Value。如果与该Key关联的Value不是string类型，Redis将返回错误信息，因为GET命令只能用于获取string Value。

返回值：与该Key相关的Value，如果该Key不存在，则返回nil。

**（2）Redis数据结构之List**

在Redis中，List类型是按照插入顺序排序的字符串链表。和数据结构中的**普通链表**一样，我们可以在其头部(left)和尾部(right)添加新的元素。在插入时，如果该键并不存在，Redis将为该键创建一个新的链表。与此相反，如果链表中所有的元素均被移除，那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是4294967295。

**（3）Redis数据结构之Hash**

Redis中的Hashes类型可以看成具有String Key和String Value的map容器。所以该类型非常适合于存储值对象的信息。如用户信息：Username、Password和Age等。每一个Hash可以存储4294967295个键值对。

hset user01 username zhangsan

**（4）Redis数据结构之Set**

在Redis中，我们可以将Set类型看作为没有排序的字符串集合。Set可包含的最大元素数量是4294967295。

Set类型在功能上还存在着一个非常重要的特性，即在服务器端完成多个Sets之间的聚合计算操作，如unions、intersections和differences。由于这些操作均在服务端完成，因此效率极高，而且也节省了大量的网络IO开销。

**（5）Redis数据结构之SortedSet**

Sorted-Sets和Sets类型极为相似，它们都是字符串的集合，都不允许重复的成员出现在一个Set中。它们之间的主要差别是Sorted-Sets中的每一个成员都会有一个分数(score)与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序。然而需要额外指出的是，尽管Sorted-Sets中的**成员必须是唯一**的，但是**分数****(score)****却是可以重复**的

### **7.2 redis的持久化机制** ###

Redis是一个开源的高性能键值对数据库

是NoSQL技术阵营中的一员

它通过提供多种键值数据类型来适应不同场景下的存储需求

借助一些高层级的接口使其可以胜任，如缓存、队列系统的不同角色

可用作缓存、队列、消息订阅/发布

1). RDB持久化：

该机制是指在指定的时间间隔内将内存中的数据集快照写入磁盘。

可以通过配置设置自动做快照持久化的方式。我们可以配置redis在n秒内如果超过m个key被修改就自动做快照，下面是默认的快照保存配置

save 900 1     #900秒内如果超过1个key被修改，则发起快照保存
       save 300 10    #300秒内容如超过10个key被修改，则发起快照保存
       save 60 10000

2). AOF(append only file)持久化:

该机制将以日志的形式记录服务器所处理的每一个写操作，在Redis服务器启动之初会读取该文件来重新构建数据库，以保证启动后数据库中的数据是完整的

### **7.3 mySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据** ###

相关知识：redis 内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略（回收策略）。redis 提供 6种数据淘汰策略：

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

** ****　**

### **7.4 redis常见性能问题和解决方案** ###

1).Master写内存快照，save命令调度rdbSave函数，会阻塞主线程的工作，当快照比较大时对性能影响是非常大的，会间断性暂停服务，所以Master最好不要写内存快照。

2).Master AOF持久化，如果不重写AOF文件，这个持久化方式对性能的影响是最小的，但是AOF文件会不断增大，AOF文件过大会影响Master重启的恢复速度。Master最好不要做任何持久化工作，包括内存快照和AOF日志文件，特别是不要启用内存快照做持久化,如果数据比较关键，某个Slave开启AOF备份数据，策略为每秒同步一次。

3).Master调用BGREWRITEAOF重写AOF文件，AOF在重写的时候会占大量的CPU和内存资源，导致服务load过高，出现短暂服务暂停现象。

4). Redis主从复制的性能问题，为了主从复制的速度和连接的稳定性，Slave和Master最好在同一个局域网内

### **7.5 redis的并发竞争问题如何解决?** ###

Redis是单进程单线程的，redis利用队列技术将并发访问变为串行访问，消除了传统数据库串行控制的开销

### **7.6 redis事务的命令** ###

Redis 事务命令

下标列出了redis事务的相关命令

1. DISCARD

取消事务，放弃执行事务块内的所有命令。

2. EXEC

执行所有事务块内的命令

3. MULTI

标记一个事务块的开始

4. UNWATCH

取消WATCH命令对所有key的监视

5. WATCH key \[key ...\]

监视一个(或多个)key，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

[https://www.cnblogs.com/Survivalist/p/8119891.html][https_www.cnblogs.com_Survivalist_p_8119891.html]

### **7.7 redis事务的特征** ###

（1）在事务中的所有命令都将会被串行化的顺序执行，事务执行期间，Redis不会再为其它客户端的请求提供任何服务，从而保证了事物中的所有命令被原子的执行。

（2）在Redis事务中如果有某一条命令执行失败，其后的命令仍然会被继续执行。

（3）MULTI命令开启一个事务，可以通过执行EXEC/DISCARD命令来提交/回滚该事务内的所有操作

redis中也是有事务的，不过这个事务没有mysql中的完善，只保证了一致性和隔离性，不满足原子性和持久性。

### 7.8 redis集群搭建 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 4][]

架构细节:

(1)所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽.

(2)节点的fail是通过集群中超过半数的节点检测失效时才生效.

(3)客户端与redis节点直连,不需要中间proxy层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可

(4)redis-cluster把所有的物理节点映射到\[0-16383\]slot上,cluster 负责维护node<->slot<->value

Hash一致性算法

Redis 集群中内置了 16384 个哈希槽，当需要在 Redis 集群中放置一个 key-value 时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，redis 会根据节点数量大致均等的将哈希槽映射到不同的节点

**集群搭建**

集群中应该至少有三个节点，每个节点有一备份节点。需要6台服务器。

搭建伪分布式，需要6个redis实例。

搭建集群的步骤：

第一步：创建6个redis实例指定端口从7001到7006

第二步：修改redis.conf 打开Cluster-enable yes前面的注释。

第三步：需要一个ruby脚本。在redis源码文件夹下的src目录下。redis-trib.rb

第四步：把redis-trib.rb文件复制到到redis-cluster目录下。

第五步：执行ruby脚本之前，需要安装ruby环境。

1、yum install ruby

2、yum install rubygems

3、安装redis-trib.rb运行依赖的ruby的包。

![20190307171239509.png][]

\[root@bogon ~\]\# gem install redis-3.0.0.gem

第六步：启动所有的redis实例。

第七步：使用redis-trib.rb创建集群。

./redis-trib.rb create --replicas 1 192.168.25.153:7001 
    192.168.25.153:7002 192.168.25.153:7003 
    192.168.25.153:7004 192.168.25.153:7005  192.168.25.153:7006

使用客户端连接集群： redis01/redis-cli -p 7001 **-c**

## ##

## 8 SpringMVC ##

### 8.1 springMVC的运行流程 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 5][]

1. 用户向服务器发送请求，请求被SpringMVC 前端控制器DispatcherServlet捕获；

2. DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回；

3. DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter；（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler方法）

4.  提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。 在填充Handler的入参过程中，根据你的配置，SpringMVC将帮你做一些额外的工作：

HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息。

数据转换：对请求消息进行数据转换。如String转换成Integer、Double等。

数据根式化：对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等。

数据验证： 验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中。

5.  Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；

6.  根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到SpringMVC容器中的ViewResolver)返回给DispatcherServlet；

7. ViewResolver 结合Model和View，来渲染视图；

8. 将渲染结果返回给客户端。

### 8.2 mvc模式 ###

*  （控制器Controller）- 负责转发请求，对请求进行处理。
 *  （视图View） - 界面设计人员进行图形界面设计。
 *  （模型Model） - 程序员编写程序应有的功能（实现算法等等）、数据库专家进行数据管理和数据库设计(可以实现具体的功能)。

## 9 Spring ##

### 9.1 什么是IOC，以及其原理？ ###

IOC控制反转，不是一种技术，而是一种思想，对象的生命周期不是由程序本身来决定，而是由容器来控制，所以称之为控制反转。

ioc底层原理使用技术

（1）xml配置文件

（2）dom4j解决xml

（3）工厂设计模式

（4）反射

步骤：

第一步：创建类的.xml文件

<bean id="userService" class="....."/>
    
    第二步：创建一个工厂类：使用dom4j解析配置文件+反射
    
    public class UserFactory{
    
        public static UserService getUserService(){
    
            //使用dom4j解析配置文件
    
            //根据id值获得class的属性值
    
            String classValue="class属性值"；
    
            //使用反射来创建class对象
    
            Class class=Class.forName(classValue);
        
            UserService service=class.newInstatnce();
    
            return service;
        }
    }

![SouthEast][]

### 9.2 IOC和DI的区别？  ###

依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；

而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

### 9.3 什么是aop ###

`aop是面向切面编程，aop是对oop（面向对象编程）的补充和完善，OOP引入封装、继承和多态性等概念建立一种对象的层次结构。当我们需要为不具备上下级关系的对象添加一系列公共的行为时，oop显得很无力。如日志，日志代码所在所有对象之间毫无关系。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统，提高代码的复用性。`

1） *Aspect* ：切面，切入系统的一个切面。比如事务管理是一个切面，权限管理也是一个切面；

2） *Join point* ：连接点，也就是可以进行横向切入的位置；

3） *Advice* ：通知，切面在某个连接点执行的操作(分为: *Before advice* , *After returning advice* , *After throwing advice* , *After (finally) advice* , *Around advice* )；

4） *Pointcut* ：切点，符合切点表达式的连接点，也就是真正被切入的地方；

Spring AOP的五个通知类型

<table> 
 <tbody> 
  <tr> 
   <td style="width:166px;">通知类型</td> 
   <td style="width:683px;">作用</td> 
  </tr> 
  <tr> 
   <td style="width:166px;"><strong>before</strong></td> 
   <td style="width:683px;"><strong>前置通知</strong></td> 
  </tr> 
  <tr> 
   <td style="width:166px;"><strong>around</strong></td> 
   <td style="width:683px;"><strong>环绕通知---需要放行操作</strong></td> 
  </tr> 
  <tr> 
   <td style="width:166px;"><strong>after</strong></td> 
   <td style="width:683px;"><strong>后置通知----不论拦截的方法是否有异常</strong></td> 
  </tr> 
  <tr> 
   <td style="width:166px;"><strong>after-returning</strong></td> 
   <td style="width:683px;"><strong>后置成功通知---------拦截的方法没油抛出异常就会执行--拦截到的方法必须正确返回；</strong></td> 
  </tr> 
  <tr> 
   <td style="width:166px;"><strong>after-throwing</strong></td> 
   <td style="width:683px;"><strong>后置异常通知----拦截的方法如果抛出异常则会执行----有异常执行它没油异常不执行</strong></td> 
  </tr> 
 </tbody> 
</table>

aop简单使用如下：

定义一个注解

@Target(value = { ElementType.METHOD })
    @Retention(value = RetentionPolicy.RUNTIME)
    public @interface AnalysisActuator {
    	TimeUnit timeType() default TimeUnit.SECONDS;
    
    }

定义切面

@Aspect
    @Component
    public class AnalysisAspect {
    	private long stTime;
        //定义切点
    	@Pointcut("@annotation(com.whty.aop.annotion.AnalysisActuator)")
    	public void declareJoinPointExpression() {
    	}
    	@Before(value = "declareJoinPointExpression()")
    	public void beforemethod() {
    		long currentTimeMillis = System.currentTimeMillis();
    		stTime=currentTimeMillis;
    		System.out.println("开始执行时间"+currentTimeMillis);
    	}
    	@After(value = "declareJoinPointExpression()")
    	public void aftermethod(JoinPoint pjp) {
    		//获取方法
    		MethodSignature signature = (MethodSignature) pjp.getSignature();
    		Method method = signature.getMethod();
    		method.getAnnotation(AnalysisActuator.class);
    		AnalysisActuator analysisActuator=(AnalysisActuator)method.getAnnotation(AnalysisActuator.class);
    		TimeUnit timeType = analysisActuator.timeType();
    		long currentTimeMillis = System.currentTimeMillis();
    		long t=currentTimeMillis-stTime;
    		System.out.println("结束执行的时间为"+currentTimeMillis);
    		System.out.println(timeType.convert(t, TimeUnit.MILLISECONDS));
    	}
    }

测试

@RestController
    public class Demo {
    	@RequestMapping(value="/demo")
    	@AnalysisActuator(timeType=TimeUnit.MILLISECONDS)
    	public Object demo() {
    		for (int i = 0; i < 10000000; i++) {
    			
    		}
    		return "hello";
    	}
    
    }

结果：

![20190304160505372.png][]

切点语法

<table> 
 <tbody> 
  <tr> 
   <td style="width:246px;">AspectJ指示器</td> 
   <td style="width:603px;">描述</td> 
  </tr> 
  <tr> 
   <td style="width:246px;">execution()</td> 
   <td style="width:603px;">用于匹配是连接点的执行方法</td> 
  </tr> 
  <tr> 
   <td style="width:246px;">@annotation</td> 
   <td style="width:603px;">限定匹配带有指定注解的连接点</td> 
  </tr> 
  <tr> 
   <td style="width:246px;">bean()</td> 
   <td style="width:603px;">Bean的使用相对来说是比较简单的 bean()括号里面放的是你在Spring中注册的类的标识</td> 
  </tr> 
  <tr> 
   <td style="width:246px;">within()</td> 
   <td style="width:603px;">限制连接点匹配指定的类型</td> 
  </tr> 
 </tbody> 
</table>

### 9.4 SpringBean实例化方式 ###

（1）使用类的无参构造函数

(2)使用静态工厂创建

public class BeanFactory2{
        public static Bean2 getBean2(){
            return new Bean2();
        }
    }

(3) 使用实例工厂创建

public class BeanFactory3{
        public static Bean3 getBean3(){
            return new Bean3();
        }
    }

### 9.5 springBean的生命周期 ###

![70][]

1、spring对bean进行实例化

2、spring将值和bean的引用注入到bean对应的属性中

3、如果bean实现了BeanNameAware接口，spring将bean的id传递给setBeanName()方法

4、如果bean实现了BeanFactoryAware接口，Spring将调用setBeanFactory()方法，将BeanFactory容器实例传入

5、如果bean实现了ApplicationContextAware接口，Spring将调用setApplicationContext()方法，将bean所在的应用上下文的  
引用传入进来

6、如果bean实现了BeanPostProcessor接口，Spring将调用它们的postProcessBeforeInitialization()方法；

7、如果bean实现了InitializingBean接口，Spring将调用它们的afterPropertiesSet()方法。类似地，如果bean使用init-method声明了初始化方法，该方法也会被调用

在spring初始化bean的时候，如果该bean是实现了InitializingBean接口，并且同时在配置文件中指定了init-method，系统则是先调用afterPropertiesSet方法，然后在调用init-method中指定的方法

8、如果bean实现了BeanPostProcessor接口，Spring将调用它们的post-ProcessAfterInitialization()方法；

9、此时，bean已经准备就绪，可以被应用程序使用了，它们将一直驻留在应用上下文中，直到该应用上下文被销毁；

10、如果bean实现了DisposableBean接口，Spring将调用它的destroy()接口方法。同样，如果bean使用destroy-method声明  
了销毁方法，该方法也会被调用

### 9.6 Spring的事物管理 ###

（1）**编程式事务管理**：将事务管理代码嵌入到业务方法中来控制事务的提交和回滚，在编程式事务中，必须在每个业务操作中包含额外的事务管理代码

编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate

（2）**声明式事务管理**：大多数情况下比编程式事务管理更好用。它将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。事务管理作为一种横切关注点，可以通过AOP方法模块化。Spring通过Spring AOP框架支持声明式事务管理。

声明式事务管理

1.基于xml配置文件实现

2.基于注解实现

### 9.7 Spring事物的隔离级别和传播行为 ###

Spring事务的隔离级别：

**\* read uncommitted  :****未提交读.****脏读、不可重复读、虚读都是有可能发生.**

**\* read committed    :****已提交读.****避免脏读.****但是不可重复读、虚读是有可能发生.**

**\* repeatable read   :****可重复读.****避免脏读、不可重复读.****但是虚读是有可能发生.**

**\* serializable      :****串行化的.****避免脏读、不可重复读、虚读的发生.**

Spring事务的传播行为

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 6][]

### **9.8 BeanFactory和ApplicationContext有什么区别？** ###

**BeanFactory****：**

是Spring里面最低层的接口，提供了最简单的容器的功能，只提供了实例化对象和拿对象的功能；

**ApplicationContext****：**

应用上下文，继承BeanFactory接口，它是Spring的一各更高级的容器，提供了更多的有用的功能；

1) 国际化（MessageSource）

2) 访问资源，如URL和文件（ResourceLoader）

3) 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层

4) 消息发送、响应机制（ApplicationEventPublisher）

5) AOP（拦截器

**两者装载bean的区别**

**BeanFactory****：**

BeanFactory在启动的时候不会去实例化Bean，中有从容器中拿Bean的时候才会去实例化；

**ApplicationContext****：**

ApplicationContext在启动的时候就把所有的Bean全部实例化了。它还可以为Bean配置lazy-init=true来让Bean延迟实例化；

### **9.9 Spring Bean的作用域之间有什么区别？** ###

Spring容器中的bean可以分为5个范围。所有范围的名称都是自说明的，但是为了避免混淆，还是让我们来解释一下：

（1）singleton：这种bean范围是默认的，这种范围确保不管接受到多少个请求，每个容器中只有一个bean的实例，单例的模式由bean factory自身来维护。

（2）prototype：原形范围与单例范围相反，为每一个bean请求提供一个实例。

（3）request：在请求bean范围内会每一个来自客户端的网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。

（4）Session：与请求范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。

（5）global-session：global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。

### 9.10 JDK动态代理和Gglib动态代理的区别 ###

1.JDK动态代理是实现了被代理对象的接口，Cglib是继承了被代理对象。

2.JDK和Cglib都是在运行期生成字节码，JDK是直接写Class字节码，Cglib使用ASM框架写Class字节码，Cglib代理实现更复杂，生成代理类比JDK效率低。

3.JDK调用代理方法，是通过反射机制调用，Cglib是通过FastClass机制直接调用方法，Cglib执行效率更高。

### 9.11 BeanFactory与FactoryBean的区别 ###

BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖

FactoryBean它是实现了FactoryBean<T>接口的Bean

###  9.12 spring在bean的创建过程中解决循环依赖 ###

Spring先是用构造实例化Bean对象， 创建成功后将对象暴露出来，此时的对象还没有完成属性注入，属于早期对象，此时Spring会将这个实例化结束的对象放到一个Map中，提供set方法设置属性。

### 9.13 @Transactional使用 ###

@Transactional 注解只能应用到 public 可见度的方法上

默认情况下，spring会对unchecked异常进行事务回滚；如果是checked异常则不回滚。

RuntimeException（比如空指针，1/0）的异常称为unchecked异常

### 9.14 获取spring容器的常用的4种方式 ###

（1）通过Spring提供的ContextLoader

import org.springframework.web.context.ContextLoader;
    import org.springframework.web.context.WebApplicationContext;
    public class SpringContextUtil {
    	WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext();
    }

Spring容器初始化时，不能通过下面方法获取Spring 容器 （获取为null）

（2）继承自抽象类ApplicationObjectSupport

说明：抽象类ApplicationObjectSupport提供getApplicationContext()方法。能够方便的获取ApplicationContext。

Spring初始化时。会通过该抽象类的setApplicationContext(ApplicationContext context)方法将ApplicationContext 对象注入。

（3）继承自抽象类WebApplicationObjectSupport

（4） 实现接口ApplicationContextAware

实现该接口的setApplicationContext(ApplicationContext context)方法，并保存ApplicationContext 对象。Spring初始化时，会通过该方法将ApplicationContext对象注入

public class SpringContextUtil implements ApplicationContextAware {
    
    	private static ApplicationContext applicationContext;
    
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    		SpringContextUtil.applicationContext = applicationContext;
    	}
    
    	public static <T> T getBean(Class<T> clazz) {
    		return (T) applicationContext.getBean(clazz);
    	}
    
    }

### 9.15 Spring支持三种依赖注入方式 ###

分别是属性（Setter方法）注入，构造注入和接口注入。

## 10 Mybatis ##

## 10.1 mybatis的原理  ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 7][]

### 10.2 \#\{\}和$\{\}的区别是什么？ ###

\#\{\}是预编译处理，$\{\}是字符串替换。

Mybatis在处理\#\{\}时，会将sql中的\#\{\}替换为?号，调用PreparedStatement的set方法来赋值；

Mybatis在处理$\{\}时，就是把$\{\}替换成变量的值。

使用\#\{\}可以有效的防止SQL注入，提高系统安全性。

### 10.3 通常一个Xml映射文件，都会写一个Mapper接口与之对应，请问，这个Mapper接口的工作原理是什么？Mapper接口里的方法，参数不同时，方法能重载吗？ ###

Mapper接口的全类名，就是映射文件中的namespace的值，接口的方法名，就是映射文件中MappedStatement的id值，接口方法内的参数，就是传递给sql的参数。Mapper接口是没有实现类的，当调用接口方法时，接口全类名+方法名拼接字符串作为key值，可唯一定位一个MappedStatement.

java.lang.IllegalArgumentException: Mapped Statements collection already 
    contains value for com.whty.hxx.sta.web.mapper.CityMapper.getCityByExamId

Mapper接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Mapper接口生成代理proxy对象，代理对象proxy会拦截接口方法，转而执行MappedStatement所代表的sql，然后将sql执行结果返回。

### 10.4 Mybatis分页插件的原理是什么？ ###

使用Mybatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的sql，然后重写sql，根据dialect方言，添加对应的物理分页语句和物理分页参数。

### 10.5 简述Mybatis的插件运行原理，以及如何编写一个插件 ###

Mybatis仅可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件，Mybatis使用JDK的动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这4种接口对象的方法时，就会进入拦截方法，具体就是InvocationHandler的invoke()方法，当然，只会拦截那些你指定需要拦截的方法。

实现Mybatis的Interceptor接口并复写intercept()方法，然后在给插件编写注解，指定要拦截哪一个接口的哪些方法即可，记住，别忘了在配置文件中配置你编写的插件。

*  编写Interceptor的实现类;
 *  使用`@Intercepts`注解完成插件签名;
 *  将写好的插件注册到全局配置文件中;

### 10.6 mybatis是否支持延迟加载？如果支持，它的实现原理是什么？ ###

Mybatis仅支持association关联对象和collection关联集合对象的延迟加载，association指的就是一对一，collection指的就是一对多查询。在Mybatis配置文件中，可以配置是否启用延迟加载lazyLoadingEnabled=true|false。

它的原理是，使用CGLIB创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用a.getB().getName()，拦截器invoke()方法发现a.getB()是null值，那么就会单独发送事先保存好的查询关联B对象的sql，把B查询上来，然后调用a.setB(b)，于是a的对象b属性就有值了，接着完成a.getB().getName()方法的调用。这就是延迟加载的基本原理。

### 10.7 Mybatis都有哪些Executor执行器？它们之间的区别是什么？ ###

答：Mybatis有三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。

SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。

ReuseExecutor：执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map<String, Statement>内，供下一次使用。简言之，就是重复使用Statement对象。

BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。

作用范围：Executor的这些特点，都严格限制在SqlSession生命周期范围内。

### 10.8 mybatis缓存 ###

**一级缓存 **是 SqlSession 级别的缓存，是基于 HashMap 的本地缓存。每个线程都有自己的SqlSession 实例，SqlSession 实例是不能被共享，也不是线程安全的，

当同一个 SqlSession 执行两次相同的 sql 语句时，第一次执行完后会将数据库中查询的数据写到缓存，第二次查询时直接从缓存获取不用去数据库查询。当 SqlSession 执行 insert、update、delete 操做并提交到数据库时，会清空缓存，保证缓存中的信息是最新的。MyBatis 默认开启一级缓存。

**二级缓存 **是 mapper 级别的缓存，同样是基于 HashMap 进行存储，多个 SqlSession 可以共用二级缓存，其作用域是 mapper 的同一个 namespace。不同的 SqlSession 两次执行相同的 namespace 下的 sql 语句，会执行相同的 sql，第二次查询只会查询第一次查询时读取数据库后写到缓存的数据，不会再去数据库查询。

## 11 springBoot ##

### 11.1 **什么是 Spring Boot？** ###

Spring Boot 是 Spring 开源组织下的子项目，是 Spring 组件一站式解决方案，主要是简化了使用 Spring 的难度，简省了繁重的配置，提供了各种启动器，开发者能快速上手。

### **11.2 Spring Boot 的核心配置文件有哪几个？它们的区别是什么？** ###

Spring Boot 的核心配置文件是 application 和 bootstrap 配置文件。

application 配置文件这个容易理解，主要用于 Spring Boot 项目的自动化配置。

bootstrap 配置文件有以下几个应用场景。

*  使用 Spring Cloud Config 配置中心时，这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息；
 *  一些固定的不能被覆盖的属性；
 *  一些加密/解密的场景；

### **11.3 Spring Boot 的配置文件有哪几种格式？它们有什么区别？** ###

.properties 和 .yml，它们的区别主要是书写格式不同。

1).properties

app.user.name = javastack

2).yml

app:
      user:
        name: javastack

另外，.yml 格式不支持 `@PropertySource` 注解导入配置。

### 11.4 **Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？** ###

启动类上面的注解是@SpringBootApplication，它也是 Spring Boot 的核心注解，主要组合包含了以下 3 个注解：

@SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。

@EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能： @SpringBootApplication(exclude = \{ DataSourceAutoConfiguration.class \})。

@ComponentScan：Spring组件扫描。

### **11.5 开启 Spring Boot 特性有哪几种方式？** ###

1）继承spring-boot-starter-parent项目

2）导入spring-boot-dependencies项目依赖

### 11.6 **Spring Boot 需要独立的容器运行吗？** ###

可以不需要，内置了 Tomcat/ Jetty 等容器。

### 11.7 **运行 Spring Boot 有哪几种方式？** ###

1）打包用命令或者放到容器中运行

2）用 Maven/ Gradle 插件运行

3）直接执行 main 方法运行

### 11.8 **Spring Boot 自动配置原理是什么？** ###

注解 @EnableAutoConfiguration, @Configuration, @ConditionalOnClass 就是自动配置的核心，首先它得是一个配置文件，其次根据类路径下是否有这个类去自动配置

### 11.9 **如何在 Spring Boot 启动的时候运行一些特定的代码？** ###

可以实现接口 ApplicationRunner 或者 CommandLineRunner，这两个接口实现方式一样，它们都只提供了一个 run 方法

### 11.10 **Spring Boot 有哪几种读取配置的方式？** ###

Spring Boot 可以通过 @PropertySource,@Value,@Environment, @ConfigurationProperties 来绑定变量

@PropertySource(value={"classpath:/user.properties"})
    public class Configs {
        @Value("${u.name}")
        private String userName;
    
        @Value("${u.age}")
        private Integer age;
    }

mail.host=localhost
    mail.port=25
    mail.smtp.auth=false
    mail.smtp.starttls-enable=false
    mail.from=me@localhost
    mail.username=duan
    mail.password=duan123456

import org.springframework.boot.context.properties.ConfigurationProperties;
    
    @ConfigurationProperties(locations = "classpath:mail.properties", ignoreUnknownFields = false, prefix = "mail")
    public class MailProperties {
        private String host;
        private int port;
        private String from;
        private String username;
        private String password;
        private Smtp smtp;
    
    }

### **11.11 Spring Boot 支持哪些日志框架？推荐和默认的日志框架是哪个？** ###

Spring Boot 支持 Java Util Logging, Log4j2, Lockback 作为日志框架，如果你使用 Starters 启动器，Spring Boot 将使用 Logback 作为默认日志框架

### 11.12 **SpringBoot 实现热部署有哪几种方式？** ###

主要有两种方式：

*  Spring Loaded
 *  Spring-boot-devtools

### 11.13 **你如何理解 Spring Boot 配置加载顺序？** ###

在 Spring Boot 里面，可以使用以下几种方式来加载配置。

1）properties文件；

2）YAML文件；

3）系统环境变量；

4）命令行参数；

### **11.14 Spring Boot 2.X 有什么新特性？与 1.X 有什么区别？** ###

*  配置变更
 *  JDK 版本升级
 *  第三方类库升级
 *  响应式 Spring 编程支持
 *  HTTP/2 支持
 *  配置属性绑定
 *  更多改进与加强...

## 12 微服务 ##

## 12.1 SpringCloud和Dubbo有哪些区别？              ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:253px;">&nbsp;</td> 
   <td style="width:313px;">Dubbo&nbsp;&nbsp; &nbsp;</td> 
   <td>&nbsp;SpringCloud</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">服务注册中心</td> 
   <td style="width:313px;">Zookeeper&nbsp;&nbsp; &nbsp;</td> 
   <td>Eureka</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">服务调用方式</td> 
   <td style="width:313px;">RPC&nbsp;&nbsp; &nbsp;</td> 
   <td>&nbsp;REST API</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">服务监控</td> 
   <td style="width:313px;">&nbsp;Dubbo-monitor</td> 
   <td>Spring BootAdmin</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">断路器</td> 
   <td style="width:313px;">&nbsp;不完善&nbsp;</td> 
   <td>Spring Cloud Netflix Hystrix</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">服务网关</td> 
   <td style="width:313px;">无</td> 
   <td>Spring Cloud Netflix Zuul</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">分布式配置</td> 
   <td style="width:313px;">无</td> 
   <td>Spring Cloud Config</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">服务跟踪&nbsp;</td> 
   <td style="width:313px;">&nbsp;无</td> 
   <td>Spring Cloud Sleuth</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">消息总线</td> 
   <td style="width:313px;">无&nbsp;</td> 
   <td>Spring Cloud Bus</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">数据流&nbsp;</td> 
   <td style="width:313px;">&nbsp;无&nbsp;</td> 
   <td>Spring Cloud Stream</td> 
  </tr> 
  <tr> 
   <td style="width:253px;">批量任务</td> 
   <td style="width:313px;">&nbsp;无&nbsp;</td> 
   <td>Spring Cloud Task</td> 
  </tr> 
 </tbody> 
</table>

最大区别：SpringCloud抛弃了Dubbo的RPC通信，采用的是基于HTTP的REST方式。  
    总体来说，两者各有优势。虽说后者服务调用的功能，但也避免了上面提到的原生RPC带来的问题。而且REST相比RPC更为灵活，服务提供方和调用方的依赖只依靠一纸契约，不存在代码级别的依赖，这在强调快速演化的微服务环境下，显得更加合适。  
    品牌机与组装机的区别：很明显SpringCloud比dubbo的功能更强大，覆盖面更广，而且能够与SpringFramework、SpringBoot、SpringData、SpringBatch等其他Spring项目完美融合，这些对于微服务至关重要。使用Dubbo构建的微服务架构就像组装电脑、各环节我们选择自由度高，但是最总可能会因为内存质量而影响整体，但对于高手这也就不是问题。而SpringCloud就像品牌机，在Spring Source的整合下，做了大量的兼容性测试，保证了机器拥有更高的稳定性。  
    在面临微服务基础框架选型时Dubbo与SpringCloud只能二选一。

# #

### 2. SpringBoot和SpringCloud,请你谈谈对他们的理解？ ###

①   SpringBoot专注于快速方便的开发单个个体微服务。  
②   SpringCloud是关注全局的微服务协调、整理、治理的框架，它将SpringBoot开发的单体整合并管理起来。  
③   SpringBoot可以离开SpringCloud独立使用开发项目，但是SpringCloud离不开SpringBoot，属于依赖关系。

### 3. 什么是服务熔断？什么是服务降级？ ###

熔断机制是应对雪崩效应的一种微服务链路保护机制。当链路的某个微服务不可用或者响应时间太长时，会进行服务降级，进而熔断该节点微服务的调用，快速返回“错误”的响应信息。当检测到该节点微服务调用响应正常后恢复调用链路。在SpringCloud框架里熔断机制通过Hystrix实现，Hystrix会监控微服务间调用的状况，当失败的调用到一定阈值，缺省是5秒内调用20次，如果失败，就会启动熔断机制。熔断机制的注解是@HystrixCommand  
        服务降级是在客户端，一般是从整体负荷考虑。就是当某个服务熔断之后，服务器将不再被调用，此时客户端可以自己准备一个本地的fallback回调，返回一个缺省值。这样做，虽然水平下降，但好歹可用，比直接挂掉强。

###    4. Eureka和zookeeper都可以提供服务注册与发现的功能，请说说两个的区别？ ###

分布式领域中存在CAP理论，任何分布式系统只可同时满足两点，无法三者兼顾。

①C：Consistency，一致性，数据一致更新，所有数据变动都是同步的。

②A：Availability，可用性，系统具有好的响应性能。

③P：Partition tolerance，分区容错性。

Zookeeper保证了CP（C：一致性，P：分区容错性），Eureka保证了AP（A：高可用）

（1）当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的信息，但不能容忍直接down掉不可用。也就是说，服务注册功能对高可用性要求比较高，但Zookeeper会出现这样一种情况，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新选leader。问题在于，选取leader时间过长，30 ~ 120s，且选取期间zk集群都不可用，这样就会导致选取期间注册服务瘫痪。在云部署的环境下，因网络问题使得zk集群失去master节点是较大概率会发生的事，虽然服务能够恢复，但是漫长的选取时间导致的注册长期不可用是不能容忍的。  
          （2）、Eureka保证了可用性，Eureka各个节点是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点仍然可以提供注册和查询服务。而Eureka的客户端向某个Eureka注册或发现是发生连接失败，则会自动切换到其他节点，只要有一台Eureka还在，就能保证注册服务可用，只是查到的信息可能不是最新的。除此之外，Eureka还有自我保护机制，如果在15分钟内超过85%的节点没有正常的心跳，那么Eureka就认为客户端与注册中心发生了网络故障，此时会出现以下几种情况：  
           ①、Eureka不在从注册列表中移除因为长时间没有收到心跳而应该过期的服务。  
           ②、Eureka仍然能够接受新服务的注册和查询请求，但是不会被同步到其他节点上（即保证当前节点仍然可用）  
           ③、当网络稳定时，当前实例新的注册信息会被同步到其他节点。

因此，Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像Zookeeper那样使整个微服务瘫痪。

[aHR0cHM6Ly9pbWFnZXMuY25ibG9ncy5jb20vY25ibG9nc19jb20vamlsbHpoYW5nL1dpbmRvd3NMaXZlV3JpdGVyL2Zsb2F0X0E5MTkvY2xpcF9pbWFnZTAwMSU1QjMlNURfMi5naWY]: /images/20220321/f3a0f7a4bad444fdbd6af7d85d95f969.png
[double]: /images/20220321/b6bcb8ab947943709337a4cef5f605cc.png
[20190214111733829.png]: /images/20220321/25d8e952a45849fbbfe532977477dac4.png
[format_png]: /images/20220321/8302e5ae4e454f069a9076483b3bae20.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70]: /images/20220321/898a5b6f9437453aa14bb256115d4f45.png
[jmap]: http://my.oschina.net/biezhi/blog/286223#OSC_h2_1
[20190305100157130.png]: /images/20220321/4f103ecdabda460eb03e8745e2b303cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 1]: /images/20220321/99de3472b4c94de692efd549a6876d7f.png
[Link 1]: https://www.ibm.com/developerworks/cn/java/j-jtp06197.html
[20190218151725956.png]: /images/20220321/8032c5f3a5a14e5885b1aa848ec62d54.png
[format_png 1]: /images/20220321/020f771ed3f94ce88d81ec4d4136538c.png
[20190218155734807.png]: /images/20220321/dd2f273aa4cd4af6a6096d7a37ea1010.png
[20160220110058880 _558_231]: /images/20220321/3da20a6ca2fd465db7e93b42cedb4e15.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 2]: /images/20220321/30a29bfd605d418cbe3b432ef08a9eda.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 3]: /images/20220321/5672e1269e9347dc90ed993cf49d9261.png
[20190219171435186.png]: /images/20220321/b86a989968a94e03a342b5ca14ee6514.png
[20190219171851550.png]: /images/20220321/96c9295fc0c2422bab47d15416b2af96.png
[20190221091906149.png]: /images/20220321/e8338e3d4ccf41bf9a8bb8fcb68f4bee.png
[Link 2]: https://www.baidu.com/s?wd=%E6%B5%B7%E9%87%8F%E6%95%B0%E6%8D%AE&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YdPWfdPW03m1w-mvPBmHm40ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EnH0YPWDsnHbznHf1PWmsnjf4rf
[Link 3]: https://www.baidu.com/s?wd=%E4%B8%9A%E5%8A%A1%E9%80%BB%E8%BE%91&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YdPWfdPW03m1w-mvPBmHm40ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EnH0YPWDsnHbznHf1PWmsnjf4rf
[20190225090127299.png]: /images/20220321/b2c7e2b1489a4afe9e82f7b5fda82840.png
[20190225090217820.png]: /images/20220321/d5141183868c47f582cbc67bae232bbd.png
[https_www.cnblogs.com_Survivalist_p_8119891.html]: https://www.cnblogs.com/Survivalist/p/8119891.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 4]: /images/20220321/471df6187a2f4980a81e5504a5d608b6.png
[20190307171239509.png]: /images/20220321/5f046376ab8e4499a99323615443c732.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 5]: /images/20220321/c76537e127f84b998dbabf1c9b481e6e.png
[SouthEast]: /images/20220321/ea7048d8d90146d69fb723980af1d0c4.png
[20190304160505372.png]: /images/20220321/d2cc288ecc234d63942c913e6b389cb5.png
[70]: /images/20220321/46186d139f644200934f55c53bb349eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 6]: /images/20220321/85624c77182040eab8a63e8b88a7499a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 7]: /images/20220321/b75836047b764238996e0735c7a1c687.png