阿里高级面试题 2019

阿里内推Java一面题目

数据库

1. 使用mysql索引都有哪些原则？？索引什么数据结构？？B+tree 和 B tree 什么区别？？

一、 对于查询频率高的字段建立索引；
二、 对排序、分组、联合查询频率高的字段建立索引；
三、 索引的数目不宜太多
      缘由：a、每建立一个索引都会占用相应的物理控件；
　　          b、过多的索引会致使insert、update、delete语句的执行效率下降；
四、若在实际中，须要将多个列设置索引时，能够采用多列索引
      如：某个表(假设表名为Student)，存在多个字段(StudentNo, StudentName, Sex, Address, Phone, BirthDate)，其中须要对StudentNo,StudentName字段进行查询，对Sex字段进行分组，对BirthDate字段进行排序，此时能够建立多列索引
      index index_name (StudentNo, StudentName, Sex, BirthDate);      #index_name为索引名
      在上面的语句中只建立了一个索引，可是对4个字段都赋予了索引的功能。
       建立多列索引，须要遵循BTree类型，
       即第一列使用时，才启用索引。
       在上面的建立语句中，只有mysql语句在使用到StudentNo字段时，索引才会被启用。
       如:     select * from Student where StudentNo = 1000;      #使用到了StudentNo字段，索引被启用。
       能够使用explain检测索引是否被启用
        如:explain select * from Student where StudentNo = 1000;
五、选择惟一性索引
        惟一性索引的值是惟一的，能够更快速的经过该索引来肯定某条记录。例如，学生表中学号是具备惟一性的字段。为该字段创建惟一性索引能够很快的肯定某个学生的信息。若是使用姓名的话，可能存在同名现象，从而下降查询速度。
六、尽可能使用数据量少的索引
       若是索引的值很长，那么查询的速度会受到影响。例如，对一个CHAR(100)类型的字段进行全文检索须要的时间确定要比对CHAR(10)类型的字段须要的时间要多。
七、尽可能使用前缀来索引
     若是索引字段的值很长，最好使用值的前缀来索引。例如，TEXT和BLOG类型的字段，进行全文检索会很浪费时间。若是只检索字段的前面的若干个字符，这样能够提升检索速度。
八、删除再也不使用或者不多使用的索引.
     表中的数据被大量更新，或者数据的使用方式被改变后，原有的一些索引可能再也不须要。数据库管理员应当按期找出这些索引，将它们删除，从而减小索引对更新操做的影响

B+ tree树索引, B tree, 散列

2.Mysql有哪些存储引擎？？都有啥区别？？要详细？？

InnoDB: 事务型存储引擎,  而且有较高的并发读取频率
MEMORY： 存储引擎，存放在内存中，数据量小， 速度快
Merge: 
ARCHIVE： 归档， 有很好的压缩机制

3.设计高并发系统数据库层面该如何设计？？ 数据库锁有哪些类型？？如何实现？？

1.	分库分表： 一样量的数据平均存储在不一样数据库相同表（或不一样表）中，减轻单表压力，若是仍是很大，就能够每一个库在分多张表，根据hash取值或者其余逻辑判断将数据存储在哪张表中
2.	读写分离： 数据库本来就有主从数据库之分，查询在从服务器，增删改在主服务器， 
3.	归档和操做表区分： 建一张归档表，将历史数据放入，须要操做的表数据单独存储
4.	索引啊之类的建立，对于数据量很大，百万级别以上的单表，若是增删改操做不频繁的话， 能够建立bitMap索引，速度要快得多

1.	共享锁：要等第一我的操做完，释放锁，才能操做
2.	更新锁：解决死锁，别人能够读，但不能操做
3.	排他锁：读写都被禁用
4.	意向锁（xlock）： 对表中部分数据加锁，查询时，能够跳过
5.	计划锁： 操做时，别的表链接不了这张表，

4.数据库事务有哪些？？

1.	原子性： 全部操做要么所有成功，要么所有失败
2.	一致性： 例如转帐，一个事务执行前和执行后必须一致
3.	隔离性： 防止脏读， 重复读问题
4.	持久性： 永久性提交数据库

5. Oracle经常使用函数有哪些？？

Concat: 字符串拼接， 或者 ||
Instr: 指定字符串位置
Length: 长度
Trim: 去空格
Lower: 小写
Upper:大写
Nvl: 判断空
Replace: 替换
Substr: 截取
Floor: 向下取整
To_number:
To_char:
To_date:
Decode: 判断函数等等

6. Sql中哪些状况可能不会走索引？？

