知识整理(一)

我会带着你远行 2021-10-19 08:32 869阅读 0赞

**目录**

1.gcroot有哪些？

2.full gc，Minor gc区别？

3.Compareble 排序

4.分布式锁的几种方案

5.Java中锁的种类

6.线程的状态

7事务隔离级别

8.redis为什么这么快？

9怎么排查cpu过高

10.幻读和脏读的区别

11.hash一致性

12.Hashset和HashMap的区别

13.redis的数据结构

13 redis数据结构应用场景

14 dubbo的序列化方式

15.bio,nio,aio区别

16.怎么判断一个链表有环?

17.链表反转

18.判断两个单向链表是否相交，如果相交，求出交点

19.在一个有环链表中，如何找出链表的入环点？

20.java队列

21.线程池

22.dubbo之间协议

23.mysql索引

24.b+树

25.hashMap源码

26.索引失效

27.jdk动态代理和cjlb区别

28.设计模式

29.单例模式

30.设计模式的原则

31.什么叫做可重入锁

32.死锁的条件，死锁的解决方式

33.斐波那契数列全算法

34.泛型

35.怎么线上判断堆栈的健康

36.java类加载过程

37.常见算法待更新

38 redis淘汰策略

39.redis集群方式

40.redis分布式锁

41.单链表反转

42.mysql主从复制

43.网络中的三次握手和四次挥手

44.java中常见的集合类

45.springmvc 请求过程

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

### 1.gcroot有哪些？ ###

a.虚拟机栈(栈桢中的本地变量表)中的引用的对象

b.方法区中的类静态属性引用的对象

c.方法区中的常量引用的对象

d.本地方法栈中JNI的引用的对象

### 2.full gc，**Minor** gc区别？ ###

Gc触发条件：系统调用system.gc();

当年轻代需要回收时会触发**Minor GC**(也称作**Young GC**)。

年轻代由Eden Space和两块相同大小的Survivor Space（又称From Space和To Space）构成，Eden区和Servior区的内存比为8:1，可通过-Xmn参数来调整新生代大小，也可通过-XX:SurvivorRadio来调整Eden Space和Survivor Space大小。不同的GC方式会按不同的方式来按此值划分Eden Space和Survivor Space，有些GC方式还会根据运行状况来动态调整Eden、From Space、To Space的大小。

年轻代的Eden区内存是连续的，所以其分配会非常快；同样Eden区的回收也非常快（因为大部分情况下Eden区对象存活时间非常短，而Eden区采用的复制回收算法，此算法在存活对象比例很少的情况下非常高效）。如果在执行垃圾回收之后，仍没有足够的内存分配，也不能再扩展，将会抛出OutOfMemoryError:Java Heap Space异常。

Minor GC触发条件：当Eden区满时，触发Minor GC。

Full GC触发条件：

（1）调用System.gc时，系统建议执行Full GC，但是不必然执行

（2）老年代空间不足

（3）方法区空间不足

（4）通过Minor GC后进入老年代的平均大小大于老年代的可用内存

（5）由Eden区、From Space区向To Space区复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小。

### 3.Compareble 排序 ###

### 4.分布式锁的几种方案 ###

1.基于数据库。

2.基于缓存环境，redis，memcache等。

3.基于zookeeper。

zookeeper分布式锁特点:

使用zookeeper创建临时序列节点来实现分布式锁，适用于顺序执行的程序，大体思路就是创建临时序列节点，找出最小的序列节点，获取分布式锁，程序执行完成之后此序列节点消失，通过watch来监控节点的变化，从剩下的节点的找到最小的序列节点，获取分布式锁，执行相应处理，依次类推……

### 5.Java中锁的种类 ###

乐观锁，悲观锁，可重入锁，分段锁等

悲观锁  
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁  
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write\_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

两种锁的使用场景  
从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

[https://blog.csdn.net/qq\_34337272/article/details/81072874][https_blog.csdn.net_qq_34337272_article_details_81072874]

### 6.线程的状态 ###

新建，就绪，运行，阻塞，死亡

![è¿éåå¾çæè¿°][SouthEast]

### 7事务隔离级别 ###

读已提交，读未提交，重复读，串行读

**为什么mysql用的是repeatable而不是read committed:在 5.0之前只有statement一种格式，而主从复制存在了大量的不一致，故选用repeatable**

### 8.redis为什么这么快？ ###

1、完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)；

2、数据结构简单，对数据操作也简单，Redis中的数据结构是专门进行设计的；

3、采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；

4、使用多路I/O复用模型，非阻塞IO；

5、使用底层模型不同，它们之间底层实现方式以及与客户端之间通信的应用协议不一样，Redis直接自己构建了VM 机制 ，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求；

### 9怎么排查cpu过高 ###

1. 使用top命令定位异常进程。可以看见12836的CPU和内存占用率都非常高

2.使用top -H -p 进程号查看异常线程

3.使用printf "%x\\n" 线程号将异常线程号转化为16进制

4. 使用jstack 进程号|grep 16进制异常线程号 -A90来定位异常代码的位置（最后的-A90是日志行数，也可以输出为文本文件或使用其他数字）。可以看到异常代码的位置

### 10.幻读和脏读的区别 ###

脏读：脏读是读到了别的事务回滚前的脏数据。比如事务B执行过程中修改了数据X，在未提交前，事务A读取了X，而事务B却回滚了，这样事务A就形成了脏读。

幻读：事务A首先根据条件索引得到N条数据，然后事务B改变了这N条数据之外的M条或者增添了M条符合事务A搜索条件的数据，导致事务A再次搜索发现有N+M条数据了，就产生了幻读

[不可重复读][Link 1]：事务A首先读取了一条数据，然后执行逻辑的时候，事务B将这条数据改变了，然后事务A再次读取的时候，发现数据不匹配了，就是所谓的[不可重复读][Link 1]了。

也就是说，当前事务先进行了一次数据读取，然后再次读取到的数据是别的事务修改成功的数据，导致两次读取到的数据不匹配，也就照应了[不可重复读][Link 1]的语义

### 11.hash一致性 ###

首先什么是一致性哈希算法?***一致性哈希算法(Consistent Hashing Algorithm)是一种分布式算法，常用于负载均衡。Memcached client也选择这种算法，解决将key-value均匀分配到众多Memcached server上的问题。它可以取代传统的取模操作，解决了取模操作无法应对增删Memcached Server的问题(增删server会导致同一个key,在get操作时分配不到数据真正存储的server，命中率会急剧下降)。***

### 12.Hashset和HashMap的区别 ###

HashSet就是一个简化板的hashmap，仅仅存放了HashMap中的key而已

### 13.redis的数据结构 ###

字符串：sds动态字节码

列表：列表是使用ziplist和linkedlist实现的，在这些老版本中，当列表对象同时满足以下两个条件时，列表对象使用ziplist编码：

