sowhat1412 后端总结

按需加载 *.class文件到内存生成Class 目标对象

wait、notify还是notifyAll()都是在同步代码块中调用的
调用wait()的线程会释放掉锁，Thread.sleep不会释放锁
wait被唤醒：该线程被中断，wait()时间到了，被notify()唤醒，被notifyAll()唤醒

transfer 函数， 多线程扩容时会产生环

继承自HashMap，保存了数据插入的顺序。方便访问。 HashMap + 双向链表 = LinkedHashMap

LinkedHashMap和HashMap不同的是LinkedHashMap通过继承hashMap中的Entry<K,V>,并添加两个属性Entry<K,V> before,after,和header结合起来组成一个双向链表，来实现按插入顺序或访问顺序排序

基于LinkedHashMap实现LRU

arraylist原理 transient Object[] elementData，为什么数组加 transient

线程不安全，可用 Collections.synchronizedList 包装下变为安全的

Function 函数型接口：有一个输入参数，有一个输出

Predicate 断定型接口：有一个输入参数，返回值只能是 布尔值！

Consumer 消费型接口: 只有输入，没有返回值

Supplier 供给型接口 没有参数，只有返回值

() -> {}

Java是没有权限开线程的，无法操作硬件，都是调用的native方法 由C++实现

线程状态

yield 跟sleep区别

早期OS没有线程概念，只有进程。操作系统按照进程调度，应用层进行线程的创建跟维护还有调度。

优点：OS不支持线程也可通过库函数支持线程。不会引发用户态到内核态的切换，为啥go流行，它的协程借鉴了这点

缺点: OS不知道线程存在，进程中一个线程耗时过久会阻塞整个进程。某个线程进行网络IO导致线程中断也会引发阻塞整个进程。

Linux中JVM基于pthread实现，Java线程本质是OS线程。

为避免线程消耗资源过大引入了协程，协程是按需使用栈内存的，即是在用户态做线程资源切换，也让操作系统在内核层做线程调度。

wait 来自Object

sleep 来自Thread

wait释放锁

sleep不释放

wait必须在同步代码块中

sleep可以任意使用

wait不需要捕获异常

sleep需捕获异常

Thread 是线程对象，Runnable 是任务，一线程启动的时候一定是对象

Callable 与 Runnable 的区别

1、互斥条件
2、不可抢占条件
3、占有且申请条件
4、循环等待条件

1、jps -l 定位进程号
2、jstack 进程号找到死锁问题

破坏产生条件

实例对象：类的属性信息跟父类属性

填充数据：仅仅是为了字节对齐，8字节倍数

对象头

JDK6后锁升级

syn锁升级图

整个J.U.C都是建立在CAS之上的

ABA：解决方法是引入版本号 AtomicStampedReference

开销问题：长期不成功那就会进入自旋，JVM提供了pause指令可以有效减少自旋导致的资源浪费。

只能保证一个共享变量之间的原则性操作，JDK5后可以将多个变量放到一个对象中AtomicReference操作。

CAS导致只有一个线程获得锁成功，太多线程进入自旋，JDK8 节点ConcurrentHashMap的分段锁思维引入了LongAdder。

1、Synchronized 是Java内置关键字，Lock是Java接口
2、Synchronized 无法判断获取锁状态，Lock可以判断是否获取到锁了
3、Synchronized 会自动释放锁，Lock必须手动释放锁。
4、Synchronized 后来线程会傻傻等待锁，Lock锁可能存在加塞 不会苦等。
5、Synchronized 是可重入锁，不可以中断。Lock 可重入锁，可以设置锁是否公平。
6、Synchronized 适合少量代码块同步，Lock适合大量代码块。
7、Synchronized 不可timeout，Lock可以timeout
8、Synchronized 可能涉及到monitor 用户态到CPU态切换，Lock不会涉及切换，效率更好些。

基本用法lock()、unlock()

Lock可以实现公平锁跟非公平锁

锁降级：从写锁变成读锁
锁升级：从读锁变成写锁

1、锁降级：ReentrantReadWriteLock 支持锁降级。
2、锁升级：ReentrantReadWriteLock 不支持锁升级。

总结：

一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。

N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。

JDK8底层级别优化

1、队列FIFO
2、写入：如果队列满了就必须阻塞等待。
3、取值：如果队列是空的必须阻塞等待生产。
4、阻塞队列使用：多线程并发处理线程池。

用时功能如上

1、每个Map存储的KV数据变小了，以前是线程个数多则ThreadLocal存储的KV数就变多。现在的K是用ThreadLocal实例化对象来当key的，多线程情况下ThreadLocal实例化个数一般都比线程数少！
2、以前线程销毁后ThreadLocal这个Map还是存在的，现在当Thread销毁时候，ThreadLocalMap也会随之销毁，减少内存使用。

InheritableThreadLocal

阿里编程规范跟源码建议：ThreadLocal对象建议使用 static修饰。这个变量是针对一个线程内所有操作共享的，所以设置为静态变量，所有此类实例共享此静态变量 ，也就是说在类第一次被使用时装载，只分配一块存储空间，所有此类的对象(只要是这个线程内定义的)都可以操控这个变量。

1、ThreadLocalRef用完后Entry没有手动删除。
2、ThreadLocalRef用完后CurrentThread依然在运行ing。

线程池的使用不要用 Executors（底层调用也是ThreadPoolExecutor），要通过ThreadPoolExecutor创建，这样可以明确线程池运行规则，Executors创建的线程池允许的请求队列最大值是int最大值，容易导致OOM

1、 单个线程池 Executors.newSingleThreadExecutor();
2、 固定大小的线程池 Executors.newFixedThreadPool(5);
3、 弹性线程池 Executors.newCachedThreadPool();

1、corePoolSize：核心线程池大小。
2、maximumPoolSize：表示允许的最大线程数 = (非核心线程数+核心线程数)，当BlockingQueue也满了，但线程池中总线程数 < maximumPoolSize时候就会再次创建新的线程。
3、keepAliveTime：非核心线程 =(maximumPoolSize - corePoolSize ) ,非核心线程闲置下来不干活最多存活时间。
4、unit：线程池中非核心线程保持存活的时间，比如 TimeUnit.MINUTES
5、workQueue：线程池 等待队列，维护着等待执行的Runnable对象。当运行当线程数= corePoolSize时，新的任务会被添加到workQueue中，如果workQueue也满了则尝试用非核心线程执行任务，另外等待队列尽量用有界的哦！！
6、threadFactory：创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等。
7、handler：corePoolSize、workQueue、maximumPoolSize都不可用的时候执行的 饱和策略。

1、AbortPolicy ：直接抛出异常，默认用此
2、CallerRunsPolicy：用调用者所在的线程来执行任务
3、DiscardOldestPolicy：丢弃阻塞队列里最老的任务，队列里最靠前的任务
4、DiscardPolicy ：当前任务直接丢弃
5、想实现自己的饱和策略，实现RejectedExecutionHandler接口即可

execute

submit

Runtime.getRuntime().availableProcessors() + 1 ，+1是因为可能存在页缺失(就是可能存在有些数据在硬盘中需要多来一个线程将数据读入内存)。如果线程池数太大，可能会频繁的 进行线程上下文切换跟任务调度

线程数适当大一点，机器的Cpu核心数*2。

Java中主要依靠 共享内存 跟 wait notify

内存模型解决并发问题方式：限制处理器优化和使用内存屏障。

JMM就作用于工作内存和主存之间数据同步过程。他规定了如何做数据同步以及什么时候做数据同步

Java中提出 as-if-serial：不管如何重排序 都必须保证单线程代码执行的准确性跟幂等性

Java中提出 happens-before：用来阐述操作之间的内存可见性，及两个操作直接前后依赖性

