后端Java知识指北

初始标记（CMS initial mark）：仅仅只是标记一下GC Roots能直接关联到的对象，速度很快，需要“Stop The World”。

并发标记（CMS concurrent mark）：进行GC Roots Tracing的过程，在整个过程中耗时最长。

重新标记（CMS remark）：为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段稍长一些，但远比并发标记的时间短。此阶段也需要“Stop The World”。

并发清除（CMS concurrent sweep）

并发收集、低停顿，因此CMS收集器也被称为并发低停顿收集器（Concurrent Low Pause Collector）。

对CPU资源非常敏感 其实，面向并发设计的程序都对CPU资源比较敏感。在并发阶段，它虽然不会导致用户线程停顿，但会因为占用了一部分线程（或者说CPU资源）而导致应用程序变慢，总吞吐量会降低。CMS默认启动的回收线程数是（CPU数量+3）/4，也就是当CPU在4个以上时，并发回收时垃圾收集线程不少于25%的CPU资源，并且随着CPU数量的增加而下降。但是当CPU不足4个时（比如2个），CMS对用户程序的影响就可能变得很大，如果本来CPU负载就比较大，还要分出一半的运算能力去执行收集器线程，就可能导致用户程序的执行速度忽然降低了50%，其实也让人无法接受。

无法处理浮动垃圾（Floating Garbage） 可能出现“Concurrent Mode Failure”失败而导致另一次Full GC的产生。由于CMS并发清理阶段用户线程还在运行着，伴随程序运行自然就还会有新的垃圾不断产生。这一部分垃圾出现在标记过程之后，CMS无法再当次收集中处理掉它们，只好留待下一次GC时再清理掉。这一部分垃圾就被称为“浮动垃圾”。也是由于在垃圾收集阶段用户线程还需要运行，那也就还需要预留有足够的内存空间给用户线程使用，因此CMS收集器不能像其他收集器那样等到老年代几乎完全被填满了再进行收集，需要预留一部分空间提供并发收集时的程序运作使用。

标记-清除算法导致的空间碎片 CMS是一款基于“标记-清除”算法实现的收集器，这意味着收集结束时会有大量空间碎片产生。空间碎片过多时，将会给大对象分配带来很大麻烦，往往出现老年代空间剩余，但无法找到足够大连续空间来分配当前对象。

如果对象分配率高于CMS回收的效率，将导致在CMS完成之前老年代就被填满，这种状况成为“并发模式失败”，同样也会引起full GC。可以调节-XX:CMSInitiatingOccupancyFraction和新生代的堆大小。

-XX:+UseConcMarkSweepGC - 启用CMS，同时-XX:+UseParNewGC会被自动打开。

-XX:CMSInitiatingOccupancyFraction - 设置第一次启动CMS的阈值，默认是68%。

-XX:+UseCMSInitiatingOccupancyOnly - 只是用设定的回收阈值，如果不指定，JVM仅在第一次使用设定值，后续则自动调整。

-XX:+CMSPermGenSweepingEnabled - 回收perm区。

-XX:+CMSClassUnloadingEnabled - 相对于并行收集器，CMS收集器默认不会对永久代进行垃圾回收（在1.7中是默认关闭，但是在1.8中是默认打开的）。如果希望对永久代进行垃圾回收，则可以打开此标志，同时打开-XX:+CMSPermGenSweepingEnabled  92%默认值。

-XX:+CMSConcurrentMTEnabled - 并发的CMS阶段将会启动多个GC线程和其他线程并发工作，默认为true。

-XX:+UseCMSCompactAtFullCollection - 在full GC的时候进行整理(mark sweep compact)，默认为true。

-XX:+CMSFullGCsBeforeCompaction - 在上一次CMS并发GC执行过后，到底还要再执行多少次**full GC**（注意不是CMS GC）才会做压缩，默认是0。如果增大这个参数，会使full GC更少做压缩，但也就更容易使CMS的老年代受碎片化问题的困扰。 本来这个参数就是用来配置降低full GC压缩的频率，以期减少某些full GC的暂停时间。CMS回退到full GC时用的算法是mark-sweep-compact，但compaction是可选的，不做的话碎片化会严重些但这次full GC的暂停时间会短些，这是个取舍。

-XX:+CMSParallelRemarkEnabled - 并行remark，以减少remark的等待时间。默认为true。

-XX:+CMSScavengeBeforeRemark - 强制remark之前开始一次minor GC，可以减少remark的等待时间，因为老生代的对象有的会依赖于新生代的对象，当增加了这个命令时会在remark之前执行一次minor GC的操作，从而可以减少老生代到新生代的可到达对象数。默认为false。

JVM是如何判断对象被移动过呢？就是利用对象引用的地址，即着色指针。

着色指针是一种将信息存储在指针中的技术。

ZGC实际仅使用64位地址空间的第0~41位，而第42~45位存储元数据，第47~63位固定为0。

解决了转移过程中准确访问对象的问题，实现了并发转移。大致原理描述如下：并发转移中“并发”意味着GC线程在转移对象的过程中，应用线程也在不停地访问对象。假设对象发生转移，但对象地址未及时更新，那么应用线程可能访问到旧地址，从而造成错误。而在ZGC中，应用线程访问对象将触发“读屏障”，如果发现对象被移动了，那么“读屏障”会把读出来的指针更新到对象的新地址上，这样应用线程始终访问的都是对象的新地址。

读屏障是JVM向应用代码插入一小段代码的技术。当应用线程从堆中读取对象引用时，就会执行这段代码。需要注意的是，仅“从堆中读取对象引用”才会触发这段代码。

-Xms10G -Xmx10G   -Xms -Xmx：堆的最大内存和最小内存，这里都设置为10G，程序的堆内存将保持10G不变。

-XX:ReservedCodeCacheSize=256m -XX:InitialCodeCacheSize=256m   -XX:ReservedCodeCacheSize -XX:InitialCodeCacheSize：设置CodeCache的大小， JIT编译的代码都放在CodeCache中，一般服务64m或128m就已经足够。我们的服务因为有一定特殊性，所以设置的较大，后面会详细介绍。

-XX:+UnlockExperimentalVMOptions -XX:+UseZGC   启用ZGC的配置。

-XX:ConcGCThreads=2 -XX:ParallelGCThreads=6    -XX:ConcGCThreads：并发回收垃圾的线程。默认是总核数的12.5%，8核CPU默认是1。调大后GC变快，但会占用程序运行时的CPU资源，吞吐会受到影响。 -XX:ParallelGCThreads：STW阶段使用线程数，默认是总核数的60%。

-XX:ZCollectionInterval=120 -XX:ZAllocationSpikeTolerance=5   ZGC发生的最小时间间隔，单位秒。 /////   ZGC触发自适应算法的修正系数，默认2，数值越大，越早的触发ZGC。

-XX:+UnlockDiagnosticVMOptions -XX:-ZProactive   是否启用主动回收，默认开启，这里的配置表示关闭。

-Xlog:safepoint,classhisto*=trace,age*,gc*=info:file=/opt/logs/logs/gc-%t.log:time,tid,tags:filecount=5,filesize=50m   设置GC日志中的内容、格式、位置以及每个日志的大小。

阻塞内存分配请求触发：当垃圾来不及回收，垃圾将堆占满时，会导致部分线程阻塞。我们应当避免出现这种触发方式。日志中关键字是“Allocation Stall”。

基于分配速率的自适应算法：最主要的GC触发方式，其算法原理可简单描述为”ZGC根据近期的对象分配速率以及GC时间，计算出当内存占用达到什么阈值时触发下一次GC”。自适应算法的详细理论可参考彭成寒《新一代垃圾回收器ZGC设计与实现》一书中的内容。通过ZAllocationSpikeTolerance参数控制阈值大小，该参数默认2，数值越大，越早的触发GC。我们通过调整此参数解决了一些问题。日志中关键字是“Allocation Rate”。

基于固定时间间隔：通过ZCollectionInterval控制，适合应对突增流量场景。流量平稳变化时，自适应算法可能在堆使用率达到95%以上才触发GC。流量突增时，自适应算法触发的时机可能会过晚，导致部分线程阻塞。我们通过调整此参数解决流量突增场景的问题，比如定时活动、秒杀等场景。日志中关键字是“Timer”。

主动触发规则：类似于固定间隔规则，但时间间隔不固定，是ZGC自行算出来的时机，我们的服务因为已经加了基于固定时间间隔的触发机制，所以通过-ZProactive参数将该功能关闭，以免GC频繁，影响服务可用性。 日志中关键字是“Proactive”。

预热规则：服务刚启动时出现，一般不需要关注。日志中关键字是“Warmup”。

外部触发：代码中显式调用System.gc()触发。 日志中关键字是“System.gc()”。

元数据分配触发：元数据区不足时导致，一般不需要关注。 日志中关键字是“Metadata GC Threshold”。

方法调用指令

循环跳转指令

异常跳转指令

抢占式

主动式

使用年轻代命令行-XX:YoungGenerationSizeIncrement=<Y>和年老代命令行-XX:TenuredGenerationSizeIncrement。

分代收缩的百分比由命令行标识-XX:AdaptiveSizeDecrementScaleFactor=<D>。如果增长率是X%，则收缩率为X/D%。

用“指针碰撞”来分配内存

用“空闲列表”来分配内存

对分配内存空间的工作进行同步处理

每个线程分配一块本地线程分配缓冲区

存储运行时数据

存储类型指针

如果对象是数组对象，还有一个保存数组长度的空间，占4个字节

是对象真正存储的有效信息

起占位符的作用

1. reference中地址相对稳定；
   
2. 对象被移动（GC时）时只会改变句柄中的实例数据指针
   

访问速度快，节省了一次指针定位的开销

存在就不回收

将要发生内存溢出之前

下一次垃圾回收

对对象的生存时间没有影响

虚拟机栈中引用的对象

本地方法栈中引用的对象

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

方法区中常量引用的对象

没有任何一个对象引用常量池中的“abc”常量

1、该类所有的实例都已经被回收

2、加载该类的加载器被回收 

3、该类对应的javalang.Class对象没有在任何地方被引用，无法通过反射访问该类的方法 

Java虚拟机字节码解释器通过改变这个计数器的值来选取下一条要执行的字节码指令

基本类型变量，（boolean,byte,char,short,int,float,long,double）