1.	查询谓词没有使用索引的主要边界,换句话说就是select *，可能会致使不走索引
2.	单键值的b树索引列上存在null值，致使COUNT(*)不能走索引。索引列存在空值
3.	索引列上有函数运算，致使不走索引
4.	隐式类型转换致使不走索引。
5.	表的数据库小或者须要选择大部分数据，不走索引
6.	！=或者<>(不等于），可能致使不走索引 
7.	表字段的属性致使不走索引，字符型的索引列会致使优化器认为须要扫描索引大部分数据且聚簇因子很大，最终致使弃用索引扫描而改用全表扫描方式，
8.	使用like, in 等， 可能致使不走索引

分库分表

1.如何设计能够动态扩容缩容的分库分表方案？？ 2.用过哪些分库表中间件， 有啥优缺点？？讲一下你了解的分库分表中间件的底层实现原理？？ 3.我如今有一个未分库分表的系统，之后系统需分库分表，如何设计，让未分库分表的系统动态切换到分库分表的系统上？？ 4.分布式事务知道么？ 大家怎么解决的？？ TCC ?? 那若吃醋先网络缘由，网络连不通怎么办？？ 5.为何要分库分表？？ 6.分布式寻址方式都有哪些算法？？ 知道一致性hash吗？？手写一下java实现代码？？你若userId取摸分片，那我要查一段连续时间里的数据怎么办？ 7.如何解决分库分表主键问题？？有什么实现方案？

分布式缓存

1.Redis和memcheched 什么区别？？为何单线程的redis比多线程的memched效率要高？？ 2.Redis有什么数据类型？？都在哪些场景下使用？？ 3.redis主从复制是怎么实现的？？Redis的集群模式是如何实现的？？redis的key是如何寻址的？？ 4.使用redis如何设计分布式锁， 使用zk能够么？？如何实现？？这两种那个效率更高？？ 5.知道redis的持久化么？？ 都有什么优缺点？？具体底层实现呢？？ 6.Redis过时策略都有哪些？？LRU??写一下java版本的代码？？

分布式服务框架

1.说一下dubbo的实现过程？？注册中心挂了能够继续通讯么？？ 2.Zk原理知道吗？Zk均可以干什么？？Paxos算法知道吗？？说一下原理和实现？？ 3.Dubbo支持哪些序列号协议？？Hessian？？说一下hession的数据结构？？PB知道吗？？为啥PB效率是最高的？？ 4.知道netty么？？Netty能够干吗啊？？NIO, BIO, AIO都是什么啊？有什么区别么？ 5.Dubbo复制均衡策略和高可用策略都有哪些？？动态代理策略呢？？ 6.为何要进行系统拆分啊？？拆分不用dubbo能够吗？？Dubbo和thrift什么区别？？ 7.Mq相关？

java基础相关

1. Hashcode相等，两个类相等么？？equals 呢？？ 相反呢？？

不必定相等，都不必定至关。 反过来（equals相同，hashcode相同，则类相同）可能成立
Equals用来判断两个对象的值是否相等， 
==用来判断两个对象的引用地址和值是否相等

2.介绍一下集合框架？？

分两种： 
Collection: 包含独立元素， 能够重复，无序的， 继承了iterable接口，有一个iterator方法返回迭代器对象， 相关接口有list, queue， set
Map: 包含键值对的元素，key不重复，value容许重复， 实现接口TreeMap, HashMap, LinkedhashMap, concurrentHashMap, hasTable

3.Hashmap ， hashtable底层实现什么区别？？Hashtable 和concurrenthashMap呢？？

hashmap非线程安全的，key和value能够接收nul值
Hashtable线程安全的，不能接受null
单线程下，hashmap比hashtable快得多
concurrentHashMap融合了hashtable和hashmap的优势，写能够多线程写，而且是线程安全的，读线程不受限制

4.Hashmap 和treemap 什么区别？？底层数据结构是什么？？

Hashmap: 数组方式存储， 线程非安全，可存储null, 无序
Treemap: 基于二叉树实现方式， 线程非安全，不容许null, 存入元素需实现comparable接口， 自定义排序规则。

5.线程池用过么？？都有什么参数？？底层如何实现的？？

核心池大小
线程池最大线程数
保持多久时间会终止
阻塞队列，存储等待执行的任务
；
Java经过Executors能够提供四种线程池

6.Sychnized和lock什么区别？？Sychnize 什么状况，状况下是对象锁？？何时是全局锁？？为何？？

1.synchnized 是关键字，在方法出错以后由java虚拟机自动解除锁定，而 Lock属于Api级别的锁，它须要本身在 finally方法后面保证锁的释放。
2.synchnized 不能实现公平锁，而 Lock能够，Lock还能够添加多个监听条件来对锁进行控制，能够中断。
3.synchronized 做用在普通方法上属于对象锁，做用在静态方法，类.class 上面，属于全局锁。对象锁只对同一个对象加锁，做用对象是同一个对象。而类锁是对类加锁，对整个类都有效。 
若是锁住的是通常方法就是对象锁，对象锁只会对同一个对象起做用，若是是锁住了static 方法则是全局锁，会对全局对象都管用，若是想在普通方法中使用全局锁须要锁住class对象。

7.ThreadLocal 是什么？？ 底层如何实现？？写一个例子呗？？

ThreadLocal 底层是存储在 线程本地Map里面的一个对象，它跟当前线程绑定，以 ThreadLocal 对象自己为 key，以ThreadLocal里面存的值为值，目的是为了实现线程之间的数据的隔离。
public static final ThreadLocal session = new ThreadLocal();   
   public static Session getCurrentSession() {   
       Session s = (Session)session.get();   
       if(s == null){   
           s = sessionFactory.openSession();   
           session.set(s);   
       }   
       return s;   
   }

8.Volitile的工做原理？？

实例化一个对象其实能够分为三个步骤：
　　（1）分配内存空间。
　　（2）初始化对象。
　　（3）将内存空间的地址赋值给对应的引用。
多线程状况下，Volitile修饰的变量会被加一个lock指令，这个指令作两件事情，
1.在变量改变以后，会马上从cpu高速缓存写到内存
2.会通知其余cpu缓存中的该变量的值设置成无效，用到该变量时会到内存中从新读取该变量的值。

Lock指令保证了缓存一致性原理

9.Cas知道么？？如何实现的？？

CAS（Compare and Swap）即比较并替换，实现并发算法时经常使用到的一种技术,
三个参数，比较是否相等，当内存值和预期值相等时，才会将第三个值更新，并返回true

10.请用至少四种写法， 写一个单例模式呗？？

1. 实例静态类
2. volitile修饰，sychnized修饰
3. 枚举使用（推荐）

JVM

1.请介绍一下jvm内存模型？？ 用过什么垃圾回收器？？ 都说说吧？？ 2.线上发送频繁full gc如何处理？？ cpu使用率太高怎么办？？ 如何定位问题？？如何解决？？说一下解决思路和处理方法？？ 3.知道字节码么？字节码都有哪些？Integer x =5 , int y = 5 , 比较x == y 都须要通过哪些步骤？？ 4.讲讲类加载机制呗？？都有哪些类加载器？？这写类加载器都加载哪些文件？？手写一下类加载demo?? 5.知道osgi么？？他是如何实现的？？ 6.请问你作过哪些JVM优化？？使用什么方法？？达到什么效果？？ 7.Class.forName(“java.lang.String”)和String.class.getClassLoader().loadClass(“java.lang.String”)有什么区别么？？

Spring

1.spring都有哪些机制？？AOP底层如何实现的？？IOC呢？？ 2.Cglib知道么？？他和jdk动态代理什么区别？？手写一个jdk动态代理吧？？

分布式消息队列

1.为何是用消息队列？？消息队列有什么优势和缺点？？ 2.如何保证消息队列的高可用性？？如何保证消息不被重复消费？？ 3.Kafka， activemq , rabbitmq, rocketmq 都有什么优缺点？？ 4.若是让你写一个消息队列， 该如何进行架构设计？？说一下你的思路

分布式搜索引擎

1.Es的工做过程实现是如何的？？ 如何实现分布式的？？ 2.Es在数据量很大的状况下（数十亿级别）如何提升查询效率？？ 3.Es的查询是一个怎么的工做过程？？底层lucence介绍一下？？倒排索引知道么？？Es和mongdb什么区别啊？？都在什么场景下使用啊？？

高并发高可用架构设计

1.如何设计一个高并发高可用系统？？ 2.如何限流？？工程中怎么作的？？说一下具体实现？？ 3.缓存如何使用的？？缓存使用不当会形成什么后果？？ 4.如何熔断啊？？熔断框架都有哪些？？具体实现原理知道吗？？ 5.如何降级？？如何进行系统拆分？？如何数据库拆分？？

通讯协议

1.说一下TCP/IP四层？？ 2.http的工做流程？？http1.0, http1.1 , http2.0 具体哪些区别？？ 3.Tcp三次握手， 四层分手的工做流程??画一下流程图？？为何不是四次五次或者二次啊？？ 4.画一下https的工做原理？？具体如何实现的，如何防止被抓包啊？？

算法

1.比较简单， 我一个文件， 有45亿个阿拉伯数字， 如何进行去重啊？？如何找出最大的那个数啊？？

数据结构

1.二叉树和红黑数等？？

---

java集合相关

请简要描述一下J2EE应用中的class loader的层次结构？ java1.7 和1.8中，hashmap的区别 mybatis一级缓存，二级缓存，缓存策略 osi七层网络模型，五层网络模型，每次层分别有哪些协议 死锁产生的条件， 以及如何避免死锁，银行家算法，产生死锁后如何解决 如何判断链表有环 虚拟机类加载机制，双亲委派模型，以及为何要实现双亲委派模型 虚拟机调优参数 拆箱装箱的原理 JVM垃圾回收算法 CMS G1 hashset和hashmap的区别，haspmap的底层实现put操做，扩容机制，currenthashmap如何解决线程安全,1.7版本以及1.8版本的不一样md5加密的原理 有多少种方法可让线程阻塞，能说多少说多少 synchronized和reetrantlock锁 AQS同步器框架，countdowmlatch，cyclebarrier，semaphore，读写锁

阿里内推Java二面题目

B-Tree索引，myisam和innodb中索引的区别 BIO和NIO的应用场景 讲讲threadlocal 数据库隔离级别，每层级别分别用什么方法实现，三级封锁协议,共享锁排它锁，mvcc多版本并发控制协议，间隙锁 数据库索引？B+树？为何要建索引？什么样的字段须要建索引，建索引的时候通常考虑什么？索引会不会使插入、删除做效率变低，怎么解决？ 数据库表怎么设计的？数据库范式？设计的过程当中须要注意什么？ 共享锁与非共享锁、一个事务锁住了一条数据，另外一个事务能查吗？ Spring bean的生命周期？默认建立的模式是什么？不想单例怎么办？

阿里内推Java三面题目

高并发时怎么限流 线程池的拒接任务策略 springboot的启动流程 集群、负载均衡、分布式、数据一致性的区别与关系 数据库若是让你来垂直和水平拆分，谁先拆分，拆分的原则有哪些(单表数据量多大拆) 最后谈谈Redis、Kafka、 Dubbo，各自的设计原理和应用场景

---

6，唤醒一个阻塞的线程 如由于Sleep，wait，join等阻塞，能够使用interrupted exception异常唤醒。

8，redis使用单线程模型，数据顺序提交，redis支持主从模式，mencache只支持一致性hash作分布式；redis支持数据落地，rdb定时快照和aof实时记录操做命令的日志备份，memcache不支持；redis数据类型丰富，有string，hash，set，list， sort set，而memcache只支持简单数据类型；memcache使用cas乐观锁作一致性。

9，Class.forName()将类加载到JVM，还会对类解释，执行static块，而ClassLoader也加载到JVM，可是不会执行static块，而且只有调用了new Instance方法才会调用构造函数。

10，java反射机制。 能够在运行时判断一个对象所属的类，构造一个类的对象，判断类具备的成员变量和方法，调用1个对象的方法。4个关键的类：Class，Constructor，Field，Method。 getConstructor得到构造函数/getDeclardConstructor； getField/getFields/getDeclardFields得到类所生命的全部字段；getMethod/getMethods/getDeclardMethod得到类声明的全部方法，正常方法是一个类建立对象，而反射是1个对象找到1个类。

11，Object类中的方法：clone()，可是使用该方法必须实现Java.lang.Cloneable接口，equal()方法判断引用是否一致，指向同一对象，即相等于==，只有覆写了equals()方法以后，才能够说不一样。hashcode()，对象的地址， toString()， finalize()。

12，序列化和反序列化 序列化和反序列化即对象和字节序列间的转化，进程间传送文本图片音频等以二进制传送。JDK中ObjectOuputStream和ObjectInputStream为输出输入流，只有实现SeriaLizable/Externalizable接口的类才能被序列化。如Person对象传递给内存流使用DataConstractJsonSeralizer， MemoryStream stream = new MemoryStream(); DataConstractJsonSeralizer SER = new DataConstractJsonSeralizer(typeof(person)); ser.writeObjectStream(stream, person);显示json输出，StramReader sr = new StreamReader(stream1); sr.ReadToEnd()。

13，讲讲分布式惟一ID。 肯定ID存储用64位，1个64位二进制1是这样的00000000.....1100......0101，切割64位，某段二进制表示成1个约束条件，前41位为毫秒时间，后紧接9位为IP，IP以后为自增的二进制，记录当前面位数相同状况下是第几个id，如如今有10台机器，这个id生成器生成id极限是同台机器1ms内生成2的14次方个ID。

分布式惟一ID = 时间戳 << 41位， int类型服务器编号 << 10，序列自增sequence。每一个时间戳内只能生成固定数量如（10万）个自增号，达到最大值则同步等待下个时间戳，自增从0开始。将毫秒数放在最高位，保证生成的ID是趋势递增的，每一个业务线、每一个机房、每一个机器生成的ID都是不一样的。如39bit毫秒数|4bit业务线|2bit机房|预留|7bit序列号。高位取2016年1月1日1到如今的毫秒数，系统运行10年，至少须要10年x365天x24小时x3600秒x1000毫秒=320x10~9，差很少39bit给毫秒数，每秒单机高峰并发小于100，差很少7bit给每毫秒的自增号，5年内机房小于100台机器，预留2bit给机房，每一个机房小于100台机器，预留7bit给每一个机房，业务线小于10个，预留4bit给业务线标识。

64bit分布式ID（42bit毫秒+5bit机器ID+12位自增）等

生成分布式ID的方式：A，2个自增表，步长相互隔开 B，时间的毫秒或者纳秒 C，UUID D，64位约束条件（如上）

14，NIO和IO的区别

第一点，NIO少了1次从内核空间到用户空间的拷贝。

ByteBuffer.allocateDirect()分配的内存使用的是本机内存而不是Java堆上的内存，和网络或者磁盘交互都在操做系统的内核空间中发生。allocateDirect()的区别在于这块内存不禁java堆管理, 但仍然在同一用户进程内。

第二点，NIO以块处理数据，IO以流处理数据

第三点，非阻塞，NIO1个线程能够管理多个输入输出通道

15，内存泄漏

未对做废数据内存单元置为null，尽早释放无用对象的引用，使用临时变量时，让引用变量在推出活动域后自动设置为null，暗示垃圾收集器收集；程序避免用String拼接，用StringBuffer，由于每一个String会占用内存一块区域；尽可能少用静态变量（全局不会回收）；不要集中建立对象尤为大对象，能够使用流操做；尽可能使用对象池，再也不循环中建立对象，优化配置；建立对象到单例getInstance中，对象没法回收被单例引用；服务器session时间设置过长也会引发内存泄漏。

16，对象克隆和实现方式

克隆的对象可能包含一些已经修改过的属性，而new1个对象属性都仍是初始化时候的值，被复制克隆的类要实现Clonable接口，覆盖clone()方法，访问修饰符为public，方法中调用super.clone()获得所须要的复制方法，类中的属性类也须要实现Clonable接口，覆写clone()方法，并在super中也调用子属性类的clone()复制，才能够实现深拷贝。

或者写到流中序列化的方式来实现，没必要考虑引用类型中还包含引用类型，直接用序列化来实现对象的深复制拷贝，即将对象写到流，再从流中读出来，须要实现seriazation接口。

17，redis内存数据上升到必定大小会执行数据淘汰策略，redis提供了6种数据淘汰策略。

LRU：从已设置过时时间的数据集合中挑选最近最少使用的数据淘汰

random：从已设置过时时间的数据中挑选任意数据淘汰

ttl：从已设置过时时间的数据集合中挑选将要过时的数据淘汰。

notenvision：禁止驱逐数据

如mysql中有2千万数据，redis只存储20万的热门数据。LRU或者TTL都知足热点数据读取较多，不太可能超时特色。

redis特色：速度块，O(1)，丰富的数据类型，支持事物原子性，可用于缓存，比memecache速度块，能够持久化数据。

常见问题和解决：Master最好不作持久化如RDB快照和AOF日志文件；若是数据比较重要，某分slave开启AOF备份数据，策略为每秒1次，为了主从复制速度及稳定，MS主从在同一局域网内；主从复制不要用图状结构，用单向链表更为稳定 M-S-S-S-S。。。。；redis过时采用懒汉+按期，懒汉即get/set时候检查key是否过时，过时则删除key，按期遍历每一个DB，检查制定个数个key；结合服务器性能调节并发状况。

过时淘汰，数据写入redis会附带1个有效时间，这个有效时间内该数据被认为是正确的并不关心真实状况，例如对支付等业务采用版本号实现，redis中每一份数据都维持1个版本号，DB中也维持1份，只有当redis的与DB中的版本一致时，才会认为redis为有效的，不过仍然每次都要访问DB，只须要查询version版本字段便可。

18，异步化，生产接口每秒钟10万并发，消费者用异步慢慢消费。缓存模式空间换时间，把1两亿的数据名单打到缓存。服务降级，把不重要的任务放弃；静态资源离线包下载机制，在wify下会主动提早把静态下载前端层保护可请将用户请求延长，点击后主动给它随机等待2s的时间/2分钟以内不能请求；后端作部分接口的开关，设置超短耗时时间，原来只用5ms的只给20ms。

系统一段时间内会自动重试，重试屡次后就认为是失败了，检查支付接口返回该订单的钱，支付操做若是回复错误则回滚扣库存的事务，没返回则会记录进行中pendding状态，结束整个过程，等通知失败/成功，AB系统之间会出现死循环补偿，如B退单不成功，通常就是记录错误日志了。超时每隔一段时间去定时回调服务定时回滚，必定次数仍是超时则提示用户联系客服，订单库存能够不会滚，记录状态，若是一直调用支付不成功，则让用户本身去处理联系客服，能够不回滚用户的数据，金额扣了才算真正完成，是一种简单粗暴的作法。

公共配置抽象成存储到zookeeper配置中心或者redis等，DB也存储一份，各应用监听ZK的配置变化，能够建一个配置web管理页面。

19，dubbo用ProxyFactoty代理工厂将HelloServiceImpl封装成1个Inoke执行，即ProxyFactory.getInvoke(ref, (Class)接口，注册URL，解码参数)，并将Invoke导出成1个Exporter，包括去注册中心ZK注册服务。Invoke有本地执行的Invoke，远程通讯执行的Invoke。

20，每次扣减库存时加上1个请求流水编号，上层请求扣减库存没拿到结果的话，从新查询1次作重试操做，量不大都是加锁处理。减小锁的时间，牺牲幂等性，扣减为DB下地操做，查询扣减和设置合成1步，中间没有网络请求。利用缓存，经过写log记录操做，异步合并日志及更新，重启时cache失效，读log恢复，避免重复提交，写操做不建议重试快速失败。多个商品同时增减库存，可以使用订单号作幂等处理，应用层对单个商品减库存，操做排队，商品消息ID路由在1个应用server处理，读本地缓存，失效再redis，DB采用乐观锁，组提交，1次减库存多个订单的购买量。可将同一个key下库存m分为n组k1......kn，每组数为m/n，扣减依次在各组扣减，减小并发冲突。队列装满后关闭队列进入，而后用户轮训本身是否抢到了异步ajax，用户资源队列固定长度。2个队列，1个销售的资源队列放入redis，有另外1个队列用来装抢购的会员的uid。

红包状态正常，并成功将状态改成“已领取”，且消息发送成功，用户端开始消费该消息，若是消费失败/超时，用MQ作重试作幂等，直到成功，每条消息有惟一编号且保证消息处理成功与去重表的日志同时出现。

热点将hot data拆分，分在不一样库和不一样表，分散热点Data，减轻DB并发更新热点带来RT升高和应用链接超时。SQL在mysql层加以限制，SQL超时/thradrunning到1定值则拒绝SQL执行，必定时间异步将结果写入DB，nginx对IP作限制，可能误杀。

21，SpringAOP，XML配置aop:config，切面aop:aspect切点aop:pointcut，链接切点和通知方法aop:before和aop:after等，注解能够直接使用@before执行方法@after ，@before(“pointcut()”) ，@after("pointcut")， @Aroud("excutete())，@AfteReturning，@AfterThrowing，可做日志事务，权限等待，AOP即经过把具体的类建立对应的 代理类，从代理类来对具体进行操做。

目标实现了接口，默认采用JDK实现AOP，也能够强制使用CGlib来实现AOP，目标没有实现接口的话，则必须采用CGlib，Spring自动在JDK和CGlib切换。若是要求spring强制使用CGlib实现AOP，则能够配置，添加Cglib库。。。jar， Spring配置文件中加入<aop:aspecj-autoproxy proxy-target-Class=true>

22，MyISM采用表级锁，对Myism表读不会阻塞读，会阻塞同表写，对Myism写则会阻塞读和写，即一个线程得到1个表的写锁后，只有持有锁的线程能够对表更新操做，其余线程的读和写都会等待。

InnoDB，采用行级锁，支持事务，例如只对a列加索引，若是update ...where a=1 and b=2其实也会锁整个表， select 使用共享锁，update insert delete采用排它锁，commit会把锁取消，固然select by id for update也能够制定排它锁。

23，实时队列采用双队列模式，生产者将行为记录写入Queue1，worker服务从Queue1消费新鲜数据，若是异常则写入Queue2（主要保存异常数据），RetryWorker会监听Queue2，消费异常数据，若是还未处理成功按照必定的策略等待或者将异常数据再写入Queue2，若是数据发生积压能够调整worker的消费游标，从最新数据从新开始消费，保证了最新data获得处理，中间未处理的一段则能够启动backupWorker指定起止游标在消费完指定区间的数据后，backupWorker会自动中止。

DB降级开关后，可直接写入redis（storm），同时将数据写入一份到Retry队列，在开启DB降级开关后消费Retry队列中的数据，从而把数据写入到mysql中，达到最终一致性。MYSQL切分为分片为2的N次方，例如原来分为两个库d0和d1均放在s0服务器上，s0同时有备机s1，扩容只要几步骤：确保s0到s1服务器同步顺利，没有明显延迟；s0暂时关闭读写权限；确保s1已经彻底同步到s0更新；s1开放读写权限；d1的dns由s0切换到s1；s0开放读写权限。

24，DB的特性和隔离级别

4大特性：原子性，一致性，分离性，持久性

隔离级别：

读提交：写事务禁止读

读未提交：写事务容许读

可重复读：写事务禁止读事务，读禁止写

序列化：所有禁止

详细说明：读提交1个事务开始写则所有禁止其余事务访问该行。读未提交1个事务开始写则不容许其余事务同时写，但能够读。可重复读 读事务会禁止写事务，写事物则禁止其余任何事务。序列化性能最低，所有禁止，串行执行。 MYSQL默认的是可重复读。

25，帖子服务、元数据服务、帖子搜索服务，提供索引数据存储，tid和uid查询直接从帖子服务从元数据返回，其余检索查询有帖子搜索服务从索引数据检索并返回，帖子服务增删改查用MQ同步到帖子搜索服务，搜索服务修改索引的数据（索引树，倒排表），索引表t_mapping（tid，uid）。

300亿数据在全量索引库中，数百万一天内修改过的数据在一天库中，50万小时内修改过的数据在小时库中，在update请求时，只会操做最低级别的索引例如小时库。小时库，1小时合并一次，合并到天库，天库一天合并1次，合并到全量库中。

26，讲一下NIO和网络传输

NIO Reactor反应器模式，例如汽车是乘客访问的实体reactor，乘客上车后到售票员处Acceptor登记，以后乘客即可休息睡觉了，到达乘客目的地后，售票员Aceptor将其唤醒便可。持久TCP长连接每一个client和server之间有存在一个持久链接，当CCU（用户并发数量）上升，阻塞server没法为每一个链接运行1个线程，本身开发1个二进制协议，将message压缩至3-6倍，传输双向且消息频率高，假设server连接了2000个client，每一个client平均每分钟传输1-10个message，1个messaged的大小为几百字节/几千字节，而server也要向client广播其余玩家的当前信息，须要高速处理消息的能力。Buffer，网络字节存放传输的地方，从channel中读写，从buffer做为中间存储格式，channel是网络链接与buffer间数据通道，像以前的socket的stream。

27，缓存击透

预加载；

加载DB时同步，其余则等待；

DB端作SQL合并，Queue合并排队处理；

部分缓存设置为永不过时；

先清除缓存，读取数据时候则等待500ms，500ms缓存应该已经加载完成；

采用双key缓存，A1为原始缓存，A2为拷贝缓存；

若是DB为空null则g给redis设置1个NFC空nei容。

28，Dubbo源码使用了哪些设计模式

A，工厂模式，ExtenstionLoader.getExtenstionLoader(Protocol.class).getAdaptiveExtenstion()

B，装饰器模式+责任链，以provider的调用链为例，具体调用链代码是在protocolFilterWrapper的buildInvokeChain完成的,将注解中含有group=provider的Filter实现，调用顺序为EchoFilter -> ClassLoaderFilter -> GenericFilter -> ContextFilter -> ExceptionFilter -> TimeoutFilter -> MonitorFilter -> TraceFilter。装饰器模式和责任链混合使用，Echo是回声测试请求，ClassLoaderFilter则只是在其主功能上添加了功能。

C，观察者模式，provider启动时须要与注册中心交互，先注册本身的服务，再订阅本身的服务，订阅时采用了观察者模式，注册中心每5s定时检查是否有服务更新，有更新则向服务提供者发送1个notify消息后便可运行NotifyListener的notity方法，执行监听器方法。

D，动态代理模式。 扩展JDK的ExtensionLoaderdeAdaptive实现，根据调用阶段动态参数决定调用哪一个类，生成代理类的代码是ExtensionLoader的createAdaptiveExtenstionClassLoader方法。

29，平衡二叉树，左右高度之差不超过1，Add/delete可能形成高度>1，此时要旋转，维持平衡状态，避免二叉树退化为链表，让Add/Delete时间复杂度但控制在O(log2N)，旋转算法2个方法，1是求树的高度，2是求2个高度最大值，1个空树高度为-1，只有1个根节点的树的高度为0，之后每一层+1，平衡树任意节点最多有2个儿子，所以高度不平衡时，此节点的2棵子树高度差为2。例如单旋转，双旋转，插入等。

红黑树放弃彻底平衡，追求大体平衡，保证每次插入最多要3次旋转就能平衡。

30，多线程同步锁

A，RentrantLock，可重入的互斥锁，可中断可限时，公平锁，必须在finally释放锁，而synchronize由JVM释放。可重入可是要重复退出，普通的lock()不能响应中断，lock.lockInterruptbly()可响应中断，能够限时tryLock()，超时返回false，不会永久等待构成死锁。

B，Confition条件变量，signal唤醒其中1个在等待的线程，signalall唤醒全部在等待的线程await()等待并释放锁，与lock结合使用。

C，semaphore信号量，多个线程比（额度=10）进入临界区，其余则阻塞在临界区外。

D，ReadWriteLock，读读不互斥，读写互斥，写写互斥。

E，CountDownLantch倒数计时器，countdown()和await()

F，CyCliBarrier

G，LockSupport，方法park和unpark

31，栈溢出的缘由

是否递归的调用；大量循环；全局变量是否过多；数组，List，Map数据是否过大；用DDMS工具检查地方。

内存溢出的缘由

过多使用了static；static最好只用int和string等基本类型；大量的递归或者死循环；大数据项的查询，如返回表的全部记录，应该采用分页查询。检查是否有数组、List、map中存放的是对象的引用而不是对象，这些引用会让对应对象不能被释放。

栈过大会致使内存占用过多，频繁页交换阻碍效率。

32，说一下http/2

Http/2采用二进制格式而不是文本

Http/2是彻底多路复用的，而非有序并阻塞的。

Http/2使用报头压缩

Http/2让服务器能够将响应主动推送到客户端缓存中。

33，说一下内存泄露

A，HashMap,vector等容易（静态集合类）， 和应用程序生命周期同样，所引用的全部对象Object也不能释放。

B，当集合类里面的对象属性被修改后，再调用remove()不起做用，hashcode值发生了改变

C，其对象add监听器，可是每每释放对象时忘记去删除这些监听器

D，各类链接记得关闭

E，内部类的引用

F，调用其余模块，对象做用参数

G，单例模式，持有外部对象引用没法收回。

内存泄露例子

Vector<String> A = new Vector<String>();

for(int i = 0; i < 100; i++){

Object o = new Object ();

A.add(o);

o = null;

}

........

内存溢出的例子

StringBuffer b = new StringBuffer ();

for(int i =0; i < 100; i++){

for(int j =0; i < 100; j++){

b.append(*);

}

}

34，SpirngMVC的生命周期 和 SpringBean的生命周期

SpirngMVC的生命周期 ：

A，DispatcherSerlvet（前端控制器）

B，-》 HandlerMapping（处理器映射器），根据xml注解查找对应的Hander -》 返回Handler

C，-》处理器适配器去执行Handler

D，-》Handler执行完成后给处理器适配器返回ModelAndView

E，-》前端控制器请求视图解析器去执行视图解析，根据逻辑视图名解析成真正的视图JSP，向前端控制器返回view

F，-》前端控制器进行视图渲染，将模型数据放到request-》返回给用户

SpringBean的生命周期：

Instance实例化-》设置属性值-》调用BeanNameAware的setBeanName方法-》调用BeanPostProsessor的预初始化方法-》调用InitializationBean的afterPropertiesSet()的方法-》调用定制的初始化方法callCustom的init-method-》调用BeanPostProsessor的后初始化方法-》Bean能够使用了 -》 容器关闭-》 调用DisposableBean的destroy方法-》调用定制的销毁方法CallCustom的destroy-method。

35，AQS，抽象队列同步器

AQS定义2种资源共享方式：独占与share共享

独占：只能有1个线程运行

share共享：多个线程能够同p执行如samphore/countdownlanch

AQS负责获取共享state的入队和/唤醒出队等，AQS在顶层已经实现好了，AQS有几种方法：acquire()是独占模式下线程共享资源的顶层入口，如获取到资源，线程直接返回，不然进入等待队列，直到获取到资源为止。tryAcquire()将线程加入等待队列的尾部，并标志为独占。acquireQueued()使线程在等待队列中获取资源，一直到获取资源后不返回，若是过程被中断也返回true，不然false。

线程在等待过程当中被中断是不响应的，获取资源才补上中断。将线程添加到队列尾部用了CAS自旋（死循环直到成功），相似于AutomicInteger的CAS自旋volatile变量。

start->tryAcquire -> 入队 -> 找安全点 -> park等待状态 -> 当前节点成对头 -> End

36，单例模式的7种写法

懒汉2种，枚举，饿汉2种，静态内部类，双重校验锁（推荐）。

37，lucence倒排索引

三个文件：字典文件，频率文件，位置文件。词典文件不只保存有每一个关键词，还保留了指向频率文件和位置文件的指针，经过指针能够找到该关键字的频率信息和位置信息。

field的概念，用于表达信息所在位置（如标题中，文章中，url中），在建索引中，该field信息也记录在词典文件中，每一个关键词都有一个field信息(由于每一个关键字必定属于一个或多个field)。

关键字是按字符顺序排列的（lucene没有使用B树结构），所以lucene能够用二元搜索算法快速定位关键词。

假设要查询单词 “live”，lucene先对词典二元查找、找到该词，经过指向频率文件的指针读出全部文章号，而后返回结果。词典一般很是小，于是，整个过程的时间是毫秒级的。 　　

对词典文件中的关键词进行了压缩，关键词压缩为<前缀长度，后缀>，例如：当前词为“阿拉伯语”，上一个词为“阿拉伯”，那么“阿拉伯语”压缩为<3，语>。对数字的压缩，数字只保存与上一个值的差值。

38，ZooKeeper分布式高可用

ZooKeeper 运行期间，集群中至少有过半的机器保存了最新数据。集群超过半数的机器可以正常工做，集群就可以对外提供服务。

zookeeper能够选出N台机器做主机，它能够实现M:N的备份；keepalive只能选出1台机器做主机，因此keepalive只能实现M:1的备份。

一般有如下两种部署方案：双机房部署（一个稳定性更好、设备更可靠的机房，这个机房就是主要机房，而另一个机房则更加廉价一些，例如，对于一个由 7 台机器组成的 ZooKeeper 集群，一般在主要机房中部署 4 台机器，剩下的 3 台机器部署到另一个机房中）；三机房部署（不管哪一个机房发生了故障，剩下两个机房的机器数量都超过半数。在三个机房中都部署若干个机器来组成一个 ZooKeeper 集群。假设机器总数为 N，各机房机器数：N1 = (N-1)/2 ，N2=1~(N-N1)/2 ，N3 = N - N1 - N2 ）。

水平扩容就是向集群中添加更多机器，Zookeeper2种方式（不完美），一种是集群总体重启，另一种是逐台进行服务器的重启。

39，如何将数据分布在redis第几个库？

答：redis 自己支持16个数据库，经过 数据库id 设置，默认为0。 例如jedis客户端设置。一：JedisPool(org.apache.commons.pool.impl.GenericObjectPool.Config poolConfig, String host, int port, int timeout, String password, int database); 第一种经过指定构造函数database字段选择库，不设置则默认0库。二：jedis.select(index);调用jedis的select方法指定。

40，类加载器的双亲委派加载机制？

答：当一个类收到了类加载请求，他首先不会尝试本身去加载这个类，而是把这个请求委派给父类去完成，每个层次类加载器都是如此，所以全部的加载请求都应该传送到启动类加载其中，只有当父类加载器反馈本身没法完成这个请求的时候（在它的加载路径下没有找到所需加载的Class），子类加载器才会尝试本身去加载。

41，kafka高性能的缘由？

答：

A，Broker NIO异步消息处理，实现了IO线程与业务线程分离；

B，磁盘顺序写；

C， 零拷贝（跳过用户缓冲区的拷贝，创建一个磁盘空间和内存的直接映射，数据再也不复制到用户态缓冲区）；

D，分区/分段（每次文件操做都是对一个小文件的操做，很是轻便，同时也增长了并行处理能力）；

F，批量发送 (能够指定缓存的消息达到某个量的时候就发出去，或者缓存了固定的时间后就发送出去，大大减小服务端的I/O次数)

E，数据压缩

42，幂等的处理方式？

答：1、查询与删除操做是自然幂等

2、惟一索引，防止新增脏数据

3、token机制，防止页面重复提交

4、悲观锁 for update

5、乐观锁（经过版本号/时间戳实现， 经过条件限制where avai_amount-#subAmount# >= 0）

6、分布式锁

7、状态机幂等（若是状态机已经处于下一个状态，这时候来了一个上一个状态的变动，理论上是不可以变动的，这样的话，保证了有限状态机的幂等。）

8、select + insert（并发不高的后台系统，或者一些任务JOB，为了支持幂等，支持重复执行）

43，HTTPS工做流程？ a、客户端发送本身支持的加密规则给服务器，表明告诉服务器要进行链接了 b、服务器从中选出一套加密算法和hash算法以及本身的身份信息(地址等)以证书的形式发送给浏览器，证书中包含服务器信息，加密公钥，证书的办法机构 c、客户端收到网站的证书以后要作下面的事情： c一、验证证书的合法性 c二、若是验证经过证书，浏览器会生成一串随机数做为密钥K，并用证书中的公钥进行加密 c三、用约定好的hash算法计算握手消息，而后用生成的密钥K进行加密，而后一块儿发送给服务器 d、服务器接收到客户端传送来的信息，要求下面的事情： d一、用私钥解析出密码，用密码解析握手消息，验证hash值是否和浏览器发来的一致 d二、使用密钥加密消息，回送 若是计算法hash值一致，握手成功

44，RabbitMQ消息堆积怎么处理？

答：

增长消费者的处理能力(例如优化代码)，或减小发布频率 单纯升级硬件不是办法，只能起到一时的做用 考虑使用队列最大长度限制，RabbitMQ 3.1支持 给消息设置年龄，超时就丢弃 默认状况下，rabbitmq消费者为单线程串行消费，设置并发消费两个关键属性concurrentConsumers和prefetchCount，concurrentConsumers设置的是对每一个listener在初始化的时候设置的并发消费者的个数，prefetchCount是每次一次性从broker里面取的待消费的消息的个数 创建新的queue，消费者同时订阅新旧queue 生产者端缓存数据，在mq被消费完后再发送到mq 打破发送循环条件，设置合适的qos值，当qos值被用光，而新的ack没有被mq接收时，就能够跳出发送循环，去接收新的消息；消费者主动block接收进程，消费者感觉到接收消息过快时主动block，利用block和unblock方法调节接收速率，当接收线程被block时，跳出发送循环。 新建一个topic，partition是原来的10倍；而后写一个临时的分发数据的consumer程序，这个程序部署上去消费积压的数据，消费以后不作耗时的处理，直接均匀轮询写入临时创建好的10倍数量的queue；接着临时征用10倍的机器来部署consumer，每一批consumer消费一个临时queue的数据；等快速消费完积压数据以后，得恢复原先部署架构，从新用原先的consumer机器来消费消息； 45，RabbitMQ的消息丢失解决方案？

答：

消息持久化：Exchange 设置持久化：durable:true；Queue 设置持久化；Message持久化发送。 ACK确认机制：消息发送确认；消息接收确认。 46，负载均衡算法？

常见6种负载均衡算法：轮询，随机，源地址哈希，加权轮询，加权随机，最小链接数。

nginx5种负载均衡算法：轮询，weight，ip_hash，fair（响应时间），url_hash

dubbo负载均衡算法：随机，轮询，最少活跃调用数，一致性Hash

47，JVM内存区域划分？

答：

堆：Java中的堆是用来存储对象自己的以及数组（固然，数组引用是存放在Java栈中的），是Java垃圾收集器管理的主要区域。堆是被全部线程共享的，在JVM中只有一个堆。 虚拟机栈：虚拟机栈中存放的是一个个的栈帧，每一个栈帧对应一个被调用的方法，在栈帧中包括局部变量表、操做数栈、指向当前方法所属的类的运行时常量池的引用、方法返回地址和一些额外的附加信息。当线程执行一个方法时，就会随之建立一个对应的栈帧，并将创建的栈帧压栈。当方法执行完毕以后，便会将栈帧出栈。 本地方法栈：本地方法栈则是为执行本地方法（Native Method）服务的，在HotSopt虚拟机中直接就把本地方法栈和Java栈合二为一 方法区：方法区与堆同样，是被线程共享的区域。方法区存储了类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。在方法区中有一个很是重要的部分就是运行时常量池，它是每个类或接口的常量池的运行时表示形式，在类和接口被加载到JVM后，对应的运行时常量池就被建立出来。固然并不是Class文件常量池中的内容才能进入运行时常量池，在运行期间也可将新的常量放入运行时常量池中，好比String的intern方法。当方法区没法知足内存分配需求时，则抛出OutOfMemoryError异常。在HotSpot虚拟机中，用永久代来实现方法区，将GC分代收集扩展至方法区，可是这样容易遇到内存溢出的问题。JDK1.7中，已经把放在永久代的字符串常量池移到堆中。JDK1.8撤销永久代，引入元空间。 程序计数器（线程私有）：是当前线程所执行的字节码的行号指示器，每条线程都要有一个独立的程序计数器，这类内存也称为“线程私有”的内存。正在执行java方法的话，计数器记录的是虚拟机字节码指令的地址（当前指令的地址）。若是仍是Native方法，则为空。 直接内存：在JDK1.4中新加入的NOI类，引入了一种基于通道与缓冲区的I/O方式，它能够使用Native函数直接分配堆外内存，而后经过一个存储在Java堆中的DirectByteBuffer对象做为这块内存的引用进行操做。 48，jvm YGC和FGC发生的具体场景？

答：

正在处理的实现事务功能，下次自动回滚。

队列实现持久化储存，下次启动自动载入。

添加标志位，未处理 0，处理中 1，已处理 2。每次启动的时候，把全部状态为 1 的，置为 0。

关键性的应用就给电脑配个 UPS。

YGC ：对新生代堆进行gc。频率比较高，由于大部分对象的存活寿命较短，在新生代里被回收。性能耗费较小。 FGC ：全堆范围的gc。默认堆空间使用到达80%(可调整)的时候会触发fgc。以咱们生产环境为例，通常比较少会触发fgc，有时10天或一周左右会有一次。

YGC发生场景：edn空间不足 FGC发生场景：old空间不足，perm空间不足，调用方法System.gc() ，ygc时的悲观策略, dump live的内存信息时(jmap –dump:live)

49，一个线程池正在处理服务若是突然断电该怎么办？

答：

队列实现持久化储存，下次启动自动载入。 可是实际须要看状况，大致思路是这样。 添加标志位，未处理 0，处理中 1，已处理 2。每次启动的时候，把全部状态为 1 的，置为 0。或者定时器处理 关键性的应用就给电脑配个 UPS。

50，SpringBoot的优势？

答：

快速构建项目，极大的提升了开发、部署效率。 对主流开发框架的无配置集成。 项目可独立运行，无须外部依赖Servlet容器。 提供运行时的应用监控。

51，DoS，DDoS，DRDoS攻击分别是什么？

答：DoS是Denial of Service的简写就是拒绝服务。

DDoS就是Distributed Denial of Service的简写就是分布式拒绝服务。

DRDoS就是Distributed Reflection Denial of Service的简写,分布反射式拒绝服务。

DoS、DDos以及DRDoS攻击手段和防范措施 52，服务限流的方式？

答：

漏桶：水(请求)先进入到漏桶里,漏桶以必定的速度出水(接口有响应速率),当水流入速度过大会直接溢出(访问频率超过接口响应速率),而后就拒绝请求。 令牌桶算法：系统会按恒定1/QPS时间间隔(若是QPS=100,则间隔是10ms)往桶里加入Token，若是桶已经满了就再也不加了.新请求来临时,会各自拿走一个Token,若是没有Token就拒绝服务。 基于redis实现的限流：假设每分钟访问次数不能超过10次，在Redis中建立一个键，过时60秒，对此服务接口的访问就把键值加1，在60秒内增长到10的时候，禁止访问服务接口。 计数器，滑动窗口 53，Quartz实现原理?

答：A、scheduler是一个计划调度器容器（总部），容器里面能够盛放众多的JobDetail和trigger，当容器启动后，里面的每一个JobDetail都会根据trigger循序渐进自动去执行。 B、JobDetail是一个可执行的工做，它自己多是有状态的。 C、Trigger表明一个调度参数的配置，何时去调。 D、当JobDetail和Trigger在scheduler容器上注册后，造成了装配好的做业（JobDetail和Trigger所组成的一对儿），就能够伴随容器启动而调度执行了。 E、scheduler是个容器，容器中有一个线程池，用来并行调度执行每一个做业，这样能够提升容器效率。

54，数据库的锁？

答：行锁（共享锁和排他锁），表锁，页级锁，页级锁，意向锁，读锁，写锁，悲观锁，乐观锁等

55，简述ThreadPoolExecutor内部工做原理？

答：

先查看当前运行状态，若是不是RUNNING 状态会拒绝执行任务，若是是RUNNING状态，就会查看当前运行的线程数量，若是小于核心线程数，会建立新的线程来执行这个任务，若是不小于核心线程，会将这个任务放到阻塞队列去等代执行，直到上一个任务执行完再来执行这个任务。若是失败会建立一个非核心线程来执行这个任务若是当前线程数大于最大线程数，会直接拒绝该任务。

56，汇集索引和非汇集索引的区别？

答：

汇集索引： 索引中键值的逻辑顺序决定了表中相应行的物理顺序（索引中的数据物理存放地址和索引的顺序是一致的），能够这么理解：只要是索引是连续的，那么数据在存储介质上的存储位置也是连续的。 比方说：想要到字典上查找一个字，咱们能够根据字典前面的拼音找到该字，注意拼音的排列时有顺序的。 汇集索引就像咱们根据拼音的顺序查字典同样，能够大大的提升效率。在常常搜索必定范围的值时，经过索引找到第一条数据，根据物理地址连续存储的特色，而后检索相邻的数据，直到到达条件截至项。 非汇集索引 索引的逻辑顺序与磁盘上的物理存储顺序不一样。非汇集索引的键值在逻辑上也是连续的，可是表中的数据在存储介质上的物理顺序是不一致的，即记录的逻辑顺序和实际存储的物理顺序没有任何联系。索引的记录节点有一个数据指针指向真正的数据存储位置。 总结以下： 若是一个主键被定义了，那么这个主键就是做为汇集索引 若是没有主键被定义，那么该表的第一个惟一非空索引被做为汇集索引 若是没有主键也没有合适的惟一索引，那么innodb内部会生成一个隐藏的主键做为汇集索引，这个隐藏的主键是一个6个字节的列，改列的值会随着数据的插入自增。 InnoDB引擎会为每张表都加一个汇集索引，而汇集索引指向的的数据又是以物理磁盘顺序来存储的，自增的主键会把数据自动向后插入，避免了插入过程当中的汇集索引排序问题。若是对汇集索引进行排序，这会带来磁盘IO性能损耗是很是大的。

57，java并发包下有哪些类？

答：ConcurrentHashMap，ConcurrentSkipListMap，ConcurrentNavigableMap

CopyOnWriteArrayList

BlockingQueue，BlockingDeque （ArrayBlockingQueue，LinkedBlockingDeque，LinkedBlockingQueue，DelayQueue，PriorityBlockingQueue，SynchronousQueue）

ConcurrentLinkedDeque，ConcurrentLinkedQueue，TransferQueue，LinkedTransferQueue

CopyOnWriteArraySet，ConcurrentSkipListSet

CyclicBarrier，CountDownLatch

Lock（ReetrantLock，ReetrantReadWriteLock）

Atomic包

58，threadlocal为何会出现oom？

答：ThreadLocal里面使用了一个存在弱引用的map, map的类型是ThreadLocal.ThreadLocalMap. Map中的key为一个threadlocal实例。这个Map的确使用了弱引用，不过弱引用只是针对key。每一个key都弱引用指向threadlocal。 当把threadlocal实例置为null之后，没有任何强引用指向threadlocal实例，因此threadlocal将会被gc回收。 可是，咱们的value却不能回收，而这块value永远不会被访问到了，因此存在着内存泄露。由于存在一条从current thread链接过来的强引用。只有当前thread结束之后，current thread就不会存在栈中，强引用断开，Current Thread、Map value将所有被GC回收。最好的作法是将调用threadlocal的remove方法。

在ThreadLocal的get(),set(),remove()的时候都会清除线程ThreadLocalMap里全部key为null的value，可是这些被动的预防措施并不能保证不会内存泄漏：

（1）使用static的ThreadLocal，延长了ThreadLocal的生命周期，可能致使内存泄漏。 （2）分配使用了ThreadLocal又再也不调用get(),set(),remove()方法，那么就会致使内存泄漏，由于这块内存一直存在。

59，mysql数据库锁表怎么解决？

答：查询锁表信息 当前运行的全部事务 select * from information_schema.innodb_trx 当前出现的锁 select * from information_schema.innodb_locks 锁等待的对应关系 select * from information_schema.innodb_lock_waits

经过 select * from information_schema.innodb_trx 查询 trx_mysql_thread_id而后执行 kill 线程ID KILL 8807;//后面的数字即时进程的ID

60，java 判断对象是不是某个类的类型方法？

instanceof 运算符是用来在运行时指出对象是不是特定类的一个实例。instanceof经过返回一个布尔值来指出，这个对象是不是这个特定类或者是它的子类的一个实例。 getClass判断，如o.getClass().equals(ClassA.class)。（使用instanceof来判断一个对象是否是属于某个类，可是有时候这个类是继承于一个父类的，因此，不能严格判断出是否是本身的类，而不是本身的父类。） 61，Spring+MyBatis实现读写分离简述？

答：

方案一：经过MyBatis配置文件建立读写分离两个DataSource，每一个SqlSessionFactoryBean对象的mapperLocations属性制定两个读写数据源的配置文件。将全部读的操做配置在读文件中，全部写的操做配置在写文件中。 方案二：经过Spring AOP在业务层实现读写分离，在DAO层调用前定义切面，利用Spring的AbstractRoutingDataSource解决多数据源的问题，实现动态选择数据源 方案三：经过Mybatis的Plugin在业务层实现数据库读写分离，在MyBatis建立Statement对象前经过拦截器选择真正的数据源，在拦截器中根据方法名称不一样（select、update、insert、delete）选择数据源。 方案四：经过spring的AbstractRoutingDataSource和mybatis Plugin拦截器实现很是友好的读写分离，原有代码不须要任何改变。推荐第四种方案 62，红黑树的特色？

答：（1）每一个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每一个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！] （4）若是一个节点是红色的，则它的子节点必须是黑色的。 （5）从一个节点到该节点的子孙节点的全部路径上包含相同数目的黑节点。[这里指到叶子节点的路径]

63，kafka消息会不会丢失？

答：Kafka消息发送分同步(sync)、异步(async)两种方式。默认是使用同步方式，可经过producer.type属性进行配置；Kafka保证消息被安全生产，有三个选项分别是0,1,-1。 经过request.required.acks属性进行配置： 0表明：不进行消息接收是否成功的确认(默认值)； 1表明：当Leader副本接收成功后，返回接收成功确认信息； -1表明：当Leader和Follower副本都接收成功后，返回接收成功确认信息；

网络异常 acks设置为0时，不和Kafka集群进行消息接受确认，当网络发生异常等状况时，存在消息丢失的可能； 客户端异常 异步发送时，消息并无直接发送至Kafka集群，而是在Client端按必定规则缓存并批量发送。在这期间，若是客户端发生死机等状况，都会致使消息的丢失； 缓冲区满了 异步发送时，Client端缓存的消息超出了缓冲池的大小，也存在消息丢失的可能； Leader副本异常 acks设置为1时，Leader副本接收成功，Kafka集群就返回成功确认信息，而Follower副本可能还在同步。这时Leader副本忽然出现异常，新Leader副本(原Follower副本)未能和其保持一致，就会出现消息丢失的状况； 以上就是消息丢失的几种状况，在平常应用中，咱们须要结合自身的应用场景来选择不一样的配置。 想要更高的吞吐量就设置：异步、ack=0；想要不丢失消息数据就选：同步、ack=-1策略

64，kafka的leader副本选举？

答：若是某个分区patition的Leader挂了,那么其它跟随者将会进行选举产生一个新的leader,以后全部的读写就会转移到这个新的Leader上,在kafka中,其不是采用常见的多数选举的方式进行副本的Leader选举,而是会在Zookeeper上针对每一个Topic维护一个称为ISR（in-sync replica，已同步的副本）的集合,显然还有一些副本没有来得及同步。只有这个ISR列表里面的才有资格成为leader(先使用ISR里面的第一个，若是不行依次类推，由于ISR里面的是同步副本，消息是最完整且各个节点都是同样的)。   经过ISR,kafka须要的冗余度较低，能够容忍的失败数比较高。假设某个topic有f+1个副本，kafka能够容忍f个不可用,固然,若是所有ISR里面的副本都不可用,也能够选择其余可用的副本,只是存在数据的不一致。

65，kafka消息的检索？

答：其实很简单主要是用二分查找算法,好比咱们要查找一条offest=10000的文件,kafka首先会在对应分区下的log文件里采用二分查看定位到某个记录该offest =10000这条消息的log,而后从相应的index文件定位其偏移量,而后拿着偏移量到log里面直接获取。这样就完成了一个消息的检索过程。

66，RabbitMQ 集群方式？

答：

1）普通集群：

以两个节点（rabbit0一、rabbit02）为例来进行说明。 rabbit01和rabbit02两个节点仅有相同的元数据，即队列的结构，但消息实体只存在于其中一个节点rabbit01（或者rabbit02）中。 当消息进入rabbit01节点的Queue后，consumer从rabbit02节点消费时，RabbitMQ会临时在rabbit0一、rabbit02间进行消息传输，把A中的消息实体取出并通过B发送给consumer。因此consumer应尽可能链接每个节点，从中取消息。即对于同一个逻辑队列，要在多个节点创建物理Queue。不然不管consumer连rabbit01或rabbit02，出口总在rabbit01，会产生瓶颈。当rabbit01节点故障后，rabbit02节点没法取到rabbit01节点中还未消费的消息实体。若是作了消息持久化，那么得等rabbit01节点恢复，而后才可被消费；若是没有持久化的话，就会产生消息丢失的现象。

2）镜像集群：

在普通集群的基础上，把须要的队列作成镜像队列，消息实体会主动在镜像节点间同步，而不是在客户端取数据时临时拉取，也就是说多少节点消息就会备份多少份。该模式带来的反作用也很明显，除了下降系统性能外，若是镜像队列数量过多，加之大量的消息进入，集群内部的网络带宽将会被这种同步通信大大消耗掉。因此在对可靠性要求较高的场合中适用 因为镜像队列之间消息自动同步，且内部有选举master机制，即便master节点宕机也不会影响整个集群的使用，达到去中心化的目的，从而有效的防止消息丢失及服务不可用等问题

67，ElasticSearch如何解决深度分页的问题？

答：使用scroll（有状态）和search after（无状态）的游标方式。

68，java代码优化(一)

答：尽可能指定类、方法的final修饰符。 尽可能重用对象。 尽量使用局部变量。 及时关闭流。 尽可能减小对变量的重复计算。 尽可能采用懒加载的策略，即在须要的时候才建立。 慎用异常。 不要在循环中使用try...catch...，应该把其放在最外层。 若是能估计到待添加的内容长度，为底层以数组方式实现的集合、工具类指定初始长度。 当复制大量数据时，使用System.arraycopy()命令。 乘法和除法使用移位操做。 循环内不要不断建立对象引用。 基于效率和类型检查的考虑，应该尽量使用array，没法肯定数组大小时才使用ArrayList。 尽可能使用HashMap、ArrayList、StringBuilder，除非线程安全须要，不然不推荐使用Hashtable、Vector、StringBuffer，后三者因为使用同步机制而致使了性能开销。 不要将数组声明为public static final。

69，java代码优化(二)

答：尽可能在合适的场合使用单例。 尽可能避免随意使用静态变量。 及时清除再也不须要的会话。 实现RandomAccess接口的集合好比ArrayList，应当使用最普通的for循环而不是foreach循环来遍历 使用同步代码块替代同步方法。 将常量声明为static final，并以大写命名。 不要建立一些不使用的对象，不要导入一些不使用的类。 程序运行过程当中避免使用反射。 使用数据库链接池和线程池。 使用带缓冲的输入输出流进行IO操做。 顺序插入和随机访问比较多的场景使用ArrayList，元素删除和中间插入比较多的场景使用LinkedList。 不要让public方法中有太多的形参。 字符串变量和字符串常量equals的时候将字符串常量写在前面。 请知道，在java中if (i == 1)和if (1 == i)是没有区别的，但从阅读习惯上讲，建议使用前者。 不要对数组使用toString()方法。 不要对超出范围的基本数据类型作向下强制转型。

70，java代码优化(三)

答:公用的集合类中不使用的数据必定要及时remove掉。 把一个基本数据类型转为字符串，基本数据类型.toString()是最快的方式、String.valueOf(数据)次之、数据+""最慢 使用最有效率的方式去遍历Map。 对资源的close()建议分开操做。 对于ThreadLocal使用前或者使用后必定要先remove。 切记以常量定义的方式替代魔鬼数字，魔鬼数字的存在将极大地下降代码可读性，字符串常量是否使用常量定义能够视状况而定。 long或者Long初始赋值时，使用大写的L而不是小写的l，由于字母l极易与数字1混淆，这个点很是细节，值得注意。 全部重写的方法必须保留@Override注解。 推荐使用JDK7中新引入的Objects工具类来进行对象的equals比较，直接a.equals(b)，有空指针异常的风险。 循环体内不要使用"+"进行字符串拼接，而直接使用StringBuilder不断append。 不捕获Java类库中定义的继承自RuntimeException的运行时异常类。 避免Random实例被多线程使用，虽然共享该实例是线程安全的，但会因竞争同一seed致使的性能降低，JDK7以后，能够使用ThreadLocalRandom来获取随机数。 静态类、单例类、工厂类将它们的构造函数置为private。

71，单点登陆原理与简单实现？

答：相比于单系统登陆，sso须要一个独立的认证中心，只有认证中心能接受用户的用户名密码等安全信息，其余系统不提供登陆入口，只接受认证中心的间接受权。间接受权经过令牌实现，sso认证中心验证用户的用户名密码没问题，建立受权令牌，在接下来的跳转过程当中，受权令牌做为参数发送给各个子系统，子系统拿到令牌，即获得了受权，能够借此建立局部会话，局部会话登陆方式与单系统的登陆方式相同。这个过程，也就是单点登陆的原理，用下图说明

单点登陆天然也要单点注销，在一个子系统中注销，全部子系统的会话都将被销毁，用下面的图来讲明

72，MQ作数据同步也会形成不一致，又须要引入监控，实时计算2个集群的数据同步，作一致性同步。大部分来讲，同步es和solr不要在代码中去同步，同步失败没法保证事务，并且业务耦合。能够使用Databug和cancel等工具去作代码解耦，MQ支持重试，存储失败后抛出异常下次再处理。数据作异构，对外服务时任意拼装，MYSQL在半同步复制上作了一些优化，保证了一致性，引入了诸如paxos等主流算法保证强一致性问题。 当DB（监遵从库），binlog有变化，cancel监听到时候解析过滤发送MQ（表名字，主键等）到变化的实时从库中查询数据同步到ES聚合表，MQ能够重试，系统解耦。事务log挖掘县城会对DB的事务log监听，并把这些事件发布到消息代理。

73，分布式服务调用能够实现跟踪系统，能够在业务日志中添加调用链ID，各个环节RPC均添加调用时延,QPS等。

非业务组件应该少加入业务代码，服务调用采用买点，也会采用配置采样率方式，买点即当前节点的上下文信息，包含TraceId，RPCId，开始结束时间，类型，协议，调用方IP，端口，服务名等，以及其余异常信息，报文等扩展，日志采用离线+实时的如flume结合kafka等，应按照TraceId汇总日志后按RPCId顺序整理。

74，Sentinel 工做原理？

答：（1）每一个 Sentinel 以每秒钟一次的频率向它所知的 Master，Slave 以及其余 Sentinel 实例发送一个 PING 命令； （2）若是一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 Sentinel 标记为主观下线； （3）若是一个 Master 被标记为主观下线，则正在监视这个 Master 的全部 Sentinel 要以每秒一次的频率确认 Master 的确进入了主观下线状态； （4）当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认 Master 的确进入了主观下线状态，则 Master 会被标记为客观下线； （5）在通常状况下， 每一个 Sentinel 会以每 10 秒一次的频率向它已知的全部 Master，Slave 发送 INFO 命令； 当 Master 被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的全部 Slave 发送 INFO 命令的频率会从 10 秒一次改成每秒一次； （6）若没有足够数量的 Sentinel 赞成 Master 已经下线， Master 的客观下线状态就会被移除； （7）若 Master 从新向 Sentinel 的 PING 命令返回有效回复， Master 的主观下线状态就会被移除。

监控（ Monitoring ）： Redis Sentinel 实时监控主服务器和从服务器运行状态； 自动故障转移：若是一个 master 不正常运行了，哨兵能够启动一个故障转移进程，将一个 slave 升级成为 master，其余的 slave 被从新配置使用新的 master，而且应用程序使用 Redis 服务端通知的新地址；

75，高性能统计UV的方式？

（1）使用redis的set集合

（2）使用redis的bitmap（注意内存消耗）

76，Hbase二级索引，索引海量数据实现方案？

答：

(1) 方案1:使用开源的hbase-indexer，是借助于hbase的WAL实现，不会影响hbase性能

https://blog.csdn.net/xiahoujie_90/article/details/53400044

(2) 方案2：基于ES本身实现，利用habse的协处理器实现，会影响hbase性能

关键注意点：由于数据是存在Hbase中，ES充当的是索引角色，因此在建立ES的mapping时，

应指定_source为enabled:false。关闭存储原始文档。

https://wenku.baidu.com/view/422722fdd0f34693daef5ef7ba0d4a7303766c71.html

77，Elasticsearch分片使用优化?

答：(1)拆分集群 对于存在明显分界线的业务，能够按照业务、地域使用不一样集群，这种拆分集群的思路是很是靠谱的。对于咱们的场景，已经按照地域拆分了集群，且同一地域的子业务间分界线不明显，拆分过多的集群维护成本较高。 (2)调整滚动周期 根据保留时长调整index滚动周期是最简单有效的思路。例如保留3天的数据按天滚动，保留31天的数据按周滚动，保留一年的数据按月滚动。合理的滚动周期，能够在存储成本增长不大的状况下，大幅下降分片数量。 对于咱们的场景，大部分数据保留31天，在按周滚动的状况下，集群的总分片数能够降低到6.5w~个。 (3)合理设置分片数和副本数 除个别子业务压力较高外，大部分业务压力较小，合理设置单Index的分片数效果也不错。咱们的经验是单个分片的大小在10GB~30GB之间比较合适，对于压力很是小的业务能够直接分配1个分片。其余用户可结合具体场景考虑，同时注意单分片的记录条数不要超过上限2,147,483,519。 在平衡咱们的业务场景对数据可靠性的要求 及 不一样副本数对存储成本的开销 两个因素以后，咱们选择使用一主一从的副本策略。 目前咱们集群单Index的平均分配数为3，集群的总分片数降低到3w~个。 (4)分片分配流程优化 默认状况下，ES在分配分片时会考虑分片relocation对磁盘空间的影响。在分片数较少时，这个优化处理的反作用不明显。但随着单机分片数量的上升，这个优化处理涉及的多层循环嵌套过程耗时愈发明显。可经过cluster.routing.allocation.disk.include_relocations: false关闭此功能，这对磁盘均衡程度影响不明显。 (5)预建立Index 对于单集群3w分片的场景，集中在每周某天0点建立Index，对集群的压力仍是较大，且存储空间存在波动。考虑到集群的持续扩展能力和可靠性，咱们采用预建立方式提早建立分片，并把按Index的建立时间均匀打散到每周的每一天。 (6)持续调整分片数 对于集群分片的调整，一般不是一蹴而就的。随着业务的发展，不断新增的子业务 或 原有子业务规模发生突变，都须要持续调整分片数量。 默认状况下，新增的子业务会有默认的分片数量，若是不足，会在测试阶段及上线初期及时发现。随着业务发展，系统会考虑Index近期的数据量、写入速度、集群规模等因素，动态调整分片数量。

###78，如何编写高质量代码151建议？

答：

1、Java开发中通用的方法和准则
不要在常量和变量中出现易混淆的字母;
莫让常量蜕变成变量;
三元操做符的类型务必一致;
避免带有变长参数的方法重载;
别让null值和空值威胁到变长方法;
覆写变长方法也要循规蹈矩;
警戒字增的陷阱;
不要让旧语法困扰你;
少用静态导入;
不要在本类中覆盖静态导入的变量和方法;
养成良好习惯，显示声明UID;
避免用序列化类在构造函数中为不变量赋值;
避免为final变量复杂赋值;
使用序列化类的私有方法巧妙解决部分属性持久化问题;
break万万不可忘;
易变业务使用脚本语言编写;
慎用动态编译;
避免instantceof非预期结果;
断言对决不是鸡肋;
不要只替换一个类;


2、基本类型
使用偶判断，不用奇判断;
用整数类型处理货币;
不要让类型默默转换;
边界，边界，仍是边界;
不要让四舍五入亏了一方;
提防包装类型的null值;
谨慎包装类型的大小比较;
优先使用整型池;
优先选择基本类型;
不要随便设置随机种子;


3、类、对象及方法
在接口中不要存在实现代码;
静态变量必定要先声明后赋值;
不要覆写静态方法;
构造函数尽可能简化;
避免在构造函数中初始化其余类;
使用构造代码块精炼程序;
使用静态内部类提供封装性;
使用匿名类的构造函数;
匿名类的构造函数很特殊;
让多重继承成为现实;
让工具类不可实例化;
避免对象的浅拷贝;
推荐使用序列化实现对象的拷贝;
覆写equals方法时不要识别不出本身;
equals应该考虑null值情景;
在equals中使用getClass进行类型判断;
覆写equals方法必须覆写hashCode方法;
推荐覆写toString方法;
使用package-info类为包服务;
不要主动进行垃圾回收;


4、字符串
推荐使用String直接量赋值;
注意方法中传递的参数要求;
正确使用String、StringBuffer、StringBuilder;
注意字符串的位置;
自由选择字符串拼接方法;
推荐在复杂字符串操做中使用正则表达式;
强烈建议使用UTF编码;
对字符串排序持一种宽容的心态;


5、数组和集合
性能考虑，数组是首选;
如有必要，使用变长数组;
警戒数组的浅拷贝;
在明确的场景下，为集合指定初始容量;
多种最值方法，适时选择;
避开基本类型数组转换列表陷阱;
asList方法产生的List对象不可更改;
不一样的列表选择不一样的遍历方法;
频繁插入和删除时使用LinkedList;
列表相等只需关心元素数据;
推荐使用subList处理局部列表;
生成子表后不要再操做原列表;
使用Comparator进行排序;
不推荐使用binarySearch对列表进行检索;
集合中的元素必须作到compareTo和equals同步;
集合运算时使用更优雅的方式;
使用shuffle大乱列表;
减小HashMap中元素的数量;
集合中的哈希码不要重复;
多线程使用Vector或者HashTable;
非稳定排序推荐使用List;


6、枚举和注解
推荐使用枚举定义常量;
使用构造函数协助描述枚举项;
当心switch带来的空值异常;
在switch的default代码块中增长AssertionError错误;
使用valueOf前必须进行校验;
用枚举实现工厂方法模式更简洁;
枚举项的数量限制在64个之内;
当心注解继承;
枚举和注解结合使用威力更大;
注意@Override不一样版本的区别;


7、枚举和注解
Java的泛型是类型擦除的;
不能初始化泛型参数和数组;
强制声明泛型的实际类型;
不一样的场景使用不一样的泛型通配符;
警戒泛型是不能协变和逆变的;
建议采用的顺序是List<T>、List<?>、List<Object>;
严格限定泛型类型采用多重界限;
数组的真实类型必须是泛型类型的子类型;
注意Class类的特殊性;
适时选择getDeclaredXXX和getXXX;
反射访问属性或方法时将Accessible设置为true;
使用forName动态加载类文件;
动态加载不合适数组;
动态代理能够使代理模式更加灵活;
反射让模板方法模式更强大;
不须要太多关注反射效率;


8、异常
提倡异常封装;
采用异常链传递异常;
受检异常尽量转化为非受检异常;
不要在finally块中处理返回值;
使用Throwable获取栈信息;
异常只为异常服务;
多使用异常，把性能问题放一边;


9、多线程和并发
不推荐覆写start方法;
启动线程前stop方法是不可靠的;
不使用stop方法中止线程;
线程优先级只使用三个等级;
使用线程异常处理器提高系统可靠性;
volatile不能保证数据同步;
异步运算多考虑使用Callable接口;
优先选择线程池;
适时选择不一样的线程池来实现;
Lock与synchronized是不同的;
预防线程死锁;
适当设置阻塞队列长度;
使用CountDownLatch协调子线程;
CyclicBarrier让多线程齐步走;