列表对象保存的所有字符串元素的长度都小于64字节

列表对象保存的元素数量小于512个

hash：

redis的散列可以存储多个键 值 对之间的映射，散列存储的值既可以是字符串又可以是数字值，并且用户同样可以对散列存储的数字值执行自增操作或者自减操作。散列可以看作是一个文档或关系数据库里的一行。hash底层的数据结构实现有两种：

一种是ziplist，上面已经提到过。当存储的数据超过配置的阀值时就是转用hashtable的结构。这种转换比较消耗性能，所以应该尽量避免这种转换操作。同时满足以下两个条件时才会使用这种结构：

当键的个数小于hash-max-ziplist-entries（默认512）

当所有值都小于hash-max-ziplist-value（默认64）

另一种就是hashtable。这种结构的时间复杂度为O(1)，但是会消耗比较多的内存空间。

zset：

是ziplist结构。

与上面的hash中的ziplist类似，member和score顺序存放并按score的顺序排列

另一种是skiplist与dict的结合。

set：

### 13 redis数据结构应用场景 ###

String，redis对于KV的操作效率很高，可以直接用作计数器。例如，统计在线人数等等，另外string类型是二进制存储安全的，所以也可以使用它来存储图片，甚至是视频等。

hash，存放键值对，一般可以用来存某个对象的基本属性信息，例如，用户信息，商品信息等，另外，由于hash的大小在小于配置的大小的时候使用的是ziplist结构，比较节约内存，所以针对大量的数据存储可以考虑使用hash来分段存储来达到压缩数据量，节约内存的目的，例如，对于大批量的商品对应的图片地址名称。比如：商品编码固定是10位，可以选取前7位做为hash的key,后三位作为field，图片地址作为value。这样每个hash表都不超过999个，只要把redis.conf中的hash-max-ziplist-entries改为1024，即可。

list，列表类型，可以用于实现消息队列，也可以使用它提供的range命令，做分页查询功能。

set，集合，整数的有序列表可以直接使用set。可以用作某些去重功能，例如用户名不能重复等，另外，还可以对集合进行交集，并集操作，来查找某些元素的共同点

zset，有序集合，可以使用范围查找，排行榜功能或者topN功能。

### 14 dubbo的序列化方式 ###

fastjson，hession2

### 15.bio,nio,aio区别 ###

BIO是一个连接一个线程。

NIO是一个请求一个线程。

AIO是一个有效请求一个线程。

### 16.怎么判断一个链表有环? ###

三种方法，hashset存id，每遍历一个节点对比之前节点，两个指针，一个走一步，一个走两步。

### 17.链表反转 ###

方法1：将单链表储存为数组，然后按照数组的索引逆序进行反转。

方法2：使用3个指针遍历单链表，逐个链接点进行反转。

方法3：从第2个节点到第N个节点，依次逐节点插入到第1个节点(head节点)之后，最后将第一个节点挪到新表的表尾。

方法4:   递归(相信我们都熟悉的一点是，对于树的大部分问题，基本可以考虑用递归来解决。但是我们不太熟悉的一点是，对于单链表的一些问题，也可以使用递归。可以认为单链表是一颗永远只有左(右)子树的树，因此可以考虑用递归来解决。或者说，因为单链表本身的结构也有自相似的特点，所以可以考虑用递归来解决)

### 18.判断两个单向链表是否相交，如果相交，求出交点 ###

如果相交的话最后一个节点必然相等，   第一个链表的尾部指向第二个头部，判断单链表是否有环。

hashset存储焦点。

### 19.在一个有环链表中，如何找出链表的入环点？ ###

p1.p2两个指针的问题。

### 20.java队列 ###

\* ArrayBlockingQueue ：一个由数组支持的有界队列。  
　　\* LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。  
　　\* PriorityBlockingQueue ：一个由优先级堆支持的无界优先级队列。  
　　\* DelayQueue ：一个由优先级堆支持的、基于时间的调度队列。  
　　\* SynchronousQueue ：一个利用 BlockingQueue 接口的简单聚集（rendezvous）机制。

### 21.线程池 ###

*  corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
 *  maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
 *  keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
 *  unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

*  workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
 *  TimeUnit.DAYS; //天
 *  TimeUnit.HOURS; //小时
 *  TimeUnit.MINUTES; //分钟
 *  TimeUnit.SECONDS; //秒
 *  TimeUnit.MILLISECONDS; //毫秒
 *  TimeUnit.MICROSECONDS; //微妙
 *  TimeUnit.NANOSECONDS;
 *  workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：ArrayBlockingQueue;
 *  LinkedBlockingQueue;  
    SynchronousQueue;

ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

*  threadFactory：线程工厂，主要用来创建线程；
 *  handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
    ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
    ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
    ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

参考