LoadLoad 屏障
StoreStore 屏障
LoadStore 屏障
StoreLoad 屏障

对一个volatile变量的读，总是从共享内存中读取最新的数据来用

对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性。

指令重排定义：你写的程序，计算机并不是按照你写的那样去执行的。处理器在进行指令重排的时候，考虑：数据之间的依赖性！

读写理解

volatile修饰的变量进行写操作的时候会使用CPU提供的Lock前缀指令 来实现上面说的读写理解功能

1、调用自定义同步器的tryAcquire()尝试直接去获取资源，如果成功则直接返回；
2、没成功，则addWaiter()将该线程以CAS方式加入等待队列的尾部，并标记为独占模式；
3、acquireQueued()使线程在等待队列中休息，有机会时（轮到自己，会被unpark()，用到线程阻塞工具类LockSupport）会去尝试获取资源。获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。
4、如果线程在等待过程中被中断过，它是不响应的。只是获取资源后才再进行自我中断selfInterrupt()，将中断补上。
5、每个等待线程都进入到自旋状态了 这点需明白。

release()是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源tryRelease，如果彻底释放了（即state=0）,它会唤醒等待队列里的后面最近能用的线程来获取资源。

tryAcquireShared()需自己实现不过返回值中负值代表获取失败；0代表获取成功，但没有剩余资源；正数表示获取成功，还有剩余资源，其他线程还可以去获取

1、tryAcquireShared()尝试获取资源，成功则直接返回；
2、失败则通过doAcquireShared()进入等待队列park()，直到被unpark()/interrupt()并成功获取到资源才返回。整个等待过程也是忽略中断的。
3、其实跟acquire()的流程大同小异，只不过多了个自己拿到资源后，还会去唤醒后继队友的操作（这才是共享嘛）。

releaseShared() ：释放掉资源后，唤醒后继。后面的需要5个如果只有空闲4个还是会继续等待资源。

1. 在AQS 同步队列中 -1 表示线程在睡眠状态
2. 当前Node节点线程会把前一个Node.ws = -1。当前节点把前面节点ws设置为-1，你可以理解为：你自己能知道自己睡着了吗？ 只能是别人看到了发现你睡眠了！
3. 持有锁的线程永远不在队列中。
4. 在AQS队列中第二个才是最先排队的线程。
5. 如果是交替型任务或者单线程任务，即使用了Lock也不会涉及到AQS 队列。
6. 不到万不得已不要轻易park线程，很耗时的！所以排队的头线程会自旋的尝试几个获取锁。

多线程任务中我们可以new出多个等待任务队列，所以真正的AQS任务中一般是一个任务队列N个等待队列的。

ReentrantLock的锁是可重入的不管是公平锁还是非公平锁，我们以默认的非公平锁为例看下获取的状态。可以发现当进行可重入的时候锁的数据是不断增加的，同时当进行释放的时候锁的个数是不断减少的。

非公平：当前进程尝试获取锁的时候，如果发现锁的状态位是0的话就直接尝试将锁拿过来，然后setExclusiveOwnerThread，根本不管其他原因。

公平锁：当前进程来来后先看一看前面是否有前驱节点。

负数：表示进行初始化或者扩容，-1：表示正在初始化，-N：表示有 N-1 个线程正在进行扩容
正数：0 表示还没有被初始化，> 0的数：初始化或者是下一次进行扩容的阈值，有点类似HashMap中的threshold，不过功能更强大。

程序计数器：记录当前线程执行的字节码的行号指示器

Java栈(stack)：线程私有，生命周期跟线程，每个方法都会在执行的时候创建一个栈桢用来存储局部变量

本地方法栈：本地方法栈保存的是native方法信息，当一个JVM创建一个线程调用native方法后

堆(heap)：涉及到内存的分配 (new关键字，反射等)与回收(回收算法，收集器等)

方法区：也叫永久区，用于存储已经被虚拟机加载的类信息，常量 (“zdy”,"123"等)，静态变量(static变量)等数据

运行时常量池：方法区的一部分，用于存放编译期生成 的各种字面量(“zdy”,"123"等)和符号引用

在Java中用方法区(永久代)来存储类信息，常量，静态变量等数据不是好注意，因为这样很容易造成内存溢出。同时对永久代的性能调优也很困难，因此1.8以后引入了元空间来存储这些本来在方法区的东西，主要优势就是不在JVM机中占有空间了

不一定看对象经过了逃逸分析跟标亮替换后发现该变量只是用到方法区呢则JVM会自动优化，在栈上创建该对象

逃逸分析（Escape Analysis）：简单来讲就是，Java Hotspot 虚拟机可以分析新创建对象的使用范围，并决定是否在 Java 堆上分配内存

标量替换：JVM通过逃逸分析确定该对象不会被外部访问。那就通过将该对象标量替换分解在栈上分配内存，这样该对象所占用的内存空间就可以随栈帧出栈而销毁，就减轻了垃圾回收的压力。

虽然经过逃逸分析可以做标量替换、栈上分配、和锁消除。但是逃逸分析自身也是需要进行一系列复杂的分析的，这其实也是一个相对耗时的过程。如果对象经过层层分析后发现 无法进行逃逸分析优化则反而耗时了，因此慎用。

1、第一部分Mark word 8个字节 用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。
2、另外一部分是class pointer 类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，默认压缩4字节，不压缩则8字节

JVM要求对象大小为8字节倍数，如果不满足则填充

使用句柄访问的话，那么Java堆中将会划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息。类似一个中间件

使用直接指针访问， reference中存储的直接就是对象地址。

1、当一个对象到 GC Roots 没有任何引用链相连时，则判断该对象不可达。只是不可达还未宣判死亡

2、第一次标记和筛选 将需要执行finalize() 的对象放到一个 待处理队列中 让第二次标记筛选处理

3、当对象经过了第一次的标记 & 筛选，会被进行第二次标记 & 准备被进行 筛选

流程图

可作为GC Roots 的对象

弱引用跟强引用 应用到 ThreadLocal底层内存泄露

Eden Space（伊甸园） 跟 Survivor Space（分别叫from和to） 默认比例为8:1:1

默认16次存活 才放到年老代，

各种GC器

新生代

老年代

划时代的 CMS

jdk1.7跟1.8 默认垃圾收集器Parallel Scavenge（新生代）+Parallel Old（老年代）

jdk1.9 默认垃圾收集器G1

G1

 JDK11 ZGC

查找并加载类的二进制数据

1、通过一个类的全限定名来获取其定义的二进制字节流。
​2、将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
3、在Java堆中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口。

2.1、验证（Verification）

2.2、准备（Preparation）

2.3、解析（Resolution）

前面在加载类阶段 用户应用程序可以通过自定义类加载器参与之外其余动作完全由虚拟机主导和控制。

真正开始执行类中定义的Java程序代码，执行程序员通过程序制定的主观计划去初始化类变量和其他资源 = 编译器收集 类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的

日常使用

1、执行了System.exit()方法
2、程序正常执行结束
3、程序在执行过程中遇到了异常或错误而异常终止
4、由于操作系统出现错误而导致Java虚拟机进程终止

1、loadClass() ： 加载目标类的入口，它首先会查找当前 ClassLoader 以及它的双亲里面是否已经加载了目标类，找到直接返回
2、findClass() ： 如果没有找到就会让双亲尝试加载，如果双亲都加载不了，就会调用 findClass() 让自定义加载器自己来加载目标类
3、defineClass() ： 拿到这个字节码之后再调用 defineClass() 方法将字节码转换成 Class 对象。

定义：当某个类加载器需要加载某个.class文件时，首先把这个任务委托给他的上级类加载器，递归这个操作，如果上级的类加载器没有加载，自己才会去加载这个类。

