吐血总结

1. 面向对象
   在java，c＋＋等面向对象编程的语言中，他们将一切事物都当作对象，而将事物的特征和行为定义为对象的属性和方法

   封装是实现面向对象程序设计的第一步，封装就是，具有有相同特性（属性）和相同行为（方法）的对象用一个类来描述。这样对象只要去调用类中方法，就可以实现功能，而不用管具体的实现。

   继承主要实现重用代码，节省开发时间。

   多态就是，多种形态，同一操作作用于不同的对象，可以有不同的解释，
   产生不同的执行结果。在运行时，可以通过指向父类的指针，来调用实现子类中的方法。

   分为编译时多态，运行时多态，
   编译时多态就是重载：系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。
   运行时多态就是覆写：直到系统运行时，才根据实际情况决定实现何种操作。
   编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的特点。

2. 谈谈对IOC和AOP的理解
   IOC控制反转是相对我们之前创建对象都是new的方式来讲的，而现在我们将对象的管理交给spring，由spring去控制，降低了对象与对象之间的耦合度。

   AOP是面向切面编程，面向对象编程引入封装、继承、多态等概念建立一种纵向的开发方式，而AOP则是建立了一种横向的开发方式。对于如权限认证、日志、事务等几乎业务功能都需要的功能，若采用OOP的设计则会产生大量的重复代码，不利于各模块的重用。

   而AOP则把系统分为两部分：核心关注点和横切关注点。业务的核心处理流程为核心关注点，而权限认证、日志、事务等则为横切关注点。AOP思想的作用在于分离系统中的各种关注点，进一步解耦模块间的相互依赖，提高模块的重用性。

3. IOC有什么好处
   将bean交给Spring容器管理，开发不用关心具体细节。
   spring容器中的bean都是单例的

4. SpringBoot的优缺点
   优点：
   springboot内嵌了servlet容器。
   快速整合第三方框架，无需配置文件。
   配合各种starter使用，基本上可以做到自动化配置，提高了开发效率。
   配合Maven或Gradle等构件工具，打包、部署简单。
   缺点：
   没有相应的服务发现和注册。

5. maven构建生命周期
   1：clean、２：resources、３：compile、４：testResources、５：testCompile、６：test、７：jar、８：install
   https://blog.csdn.net/zhaojianting/article/details/80321488
   版权声明：本文为博主原创文章，转载请附上博文链接！

6. 熟悉的数据结构，ArrayList，LinkedList，HashMap，Hashtable，LinkedHashMap（LRUCache），ConcurrnetHashMap

7. 算法：
   快排 https://blog.csdn.net/hacker00011000/article/details/52176100
   归并排序 https://www.cnblogs.com/acm-bingzi/p/mergesort.html
   雪花算法 https://blog.csdn.net/LGM_lx/article/details/84727813
   LRUCache https://blog.csdn.net/caoshangpa/article/details/78783749
   常用的排序算法的时间复杂度和空间复杂度 https://blog.csdn.net/LGM_lx/article/details/84708173

   红黑树的特性 :
   每个节点或者是黑色，或者是红色。
   根节点是黑色。
   每个叶子节点（NULL）是黑色。
   如果一个节点是红色的，则它的子节点必须是黑色的。

8. 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

9. 设计模式：单例+简单工厂+适配器，代理模式
   静态代理：
   1）首先创建一个接口（JDK代理都是面向接口的）；
   2）然后创建具体实现类来实现这个接口；
   3）再创建一个代理类同样实现这个接口，不同之处在于，具体实现类的方法中需要将接口中定义的方法的业务逻辑功能 实现，而代理类中持有具体实现类的引用，代理类的方法中使用该引用调用对应方法。
   这样我们在需要使用接口中的某个方法的功能时直接调用代理类的方法即可，将具体的实现类隐藏在底层。

   动态代理
   只能对实现了接口的类生产代理，不能针对类。
   1）首先创建一个接口（JDK代理都是面向接口的）；
   2）然后创建具体实现类来实现这个接口；
   3）创建代理对象，实现java.lang.reflect.InvocationHandler接口，实现接口方法。在代理对象传入被代理对象实例。

   https://blog.csdn.net/jinjin603/article/details/78951755

10. JAVA反射获取私有属性
    反射获取类对象，获取私有属性和方法集合，然后取消访问检查setAccessible(true)，最后调用私有属性或方法。

    反射优点：

    能够运行时动态获取类的实例，大大提高了系统的灵活性和扩展性；
    与java动态编译相结合，可以实现无比强大的功能。
    反射缺点：
    使用反射的性能较低；
    使用反射来说相对不安全；
    破坏了类的封装性，可以通过反射来获取这个类的属性，和私有方法。