对象句柄

方法参数

方法的局部变量

内容：存放编译产生的字面量（常量final）和符号引用

特点：运行时常量池相对于Class文件常量池的一个重要特征是具备动态性

参考垃圾对象的判定

目的：更好的回收内存和更快的分配内存

新生代

老年代

-Xms初始堆大小 -Xmx最大堆大小

从 Collection 和数组

BufferedReader

静态工厂

java.util.stream.IntStream.range()

java.nio.file.Files.walk()

自己构建

.......

Intermediate

Terminal

升级

JDK1.8原理

线程不安全

可以存NULL

源码

线程安全

默认初始容量11，装填因子0.75

每次扩容容量是2倍+1

直接使用hasoCode的值作为hash值

红黑树实现

key自动排序

链表实现

应用场景

线程不安全

JDK1.7

JDK1.8

cocurrentHashMap的底层机制

ArrarList

LinkedList

Vector

CopyOnWriteArrayList

TreeSet

HashSet

LinkedHashSet

CopyOnWriteSet

Deque

BlockingQueue

AbstractQueue

为什么boolean没有规定字节数?

Boolean

Byte

Character

Short

Integer

Long

Double

什么是缓冲池?

那些包装类具有缓冲池?

改变

String为什么被声明为final(声明为final的好处？)

什么是StringPool(StringTable)

线程不安全，可以被改变

线程安全，内部被synchronized同步

关键字

在java8中接口可以有default方法，也可以有静态方法

但是静态方法不能够被重写，default方法可以被重写

RuntimeException

非运行时异常

运行时异常和非运行时异常区别?

OutOfMemoryError

StackOverflowError

ThreadDeath

...

子类泛型类型确定

子类泛型类型不确定：继续使用父类定义的泛型

在泛型中并没有像我们面向对象的继承结构，想要使用任意的泛型类型，我们可以使用通配符！

?号通配符表示可以匹配任意类型，任意的Java类都可以匹配

PECS(Producer Extends Consumer Super)原则

如果参数之间的类型有依赖关系，或者返回值是与参数之间有依赖关系的。那么就使用泛型方法

如果没有依赖关系的，就使用通配符，通配符会灵活一些.

1.获取Class对象的方法

2.无参数创建对象

3.有参数创建对象

1.获取属性

2.Field类描述

3.安全管理

4.修改属性中的修饰符

Method m = class.getDeclaredMethod("setName",String.class);
m.setAccessible(true); //同样需要忽略访问权限的限制
m.invoke(class,"老王");

当Class.foeName()中路径获取不到对应的Class时，会抛出异常。

1.确实不存在这个Field，抛出异常。

2.修饰符导致的权限问题，抛出相同异常。

1.getField只能获取对象和父类的public修饰的属性。

2.getDeclaredField获取对象中的各种修饰符属性，但是不能获取父类的任何属性。

3.先使用getSupperclass方法可以获取父类的suppereClass对象，再使用getDeclaredField方法获取父类的全部属性

1.Class.newInstance()

2.Contructor.newInstance()

public class TestMethod{
       static void test（）{}
}
Class cla = Class.foeName("TestMethod");
Method m = cla.getDeclaredMethod("test");
m.invoke(null);

1.Java的泛型擦除概念，泛型T在编译时会自动向上转型为Object

public class Test<T>{
      public void test(T t){}
}  
Class cla = Test.class;
Method m = cla.getDeclaredMethod("test",Object.class);
m.invoke(new Test<Integer>(),1);

反射出该类的方法

通过方法得到注解上具体的信息

将注解上的信息注入到方法上

得到想要类中注入的属性，得到该属性的对象

得到属性对应的写方法，通过写方法得到注解

获取注解详细的信息，将注解的信息注入到对象上

调用属性写方法，将已填充数据的对象注入到方法中

RetentionPolicy.SOURCE---Java文件时期

RetentionPolicy.CLASS---Class文件时期

RetentionPolicy.RUNTIME---运行时期

由于我们使用注解常常都是配合反射来使用，所以一般都设置为RunTime时期

TYPE

FIELD

METHOD

PARAMETER

CONSTRUCTOR

LOCAL_VARIABLE

ANNOTATION_TYPE

PACKAGE

@Documented用于指定被该Annotation修饰的Annotation类将被javadoc工具提取成文档

被修饰过的Annotation将具有继承性

@Overried是告诉编译器要检查该方法是实现父类的...可以帮我们避免一些低级的错误.

该注解也非常常见，Java在设计的时候，可能觉得某些方法设计得不好，为了兼容以前的程序，是不能直接把它抛弃的，于是就设置它为过时。

抑制编译器警告【如果我们程序中没有使用新特性(没有使用泛型),编译器默认会警告我们】，使用这个注解会抑制编译器警告

当把一个不是泛型的集合赋值给一个带泛型的集合的时候，这种情况就很容易发生堆污染

@FunctionalInterface用来指定该接口是函数式接口

围绕着一个同步队列和park还有自旋锁实现

公平锁线程在唤醒的时候不能插队，非公平锁可以插队

lock加锁

unlock解锁

创建该对象的时候可以传入一个数值，每次调用countDown就会减一，计数器为零的时候await才不会阻塞

创建该对象的时候需要设置一个值，并且可以写一个实现Runnable的类，每次调用await就会加1，当加到设定的值后就会触发实现Runnable类的线程开启

可以用来做多线程限流，创建该对象的时候可以传入一个资源数量，每次调用acquire就会减少一个资源，资源为零的时候在调用该方法会导致他的线程进入阻塞状态，除非调用release释放锁。

容量为一的同步队列

Executors.newSingleThreadExecutor();// 单个线程

Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小

Executors.newCachedThreadPool(); // 可伸缩

int corePoolSize, // 核心线程池大小

int maximumPoolSize, // 最大核心线程池大小

long keepAliveTime, // 超时了没有人调用就会释放

TimeUnit unit, // 超时单位

BlockingQueue<Runnable> workQueue, // 阻塞队列

ThreadFactory threadFactory, // 线程工厂：创建线程的，一般不用动

RejectedExecutionHandler handle // 拒绝策略

假设现在有一个银行，银行的窗口就是线程，进来办理业务的人就是task

new ThreadPoolExecutor.AbortPolicy() // 满了，还有人进来，不处理这个人的，抛出异常

new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！

new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！

new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会抛出常！

继承Thread类创建线程

实现Runnable接口创建线程

使用Callable和FutureTask创建线程

使用stop方法强行终止，但是不推荐这个方法，因为stop和suspend及resume一样都是过期作废的方法。

使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

使用interrupt方法中断线程。

notify():
唤醒一个处于等待状态的线程，
注意的是在调用此方法的时候，
并不能确切的唤醒某一个等待状态的线程，
而是由JVM确定唤醒哪个线程，而且不是按优先级。

notifyAll():
唤醒所有处入等待状态的线程;
并可以理解为把他们排进一个队列;
只不过只有头部的线程获得了锁，才能运行;
注意！！并不是给所有唤醒线程一个对象的锁，而是让它们竞争，
当其中一个线程运行完就开始运行下一个已经被唤醒的线程，因为锁已经转移了。

如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。

当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争

优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。

sleep()是线程类（Thread）的方法，不涉及线程通信，调用时会暂停此线程指定的时间，但监控依然保持，不会释放对象锁，到时间自动恢复；

wait()是Object的方法，用于线程间的通信，调用时会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才进入对象锁定池准备获得对象锁进入运行状态。

wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用（使用范围）。

sleep()方法必须捕获异常InterruptedException，而wait()\notify()以及notifyAll()不需要捕获异常。

sleep方法只让出了CPU，而并不会释放同步资源锁。

线程执行sleep()方法后会转入阻塞状态。

sleep()方法指定的时间为线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。

　notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度。

守护线程与普通线程的唯一区别是：当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；

如果还有一个或以上的非守护线程则不会退出。（以上是针对正常退出，调用System.exit则必定会退出）

JVM 的垃圾回收线程就是 Daemon 线程，Finalizer 也是守护线程。

Thread 的 setDaemon 方法设置现称为守护线程  必须在线程启动之前调用，

当你在一个守护线程中产生了其他线程，那么这些新产生的线程不用设置Daemon属性，都将是守护线程，用户线程同样。

意义    JVM不需要等待它退出，让JVM喜欢什么退出就退出吧，不用管它。

 等待、通知唤醒

锁机制

同步机制

ThreadLocal类

通讯

NEW 新生

RUNNABLE 运行

BLOCKED 阻塞

WAITING 等待

TIMED_WAITING 超时等待

TERMINATED 终止

可重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。

JAVA环境下 ReentrantLock 和synchronized 都是 可重入锁

可重入锁最大的作用是避免死锁

什么时候应该使用可重入锁？

不能

Lock 能完成synchronized所实现的所有功能； 

Lock有比synchronized更精确的线程语义和更好的性能，而且不强制性的要求一定要获得锁

synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且最好在finally 块中释放（这是释放外部资源的最好的地方）。

理解

实现

相关铺垫

https://www.jianshu.com/p/f584799f1c77

ReentrantLock 默认采用非公平锁，除非在构造方法中传入参数 true 。

公平锁

非公平锁

公平和非公平锁的队列都基于锁内部维护的一个双向链表，表结点Node的值就是每一个请求当前锁的线程。公平锁则在于每次都是依次从队首取值
非公平锁在等待锁的过程中， 如果有任意新的线程妄图获取锁，都是有很大的几率直接获取到锁的
（在ReentrantLock中很明显可以看到其中同步包括两种，分别是公平的FairSync和非公平的NonfairSync。公平锁的作用就是严格按照线程启动的顺序来执行的，不允许其他线程插队执行的；而非公平锁是允许插队的。
默认情况下ReentrantLock是通过非公平锁来进行同步的，包括synchronized关键字都是如此，因为这样性能会更好。因为从线程进入了RUNNABLE状态，可以执行开始，到实际线程执行是要比较久的时间的。而且，在一个锁释放之后，其他的线程会需要重新来获取锁。其中经历了持有锁的线程释放锁，其他线程从挂起恢复到RUNNABLE状态，其他线程请求锁，获得锁，线程执行，这一系列步骤。如果这个时候，存在一个线程直接请求锁，可能就避开挂起到恢复RUNNABLE状态的这段消耗，所以性能更优化）