作用：
1、可以防止重复加载同一个.class。通过委托去向上面问一问，加载过了，就不用再加载一遍。保证数据安全。
2、保证核心*.class不能被篡改,通过委托方式，不会去篡改核心.class

常见加载器

双亲委派机制只是Java类加载的一种模式，但是当我们使用一些第三方框架的时候比如JDBC跟具体实现的时候，反而会引发错误，因为JDK自带的JDBC接口由启动类加载，而第三方实现接口由应用类加载。这样相互之间是不认识的，因此JDK引入了线程上下文加载器来实现用同一个加载器加载。

Tomcat 总是先尝试去加载某个类，如果找不到再用上一级的加载器，这跟一般类加载器顺序正好相反。

用 javap -c *.class 看下底层

编译期确定下来的调用对象

运行期确定下来的调用对象，类似C++中的多态：多态的实现机制就是父类跟子类各自有一个方法表，然后会选择性调用

CDN ：联想到京东物流存储系统， 本质是将媒体资源、图片资源、HTML、CSS、JS内容缓存到距离用户更近的互联网数据中心（Internet Data Center，简称IDC），让用户进行资源共享，实现缩减响应时间请求。

Client 模式：当虚拟机运行在-client 模式的时候，启动快，使用的是一个代号为 C1 的轻量级编译器

Server 模式：–server 模式启动的虚拟机采用相对重量级代号为 C2 的编译器。速度较慢，但是一旦运行起来后，性能将会有很大的提升。C2 比 C1 编译器编译的相对彻底，服务起来之后，性能更高。

public void SetAge(int age){
this.age = age
}
-------JIT 优化后直接就是 如下，避免类方法调用。
this.age = age 

GC时间够少
GC次数够少

1、选择合适的GC回收器来组合。
2、选择合适的堆大小。
3、选择合适年轻代在堆中的比例。
4、尽可能减少full GC 的发生跟耗时。

1、minor GC 单次小于50ms，频率10秒以上。说明年轻代OK。
2、Full GC 单次小于1秒一下，频率10分钟以上，说明年老代OK。

-Xms5m设置JVM初始堆为5M，-Xmx5m设置JVM最大堆为5M。-Xms跟-Xmx值一样时可以避免每次垃圾回收完成后JVM重新分配内存。
-Xmn2g:设置年轻代大小为2G，一般默认为整个堆区的1/3 ~ 1/4。-Xss每个线程栈空间设置。
-XX:SurvivorRatio，设置年轻代中Eden区与Survivor区的比值，默认=8，比值为8:1:1。
-XX:+HeapDumpOnOutOfMemoryError 当JVM发生OOM时，自动生成DUMP文件。
-XX:PretenureSizeThreshold 当创建的对象超过指定大小时，直接把对象分配在老年代。
-XX:MaxTenuringThreshold 设定对象在Survivor区最大年龄阈值，超过阈值转移到老年代，默认15。
开启GC日志对性能影响很小且能帮助我们定位问题，-XX:+PrintGCTimeStamps -XX:+PrintGCDetails -Xloggc:gc.log

常用策略

Server层

存储引擎层

redo log

binlog（归档日志）

redo log 跟binlog 区别

还有个undo log 用于事务回滚的，记录的意思都跟用户提交的SQL 方向相反。 在MVCC中用到

脏读（dirty read）：B事务更改数据还未提交，A事务已经看到并且用了。B事务如果回滚，则A事务做错了

不可重复读（non-repeatable read）：不可重复读的重点是修改: 同样的条件, 你读取过的数据, 再次读取出来发现值不一样了，只需要锁住满足条件的记录

幻读（phantom read）

你隔离得越严实，效率就会越低。因此很多时候，我们都要在二者之间寻找一个平衡点。SQL标准的事务隔离级别由低到高

快照读 跟 当前读 ：RR级别下的当前读会出现不可重复读问题，而快照读不会出现不可重复读问题

读未提交：别人改数据的事务尚未提交，我在我的事务中也能读到。

读已提交(Oracle默认)：别人改数据的事务已经提交，我在我的事务中才能读到。

可重复读(MySQL默认)：别人改数据的事务已经提交，我在我的事务中也不去读，以此保证重复读一致性。

串行：我的事务尚未提交，别人就别想改数据。

begin 或 start transaction。配套的提交语句是commit，回滚语句是rollback

set autocommit=0，这个命令会将这个线程的自动提交关掉。意味着如果你只执行一个select语句，这个事务就启动了，而且并不会自动提交。这个事务持续存在直到你主动执行commit 或 rollback 语句，或者断开连接。

应用端

数据库端

长事务意味着系统里面会存在很老的事务视图。由于这些事务随时可能访问数据库里面的任何数据，所以这个事务提交之前，数据库里面它可能用到的回滚记录都必须保留，这就会导致大量占用存储空间。长事务还占用锁资源，也可能拖垮整个库。

读-读：不存在任何问题，也不需要并发控制

读-写：有隔离性问题，可能遇到脏读，幻读，不可重复读

写-写：可能存更新丢失问题，比如第一类更新丢失，第二类更新丢失

手动 lock tables … read/write

表级的锁是MDL（metadata lock)，自动开启。

在InnoDB事务中，行锁是在需要的时候才加上的，但并不是不需要了就立刻释放，而是要等到事务结束时才释放。这个就是两阶段锁协议。如果你的事务中需要锁多个行，要把最可能造成锁冲突、最可能影响并发度的锁尽量往后放。

死锁和死锁检测

行锁：共享锁跟排它锁

悲观并发控制 Pessimistic Concurrency Control 采用一种持悲观消极的态度，先取锁再访问

乐观并发控制 Optimistic Concurrency Control 乐观锁是假设认为即使在并发环境中，外界对数据的操作一般是不会造成冲突，实现原理跟JUC中的CAS类似。

在数据库中，形成经典两个组合

InnoDB 三个log

三个重要信息 3个隐式字段(rowid,insertid,deleteid)，undo日志 ，(快照读视图)Read View 

工作原理：可以认为当delete一条记录时，undo log中会反向思维的记录一条对应的insert记录，反之亦然，当update一条记录时，它记录一条对应相反的update记录。
这种情况下当执行rollback时，就可以从undo log中的逻辑记录读取到相应的内容并进行回滚。有时候应用到行版本控制的时候，也是通过undo log来实现的：当读取的某一行被其他事务锁定时，它可以从undo log中分析出该行记录以前的数据是什么，从而提供该行版本信息，让用户实现非锁定一致性读取。

1、普通记录的删除只是标记位删除，只有符合条件的新记录才可以用该空洞。

2、删除数据页只是标记整个页为可用，但磁盘文件的大小是不会变的。也就是说，通过delete命令是不能回收表空间的。

alter table t engine = InnoDB

DBA 推荐 Github：gh-ost

count聚合函数的遍历整个表，判断不是NULL，累计值就加1，否则不加。最后返回累计值。

统计原则

MySQL设计思想：如果内存够，就要多利用内存，尽量减少磁盘访问。

1、从一般索引找到满足条件的数据，然后找到对应的主键索引位置，取出所需信息存到sort_buffer。然后对sort_buffer排序。最终返回结果。如果sort_buffer空间不够还需要将数据切分若干份存到磁盘，然后用归并排序。
3、有时候 max_length_for_sort_data 不满足条件还会出发 rowid，浪费点是多一次主键索引访问。
4、可以权衡的用联合索引跟覆盖索引来实现必要查询，当然前提是要考虑维护成本。

rowid：对于有主键的InnoDB表来说，这个rowid就是系统生成的6字节主键ID；

order by rand()

逐步优化的随机读

Hash表：等值查询

有序数组：适用于静态存储索引，插入让人头疼