[https://blog.csdn.net/weixin\_28760063/article/details/81266152][https_blog.csdn.net_weixin_28760063_article_details_81266152]

### 22.dubbo之间协议 ###

Dubbo支持dubbo、rmi、hessian、http、webservice、thrift、redis等多种协议，但是Dubbo官网是推荐我们使用Dubbo协议的。

### 23.mysql索引 ###

1.普通索引index :加速查找
    2.唯一索引
        主键索引：primary key ：加速查找+约束（不为空且唯一）
        唯一索引：unique：加速查找+约束 （唯一）
    3.联合索引
        -primary key(id,name):联合主键索引
        -unique(id,name):联合唯一索引
        -index(id,name):联合普通索引
    4.全文索引fulltext :用于搜索很长一篇文章的时候，效果最好。
    5.空间索引spatial :了解就好，几乎不用

#我们可以在创建上述索引的时候，为其指定索引类型，分两类
    hash类型的索引：查询单条快，范围查询慢
    btree类型的索引：b+树，层数越多，数据量指数级增长（我们就用它，因为innodb默认支持它）
    
    #不同的存储引擎支持的索引类型也不一样
    InnoDB 支持事务，支持行级别锁定，支持 B-tree、Full-text 等索引，不支持 Hash 索引；
    MyISAM 不支持事务，支持表级别锁定，支持 B-tree、Full-text 等索引，不支持 Hash 索引；
    Memory 不支持事务，支持表级别锁定，支持 B-tree、Hash 等索引，不支持 Full-text 索引；
    NDB 支持事务，支持行级别锁定，支持 Hash 索引，不支持 B-tree、Full-text 等索引；
    Archive 不支持事务，支持表级别锁定，不支持 B-tree、Hash、Full-text 等索引；

### 24.b+树 ###

B+树是应文件系统所需而产生的一种B树的变形树（文件的目录一级一级索引，只有最底层的叶子节点（文件）保存数据）非叶子节点只保存索引，不保存实际的数据，数据都保存在叶子节点中，这不就是文件系统文件的查找吗?

1、非叶子节点的子树指针与关键字个数相同；   
2、非叶子节点的子树指针p\[i\],指向关键字值属于\[k\[i\],k\[i+1\]\]的子树.(B树是开区间,也就是说B树不允许关键字重复,B+树允许重复)；   
3、为所有叶子节点增加一个链指针；   
4、所有关键字都在叶子节点出现(稠密索引). (且链表中的关键字恰好是有序的)；   
5、非叶子节点相当于是叶子节点的索引(稀疏索引),叶子节点相当于是存储(关键字)数据的数据层；   
6、更适合于文件系统；

### 25.hashMap源码 ###

非线程安全

hash碰撞

### 26.索引失效 ###

1.如果条件中有or，即使其中有条件带索引也不会使用(这也是为什么尽量少用or的原因)

2.like查询是以%开头

3.如果列类型是字符串，那一定要在条件中将数据使用引号引用起来,否则不使用索引

4.没有查询条件，或者查询条件没有建立索引

5. 在查询条件上没有使用引导列

### 27.jdk动态代理和cjlb区别 ###

DK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，**但因为采用的是继承，所以不能对final修饰的类进行代理**。   
示例

对于JDK 的Proxy,有以下几点：

1）Interface：对于JDK proxy，业务类是需要一个Interface的，这也是一个缺陷

2）Proxy，Proxy 类是动态产生的，这个类在调用Proxy.newProxyInstance(targetCls.getClassLoader, targetCls.getInterface,InvocationHander)之后，会产生一个Proxy类的实例。实际上这个Proxy类也是存在的，不仅仅是类的实例。这个Proxy类可以保存到硬盘上。

3） Method:对于业务委托类的每个方法，现在Proxy类里面都不用静态显示出来

4） InvocationHandler: 这个类在业务委托类执行时，会先调用invoke方法。invoke方法再执行相应的代理操作，可以实现对业务方法的再包装

### 28.设计模式 ###

23种模式，单例模式，策略模式，工程模式，构造模式等

### 29.单例模式 ###

懒汉，饿汉

class SingletonHungary \{  
    private static SingletonHungary singletonHungary = new SingletonHungary();  
    //将构造器设置为private禁止通过new进行实例化  
    private SingletonHungary() \{  
          
    \}  
    public static SingletonHungary getInstance() \{  
        return singletonHungary;  
    \}  
\}

class SingletonLazy1 \{  
    private static SingletonLazy1 singletonLazy;

private SingletonLazy1() \{

public static SingletonLazy1 getInstance() \{  
        if (null == singletonLazy) \{  
            try \{  
                // 模拟在创建对象之前做一些准备工作  
                Thread.sleep(1000);  
            \} catch (InterruptedException e) \{  
                e.printStackTrace();  
            \}  
            singletonLazy = new SingletonLazy1();  
        \}  
        return singletonLazy;  
    \}  
\}

### 30.设计模式的原则 ###

**1.单一原则**（Single Responsibility Principle）：一个类只负责一项职责，尽量做到类的只有一个行为原因引起变化；

a、业务对象（BO business object）、业务逻辑（BL business logic）拆分；

**2.里氏替换原则**（LSP liskov substitution principle）：子类可以扩展父类的功能，但不能改变原有父类的功能；

（目的：增强程序的健壮性）实际项目中，每个子类对应不同的业务含义，使父类作为参数，传递不同的子类完成不同的业务逻辑。

**3.依赖倒置原则（dependence inversion principle）**：面向接口编程；（通过接口作为参数实现应用场景）

抽象就是接口或者抽象类，细节就是实现类

含义：

上层模块不应该依赖下层模块，两者应依赖其抽象；

抽象不应该依赖细节，细节应该依赖抽象；

【接口负责定义public属性和方法，并且申明与其他对象依赖关系，抽象类负责公共构造部分的实现，实现类准确的实现业务逻辑】

**4.接口隔离（interface segregation principle）**：建立单一接口；（扩展为类也是一种接口，一切皆接口）

定义：

a.客户端不应该依赖它不需要的接口；

b.类之间依赖关系应该建立在最小的接口上；

【接口的设计粒度越小，系统越灵活，但是灵活的同时结构复杂性提高，开发难度也会变大，维护性降低】

**5.迪米特原则（law of demeter LOD）**：最少知道原则，尽量降低类与类之间的耦合；

一个对象应该对其他对象有最少的了解

**6.开闭原则（open closed principle）：**用抽象构建架构，用实现扩展原则；（总纲）

**（solid稳定的  记忆首字母）**

### **31.什么叫做可重入锁** ###

ReentrantLock支持两种获取锁的方式，一种是公平模型，一种是非公平模型。在继续之前，咱们先把故事元素转换为程序元素。

ReentrantLock 是一个**可重入的互斥（/独占）锁**，又称为“独占锁”。

**独占”**，就是在同一时刻只能有一个线程获取到锁，而其它获取锁的线程只能处于同步队列中等待，只有获取锁的线程释放了锁，后继的线程才能够获取锁。

**“可重入”**，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。

讲解：

[https://www.cnblogs.com/gxyandwmm/p/9387833.html][https_www.cnblogs.com_gxyandwmm_p_9387833.html]

### 32.死锁的条件，死锁的解决方式 ###

死锁是由于两个或以上的线程互相持有对方需要的资源，导致这些线程处于等待状态，无法执行。

1.互斥性：线程对资源的占有是排他性的，一个资源只能被一个线程占有，直到释放。

2.请求和保持条件：一个线程对请求被占有资源发生阻塞时，对已经获得的资源不释放。

3.不剥夺：一个线程在释放资源之前，其他的线程无法剥夺占用。

4.循环等待：发生死锁时，线程进入死循环，永久阻塞。

解决方式

1.每个进程、每个资源制定唯一编号

2.设定一张资源分配表，记录各进程与占用资源之间的关系

3.设置一张进程等待表，记录各进程与要申请资源之间的关系

允许进程进行抢占，方法一：如果去抢资源，被拒绝，就释放自己的资源。方法二：操作系统允许抢，只要你优先级大，可以抢到。

想办法，让进程不要那么贪心，自己已经有了资源就不要去竞争那些不可抢占的资源。比如，让进程在申请资源时，一次性申请所有需要用到的资源，不要一次一次来申请，当申请的资源有一些没空，那就让线程等待。不过这个方法比较浪费资源，进程可能经常处于饥饿状态。还有一种方法是，要求进程在申请资源前，要释放自己拥有的资源。

允许进程进行抢占，方法一：如果去抢资源，被拒绝，就释放自己的资源。方法二：操作系统允许抢，只要你优先级大，可以抢到。

### 33.斐波那契数列全算法 ###

[https://blog.csdn.net/acecandy/article/details/83864763][https_blog.csdn.net_acecandy_article_details_83864763]

### 34.泛型 ###

**泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。**

**泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）**。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

![aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvNzAyNDM0LzIwMTcwNy83MDI0MzQtMjAxNzA3MDIwMTEwMjc3NzQtMTkwNTA3OTc0OS5wbmc][]

### 35.怎么线上判断堆栈的健康 ###

jps \#显示所有java程序和线程ID

jps -m \#输出main method的参数

jps -l \#输出完全的包名，应用主类名，jar的完全路径名

jps -v \#输出jvm参数

$jstack –l 23561 >> xxx.dump

通过上节的介绍的方法打印堆栈信息，我们只关注java用户线程，其他由虚拟机自动创建的，在实际分析中，只关心java用户线程即可。

*  当一个线程占有一个锁的时候，线程堆栈会打印一个－locked<0x22bffb60>
 *  当一个线程正在等在其他线程释放该锁，线程堆栈会打印一个－waiting to lock<0x22bffb60>
 *  当一个线程占有一个锁，但又执行在该锁的wait上，线程堆栈中首先打印locked,然后打印－waiting on <0x22c03c60>

### 36.java类加载过程 ###

![aHR0cHM6Ly9pbWFnZXMyMDE3LmNuYmxvZ3MuY29tL2Jsb2cvNjg4NjcwLzIwMTcxMS82ODg2NzAtMjAxNzExMTMwMDIxNDExMjItMjEzMjk1NDU0Mi5wbmc][]

### 37.常见算法待更新 ###

/**
         * 冒泡排序
         *
         * @param a
         * @return
         */
        public static int[] bubbleSort(int a[]) {
            for (int i = 0; i < a.length; i++) {
                int temp = a[i];
                for (int j = i + 1; j < a.length; j++) {
                    if (temp > a[j]) {
                        a[i] = a[j];
                        a[j] = temp;
                        temp = a[i];
                    }
                }
            }
            return a;
        }
    
        /**
         * 插入排序
         */
        public static int[] insertSort(int a[]) {
            for (int i = 1; i < a.length; i++) {
                int temp = a[i];
                for (int j = i - 1; j < i; j++) {
                    if (temp > a[j]) {
                        a[i] = a[j];
                        a[j] = temp;
                        temp = a[i];
                    }
                }
            }
            return a;
        }
    
    /**
         * 快排
         *
         * @param a
         * @return
         */
        public static void quickSort(int a[], int low, int high) {
            int i, j, temp, t;
            if (low > high) {
                return;
            }
            i = low;
            j = high;
            temp = a[low];
    
            while (i < j) {
                while (a[j] <= temp && i < j) {
                    j--;
                }
                while (a[i] >= temp && i < j) {
                    i++;
                }
    
                t = a[i];
                a[i] = a[j];
                a[j] = t;
    
            }
            a[low] = a[j];
            a[j] = temp;
            quickSort(a, low, j - 1);
            quickSort(a, j + 1, high);
        }
    
     /**
         * 选择排序
         *
         * @param a
         */
        public static void selectSort(int a[]) {
            int len = a.length;
            for (int i = 0; i < len; i++) {
                int min = i;
                for (int j = i + 1; j < len; j++) {
                    if (a[j] < a[min]) {
                        min = j;
                    }
                }
                int temp = a[min];
                a[min] = a[i];
                a[i] = temp;
            }
        }
    
     public static void headSort(int[] list) {
            //构造初始堆,从第一个非叶子节点开始调整,左右孩子节点中较大的交换到父节点中
            for (int i = (list.length) / 2 - 1; i >= 0; i--) {
                headAdjust(list, list.length, i);
            }
            //排序，将最大的节点放在堆尾，然后从根节点重新调整
            for (int i = list.length - 1; i >= 1; i--) {
                int temp = list[0];
                list[0] = list[i];
                list[i] = temp;
                headAdjust(list, i, 0);
            }
        }
        
        private static void headAdjust(int[] list, int len, int i) {
            int k = i, temp = list[i], index = 2 * k + 1;
            while (index < len) {
                if (index + 1 < len) {
                    if (list[index] < list[index + 1]) {
                        index = index + 1;
                    }
                }
                if (list[index] > temp) {
                    list[k] = list[index];
                    k = index;
                    index = 2 * k + 1;
                } else {
                    break;
                }
            }
            list[k] = temp;
        }

### 38 redis淘汰策略 ###

noeviction: 不删除策略, 达到最大内存限制时, 如果需要更多内存, 直接返回错误信息。 大多数写命令都会导致占用更多的内存(有极少数会例外, 如 DEL )。  
allkeys-lru: 所有key通用; 优先删除最近最少使用(less recently used ,LRU) 的 key。  
volatile-lru: 只限于设置了 expire 的部分; 优先删除最近最少使用(less recently used ,LRU) 的 key。  
allkeys-random: 所有key通用; 随机删除一部分 key。  
volatile-random: 只限于设置了 expire 的部分; 随机删除一部分 key。  
volatile-ttl: 只限于设置了 expire 的部分; 优先删除剩余时间(time to live,TTL) 短的key。

### 39.redis集群方式 ###

redis有三种集群方式：主从复制，哨兵模式和集群。

**1.主从复制**

**主从复制原理：**

*  从服务器连接主服务器，发送SYNC命令； 
 *  主服务器接收到SYNC命名后，开始执行BGSAVE命令生成RDB文件并使用缓冲区记录此后执行的所有写命令； 
 *  主服务器BGSAVE执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令； 
 *  从服务器收到快照文件后丢弃所有旧数据，载入收到的快照； 
 *  主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令； 
 *  从服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令；（**从服务器初始化完成**）
 *  主服务器每执行一个写命令就会向从服务器发送相同的写命令，从服务器接收并执行收到的写命令（**从服务器初始化完成后的操作**）

**主从复制优缺点：**

**优点：**

*  支持主从复制，主机会自动将数据同步到从机，可以进行读写分离
 *  为了分载Master的读操作压力，Slave服务器可以为客户端提供只读操作的服务，写服务仍然必须由Master来完成
 *  Slave同样可以接受其它Slaves的连接和同步请求，这样可以有效的分载Master的同步压力。
 *  Master Server是以非阻塞的方式为Slaves提供服务。所以在Master-Slave同步期间，客户端仍然可以提交查询或修改请求。
 *  Slave Server同样是以非阻塞的方式完成数据同步。在同步期间，如果有客户端提交查询请求，Redis则返回同步之前的数据

**缺点：**

*  Redis不具备自动容错和恢复功能，主机从机的宕机都会导致前端部分读写请求失败，需要等待机器重启或者手动切换前端的IP才能恢复。
 *  主机宕机，宕机前有部分数据未能及时同步到从机，切换IP后还会引入数据不一致的问题，降低了系统的可用性。
 *  Redis较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。

**2.哨兵模式**

当主服务器中断服务后，可以将一个从服务器升级为主服务器，以便继续提供服务，但是这个过程需要人工手动来操作。 为此，Redis 2.8中提供了哨兵工具来实现自动化的系统监控和故障恢复功能。

哨兵的作用就是监控Redis系统的运行状况。它的功能包括以下两个。

（1）监控主服务器和从服务器是否正常运行。   
    （2）主服务器出现故障时自动将从服务器转换为主服务器。

**哨兵的工作方式：**

*  每个Sentinel（哨兵）进程以每秒钟一次的频率向整个集群中的Master主服务器，Slave从服务器以及其他Sentinel（哨兵）进程发送一个 PING 命令。
 *  如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 Sentinel（哨兵）进程标记为主观下线（SDOWN）
 *  如果一个Master主服务器被标记为主观下线（SDOWN），则正在监视这个Master主服务器的所有 Sentinel（哨兵）进程要以每秒一次的频率确认Master主服务器的确进入了主观下线状态
 *  当有足够数量的 Sentinel（哨兵）进程（大于等于配置文件指定的值）在指定的时间范围内确认Master主服务器进入了主观下线状态（SDOWN）， 则Master主服务器会被标记为客观下线（ODOWN）
 *  在一般情况下， 每个 Sentinel（哨兵）进程会以每 10 秒一次的频率向集群中的所有Master主服务器、Slave从服务器发送 INFO 命令。
 *  当Master主服务器被 Sentinel（哨兵）进程标记为客观下线（ODOWN）时，Sentinel（哨兵）进程向下线的 Master主服务器的所有 Slave从服务器发送 INFO 命令的频率会从 10 秒一次改为每秒一次。
 *  若没有足够数量的 Sentinel（哨兵）进程同意 Master主服务器下线， Master主服务器的客观下线状态就会被移除。若 Master主服务器重新向 Sentinel（哨兵）进程发送 PING 命令返回有效回复，Master主服务器的主观下线状态就会被移除。

**哨兵模式的优缺点**

**优点：**

*  哨兵模式是基于主从模式的，所有主从的优点，哨兵模式都具有。
 *  主从可以自动切换，系统更健壮，可用性更高。

**缺点：**

*  Redis较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。

**3.Redis-Cluster集群**

redis的哨兵模式基本已经可以实现高可用，读写分离 ，但是在这种模式下每台redis服务器都存储相同的数据，很浪费内存，所以在redis3.0上加入了cluster模式，实现的redis的分布式存储，也就是说每台redis节点上存储不同的内容。

Redis-Cluster采用无中心结构,它的特点如下：

*  所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽。
 *  节点的fail是通过集群中超过半数的节点检测失效时才生效。
 *  客户端与redis节点直连,不需要中间代理层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可。

**工作方式：**

在redis的每一个节点上，都有这么两个东西，一个是插槽（slot），它的的取值范围是：0-16383。还有一个就是cluster，可以理解为是一个集群管理的插件。当我们的存取的key到达的时候，redis会根据crc16的算法得出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，通过这个值，去找到对应的插槽所对应的节点，然后直接自动跳转到这个对应的节点上进行存取操作。

为了保证高可用，redis-cluster集群引入了主从模式，一个主节点对应一个或者多个从节点，当主节点宕机的时候，就会启用从节点。当其它主节点ping一个主节点A时，如果半数以上的主节点与A通信超时，那么认为主节点A宕机了。如果主节点A和它的从节点A1都宕机了，那么该集群就无法再提供服务了。

### 40.redis分布式锁 ###

public static boolean tryGetDistributedLock(Jedis jedis, String lockKey, String requestId, int expireTime) \{

String result = jedis.set(lockKey, requestId, SET\_IF\_NOT\_EXIST, SET\_WITH\_EXPIRE\_TIME, expireTime);

if (LOCK\_SUCCESS.equals(result)) \{

return true;

return false;

可以看到，我们加锁就一行代码：jedis.set(String key, String value, String nxxx, String expx, int time)，这个set()方法一共有五个形参：

第一个为key，我们使用key来当锁，因为key是唯一的。

第二个为value，我们传的是requestId，很多童鞋可能不明白，有key作为锁不就够了吗，为什么还要用到value？原因就是我们在上面讲到可靠性时，分布式锁要满足第四个条件解铃还须系铃人，通过给value赋值为requestId，我们就知道这把锁是哪个请求加的了，在解锁的时候就可以有依据。requestId可以使用UUID.randomUUID().toString()方法生成。

第三个为nxxx，这个参数我们填的是NX，意思是SET IF NOT EXIST，即当key不存在时，我们进行set操作；若key已经存在，则不做任何操作；

第四个为expx，这个参数我们传的是PX，意思是我们要给这个key加一个过期的设置，具体时间由第五个参数决定。

第五个为time，与第四个参数相呼应，代表key的过期时间。

总的来说，执行上面的set()方法就只会导致两种结果：1. 当前没有锁（key不存在），那么就进行加锁操作，并对锁设置个有效期，同时value表示加锁的客户端。2. 已有锁存在，不做任何操作。

### 41.单链表反转 ###

public static class Node {
        public int value;
        public Node next;
    
        public Node(int data) {
            this.value = data;
        }
    }

反转方法如下：

public Node reverse(Node head) {
        if (head == null || head.next == null)
            return head;
        Node temp = head.next;
        Node newHead = reverse(head.next);
        temp.next = head;
        head.next = null;
        return newHead;
    }

### 42.mysql主从复制 ###

mysql主从是异步复制过程

master开启bin-log功能，日志文件用于记录数据库的读写增删  
需要开启3个线程，master IO线程，slave开启 IO线程 SQL线程，  
Slave 通过IO线程连接master，并且请求某个bin-log，position之后的内容。  
MASTER服务器收到slave IO线程发来的日志请求信息，io线程去将bin-log内容，position返回给slave IO线程。  
slave服务器收到bin-log日志内容，将bin-log日志内容写入relay-log中继日志，创建一个master.info的文件，该文件记录了master ip 用户名 密码 master bin-log名称，bin-log position。  
slave端开启SQL线程，实时监控relay-log日志内容是否有更新，解析文件中的SQL语句，在slave数据库中去执行。

### 43.网络中的三次握手和四次挥手 ###

[https://www.cnblogs.com/lms0755/p/9053119.html][https_www.cnblogs.com_lms0755_p_9053119.html]

![format_png][]

![format_png 1][]

### 44.java中常见的集合类 ###

首先java中集合类主要有两大分支：

（1）Collection （2）Map

先看它们的类图：

(1)Collection

![Collection][]

(2)Map   
![Map][]

粗略一看一堆类很吓人，但其实用起来很方便很简单。

先看看Collection下的东西：

List：

1.可以允许重复的对象。

2.可以插入多个null元素。

3.是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。

常用的实现类有 ArrayList、LinkedList 和 Vector。

ArrayList和Vector底层都是用数组实现的，最大的区别在于Vector是线程安全的，因此效率不如ArrayList。

LinkedList底层用双链表实现，与前两个相比，优点是便于增删元素，缺点是访问元素性能效率相对低。

（数组连续内存空间，查找速度快，增删慢；链表充分利用了内存，存储空间是不连续的，首尾存储上下一个节点的信息，所以寻址麻烦，查找速度慢，但是增删快。）

还有一点是继承Vector类的Stack，Java自带的栈。进栈push()，弹栈pop()，获取栈顶peek()，判断空否empty()...

Set：

1.不允许重复对象

2. 无序容器，你无法保证每个元素的存储顺序，TreeSet通过 Comparator  或者 Comparable 维护了一个排序顺序。

3. 只允许一个 null 元素

Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet；TreeSet 还实现了 SortedSet 接口，因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。

HashSet：哈希表是通过使用称为散列法的机制来存储信息的，元素并没有以某种特定顺序来存放；底层是HashMap。

LinkedHashSet：以元素插入的顺序来维护集合的链接表，允许以插入的顺序在集合中迭代； 底层是HashMap。

TreeSet：提供一个使用树结构存储Set接口的实现，对象以升序顺序存储，访问和遍历的时间很快。底层是TreeMap。

例子：插入BADECF  [https://www.cnblogs.com/ibook360/archive/2011/11/28/2266062.html][https_www.cnblogs.com_ibook360_archive_2011_11_28_2266062.html]

HashSet<String> hs = new xxxxSet<String>();  
            hs.add("B");  
            hs.add("A");  
            hs.add("D");  
            hs.add("E");  
            hs.add("C");  
            hs.add("F");  
            System.out.println("xxxxSet 顺序:\n"+hs);

HashSet 顺序:

\[D, E, F, A, B, C\] //无序

LinkedHashSet 顺序:

\[B, A, D, E, C, F\] //插入顺序

TreeSet 顺序:

\[A, B, C, D, E, F\] //有序

Queue:        [https://www.cnblogs.com/zhilu-doc/p/5251643.html][https_www.cnblogs.com_zhilu-doc_p_5251643.html]

没怎么用过。可以用LinkedList实现，例如：Queue q = new LinkedList();

remove    移除并返回队列头部的元素    如果队列为空，则抛出一个NoSuchElementException异常

element   返回队列头部的元素             如果队列为空，则抛出一个NoSuchElementException异常

offer       添加一个元素并返回true       如果队列已满，则返回false  
poll         移除并返问队列头部的元素    如果队列为空，则返回null

peek       返回队列头部的元素             如果队列为空，则返回null

offer,poll,peek对应add,remove,element，区别在于前者不会抛出异常，而是返回false或null。

接下来看看Map有什么好东西

Map:

1.Map 不是collection的子接口或者实现类。Map是一个接口。

2.Map 的每个 Entry 都持有两个对象，也就是一个键一个值，Map 可能会持有相同的值对象但键对象必须是唯一的。

3. Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。

4.Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。（HashMap、TreeMap最常用）

HashMap                [ https://blog.csdn.net/junchenbb0430/article/details/78643100][https_blog.csdn.net_junchenbb0430_article_details_78643100]

HashMap是很常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度，遍历时，取得数据的顺序是完全随机的。因为键对象不可以重复，所以HashMap最多只允许一条记录的键为Null，允许多条记录的值为Null，是非同步的，底层是数组+链表。先对Key用hashcode()计算存放位置，再对Key用equals()遍历链表查找。

默认：初始容量为 16，负载因子为 0.75，当存储元素>容量\*负载因子时扩容。

在jdk1.8版本后，java对HashMap做了改进，在链表长度大于8的时候，将后面的数据存在红黑树中，以加快检索速度。

（解决链表长度过长时链表的查询性能差的问题）

![70][]

Hashtable

Hashtable与HashMap类似，是HashMap的线程安全版，它支持线程的同步，即任一时刻只有一个线程能写Hashtable，因此也导致了Hashtale在写入时会比较慢，它继承自Dictionary类，不同的是它不允许记录的键或者值为null，同时效率较低。

ConcurrentHashMap

线程安全，并且锁分离。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行。

LinkedHashMap

LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的，在遍历的时候会比HashMap慢，有HashMap的全部特性。

TreeMap

TreeMap实现SortMap接口，能够把它保存的记录根据键排序，默认是按键值的升序排序（自然顺序），也可以指定排序的比较器，当用Iterator遍历TreeMap时，得到的记录是排过序的。不允许key值为空，非同步的；

Map推荐遍历方式

entrySet（）  
Set<Map.Entry<K,V>> entrySet() //返回此映射中包含的映射关系的 Set 视图。（一个关系就是一个键-值对），就是把(key-value)作为一个整体一对一对地存放到Set集合当中的。Map.Entry表示映射关系。entrySet()：迭代后可以e.getKey()，e.getValue()两种方法来取key和value。返回的是Entry接口。  
典型用法如下：  
  
//将map集合中的映射关系取出，存入到set集合  
Iterator it = map.entrySet().iterator();  
while(it.hasNext())\{

> Entry e =(Entry) it.next();
> 
> System.out.println("键"+e.getKey () + "的值为" + e.getValue());

### 45.springmvc 请求过程 ###

![format_png 2][]

![format_png 3][]

### 46.linux查询磁盘IO命令 ###

第一种：用 top 命令 中的cpu 信息观察

第二种：用vmstat

vmstat 命令报告关于线程、虚拟内存、磁盘、陷阱和 CPU 活动的统计信息。由 vmstat 命令生成的报告可以用于平衡系统负载活动。系统范围内的这些统计信息(所有的处理器中)都计算出以百分比表示的平均值，或者计算其总和。

第三种：用iostat

### 46.Linux 查看系统信息命令 cpu、内存、进程、硬盘、网卡 ###

**一.统计磁盘整体情况，包括磁盘大小，已使用，可用。命令“df”**

**系统**   
uname -a \# 查看内核/操作系统/CPU信息   
head -n 1 /etc/issue \# 查看操作系统版本   
cat /proc/cpuinfo \# 查看CPU信息   
hostname \# 查看计算机名   
lspci -tv \# 列出所有PCI设备   
lsusb -tv \# 列出所有USB设备   
lsmod \# 列出加载的内核模块   
env \# 查看环境变量   
**资源**   
free -m \# 查看内存使用量和交换区使用量   
df -h \# 查看各分区使用情况   
du -sh \# 查看指定目录的大小   
grep MemTotal /proc/meminfo \# 查看内存总量   
grep MemFree /proc/meminfo \# 查看空闲内存量   
uptime \# 查看系统运行时间、用户数、负载   
cat /proc/loadavg \# 查看系统负载   
**磁盘和分区**   
mount | column -t \# 查看挂接的分区状态   
fdisk -l \# 查看所有分区   
swapon -s \# 查看所有交换分区   
hdparm -i /dev/hda \# 查看磁盘参数(仅适用于IDE设备)   
dmesg | grep IDE \# 查看启动时IDE设备检测状况   
**网络**   
ifconfig \# 查看所有网络接口的属性   
iptables -L \# 查看防火墙设置   
route -n \# 查看路由表   
netstat -lntp \# 查看所有监听端口   
netstat -antp \# 查看所有已经建立的连接   
netstat -s \# 查看网络统计信息   
**进程**   
ps -ef \# 查看所有进程   
top \# 实时显示进程状态   
**用户**   
w \# 查看活动用户   
id \# 查看指定用户信息   
last \# 查看用户登录日志   
cut -d: -f1 /etc/passwd \# 查看系统所有用户   
cut -d: -f1 /etc/group \# 查看系统所有组   
crontab -l \# 查看当前用户的计划任务   
**服务**   
chkconfig –list \# 列出所有系统服务   
chkconfig –list | grep on \# 列出所有启动的系统服务   
**程序**   
rpm -qa \# 查看所有安装的软件包

### 47.hashMap， hashtable，**ConcurrentHashMap 原理** ###

### **HashTable** ###

*  底层数组+链表实现，无论key还是value都**不能为null**，线程**安全**，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低，ConcurrentHashMap做了相关优化
 *  初始size为**11**，扩容：newsize = olesize\*2+1
 *  计算index的方法：index = (hash & 0x7FFFFFFF) % tab.length

### **HashMap** ###

*  底层数组+链表实现，可**以存储null键和null值**，线程**不安全**
 *  初始size为**16**，扩容：newsize = oldsize\*2，size一定为2的n次幂
 *  扩容针对整个Map，每次扩容时，原来数组中的元素依次重新计算存放位置，并重新插入
 *  插入元素后才判断该不该扩容，有可能无效扩容（插入后如果扩容，如果没有再次插入，就会产生无效扩容）
 *  当Map中元素总数超过Entry数组的75%，触发扩容操作，为了减少链表长度，元素分配更均匀
 *  计算index方法：index = hash & (tab.length – 1)
 *   
 *  HashMap的初始值还要考虑加载因子:
 *   **哈希冲突**：若干Key的哈希值按数组大小取模后，如果落在同一个数组下标上，将组成一条Entry链，对Key的查找需要遍历Entry链上的每个元素执行equals()比较。
 *  **加载因子**：为了降低哈希冲突的概率，默认当HashMap中的键值对达到数组大小的75%时，即会触发扩容。因此，如果预估容量是100，即需要设定100/0.75＝134的数组大小。
 *  ***空间换时间**：如果希望加快Key查找的时间，还可以进一步降低加载因子，加大初始大小，以降低哈希冲突的概率。*
 *  HashMap和Hashtable都是用hash算法来决定其元素的存储，因此HashMap和Hashtable的hash表包含如下属性：
 *  容量（capacity）：hash表中桶的数量
 *  初始化容量（initial capacity）：创建hash表时桶的数量，HashMap允许在构造器中指定初始化容量
 *  尺寸（size）：当前hash表中记录的数量
 *  负载因子（load factor）：负载因子等于“size/capacity”。负载因子为0，表示空的hash表，0.5表示半满的散列表，依此类推。轻负载的散列表具有冲突少、适宜插入与查询的特点（但是使用Iterator迭代元素时比较慢）

### **ConcurrentHashMap** ###

*  底层采用分段的数组+链表实现，线程**安全**
 *  通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)
 *  Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术
 *  有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁
 *  扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容

### 48.jvm调优 ###

![20180417153107680][]

控制参数

\-Xms设置堆的最小空间大小。  
堆中 年轻代和年老默认有个比如 是  NewRatio   = 2 (默认是 2:1)  
年亲代中eden和suvivor默认有个比例 8:1:1  （SurvivorRatio = 8）  jps查看进程 jmap -heap 进程编号 查看到改参数  
\-Xmx设置堆的最大空间大小。  
\-XX:NewSize设置新生代最小空间大小。  
\-XX:MaxNewSize设置新生代最大空间大小。  
\-XX:PermSize设置永久代最小空间大小。  
\-XX:MaxPermSize设置永久代最大空间大小。  
\-Xss设置每个线程的堆栈大小 （64位 默认是1M  -XX:ThreadStackSize默认是0）。  
帮助查看-X参数  （java -X）  
 ————————————————   
版权声明：本文为CSDN博主「liaomin416100569」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。

### 49.jvm垃圾回收算法 ###

1.**标记-清除算法**

等待被回收对象的“标记”过程在上文已经提到过，如果在被标记后直接对对象进行清除，会带来另一个新的问题——内存碎片化。如果下次有比较大的对象实例需要在堆上分配较大的内存空间时，可能会出现无法找到足够的连续内存而不得不再次触发垃圾回收。

2.**复制算法****（Java堆中新生代的垃圾回收算法）**

此GC算法实际上解决了标记-清除算法带来的“内存碎片化”问题。首先还是先标记处待回收内存和不用回收的内存，下一步将不用回收的内存复制到新的内存区域，这样旧的内存区域就可以全部回收，而新的内存区域则是连续的。它的缺点就是会损失掉部分系统内存，因为你总要腾出一部分内存用于复制。

在上文[《JVM][JVM][入门——运行时数据区》][JVM]提到过在Java堆中被分为了新生代和老年代，这样的划分是方便GC。Java堆中的新生代就使用了GC复制算法。在新生代中又分为了三个区域：Eden 空间、To Survivor空间、From Survivor空间。不妨将注意力回到这张图的左边新生代部分：

![format_png 4][]

新的对象实例被创建的时候通常在Eden空间，发生在Eden空间上的GC称为Minor GC，**当在新生代发生一次GC后****，****会将Eden****和其中一个Survivor空间的内存复制到另外一个Survivor中**，如果反复几次有对象一直存活，此时内存对象将会被移至老年代。可以看到新生代中Eden占了大部分，而两个Survivor实际上占了很小一部分。这是因为大部分的对象被创建过后很快就会被GC（这里也许运用了是二八原则）。

3.**标记****-****压缩算法****（或称为标记-整理算法，Java堆中老年代的垃圾回收算法）**

对于新生代，大部分对象都不会存活，所以在新生代中使用复制算法较为高效，而对于老年代来讲，大部分对象可能会继续存活下去，如果此时还是利用复制算法，效率则会降低。**标记-压缩算法首先还是“标记”，标记过后，将不用回收的内存对象压缩到内存一端，此时即可直接清除边界处的内存**，这样就能避免复制算法带来的效率问题，同时也能避免内存碎片化的问题。老年代的垃圾回收称为“Major GC”。

不积跬步，无以至千里；不积小流，无以成江海。

### 50.ziplist和skipList的数据结构 ###

![format_png 5][]

*  zlbytes: ziplist的长度（单位: 字节)，是一个32位无符号整数
 *  zltail: ziplist最后一个节点的偏移量，反向遍历ziplist或者pop尾部节点的时候有用。
 *  zllen: ziplist的节点（entry）个数
 *  entry: 节点
 *  zlend: 值为0xFF，用于标记ziplist的结尾

普通数组的遍历是根据数组里存储的数据类型 找到下一个元素的，例如int类型的数组访问下一个元素时每次只需要移动一个sizeof(int)就行（实际上开发者只需让指针p+1就行，在这里引入sizeof(int)只是为了说明区别）。  
上文说了，ziplist的每个节点的长度是可以不一样的，而我们面对不同长度的节点又不可能直接sizeof(entry)，那么它是怎么访问下一个节点呢？  
**ziplist将一些必要的偏移量信息记录在了每一个节点里，使之能跳到上一个节点或下一个节点。**  
接下来我们看看节点的布局

节点的布局(entry)

每个节点由三部分组成：prevlength、encoding、data

*  prevlengh: 记录上一个节点的长度，为了方便反向遍历ziplist
 *  encoding: 当前节点的编码规则，下文会详细说
 *  data: 当前节点的值，可以是数字或字符串

为了节省内存，**根据上一个节点的长度prevlength 可以将ziplist节点分为两类：**

![format_png 6][]

*  entry的前8位小于254，则这8位就表示上一个节点的长度
 *  entry的前8位等于254，则意味着上一个节点的长度无法用8位表示，后面32位才是真实的prevlength。**用254 不用255(11111111)作为分界是因为255是zlend的值，它用于判断ziplist是否到达尾部。**

**根据当前节点存储的数据类型及长度，可以将ziplist节点分为9类**：  
其中整数节点分为6类：

[https://www.jianshu.com/p/afaf78aaf615][https_www.jianshu.com_p_afaf78aaf615]

skiplist特性

跳表具有如下性质：

(1) 由很多层结构组成

(2) 每一层都是一个有序的链表

(3) 最底层(Level 1)的链表包含所有元素

(4) 如果一个元素出现在 Level i 的链表中，则它在 Level i 之下的链表也都会出现。

(5) 每个节点包含两个指针，一个指向同一链表中的下一个元素，一个指向下面一层的元素。

[https://www.cnblogs.com/a8457013/p/8251967.html][https_www.cnblogs.com_a8457013_p_8251967.html]

### 51.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来执行

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

Fork/Join框架的实现原理

ForkJoinPool由ForkJoinTask数组和ForkJoinWorkerThread数组组成，ForkJoinTask数组负责将存放程序提交给ForkJoinPool，而ForkJoinWorkerThread负责执行这些任务。

ForkJoinTask的Fork方法的实现原理：  
　　当我们调用ForkJoinTask的fork方法时，程序会把任务放在ForkJoinWorkerThread的pushTask的workQueue中，异步地执行这个任务，然后立即返回结果，代码如下：

[https://www.cnblogs.com/senlinyang/p/7885964.html][https_www.cnblogs.com_senlinyang_p_7885964.html]

### 52.jmap命令 ###

Jmap是一个可以输出所有内存中对象的工具，甚至可以将VM 中的heap，以二进制输出成文本。打印出某个java进程（使用pid）内存内的，所有‘对象’的情况（如：产生那些对象，及其数量）。

使用方法 jmap -histo pid。如果使用SHELL ,可采用jmap -histo pid>a.log日志将其保存到文件中，在一段时间后，使用文本对比工具，可以对比出GC回收了哪些对象。jmap -dump:format=b,file=outfile 3024可以将3024进程的内存heap输出出来到outfile文件里，再配合MAT（内存分析工具）。

64位机上使用需要使用如下方式：

jmap -J-d64 -heap pid

2、命令格式

l  jmap \[ option \] pid

l  jmap \[ option \] executable core

l  jmap \[ option \] \[server-id@\]remote-hostname-or-IP

3、参数说明

1)、options：

l  executable :产生core dump的java可执行程序;

l  core 将被打印信息的core dump文件;

l  remote-hostname-or-IP 远程debug服务的主机名或ip;

l  server-id 唯一id,假如一台主机上多个远程debug服务;

2）、基本参数：

Ø  -dump:\[live,\]format=b,file=<filename> 使用hprof二进制形式,输出jvm的heap内容到文件=. live子选项是可选的，假如指定live选项,那么只输出活的对象到文件.

$jmap–dump:live,format=b,file=aaa.bin 3772

### 53.redis的持久化 ###

rdb和aof

触发rdb快照

1 在指定的时间间隔内，执行指定次数的写操作  
2 执行save（阻塞， 只管保存快照，其他的等待） 或者是bgsave （异步）命令  
3 执行flushall 命令，清空数据库所有数据，意义不大。  
4 执行shutdown 命令，保证服务器正常关闭且不丢失任何数据，意义...也不大。

通过RDB文件恢复数据

将dump.rdb 文件拷贝到redis的安装目录的bin目录下，重启redis服务即可。在实际开发中，一般会考虑到物理机硬盘损坏情况，选择备份dump.rdb 。可以从下面的操作演示中可以体会到。

rdb的优缺点

优点：  
1 适合大规模的数据恢复。  
2 如果业务对数据完整性和一致性要求不高，RDB是很好的选择。

缺点：  
1 数据的完整性和一致性不高，因为RDB可能在最后一次备份时宕机了。  
2 备份时占用内存，因为Redis 在备份时会独立创建一个子进程，将数据写入到一个临时文件（此时内存中的数据是原来的两倍哦），最后再将临时文件替换之前的备份文件。  
所以Redis 的持久化和数据的恢复要选择在夜深人静的时候执行是比较合理的。

AOF

AOF ：Redis 默认不开启。它的出现是为了弥补RDB的不足（数据的不一致性），所以它采用日志的形式来记录每个**写操作**，并**追加**到文件中。Redis 重启的会根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。

从配置文件了解aof

打开 redis.conf 文件，找到 APPEND ONLY MODE 对应内容  
1 redis 默认关闭，开启需要手动把no改为yes

aof的优缺点

优点：数据的完整性和一致性更高  
缺点：因为AOF记录的内容多，文件会越来越大，数据恢复也会越来越慢。

### 54.dubbo协议和hession2等dubbo中协议的区别 ###

1、dubbo协议

Dubbo缺省协议采用单一长连接和NIO异步通讯，适合于小数据量大并发的服务调用，以及服务消费者机器数远大于服务提供者机器数的情况。