互斥是进程同步关系的一种特殊情况，相当于只存在一个临界资源，因此同时最多只能给一个线程提供服务。但是，在实际复杂的多线程应用程序中，可能存在多个临界资源，这时候我们可以借助Semaphore信号量来完成多个临界资源的访问。

SynchronizedMap()和Hashtable一样，实现上在调用map所有方法时，都对整个map进行同步

ConcurrentHashMap的实现却更加精细，它对map中的所有桶加了锁。所以，只要有一个线程访问map，其他线程就无法进入map，而如果一个线程在访问ConcurrentHashMap某个桶时，其他线程，仍然可以对map执行某些操作。CAS算法

多读少写的场景

CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

Servlet不是线程安全的

线程安全就是说多线程访问同一代码，不会产生不确定的结果。

Java基础 -> 多线程 -> 线程安全 -> 线程同步

一个是编译器编译的的时候，一个是处理器运行的时候。

指令重排使得具有相似功能单元的指令接连执行来减少流水线中断的情况。

作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值，即不是从寄存器里取备份值，而是去该地址内存存储的值。

对变量的写操作不依赖于当前值且该变量没有包含在具有其他变量的不变式中。

理解    
立即可见

Java内存模型规范了Java虚拟机与计算机内存是如何协同工作的。

Java虚拟机是一个完整的计算机的一个模型，因此这个模型自然也包含一个内存模型——又称为Java内存模型。

知识点

与硬件关联

使用CyclicBarrier 在多个关口处将多个线程执行结果汇总， CountDownLatch 在各线程执行完毕后向总线程汇报结果。

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

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

java线程池参数  参考 ThreadPoolExecutor

如果是CPU密集型应用，则线程池大小设置为N+1。

如果是IO密集型应用，则线程池大小设置为2N+1。

1. 有界队列有助于避免资源耗尽的情况发生。但他带来了新的问题：当队列填满后，新的任务怎么办？所以有界队列适用于执行比较耗资源的任务，同时要设计好相应的饱和策略。

2. 无界队列和有界队列刚好相反，在资源无限的情况下可以一直接收新任务。适用于小任务，请求和处理速度相对持平的状况。

3. 其实还有一种同步移交的队列 SynchronousQueue ，这种队列不存储任务信息，直接将任务提交给线程池。可以理解为容量只有1的有界队列，在特殊场景下有特殊作用，同样得设计好相应的饱和策略。

CopyOnWriteArrayList、CopyOnWriteArraySet

CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

查看   多线程 -> 常见问题 -> 锁 -> 乐观锁 -> CAS

比如网上共享白板，共享文档等都适用。

读写锁逻辑：

1. 当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞。
2. 当读写锁在读加锁状态时, 所有试图以读模式对它进行加锁的线程都可以得到访问权，但是以写模式对它进行枷锁的线程将阻塞。
3. 当读写锁在读模式锁状态时, 如果有另外线程试图以写模式加锁, 读写锁通常会阻塞随后的读模式锁请求, 这样可以避免读模式锁长期占用, 而等待的写模式锁请求长期阻塞。

状态标志：把简单地volatile变量作为状态标志，来达成线程之间通讯的目的，省去了用synchronized还要wait，notify或者interrupt的编码麻烦。

替换重量级锁：如果某个变量仅是单次读或者单次写操作，没有复合操作(i++,先检查后判断之类的)就可以用volatile替换synchronized。

read 把一个变量的值从主内存传输到工作内存

load 在read之后执行，把read得到的值放入工作内存的变量副本中

use 把工作内存中一个变量的值传递给执行引擎。

assign 作用于工作内存的变量，它把一个从执行引擎收到的值赋值给工作内存的变量

store 作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作

write  作用于主内存的变量，它把store操作从工作内存中的一个变量的值传送到主内存的变量中

lock 作用于主内存的变量，把一个变量标识为一条线程独占状态

unlock  作用于主内存的变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定

为什么需要指令重排序？

指令重排序的种类

规则

带来的问题

解决方案

可以使用内存屏障的方法禁止重排序，我们遵守happens-Before规则底层就是使用了内存屏障

程序顺序规则：一个线程中的每个操作，happens- before 于该线程中的任意后续操作。

监视器锁规则：对一个监视器锁的解锁，happens- before 于随后对这个监视器锁的加锁。

volatile 变量规则：对一个 volatile 域的写，happens- before 于任意后续对这个 volatile 域的读。

传递性：如果 A happens- before B，且 B happens- before C，那么 A happens- before C。

Happens-Before 规则可以解决有序性问题

同步方法

同步代码块

ajax属性async 同步异步区别（入门使用级）

阻塞和非阻塞，同步和异步

简述linux同步与异步、阻塞与非阻塞概念以及五种IO模型

15分钟读懂进程线程、同步异步、阻塞非阻塞、并发并行

采用BIO通信模型的服务端，通常由一个独立的Acceptor线程负责监听客户端的连接

它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理没处理完成后，通过输出流返回应答给客户端，线程销毁

典型的一请求一应答通信模型

最大的问题

读取数据较慢时（比如数据量大、网络传输慢等），大量并发的情况下，其他接入的消息，只能一直等待，这就是最大的弊端。

NIO就能解决这个难题

使用ByteBuffer的allocateDirect方法

使用FileChannel的map方法

本质

状态变量

常用实现

管道的理解

常用管道

管道和流的区别

一个组件，可以检测多个NIO channel，看看读或者写事件是否就绪。
多个Channel以事件的方式可以注册到同一个Selector，从而达到用一个线程处理多个请求成为可能。

我们对数据的读取和写入要通过Channel，它就像水管一样，是一个通道。通道不同于流的地方就是通道是双向的，可以用于读、写和同时读写操作。

Selector提供选择已经就绪的任务的能力

Selector会不断轮询注册在其上的Channel，如果某个Channel上面发生读或者写事件，这个Channel就处于就绪状态，会被Selector轮询出来

然后通过SelectionKey可以获取就绪Channel的集合，进行后续的I/O操作。

一个Selector可以同时轮询多个Channel，因为JDK使用了epoll()代替传统的select实现，所以没有最大连接句柄1024/2048的限制。

所以，只需要一个线程负责Selector的轮询，就可以接入成千上万的客户端

Netty核心组件初步了解

Hello，Netty

Channel、EventLoop 和ChannelFuture

ChannelHandler 和ChannelPipeline

内置通信传输模式

ByteBuf

基于STOMP的SpringBoot

基于Netty

为什么使用SLF4J而不是Log4J来做Java日志

Java日志框架：slf4j作用及其实现原理

log4j日志级别配置详解

Logback的配置和使用(终极)

src/main/resources

src/main/java

pom.xml

如果在集合中还有对象的关系要体现出来的话，那我们只能使用ofType。

如果集合中都是对象本身基本属性了，那么可以使用resultMap

flushCache=&quot;false&quot;

InitializingBean（初始化设置值之后）

DisposableBean（销毁）

JSR250

&beanName获取Factory本身

@Resources（JSR250）

@Inject（JSR330，需要导入javax.inject）

Controller / RestController

RequestMapping

Resource  / Autowired

ModelAttribute / SessionAttributes

PathVariable

requestParam

ResponseBody

Component

Repository

Service

spring容器初始化的整个流程图

源码

Spring源码学习--Bean的生命周期

Servlet容器在启动时会加载Web应用，并为每个Web应用创建唯一的ServletContext对象。

ServletContext看作一个Web应用的服务器端组件的共享内存

1.ServletContext创建之后，然后读取web.xml中&lt;context-param&gt;&lt;/context-param&gt;节点内容

2.触发ServletContextEvent事件，ServletContextListener监听这个事件

3.ContextLoaderListener实继承ContextLoader并实现ServletContextListener，所以也监听ServletContextEvent事件，事件触发后ContextLoaderListener会执行初始化方法。

4.ContextLoaderListener监听ServletContextEvent事件，执行初始化contextInitialized(ServletContextEvent event)方法

contextInitialized 是在容器初始化上下文的时候调用的;

contextDestroyed是容器销毁上下文的时候调用的

执行static代码块获取ContextLoader.properties

ContextLoader初始化过程中，会通过xml中contextConfigLocation的配置，比如springmvc的配置

ServletContextListener方法contextInitialized(ServletContextEvent event)会执行继承自contextLoader的initWebApplicationContext(ServletContext context)方法

0.spring中WebApplicationContext、DispatcherServlet与web容器的ServletContext关系梳理

1.contextInitialized(ServletContextEvent event),执行继承自ContextLoader中的initWebApplicationContext(ServletContext context)方法，获取webApplication上下文环境

2.contextDestroyed(ServletContextEvent event)

refresh之prepareRefresh方法

读取并解析spring xml配置文件的入口，spring XML配置文件的解析流程

refreshBeanFactory();

在完成解析，把所有的BeanDenifition注册到bean工厂完成后，开始执行prepareBeanFactory方法。

这个方法是配置工厂的标准上下文特征

refresh之prepareBeanFactory方法

postProcessBeanFactory后处理beanFactory。时机是在所有的beanDenifition加载完成之后，bean实例化之前执行。

比如，在beanfactory加载完成所有的bean后，想修改其中某个bean的定义，或者对beanFactory做一些其他的配置，就可以用此方法。

refresh之postProcessBeanFactory方法

invokeBeanFactoryPostProcessors执行BeanFactory后置处理器，当然前提是你已经在容器中注册过此处理器了。

refresh之invokeBeanFactoryPostProcessors方法

registerBeanPostProcessors从名称可以看出是用来注册BeanPostProcessor的

BeanPostProcessor

refresh之registerBeanPostProcessors方法

BeanFactoryPostProcessor和BeanPostProcessor的区别

国际化初始

初始化应用事件广播器，这事观察者模式得典型应用。

观察者模式由主题Subject和Observer组成。广播器相当于主题Subject，其包含多个监听器。当主题发生变化时会通知所有得监听器。

refresh之initApplicationEventMulticaster方法

这个方法是空的，解释是在特定的上下文中初始化特别的beans，可以看到其也是用于初始化的

refresh之onRefresh方法

注册监听器，与广播器是同时存在的。在广播器章节，spring只是初始化的广播器，但是并没有为广播器绑定Listener。

refresh之registerListeners方法