搜索树：B+ 树

数据都存储在主键索引的叶子节点

聚集索引：主键索引

非聚集索引：触发回表

索引维护

预跑sql  explain

排除 缓存 sql nocache

有时候MySQL的优化器选择索引会出错

存在回表的情况：尝试用覆盖索引优化

联合索引 

给字符串加索引的建议

数据库的flush的时机

索引字段不要做函数操作，会破坏索引值的有序性，优化器会放弃走树结构，如果触发隐式转换 那也会走cast函数 会放弃走索引

饮鸩止渴的短时优化方案

mysql io性能瓶颈

关于主键操作

三大范式

普通索引 还是唯一索引

索引使用原则

更新

1、如果可以使用被驱动表的索引，join语句还是有其优势的；

2、如果不能使用被驱动表的索引，只能使用Block Nested-Loop Join算法，这样的语句就尽量不要使用；

3、在使用join的时候，应该让小表做驱动表。

4、在决定哪个表做驱动表的时候，应该是两个表按照各自的条件过滤，过滤完成之后，计算参与join的各个字段的总数据量，数据量小的那个表，就是“小表”，应该作为驱动表

1、无索引的原始连表join：Simple Nested-Loop Join，完全暴力两个嵌套循环查找。
2、无索引的连表join优化：Block Nested-Loop Join(BNL)，驱动表引入了 join_buffer(暂存驱动表的数据)。
3、有索引的连表join：Index Nested-Loop Join(NLJ)。从驱动表一行行拿出数据然后从被驱动表通过索引查询。
4、Batched Key Acess(BKA) ：先引入 Multi-Range Read实现主键无序查询变为有序查询。然后批量拿数据(join_buffer)从被驱动表匹配数据，属于NLJ优化。
5、BNL算法 被驱动表是大表的时候 可能会多次扫描被驱动表，占用磁盘IO资源；判断join条件需要执行M*N次对比占用CPU资源大，可能会导致Buffer Pool的热数据被淘汰，影响内存命中率。explain 加索引，BNL转BKA
6、让join语句能够用上被驱动表上的索引，来触发BKA算法，提升查询性能。
7、业务端获取所需数据后 自己实现hashjoin

临时表：用于处理比较复杂的计算逻辑。由于临时表是每个线程自己可见的，所以不需要考虑多个线程执行同一个处理逻辑时，临时表的重名问题。在线程退出的时候，临时表也能自动删除，省去了收尾和异常处理的工作。

特色

存储过程可以看成是对一系列 SQL 操作的批处理

ShardingSphere 是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy 和 Sharding-Sidecar这3款相互独立的产品组成。

他们均提供标准化的数据分片、分布式事务 和 数据库治理功能，可适用于如Java同构、异构语言、云原生等各种多样化的应用场景。

MySQL基础巩固

按照 UserId 分库分表后想根据UserName查询信息咋办。
1. 建立 userName 跟 UserId 映射的中间表。
2. 把1的数据存储到redis缓存中。
3. userName通过fun函数生成UserId，函数质量要高。
4. userName基因融入userId，64UserId = 61位UserId + UserName生成的

分库引入的分布式事务
分库引入的跨库跨表join。
额外的数据管理跟数据运算。

适用

不适用

图形化监控方案 RedisLive

功能：误差允许范围内做基数统计set的时候非常有用，每个HyperLogLog的键可以计算接近2^64不同元素的基数，而大小只需要12KB。错误率大概在0.81%

底层理论

用法

但是一般较少使用，如果真需要发布订阅功能引入专业的消息中间件即可，比如RabbitMQ、ActiveMQ、Kafka等

GeoHash算法，再往深入说就是GIS了

bitMap是位图，其实准确的来说，翻译成基于位的映射

当list对象的所有字符串元素长度都小于64字节，并且保存的元素数量小于512个时，使用压缩列表
如果不满足上述条件中的任意一个，都会使用链表

在redis里面是采用SDS(simple dynamic string)来封装char[]的，这个也是redis存储的最小单元

String： 当我们 set name blog 时，redis其实会创建两个RedisObject对象， 键的RedisObject 和 值的RedisOjbect 其中它们的type=REDIS_STRING。源代码在sds.h

List：底层数据格式为双向链表，可用来实现简单的任务队列等，源代码是在adlist.c，K=RedisObject String 类型，Value = String类型的双向链表

Set：底层是个HashTable 可以认为是上面Hash的简单版

字典Hash

Zset

*3
$3
set
$4
name
$4
alex

给key设置过期定时器，该策略可自动删除过期数据，但占用太多资源处理过期数据，影响缓存响应时间跟吞吐量。

访问时才判断key是否过期了，该策略可大大优化CPU资源，但是对内存不友好，存在大量占用内存情况。

expires字典会保存所有设置了过期时间的key的过期时间数据，其中，key是指向键空间中的某个键的指针，value是该键的毫秒精度的UNIX时间戳表示的过期时间。键空间是指该Redis集群中保存的所有键。

前两者的一个折中方案，隔一段时间就扫描expires来清理其中过期key。通过调整定时扫描的时间间隔和每次扫描的限定耗时，可以在不同情况下使得CPU和内存资源达到最优的平衡效果。

pipeline 批量执行 以此加速

1、Redis 事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令。
2、Redis事务没有隔离级别的概念：
3、Redis不保证原子性：
4、 multi exec  discard

多路网络连接复用一个io线程

select、poll、epoll

RDB 默认

AOF

主从同步

快照同步

单机问题：机器故障、容量瓶颈、QPS瓶颈。

1、Redis主从复制：全量同步跟增量同步，但是master挂掉后如何保证Redis还可用？

2、Redis哨兵(Sentinel)：监控多个master-slave集群，发现master宕机后能进行自动切换,实现高可用。

3、redis-cluster集群部署：每个主节点通过哨兵机制监控安排了从节点，利用哈希槽(2^14)分配数据存储。

RedLock：分布式锁

Redis 集群扩容

现象：大批量key在同一时间同时失效导致所有请求都打到了MySQL

解决方法：

现象：大并发集中对这一个热点key进行访问，当这个Key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库。

解决方法：设置热点数据永远不过期。加互斥锁来访问DB

现象：缓存和数据库中都没有的数据，而用户不断发起请求，比如 id = -1这样请求

解决方法

事前：Redis 高可用，主从+哨兵，Redis cluster，避免全盘崩溃。

事中：本地 ehcache 缓存 + Hystrix 限流 + 降级，避免MySQL 被打死。

事后：Redis 持久化 RDB+AOF，一旦重启，自动从磁盘上加载数据，快速恢复缓存数据。

双写：缓存跟数据库均写入数据，如何保证数据一致性。串行化可实现但是容易阻塞。

Cache Aside Pattern：

分布式锁

bigkey命令 找到干掉

缓存时间不失效

多级缓存

布隆过滤器

读写分离

1、恒定速率往容器中放入令牌token。List leftPop
2、请求来容器中拿令牌，拿到说明没超出限制，拿不到说明超出限制。
3、能够限制数据的平均传输速率，允许某种程度的突发传输。
4、空轮询、重试。
5、可能出现瞬间并发高现象 

目的：控制数据注入到网络的速率

实现：请求以任意速率流入桶中，桶满则拒绝接受请求，按照固定速率流出消耗请求。

狂神说B站教程 或 mybatis 中文官网即可

collection

association

FIFO

LFU

LRU默认

一级缓存是指 SqlSession 级别的缓存

二级缓存是指可以跨 SqlSession 的缓存。是 mapper 级别的缓存

插入

更新

乐观锁

查询/分页查询

删除/逻辑删除

性能分析插件

条件构造器 QueryWrapper

代码自动生成器 AutoGenerator

Proxy 跟 InvocationHandler