11. 多线程：
    线程池 https://blog.csdn.net/LGM_lx/article/details/84673691
    ConcurrnetHashMap https://blog.csdn.net/LGM_lx/article/details/84615107
    ThreadLocal https://blog.csdn.net/LGM_lx/article/details/84639302

12. 如果有5个线程分别处理不同的任务，需要等这5个线程都执行完成后输出一条日志，如何解决。
    Java并发编程：http://www.importnew.com/21889.html
    CountDownLatch:利用它可以实现类似计数器的功能，原理是AQS。 https://blog.csdn.net/joenqc/article/details/76794356
    CyclicBarrier:通过它可以实现让一组线程等待至某个状态之后再全部同时执行
    Semaphore(sai me fer)：Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

13. Java线程的5种状态

    1. 新建(NEW)：新创建了一个线程对象。

    2. 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

    3. 运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。

    4. 阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种：
       (一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
       (二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
       (三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

    5. 死亡(DEAD)

14. JAVA并发编程: CAS和AQS
    什么是CAS（Compare And Swap）？是解决多线程并行情况下使用锁造成性能损耗的一种机制。
    什么是AQS（AbstractQueuedSynchronizer）？是JDK下提供的一套用于实现基于FIFO等待队列的阻塞锁和相关的同步器的一个同步框架。
    https://blog.csdn.net/u010862794/article/details/72892300

15. synchronized和lock（）
    类别 synchronized Lock
    存在层次 java关键字，在jvm层 类
    锁的释放 1.获取锁的线程执行完了该代码块，然后线程释放对锁的占有；2. 线程执行发生异常，此时JVM会让线程自动释放锁。 Lock则必须要在finally中手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
    锁的获取 假设A线程获得锁，B线程等待，如果A阻塞，B线程一直会等待。 多种方式
    锁的状态 无法判断 可以判断
    锁类型 可重入，不可中断，非公平 可重入，可判断，可公平
    性能 少量同步 大量同步

    volitile没有加锁，volatile的语义, 其实是告诉处理器, 不要将我放入工作内存, 请直接在主存操作我.

16. 序列化的优缺点 https://blog.csdn.net/u010486679/article/details/81562344

17. JVM的内存模型 https://blog.csdn.net/LGM_lx/article/details/84711404

18. mysql的ACID原理
    事务的 ACID 是通过 InnoDB 日志和锁来保证。事务的隔离性是通过数据库锁的机制实现的，持久性通过 Redo Log（重做日志）来实现，原子性和一致性通过 Undo Log 来实现。

19. mysql各种引擎对比 https://blog.csdn.net/LGM_lx/article/details/84675043
    以下两点必须使用 InnoDB：
    1）可靠性高或者要求事务处理，则使用InnoDB。这个是必须的。
    2）表更新和查询都相当的频繁，并且表锁定的机会比较大的情况指定InnoDB数据引擎的创建。
    对比之下，MyISAM的使用场景：
    1）做很多count的计算的。如一些日志，调查的业务表。
    2）插入修改不频繁，查询非常频繁的。

20. sql优化 https://blog.csdn.net/LGM_lx/article/details/84675578
    in 和 not in 应避免使用，会导致全表扫描
    应尽量避免在 where 子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描
    不要使用select * from t的形式进行查询
    避免出现隐式转换，保持SQL中变量类型与字段类型一直
    当需要插入大量数据时，使用copy方式，避免执行大量 insert 语句

21. 数据库索引类型
    普通索引
    唯一索引：索引的值必须唯一，允许为空
    全文索引
    单列索引和多列索引
    组合索引（最左前缀）

22. 聚集索引和非聚集索引
    聚集索引：数据行的物理顺序与列值（一般是主键的那一列）的逻辑顺序相同，一个表中只能拥有一个聚集索引。例如新华字典拼音目录从A到Z。
    非聚集索引：该索引中索引的逻辑顺序与磁盘上行的物理存储顺序不同，一个表中可以拥有多个非聚集索引。例如新华字典可以根据偏旁部首来查询。

23. 产生死锁的四个必要条件：
    （1） 互斥条件：一个资源每次只能被一个进程使用。
    （2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
    （3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
    （4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

24. 数据库的锁
    乐观锁：乐观的任务数据不会被改，需要自己实现，每次查的时候获取版本，update时候比较版本（时间戳）；
    悲观锁：数据库默认锁，认为数据被改动，包括共享锁（lock in share mode），排它锁（for update）
    https://blog.csdn.net/puhaiyang/article/details/72284702

25. 分布式锁
    CAP定理：一个分布式系统不可能同时满足一致性（C），可用性（A）和分区容错性（P）这三个基本需求，最多只能同时满足其中的两项。
    三种实现方式：

    基于数据库实现分布式锁； 共享锁，排他锁
    基于缓存（Redis等）实现分布式锁；
    基于Zookeeper实现分布式锁；
    https://blog.csdn.net/xlgen157387/article/details/79036337

26. redis的五中数据结构
    

27. nginx的常用功能
    1 正向代理
    2 反向代理
    3 透明代理
    4 负载均衡

28. 分布式事务：https://www.jianshu.com/p/16b1baf015e8
    CAP 定理，又被叫作布鲁尔定理。
    C (一致性)：对某个指定的客户端来说，读操作能返回最新的写操作。对于数据分布在不同节点上的数据来说，如果在某个节点更新了数据，那么在其他节点如果都能读取到这个最新的数据，那么就称为强一致，如果有某个节点没有读取到，那就是分布式不一致。
    A (可用性)：非故障的节点在合理的时间内返回合理的响应(不是错误和超时的响应)。可用性的两个关键一个是合理的时间，一个是合理的响应。合理的时间指的是请求不能无限被阻塞，应该在合理的时间给出返回。合理的响应指的是系统应该明确返回结果并且结果是正确的，这里的正确指的是比如应该返回 50，而不是返回 40。
    P (分区容错性)：当出现网络分区后，系统能够继续工作。打个比方，这里集群有多台机器，有台机器网络出现了问题，但是这个集群仍然可以正常工作。

    由于CAP原理，如果我们选择了 CA 而放弃了 P，那么当发生分区现象时，为了保证一致性，这个时候必须拒绝请求，但是 A 又不允许，所以分布式系统理论上不可能选择 CA 架构，只能选择 CP 或者 AP 架构。

    对于 CP 来说，放弃可用性，追求一致性和分区容错性，我们的 ZooKeeper 其实就是追求的强一致。

    对于 AP 来说，放弃一致性(这里说的一致性是强一致性)，追求分区容错性和可用性，这是很多分布式系统设计时的选择，后面的 BASE 也是根据 AP 来扩展。

    分布式方案：

    • 两阶段提交（2PC），两阶段提交就是使用XA协议
    • 补偿事务（TCC），：针对每个操作，都要注册一个与其对应的确认和补偿（撤销）操作
      1、首先在 Try 阶段，要先调用远程接口把 Smith 和 Bob 的钱给冻结起来。
      2、在 Confirm 阶段，执行远程调用的转账的操作，转账成功进行解冻。
      3、如果第2步执行成功，那么转账成功，如果第二步执行失败，则调用远程冻结接口对应的解冻方法 (Cancel)。
      第一阶段Prepared消息，会拿到消息的地址。
      第二阶段执行本地事务，第三阶段通过第一阶段拿到的地址去访问消息，并修改状态。
    • RocketMQ
      第一阶段Prepared消息，会拿到消息的地址。
      第二阶段执行本地事务。
      第三阶段通过第一阶段拿到的地址去访问消息，并修改状态。

29. 分布式算法(一致性Hash算法)：https://www.cnblogs.com/moonandstar08/p/5405991.html
    一致性哈希算法(Consistent Hashing Algorithm)是一种分布式算法，常用于负载均衡。

    简单来说，一致性哈希将整个哈希值空间组织成一个虚拟的圆环

    下一步将各个服务器使用H进行一个哈希，具体可以选择服务器的ip或主机名作为关键字进行哈希，这样每台机器就能确定其在哈希环上的位置
    接下来使用如下算法定位数据访问到相应服务器：将数据key使用相同的函数H计算出哈希值h，通根据h确定此数据在环上的位置，从此位置沿环顺时针“行走”，第一台遇到的服务器就是其应该定位到的服务器。

30. impala和hive的比较
    https://www.cnblogs.com/zlslch/p/6785207.html?utm_source=itdadao&utm_medium=referral

31. 什么是OLTP与OLAP？

    数据处理大致可以分成两大类：联机事务处理OLTP（on-line transaction processing）、联机分析处理OLAP（On-Line Analytical Processing）。OLTP是传统的关系型数据库的主要应用，主要是基本的、日常的事务处理，例如银行交易。OLAP是数据仓库系统的主要应用，支持复杂的分析操作，侧重决策支持，并且提供直观易懂的查询结果。

    OLTP 系统强调数据库内存效率，强调内存各种指标的命令率，强调绑定变量，强调并发操作；
    OLAP 系统则强调数据分析，强调SQL执行市场，强调磁盘I/O，强调分区等。

32. 一文读懂Apache kudu
    https://www.jianshu.com/p/83290cd817ac