spring bean创建和初始化

在Spring中还提供了Lifecycle，Lifecycle中包含了start/stop方法

实现此接口后Spring会保证在启动的时候调用其start方法开始生命周期，并在Spring结束的时候调用stop方法来结束生命周期

通常用来配置后台程序，在启动后一直运行。而ApplicationContext的初始化最后正是保证了这一功能的实现。

spring boot使用拦截器(以session校验为例)

@Filter中FilterType包含的类型及意义

spring boot使用过滤器(以session校验为例)

单体架构

微服务

微服务的4个设计原则和19个解决方案

分布式

集群

SOA[组装服务/ESB企业服务总线]

微服务[找到服务/微服务网关open API]

由于使用的SOAP协议，使用WSDL，这本质上是使用的XML进行内容通信，速度太慢，处理的效率太低

如果想使用本地接口的方式调用，要利用开发工具根据WSDL文件生成很多工具代码，接口任何变动都回导致工具代码重新生成，开发特别繁琐

基于webService而来

springcloud中常用的注解@

springcloud中常用注解

@Autowired和@Resource的区别

配置文件注解

过滤器注册

Java开发之@PostConstruct和@PreConstruct注解

第一种方法在多个文件中配置

在一个文件中配置

Server服务端源码

Client服务提供者源码

Client服务调用者源码

项目源码(不理解)

Dubbo的底层原理

Dubbo源代码实现一：切入Spring

Dubbo源代码实现二：服务调用的动态代理和负载均衡

Dubbo源码解析

Dubbo实现源码分析

深入理解dubbo之服务发布源码分析

深入理解dubbo之服务引用

Dubbo RPC源码解读

dubbo源码解析-服务暴露原理

dubbo服务端处理请求源码分析

maven+springmvc+dubbo+zookeeper

Springboot 整合 Dubbo/ZooKeeper 详解

spring cloud和dubbo的区别

dubbo四种负载均衡策略

思路清晰易懂(推荐)

统计在线人数

@Configuration ShiroConfig

前序：根节点、左子树、右子树。

中序：左子树、根节点、右子树。

后序：左子树、右子树、根节点。

层序：一层一层遍历。

使用静态类.doSomething()体现的是基于对象

&nbsp;使用单例设计模式体现的是面向对象。

直接在成员变量上new出实例，提供方法返回

等到调用方法的时候再创建对象，该方法需要加Synchronized锁

基于普通懒汉式的提升，普通懒汉式的效率太低了

1.使用volatile修饰我们的对象引用

2.外部if判断对象是否为null，为null往下执行，不为null直接返回对象

3.使用syn同步进入代码块，使用if判断对象是否为null，为null就创建对象

4.使用volatile修饰成员变量的原因就是防止重排序的问题---&gt;变量还未完全初始化就被线程B返回了

创建一个内部类，在内部类直接创建对象

外部类提供方法来获取内部类创建的对象

这种方式是非常方便和友好的，在外部调用的时候，内部类才会创建对象

public enum Java3y3y { JAVA_3_Y_3_Y, }

省事，安全(枚举能够有效防止多次实例化的问题)

优点

缺点

优点

缺点

减少了工厂的数据

难以扩展产品族，会修改非常多的类

&nbsp;代理对象拥有目标对象相同的方法【因为参数二指定了对象的接口，代理对象会实现接口的所有方法】 用户调用代理对象的什么方法，都是在调用处理器的invoke方法。【被拦截】 使用JDK动态代理必须要有接口【参数二需要接口】

所有通过动态代理实现的方法全部通过invoke()调用

如果没有接口的情况下，这种形式可以通过类来实现动态代理，生成的是子类代理

需要自己实现接口下的所有方法

继承

包装模式

代理模式

&nbsp;定义了一个框架，实现对基本方法的调用，完成固定的逻辑。

在子类实现，并且在模板方法中被调用

mysql -u用户名 -p密码

创建库

查看库

删除库

修改库

备份库中的数据和

增加表

修改表

查看表

删除表

增加

修改

删除

查看

1.FROM

2.WHERE

3.GROUP BY

4. HAVING

5.SELECT

6.ORDER BY

AVG()

MAX()

MIN()

COUNT()

SUM()

用LIKE操作符进行过滤

使用ORDER BY 排序数据

使用GROUP BY分组

FROM字句后边不止一个表，就叫联结

FROM子句跟着是两个相同的表叫自连接

创建
CREATE [UNIQUE] INDEX indexName ON mytable(columnname(length));

更改
ALTER mytable ADD [UNIQUE] INDEX [indexName] ON(columnname(length));

删除
DROP INDEX [indexName] ON mytable;

查看一个表的索引信息
show index from [tableName];

/* 触发器 */ ------------------
触发程序是与表有关的命名数据库对象，当该表出现特定事件时，将激活该对象
监听：记录的增加、修改、删除。
-- 创建触发器
CREATE TRIGGER trigger_name trigger_time trigger_event ON tbl_name FOR EACH ROW trigger_stmt
参数：
trigger_time是触发程序的动作时间。它可以是 before 或 after，以指明触发程序是在激活它的语句之前或之后触发。
trigger_event指明了激活触发程序的语句的类型
INSERT：将新行插入表时激活触发程序
UPDATE：更改某一行时激活触发程序
DELETE：从表中删除某一行时激活触发程序
tbl_name：监听的表，必须是永久性的表，不能将触发程序与TEMPORARY表或视图关联起来。
trigger_stmt：当触发程序激活时执行的语句。执行多个语句，可使用BEGIN...END复合语句结构
-- 删除
DROP TRIGGER [schema_name.]trigger_name
可以使用old和new代替旧的和新的数据
更新操作，更新前是old，更新后是new.
删除操作，只有old.
增加操作，只有new.
-- 注意
1. 对于具有相同触发程序动作时间和事件的给定表，不能有两个触发程序。
-- 字符连接函数
concat(str1,str2,...])
concat_ws(separator,str1,str2,...)
-- 分支语句
if 条件 then
执行语句
elseif 条件 then
执行语句
else
执行语句
end if;
-- 修改最外层语句结束符
delimiter 自定义结束符号
SQL语句
自定义结束符号
delimiter ; -- 修改回原来的分号
-- 语句块包裹
begin
语句块
end
-- 特殊的执行
1. 只要添加记录，就会触发程序。
2. Insert into on duplicate key update 语法会触发：
如果没有重复记录，会触发 before insert, after insert;
如果有重复记录并更新，会触发 before insert, before update, after update;
如果有重复记录但是没有发生更新，则触发 before insert, before update
3. Replace 语法 如果有记录，则执行 before insert, before delete, after delete, after insert

/* 存储过程 */ ------------------
存储过程是一段可执行性代码的集合。相比函数，更偏向于业务逻辑。
调用：CALL 过程名
-- 注意
- 没有返回值。
- 只能单独调用，不可夹杂在其他语句中
-- 参数
IN|OUT|INOUT 参数名 数据类型
IN 输入：在调用过程中，将数据输入到过程体内部的参数
OUT 输出：在调用过程中，将过程体处理完的结果返回到客户端
INOUT 输入输出：既可输入，也可输出
-- 语法
CREATE PROCEDURE 过程名 (参数列表)
BEGIN
过程体
END

/* 用户和权限管理 */ ------------------
-- root密码重置
1. 停止MySQL服务
2. [Linux] /usr/local/mysql/bin/safe_mysqld --skip-grant-tables &
[Windows] mysqld --skip-grant-tables
3. use mysql;
4. UPDATE `user` SET PASSWORD=PASSWORD("密码") WHERE `user` = "root";
5. FLUSH PRIVILEGES;
用户信息表：mysql.user
-- 刷新权限
FLUSH PRIVILEGES;
-- 增加用户
CREATE USER 用户名 IDENTIFIED BY [PASSWORD] 密码(字符串)
- 必须拥有mysql数据库的全局CREATE USER权限，或拥有INSERT权限。
- 只能创建用户，不能赋予权限。
- 用户名，注意引号：如 'user_name'@'192.168.1.1'
- 密码也需引号，纯数字密码也要加引号
- 要在纯文本中指定密码，需忽略PASSWORD关键词。要把密码指定为由PASSWORD()函数返回的混编值，需包含关键字PASSWORD
-- 重命名用户
RENAME USER old_user TO new_user
-- 设置密码
SET PASSWORD = PASSWORD('密码') -- 为当前用户设置密码
SET PASSWORD FOR 用户名 = PASSWORD('密码') -- 为指定用户设置密码
-- 删除用户
DROP USER 用户名
-- 分配权限/添加用户
GRANT 权限列表 ON 表名 TO 用户名 [IDENTIFIED BY [PASSWORD] 'password']
- all privileges 表示所有权限
- *.* 表示所有库的所有表
- 库名.表名 表示某库下面的某表
GRANT ALL PRIVILEGES ON `pms`.* TO 'pms'@'%' IDENTIFIED BY 'pms0817';
-- 查看权限
SHOW GRANTS FOR 用户名
-- 查看当前用户权限
SHOW GRANTS; 或 SHOW GRANTS FOR CURRENT_USER; 或 SHOW GRANTS FOR CURRENT_USER();
-- 撤消权限
REVOKE 权限列表 ON 表名 FROM 用户名
REVOKE ALL PRIVILEGES, GRANT OPTION FROM 用户名 -- 撤销所有权限
-- 权限层级
-- 要使用GRANT或REVOKE，您必须拥有GRANT OPTION权限，并且您必须用于您正在授予或撤销的权限。
全局层级：全局权限适用于一个给定服务器中的所有数据库，mysql.user
GRANT ALL ON *.*和 REVOKE ALL ON *.*只授予和撤销全局权限。
数据库层级：数据库权限适用于一个给定数据库中的所有目标，mysql.db, mysql.host
GRANT ALL ON db_name.*和REVOKE ALL ON db_name.*只授予和撤销数据库权限。
表层级：表权限适用于一个给定表中的所有列，mysql.talbes_priv
GRANT ALL ON db_name.tbl_name和REVOKE ALL ON db_name.tbl_name只授予和撤销表权限。
列层级：列权限适用于一个给定表中的单一列，mysql.columns_priv
当使用REVOKE时，您必须指定与被授权列相同的列。
-- 权限列表
ALL [PRIVILEGES] -- 设置除GRANT OPTION之外的所有简单权限
ALTER -- 允许使用ALTER TABLE
ALTER ROUTINE -- 更改或取消已存储的子程序
CREATE -- 允许使用CREATE TABLE
CREATE ROUTINE -- 创建已存储的子程序
CREATE TEMPORARY TABLES -- 允许使用CREATE TEMPORARY TABLE
CREATE USER -- 允许使用CREATE USER, DROP USER, RENAME USER和REVOKE ALL PRIVILEGES。
CREATE VIEW -- 允许使用CREATE VIEW
DELETE -- 允许使用DELETE
DROP -- 允许使用DROP TABLE
EXECUTE -- 允许用户运行已存储的子程序
FILE -- 允许使用SELECT...INTO OUTFILE和LOAD DATA INFILE
INDEX -- 允许使用CREATE INDEX和DROP INDEX
INSERT -- 允许使用INSERT
LOCK TABLES -- 允许对您拥有SELECT权限的表使用LOCK TABLES
PROCESS -- 允许使用SHOW FULL PROCESSLIST
REFERENCES -- 未被实施
RELOAD -- 允许使用FLUSH
REPLICATION CLIENT -- 允许用户询问从属服务器或主服务器的地址
REPLICATION SLAVE -- 用于复制型从属服务器（从主服务器中读取二进制日志事件）
SELECT -- 允许使用SELECT
SHOW DATABASES -- 显示所有数据库
SHOW VIEW -- 允许使用SHOW CREATE VIEW
SHUTDOWN -- 允许使用mysqladmin shutdown
SUPER -- 允许使用CHANGE MASTER, KILL, PURGE MASTER LOGS和SET GLOBAL语句，mysqladmin debug命令；允许您连接（一次），即使已达到max_connections。
UPDATE -- 允许使用UPDATE
USAGE -- “无权限”的同义词
GRANT OPTION -- 允许授予权限