Cglib

1.前置通知
2.环绕通知
3.后置通知
4.异常通知
5.最终通知

顺序

聊1小时AOP

1. singletonObjects，一级缓存，存储的是所有创建好了的单例Bean

2. earlySingletonObjects，完成实例化，但是还未进行属性注入及初始化的对象

3. singletonFactories，提前暴露的一个单例工厂，二级缓存中存储的就是从这个工厂中获取到的对象

Spring Boot 基于 Spring 开发，Spirng Boot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发者体验的工具。Spring Boot 以约定大于配置核心思想开展工作

急速上手

父依赖，版本仲裁

spring-boot-starter 跟 spring-boot-starter-xxx

META-INF/spring.factories 各种各样的autoconfigure 具体可看第五节原理分析

以数据为中心

1、SpringBoot启动会加载大量的自动配置类

2、我们看我们需要的功能有没有在SpringBoot默认写好的自动配置类当中；

3、我们再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件存在在其中，我们就不需要再手动配置了）

4、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们只需要在配置文件中指定这些属性的值即可；

5、xxxxAutoConfigurartion：自动配置类；给容器中添加组件

6、xxxxProperties:封装配置文件中相关属性；

相对来说根据上一章节操作即可，可以选择性的定制化一些东西

1、网页访问/webjars/** 会在 classpath:/META-INF/resources/webjars/ 找资源

2、网页访问"/**" 访问当前项目的任何资源，都去（静态资源的文件夹）找映射

3、欢迎页； 静态资源文件夹下的所有index.html页面；被"/**"映射；

4、favicon.ico ：所有的 **/favicon.ico 都是在静态资源文件下找；

模板引擎意义：后台处理好的数据 + 模板引擎 = 前端最终展示页面

Thymyleaf

SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配置的（如果用户自己配置@bean），如果有就用用户配置的，如果没有就用自动配置的

子主题

可以自定义一些MVC组件然后跟系统组件拼装起来一起用，谨慎使用@EnableWebMvc

整体来说没啥特别难的，都是百度配置即可，主要是找好看的UI(bootstrap) 然后设置中英文切换按钮

HandlerInterceptor 的子类实现跟注册

Servlet、Filter、Listener 功能的实现

Spring Data的使命是为数据访问提供熟悉且一致的基于Spring的编程模型，同时仍保留底层数据存储的特​​殊特性。

Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控，如何整合 如何配置查看 SQL查询

整合MyBatis

功能：实现 用户认证（Authentication）和用户授权（Authorization）

相比 Shiro更加简单方便，添加若干配置即可完成权限配置。

1、引入Shrio必备依赖
2、自定义实现Realm用户登陆跟权限认证。
3、编写ShiroConfig实现Realm、SecurityManager、ShiroFilterFactoryBean三个必备组件到集成。
4、相比Spring Security 复杂一些可定制化更多一点。

前后端交互文档，定制化文档，多文档，开发环境记得关闭

比较简单 会用即可

方志朋SpringBoot 各种整合三方

解决方案

1、集群式服务对外网关如何提供

2、服务之间如何通讯，RPC还是HTTP

3、服务之间如何治理，注册跟发现

4、服务熔断跟降级如何处理

优点

缺点

SpringCloud简介

官网

 SpringCloud：采用HTTP的REST方式调用，定位是微服务架构下一站式解决方案。

Dubbo：RPC通讯，存在代码级别强依赖，Dubbo的定位是一款RPC框架。

1、导入依赖

2、编写配置文件

3、开启这个功能@EnableXXX

4、配置类

Eureka (由蕊卡)

负载均衡(load balance)

Hystrix：服务熔断

Zuul 路由网关

SpringCloud Config

Spring Cloud Bus

Spring Cloud Zipkin

1、解决分布式系统中，服务之间的调用问题。
2、远程调用时，要能够像本地调用一样方便，让调用者感知不到远程调用的逻辑。

RPC 框架所需部件：约定要通信协议，序列化的格式、一些容错机制、负载均衡策略、监控运维和一个注册中心！

官网：http://dubbo.apache.org/zh-cn/

Dubbo 分层架构

Dubbo调用过程

全称 Service Provider Interface，是一种服务发现机制。约定在 Classpath 下的 META-INF/services/ 目录里创建一个以服务接口命名的文件，然后文件里面记录的是此 jar 包提供的具体实现类的全限定名
当引用了某个 jar 包的时候就可以去找这个 jar 包的 META-INF/services/ 目录，再根据接口名找到文件，然后读取文件里面的内容去进行实现类的加载与实例化

简单的说就是先找当前线程绑定的 ClassLoader，如果没有就用 SystemClassLoader，然后清除一下缓存，再创建一个 LazyIterator。

通过 ExtensionLoader，我们可以加载指定的实现类，类似 Java SPI 中 ServiceLoader 的存在。

Adaptive 注解 - 自适应扩展

Dubbo 就是采用 URL 的方式来作为约定的参数类型，被称为公共契约， Dubbo 用 URL 作为配置总线，贯穿整个体系

protocol://username:password@host:port/path?key=value&key=value

Dubbo 利用了 Spring 配置文件扩展了自定义的解析xml

代码的流程

从对象构建转换的角度

服务暴露的过程起始于 Spring IOC 容器刷新完成之时 ServiceBean ，具体的流程就是根据配置拼接 URL，再利用 Dubbo SPI 机制根据 URL 的参数选择对应的实现类，实现扩展。

通过 javassist 动态封装 ref (你写的服务实现类)，统一暴露出 Invoker 使得调用方便，屏蔽底层实现细节，然后封装成 exporter 存储起来，等待消费者的调用，并且会将 URL 注册到注册中心，使得消费者可以获取服务提供者的信息。

饿汉式：通过实现 Spring 的InitializingBean接口中的 afterPropertiesSet方法，容器通过调用 ReferenceBean的 afterPropertiesSet方法时引入服务

懒汉式：懒汉式是只有当这个服务被注入到其他类中时启动引入流程，也就是说用到了才会开始服务引入。

BeanFactory： IOC 容器，具有多种实现类， Spring 里面的 Bean 都归它管
FactoryBean：也是一个Bean，但是可以把所需Bean封装一层做复杂组装操作，通过getObject()获取Bean。
ObjectFactory ：用于延迟查找的场景，只有当getObject()方法时，才会触发 Bean 实例化等生命周期。

本地引入：服务暴露时本地暴露，避免网络调用开销。

直接连接引入远程服务：不启动注册中心，直接写死远程Provider地址 进行直连。

通过注册中心引入远程服务：通过注册中心抉择如何进行负载均衡调用远程服务。

服务引入源码跟踪

固定长度形式：固定长度读协议，后面读数据，效率高但是存在浪费。

特殊字符隔断形式：优点是长度自由，缺点就是需要一直读，直到读到一个完整的协议单元之后才能开始解析

header+body 形式：头部是固定长度的，然后头部里面会填写 body 的长度， body 是不固定长度的，这样伸缩性就比较好了，可以先解析头部，然后根据头部得到 body 的 len 然后解析 body。Dubbo采用此方式

约定序列化器，序列化大致分为两大类，一种是字符型(XML或json 人可看懂 传输效率低)，一种是二进制流(数据紧凑，机器友好)。默认使用hessian2。

oneway:不关心请求是否发送成功，消耗最小。

异步调用Async：Dubbo天然异步，客户端调用请求后将返回的ResponseFuture存到上下文中，用户可以随时调用future.get获取结果。

同步调用sync : 在 Dubbo 源码中就调用了 future.get，用户感觉方法被阻塞了，必须等结果后才返回。

默认全部都会进入线程池

1. 首先客户端调用接口的某个方法，实际调用的是代理类，代理类会通过 cluster 从 directory 中获取一堆 invokers(如果有一堆的话)，然后进行 router 的过滤（其中看配置也会添加 mockInvoker 用于服务降级），然后再通过 SPI 得到 loadBalance 进行一波负载均衡。默认的 cluster 是 FailoverCluster ，会进行容错重试处理
2. 现在我们已经得到要调用的远程服务对应的 invoker 了，此时根据具体的协议构造请求头，然后将参数根据具体的序列化协议序列化之后构造塞入请求体中，再通过 NettyClient 发起远程调用。
3. 服务端 NettyServer 收到请求之后，根据协议得到信息并且反序列化成对象，再按照派发策略派发消息，默认是 All，扔给业务线程池。
4. 业务线程会根据消息类型判断然后得到 serviceKey 从之前服务暴露生成的 exporterMap 中得到对应的 Invoker ，然后调用真实的实现类。
5. 最终将结果返回，因为请求和响应都有一个统一的 ID， 客户端根据响应的 ID 找到存储起来的 Future， 然后塞入响应再唤醒等待 future 的线程，完成一次远程调用全过程。

将能调用的服务的对象都封装成 invoker

类似服务的目录，通过这个目录来查找远程服务，实际是一堆invoker集合。同样的服务可能有多个提供者。还实现了监听注册中心的功能（指的是RegistryDirectory ）

RegistryDirectory

StaticDirectory

条件路由 ConditionRouter (常用)

脚本路由 ScriptRouter

标签路由 TagRouter

是一个中间层，为消费者屏蔽了服务提供者的情况，简化了消费者的使用，并且也更加方便的替换各种集群容错措施。

架构师初始思维：没有什么是加一层解决不了滴

RandomLoadBalance(默认)：加权随机
LeastActiveLoadBalance：最少活跃数负载均衡
ConsistentHashLoadBalance：一致性 Hash 负载均衡算法
RoundRobinLoadBalance：加权轮询到平滑加权轮询

自我实现RPC 重要点

进行DNS解析操作，根据DNS解析的结果查到服务器IP地址
通过ip寻址和arp，找到服务器，并利用三次握手建立TCP连接
浏览器生成HTTP报文，发送HTTP请求，等待服务器响应
服务器处理请求，并返回给浏览器
根据HTTP是否开启长连接，进行TCP的挥手过程
浏览器根据收到的静态资源进行页面渲染

1、数据的封装跟解封
2、链路管理，自动处理错误帧数据。
3、编码与译码，数据加工发到网络，接受网络数据解析。

Media Access Control(MAC)地址是6字节数据烧录在网卡上的，MAC地址跟身份证号一样具有全球唯一性。

一般特指能够实现路由寻找和转发的特定类产品，路由器很显然能够实现网关的功能

（1）网络互连，实现不同网络互相通信
（2）数据处理，提供分组过滤转发、优先级、防火墙等功能
（3）网络管理，提供配置管理、性能管理、流量控制等功能

原理: 固定统一的通信协议TCP/IP

猫：学名宽带无线猫

路由器做了2个普通交换机做不了的

MQ发送响应信息给生产者

Kafka分区策略

收集、存储、建模、分析、变现

定位方向

一致性（Consistency）

可用性（Availability）

分区容错性（Partition Tolerance）

一般情况下P必须要，大部分时候都在AC之前抉择平衡

我们说，CAP 不可能同时满足，而分区容错是对于分布式系统而言，是必须的。最后，我们说，如果系统能够同时实现 CAP 是再好不过的了，所以出现了 BASE 理论，今天就来讲讲 Base 理论。

BASE：全称：Basically Available(基本可用)，Soft state（软状态）,和 Eventually consistent（最终一致性）

Basically Available(基本可用)

Soft state（软状态）

Eventually consistent（最终一致性）

总结

2PC(Two-Phase Commit)可认为是一种算法协议。目的是为保证分布式系统数据一致性。

顾名思义，二阶段提交就是将事务的提交过程分成了两个阶段来进行处理

优缺点

TCC解决分布式事物的思路是，一个大事务拆解成多个小事务。

原本一个方法，现在却需要三个方法来支持，可以看到 TCC 对业务的侵入性很强，而且这种模式并不能很好地被复用，会导致开发量激增。还要考虑到网络波动等原因，为保证请求一定送达都会有重试机制，所以考虑到接口的幂等性。

科技哥：分布式事务

3PC，全称 three phase commit，是 2PC 的改进版，其将 2PC 的 提交事务请求 过程一分为二。

三个阶段

优缺点

Paxos 的目标：保证最终有一个提案会被选定，当提案被选定后，其他议员最终也能获取到被选定的提案。

Paxos 协议用来解决的问题可以用一句话来简化： 将所有节点都写入同一个值，且被写入后不再更改。

目标就是成为一个易于理解的一致性算法。以替代 Paxos 的晦涩难懂。

组成

挺好玩的在线demo

小灰通俗说 Raft

参考ZooKeeper中讲解 

主要是对IP进行hashcode的求值，然后可能涉及到虚拟节点来均衡映射

计算机网络中所存在的一致性问题。如何解决呢？ 存在某个节点故意传播坏消息的情况下

解决一致性的一种方法比如 Raft算法 或者 Paxos算法 ZAB算法等

1、简单数据存储结构：共享的树形结构，存储于内存。
2、可以构建集群：避免单点故障，超过半数即可工作。
3、顺序访问：对于读请求zk分配ZXID保证递增性，实现高级协调服务。
4、高性能：基于内存操作 3台QPS可达13W+。

分布式系统配置文件写入Znode，一旦Znode修改通知各个客户端服务器。

分布式系统实时掌握大数据集群节点状态。Hadoop、Kafka等。

启动服务后注册到zk集群，服务出现任何变化客户端可实时感知到。

zk中记录集群中节点访问次数，最少访问服务器处理最新请求。

分布式环境对应用服务统一命名，便于识别。

选举流程知识点

其他的增删改查节点操作 百度命令即可

写过程

消息广播

崩溃恢复

总结

服务启动时候往zk中注册下

调用该服务的从zk中获取指定目录，然后监控数据变化，实时更改可用服务池实现 服务的注册跟发现

核心思想：在zk中有一个唯一的临时节点，只有拿到节点的才可以操作数据，没拿到就需要等待。

第一种实现

第二种实现

相比来说 Redis的分布式锁性能更加好一些，完全基于内存不涉及节点的创建跟删除

思想几乎跟负载均衡一样

比如mybatis通过URL访问mysql，我们通过动态的修改URL实现从访问A数据库到访问B数据库的切换。核心就监听 dataChange。

zk客户端是异步的哦！需要引入CountDownLatch 来确保连接好了再做下面操作。zk 原生api是不支持迭代式的创建跟删除路径的

优化一、在session loss和session expire时自动创建新的ZooKeeper实例进行重连。

优化二、将一次性watcher包装为持久watcher

是Netflix公司开源的一套Zookeeper客户端框架。了解过Zookeeper原生API都会清楚其复杂度。Curator帮助我们在其基础上进行封装、实现一些开发细节，包括接连重连、反复注册Watcher和NodeExistsException等。目前已经作为Apache的顶级项目出现，是最流行的Zookeeper客户端之一

1、平台组：平台环境搭建、集群性能监控及调优。
2、数仓组：ETL工程师、数仓建模
3、数据挖掘组：算法、推荐、用户画像
4、报表开发组：Java开发工程师

Hadoop 部署方式

各种细节思维导图

Google 论文 及GFS延伸出了HDFS（Distributed File System）

特性

是一个分布式运算程序的编程框架，核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个hadoop集群上。

注意点总结

reduce  join

map join