-- Normal Format, NF
- 每个表保存一个实体信息
- 每个具有一个ID字段作为主键
- ID主键 + 原子表
-- 1NF, 第一范式
字段不能再分，就满足第一范式。
-- 2NF, 第二范式
满足第一范式的前提下，不能出现部分依赖。
消除复合主键就可以避免部分依赖。增加单列关键字。
-- 3NF, 第三范式
满足第二范式的前提下，不能出现传递依赖。
某个字段依赖于主键，而有其他字段依赖于该字段。这就是传递依赖。
将一个实体信息的数据放在一个表内实现。

/* 备份与还原 */ ------------------ 备份，将数据的结构与表内数据保存起来。 利用 mysqldump 指令完成。 -- 导出 mysqldump [options] db_name [tables] mysqldump [options] ---database DB1 [DB2 DB3...] mysqldump [options] --all--database 1. 导出一张表 　　mysqldump -u用户名 -p密码 库名 表名 > 文件名(D:/a.sql) 2. 导出多张表 　　mysqldump -u用户名 -p密码 库名 表1 表2 表3 > 文件名(D:/a.sql) 3. 导出所有表 　　mysqldump -u用户名 -p密码 库名 > 文件名(D:/a.sql) 4. 导出一个库 　　mysqldump -u用户名 -p密码 --lock-all-tables --database 库名 > 文件名(D:/a.sql) 可以-w携带WHERE条件 -- 导入 1. 在登录mysql的情况下： 　　source 备份文件 2. 在不登录的情况下 　　mysql -u用户名 -p密码 库名 < 备份文件

原子性

一致性

隔离性

持久性

脏读

不可重复读

幻读

更新丢失

读未提交：read uncommitted

读已提交：read committed

可重复读：repeatable read

串行化：serializable

常见问题

顺序查找 O(n)

二分查找 有序  O(logn)

二叉排序树查找

多叉平衡查找树

http://blog.csdn.net/kennyrose/article/details/7532032

http://www.xuebuyuan.com/2216918.html

唯一索引

普通索引

复合索引(联合索引)

主键索引

全文索引

索引的数据结构

B树和B+树区别

优点

缺点

http://www.cnblogs.com/mxmbk/articles/5226344.html
http://www.cnblogs.com/simplefrog/archive/2012/07/15/2592527.html
http://www.open-open.com/lib/view/open1418476492792.html
http://blog.csdn.net/colin_liu2009/article/details/7301089
http://www.cnblogs.com/hongfei/archive/2012/10/20/2732589.html

Explain(查询语句执行计划)

什么是复合索引的最左匹配原则?

索引失效的情况

查询优化

简述在MySQL数据库中MyISAM和InnoDB的区别

Datetime 和 Timestamp 区别

使用索引的注意事项

为什么索引能提高查询速度

身份认证和权限相关(登录 MySQL 的时候)。

执行查询语句的时候，会先查询缓存（MySQL 8.0 版本后移除，因为这个功能不太实用）。

没有命中缓存的话，SQL 语句就会经过分析器，分析器说白了就是要先看你的 SQL 语句要干嘛，再检查你的 SQL 语句语法是否正确。

按照 MySQL 认为最优的方案去执行。

执行语句，然后从存储引擎返回数据。

文件

特点索引存放的是数据具体存放在磁盘上的地址

一张表最多有16个索引，每个索引的最大长度是255个字节 

事务型数据库的首选引擎，支持事务安全表（ACID），支持行锁定和外键，上图也看到了，InnoDB是默认的MySQL引擎。

按照锁机制分类

按照锁的粒度分类

InnoDB存储引擎 行锁的实现方式

更新的时候没有索引或者索引失效时，InnoDB 的行锁变表锁

间隙锁（Gap Lock）是Innodb在可重复读提交下为了解决幻读问题时引入的锁机制，

行锁是行级别的，粒度比较小，好，那我要你在拿行锁之前，必须先拿一个假的表锁，表示你想去锁住表里的某一行或者多行记录。

这样，Mysql 在判断表里有没有记录被锁定，就不需要遍历整张表了，它只需要看看，有没有人拿了这个假的表锁。

锁表

系统升级，加字段正确方法

用插件解决加字段问题

InnoDB

MyISAM

（1）在应用中，如果不同的程序会并发存取多个表，应尽量约定以相同的顺序来访问表，这样可以大大降低产生死锁的机会。

（2）在程序以批量方式处理数据的时候，如果事先对数据排序，保证每个线程按固定的顺序来处理记录，也可以大大降低出现死锁的可能。

（3）在事务中，如果要更新记录，应该直接申请足够级别的锁，即排他锁，而不应先申请共享锁，更新时再申请排他锁，因为当用户申请排他锁时，其他事务可能又已经获得了相同记录的共享锁，从而造成锁冲突，甚至死锁。

（4）在REPEATABLE-READ隔离级别下，如果两个线程同时对相同条件记录用SELECT...FOR UPDATE加排他锁，在没有符合该条件记录情况下，两个线程都会加锁成功。程序发现记录尚不存在，就试图插入一条新记录，如果两个线程都这么做，就会出现死锁。这种情况下，将隔离级别改成READ COMMITTED，就可避免问题。

（5）当隔离级别为READ COMMITTED时，如果两个线程都先执行SELECT...FOR UPDATE，判断是否存在符合条件的记录，如果没有，就插入记录。此时，只有一个线程能插入成功，另一个线程会出现锁等待，当第1个线程提交后，第2个线程会因主键重出错，但虽然这个线程出错了，却会获得一个排他锁。这时如果有第3个线程又来申请排他锁，也会出现死锁。对于这种情况，可以直接做插入操作，然后再捕获主键重异常，或者在遇到主键重错误时，总是执行ROLLBACK释放获得的排他锁。

死锁检测

https://draveness.me/database-concurrency-control/

分类

【强制】页面搜索严禁左模糊或者全模糊，如果需要请走搜索引擎来解决

说明:索引文件具有 B-Tree 的最左前缀匹配特性，如果左边的值未确定，那么无法使用此索引。

【强制】不得使用外键与级联，一切外键概念必须在应用层解决。

说明:以学生和成绩的关系为例，学生表中的 student_id 是主键，那么成绩表中的 student_id 则为外键。如果更新学生表中的 student_id，同时触发成绩表中的 student_id 更新，即为级联更新。外键与级联更新适用于单机低并发，不适合分布式、高并发集群;级联更新是强阻塞，存在数据库更新风暴的风 险;外键影响数据库的插入速度

使用外键带来的问题

@Transactional事务不要滥用。事务会影响数据库的QPS，另外使用事务的地方需要考虑各方面的回滚方案，包括缓存回滚、搜索引擎回滚、消息补偿、统计修正等。

1. 限定数据的范围

2. 读/写分离

3. 垂直分区

4. 水平分区

在连接池中，创建连接后，将其放置在池中，并再次使用它，因此不必建立新的连接。如果使用了所有连接，则会建立一个新连接并将其添加到池中。

连接池还减少了用户必须等待建立与数据库的连接的时间。

UUID：不适合作为主键，因为太长了，并且无序不可读，查询效率低。比较适合用于生成唯一的名字的标示比如文件的名字。

数据库自增 id : 两台数据库分别设置不同步长，生成不重复ID的策略来实现高可用。这种方式生成的 id 有序，但是需要独立部署数据库实例，成本高，还会有性能瓶颈。

利用 redis 生成 id : 性能比较好，灵活方便，不依赖于数据库。但是，引入了新的组件造成系统更加复杂，可用性降低，编码更加复杂，增加了系统成本。

Twitter的snowflake算法 ：Github 地址：https://github.com/twitter-archive/snowflake。

美团的Leaf分布式ID生成系统 ：Leaf 是美团开源的分布式ID生成器，能保证全局唯一性、趋势递增、单调递增、信息安全，里面也提到了几种分布式方案的对比，但也需要依赖关系数据库、Zookeeper等中间件。感觉还不错。美团技术团队的一篇文章：

大多数情况是正常的，只是偶尔会出现很慢的情况。

在数据量不变的情况下，这条SQL语句一直以来都执行的很慢。

1NF

2Nf

3NF

BCNF