Yarn是一个资源调度平台，负责为运算程序提供服务器运算资源，相当于一个分布式的操作系统平台，而mapreduce等运算程序则相当于运行于操作系统之上的应用程序。在Hadoop2.* 版本中出现

作业调度平台

HDFS HA功能通过配置Active/Standby两个nameNodes实现在集群中对NameNode的热备来解决上述问题。如果出现故障，如机器崩溃或机器需要升级维护，这时可通过此种方式将NameNode很快的切换到另外一台机器。

YARN HA

输入

map 阶段

Reduce阶段

IO阶段

数据倾斜问题

HDFS小文件

MapReduce任务慢

Hive处理的数据存储在HDFS
Hive分析数据底层的实现是MapReduce
执行程序运行在Yarn上

查询语言、数据存储位置、数据更新、索引、执行延时、可扩展性、数据规模、

语句demo

加载数据

数据导出

各种基本算子  max min avg 等

排序

case when 注意对应性

列转行

行转列

需求：既显示聚集前的数据,又要显示聚集后的数据,这时我们便引入了窗口函数.

注意：在SQL处理中，窗口函数都是最后一步执行，而且仅位于Order by字句之前.

rank()：排序相同时会重复，总数不会变
dense_rank()：排序相同时会重复，总数会减少
row_number()：会根据顺序计算

1、查看系统自带的函数 ：show functions
2、详细显示自带函数用法：desc function extended upper;

1、UDF（User-Defined-Function）：一进一出 类似upper，trim
2、UDAF（User-Defined Aggregation Function）: 聚集函数，多进一出 类似count/max/min
3、UDTF（User-Defined Table-Generating Functions）: 一进多出 比如 lateral view explore()

可尝试开启map阶段压缩跟reduce阶段的压缩来提速

Hive支持的存储数的格式主要有：TEXTFILE 、SEQUENCEFILE、ORC、PARQUET。

行存储的特点

列存储的特点

列处理：在SELECT中，只拿需要的列，如果有，尽量使用分区过滤，少用SELECT *。

行处理：在分区剪裁中，当使用外关联时，如果将副表的过滤条件写在Where后面，那么就会先全表关联，之后再过滤

对分区表Insert数据时候，数据库自动会根据分区字段的值，将数据插入到相应的分区中，不过需要根据实际工作设置若干参数，比如分区最大值，HDFS最大文件数

通常情况下，作业会通过input的目录产生一个或者多个map任务

reduce优化

map优化

Hive会将一个查询转化成一个或者多个阶段，默认情况下，Hive一次只会执行一个阶段。

尝试开启并行执行，没有关联的阶段并行执行

hive提供了严格模式可以防止用户执行那些可能意想不到的不好的影响的查询

JVM重用是Hadoop调优参数的内容，其对Hive的性能具有非常大的影响

Hadoop采用了推测执行（Speculative Execution）机制，根据一定法则推测出拖后腿的任务，并为这样的任务启动个备份任务，让该任务与原始任务同时处理同一份数据，并最终选用最先成功运行完成任务的计算结果作为最终结果。

EXPLAIN [EXTENDED | DEPENDENCY | AUTHORIZATION] query

就是一款NoSQL数据库，面向列存储，用于存储处理海量数据。

HBase并不是足够快，而是数据量很大的时候它慢的不明显

传统关系型数据库 分表分库的概念存储 及行式存储不足

海量存储、列式存储(列族)、极易扩展、高并发IO、稀疏(针对灵活列)

1、Master:负责启动的时候分配Region到具体的RegionServer,数据的读写操作与master无关，不过涉及到DDL跟region的分割合并要用到。
2、RegionServer:在它上边有多个region。我们读写的数据就存储在Region中。
3、Region：它是表拆分出来的一部分，HBase是一个会自动切片的数据库。当数据库过高时，就会进行拆分。
4、HBase的数据存储是基于HDFS的，它是真正承载数据的载体。
5、Zookeeper：在集群中负责存储hbase:meata的位置存储信息，客户端在写数据时需要先读取元数据信息。

RegionServer详细说

Store 细节

1、Client：Client包含了访问Hbase的接口，另外Client还维护了对应的cache来加速Hbase的访问，比如cache的.META.元数据的信息。
2、Zookeeper：HBase通过Zookeeper来做master的高可用、RegionServer的监控、元数据的入口以及集群配置的维护等工作
3、Hmaster：主要负责负载均衡Region跟对应的DDL
4、HregionServer：直接对接用户的读写请求，是真正的干活的节点，处理客户端读写请求。
5、HDFS：提供元数据和表数据的底层分布式存储服务，数据多副本，保证的高可靠和高可用性

写原理

读原理

Flush 各种参数配置

flush 可以删除在同一个内存中的数据，flush只会操作当前内存。并且写入本地后 内存数据会丢失。
Major compaction 大合并时候会自动把所以数据排序删除旧数据。

删除记得先下线 再删除

HBase就把他当做大数据中的数据库即可，然后任何可以分析HBase的引擎比如MR，Hive，spark链接上HBase都可以实现控制。

MapReduce操作HBase

Hive操作HBase

Hmaster负责监控RegionServer的生命周期，均衡RegionServer的负载，如果Hmaster挂掉了，那么整个HBase集群将陷入不健康的状态，并且此时的工作状态并不会维持太久。所以HBase支持对Hmaster的高可用配置。

没预先分区绝对会数据倾斜。创建表的时候要设置好分区。根据就是数据大小跟机器规模

1. 手动设定预分区

2. 生成16进制序列预分区

3. 按照文件中设置的规则预分区

4. API 分区

设计rowkey的目的 ，让数据均匀的分布于所有的region中(散列性，唯一性，长度(生产中甚至可能70~100位))，在一定程度上防止数据倾斜。

HBase操作过程中需要大量的内存开销，但是不建议分配非常大的堆内存 RegionServer刷新会导致服务不可用

允许在HDFS的文件中追加内容、优化DataNode允许的最大文件打开数、优化数据的写入效率、设置RPC监听数量、优化hbase客户端缓存等等

核心思想：假设内存足够大，更改跟插入操作先写入内存。达到条件再flush磁盘(归并排序方式)。

读取时需先看是否命中内存，否则访问磁盘。写性能比MySQL高了一个数量级，读性能低了一个数量级

结构化合并树把一棵大树拆分成N棵小树，首先写入内存中，随着小树越来越大，内存中的小树会flush到磁盘中，磁盘中的树定期做merge成一棵大树，以优化读性能。

LSM 树解析

1、有 BlockCache 跟 MemCache 缓存功能。都找不到才加载HFile内容。
2、按照rowKey有序存储。HFile文件按页存储。
3、缓存 + 高效有序而复杂的数据存储

从非大数据集群（RDBMS）向大数据集群（HDFS，HIVE，HBASE）中传输数据，使用import关键字。

导出概念指：从大数据集群（HDFS，HIVE，HBASE）向非大数据集群（RDBMS）中传输数据，叫做：导出，即使用export关键字。

基本流程就是 Coordinator(协调者) 感知到 消费者组的变化，然后在心跳的过程中发送重平衡信号通知各个消费者离组，
然后消费者重新以 JoinGroup 方式加入 Coordinator，并选出Consumer Leader。
当所有消费者加入 Coordinator，Consumer Leader会根据 Coordinator给予的分区信息给出分区方案。
Coordinator 将该方案以 SyncGroup 的方式将该方案执行下去，通知各个消费者，这样就完成了一轮 重平衡了。

业务层、数据中台层、源数据层

1. 效率问题：应用开发增加个报表，因为数据源变化了。

2. 协作问题：业务开发逻辑类似，数据源不一样，重新梳理。

3. 能力问题：多个应用公开发人员，数据开发人员太少。

用运营方式经营数据中台，分析我们对外API调用的情况，及时调整改变优化数据服务，实现可经营化中台。

数据中台是企业级的逻辑概念，体现企业 D2V（Data to Value）的能力，为业务提供服务的主要方式是数据 API

数据中台距离业务更近，为业务提供速度更快的服务

数据中台可以建立在数据仓库和数据平台之上，是加速企业从数据到业务价值的过程的中间层

在大数据基础上出现的融合了结构化和非结构化数据的数据基础平台，为业务提供服务的方式主要是直接提供各种数据集，用户把所需数据集提取出来 单独分析建立模型

是一个相对具体的功能概念，是存储和管理一个或多个主题数据的集合，为业务提供服务的方式主要是分析报表

CPU

磁盘(硬盘)：访问数量级比CPU慢三个

总线（Bus）

主板（mainboard）

冯诺依曼计算机体系

BIOS自检

系统引导

启动内核

初始化系统

进程

地址空间

文件

shell （计算机壳层）

OS 提供了一套 可移植操作系统接口 POSIX，

虚拟内存

TLB（Translation Lookaside Buffer）

段页式内存管理

Linux 内存管理

进程Process

调度程序（scheduler）：目的就是要使得进程要「快」

线程 Thread

进程线程区别

功能：负责管理跟存储数据到磁盘中

Linux :一切皆文件

读写基本单位

虚拟文件系统（Virtual File System，VFS）

文件的存储

空闲空间管理

软链接和硬链接

文件 I/O

设备控制器（Device Control）

I/O 控制方式

设备驱动程序

通用块层

存储系统 I/O 软件分层

IO 多路复用

操作系统 - 哈工大

基本思维导图

生成器generator

Python中默认 __name__就是特殊变量，_xxx是非公开的，

@staticmethod和@classmethod

1、多进程：fork、multiprocessing、Pool，通讯Queue、Pipes。
2、多线程：threading、lock、伪多线程，GIL锁：Global Interpreter Lock，任何Python线程执行前，必须先获得GIL锁
3、正则表达式。

异步IO：执行耗时的IO操作时，只发出IO指令，不等待IO结果。然后去执行其他代码。协程概念思想。

jupyter lab 下一代的jupyter notebook

周志华 机器学习 西瓜书

1、微积分：主要用到了微分部分，作用是求函数的极值

2、线性代数：几乎所有地方都有使用

3、概率论：把机器学习所处理的样本数据看作随机变量/向量，我们就可以用概率论的观点对问题进行建模

4、最优化方法：几乎所有机器学习算法归根到底都是在求解最优化问题，指导思想是在极值点出函数的导数/梯度必须为0，必须理解梯度下降法，牛顿法，坐标下降法

白话大数据与机器学习

子主题

掷骰子、蒸馒头、图像卷积旋转、吃冰淇淋

连续形式

局部感知

参数共享

数据结构struct  的逻辑存储跟物理存储  

算法 Algorithm

冒泡排序 稳定

选择排序  不稳定

插入排序 稳定

希尔排序 不稳定

归并排序  稳定

快速排序 不稳定

堆排序 不稳定

计数排序

基数排序

桶排序

单链表

双向链表

循环链表

静态链表：使用数组模拟链表

特点：插入和删除限定为仅在一端进行，后进先出

子弹上膛、浏览器返回上一级

顺序栈：数组实现

链式栈： 链表实现

递归就是栈的应用

特点： 先进先出

普通队列：一端进 一端出

双端队列：两端均可进出

循环队列：数据存储成环，MySQL中的 redo log

阻塞队列：队列max有上线

优先队列：根据优先级执行

并发队列

子主题

功能：专门处理字符串匹配的数据结构

直接定址法
平方取中法
折叠法
除留取余法

链表法

开放寻址

这一块理解了 Java中的HashMap则一切尽在不言中

完全二叉树、满二叉树

哈夫曼树：路径之和最小化

二叉查找树 Binary Search Tree

平衡二叉树 Balanced Binary Tree

平衡二叉查找树

树跟森林的转换

B树

B+树

B*树

MySQL 底层存储

大根堆：父节点的值大于或等于子节点的值

小根堆：父节点的值小于或等于子节点的值

重要两个属性 ：节点Vertex、边Edge

1、邻接矩阵：一维数组存定点，二维数组存边。如果边少存在浪费。

2、邻接表：一维数组存定点，每个数组item后用链表连接到的边，可以有向图可以无向图。关注了出度就无法关注入度

3、十字链表：一个节点有出度链表跟入度链表，属于邻接表有向图的优化。

4、邻接多重表：关注无向边，属于邻接表无向图的优化。

5、边集数组：一个数组存节点信息，一个数组每个item存begin、end、weight

深度优先遍历：DFS(depth first search)

广度优先遍历：BFS(Breadth first search)

普里姆(Prim)算法

克鲁斯卡尔算法(Kruskal算法)

迪杰斯特拉（Dijkstra算法）

弗洛伊德算法:任意两顶点之间的最短路径

拓扑排序

工程关键路径

基本思路

存在问题

案例：活动安排、找零钱、背包、移动纸牌、最大整数

思想：分而治之

1、原问题可以分解为多个子问题
2、原问题在分解过程中，递归地求解子问题
3、在求解并得到各个子问题的解后应能够采用某种方式、方法合并或构造出原问题的解。

案例：二分查找法、归并排序、ForkJoin

回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。它是隐式地，通过递归，构建出一棵解的空间树

案例：八皇后、01背包问题、矩形最短路径问题

思想：将问题的所有可能的答案一一列举，然后根据条件判断此答案是否合适

案例：百钱买白鸡，在暴力解题的基础上看如何减少循环

斐波那契数组(兔子问题)优化、青蛙跳台阶、矩形组合、数字变化字母

经典最小路径和

剑指offer全集

小争哥 极客时间

Docker入门

容器数据卷

DockerFile

Docker网络

定义：

Compose 需单独安装

关键三个步骤

定义：

Raft协议

搭建集群、动态管理容器、启动服务

子主题

手段：集群部署，缓存CDN跟Redis，分库分表，TiDB ，降低IO，MQ，限流，HTTP池化跟线程池，JVM优化。

手段：Nginx/F5负载均衡，服务降级保证核心，进行熔断，心跳检测，接口幂等性，CPU/磁盘/网络/JVM/数据库监控体系。

手段：合理的业务分层，数据存储拆分，按照商品服务跟订单服务拆分，按照核心跟非核心拆分，请求资源TO C 还是 TO B，

理解正向代理跟反向代理的区别：正向代理代理的对象是客户端，反向代理代理的对象是服务端

ABC三台机器提供相同对外服务形成集群，Nginx是这个集群的代理，将用户请求通过制定算法分发到具体的机器上，最终实现Load Balance

1、缓存文件放在哪儿？
2、如何指定哪些请求被缓存？
3、缓存的有效期是多久？
4、如何指定哪些请求不被缓存？

静态资源： html、js、css、图片、音乐、视频等。

动态资源： 我的理解就是我们所说的接口

啥是跨域

如何解决

select/poll模式 ：饭店服务员（内核）告诉饭店老板（用户程序）：”现在有客人结账“ 但是这个服务员没人明确告诉老板，哪几桌的客人结帐。老板得自儿一个一个桌子去问：请问是你要结帐？

跨平台的Web服务器软件

epoll是基于JAVA NIO的同步非阻塞开发，在高并发情况下能支持更多的连接！nginx是事件驱动的，一个主进程跟多个工作进程组成的工作模式，主线程负责循环分配事件，多个工作线程负责事件的处理！

epoll模式：饭店服务员（内核）告诉饭店老板（用户程序）：”1,2,5号客人结账“ 老板就可以直接去1,2,5号桌收钱了