Redis 是一个开源，高级的键值存储和一个适用的解决方案，用于构建高性能，可扩展的 Web 应用程序。Redis 也被作者戏称为 数据结构服务器 ，这意味着使用者可以通过一些命令，基于带有 TCP 套接字的简单 服务器-客户端 协议来访问一组 可变数据结构 。(

异常快 - Redis 非常快，每秒可执行大约 110000 次的设置(SET)操作，每秒大约可执行 81000 次的读取/获取(GET)操作。

支持丰富的数据类型 - Redis 支持开发人员常用的大多数数据类型，例如列表，集合，排序集和散列等等。这使得 Redis 很容易被用来解决各种问题，因为我们知道哪些问题可以更好使用地哪些数据类型来处理解决。

操作具有原子性 - 所有 Redis 操作都是原子操作，这确保如果两个客户端并发访问，Redis 服务器能接收更新的值。

多实用工具 - Redis 是一个多实用工具，可用于多种用例，如：缓存，消息队列(Redis 本地支持发布/订阅)，应用程序中的任何短期数据，例如，web应用程序中的会话，网页命中计数等。

基本数据结构

地理位置(GeoHash )

HyperLogLog

位图  bitmap

布隆过滤器

内存回收 因为c语言不具备自动内存回收功能，当将redisObject对象作为数据库的键或值而不是作为参数存储时其生命周期是非常长的，为了解决这个问题，Redis自己构建了一个内存回收机制，通过redisobject结构中的refcount实现.这个属性会随着对象的使用状态而不断变化。 创建一个新对象，属性初始化为1 对象被一个新程序使用，属性refcount加1 对象不再被一个程序使用，属性refcount减1 当对象的引用计数值变为0时，对象所占用的内存就会被释放

内存共享 refcount属性除了能实现内存回收以外，还能实现内存共享 将数据块的键的值指针指向一个现有值的对象 将被共享的值对象引用refcount加1 Redis的共享对象目前只支持整数值的字符串对象。之所以如此，实际上是对内存和CPU（时间）的平衡：共享对象虽然会降低内存消耗，但是判断两个对象是否相等却需要消耗额外的时间。对于整数值，判断操作复杂度为o(1),对于普通字符串，判断复杂度为o(n);而对于哈希，列表，集合和有序集合，判断的复杂度为o(n^2).虽然共享的对象只能是整数值的字符串对象，但是5种类型都可能使用共享对象。

时间轴、队列应用场景设计

购物车开发与设计实战

Redis与Lua模拟抢红包实战

网站投票设计与开发实战

能谈下Redis的底层协议吗

RESP是什么，在Redis怎么体现

RDB

AOF

aof-use-rdb-preamble yes

如果开启了混合持久化，aof在重写时，不再是单纯将内存数据转换为RESP命令写入aof文件，而是将重写这一刻之前的内存做rdb快照处理，并且将rdb快照内容和增量的aof修改内存数据的命令存在一起，都写入新的aof文件，新的aof文件一开始不叫appendonly.aof，等到重写完成后，新的aof文件才会进行改名，原子的覆盖原有的aof文件，完成新旧两个aof文件的替换。
于是在redis重启的时候，可以先加载rdb文件，然后再重放增量的aof日志就可以完全替代之前的aof全量文件重放，因此重启效率大幅得到提高。

EVAL script numkeys key [key ...] arg [arg ...]

SCRIPT LOAD script

EVALSHA sha1 numkeys key [key ...] arg [arg ...]

SCRIPT EXISTS script [script ...]

SCRIPT FLUSH

SCRIPT KILL

redis-cli --eval /Users/jihite/activeuser.lua user , 1

减少网络开销：多个请求通过脚本一次发送，减少网络延迟

原子操作：将脚本作为一个整体执行，中间不会插入其他命令，无需使用事务

复用：客户端发送的脚本永久存在redis中，其他客户端可以复用脚本

可嵌入性：可嵌入JAVA，C#等多种编程语言，支持不同操作系统跨平台交互

Publisher 往 channel 中发布消息时，关注了指定 channel 的 Consumer 就能够同时受到消息。

# 订阅频道： SUBSCRIBE channel [channel ....] # 订阅给定的一个或多个频道的信息 PSUBSCRIBE pattern [pattern ....] # 订阅一个或多个符合给定模式的频道 # 发布频道： PUBLISH channel message # 将消息发送到指定的频道 # 退订频道： UNSUBSCRIBE [channel [channel ....]] # 退订指定的频道 PUNSUBSCRIBE [pattern [pattern ....]] #退订所有给定模式的频道

不持久化消息： 如果 Redis 停机重启，PubSub 的消息是不会持久化的，毕竟 Redis 宕机就相当于一个消费者都没有，所有的消息都会被直接丢弃。

没有 Ack 机制，也不保证数据的连续： PubSub 的生产者传递过来一个消息，Redis 会直接找到相应的消费者传递过去。如果没有一个消费者，那么消息会被直接丢弃。如果开始有三个消费者，其中一个突然挂掉了，过了一会儿等它再重连时，那么重连期间的消息对于这个消费者来说就彻底丢失了。

Redis 5.0 新增了 Stream 数据结构，这个功能给 Redis 带来了 持久化消息队列

Redis Stream 从概念上来说，就像是一个 仅追加内容 的 消息链表，把所有加入的消息都一个一个串起来，每个消息都有一个唯一的 ID 和内容，这很简单，让它复杂的是从 Kafka 借鉴的另一种概念：消费者组(Consumer Group) (思路一致，实现不同)

消息

命令

常见问题

我们在系统中修改已有数据时，需要先读取，然后进行修改保存，此时很容易遇到并发问题。由于修改和保存不是原子操作，在并发场景下，部分对数据的操作可能会丢失。在单服务器系统我们常用本地锁来避免并发带来的问题，然而，当服务采用集群方式部署时，本地锁无法在多个服务器之间生效，这时候保证数据的一致性就需要分布式锁来实现。

Redis 锁主要利用 Redis 的 setnx 命令。

加锁解锁伪代码

SETNX 和 EXPIRE 非原子性

锁误解除

超时解锁导致并发

不可重入

无法等待锁释放

集群

分布式锁与实现（二）—基于ZooKeeper实现

分布式锁与实现(一) —基于Redis实现

工作机制

优缺点

redis的主从模式搭建及注意事项

基本原理

功能

工作机制

优缺点

Cluster模式实现了Redis的分布式存储，即每台节点存储不同的内容，来解决在线扩容的问题。

无中心结构

工作机制

Cluster模式集群节点最小配置6个节点(3主3从，因为需要半数以上)，其中主节点提供读写操作，从节点作为备用节点，不提供请求，只作为故障转移使用。

优缺点

基于客户端分片

Twemproxy

Codis

简单来说 Redis 就是一个使用 C 语言开发的数据库，不过与传统数据库不同的是 Redis 的数据是存在内存中的 ，也就是它是内存数据库，所以读写速度非常快，因此 Redis 被广泛应用于缓存方向。

另外，Redis 除了做缓存之外，Redis 也经常用来做分布式锁，甚至是消息队列。

Redis 提供了多种数据类型来支持不同的业务场景。Redis 还支持事务 、持久化、Lua 脚本、多种集群方案。

分布式缓存的话，使用的比较多的主要是 Memcached 和 Redis。不过，现在基本没有看过还有项目使用 Memcached 来做缓存，都是直接用 Redis。

Memcached 是分布式缓存最开始兴起的那会，比较常用的。后来，随着 Redis 的发展，大家慢慢都转而使用更加强大的 Redis 了。

分布式缓存主要解决的是单机缓存的容量受服务器限制并且无法保存通用的信息。因为，本地缓存只在当前服务里有效，比如如果你部署了两个相同的服务，他们两者之间的缓存数据是无法共同的。

共同点

区别

操作缓存就是直接操作内存，所以速度相当快。

一般像 MySQL 这类的数据库的 QPS 大概都在 1w 左右（4 核 8g） ，但是使用 Redis 缓存之后很容易达到 10w+，甚至最高能达到 30w+（就单机 redis 的情况，redis 集群的话会更高）。

直接操作缓存能够承受的数据库请求数量是远远大于直接访问数据库的，所以我们可以考虑把数据库中的部分数据转移到缓存中去，这样用户的一部分请求会直接到缓存这里而不用经过数据库。进而，我们也就提高的系统整体的并发。

Redis 基于 Reactor 模式来设计开发了自己的一套高效的事件处理模型

Redis 通过IO 多路复用程序 来监听来自客户端的大量连接（或者说是监听多个 socket），它会将感兴趣的事件及类型(读、写）注册到内核中并监听每个事件是否发生。

虽然说 Redis 是单线程模型，但是， 实际上，Redis 在 4.0 之后的版本中就已经加入了对多线程的支持。

为什么不使用多线程

Redis6.0 引入多线程主要是为了提高网络 IO 读写性能

虽然，Redis6.0 引入了多线程，但是 Redis 的多线程只是在网络数据的读写这类耗时操作上使用了， 执行命令仍然是单线程顺序执行。

Redis6.0 的多线程默认是禁用的，只使用主线程。

因为内存是有限的，如果缓存中的所有数据都是一直保存的话，分分钟直接Out of memory。

比如我们的短信验证码可能只在1分钟内有效，用户登录的 token 可能只在 1 天内有效

Redis 通过一个叫做过期字典（可以看作是hash表）来保存数据过期的时间。过期字典的键指向Redis数据库中的某个key(键)，过期字典的值是一个long long类型的整数，这个整数保存了key所指向的数据库键的过期时间（毫秒精度的UNIX时间戳）。

惰性删除 ：只会在取出key的时候才对数据进行过期检查。这样对CPU最友好，但是可能会造成太多过期 key 没有被删除。

定期删除 ： 每隔一段时间抽取一批 key 执行删除过期key操作。并且，Redis 底层会并通过限制删除操作执行的时长和频率来减少删除操作对CPU时间的影响。

扩展     
仅仅通过给 key 设置过期时间还是有问题的。因为还是可能存在定期删除和惰性删除漏掉了很多过期 key 的情况。这样就导致大量过期 key 堆积在内存里，然后就Out of memory了。

怎么解决这个问题呢？答案就是： Redis 内存淘汰机制。

volatile-lru（least frequently used）：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰

volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰

volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰

allkeys-lru（least recently used）：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的 key（这个是最常用的）

allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰

no-eviction：禁止驱逐数据，也就是说当内存不足以容纳新写入数据时，新写入操作会报错。这个应该没人使用吧！

4.0 版本后增加
volatile-lfu：从已设置过期时间的数据集(server.db[i].expires)中挑选最不经常使用的数据淘汰

4.0 版本后增加
allkeys-lfu：当内存不足以容纳新写入数据时，在键空间中，移除最不经常使用的 key

见
数据库 -> NoSql -> Redis -> 持久化

跟计算机性能有关10万

redis 实际上是个单线程工作模型

Redis五种数据类型及应用场景

五种数据类型

redis的过期策略详解

文件事件处理器是单线程的

为啥 redis 单线程模型也能效率这么高

redis 实现高并发主要依靠主从架构，一主多从

高并发的同时，容纳大量的数据，需要redis集群

redis 高可用，如果是做主从架构部署，那么加上哨兵就可以了

Redis数据备份和重启恢复

解决缓存雪崩的方案

缓存穿透现象以及解决方案

什么是Redis的并发竞争问题

常见分布式缓存问题

分布式系统常见的几个问题和解决办法

分布式session问题

分布式跨域问题

分步式事务

分布式任务调度

分布式锁

分布式幂等性

分布式缓存

完善_Redis高性能缓存数据库

本地缓存Ehcache

Ehcache与redis整合

spring整合redis缓存

缓存与DB存在不同步

redis缓存引发问题

服务器session作用

分布式session不一致

分布式Session一致性解决方案

出现分布式锁的原因

spring redis锁实例

zookeeper基本操作

zookeeper应用场景

zookeeper分布式锁

Java并发：分布式应用限流 Redis + Lua 实践

接口限流算法：漏桶算法&令牌桶算法

【Redis使用系列】使用Redis做防止重复提交

shiro整合redis使用

缓存失效时间变短（不推荐，治标不治本） ：我们让缓存数据的过期时间变短，这样的话缓存就会从数据库中加载数据。另外，这种解决办法对于先操作缓存后操作数据库的场景不适用。

增加cache更新重试机制（常用）： 如果 cache 服务当前不可用导致缓存删除失败的话，我们就隔一段时间进行重试，重试次数可以自己定。如果多次重试还是失败的话，我们可以把当前更新失败的 key 存入队列中，等缓存服务可用之后，再将 缓存中对应的 key 删除即可。

采用 Redis 集群，避免单机出现问题整个缓存服务都没办法使用。

限流，避免同时处理大量的请求。

设置不同的失效时间比如随机设置缓存的失效时间。

缓存永不失效。

更多脑图和最新原创技术文章可关注公众号：Java3y

所有与网络有关的

网卡，交换机

控制子网的运行，如逻辑编址，分组传输，路由

ifconfig：查看网络接口信息

ifup/ifdown：开启或关闭接口

route命令：可以临时地设置内核路由表

hostname命令：可以临时地修改主机名

sysctl命令：可以临时地开启内核的包转发

&nbsp;ifconfig命令：可以临时地设置网络接口的IP参数

ifconfig 检测网络接口配置 route 检测路由配置 ping 检测网络连通性 netstat 查看网络状态 lsof 查看指定IP 和/或 端口的进程的当前运行情况 host/dig/nslookup 检测DNS解析 traceroute 检测到目的主机所经过的路由器 tcpdump 显示本机网络流量的状态

yum

rpm

wget

useradd

usermod

userdel

groupadd

groupmod

groupdel

成批添加/更新一组账户：newusers

成批更新用户的口令：chpasswd

向标准组中添加用户 gpasswd -a &lt;用户账号名&gt; &lt;组账号名&gt; usermod -G &lt;组账号名&gt; &lt;用户账号名&gt; 从标准组中删除用户 gpasswd -d &lt;用户账号名&gt; &lt;组账号名&gt;

&nbsp;口令时效设置：

&nbsp;口令维护(禁用、恢复和删除用户口令)：

设置已存在用户的口令时效：

su

sudo

id：显示用户当前的uid、gid和用户所属的组列表

groups：显示指定用户所属的组列表

whoami：显示当前用户的名称

w/who：显示登录用户及相关信息

newgrp：用于转换用户的当前组到指定的组账号，用户必须属于该组才可以正确执行该命令

查看文本文件内容

可以分页看

不仅可以分页，还可以方便地搜索，回翻等操作

查看文件的尾部的10行

查看文件的头部20行

显示文件和目录列表

切换目录

显示当前工作目录

创建目录

删除空目录

生成一个空文件或更改文件的时间

复制文件或目录

移动文件或目录、文件或目录改名

删除文件或目录

建立链接文件

查找文件

查看文件类型或文件属性信息

把内容重定向到指定的文件中 ，有则打开，无则创建

将前面的结果给后面的命令，例如：`ls -la | wc `，将ls的结果加油wc命令来统计字数

例如：`echo &quot;Java3y,zhen de hen xihuan ni&quot; &gt; qingshu.txt `把左边的输出放到右边的文件里去

jobs：列举作业号码和名称

bg：&nbsp;在后台恢复运行

fg：在前台恢复运行

ctrl+z：暂时停止某个进程

at

cron

chkconfig

service

&nbsp;ntsysv

gzip filename

bzip2 filename

tar -czvf filename

gzip -d filename.gz

bzip2 -d filename.bz2

tar -xzvf filename.tar.gz

在文件 myfile 中查找包含字符串 mystr的行

显示 myfile 中第一个字符为字母的所有行

G&nbsp;用于直接跳转到文件尾

ZZ&nbsp;用于存盘退出Vi

ZQ&nbsp;用于不存盘退出Vi

/和？&nbsp;用于查找字符串

n&nbsp;继续查找下一个

yy&nbsp;复制一行

p&nbsp;粘帖在下一行，P粘贴在前一行

dd 删除一行文本

u 取消上一次编辑操作（undo）

使用i或a或o进去插入模式

使用esc返回普通模式

w&nbsp; 保存当前编辑文件，但并不退出

w&nbsp; &nbsp;newfile 存为另外一个名为 “newfile” 的文件

wq&nbsp; &nbsp;用于存盘退出Vi

q!&nbsp; &nbsp;用于不存盘退出Vi

q&nbsp; &nbsp;用于直接退出Vi （未做修改)

set autoindent 缩进,常用于程序的编写

set noautoindent 取消缩进

set number 在编辑文件时显示行号

set tabstop=value 设置显示制表符的空格字符个数

set 显示设置的所有选项

显示扩展属性：lsattr [-adR] [文件|目录]

修改扩展属性：chattr [-R] [[-+=][属性]] &lt;文件|目录&gt;

客户端必须设置正向代理服务器，当然前提是要知道正向代理服务器的IP地址，还有代理程序的端口。

正向代理 是一个位于客户端和原始服务器(origin server)之间的服务器，为了从原始服务器取得内容，客户端向代理发送一个请求并指定目标(原始服务器)

然后代理向原始服务器转交请求并将获得的内容返回给客户端。客户端必须要进行一些特别的设置才能使用正向代理。

（1）访问原来无法访问的资源，如google

（2） 可以做缓存，加速访问资源

（3）对客户端访问授权，上网进行认证

（4）代理可以记录用户访问记录（上网行为管理），对外隐藏用户信息

初次接触方向代理的感觉是，客户端是无感知代理的存在的，反向代理对外都是透明的，

访问者者并不知道自己访问的是一个代理。因为客户端不需要任何配置就可以访问。

反向代理（Reverse Proxy）实际运行方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器

从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器。

（1）保证内网的安全，可以使用反向代理提供WAF功能，阻止web攻击

（2）负载均衡，通过反向代理服务器来优化网站的负载

配置文件

网页文件

日志文件

二进制程序

linux nginx启动重启关闭命令

ps aux|grep nginx 和ps -ef|grep nginx一样

关闭nginx (./sbin/nginx -s stop)

./nginx -c nginx.conf

./nginx -s stop

./nginx -s quit

./nginx -s reload

kill -QUIT  进程号

kill -TERM 进程号

配置文件结构

#主模块命令， 指定Nginx的worker进程运行用户以及用户组，默认由nobody账号运行

指定Nginx要开启的进程数。

#错误日志存放目录

logs/nginx.pid;

worker进程的最大打开文件数限制

cpu亲和力配置，让不同的进程使用不同的cpu

use用来指定nginx的工作模式

设置nginx每个进程最大的连接数，默认是1024

文件扩展名与文件类型映射表

默认文件类型，当文件类型未定义时候就使用这类设置的。

设置日志模式

server_names_hash_bucket_size 128;client_header_buffer_size 512k;large_client_header_buffers 4 512k;client_max_body_size 100m;

隐藏响应header和错误通知中的版本号

激活tcp_nopush参数可以允许把httpresponse header和文件的开始放在一个文件里发布，积极的作用是减少网络报文段的数量

激活tcp_nodelay，内核会等待将更多的字节组成一个数据包，从而提高I/O性能

开启高效传输模式

长连接超时时间，单位是秒

upstream表示负载服务器池，定义名字为backend_server的服务器池

轮询

权重

ip_hash

url_hash

设置一个虚拟机主机，可以包含自己的全局快，同时也可以包含多个locating模块。

listen 80;

server_name localhost;

index index.html index.htm index.php;

root /data0/abc;

error_page 500 502 404 /templates/kumi/phpcms/404.html;

rewrite ^/list-([0-9]+)-([0-9]+)\.html$ /index.php?m=content

access_log /var/log/nginx/access.log access;

location ~ /.svn/ { deny all;}

location /

error_page 500 502 503 504 /50x.html;

location = /50x.html

nginx location 配置 正则表达式实例详解

默认是大小写敏感，前缀匹配，相当于加了“~”与“^~”

DNS将域名解析为真实ip地址和端口号

查找浏览器DNS缓存

查找本地host文件(ip与域名的关系)

访问nginx服务器地址

从网络运营商获取对应的IP地址

反向代理的好处隐藏真实内部ip地址，请求先访问nginx代理服务器（外网可以访问到）,在使用nginx服务器转发到真实服务器中

当客户端访问www.itmayiedu.com,监听端口号为80直接跳转到真实ip服务器地址 127.0.0.1:8081

外网映射的作用

外网映射的工具

蚂蚁课堂架构.png

公网服务器

局域网服务器

抓包分析反向代理跳转地址

解决高并发,减少单台服务器的压力,拦截到请求，在采用负载均衡算法后，分配到不同的真实服务器上

服务器故障转移

upstream和location配置

upstream表示负载服务器池，定义名字为backend_server的服务器池

url_hash

ip_hash

权重

轮询

当上游服务器(真实访问服务器),一旦出现故障或者是没有及时相应的话，应该直接轮训到下一台服务器，保证服务器的高可用

负载均衡的故障转移配置

如果访问的ip地址为192.168.5.165,则返回403

不允许谷歌浏览器访问 如果是谷歌浏览器返回500

#当客户端访问www.itmayiedu.com,监听端口号为80,直接跳转到data/www目录下文件

#当客户端访问bbs.itmayiedu.com,监听端口号为80,直接跳转到data/bbs目录下文件

#当客户端访问www.itmayiedu.com,监听端口号为8080,直接跳转到data/www目录下文件

#当客户端访问www.itmayiedu.com,监听端口号为8081,直接跳转到data/bbs目录下文件

不支持post请求，代码书写比较复杂

前端Q向后端B发送请求，Q先请求后端A，后端A请求后端B,获取数据后响应前端Q

response.setHeader(&quot;Access-Control-Allow-Origin&quot;, &quot;*&quot;)

原理：保证域名和端口号是相同的，根据不同项目名称使用nginx转发到真实服务器地址

解决了运行环境和配置问题软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。

一次构建、随处运行

新浪

美团

蘑菇街

......

docker官网：http://www.docker.com

docker中文网站：https://www.docker-cn.com/

Docker Hub官网: https://hub.docker.com/

yum install -y epel-release

yum install -y docker-io

安装后的配置文件：/etc/sysconfig/docker

启动Docker后台服务：service docker start

docker version验证

https://docs.docker.com/install/linux/docker-ce/centos/

安装步骤

是什么

注册一个属于自己的阿里云账户(可复用淘宝账号)

获得加速器地址连接

配置本机Docker运行镜像加速器

重新启动Docker后台服务：service docker restart

Linux 系统下配置完加速器需要检查是否生效

基本同上述阿里云

docker run hello-world

run干了什么

列出本地主机上的镜像

OPTIONS说明：

网站

命令

下载镜像

docker pull 镜像名字[:TAG]

删除镜像

删除单个

删除多个

删除全部

结合我们Git的学习心得，大家猜猜是否会有 docker commit /docker push？？

docker pull centos

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

docker ps [OPTIONS]

两种退出方式

docker start 容器ID或者容器名

docker restart 容器ID或者容器名

docker stop 容器ID或者容器名

docker kill 容器ID或者容器名

docker rm 容器ID

启动守护式容器

查看容器日志

查看容器内运行的进程

查看容器内部细节

进入正在运行的容器并以命令行交互

从容器内拷贝文件到主机上

从Hub上下载tomcat镜像到本地并成功运行

故意删除上一步镜像生产tomcat容器的文档

也即当前的tomcat运行实例是一个没有文档内容的容器， 以它为模板commit一个没有doc的tomcat新镜像atguigu/tomcat02

启动我们的新镜像并和原来的对比

直接命令添加

DockerFile添加

备注

以上一步新建的镜像zzyy/centos为模板并运行容器dc01/dc02/dc03

它们已经具有容器卷

先启动一个父容器dc01

dc02/dc03继承自dc01

回到dc01可以看到02/03各自添加的都能共享了

删除dc01，dc02修改后dc03可否访问

删除dc02后dc03可否访问

新建dc04继承dc03后再删除dc03

结论：容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止

编写Dockerfile文件

以我们熟悉的CentOS为例

1：每条保留字指令都必须为大写字母且后面要跟随至少一个参数

2：指令按照从上到下，顺序执行

3：#表示注释

4：每条指令都会创建一个新的镜像层，并对镜像进行提交

（1）docker从基础镜像运行一个容器

（2）执行一条指令并对容器作出修改

（3）执行类似docker commit的操作提交一个新的镜像层

（4）docker再基于刚提交的镜像运行一个新容器

（5）执行dockerfile中的下一条指令直到所有指令都执行完成

基础镜像，当前新镜像是基于哪个镜像的

镜像维护者的姓名和邮箱地址

容器构建时需要运行的命令

当前容器对外暴露出的端口

指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点

用来在构建镜像过程中设置环境变量

将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包

类似ADD，拷贝文件和目录到镜像中。 将从构建上下文目录中 的文件/目录复制到新的一层的镜像内的 位置

容器数据卷，用于数据保存和持久化工作

指定一个容器启动时要运行的命令

Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换

指定一个容器启动时要运行的命令

ENTRYPOINT 的目的和 CMD 一样，都是在指定容器启动程序及参数

当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发

Docker Hub 中 99% 的镜像都是通过在 base 镜像中安装和配置需要的软件构建出来的

编写

构建

运行

列出镜像的变更历史

都是指定一个容器启动时要运行的命令

CMD

ENTRYPOINT

mkdir -p /zzyyuse/mydockerfile/tomcat9

在上述目录下touch c.txt

将jdk和tomcat安装的压缩包拷贝进上一步目录

在/zzyyuse/mydockerfile/tomcat9目录下新建Dockerfile文件

构建

run

验证

结合前述的容器卷将测试的web服务test发布

tcc执行过程

写消息的过程中，消息没有到达rabbitmq在网络传输过程中就丢了

rabbitmq接到消息后先暂存到自己的内存里，结果消费者还没来得及消费，rabbitmq挂掉了

消费者丢数据一般是因为采用了自动确认消息模式。至于解决方案，采用手动确认消息即可。

准备文件

配置文件policyBatches-message-producer.xml

PolicyBatchesMsgSenderImpl

TestPolicyBatchesSenderImpl

配置文件policyBatches-message-consumer.xml

PolicyBatchesMsgConsumerPolicyImpl

PolicyBatchesMsgConsumerEndorImpl

TestPolicyBatchesConsumerImpl

Spring Boot系列十三 Spring Boot集成RabbitMQ

Spring Boot系列十五 spring boot集成RabbitMQ 源码分析

Windows环境安装与配置RocketMQ

RocketMQ-Console安装、使用详解

springboot的RocketMq实例

RocketMQ-延迟队列

RocketMQ-死信队列

RocketMQ-重试队列

1.解耦

2.削峰

3.数据分发

1.系统可用性降低

2.系统复杂度提高

3.一致性问题

顺序消息生产

顺序消息消费

延时消息生产

延时消息消费

过滤消息生产

过滤消息消费

事务消息生产

事务消息消费

下单组件图.png

下单时序图.png

失败补偿机制

生成预订单.png

扣减库存(库存服务)

扣减优惠券(优惠券服务)

扣减余额(用户服务)

确认成功

确认失败

发送订单确认失败MQ消息

支付组件图.png

支付流程图.png

创建支付订单.png

支付后回调.png

消息存储方式.png

消息生成者发送消息

MQ收到消息，将消息进行持久化，在存储中新增一条记录

返回ACK给生产者

MQ push 消息给对应的消费者，然后等待消费者返回ACK

如果消息消费者在指定时间内成功返回ack，那么MQ认为消息消费成功

MQ删除消息

文件系统&gt;关系型数据库DB

RocketMQ消息的存储是由ConsumeQueue和CommitLog配合完成 的

RocketMQ的消息是存储到磁盘上的，这样既能保证断电后恢复， 又可以让存储的消息量超出内存的限制。

RocketMQ分布式集群是通过Master和Slave的配合达到高可用性的。

Master和Slave的区别

在Consumer的配置文件中，并不需要设置是从Master读还是从Slave 读

当Master不可用或者繁忙的时候，Consumer会被自动切换到从Slave 读。

当一个Master角色的机器出现故障后，Consumer仍然可以从Slave读取消息，不影响Consumer程序

消息发送高可用设计.jpg

Topic的多个Message Queue创建在多个Broker组上（相同Broker名称，不同 brokerId的机器组成一个Broker组）

当一个Broker组的Master不可 用后，其他组的Master仍然可用，Producer仍然可以发送消息

RocketMQ目前还不支持把Slave自动转成Master

如果机器资源不足， 需要把Slave转成Master，则要手动停止Slave角色的Broker，更改配置文 件，用新的配置文件启动Broker。

producer负载均衡.png

Producer端，每个实例在发消息的时候，默认会轮询所有的message queue发送，以达到让消息平均落在不同的queue上。

由于queue可以散落在不同的broker，所以消息就发送到不同的broker下

集群模式

广播模式

消息队列 RocketMQ 会自动不断进行消息重试（每次间隔时间为 1 秒）

应用会出现消息消费被阻塞的情况

在使用顺序消息时，务必保证应用能够及时监控并处理消费失败的情况，避免阻塞现象的发生

无序消息的重试只针对集群消费方式生效；

广播方式不提供失败重试特性，即消费失败后，失败消息不再重试，继续消费新的消息。

死信消息特性

死信队列特性

某些因素导致消费者无法正常消费该消息，需要排查可疑因素并解决问题

在消息队列 RocketMQ 控制台重新发送该消息，让消费者重新消费一次

发送时消息重复

投递时消息重复

负载均衡时消息重复

真正安全的幂等处理，不建议以 Message ID 作为处理依据

最好的方式是以业务唯一标识作为幂等处理的关键依据

拉取镜像并启动

测试是否安装成功

海量的存储：主从型分布式存储，存储空间方便拓展

fastDFS对文件内容做hash处理，避免出现重复文件

fastDFS结合Nginx集成, 提供网站效率

fastdfs上传文件流程.png

写操作的时候，storage会将他所挂载的所有数据存储目录的底下都创建2级子目录，每一级256个总共65536个

新写的文件会以hash的方式被路由到其中某个子目录下，然后将文件数据作为本地文件存储到该目录中

fastdfs下载文件流程.png

当客户端向Tracker发起下载请求时，并不会直接下载，而是先查询storage server（检测同步状态），返回storage server的ip和端口

然后客户端会带着文件信息（组名，路径，文件名），去访问相关的storage，下载文件

良好架构单体应用优先

单体应用组件分离微服务

粗粒度服务，之后再拆分

前端

后端

git pull

git更新步骤

解决fatal: refusing to merge unrelated histories

fatal: &apos;origin&apos; does not appear to be a git repository

. git 中 rebase 和 merge 有什么区别

缺少 sudo docker pull gitlab/gitlab-ce:latest