马士兵-MCA-架构师课程笔记-七-

马士兵 MCA 架构师课程笔记（七）

系列 6：P70：Spring源码基础讲解 - 马士兵学堂 - BV1RY4y1Q7DL

在ppt上面我大概列了几个五个问题啊，大家看一下这五个问题，你们在面试中有没有被面试中面试官问到过。

好吧，我觉得这几个问题啊，面试还是问的很常问的吧。

那么你们对于这些问题的回答是什么样子的，当然我也知道像这几个问题啊。

是我们的同学面试反问回答的问题，网上也有很多的帖子。

去给你整理一套文字性的表述，让你进行回答，但是我再说一件事。

如果你现在纯靠啊背诵面试题这种方式。

你基本上是过不了面试的，过不了面试的好吧，固定面试他可能蒙的过去就背八股文。

但如果到中高级的话，你想去通过背诵八股文的方式过面试梅西好吧。

所以重点是什么，你要对它的理解。

那今天我们来统一的讲一下怎么里面的框架啊，咱们这个框架好吧。

讲课的时候一样啊，呃我这人喜欢画图，我们直接画图来给大家进行描述，一会我会在课程里面穿插到，我们刚刚涉及到的五个问题，都会给大家讲清楚的啊，你好好听课，ok来先说第一个吧，spring spring啊。

我就所有人在用吧，在公司里面你们可能会用spring boot，可能会用spring cover，无所谓什么技术，但是它最终的底层基础支撑都是我们的spring吧，而且每个学生在刚接触框架的时候。

基本上都是一spring开始的，那面试的时候经常会问到一个问题，说来你给我谈一下你对spring的理解，当问到这样问题的时候，告诉我怎么回答，有思路吗，我们还是一样，我们我们围绕着面试来说好吧。

谈一下你对spring的理解，这个怎么说，怎么表达呀，很多同学啊其实是非常害怕，或者说惧怕这种宽泛性这种问题的，在我看来，我觉得这东西啊它是非常容易的一件事，为什么。

因为你答的东西只要跟spring沾边，都不能说你错，那个同学在面试的时候经常会怎么表述，基本上会提到两个名词，第一个是l c我们叫控制控制反转，第二个叫什么叫l o p叫面向切面编程，然后呢。

你们可能会描述一下，l o k好解决什么样的一个问题，a o p解决了什么问题，然后到这个环节的时候，基本上戛然而止了，我告诉大家，你们以这样的方式去表述，百分之百是不对的，对有同学老师。

我在i o c的时候还会提另外一个东西，叫d i对吧，提到一些名词，这些名词告诉大家谁都会，你要凸显的是什么，你与别人不一样的地方，所以你在你这个问题的里面，你要贯穿进去。

你对于整个spring体系的理解，那么在回答问题的时候要怎么去回答，告诉大家一定要回答一种方式叫总分，什么叫总分，既然说明清楚好吧，总的spring理解是什么样子的。

你可以说spring是一个轻量级的框架啊，简化我们的开发，明天重点包含两个模块，一个啊两个功能，一个叫l o c，一个叫a o p，l o c叫控制反转，原来我们在使用对象的时候，必须要自己去new。

然后才能进行雕啊，现在使用l o c之后可以干嘛呢，由容器帮我们来创建对象，并且由容器来帮我们管理对象对吧，减去我们很多的一些呃，开发代码上面的一个成本，好提高我们对应开发的一个效率。

lp叫什么叫面向切面编程指标，面向切面编程呢，我们在使用的时候，需要嵌入一些跟业务无关的一些核心代码的时，候，可以在a op里面进行操作，比如说日式权限的增加，都可以在a op里面进行操作。

很多同学基本上这样描述，你聊完之后就结束了啊，这样说我不能说你错，但我只觉得这样说不是特别完整，那么下一步你要紧跟着说什么，这上面是对i o c和a o p的解释。

那么紧跟着我希望你能说出对于spring的理解，那服装是什么，说完这些点之后，你可以加一句话，其实在我看来，spring的本质是什么，是一个容器，虽然我们把它当成框架来用，但是呢基本上是容器好吧。

除了容器之外呢，我c还有一点是我自己的理解叫生态，因为我们现在在公司里面用的主流的框架，基本上都是在spring的基础之上，上层框架，比如说spring boot，spring color。

spring data，jpa，spring security等等一系列相关的点好，这是它对应的东西，那么我们要了解的是什么，在整个spring里面，最关键和最核心的就是我们整个ioc容器里面。

如何帮我们去创建好吧，以及管理对象的，那么这里面必不可少的，要涉及到我们的什么ban的生命周期问题吧，你是不是可以把病的生命周期带出来，再带到b的生命周期的时候，你可以提到spring源码里面。

它有哪些具体的扩展点，提到扩展点之后，你必然会提到一个东西叫being post processor，提到being post processor之后，必然会提到a o p。

提到l o p之后再解释a op的详细功能，能理解我刚刚说的这个思路吗，能力的来给老师扣个一，能听懂吗，就是什么叫体系性回答，你要给别人展示出你自己不一样的地方，怎么去展示。

因为一般同学基本上回答完这个东西结束了，你不会有自己的理解，那后面你要去贯穿上你的理解，什么病的生命周期了对吧，a o p的一些简单的应用了的实现原理了，这些东西啊，包括动态代理对象啊。

这些东西你是可以能输进去的，你要把它揉到一块儿去，给面给面试官的感觉是什么，这个人还了解过源码，或者说看过源码，或者说对这个技术框架是有深入理解的，要给人这样一个感受，明白意思吧好吧。

这样的话你的薪水能高上去，但如果说老师我对这东西不理解啊，我到现在对于spring也简简单单的就是一个会用，哪怕我对应面，就是面试中问到我那个病人生命周期问题，我都是提前一天去网上搜一个帖子。

我背下来了，我把它背完之后对吧，我这边正好给你算出，至于你说的那个扩展点，我压根不知道是啥，这个别慌，今天这节课我们第一个点，我先帮你去把整体的思路给你贯穿起来，好不好，从下面哈好好听课啊。

来我刚刚啊已经做了一个范本了好吧，有兴趣的同学下去之后，可以把我刚刚说的那套东西好吧，整理成一个文字描述，然后自己往里面填肉啊，把各种细节都填充完整了，那下面我要说的是什么。

是整体的spring框架的实现原理，l o k的整体的实现机制好吧，spring怎么解决循环依赖问题，这个是一个比较大的问题，明天我会专门拿出一节课来表述，别着急好吧，什么画图软件叫枫叶云笔记好吧。

这个画图软件大家如果想要的话，可以去下载一下好吧，枫叶云笔记。

系列 6：P71：spring加载bean的过程及框架的扩展 - 马士兵学堂 - BV1RY4y1Q7DL

来接着来讲我们的spring spring，最开始提到之后，第一点他一定是个什么容器吗，好吧，容器干嘛的，用来装载东西的，比如说我们的水杯水壶水缸对吧，对于我们的应用程序而言，它用来放什么。

放我们的定对象，当然里面可以放一堆的，并对象不只是一个n多个好看，你个人的一个需要钱吗，多少个放多少个，那这个时候你想我们如何去把i o c给它，融融融融融到一块呢，ioc是个容器。

我们可以把整体这个框框认为i o c容器里面，b对象它是如何帮我们去创建的，或者换一句话说，谁能告诉我，spring是怎么知道你要去创建哪些对象的，怎么创建，先不管他怎么知道我要创建这些对象啊。

通过什么来知道好，同学们通过什么看，也就是说我们其实是有些方式，可以让死人感知的，比如说最开始学习的时候，很多人接触的时候用的是xm 2，上面配置文件嘛对吧，然后后来呢大家可能为了简简简化操作。

我们更多用的是注解，不管是ta也好，还是我们的注解也好，包括我们的配置类也好，这些方式里面它都是定义好了，预先存在的并对象，帮我把那些并对象定义好之后，然后我就要容器来帮我们管理。

那这里面定义的到底是个啥呀，对像零零后的程序员可能都没有写过xm，因为现在很多机构讲课的时候，基本上都是直接以配置文件，直接以这个注解的方式来讲，但是坦白说我要提一件事。

我还是希望大家能够好好的把插m文件，这种方式理解一下的，因为它是根，但是本质，如果你能把xml文件的方式理解得很透彻的话，对于注解的方式更容易理解，好吧，我问一下上面文件也好，数据也好。

它里面定义的是啥啊，比如说老师定义的类定义的病吗，其实这里面定义的应该怎么说，他叫病的定义信息，我希望你们这么去描述它叫bean的定义信息，比如老师什么叫病的定义信息啊，我们想创建出一个对象的时候。

如果用反射的方式的话，我必须要知道他的一些内心期望，写一个案例吧好吧，比如说我这随便写一个配置文件，对于很多零零后没见过小孩，我给你们写一下好吧，写有很多零零后程序啊，你不要觉得这事很难啊。

比如说写一个叫beta source对吧，class，等于com点回味一下这种方式，动力的报，第二个一data，boss可以这么干嘛对吧，然后加上之后里面会有我们对应的property属性。

name等于写一个，写一会儿，然后呢value给一个the dollar，大括号b d b c点，user name，当然里面还可能包含一些其他的一些属性值，对啊我这不写了好吧。

然后最后再来一个闭合标签，这不就是我们病的一个定义吗，像这样的一些定义，什么叫病的定义信息，比如说里面的什么id的属性了，class的属性了，name的属性了，y的属性了。

这些这种东西都可以成为定义信息，我这获取到这些完整的定义信息之后，我才能够去创建出一个具体的并对象，在这里面会涉及到ta也好，注解也好，就是定义的都是这样的，b b信息，有了这些b信息之后，我会干嘛。

我要预先把这些bean的信息，加载到我们整个容器里面去吧，因为加载完成之后，在容器里面我才能够去把对象给充电出来，如果不在不加载进去的话，在外面放着，我是识别不到的，对。

我是必须要有这样当前这样的一个加载过程的，因此在这个地方你可以这么写，在评论里面，它提供了一个默认的接口，用来承载这些具体的信息，比如说叫b，所以你看这个单词的名字。

你能猜出来它翻译过来不就叫病的定义信息吗，是不是意思注解也一样的，注解最终在解析的时候也要把它转换成一个，然后我通过各种方式可以把我们叉m2 加进来，可以把我们的注解加进来，最终都组装成这样一个对象。

这没问题吧，来到这块能听明白的同学给老师扣一，能听懂吗，没问题吧，那有没有同学会好奇啊，老师我这样pr文件是如何组装成这对对象的，如果是你让你来实现，你现在有一个xml文件，你怎么把它组装成这样的对象。

能做吗，可不可以做，可以吧，第一步，刚开始我是开发文件，下发文件，有了之后可以干嘛，是不是可以把这些读物文件给读过来，你告诉我读文件用什么方式，无文件用什么方式，io流io流的方式把它给读取过来。

好读取回来之后，先把它放到我们对应的内存里面，放内存之后别忘了它是内存里面的一个数据了，顶着要干嘛，说白了上面文件里面放的东西，在我看来就是一堆字符串，那这些字符串。

我如果想把这些字符串给充分的利用起来的话，我要怎么做，说好的对象，那你们别忘了，ta文件是一种非常独特的具备特殊格式的文件，所以在这里面我可以通过什么，比如说f a x对吧，比如说到我方c，这样的方式。

我是不是能把插m文件转换成什么东西，document文档类型吗，当我有了这样一个文档类型对象之后，我是不是意味着里面就包含了对应的父子节点，对吧。

里面有堆的什么note note note note对象有了note之后，我能不能通过循环的方式，把note里面的每一个属性值，属性名称把它取出来，取出来之后我能不能设置到我们对象里面去，设置到bp中。

可以这么做吗，可以吧，这个流程能听懂吗，如果让我们自己操作的话，我们一定会这么干，于是源码里面也是这么做的，跟我们想的东西是一模一样的，只不过很多同学没看过这些原版，所以感觉这东西好像很难的样子。

其实不难，你就按照你传播的手段做操作就可以了，bd是啥，bd不是ban definition吗，我这儿我这儿写不下了，所以我写了个bd叫bean definition，好明白意思吧。

如果大家不信这公司的话，我们可以来验证好吧，在验证呃，我问一下有多少同学在私下里边自己看过源码，给老师扣个一，就自己尝试看到过这个东西，不是让你在项目中用的，是帮你帮你把这个流程梳理清楚。

你面试的时候能跟面试官去吹牛逼，懂我意思了吗，不是让你自己在项目里面用的，一般人接触不到，好吧，如果你看过源码的话，你应该会知道啊，在源码里面很多人在看的时候，基本上会提到一个非常重要的类。

叫obstruct，application contents，在这个类里面会包含一个非常重要的方法，叫什么呢，叫reflesh，之前有人说过一句话说，如果你把reflesh的流程看明白了。

那么你对spring框架理解到位了，我们不带你看这东西啊，我带你看到处理那个配置文件的那个地方，他是在哪做的，回答，你看这个东西叫load bean definition，叫加载bean的定义信息。

点开里面我们一直往这边看啊，选它tm，然后选择这个选择这个选择这个，然后走选择，你不用跟上我的速度啊，无所谓，我对这东西很熟了，所以打的很快，你们可能跟不上啊，跟着往下听就行了。

我带你们找到具体的地方来，往这看到这行的时候，你告诉我你看到什么东西，这行代码能看到吗，比如说我们写在外面的cheml文件，会把它变成一个resource的一个对象，然后我通过这个result对象。

可以读取我们对应的数据，所以这样获取到result之后，第一步获取到我们的input stream是吧，引流了，当完引流之后，我开始对这些流进行相关的一个处理了吧，不要把数据进行处理的那么点进去。

在这一刻它有个东西，把刚刚的input source，input source里面是个input stream工作rap拿出来之后，把它组装成一个什么东西，啥是我们刚说的document的。

不管你通过xx也好，还是通过我们的端口pg也行，把它转换成一个document文档，没问题吧，那我有了文档之后在干嘛，文档是包含了父子节点关系的，就在这里面我会干嘛呢，解析出我们具体的父子节点关系。

是不是可以通过循环点进去看这块儿诶，哪去了啊，看到我开始获取到它所有的子节点，有了对应的子节点之后，我可以把他们每一个节点取出来，取出来之后我看一下，我是把它当成一个默认元素进行解析。

还是把它当成一个用户自定义的元素进行解析，是不是数据流程跟我刚刚写的一样吗。

一样吗，所以你们在看源码的时候，同学们注意了，为什么很多同学看源码看不懂原在什么地方，你看源码，你就真的是在看源码，而不是说我在不考虑东西，如果是我的话，我会怎么来考虑这件事情，或者我会怎么来创建对吧。

别人写的方式比我写的方式到底好在什么地方，这是你需要去对比思考的事情，你带着思考去学习，和你直接跟着学习，效果是完全不一样的，明白意思吗，来这块儿能听的同学被老师会议，问题吧，那中学怎么做注解一样吗。

我识别到你的类上面加了一个at component，at service，好吧，at reporitory好吧，at control，这样注解的时候把具体的类对象给你识别到，识别到了之后。

把它装成一个bd对象之后，我把这些b对象来生成我们的具体对象，不就完了吗，一样的流程一模一样好吧，但是你还要去做一件事情，同学们大mod转完之后，看起来我们好像已经把这个流程给结束了。

技术完之后紧跟着我们干嘛，叫创建对象对吧，我问一下，在框架里面创建对象一般怎么创建啊，怎么创建，能创建吗，反反射吧，基本上都是反射，很少有人用new的方式来创建我们这个对象，基本上反射也反射。

它足够灵活，能满足我们各种各样的一些需要，好看完对象之后，我可以拿过来直接用了，看起来就说好像很简单，那这个时候你就要思考了，为什么这个地方在写的这个配置文件好吧，它定义成xml文件，俗话说。

如果我把它定义成一个properties文件行不行，就我定义一个配置文件格式，这个配置文件格式呢叫properties，我在properties里面能不能也把它装成一个理对象，男孩们呢，可以吧。

那你告诉我propose和吃个包，那么区别在什么地方，不就是两种文件的解析方式是不一样的吗，我只要配置好对应的purpose，它的解析方式不就可以了吗，用解析properties文件方式解析它。

用trap文件的方式解析它是不是可以，那同样的刚刚说的用压毛是不是也可以对吧，我能不能用json是不是也可以，我只要能解析好它对应的关系不就完了吗，这个很简单，那你在这块你要去思考什么东西。

同学们想好了，不同的定义方式，需要有不同的什么解析方式吧，我要不要给它形成一个统一的规范，因为在我没读取之前，我其实并不知道我的配置文件是哪一个，是不是这意思啊，我在这块我是不是可以定义规范。

写东西叫定义，约束规范对吧，所有啊需要进行解析的操作都要实现是接口，可以不，那这样的话，不管怎么样，我后面如果有其他，如果有了其他新的配置文件，我是不是也可以实现这个接口，然后实现好接口了。

我匹配到对应的类了，我是不是可以把对应的实现类或者解析类，给它充进去，我是不是就可以解析对应的配置文件了，这块能理解吗，能理解来给老师扣个一，能不能理解，所以这就是，为什么源码里面要提供这么多的接口。

这么多的抽象类里面的原因，我要定义好对应的约束和规范，那同样的在源码里面这块会有一个东西叫什么，叫be definition，reer，好包含这样的一个对象。

当你有这样的一个对象之后，我们可以来看一下表b 10%规则。

它是不是一个接口，你接口之后我定义好对应的方法，我只需要去实现具体的子类就可以了，那这样的话我根据我不同的子类，我就可以进行配置进行识别，并且对不同的配置文件进行相关的解析工作了。

这块意思呢是吧，所以这个地方其实在源码里面，你在看的时候注意到，像spring里面有7000多个杂完类，里面有很多的接口，很多抽象类，其实都是为了方便我们进行扩展栏使用的。

只不过我们平常在做业务开发的时候，你用不到这些扩展点，经此而已，但你不能不理解其中的扩展，因为一个框架能够流行起来，或者说能够被绝大部分人认可，最关键和最核心点就在于它什么，它的扩展性，你懂我意思吧。

好，所以我希望大家时时刻刻把这两个字留意起来，我问一下，如果你们需要在框架里面做扩展的话，可以用哪些扩展方式，或者我们自己在写我们自己的业务逻辑，代码的时候，可以用哪些扩展点啊，有吗，没想到吧。

刚刚我说的接口是一个还有吗，不要说bpp和bmp可以看，听过课的同学，听过的同学，可能知道什么叫b b b和b b f p p，没听过的同学，可能不知道什么叫b b b b和b f p p。

比如说模板方法这种东西知道吗，设计模式吗。

设计模式里面不是可以扩展，像spring里面它有很多这样的扩展点，我给你看一个再找一个吧，看这里面我们找到我们刚刚说的那个，reflect方法，在瑞负债方法里面一共包含了13个方法。

你点开这个方法里面有任何子类实现吗，没死的时间吗，所以他这个东西干嘛的，就是留给子类进行扩展的，再比如说往下看这个unreflesh，这直接告诉我名字叫dostop class。

do nothing by default，我留好这个口，你说这个口之后，我就可以在这里面实现我具体的业务逻辑了，那这样我问一个问题，你们都是有经验的开发程序员对吧，你知道的，有人知道吗。

哪些地方用到这个on reflash方法了，有没有知道，啊对在spring boot里面内嵌泡沫cut的时候，是不是就是在on reflash里面进行操作的，是不是你要发现这些东西的关联性。

我为什么说spring是基础，是生态，因为很多上层的建筑和上层那些框架，都是在spring的基础之上做了一些额外的扩展功能，你下去之后可以自己看在什么boot框架里面好吧。

这一块就是用来创建我们对应的tomcat server，我们开的server就在这个步骤里面完成的，就扩展点吗，默认的时候它是dj，什么都没实现，就这意思好，听懂了吗，来这块听懂的同学给老师扣个一。

能不理解，我需要我带你们看一下spring book里面怎么扩展了吗，有需要的吗，我打开一个项目好吧，扯远了，随便打开一下午啊，我带你快速快速看一下，这个这个这个这个这个这个东西好吧，呃登子怎么看。

大概你的启动类改完成之后，这有一个run涨多少，我就直接带你们找过去了，好吧，不一行带你们看了银行再看，太浪费时间了，reflex reflesh，看到吗，从这里面reflesh一行一行点的时候。

就能点到这个refresh方法里面去，依然是这个abstract object contest，然后在里面找什么，找on reflash方法，点击之后，这默认实验没有，你点开里面太快了，冲不出来啊。

那你6g给bug启动起来好不好，我把它启动起来，好了进来之后点mc进去好吧，找到new run方法进去，再点击run方法，然后听到它核心的启动流程里面去，在启动流程里面。

下面有一个东西叫reflesh contest，找到我们的reflesh contest，这行代码好，然后点f7 进去，再点f7 进去往下走，点f7 进到refresh里面去。

super reflash里面再点f7 进去，我咱们这节课不讲spring bot好吧，我带你看看流程，你看一下这有reflesh，我刚刚在你们看的时候，这里面是不是也是reflesh。

re是reflash，两个地方是不是一模一样的，都是这个abstract application contest，好，后面这也是不算的，是刚才的类是一样的，只不过我在找的时候找的具体子类实现不一样。

我们往下走走走走走走走，准备一下走走，走到on refs这行代码里面去，然后点fc进去，这有一个super reflash对吧，再减去往下走，就是个create web server，点不进去往下走。

往下走，可填空吧，等一空之后开始获取我们的web server factory，这一获取下一步告诉你了，当前的factory是什么，这tom cat sweb server factory。

有了这个feat对象之后，我就可以根据这个工厂来创建出，我们具体的什么，他们看到server了吧，是不是东西，所以我给大家讲这么多意思是什么，一有时间我给你们讲，能报个源码好吧。

这个这个这个这个没啥难的。

我想给大家说的是什么，你要知道它其中的扩展点在什么地方，你要知道这东西啊，而且你在看源码的时候，你要时刻留意这东西，就这东西你掌握好了，才是你自己的实力提升的点，明白了吧好吧，听了废话不多说了啊。

还是一样，跟着我学学的是什么，不是说简单把这流程学会了，我希望大家学会的是什么方法，方法很重要，ok好了，我们这涉及到接口，了解到接口之后，问一个比较low的问题啊，特别low的问题。

谁能告诉我这个接口和抽象类的区别啊，讲到接口了，我说了源码里面spring源码有7000多个类，里面一定有很多的接口和抽象类，接口和抽象类有区别吗，谁能说一下，单集成多实现，这个蜡笔没了。

小心你居然听过我的课是吗啊，我要是在bw带过bw什么，很多同学啊听过我的课，应该会知道我强调过这件事情，这样的接口有什么，你们换成刚告诉什么单继承多实现什么，不能写具体的方法，代码什么之类的。

这东西没问题，但我认为你们所说的这些点统一的称为什么，叫语法上的区别点，你在面试的时候，如果只去跟别人说语法上的区别点的话，不好意思，这东西谁都会，哪怕一个小白，刚学完之后。

老师也一定给他总结了很多具体的东西，这东西不重要好吧，重要是什么，你要体会其中的设计思想，什么叫设计思想，第二口和扩展类最主要的缺区别，能在什么地方写一下，接口它本身是一种叫自上，第二下的思维模式。

而中药类，叫做就这样，向上来，这样东西能理解的扣一，不能理解的扣二，什么叫自称在下，什么叫自相上乘，之前说过乔尔同学比较多，我解释一下这件事情，你们之前在面试的时候，如果去给别人说语法上的区别。

我觉得没问题好吧，因为他这样区别没问题，但如果你想凸显的自己跟别人不一样，你要说这玩意儿什么叫自向上上，什么叫自向向上，这两种东西怎么理解，很简单，接口我们叫什么叫定义的，叫约束和规范，就意味着什么事。

我定好了规则，你的子类必须要按照我的规则实现来，没个意外好吧，推荐你什么意思，抽象类是因为你有了很多具体的子类实现，你把很多公共的特性拿出来了，变成了一个抽象类，能听懂这意思吗。

比如说我们动物动物有什么眼睛的颜色了，名字了好了，把这个属性拿出来，拿出来之后，我变成一个抽象类，其他的具体实现子类我直接继承就完事了，那接口呢我定义好了，具体的方法实现，你就必须要按照我的方法规范来。

你可以自己加，你自己加没问题，但是我我写东西你必须要有，所以这个时候你理解什么叫自上向下，什么叫自向向向上了吗，来理解的扣一，所以你面试的时候你要给别人说这东西，不是说你们说那些语法上的区别。

你说语法上的区别没有意义，好吧，显示不出你自己的技术史实力，谁说不理解，下课之后你私聊我录像，问你什么意思，sel你怎么定义的，你先定义了一个interface，里面有a方法，b方法，有三方法。

我的实现子类在实现了这个接口之后，我必须要把a b c3 个方法去重写，我可以自己再扩展一个地方法，但是我必须要按照接口里面的a b c这个方法，来对他是自上向下的一种模式，我定义好约束你来实现就完了。

而冲向类呢什么意思，我有猫对吧，有狗有肚子，这里面有一些公共的属性，比如说毛化对吧，比如眼睛，比如内蒙这样的一些名字，每个里面都有，我为了简化操作，我把这些公共的属性拿出来，变成了一个抽象类。

我的子类只需要写自己独特的属性就可以了，它是什么，它是共性的东西，它并不是定义了约束和规范，所以它是自下向上了，而接口是自上向下的，理解了吗，这东西啊你们学基础的时候，老师应该告诉我们。

那你们很多人基础的老师不讲这玩意儿，你讲完之后之后，很多人不理解，但你写这本写多了，你就理解了，明白意思吧，好吧行了，不多说了不多说了，这东西讲讲讲，扯的有点远，真没告诉我，你要你要去思考什么叫思考。

对不对，好吧好了，内部之后，我们来接着往下讲，回到我们spring来中，回到spring这块好吧，老实说背背就行。

背会你体现不了别人的差距啊，我还是那句话。

系列 6：P72：spring的增强器的处理postProcessor讲解 - 马士兵学堂 - BV1RY4y1Q7DL

好不好好了，再往上收啊，回来之后来紧接着往上写，来往这来，我们刚才说了，刚刚经过我刚刚的讲解之后，我们其实已经把我们对应的插画文件和注解，里面定义的这些bean的定义信息，把它转换成我们的bd对象了。

有了编辑对象之后很简单，我可以把对象里面的属性拿出来。

通过反射的方式，我可以创建出具体对象，当我把对象创建出来之后，好紧跟着下一步我是不是可以去使用对象了，对吧，当我的对象使用完成之后，那简哥呢，我是不是可以去销毁对象了，对啊，这是我们大概的一个流程嘛。

基本流程都要这么定了好吧，从我们的创建到使用到销毁这个流程，这个环节能理解吗，你如果这样看起来的话，spring里面的东西其实还是比较简单的，但是你想这不可能这么简单吗，如果你真的看过源码的话。

你可以点开它里面的统计，我刷新一下，你可以看一下它里面一共包含多少呢，包含了7000多个类，同学们，7000多扎完类不可能就完成这么点事儿啊。

他完成的工作一定很多，我们找一下扎拉费，你搜一下扎了1412的内这么多类，对这么多对象，这么多代码，我不可能完成这么简单的事情，所以在框架里面还是那句话，最主要和最核心的是什么。

你要体会的是它里面的扩展性，这个东西，我今天啊不止一次的说过扩展性这东西了，我希望你能把这三个字给我记到心里面去，因为这东西才是框架，或者说你自研框架的一些核心点，那这样我有什么需要进行扩展的地方吗。

或者我需要进行什么扩展吗，注意但我们的spring框架它是跟我们的业务无关的，每个人拿到辅助框架之后，你可能做比如金融方面的业务，银行方面的业务，保险方面的业务好吧，医疗方面的业务各又有点不一样。

那意味着不同的项目里面会产生不同的需要，我作为一个跟业务不仅无关的一个框架，我如何能够适配到那些所有商品里面去呢，因为我在框架的某些点里面，我要把它加进去，非常非常多的一些什么扩展点。

让用户可以按照自己的需要去随意地进行扩展，把其随意的进行扩展，这些哪是很重要的，那这有什么扩展点呢，来听我讲，我相信很多同学在看源码的时候，多多少少见到过一些一些类似于这样的描述。

叫post processor，我们叫这个东西吗，什么叫post processor，见过吧，这东西怎么理解啊，有人把它称之为叫后置处理器，没问题，后置处理器更多是什么，是直接翻译过来的。

我上课时给我们的vs前杠过，我说这东西啊，你最好把它称之为叫增强器，它是用来完成某些扩展功能存在，那在这个扩展功能里面有两个非常重要，或者说比较著名的接口，哪两个呢。

第一个接口叫be factory post processor，这是第一个，我们只说接口好吧，此类有很多，比如说接口，第二个叫b post processor，这两个是大家见的比较多的。

同时给大家用的比较多的两个接口，那这两个键有什么意义啊，或者说他们两个接口有什么区别呀。

其实你通过名字你能够发现两个东西的区别，区分点在于什么，那么针对的操作对象是不一样的，这个东西它真的操作对象是谁啊，是不是bbruary，好吧，那同样的这个东西呢，看看这是谁，是我们的并对象。

是不是他们两个针对的对象是不一样的，但是不管你针对的东西是什么，最主要的是什么，都是为了完成某些具体的扩展功能而存在的，这点是不变的，当然在这个里面，还会有很多对应的扩展子类实现。

比如说他依然会有一些子类，什么子类，我写一下，里面有一个叫b，也会包含一些子类接口实现，对此类接口实现我们就不说了啊，因为这个子类里面有东西有很多好吧，我们只说这些最关键的，所以你要知道什么。

这两个东西一个叫bean factory，post processor，一叫bean post processor，这东西我会挨个来给大家聊一下，跟大家聊一下好吧，来先说第一个。

谁能给我解释一下什么叫b factory啊，什么叫bean factory，你们对于bean factory的理解是什么样子的，谁能告诉我叫兵工厂嘛对吧，大家一般人都是这么理解的，叫兵工厂啊，告诉大家。

你翻译成兵工厂没问题，没毛病好吧，但是我希望大家看一下源码里面，对于bean factory的一个核心解释，到底什么叫并factory，其实并不是大家说的那个兵工厂。

可以来看看，它也是一个接口，再往上翻，然后翻翻翻翻到这条来翻译一下，the root interface for assessing a spring being container，什么意思。

root interface吗，跟接口干嘛的，跟接口呢用来访问一个spring定容器的根接口，也就是说我如果想访问一个容器的话，必须要通过我们的什么bean factory来进行操作啊，这好比什么意思。

很简单，看好了，我这刚刚画了一个大框，这个大框我说的就是我们的容器，就跟你家的门一样，你加个防线影，你家有个房间，你如果想进到这个房间里面去，必须要个门吧，没有门，是不是要有个窗户，你才能进得去。

那这块是一个封闭的框的，我是不是也要提到一个对应的出入口，能方便我们对里面的属性进行相关的操作，所以这东西可以理解为什么叫bb，这能理解吗，来能理解了，给老师扣一，好在这个朋友就会问老师不对。

我在平常自己进行使用的时候，我很少会用到并facer，我用的更多叫什么叫application contest，因为我在写代码的时候，我基本上是这么干的，怎么干的呢，叫contest，第二get是病。

比如说里面有个命令叫person，我写一个person加class，我是这么做的，我通过这样的方式来获取我们并对象的，注意了，这个context是谁，他翻译过来叫什么。

叫application context，它也是一个接口，那这个接口和我们的bean final有什么区别呢，你看一张类图，你知道了，application，你可以把它翻译成上下文，没关系。

i这个接口，你可以看一下这个接口，它给它的内存是ram，这个东西它继承次定factory，所以并出来的叫什么叫根接口，所有东西，如果你想去获取到容器里面的一些属性也好，方法也好，属性也好，干嘛也好。

你属性值也好，你必须要通过并better类实现，只不过我在这些具体子类的时候，我提供了一些更加强大，或者说更加完善的一些功能而已，明白了吗，所以如果我想去操作容器的话，我最应该操作的是谁。

是我们的bean factory，来关于这个bean factory能理解吗，所以我会干干什么事，可以这么来形，in factory，其实完全可以把它等同于我们当下的这个容器，因为我操作的时候。

容器里面包含了bedation，包含了我们对象，所以这个东西可以等同于我们的容器，但其实它只是一个访问的根接口而已啊，如果你把这件事理解了，那么紧跟着你再看这个接口的下面的这些注释。

和下面这些翻译的时候，你就会体会到这样一个东西，往上看，说being battery employments，说being bat子类实现好吧。

素的sport应该支持叫the standard bean，levecle interface，叫标准的bean的生命周期接口，什么意思啊，我的此类实现，必须要尽可能多的支持我的生命周期的接口，好吧。

他们the first set of information method，那their standard orders的意思，他们这些初始化的方法结合和他们的标准顺序，如下所示。

你告诉我这块里面描述的是啥，描述什么东西，这图描述啥不就是病的生命周期吗，明白了吗，所以你们很多人都去网上，搜一些生命周期的东西，用搜吗，原文里面给你写的很详细，你有本事你把这些东西搞清楚。

你自然就搞明白了，明白意思吧，所以去看那些注释的注释很有意义。

明白意思吗，所以你要把你可以搞明白了，ok当然对面出这事，一会我会敞开给你聊，不着急啊，我们先回到这块，当下这个问题之后好了，下面我就要思考了，那对于being fx的扩展，我要怎么去扩展呢，很简单。

举个例子，我刚刚在写了一个对象，写对象的大家应该觉得很特殊，很奇怪，用在什么地方啊，我这里面的这个property value，我用了一个东西叫dollar gdb c ular name。

实际上我们知道我们在进行配置的时候，一般会引入一个外部的配置文件，叫dd叫tm这配置文件对吧，这个db点，coerce文件里面，包含了我们连接数据库的四个属性，是不是这意思，那我问个问题啊。

我们前面从tm文件解析完这些东西之后，组装到bin dbs里面去之后，注意啊，躲到里面去之后，这里面的这个属性值会修改吗，会不会改，你们想想到底会不会改，肯定不敢骂你，这没必要去改它。

你这只是把原来我们写的插画文件也好，处理也好，满只能把它解决过就可以了，那下一步我明明就应该开始创建对象了，你告诉我我要在哪去修改，我要从哪个地方去修改，所以在这块的时候，就会包含了一个非常重要的接口。

刚刚说的，post吧，我在这是不是在这干什么，是不是我们可以来做一个验证，好吧，来自爆这个接口叫b。

batter dot processor，对接口好，在接口里面上面有一定的解释啊，不管它好，然后点开它有一堆的实现子类，子类是非常多的，我这不带你拿一个看了好吧，我们直接点进去。

它里面有这样一个实现子类，叫holder configure sport对吧，往上翻上面里面做一件事，看这句话还是看注释好吧，看注释怎么怎么怎么去解释这个类的，跟这个接口，他说这是一个不像的基础类。

没问题吧，这个抽象基础费用来干什么事呢，叫属性资源配置，也就是说它是应用来进行属性资源配置的，一个基础图像类啊，那进行什么属性资源配置呢，大家看叫resolve police，holders。

in ban definition，property value，在b definition里面的，property里面的value里面的站位服务操作，你再看一下刚刚我写的东西，他是在bd里面的。

是在bd的property里面吗，是在bd prop里面的value里面吗，我是不是要把这个值进行替换了，刚刚有人问我说，老师为什么要替换你，下一步就该对象创建了，创建完对象之后，紧跟着干嘛呢。

该进行属性值的设置了，你不能把这个属性值设置进去啊，所以只能在那做，只能在bean factory post processor里面做，这能理解，同学给老师扣一能理解吗，当然这一块你可以写很多个。

按照你的业务需要，你可以写很多个，你想写多少写多少个，就有人会说老师说是真的吗，是不是真的，我们完全可以来做一个验证啊，我给你验证一下，这事儿为什么不在创建对象里面做，创建对象属于jvm里面的东西了。

你一个属性值得替换，要放到jvm里做吗，啊就跟你出去玩一样，你出去玩的时候，你告诉我你要不要提前做些准备工作，什么事再好对吧，医生一些吃的喝的带好，这不是一样的吗，我要提前把这些属性做好吗。

是不是这意思，你不做好这个准备工作，你怎么去做做事情呢，就这意思，所以非常简单啊，你要把这东西搞明白了，那我们可以来做一个验证，做一个验证，怎么验证来，我带你们看一个代码，着急了再往上看。

注意像这里面我就写了一个data source，没问题吧，这些data source里面出现的都是dollar吧，都是我们占位符，那会干什么事，我就接debug，debug之后，我们直接去跳过去。

好听好内行，我们看看是不是在哪儿，在我们的bean factory post processor里面完成这个工作了，我先来验证一下，这东西很好验证好吧，这里面有一堆断点，我把断点断掉，特殊搜索。

大家来看看这块要注意了，我每次因为我编译的是源码，因为编源码的时候比较浪费时间，这都要编译一下好吧，那dmc进去拿下走，点f7 f7 ，找到我们的reflesh方法，然后往下走，往下走往下走。

怎么进来拿走，这不用管他跳过去就行了，刚才点没削完，拿走拿走到这步好了，当你到这一步之后，我们打开我们的factory，然后呢打开它之后往下找，找到一个东西叫bean definition map。

这个bean definition map里面就是啥，就是我们说那个封装好的bg对象，所以我可以打开我们的gen source，里面有一个property value。

然后这个property value value里面有个property value list，找这个意思list你看到了吗，是username，password，122ja class name。

你点开之后，你看看这个值是啥，他这个只有进行替换吗，同学们有没有替换，没有吧，我配置文件里面写的啥，对面是不是还是啥，然后写着看往下一步做一个操作，谁能给我翻译一下这句话的意思是啥，这个叫什么。

叫invoke，bean，factory tos processor，invoke，什么意思，调用执行吧，要执行并factory post product来，我们往下执行一下，走好了，执行完了。

当我执行完成之后，你来看看值替换了吗，听完了没，听到了吗，不就是在这个步骤里面，完成了这些替换职的工作吗，就这个意思好，所以你要把这搞明白了，把这搞明白了，明白意思吧，好吧，来这块能听懂。

同学给他扣个一，能听懂吗，好了完成之后来再问一个问题，再问个问题啊，我们现在我们刚刚讲了拆包文件的方式，我问一下拆包和注解，xml和注解谁先有谁后，有的是先有的注解，还是先有xml文件，上文件吧。

比如说我现在上方文件这样的一个配置方式，我先有了xm文件配电方式方式之后，我一定我要写出一个叫标准的，是解析流程对吧，这没毛病吧，就是我在有刚开始有插盘文件吗，有拆包文件之后，我要有个标准解析流程啊。

后面我有了注解，我问一下，当我有了注解之后，我是把原来的这些标准的解析流程都干掉，他说我要在这个基础上做扩展，扩展啊，肯定是不是一个扩展点，对不对，在原有流程的基础上，原有流程基础之上多扩展。

那这种问题来了，我们之前写过什么叫at controller对吧，at compu能不能干，at import，有这样的一堆注解，我问一下，包括我们的at bean，一堆这样的注解，这些注解都是干嘛的。

注解是干嘛的，是不是用来生成我们具体的，或者说用来创建我们具体的并对象吧，是不是意思好吧，那在解创建变量之前，是不是先要有bd，那你告诉我bd在哪在哪，是不是在这个bean factory里面，对不对。

如果在bean factory里面的话，我现在想对它进行扩展，能扩展吗，可以怎么做，一样你找到我们刚刚说的叫bean factory post processor，这接口说它的一个实现子类叫什么。

叫这玩意儿，不知道没见过，叫configuration class post processor，在这里面会有一个方法来处理这块，就这个方法好，这个方法里面你可以往里边点点开它，然后往下走。

变成我们的pass好吧，找pass之后找到我们的pass找他，然后你往这看，还在下面这个东西，你看那有什么东西，它会判断一下你当前注解有没有实现这个类，如果有时间这个东西的话，ok好。

我就把它声明成一个具体的注解对吧，再往上走是什么意思，process处理任何at property source这个注解的处理，往下走，要处理任何网破的干注解的处理对吧。

往下走处理任何at import注解的处理对吧，往下走处理任何at import resource注解的处理，再往下走，adb注解的处理，我是不是可以在这个环境里面完成这件事，能听懂吗。

这是不是也是空难点，就因为我现在预留出来了很多具体的扩展点，所以在后续的时候我想增强某些功能的时候。

我可以按照我的需要去随意扩展，这玩意儿就出来这个东西的核心所在，你小白啊，如果你对这个源码没看过，同学你不需要听懂，你把我刚刚说的东西，什么扩展的那事儿给我记清楚就完事儿了，明白意思了吗，能听懂吧好吧。

所以他要经过这样一系列的一个处理过程，当这样的一系列处理过程处理完成之后，好往下走，诶诶诶诶诶诶发不过来了，一条线过来好吧，当然内部处理完了好了，我现在获取什么叫完整是吧，b d对象明白吗。

完整比对象有了这个完整的bd对象之后，紧跟着我就可以去创建我们的对象了，这个时候这个创建流程他应该是一个直线，所以说从这块开始才开始，涉及到我们具体对象的一个创建，明白意思了吧。

来到这儿能听懂的同学有点扣个一，能听懂吗，这这这我我看这些东西都是从官网里面看的，或者自己研究对象里面看的，又忘了bd是啥了，不就是病单分析肾吗，哦反正你搞清楚了好了，大家搞完了之后，那下一步很简单。

该干嘛了，来创建对象，使用对象，销毁对象对吧。

系列 6：P73：详解spring的bean的生命周期 - 马士兵学堂 - BV1RY4y1Q7DL

呃说这三个步骤啊，说这三个步骤我觉得其实有点有点少，正常情况下，我们其实应该里面包含一些其他步骤的，这个创建对象其实是可以分为两个环节的，哪俩环节呢，一个叫磁力化，还有个东西叫什么呢，叫初始化。

我是希望大家把这两个步骤给分开的，一个叫实例化，一个初始化，比如说先有的我们的实例化，然后再整个我们的初始化，初始化完了之后，紧跟着才是对象，使用才是相互对象，所以当你把这块一起框起来的时候。

这是个什么东西，这就是我们面试中经常面试被问到的一个问题，不就是bean的生命周期吗，这种病的生命周期，所以你需要把这个病的生命周期好好理解一下，的bean的生命周期，能不能搞清楚了好吧。

那我这我在讲这个病的生命周期之前好吧，先说明一件事啊，什么叫实例化，什么叫初始化呀，我需要把这俩东西大家解释清楚啊，初始化实例化什么区别，注意啊，实例化只是，在内存中叫开辟空间好吧。

那初始化呢最容易理解的是什么叫属性赋值的，属性赋值，明白吗，这大家正常的理解，你也可以这样方式理解，只不过在through里面，它提供的初始化的环节会更多，或者在初始化里面做的东西会更多一点。

这东西我会放那一会给大家详细去进行描述，是打了东西哇，所以这个图我希望大家能够理解到了，这东西好好的搞清楚啊，来刚刚讲的这些东西，能理解或者能听懂的同学扣个一吧，好不好啊，不是说创建变量要创建对象。

在堆里面申请空间，是这意思，ok下面我们来解释一个问题吧，就是我们刚刚说的叫病的生命周期啊，那病的生命周期到底怎么去回答呀，这些并保存在什么地方，保存在我们的map里面去，在我们对象创建完成之后啊。

有这样一个东西，ub或者b a b音响，嗯defab这东西我这样的对象。

在这个对象里面呢，它里面包含了几个map结构，来找我们找一下看吧，这这三个东西这三东西就是什么，不在这往上翻是啥东西，这三个东西里面就用来干嘛，放我们具体的b类项目，这东西就是我们的一级缓存对吧。

这是我们的三级缓存对吧，这是我们的二级缓存，这东西明天我们详细讲了。

别着急别着急好吧，那你记住容器里面是有一定的map结构的，map结构里面放的是什么，放的是我们具体的一个对象啊，先不管它，ok我们先来把这个b的生命周期啊，啊生命周期好好去理解一下。

到底什么叫生命周期好吧，怎么理解东西啊，我相信啊，老同学之前都背过吧，啊不用截图好吧，这图我分享不用截图，没没必要截图好吧，你们就好好听课哦，保证我这个讲的东西你能消化一下，没必要去记笔记。

我这个图会分享出去的，好不好好听课，到这儿之后来，我们接着往下讲讲生命周期，我问一下生命周期你们是怎么背的呀，我相信很多同学肯定会搜索b的生命周期对吧，出来一堆帖子，非常详细，告诉你，啪一堆好了。

我背一下啊，背完之后面试去说对吧，当然有很多同学比较聪明对吧，图片看图片有一张图应该用的比较多的，就是这张图好，一共有13个步骤对吧，大家把这13个步骤给记住了，我问一下这13个步骤。

你记住了就真的能理解吗，这里面我就问一个问题，同学们，我就问一个问题，谁能给我详细的解释一下，这玩意儿是干啥的，要检查偶威尔相关接口，并设置相关依赖，就这一个步骤，首先我解释一下，理解不了是吧。

小心说对了吗，小心说是对的，除了小新，其他都不理解，好吧，我们来详细画一下这个流程好吧，画流程再次重申一件事，同学们记住了，病的生命周期不需要被听懂了吗，bean的生命周期不需要背。

你就按照正常的一个线性思维，去理解它就可以了哇，怎么理解很简单，第一个步骤，我们叫什么叫实例化，刚刚我已经解释过了，什么叫实例化，实例化干嘛了，谁要干嘛呢，就在堆空间中，申请内存，当你申请完内存之后。

我问一下那个对象的属性值是什么值啊，对象的属性值是什么，零现在还说零，现在苏联不合适吧，默认值吧，默认值好吧，你数据类型不一样，肯定是默认值嘛，对不对，然后呢，当你实例化完成之后，紧跟着第二个思维方式。

你肯定就想着老师，我实例化完成之后，紧跟着下一个步骤，我一定要开始进行，什么叫初始化，对吧，那初始化的时候还没想到第一件事干嘛，不用猜嘛，肯定是要设置属性吧，你肯定要说是属性，对不对。

那这块在描述的时候，你要怎么去描述这东西啊，你不要大人就说实例化，你说实际话是不对的或者不严谨的，你该怎么去说，你说变生命周期从对象的创建开始，第一步我们称之为叫实例化，实话是通过哪开始的呢。

通过一个非常重要的方法，那方法名字叫什么叫create叫b然后instance好吧，通过这个方法，可以完成我们具体的实例化的操作啊，那这里面怎么完成的呢。

这里面实现的核心逻辑是谁，是我们的反射，对吧，这个时候可以把你的反射技巧带一下吗，什么反射技巧，第一步我要获取到对应的class对象，第二步我获取到我们的构造器。

第三步我要开始new instance了，来创建对象，我问一下这个反射代码会吗，反正不会的，扣二反正会吗，会吗，看一下来简单写一下好吧，比如说我现在想创建一个对象，我怎么怎么写反馈呀，很简单，跪求百度。

简单写一下吧，好吧也写一下，第一步获取，对象有三种方式，第一种叫class。for name，对吧，你们在刚接触数据库的时候，下载驱动的时候都是这么干的，写一个字符串，对我来写一个class。

class等于第一种方式，第二种方式的class，等于什么东西等类名加class，没有第三个这样子，class等于对象名，点get class，这第二步对吧，第二步叫获取构造器怎么做。

ctrl c t o r等于class，点get excel，ctrl t，对不对啊，第三步叫创建，对象，然后我第二套o b j等于c t o r点，new means h就这样好了吧，这下代码啊。

谁如果反射不会的话，下去之后一定要看，好好看一下呃，反射这东西是呃基本功，我们叫童子功，这东西如果你都不会的话，我觉得你的基础知识，或者是你的技术储备是有问题的，是有问题的啊，啊为什么这么写很简单。

因为原文里面就是这么干的，我刚给大家说了，你如果看的话，可以找到这个方法，我们来看一下，说一下the creative in instance。

就这样，方法那里面第一步我先获取到我的cr c项，是获取到之后呢，我们下翻翻下面的中间都是判断逻辑，判断逻辑无所谓，还有个东西叫实例化，点开之后有一个实例化策略，选择实例化特别精确。

进来之后第一个步骤叫class class等于bd点，get in class获取到我们的卡的类对象，获取完成之后，第二步叫class get declared constructor。

获取到我们的构造器，当我有了具体的构造器之后，紧跟着通过编译tos来进行实例化，怎么说话呢，叫c t o2 点new yance好，他就完成了我们的反射，刚刚有同学提到优势啊，说老师反射不是效率低吗。

那为什么那个还要用反射呢，注意了，反射效率低，它是有数量级的控制的，你在100000加对象创建的时候，有一口气创建100000加对象的时候，才有可能效率低，就我们创建这零零星的。

对这些对象效率还是很高的啊，为啥要用being in tab，有跳是什么，是spring里面提供的一个封装类，网上提供服装类，方便我们进行相关的一些病的处理工作，你在公司里面是不是经常封装一些工具类啊。

这是一样的意思，在spring里面他帮我们提供了一个工具类，方便我们进行使用，就是一个反射，那这样能力的同学给老师扣一反射，不方便，举bug挺方便的，没啥不方便的，你不熟熟了就方便了啊，好了。

这第一个步骤，所以当这个步骤执行完成之后，我们第二步骤干嘛了，该叫设置属性，设置属性呢同样，也会包含一个非常重要的方法，发名字叫什么叫pul b，有这样方法，这个方法完成什么事情，就你们刚刚说的。

要给属性赋值，怎么赋值，要调用，set方法赋值里面就是这么干的，叫populate b，明白意思吧，啊popub，这没问题吧，这是我们正常的一个线性思维吧，紧跟着第一步，先实例化，实际完成之后。

我们该进行设置属性了，那这块能力的同学给老师扣一，这样能理解吧，我觉得这个应该方便大家理解啊，当这个步骤完了之后，紧跟着下一个步骤该干嘛了，如果你去看那张图的话，背那张图的话。

就告诉你叫什么叫检查aw相关依赖，并设置对应的一些属性，很多同学对于这个东西是模棱两可的，或者认知不清楚的，那什么叫检查并设置相关依赖呢，其实非常简单啊，先先来看一下这个接口吧。

play进入到什么叫awa这个接口接口干嘛呢，这个单词怎么翻译啊，谁能告诉我嗯，单词，感知对不对，联想到意识到通知对吧，是这个意思吧，你如果看源码的话，你可以打开这个接口看一下。

这个接口很好玩，他跟我们那个那个呃serializable接口一样，里面什么都没有，它是一个空的接口实现，那为什么要包含这么个玩意呢，或者这么个东西，它到底有什么样的意义和价值呢。

举个例子你就听明白了是吧，来举个例子有啥意思呢，写在哪，这块我写一个代码，在里面new一个class，比如叫dog，好吧，我定好dog类之后，我里面一定要干嘛，叫private int id，没问题吧。

private three name，我一定可以定义这样一些属性值，是不是这意思，当定好属性值之后，我必然要干嘛呢，写上它对应的set和get方法，然后呢，我在设置属性的时候。

我可以调用这些对应的set方法，来设置具体属性值，没问题，了解一下，我调用，公共的that的方法完成属性值的设置工作对吧，这能理解吧，一般都这么干啊，但是有一个问题。

同学们除了我们这样的一些自定义的属性之外，还可能包含一些额外的属性，什么属性呢。

很简单，也就是说在整个容器里面对象好吧。

如果按照使用者来分，可以分为几类，就是说啊按照使用出来的可分为几类，两类，第一类叫什么叫自定义属性，比如说我们写的什么person啦，dog啦，看到啦这个东西的定义属性就之外，还有个东西叫什么。

这叫容器属性，什么叫容器属性啊，叫自定义对象，就自定属性对象，还有什么叫容器对象，什么叫容器对象，就在容器里面使用的时候，或者容器在调用的时候需要对象，这有哪些啊，比如说很重要的。

我们说的叫bean factory对吧，再比如说叫application context对吧，再比如说这environment，对吧，这就是result lom，这些对象是你是我们自己创建的吗，不是吧。

都是容器，在整个运行过程中，它自己需要的对象是容器的吧，好吧，那假设我们自定义的对象里面，他如果包含了这样的属性怎么办，private b factory可以这么写吗。

private the application contest，你别说老师，我从我对象里面不需要包含这些属性，假设就需要吗，啊假设这种能怎么办，这两个都是自由的属性，这意味着一件事情。

我必须要通过公有的set和get方法，来把它给设置进去，对这里面会有一个问题，什么问题，这就是谁在什么时候调用词set方法，为什么需要举个例子啊，举个例子，你这有道对不对。

看啊你这有道道德对象到对象交给容器，调出去之后，我外面我写了一个测试类，在这里面可以怎么写呢，可以这么写，一个叫contest，第二get b dog，the class，当我设置好到对象之后。

跟对象之后，我突然就要把dog对象设置到某一个对象里面去，怎么办，或者说我需要对，只需要获取容器的其他对象来进行操作，怎么办，在dog对象中，在b对象中，啥意思呢，我报告里面我写了一个方法，写下来。

还有这个，bogo里面写一个并排骨，在这里面我需要翻译一件事，干什么事呢，叫b factory，点get b写一个，我这不传参数了，这么干，我这里面需要用这个东西，我就需要用这些pad对象怎么办。

你能保证你的容器里面严格不需要那玩意儿吗，你能保证吗，加我有这样一个代码，我我这个地方怎么办，怎么复制，你告诉我，你是不是需要把它设置成一个属性，你把它设置成一个属性之后，我是不是才能进行具体调动了。

是不是这个意思能听懂吗，啊能听懂不，为啥要设成私有属性，大哥咱们学面向对象三大特征的时候，属性不都是私有的吗，看看为啥把它设成私有属性，这就封装吗，所以这里面我就必须要干嘛。

把这个对象或者把这个属性给它赋值赋上，如果我想赋值赋上的话，我怎么赋值，我一定要调用我们的set方法，你tm病理的复制可以按你们说的来里面写，并对象class报告我写这样的东西，我里面提属性了。

property name in battery，你告诉我这写谁，你告诉我这写什么东西，我写啥，你要想水泵，你必须要干嘛，是不是有一个对象在这，你没对象，你写啥，你咋写，你写不了。

你喜欢那玩意儿就没法这么干，完了怎么办，所以我要把对象给他设置进去，设置进去之后就是一件事，我是需要调用我们的set方法，来给大家进行处理的，这有一个set back battery。

下面有一个set of pication contest，那这里就有个问题，就是谁在什么时候调回复方法，谁在什么时候掉，第一个问题，谁要告诉我，谁来教，是我们自己去掉吗，不是吧，肯定是容器。

第二个问题在什么时候的，啊什么时候初始化，你说这个初始化是不是太绿太太粗了，别忘了这还有个set factory，in factory，还有个set of context。

我如果在后面再加一个environment，我这可能还要再加一个这set in warm，什么表，所以你很难判断，因此怎么办，很简单，能否，这是一个统一的接口来作为标识好，当实现此接口。

到时候来统一的设置这些属性操作，什么意思，当你打开aware接口之后，你可以搜一个接口叫be，待会aw，它里面有一个框叫什么叫set bean factory。

当您打开这个叫application compass aware的时候。

它有一个方法叫什么叫set of application compass。

当你需要environment的时候，还有一个environment awa接口叫set environment。

看到了吧，所以我可以做什么事情，我只需要在当前这个类上面，加上一个东西就行了，加什么叫impliment，对吧，application context aw对吧，environment。

aw我里面是不是已经包含了这些测试方法了，那么我在进行这些属性值设置的时候，怎么判断，我只需要判断一下这个病对象，instance of aware不就完了吗，怎么做一个做成判断。

第一步括号并instance of w对吧，里面可以做什么设置，if，变instance叫bean factory aware，应该怎么调并点set bean factory，我是不可行设置啊。

能听懂这意思吗，我不可以这样逻辑判断，所以在这里面它也是一样的，在这个方法在里面的调用awa相关接口里面，都是说做什么事情，它所对应的方法也非常简单，就我刚刚说的叫inno。

嗯aware methods，这东西有这玩意儿，你可以打开我的钥匙看看，看到了吗，你能不能做这样设置工作啊，能同学们能吗，听懂了没，这儿听懂了没，这没问题吧。

所以你再反过头来想一下什么叫调用啊，vr相关接口并设置相关依赖，这句话怎么去理解，啊怎么理解，这一步是不是也是设置，属性上面设置什么属性叫自定义属性，下面呢找容器对象属性，听懂了吗。

所以他们两个包含在一块的时候，都属于什么操作，加上这个底，这个底，他俩统一叫做设置属性，懂了吗，啊明白意思吗，你现在你你想什么，叫检查偶尔相关接口并设置依赖，有这玩意吗，就调用这些方法吗。

完成这个工作吗，来听我的扣一，明白了吧好吧，所以把这东西理解清楚了，理解清楚了，当这一块搞明白之后，紧跟着下面再来注意了，现在实例化堆里面已经有内存了，点跟着我的属性设置完成了，属性设置完了之后。

紧跟着郭凤龙还在那说啊，威尔接口做什么用的，我讲了半天，我在讲啥，哪个在那个设置自定义属性，在前期属性在后好吧，明白了吗，所以当这个步骤做完之后，其实我这画一个大箭头，正常情况下。

在我们自己在创建对象的时候，你告诉我我自己创建对象的时候，是不是创建完之后就结束了，就这样可能划分一下，你要划分一下，很简单，当这个步骤，当上述方法调用完成之后，的对象能否直接拿过来进行使用，那么。

我告诉陈说了，要是自定义对象，这个时候还没在容器里面怎么办，你容器创建的时候已经把这些东西创建好了，明白了吗，他在前期的时候有很多对应的依赖，已经提前把对象创建好了，不会出现你说的那种情况。

压根不会出现，你想去看原版就知道了，别这样，天都准备好啊，这个地方能不能拿这些使用啊。

可以吧，是可以的，但这个时候你要思考一件事儿，什么事儿，还是我们之前说的什么，它是一个框架呀，我不可能拿过来就直接使用了呀，对不对，我发干嘛，比如老师是不是该纳入容器管理了，围绕这块拿什么操作。

判断是否需要对病对象进行，什么扩展又是扩展这个点，所以当这个步骤我结束完了之后，紧跟着会做什么工作，做一件事叫执行铺，叫前置处理方法是有前置，意味着一定有后置，叫执行，后置处理方法很多，很懵逼。

老师什么叫前，这是什么叫后置，这样东西到底怎么样去理解，好吧，它与生俱来对应的，是我们的另外一个对象，就是我在前面已经给大家做过普及的一个东西，什么叫being post procession。

这玩意儿如果你打开这个接口的话，你会看到看一下post统帅的。

但是里面两个方法，一个叫post process for insulation，后面还有一个post process after insulation，好吧，所以这两个对应过来之后。

就是前置和后置的处理方法来，这能理解同学给老师扣一，我不需要做扩展，无所谓，我如果不需要做扩展，没关系，你跳过就可以了，如果你需要做扩展，你是不是在这里完成对吧，有什么用，并对象需要做什么扩展呀。

需要吗，我问一下，在spring里面有一个非常重要的东西，除了ioc，还有个东西叫a op，是的vip，我问一个问题，aop的底层实现原理是啥，a op的底层实现原理是啥，动态代理。

动态代理的两种实现方式是什么，第一个叫ktk，第二个叫cdd，没毛病吧，所以假设我现在这个对象，我就需要被创建动态的对象，怎么办，是不是意味着我要在中间某个步骤里面去生成，我们代理项不可能生成。

我是一定要生成的。

那如果我想生成的话怎么办，我是一个接口，所以我要去找到这个接口，这个接口里面一样，你点开之后会发现有一堆的实现子类一堆，抓住一个，找一个东西，让他叫abstract。

auto property creator是吧，你这个东西吗，当你看到这个东西之后，你找谁找它的前置和后置处理方法，我们先看前置，等一下叫before insulation。

你告诉我这个前置处理方法里面有多多，有有有多的工作吗，有做任何工作吗，没有吧，你做没是录播吗，对是录播，没有吧，前置如果没有的话，那你找谁找后置嘛，对不对，点开后置，后者里面是有处理逻辑的，那好了。

我们来看一下它的处理逻辑，我们看啊找他的方法吗，有一个方叫什么叫viper，if necessary对吧，来点f7 ，进去，点了之后往下拉拉拉拉拉拉，我进行来告诉我这个方法叫什么，叫啥。

啊叫什么创建代理，对不对，看代理，然后再点进去，往下最后一行叫propose february，点get propose，我要获取我们代理工厂，我再点进去，是不是获取我们a o k代对象。

然后来获取代理点，mc进去，进来之后发现它是接口里面的某一个实现子类，那么这个时候你再点开它的实现，此类咱们你们看到了什么什么。

cj力量a op policy和jdk dynamic a o p propose，所以很多东西跟我老是动态代理，或者a o p的入口在什么地方，这不就是入口吗，什么意思。

这不是我们刚刚看到的两种代理的方式，明白意思了吗，就从而进来的吗。

对我可以干嘛，是在我们的后置方法里面，完成我们代理对象的创建，注意这不就是我们对应的一个扩展点吗，明白这意思了吧，所以你要把这个东西给理解了，刚才我说老师为什么a o b要存在两种代理，那你让我咋解释。

谁能解释一下为什么a op要存在两种代理啊，啊为啥他就是两种方式吗，他为啥他们为啥他又提供了两种实现的方式吗，对不对，好吧，你要想用的话，你只能用这两种方式来进行实现吗，不是这意思吗，好吧。

所以把东西搞清楚了，这中间是这块处理的一个逻辑，比如说前置处理方法和后置处理方法都有，你可以来进行自己的一个实现，选择在前置处理方法里面进行扩展，也可以选择在后置处理方法里面进行扩展，你随意来挑。

看你心情，你开心就好，这么简单能明白意思吧好吧，当你这儿搞明白了之后，所以扩展点就结束了。

但是你注意了这两个扩展点中间那个接口，它的名字叫什么，叫post process before，后面有个单词叫information，什么意思啊，翻译过来叫什么叫初始化，可能是懵逼的。

老师怎么又一个初始化呀，我们最外层这块不就是初始化吗，就是又一个初始化，这个初始化是什么，他表示叫什么叫调用初始化方法，什么叫调用初始化方法呢，也很好理解，同学们，等我把这圈画完，两条线好，什么意思呢。

我们在配置某一个具体的并对象的时候，你是可以在ban对象里面加一个操作属性的，什么属性，随便点开一个，这可以加一个叫init method，就是我们说的初始化方法，当然这个初始化方法一般是不用的。

一般是不用的好吧，所以我们也没人计较这事儿啊，它对应过来的一个方法处理逻辑叫什么，我写到这边吧，叫invoke体系上，messap的最大名字叫这玩意儿啊，其实这个方法它其实并不是特别重要。

并不是特别重要，关键点是什么，在当下这个方法里面，它也包含了一个相对比比较重要的处理逻辑，什么是逻辑呢，它会判断，当前的d啊是否实现了一个东西，叫是否实现了第一alien bein这个接口。

什么叫你来能定呢，这玩意怎么理解呢，在这里面如果你实现了，它在里面会调用，一个方法，你们很多人应该见过叫up，property set，方你实现的接口，ok我才能调这个方法，如果不实现，我就不调了。

明白意思了吗，所以这块能不能理解这咋中间这块得出逻辑，我调一下，哎好了吧，明白意思吗，很多同学在公司里面应该是用到，用到过这个方法的意思，所以这个need message并不重要。

重要的是这里面这个东西，你要把这东西给理解了，懂我意思了吧，好所以这就是这块的一个处理解，当你这些东西我都做完了之后，就像你们刚刚说的，那干嘛呢，要把对象交给容器来管理对吧，当我交给容器来管理之后。

紧跟着下一步是不是掉一个东西啦，叫对象啊，使用吧，我对象使用完了之后在干嘛，是不是叫对象销毁啊，你明白吗啊，怎么交给对象，对，我告诉你怎么交个对象好吧，当你创建完完整的对象之后好吧。

你可以看到一个方法叫do create being in方法，在多亏了bin方法里面好吧，就是我们刚刚说的一些完整的处理逻辑，比如说这块引用来自b，第一步要调用aware message。

第二步执行前置处理方法，第三步执行我们的message，第四步执行后置处理方法，当然这些方法我都执行完成之后，我往回翻红眼，上面这东西处理完了，我可以把对象返回回去了，一直返回把这注册一个要销毁对象。

把对象暴露出去，当暴露出去之后，你可以找一个东西叫get，另一部分，这一方法唉不是这个，叫get pul，是要在三部分吗，找一下呃，不叫盖伦盖的新闻，是这个是方法啊，这里面可以传一个东西。

在这个方法里面有一个操作逻辑，叫它叫at singleton，在这个at singleton里面看到的vs。single object，点put，把暴露的对象给他传回去，把它放到一级缓存里面去。

然后你把它放到一级缓存里面去了好了，容器就把我们给管理起来了，明白意思了吗，就这块处理逻辑好吧，所以你要把这些东西也清楚了，这是我们说的整个病的生命周期，那时候有人会问说老师这个对象销毁，你不讲吗。

我一般不怎么进行销毁，为什么不讲对象销毁，你们有自己的销毁过对象吗，同学们，你们有销毁过对象吗，我说什么时候会触发这个效果，对象是jc，jc是垃圾回收容器，里面是可以有一个关闭操作的。

也就是说我们定义好一个具体的容器之后，比如说我们写的application context，当你定义好它之后，在这里面你可以写一个contest close方法，让你调用close方法之后。

你才会受到销毁，但是你告诉我你们谁写过close方法，每次都是直接点这东西结束吧，谁写过没写过，所以面试没问，没人问销毁你感兴趣，你就看看，不给你就算了，无所谓。

好面试，我们到目前为止没人遇到过问销毁，所以你们也不需要在这上面浪费时间好吧，把销毁这个步骤记住就行了，所以这就是我们说的这个病的生命周期，能理解吗啊同学们，大家好不好，理解我就不难吧，我还说这句话。

这东西需要背吗，我觉得不需要背，我觉得不需要背，你就跟着去听好吧，理解这个东西好吧，按照流程去捋这样的一个思路，捋这样的一个逻辑，我都说了，不用截图，我发给你们这个图，这图我给你们，二维码有好吧。

加过咱们咨询老师同学好吧，扫描二维码啊，没加没加过同学，扫二维码加我同学直接找他要好吧，把这东西给大家，把这图给大家没问题啊，刚才说老师这个宝贝说老师太粗了，肯定太粗了吗，我说了第一个干嘛。

主要是帮你梳理你整个的逻辑线，我不是说我要一行一行带着你们去debug，如果一行一行带着你们debug，我告诉你几个小时搞不定，每个小时根本搞不定，明白意思吧，循环依赖那里是不是代理会提前，是的。

如果你出现了循环依赖，那么代理对象的创建是有可能会提前的，就是明天我们要讲的东西，我告诉大家，你不需要去了解这些细节，如果你面试的时候能够按照我这样的方式，把这些东西都给面试官说清楚，面试官不会再问了。

我之前专门讲过，我们面试突击班的源码，有spring源码，我如何让你在短期之内考虑这个东西，你不需要去看源码，配件没有意义，你也没那个时间，就这个源码课sram我大概讲了80个小时课。

那vip课我讲了八个小时，你马上要面试了，你有80个小时新时间去看这东西吗，纯视频八个小时，你自己消化消化160个小时，不过分吧，对不对，所以你不可能，所以会告诉大家什么，你要掌握的是什么。

是一整个就是这个表述的方式，你要怎么去回答这个问题，让面试官感觉ok够了，我不需要再问了，明白意思吗，所以我说我之前还讲过这个东西吗，我要找一下我在专门讲过这种面试，同学们当时上课的时候，大家手敲我说。

答题技巧看好了好吧，哪些知识点12345分开描述好，避重就轻，没有重点好吧，没问题能占我面试多长时间，问的越多，可能露出来越多，所以尽量拖时间，怎么去理解这个东西怎么解释好吧，奔着怎么去描述好吧。

传一下l o p的比赛实现，并且生命周期我要怎么去描述好吧，怎么解决循环依赖的问题，我要说什么东西，你把这个搞定，就按照我说的，里面会带很多的类接口方法的名字，你把这些名字借记住了。

然后面试的时候去面试官去说这东西，面试官会感觉到哦，原来你学过，我原来你看过这个源码，明白意思吗，内部房子给vip的吧，好吧。

我说了这个图给你们，但是我这些带中文注释的这个源码我是不发的，为什么不发，解释一下，因为这是给vip在讲vip课的时候好吧，分享出来的东西，我为了讲vip课，我辛苦苦写的，如果免费给到大家。

那对vip不太公平，所以非常抱歉好吧，所以买东西我希望大家能够记住了，ok直接图我可以给到大家，这个没问题，你把整体的思路捋出来。

捋出来之后按照你整体的东西，然后你整体逻辑自己下去之后。

好好去干一下，好好去跟一下，好好去debug一下啊，这事儿比什么都重要啊，不发说个话。

系列 6：P74：BeanFactory和FactoryBean的区别 - 马士兵学堂 - BV1RY4y1Q7DL

不给了好了，来回到我们这节课上面，第一个变得生命周期能说清楚了吧，对不对，第二个重要的扩展点，第一个刚刚说的，你在执行post process里面post啊啊叫叫什么来着。

post in factory，post processor的时候，你可以有一个扩展点，那个模板方法，还有那个reflesh对吧，可以有模板方法的扩展点，除此之外，你的bb p p和你的b f p p。

是不是都是我们的扩展点对吧，这就是我们说的扩展点，你能把这三个东西给面试官说出来，足够使，因为一般人根本理解不到这个程度好吧，第三个。

bean factory和obligation context的区别不用说了吧，一个是它的子类实现而已好吧，第五个判断你对此的理解，看这个问题的时候，就按照我上课说的东西，这东西来来来来说就可以了好吧。

第四个问题刚刚没说叫bean factory和facing的区别。

有人没碰到过这个问题吗，就bean factory和factory bean的区别，有人问到过没，那我扣一这还有什么区别啊，其实区别点啊非常非常简单，大家说一下，in factory。

还有factor b，首先啊两个东西，两个东西他们都是用来创建对象的，明白了吧，都是常出现对象的，都完成这样的功能，但是我们在使用并better这种模式，来看看对象的时候，它类似于什么呀。

叫必须遵循完整的bean的生命周期，创建对象是不是意思，我问一下这个过程麻烦吗，复杂吗，你们觉得，不复杂啊，你第八下源码就试试了，你第八个下原版就知道了，很复杂，我刚刚带你看的时候，有很多逻辑判断。

跳过去的，没带你们看，如果你加上那些逻辑判断的话，它是非常复杂的好吧，所以我把它称之为什么呢，很简单，叫流水线式的创建对象，流水线式创建对象，然后就点个声音，改个能像没点烟好吧。

那第二个factory是什么意思，它更多是什么，也是创建对象，但是没有标准的流程啊，它更多类似于什么东西叫私人定制，什么叫私人定制呢，其实很简单，比如说这里面它这个接口里面会包含三个方法。

第一个方法叫什么呢，叫is singleton，什么叫tmt，很简单吧，判断是否是单例，这第一个一生都这样，还有第二个方法叫get object type，要返回对象的类型，还有第三个。

懂了要get obje，怎么着，要返回对象啊，它有这三个东西，它有这三个有什么用处呢，很简单，比如说我刚刚的报告打开我们的对，我如果在上面也实现了这个接口，这个实验在里面的方法。

这两个还有一个叫意思不分，这个如果是单位的话，返回true对吧，这不是太太保，可以返回dog。class对吧，第一个这个概率不变成，你可以怎么办，啊你怎么办，很简单，第一步。

dog dog等于又一个dog，可以不是6万，还有什么还有啥可怎么做，dog。class，点get deconstructed，点new instance，我是不是也可以返回一个到对象，对不对。

第三种我可以使用什么动态，代理嘛对吧，intensor enhancer等于又一个enhancer对象，然后在intel里面我可以设置一些set什么东西，设置一些东西，做完这些东西东西之后。

然后呢来进行进行创建，是不是也可以，然后最终我返回一个报告对象，是不是也可以，你是不是可以按照你自己的一个方式来进行，对象的一个创建，能明白意思吗，啊同学们是这意思。

所以就是他们两个之间的区别，来这块能听懂的同学给老师扣一听懂吗，所以把东西啊大家搞清楚了啊，这是这是我要讲的一些点，对于这几个问题，我希望你们在面试中，如果在面试被问到了啊，能够把这些东西啊搞清楚。

不要因为这些问题再被卡住，很难受啊。

同样的，刚刚我也带你们看了一下源码，一直在讲给大家捋思路，捋着思路。

系列 6：P75：源码学习方法论 - 马士兵学堂 - BV1RY4y1Q7DL

我问一下，听过我的讲解，你能不能总结出来说第一点啊，现在还有多同学觉得原版难的，给老师扣一，他多少同学原版难，不能的扣二好吧，按键怎么样，下面还不扣一哈哈哈哈哈哈哈，而那句话大家在看源码时。

为什么觉得难，是因为大家没入门或者没找到合适的方法，引导合适方法掌握好好学习技巧，你的学习效率会呈指数级增长好吧，所以呢下面我给大家分享个东西，要学习200的方盒，你们不要想着你们不要想着说老师。

你们有没有什么内部资料，我看完这些内部资料之后，我就能够就是把这些东西都理记得倍儿清楚，这不可能所有的技术啊，你记住，如果你觉得难的技术，他一定是所有人都觉得难，如果做完做简单的话。

他是一定要需要你去耗费时间和精力进去，然后能达到好的效果，如果你不耗费时间和精力进去，我告诉你根本学不会这玩意儿啊，它只能治标不治本，所以这里面有一些方法的东西，我需要给大家说一下，明白吗。

聪明人都是下笨功夫，这句话我非常认可，就不止一个人觉得难都难，但是你要反思一件事，就是越难的东西怎么样越值钱，把这事记心里面去好吧，学习开始哪些有哪些技巧，我不建议直接看书啊，看书会误导你的思路好吧。

看书会误导你的思路，另外有什么方法呀，第一个我要强调的，不要忽略编码中的注释，这一点很重要，很多东西啊，你们不善于看注释，源码里面，并不是说我每一行代码我都给你写注释了，并不是这样的。

而在关键性的地方我才会给你写注释，所以他写注释的地方，一定是他觉得这个东西可能会比较难理解，明白吗，所以你是必须要去看那些注释的，不要看着之后装没看到，你说老师我英文能力比较。

我看不懂注解怎么办，哎呀还有人问这样的问题，毒死人，你说这种东西它有什么看不懂的，你告诉我能不能这样啊，看到东西了吗，你能不能加一个翻译啊，大哥，怎么加翻译。

可以的，有很多插件，你翻译一下，就是这个第一点，第二点还有什么，叫仙督理脉络，好再去，抠细节，很多同学啊为什么看源码没有看进去，或者说为什么没有坚持下来，原因在于什么地方呢，原因在于很多同学手欠。

这个不是骂人的话，手欠什么叫手欠呢，就你在黑小马的时候，看到一个方法，总想点进去瞅一眼，看到一个方法点击瞅一眼，看到一个方法点击抽一等，你一直往里面点点，到最后之后懵逼了，诶我为什么要进来。

这个我干嘛来着，一脸懵，回过头来的时候也不知道自己从哪进来的对吧，这一看的时候也没看明白是个啥，就这样稀里糊涂的，你不要脸是吧，先输一场对应的脉络脉络，搞明白之后再去看里面的细节。

就比如我刚刚画了一张图，我今天我就看一个东西，就看xml文件的解析，明天就看具体的解析，后天就看being put process处理是吧，大后天就看实例化，大后天就看初始化，你一步步分开来看好。

先把脉络给他，一定要理清楚，懂我意思吧，不是这个事，第三点还有什么有建明之意，编码中的类接口好吧，方法它的名字起的还是相对于比较规范的，对你有时候看到那些方法名字之后。

你就足以猜测到他到底要表达什么意思，或者说这个到底干什么事，那这个时候你就不需要再点到里面去看了，没有意义没有意义，明白意思啊，这第三点第四点看什么东西叫大胆猜测，小新验证，你们听我bb了一晚上了。

感觉啊老师你讲的好牛逼啊，老师你讲的挺好的，但这东西是一定是对的吗，源码又不是我写的，只是我自己的理解而已，明白了吗，只是我自己的理解而已，好无力的，不一定对，只不过说能说得过去，或者说能自圆其说。

你们也是一样的，看到一个功能之后，不想去想它这么设计的原因在什么地方，他这么写的原因在什么地方，为什么这么写，去猜，猜完之后去看它的详细的逻辑处理过程，这么做到底是为了啥，搞清楚这些东西。

明白意思吧好吧，然后第五点，什么叫善于使用小插件，比如刚给大家说的翻译的translate对吧，比如说还有个东西叫sequence diagram，都可以用这些插件，你好好去看一下好吧。

理解一些东西，然后第六点很重要一点就是坚持，有点东西肯定是难，谁都知道难，我也知道，男好吧，你们所有听课的人都觉得这个东西难不难的话，你们就不会来听课了，好吧，难不怕，但是你要坚持下来。

别跟我之前讲课的时候举个例子，我说很多同学这个时候为了考四六级，背了4年就记住一个单词叫abandon，就放弃看东西都没记住，不要这样，你一天看一点点，一天看一点点，不要什么，每次都开始从头看。

你每次从头看，每次什么都记不住，明白了吗啊，所以一定要坚持走啊，搞明白这东西，你把这东西搞清楚，他会的就是会的，哪怕你忘了，你整体的逻辑思路线是不会断的，而如果你不看这东西，我告诉大家。

你以后可能会越来越难受，当有同学问我说老师源码是什么样的知识的，同学会问，你觉得沈阳这些同学会问，就是你拿多少薪水，可能会问源码，你们觉得，其实坦白说，原来的时候问原来的人其实并不是特别多，源码。

其实原来没没那么多人问，真的没那么多人问，好吧，大概就是问一下，变成生命周期，把你一背背完之后，ok结束了啊，你不用再问这东西了，但现在几乎你的薪水，如果想要到20k以上的话，基本上都会问到这东西。

问东西原因是啥，你说你工作能用吗，同学们，我问一下你工作能用吗，有很多同学都问我老师，我学学法的原因是啥，是因为我工作都要用吗，不是你工作中，我告诉你，就你们天天写一些c l o d业务逻辑代码。

系列 6：P77：图解循环依赖 - 马士兵学堂 - BV1RY4y1Q7DL

好吧废话不要这么多，下面我们来模拟一下a b两个对象的创建过程，因为啊我现在有两个ab对象了，那我在创建之前就意味着一件事我怎么做呀，首先第一个步骤画一个图啊，看看这个图，第一个叫创建a对象。

这没问题吧好吧，我问一下创建a对象的时候，要包含几个步骤和环节，第一个是什么，第一个是啥反射实例化吧，我们还有我刚才说了啊，我们说的时候只说这几个步骤，实例化也就说对吧，实例化就是绿化a对象。

当我完成a对象的实例化操作之后，我的问题是这里面的b属性此时是等于什么值，b是什么值，默认值吧，等于空对吧，然后紧跟着第二个步骤要干嘛，是不是要给，a对象的b属性，变形赋值了，那么在进行赋值的时候。

大家应该知道容器里面的对象默认是单例的，也就是说有且仅有一个对象，这下面我会去判断一个东西，判断啥，判断我们其中是否有b对象，那是否有的话，就意味着一定有一个事，下面会有两个路径，有或者没有吧，好吧。

来往上写，如果没有，如果有有的话怎么办，如果有这个值，那ok我直接赋值即可吧，是不是接完成负值了，赋完值之后好了，把它给回去结束了对吧，那如果没有呢，没有没有，它意味着下面我干嘛叫创建b对象，什么意思。

而创建b对象的时候，因为你要遵循完整的bean的生命周期，所以整体的流程和步骤是一模一样的，所以第一个步骤干嘛叫实例化b对象，当我把b对象实例化完成之后，紧跟着里面的a属性等于什么值控制吧。

依然是默认值等于now，当闹完了之后，紧跟着再进行一个事，叫做给，b对象的a属性进行赋值，那赋值的时候，这上面一样必然要经过一个判断，判断一下你到底是判断一下，判断容器中是否有a对象和我电。

要进行判断一样，两个步骤，要不然有，要不然没有，如果没有，先写有吧，叫直接赋值即可，然后把条线连过来，写一下，有是这样的，如果没有，没有就这个步骤，这能理解吗，我刚刚画这个步骤没问题吧。

所以在我刚刚画的这个步骤里面，你能不能看到一个非常简单且直接的闭环操作，这么长吗，小一点，看这个你看到了吗，这就是我们说循环依赖吗，在整个整个执行过程里面，它形成了一个闭环嘛，是这意思，死循环吗。

那死循环其实就是我们要解决的这个，循环依赖的问题，这是为什么面试中经常问这个问题，好吧，那我们怎么样去解决这个问题啊，很多同学在遇到这样问题的时候，说老师完了形成闭环了，这个闭环我要怎么解开。

你记住所有的闭环不只是循环依赖啊，任何地方你在遇到闭环的时候，你要想解开这个闭环思考的维度是什么，在哪个地方是最后一个步骤落成了闭环，我们刚刚画这张图的时候，在这这个步骤是形成闭环。

假设这条路径如果没有的话，把删掉，如果没有的话，还会有这个闭环吗，不存在了吧，所以这个事你就要思考一件事，我能多把这条线给他干掉，比如说这个线发生存在，因为这条线只要不存在，ok我的闭环就没有了。

那这个时候你就要思考另外一件事，同学们什么事情呢，我这是要去查找我们容器里面是否有a对象，那你告诉我在整个容器的创建过程中，我在整个对象的创建过程中，到底有没有a对象就执行到这一步的时候。

有没有a对象有，有吧其实是有的吧，好吧，哪创建a了，在刚开始的时候，我们在执行前面这块的时候，其实我已经把a对象给创建出来了，只不过此时的a对象，它不是我们理解的那种完整对象，是一个非完整对象。

所以此时我来给大家一个描述，就是你们在很多帖子上看到的一个描述，第一个描述什么叫成品对象，第二个叫半成品，半成品，什么叫成品，什么叫半成品呢，很好理解，所谓的成品指的是完成实例化且完成初始化。

那什么叫半成品呢，也是一样的，叫完成什么实例化，但未完成初始化来这两个东西能理解的，同学给老师扣一能理解吗，什么问题吧，很简单的一个知识，所以当我拿过来这块之后，你会发现此时我在找a对象的时候。

a对象实际上是有的，那你告诉我a对象现在是成品还是半成品，层面上慢慢变半成品吧，我说了不是完整对象吗，所以是个半成品，那这个时候就会有一个问题，同学们听好了，我下面这段话的描述。

如果只有了某一个对象的引用，那么能否在后续步骤的时候，对该对象进行赋值操作，能还是不能最小吗，你们看这字儿再大一点，看的东西，这能理解吗，就如果我持有某个对象引用，能否在后续的时候给它进行赋值。

可不可以，可以吗，因为你在堆里面生存的空间，说白了就是一个地址，我只要有一个指向性的一个地址，那好了，我就可以干嘛，拿到b地址的引用来进行对象的一个复制操作，对完了吗，对这个步骤是可以的。

如果是可以的话好，那现在你要去想一件事了，想什么事，我们再把刚刚那个步骤重新去执行一遍，刚开始我先去创建a对象，创建完a对象之后，紧跟着叫实例化对象，b等于n，我现在把这个对象我放到一个结构里面去。

什么结构呢，在中间这块我放一个map结构，这可以吧，那分结构在结构里面段位是我放的时候，因为现在上创建出a对象了，对k的值就是我们的a没问题吧，我问一下现在的a是什么状态，成品还是半成品，啊。

成品还是半成品啊，半成品吧，我把这个半成品对象先记录到我们map里面去，或者说先放到我们map结构里面去，把这来连起来，紧跟着我开始给a对象里面的b属性，进行赋值操作，在赋值的时候。

紧跟着我要去判断容器里面有没有b对象，同时我判断一下当前的缓存里面，它有没有b对象，我们通过这个判断，你能判断出来，这里面我中间画了个map里面那包含了b对象吗，看有没有对象，对不上有吗，没有吧是吧。

没有没有的话好了，我紧跟着往下面走，到这步叫创建b对象，当我执行完实例化b对象之后，会紧跟着我往上，我也连一条线过去，那此时我可以把我们的b对象也放进来，b冒号它也是一个半成品，没问题吧。

我把b对象也放进去了，当我把b对象也放进去之后，紧跟着我开始给b对象的a属性赋值，那么我这块在进行查找的时候，我能否从这个容器里面去找到，我们当下的a对象，你告诉我能不能取到，真难对啊，算了不对了。

好吧能吧能吧，如果我这样可以取到这个对象的话，你告诉我我这条线还有必要存在吗，没了吧，我是不是把它给干掉了，这样说好了，我取出了我们的a对象，当我取出a对象之后好了，我把a的属性给它赋值。

当它赋完值之后，你告诉我现在我们的b是成品还是半成品，成大范成品什么什么，因为你实例化出来都完成了对吧，所以这时候有了一个b的，我们叫成品对象，注意思，然后呢再跟着往回走走走走，走到这块。

刚刚我为什么要创建pc向来着，我创建b对象的原因是什，么，是为了给a里面的b属性赋值，现在我的b对象已经创建完成了，并且变成了一个成品对象了，你告诉我，我能否给我们的a对象里面的b属性，进行赋值了。

能不能，可以吧，是不是可以，你先不要先不要管三个缓存里面放什么东西，你跟着我的思路去走，就这时候我可以给a对象里面的b属性赋值了，那赋完值之后，我现在的a它是成品还是半成品，a成品半成品，成品吧。

那我是不是可以把我们的a对象，我也放在这个地方，a冒号成品，那你告诉我，当现在这个步骤完成之后，我的ab对象是不是都已经创建完成了，我都创建完成之后，你告诉我，我还会出现我们刚刚说的闭环问题所在吗。

还有闭环吗，不会吧，是闭环就没有了，变化没有了，所以你来告诉我，我们在解决这个循环依赖问题的时候，它最本质的点在什么地方，在什么地方在o p跟op有什么关系，man哈中间有缓存吧。

所以为什么要使用缓存来解决这个东西，其实最关键的点并不在于这个mac map，只是为了帮我们把这些对象提前放到一个地方，这还不是最主要和最关键的，最关键的是什么，最关键的是叫实例化和初始化是分开执行的。

这才是最本质的东西，就像红桃六说的，红桃六说的叫实例化和初始化去分开，能懂能懂我意思吧好吧，所以它是分开执行的，所以他能够解决这个问题，当然这个东西啊，我只是画了一个简单的图示。

通过图的方式来给大家解决，图之后一定看到会有问题，老师你这个map里面a有成品有半成品，b有成品有半成品，这肯定是不对的，好吧，我们要怎么去解决这个问题，或者说我要去怎么来分割我们对这个缓存。

那这个时候你就想，我能不能把不同类型的对象去，放到不同的map结构里面去，可以吗，这是不是就可以做一个最最最基础的分类了，明白这意思了吗，所以这个下面我们要思考的一件事啊。

但是就算我要把这个东西按照类别来分类的话，你也会发现，其实我好像需要两个map就够了，一个map放半成品，一个map放成品是够了，我完全不需要用三级缓存啊，我为什么一定要说是使用三级缓存。

来解决我们的循环依赖问题呢，所以这是下面我们要探究的一个问题点，我把这些东西给大家标注个颜色，你可以看到一件事情，他们的执行步骤其实都是差不多的，这不就是断对象整体的一个创建过程吗，是差不多的啊。

把这东西好好搞清楚，那把这个图先说这个图能理解的，来给老师扣个一，能理解吗，图啊是我带着你们引导你们的思路，然后呢去进行一个解释，那这个实际上是不是这样的，我们来进行一个验证，好吧好吧，怎么验证。

我说了，我们一定要去看代码，如果你想把这东西理解透了。

你不看代码简直就是耍流氓，所以代表你是必须要看的好吧。

怎么看这东西，先问第一个问题，谁真正的见过三级缓存到底指的是哪。

三个mac结构，谁能告诉我。

都在说三级缓存哪哪三个满分，啥是半成品。

我上面不是解释了吗，成品表示什么叫完成实例化，写完成初始化，什么叫半成品，叫完成实例化，未完成初始化，不解释这东西了吗。

系列 6：P78：debug循环依赖的前置准备 - 马士兵学堂 - BV1RY4y1Q7DL

对昨天如果你昨天听课了，昨天上课的时候，其实我再给大家看这东西，今天我把这东西同样给大家拿出来。

怎么看呢，把它关掉来，我们搜一个东西叫匹配的那个being rejection，在当前这个类里面，你往上翻，最上面这块有三个具体的map结构，就是啥玩意儿，我把它当东西给大家截出来，源源码里面啊。

本来原版里面写的是私有的，我改成了公有的，改动的原因是什么，是因为我修改源码了，一会给大家说好吧。

就给大家说，然后我们把这个图粘过来，实际尺寸。

这就是我们经常说到的东西，一级二级三级缓存，比如说这里面实际上指的是这三个mac结构，你是需要对这三个map结构，有整体的认知和把控的好，这三map到底什么意思啊，也非常简单，这个叫什么，大家注意了。

上面这个叫singleton object，single object，它表示是一级缓存，改一下颜色。

他表示一级缓存，而我们下面第二个这东西，我们称之为什么叫三级，换成好，再往下走，一个这玩意儿叫二级红色，他没有按照我们那个书的顺序来定义好吧，你知道这东西可以了，一级缓存叫snon objects。

二级缓存好吧，叫做early sigmjs，三级缓存叫做sington factories，那下面我紧跟着就会问一个问题，这三个缓存结构有什么样的区别，有区别吗，为什么有的是ctrl还行吧。

有人还信办法，现实安全不安全吗，好一级和二级，一级和二级是线程不安全的，所以要加snet的，而三级是安全的，所以要用哈希map就可以了，这代一下后面代码的操作，我一会儿看一下就知道了，好吧。

那有什么区别，先说有区别吗，有吧，第一个区别就是你们说的，老师看后面的窗帘对象不一样，一级二级是ctrl哈，新办法，三二级13级是哈希拜访，除了这个之外，比如说老师还有容量，一级22562节16。

三级16，为什么一级更大一点对吧，这些点不是最主要的，最主要的东西是什么，就是同学们说的这个玩意儿，你看一下一级和二级里面放的东西，都叫object对象对吧。

而三级里面放了一个东西叫object factory，那下面就要解释一下什么叫object factory，是怎么理解啊，能这样这玩意儿吗，它是个啥，它具体要表达的到到底是什么样的一个意思啊。

这东西啊不要不要直接翻译，同学们不要求对象工程，它是什么，它是一个函数式接口，如果接触过拉姆达式的同学，应该知道它是一个函数式，接口好吧，有且仅有一个方法，明白意思吧，那它有什么用处呢，可以啊。

当做方法的参数传递进去，也就是说当指明此类型参数的方法好吧，可以传入，传传传传入一个拉姆达表达式，在执行的时候并不会执行，让他表示，反而在好吧，调用get object方法的时候才会去调用。

那么表示处理的逻辑，这东西如果谁不清楚的话，下去去补充对应的基础实例，可以看一下兰表达式对应的一些点，好，我们这不在浪浪费这个时间，你就记住为啥看狼表达式就知道了，好记住了，我们在指定方法的时候。

你可以传一个object factory这样一个类型，那么在传参数的时候不可以不是一个具体的值，而我可以传一个拉姆达表达式进去，当我把拉姆表示器传进去之后，我在调用这个方法的时候，他并不会立刻执行。

只有在调用这个get ob战的时候才会执行这块，你可以好好去看一下，这个代码叫bad factory，我们就可以直接点过去啊，他们叫functional interface是吧。

然后里面有个get不带上好，通过这个方法来进行调用，这个函数都是编程的一个思想，下来自己看好吧，我不再讲这东西了，属于比较基础的东西，所以你要把这个点记住，因为我们三级缓存存在的意义和价值。

说白了就变成这玩意儿最核心的点，其实就在于这一块儿，好吧，ok把这三种先记住，那把这三种记住之后，还有还有啥，我们要实际的去模拟一下ab对象，在整体的整个创建过程中，它到底在三个缓存中是如何流转。

所以呢我为了方便给他画图，我再画几个框，这是一级，啊写到这儿了过来，一级缓存，下面是我们的二级缓存，后面是我们三级缓存，我把这三个缓存结构放到这块，然后我们在整体对象创建的时候。

我会往后面加上我们对象跟水流传过程，你要跟着我的思路往后慢慢捋，当然在最开始的时候，这个对象一定是等于空的，这没问题吧，放我这啊，后面我会往后面画框，你跟着我的思路把这个对象的流转，你要搞明白了。

那这个时候下一步我们紧跟着进行一个操作，干嘛，有经理bug，我知道很多同学，我问一下，有多少同学自己比bug源码进行过这个操作，同学扣一没进过这个操作，扣二，好了，大部分同学投的都是二。

为了方便大家去理解，我们这儿先做一个我提前的预告，在整个对象的生命周期里面，我们在创建对象的时候，大概有几个非常重要且标准的方法，你给我记住了啊，一共就六个方法名字，你把这六个方法名字给我记住。

第一个发名叫什么呢，叫get b是第一个，第二话名字叫do get变，第二个，第三个叫create b，第三个记住，第四个叫do create。

然后紧跟着后面第五个叫create bean instance，然后第六个，叫pp的b，来这六个方法能不能记住，这没问题吧，我就靠大家的记忆力，脑瓜子记住这个方法没问题吧，这还是很容易的。

比如说我们一会再进行debug的时候，你其他任何的逻辑代码你都不需要看，你只需要给我记住这六个关键方法，当一个方法执行完成之后，我希望你能去报代码里面，去找下一个方法的处理逻辑就完事儿了。

因为原版里面啊代码很多，你要一行一行的去看，太浪费时间，同时很多同学可能跟不上，所以我们要记住的东西，方便你来带着整体的流程，同时我也做一个预告，在原版里面会有很多套娃的存在。

当你看到套娃之后也觉得奇怪啊，很正常一件事情，ok好了，这东西聊完之后，前期准备工作做完之后，我们开始提高代码怎么debug，debug之前，我一定要去给大家看一下我们的原始代码啊。

我这写了一个包叫sql啊，里面定义了一个a对象，你可以看到a对象非常简单，里面只有一个b属性，提供了一个b属性的set get方法，有一个合作方法，有一个tostring没了好吧，同时有一个b对象。

有a里面的set和get方法没了好吧，然后我在配置我们具体的配置文件的时候，也很简单，上面啥都没定义，配置了一个并对象a配置了一个并对象b，然后a的属性b好吧，引用了b。

然后呢b对象的属性a引用了属性a就这意思，这能看懂吗，来这个代码能看懂，同学给老师扣一，这个很简单很基础的东西了，你这个东西必须要会好吧好了，这看了之后，我们开始运行整个应用程序。

系列 6：P79：循环依赖的详细debug过程 - 马士兵学堂 - BV1RY4y1Q7DL

加上之后我们开始运行整个应用程序，打开我的test tt里面也非常简单，我这打一个点，打完之后开始右击第八个，我错了，为啥写配置文件，你可以用auto wear，没关系，我为什么讲配置文件。

讲配置文件的原因非常简单，因为配置文件是最原始最老的方式，它也是最完善的功能体现，如果你能把配置文件的方式搞清楚了，那么你再看注解也好，看配置类也好，都会非常轻松，因为他是最麻烦的，明白吗。

他是最麻烦的好，所以这样带你们看最麻烦的东西，捡东西你们自己看啊，所以刚开始会提到这个地方，我们点f7 进去创建对象，这是一个weblogic，等于bug，不管它点mc进到我们的构造方法里面去。

再点mc进来，上面的东西super不用说了吧，调用父类的构造方法干什么事，不管爱干嘛干嘛，我昨天给大家说过了，看原版的方法论了，不要每一个方法都点进去，你通过方法名字，知道我调用父类构造方法就完事了。

爱干嘛干嘛，管他下一个叫sconfig equations，什么意思，要设置配置文件路径传过来的，就是我们的dota 2的称号对吧，我只要把配置文件传进来，他会设置到我们指定的位置里面去就ok了。

明白意思吗，还是硬，你别点进去看好吧，里面处理逻辑还多呢，你要一层层往里边点，我告诉你一会就点蒙了很多，别忘你的点啊，学会适可而止，控制住自己的手好吧，不用管它，再往下走，看看我们的reflash方法。

我昨天也说过这件事了，我说如果你能把abstract application，contest里面的reflesh方法，你如果能看懂的话，我告诉大家，基本上源码已经从源码已经接到了，基本就够了好。

但是还是那个里面逻辑还是很多的好吧，这块前面有一些准备工作好吧，要做一些容器的初始化好吧，赋值啊，包括像监听器啊这些东西操作，不管它，我们直接到这个代码里面去，这个因为从这个步骤开始。

才正儿八经的去创建我们的对象，所以这直接跳过来，有的老师是这样吗，是不是这样，我们可以做一个验证，刚刚我带你看过了1233缓存是什么，一级缓存叫c工程object。

二级缓存叫early signal objects，三级缓存叫signal factories，所以你打开当前这个第八页面之后，找到我们的b3 腿，在b feat里面找c工程objess，找一下。

往下看，spinal test里面有对象吗，有吗，点开有ab对，有ab对象吗，这里面提现这五个对象是什么，是容器需要对象，并不是我们创建的a和b对象，所以现在容器里面没有ab对象，你再看二级缓存。

明白三级缓存零吧，我说了对象还没开始创建，所以现在这个步骤一定都是空，不管它，我们点f7 进去进去好吧，进来之后上面有一些属性值的判断，你可以直接跳过好吧，这些步骤也是出现对象了，我们直接到这一行。

从这一行开始，终于进入到我们创建对象的流程里面去了，所以再点f7 进来，加之后来问一个问题，刚刚的配置文件里面，我问一下，我需要创建几个对象，我需要出现几个病，俩吧，就2万，一个a一个b没别的东西了。

就是两种东西好吧，所以当我识别到之后，我点开我的创建类，你看到他会把病对象的名字给你，放到一个集合里面，器是release里面，就是我们的a和b两个对象，我说了a b两个对象，它没有明显的先后创建顺序。

也就是说我可以先创建a也可以先创建d，这个无所谓啊，对于我们当前应用程序而言，0号位置是a嘛，所以刚开始取的时候取的是a对象，我先把b列母取出来好吧，当我取到b类a等于之后干嘛了。

是不是该创建我们的a对象了，但是注意了，同学们在创建任何对象之前，我都要去做一个预先的判断，那什么东西啊，我需判断茶才能告诉我，对容器里面是否有对象，所以往下走走走哦，这行代码里面叫get be。

我要先去容器里面获取一下，我到底有没有当前的a对象，所以从这开始，进入到我们核心的处理逻辑里面去了，也是我刚刚给你说的第一个方法叫a对象，这个叫get in，这是我们第一个叫get in好吧。

get完之后点f c进去，到第二个方法叫do get in好吧，这儿提个醒以后，你们再看一些框架源码的时候，如果你看到了以do开头的方法，一定要警醒一下自己，为什么。

因为你不开头的方法基本上是实际干活的方法，也就是说在这个do开的方法里面，包含了非常多的真实的处理逻辑，在这儿是我们要小心的留意的，ok我再点f7 进去，进来之后先获取一下我们对应的名字吧。

获取完名字之后来了一个东西叫get singleton，什么叫get sgo，电瓶之翼啊，我昨天讲过电瓶之翼，为啥注释是黄色的，给自己改的颜色亮一点，好看一点，获取单单单单例对象吗。

我们现在能获取到a的单例对象吗，不是一级缓存的名字啊，这是一个方法叫获取单对象能吗，你都没创建，你哪来的获取不能啊，所以当这个步骤执行完成之后，你会发现这个对象等于空，如果等于空意味着什么事。

我是不是必须要去创建a对象了对吧，已经创建了吗，因为没有吗，没有你只能创建吗，别人不会给你，所以我再往下走，下面有一堆的逻辑判断，你可以直接跳过，不用管它好吧，不用管他，不用管他。

我们直接找到一行代码里面去，再定行，到这块之后，你会发现了一个方法叫什么，叫create密码对吧，终于看到了创建对象这个方法名字，这是我说的第三个方法，然后往下走一步，又来到一个方法里面。

叫get singleton，这个时候我希望你能好好留意一下，get singleton这个代码，就是刚刚给大家说那个object factor，这个这个东西就拿出来，让你好好看一下，拿过来。

我把这些乱七八糟的注释给他干掉，是不是没啥用，同学们注意看在当前这个方法里面，我放什么东西，get telement是方法名字对吧，b name是方法的第一个参数就是a，然后后面我重来一个另这玩意。

这玩意是啥，就是我们的lambda表达式啊，它对应的就是我们刚刚那个object factory函数式接口，它的一个调用过程，所以当我开始进到这个singleton方法里面去的时候。

我这里面的cret d并不会真正的去执行。

所以来点mp进去，进到这个方法里面去，调完之后，这里面依然有一堆的判断逻辑，我刚刚前面写过了，我说这个东西要通过什么来调用来着，通过get object的方法来进行调用，所以此时我们在看源码的时候。

我就要去找了，完找找啊，找一堆的判断跳过去，不管它，你不要好奇，看这东西没用好吧，直接到这一行，叫single factory，singleton factory是啥呢，往上翻是我们刚刚传过这个参数。

传递参数是啥，是我们的拉姆达表达式，所以此时当我在调用这个get object的时候，你告诉我实际执行的方法逻辑是谁，不要三跟三熊猫跟3d缓存没关系，没到那是我们的qub方法，所以我点一个f一进去。

是不是到壳里病了，到creepin方法了，从这个步骤开始，我要真正的去创建我们对象，然后再点f7 进去，这里面又有一堆的逻辑判断，我说了这些逻辑判断，你可以不管，我问一下第四个方法名字叫什么。

他们听好了，这东西啊，很难理解，我在带着你去抵八个源码，如果你都觉得很难理解的话，你自己去看，你会变得更懵，所以现在晕，这着急，跟着我的逻辑线去慢慢往后走，你会把这些源码给理解透的。

没大家想的那么难好吧，所以这个方法叫do create b，我们下期要找了，找找找找，找好了，找到了第四个方法叫do credd，我刚刚也说过了，不开多方法都是实际干活的方法，所以我们再点fc进去之后。

终于到了实际创建bean对象的一个处理逻辑吧，好意思，往下走往下走，往下走，往下走，到这个方法，那么到这一步之后，这是我们说的第五个方法吧，来这个fm叫什么，叫pread bean instance。

叫创建并实例，说白了就是我们创建对象对象名字是谁，是a嘛，所以我创建出来的就是我们的a对象，对往下走一步，你会看到现在我获取到的a对象叫什么，叫aat 1655里面的属性b是什么，是空的吧。

是不是空的好吧，所以这样我一个标做一个标注了，我先创建出一个a对象，叫a at 1655，此时的b等于n，我问一下，现在我有往三个map结构里面放东西吗，现在我要往三个map里面放东西吗，没有啊。

还没我只是把当前对象给创建出来了啊，所以这是什么，相当于我们刚刚在这张图里面，我只完成了实例化对象，还没开始这里面进行赋值呢，哎同步b解错了，所以我先把它扔一边，先放这个地方，当放这个方之后。

中间依然有一些逻辑判断，不管它我们该干嘛了，是该去填充我们的属性了，所以来到我们的第六个方法里面去，那第六个呢叫popub，但是在populate b之前有这样的一个处理逻辑。

叫adsingleton factory，当你看到这个方法之后，别着急，猜这个方法干嘛的，你注意看它的参数，第一个叫bean name，第二个我又传递了个什么玩意儿，什么玩意儿，lambda表达式。

这个拉姆表达式我要给大家站出来，因为这东西才是我们解决循环依赖的，最关键的问题所在，我需要把它给粘出来，方便我们一会来进行查看，站出来爆炸好吧，放完之后来往下看，干什么事呢，很简单点。

m7 进去往这方面去，进去之后往下走，里面有一些异常的处理，不是那个现成的数据操作，不管它，第一步叫this。c构成factories，点put，这是往哪个缓存里面放，哪个三级缓存吧，但是你注意三级啊。

不是二级啊，三级，但是你注意往三级缓存里面放的是啥，k是我们的a value是个什么玩意儿，什么玩意儿，lambda表达式，它并不是把我们的a对，他并不是把a对象放进去了，留大案。

他并不是把a对象放进去的，而是放了一个，然后表达式，所以我这在进行标注的时候，我也应该这样来标注它，什么叫做刚开始k冒号放的是我们的a对象，对吧，而value放的是什么，叫拉表达式，哪个老表达式呢。

就是下面这块我放这儿了，下面这个对象把它放进去了，搞清楚没放对象好吧，现在没放对象，ok完了之后来往下走，叫this radily singapore object remove啊。

二级可这个移除掉二级，可能现在里面本来就是空的，啥都没放，就不管它再往下走，叫reject c功能，当你所有的病对象放完之后，会有一个已注册的并对象把它放进去，所以这相当于是一个已注册并对象。

的一个呃集合，不管它没啥用，跟三级缓存没关系，跳过也就是说在对象属性设置之前，我已经把k等于a value，等于拉姆表达式的一个东西，放到了三级缓存里面去，注意我放的并不是a对象。

而是包含a对象的一个lab表达式，来这儿能听懂的，给老师扣一，能听懂吗，好了继续跟没到精彩的地方，当这执行完了之后，我们紧跟着再来干嘛，下一个步骤叫popular bean。

你注意popular be pop类的变叫填充属性，你可以翻一下，说白了就是给我们的属性来进行赋值好吧，现在我们的a对象还是这玩意儿，a at t1655 好吧，b等于空，没做任何变化。

然后从这个步骤开始，我要开始填充我们对象了，这里面有一堆的逻辑操作，你都不用管它，我们直接跳到最后一行，因为只有在最后一行，这块才是具体的属性值的操作，中间这块都是检查判断啊，没啥用。

所以我这直接跳过来了，到最狠哈，明白吧，直接跳过来，跳完之后点f7 进去啊，进来之后怎么进行属性的赋值啊，走走走走走走走，注意啊，我先问你个问题啊，a里面有几个属性，一个吧只有一个b属性。

所以我要找到我们对应的属性值，所以往下走走走走，走到这往下看，叫pv，pv就是我们的属性值的集合，好吧，里面只有一个属性值b，所以当我重新完成之后好了，我获取到我们属性名字了。

等于b好在下一步我该干嘛呢，叫pv。get value，正常情况下，你告诉我我这个get value应该获取到一个什么值啊，得到一个什么值，那么好吧，但是当你执行完成之后，你会发现他这获取到一个对象。

这个对象你们可能没见过叫什么，叫raw time being reference，记住啊，叫roten being reference，把这个名字给我记住，因为后面我们会用到的东西。

probe refer，暂时记住叫运行时的一个并引用，这样你是必须要知道的好吧，当你知道这车之后往下走，来到这行叫value reserve的result value，if necessary。

通过名字判断你告诉我干嘛的，如果必要的话，我要去处理value值了，实际上我们这个value我最想获取到的是啥，是不是应该是一个b对象，因为如果我能够获取到b对象的话，我就可以直接完成我们的布置工作了。

但是我现在获取到的是什么，是一个wrong time being reference的一个对象引用，而不是b对象，所以现在我要去处理我们的b b对象了，这是不是必须要注意了，因此从这点f7 进去。

进来之后，这有个逻辑判断，if value inance of wrong time being reference，来告诉我我们刚刚传过来value值是不是这个类型，是不是这个类型是吧好了。

如果是的话，我能进来，第一步类型强转调整完了之后，到这叫resolve reference，开始处理我们的引用了，我再点f7 进去，第一步先获取我们b类型的b的类型，但只有一个标签b嘛。

好返回之后等于空获取标类型，如果他在找他的复工厂里面有什么东西好吧，然后说如果不等于空做什么事，我们再等于空可以跳到这，往哪儿看，同学们关键点来了，叫string。

value of two evolureference，get the name，说白了我就是把什么，把我们刚刚传过来那个b参数，给它做一个名字转换，所以这样处理完成之后。

我的名字等于谁等于b a你写不出来了，没事儿，往哪看，这个叫result name于谁等于b，然后当你到b站之后泡完，从此开始看下面这行代码，叫并等于this，点been fashi，点get。

并告诉我这是你第几次看到get并对象，第一次第二次吗，相当于什么事儿，我现在本来要给a里面的b属性赋值了，我通过我的名字拍完照之后，我发现我没有b对象，所以我现在要干嘛。

是不是要去容器里面查找我们的b对象吧，回到这张图上，是判断容器里面是不是有b对象，知道这个步骤了，从这开始要判断了，来到这儿还能跟上同学给老师扣一，听好了，这个地方我为什么说它是套娃了，开始。

因为从现在开始，他的执行步骤，跟我们刚刚创建a对象的执行步骤，是一模一样的，所以当我点f7 进去之后，又回到了我们的第一个数理逻辑里面去，叫get be get in，后面的第二个方法叫什么。

叫do get in对吧，再减f7 进去，第一步转换名字，第二步叫get singleton，来，问题来了，这个get singleton里面有b对象吗，有没有没有，所以这取出来a等于空。

当它等于空之后，紧跟着我是不是要去创建我们的b对象了，对往下走走走走走走走走走走，走到这儿再进到我们的get single里面，然后里面是什么，create编码一模一样，p m c进去填完之后找什么。

找get object的方法，走走走走，当我找到get object方法之后，紧跟着我要去调用我们的create bean方法，我再点fc进去，下一个方法是啥，下一个方法是什么。

do create bean，所以往下走走走走，一直走去看看，跳过不管走走到这叫do created by，不是去了点fc进去，进去之后往下走走走走啊，到这一步，当我到这一步之后干嘛了。

我是不是要去创建我们的并对象了，此时我创建对象是谁，一把是该b了，所以这时候你打开，你会发现我现在已经把b对象创建好了，创建好之后，b是谁，叫bf 1995来拿出来，我依然想扔一边，b at 1955。

此时a属性等于空，来，我问一下，那对于我们上面那个图里面，哪个步骤是这个步骤，我开始完成b对象的实例化了吗，b对象实例化，当我b对象的实例化结束了之后，紧跟着来再进行操作。

往下走走走走走走走走走走走走走，走到这层来告诉我这行干嘛，这样干嘛，放缓存吧，往哪放，往三级里面放，放的是谁，到这儿，我往三级里面放的时候，我一样的，我放的对象k他放的是谁叫b。

但是我的value是谁啊，还是那个拉姆达表达式，所以现在三级里面都已经包含上我们的ab对象，和a b的名字了，但是不过我的值是一个拉姆达表达式而已，那这个拉表达式有什么用，一会儿我们再说啊。

先把它搞定好了，这边执行完了，所以往下走，大家都这叫populate bean，点mc进去吧，哎那就这干嘛了吗，现在是不是该给b对象里面的a属性，来进行赋值了对吧，给b对象里面的a属性进行赋值。

所以点mt进去下来之后，营养老规矩直接跳过到最后一行，叫apply property values，再点f t进来，进来之后往下执行我们代码的一个逻辑，找谁找属性名字吗，都跳过跳过跳过跳过。

不管他跳过跳过跳过跳过，好到这一步获取我们属性的名称，往下走，名称是谁，a吧好吧，紧接着获取我们的value值，这个时候你再看你获取到的value值是谁，是什么，同学们是不是依然是a吗，怎么会是a呢。

你a现在都没往里面放，咋那会是a呢，不是a啊，是不是还是一个运行时的并引用，依然是一个运行时的并用啊，没关系，当我看到运行的并运用，我也不慌，往下走，是不是该进行值处理了，点f7 进去好吧。

判断一下你是否是这个类型，很明显我们的value值是这个类型，一旦我是这个类型之后，可以干嘛，是不是可以强转类型，转完之后开始处理我们的引用，初进营的时候步骤一样，第一步get beat啊，没有好吧。

然后呢，变态不等于空进入到里面，等于空往下走，又开始获取我们的属性值了，当这儿获取完成之后，我破掉了a8 好了，现在告诉我第几次看到get b方法，第三次第三次了，所以我说了。

如果你真正的能把一遍流程跑通的话，你会发现里面基本上都是套娃，它的处理流程，处理步骤几乎是一模一样的，所以不需要慌，好吧，来再点x，这这干嘛来着，我要去找找谁了，现在我要去找谁了，告诉我，找a对象吧。

好找a对象，然后我点f7 进去又到哪了，do get been对吧，再点f7 进去哇，获取名字，然后到这个里面去，现在问题来了，他到哪了，是不是相当于执行到这个步骤了，不知道这个步骤了，来执行这个步骤。

能理解，同学给老师扣一大能理解吗，可以吧，能理解的话，来我问一下，这里面有a对象吗，我们现在三个缓存里面有a对象吗，看着看图有没有，有对象，那有吗，注意你是没办法从1233个缓存里面。

直接去获取a对象的，但是这有一个你看三级缓存里面有值吧，所以我没干什么事，来看他的处理逻辑，点f7 进去，再点f7 进去，照这个方法干什么事呢，第一步从一级缓存里面获取值，一级缓存里面有a对象吗，没有。

所以这值变等于空，没问题吧，第二个判断一下，如果这个值等于空，并且叫is singleton come increation，我问一下，现在我们的a对象是不是在创建过程中，是吧，所以就等于true。

我能够进来，进来之后，我从二级缓存里面取，我问一下二级缓存里面有对象吗，看图有没有没有，依然是等于空的，所以跳过这个值是恒等于处的，那如果这个等于空，这个值等于负的话，ok我进来劈开之后往下看。

这是从哪儿取，一级吧，这里面有一个synont的双重检查，一级怎么是三级呢，一节再走一遍，一节二节都取不到之后，紧跟着我开始从三级缓存里面取对象了，我问一下，从三级里面取完之后，我获取到的是个啥。

是a对象吗，不是是一个拉姆达表达式，所以你取出来看看，dollar拉姆达i1738 是一个拉美达式，当我把这个拉姆达式取出来之后，我是不是要调我们的get不get了，你告诉我。

当我在调这个get object的时候，我执执行的实际的处理逻辑是哪个逻辑，get early being real reference吗，这东西get early being reference。

是不是该进行它了好吧，然后点f7 进去，再点f7 进去，到这个画路径里面，到这之后你好像看到点东西这个属性名字，我觉得你应该认识叫exposed object来。

谁能告诉我什么叫exposed object，翻译过来叫啥，看过叫啥，暴露对象，这是你们在看帖子的时候看到那个暴露对象，什么叫提前暴露对象，暴露是谁，暴露的是这个玩意儿，这玩意儿干嘛呢，来往下看。

第一步操作，我先把a对象赋值给了expose project，紧跟着我在最后返回的时候，我返回的是object，但是中间这一块的时候，你pose不在，有没有可能会改变，有没有可能会改变，可能吧好吧。

这里面是不是有数理逻辑改变啥呢，这需要做什么改变吗，需要有什么改变，来我们点到这个方法里面看一眼，点进去，点完之后找实现类，第一个是一个debtor适配器，不用管它，它上面有一个类叫abstract。

auto purposecurity，再点进去叫viper，if necessary，我再点进去叫create propose，再点进去叫propose battery，they get policy。

我再点进去干什么，再点进去往这儿看，你告诉我干嘛，我这是不是有可能拥有一个判断，判断什么东西啊，同学们，判断一下我此处是否需要把它改成代理对象，也就是说这个步骤我在提前进行暴露的时候。

要不然我暴露的是原始对象，要不然我暴露的是代理对象，来这句话能听懂的，扣一，记住啊，我说的是要不难，要么暴露的是原始对象，要么暴露是代理对象，至于是否是带着项，取决于什么。

决于当前这个衣服放大能不能进来，我们刚刚的配置很简单，什么东西配，就配了一个ab对象，那个ab对象他需要生成代理对象吗，需要不需要不需要吗，对这个地方if是进不来的，我直接把谁返回了，把线返回了。

不就是我们的a对象吗，对对象a at 1655，把a对象返回回去，当我返回回去之后，你告诉我我能不能取到a对象了，能不能，为什么a b没有带这样，你配了吗，因为没配在这个项吗，所以返回原始对象吗，好了。

当我返回原始对象之后，紧接着看叫this early snoobject，点put放哪儿了，把原始对象放哪了，二级缓存嘛，所以现在我可以改变一下，我们将图了拿过来，k依然是我们的a。

但是value变成什么，叫aat 165，问题是现在的a是成品还是半成品，半成品啊，记住了好了，放这半成品，ok放完之后紧跟着叫v4 点sgo，再点remove，把谁删除了，把那东西删除了。

把三级缓存里面的东西给删除掉，我们这儿不停的删除，给他标个红色表示删除吧，删删除掉，为什么要删除啊，有人想这事吗，为什么是半成品，你看这个a对象，你的b是等于空啊，你没给b赋值啊，对不对。

所以为什么是三级，可能要删除掉啊，因为你的查找顺序是一级二级三级，如果二级里面有了我，三级还有必要存在吗，没必要明白意思吧，没必要了，这个是不是这个意思好吧，把它搞清楚了，所以这块我们到这就不说了。

这是为什么三级缓存容量比较小的原因，原因在这16 16吗，哇好了，被搞明白了吧，搞明白之后来现在我的他说网络返返返返回返，回到这步之后，我把我们的为什么拉表示一会儿来说好不好，别着急，我说了。

你们跟着我的思路走，要提前问问题，你现在都想不通，后面的东西，你没法问，问的东西白问，这是我的思路走，我后面会解释的，为什么要换完美达式，我不解释的，别着急，好不好，心急吃不了热豆腐，晚上哪来好不好。

我已经尽快放慢这个节奏了，好听ok好了，现在我有没有把a对象给取到，按计划就能调档了，你放的数据多了，自然而然就扩容吗，还有自动扩容技术，为什么要自己去设置，不像吗，提到了吧。

我刚刚为什么要取a对象来着，我取a对象的原因是啥来着，对不对，不错了，不好意思啊，所以现在我已经把a对象获取到了，我能不能给我们的b对象来赋值了，你看到了。

刚刚没有create并列方法是进不去create并了，所以往回返再往回返，在往下走，现在我获取到了我们的a对象，那我可以干什么事了，我是不是可以给我们的b属性赋值了，在哪复制，很简单，看完啊。

看完在这个步骤里面叫b w。set property values，在这里面可以完成我们整个的赋值工作，往下走走走，返回返回，好吧，再往下啊，不是到这就可以了，你再看一下你的b对象，有了吗，是不是有了。

有了的话，你告诉我现在的b是成品还是半成品，成名了吗，虽然这个a里面是b，但没关系，我的b对象已经有属性值了，所以b现在已经成品了，那成品之后往下走，谁走走走，一直往回返返返返返返回来。

按照我们刚刚出逻辑，一直往回返反到哪呢，放到这个方法里面去，叫adsingleton，注意b类是b signal object，是谁，是b对象，然后点f7 进去，第一步叫these。

点sigmobject，点put，这是几级缓存，一级放的谁和b对象吧，所以此时可以到一个结论，我可以把什么把我们的b对象给放回来了，写一下k冒号是谁b吧，value冒号谁叫b at 1995。

现在我们的b对象是成品还是半成品来着，刚说过了吧，成品对象好吧，翻转过来了，挪过来之后，紧跟着干一件事，就this sfactory，三级缓存移除掉，然后呢二级缓存移除掉。

是把三级和二级给1921955，这把二级和三级干掉，这样我们一样标红b是不是完了，不就是成品了吗，赋完值之后不就是成品了吗，对不对，好了，当然完之后剪下来下一个问题，我为什么要去创建b对象来着。

可能听好，我为什么要对创建p对象来着，是为了给a里面的b属性赋值，现在我的b对象已经获取完了，我是不是可以给a属性赋值了吧，所以返回返返到这，我现在我已经能获取到我们这个b对象了，当时看诶。

哎看那b i s1991995 就是九五，没写错啊，那就这写错了，好吧，这写错了，所以现在我已经获取到我们对应的b对象了，那我获取到b对象，而且获取到是一个成品对象，下一步干嘛。

是不是该给a属性a里面的b属性赋值了，所以往回翻翻翻翻翻反反反一直反，现在这逻辑判断，不管它过过过过高铁好，叫bw表示set pro value到那儿完成之后，是不是给b赋值了。

所以往回反反一步到这一步，你再看当前的a对象，a对象里面有没有b有b吗，有吧，是不是，意味着我的ab对象对象都已经创建完成了，对不对，所以此时ab都成了成品，但是还没完，怎么做，走走走走走走。

往回返返返返返好吧，反到哪，我现在a对象我也创建完成了，翻完之后别忘了，还有一个步骤叫adsingleton and on，干嘛，是不是a还要去丢到我们的一级缓存里面去，把它丢上来，听完之后。

现在我们的a变成了成品对象，然后把二级是不是也给干掉，是不是意思好，是不是删掉，我说让红色表删除，那你告诉我，现在我这个逻辑执行完了吗，听完了没完了吗，没完没有，同学们，你不要忘了。

刚刚我们为什么要创建a对象来着，我问一下为什么要去创建a对象，说实话是，因为我们在刚开始的这个循环结构里面，我是先取了a，对不对，当我取完a之后，别忘了这个集合里面有两个值，你只是把a处理完了。

现在你的b处理了吗，没有吧，我先干嘛，该处理毕了吧，处理b的时候是不是也是一样，我找get in，找不get in，然后这个步骤你告诉我，现在能不能从一级里面取到b，能不能从一级里面去取到b可以吧。

所以此时我直接获取到b对象，我获取到b对象了，好了，我下面我还需要去重新叫create b吗，还需要执行这个步骤吗，不需要啊，他就执行完了，所以当这个步骤执行完成之后好了，我们整个处理器才算是结束了啊。

这是刚刚整个ab对象的创建流程。

来听懂的，扣一，告诉你我我以这样的方式去debug，你们能能能读上吗，应该没问题吧，好了，这能跟上，我告诉大家还有问题，其实告诉大家，现在给大家解释这个流程，它并不是循环依赖里面的最关键的点。

最关键的点，下面我要写的这段文字，描述才是最重要且最关键的点，也就是说那个流程其实非常简单，你只要正常情况下，你听完了，你应该能认得出来，哪怕你跟不出来，你下去之后自己跟着做一遍也能跟上来。

这其实并不是主要的，主要是什么。

系列 6：P8：优化运行JVM运行环境（慢、卡顿） - 马士兵学堂 - BV1RY4y1Q7DL

刚才就是那个卖了回放一波文体了啊。

刚刚是讲到哪的时候，是不是讲到阿里的时候，其实就是很简单，这个安利呢在它的内部的编程规约里头，有一个要求创建线程池，线程或者线程池的时候，必须指定有意义的线程名称，大联合政策对。

为什么呀，他说你们想想看吧，假如我在内存之中定定定位出来。

说这个线程它产生了一些问题，没问题的，哎，这就是总而言之，c900 分百看到了吗，他们说阿after death，bk这个cpu百分百这样的一个问题，那这个现场是干嘛使的，我们得知道。

所以在安利的规定公约里，现成的名称要有一呃呃，扩展一点项目内容，作为现场来说呢，一般刚才那个问题说cpu百分百，cpu爆了之后，你怎么去定位呢，怎么定位呢，首先给他揪出来是哪个线程。

然后这里面分两种情况，你认比较，如果你揪出来一个线程在那里，他特别忙，占很多视线，那么这里面分两种情况，我就把它停掉了。

啊这里面的分两种情况，第一种情况占cpu的，如果是什么线程的，是业务情况，那啥也别说，你好不容易去调你的业务代码，第二个如果站c u的是j v m内部线程，这个一般是gc线程。

那说明一定是发生了这些特殊情况，比如说他频繁的物理所，因为调色之后在哪来来回回抽，比如说他一次f d c的时间超级长，cpu在那里使劲分离c他不有别的事，所以这个时候你就需要去看你的知识日志，去看过吗。

听懂了吗，所以你怎么调，别人在问你这个问题的时候该怎么回答，大家是不是听过，我再重复一遍，这个问题就是面试官的问题，假如你的系统它产生了cpu暴增的情况，你如何定位，定位的话相当简单。

你可以说alphastation store里能观察，观测到这个没有问题，另外定位完问题之后，你得继续说，你说如果是一个业务线程，那我就定位业务业务的问题，业务方面的问题，我现成名字取的要有意义。

我就知道是哪个线程，你关注这个线程代码就可以了，假如说是不是业务线程，而是系统线程，那说明一定是gc的问题，我要去观测gc的认知，看看到底发生了什么，是om，是频繁gc了还是什啊，这个回答大家听清楚啊。

有没有谁有疑问的，唯一就是好处吗，其他有没有人会觉得，有回音是吧，what来再重新试一下，hello，现在可以了吗，哎呦我勒个去啊，继续现在好了是吧，嗯那就行。

o m为什么会造成cpu了吗，om并不会造成。

但是他不断的f d c消耗cpu资源，就会造成cpu暴增。

不会拉满，听懂了吗，所以你要观测具体是哪个线程，那么如果你呃我们继续聊啊，这个，呃假如说我们你观测到的是业务线程，那么业务线程呢，你就观察业务线程的一些特殊情况，这个业务线程特殊情况我怎么去观察呢。

注意看看这里。

我重新把这十项环实验环境搭一下。

把程序起来，把office起来挂上去。

在office里面还有一个命令，这个命令叫什么，叫thread回车thread呢。

它会把整个这个java进程里面的所有线程全给你，列出来，哪个县城站的站。

这cpu是多少，哪个线程占的cpu是多少等等，现在我们假设如果这个业务线程有问题，17号观察这个号码，17号业务线程有问题。

那么这时候你可以怎么做呢，thread 17回车。

他就会把这个业务线程里面，在这个线程里面是哪个方法，调用了哪个方法又调用哪个方法，总而言之就是把线程b站给打印出。

你去调整你的现成的业务逻辑，去观察一下到底是哪个方法有可能会产生问题，去读你对应方法的代码好了，同学们不知道大家听清楚没有，这个问题大家是不是能回答了，至少初级的能回答了，再重复一遍。

由于中间老出一些情况，我再重复一遍，这个问题是什么，就是面试官如果问你cpu暴增的情况下，如何排查。

记得我好像是在哪记录过了，所以重新给大家记录一遍吧，cpu帮他如何排查呀，如果你用普通的那个那个linux命令的话，就是呃怎么查的，就top，杠hp就可以就找出来哪个进程里面，哪个线程占比最高。

然后呢再用jtag去观察这个线程的一些情况，如果你用aths的话，怎么做呢，dashboard或者是thread命令以及thread命令加上什么，加上这个线程号，呃当然分如果查出问题来分两种情况。

第一种是业务线程，那你就查业务，啥也别说，第二种是什么b c线条，那你就不去读gc日志，然后根据日志来了解一些具体情况好了，这个过程不知道我说清楚没有，有没有同学有疑问的，这是cpu暴增如何排查。

当然面试官里头还经常会问一个问题，死锁如何排查，假如你怀疑你系统里会有死锁，死锁是后排的，这个怎么查，那么问题来了。

怎么看dc日志啊，你的问题你留着吧。

今天讲不到那么深，那么深的深度好了，同学们这问题怎么怎么回答，同学们听我说，观察gc就是观察这个线程的死锁情况，如果你用aths超级简单，auth是这么玩的，还是thread命令thread。

the help。

你会发现它有一个命令叫什么，叫杠b杠b的意思是，include blocking threaten，find the thread，who is holding a lock that blocks。

the most lethreats，读一下，他说你把那个什么东西给我揪出来啊，有一个县城，这个县城只有一把锁，他这把所持有的时间特别长，其他的线程都得给我block阻塞，说明这地儿一定是有思索。

听懂了吗，所以你就查怎么查，自然刚毕，当然我这个程序里头是没有思索的。

所以你看不出来，所以这块的话呢我告诉你数学如何排查，如果你用最初级的命令，你还是要jdk来观察线程的情况，这个有点他那个线程的信息给的不是特别明确，而且线程特别多的时候比较难观察。

但是你如果用aths直接就给你定位出来了，artist用什么四川当地搞定啊。

关于刚刚讲的这一小段，有没有同学有疑问呢，这console也可以吗，没用过，不知道可以可不可以，这console不知道可以不可以啊，这个excel也能看到搜索对，可以的，好我们可以继续了吗，可以继续。

我要给老师扣一。

好那下面的问题是我们刚才不是说了吗。

这哥们是在不断的呃产生f d c嘛，对不对，那就是说刚才我们分析过他不断产生f d c，产生了fg c之后的问题出在哪呢，就是由于有一些对象不断的占用内存的，产生内存泄漏，那现在的问题就在于。

我们怎么去揪出那些对象来，好。

怎么揪出那些对象来，是哪些对象占用内存的，听我说，这个时候一般我们使用哪个命令呢。

这个命令呢，authors里面唯一不能够替代java自带的命令行，的一个命令，就是他这个命令叫jay map。

对啊，当然了，你不用背啊。

就是我给你讲的这些东西你都不用背呃，为啥呢，因为像老师这么贴心的人，肯定是都给你记录好了，好吧，就是，这个命令呢是这个啊，请大家记住它，就是他叫j map，ok这个命令是最常用的j map。

j map的意思是什么呢。

来看这里，gm gpistol histogram指的是生成一个内存图。

后面的要跟我们的进程的id看一下。

11778。

1778回车。

呃由于它产生的结果是特别长。

所以这时候呢我加一点小东西。

把前面的给大家截出来，就不用盖帽了，还黑点20就可以了。

把前面几行列出来，要用japan j map命令生成内存的内存图。

把前面20行列出来，回车哦，你会看到它最终产生了什么结果呢，是这么一个结果，我们有这样的一个类，它叫做schedued future task，它有多少个对象呢，instances有多少个对象呢。

有39万个对象，与此同时，我们有这么一类叫big animal，它有39万的对象，注意记住了这个数39万，我们再来运行一遍，那依然是39万，完蛋了，已经内存溢出了啊。

out of memory error，看到了吧，重新运行，再来好程序跑起来，为了让大家理解这个命令，j map的命令到底是什么意思，我们重新跑一下回车，sorry，gps，1949，回车你会看到呢。

我有一个scheduled fish test，他现在有2万个对象，node呢有3万个，然后big dancma有2万个，看到了吧，哎你们继续啊，再再再跑一遍，注意你会看到这个对象变成了3万多个了。

依然是那个schedule free task，3万个，再跑一遍，已经变成4万个了，好如果你持续不断地跑的话，你会发现这哥们儿就是这个对象，以及下面的什么big simal以及下面的cut infer。

以及下面的date等等，它在不断的吃内存，不是vip学员那里能领资料吗，可以没问题啊，好这个从他必须会超级会一定会，所以你跟面试官讲，我在正在运行的系统里头执行了j map，你别搞笑了。

面试官一个大嘴巴子抽上来，出门右转拜拜，那有同学说老师我这map能不能用生产机，肯定是不能这么用的，那怎么用啊，好第一种测试环境下的压测，用gmap没问题，听懂了吗，第二种，如果有高可用两台机器。

高可用，我隔离一台，用其中一其中的一台来给他做测试，这个没问题，如果是说那种高可用也不允许，也没有，然后线上的机器我怎么办呀，t c p copy，把来的流量拷贝一份，用另外一台测试机怼上去。

在这台测试机上做实验，这是第三种，第四种，第四种，配置你的常见的jvm的参数配置怎么配呢。

here，就必须配一个参数，这个参数叫叫它叫什么，叫hit down on out of memory error，我这句话是什么意思，读一下，可dump on audience memory era。

资料会给吗，不给没问题啊，take down on olive oliver error，对，把整个堆内存给dump出来，dump成一个文件，那么这个东西在什么时候弹不出来呢。

out of memory error，只要产生om异常之后，它会自动给你生成一个这叫堆转储文件，对专储文件我们可以对对专注文件是什么意思，它就是相当于把你内存里面，这个堆的信息全部给你导成一个文件里。

我们可以用工具对它进行分析，在这里才会用上你们所熟悉的啊，你们所熟知的，你们听说过的mp，虽然我不建议用它，但是网上有很多人讲他的我不太喜欢用它，原因是啥呢，因为它吃内存，吃的比消耗的比较多。

呃堆堆内存就是你有了这个文件之后，分析这个文件能用到的有工具特别多，这vivm本身就可以，还有一个叫j hat的自在的命令也可以，j v vm也可以，m a t也可以，j consol也可以。

这profiler也可以进行dump文件的分析，好吧，在这儿呢，首先，教大家怎么分析吧，啊我看那个anybody问了一个触及灵魂的问题，说这个参数会影响线上性能吗，来各位同学回答一下。

any andy bug啊，安迪的bob鲍国，安迪鲍勃同学会吗，讲个实战大哥，我讲的还不够实战啊，你还要怎么实战，不会的都死了，怕啥对啊，他都已经死了，on out of memory error。

大哥他都已经死了，你有什么可可可可影响的，他已经死人了，你们随便怎么鞭尸都可以吗，对不对啊，所以这东西没没事儿啊，没关系呃，这是一种，当然我给你配置这种的话。

我得等到它out of member error之后，我才能够看到那个堆存储文件，所以有了这个文件之后，怎么进行分析，我能跑这个历程的时候。

讲讲讲另外一个命令就可以了，这个命令是什么呢，就是依然是gnap，当然这个命令还会可以给你产生一个对，专储文件，我再说一遍啊，我只是为了模拟一下，实际你正在运行的这个线上的生产环境，里头的系统。

你不要用gmap，因为直接就把你的把你的机器给你打卡了，卡顿了，听懂了吧，影响它影响非常大，它会产生s t w啊，这个肯定是在生产环境里是不合适的，我给大家讲这个呢，主要是为了你会看到它会生成。

如果你配了刚才那个参数的话，它会生成这么一个文件啊，说了这么一个文件之后，该怎么进行分析，是我们下一步的重点来能get到的，同学老师扣一。

嗯那这个命令怎么用呢，其实你你记着就行了，就很简单，然后file等于什么，p i d等于什么，就就这么简单好j map什么什么什么好。

也不演示了，除了gmap之外。

还有一个命令是什么，除了jyp之外，咱们今天重点讲的不是不是ars吗。

除了gmp之外也可以。

看这里。

回收。

发射里面也有命令，阿特里面有什么命令呢，有这个命令叫做hip dump。

看到了吗，hp down。

okay，那这keep up怎么用啊，help，他会给你几个exams给的非常的到位，hdmp刚刚live hedgtime，什么什么什么，所以你如果想导出一个堆的话，可以dp，如果想导出活的对象。

那就是live time下面的我就编time了，自己根目录下面root下面的嗯嗯今天是，06146月14号点proce，注意这个后缀名是什么，其实没关系的啊，这个后缀名是什么，其实没关系的，听懂了吗。

是无所谓的事情，ok我们就有了这么一个h profile文件，那我们有了这个profile文件，还记得我们的问题吗，我的问题是这样的，就是一个线上的系统，我配了一个参数。

这个参数叫做hip dump on out of memory error，像现在假设它已经产生out of om了，那么这时候它会自动的产生这么一个对，准储文件，而作为我的我我来说。

我一定要分析一下为什么它会产生o o m，我要定位问题，所以我要分析这个文件，这是我们下一步要进行的操作，来可以继续的给老师扣一，那当我们有了这个文件之后，我们怎么去分析啊，参数怎么加。

你你你你想气死我吗，你知道命令参数怎么加，不会是吗，那我那我能说啥，看这里我们不能照顾所有人啊，我们先先照顾大家伙普普遍的平均的水平呃。

当我们有了这个转储文件之后，我们就把它下载了，下载完了之后呢，下载到windows，你打开就行了，好吧，就这么简单，装入我以前有一些呃dump文件啊，我找一下，找到最近的，什么玩意的文件在哪。

我搜一下啊，有一些文件，这，是原来曾经，嗯cross实战加班调教训练营在这里吧，这是我原来曾经那个妆容，这是原来曾经产生过的一个，我们打开来看看就知道是什么意思，就是相对比较简单，c。

work causes，报呃当我们有了这个对专注文件之后，他就会把这个文对文件给你打开，打开之后呢，里边的一些所有的信息，就可以通过这这vo vm给读出来了，比方说这是基本的信息啊。

这就是操作系统是什么，然后java主目录，java版本等等，系统属性显示线程都可以，比方说我我们说刚才的那个实例，sorry，我们说刚才的那个啊那个，这是他的堆，这是它的类好看这里呃。

当我们打开它它这个这个目录的时候，类这个目录，其实你就能看到到底是哪些个类文件，知道吧，哎哪些个对象在占我的实际当中当中的内存了，所以你就直接可以通过它就可以定位出来。

比如说你看到了这个big decimal挣了多少，超级多16万个了，这个也是16万个，16万个，16万个，所以你很容易定位出来，是哪些对象在占用我的空间，接下来你就查你的业务逻辑器就行了。

是不是很简单呃，当然除了这个之外，还会有一些可以帮助你去定位，哪些个对象出了问题的，比如说你要查询哪些对象有问题，可以用什么呢，o q l语言叫object query language，这个我也用的。

其实并不多，给大家稍微演示一下就行了，select，呃s from，比方说java。land。string s执行一下，他会干一件事，他会把整个这个对象里面，整个这个这个内存的转储文件里面。

那些所有的string类型的对象全给你列出来，你可以去观察到底哪个对象有些什么样的问题，o。

这个呢就是怎么分析对称程文件啊，当然像里面的一些小小的细节啊，去怎么去去去去调哪个菜单，会有一些什么特殊的功能呃，我在这儿就不想跟你多说了啊，这个也没什么意思，那么到现在为止。

我觉得面试官再问到你这些问题的时候，我觉得你应该能回答出来了。

系列 6：P80：金三银四循环依赖面试题总结与解答 - 马士兵学堂 - BV1RY4y1Q7DL

你只要把这几个思考的问题搞明白之后，我回来之后，你才能真正的理解循环依赖到底是如何解决的，好了，下面我们开始采用一问一答的方式，我来问，你来答，第一个，三个map结构中分别存储什么对象。

先说一级缓存放什么成品对象对吧，二级缓存放什么。

半成品对象好了，三级缓存放什么，long的表达式，哪个浪费达式叫get early，变reference，对吧，记住这个名字，好了，来第二个问题，三个缓存map缓存的查找对象的顺序是什么样的，嗯什么呀。

先查一级缓存，找不到，啊这二级缓存在找不到，找三级缓存问题吧，好了来第三个问题来了，听好了，三个问题，如果只有一个map，能否解决循环依赖的问题，不能为什么，你要说清楚为什么好吗。

你不能光说不能为什么为什么不能，无法解决闭环本质上不是这样的，如果，只有一个map，那么成品对象和半成品对象是必须要，都必须要放在同一个map中，而半成品的对象是不能够暴露给外部使用的啊，所以必须。

要做区分吧，否则就有可能造成什么，所以就有可能暴露半成品，对象能理解吗，能进来扣一，有人之前提出过解决方案，说老师那可以啊，我只需要在map的value值里面加一个标志位，就行了吗，如果是零表示半成品。

如果是一表示成品，这样不也不不不也可以吗，对吧是这样的，我给大家整加一标位吧，是不是可以，你疯了吧，明明两个map可以很轻松的解决这件事情，为什么你要加一个标志位，你要考虑是什么。

你如果加了一个标志费之后，意味着每次在判断的时候，都要去取一下这个value值，你麻烦不麻烦，是不是意思明白意思了吗，为啥不能暴露战平，你半成品里面的属性都是空的，你你你你你你告诉我，你报出去干啥。

那没用，用完之后你你报一个空指针，你何必呢，你要觉得不麻烦，你就加b加一个前端的后缀，行，你要想这么干就这么干，你自己来评估哪个效率高，哪个效率低好不好，你自己来评估这件事情就完事了啊。

这就是设计方面的原则，ok来紧跟着第四个点，第四个问题，如果只有两个map，能否解决循环依赖问题，那么，现在还在为成品和半成品的事，我解释过了吧，我不再解释了好吗，能吗，能但是有前提条件，什么条件呢。

写到一边，我问一下，在刚刚的整个debug的环节里面，你在哪些地方看到了三级缓存，哪个地方，本产品russip产品了，啊这个地方两个地方用到三级缓存吧，第一个方法叫什么。

叫都create b方法里面有3d缓存，第二个叫get singleton，这样画吧好吧，那我们先来做一件事情，把源码改了好吧，我们改下源码，看能不能行，平常心说，这是录播，真对，这是录播，是录播啊。

录播录播录播。

抢了一晚上的录播直播来找那方法叫do create be，好找这行。

我们在刚刚进行的时候，我是不是看到了三级缓存的存储，我把这行代码给干掉，注释起来，然后我把下面两行代码给打开，看到同学们下一行代码，三级这几集缓存，这几款三二级吧，我没往三级里面放这个东西。

把它改成二级三级缓存，注释掉了，不要了，注释掉不要了好吧，然后紧跟着第二个地方叫get singleton。

这个方法一样的，我把这个东西逻辑都改掉，直接注释，说完之后改成我自己写的，来看一下这一段的代码逻辑，它有没有三级缓存存在，没有吧，是没有好吧，所以我可以做这件事情，我可以做这件事情好吧。

然后我们来掌握我们的警卫，我把d盘的东西关掉，来找到我们的启动词类，然后右击run，我们来看一下它是否会报错好吧，如果没报错，是味着可以解决，我来看看这里能不能能能不能行，会报错吗，会报错吗，不会嗯嗯。

马洛卡，没软件了，换啥软件，这编译啊，等着编译，换电脑来，我来看，这是b对象，这是a对象，我的ab对象成功了吗，成功了吗，成功了吧，没报错吧，是不是报错，但是同学们，你注意一件事，我现在改点东西。

改点啥，打开我的配置文件，把这行解开，把这行解开，我加入进去我们a op的相关配置，然后我再来重新运行我们的代码，右击wrong，重新运行所存运行，看效果，好了已经报错了，报错之。

后来我们把错误代码错误的提示给大家翻出来。

大家要学会去看这样的错误提示，因为测试题库提示里面，给了我们很多的一些信息，来截一下好吧，盖帽是异常，好了，大概分成四段吧，换成四段之后，前面这个东西告诉你说是什么异常，解释一下a对象出现了什么问题。

告诉你说可能出现了循环引用是吧，但是看中间这一行是最主要的一句话说，this means that that other beans。

do not use the final version of the bean，这句话怎么翻译啊，这意味着好吧，其他的并对象并没有使用叫the final version of the bean。

叫最终版本的并对象，这里面怎么还会涉及到版本的问题呢，来看好下面的思考和解释，这个时候重头戏来了，就是为什么要使用三级缓存来往下看，最后来说说能不能解决循环依赖问题可以，但是有前条件，什么天气条件。

循环依赖中不包含好吧，a op的处理逻辑只要不包含a o p好了，你就可以用二级缓存来解决循环依赖问题，但是出现a o p问题之后，我们就必须要解决这个事了，好吧，那第五个问题，警力来了。

为什么三级缓存，就可以解决a op过程中的代理啊，关注解决，解决循环依赖中，代理对象的问题，为什么呀，这是录播吧，对是录播，是的，为什么呀，来同学们听好，不不不不要不要的，这些录播直播了好吧。

下面的东西来了好吧，下面的东西关键点的东西来了，这里面我会抛出几个问题，听好了，第一个，创建代理对象，这时候好是否需要创建出原始对象，需要吗，需要吗。

你想想我刚刚在你提拔的过程，想想我刚刚在一个debug的过程，需要不需要在没生成代理对象之前，是不是已经创建出原始对象了，为什么，因为我们在创建对象的时候。

主要是do create in这个方法，在这个方法的最上面就已经，是不是把原始对象给创建出来了，后面在这个里面，的being post processor里面的方法，里面是不是才会生成代理对象。

是不是一定需要，因为你的标准的病的生命周期，有这样的要求和规范，就必须要生成，所以这个地方是需要的，需要明白意思吗，需要是吧，紧跟着第二个问题，同一个容器中。

容器中能否出现同名的两个，不同的对象，能吗，不能是不是意思肯定不能吧，这不用我解释了吧，肯定不能好吧，点开了第三个问题，如果一个对象被代理好吧，那么代理对象跟原始对象应该如何去进行存储。

本来的对象和代理对象并不一样吗，一样啊，最后说了嘛，这同名的两个不同对象吗，同名的两个不同对象吗，因为你名字一样都叫a，但是a里面可能是原始对象，也可能是带对象嘛，两个可能同时存在嘛，这时候怎么办。

好了同学告诉我答案说存代理对象，为什么存代理对象啊，凭什么就存在对象，这没道理啊，不能说你存在，你就说你说存在就存在理吧，什么意思啊，所以应该怎么去做，怎么记住，如果需要代理对象，好吧。

那么代理对象创建完成之后应该干嘛，覆盖原始对象吗，这能理解吗，叫覆盖也是很强的理解吗，能理解来归一，真的不理解，可以吧，当你当我提到这个覆盖这样的一个名词的时候，你有没有点感受，有点感觉啊。

在之前的某个步骤中，好像出现了补钙的过程在哪儿，哪，get early，reference方法中会判断是否需要代理对象，如果创建出代理对象了是吧，那么就需要补钙，是不是一个更能理解来扣一，对吧。

再想一个问题，那在对象对外暴露的时候，我怎么知道，或者说容器怎么知道什么时候需要，呃被暴露了，比如说我在对外暴露的时候，我怎么对外暴露，我什么时候对外暴露啊，啊或者换句话说不要这样说了，这样说吧。

在对象对外暴露的时候，如何准确的给出原始对象或者代理对象，因为因为正常的代理对象的创建是在，b p p，后置处理方法中在，解决循环依赖问题的时候，还没有执行到那个地方，是不是意思怎么办，我该怎么操作。

明白不，啊所以此时需要拉姆达表达式的啊，类似于是一种回调机制，在确定要对外暴露的时候，就唯一性的确定到底，代理对象还是原始对象，这也是为什么啊不把对象直接放到二级缓存中，而通过三级缓存。

把lava表达式的方式来执行的原因来，这句话能看懂吗，能看出来扣一，看能不，因为我不知道什么时候都在暴露，我没办法去确定好当前这个时间好吧，所以我在设置的时候，我就直接只会把我们的哪去了。

所以我因为我没办法确定什么时候对外暴露，你app being post processor，昨天讲过了啊，因为我没办法确定他什么时候都要暴露，所以此时我干嘛，我放一个拉姆达表达式进去。

如果这个对象在整体的调用链的处理逻辑里面，我需要变成一个什么，变成一个属性给他引用出去的时候，那么好了，我就去执行拉姆达表达式，而在这个lambda表达式里面，这里面我可以预先的做一个if逻辑的判断。

来判断一下我是否需要进行代理对象的创建，那么在这儿创建出代理对象之后，我还需要去在b p p里面执行，我们对应的后置处理方法吗，还需要不需要了，还需要吗，不需要了吗，写错了，啊bpp，写全。

是不是这意思能听懂吗啊，如果如何，哪，找不着了啊，你们你们你们自己找吧啊，如何，能懂这意思吗，来刚刚这块能听明白，同学12q1 ，能听懂，不，来再说一遍啊，那么听好了，正常情况下。

如果我一个对象需要需要被对，需要进行代理的话，我怎么办，正常一个对象需要在一个在哪，你需要在哪进行处理，告诉我，正常的一个对象，如果需要生成代理对象，我在哪处理，我是不是要执行到我们这个方法之后的。

这个里面，这里面再进行处理吧，是不是在这这里面之后，我才能去这里的构成处理方法里面生成，我们再在理想，但是我们在进行处理这种循环依赖问题的时候，我有执行到这个步骤吗，同学们，你想想我有执行到这个步骤吗。

根本执行不到这，如果执行不到这的话，我就要在这里面进行处理，那在这里面处理的时候，其实我程序是写死的，程序其实没办法判断说你什么时候，这个对象需要被其他对象进行一个调用，或者需要变成某一个对象的属性。

我是没办法确定的，所以我把它干嘛，我把它放成一个拉姆达表达式，这个时候我并没有具体的执行，我换成拉姆表达式之后好了，我放到三级缓存里面去了，我刚刚在调用的时候，你想我先创建a对象，然后创建b对象。

在创建完b对象里面，我重新的去三级缓存里面，找到了这个拉姆达表达式，然后来执行判断说，我到底需要是否需要代理对象，是不是相当于把这个东西前置了，因为拉表示这是相当于一个回调机制，它并不会立刻执行。

就当你需要给这个属性进行赋值的时候，你才会执行，你不不值，你需要执行吗，需要执行吗，不需要吧，你懂我意思了吗，所以这就是这个拉表达式存在的一个意义，就为什么用拉普达式之后。

会用三级缓存之后就可以支持这个功能，就因为这个东西对我一直来说，我说你详细看这个逻辑，他的逻辑是什么样子的，刚开始有一个这个东西是吧，刚开始原始对象放给暴露，如果需要被代理好了，我把它变成代理对象。

我对外反馈的都是这个已经暴露的对象，这个东西明白意思了吗，你某一个对象的代理值可能是一个吗，对不对，如果你是多个代理的话，你就要看你代理对象创建了一个顺序了，你懂我意思了吗，来刚刚这块儿。

因为麦同学给老师扣个一，其实这题我跟你聊啥，不是聊一个时间问题，什么时候需要对外暴露，程序没办法确定，所以需要通过拉姆达表达式的方式，在确定需要对外暴露的时候才执行对象的确定。

确定啥也就是确定到底是原始还是代理，就这意思，好吧，和你说，那把la表达式放到二级缓存里面去，二级缓存里面执行不就不需要三级缓存了吗，那你告诉我你的成品对象和你的半成品对象，你要放哪，你怎么区分啊。

别忘了你的三个缓存里面，一级二级能放是object，而三级里面需要放拉姆达，是必须用object factory，他是没办法直接放对象的，6662阶段是没法直接放对象了，听明白了吗，明白意思吧。

哦所以下去之后自己再好好去debug，再好好去操作一下这个对象的一个操作，你大概就能够理解了，就是为什么，但在代代代理对象的时候，他必须要有这样的一个流程啊，他怎么知道哪些类需要被代理呢。

只是冲突就回去，还是集成某个类，某个接口类这种带对象，你什么时候需要配代理对象，你不知道吗，你城里面是配好了，这配置电车已经配置过了，面子，好吧这样搞清楚了，那这个时候就会突然有一个问题啊。

同学们想好了，就是什么里面提供了循环依赖的解决方案，你们在日常的实际的工作环境里面，有没有遇到过循环依赖的问题，6万为什么呀。

为什么它已经提供了循环依赖解决方案，为什么我们工作中还是会遇到呢，为什么，同学们注意一件事儿，spring是一个跟业务无关的技术框架，好业务在满足它只能是预先预防一些问题，而不是解决所有问题。

就跟我们写代码之后的异常处理一样，你能预先判断到一些问题，但是不是所有的异常情况，全部，都能解决掉的，能理解吗，同学们来这儿能记的东西多少扣一，他只是给了我们一个一种预防方案，如果你是这样的方式的话。

ok没问题，我可以解决，但是如果不是这种方式的话，不好意思，找人办不到，你写异常背也是一样的吗，你能保证你写的程序没办法是这意思，比如说你在用spring bot的时候，最基本的数据源那个异常循环依赖。

你在引入一些那个连接词的时候，数据这个问题最常见的吧，这个时候当你出现这种循环依赖问题的时候，你就要去排查了，什么时候出现这种循环依赖问题，我的循环它到底怎么解决的啊，到底怎么去做的。

应该怎么去排查这个应链的关系，这个时候你要根据你具体的代码逻辑，去进行具体的解解决了，而这句话他不是所有东西都可以解决掉的，好有同学说老师我可以加and lily来加载，可以几个一部分。

但也不是全部明白吗，所以根据实际情况来进行实际的一个解释好吧，终于讲完了，来什么感受，小伙伴们二表达你的感受，一个圆形，一个单例，两个循环依赖会报错吗，会，脑子不够用，我是谁，我在哪，哈哈哈哈对啊。

你就想一件事，同学们像这样逻辑，其实你应该去怎么办，大家都尽力了，大家尽力了，其实你应该怎么怎么做，其实非常简单，你可以去进行一个基本的操作，什么操作你可以去试一下，按照我刚刚的解决的方案。

你可以去调用一下好配置，上我们具体的理由逻辑，你可以琢磨一下这个事儿，如果你听到一件事啊，如果我现在我在带着你debug，你现在都听不懂，你在自己写的时候就会很很懵。

而你们现在很多同学都听不懂的原因是什么，是因为我刚刚带着你们过了一下思路，但是仅仅是过了一遍，你在脑海里面并没有形成那样的一套思维逻辑，懂我意思吗，其实我们可以画一个图出来，你就大概理解了。

来看看流程图，刚开始的时候我是创建a对象，听好了，a对象行了，直接写吧，叫实例化，对象嘛对吧，然后再开始叫初始化，要给a对象的b属性，赋值对不对，在赋值的时候你要干什么事儿，复制干嘛。

是不是到一个问题叫创建b对象，但这个时候中间会有一个环节，别忘了再给它实例化，完成之后。

在中间这块，把a对象，是拉达表达式，放到缓存中，单集中，缓存，这种地方同学们，这没问题吧好吧，然后下一步在干嘛，应该创建b对象了，刷新对象完成之后，紧跟着下一步是不是b对象的，然后表达式也放进去。

然后紧跟着干嘛，是不是该给，b对象的a属性变形赋值吧，那么在赋值的时候要干嘛，要查找a对象了，那么查找对象会去哪儿，会从哪取，那干嘛会从三级缓存中获取到谁是不是a对象。

好但是此时的a对象放的是拉姆达表达式，我问一下，在这个步骤里面，在我这个步骤里面，我现在因为要赋值了，我现在要不要给出一个确定的a对象，我要不要给a一个确定对象，这是不是一个明确好时间点了。

但在前面那个流程里面的时候，你是并不知道我什么时候用的，那你这个时候你确定需要一个a对象，你告诉我你怎么办，你不要不就需要通过那个lam表达式里面的，get in get，这里并。

reference方法来确定到底返回的是，原始对象还是，代理对象吧，你这是不是要联储决定好了，这不是训练好了，那你这个时候只能通过拉表达式里面的，什么叫get get方法，你只能在这里面通过get。

哦不对的方法去交通确定了吗，就这意思吗，好吧，这东西啊，我觉得我不要再讲，讲完之后你们脑海里面没有这样一个图，你没有这样的图，你脑海里面你是很难转过这个弯的，所以我觉得下去之后按照我说的那个思路。

把刚刚那个流程再重新的去进行一个debug操作，因为在整体这个创建链路里面，我是不知道什么时候确定的，但在这个步骤里面，我因为要赋值了，所以我必须要确定出一个具体的对象，然后才能够进行给它赋值。

明白意思吗好吧，所以这一定要搞清楚了好吧，这东西还是要明白呃，这东西我自己啊在学习的时候，自己在看的时候，我自己本身我也琢磨了很久，我也琢磨了很久，所以这东西你下一步你说你光听我讲一遍。

你就把这东西完全理解透了，我觉得不太不太现实，更多的是什么，你自己一定要去实操，实际的跟着这个逻辑好好捋一下，捋通一下，真的你自己不用多三遍提bug，你能提拔下来，基本就通了，但是你如何去debug。

我刚刚在刚上课的时候，我已经说过了，你就叫你先不要考虑三个四个带有象好不好，别考虑事，同学们，你先想把一个东西想明白，你先把一个东西想明白之后，你再说三个四个代理对象怎么处理，你一个都没搞明白。

你现在搞三四个，别给自己找事儿，憋着要找找麻烦，一步一步来好吧，好了，这东西我觉得就聊这么多吧，好吧对点了个蚊香，有蚊子咬，我点个蚊香是吧，呃这东西啊，咱们就聊这么多吧好吧，下去之后还是那句话。

一定要自己去实操，你不去思考这东西，我也不知道该以什么样的方式去给大家进行，讲解了，因为我在讲vip的时候，这块我也是一样，我讲了就讲了挺久的，就讲了特别久，就这东西我也讲了，给同学们讲了很多遍。

很多遍可能还是比较难理解一点，但其实最关键和最核心，还是你自己缺少这样一个逻辑思维，或者一个线性的一个贯穿过程，如果你真的能把这个贯穿过程给贯穿下来的话，其实真的还是相对比较好理解的，好吧。

来今天晚上的课，觉得有收获的同学给老师扣波六吧，好不好，啊你们扣六，我就我就我就我就放心了，我就放心了，那在面试的时候，你去回答这样的问题的时候，你就知道怎么去回答类似于这样的问题了啊，好好去回答。

而是那句话，原版的问题啊。

系列 6：P81：如果进行系统的学习提升？ - 马士兵学堂 - BV1RY4y1Q7DL

今天下午的时候也是一样，在咱们的一个群里面是有同学分享一个念经，我不知道有多少人在那个群里面给大家看一下，他分享的是面筋，但没经过他自然允许我发一下，这个同学如果介意的话，我给你道歉，非常抱歉。

我不知道这学们来上课，就是啊他分享一下他面试的一些面筋，就是这个东西啊，一会儿下课之后可以给大家分享出去，是他面临一些公司吧，什么小红书啊什么之类的，就是我分享的是吧，我我可以给大家看一下吗。

这同学大家看一下这个同学分享了好吧，这些同学分享了，我给大家看一下，好吧，就是大家很多人可能最近都在面试啊，我把这个东西收藏了一下，我觉得这个问题呃，这里面发这些问题，我觉得挺好的啊。

因为这个这个问题其实坦白说它是非常全面的，你们其实可以自己去看一下，他到底问了啥啥东西，诶怎么点不开了，诶，我收藏点离开吗，重开了吗，点开我找一下在哪个群里，知道了。

我想给大家发一下这个同学免费分享出来的，我觉得挺好的，大家其实也可以分享一些这样的一些面试题，就是然后他发的东西我觉得挺好，看这个大家自己总结的，那面试问什么，现在面试确实问的话难度会很高。

你们可以了解一下，比如说他们到了海内外工作原理，1。81。7的区别，卡卡的smap的原理，synt是并发编程的线程池，并发编程的ur卡是我们的注册与服务中心啊。

spring cloud zk是我们lukeeper，然后bean的加载原理，3d缓存，redis是我们的缓存吧，reaction log sync的区别，这东西是我们的并发编程里面的好吧。

masterc下次聊聊到了隔离级别怎么解决换图，然后索引sql优化对吧，下面有卡夫卡的东西对吧，有分区的一些配置，相信有居性啊，还有a q s也是并发编程里面的slocal对吧。

强化入侵引用cm s垃圾回收器的，包括像redis一些东西，mysql一些东西，什么m v c c标sher这些点，然后还有一些算法的题，rise的题对吧。

bean factory和factb的区别主要降低很多，看完这些东西吧，就是这些点都是面试中现在问的比较多，或者比较常用一些点，这是算法上面的问题对吧，都是算法的问题，所以现在的面试啊。

基本上考核的东西是比较多的，写一个什么缓存类的啊，去提交一下这样的问题啊之类的，你们可以看一下这些问题，真的就这些问题你可以自己浏览一下，你到底能解决多少，或者说到底自己能理解多少，这东西啊。

就是现在面试的难度，我自认为我觉得这东西挺好，为什么挺好，原因非常简单，我觉得这东西啊啊，这个面试如果是一个面试里面的，如果一个面试里面的，我觉得真的问的挺全面的，这个东西最起码是高开。

或者说初级架构师这个级别才会面试，问到的问题，明白意思吧，编制的问题啊，包括天下午我们一个学生也是一样，他也是给大家分享一下面试题啊，延时间面试题，你们下去自己看一下好吧，给大家看一下，就这个学生啊。

他最近在面试，你看这题会不会啊，你们你们看自己会不会啊，那聊了很多啊，你可以瞅一眼，往哪看用户如果有用户反馈进入个人中心好吧，个人时间很长怎么办，那怎么定位。

怎么通过sql语进行优化来看压制怎么排查问题，事故的问题告诉为什么回滚好吧，m q的百分百策略回表是什么，所以覆盖是什么几点存什么数据，masgo的匹配前列啊，匹匹配前缀好吧，什么时候导致索引失效。

省时间，藏品茶对吧，还有分布式的一些解决方案对吧，什么是双写release和macbook的双写一致性，怎么保证tp m的参数怎么设置，线上日志怎么定位对吧，大家看双击执行的m q的稳定性对吧。

参数设置o m的排查方案看了吗，c k的东西怎么去做，你看他问多少东西吗，这是他最近去面试的时候问到的问题，来告诉我你们会几个，你们会多少，零哈哈哈哈哈哈，别说零啊，嘿你觉得人问难吗。

就拿的扣一不难的扣二，告诉大家这个同学刚刚发的那些面试题，大概处于的水平是什么，是中级这个水平，中级好吧，他已经找到工作了，今天下午刚跟我说的，往上看，他说的，今天下午5。20老师面试了一些。

然后有一个19k的offer在纠结，距离太远了，然后呢两个小时地铁什么之类的，19k，比如说面19k需要面到这样的一个程度，北京在北京还是在北京的，然后你跟我说他金融公司什么之类的。

那我问我应该怎么去做好吧，那我怎么怎么怎么办，租房子什么之类的，他聊了很多，看了吗，这是持久k需要面试问的问题，所以你们可以看一下他大概面试的一个19，高级没到，高级好吧。

所以这里面会签到一个问题就变得越来越难，我今天这个训练营写的东西也是一样，叫精精三银四，带你轻松跨过这个词。

面试重灾区，为什么说面试要求问的比较高，这就是现在面试的一个难度。

就你必须要学会这样的问题，昨天我上课的时候也给大家解释过了，为什么说面试要问这些东西，你们理解吧，就在公司里面，公司里面我们更多的可侧重于是业务和需求，但技术其实已经荒废了，技术已经荒废了好吧。

但是但是在面试的时候问的更多是什么，是技术，连这也没办法了哦，所以你想想你自己到底要怎么样进行储备，怎么样进行相关的一个基础的学习吧好吧，今天的干货东西咱们就聊这么多了好吧，下面的开始进入到mc环节。

你们可以理解为麦克没关系的，我觉得更多是什么，给大家梳理一下，你到底要进行什么样的一个基础储备，好吧，呃什么对前面那个是30k的，可同学说了，前面是30k的好吧，呃所以呢这里面会受到一个点。

就是现在面试啊问的东西会越来越大，越来越全面，就他考核你的东西啊，不再是某一个具体的点，而是说你整体的系统性的东西，这些面试题刚刚我上课展示这些面试题，大家如果想要的话，包括我今天晚上画上课画那个笔记。

大家想要的话，如果已经加过咱们小弟的微信了，不需要重复加，没加过的话，扫码加一下，我会分享出来好吧，找他们消解药就可以了，ok所以下面我想说的是什么，就是大家在这个行业里面都想继续的走下去。

那其实最主要是什么，是你的学习思路和你对应的一个学习方案，这事儿其实是非常非常重要的，我也希望同学们在这行里面一定要记住，叫持续性学习哦，而且不断学习，如果你不学习，你很容易被淘汰，就直说吧。

这很容易被淘汰啊，但很多同学其实是不知道自己要学什么的，昨天我分享一下我们的大纲，我也给大家说，我说这个大纲是什么东西。

你可以把它理解为是我们对应的课程大纲，所以它更多的应该算是什么，是一个学习路线，就如果你想成为一个合格的程序员，或者说如果你想在这个行业里面走得更远的话，你应该去如何沉淀自己的技术。

你应该以什么样的方式去总结自己的技术，去学习自己的技术，这些都挺重要的，是你报不报名，先扔一边，你可以报，可以不报，没关系，你自己来自由选择，这也是无所谓的，但关键点是什么，你要知道我现在欠缺点是什么。

像刚刚我给你展示的，下午那个同学分享了一些面经，基本上咱们的技术里面全覆盖了，好吧，同学们，你们现在可以给我提供一些你自己的信息，什么信息呢，第一你的年龄，第二你的城市，第三你的薪水，在听课的同学。

你们都发一下，发这东西干嘛，你们可以来评估一下，你现在的年龄和你现在的城市对，和你对应拿到的这个薪水是否是匹配的，你可以自己去做一个验证好，大家可以去看一下，好吧，这个同学说老师我最近面试被问到了很多。

不知道怎么说难点和亮点，难点和亮点要围绕在什么地方去说呢，难点和亮点要不要到一些调度的点，重构的点，以这些维度去说明，包括你项目中的大数据量的点，可以看一下同学分享了，我们来看一下这个东西。

大家看一下他的薪水，南京25岁10k27 岁，27岁，北京22k，北京28 6年25k对吧，24北京18k，北京20 61k，大家可以看一下这个薪水，这个北京27岁22k，这个26岁11k。

其实大家是能够看到你们对应的差距的，这差距不用我多说，好，吸嘴高的同学，那自己一定有自己技术比较擅长的点，就比如同学说，老师，我到底应该怎么去凸显我的亮点和我的优势，我就拿一个东西来说。

我们先不聊路线点，你们在写简历的时候，同学们问一个问题，要不要写一个模块叫自我评价，有人写吗，写不写，你们，个人优势对吧，可以说个人优势，别个人评价，你们要写啊，你们告诉我你们写的什么，热爱学习好吧。

能忍受加班，性格比较好，热爱篮球，有人这么写吧，学习态度好，自学能力强，有人这么写吗，有吧，一定有一定有好吧，但是你知道我们要求我们的学生，是怎么写这个东西的吗，我也看几个例子好吧，来看这个东西。

你们可以截取，你们看看他怎么写的，5年开发经验，3年项目架构设计经验，3年团队管理经验，分布式高并发高可用大数据样本架构设计经验，研发经验，负责的项目什么样子的，什么效果。

对什么技术有什么原理理解来敢这么写的，扣一不敢这么写的，扣二，我相信很多人都不敢，为什么，因为你但凡写这样的东西，你一定会担心老师，我面试的时候，面试官问我，你怎么办，我不就垮了吗，我告诉你。

实际上这个学生他们也没有这么牛逼，他那个项目里面注册用户300万，好日活3万，没没没这么高，收入大概几10万，访问量一个亿，没有没这么多，真没这么多，但是他有自己的技术储备之后，他是敢写的。

面试如果被问盘问趴下了，没关系，问他问他呗，此书不留爷，自有留爷处，对不对，但你不能说，如果你连这种东西像你们写了些什么，热爱学习，自学能力强，什么态度，积极，团队协的能力强。

你想想这玩意你告诉我有什么意义，他真的没意义，所以你如果想写成这样，前提是什么，你要有对应的技术做支撑，明白意思吗，你要有这样的一些技术解决方案，或者有这样的一些技术背景，在那前提是什么。

前提就是你必须要对自己的技术有深切的把握，你刚刚给你们看了你们对应的城市薪水和年限，工作时间，你们其实能对比出大家的一个区别，那么你可以再反思一下，你自己的技术水平，到底是处于什么样的一个状态。

你自己去评估，我今天给大家展示过这张图了，我今天再给大家好好说一下这东西，如果你现在在公司里面，已经是一个最基本的开发程序员了，那么在我的在我们的课程体系里面，你大概属于什么叫p5 。

这个直接那么意味着什么，你具备了一些前的前置知识，就在今天下午，我们还有一个学生，今天下午刚刚找我聊天，我会给大家看，看情况分很简单，你看这学生情况，他是我们vip天下观察我的好吧，20年毕业生。

204月份马拉特好吧，跟着课程开始学习，然后120年7月的1~20年9月，南京加工工作，6月份看秋季班好吧，然后呢这和iphone找到了offer，9月份到阿里了，直接p51 直供到现在。

他问我后面怎么持续发展，他已经进到阿里拿p5 了，也就是说你可以做一个正常技术水平的开发了，那么你告诉我后面你要学什么，如果你掌握了s m spring boot好吧，能做一些基础开发了。

能做zo p了，ok你就是一个p5 开发工程师啊，那到屁股之后，你还要做晋升啊，你还要储备你的技术啊，你要储备什么东西，昨天我也给大家说过，这东西非常简单，第一个底层的技术，刚刚上课，我也问了很多同学。

都是非科班出身，你有多少同学是培训出来的，给老师扣个一，扣个一，我看看没事，你们破好吧，我看不到你的学习那个真实信息，哪怕你不是培训出身，在大学里面也很少有人是科班出身，所以呢会涉及到一些操作系统。

计算机组成原理，网络io啊，运维，数据结构和算法知识，这东西我相信大部分同学都不会，哪怕你是科班出身，可能也不会，这东西要不要学，而且你走的职级越高，这些东西都要获得，你们现在应该有感受。

现在面大厂算法要求吗，面大厂是不是叫算法，我问一下你们了解的必学必考，算法必考，这为什么，因为现在的公司就会发现，他越来越注重这些底层技术的一个什么支撑了，如果你没有这些底层基础支撑，那不好意思。

真的很难对吧，第二个吧，并发编程，刚刚看面试题里面有到的操作系统支持并发，并发支持队列的内存模型的，线程池的集合的c e s的，slocal的j u c g m h的character了。

是不是很多对吧，通信东西，现在大部分的项目只要不是传统行业，互联网行业里面基本上都是分布式架构，你要不要了解一下通信的东西，什么叫r p c，什么叫g r p c，什么叫rest。

你的craft包包括z k啊，和我们的double里面到底是怎么进行通信的是吧，nike怎么进行通信，你不是说你不会，你不会怎么办，对不对，包括中间件这块中间件比较多，什么ex mq，rock mq。

robmq，卡不卡拉什一堆，我们对学员要求是这样的，精通一个熟悉其他中间件，提供面试必问，你一定要有一个能拿出手的，不管你选择rocket还是选择卡夫卡都可以。

但是不要选择i s m q这东西已经淘汰了，包括rob hq也在被淘汰过程中，所以选择最新的技术，你要储备好，你要做到精通，不能说你只是会用，会用，这个层次太基础太简单了，更多是什么，了解其中的原理啊。

甚至你要去看源码，像咱们这边课程基本都讲源码这系列，好吧，包括中间件release，很多同学我相信公司里面还有五个版本吧，我们已经讲了六了对吧，像这个软件设计技术可能不太重要。

是敏捷开发了文档编写这类东西，这东西能了解一下就可以了对吧，分布式架构里面什么分布式锁，分布式事物，分布式绘画，分布式密度，分布式id，分布式权限控制，分布式预警监控，分布式链路追踪。

你要不要会分布式电台面试一样，你想进互联网公司就是逼问别再挑对吧，包括优化的tvm调优，mysql调优，tomcat调优，n g调优，项目调优，要并发的平a调优，你也要储备吗，是这意思存储的。

你不能说一涉及到存储，你想吧，就是msl浩克要不要回一下，对不对，太低b要不要会一下，好多次，要不要会一下，这都是新技术，银行会啊，你不能说手里的msl过一辈子是道理，搜索的e也不会。

如果你有一个e认证证书，是不是很值钱对吧，包括海量数据库里的数据里面的一些flink spark，那维持base这样的东西，那么rose这样的东西是不是也要接触一下对吧。

包括上运维的cd n t n s是啥对吧，在office里面的docker k8 s普罗米修斯grafal对吧，ex你要不要会啊，包括一些技术测试的东西，是不是要会所，这是一个基础级别的。

像p对我们的技术专家侧方式叫操作与落地，这个层面你需要掌握的技能来，觉得多的同学给老师扣一，多吗啊多吧很多吧，但是你要去思考一件事，如果你不去学这些东西，如果有人学了，你尴尬不动的。

就如果你没学别人学的这套东西了，你告诉我你跟别人的竞争力在什么地方，你拿什么跟别人去同台pk，拿什么跟别人去竞争，这东西就是面试中必问点，看这哥们说的，就像我那个哥们工作6年了，应该是工作6年了。

好基本面试都会问，就是这些常问点，比如你想拿到30k或者二维左右的薪水的话，那这一点就是基础的低分项，你说你不会这些技术，我都不好意思，真的很难，真的很难好吧，你以为到这就结束了吗，没有啊。

包括下面还会有p7 的原理与设计，你需要掌握一些理论基础，比如说c a p paths rap这些东西对吧，你需要掌握一下最关键的算法，令牌桶算法，漏斗算法，那选拔d对吧，分布式算法配置rank。

这东西特别会包括一些机器学习里面的，朴素贝叶斯协同过滤好吧，逻辑回归，线性回归，不要懂一下这东西好吧，包括源码，让我直接讲源码就其中一个章节吗，你以为只掌握密码就够了吗。

不是你要掌握spring spring vc，spring boot mybatis对吧，包括tom c，包括像我们的spring cloud，包括像m q的。

包括像net和spt e l k对不对好吧，再比如说你要懂一些架构设计，像刚刚那个面试题里面就给大家分享的东西，里面涉及到红包雨的设计，秒杀系统的设计，要不要会分流，怎么设计服务并行，没法怎么设计存储。

怎么设计缓存，怎么设计应用保护，怎么设计可靠性怎么设计，对不对，包括一些真实的案例可以看一下对吧，红秒杀专题，红包雨的微博互关的票务系统的弹幕的是吧，全力都压缩了啊，你如果真的把一个技术学得精通了。

或者学会了咱们的课，你看完了，你不用多看号的呀，我们的每一门课你看完之后，你掌握61%个点，涨1000块钱没问题，真的是这样，这个一点不开玩笑好吧，这是我们的这个技术点，这只是单纯的技术点。

除了这些技术点之外，项目要不要储备一下，我们有一个大型的东宝商城架构项目，web前端架构，后端架构用什么技术，你看到了吗，注册中心配置中心，网关服务调用限流认证认证，授权链路追踪的同步的数据。

同步的全文检索的缓存的，分布式锁的分是用调用调动的，都要学啊，大数据架构里面要学什么对吧，实时数仓离线数仓是分ai分析里面要学什么，怎么做任务，用户画像怎么做。

推荐系统是原生架构里面docker k8 s怎么上对吧，包括我们的网易车项目，网游服务器项目，好推荐系统这些东西都会有，包括我昨天给大家看了这个，我们马上，我马上就开始搞一个叫马士兵严选的项目，对不对。

这都是你要储备的必备的技术点，除此之外还有面试，你要学啥对吧，面试题的精讲，简历的指导对吧，包括你晋升的指南好吧，你面试的指南对吧，包括你如果说我职位比较高了，我想冲击更高的职位，加工时间掌握什么东西。

云原生的啊，我们专门有一种大厂bug处理专题的亮点，大家怎么写，能不能把这些点写上去，对不对，包括我们的架构设计方面的东西，架构师里面总结架构师掌握的管理的领域，驱动的啊，ai的产品管理的。

你是不是也不会明白意思吗，所以它是一个全方位全体系的一个课程，你工作确实就有一点告诉大家，工作确实就是硬的，但是但是你的面试会问的很多，所以我为你来说，我说你报不报名没关系。

但是我希望你能够把这个东西要走，为什么要，因为你要去梳理里面的知识体系，好吧，你要知道自己欠缺的点在什么地方，然后我要怎么去进行这样的一个储备啊，没有人会说老师你们这个课大概多长时间啊。

有人好奇多长时间吗，耗尽时间来，第二扣个一，有人好奇时间吗，就这个课大概要讲了多长时间。

我给你们看一下好吧，推销mc百万高级架构师好吧，这里面可以看一下165册，13685节，3256个小时，这只是已经讲完的视频课，我今天讲的这个源码东西，就是其中的一奶奶思维源码体系，看我讲多少。

你自己看啊，这是我们讲的源码的东西好吧，反正你以为这东西就完了吗，没完没完，还有什么，还有我们的科研更新，比如说我们每门课都可以进行课程更新，每天有我们对应课程的一个更新日志。

这更新日志你自己也可以看了，你可以自己去看吧对吧，比如说21号更新了什么课，20号更新什么课，19号更新什么课，18号更新什么课，更新多长时间，你自己去看看，所以你要按照这样的方式来进行技术的储备。

持续不断的把你的技术给提升起来，这样的话你才能够具备你自己的核心竞争力，这才是最主要的东西，明白什么，那有人会问老师，你们这3000个小时的课，我得花多久学习，如果你正常学。

你可能需要花2年甚至更长的时间啊，但是还是那句话，你每一个人在短期时间之内一定有自己的目标，那么老师会根据你个人的情况，给你规划出一条适合你自己的学习路线出来，什么叫适合你自己的学习路线。

可以给大家看一下，每个人报名之后，账号进去，说有个人中心在个人线，每个东西叫学习路线，老师会根据你个人的情况，给你规划出一条学习路线出来，比如这哥们呢啊，不需换工作，你可以根据这个路线来学习啊对吧。

这块点进去，你可以直接按照路线的节奏。

一步一步进行持续化的一个学习和沟通，都是有的，明白意思吗，学都可以看，老师会为你量身定制适合你自己的学习路线，你只需要把这些学习路线，按照老师的规划储备就行了，播完了老师，我当前这个阶段学完了。

我要学什么，k老师再给你规划下一个步骤，你要储备的技术都有的，看到没，看到了吗，你可以直接在平台里面进行学习，这才是你要做的基础上的一个提升，明白意思吧，刚同学老师课程报名之后能一直学吗。

你当下这个阶段，如果你报名的话，现在的课你可以全部来进行学习好吧，能学多久，课程有效期，这些课这些课有效期是永久，但是但是你注意了，我们的课程因为一直一直在更新，你能享受2年时间的更新的权益。

但是2年之后你如果还想享受我们的资金权益，每年你需要加一个188元，这是什么东西，一会儿我会给大家解释这件事情，解决大事情，当你们说会不会到时候找不到老师，我就给你从平台里面直接看一个例子好吧。

我把学生信息隐藏一下，给你看一个最基础的例子好吧，有一个学生，你看这个这是刚报名的一个学生，最近时间3月18号刚报名的名字，隐藏一下，看看这个学生你可以看一下，我当我给他规划路线之后好几天了。

你看一下我给你聊多久，看了吗，我们一直在聊天，在沟通，在沟通，他今天聊完之后，你看一下他的反馈好吧，同学们，这个你看看聊多少，这边有好几个老师，这老师看着他的笔记对吧，他的评价可以看一下，真的强。

直接讲通透了，无敌好吧，百度出来不值钱，老师牛逼，看了吗，看东西了吗，这是学生的反馈，你说老师有没有可能老老师到最后不管你了，你觉得可能吗，拿我个人来说，我现在还是没bb老师，你看到了吗，我现在上课。

今天晚上课44条消息，这次热搜里面有很多是之前很久之前老学员，我随便给你拿一个案例来说吧，好吧，看你会不会有学生，这个学生这哥们儿他最早的工作了，看看这个学生，看着老师这个东西好吧，要不要去打算接了。

25岁有点销，我说你是应届吗，应届毕业生年包40万，就是昨天不要着急，我给你看，我跟他聊多少好吧，你们自己去看，12 2020年11月份的，中间可能消息没同步啊，是2020年的，这是2021年的。

2020年开始，我就一直在给大家聊，你看10月份的你可以看我的学生做多少啊，20s k by 24号，我并不是说我随便拿出来一个案例，说给大家展示一下，说ok这选手多牛逼，看这个这些中，老师连走都走。

收到什么offer了，总包涨了80%好吧，你准确说连报36万好吧，我给你往上看看，我们沟通3月份的1月31号，12月份的，11月份看到了吗，你说我可能去不理他吗，啊你觉得还需要我给你看聊天记录吗。

还要多展示吗，不用了吧，你不需要在意这些事情，你随便打开一个东西，你找到个消息，需要老师有一堆的这种聊天就等着你，只要有问题，老师看到了一定会给你回，记住一定会给你回，当然会给你回，我如果解决不了。

我找其他老师解决，如果其他老师也解决不了，我们请我们大堂里面的一些建设老师给解决，如果见到老师也解决不了，那可能这个问题就真的成为一个问题了，但总之一定会想办法帮你解决，在我们能力允许的范围之内。

所以你过来跟着我们，他是学习就完事了，所以为什么很多同学跟着我们，在当下这个阶段，还有很多同学能够推导成功，为什么你们自己在找工作的时候觉得非常麻烦，来，原因也在这，它是由老师给他保驾护航的。

还有老师来帮助你进行对应的一个技术储备，同时做你的后盾，明白意思吗，所以你学起来没有后顾之忧吗，你就按照老师的规划，一步步踏踏实，正能量绝对没问题，我因为我们已经服务过成百上千的学生了，我就给你看。

我个人，我个人现在能出多少学生可以给大家看一下，好吧，这个我也不大牛逼，皱着群，你看一下你自己看多少钱，看了吗，学习规划的群，我们在给学生进行沟通好，再给学生做这个问题解答，你把心放肚子里面。

踏踏实实的跟着过来学，绝对让你的学习效果是事半功倍，明白意思吗，如果你对于这些教学效果不满意的话，你可以打开马士兵教育的官网，在马士兵教育的官网的上面对，再把人民教育的官网这块儿。

说出来了，等一下官网下面有一个模块叫做就业喜报。

你可以打开这个节约喜报。

随便去看，我能给大家做出的保证是什么，保证告诉大家这里面的每一个就业截图，记住每一个，我说不多了，每一个，如果你对这里面的任何一个就业截图有怀疑，是你报名之后，我可以把未打马赛克的完整的截图发给你看。

如果那个学生允许的话，我甚至可以拉你们两个前聊天都没问题，我因为什么我们保证这东西绝对真实，有一个假的，你报名之后，你发现老师这图是假的，ok告诉大家学费，我员工投资的退给你一分钱，不要我们不需要放假。

我们就凭我们的正确实学，我们就可以保证很多同学还有这个薪水，20给个建议，滴滴35x15，39x14，选哪一个，585年的，看了吗，36周岁了，其他款37的上下也需要钱啊，贝斯高选择了火币。

被人民币打败了对吧，你可以看这哥们儿30后面三个月，34岁涨了3000块钱是吧，转行的成功就业，月薪20k，原始6k涨到50%，看了吗，这是我们最真实的一个情况，你随便自己去查。

我把这个地址发在你随便去查，我说了，你需要任何的记住任何一张的位置，马赛克的真实聊天我都可以给到大家，有一个是假的，我把你的学费原封不动的退给你，就这么自信好吧。

包括女老师，我想要就业内推可以吗，可以我们有专门的就业内推，这把有一堆堆网站，那你可以自己去研究，自己去看啊，包括字节的有很多，你看这个这个这哥们发这个消息，我是自己通网直播平台的好吧。

研发负责人看到马老师的个人材料，觉得可能有不错的学员推给我，可以直接安排面试，明白意思吗，好吧，你可以自己去看看他的工牌身验证，懂我意思吧，所以你把心放肚子里面过来，认真地学。

踏踏实实的储备和完善你的技能，百分之百的认识，把这哥们说，求你们别去抖音做ad了，ad是这市场都在做啊，怎么了，有问题有啥问题吗，这同学米哈游不清楚啊，小公司一般不太多，大公司一般都有，小公司不太多。

米哈游，好像没有没听过这个东西，没有啊，这个没有，但是你说美团你搜一下肯定是有的好吧，所以啊踏实实的储备和完善一个技能，让咱们来进行学习就可以了，关于课程介绍，我大概就聊这么多啊，他要这么多。

大家如果有需要的话，踏踏实实的让老师来学习，你们能感受到，老师这边的教学水平是什么样子的，我在我们机构是最菜的，最菜的老师好吧，所以你可以相信好吧，马师傅教老师踏踏实实的跟着自己的路线。

跟自己目标来进行对应的一个技术储备好吧。

那么今天晚上我也要说一件事，就今天晚上报名同学，你会有什么样的一个优惠活动。

可以给大家简单看一下好吧，还是昨天的一些优惠啊，第一个点叫福利二选一好吧，今天晚上报名同学，你可以选择六期免息，12期免息呢，就是很多同学说老师你们学费比较贵，我拿不出钱来好吧，拿不出钱来。

所以呢呃需要呃分期来付款，没关系，我们支持很多个平台的分析，那么六期分期的话，我们可以给大家领到利息好吧，第二个你可以选择零元入学，什么留言入学，也就是说这个月开始报名法，那么3456789。

这几个月你都不需要进行交钱，后面12个月啊，后面从10月份开始，分12个月来补齐你的学费就ok了，明白意思吧好吧，同样的，今天晚上报名同学像我们的mc课程师，课程架构师，大数据的算法。

有一个要问号980的价格，同时进了还有一个京东满减的优惠券啊，这京东满减优惠券是一直有的啊，偶尔会有。

系列 6：P82：深入剖析MySQLl背后的架构设计，带你充分了解MySQL的架构设计 - 马士兵学堂 - BV1RY4y1Q7DL

这个东西啊，我先说一下，你连了它之后，对你对于mysql的调优也好，还是对mysql的深入理解也好，都是有帮助的好吧，那我们在划分的时候，基本上会发划分为三个层次，第一个层次我们经常称之为叫客户端。

客户端，什么叫客户端，就比如说我们自己写的代码，像jd b c的对吧，比如说你们自己之前用过的一些工具来vc对吧，再比如说用的sql这些东西全部都属于客户端，客户端它存在的意义和价值是什么，注意的。

只是为了提交sql语句，就建立连接，提交搜索，明白意思吧，把这件事你要先搞明白了，叫建立连接，提交sql第一个步骤，当客户端完了之后，客户端是向谁发起连接，并且建立连接呢。

在下面第二部分包含了第二个组件，叫做server，server是什么意思，指的是mysql的服务，这东西啊怎么去理解它，很明显，假如说你想运行你当前的mysql的话。

那么意味着你必须要先开启mysql的服务吧，只要打开你的电脑里面一定有一个mysql 5。7，显示的是正在运行，它表示的是mysql在运行的这个进程，运行的进程，如果你想正确的正常的连接单词口。

这东西必须要有的，如果你在linux服务器里面，比如service mysql is start，它也属于启动mysql的服务服务，必须要正常，大家看到了，我在服务端这块我画了很大很大的一个框。

为什么很大原因很简单，这里面其实也包含了非常非常多的组件，好什么组件，第一部分听好了，第一部分叫做连接器，这个连接器代表什么意思，就其中一个组件一个部分好吧，它主要承担的功能也非常简单，叫做管理连接。

管理连接，第二个要验证权限，每次在进行数据库的访问的时候，必然是不是需要输入用户名和密码，它会进行权限的一个验证之类的啊，这是这块的一个基本操作，而且我们是可以查看我们msl对应链接的。

我问一下有多少同学之前查看过msl的连接。

看过吗，有一个很简单的命令啊，我们来看看。

比如说我这先登录nsgo杠u root杠p，123456进来写个东西叫show process died。

这就表示我们当前数据库里面正在建立的连接。

有几个，有两个正在访问我们当前的一个数据库，叫connect to master，还有一个starting对吧，只是我们对应的一些连接操作。

你知道这玩意就可以了，就这一个连接器，我们一般很少关注于这个模块，我是第一部分，第一部分连接器，当我连接成功建立之后，第二个步骤叫什么叫分析器，这个分析器是个什么玩意儿呢，什么叫分析器啊。

其实非常简单诶，这分析非常简单，其实大家注意了什么叫分析器，我们的sql语句，最终是要提交给mysql server来开始执行的，但是sql语句是个啥呀，其实在我本人看来，你写的一个sql语句。

比如最简单的select行from table，这个就足够简单吧，你在公司里面也可能写一个上百行的sql语句，它可能会变得非常非常复杂，但不管是简单还是复杂，你都要搞明白一件事。

他说白了就是一堆的字符串，而我的server拿到这一系列字符串之后，我是需要对当前的字符串进行，某些简单的解析操作的，有些同学应该听过一个名词，我不知道有没有听过啊，叫a s t，有听过吗。

什么叫a s p，它的全称叫做抽象，民法术最终一个简单的sql语句，不管多简单都死完，sql语句都会转变成一个树形的结构，有人见过这个抽象语法树长什么样子吗，见过的扣一，没见过的扣二见过吗，好吧。

有同学没见过，今天我来带你看一下，其实啊树长什么样子，它又长什么样子，这东西啊，你善于去看官网，我要打开一个官网，有一个组件叫3d sphere，它是一个分库分表的一个组件，在当前这个组件的官网里面。

他给我们展示了一张图，图里面展示的就是抽象语法树这样的一个结构，比如说不管你的语句，sql语句什么样子，他都会帮我们进行一个转换，这么慢吗，来中文这个网站，有中文网站拿过来之后可以直接进行查看的。

什么情况能这么慢，4。2s，咦，这咋了，是我网络的问题吗，来打开concept，这太慢了，4。一点，可能因为我同时开了两个直播间，所有点有点卡，哎呀这看不了贴子，重新连接一下，我搭完梯子之后。

你们这个客户端听课这东西就断掉了啊，什么情况，这是，算了有点慢，咱慢慢开着吧，慢慢慢开着，看完之后我们再说，这不是公司网速的问题啊，老师笔记本什么配置，我怕说出来吓死你好吧，懂了吗，一会儿带你看。

然后慢慢打开的，那这里面会进行两个最基本的操作，一个叫词法分析，你的语法分析，但不管你怎么进行司法分析还是进语法分析，最终会转换成一个抽象语法树，而我们sql语句在进行正常执行的时候。

都是按照这样的一个树形结构来执行的，有很多同学可能会对这个呃分析这个工具啊，或者分析这个插件有感有比较感兴趣，我再给大家说一下，一般情况下sql语句进行语法解析的时候，重点或者用比较多的有两个组件。

第一个组件叫a n t l2 ，这第一个第二个是阿帕奇的，这东西我也不知道怎么读好吧，我就不给大家读了，这样东西用的是比较多的，如果谁不清楚的话，也很简单，你可以百度搜一下a n t l2 。

想了解的可以详细了解下，就告诉你了，说这东西是可以根据输入自动生成语法数，并可视化的显示出来的，开源语法分析器，这是第一个好，除他之外，还有第二个叫阿帕奇，这东西它也是一个开源的sql解析工具。

可以将各种sql语句解析成抽象语法树，明白意思吧，就这玩意的玩意儿，如果你在公司里面需要去开发，或者说需要去自研，我自研一些呃sql语句的一些中间件的话，这个时候可能会涉及到sql的语法解析工作。

如果不需要的话，那这块是没是没必要了解的，可以不了解哈，好吧，来找一下shing costc，官网又变了，这这盖子都宽敞，内核内核的一个引导，这边有个pass engine叫解析引擎。

在当前解析引擎里面有这样一个东西，来看好了出来了啊，晚上看这个词组语句，没有人不熟吧，select id name from the user。

where this is等于active and h大于18，我们从这里面能够发出什么信息，像这里面的send from wand，这些东西是不是都是我们对应的关键字。

但是像id name table名称加上我们的字段，加上我们对应的一个值，这些东西都是可变的吧，所以它会把你当前的这个思思路语句，转成一个这样的树形结构，整成这样数据结构，看到了吗。

最上面是root节点，下面绿色的表示我们对应的关键字，这里面叫做token标识token，然后用film属性有id和name好吧，有tables告诉你，t user clinicians有条件。

首先里面有and等于大于，这都是我们的token关键字，下面是我们具体的一些变量值，它都会填充到这个地方，所以不管你写的sql语句，都会转成这样一个数据结构，按照这样的一个数形结构来进行。

具体sl的解析工作，来这个东西了解的话，给老师扣个一，看到了吧，就这样子好吧，就这样子，当然你不需要不需要详细去了解，这个过程没意义是吧。

小子你说这是录播吗，对是录播，你是回答非常正确啊，好了，这是第二部分核心的一个组件，讲个色儿吧，我加了色，总感觉很丑的样子，填完色之后效果立马就不一样了，好吧，ok这是第二部分。

然后呢第三部分除了分析器之外，下面还有一个东西叫什么呢，叫做优化系，优化器优化是什么意思，我们经常说我要进行sql语句的调用了，其实在mysql内部里面，他已经要进行相关的一些优化调整了，刘老师。

这需要进行什么优化调整吗，比如说我举个例子吧，我们经常写一个sql语句，叫flat行plt 1，然后撞1t2 t一点id是等于t2。2i d，我问一下，对于这样的一个sql语句，它是先读取t一这张表。

还是先读取t2 这张表，现在去哪个，你知道吗，这个时候一定有人会告诉老师先读取驱动表，然后再读取另外一张表，你告诉我什么叫驱动表，他每次一定是都先读t1 ，或者都先读t2 吗，不是吧，对不对。

这是不一定的，所以对于先读t一还是先从t2 ，这个时候就是由我们对应的一个优化器来选择，执行的优化，选择执行，而优化器跟大家说一下，优化器在进行优化的时候，主要依据于两个标准，第一个标准叫r b o。

第二个第二名叫c b o，什么叫r b o，所谓的r b o表示叫基于规则的优化，cpu要基于成本的优化，在现在的主流数据库里面，像这个cpu用的是比较多的，r b o用的是比较少的，但是你不要说老师。

你能给我说一下，具体的优化器有哪些优化规则吗，如果你想看优化规则，不好意思，需要看源码这块，我也没有怎么看过，我虽然没看过mysql关于优化数方面的一个解释，但是我看过一个框架叫做have，你知道吗。

你知道这玩意儿吗，还有你知道这这这个东西吗，have数仓零税仓库哇，新仓库里面在进行色度解析的时候，它也需要一个优化器，在have里面我看过have源码，看源码里面我那是二点，不是1。1。2版本，1。

1。2版本，在这个版本的时候，它里面大概包含了134个优化器，134个，就根据你不同的sql语句的情况，来判断说我到底使用什么样的一个优化规则，是这样的方式，而mysql里面有多少个，我具体我也不确定。

因为mysql源码是用c语言写的，我看c语言虽然能看，但有点困难，所以这块了解比较少，所以你大概知两个东西就可以了，如果你想详细看的话，这东西也是有地方可以查的，你就搜一个东西叫msl cpu就够了。

看到了吗，mac p u的什么体系，什么之类的，sql优化器，cpu和r b o分别代表什么意思，里面有一堆的体系工作啊，c p u那是cost r b o，找数基于规则的优化器。

和基于代价或基于成本的优化器，就这意思好吧，我还以为是直播呢，不是直播，是录播好吧，r b o基本团队现在主用的就是c p u，r b o现在几乎用的很少了，所以大概只有两个概念就够了，这是第三个组件。

包含三个组件之后，下面还有第四个组件叫什么，叫做执行性时间线，有什么有什么作用呢，它的意义在什么地方，其实也非常简单，它的作用是，执行sql跟执行sql，跟存储引擎，交互村长已经进行交互。

这句话什么意思呢，其实非常简单，朋友们，比如说我们现在换了客户端了，我们下面画了中间的server层，其实在这两层的下面还有一个层次，这个层次这是干嘛的呢，我们叫做存储引擎好吧，什么叫存储引擎。

就是你们之前说的一些东西，像my sum对吧，像in n d b对吧，像memory，对吧，这三东西都是指我们存储引擎，那最终我们的直线器是需要跟我们的存储引擎，进行交互的。

它需要从存储引擎里面把数据给查询出来，并且返回给我们具体的一个客户端，明白意思吧，来我画这张图能看明白，同学第20扣一自信点把吧，去掉这些东西好吧，当然很多同学啊一直对于存储引擎的概念。

可能理解的并不是特别清楚，我想问一下什么叫存储引擎，这东西到底怎么去理解它，谁能告诉我，我们怎么理解存储引擎，先问一下mysql的数据文件，存在磁盘，还存内存，知道吗，在我们看到文件的时候。

其实说白了它就是一个一个单独的数据文件，但是你注意了，你在换不同的存储引擎的时候，他们在磁盘上面的存储形式是不一样的，也就是说叫不同的数据文件，在磁盘的不同组织组织，形式好吧。

我们给他们起了一个统一的描述，或者统一的概述，叫做存储引擎，我举一个例子，你就明白了，很多同学可能经常看的是表，通过可视化工具直接看表了，你其实很少了解过这些对应的数据文件，那么在像这样的数据文件里面。

我们可以看一下，打开我电脑好，选择c盘，找到program date，找到mysql max，5。7找到date，我打开随便打开一个库，比如demo在这个库里面，或者在这个目录文件里面。

大家可以看到同名的文件，是不是有两个aa是同名文件，一个是farm，一个是ibd f rm表示什么意思，它表示存储的是表结构相关的一些原数据信息，而a b d表示什么意思，它表示存放的是我们的数据文件。

以及对应的索引文件，所以当你看到这样的一些东西的时候，就表示说当前aa这张表，我所使用的存储引擎用的是什么叫in low db，这种存储引擎，明白意思吧好吧，同样的我可以换另外的一个目录。

比如打开nsl这个目录，这个时候你同样看同名的文件包含几个三个嘛，好吧，后缀名名名称不一样，f2 m还是表示我们对应的表结构，而m y d表示是my sum的date文件date。

而m yi表示所属的是masm的index文件，他看到了在inno bb存储引擎里面，数据跟索引是放在一块的，而在我们当前的这个呃，怎么说这个masm里面，你的数据文件和所有文件就是分开存储的。

这是他们区别的，比如说你在使用不同存储引擎的时候，他们在磁盘里面实际存储的时候是不一样的，虽然都是以文件的方式来进行存储，但是不好意思，他们是不一样的，明白意思吧，来刚刚讲的东西。

能听懂的同学给老师扣一，哇这是整个体系的一个架构，当然有很多同学可能还会知道一个东西，说老师mysql里面不是还应该包含另外一个组件吗，什么组件在这块，这里面是不是还包含另外一个东西，叫做查询缓存啊。

什么叫查询缓存，这东西怎么去理解，非常简单的，比如说我从数据库里面查到一批数据，查完之后，我下次有可能还会再次查询，那这个事儿，我是如果能够在缓存里面放好数据的话，直接从缓存里面取就行了，是不是意思。

注意啊，这我说明一件事，在以前的版本的时候，mysgo确实有这样的一个查询缓存，这样的一个组件，但是注意了，八点以上版本，取消，所以这就没换了，为什么，因为它的数据命中率非常非常低。

好需要经常的更新里面的数据，所以这个东西被删掉了，直接给干掉了，所以大家也现在不需要去记这么个玩意儿，你大概了解有这个东西就可以了，好吧，旭东说，老师你画出了什么笔记，叫分页用笔记。

那个process on给大家说一下，之前我也用process on，但那个如果你不注册会员的话，只能画几张图片，有些东西叫分页用笔记，你可以用一下，这东西跟ptdown是一样的。

它里面也支持在线买一个客户端，你可以在里面画图，跟pton几乎一模一样，可以拿它来进行一个画图，好吧，是这样的东西啊，这个小工具你们可以用它不限制图片的个数。

不限制图片的个数，而且没有那种呃呃对应的一些充值的一些需要，这个没有啊，所以踏实的放开用就行了，ok好了，就刚刚我讲的一些mysql整体的一个架构，你把这东西首先要理解清楚了，当你把这东西理解清楚之后。

它有什么好处啊，好处就在于，我们可以在各个层次或在各个级别的时候，对mysql的一些东西进行举进行基本的了解，比如说同学们经常要在面试中，被问到优化的问题，当被问到优化问题的时候。

大部分同学会条件反射出来说，老师我要通过添加索引的方式来进行优化，那么我想问的时候，所以是怎么存储的，你不了解这样架构的时候，其实对于索引仪式很难理解的，再比如说刚刚我看到一个同学问我一个问题。

说老师方便的时候，一会儿讲了一个东西叫什么对，所以下推和索引覆盖它们两个之间的区别，那叫signal还叫什么，你叫signal吧，同学问的，所以下跌，所以我把那个索引覆盖的区别，你了解完这个架构之后。

你就会了解说什么叫覆盖，什么叫下推，好一会我都会讲，有这张图是一个预先了解的一个知识图，因为一会索引的时候，我们会用到对应的一个知识点，好吧，这是这些相关的东西啊，我是小白，不管你白不白。

系列 6：P83：MySQL的索引系统是如何设计的，为什么要使用B+树 - 马士兵学堂 - BV1RY4y1Q7DL

所以先把这个架构了解清楚了。

当把这东西搞清楚之后，下面我们来聊第二个问题，说mysql的索引系统是如何设计的，为什么要使用b加数。

下午的时候有一个同学在群里面也问到，这是逻辑架构吧，不会讲物理架构，不讲物理架构好吧，不讲物理架构，物理架构主要是它具体的一个搭建，比如分布式的时候，单机的要怎么搭建内容。

我想网盘里面就包含了这样的一些具体的组件，和完成具体的一个功能好吧，当你把这块东西搞明白之后，下面我们聊聊一下具体的索引，只要学的东西，我觉得所以他是一个老生常谈的一个话题了，基本上在面试过程中。

只要提到mysql，所以它会成为一个必备项，那么所以你们要考核的记录点其实非常非常多，就比如说我刚刚写的说，为什么要使用b加速这样的一个数据结构，当然很多同学可能在之前的时候，你看过一些帖子。

看过一些撕掉哦，你知道了他就要使用变压数，但我还是希望同学们能够系统地把它了解一下，那作为我们学习者，我应该怎么去学习，你可以来想一下，如果让你自己来设计一套mysql的索引系统，你会怎么来设计。

你要多几次这样的思考，你多这样思考之后，你后面看问题的角度是不同的，我来问一下吧，假如说让你自己来设计到索引系统，你会怎么来设计，告诉我你的思路是什么，你们咋设计啊，首先设计是什么，明确一件事啊。

所以你存在的意义是什么，你上来就用数据结构，你上来好好显明，你上来就说用数据结构树形结构是不对的，你刚开始不可能一口就想到这个地方，首先明确一件事，我在进行索引或添加索引的时候，你要考这件事。

索引的意义是什么，叫加快数据来加快，数据访问，对吧，哎房子提高查询项目，这都是我们随随便便说了两句话，那你要考虑一件事了，我们的数据最终存储在什么地方，刚刚我也问了，数据存储在磁盘，对不对。

但是你如果存在磁盘的话，你就要考虑一件事了，从磁盘里面读取数据，但效率是高还是低，比如内存和磁盘在进行数据交互的时候，它的效率是高还是低啊，对吧对吧，从c盘读取数据效率低，特别是你在读取大量数据的时候。

效率是不是依然很低，因为这些东西说白了它卡在瓶颈，是卡在软件层面吗，是平面，是卡在软件层面吗，不是这卡在硬件层面io，就我经常举个例子，我说同学们，如果你们买了新电脑之后，但凡家里有点条件。

是不是要把你的机械硬盘换成ssd固态硬盘，为什么速度快吗，是速度快了对吧，这是硬件方面的瓶颈，我们是没办法解决的，但是我在进行软件设计的时候，能不能在一定程度上对我们的ia操作，进行相关的优化。

可以在优化的时候，你是不是可以考虑两个层面，或者说两个维度，第一个维度我能不能去尽可能少的读取数据，也就是说减少i o亮可不可以，比如说本来我只需要实战数据，我需要实战，我就读十张，绝对不读11章。

可不可以，你多不同大小数据量，你的性能损耗一定是不一样的，对不对，第一个减少io量，除了减少io量之外，第二个能不能考虑一件事情，减少i o次数，什么叫减少io次数，你的数据是存储在磁盘的。

从磁盘里面读取数据的时候，是要涉及到词b的移动，或者说寻址的一个时间的，这都是太浪费时间的一个点，所以我能不能，如果说我能一次性读取来的数据，我就不要读两次，是这意思。

所以这是不是我们在进行软件设计的时候，会在进行一些基本操作的时候，我们应该尽可能考虑的一个点来，这些能听明白的，给老师扣个一，能听懂吗，好了，当你把这东西有了前提之后，下面我们就要开始进行思考了。

思考啥，所以要加快数据访问，同时要减少io量，减少io次数，那我要怎么去设计它，它存储io市场，io市场，input output，好吧，有时候我们要进行所有的设计来。

要考虑说我到底要怎么去存储我们数数据的，一个就是说哎和下面这些东西了解清楚后，我们要考虑，我们索引到底要存储什么样的数据文件吗，或者这样说索引，把数据格式是什么，什么叫数据格式。

比如说我应该用什么样的方式去存储，我们的索引，大家想一下，你的数据是放在一个非常非常大的文件里面的，在这个文件里面包含了一行一行的记录，不画了，可能有n多行，一行一行记录对吧，这么多行记录。

我如何去直接定位到我想要的数据，它在哪一个位置呢，并且如何能够把对应的数据位置给读取，得读取出来呢，那这时候我应该怎么考虑，比如说我应该选择什么的数据格式，来存储数据的，比如说一个表1000万。

我想读进六六百93条文要怎么存哈，希哈希能取吗，这样叫数据格式，大家想你们在创建索引的时候，是不是一定有一个k值，每次是不是根据那个k值，我找到了整行的value值，是这样做的。

所以我在实际的一个存储的时候，能做这样一个实现什么实现，我用kv格式的数据能不能完成这件事情，k是什么，k就是我们对应的字段信息对吧，那value是什么呢，value也非常简单。

我的数据是存储在文件里面的，我能不能指定好我具体在哪一个文件，有文件网名称以及还需要啥，别忘了你是需要读取我们对应数据文件的，你除了知道这个数据要放在哪个文件里面之外，还要知道什么。

磁盘地址我们换一个描述，天一亮，可以吧，纯纯说的我们能不能知道偏移量，当我知道我们对应的文件名称了，知道我的偏移量了，我是不是能把我们当前的数据给读取回来，与此同时，我还要还需要知道什么东西。

如果你想加的话，还需要知道读取的什么数据长度吧，当我明确好这些信息之后，我能不能把一条数据给定向的取回来，能还是不能，能同学们，如果我知道这样的信息，别自然信息就自带池，当我知道一个值之后。

我就可以定位到某某一个文件，然后定位到偏移量，定位到数据长度，我是不是就可以把整条数据给读回来了，好吧，但是我们之前说过了，mexico，他用的是b加数，而没有用这样的一种格式，为什么原因在什么地方。

他为什么不选择这样的结构呢，同学们，这样的方式会存在一个非常非常大的问题，是什么，当你的数据文件变得越来越大的时候，你当前存储索引的文件，有没有可能也会变得非常非常大，听描述啊。

当你的数据文件变得非常非常大的时候，你当前的索引文件，是不是有可能变得非常非常大，当你当前的索引文件也变得非常大的时候，那我是不是还有必要在索引文件的前面，我再给他建一个索引，我再给他建一个索引。

我再给建一个索引，这没有头了，这东西永远结束不了了，这明显是不合适的，对不对，所以这些东西它不适合什么意思，当数据原件变多，这时候索引文件也会变大，所以为什么会变大，大哥，你索引是字段的值。

你现在有原来是1000万条，1000万，现在变成一个亿了，你表里面的数据量增大了十倍，你所有的东西能不变吗，你所以不会跟着涨吗，这个green shadow绿眼混干面吗，当数据文件表多的时候。

表变多不是表多，变多的时候，你的所有文件也会与时俱进的跟着变大，那这样的话你当前你的数据结构就你这怎么说，但是将会变得越来越大，你在前面还要建索引，这很明显是不合适的，明白意思吧，原谅一个不是绿的吗。

是不是意思是就算你存一个指针也是一样的，你的所有文件是要一直与日俱增的，所以这种结构是不可以的吧，而且其实最关键的是是啥，你变大其实也没关系，也没关系，这里面涉及到一个核心概念或是两个东西。

我需要同学们了解一下第一个东西叫什么，叫o l a p，第二个东西，叫lol tp，我不知你的同学听过听过这样的东西，听过吗，听过的扣一，没听过的扣二，有没有听过这啥玩意儿，op叫联机。

分析处理l o l t名叫什么，叫连接事物，处理他们两个针对的应用场景是不一样的，像o r a p它有什么作用呢，它主要是对历史数据进行分析，产生决策影响啊，不要求短时间内返回结果。

而我们的联机事务处理是什么意思，叫支撑业务，系统的需要，需要在短时间内返回对应的数据结果，所以当我这个文件如果变大之后，注意了哈，无法在短时间之内返回我们对应的数据，所以它是会有问题的。

而第二个叫o r a p，它对应过来的应用场景是什么，有些东西叫数据仓库，而我们的连接事故处理，它对应过来是什么叫数据库，他们俩之间的一个区别，所以像我们讲的mexico它属于什么。

它属于关系型的数据库，然后刚刚说的have这玩意儿，它属于什么叫数据仓库，所以在ham里面，它确确实实的索引就是以这样的方式来存在的，但是没关系，我反正也不要求你，很快时间之内我返回对应的结果。

慢慢查了就行了，而mexico是没办法的，他必须要求在秒级别或者毫秒级别，给你返回对应的数据，所以这种写的时候他就不行了，能听懂吗，这些点能听明白的，给老师扣个一，能听懂，不，并不是说他不行他行。

只不过对于我们当前这种应用场景或这种需求，还用不到，或者没法用面试，既然是这样的方式不行的话，我们现在明确的说我要存储kv格式的数据，那我就要考虑下面一件事了，什么事存储k v格式的时候。

可以杠v格式数据的时候，需要使用什么数据结构，数据的存储形式我们确定下来了，那下面我们就要考虑对应的数据结构了，我问一下，你了解的有哪些数据结构，可以支持kv格式的数据存，储，哪些，换一个描述吧。

还细表好不好，传奇掉对吧，还有吗，能做到二叉树对吧，红黑树，对不对，看到吗，release你你mysql的索引用redis来实现，咋整啊，开头说的b数对吧，然后才知道b加数，我们都知道在最后环节的时候。

b加数胜出了，前面几个数都不行，下面我们来分析一下，为什么前面几个数它有问题或者他不行，你要把他们的原因搞清楚，为什么这些数据结构不行，为什么b加数就可以，其实通过上面的分析啊，通过这些分析的时候。

同学们能得到一个结论，什么结论，也就是说随着我们数据量的增长，你所有的数据量也是与日俱增的，也是与日俱增的，那同时你要考虑一件事，我有没有可能一口气把磁盘里面的，所有的数据文件。

全部都一口气读取到内存里面去听，有问题啊，随着你的数据量的增长，你的索引这数据量也在增长，我有没有可能把所有的书索引文件，一口气全部读取到内存里面，你懂了吗，不太可能对不对，或者没有可能对不对。

如果没有可能的话，基于这样的场景，我们要思考什么事情，如果我一口气读不下来，那我可以考虑怎么读，怎么读对，就是我想听你说，这东西分段也行，分块也行，叫分块，分块，读取，这也是mysql所有系统里面。

一个非常非常重要的东西，叫分块读取，分块读取，什么叫分块读取，这里面其实有一个设计思想，同学们听一下，叫孙而治之，很多大数据的设计里面都会用到这样的东西，叫分而治之，比如说我们在进行数据读取的时候。

也要保证它能够分块去读取数据，只要还能够分块读取了，那么你的效率是有可能会进行一个提升的，联合件提升的这东西我们形成一边，一会再详细聊分块这件事情，治疗综合这件事情，我们接下来解释这几个数据结构。

它到底有什么区别，以及为什么最终我们选择了b加数，这样数据结构，先看第一个哈希表哈，希表我们就不用我解释了哈，希表长什么样子啊，都知道吧，来画个图吧，来看看它里面长什么样子，上面是我们对应的一个数组吧。

下面是我们链表，然后这是有指针指向的，然后在输入里面我们可以写我们下标从零开始，1234567对吧，这里面可以存储我们具体的一个数据结果值，那这些东西搞清楚之后，我们先要思考一件事了，为什么哈希表不行。

或者说哈希表它到底存在什么样的一个问题，你把问题找到了，你才能定向的去解决我们这里面的一些疑惑啊，还有什么问题吗，有吧，第一个使用焊锡表，的意义是为了让数据尽可能尽可能的散列，因此在使用，哈希表的时候。

要选择合适的，什么叫哈希算法，避免哈希碰撞和哈希冲突吧，是不是意思，像我刚刚画了一张表，如果我这个都是一个完整的哈希表的话，你发现它的数据散列均匀吗，看数据产业就业吗，不均匀吧。

你看到了1号和3号里面有数据，但是024674567应该都没有数据，他浪费了很多的存储空间，是不是意思，而且如果你的数据都集中在，1号位和3号位置的话，链表它是需要按个遍历迭代的。

它的调音参数效率会降低好吧，所以这个哈希算法它是一个非常大的考验，这个其实还不是太重要的，最主要的一件事是什么，我问一下pc表在进行数据存储的时候，它里面的数据是有序的还是无序的，有序还是无序。

无序吧存储的数，有t吗，这同学是要点吗，还是表示这个同学还是表示有序的吗，无序啊哈希表存储的数据结构，它是无序的，当需要进行范围查询的时候怎么办，只能挨个进行便利，对比是效率极低，那这时候你想你工作中。

你工作中所对应的那个范围查询多吗，多吧是不是很多，如果你都是范围查询的话，你有话题表达行吗，不可以的不可以了好吧，还有第三个点是什么，对我问一下pc版在读取数据的时候，我能一块一块读吗。

他先表在读取数据的时候，我能一块一块去进行数据的读取吗，不能吧，这是不是也会存在对应的问题，是不是有病的问题，所以这些东西都不太适合我使用，我们的哈希表啊，但是我要说明的一件事是什么。

虽然说哈希表没有作为我们哈希索引的一个存，储索引的一个存储存储的数据结构，但是mysql里面它有没有哈希索引，有没有，有啊有啊，来说一下mysql中的memory存储引擎知识，哈希。

所以啊同时还有一部戏叫inno db存储引擎支持，叫自适应哈希什么叫自适应滑行啊，就这个这个这个过程它不是由人未来干预的，是由mysql的索引，是由mico的服务自己来断定的，而不是我们来判定好的。

明白意思吧，而不是我们来判定好的，所以这个东西你要考虑清楚了，这块也不是我说的是mysql官网里面来说的，我们来看一下，注意啊，你们在选择官网，选择这个资料学习的时候啊，官网就是最好的资料。

做一手资料里面都有相关的描述，对数量少就用花西，数量多的话就不用花西了，是他自己来操作的，人为是没办法去进行干预的，明白吗，人为干预不了的，来选择5。7吧，我们现在是5。7版本的，在5。7版本里面。

我们找一个mysql的索引的模块，找一下，就这样东西说了，most mexico index好吧，像primary ket，uniqual index，fda store in b杠tra。

这显示的是b数，但实际上指的是你能用什么是b加数好吧，然后往下看，下面有个东西，memory table outsport has seen index好吧。

memory but also smart hash index，百度搞清楚可以了好吧，把字搞清楚就可以了，所以一般情况下我们用的不加数，但是在memory存储引擎里面支持哈希索引。

同时intedv自持支持这个自适应刷新好吧，然后那个同学说对啊，那个建档的时候他会自己选择我们存储引擎，我问一下mysql现在默认的存储引擎是啥，默认的存储引擎是啥，pp移动db运动db，你懂db。

反正搞清楚行吗好吧，这是这个东西，来，下面来我们接着聊哈，希表不行了吧，他现在不行的话，我们下面就要换各种数的结构了吧，我这儿给大家列几个数，你看看好吧，某某人的什么意思，学会看官网好吧。

官网里面有很多对应的一些资料是标准答案，一定要看官网来，我们现在说几个数的东西好吧，刚才提到二叉树对吧，我让他再补充几个，比如说除了他之外，还有个东西叫b s t tra对吧，除了b s t税之外。

后面还有个东西叫a v l数，除了a v l数之外，下面还有一个东西叫红黑树，我先把这几个数据结构融入到一块啊，这几个数据结构，在常规的数据结构的一个考核中，应该问的是比较多的吧，面试中文的也比较多。

你需要对这些东西有所了解，有所掌握，很重要啊，谁说我这几个数据结构不清楚的话，这插播一个广告，谁如果对数据结构和算法东西不清楚的话，可以去学习一下左神左程云老师讲的，数据结构和算法的课程。

有人知道做什么，左晨宇老师，左晨曦老师啊，在马士兵教育，全职讲对应的数据结构和算法的课程，所以谁如果对数据结构，算法相关的东西有疑惑的话，直接导组成哇，贼牛逼对，确实很牛逼好吧，大家可以搜一下。

就成为那个人对，昨天晚上刚上完公开课好吧，所以差不多广告，呵呵好吧，我这儿啊不详细去讲这些对应的数据结构，它具体每个的特点是什么，我只给大家总结几个东西，首先先看这样，我罗列出来四个数，b数和b加数。

我是没写的，我先把这几个数罗列到这样看，那四个你告诉我有什么共同的特点，有特点吗，都是数你，你这话说还能再再再再那啥点啊，都是数，这最多只能有两个两个分支，没问题吧啊最多只能有两个分支。

是他们这四个数对应的特点，同时我会慢慢的缩小我们对应的范围，那后面这三个数是什么，这一个bs t tra啊，什么叫bs t tra啊，叫binary search tree，二叉搜索树好吧。

那后面这三个数它有什么特点，什么样，叫有序有序，后面一个数都是有顺序的好吧，左子数必须要小于根节点，右子数必须要大于根节点对吧，就是这个，那现在再来，还有下面这个东西，后面这两个它们具备什么特点。

对叫平衡平衡，这是他们对应的一系列的一个特性哦，我这儿给大家做一个简单的小总结，他们之间的一个区别以及对应的一些特点，那讲完这个东西之后，下面我们要聊什么，聊一个话题，所有人应该都知道二叉树长成的样子。

他们都有两个分支嘛，好吧都有序嘛，有可能会平衡嘛对吧，那什么叫二叉树啊，它怎么排列的，一个节点里面至多只能有两个字节点，我把这个东西补全，当我补全之后，大家其实可以看到当前数的一个样子，来放到这儿。

好了我连线我就不连了，假设这是我们对应三层的一个数吧，三层1233层三层的一个这样的数据结构，我问一下，存满之后至多能存储多少条数据，多少，是多啊是多，如果都存档的话，能吃几条数据，二三次方减一七条吧。

是不是纯白只能放弃上，你数一下都来得及，1234567嘛，这都不能放弃上数据，如果只能放七条数据的话，这里面会有一个问题，什么问题，如果我想存储更多的数据的话，应该怎么办。

比如说暗杀数在存满的情况下是制作制度，只能存储七条结果，如果想存储，更多的数据怎么办，只能将树的，的高度提高吧，提高变成四层，或者五层，或者更多层，那么层数变多了会有什么影响呢，刘老师，那变高就变高呗。

变高又怎么样，为什么不能让变高呢，变高会有什么影响，会有会有会有什么影响吗，有没有，速度慢，命中低好了，刚刚没有名字，这个同学说了一句话，叫io次数会变多，会涉及到一个数据结构工程。

不是涉及到一个操作系统里面相关的知识点，这样我要给大家说明一下什么东西，有没有人听过一个名词，什么意思呢，叫做磁盘预读，来听过的扣一，没听过的扣二，老师你怎么光讲这些新鲜名词啊，我都没听过这东西。

没听过，说明你技术有短板了，需要把这东西磨练起来，什么叫磁盘预读，注意一件事，就是内存跟磁盘进行数据交互的时候，有一个最基本的逻辑单位是称之为e或者叫做，你们能听过data配置能清过吗。

叫data page或者叫ye的大小是跟操作系统相关的，一般是四kb或者八kb好我们再进行，数据读取，这时候一般操作的都是列的整数倍，这个概念我希望大家能够理解，听到了吗，这是我需要你了解的一个。

最最最基础的一个基本概念，你把这个概念了解了，后面的东西才能往下聊，没问题吧，大家想一下，当我这儿已经有了一个页的东西了，也就是说内存和磁盘交互的时候，是有一个单位的。

这个时候你再把它跟我们前面讲的这个东西，能不能关联起来，我们先说了，这东西在进行数据读取的时候，要进行分块读取吧，既然诶怎么连不过来，是要进行分块读取，我现在要分块读取。

你想一下我们这个业的单位或页大小，不就天然已经分好块了吗，我能不能每次我就读四kb大小，能不能挺好，我能不能每次就读四kb大小，行不行，可以了，这不就天然就已经分好块了吗是吧，但是别忘了。

我们在进行数据的一个实际存储的时候，它是以页为单位进行交互的，像你这个地方，这是一个节点，一个节点是不是意味着我要读取一个月的数据，但是我们都知道，这里面明显我只能存放一个值吧，比如这是十，这是五。

这是15，这只能放三，再放八小七，这放12，这放19，是不是讲讲成这样的东西，因为每一块里面或者每一个节点里面，你是不是只能存放一个数据值，你这个节点里面我能存储更多的数据结果值吗，能吗，同学们，能啊。

你这里面能放多个值吗，你怎么放，看只有两个分支，要不然比他大小比他小，你能放多个分支吗，你是放不了的，如果你放不了的话，你就要考虑一件事，这里面有一页的一个单位了，那我如果有一页这样一个单位之后。

我如果存不满怎么办，存档会放其他东西吗，来举个例子来验证一下，打开我的电脑，这里面我新建一个文档，举个例子就知道了，这是一个文本文档里面现在什么都没有空的，我现在往里面随便复制一点东西，随便带点。

ctrl c ctrl v，你告诉我这里面有多少个字节，再加点多少字节告诉我，你知道吗，我也不知道多少字节好吧，你右击点击属性，你看到了多少字节，一共是1198个字节，但是它占用的空间是多少。

对4k b吧，你相当于你的磁盘，是不是都一个一个4k的小格子，如果我占不满的话，不好意思，占不满就占不满吗，这空着不就完了吗，是不是这意思啊，所以你想我们这里面每一个节点，如果我只能存储一个数据值的话。

我如果想让它存储更多数据的话，我是不是要加层，我如果加成的话，每一个层或者每一个节点里面读取的时候，我都是一页的话，你层数加多了，你层数加工了，你告诉我，你最后能会不会导致你的io量变多，会不会。

老同学们会不会，别关注壁纸好不好，关注壁纸干嘛，你们真的是，这壁纸我发给你了，好吧，这壁纸有什么可关注的，真的是绝了，你们也是，所以啊我们要考虑一件事，同学们什么事，为什么你的层数变高之后。

你的io次数是变多，这是产生最根本的一个原因，所以你要考虑一件事，什么事考虑什么，是不是要尽可能，多的存储数据还要减少i o的次数，换句话说是不是要减少io的，我会减少树的高度吧，是不是减少高速度高度。

这句话能理解吗，来能理解的同学给老师扣一，所以说不能越高，如果不能越高的话，你想这个数我们能变形吗，或者我们这个数能变种吗，可以吗，怎么变形，每一个阶里面我是放了一个值。

如果我的一个阶里面我如果能放多个值呢，颜值放一个十甲里面放十多号，20多号30，如果我放了三个值，你告诉我我下面的子节点，子节点会放几个，或者说会有几个孩子节点，这个六个，你哪来六个大哥这一层啊。

说这一层，两个我能犯这样的范围，第一个范围小于十可以吗，第二范围我能换成十，到20之间，可以吧，下一个我能放20~30，对吧，再下一个，我能放30，大于30的，可以吧。

我是不是可以存到我们对应四个区间了，比如说原来我现在是二叉树，我能不能让当前的这个结构，它变形或者变种一下，变成什么东西，叫多差数可以吗，可不可以，这没问题吧，当你变成多叉树之后。

是不是意味着你的孩子几点变多了，你的孩子几点变动之后，你的树是不是就变矮了，同时我这里面在进行数据存储的时候，该有序还有序对吧，该平衡你还平衡，把你之前那些二叉数这些特点我都保留下来。

所以在这个东西的基础之上慢慢变过渡之后，变成了一个什么东西，叫b数，叫b数，你是要把b数这玩意儿搞清楚了，b数是吧，来到目前为止还能跟上同学给老师扣一，能跟上吗，平衡板上的树高。

最最长指数和最短指数之差不能超过一，是那个a b l数的红黑数的话是两倍，这个不一样啊，这不一样好吧，现在把这些东西你要搞清楚了啊，这是b数，那我们现在来看一下b数的一个结构，它大概长什么样子。

很多学啊可能没见过b数长什么样子，没关系，我们一起来看一下，b数结构大概是这样一个东西，首先你在进行b数的一个实际数据存储的时候，需要搞明白一件事，什么事，它有一个最基本的概念叫做什么叫做degree。

这个diy怎么翻译呢，翻译过来叫做do，或者叫做接好do或者接什么叫do，什么叫接，表示每一个节点里面最多存放n多，n减一条数据来看一下，比如说选择四阶，四阶什么意思，每一个节点里面我可以放三条数据。

我们可以往里面插一下，你看看效果好吧，比上一走，这是一点点，我再插入二，它不会新增节点，而是往当前节点里面插入其他的一些数据值，再比如三看到往里面加每个里面因为选了四阶，最多能存放n减一个。

所以最多能放三个数据，当我再插入四这个数据的时候，它就要分裂了，看到了吗，这就进行分裂了，速度调快一点，我再往里面查看，比如说56x6 的时候，他遇到进行分裂了，再叉七差八分裂，那差一个九没事。

当我再插一个十之后，同学们告诉我什么效果，当我再插入一个十这个数据的时候，它有什么样一个效果啊，圆满了，你插20的时候，下面也要满吗，下面是不是要满了啊，它会变成一个三层的数，这是我们对应的一个b数。

对应倍数，看到了吗，这是最基础和最简单的一个数据结构吧，啊你把这东西搞清楚了，没完，还需要懂这件事什么，它只是一个最基本的数据结构的一个模型，它你知道它是没意义的，我需要把这个模型做一个过渡。

过渡是什么样子，我要存放我们数据库里面的表，里面的行记录了，所以这看起来好像是一个数值，那么我们在实际存储我们的行数据的时候，它不可能存存放一个数值，比如说这个节点往里面添换的时候。

这个值要变成几种类型的数据，首先第一个存放数据的时候，k值要有吧，k值不可能没有，k值是必须要有的，是不是意思，截图，来同学们听好了，我k值是不是要用，也是这里面我可以存储三个类型的数据。

第一个k值要什么，你需要根据你的k值来检索到我对应的数据啊，是不是在哪个地方ky要有吗，除了ky之外，你能告诉我你还需要别的数据吗，我说了啊，这是数据模型的图，我们要把它换成我们一张表。

还需要什么东西叫啥，字段信息行数据吧，行数据，还需要啥，还需要吗，value value不是行数据吗，还需要什么东西，同学们别忘了它是我们对应的数，下面是有对应的节点的。

我是不是要知道我下一个读取的数据，节点的地址是什么，下一个节点的地址，这样的东西如果你是六组利用小于六的，是不是读取五这块儿六和八之间的时候都是七，这个块大于八，读取这块这个地址。

这里面我们会包含三种类型的数据，所以你需要先把这东西搞清楚，你把这东西搞清楚之后，你就可以跟着他来画出一张图，什么图，关于我们索引的数据结构，一张图来给大家看一下。

这之前用process on的时候给大家画了一些图啊，我没挪啊，还在里边放着，找到我的msl，来你看这张图，你能不能看懂。

每一个磁盘块，就代表是我们读取的n个页的信息，我说了吗，每次在进行数据交互的时候，读取的是e的整数倍，把每个方块表示独一个页的整数倍，默认这读的是假设是16kb。

每个方块12345678 90是多少次方块，当我练好这个磁盘块之后，每个磁盘块里面是包含三种类型的数据，第一个16 34表示我们具体的k值对吧，data表示我们实际的行数据。

p1 p2 p3 表示我们实际的指针，我这啊只画了三个范围，但其实实际存储的时候，你的范围可能比这些东西要多得多，可能很多个，但是空间有限，所以我这只画了三个来，这个图能不能看懂，能看懂的扣一好不好。

没问题吧，这如果没问题之后，下面当你看到这样的一个三层的数之后，三层数之后我要问问题了，如果我要读取28这条数据的话，a a b等于28条数据的话，我要怎么去读取，记住啊，28怎么读。

我是不是先读取磁盘块一，把磁盘块一给读取回来，读取过来之后，我要把28和36和34做对比，我一对比发现诶正好在中间，是不是沿着p2 指针把磁方块三给读取回来，当我把磁盘块三读取回来之后。

我再把28和25和31度对比，但是又好正好在中间，我是不是再根据p2 指针把磁盘块八给读回来，当我读出来之后，我是不是能把28条数据给返回回去了，这里面它整体的一个查找过程，在整个查找过程中。

我一共读取了几个四方块，三个吧是不是三个同学们注意一件事，出现什么事情，在mysql in no db的存储引擎里面，它有一个变量受，角in no bb象限配置上限size。

你这样属性值g值多少，它默认读取的是16kb的数据，默认读取16频率的数据，也就是说这样假设我们每一个磁盘块。

每个磁盘块它占大小是16k，我在整体读取过程中，我一共读了多大的数据量，多大的数据量，一共，不大是不是一共是48kb的数据，这个48kb对于我们现在的操作系统而言，很小的数据量吗。

像你们的电脑基本上8g内存起步吧，我始终给内存起步吧对吧，有些更有钱的同学可能配上32g内存，64g内存，是不是意思，他应该是比较简单的哇，48k很少完了，这样对于我们的内存的四点而言并不是特别高。

那下面你就要考虑另外一件事了，同学们16级不算大好吧，我给你看我电脑内存多大，64g好吧，你这个大点没关系的，越大越快好吧，这也没关系的，来往上看，我们再往下看，我们接着往下走啊。

当你把这东西搞清楚之后，你下面就要思考一件事，思考一件事的思考什么事，我如果b加数对，不是这个b数，它只有三层，我存满了之后记住啊，存满了之后，我可以存多少条数据，存满之后存多少数据，你告诉我能计算吗。

八是什么意思，我们是不是可以大概算一下，我们为了方便计算，假设一个z我占了大小是一kb，我问一下，在当前这个磁盘块里面，我最多能有几个子节点，最多能有几个直接，三个我这换了三个，你一个大小是16kb。

一个date是一kb，我最多可以存多少个，你data是不是只能占一kb上面是不是占范围，也说你最多有15个date，15个date相当于16个范围吧，是不是六个范围，是不是，这意思。

就是说我这一层里面最多可以有16个子节点，那我第二层我可以有多少子节点，第二层多少个，也是16个吧，是不是也是16个，第一层16个子地点，第二层是不是也是16个子地点，大小是一样的吗，第三层多少个。

是不是也是16个，一个dt 1 k兵马，也就是说如果我这三层全部全部我都存满了，我的计算公式应该是什么样子，应该是16乘，16x16=4096条记录啊，这等于四是多少，那么我的问题是什么。

4000条数据多还是少，多还是少，说吧，你平常自己做个练习都不止4000条记录，那如果我想存储更多的结果的话，我应该怎么办，怎么办，我是不是只能去加我们的层次了，比如说把三层的一棵树变成四层。

是不是这意思，但是很明显的一件事，朋友们你要注意了，如果我要把三层变成四层的话，我的i o的次数会不会变多，会还是不会会不会会吧，那这跟我们的设计原则又相悖了，那这时候我们要找问题了，找出问题。

为什么这个三层的b数它只能存4000条数据，谁占用了大量的存储空间，谁，date吧，那下面我就要思考一件事，我能不能把data给干掉了，对不对，所以在b数的基础之上，有了另外一个东西叫b加数，来。

我们先看b加数的数据结构，我依然往里面插入一到十十个数据，你再对比一下区别好吧，一三还是三个，四的时候变了，然后56789，传输十十个数据之后，依然是底层三层吧，我把这个图拿过来放里边，当我放过来之后。

来告诉我他们之间的区别是什么，开始找不同有什么区别吗，什么区别，同学们，箭头哈哈哈哈，最下面一层有了一个指针，或者有一个链表的指针，能够相互指向，还有吗，这边最主要的看到没有，最下层的数据最多。

患者描述呢，看好相应的区别和特点，所有在b处的时候，我们的数据是12345678 90，看数据没有重复，但在b加速的时候，叶子烟里面是包含了全量的数据，而非页里面是包含了部分数据，那通过它的对比之后。

是不是相当于有了一定的数据的冗余，当有冗余之后，我们可以思考一件什么事儿，我能不能把刚刚这个图里面的所有的date，都放到叶子节点里面去，能还是不能，你能吧，所以我在变形之后。

我能不能有这样的一张图来看好了。

还是等，来这个图你们能看懂吗，什么意思，我的非叶子节点里面不再存储实际的数据，只有在夜间里面才会存储实际的数据，这么干行不行，行吗，可以吗，如果可以的话，一样道理，我们要进行计算了，我计算什么东西。

这样的一个三层的b加数，我如果存满的话，我可以支持多少数据量的存储，算一算吧，每一个三方块依然是16k 16 k 16 k，我读取的时候依然是读取了48kb的数据，对吧，假设我们的p一加28。

我占了十个字节，记住吧，假设你占十个字节，那相当于16x1024，再除以十，为了方便计算，24不要了，1000等于多少，1600吧，比如18号一，我可以有1600个子节点，第二层一样的算法。

是不是也是1600个子节点，第三层一个date 1 kb，是不是只能存16条，你这三层的一个b加数，如果我存满的话，我可以吃多少，1600x1600，再乘以16，等于4096万。

是不是意思我能知道多少范围是这样了，烂级别吧，是不是意思，来刚刚能听的过程能听明白，同学表示扣个一，问题吧，当你把这套东西看明白之后，与生俱来的就会面试官问出一个问题，mysqb加数的，所以一般是几层。

告诉我一般是几层，三层不问不问就不问呗，不问怎么办，那还能怎么办，你打面试官一顿问就不问呗，三层吧，四层吧，告诉大家，你说三层也好，说四层也好，个人认为都不是那么的严谨啊，都不是那么的严谨。

我这儿给大家一个统一的描述，听好了，听好了挺好，一般情况下，3_{4层的b加数，足以支撑千万级别的数据量存储，来再来一遍，一般情况下，3}4层的b加数，足以支撑千万级别的数据量存储，能记住这句话吗。

面试官在问的时候，你就以这样的方式去给他进行表述，给他进行回答，没问题了，明白意思吧，因为在刚刚整个计算的公式里面，在计算的公式里面，你告诉我谁占了绝大的一个因素，或谁占了一个很大的因素，谁啊。

这吗是这吗，不要再理解为data了，好吧，是指针吗，大哥们别忘了我刚刚说的东西，我说假设p一和28占十个字节，指针的大小是不变的，而这个值是你选择的索引，只选索引列的值，这个值是有可能会变化的。

所以影响最大是谁是k这个值，假设我刚刚举个例子啊，如果我们的p和指针和p一和28，占了100个字节，你依然按照刚刚的公式算的话，变成多少了，是160x160x16，就变成了多少，409600，明白了吗。

所以谁在整个计算过程中，一对对这个这个意义非常重大，是k的值大小或者k所占用的存储空间大小，你告诉我k是大了好还是小了好，大号还是小号吗，小所以要保证一件事，保证什么k要尽可能少的占用存储空间。

明白意思吧，那这样就会有一个问题，我们在创建索引列的时候，我会用int类型好，还是用what串类型好，哪个好，int int占四个字节，但是vx所占用的字节是你自己指定的吧，如果往上站三个呢。

如果你写了三呢，但我们一般不写三了，如果你写了三呢，所以要判断什么，谁占用的空间小，我就要用哪个列作为索引，听明白了吗，就这样你要考虑清楚了，来我刚刚讲了点，听明白同学多少科目，一听白了吗，好吧。

当这个问题过了之后，面试官又会问一个问题，什么问题什么问题啊，我们的mysql的表在进行创建的时候，我的组件要不要自增，你看这张图来给我反馈，要不要自尊，你来告诉我，也说不要的，有说要你不管说要也好。

还是说不要也好，我希望你能搞明白一件事，什么事，原因是啥，你说要以前说不要以前你总要有个理由吧，占用空间小，那么我先说结论，结论是这样的，在满足业务系统的支撑的情况下，尽可能的自增。

尽可能自动叫满足业务系统情况自动自增，为什么这里面会涉及到另外的一个问题，叫什么叫索引的维护，这玩意儿很麻烦，什么叫所有的维护，举个例子来看，四八块五，15，假设18块五，我最多只能放四条记录。

比如现在我已经存满了，11 12 12 13 15，我存满了，当我存满了之后，我的问题是什么，现在我要插一条14的记录，我该怎么插，因为你底层的叶子节点之间它是有顺序对吧，有序的。

所以你的14只能插到这个里面去，那我需要干嘛，把当前的方块要拆分成两个磁盘块，11 12在这13 15在这，当你分开之后，同学们注意了，你不是单单分开就完事儿了，你上层是要有指针指下来的。

意味着上层我也需要增加一个指针，如果这个时候特别不巧，他也满了，他满了之后，他是不是也要分裂成两个，但是还要往上增，就说你在进行数据插入的时候，有可能会影响到上层的一个新增吧，业的分裂吧。

这东西是很麻烦的，而如果你递增之后会有什么效果，是往后面追加就可以了，前面会有影响吗，前面的东西会产生液分裂吗，不会了吧，是这意思啊，所以我说了，在满足业务系统的情况下，尽可能自增，刘老师。

我分配的环境里面没法自证，那就不自增了吗，对不对，能自成就自身不能自动算了，我放弃了好不好，来刚刚讲解听明白，同学给老师扣个一，神组是用分布式id嘛，小号算法吗，用小号算法都分布式id吗，rest好吧。

所以刚刚是用索引的这套知识，所以这时候再回过头来来，你告诉我为什么要使用b加数，能听明白了吗，能听明白了吗，我刚才讲了一堆。

你要搞明白这个逻辑过程吗，面试的时候把这些点给面试官去陈述清楚哦，这里面涉及的东西还是挺多的，数据结构的，操作系统的网都有涉及到，包括他数据读取的多了去了，这东西了解了。

才能展示出来你个人的一个技术实力啊，这才是你最应该学的明白了吧，好了。

系列 6：P84：聚簇索引、二级索引和联合索引具备哪些特点 - 马士兵学堂 - BV1RY4y1Q7DL

那咱们就过了，过了之后来聊下一个话题是吗，说剧组索引。

二级索引和联合索引，它们具备什么样的一些特点，什么叫剧组索引，什么叫联合索引，什么叫二级索引，记住，对，二级，所以还有一个叫联合索引，哇这三个对应的点抽根烟抽根，那这个普通表行记录大黄进度大的话。

插入上亿数据会失败的，失败应该不会啊，失败应该不会啊，但是数量越大的话，你的查询效率肯定会降低的好吧，来我们来解释几个概念嗯，给大家你算了，不给时间，给他一分钟时间吗，给你们一分钟时间，我点根烟。

你们上个厕所好不好，现在是28 两分钟吧，我们九点半接着讲，上厕所去好吧，上厕所去，一会儿我们接着讲下一个话题啊，叶子节点包含了完整的行记录，对叶子节点包含了完整的行记录，是的，李老师有回放吗，呃回放。

我也不知道有没有啊，我这没录啊，就确定对着呢，没问题好吧，是包含的，但是这东西啊你要说你要说完全包含，也也不能说完全对，为什么一会儿我讲到这个二级索引的时候，你就知道了，二级索引和普及索引它是有区别的。

像二级索引里面就不一定不一定好吧，一会儿来解释，算了算了，李老师，这回放我都不敢二倍速，我这个人语速比较快啊，所以那个二倍速可能背诵不了倍速干啥对吧，主键字节我就随便指了一个数据嘛，假设嘛对吧，假设。

好了九点半了，我们接着往下讲，有问题的话，我们一会来专门答疑好吧，一会就这么答疑啊，来我接着往下说，这东西第一个句子作业，什么叫句子作业向上，这来还在同学公文一，我们今天晚上讲了，来聊剧索引的事。

什么意思，想了解剧索引，你需要知道一个最基本的概念是什么概念，注意啊，我这有指定的条件，叫音中d b存储引擎中数据在进行插入的时候，数据必须跟某一个索引列绑定在一起，如果表中有主见，那么跟主键绑定。

如果没有主见，那么跟唯一键绑定，如果没有唯一见，那么选择一个六字节roid，进行绑定，这东西它是一个墨守成规的一个前提，刚刚在讲课之前，我给大家看了inno db的存储文件，还记得吧。

在移动db这种存储引擎里面，你看到了你的数据和你的索引，都放在a b d这样的一个文件里面去，里面既有数据又有索引，所以intedv存储引擎在实际的数据插入的时候。

是必须要跟我们的，所以绑定在一起的，那么它就会有一个选择的过程，逐渐有最后的组件，没组件我们就用唯一键，没有唯一性的话，我们就用六字节的roid来进行实际的数据存储，这句话能理解的，根号扣个一能理解吗。

懂吧，所以这就会有一个问题，那到底什么叫句速索引，什么叫非剧组索引呢，记住了，听好了，叫数据，跟索引放在一起的叫做聚簇索引数据跟索引，分开存储的叫做非巨富，所以明白吧，所以把两个东西你要分清楚了。

你要分清楚了，六个字节的raid是什么，就是一个随机字符，六个字节的一个随机字符串被绑定在一起，没在一起，所以这里面与生俱来的会有另外的一个问题，垂直冲地说，所以my sum是非激素，非常正确，记住了。

叫my su中，只有非巨富，所以因为你的数据文件，你的数据文件和你的所有文件是分开存放的，生态释放了好吧，安静说，如果表中没有六字节的呢，他那个64年中y d是隐藏的，你是看不到的。

跟你表有名字字段没关系，它是一个隐藏字段，刘娜说的非常对啊，它是一个隐藏字段，你是看不到的，在我们实际的mysql的数据行里面，其实包含了非常多的隐藏字段，比如说有什么流动性当中啊。

等待着享受db下划线任务，下划线id隐藏字段，还有db下划线，肉下划线p t2 对吧，还有db下划线，t rx下划线id，还有还有delete，想想d它有很多对应的隐藏字段，这些隐藏字段你是看不到的。

你怎么看都看不到，怎么看不到，除非你看源码明白了吗，类似于oracle remember跟zamer好像不太一样，remember是有可能显示查出来的，而mexico它是绝对查不出来的，明白意思吧。

绝对查不出来啊，这些东西，所以下面还有一个问题是什么，刚刚说了max sum是结果飞进作业，那么一扔d b中有没有剧作业，有啊，有句数索引有没有非聚数索引呢，有没有非技术索引，叫移动bb，支持剧组索引。

也支持，叫非约束所，这时候肯定有很多同学就会有问题了，它其实是跟我们下面的二级索引，要产生关联的一个核心点，关键的一个核心点我一样，再给大家个问题来讲，到现在能听懂的同学给老师扣个一，能听懂吗，问题吧。

下面来聊几个问题，什么问题，我们就来解释，首先第一个一个表可以有几个，所以，记号，无限三个可以吧，第二个每一个索引都是一颗b加数，还是所有的索引供应雇雇用，b和b加数，共有啥能力的独立啊。

独立也就是说是一个表中会存在多颗一加数，明白了啊，第三个数据数据就表中数据存储几份，我们都知道叶子烟里面存的是数据行，存几份，记住一份，如果存一份的话，就会存在一个问题，同学们什么问题。

我一个表里面会包含n多个b加数，如果你的数据只存储实际的一份的话，那么其他的b加数的yes di里面存储什么数据，什么数据，所以记住一句话，同学们记住我下面写这句话，数据是只存储一份的。

这是孙处一份好吧，其他的非聚簇索引的叶子节点中存储的是什么，剧组索引的k值叫k值，能理解意思吧，所以，念头gb中也包含了非聚簇，所以嘛能听明白了吗，也包含了非技术索引，它放的是i d值。

这样一样给大家举一个例子吧，比如说看这张图表里面这个表有三个字段，id name age，一共有三个对应的数据列，下次训练之后，我现在id是主键，内部是一颗普通索引，那么d组件的索引建成之后是这样子。

下面啊空间有限，所以a值自动我没写，这是我们对应的这个剧组索引，而name也是一颗b加数的话，name这个里面存的是什么，看到了吗，名字对应下来之后，最底下放的是什么，放的是我们对应的id值。

所以在内部这颗b加树它就是一颗非聚簇索引，而i d这个b加树它就是一棵巨树索引，明白了吗，同学们听明白了吗，来这块听明白，同学给老师扣个一吧，能听懂，啊把这东西啊你要搞清楚了，所以什么叫二级索引呀。

或者说什么叫辅助索引，表示意思是一样的，引导db中的非剧组，所以都可以称之为叫二级，所以或者辅助，明白吧，这是它最基本的一个概念，我希望同学们把这个概念给了解清楚了，就这块的一个基本讲解。

这块的基本讲解啊，来这东西能过的，来给老师扣个一，能够吗，两个概念，二级索引跟回表没关系，回表描述是一个过程，所以描述是一个具体的物理结构，pad是不一样的，一会我来解释回表的事情。

一会儿我来解释回表的事情，20岁一定没有很懂，举举个例子吧，举例子说明啊，文章表里面有id逗号，name，逗号配置逗号，tender，四个列在四个列里面，id是主键，内蒙是普通索引，好那我问一下。

在查询的时候，数据跟谁绑在一块儿，数据跟id绑定在一起对吧，name对应这b加数叶子节点中存储的什么值，开机了是吧，此时内部，就叫做辅助，所以或者二级，所以这个意思听到了吗。

它是用来帮助辅助查询的国家里，所以就这意思明白了吗，好吧，如何来确定哪个索性是二级索引，你非技术索引都是二级索引，就这么简单，没有任何唯一件和组件的表述，是建立的第一个索引吗，没有任何主见。

没有任何文件的话，他会选择六六字节的roid，作为你的技术索引存在，作为你的句子逻辑存在，就是我刚刚说的顺序是优先主键，主键没有唯一键，唯一键没有的话，会生成一个六字节的roy d。

这上面的顺序把顺序要记清楚了好吧，就这一块儿，小梦说优先pk嘛，什么意思，没懂来下面来解释多个链接索引的，不管你有多少个列，非静索引，都是我们对应的辅助索引或者二级索引，明白了吗，不关就多少个练好吧。

但是你的表里面可能出现一种情况，主线可能只有一个，但是唯一一件有多个，如果存在多个唯一键的话，那么这个时候表里面又没有主见，那么你的数据剧组索引，会按照你唯一键指定的顺序来。

比如a b c3 个点都是va键，a在前就选择a b在前，选择b c在前，选择c，唯一四代和c指针吗，要要，没有任何唯一键和主键的表，多个列建索引的，哪个是主线，六字节的rod，明白了吗。

六字节的rod，六字节的roid过目，v4 c指令吗，要要没指定的话，就是i d了，好吧，来下面解释下一个概念叫联合索引，这还有个概念叫符合，所以这是什么意思，很简单好吧，类似于联合主键的意思。

一般情况下我们在设置索引列索引列的时候，只会选择一个列作为索引字段好，但是在某些特殊情况下，需要将多个列共同组成一个索引字段，把称之为叫句哦，称之叫联合，所以就相当于原来是一个列，现在变成了多个列。

仅此而已，仅此而已，好吧，这能听明白吗，这个联合作业，联合主键和联合有啥区别，他俩能在一块比，这俩能在一块比吗，这俩没有什么可比性啊，明白了吗，my time中索引都是辅助索引吗，可以这么理解。

因为它没有句索引，只有非剧索引，所以它都是辅助来进行查询的啊，来你连个作业听明白了吗，听明白了，给老师扣个一，所以你就查找标记吗，是你查找的字段吗，那你的字段来判断吧，是这意思好吧好了。

这是这几个存在的最基本的概念，我觉得你应该了解了吧，好吧，来再往下看，说第四个在进行索引优化的时候。

需要注意什么问题，我刚刚已经展示了非常非常多的索引相关的，一些信息了，你告诉我根据上面学的东西，我们如何来进行索引优化呢，可以说那my sm里面e键存的是什么，存的是地址，存的是地址，看好了。

上面我已经讲了这么多点了，下一个问题是。

系列 6：P85：在进行索引优化时应该注意什么问题？ - 马士兵学堂 - BV1RY4y1Q7DL

所以优化的时候，要注意啥，注意什么，同学知道了啊，第一个，所以占用的存储空间需要尽可能索引字段，要尽可能少的占用存储空间，还有吗，在满足业务系统的需求类，尽可能就这还有吗，还有啥，没了，所以在进行。

索引字段，我刚才没提这东西，hope说了就尽可能不要为空，我说的东西啊，呃空这玩意在数据库里面，它是一个非常非常特殊的存在，因为在很多情况下面，空都不等于空，对吧。

空调那叫is not for long呢对吧，但是尽量不要选择为空的字段，听明白意思吧好吧，这个东西啊，还有第四个选择索引的时候，索引，的基数要尽可能的，有人知道什么叫基数吗，你知道什么叫基数吗。

这里面有一个计算公式，什么计算公式，就是说我们在建索引的时候，到底给哪些列来建我们对应的索引，这边有计算公式，记住了，叫dv除以count，大于等于80%，这四段适合创建，所以明白意思吗。

刚刚那个同学恶龙咆哮说，假如给性别加字段，你给性别加索引一点意义都没有，一点意义都没有，dv是什么，不知道dv是啥吗，就这，distinct value，唯一值，唯一值除以count要大于等于80%。

明白了吗，性别这个字段你加索引一点意义都没有，就是要给你视频加作业没意义啊，你加作业干嘛，你性别只有男和女男女，你加缩减之后，你通过作业来查询没有意义啊，你加这玩意儿明白意思吧，这没理啊。

对你的不重复的值要尽可能的多好吧，充值多的话，这个长期的话要比较麻烦，ok那什么，看到了吗，查了也不会怎么样吗，你在另外一个字段查询的时候，查出来都是重复数据吗，那没意义，也不会怎么样，还有啥。

不要给所有的字段都添加索引，并不是索引越多越好，明白了吗，这点是很重要的，很多同学老师，我能不能给表里面的每一个字段都添加了，所以不要这样，你给人表里面的每一个字段都添加索引之后，效率不一定高。

效率不一定高，它会占用大量的存储空间，明白意思吧啊再往下看第六个还有什么，还有吗，尽量避免索引失效，尽量避免索引失效，尽量避免索引失效，那这里面就涉及到一个问题，老师索引失效会有哪些场景。

比如下一个我要聊的话题，什么情况下会导致索引失效，有人能说一下吗，所以那应该是很少修改的，这个是对的，下一个吧，这个我这我之前没准备啊，下一个，尽量选择的索引字段尽量不要频繁，修改，来第一种情况。

所以这种情况你们说的啥来着，查询的时候，左边时候，不要加百分号对吧，还有吗，意思呢all的情况我建议你不要说all的情况，不要说，看到吗，所以是这样的，好，所以字段上不要添加任何的表达式操作，明白吧。

不要加任何表达式操作啊，这是第二个，还有吗，第三个对，所以，字段在使用的时候不要出现类型的影视，也是，转换，看啥，所以，以上不要出现函数计算，说什么组合索引在进行使用的时候，要遵循最主匹配原则。

我还没说这东西啊，匹配原则，可作品原则我还没说，不知道电影是转换啥意思，来给你举个例子啊，等下我给你找个案例啊，找一个案例，我想想在哪放着，国家电营业一堆情况。

知道一下，你找一下这个东西，所以失效，嗯还有啥，你现在睡觉吗，不知道从哪讲，这玩意儿，等我找一下，忘了昨天咱俩讲的，所以失效的情况我这写了一堆啊，宋主要，什么算了，给大家举个例子啊。

就是这个东西是啥意思，什么叫影视转换，比如说我们在进行具体的数据库操作的时候，有一个叫做什么来着算，来看这个方式来演示这个这个这个这个案例啊，来打开我们的数据库，演示一个案例，柚子dem。

大概有点存在多少，这个user你看看表吧，表演单一几个字段，三个字段好吧，123id name和phone，只有且只有这三个字段好吧，当报完了三个字段之后，还有一件事。

我现在给我们的phone字段我添加一个索引，讲完了讲完之后查询语句，你在写的时候，比如说我随便写一个，大家看到这个sql语句吗，我问一下，我现在这种作文字段是什么类型的，什么类型，观察类型啊。

我现在写什么类型，数字是数字类型，你运行之后，你看一下你的执行计划，在执行计划里面k这页里面显示的就是n，如果现在我换一种操作，我把这个东西加上单引号引起来，这有值了吗，你知道吧，这就是我们对应的类型。

如果你的类型发生一种隐式转换的话，它可能会导致我们对应的索引失效，就这意思明白吧，看出来了吗，那这个案例看明白的同学给老师扣个一。

能看懂吗，就就这意思好吧，大家都懂的情况好吧，再往下看，还有一个东西我需要大家说一下，in或者，很多情况下会导致，所以失效，但是要根据实际的情况来进行判断，明白意思吗。

你不要上来就说印会失效或者懊悔失效，这种说法都是不对的，都是不对的，ok直播不是直播，是录播，所以啊把这几种情况给大家说清楚，说清之后，你随便哪个地方能举出一些案例就够了，能举出一些案例。

我记得我之前用过这东西，但是忘了好吧，来再看还有什么，第七个，在使用组合索引的时候，如果中间的某个索引列使用了范围查询，那么会导致后续的索引失效，这东西啊一会儿也是一样，我会给大家举个例子。

来说明这几种对应的一个情况，好吧，这我写了七个，我就差不多够了吧，你面试的时候，请给面试官说这些情况就可以了好了，这几个点能听吗，同学给我扣一，能看懂吗，这这个东西啊我来给大家一会，我来解释几个名词。

解释几个名词的时候，我们把对应的案例啊给大家做一个演示，做个演示好吧好了，这是刚刚上面讲的这些核心的一些知识，讲完核心知识之后，我们再讲几个关键名词吧，把几个关键名词讲完之后，基本上就结束了。

第一个名词刚才提到的这回表，来知道回表是啥意思的，给老师扣一，不知道扣二，你们知道什么叫回表吗，鬼表示这样一个意思啊，给大家解释一下，我们来列举一个场景，什么场景，比如说表里面有id逗号，name逗号。

认识多少，针对四个字段啊，先明确这四个字段，当我定好四个字段之后，我来规定一下，这里面有i d是组件好吧，name是普通，所以我写一个语句叫flat行，from people where name等于。

张三问一下，这条sql语句的查找过程是什么样子的，商用的，先根据，内部的值去name b加数，找到对应的叶子节点吧，我问一下这个叶子节点取得数据是什么数据啊，液在放什么，取出id值吧。

再根据id值去id，b加速攻找到查找全部的结果，这个过程称之为回表，是回表的意义，明白意思吧，那我问的是什么，回表的效率高还是低啊，回转的效率高还是低，怀表的效率比较低好吧，尽可能不要使用。

我尽可能避免回表的产生，明白意思吧，这些东西这是回表，那这个没问题的，扣一这个回答概念啊，他需要来回去回到原来表里面查询，我们对应的一个数据记录，是第一个来聊第二个东西，刚才要是讲的第二个叫索引覆盖。

什么叫索引覆盖啊，表示一模一样的数据一模一样，我把这个语句改一下，改成什么呢，加油id逗号name，大家问一下他的操作构成什么样子的，什么样子，是不是先根据name的值去name的b加数查找结果，能够。

直接获取到id和内容，还需要就不需要去a d的d加数，查找其他的查找数据了，这个过程，叫做索引覆盖，明白了吗，什么叫索引覆盖，也非常简单，就是说索引的叶子节点中，包含了要查询的全部数据啊，叫做索引覆盖。

能听懂吗，这效率高还是低啊，是高还是低高吗，这谁啊推荐使用，所以盖这些东西，看来再往下看下一个，他们叫什么叫最左匹配原则，这是什么东西啊，什么叫最左匹配原则呀，其实他也挺好理解的啊，它主要针对什么。

针对的是组合索引，一样改一下条件吧，id name和逗号位置是组合所有，组合专业就在查询，有时候必须要从左向右匹配这东西啊，就算我们呃去购物网站，你在购物网站里面写写写地址的时候一样，必须要先学省。

再选四，再选缺，缺一不可的，必须按照这样的这样的一个数据来，老师这里面会与生俱来对应几个语句啊，给大家查一下现在的行，from table，where name等于比如问号and edge等于问号。

这是第一个语句，下面还有几条，把它干一下，删掉，删掉，我问一下这四条语句里面哪个会用到组合索引，14134134，还是那句话，你记住，我刚刚说那个标准顺序，必须要从左向右挨个匹配，所以在匹配的时候。

我们先匹配第一个内部age是不是符合这个顺序，所以是没问题的，第二个edge能复合吗，必须要先匹配name再匹配edge，你这里面没有name，所以第二个是不行的，第三个可以吗，可以啊，虽然没有。

但是我能匹配到name也是可以使用的，第四个把name和age顺序换了一下，第四个行不行，第四个节目，这是比较有争议的地方，其实我问一个问题就行了，如果把name和age的顺序来回换一下。

会影响我们最终的查询结果吗，会影响吗，不会的，所以这块会有一个东西，就刚刚说的是优化系，会优化明白吧，会调整好我们对应的一个顺序就完了，这就是我们说的最左匹配原则对吧，除了最左匹配原则之外。

还有下面一个东西，什么原理是什么，没啥原理。

系列 6：P86：什么情况下会导致索引失效？ - 马士兵学堂 - BV1RY4y1Q7DL

在比较数据的时候，你要先比较第一个才能比较第二个，只有第一个相同的，我才会比较第二个，可能如果第一个不一样，第二就没必要比较了，就这么简单，来啊下面最后一个我们来讲一个索引，下推液化气后会不会走。

索引是不是优化气不会阻索引，它优化完成之后，会把你这两个条件的顺序换一下，换完之后不就符合内幕和a值了吗，它就会走啊，会走啊，汇总好吧，为什么内部一定要在前，因为你在创建对应的b加数的时候，大家看好了。

我们刚刚给大家展示的，找一下，刚给大家展示这个索引结构的时候，他这个key是不是只有一个值，当你是一个组合索引的时候，它就变成两个直道，比张三和28会放在一起，李四和39会放到一起，所以我在匹配的时候。

它相当于是一个二元组，明白吗，x y2 元组我必须要先比较x才能比较y，如果x不一样，我就连y比较的意义都没有了，y的永远不可能比到，只有x降头的时候，我才可能才可能会比到y就这意思好吧，是这意思啊。

你要最后面一个话题吧，叫三能行吗，三行啊，三可以不要说话吗，国木森可以的，虽然可以啊，虽然另外一只，但是name的符合那个顺序嘛，所以是可以用的，来聊最后一个东西叫索引下推，什么叫索引下推。

其实他也非常好理解啊，非常好理解什么意思，还是当前这样一个情况，我来写一个sl语句吧，flag行from k宝，where name等于根号，an值等于根号，就这样的一个普通字母语句，在没有。

所以下推之前他是怎么处理的呢，处理原则非常非常简，单，是先根据内部这值从存储，引擎中拿到符合条件的数据，然后什么在server中对age进行数据过滤，这没有索性下载之前有了，所以下推之后怎么做的，直接。

根据name和age，从存储引擎中筛选对应的数据返回给server，不需要，做数据过滤，明白意思吧，就这意思，必要的数据获利好吧，这叫回应下推，所以你把这东西想到之后，你再联想一下。

刚刚最上面我给你画了个图，他下推是相对哪了什么的，下推，这是神子下垂是吧，原来在server层，我要对age做的下推挪到了哪，挪到了存储引擎层，明白意思吧，从service层数多少，存储引擎层。

什么叫有了，什么叫没有，在mysql 5。6和5。7之前。

是不包含索引下推这个东西的，是5。6还是5。78，不忘的一个版本的啊，这个版本之后它才具备了索引下推这个功能，当然这个功能是不需要用户开启的，它默认是开启的，有一个属性15万吧。

是那。

叫啥来着，叫。

你一声，我来看啊，有一个东西叫索引下推，这个叫index，肯定是push down，它默认是开启的。

默认是开启的，在5。7之后默认就开启了，所以你不需要管这些东西。

你大概知道，所以下跌是什么意思就可以了，明白意思了吧，这叫算下退，没别的意思，来这些点看学校同学给我扣个一，没看懂吗，没问题吧好吧，当这些东西都没问题之前都都没问题之后，下面我们要说一个东西了。

说啥最后一个问题，刚刚讲了这么多，讲这么多是吧，有有有啥用来告诉我。

所以下载有用吗，所以下载有用吗，它的数据量是一个级别吗，你只匹配内幕，是把所有内幕匹配的数据反而回去了，age还没做数据筛选，你把mate和a这两个东西一起数据筛选，看筛选完数据是不是要少了。

你io量已经少少了吧，好吧，好了聊完这个东西之后，下面我们来聊最后一个东西，这个东西什么东西，所以优化我刚刚讲那么多东西了，讲那么多东西了，我们在回答索引优化问题的时候，我到底应该怎么去回答。

你不要上来之后，你不要上来之后就给面试官说，我通过判断之后发现我们的索引，我们的索引那个我没索引没有失效，所以我加了个索引字段，你这样去描述是没有意义的，你告诉我这个，所以这个优化问题我应该怎么去回答。

没有你所学的知识能回答吗，能回答，大院记住啊，你在回答优化问题的时候，你要给人的感觉是什么，是你真真正正的你做过优化，而不是说我从网上随便看了个帖子，我就能把优化的问题给大家说出来，不是这样的。

你要怎么去判断这件事情，非常简单，来听好了，这样的方式回答在之前，做叉叉项目的时候，我们有一个要数据量非常大哇，千万级别，千万级别好吧，写了一个非常简单的sql语句，就是一个条件，过滤好。

但是查询的效果非常差，花费了十几秒，哇通过分析之后，我发现通过查看执行计划后，也确实用到的索引是吧，而且查询条件非常简单，只有一个，怎么办，只有一个，怎么定义用法，能优化吗，啊怎么做。

利用前面所学的知识组合索引对覆盖话费，剃头说的非常对，现在可以说只有一个经过分析，发现我要查询的字段，字段用四个字段啊，但是这四个字段啊，而且这四个字段包含了查询的某一个查，包含了查询的。

还包含查询条件，因此不考虑减少回表，因此考虑在长安学过程中出现了大量的回表，好吧，此时将所有的查询表字段，和条件是组成了组合，所以好达到了优化效果好，执行完成之后，只需要，花费一秒左右就可以完成查询。

你这么说吗，拆开说绝对录播了，自己我看过对，是录播，我问你是录播吗，一直说录播吗，看到了吗，你能这样说吗，好同学们，你能能不能这样说，才说这能量扣一不能的，扣二能吗，不严谨，那不严谨吗。

我上课临时写的吗，你觉得哪儿不严谨，能不能自己学优化，能不能自己再编一下，能不能带上你自己的业务量，带上你自己的数据量可以吗，可以吧，我觉得没问题吧，嗯1000万数据加索引要dba来。

要dba以来没关系，你后面可以再加一个补充大量数据，添加索引字段信息的时候，可能会出现缩表情况，所以是跟那个那个，所以我提出建议使用什么，mysql提供的在线d d l操作，来完成天下索引的功能。

行不行，可以吗，这有漏洞对吧，给你补上了吧，有什么东西吗，粉丝都不知道这东西啊，在线b b r mysql，5。6版本之后出现一个在线地点啊，你可以给它进行索引的一个添加，没关系的。

这就是具体东西下去自己看明白了吗，这可以了吧对吧。

你黑马扎吗，我只是给到大家一个案例，我我并不是想把这个例子交给你们好吧，因为我既然公开课上讲到这玩意儿了，这玩意就烂大街了，明白吗，很多人都会抄走，很多人都会有这个东西，所以这东西不是你的加分项。

加分在什么地方，是这样的描述方式，你在写的时候一定要突出什么几个点，同学们记清楚了，第一个叫实际场景，你需要进行切换，第二个第21场景，第二个是什么，是问题的情况，第三个是优化的方式和你的思考。

思考的过程好吧，第四个是达到的效果，能懂这意思吗，这是你在回答对应的优化问题的时候，你整体的思路，你要以这样的方式去回答，而不是上来之后不要用三星，再用索引，不要这么去描述，能听到我想教给你的是啥吗。

来听白同学给我扣个一，能不能认懂，所以你把这种方式画出技巧，学会了，套用上你之前项目里面的案例不就完了吗，我不信你们项目里面没有对应的sql优化案例，不可能没有吧，光我现在学生问到我了。

我给你开一个实际的案例好吧，一个学生之前问我的，他实际公司里面的应用场景出现了问题，这数据量消耗比较慢，我给你看一下，太多了好吧，让我们来看你学生问我的，李老师打扰你一下，来看一下干什么事儿。

这个学生他的情况也非常简单，这是对应查询语句，sd什么cell number，cancel，什么什么chinese name，type of，type of product，这不多吧，这一句能看懂吗。

能看懂吧，我觉得这一句已经非常简单了，执行完成之后，他花费的时间是多少，0。104秒，我问一下这个0。104秒是快还是慢，快还是慢，大哥们负点责任，你们在说快再说慢的时候，能不能问一嘴数据量。

他过亿的数据量还还卖吗，别上来就慢跑快，你问一下数据量吗。

对不对，所以下次问了一个问题，他说打扰你一下，他说这个表总共才35万，数据category id等于6980，有20多万条好看的id，也要有索引字段了，好吧，我发完之后，他给我发了什么。

发现它对应的执行计划，杜老师，你看这个执行计划这样的，这个字段明显用到了索引，不是没用。

索引用到了听到索引了，但是效率依然很低，不太能满足我们的业务需要。

怎么办，我看完他之后，我说我可以ok，你可以考虑关闭一个属性叫index merge，我我刚开始怀疑啊，他可能触发了一些索引合并，所以导致了他出现了一些问题好吧，做完之后他说老师运行完了还是100多秒。

没有任何变化，0。106反而还慢了一点，我觉得这个那这东西肯定不行了对吧，再给它进行优化，我说这个有组合索引吗，可是没有组合索引，我说你串一个组合索引试试好吧，我串完之后他说还不行。

我说把排序再去掉试试看是不是排序的问题，是做了一堆，做了一堆检测完啊，都不行，还一样，这东西要慢慢去调整的，这次是0。1118秒好吧，再优化再优化，我说你加这个东西，再加上排序，加完之后。

这是它对应的结果，大家看看效果，谁叫我，我们出一下吧，0。106÷0。006，快了17倍。

看明白了吗，就是快这么多，自己都自己都惊讶了，明白了吗，这是对应的数据吗，所以你要想明白说我要在哪些地方去进行优化，我要去调整哪些地方，你别两眼一抹黑，竞猜我最怕什么，你知道吗。

很多b i g同学找到我说，梁老师，你帮我看一下这个sl语怎么优化，你发给我，我也懵逼，真懵逼，我根本不知道怎么做，你想你发给我一个那么复杂的sql语句，然后你告诉我说老师你帮我优化一下。

我咋能给你优化了，我是个人，我又不是个神，能懂我意思吗，这经常说的一个一个很重要的一个问题，好吧，等下我给你找一下午一个同学，就今天下午一个学生刚给我发的，呃找一下，就这个。

我们等会儿等会儿我们看看这个sql语句啊，我跟你说，看完这个剧，我自己心态都崩了，嗯还没翻到，等一下，看这个，这是他给我发了一个sql语句，从select开始往下走走走走走，你去看这个sql语句。

你去看，这最后一句。

来你告诉我这样的语句，你告诉我，你让我去怎么优化，我我我我打优化，你告诉我怎么做，一条就一条没完，你告诉我能优化吗，我优化不了，我是个人，我不是个神，好不好，所以你们要搞清楚这个东西明白了。

所以不同的案例你要去分析他，说到底哪出现了问题，应该怎么去做，这些东西应该以什么方式进行优化，这才是最关键和最核心的点，明白了吗，噗都打结了，不是打结了，这个东西展开啊，微信里面可能看的比较长。

微信里面看的比较长，打开之后已经大概几十行几百行，但是依然很很麻烦啊，是不是，不是故意难为我，我在公司里面见过最长的一个，一个sql 145500行。

系列 6：P87：如果通过索引知识来进行优化？ - 马士兵学堂 - BV1RY4y1Q7DL

下次注意句，这很正常，所以你们需要说的是什么，我需要给你讲实啊，不是让你们去说这个思路语句长度的问题，而是说你们在进行优化的时候，不要2。18，黑，明白吗，最害怕的是这玩意儿啊，你要干嘛。

哪怕sql语句，sql语句再复杂，不管它多么复杂都没关系，你要学会去做拆分，你要自由就去拆分，你要一层一层的去迭代，一层一层的去搞这东西，把它理解错了，这才是最关键，最核心的，他是生病，铅笔干啥。

这很正常，但好多表在关里面就这死杂一点，复杂点也正常吧，明白意思吧，所以掌握合理的方式方法，这一点很重要啊，包括你们在提到这些优化问题的时候，再好好去思考，一定要按照我说的这个思路你去进行处理。

如果你按照这样的思路去解决的话，真的很麻烦，真的很麻烦，不要上来之后有老师你帮我调一下优，我咋调都调不了，好吧行了，这东西啊，咱们大概就聊这么多吧好吧，来这今天晚上有收获的同学给老师扣个一了，好不好。

讲了两个小时啊，我觉得我讲的已经够多了好吧，老师数据量过亿，增加索引会非常慢，有什么好的方式了，没办法，就是用在线d d l的方式来加索引，这个没别的招都能夸张，慢就慢，这个没没办法，我们打扰一下。

现在几位是不是应该分表了，举个例子，10万百万就比较合适，低于多少条加索引访问一下写系统，我觉得是这样哈，帮助听好你的问题，我们一般情况下数据量过千万级的时候，就要进行分部分表了，但这只是一个预估量。

它没有明显的一个数据统计，你过千万，你还要判断一件事，除了过千万这个级别之外，你还要判断什么东西，你要判断一个点，您每一行记录占用的空间是多大，每一行记录你一个一行业里面。

十个字段和50个字段和三个字段，效果一定是不一样的，所以不一定是说过千万，我就要重复分表，这东西是干什么，是根据你实际的需求来判定，当你发现你的表数据变多之后，你查询不管怎么优化都优化不了了。

这个时候可以考虑添加我们对应的啊，可以进入我们的错误分表，但不是说我一旦过千万之后，就一定要分出去秒，这也没什么说的，没什么说的好吧，如果my mysql中某个字，但是汉字的话。

在汉字键索引该b加数是汉字的话，怎么保持有序，奥斯干嘛吗，字典序吗，英文名字典序嘛，数字就是数值嘛，汉字的话你要干嘛嘛，但是建议不要用汉字，不要用汉字，汉字的话这个太麻烦了，好吧好吧行了，这东西啊。

咱们大概就聊这么多吧，这只是mysql里面的呃，一丢丢或者一奶奶，刚刚也给大家提到了相关的一些优化的问题啊，给大家看一个文档，就是之前我在讲这个mysql优化课的时候，大家看一下，这叫msl调优。

讲mysql调优的时候，给大家讲到的一些细节上的一些点，大家看一下，你调料里面包含的东西非常多，你不要上来之后就想着说我要加索引，所以优化的时候你可以分几个维度和几个细节。

比如说你关于mysql性能的一个监控是什么样子的，对吧，你对应mysql的一些呃spammer表结构是什么样子的，你的索引要怎么进行优化，包括你对应的sql语句要怎么调整，包括你的参数要怎么去优优化。

怎么去调整，包括你是不是要加分工那个分布式的数据库。

这东西都要合理判断好吧，沈阳马天志说看不到，我说话吗，对看不到的，因为是录播，所以看不到，开玩笑，画风有什么软件啊，我刚说了吗，分叶云笔记，枫叶云笔记，是直播是直播，哎呀是直播啊，那你不理我。

我没看到你发的消息啊，你发啥了，没看到吗，梁老师结束的时候，可以谈一下，不同的存储引擎对于事物的支持区别吗，可以另外给压缩了，来说一下它们的区别呃，我之前讲过这东西，我现在在哪儿讲，我找一下。

我记得之前讲过这玩意儿好像，四个，我，找一下，所以，太多了个旺，看这图吧，这是之前画的一张图啊，就是关于这个组合式九的msl，amex up和windodb的呃，首先第一个综艺类型masm面。

只有非技术索引性层地狱里面有剧组索引，也有非剧索引，第二个事物呃，my sm是不支持事物的，印度db是支持事务的，第二个第三个表所my sum支持表，所应当db也支持表锁行锁，my sum不支持。

但应当db支持外界maximism，不支持移动db支持全员索引masm支持，然后应用db五点之后支持操作，大量查询的时候用我们的my su，然后增删改查的时候就移动db，但这东西啊。

坦白说一般情况下移动db用的更多一点，其他用的并不是特别多，好你大概了解一下就够了，ok所东西啊，咱们明天讲吧，明天我讲一下事物相关的点，好，检查事物一些特性啊，检查事物特性的一些实现原理。

讲一下mv c c，咱们再到时再聊好吧，老师有主从知识吗，有主从的话，我讲过主从复制，然后讲过读写分离仪，讲过分部分表都都讲过，包括像mt这样东西我也讲过，好吧，就是你学生问你的那个，有学生问我。

那个为啥那个索引添加之后排序变坏了，就减少了回表嘛，就减少了回表，就是减少回表，我那个东西我没公开课那个那个那个不是主从，这东西我公开课没讲过啊，都是在vip里面讲的，公开课没讲过，来看一下吧。

嗯这里有一定的文档给大家看一下，就是比如说主动复制的原理，我之前写的什么主动复制原理是啥，怎么去复制的步骤是啥，形式有哪些，然后主动复制延时应该怎么去做，这是应该都提到过，都讲过这个东西好吧。

包括它的一些安装配置，你要怎么去配，搭建的时候要怎么去搭建详细的步骤，这些东西都有好吧，他那个也是减少了回表的产生，就这么干的是吧，然后包括像my cashing sphere，我都给讲过，没讲过。

ok笔记能发下吗，笔记不发了发吗，写这种东西要发吗，再说吧好吧，都发下来吧，那么多markdown想多了好吧，就发ok好了，今天的这个具体干货，咱们就聊这么多吧好吧，下面呢聊点更好玩的东西，聊聊什么啊。

不发怎么学，听我讲这些东西你就慢慢消化吧。

不发你那个那个那些段都发了，跟vip同学太太不公平了好吧，下面聊点好玩的东西吧，聊点好玩的啥啊，刚刚给大家讲了mico相关的东西，我刚刚给大家看了一下msl调的一个文档啊。

呃下面给大家说一些东西，就是你在学技术的时候，或者你在学习的时候到底要怎么去学习，接下广告，我不不打广告，我们就聊会儿天，我们不麦克，今天不卖课，不给大家打广告，里面点好玩的东西啊，就是聊到一个问题。

你们觉得我今天讲完这个课之后，你们都觉得收获比较大，我能学到很多东西，这样我想给大家说一件事是什么，希望大家在以后学习的时候，能有一个很重要的东西，叫什么叫方向性的东西，这东西我觉得是比较重要的。

什么意思啊，有很多同学听完我这个讲东西之后，你觉得我把索引讲完了吗，或者你觉得我把索引讲完整了吗，其实没有啊，这所有里面包含的东西还有很多，这只是其中的一些细节，或者一些比较重要的部分。

和面试中问的比较多的东西，我优先拿出来给你讲，但其实索里面包含的东西还很多，大家以后在学习的时候啊，你们既然晚上来听课了，意味着你们平常的时候，自己可能也会学点别的东西，包，或者以后琢磨点东西对吧。

一定要一直在不断的学习，那么我想说的是什么，你们在学习的时候一定要有一个方向，同时一定要注意一件事，什么事儿叫体系化学习，体系化学习这件事情是非常非常重要，什么叫体系化学习嗯，很多同学出去面试的时候。

应该收到过一些评价，比如说知识碎片化，比如知识不成体系，一定收到过这样的一些评价，这些评价都反映了你在学习技术的时候，你自己存在的一些短板，所以我希望同学们在学习的时候，一定要有一个体系化学习。

我就是不要说我今天学一点，每天学一点或者学一点，但学的东西都不一样，这是最可怕的一件事情，包括我们的vip也经常问我一个问题的老师，我在学技术的时候，我是多个技术并行着学，还是说我学完某一个点之后。

我再去学另外一个点，你们觉得哪个好一点，你们觉得病情好还是单独学一个好一发，一般都是看到什么学什么，告诉大家我个人的建议啊，大家学习的时候一个一个来，你千万不要同一时刻看三门新技术，或者看n门新技术。

或者看一门技术，千万不要这样，这边一定要一个一个来，因为11111堆东西堆到你那儿之后，你很麻烦，或者你看起来会很容易忘，或者说体育效果是非常非常差的，学习就是把某一个体系，某个体系学完了还有一个点。

还有一点也很重要，一定会用到自己的一些知识盲区，老师讲课的时候一定会提到一些点，当你提到了一些点之后，你会发现一件事，什么事，这东西我不会，那东西不会那么很多同学会干嘛呢，会从这个点里面离开。

把我要搞明白的东西，我搞明白之后，我再接着来学习，有多少人这么干的，有吗，就比如我学mysql，昨天讲了一个o l a p，我不知道是啥意思好了，我去学o l a p，我把o l p搞明白之后。

我再回过头来学mysql，这种方式，也是大家非常非常要就一定要摒弃掉的，我刚才有好的方式是什么，你在学习技术的时候，学习技术的时候，先去过一遍整体的知识的总体概括，概括完了之后，当你不会的点。

拿一个本或拿一个文档，在线文档把它给记录下来，你把它记录下来之后，接着往下学，等你有时间有一些零碎的时间，额外的时间之后再去补那些你不会的点，千万不要让自己跑偏了，也有可能有很多学生是学生是这样学习的。

他沿着一条主线去学习学学的翻译，有东西不会了好了，我从中间分一条叉出来对吧，从这分量差出来，然后又有同学说老师这个东西我也不会好吧，又分量差出来又被拿出来，有些同学还比较好，他能回归到主线上面去。

但有很多同学你是回归不到主线的，你学学学pp了，明白吗，你学篇之后就变得很麻烦，你懂我意思吧，所以这些东西才是你要摒弃一些点，这都是学习方法上面的一些小技巧，然后除了这个东西之外，约等于1米8。

说有详细的路线分享吗，呃想要路线，一会我可以给你，但是我在讲路线之前啊，我还想再说明一个东西，或者再说明一件事，你们有人对学习路线有疑惑吗，老师我现在想学学要学什么东西，有疑惑就要扣101或者扣二。

有疑惑吗，都有是吧，当你在有疑惑之前，或者说当你在要路线之前，出现之前，我需要你们先做一件事情，什么事情，这东西，叫定位，你们知道很多定位吗，什么叫定位啊，谁能给我解释一下，目标菜头师，目标是全站。

想搞全站同学，我建议你换一个换换换一个目标好吧，先生东西叫定位，什么叫定位啊，现在啊这个技术太太太多了，明白吗，就是你要学的话，你根本学不过，你根本学不过来，这学起来是非常非常吃力，而且他学习的时候。

他不一定能收到对应好的效果，所以我非常不建议说你真的说把所有剧都学了，但是你一定要有一个定位，定位什么意思，自己处于哪一个水平，之前我有一个vip学生报名了，报名之后让我做规划，规划的时候呢。

说老师我现在年薪14k，年轻时不是月薪14k，我想出明年冲击年薪50万，你觉得可能吗，挺好啊，现在月薪14k，明年冲击年薪50万，你觉得可能吗，太难了太难了，真的太难了，好吧，记住一句话。

叫饭要一口一口吃，路要一步一步走，技术要一个一个学，所以我为什么说你要定位第一任老师，那我现在到底处于初级，中级高级到底属于哪个哪个阶段，我没法去判断啊，很简单，现在国内或者说现在的市场。

市场上面没有一个明确的标准，说你掌握了什么技术，你就是一个初级的掌握了什么技术啊，就是高级的掌握什么技术，就是中级的没有障碍，拼标准，但是有一个标准是存在的，什么东西叫职级，你们知道吗。

当你们接到大考之后，一般情况下是都要有直接评级的哇，最简单的题节举例子，比如说阿里的我们从p5 到p8 ，对不对，这就是最基本的一个直接像你上网搜，你是能看到很多，对于不同职级的一些技术要求的。

进行更更更改的，当你掌握好这些东西之后，你可以对号入座，你自己现在大于位于某一个水平，同学们来方便同学，你可以给我发一下，你现在的工作年限加你的薪水，你能方便发一下吗，我觉得今天晚上大部分来听课的同学。

你们大部分人的就是薪水等级，或者你们大部分职级应该处于一个中级往上，稍微多那么一点点的一个阶段，就可能很少有那种高级这样，一个一个一个一个一个一个水平的学生，因为接下来我讲的东西其实并不是特别难。

它其实属于是一些基础的必备的常用知识，9年16x14，在合肥3年15 6年10万和6。5k实习，刚毕业10k哇，这80k合肥知道吗，是大家发现了，你们其实大部分人其实应该处于的是什么。

是p5 这个级级别什么意思，我能去做一些独立的开发了，我对我们基本的一些框架，比如说s s m对吧，比如说spring boot，比如说spring cod这些基本的应用我是没问题的啊。

基本应用是没问题的，那其实你当你了解完这些东西之后，下一步你就要考虑到我老师我要掌握p6 ，或者说我要达到p6 这个级别，如果你拿到p6 级别，那p6 我应该具备什么样的能力，或者我应该学什么样的技术。

当你聊到p6 这块之后，下一步才是聊什么，聊路线的事情，明白吗，所以不要把这个前后的顺序给颠倒了，很多同学就是因为把前后的顺序颠倒之后，导致你学起来一直处于一个迷茫的阶段，迷茫阶段哦，比较迷茫。

就一定是先搞清楚你自己的定位，就是我做事情一直是这样的，第一步先有一个定位或分析，分析完之后，第二步数据对应的目标，网站的目标是小目标，不是大目标，有老师，我要年薪百万，老师我要领取白富美，别扯淡。

我现在45k，下一份我就要20k，我就25k，这是比较现实的，一上来就我家构师，我年年纪大了，你舍不得我，财富恶龙咆哮，目标28岁，财富自由，这个梦做的有点大啊，并不是达不到好吧，但是比较难。

所以先输入一个小目标，比如先赚他一个亿，是这意思，现有目标，有了目标之后，下一步干什么事，变成这叫制定计划了吗，对吧，当计划完成之后，下一步才是什么东西，就像一件事就落实，张老师，当然这里面最关键。

什么叫定下一个目标，你还没干呢，就定下一个目标，等这东西实现之后实现了，然后再回过头来搞搞定位，搞目标是这样逻辑，你还没干呢，你就跟下一目标干嘛，一点意义都没有，听明白意思吗，你们以后在学习也好。

在干嘛也好，一定要遵循这样的一个路线，这东西我觉得是心理有效的啊，当然这里面最关键是什么，是这个步骤目标，你的目标不要太远大，不要太红的，这辈子都实现不了，不要带这个东西没意义没意义啊，最关键的是什么。

你要树立一个你能好吧，经过一段时间努力之后，你能够得着的一个目标，而不是一个痴人说梦的目标哇，这才是最重要，最最关键的是年龄不是问题吧，年龄又会有问题，但是你要结合你自己的情况。

在最短时间之内达到你想要的东西就完事了，就这么简单，所以把这个东西你要想明白了，不要去抱怨卷这件事情啊，卷是常态，明白吗，你是改变不了卷这件事情的，所以你能做的事情只有一件事，你去改变你自己。

而不是改变卷这个现现状，卷这个行业动态改变不了，明白了吗，你要改变的是你自己，所以当你把这套东西搞清楚之后好了，我们再来聊路线的事情，比如说这个计划的事情，比如老师那p6 应该学什么东西来。

有人好奇p6 要学什么吗，好奇给老师扣个一，有没有好奇，地址不是说年龄大了怎么办，好了，一会儿我们留出点时间，你们把你们的个人情况告诉我，咱们一会简单聊一下你们个人的规划，我先告诉大家路线是什么样子。

路线什么样子好吧，p6 年薪多少，p6 的年薪大概是40万~60万啊，当然前两天我听曹老师说，阿里出了一个p6 的顶薪，大概是90万，p6 的底薪90万，但这个很难了很难了好吧。

它不是一个短期内能实现的目标哦，所以你需要是什么，比如说这个地方p6 他看中的是什么，p心他看中的是什么，你要做到心里有数明白吗，p6 需要是啥呀，其实非常简单，给大家看一下。

这里面其实就对应路线注意了，p6 它针对的是什么叫操作与落地，明白吗，什么叫操作落地，这个操作流落地里面包含了非常多的东西，我们一块合一下，只能把你们吓到了，好吧，这是hero里面。

p6 里面要包含的相关的核心竞争点，和核心知识点，好吧，比如说现在你要想达到p6 的话，你要有一些自己的前置知识，什么叫全日知识，比如s m spring boot，我能做一些独立的开发对吧。

了解一些新特性什么之类的东西是前置知识，我觉得基本上你做开发了都要具备这样的能力，那再往下看，你还要掌握什么，掌握一些底层技术，比如说操作系统的，比如说计算机组成原理的，比如说网络的，比如说i o的。

比如说linux的，比如运维的以及数据结构和算法的东西，这都是你要掌握的必备的一些底层的技术，现在面试他就问这些，其实不单单是p6 ，你在面临一些上规模的公司的这些开发的时候。

中高级职位的时候基本上都会涉及到这些东西，好吧，再比如说并发编程，你要了解操作系统的并发知识队列的东西，内存模型的东西，线程池的并发集合的c s s y local的j u c的，gm i h的。

你都掌握，是华沙等，说掌握的话，要掌掌握到什么样的一个程度，你要能把这套东西形成自己的一套知识图谱，或者说知识体系，不知识体系什么意思，我一样可以给大家看一个东西，这是我们之前vip他自己做的一个笔记。

他在学jvm的时候，他做的一套东西，我给你看一下，你是能描述出来，当你学完一个东西之后，你如果能把笔记做成这样就ok了，在我的评估范围内，我觉得就ok了，在这个学生他学完jvm之后，他自己画的一套笔记。

我做了一个自己的j a m思维导图，如果你能做成这样子，我觉得你就学到位了，就这么简单，还是那句话，你要掌握是什么，同学们永远记住这两个字，叫体系，能懂吗，不是某一个点，不是问到垃圾回收器的。

我知道是个啥，那能不能把那些同学更好，知道是啥，不是这些东西，你要对各个细节你都要考明白，我可以给你放大看，每个地方都是他做的一些详细的东西，看了吗，做的很清楚啊，参数也好，调整也好。

什么东西啊都做的非常完善，非常完整，这才是你应该掌握的哇，你要能形成这样一套东西出来，所以就说当面试官问到你，不管问到你什么技术的时候，脑海里面啪能打开一张图，同年包含了非常多的东西。

他只要问到三观点了，你能侃侃而谈，这才是最主要的好吧，那现在应该很牛吧，确实很厉害确实很厉害哦，所以这才是你们需要学习的东西对吧，这是并发编程这一块，除了之外，你要掌握一些通信框架的一些东西。

比如说reaper里面通信double对吧，r p c的rust thrust和net这些东西都要掌握，用中间件也要掌握，rock mq卡不卡对吧，都是必备的基础，包括像中间件的应用mem catch。

还有这个redis对吧，包括你要掌握一些软件设计的，一些基础的理论知识，是设计模式，软件工程了对吧，敏捷开发了对吧，一些文档的案例编写的都有，包括你们的分布式架构实践，分布式架构时间。

不单单里面包含了什么分布式事务，分布式锁，分布式id了，不单单包含这些东西，还包含了一系列上分布式密度，分布式绘画，分布式任务，分布式权限控制，分布式预警系统，分布式链链追踪等等东西。

都是你要进行掌握的把，包括你要掌握到微服务对吧，注册发现了网关，路由了服务调用了负载，集成了nfx阿里巴巴的多少物对吧，以及性能调优的cfm调优mysql调用，他们看调用，但这个调用对吧。

海量数据存储的对吧，e的培根house messl news，太dd的，对不对，包括我们搜索e的，对不对，包括像海量数据处理的一些东西，flink还有很多东西，包括像运维的，你要了解一点啊。

di要了解一点，然后测试的你肯定要稍微了解一点对吧，service nt东西了解一下，所以这些东西都是你要进行储备的，明白意思吧，你说如果你想达到p6 这样的一个，技术实力的话。

那么这些核心点就是你要处理的东西，学校做的同学给老师扣个一东西多吗，那你们觉得多多多吧，很多吧，这些东西你都需要学习吗，你需要把所有的东西都一口气学完吗，需要不需要，我告诉大家。

如果谁想着我要一口气把这些东西学完，我觉得你肤浅，为什么技术这东西它是没有边界的，明白吗，你今天学完一个东西，明天可能出一些新的东西，你永远学不完，那你要学的是什么东西，学的是啥东西。

掌握你现在必备的基础，那么你可能会疑惑，老师我现在必备的是啥，这里面有你一点都不会的吗，有没有你现在一点都不会了，你能不能抓紧时间学，能不能从这些模块里面挑一些东西拿出来，优先去学习，能不能。

这是没问题的对吧，你能不能给自己规定一个时间轴，就我刚刚说的，我这一生的目标或这一个月的目标，我要把什么，我要把并发编程搞定，下一个目标，我要把中间键搞定，下一下这个目标，我要把什么东西搞定。

能不能做这样的东西，不怕你不干好吧，就怕你什么，就怕你们瞎干，盲目的干明白吗，所以当你这个东西给到你之后，你能不能有明显的一个路线或大纲，在当你有这样路线之后，你一块一块学不行吗，好吧，虽然说可以。

但是不知道选哪些，不知道选哪些，也非常简单，也非常简单，怎么做，我告诉你第一路线给到你了，你从这个路线里面诶，我问一下，有人想要这个路线吗，想给老师扣个一，有人想要的，谁如果想要的去找咱们的班主老师。

找他们去领取扫地的二维码和扫码器进行领取，能明白这意思吧，上面进行领取，如果你之前加过咱们任何一个咨询老师，找他领取，也是ok的，也是ok的，明白意思吗，好吧，我要说的是什么，当你有这东西之后。

你可以自己从里面选择一些你不会的点，但这是一个方式，除了这样的方式之外，还有什么方式，我再解释一下，还可以干一件事，你找一个领路人，找一个你的师哥师姐，找一下你的一个领导，让他来根据你个人的技术实力。

帮你从里面能不能提取出一些关键的点，你们这样的人，如果这样的人也没有的话，那我告诉你，你就需要报名马士兵教育的课，什么意思，你不知道没关系，老师知道我们会告诉你一步步你要怎么做，懂我意思吗。

啊拿到了和人最差了好多差就对了，人不怕自己说我现在混的差，而最怕什么，最怕不知不自知，明白吗，就我不知道学什么，所以你要掌握是什么东西，把这些关键的核心点，你要知道我哪儿缺乏了。

我要把什么技术给弥补起来，这才是最主要和最核心的关键点，听明白了吗，所以如果需要的话，整体设计领取好，详细看一下东西，我说的东西很多，但不需要你，你你每个挨个都选一下，有老师可以帮你。

慢慢的捋出一条适合你自己的独特的路线，而且每个人的目标是不一样的，所以你每个人需要储备的技术，也不是也是不一样的，如果你真的把这些点都学会了，在p6 级别里面，你真的可以拿到顶薪，明白了吗。

顶薪难度最高，这个东西完全不夸张好，这才是你要储备的，这只是p6 这个职级，这个级别你需要储备的，有人想看pc吗，想看pc的，给老师扣个一，想看吗，就pc我要掌握什么样的技术实力。

这是p6 的p6 强调的是什么叫操作与落地，pc小调，什么叫原理与设计，这里面我们依然包含了一系列的东西，好吧先合一下好吧，然后什么第一个叫分布式设计的理论基础。

这里面包含了一些像c a p的puzzles了，rap了啊，该s i p到这样的一些协议，第二个你要掌握一些核心的算法，分别是架构相关算法和机器学习算法，第三个你要掌握一些框架的原理，什么血压桶呢。

my best is对吧，他们看到这个cd m cute net hosports e l k，你都需要掌握这些东西啊，包括有一个高性能架构设计，什么叫高性能架构设计，比如说分流设计怎么做。

服务并行并发怎么做，缓存设计怎么做，存储设计怎么做，可靠性设计怎么做，并用保护设计怎么做，多位了解，再比如说下面还有一个案例驱动设计，我们这里面提供了一堆的项目设计的课程，比如说每秒数是每秒数10万。

超高并发通用设计专题，有一堆的案例告诉你怎么去设计好吧，应该有什么技术键技术站进行相关的一个搭建，比如说有n个九全链路，高可用通用设计专题对吧，有云集百万年薪好吧，案例驱动式架构设计专题对吧。

有我们的一级流量，多级缓存的架构设计专题，这里面我们更多承受，就不单单是那些比你基础的技术实力了，或基础的一些应用了，更多强调是什么，就是我们整体的架构设计能力了啊，这才是你能拿到pc这个级别。

最最最重要和最最最最核心的关键点，明白意思吗，除此之外，这只是p7 的，这边还给你搭配了一堆的项目的课程对吧，有一些用户中心的，有一些架构设计的，比如说我们有一堆项目课。

有一些网多人在线网游服务器的对吧，东方商城的有没有飞机出行的，有推推荐的，有刘诗云平台的对吧，这都是你要讲的相关的核心点，讲数据库连接池了吗，讲了数据连这最最基础的内容嘛，肯定要讲了。

包括有人说老师我现在技术学完了，我需要准备面试怎么办。

没关系。

系列 6：P88：事务的四个特点是什么？他们的实现原理是什么？ - 马士兵学堂 - BV1RY4y1Q7DL

来先聊第一个问题，mysql事务，mysql的事物它有几个特点，结合点，谁能告诉我，四个吧，我觉得所有人都能说出来，叫a c i d，对不对，它们分别对应过来的特性是什么特性，第一个叫做原子性对吧。

第二个把这个字调大一点，第二个叫做一致性，第三个叫做隔离性，第四个叫做持久性，这几个东西啊，我觉得大部分同学你只要在接触数据库的时候，都会学习这几个点，但是这个东西不是我之前想讲的重心。

我想讲的重心是什么，这四个特点，它们分别是用什么样的方式来进行实现的，也就是说实现方式是什么，好吧，一定要做到什么叫知其然还要知其所以然，这件事很重要，什么叫实现方式，也就是说我们的实现原理是什么呢。

他通过想要的方式来进行保证的好吧，那先说第一个吧，原子性啥叫原子性来着，什么叫原则性，就要么全部成功，要么全部失败，是不是这意思好吧，那我怎么保证它啊，其实成功的话非常简单，我数据直接更新成功就可以了。

如果失败的话，我是需要进行回滚的，那我怎么样能够把数据给回滚回去呢，这里面其实涉及到一个问题，什么问题，同一个事物里面可能会包含12345，n多条的sql语句，这n多条sql语句里面。

前三条我可能已经执行成功了，但第四条和第五条执行失败了，一旦失败之后，我前三条执行成功的sql语句，也要回滚到之前的历史版本里面，那我问一下，如果让你自己来实现这个东西，你会怎么实现。

就你自己会怎么实现，是吗，其实你可以做一些思考吗，我只要能做一件事就可以了，我保留着我之前的数据的历史状态，如果我没有提交，我的历史状态依然保持着，当我需要回滚的时候。

我是不是可以把我历史数据重新拿回来，回放进去不就完了吗，是不是这意思好吧，所以这里面是什么样的一个方式，注意了，我先说它底层的实现，基本原则性是通过什么来实现呢。

是通过一个东西叫undo log来进行实现的，来知道undo log的扣一，不知道undo log的扣二，好了，有很多同学不清楚这玩意儿，不清楚这玩意的话，我们来说明一下mysql里面的日志。

专门聊一下这个日志系统，你们在日常开发中啊，其实日志用的也是非常非常多的，在mexico这个图里面，或者msl这个竞争里面，它也包含了非常多的日志，比如说我们比较熟练的日志有哪些啊。

第一个比如说blog，你们是知道的对吧，这个用的是最多的对吧，除了blog之外，第二个刚刚提到的read on the log，除了on blog之外，还有什么，还有redo log对吧。

以及还有很多同学说老师还有这个东西叫error log，错误日志吗对吧，还有什么，slow log慢日志吗，对吧，还有什么，relay vlog r e l a y logo，有人在这里面。

它其实包含了屏幕不动了吗，hello，hello，屏幕不动吗，能看屏幕吗，应该是应该是用浏览器的同学卡了，你们把那个浏览器刷新一下，好不好，把浏览器刷新一下，刷新一下，你在这个地方我写了一堆的日志。

一堆的日志，这件事里面有些用的比较多，有些用的比较少，挨个给大家解释，第一个vlog，它叫什么呢，叫做中继日志，中介就是这个东西啊，是在主从复制的时候用到的，暂时你可以先不管它，或者先不了解他。

在主从复制或主从同步的时候，会用到这玩意儿是吧，这个叫slog，叫慢日志吧，也就是说你在你的数据库里面，经常会开启慢查询，当一个sql语句执行时间，超过某一个限定的范围的时候。

会在我的slog里面记录条日志，我可以根据这个日志来判断一下哪条思路，语句执行的比较慢，那么来进行相关的一个调整对吧，这个这个叫erroid，什么意思，错误日志吗，在整个mysql执行过程中。

如果某一个呃操作出错了，会进入到所有errolog里面去，就这几个，这个我觉得还是比较容易或者比较好理解的啊，上面这三个我需要重点给大家解释一下，这是我们今天要聊的比较多的东西，为啥删掉不删掉就留着嘛。

无所谓了，写写下错误日志，慢日志好吧，留着留着留着，你们说留着就留着，什么时候出现错误日志，你程序出错的时候就出现嘛，对吧，这有啥，下面我要聊出去聊这三个东西啊，这三个东西上面这三个给我们今天讲的课程。

关联度会比较高一点，第一个blog blog叫什么叫二进制日志文件好吧，他在mysql里面默认是不开启的，但是我建议同学们不管是你自己练习也好。

还是生产环境里面也好，最好把冰冻保存开启，因为它能够帮助我们进行数据同步以及恢复，这事很重要，也就是说当你有了blog之后，哪怕你的数据丢失掉了，我也can you。

可以根据我们的blog把数据给恢复回来，好吧，下一个叫undo log，什么叫undo log，它的名称叫做回滚日志，回滚日志是吧，还有一个relog，它叫什么叫前滚日志，这当做自己取的名字啊。

前滚这是一个回滚，一个前滚，他俩其实相相对应的，相对应的，那我想说的是什么，一会儿我会重点解释一下undo log和redo log，他们两个的实现机制是什么，但是我这要强调一件什么事。

同学们一定要注意了，我们的blog，昨天我给大家讲解过mysql相关的一些架构体系了，那这样我要说明的是一件什么事，情，注意blog它归属的层次是谁，是massive的server层。

而我们的undo log和我们的resulg，它并不是存储在masl server层里面的，它是属于哪个呢，它是属于in no db这种存储引擎里面去的，这是它们之间的区别。

一定要知道它在哪一个层次里面去生效，所以我们昨天今天我们讲事物吗，mason它是不支持事务的，但是inno db是支持事务的，所以这两个东西重点的时候就聊inno db相关的，合适点，能听明白吗。

来我现在讲的这些东西能理解的，给老师扣一，能理解吗，好了这些都能理解的好，我来回答出来，那它到底是怎么实现的呢，其实非常简单，我刚才已经说过了，如果我们想进行回滚的话。

我如果保留了我之前某一行记录的某一个，历史状态或历史版本的话，在我没有提交，或者说我失败之后，能不能恢复到我上一个历史版本的状态，能还是不能能不能，就我考的历史版本吗，有个历史版本之后好。

我回复回去不就完事了吗，就相当于你们在操作系统里面，或者你们在做一些呃备份的时候，是不是有一个时间，是不是有一个the time step的东西，你是不是不是tesp有个叫快到的东西。

是不是可以恢复到某一个历史时间状态，把数据恢复回去，特别是在虚拟机的时候，是不是快到，这东西就相当于是一个快照的一个组件点，当然很多东西啊还不太了解，underdog里面到底包含了什么样的一些信息。

一会儿我会通过画图的方式，给大家做一个完整的描述，你记住原子性是通过undo log来实现就够了，这是第一个好吧，那么第二个我们的一致性先扔一边，我先说隔离性，隔离性是通过什么实现，什么叫隔离性。

其实也非常好理解，比如说在并行运行的各个事物，它们之间相互独立，互不干扰啊，对不对，也就是说我一个事物在运行着，另一个事物，不能去影响我当前正在执行的这个事物，那这东西我要怎么来实现呢。

其实这里面涉及的更多的是并发相关的一些，基本操作吧，你想我该怎么做，让你自己来，实际上话你会怎么实现，好了松饼说了一个字，叫锁，确实是通过锁的机制来进行实现的，但是这有一个问题，同学们。

如果我给我们的事物加锁，会给我们的数据加锁之后，加锁之后的效率是高还是低，听到问题，加锁之后的效率是高还是低，低是不是要低，马老师之前讲事物的时候，经常讲述的时候，经常说，当你一个人上厕所之后。

他必须要等你出来之后，你才能接得上，是不是意思效率比较低，但是遇到我们这种大型的，或大量的并发处决的时候，如果我全部加锁的话，很明显效率是比较低的，因此在隔离性这块它除了用锁实现之外。

还会包含另外的一个技术点，叫做mv c c，什么叫mv cc，它的全称叫多版本并发控制好，music version control c control，这意思是叫mc s v cz啊。

有多少同学在之前面试过程中被笨到过，给老师扣，一有人面试中被问到过吗，你有没有啊，应该有吧，反正我们的vip问过我很多次这样的问题啊，所以我把这个mv c c给大家做了一个，非常非常详细的讲解。

你们之前可能有很多同学从网上搜过一些帖子，关于mc c的，但是啊我也看过一些帖子，我觉得里面说的东西并不是特别完善，所以一会儿我会拿出大量的时间来讲解mv c c，它对应的底层实现机制。

比如mv cc会成为我们这节课的重点，包括我昨天在留的那个作业里面，最后一道题想要了解的，会要讲解的也是mv c c相关的基础知识，好吧，它一会儿我们再放一边，一会再聊，它是最后一个。

还有一个东西叫什么叫持久性，这东西19年什么意思啊，19通过什么来实现，之前收到的一个名词叫做redo log，a good log，什么意思啊，这里面啊其实要保证一个机制啊，我问大家一个问题啊。

我觉得卖家问题之后，你们应该会引发大家的一些的思考好吧，首先我们的数据是存储在磁盘里面去的，当我需要去更新某一条记录的时候，这个更新的操作执行的效率是高还是低啊，听到这句话，我们现在数据是存储在磁盘的。

当我需要去磁盘里面更新某一个数据，结果值的时候，它效率是低还是高，第一把为什么低啊，这里面涉及到我们对应四川数据的一个，寻址过程吧，选址的时候他效率是非常非常慢的，非常非常慢的，但是你要去思考一件事。

同志们什么事考虑好了，我每次我在进行更新操作的时候，更新操作的时候，我需要把数据从磁盘读取到内存里面去，我现在内存里面发生对应的修改，内存里面先更新完成，更新完成之后，它会变成脏液，变成商业之后。

我需要把内存里面的数据，刷新到我们的磁盘里面来保证数据的一致性，假设我在进行寻址的过程中，突然mysql挂掉了挂了，如果mysql挂掉了，我问一下这条数据，他还没来得及写磁盘。

那么这条数据是成功了还是失败了，成功还是失败，失败了，那市面肯定不行啊，你说你msl换了老师，我重启，当你重启之后，你怎么样能够保证我能够把数据给恢复回来呢，能保证吗，不能我说过了。

这个往c盘里面更新数据是非常非常慢的，你没办法把它进行相关的一个恢复，所以此时就有了relog这样的一个东西啊，在讲主义log之前，我还是要说明一件事，什么叫有报告，它也是存在磁盘里面的一个日志文件。

比如说我每次在往磁盘里面写数据之前，我需要先往日志里面写一份，然后我再往我对应的磁盘的数据文件里面写，这就会有一个问题，你们会有疑问，老师我既然他也要写一份文磁盘，我的实际数据也要写一份磁盘。

那为什么我要它来保证我们对应的数据呢，我对应了我们数据的完整性呢，写数据不需要浪费时间吗，为什么呢，这里面一样的也涉及到了io的问题，什么io我们在进行读写操作的时候，其实分为两种基本操作的i o操作。

一个叫做听好了，随机，io还有一个东西，还有东西叫做顺序io，这个随机io和顺序啊到底代表什么意思啊，啊什么叫顺序，什么叫随机，比如说我有一个非常庞大的文件，是文件里面有11条记录。

现在我要去里面更新某一条记录，是不是相当于我在这些文件的某一行或某一个，位置里面进行修改，那此时我需要干嘛，我需要想找到这个位置，我才能够去写，光寻找这个过程就会浪费很多的时间哦，这东西叫什么叫随机。

l还有另外一种叫什么叫顺序l，什么叫顺序l，我直接不管你当前文件里面，我存储了多少数据了，我所有新增的数据都直接往后面进行啊，p的操作啊，碰到什么意思，什么叫分的追加吧，要是我直接往里面追加。

和我在中间某一个位置里面进行插入，你觉得哪个效率高，哪个效率低，那个那个b肯定是按p的高嘛，是不是这个意思好，可以这样看得到顺序的，它的效率是比我们随机要快很多的，之前也看过一个帖子。

帖子里面是这样描述的，revlog redo log，我觉得这个描述也非常准，非常准确啊，我给大家说一下，举个例子啊，vlog它相当于干了一件什么事情，举例来说明，听好了，假设啊你干了10年程序员。

到30岁之后，存点积蓄，有个一两百万是吧，一两百万之后感觉不想在北京混了，回老家了，回老家之后你也不知道干别的，不知道干啥，在你们村里面开了一个饭店，开饭店之后你要考虑一件事情。

村里的人呢都是左邻右舍好，或者说都是亲朋好友，这时候一般人来吃饭，他其实是不会干嘛，直接结账的，他一般会赊账，那3万的话，就意味着，你自己一定要有一个非常非常厚的账本。

账本里面一定记录了非常非常多的一些数据，当某一个人过来赊账，或者说比如说吃完饭了，他说哎小二来给我记一下账啊，我月月底的时候一块截给你，你如果去当前这个非常厚的账本里面，你去找到对应的这个人。

在进行对应的数据修改的话，你告诉我效率低还是高一汉高，肯定很低吧，因为你要找嘛，我说了很透的账本，很多很多肯定是非常低的对吧，那这个时候大家想，如果你是饭店里的生意比较惨淡。

一天可能就两个人来吃饭也没关系，我们玩转嘛，时间是来得及的，假设在中午或者晚上的时候，客流量非常大，来吃饭的人非常多，记账的人也非常非常多，这个时候你去账本里面找，你觉得还来得及吗，肯定来不及了。

一堆人等着排队买单，你肯定是来不及的，那这个时候怎么办，你能不能在你在前台上面，或者在你的柜台上面，你挂一个比较小的黑板，黑板是干什么意义的，当一个人需要来赊账的时候，你就让他赊市场所。

你并不是去账本里面进行相关的数据修改，而是把当前这个人的信息你进入到黑板里面，来一个人记录一条，来一个人记录一条，来一个人记录条，一直往黑板里面进行追加，当中午的客流量高峰过去了，你比较空闲了。

闲了没事干了，能不能再慢慢的把当前这个黑板上面的数据，再重新写到你自己的账本里面去，能不能可以吧，你觉得往黑板写和去账本里面找哪个效率高，哪个效率低，是不是肯定要往上面来写，效率高一点，明白意思吧。

所以relog就相当于做了这么这么做这么一件事，当我有数据来了之后，我先写到redo log里面去啊，哪怕我账本里面数据没有更新也没关系，将来有时间了，我把我revlog里面。

或者把黑板里面的数据慢慢进行一个誊写，而不需要花费大量的时间，去账本里面找具体的数据来进行数据的更新，这是我们revlog存在的一个意义和价值，来这个redo log听明白，同学给老师扣一，能听懂吗。

胡巴没听懂没听懂，说哪个没听懂，对呀，这是它存在的意义和价值，一定要把这个逻辑关系搞清楚了，一定要搞清楚，这点很重要很重要，因为在行进行实现的时候，里面有个东西叫clash safe。

它就是用来进行数据的一个存储的，对不对，就是为了解决我们class safe这样一个问题的哇，实时性咋办，他不需要什么实质性，还是那句话，我们为了房子是什么事情，如果你能找得过来，你当然是找了。

如果你找不过来怎么办，听到这个问题啊，如果你找不找得过来，没问题，你可以找，就这意思啊，你往磁盘里面写的时候，如果你能写进去，没关系，你就往里边写，如果你写不进去，突然断电宕机了，你怎么办。

你黑板在你的数据是不会进行丢失的对吗，是不定式的，并不是说我写到redo log里面去之后，我就不往我的账本里面写了，我依然往我的账本里面写，或者我依然进行数据的一个同步，只不过我是为了保证我中间。

这个过程出现问题之后，我能够进行数据恢复的，是这意思，明白了吗，哇放大说redo log会整理数据吗，它不会整理数据，redo log它有一个东西叫什么叫循环写，比如说vlog是什么。

是一个固定空间的文件，固定空间的文件，它固定空间，这意味着我一直往后面进行追加，假如说我追加完成了，这下完成了满了满了怎么办，会把我之前的数据给干掉，干掉之后我依然进行循环写，那这时候就不要问了老师。

如果我的relog我没写成功怎么办，如果relog是不是，如果你的redo log也没写成功，你实际的数据文件也没写成功，那数据丢了就真的丢了，就会产生数据丢失的问题，明白了吗，就产生数据丢失的问题。

这也是没办法的是吧，任何数据库，你不可能严格意义上，从任何一个维度解决他数据丢失的问题，是不可能的，所以他只是有这样的一种机制，明白吗啊那这时候有同学问老师，你刚刚提到了redo log和blog。

他们一个位于server层，一个位于的是印度db存储引擎层，他们两个位于层次不一样了，那我在记录了redo log之后，我的blog里面还是否会进行记录呢，挺好啊，如果我记住了redo log。

我的blog里面是否还会记录数据，会不会，会吗，会的会的，也就是说你的blog和你的redo log边都会记录数据，如果都会进入数据的话，那么会有什么问题吗，啊干饭魂，听好了，会员啊。

blog和redo log里面都会同时记录数据，当你同时记录数据之后，会有一个问题，什么问题，我是先写re redo log，还是先写blog，先说好，听到的和redo log都会同时记录数据。

好那么他们记录的顺序是什么样的，你告诉我，就是说我到底先写谁后写谁啊，现在blog啊，现在人都log，这个问题记住了，它是一个坑，不管你先写锐度还是写病都有问题，都有问题。

所以在这里面会涉及到另外一个问题点，在面试中问的也比较多，什么东西呢，这二两阶段提交这东西啊，不是分布式事物里面那个2000的提交，它就是2000的提交，比如说blog和成都log。

要保证他们两阶段提交这件事情，其实一个另一个没有写吗，注意了，你两个日志数据里面要不然都写，要不然都不写，如果说一个写了一个没写，你要判断一下它到底能否生效，或者你的数据到底是否最终是一致的。

这点很重要啊，所以这是刚刚我在ppt里面列的第二个问题，什么第三个问题说什么是二阶段提交，如何保证当机时数据的一致性。

我刚刚说过了，redo log，它是为了记录或者为了阻止，反而是safe的存在，你说我如果在中间的过程中断电了怎么办，我可以根据我们的工作log来进行数据的恢复，对吧，冰老师干嘛的。

它是为了进行主动复制或者进行数据恢复的，还有数据恢复的功能，他两个在进行操作的时候，两个日志会同时写，就意味着我在进行恢复的时候，要根据两个日志来判断，那这里面就会存在一个问题，我到底先写谁后写谁。

欢迎再打一张图给大家看一下啊，之前我讲过这个东西，来给我看一下，来看这张图，这是之前我在讲vip课的时候，给大家画一张图啊，大家看一下，比如说当我在进行数据更新的时候，它是包含这样一个更新流程的。

第一步我要先获取数据，获取数据的时候，要判断一下当前数据是否在内存中，如果没有的话，我需要把磁盘里面的数据加载到内存里面，然后我要去修改我们的数据，同时要写入新的数据，写写程序的时候一定是先写内存。

写完内存之后，我才会往磁盘里面投放在这里面，我在写这两个日志文件的时候，分为了三个步骤，就下面这三个步骤会变得很重要，第一个步骤他怎么做的，叫先写redo log，处于prepare状态。

然后再写blog，然后当你提交事务的时候，我再把我们刚刚的图片状态置为commit状态，所以这时候你就要考虑清楚一件事，他为什么要进行这样的设计，或者说这样的设计它到底有什么样的好处，他保证了什么事。

其实你可以做一个思考，其实你可以做一个思考，什么思考。

系列 6：P89：MySQL的redolog、undolog、binlog分别有什么作用？ - 马士兵学堂 - BV1RY4y1Q7DL

刚说的东西，假设两个日志啊，我明确了都要记住，我如果先写redo log进行，然后再写blog对吧，建议大家写写他这样两个方式，如果再这样写的话，这里面会有一个问题，同学们听好了，什么问题。

如果我写完redo log之后，突然啊写完do log还没来得及写vlog的时候，我突然断电了，这时候会发生什么情况，解压，当写完redo log没有写完blog的时候，会有什么情况发生。

你觉得会有什么情况发生，注意啊，我的revlog里面写完了，写完之后，我一定会把它一写到我们磁盘里面，就算我在一写磁盘的时候突然断电了，我的road log里面只要有数据或只要有对应的记录。

那么我是可以根据redo log来进行重启的，但是你要考虑一件事，你写完的redo log，你的blog里面是不记录对应信息的，那这个时候假设你有两台机器，a的操作，a机器和a服务a数据库是吧。

然后b数据库，是通过什么blog来进行数据同步的，此时你考虑清楚了，当他写完了，他没写完，你的b数据库在同步数据的时候，会不会代表这一条数据会反而不会，对位，不会如果不会的话，就会出现一种情况。

什么情况，你的a数据库里面已经做完了这条更新操作，但是你把blog同步到b机器的时候，你的b机器里面并没有这个操作，你告诉我你ab两个机器里面数据还一致吗，一致位置了，不一致了吧，那不一致。

你的主从同步不就失败了吗，不就存在对应的一个问题了吗，是不是这意思啊，所以它是不可以的，不能先写日志log再写blog，那其实反过来道理也是一样的，如果我先写了blog，然后后面我再写我的logo。

这种情况一样的吧，什么叫一样的，想好了，我先写完blog，然后没有写完redo log，这时候是什么情况，你blog里面记录了对应数据，blog记录了对应的数据，是b机器，我b服务器b已经将数据同步。

但是redo都没有，此时如果出现了凡是safe，或者说如果出现了断电，出现断电之后，你告诉我，你能够根据blog把数据给恢复回去吗，这个问题啊，你当你断电之后，你能够把你根据blog把数据给恢复回去吗。

能不能，不能吧，你连数据嘛肯定会受不了，他恢复不了，意味着a g g是a的，数据是有问题的，少一条，但是你的blog已经同步到b机器里面了，b机器里面是不是会多一条记录或多一个操作。

此时你的ab两个里面的数据还一致吗，一致位置，这又不一致了吗，是不是这意思啊，所以不管你先写日blog还是先写blog，它都是有问题的啊，所以这种机制有问题，因此才诞生了，我刚刚给大家展示的东西。

什么呢，叫两阶段提交，什么意思，我先写redo log，只不过此时我的redo log，它处于的是叫prepare这个状态，然后我再写blog，当我把blog写完之后，我事务提交了。

我再把我们的redo log置为commit状态，那在整个这个执行过程中，依然在任何步骤的时候，都有可能会出现断电情况，比如说这儿如果断电了，可以了，听好了，这如果断电了，当这断电之后。

我需要做什么判断它的运行机制是这样的，听好了，如果在此处出现断电了，那我在恢复的时候，我会先检测我的revlog，我只do log里面状态，我简称log之后发现当前的relog属于普片状态。

当它处于普片状态之后，我再去blog里面找对应的数据，比如blog里面是否同步记录了与之相同的操作，如果有，如果有，那么此时把刚刚review里的prepare状态，改成commit状态，如果没有的话。

干什么事，把刚刚redo log里面的prefer，这条日志直接置为失效，我直接认为无效数据，这样的话，我的real log和我们的blog能不能保持保持数据一致，可以吗，这是刚刚这个断电的过程。

那样吧，在下面这个步骤里面，它也很不断电，当它断片之后一样逻辑，我先找一个log，我一找诶，发现一个log里面有图片状态的数据，这时候我在找blog里面找，我一找blog。

blog里面是不是有对应的记录，有对应记录怎么办，把刚刚的prepare状态的数据改成commit状态，这样的话两条数据记录都保持了完全一致，所以不管你依靠哪个数据来进行，数据恢复的时候。

他都不会出现数据的不一致性的问题，这东西就称之为叫两阶段提交，这东西p班同学给老师扣一，能听懂吗，所以啊这东西在面试中也会经常被问到，你要给面试官把这东西给讲清楚，它对应它对应的东西。

老师redo和blog pupa团队的方式能替换吗，不可以，因为blog他没有prepare这样一个状态，blog没有prepare这样一个状态，没有prepare一个状态好吧。

所以他不可以互换位置好了，这个两阶段提交这东西我做了这么多，所以当提到这个logo的时候，你要把blog整合起来，了解一下它的两阶段提交就可以了，vlog在sl单链中还有吗，它是持久化到磁盘的。

怎么会没有呢，它是持久化到磁盘的，所以一定是有的，注意断电之后数据丢失的话，只会把内存里面的数据也丢失掉，你磁盘里面的数据是不会发生丢失的，所以不用担心这件事儿，好吧好了，刚刚我解释了原子性。

通过undo log来实现隔离性，通过mv c c加锁来实现持久性，通过relog来实现，但是我唯独没有提一个东西，就是我们的一致性，这里面我要强调一件事，同学们听好了，这里面我们写一句话，记住了。

为什么一致性没有写具体的实现方式，这边有很重要的一句话，一致性是我们根本的追求，一致性是实现，方式是由其他三个特点来保证的，明白意思，也就是说它没有什么具体的实现点，其他三个特征共同保证了我们的一致性。

问题来这儿能听懂，同学扣一能听懂吗，赶快记一点好不好，当这些问题都聊完了之后，下面我们进入到一个环节，什么环节，我们就要讲一下我们的mv c c这玩意儿啊，重点聊一下m c的这玩意儿。

m c c坦白说还是有那么一丢丢复杂的，好同学在了解m c c的时候，其实怎么说理解的都有多少有点有失偏颇，那今天我们重点把nv acc对应的实现机制，给大家讲清楚啊。

m v c这玩意儿m c刚刚不是多多，我都说过了啊，现在了解奥特fm v c c刚刚解释过了啊，什么叫mvc c，它的翻译是什么线程锁吗，不是跟县城所没有关门的关系，它叫做什么叫多版本并发啊。

这它对应的一个全称啊，既然涉及到并发了，那这里面会有一个问题，同学们数据库里面的并发大概分几种情况，听好了，数据库里面的并发大概分几种情况，这是什么，有多个事物在进行同时操作的时候，有几种情况。

三种哪三种啊，第一种叫读读是吧，第二种叫读写好，第三种叫写写，这都是我们产生这种并发读取的时候，要产生的一些操作，比如说同时读都是读还是都是写，还是有读有写啊，这样的一个这样三种情况。

那这样的情况我们要解决问题什么问题，这三种情况在进行并发操作的时候，它会有对应的问题吗，比如第一个读读会有数据安全问题吗，他需要进行并发控制吗，需不需要不需要不存在任何问题，也不需要并发控制。

因为你在进行数据读取的时候，它并没有实际的改变我们的数据值吧，所以不需要了是吧，那第二个读写会有问题吗，有吧有数据安全问题，幻读不可重复读啊，都是这种各种机制里面它要存在的一个问题啊，这东西还有第三个。

写写写写会有问题吗，有没有有有数据安全问题啊，可能存在丢失而叫更新丢失问题，就说是存在这些对应的一些情况的，当存在这些对应情况之后，我们总要考虑解决方案，对不对，在考虑解决方案的时候。

你就想什么解决方案，最普通的方式我可以通过锁的机制来实现吧，比如说加速锁是可以解决这个问题的，但是我在使用锁的时候，明显有一个问题是什么，效率低吧，是不是效率低啊，那如果我想保证我的效率足够高。

我应该怎么办，怎么做，换图的问题，一会来解释，别着急好吧，锁它的效率一定是很低的，但是这个时候你可以联想一下，你之前在java那种并发编程的时候，java里面在进行并发编程的时候。

你除了可以加那种cd带子这样的一些锁之外，还可以干什么事，好了，话费提成说的一个东西叫c a s cs叫什么，叫compare and sweep，其实我们的mv cc类似于这样的机制。

就是说他不需要去进行加锁，当然在mc里面它并不是进行对比的，只不过它减少了我们所对应的一些存在的问题，就是说它是用来解决加锁这样一个问题的，明白意思吧，跟cs不一样，但类似的机制是一样的。

类似的机制是一样的，那到底它怎么实现呢，实现的方式非常简单，刚刚有些同学提到了格林级别，隔离级别的东西，我希望同学们能够一会儿再聊，我们一会再聊隔离级别相关的问题，先扔一边。

等需要聊的时候再来隔离一边不需要聊，先不聊它好，在讲mv c c对应的实现原理之前，我需要同学们先具备两个最基础的概念，第一个概念叫什么叫当前读，第二个概念叫快照读，比如说你必须要把这两个名词搞清楚。

什么叫当前读对了是啥意思啊，是不是当前读记住了，所谓的当前读，表达的意思是说在进行数据读取的时候，读取的都是最新的版本数据，记住啊，这最新的版本数据啊，而且在读取的时候，还要保证其他并发事务不能够修改。

我们当前的这些记录，会对我们读取的机构进行加锁操作，这叫当前读，除了当前组之外，还有第二个概念，叫什么叫快照读，那什么叫快照读啊，一个人读最新的数据，那快要读读啥，读什么，对读取的是历史版本的数据啊。

是有可能读取到对应的历史版本数据的，好吧，那这里面会有一个问题，老师什么样的操作会触发当前读，什么样的操作会触发快照读呢，注意了，这样说明一下，我们当前读触发操作有以下几个，写一下，第一个。

比如说sl lock in shell model，什么意思，加读锁吧，比如说select for update加解锁吧，比如说我们执行的update操作对吧，d类的操作对吧，包括音色的操作。

像这些操作在进行操作的时候，都都都基本上都是当前读光线图，它变成快照读，那什么时候会触发我们的快照读呢，也非常简单，它有且仅有一个什么东西呢，叫select，注意。

最普通的select有可能触发的是我们的快到数据，而不是我们最新的数据，有人有这样的感受吗，就你读到的数据是旧的数据，有人这样的感受吗，你之前在操作数据库的时候，有读到过旧的数据吗，有没有。

想想回忆一下有没有，如果你说没有，那么我就要给大家举例子了，好如果你说没有调举例子了，橘子来看一下它到底是什么样的一个情况。

已经算相，但还是旧的，是这样的情况，来看好这个例子啊。

下面我来举例子说明了还是一样，我们不可能光讲理论知识，还是要带点实操的好吧，let's go，boa杠p，我来演示一个场景。

你来告诉我对应的关掉了，我来演示一个场景。

你来告诉我，对应的答案和对应的效果分别是什么，认为很重要好吧。

来了两个窗口同时进来。

mexico杠u root杠p123456 。

进来进来之后，我们use demo这个数据库，然后呢在里面我去创建一张表，grade table ut 18连接方案。

90的id int primark。

内部卧槽。

这个sql已经足够简单吧，我觉得这个sql语句有人看不懂吗。

没有吧，足够简单了啊，然后insert into t18 values。

写这个值一根号一。

三好了，往里面插入了三条，结果三大将from t18 没问题吧。

这边也是一样的，select。

七from 718。

两边数据一样不一样，告诉我两边数据是否一致，一样吧，没有任何的一个区别好吧，下面我要做一些最基本的操作了，第一个操作是干嘛，我们为了模拟事物的一个执行过程，或者执行情况。

我需要把自动提交事务的按钮给关闭掉，所以叫set auto commit等于零走。

然后commit一下，我现在把事务自动提交给关闭掉了，当我关闭掉之后，我为了模拟两个事物，a b是两两个，这是两个窗口，一个a一个b，那么我能不能手动的去开启我们的事物啊，我能主动开启事务吗，可以吧。

两种方式，第一种start的反击是第二个begin。

我依然执行begin操作，当我开启事务之后，我的问题来了，同学们，现在我开启了一个新的事物，两边数据是否一致，你这个意思你知道吧，这个没啥问题啊，肯定是一致的，如果一致的话，我们就要考虑一件事。

我在第二个窗口里面，我做一个up不对的操作，比如update t18 set name等于连，然后结束，我现在更新完成之后，两边的数据是否还一致，现在一样吗，有人会说老师应该不一样吧，为什么。

因为你从右边窗口里面是我没提交，我现在把它给提交掉，我的问题听好了，问题来了，当我这边提交完成之后，我在这边进行数据的查询，我查询到的是零还是123，告诉我零还是123，来各抒己见好吧，翻翻你们的看法。

好了，有说连的，有说123的，但是我看到的情况是123的，情况应该是偏多的，但是实际查询起来你的结果它是连，并不是123，还有刘娜说，老师要看隔离级别，这块跟隔离级跟隔离级别没有半毛钱关系。

没有半毛钱关系，我先问一下我们当前的隔离级别，mysql默认的隔离级别是什么，什么查一下嘛，flat at concision，什么repeatable read，因为我从来没有改变过合理的级别。

所以别的级别是一模一样的。

没有任何一个区别，这样你首先要记住了，好吧，先把这个记住来，现在我把两边的事物全部提交掉，commit我在演示另外一种情况，看好了另外一种情况，什么情况，我现在都commit掉了。

我同时再开启我们的事物，开启之后我看一下我们的数据，三星和t18 ，现在数一样吗，现数是一样的一样吧，一模一样，隔离级别我也没动过，我依然在第二个窗口里面，我做一个更新操作，update t18 。

set name等于合合的走，我一样在提交，我现在读取到的结果是123还是连，什么，连是吧，失联了失联唉，为什么，为什么在刚刚这里面的时候，我就可以读到最新的数据，为什么在这的时候我就读不到最新数据了。

听好在我第一次演示的时候，它是可以读到最新的数据的，修改之后的数据，但在第二次的时候。

我就读取不到修改之后的数据了，你在这边进行查询的话，他已经改了，他的数据明显就不一致了，小福利说数据库bug，怎么可能数据库bug。

这里面其实涉及到的就是当前读和快照，读的问题，跟缓存没有半毛钱关系，这也是mv c c它存在的一个重要的原理，重要的点好吧对，区分点是什么，是我在读取之前，我进行了一次查询操作。

为什么我执行一次查询操作之后，就能够达到当前的事物，但是达达当前实现效果了，原因是什么，这个原因在于mv c c。

在下面我要详细的去讲一下，mv c c具体的实现机制。

你准备好了吗，想搞明白刚刚为什么会出现这种情况吗。

为什么我多执行了一次查询操作之后，两次结果就不一样了，来想知道的扣一请结一下自己好吧。

这时候核心点和重点来了，来先说m c c m c c在进行底层实现的时候。

它总共包含了三部分操作，第一部分叫什么叫隐藏字段，什么叫永恒之断，也就是说，在我们的m v c c进行实际操作的时候，他其实除了我们看到的字段之外，会包含一些包含一些我们看不到的字段，看完自然有几个呢。

有很多这块我重点说三个，第一个什么叫db下划线，t r x下划线a b这是第一个隐藏字段，它要表述的我看表示什么意思呢，其实非常简单啊，表示什么叫自创建这条记录啊，或者最后一次修改该记录的事务id。

这是第一个字段要表示的意思，还有第二个隐藏字段叫什么叫db下划线，roll下划线p t2 ，他表示什么意思，它叫做，做完了这个回滚指针好吧，指向数据的上一个版本，上一版本都一样的。

还包含第三个字段叫db下划线，我昨天说过的东西叫roid吗，什么意思啊。

系列 6：P9：解决JVM运行过程中出现的各种问题（OOM） - 马士兵学堂 - BV1RY4y1Q7DL

你说cpu暴增怎么办，你现在应该回答出来了，然后cpu暴增的两种情况，第一种是业务线程，第二种是gc线程，你发现gc线程是由于我的gc频繁，或者是他时间特别长，老是回收不掉你。

你读日志发现他回收不掉对吧，回收不掉，那这时候怎么办呢，这时候需要你去观察，到底是不是有哪个哪个对象在产生泄漏，怎么观察呀，gmf命令，好怎么观察呀，hip on dump on a。

hip dump on out of memory error，用这个参数指定，然后他们会产生堆转储文件，dp文件，怎么对这个弹幕文件进行分析，你可以用m a t，可以用jvo vm。

可以用g console，可以用jjj had命令等等都可以，最后你就查出来，到底是哪些个对象在占用我的内存，然后去找对应的业务逻辑搞定，这个过程，不知道大家听清楚没有，有没有谁对这块有疑问的。

我今天重点给大家讲的是assets，一会再教大家assets一些比较牛逼的命令，懂了吧，其实在我看来啊，呃面试里头相对比较难一些的内容是多线程，jvm呢是一层窗户纸，你你不知道你你你你自己不知道。

答不出来，多数情况下是没有人帮你捅破这层窗户纸啊，老师就是帮你捅破的那个人，再实操一遍，我就不感觉要要求重复要求的理直气壮啊，你十几分钟说的还不够清楚啊，这么简单的东西，对啊。

你自己要动手才可以啊啊我说的就是我自己哦，原来这样啊，你再实操好多遍，随便你，你才能捅破啊，好了，可以继续了吧，没问题了吧，哎起码你再遇上面试官说，om问你怎么定位，你应该就可以了。

asset开文档就可以了，assets线上能否使用，必须在线上使用，当然可以，好看，这里死锁问题还没讲，死锁问题，我刚才不是讲了吗，thrgb，一个命令就搞定了，你还要怎么讲，看这里啊，ctrl c。

我们重新再把这个环境搭起来，继续来聊我们的others，我觉得，作为阿粉丝来讲，呃，他的比较牛逼的点，不是说能替代你原来的这些个命令，如果只是这样的话，那阿萨就一般般了，我觉得阿特比较牛逼的点在于。

这教大家一个比较酷的others的这样的一个玩法。

看这里help。

作为阿瑟来说呢，你看这个命令这个命令叫什么，叫jj a d。

它叫the compel class，the compile class，打到这里啊，the compel class dd，这是什么意思呢，比如我敲这个命令的时候。

我们把我们那个类名给复制一下，我的类名。

复制jd是什么意思。

粘贴回车，诶你会看到他干了一件事，发现了吗，干了件啥事儿，他把我这个类的源代码诶给我反编译出来了，发现了没有，很便宜，有同学可能就会说了，老师这破玩意有啥用啊，我自己都有源代码，我开发的人。

我当然就有源代码了，你在在线给我翻译一下，又是什么意思，它有它有用吗，来认为有用的同学给老师扣一，认为没用的给老师扣二，是没有用的，对我看有不少扣二了，哎为什么有用啊，为什么没用啊，同学们。

同学们听我说，凡是q2 的一定是在小p公司呆着的，或者只做过小p项目的，作为大项目的人，一定是扣一的，为什么它有什么用呢，版本号，代理类好，同学们听我说，有的时候你会生成一些代理类。

它生成这个代理类的代码，对不对啊，jd翻译过来一读就你就知道了，他对不对，这是一种，还有一种是什么版本号，比如说做一个超级大的项目，下面是有一堆的小组，每个小组里面有好多的成员在里面。

写各种各样的不同版本的代码，然后最后集成到一起，我就想问你，你写了一个基础代码，你的基础代码可能会被利用，被c用，被利用被利用好，他们在用的过程中，你的版本还在不断更迭，谁能保证他帮你发布上去的。

这个版本就是所有人都能共用的，并且不会产生问题的，谁能保证他突然出了一些莫名其妙的问题，哥们儿，你第一件事应该干的，是不是得确定一下，你们给我上传的这个是不是我想要的，那个最新最稳定的版本。

来理解这一点，同学给老师扣一啊，按红说继续继续，别解释这里了，我偏不，你听懂了，你就不考虑别人的感受吗，需要老师解释，这里的给老师扣一，我就不信没有，对不对，哈哈暗黄跟那使劲扣二，然而被我选择无视啊。

看这里啊，除了版本号，还有代理类啊，还有代理类啊，你这个代理类生成的对还是不对，jd直接可以给你看出来，好了，同学们，在线啊，就直接看出来对啊，3/4不是说了吗，他们一直出现测试环境，不是最新代码。

对这个很有可能的，非常有可能，代理类听不懂啊，代理类听不懂，你能让我说啥，水平有点弯好看，这里，凡夫俗子对，经常出来部署了一晚，结果版本不对没错，你说它没有用吗，当然有用，但是他最牛逼的点还不在于这。

下面我给大家演示另外一个小程序，来看一眼。

嗯要理解这个小例子呢。

需要大家读一下这两这两个小程序代码啊，这两小时代码比较简单，一个叫mt一点java来读一下小程序，小程序超级简单啊，稍微读一下这程序呢就是一个main方法，留在店面方法里不停的cdinner read。

当我读到一个字符来的时候，我就new一个tt调用它的m方法，当然既然这样的话，你你是不是得理解一下tt这个代码呢，这个代码也也也超级简单，这个代码是啥，t t里面有一个方法叫m。

在这个m的方法里面打印出一个一。

好然后在t里面不停的循环，我回一下车，他就掉一个m，打印一个一。

就这么一个小程序，如果你要执行他的话，那就java t回车，当我一回车打一个一单位，一回车等于一，当回车打一回车打一好，就这么简单，一下程序，不知道大家看懂了没有，那现在啊，我假设这个小程序是。

我们扔到生产环境里头上去了，生产环境已经被我扔上去了，每过来一个请求，我会给他打印一个反馈，是一个一，但是当我这个我发现我这个代码扔上去之后，我才想起来这里边有个小bug，这个小bug是什么呢。

我应该给他反馈一个二的，但是我给他反馈了一个一，我再说一下这个场景，再说一下这场景再说一遍，现在假设你已经把这个t t，部署到你的生长环境了，部署上去之后，你才发现我本来应该给他打印二反馈二。

但是我很不幸的是，我反馈了一个一同学们，现在你怎么办，有同学可能就会说，老师这事还不简单，停掉服气，代码下载下来修改一遍，重新上传搞定了，来认为这么改的同学给老师扣一，认为认为这么改，sorry。

认为这么改有问题的，给老师扣一，认为应该这么改的，给老师扣二，好我就想问你现在是一个电商系统，你上去了之后有一个产品，你那个有一个产品里边那个那个那个，我那个那个数字啊，打错了一个小数点。

你本来应该卖31块四的，结果你不小心买了，卖成了333块一毛四，但是你记住你们家的电商系统，可不只卖你一个产品啊，大哥，那你不是不只卖你一个产品，如果你要停掉的话，你要把整个服务器给停掉，各位小伙伴们。

你们想象一下后果后果是啥，就是干脆你们你们你们所有人都停掉，重新服务器再部署一遍，再启动好，所有同学，你们想象一下，作为一个大公司，一个超级的大型企业，你们知道一个线上系统从线下打包部署测试。

到线上开始运行要花多长时间吗，短的几分钟，长的一周，为什么，因为它有内部的流程，你要发布新版本，它是有内部流程的，要经过层层审批的，所以这时候怎么办，看这里passes可以帮你这么办。

nice是怎么办呢，nice，现在我们j d t t呃，你会发现他这时候打印的是个一，对不对啊，说我刚才也不停，但是我想把它修改过来，我怎么办呢，我这样来办，看这里v tt一点java，我把这个一。

给他改成二，直接我在本地做好修改，我修改之后当然要编辑一下，加个cp给点加了，然后在others里干这一件事，redefine，你得重新定义，如果你听过老师讲的class loader。

你应该知道那个class loader里面都有这么一个名字，叫define，define class，对吧，i really fine root gt class，不是好，这时候啊你会发现我程序没停。

但是在我一敲回车，如果几十个案例的上级都怎么，每个都都都都讲一遍，没错啊，几十个案例，你一个脚本不就全改完了吗，这是老师在线改，废话，你要是说你一个程序上去有300个字全写错了，你一个一个在线改。

那你这叫不熟事故好吗，你这你这是事故临时性的，临时性的，有那么一两个可能会产生问题的，稍微大点的公司哪会这样搞大哥，小点的公司才不会是大点的公司，才会这样搞石头，你是不是哪里理解错了。

我说的还不够明确是吗，如果很多，当然了，这是救急办法啊，同学们，这是救急用的服务器很多怎么办，写脚本全部一键替换，door能用吗，当然可以啊，多少为什么不能用docker更简单。

其实docker只要把docker干掉，然后重新起一个就可以了，小公司你怕啥，小公司你直接停了，没关系，修改过了之后再重新部署呗，所以你们很多的理解都是有问题啊，大公司我觉得还是k8 s直接回滚。

你除非有这个版本，万一你没有这个版本，你发布的第一个版本就出现了这个问题，你怎么回滚，你告诉我，你回滚到上一个大版本是吗，去年的双11别扯不可能，docker咋搞，docker。

你就重新把docker整个干掉，重新起一个新的不就完了，我们客户改东西流程两周，这个很正常，我告诉你，有的银行两周都算快的，好吧好吧好吧，你们认为他不牛就不牛吧啊你们认为都是对的，不跟你抬这杠了。

你赢了还不行啊。

这是今天我要讲给大家的主要的内容，就讲到这吧，嗯因为东西太多了，刚才有同学不是说嘛，说老师这个日志怎么去读啊，日志是这么回事，呃不同的垃圾回收器啊，它的日志格式是不一样的，另外比较还比较牛叉的是。

不同的垃圾回收器，在不同版本上的日志也是不一样的，比如同事几万在1。7的日志，1。8的日志，1。9的日志就全是不一样的，所以对你来说呃读日志这件事呢，一时半会你肯定是拿不下的，比如说那个p的详细的日志。

基本上他有这么多条，哈哈那个你像那个呃，最终down不出来，到最后的那个hip堆的信息有这么多条，每一个到底什么意思，当然还有一些呃g one的日志，java日志呢就更更复杂一些。

因为java你首先要明白它的一些运行的这个阶段，就混合回收和嗯，嗯这种concurrent就是并并发标记啊，这两个这两个过程，然后你才能读清楚他这个日志到底是什么意思。

呃所以读书志这块呢肯定没有办法跟你聊，聊的特别特别细啊，这个没有办法，基本上今天时间肯定是不够的，但是呢我觉得老师这个文档比较牛逼的地方，在于有几个东西特别给力，第一个呢是有一个案例的汇总。

案例汇总是什么意思，呃，我我不是讲过吗，你要敢在你的简历上说我有jvm优化经验，同学们，面试官一定会问你，你们实际当中什么情况下遇到了你，有你才有我这样的经验，对不对，他一定会问你吗。

所以我给了你大概将近20个案例，18个，在这18个案例里，你挑一个用在你的简历上就可以了，贴心吗，但是我告诉你啊，你如果显示你jvm超级牛逼的水平，应该在这，我告诉你就是jim进进程静悄悄的退出。

你该怎么办，这里面会牵扯到linux内核的一些东西，这种的你跟面试官讲清楚好吧，你就是最牛逼的了，当然还有一种是排插直接内存啊，还有它直接内存，就是那个大家知道作为这这这版本内存来说，有有占有堆。

有这个meat space，有有method area，还有一个呢就直接内存叫direct memory，直接内存怎么来着，唉这个比较好，你要你要跟面试官聊，这个就不要有事了，好吧。

呃所以现在有问jvm的问题的，像这种cpu暴增啊，om啊，死锁呀，就这类的问题都都算都算是比较简单的，我直接告诉你，比较难的是这个就是jvm进程静悄悄的退出了，怎么办，你得分析他到底是由什么情况导致的。

所以你第一步要先去干嘛，先去看那个dump文件有没有，如果dump文件都没有，那说明他静悄悄被被别人干掉的，jm自身干掉的，读他日志去，如果不是这个m自身干掉，会被谁干掉呢。

会被linux o m killer那个进程也干掉，他也有日志在哪里，或者是如果这个都没有进一步排查，是硬件或者内存的问题，以前曾经有一个小伙伴我告诉你啊，实际上的案例。

以前能有些小伙伴他们家的进程总是一不小心，jvm内存就不够了，jvm内存就不够了，后来发现中木马了，知道吗，被那个挖矿的挖矿挖矿脚本给给给给给占了，ok把内存全给占了好吧，这个也是很难定位的啊。

很难定位，因为这单本身没问题，但是他老时不时的就被挤爆了，时不时被挤爆了，这个发生过居然是中木马了，牛吧，当然如果上面这四个问题，你发现都不对，都找不着，还有一个万能的解决方案，找我好吧，呃这个。

整个的这个这个嗯，内容呢是其实是我挑了一部分啊，挑了我们整体课程就是jvm呃，调优的这个课程当中的一部分，呃这课呢我你说我想透彻的理解jvm，大概讲了20多个小时，第二个版本可能还要增加一些。

原因是呃这版本的内容呢想讲的东西太多了，越来越多嗯，比如直接内存到底怎么调，我会用案例给你讲清楚，比如说那个呃真正的，如果一个进程被静悄悄的干掉，这是什么情况，我会用案例给你讲清楚，呃，在。

真正的课程里头，我讲了那个从虚拟机的基本概念开始讲的到，讲到class文件结构，讲到内存的加载过程，讲到运行时的内存结构，像这个各种各样的stack program counter在哪里呃。

messada这个方法区是一个什么样的内容，其实这个方法区来说，有好同学可能不太理解这个方法，去跟那个呃permanent space和metadata它们的区别是什么，那听我说嗯。

permanent space，meta space都是方法区的，具体实现1。7叫permanent space，1。8以后叫meta space，这么回事，听懂了吧，文件的一句话给你给你说明白。

讲过这个m常用指令啊，那么给大家讲这些调优，这个是重点中的重点，就是每种具体参数应该怎么样去设置，场景来回收器，它的原理是什么，算法时，而这个jvm的课程呢，又是我们整体课程的一部分呃。

系列 6：P90：什么是二阶段提交，如何保证宕机时数据的一致性？ - 马士兵学堂 - BV1RY4y1Q7DL

好如果没有显示，直接说话就会多一个隐藏主线，起床下，比如说我们在创建完一张表之后，创建一张表之后，比如说我建张表里面有以下几个字段啊，看好了，比如说有id啊，先复制吧，比如说电脑里面有什么。

有name好吧，有edge有真的有这四个属性，除了这三也是三个属性，除了三个属性之外，在这一行的记录后面还会包含这三个字段，只不过这三个字段是人为看不到的，或者说你肉眼看不到的，不管你怎么查。

你都是查询不到的，实际数据就变成这样子，好的大家需要注意了，如果我插入一条记录之后，不就变成了内写个字，张张三，比如age 12真的慢，然后d b t r s i d表示什么意思来着，表示创建这条记录。

或者说最后一次修改该记录的id值，这里面有一个情况，我需要说明一下，在事务操作里面，在事务操作的时候，事务id的值是递增的，新增的，所以我们才刚开始的时候，假设他现在是新增的操作。

那么我这个值给它写成一，还有东西叫db rop t2 ，表示上一个历史版本的状态，那我现在是没有历史版本，所以这个值现在是，那如果有历史版本，你就指向历史版本，还有个dv o p t2 。

我这个表里面是没有主见的，所以这里面可以给一个值，如果有主见的话，它会写上我们对应默认的主键，它是有区别的，能明白这意思吗，好吧，来这个东西能看明白的同学给老师扣个一，能听懂吗。

就实际上你的数据还在存储的时候，除了这三个字段之外，还会包含三个隐藏字段，这是最开始的一个状态，最开始状态有一行记录，所表示的一个最基本的状态，这是第一部分叫隐藏字段，好吧，除了隐藏图断之外，第二部分。

所以呢我们之前说到这个东西，就是刚才说的叫on do log，啥意思，on load表示来着叫回滚日志吗，对不对，它里面记录是什么，记录表示数据的历史版本，是不是这意思，历史版本吗。

所以像刚刚那有一个db rop t2 ，它是不是会指向历史版本，那指向的历史版本在哪，就在我们的unlog里，那如果直接这么说的话，很多同学可能没有具象的一个感知或认知，我们来模拟一个数据。

插入一个场景来看一下到底什么效果，我来举个例子，比如说现在第一次来了一个11，请问一下，事物一好吧，插入一条记录，当我的事务一开始插入记录的时候，干什么事非常简单，不就是刚开始的数据的状态吗。

是不是只有一个东西，所以在最开始你进行数据插入的时候，它就是我们对应的最新结果，没有对应任何历史的数据，它就是最新的，来这东西能听明白的，扣一，问题吧，那现在我来了一些其他事，什么事物来了一个事务。

22，我要注意操作失误，二更新什么内蒙等于b4 ，如果我要更新内容等于李四的话，我是不是需要去改变我们对应数据结果值了，把它拿过来放到这块，我要改了，首先内部值改成李四，除了这个内幕值改成李四之外。

我还需要去改变什么东西，还要改别的吗，想想需不需要，哪些东西，这个字段也不要改啊，刚刚说了，d p p t r是这个tr c i d是啥意思来着，表示说我新增这条记录的事务id，或者说最后一次修改的事。

i的值了，我现在是不是事务201修改了，这是改成二对吧，改成二之后，db rop tr什么意思叫回归指针，我是不是指向上一个历史数据的版本状态，上一个版本在哪，不就这个记录吗，我把它拿下来放下来可以了。

放下来放完之后，这改一个地址叫0x123 ，我随便写个地址啊，这个地址是随便写的，无所谓，它就指向了当前的数据版本好，同时注意了，我要拿一个框，把这部分内容给框住，是最后，当我框住之后好吧。

下面这个框里面表示的东西是个啥，就是我们之前说的叫on do log，能听明白吗，这就是我们说的工log，它是不是存储了我们对应历史数据的版本状态，此时它是最新，结果那你告诉我这里面存的是啥。

什么东西历史结果吧，不存在，是历史记录吗，来这儿能听懂，同学表示扣一，明白吗。

好了，这是第二个，那同样的我们可以进行第三个事物来进行操作，我第三个事务也来了，干什么事儿叫事故三更新，edge等于21可以改吧。

那是不是一样道理，我只需要把这个结果挪下来，改变我的数据，把它改成21，他是不是要改变，只变成几了，表姐三嘛，他地址是不是要改0x比如说345随便写的，然后我要把下面这部分数据也拿过来放下来。

放下之后呢干一件事儿，这部分东西要往下挪。

为什么往下挪，因为现在你多了一个新的历史版本状态，这是他。

把它回到这个地方，这个箭头要指向它，向他，然后他指向他能看明白吗。

再说这个时候下面的它属于历史结果，这东西它属于最新结果。

来这个图能看懂的，图一，没问题吧，这是对应的状态。

因为最后我们其实可以得到一个结论，最终undo log里面存储的是什么东西，放多了的中会形成一个链表了啊，练手是最新的旧记录，好练为是最旧的旧记录，是不是这意思啊，练手链为有对应的具体数据，这是b块。

这时候有个问题，老师那on log里面不是会一直变大吗，你就想一个数据可能会无限增大吗，同学们，他可能一直膨胀下去吗，可能不可能，他可能一直无限涨下去吗，不可能吧，肯定不会的，肯定不会无限涨上去的啊。

如果不会无限涨上去的话，那怎么办，所以在这个里面它会有一个东西下去之后，你们自己去查，目前面试中还没人问到这个东西，有一个后台的线程叫破纸，线程会清除数据，清除，数据或者说清除没用的数据啊，这改成三啊。

会进入什么清除没用的数据。

清白意思吗，证明这个答案你们自己去查吧，我这边不讲了，因为目前还没还没有，面试官问道，mysql o r g e per。

有移动db是一个破折，什么意思，一诺这个并发机制开始为了更好支持并发，基于回归纳的一个方式，innotp只能删除记录这个记录标志来的，通过什么解决数据和这个undo log存档的问题。

需要引入或者机制来进行回收啊，炮主机的回收背景是如下所示。

下一周后详细了解一下，它也是完整的一个知识体系，明白意思吧，所以我们不提这样不提这样了，下来之后有需要的同学下一种自己聊。

ok这是第二部分，我们记录的on the dog，来这儿听，明白的同学扣一能听懂吗。

问题是第二部分，这东西还不是最主要的，最主要东西应该是第三部分组件。

第三部分是什么，有一个新的东西记住了，它叫啥呢，叫review，review这玩意怎么怎么翻译啊，或者怎么理解什么叫read view，你翻译过来叫什么叫读视图嘛对吧，但这里面有一个明确定义。

叫什么叫事物进行快照读，操作的时候好吧，是产生叫读视图，如果只是这么去理解的话。

会这么去看这个概念的话，很多同学依然是一脸懵逼，根本不知道咋回事，更不懂啥情况，其实非常好理解，在review里面它叫读视图，在当前的读视图里面，读视图里面包含什么信息，它包含的就是三个关键的字段。

你只需要把这三个字段搞清楚就完事了，好吧哪三字段呢，不论你说老师是453，不应该改不动吧，什么改不动，真要改啊，因为你是453更新嘛。

他肯定要改好吧，我先玩一下啊，要是六里面，它其实包含了包含了三个对应的结果吧，我们三个对应的字段，哪三个字段呢，第一个叫t r s下划线list代表什么意思呢，他表示的意思是这样的。

记住了表示review生存时刻，好当前系统活跃的事务id，注意啊，它是一个列表，它不是一个值，它是一个列表，然后db肉皮这个地方下面之后还有第二个字，叫什么叫up下划线，limit下划线，i b。

代表什么意思呢，也非常简单，代表意思是活跃，列表中是最小的事物ip值，除了这次到这，还有第三个字段叫low消限limit消线ip，这个表示什么意思，他表示系统，尚未分配，找下一个是我id的值。

来这三个字段能不能记住，不需要理解了吗，记住能不能记住，来，能记住的，给老师扣一，那么，这个小不点说老师为什么up是最小，露是下一个，没有啥，为啥他他就这么规定的，他就这么规定的，我没写错啊，我没写错。

他就这么规定的，我没办法好吧，这东西是需要你是需要是需要你掌握的诶，给点回忆，给点回应，大哥们能能记住不，我不要你理解啊，能不能记住就记住就完了好吧，其实这些东西都是死的，固定的概念，固定的概念好吧。

这东西都不是核心重要的点啊，重要点在什么地方，重点是当我在生成一个review的时候，他会把这些字段里面的值给进行一个填充，当填充完成之后，在下面这个环节里面会有一个东西叫什么，叫做可见性算法。

也就是说当我生成read view之后，会根据可定性算法生成的review，会根据可见性算法来判断是否，可以读取到对应的历史和对应的数据结果，如果你记不住，没关系，多听两遍，理解多点也没理解。

因为第一遍听我没办法要求你们都理解的，都理解到，但你把这东西给我记住就完了，那可见性算法是什么呢，它就是一段非常复杂且沉重的文字描述，这文字描述啊有些恶心的文字描述啊，这个不需要大家记。

我每次我也没记过，我都是检测之前放到桌面上，我都直接给你粘过来，我也没记过，这样你这玩意儿太费脑子了，估计就放过来完事，然后一会儿，我们需要进行可见性算法的一个判断，因为我们要看的原则。

那下面当这些东西我都聊完了之后，我们要干一件事，干点什么事情，我们要去做一个最基本的判断，什么判断，把我们刚刚的例子来做一个竖线好吧，刚刚上一节有什么做的例子，根据我们刚刚那个案例，我们来进行一个复线。

来看一下对应的效果到底是什么样子，来我给大家写具体情况啊，这么多，这是时刻，不要说掉头发的事好吧，你你不要去关掉这东西没意义，别人会的，你要你要不要会，你要会调整过这东西时刻，比如t10 个。

t20 克，t30 克叫451 15，25 三，然后这个时候呢干什么事，刚开始的时候三个15里面都是一个比例状态，begin dd in，然后在输入的时候，我执行了一个update操作。

然后我commit掉了对吧，然后在t3 时刻，我这进行了一个select的一个查询，刚刚的问题是什么来着，问题是当我这块进行select操作的时候，能否，读取到修改之后的结果吧，来告诉我结果是什么。

结论是什么，能不能读取到在当前这个select操作的时候，能不能读取到数据，结果能还不能还有人说不能啊，我刚刚说的都已经演示过了，我刚刚给你演示过了，演示的时候能还是不能，能吗，那为什么能啊。

他是怎么做的呀，非常简单，我们来做一个判断，做一个判断，什么判断，把刚刚我们要填充的字段给拿过来，这是我们在生成review的时候要生成东西，刚刚也说过了，什么时候生成real来着。

在进行快照读操作的时候会产生平视图。

那什么叫快照读。

是不是刚才已经解释过了，所谓的快照读就只是select操作，我们在刚刚t3 时刻。

我是不是执行了一个select作，所以此时是不是进行一个快照读了，那现在我只需要去填充好对应的字段信息，就完了，来告诉我。

当我在t3 时刻执行快照读的时候，我现在当前系统的活跃事务列表有几个，这个值是几，直接，就不能多说全了吗，一三吧，是不是一和三，这没问题吧，一和三，第二个最小的活跃列表里面有二吗，对面有二吗，同学们。

什么叫火焰，你事物已经提交到，老子还叫活跃吗，已经提交了还叫活跃吗，同学们不能了吧，就一个三两个好吧，没有二，因为我已经提交了，第二个，当前活跃列表里面最小的是y d是几一马，对不对，毫无疑问。

下一个系统尚未分配的下一个事务id是几几，四好了，把这些数据都写完整，然后除了这几个字段之外，你还要再多一个字段信息，叫什么叫db下划线，t r x下划线i b，大家进来。

它也是需要进行条件判断的这个知识点，是一吗，想想是一吗，是三吗，哎呀还四啊，什么叫bb t r s i d啊。

要创建这条记录或最后一次修改。

该记录的是yd，我现在谁修改了苏二负载了吧，知己，对不对，值是二好吧，把这几个值我都已经写完整了。

当我把这几个值写完整之后，下一步干什么事，我需要按照这个表，针对于我们当前的可见性算法，我要去做一个判断，判断一下我能不能看到对应的结果，然后来看第一个，首先比较dbt s d知识节。

小于2cm的id等于几，等于一，二小于一说，如果小于，则当前事故能看到所在的记录，我们现在小于不小于不小于吧，二是大于等于一的，对不对，如果大于等于怎么办，进入到下一个判断环节里面去。

所以再接着来判断d b7230 等于几等于二，6030等于几等于四说如果大于等于，则表代表db t i c i d所在的记录，在review生成之后才出现，那么对于当前事物肯定不可见。

我们现在r是小于四的，如果小于则进入下一判断，还依然往下走，第二课呢，d b t s i d2 是否在活跃事务中在吗，在不在，二有没有在活页列表里面不在吗，如果在，则代表巴拉巴拉巴拉巴拉巴拉巴拉。

如果不在，则说明这个事物在raw生成之前，就已经开始commit了，那么修改的结果是能够看见的，所以我们的结论是，能跟我们的实际情况能否匹配上，能不能学上，能吧，这是最终最终结果吗，结果就是这样的。

这就是这样的，来下面再演示情况，我们把第二次我做那个操作。

我也画成图来演示出来什么图，第二次画成图的时候变成亮的效果。

再改成t4 ，这没有。

系列 6：P91：MVCC如何实现多版本并发控制？如何解决读写冲突？ - 马士兵学堂 - BV1RY4y1Q7DL

这没有，那这先select，s挪到下面这样执行一个selly操作对吧，那这是一次困扰动物，这是一次困扰动，来一样的，我说了，每次在进行快照读的时候，需要生成我们的read view吧。

这里面是不是有两次快照读，第一个在t2 时刻，第二个在t4 时刻，所以我们分别要把对应的数据写写完整，把它弄下来，ctrl c ctrl v对了，那之后先看蓝色的，首先在这块我在进行查询的时候。

我当前系统的活跃列表里面的15id是几，你告诉我是几，123123没问题好吧，第二个活动列表里面最小的数y id是几一吧，不用动，尚未分配的下一个15y t的几四也不用动，这个值是几啊。

叫新增这条记录或最近修改这条记录的值，现在我有新增呢，我没看到我的新增操作，但是因为我们的事物i b的值是递增的，它一定是小于一的，我能不能给它成零，反正你小一就行了，是不是这意思啊，小e就行了。

无所谓好我这形成一个零，这没问题吧，来下面再来做操作，这是蓝色部分，还有绿色的部分，把绿色拿下来，如果是绿色部分的话，我们依然要进行判断，判断啥在这个时候，当前活跃列表是不值，这个活页列表的id是几啊。

在蓝色部分的时候，我有事务二有提高吗，听同学，听我在这儿执行的时候，二有提交吗，没有还没提交呢，在绿色部分，这时候是不是已经提交了，所以所以里面变成几了一逗号三对吧，然后最少收外力值。

是不是一是不是一直最想说话的绿色好吧，我现在是啥都给你标注好绿色这一尚未分配的，下一个是y d的解四没问题吧，然后这个只是解，加二，当你改完这个数据之后，我不知道你是否有一种毛骨悚然的感觉。

为什么有毛骨悚然的感觉，这个绿色部分的数据值，跟我们红色部分的数据值一样不一样，为啥是二，你在这儿查询的时候，你的事务二有没有对这条记录做修改，聪明做了没，你做完修改了，不就是改成二了吗，对不对。

看好啊，这个绿色部分跟红色部分的数据值一样不一样，一模一样的，没有任何区别对吧，我们的可见性算法它会变吗，都会变吗，不会变，可见性嘛，是不给你死的，那你就要思考一件事，同学们数据值是一样的。

可见性算法是一样的，但是结果却是不能，我们都要验证了，结果是不能的，那问题出哪了，所以你要考虑一件事，在整个过程里面哪儿可能会发生变化，你是要做开猜测了好了，很多生存法说radio生成的时刻是不一样的。

那我们这个地方能不能大胆的去做出一个猜测，什么猜测，猜测猜测啥呢，第二次的read view并没有是恒星生成，而是用的之前的review是不是这东西，那所以我最后我这张表应该变成什么样的一，个状态了。

前面的东西拿过来复制一下到这边，然后这样123我只需要把这个值改成二，比如说这个地方它是最终状态，这个东西能理解的扣一，能理解吗，我们现在只是猜测，猜测完成之后再做一件事，什么事儿，别忘了。

我们最终是要拿我们的可见性算法，来进行对比的，我就拿这个图和这个肯定算法来进行判断，判断哪来第一个，首先比较db t r c i d等于几等于二，小于up里面的id，它等于几等于一，很明显二不小于一。

如果大于等于，则进入下一片段，一定要记得下来，记下来之后，这再来d b t23 t等于二，low里面等于几等于四说如果小于，则进入下一判断，依然往下走，这时候再判断验证这个值是否在活跃事故中。

问一下在没在活跃事故中，在没在活跃15中，在吗，这不是1232，是在里面的，如果在，则代表在review生成的时刻，这个事物还是活跃状态，还没有commit修改的数据，当前事物也是看不到的。

所以这个时候你验证完可见性算法之后，跟我们最终的结论能不能够对上，能还是不能，能吧，所以这个时候我们可以大胆的做一个结论，什么结论，在第二次进行快照读的时候，确实使用了第一次生成的read view。

而没有重新生成来，这句话能理解的，扣一能理解吗，那这个时候很多同学会有问题的，是老师你之前要讲的东西啊，我听懂了，但是按照我之前的认知和感知来说，他有点问题，什么问题，我之前我记得是这样的。

他是跟隔离级别有关系的，是不是有关系，如果你的隔离级别是rc这种隔离级别，不管不管你之前有没有查询，那么最终我都是能看到数据的结果的，而如果你用的是r2 这种隔离级别，他确实是看不到最终结果的。

这是我之前不管是看帖子也好，还是我自愿的也好，我得到的一个结论，这是你们之前认知，刚刚我在演示那个案例的时候，为什么很多同学都说错了，根本原因在于你是存在这样的一个认知的。

唉这东西任何同学扣一是不是这么说的，你们之前看帖子也好，干嘛也好，都这么说的吧，别人都是这么教给你们的，是不是这意思，那问题出在哪了，问题就出在最后面，我要总结的这一句话，同学们记好了。

在r c隔离级别里，每次进行快照读操作的时候，都会重新生成新的read view，所以每次可以查询到最新的结果记录，这是第一个r c这种隔离级别，既然有r c了，那么就意味着有r r的隔离级别。

在r2 隔离级别离，注意了啊，只有当前事物在第一次进行快照读，这时候才会生成，read view之后进行的快照读操作都会沿用，之前的read view，听明白了吗，来听白同学666刷一波。

这就是我们mhz最终要解决的一个结论，所以为什么在隔离级别里面，你看到的效果是不一样的，原因就在于此，明白意思了，所以这一整套东西就是mv c c，它所对应的实现机制，你是需要把这套东西给搞清楚。

同时给搞明白的，好吧，当然这东西还是很多的啊，我讲了差不多一个小时了，光这一点讲一个小时了，下来之后还是需要把这些东西好好去理解一下，好好去悟一下，把这些东西搞清楚搞清楚啊，老师是读了c吗。

什么意思没懂啊，所以把这些东西好好搞清楚一下，对看过一部分源码没看全啊，msl源码太多了，没看全，看了一部分，看了一部分，我说了c语言这东西我能看懂，但让我写，我写不出来，我不会写c语言。

但我能看懂好吧，这块的一些相关的知识啊，搞不卖就行了好吧，所以刚刚上面的问题，我基本上也都给大家聊完了吧，还剩下最后一个问题叫mysql中的幻读是啥。

手机如何解决幻读问题，刚刚还有同学问换个问题吧，换图吧，小不点，问了问老师，二二项代替select之前如果进行了update吗，对这就是我马上要讲的换图的问题，来我们演示一个幻读问题。

来看看这换图大家都接触过吧，换图到底是啥，到底什么叫幻读问题，来，我打开这个文档给大家看一下，我这有换头的案例。

我给你解释一下，你这边设的数据表，把数据表给单弄一下，mv cc解决不了，换图好吧，m v c c解决不了换图，我从来没有说过mv c c能够解决换图，从来没说过换图通过什么，通过加速的方式来解决的。

来做一个演示操作，看一下啊，先commit吧。

然后drop，table below的删掉，然后呢我先插一张表，创建一张表，这个表足够简单吧，id好吧，name age i，id是主键，一共包含了三个字，发信息，然后往里面插入几条对应的数据。

结果走commit，然后select相from user 14号结果吗。

这没问题吧，然后呢再来做一件事，这边一样commit select星from user，两边数据一致不一致，同学们两边数据一样不一样，一模一样吗，那换图问题到底怎么产生的呢，非常简单，来笔记。

还是同时开启我们的事物，当我开启事务之后，我这边先做一个查询，三星from user where值等于20，走几个，结果两个吧，那这边查询呢一样的，两个结果一模一样好，两边数据是一致的。

然后我在右边窗口里面做一件事，什么事叫insert into user values，括号这25说话25，逗号20，我现在插入一条语句，然后我再commit一下这条语句，先听好我的第一个问题。

我在这边进行select查询的时候，我查询到的结果是两条还是三条，两条还是三条，吴杨记专，你白听这节课了，chine也白听这节课了，怎么还有人说三头呢，不说了吗，在rr隔离级别里面。

只会用第一次生成的read view，看这一次操作会生成read view吗，不会吧，所以这只结两条，它不会动的，那你说老师，你是真的猛，我哪儿猛啊，眉毛好吧，这两条这东西还不叫幻读。

但现在我要做一次操作，看好了，叫apple date，user set name等于连where is h等于20，我的问题是，现在我更新的时候，我更新了几条，两条还是三条，肯定成功了，两条r3 防。

三条吧，看看结果，他告诉你三行受影响了，我明明查询到的数据是两条，但是我更新了三条，此时不就是产生了幻读问题吗，这就是幻读问题产生的由来好吧，换个产生问题就来，所以这东西来这东西听明白。

同学给老师扣一能听懂吗，这不是换图吗，明明抄的是两条，更新完就是三条，什么意思吧，那换图问题你能听懂吧，那换图问题我应该怎么解决呀，怎么解决能解决吗，能没有解决不了的问题好吧，commit。

然后呢做一件事叫trank，溜了把自己干掉干掉，完成之后，我再重新插入一条我们的数据表示一样走，然后commit，准备完成之后呢，我再重新开启我们的事，p p开启之后我再查询吗。

fl将from user where r h等于20检查结果吧，明白结果吧，这下是没有任何区别的，那我如何组织宽嘴角，换个问题呢，你在查询的时候干这么一件事，加锁吗，加什么锁。

后面加一个for update，当我加上方案配置之后，我在这边我依然往里面插入我们的数据，当我在插入的时候，你看到了什么效果，同学们，什么效果，我现在还能谈恋句吗，等待吧，现在是不是被堵塞了。

你这边被阻塞者，你当前插入的这条结果，你根本就插不进去，你右边这可能会产生幻读问题吗，不难看的问题吗，不会了，产生不了换毒问题，好吧，这就是我们如何解决换多媒体存在，我这边如果一旦提交了miss。

已提交，这边立马成功。

明白意思吧，我们这边我会加锁，加锁之后解决我们对应的问题，但是我想问的是啥，刚刚缓缓图的方式情况我也演示了，演示完成之后呢，我也告诉你解决方案了，我问一下换图问题产生的本质原因是什么。

你知道为什么会产生宽度，谁能告诉我根本原因是啥，是啥有的没有，不是，来记住我下面说的这句话的一个描述，这句话很重要，如果事务中进行操作的都是快照读，那么是不会产生幻读问题的啊。

但是当快照读和当前读一起使用的时候，才会产生幻读问题，来静脉的扣六，这是刚刚扫，不咋说这个问题，因为我中间执行了一个app操作，他用了当前读，所以此时我读取的数据是不一致的，所以此时我产生了幻读的问题。

就这么简单好吧，把这些东西给想明白，你解释清楚就完事了，就这样东西，终于讲完了，松了一口气，好玩吧，你你学会体会其中的乐趣好不好，同学们，你学会体会其中的乐乐趣，老师咱们突然应这边三亚三亚。

是因为我嗓子哑了，不是这个麦的问题，是我喊了一晚上，我喊我喊哑好不，为什么update是当前读，没有，为什么就是规定好了，我刚刚上面解释了，同学们，我刚上来就解释了。

我说什么叫当前读，lock in share，model，select，update，update，delete t4 的属于当前读slack，是快是快照读，我之前就说过了吗。

我之前不告诉你这些操作是啥的吗，我之前说过这东西了所有的东西了好吧，所以啊这里面的细活，个人认为还是非常非常多的，还是非常非常多的，你们啊需要把这些东西给掌握清楚了，这效率也太低了，什么叫下的太多了。

不是因为没加锁，加锁是为了解决幻读问题，不是说我在写sql操作的时候，我一定要加锁，你加不加锁，这件事情是跟你的实际的业务需求挂钩的，不是说我写的所有操作操作我就一定要加锁，没意义，你家锁干嘛呢，好吧。

他们说为啥不能一样，什么意思，没懂，老师你串一下吧，这没啥串的，我刚刚上来，我讲了事物的一些特点，然后告诉你说事物各个特点，它对应的实现原理分别是什么，我们讲了mysql里面的一些关键的日志系配置。

然后呢重点聊了一下mv c c，它所对应的实现机制，你就记住mv c c它到底怎么实现的，刚刚有同学说的很对呀，别的东西你都可以记不住，但是最后的结论我希望你一定要记得。

就是这个房框里面的东西一定要记得，这个结论才是最关键的，我刚刚讲课讲的时间比较久的原因是什么，是因为我要带着你把这套东西给捋出来，给捋出来好吧，所以讲的时间比较久。

但其实你只需要把当前的结论给记住就完事了，南昌说当前读和快照读与隔离级别有关系吗，没关系，跟隔离级别没关系，好，带节奏什么意思，带啥节奏，不带节奏好吧，男生不要再发了，当前读和快照读。

跟隔离级别没有半毛钱关系，好不好。

系列 6：P92：MySQL中的幻读是什么？如何解决幻读问题？ - 马士兵学堂 - BV1RY4y1Q7DL

那个加的是加加的叫排他所叫排他锁，lock in share model，叫什么叫共享锁，好吧，你间隙锁和零件所讲一下什么叫间隙锁呀，比如说我在一个表里面插入对应的数据。

结果数据值我建索引了数据值是多少，是一逗号，三逗号，五逗号，五逗号七，如如果你再加电机锁，这时候它的构成是什么样子的，是负无穷无穷怎么打什么情，无穷到一，然后中间有一个一的记录所，一的记录所就行索。

然后有一个1_{3是间隙所，然后有一个三的记录所，然后有一个3}5的电机锁，然后有一个五，还有一个5~7，间隙锁，还有一个还有一个括号c到正无穷，这是我们的间隙锁，那什么叫零件锁呢，零件锁也非常简单。

零件的所表示什么叫左开右闭区间，连接所是这样的样子，它表示什么意思，叫负无穷到一这样的逗号，然后一逗号，逗号，然后三根号五，然后五，根号七，然后括号七到正无穷，明白意思吗，什么叫零件锁。

零件所不就是把间隙锁和行锁合到一块了吗，这叫零件所，是他们之间的区别，就这玩意儿，就是我如果表演的记录是1357的话，我再进行加锁的时候，如果加零件锁区间就是负无穷到一，然后加一个记录锁。

然后1_{3是间隙三，然后3}5是一个间隙，55~7，这个间隙七到正无穷是一个间隙啊，这哎中间这小的七，而如果你是零线索的话，就相当于左边是开区间，右边是闭区间，开区间闭区间，开区间，闭区间开区间闭区间。

就这些东西好吧，有啥不一样，你锁定的范围不一样吗，一个带具体值的，一个没带具体值，就这点区别，没别的区别了好吧行了，所有东西不讲了好吧，所有东西太复杂了，如果要单独讲所的话，我们要讲讲好走。

我觉得两个小时讲不完，讲不完，一个锁的东西，讲不一所东西啊，这东西不聊了啊，后面我有时间我们再详细聊具体的一个知识点，server锁是在server层还是给你填层，你要这个模板锁是给谁加的。

我是给数据加的还是给索引加的，我问一下锁是给数据加的还是给索引加的，对给索引加的好吧，给索引加的一定要搞清楚了，你要搞清楚，给索引给索引，给索引分数据封闭，给索引加好了，这锁这事啊，不聊了，好吧好了。

今天我花了差不多将近两个小时的时间，给大家进行了这些知识的一个讲解，下来之后，一定要把这些核心的知识给大家进行一个讲解，这两天我想了两天mysql相关的知识来，有收获的同学表示，q26 好不好。

我也辛辛苦讲两天了，有用过吗，好了讲完这东西之后，我最后面还是要强调一件事，同学们，这东西我只是把其中的某一块儿，的知识是拿出来做了，讲解下去之后好，还是要自己学会总结回顾整个体系给补充完整。

这事很重要，我昨天在上课的时候，咱们俩讲完干货之后，我就跟大家说过了，你们在学习的时候，一定要强调一个东西叫体系性，完整性，这玩意很重要啊，这些知识从哪来的，第一你可以看书，第二你可以看帖的。

第三你去学会上官网，很多东西在官网里面都有非常详尽，以及具体的一些描述，同时这套东西在咱们课程里面，我都进行了一个非常详尽且完善的讲解，你是需要把这些基础知识给掌握精通的，我昨天去说过了。

你把这套东西如果你真的理解了，掌握了，你去面试，我告诉大家，很容易很容易，包括你在你们公司里面去面试，这些东西都会变得很容易，我在公司里面如果遇到一些线上问题的时候，我觉得是可以解决这些问题的。

前两天我记得还有一个同学也是一样的，他通过mysql的东西就听完这节课之后好吧，它解决了它们的生长环境里面，所存在的一些对应的问题都是有的啊，所以你需要去了解这些关键的核心点。

把这些核心的知识你都要掌握清楚清楚，因为你只有掌握清楚这些东西之后，你才能够完整的知道怎么去解决问题，以及怎么样去描述这些对应的问题，明白了吗，这就是调控所带来的知识，你需要把东西搞得更明白好吧。

所以现在感觉了解的差不多了，现在感觉有点懵，还是那句话，那是因为你接收到了新的知识，所以你之前讲解接触的东西也是不完整的，所以导致会出现这样的一些错觉，明白了吧，还是要把这些东西做一个完整的体系的学习。

到把这东西都掌握好了，ok好了，聊完这些东西之后，我们聊点其他东西，昨天上课的时候，我也给大家说过一件事，我说同学们永远记住了，听我一句话，以后在做事情的时候，做些事情的时候。

我在学习的时候一定要保证一个完整性，同时我希望所有人能够去树立对应的目标，这件事情很重要，你学mysql就学mysql，不要今天学mysql，明天学院意思，后天学gbm，大连绝对服务，不要这样一个体系。

一个体系的去学习，一个块一个块去学对应的学习，因为只有进行这样的学习之后，你才能收获到对应的一个效果，才能达到对应的效果，明白吗，好吧，还是那句话，你永远不刚才同学问老师这些问题，你是怎么学的。

有人对学习方法好奇吗，不知道应该怎么去学啊，怎么去学这些东西啊，大学啊，怎么学习，非常简单，我刚才说了书官网论坛帖子，但是你在看这些东西的时候，同学们永远记住一件事，别人给你说的东西。

我希望你能够有一个最基本的判断力，明白吗，最基本的一个判断力，这点是很重要，你要能去判断，我要能要能去判断，要不然的话你借东西可能都是错的，特别是现在这个铁啊，或者现在很多东西它没那么规范。

所以导致很多东西可能会有一些错误的知识，会影响到你，所以你要具备对应的判断力啊，同时还有一件事，像这东西为什么，当你看到别人说的一些结论，或者一些对应的概念之后，我希望你能够搞明白，我希望你能去问。

说到底是为什么，别人到底是怎么实现的，这样实现的好处到底是啥，你要休息了，为什么啊，然后并且寻找到对应的答案，这件事情才是很重要的，选择太乱了，现在水平优势无法区分，就就这意思。

所以啊找到一些关键的核心东西，或者说正确东西经常去学去看一下，你要有这样的判断力啊，你不能说他说错了，你还觉得是对，我觉得你所以基本这方面判断力你应该是有的，好吧行了，这东西啊咱们就聊这么多吧好吧。

聊完这些东西之后呢，阿白说时间成本，所以这里面就会有个问题啊，就是你要去花时间，我再说一句话啊，呃现在这个人啊不是不指你呢，现在社会上的人不止你们，包括我在内，其实大家都有点浮躁，我希望大家能做一件事。

或者你要认知到一件事情啊，技术这玩意儿是需要沉淀，需要花时间来琢磨了，我不知道你们自己私下的时候，有没有琢磨这件事情的，你也别想着说老师，别人3332，别人研究了好几年的东西，我能够在很短时间内搞清楚。

这事儿不太现实，就你一定要沉下心来，你知道吗，很多同学上来之后就考虑一件事，老师我想一个月之内找到什么工作，我想一个月怎么样，我觉得不对，是送错了，你要学会去慢慢沉淀，等你沉淀好了之后。

你的技术实力是能够储备上来的，如果你沉淀不好，你的技术实力，你就没办法储备的，能懂这意思吗，这沉淀这些很重要，别着急心急，吃不了热豆腐这么简单啊，你作为一个技术人，你应该掌握这东西，好吧行了。

这些东西啊，我们就不再给大家进行其他概述了，关于mysql相关的点干货的东西，咱们就聊这么多是吧，聊完这些东西之后呢，安排问说现在学明年金三银四跳槽合适吗，我问一下有多少同学想跳槽，给老师扣个一。

你想太多了吗，懂了，听我一句话，同学们跳槽这件事情，是没有合适不合适，跟时间点是无关的，很多业主老师我要等静态一个字，老师我要等进，有延时，没这必要，你所需要判断和衡量的只有一个东西是什么。

我现在的技术实力能否支撑我跳槽，或者说能否支撑拿到更高的薪水，你只需要去判断这么一件事就够了，你不用去在乎时间，年底的时候岗位是少，虽然岗位少，但是不代表没有招聘机会，计算一次机会是多。

但不代表能把你要到明白吗，他一样，你的技术实力能否具备足够的支撑，昨天晚上上课的时候，其实我说过这件事情，同学们我也强调过这件事情呢，昨天我问一下，昨天有多少人领过咱们的路线了，零嘴给老师扣一。

有多少人领过了，懂吗，昨天上课的时候给大家分享了很多，我们关于学习，或关于你自己定位相关的一些路线，就说你到底要怎么样去完成，自己的一个技术储备，永远记住页数明白，这件事技术是学习不凡的，你不可能。

真的把所有的技术都掌握精通，但是你要有自己的加分项和你自己的亮点，你只要有自己的加分项和自己亮点了，那我觉得就可以去试一试，昨天我在展示我们对应的课程路线，比我们课程大纲的时候，大家说过了。

你们现在做开发的同学，或者你们现在的同学，我不知道你们现在是什么样的一个水平，什么样的一个层次好吧，但是你现在最起码是一个基本的开发人员，那么我觉得你做一些最基本的开发功能，完成一些c l u的工作。

你是没问题的，如果你能够独立的去做一些开发了，那么下一步你的目标你就要去做，什么叫操作与落地，不单单是说我只会c l o d，你要掌握非常非常丰满的一些技术站，我也说过了，说这东西很难去评判，说我什么。

我现在是什么水平，以及我要达到对应的什么水平，这是很难去评判，但是阿里是有一些对应的职级的，你是可以把这些职级来匹配到你个人的身上，然后按照这样的一个职级的要求，去做一些对应的技术储备的，阿白说。

我昨天拿到之后，不知道从何下手，这样我一会儿把路线再给大家详细的描述一下，你到底应该怎么去学习，路线，应该怎么学习啊，如果你还有困惑，一会儿每个同学可以把你个人的情况说明一下，说明介绍之后。

我依靠我个人的经验，和我们现在收到学生的一个情况，给你做出一条合适的规划出来，我的个人情况里面，我希望你能突出的是啥，有以下几个信息，我需要知道，第一个是你的城市，第二个年龄，第三个薪水，第四个学历。

第五个基本情况，这是你工作的一个情况，特殊情况，第二个就是你的预期，你把这些东西告诉我，我一会给你一些针对性的建议啊，每个同学你可以发一下，那下面我来聊一下我们的这个路线，你到底要怎么学哇。

我们一步一步聊，先聊p6 的级别，如果你现在能做独立开发了，那么我认为你下一步应该冲击的目标就是p6 ，当前这样一个级别了，那po里面你需要掌握什么技术，其实没几块，第一块叫底层技术实力。

很多同学进入这个行业之后，都是培训进来的，你可能没有对应的计算机的底层技术的支撑，所以你需要储备一些像qq系统，计算机组成原理，网络io linux系统，数据结构和算法这样的一些基础知识。

像这块知识是属于什么，这属于啥，有人知道吗，他是你在上大学的时候，你科班应该学的东西，但是咱们有很多同学都是非本专业的吧，来有多少是非本专业的，或者说非计算机专业的，给老师扣个一，有没有，没有啊。

都是很专业的吗，不可能吧，就你是非非本专业的，所以你是需要把这些基本的技术和基本的技能，给弥补起来的，这东西它会影响你对于很多技术，底层的储备和学习，所以你是必须要看的明白吗，必须要看的好吧。

这是第一块底层知识，咱们都有对应的课程进行讲解，说这话之外，第二部分，像现在聊并发编程聊的比较多，聊多线程聊的比较多，所向复合系统被判之时，队列的知识，内存逻辑的东西，线程池的东西。

cs的虽然local的j u c的，你多少掌握这些东西，你在工作中可能用不到，压根用不到，国产来说可能用到的几率并不是特别大，但是面试中这是一个重灾区，为什么说面试这一层难题。

因为大部分同学因为工作中接触不到，所以他对这块知识的掌握是有失偏颇的，或者有欠缺的，所以导致他这块是个弱项，那面试官为了考验你个人的技术实力，他就会拿着你的弱项来问吗，所以你需要把这块当成你的一个强项。

来进行相关的技术储备，明白了吗，这是第二块并发编程相关的技术，我觉得这块是所有人都必须要学的，第一第二都是所有人必须要学的，第三话叫rpc通信框架原理，这里面包含什么，像ogier。

像double r b c t r p c rustle，rap和nike等一些东西这一块啊，我觉得你尽可能的去了解和掌握，为什么，因为现在这样都是分布式，微服务的一些交通框架。

它都是分布式要进行这些消息通信的，这里面一定会进行到一些通信框架的一些包装，和一些使用这块东西，它不是一个必备技能，但是它一定是一个加分技能，听好了，加分技能，如果面试中你提到的nt。

你能把底层那些nl这些东西，要么非常非常清楚的啊，对面试官而言，对你的评价一定很高，因为很多同学会一般的开发程序员，对这块知识是缺失的，而如果你了解了，你就是加分项。

你就能比别人多赚几千块钱的点不在这儿，是这部分好吧，第四部分中间件，这个不用说了吧，在公司里面，你除了在一些外包和传统行业里面，消息中间件几乎必用，现在现在运动比较火的两个周边，mp卡不卡。

这样东西你必须要掌握，像i tm q了好吧，robert mq这东西有些公司在用，有些公司没用，但我不要求你全部都会有选择性的看，最起码你要做到一个是精通的，其他几个懂我略懂明白吗。

你别提到中间建了是吧，谁都哪个都说不出来，哪个都不精通，完蛋了，好一个精通往其他的东西基本了解，构成了，面试的时候，有你自己的一个常数和你自己的一个加分项啊，这是中间线的这个级别。

然后再往下是缓存应用的级别对吧，像mcat是原来用的，现在几乎mecatch都已经被淘汰掉了，除map cat之外，下面的redis redis不再是那种单机的redis。

是分布式的或集群的release，现在到六了嗯，后面我们马上也会进行六版本的一个更新，你多少进行储备对吧，包括像科班要学的软件设计基础这东西啊，它属于一个怎么说基础技能吧，如果这块你不了解没关系。

时间紧的话，暂时可以先不了解，但有时间的话，最好还是看一下像敏捷开发这样的东西，我觉得你还是了解一下好吧，以便于你自己能做更高效的开发工作对吧，再往下就是分布式架构专题，分布式价格专题里面。

并不单单是包含，咱们之前了解的什么分布式事物了，分布式锁了分布式id了，不单是这些东西，还有很多其他技能，比如说分布式预警对吧，分布式链路追踪，分布式全员控制，分布式id，分布式密度，分布式任务。

分布式分化，这都这样了解的，对，你不要说老师，我拿个分式锁分式是不是就可以了，现在面试分布式事务控制所几乎必问，问的也很多了，几乎也烂大街了，所以啊掌握一些其他的核心点好吧。

再往下看微服务的什么配置中心了，注册服务也发现了网关路由了，服务端用了负载均衡了，熔断降级限流了，这东西好吧，包括现在主流的netflix和阿里巴巴，两套微服务的技术体系站。

能够了解他也是一个必备技能好吧，性能优化的还是加分项，便于勘测你对应的工作实例，像gb m采购mysql调优tomcat，调优n这个调用对吧，以及超大流量的一些项目，调优方面的点都有啊。

这句话也是一个重要的点，因为调多项能表示你具体的工作经验，和你的工作实力，这块如果答得非常好的话，它100%的是一个很好的加分项，好吧，再往下像一些海量数据存储的，现在比较好像e s了。

click house了，rmsl太低b了对吧，像这样mysql你们可能是最熟的，加上e s了，click house和带db也有所了解了，它表示的是最新的技术，很多同学在公司里面或在生产环境里面。

可能暂时用不到这些技术，但是我觉得你要储备，还是那句话，你要保证你技术的一个东西叫前瞻性，明白了吗，前瞻性虽然没用，但是我要会，如果公司要用了，我能够立马上手，而不至于说我所有的文重新开始学。

如果你所有东西都重新开始学的话，那这个效率就太低了，明白意思了好吧，再往下还有什么e l k相关的东西，就e s的对吧，还有海量数据存储的，像大数据的一些东西，i do和hbase。

还有flink这些东西，把以下面的像网络设施运维的知识，要了解一点对啊，运维这个东西它表示的是什么，你要具备运维的一些基础能力，最起码linux相关的东西要会吧，c d n d n s这些东西你要会吧。

把静态资源你要会吧，这东西都是基础知识啊，包括像dios的对吧，docker k8 s对吧，这东西你要你要了解到这边还有些武器的测试，相关的最基本的测试也要了解了，以及我们service mesh。

像epil相关的点多少了解，所以这就是p6 级别你要储备的点，这里面有重点有非重点，你可以把你自己的薄弱项先重点补起来，上面画的，比如说并发编程比较重要，中间件比较重要，缓存文件比较重要对吧。

性能优化比较重要对吧，你能不能先看这几块，看完这几块之后，如果你还有时间，我再看其他东西行不行，什么意思啊，这么多技术点，并不是说让你一口气，全部在很短时间之内我都补充完整，不是这个目标。

是为了让你能够有一个方向，有一个目标，我能够持续的学习下去，不至于像一个无头苍蝇一样随便乱转，今天看这个，明天看那个哪个都看不清楚，不要这样好吧，说不想看怎么办，不想看你就等着被社会淘汰，被行业淘汰。

如果你想在这个行业里面干的时间更久，必须要看，逼着自己看，也要看，不干怎么行呢，必看好吧，还不想看怎么办，想拿高工资吗，闲党心吗，人生在世总有很多你要逼自己做的事情，但是还是那句话，你想不想做。

其实说白了就是懒嘛，就是懒嘛，懒这玩意啊，有人天性，但是怎么说，当你遇到一些更加现实的一些情况的时候，你会为你之前来买单，像现在听课的学生啊，我不知道你们的年龄多大，特别是一些年龄大一点的学生。

人大点学生，他很多同学发现在出去找工作的时候，容易被行业淘汰掉，原因是什么，原因就在于他之前欠的债，其实你们现在感觉薪水要不上去，工作年限很久好吧，都要不上去，薪水其实都是站，那是出来混总是要还的。

你现之前年轻的时候欠下债，你现在就要还了吗，可能会很辛苦，可能会很疲惫，没办法哇，下风飞车老师这技术图能发一下吗，如果谁需要要当前的技术路线图，好不好，好的小姐，找你的班主老师。

去进行相关的一个允许把对应的资料领取过来，路线给免费发送给大家，这东西只是我们对应的p6 级别的相关技术，除了p6 级别的相关技术之外，我们还有什么呢，刘老师老师，我达到p6 了。

我现在要准备pg级的知识怎么办，咱们p7 也有pig叫什么叫落地以实战啊，还有p7 的，有人想看pc吗，啊有想看pc吗，想看扣个一吧，有没有，对吧对吧，你去看一眼，简单看一眼好吧，你可以不了解。

但是我觉得简单要看一眼好吧，pc里面主要包含什么，包含的是另外一块东西叫原理与设计，这里面呢其实我们也包含了几个重要的模块，第一个是分布式的一些理论基础，像什么c a p了，popucraft啊。

这些东西都要有啊，还有一些分布式算法的一些支撑的东西对吧，好从这算法支撑的一些东西，包括像我们有一些架构原理和源码的一些设计，这里面包含了像spring全家桶源码对吧，o r m相关的一些源码。

把他们看的源码，spring color源码，mq的源码对吧，net源码和spot源码，e l t的源码，几乎各个源码环节，我们都会给大家讲的比较详细，因为你想成为一个高开，会想成为一个组成。

想成为一个架构师的话，那么必须要储备这样的知识，明白吗，好吧，当然原版东西啊很难难是难，但是该储备的依旧要储备，你不能说因为它难，所以我就不学了，你如果因为难不学了，你告诉我。

你怎么样能保证更好的一个那个那个薪水呢，就一定注意啊，你如果想比别人要薪水更高，就意味着一件事，什么事你必须要会点别人不会的东西，如果别人会的东西你也会，那你告诉我凭什么凭什么你拿高薪，别人拿低薪。

没道理的对啊，除此之外还有我们的高性能架构设计的东西，比如说分流的线设置，服务并行并发的设置，缓存的设置，存储的设置，可靠性的设置对吧，应用保护层的设置都要有好吧，这块大家需要记住了。

ok下面还有最后面就是最关键的一些东西，如果你想成为一个高开或成为一个主城，还有一个最主要和最核心的一个点是，什么叫架构设计方案，什么叫架构设计方案，这东西怎么去理解它，记住了同学们所谓的加入设计案。

指的是里面放的几块，第一个叫每秒数10万超高并发通用设计专题，叫n个九全链路高可用通用设计专题，叫云集百万年薪案例驱动架构设计专题，以及我们的一级流量，多级缓存架构设计专题，现在啊。

你在面临一些大厂的比较高级别的职位的时候，基本上都会聊到架构设计相关的点，那么架构设计是啥，比如说红包雨怎么设置，怎么设计，你需要哪些技术，站在面试的时候，如果问你这样怎么怎么办。

你如果对于技术的储备是有问题的话，你很明显这东西达不到的好吧，这是p6 和p7 ，你要掌握相关的一些技术，除此之外，有些同学说老师我项目也比较薄弱，怎么办，没关系，咱们呢也有很多落地的项目。

网游服务器的都马上能单体版本的电商，单体单体电商，包括我们的分布式电商，包括我们的飞机出行，包括我们的推荐系统流失平台，我们都会有好吧，课程到底课程到p8 好，我们现在授课老师里面都有p8 。

老师来给我们进行授课，真p81 会来跟大家聊一下，是勇士好吧，这后面还有说老师如果想去面试的怎么办，没关系，我们有短期的这种面试，突击跳槽的东西，比如说难题的解析，简易的指导，面试指南。

晋升的指南都会有的，除此之外，还给了很多高级别的工程师，和高级别的开发人员，也准备了一些设计专题，比如说资深架构师应该掌握的技术体系，这里面有云原生相关的技术，有常见的大厂bug处理专题。

我们请了一堆的大厂的兼职老师，让他们把他们在生产环境里面遇到的问题，给大家进行复现，复习完成之后，上课给大家讲出来以后，你在面试的时候就能够游刃有余的去回答，这些线上事故，点了都会有。

包括我们有双11 618，对于一些架构设计的解决方案对吧，这些东西除此之外，我们还有cpu级别的一些架构专题，这里面涉及到的是什么团队的管理对吧，领域驱动的一些设计，包括像智能化信用的一些设计。

以及我们的产品管理都是比较完善的，这里面的东西也都是需要进行储备和学习的，所以如果是需要安全路线，扫描屏幕右上角二维码，或找咱们的班长老师领取，如果你之前已经加过咱们的小姐，班长老师了，好直接直接干啥。

我来领取对应的路线就完事了，是刚刚给你们看到的，只是说你们当下这个阶段里面，你们应该储备和学习的东西，其实除了这些东西之外，你觉得学技术的最应该保持什么东西，同学们，除了内容之外，还要还有啥。

同学们永远记住一件事，技术是不断的更新的，技术是不断的迭代的，技术是要不断的进行学习的，所以除了这些具体的技术点之外，咱们还推出了一定，每天每个月对应的一些课程更新的计划。

给大家看一下，我们在官网首页，你们自己可以点开我们的官网去访问一下。

在官网里面，我们上面有一个专门的专题叫做科研更新，这是我们在11月份要进行的相关的课程更新，大家可以看一下对吧，go web相关的课程，open cv的课程，鸿蒙系统的课程，type script课程。

三高项目课的课程，随便点开一个，里面都有对应的课程，好课程大纲以及对应的课程授课老师，以及对应的具体的时间安排，全部都有啊，光我们的科研更新每天都有，包括我们的flao对吧，包括我们的数据中台，对不对。

包括项目部署的领域驱动的，以及后面还有x tp 7的啊，开了一些设设计东西，游戏高级架构师长，网络安全的airflow的分布式那个任务调度的对吧，以及后面的jvm top k的源码，卡不卡的源码。

包括批判的三高项目商城的维京岛，罗米修斯的对吧，还有我们tdp的codis，es的nevis上科三门课的等等一系列科研更新啊，课程每天每天都在进行不停的直播，不停的更新，所以你过来之后。

你能享受到的是什，除了现有的知识体系，知识框架之外，你能一直跟着咱们的直播课程去学下去，我可以给大家展示一个东西，就是马士兵教育对应的直播课表，这个课表你们可以随便去看，随便去对比，没有人能比得过。

这是我们这一周的这一周的直播课程，今天晚上我给你们上完公开课之后，训练营之后，明天晚上接我的vip课，我明天晚上还要讲去vip对吧，每一周至少应该是十节课，加上vip课。

你可以跟着vip课进行不断的技术储备，看明白了吗，所以有很多的课程，你都是需要进行储备和学习的。

这才是能保证你长期在这个行业里面活下去的。

一个最根本的核心点，懂我意思吧，啊这是我们对应的科研中心是吧，那我们同学会问刚刚那个路线我解释清楚了吧，有没有同学好奇楚老师我到底应该怎么学的，有人好奇吗，朱老师，你刚刚展示大纲里面展示了那么多东西。

那么多东西我到底应该怎么去学习，或者我应该学习哪些点，我应该怎么办，这告诉大家，我们为了能够更好的服务和帮助我们的学生，我们对每一个报名的学生，会制定对应的课程学习计划，牛奶问说怎么成为vip。

说老师我想成为vip学员，他会告诉你你要进行什么样的一个操作，以及做什么样的操作，你能够成为对应的vip用户啊，就是购买我们对应的一个课程就完事了，就这么简单好过，我们对应课程就完事了是吧。

这个课程叫什么叫m c a，一会我来给你详细说一下mca课程体系，刚刚我展示的课程大纲猫那个路线，其实就是mca课程体系的一个路线对吧，而且我们要做的事情其实不止于此，我还在做什么。

我们给每一个报名的学生，其实都制定了我们对应的课程的路线，因为东西点很多嘛，同学们也知道很多点是非常非常多的，所以你可以免费注册码视频教育官网，说官网之后你会有对应的体系课程，你购买什么课。

什么课就有对应的讲解好吧，然后呢下面之后会有一个东西叫学习路线，当你报名之后，老师会根据你个人的情况，给你制定一条属于你自己的学习路线，这些路线也包含了很多的点，比如说这位同学的里面要包含。

它是一个年龄比啊，只需要技术提升，年龄比较大，不需要换工作，他需要做一个体系性的学习，那么里面就包含了这一堆东西，从技术计算机底层开发技能源码，补充分布式服务，微服务的中间件的，云原生的项目。

实操的等一些东西，他在搜到这样路线之后，可以干些什么事情。

当你的鼠标放到每一门具体的课程之后，就可以直接去点击到对应的课程里面。

进行相关的技术学习了，而不需要你去找别的课课，老师已经给你排好了，你直接在这个地方进行查看和学习就可以了，而且你可以在当前这个平台里面好吧。

提问自己的问题啊。

可以有问答对吧，提问题之后针对当前是这节课，老师我给你最后做对应的答疑，同时还有对应的笔记，我可以上传自己的笔记，做好对应的总结都会有，你在平台里面你可以学，直接就学了。

明白明白的意思吧，而且每一个学生跟每一个学生，我们真正的路线其实都是不一样的，他因为工作1年经验不太多，需要储备这样的一些技术，把面试或工作中常备的一些技能，像你要储备精精通，储备基础对吧。

包括下面还有存宝骏的对吧，这样的一些课程路线，当然有一些同学，他们的情况可能符合绝大部分的情况，那么我们也会给予对应的路线的一个讲解，或者对应路线的一个分配，而且每一个学生。

并不是说这个路线就一次就不变了，不是这样的好吧，你后面如果有需要，我们会把你的课程都进行一个更新，或者都进行路线了一个安排，循环一次再来一次，再来一次之后再来一次都是没关系的好吧。

所以在你整个学习过程中，老师会为你保驾护航，你在什么时候遇到什么问题，记者老师沟通，老师都会给你讲解对应的路线，点一些最适合你自己的一个安排，好吧，那么讲到这了，有人好奇这门课多少钱呢。

好奇的给老师扣个一，有人好奇吗，其实刚刚我还扫了一个很重要的环节，没有讲很重要环节没有讲什么东西，这些课都是有一些老师讲解的，有人好奇咱们机构老师吗，燕青要说，所以说有没有怎么学讲解，没听懂啥意思啊。

2万多嗯，嗯不需要2万多，不需要2万多，这里面啊我先跟大家说这些东西啊，先把咱们的老师给大家说一下吧，就是你看完这些老师之后，你就会知道这个课程里面，具备什么样的一个实力，好吧。

首先老师有哪些马士兵老师，我解释了吧，红同学可能都是看马老师的视频直接入行的吧，这两马仕明老师除了马思明老师之外，还有我们的周志磊，朱老师是吧，讲i o的，讲release啊，大牛老师。

我把这个视频关掉啊，声音大妮老师好吧，很多同学生评价周老师课跪着听周老师课，如果你见过周老师本人的话，你会发现周老师的发量也非常感人对吧。

除重要之外，还有我们的超空杯曹老师，他是之前阿里的花名叫霍州，我们一样支持备调对吧，包括还有我们的徐克徐老师，他也是阿里的阿里的p8 花名良禽，营养知识被调好吧，还有还没写完，等会拖拖一下，对吧。

还有我们的黄金王俊，黄老师之前也是阿里的，发名叫博西，游戏是吧，包括还有我本人好吧，应该这个吧对吧，应该对我意思就有一定的了解了对吧，包括还有我们的左成云朱老师对吧，俗称左神嘛啊。

讲数据结构和算法的老师，包括我们还有一堆的张福刚，张老师主要是讲大数据的，国内第一第一批检查数据的呃，老师包括还有我们的肖斌啊，肖老师以及我们对应的杨淑娟，赵老师，赵珊珊，我都不相信姐姐介绍了啊。

赵珊珊老师对吧，还有还有谁啊，吴磊老师e的专家，还有我们的，陈瑞峰老师对吧，我们的邓洪波老师对吧，我们的严正涛老师，我们的呃谭老师对吧，包括我们从那个呃之前在京东，现在碰到新浪微博的孙老师。

给大家讲大厂15班的对吧，包括我们有呃录陈坤陆老师对吧，还有我们的毕老师李旺盛，毕老师对吧，一级点点点点点一堆啊，这个老师我给你数不完，马视频教育，光老师好，四五十位肯定是有的啊，这一点都不夸张。

所以你过来之后，你能收到各个老师详细的一个照顾，所以把心放肚里边过来看，他是跟着学就可以了，这些课程都是由这些老师来给大家进行讲解的，所以这么牛的课，这么完整的学习路线，加上这么多老师啊，对写错字了。

我对不起你啊对吧，这么多老师好吧，所以足以保证我们对应的课程质量，所以当我们提到了，我们说这个课门课多少钱，阿白说2万多，其实不需要2万多好吧，今天是咱们的训练营，那么我想说的是啥。

同学们今天训练营有一个专门的专享福利，可以给大家看一下什么专项福利呢，就这东西好吧，今天晚上训练营里面我们就要顺势而为，乘风而起，mysql调优专属直播间，mca架构课程，架构师课程。

今晚原价格是24980，今晚只有十个名额，可以领取一个121万2000元的大额优惠券，比如说今天晚上，你实际的成交价是12980好吧，这些优质的课程内容我就不说了，最关键是这边今晚报名之后。

你能够享受我们对应的课程更新是吧，同时再说明一件事，同学们一件事，什么事，仅限前五名赠送vip的黑卡服务，我们有一个vip的黑卡啊，这个vip黑卡我希望你领取一下，今天晚上仅限前五名黑卡是什么意思。

黑卡代表是你对应的福利保障，这图有点小啊，哪个小姐姐把这个黑卡图片给我发一下，那位小姐把这个黑卡图片给我发一下，我这没有这个黑卡图片，谁给我发一下，这个黑卡里面代表什么，代表你对应的福利啊。

代表你对应的福利啊，好了，来给大家看一下好吧，叫成定制，未来成就更好的你，这是我们的口号，说了第一你的vip黑卡会想到什么，第一叫个性化方案定制，第二个叫大厂的优先内推的机会，第三个叫以报名体系课一元。

每年的持续更新服务，什么意思，刚刚我给大家看到了，我们的课程一直在持续不断的更新的好吧，那么每年你只需要象征性的给我们交一块钱，那么我们就可以把这个课程更新，你可以永久的一直听下去，一直听下去。

但如果你不是vip黑卡的话，那不好意思，你能想出权限只有2年的时间啊，当然这个一元的这个权限给大家说，很快就没有了，前两天马老师做直播的时候已经说过了，之后我们的vip黑卡的权限。

如果想享受课程升级的话，每年是888元，今天这个训练营只有一元美元，所以如果需要的。

当然我也说过了，这个权益不是所有人都有的，仅限前五名，所以抓紧时间去抢就完了，同时今天在网上报考的同学可以享受白条，有钱花，信用卡，花呗等一系列的六期分期免息名额，当然这个名额也是只有十个哇。

多的也是没有的，所以需要的抓紧时间联系咱们的小姐姐，扫屏幕上的二维码就可以了，如果你之前加过任何一个咱们自己老师，不需要储物家告诉他，我是从连老师直播间过来的，我要去领取对应的优惠以及黑卡服务就完事了。

这么简单好吧，所以抓紧时间吧，龙帅说，都是网课，对咱们现在没有这种线下课，全部都是网上直播，因为现在我们的学生人群，重点的话是在职的学生，所以他不可能说我拖延多长时间，我来做一个完整的机器学习。

这是不可以的啊，所以我们工作室网课，每天晚上你只需要拿出两个小时的时间学习，几个月的机会，3~5个月涨个几千块钱，对这边而言是非常非常容易的啊，非常非常容易的，所以抓紧时间抓紧机会就可以了。

这边所有享受的课程更新都列到这儿了，如果你想要这个课程更新更新，今天一来就完了，就这么简单好吧，关于活动相关的点，不过大家要这么多好吧，我身边一个pc一个平方，一个p9 。

所以如果你想拿到更高的一个薪水，你是需要跟更牛的人一起服务的，好同学们永远注意一件事，如果你想让自己变得更牛逼，一定要认识比你牛逼的人，你在跟人做对比的时候，不要只看那些比你差的，你要看一些比你好的。

混的比你强的，这样的话你才有提升，你现在跟比你差的比你永远感很足，你平时意识不到自己存在的问题，你懂我意思了吗，好吧，有没有项目实战，我刚刚在展示大纲的时候已经给大家说过了，好吧，在最下面的时候。

我们有对应的项目实战，比如说我们的多人在线网游，服务器相关的一些课程，包括我们的东宝商城一个电商的单体版本，包括我们的东宝商城的一个，分布式微服务的一个版本，以及我们对应的网约车，飞机的出行。

网约车项目，还有我们的推荐系统的项目，和我们流失云平台的项目，这边全都有是吧，东宝商城里面包含什么，包含这些东西好吧，完整单元dios代码规范落地实践，包含了我们一系列的基础设施服务。

这里包含了我们对应的分布式id中心配置中心，分布式锁集群事务集群，缓存集群，网关服务集群，注册中心，监控中心，m q es任务调度，tx mysql哇，业务方面的话包含了用户中心，商品中心，库存中心。

订单中心，搜索中心，评价中心，客服中心，推荐中心等等，企业东西自己看好吧，网课遇到不会的，找谁问，你这个问题说的非常非常好，如果说老师，如果我在学习过程中遇到不会的问题，我应该怎么办好吧，来给你看。

我们看别的啊，看这东西，这些学生前两天就前两天刚给我发的这些学生，我讲完整东西好吧，再说了，老师这个注解会导致什么问题，好吧，这是我的问题，老师给我们解答一下好吧，两字要这么讲的。

这是跟这个人整体的一个答疑的过程，他发的信息，然后呢我来给大家做一些解释，给他进行相关的一个调整，听到了吗，你有问题，每一个学生报名之后，老师会给你做规划，除了做规划之外。

会给你拉一个独特与独属于你自己的一个群，你有任何问题可以直接在群里面跟老师进行沟，通，明白了吧啊，包括你相关的一些面试过程中，遇到一些面试题，也是跟老师自行沟通，包括我们在官网上面有自己专门的知识。

问答社区，就类似于是一个问答系统，你可以把你的问题都提上来，看一下已解决的问题，那每天我们有专门的老师，在专门的答疑团队在里面去解决，这些相关的问题，都是有回复的，听明白了吗，这啥玩意儿对吧。

theta t模式看到了吗，老师都会给予对应的回复，所以不管是情人也好，还是我们自己的问答也好，你都可以在里面进行提问，明白意思是他学生说，过去每个学生都是这么回回的过来的吗。

反正大部分同学遇到问题之后，老师都会给予回答，就比如说我今天晚上上课，我在上课，你们去看一下我个人微信，我都没退微信，这是我个人的微信，现在有44条消息没回，我下课之后。

我也要去给学生们做一些问题的答疑，问题的解答，这也没办法，因为学生们在学习过程中，一定会遇到各种各样的问题，那遇到问题的时候，你只能去回复吗，很大的工作量，咱们有老师。

这你不用担心好吧，这不是你需要担心的问题，你需要担心的问题就直接就一点好吧，你能不能学会东西，能不能学到东西就这么简单，回到几点，老师上午的时候老师一般都在休息，但是像下午和晚上，老师一般都在回答问题。

昨天晚上我还在跟一个学生聊天，我可以给你看一下，是一个国外的学生，我们聊到差不多一点多，我给你看啊，这个学生我这给你看嘛，没关系的，能看到吗，看到吗，再跟大家聊天，回到起点，我这事不跟你不敢领保障。

但是我最终跟他聊天的时候，聊到00：46，0。46，这老师有问题的话，老师也一定会给你对应的回馈，而一定是对你给你给你回答是凌晨的时候。

今天凌晨看到了吗，这个你不需要担心好吧，主要这个东西我们做不到的是我们的问题，这里不需要不需要担心，ok这种问题可以直接问老师吗，那不问老师问谁啊，所以你过来之后，你不是说你单单买了一套课。

我们其实一直想打造的是一套东西，什么叫程序员，那一套在线职业提升的一个技术解决方案，所以从你开始学习开始，老师会在你整个职业生涯里面为你保驾护航哦，你只需要踏踏实实干就完了，所以我说了。

今天晚上在这个训练营期间之内，同学们报名的话，成交价只需要12980，前五名可以免费获得我们对应的黑卡服务，同时有个同学老师，我手里没钱，没关系，我们有六期分期的名额，但是依然只有前五名。

所以同学们有需要的话，干就完了，就这么简单，好吧行吧，多余的废话，我这就大家都说了吧，啊我觉得相关的点都解释清楚了，或者你们有什么问题的话，也可以直接抛出来问一下，如果没问题的话。

同学们可以仿照上面这样的格式，我会给大家做出一些对应的规划，或者给他做出一些对应的建议，当然有的同学可能会好奇一件事，老师我学完你们的课程之后，我最终能达到什么样的一个效果。

今天下午在群里面还有一个学生在问，说他有一个学生我忘了是谁说的啊，说他有一个朋友从8k涨到了25k，你觉得可能吗，那么我问一下，我忘了下午是在学在群里面聊这个话题了。

你觉得一个人有可能从8k涨到25k吗，有没有可能这有可能扣一，没可能的话半年吧，我们不拿多长时间就半年了，可能吗，说明一下这种情况有，但它不是它不是一个普遍情况，但是不意味着这件事情他做不到。

做不到那样吗，是挺离谱的，但是确确实实还有人做到这件事情，我一样，我可以给大家看一下，像我那同学说完之后，我给大家截了一个图，我手里面还确确实实确实有这样一个学员，给大家看一下。

这是去年的时候报名的一个学员，2022年11 11月13日说，梁老师，我阿里巴巴面试通过了啊，我说我说我手机在迁移数据，刚买了新手机再迁移数据对吧，没法给他打电话，说没事，微信跟您说，估值到p6 。

昨天谈到offer，下周应该offer被调了，上个月28号开始面试的，给了25k直接就接了，我说这算快的了，涨薪多少，所以说去了飞猪出行，原来是8k涨了三倍多，我说厉害了，他说我说我这个不能算招生。

我说我说必须可以国企出身，学了多久，学了应该半年多，20年4月份买的课，才看了课程的1/3，看了吗，迈进大门了，后续继续努力，感谢林老师，感谢机构，就知道报这个准没错，看这意思了吗，好吧，然后往下走。

他还干什么事，他自己成功之后，他说老师11月16号的时候说，老师我有个室友想报名，想了解咱们的课程，下车有空咱们电话沟通一下对吧，打电话，然后还有什么老师。

我这边缺人，咱们这有差不多的嘛，h c还挺多的，把他们的招聘要求发过来了。

要求要要人，所以你只要跟着咱们的课程体系，踏踏实实地去进行学习，进行技术一个储备，掌心这件事情真的没有大家想象中的那么难，明白意思吗，啊我一直给大家说一句话，我说如果你想干一件事情，办法总比困难多。

而如果你不想干一件事情，那么困难总比办法多，就这么简单，所以你想不想，或者说你想达到什么样的一个目标，你想追求什么样的目标，如果你想，你就要动起来了啊，而且你要抓紧时间跟着干，加油干，你好意思吗。

如果你不跟着干啥的，就完犊子了吗，这么简单是懒，在如是说，妈耶妈耶咋了，别人达到目标还能拿到吗，这个也不是一个个例，我不是说拿一个个例情况给大家进行展示，呃我可以给大家看一个东西啊。

我之前记录过我手里边掌心学员的一些情况，做一下这个文档啊，我专门理了一个文档，然后文档里面就是我们掌心的学员的情况，怎么没了，这里面我把我们现在掌心的学员的情况，基本上都记录名字，基本上记录下来了。

我一会儿我可以可以看一下，对应学生的一个信息，诶，我没流到哪去了，说一下，找一下，等一下这个，那我给你看一下好吧，这时有一定的学员都找到对应的工作了，给你看几个吧，咱也别多看了好吧，3年正常性有多少。

这要看你在哪个城市啊，你城市不一样的话是不一定的，当时看这学生呢，在哪联想通过你的修改简历好吧，我已经拿到了20k的offer，给他发的东西如你所愿，17+2，17+3转正，就这学1号可以入职吗。

甲方好做的海外金融项目，我本来是去试水的，没想到就成了，谢谢联想，如果没有联想的，知道我没有没，不仅没这么快找到，把视频交给联想最好满分服务，看到了吗，拿了几个offer，17+3 k的，19x13的。

看到意思了吗，这学生基本情况，12说认真学四个月能涨多少，这要取决于你现在的贝斯多少，以及你对应的目标多少，这个没法统一给你概述啊，但是按照我们学生大部分的一个普遍情况来说，普遍情况来说。

如果你学四个月涨个5000块钱是问题不大的，张5000年问题不大好吧，这是一个学生了吧，还还想看自家学生资源案例吗，想看给老师扣个一，你想看的吗，我可以看我手里的有多少同学，他成功找到工作还有吗。

有很多是很离谱的，有很多也不太离谱，好吧，来给你看一下吧，看这个哥们儿，这哥们什么情况，我们来看，这是21年6月份找我的，说梁老师上次那个面试的，我学完了，可以给我制定一个新的技术提升方案吗。

已经规划过一次了，这是规划第二次，大家要重新规划，我涨薪了吗，说涨薪了到40了吗，这个学生我印象比较深，他年龄比较大，然后想从想一个月之内，从一从31可以涨到41k吧，应该是我没记错，好像是这样。

我到40了吗，我记得你7号40的都对到了，拿到了41k老婆说这是多久了，两个月吗，说是的，大家可以看一下这个时间，他找我汇报的时候是6月23号，你可以往上翻，我们整个规划服务里面给他做个答疑。

简易的批改，整个这个过程，他当时报名的时候可以给大家看一下，这是几号，2021年4月29号，从4月份到6月份好吧，它的期望其实也非常简单，慢慢看，目前心率是31k对吧，计划1~2个月之内期望40。

他真的成了这个什么，所以不要小潮说我能不能做到，你只要敢想就能做到安排，说有成都的吗，还真的有成都的呃，成都的我给你找一下啊，成都，不是这个，我从那搜吧，我从那里搜吧，这是我们对应的就业细胞强在里面。

一定有程度的，看这个，这儿有写吗，看一下有写成就吗，没写是吧，梅西换一个，看到他说已经入职了，看这学生情况啊，他说已经入职了好吧，然后呢，薪资多少涨多少，接近翻倍了，学多长时间，学了三个月啊。

他也是成都的，再来一个这个这有写吗，我没写到啊，收到几个offer，电力封了，然后叫能拥有的，然后两个公司好吧，去年的时候面12k都是比较虚的，袁老师好，哎，这个有，这是我的学员，我说一下这一封。

哎知道了，再往上看看，这哥们，我说了，我这有很多成功的一个案例啊，往哪走，看这个吧，我说的是拿几个offer便利蜂的好吧，然后呢创业公司然后拥有的给多少钱好吧，一个是外包面试官聊怎么怎么样，往下看。

这次去做工资拉项目，丰富经验对吧，涨薪了13k吗，对长期在不止还有两金和期权，以前的五险一金都是最低标准，还是全额对吧，以前1年15万，现在40万啊，差差点三倍了啊，今年沉淀学习了半年。

去年面12k的都很虚，今年各种大厂都不带怕了，看完意思吧，是个人的一个情况，我可以看一下它是不是成都的啊，中间被清理了，算了都被清理了，看不到了。

怎样程度的好吧，明显程度的保持个人的一个情况，所以呢掌声案例有很多，关山月说我没有自制力，没有自制力不可怕，没关系，咱们可以有班主老师督促你来学习，这个你不担心好吧，只是说没那么多时间来学习。

每天两个小时的时间，有没有，我要求不高，你每天只要拿出两个小时的时间，进行技术储备就够了，只要两个小时，明白了吗，梁老师辅以ok来看这个吧，刚刚有个学生发了一个规划的案例啊，来看一下微信昵称啊，问号。

然后呢哪的辽辽阳是哪，24岁男，目前就是2000。5年大专如火，如果体是啥意思啊，被生在吗，大家也可以把你们个人的情况，按照这样的方式发一下，发完之后给出一些个人的建议好吧，是如何储备技术吗。

你现在我不知道辽阳市，我不知道辽阳是哪个城市啊，有人知道吗，你不知道城市哪个城市啊，但是按照你现在的薪水，和你现在的工作年限的话，你的成长空间是非常非常大的，你需要把你现在具体的技术。

踏踏实实的储备完善起来好吧，什么技术，比如说像现在面试中必问的一些微服务的，一些分布式的好吧，一些关键的核心点都掌握好，把一些技术的底层实现掌握好，我觉得如果你在辽阳，我不清楚这个城市的薪水啊。

如果你去到北京的话，学到明年金三银四，你到北京至少保证你10k以上的薪水，挨着沈阳是吧，最起码保证你10k以上的薪水，如果达不到，我个人可以掏腰包退你学费，就这么简单啊，所以关于提升技术这块没问题。

好吧啊，这学生说我在，如果你现在只是想提升一下你个人的天才，学生啊，如果你现在只是想提升一下，你自己的一个技术的话，好没问题，放心在，然后建议你24岁还小，最好能去大城市里面冲一冲，拼一拼啊。

拿到更高的薪水，还是那句话，学到明年清算一次，到北京10k加的薪水，如果达不到，我退你学费，明白了吗，可以啊好吧，关山月说，武汉小姐姐跟我说，这个课程越早待会越划算，我目前准备突围，看工作需要多久时间。

如果突击的话，看一下你观察也听好了，你是否是想脱产学习，如果脱产的话，一个月一个月时间，一个月时间啊，把咱们对应的一些面试突击的关键的核心技术，看他身世的储备和完善一下，百分之百是没问题的，不脱产。

不脱产，每天两个小时，拿出两个月的时间，拿出两个月的时间，把你的技术做一个完整的提升，我现在还不知道说，你希望的薪水大概涨幅到什么样的一个地步，如果你只是说涨了几千块钱，那这事非常容易非常容易啊。

所以你最好把你的详细情况能给我说明一下，可以按照这个同学写的这个格式啊，可以说明你对应的一个呃这个核心点好吧，我们现在对于我们现在的学生也是一样的，我们并不要求你每天要学四五个小时，六七个小时，不需要。

我们只需要你每天拿出两个小时的时间，来进行对应的技术储备就完事了，就这么简单好吧，我们一直强调一件事是，什么叫零碎片化时间，系统化学习，你不需要一定要有说很多的一个整块的时间，来进行技术储备。

只要你不停的在学习，按照咱们老师给你规划好的路线，来进行技术储备就完了，就这么简单好吧。

关山月明白了吗，所以如果你有需求的话，最好能给我详细的做一个描述，好详细的描述一下，ok，你的比如你的城市啊，你对于那些情况我就好好说一下啊，这样的话了解你情况更具体。

更具体的话能给你们的建议就是越完善的，反正我们拓展学习的同学，基本上就是一个月两个月左右时间，一个月两个月左右时间脱产啊，不是不是脱产了，突击的学生有短时间跳槽的，如果说你短期配合的话。

你还需要储备很长时间的话，你就没必要了，所以呢每一个学生在进行学习的时候，他大概其实分为两个维度，第一个维度，第一个维度我们叫突击学习，第二维度叫系统化学习，初期学习只是为了保证你在短期之内能涨薪。

但是最根本的和最核心的点，还是要进行系统化学习的，比如说我们会为每一个学生规划系统化的路线，然后你按照路线来进行技术储备，完了好吧，好了别的了，还有什么问题吧，哎呀你还在吗。

其实啊刚刚给大家展示我们的课程大纲，展示咱们的老师，然后展示了咱们的学习路线，然后展示这些东西的意义在什么地方，其实就是为了给大家显示说你过来学习之后，你需要把把心放肚子里面。

只要按照路线踏踏实实的去储备和完善，你的技术，不完事了，就这么简单好，最后再说一下吧，今天晚上咱们训练营期间有专门的专享名额，好吧，然后呢只有十个名额，前五名可以抢占对应的黑卡啊，过了这五名之后。

黑卡就不再赠送了，ok，那么这个优惠优惠打了，哪里领，我说了，扫描屏幕右上角的二维码，如果你已经加过马士兵教育，的任何一个咨询老师了，那么没关系，直接去找他，说我是从李老师直播间过来的就可以了，好吧。

我说了，你扫码吧，应该能找到吧，我试一下密码应该没整过吧，可以扫啊，你可以直接扫了哦，可以直接扫码，主要是学费太高了，有点压力，我说了，如果你觉得学费高的话，咱们这边有分期免息的名额，你分六期的话。

12000块钱，每个月大概还2000块钱吧，好吧，阿贝多，只能今天吗，对只能今天，因为我说了这些黑卡福利也好，还是六期免息服福利也好，只是当前这个训练营专享的，过了这个训练营营或过了。

今天晚上12点就没有了，没有了，ok我还要和媳妇商量一下，你商量吧，这个花这么多钱肯定是要商量一下的，你该商量就商量吧，还有什么，钱在他手上，真的我也结婚了，我深有同感，我的钱也都在我媳妇手上。

已婚男人的悲哀我可以理解好吧，但是啊你抓紧时间找你媳妇聊，还是那句话，今天现在的这些福利只有新版有过了，今晚就没有了，就很简单，好了，别再发什么问题吗，问这话我不聊了，我讲了两天了，我也挺累的。

昨天啊还有很多同学找我做规划，今天没了，我都交完了，虽然我觉得分析了好多同学最现实的一些情况，老师介绍的活动就是学流行的优惠是啥意思，什么叫老师介绍的活动，就是学习路线的优惠是什么意思。

这个活动啊是对应的学习路线的一个课程，那个学习路线的课程叫什么叫m c a马士兵，certified ark te，把sc课程体系里面包含了java整个体系里面，所有的技术点。

只要按照技术点去进行技术储备就完了，所以这个刚刚展示了一个优惠，也是mc架构师课程的一个优惠，猪鼻说你们有go on老师吗，有啊我们有张三老师又在讲go浪的，刚刚给大家看了一个东西啊。

就是去了后天更新里面有一个go web的一个实例，就这个美女老师给大家讲过了，好，我给大家看一下课吧。

赵云的课好吧，各位吧，刚开始进行更新，还没上传吗。

什么意思，无法播放，这有问题啊，明明还没上传上去啊，上去之后就都会有对应的课程了好吧，这个老师来讲了，找商山老师好吧，数学老师不是说有一个6+12的分期吗，那个是什么，那个是呃，有钱花一个学习。

优惠和细节方面的东西，我也不太了解啊，如果你需要的话，可以找咱们的那个小姐姐去问一下，具体系呢我也不太清楚好吧，老师现在我有一种现象，我是学钢管的，但是公司需要优异的前端，没办法啊。

这是小公司里面存在的一个通病啊。

大家永远记住这件事，什么通病非常简单，就有多少同学想做全站的标志，扣个一有吗，有多少人想做全站，给老师扣个一，在正儿八经的大公司里面，其实是没有全站工程师这样的一个职位的，注意了。

小公司里面他想让一个人发挥多个人的价值，所以他会让你做前传，前后端什么东西你都要一个人接触，但其实蛋和生产规模的公司，基本上是专人做专事，明白吗，现在有专门的前端工程师，如果你把前端的职位的工作都办了。

那前端人干嘛呢，这是闲的没事干了吗，能明白这意思吗，所以这不是最主要也不是最关键的是，你需要的是干嘛，把你的技能里面的某一块做到极致或学到精通，这才是最主要的最主要的好吧，所以啊我不建议大家做旋转。

如果你是做后端的，做java的，就把java后面那条路线给储备扎实，储备扎实，高级工程师网架构发展不是还需要会前端吗，不需要你会前端，不需要会前端好吧，现在前端的体系也变得非常非常复杂。

你变得非常非常复杂，你不能说按照一个就是嗯怎么说，你把整个前端的架构也要搞得非常清楚，这个不需要这不需要好吧，专人做专事是最高效的开发方式，这个vip黑卡是干嘛的，哎呀刚才说了一堆都白说了。

我再来解释一下黑卡该干什么事了，好吧，这是我们黑卡的福利，黑卡里面享受的福利是什么，第一个叫个性化定制方案，第二个叫大厂优先内推，第三个是最值钱的，刚刚给大家展示了五个课程的更新，如果你没有黑卡的话。

你只能享受课程的权限，2年的时间，但是如果你有了黑卡之后，你可以享受一元的持续每年的升级更新服务，如果你没有黑卡的话，你想升级对应的课程服务的话，你需要花888块钱来进行购买，听明白意思吗。

所以这是最值钱的，包括你可以去手机上面的应用商店里面下载，码视频教学的a a p a p p里面有很多的课程，如果你是黑卡用户的话，可以享受最低的折扣价，这都是给予我们的vip学生的一个福利。

一个福利好吧。

是黑卡存在的意义，我说了，黑卡不是每个学期都有了，包括我们之前报名的v i p也一样，不是每个人都有，我们只是在不定时的时候会送出一些黑卡，福利啊，这个要多少钱买，今晚报名的话。

黑卡前五名是免费送给你的，但是我不知道现在还有没有前五名啊啊啊，今天晚上是免费送给你的，如果你正常情况买的话，我还是那句话嗯，黑卡现在我们不卖，黑卡现在是不卖，我们只会给我们定期的给一些vip福利。

不定期的给我们的一些多名学员进行赠送，今天晚上和当前训练营里面是前五，有只有前五名是有的，所以前五名是没有的好吧，vip能看go on的课程吗，我们会赠送一期go浪的课程，但都浪后续的课程更新就没有了。

布朗克斯克后续的课程那些就没有了好吧，呃内推有什么要求，还是直接就可以内推，我怕我到时候学了学了找不到满意工作，阿白把你的心放肚子里边儿，呃前两天我们有一个学生，他也是他自己的学历是有问题的。

所以导致他进不了京东，然后我们的老师帮他内推到了我们的京东，就这啊我说的是内推到京东了，什么写京东，他那些京东之后，他还给我们的那个呃陈老师还送了一面锦旗，我给大家看一下，这锦旗呢我又完了又没了。

来看一下这个，这是我们的曹老师好吧，金星培育传技能受益终身赶尸mc班白宏宇赠予。

看到了吧，就是内推这方面你可以放心，而且我给大家看一下咱们内推有多么有实力，好吧，嗯叫这个吧，应该，页面没了吗，我要看一下字节，给我们内推好吧，你看这张图片，他说我是字节跳动直播平台的研发负责人。

看到马老师的课程材料，觉得可能有不错的学员推给我，直接安排面试，就这个人工牌叫什么涛，你们如果有自己有朋友的话，自己有朋友的话，可以支持背调，看到吗，这个你放心是吧，包括这边我们一堆的企业内推。

如果你需要，你可以来看看好吧，都是给内推的，国内一线大厂里面。

我们几乎都有内推机，都内推好吧，呃余墨发了一个人情况，我给大家看看好吧，21岁，吴西方行资15000半年，本科想走后端路线，学过java，没做什么项目，如果春招想进中小厂，是项目重要还是基础重要呃。

如果你是参加校招的话，我觉得技术实力比较重要，就是比较重要，这块我也可以给你看一个学生的情况好吧，也是之前的一个学生，他个人什么情况呢，可以给大家看一下，就昨天啊我给大家展示过这个相关的信息了。

这个学生呢他这个学生报名的时候是什么，报名呢，是2020年11月份报名的，其实就相当于是你的学长，上一届的一个学生，你可以看一下啊，这学生这是勾中间打印服务啊，他找我的时候是12月19号。

可能消息没同步啊，12月19号，然后找我的时候往下走，这个学生他也是想参加春招，感觉参加重装没希望了，后面给他改简历，告诉他你怎么进行储备，怎么去谈心，怎么去储备技术，做了一堆的工作，然后呢往下看。

在最后面的时候，他搜到对应的offer了，属哪了，入职是滴滴的，虽然薪水不是特别高，但他入职了，往下看，老师一那边已经确定下来了，也签好了，三方最低的白菜价，19x15+5 k的握手费啊。

今年6月份毕业，招的时候是21年，看到了吗，就相当于去年的时候。

他跟你一样，也是11月份来报名的，报完名之后收到b offer，所以这个余某把心放肚子里边，没问题的，你过来之后，老师会给你规划一个单独适合于你的，内推的服务，你根据这个服务好吧，内存单独适应你的路线。

你按照路线去储备你自己的一个技术就行了，还有握手费吗，握手费这东西啊，看公司，有的公司是有这个公司是没有的，好吧，呃这个要多少钱呢，请您赠送，还有一个令若先来看一下吧，运用心是什么城市。

3年南京29任信息工程培训出身，运营商项目中业务一直是919 11 六，c l o d刚离职多个offer方向，我们不确定怎么走到这未来方向，互联网有希望吗，如果不行，互联网架构有信号板吗，呃个人建议。

个人建议最好能进到互联网公司里面，这样的话对你之后的发展是比较有好处的，如果你进不到这种官网公司，还有这些传统企业，那么对你之后的发展可能会受限，最好还是进互联网金公司，你现在的话大概是9+3 k拆补。

然后期望是18k，南京拿18k我觉得没问题啊，南京有一个公司叫苏宁易购，你知道光苏宁易购有多少学生，咱们这报名吗，401构的学员至少有十几个，他们都是直接朋友推荐过来的，就很简单。

因为南京啊大厂相对也比较少一点，所以如果你想拿到更高的薪水的话，你的技术实力是一定要足够扎实的，所以拿18k这件事情可没那么难好吧，没那么难，给大家看一下，应该有南京的吧，南京的啊。

这哥们儿跳了涨了4000，南京好吧大但是还是在外包，然后再看这个这个学生涨了3000好吧，后面造造成上万再考虑跳槽，现在底气还不是很足对吧，这个呢从北京到南京这边好吧，你在北京收了多少14，然后说20。

他们说涨幅只能在20~30%之间，t3 这边给到24，南京有个t3 出行直接给了24k的月薪，主要看数学班的课程，mysql redis这边我们多线程好吧，其他的没时间看，今年3月份开始看的。

到后面还是想系统的进行一个技术储备，从南京拿到18k的薪水是没问题的对吧，这也是南京专科学生，今天涨停过吗，翻倍从8k到15k，南京看到了吗，同学魏若欣，你还在吗，这都是咱们南京的成功的案例。

我们来看前两天面了，也给我发offer了，税前30k年薪大概40万，现在是一家创业公司，24。53星对吧。

他也是南京的，你懂我意思吧，哇所以看这种情况，像cs double这件事情没那么难，ok完了我还在加班，老婆睡了，能不能给我留个名额，拜拜好吧，小明说有定向内推吗，听懂这些吗，呃有啊。

大家知道我们跟京东现在的合作是什么，有一个东西给大家找一下，我们现在啊跟京东那边是定向的合作，给大家看一下，这是我们马士兵教育，跟京东java互联课程的一个独家合作。

我们派曹老师和我们的老师去其中里面进行合，作一个谈判，并且签署了专业的一个合作协议啊，这里面包含了我们对应的一些架构师，课程的一个课程共研和人才的一个贡献体系，看到了吗，包括我们后面会给京东那边。

进行课程的一个宣讲，课程的一个授课，所以如果你想进京东这边，百分之百是没问题的，明白了吗，sn啊，你只要把技术储备扎实的，进京东还是很容易的，我给你搜一下京东吧，咱们进京的学生还真的很多啊。

看那个老李老师，我是京东了好吧，之前的offer没跟你说是吧，15x14，他是在武汉，他是在武汉，武汉入职京东了，然后这个形容也是感谢zm机构好吧，老师我这边最终还是决定入职京东了好吧，18号上班。

感谢咱们机构，10月到12月两个月的时间，能让我知识和技能提升到大厂水平，机构还是牛逼，看到了吗，这学生准备入职京东了好吧，叫b 17~25k涨了8000块钱好吧，8月20号到10月8号。

大概就一个月的时间对吧，这也是我大概写也刚过了京东页面，后续还有什么要注意的，好往下看啊，那走了涨了4000对吧，京东正金什么之类的，所以把先锋做点没问题的，ok繁华3000说2年开发经验。

在杭州上海能拿到多少钱的水平，如果你是2年的真实开发经验，上海我觉得15_{20吧，最起码15}20，15~20，如果更高的话，这个上不封顶，看你个人的技术实力了，看你个人技术实力了，这个没法给你预估啊。

主要还是看你技术水平，但我觉得最低也要15~20，这个范围最低的，我只想跟你说保底的啊，上上面的话就不确定了好吧，所以还是看你个人的技术储备吧，所以说课程都是直播吗，怎么个模式。

上课时间加上自己的学习时间怎么分配，每天需要多久，两个小时课程有直播，直播完的课程会变成录播，所以你在过来学习的时候，是以直播加录播的方式来进行学习的，是你自己的时间，我要求不高。

每天晚上只要能拿出两个小时的时间来学习，就够了，这个孤冠每天只要两小时，要求不高，只要你能拿出两个小时时间，把你的技术踏踏实实的储备和完善一下。

涨薪这件事情还是很容易的好吧，基本上3_{5个月吧，3}5个月涨涨涨涨，涨一下薪水，刚刚给大家看了，我们给大家看了直播课表了，然后除了直播课表之外，已经掌握的直播课都录播了，录播课了好吧，墨丘尼。

成都27，目前九期望23年自考大专，目前专升本中，从事其他行业，17年转行培训六个月，18年工作3年，外包没有三个项目存储交地，我该怎样提升自己，你这样说的很清楚了，你没有三高经验，都是c o d原理。

源码都不了解，那你后面再进行学习的时候，就要把原理和源码当成一个重心，来进行技术储备了，你先记住啊，现在如果你想拿到更高的薪水，会在成都拿到20k的薪水，那么你需要做的事情就变得非常简单。

要把技术不但不仅仅停在应用层面，对很多底层的原理和对应源码的实现，你都要储备扎实，因为你只有储备扎实之后，你才能收获或者获取对应的薪水，如果只是那种技术应用的话，肯定不行。

像现在面试中主要问的我经常说的微服务，分布式中间件，数据库架构设计，这几块东西你都掌握好，当然哪个点先学，哪一点后学，我还是需要经过对你的技术做一个评估，评估完成之后。

才能告诉你说你的路线到底是什么样子的，明白了吗，没处理，所以你自己其实说的很清楚啊，你哪儿弱你就补哪就可以了好吧，珠海36岁，一本5年宁方项目13。5k现场，新天翼五开发还有希望不在珠海。

为什么会没希望呢，我你知道我在给我们的这个这个雨墨春晓同学，听好了，你知道我在给我们的vip做规划的时候，你知道我最害怕什么东西吗，我最害怕的就是学生给我说一句话，我给你搜一下。

这是这些学生们经常给我发的一句话，就这东西，看到了吗，这个这个这个东西真的是我我我，我最害怕同学们这么说，你知道吗，看到了吗。

就很多同学我不知道你接受了什么，是接受了多么严重的社会的毒打对吧，让你感觉自己还有救吗，为什么没救，为什么没希望，我一直说一句话，你只要开始学了，你只要开始补充你的技能了，你只要开始完善你的技术储备了。

你的薪水一定会涨，这不长得不科学，明白吗，所以不存在有救没救，你想达到什么目标，我来评判评判你这件事情说能不能达到，不过达不到，我会给你调整出你最合适的一个目标，你按照对应的目标去进行技术储备就完事了。

怎么会有那么多有救没救，这种话题呢所有人都有救，只要开始学就不晚，这是我们一直秉承一个话题，所以不管什么学校来之后，一直没说老师有救吗，有希望没有，不可能没希望，有希望就要开始学，我最怕是什么。

你不学了，你不学就真的没救了，明白了吗，听明白了没，你没生小，所以有没有叫有涨薪这件事情很容易，你现在36岁进大厂可能希望不大吧，但是如果你只是想单纯的涨个薪水，我觉得是没问题的，好吧，太不自信也不好。

不是太不自信，是你们真的一点自信都没有，能懂我意思吗，所以跟着老师的路线，我们这边服务了成千上万名的学生，总结出了一系列的学习路线的规划，你只要按照路线去储备，他怎么可能没救，其实我们对于学生人群的。

就是这个这个这个这个分析，其实非常非常到位的，我给你看一个东西啊，我帮你问下在不在了，因为还在吗，在页面里面我们看一下，这是我们现在学生的一个情况，我们对我们现在所有报名的学生，做了非常详细的人群分类。

比如说你是大学生还是研究生，想进大厂吗，比如你是非计算机专业的吗，你还是专科学历的，你还是在职海归，你要常年外包，你还是想冲大厂，还是移居外企，还是想转行，想涨薪的，想镀金的，想创业的，想传统项目的。

还是想开发爱好的，非java语言的，大龄危机的，大龄人才的转岗提升的极速，副业的，只要你是这里的类别的人群，你放宽心过来，百分之百是没问题的，好一个人可能会覆盖里面的多种情况。

但是每一种情况其实我们都有对应的成功案例，听明白了吗，同学们每一个情况都有成功案例，我们服务的学生太多了，我们也见识了太多太多的情况，明白了吗，所以在老师这一块，他不存在说没救这一说不存在哦。

只要你想学，只要你肯学，就没有没救这一说啊，我们这个路线一定是最适合你的路线，你只要按照这个路线去进行技术的一个储备，百分之百成就简单，就刚刚那几个细胞强啊，多少个机构成管理了，你可以自己去打开看看。

你自己刷一下，你光看这个就业喜报，你要看一阵子，这都是成学生成功的案例，怎么可能到你这就突然没救了呢，为啥没救了，不可能没救好，不一定有救o，漫里风铃音，你们这名字都咋起了。

上海24拿23年大专通信技术跳两次槽，年6月份收到上海市资金融公司新的14k，之前在郊区做一家互联网医疗工作的，这些技术的话，但是目标还有很大，学以后路线该怎么发展呃，你现在学历不占优势好吧。

但是好在你的年龄还是比较小的，不知道你之前跳槽跳了多家公司呃，跳了两次槽啊，3年两次也还行吧，但不要再多了呃，建议其实非常非常简单，现在把你的技术踏踏实储备一下，你现在14k3 年。

坦白说这个薪水有点低了啊，或者换一句更加委婉的表达方式，你薪水的成长空间还是比较大，还是比较大的，所以把你现在的技术储备扎实，原来学技术有提升，但更多的可能还是停留在表面，或者说没有形成自己的知识体系。

所以你需要从现在开始进行技术储备，把你的基础体系给提升上来，不要再跳槽了，好从今年开始到明年6月份之前之前，都不要再跳槽了，下班之后要突破学习，养成长期学习的习惯，每天拿出两个小时的时间。

来进行技术的一个储备，把技术给成扎实了好吧，然后下一份找工作至少20加以上，记住啊，至少二加以上，就你记住了，永远永远记住一句话，你的技术主要储备扎实的，你想拿到这个薪水，他没那么难，最怕什么。

最怕你的技术不扎实，还想要勾心，懂我意思吧，所以你想你这次跳完之后，14k你之前的话可能更低，所以技术储备是一定需要了，6月份到现在五个月时间了，你技术成长多少，还是要进行系统化学习的这种单片的。

或者说单崩的那种碎片化学习，他真的对你的成长没那么大的好处，好了吗，这个漫里风铃音听漫话，给老师扣个一好吧，明白了吗，系统化学习储备你的技术，完善你的技术储备，把技术给成长起来，就这么简单。

呃半夏北京20 41，希望18+一点，5年本科1年研发经验该怎么提升，建议建议808呃，最合适你的班就是mca架构师课程，把mca架构师课程其实不需要多学啊，我不知道你之前有没有跳过跳过槽。

如果没跳过槽的话，从现在开始学，储备到明年金三银四，在北京城市里面拿一个18的薪水，如果明年金三银四达不到，我可以自己掏腰包，把学费退给你，这就是我的信心，明白了吗，班下这是我的信息。

你现在报名去到明年34月份好吧，拿出四五个月的时间来进行去储备，按照我给你指定的路线去学习，如果达不到18月的薪水，我可以退你学费，这么简单，怎么西安18家，你如果想回到西安拿18加。

它的难度还是比较大的，西安虽然现在发展也还挺好的，但是跟北京的城市的薪水还是有所区别的，明白这意思吧好吧，而且你现在年纪还小24岁，我建议你在一线城市里面多拼一拼，多搏一搏，为什么那么早回去呢。

你在北京过一段时间拿到更好的一个薪水，拿到更好的offer之后再回去，你的身价都不一样，它不香吗，是不是，何必这么早要回去呢，回去干啥，好吧，行了，差不多也十点多了吧，现在还有什么问题吗。

如果没问题的话，咱们今天晚上就聊这么多吧，好吧嗯，很多同学也说了个人的情况，我也把个人的一些经验或者一些建议，也分享给大家了，还是那句话，赛季之后把你的技术储备扎实，所以说定向内推有啥要求，没啥要求呃。

如果你想进哪个企业，我们会把你的简历给你，陈同学听好了，如果你想进到某个大厂和某个企业，我们会提前把你的简历给你润色好，复试做好完成之后，你就可以直接去，我们会把你的简历题给投递过去。

你就等着面试就行了，就这么简单，他没有啥要求，不需要说老师我一定要具备什么样的实力，什么之类的，当然你的技术啊一定要储备扎实的技术储备，不扎实的话，相当于白白浪费机会，不要浪费机会嗯，想去网易。

网易有啊，还是觉得有点贵，没关系，觉得贵你就再看看，还是那句话，你永远记住一个课程的价值，它在什么地方，而且我告诉大家，这个课这个价你可能觉得比较贵啊，但是这个价格其实也不是我们定的，不是我们定的。

是腾讯课堂要求我们这么定的，这样一套完善的课程体系，这样一套频繁化的学习，你觉得多少钱值，如果真的话，五六千块钱你会买吗，很没意义了好吧，而且如果你觉得贵，我说了。

今天晚上前五名同学他会有对应的免息补贴，所以需要的话找他们说年龄领一下，看看现在还有没有对应的名额。

系列 6：P93：什么是缓存穿透？ - 马士兵学堂 - BV1RY4y1Q7DL

今晚的主题，黑客攻防redis缓存穿透的征集解决方案。

通过这节课你可以get到这五个知识点，这些都是你即将出去面试经常被问的好。

我们从一个非常简单的一个问题开始来了解啊。

大伙现在在公司里面做的开发，基本上都是b s架构是吧，来是b s架构，同学扣个一，我看看，ok现在基本大部分都是b s架构，那么b s架构我们大概画一下它的一个，我们站在一个上帝的视角。

画一下它的一个架构啊，这是我们的web服务器tom cat，那么tom cat服务器后面它又挂了文字数据库对吧，比如说挂的是mysql关系型数据库，那这个圈儿啊，这是我们的客户端，这是我们的客户端。

那我们用户啊发一个请求，肯定是发给我们的web服务器。

那么web服务器在处理这个请求的时候，在处理这个请求的时候，他会去我们的后台数据库中数据查数啊对吧，那么随着你客户端的增多，随着你客户端增多，那你tom cat这一侧和数据库这一侧，都有可能会发生瓶颈。

都有可能会发生瓶颈，我问大家一个问题，你觉得随着我们客户端的增多，是tom cat这一侧最先发生瓶颈，还是数据库，这一侧来是tom cat q一数据库的扣二来告诉我，好我告诉大家。

一般是数据库这一次它最容易发生一个瓶颈，一旦你数据库这一侧发生了瓶颈之后，差所带来的影响就是你的用户体验差对吧。

响应时间变长。

这是最直观的一个反馈，那怎么去解决你数据库的一个瓶颈问题。

其实解决瓶颈就一句话，解决瓶颈区就怕减少连接mysql，让连接mysql的链接变少。

它的平均不就解决了吗对吗，那么最开始我们最初的一个解决办法。

我们可以搞一个数据库连接池，网络是可以搞一个数据库连接池。

在这个连接池里面啊，我提前创建好一些数据库的连接，如果你需要联网的数据库。

直接去连接池里面去拿，用完了再还给我，防止频繁的去创建数据库连接。

这最开始的一个解决办法，但是一般我们在最初开发的时候。

把这个数据库连接池已经考虑进去了对吧，已经考虑进去了，如果你考虑进去之后还发生了瓶颈，怎么办呀，你数据库这一层还发生频率怎么办，那可能还有一个办法，就是我们可以进行一个分库分表。

把一张大表拆成一个个的小表，把一个大库拆成一个个的小库对吗，或者我们可以搞集群啊，数据库集群对吧，其实还有一种解决办法，我们可以加缓存层来，有同学这样去解决过数据库平静的扣个一。

我看看通过加缓存存来解决你数据库的瓶颈，来这样解决过的扣一，我看看没有这样解决过的扣二，ok啊来，一般目前啊，解决最常用的办法就是去加一个缓存层，加一个缓存层，那么一般我们会使用，什么技术做缓存啊。

首选就是redis，那么在之前啊可能是ready没有出来，之前选的是memory cash对吧，那么现在首选的是redis。

因为redis他的确是太牛逼了啊，有多牛逼。

我们慢慢来讲二，我们一般在common cat和数据库这个中间加一个redis，作为我们的缓存层，在我们的redis里边，它会去存放比较热门的一些数据，什么叫热门数据啊，一句话解释经常被访问的数据。

那我他妈看了，在查数据的时候。

这个时候他需要先去redis里面去查一下。

你听明白了吗，因为reis它是一个低于内存的数据库。

它的响应时间很快，我的查询速度也很快，并且它能支持海量的一个查询，如果去我的redis里边能够查到的话，我直接把数据返回回来，如果我去redis里边没有查到，这个时候再去数据库中查看。

我们的redis在tom cat和mysql的中间啊。

他给mysql是不是抵挡了一部分的请求啊。

对吧，这样就可以解决，所以再回到我刚开始说的那句话。

你想解决mysql的一个平均问题啊，其实就是减少去连接mysql，那我在这加了一个redis缓存层，是不是给他抵挡了一部分，来到此为止能听明白了，666告诉我，非常简单。

我们加了一个缓存层之后啊，其实它会引来一些问题。

他会引来一些问题。

比如就我刚才说的，我们先去redis里边去查数据。

如果redis里面没有的话，我是不是穿过了redis去找到的是mysql对吗。

其实这个现象啊，我们给它取个名字叫缓存穿透，这个现象要缓存穿透，在你的架构里边，你只要加上了redis缓存层。

缓存穿透一定会发生，如果我想避免发生缓存穿透。

我可以怎么办，大家告诉我，如果我想避免发生缓存穿透，我可以怎么办，就是我不想发生任何一次的划算传动，来告诉我主动刷新同步。

有同学说，还有一个解决办法是牛逼。

如果你想让你的架构里边。

没没有这个缓存穿透的问题，那你mysql里面的数据你得全部同步到redis里面去。

这就牵扯到了是不是数据的同步问题啊。

再说了，数据同步这是一个无解的问题，你不可能保证他俩真的能实时的去同步对吧。

如果你把mysql里面数据放全部放到redis中。

那缓存穿透的问题不严重了对吧。

因为我们的redis这是一个内存数据库啊，你全部放到这里边可能不太现实。

所以大家接下来记住这句话。

我们不能避免，缓存穿透，但是我们可以避免高频的缓存穿透。

来我们不能避免低频的缓存穿透。

但可以避免高频的缓存穿透，原因就是你不能把mysql中的数据全部放在redis，你没有那么大的内存来，这句话能听懂的，666告诉我，唉什么后果，我一会儿会说啊，别着急啊。

好好，再赘述一遍，一定要牢牢记着，我们不怕低频的缓存穿透，我们怕的是高频的缓存穿透对吗，如果我现在来了一个黑客，这个黑客啊是一个低级的黑客，假设比较low比较low，他现在做了一件这样的事。

他向我们的web服务器发起了一个请求，他请求的数据是i d等于-1的数据。

这里面有个前置条件，在我的数据库里边，压根就没有i d等于-1的数据。

那也就是说在你rise里边。

更没有i d等于-1的数据，听懂了吗，哎我现在黑客去请求这样一条数据。

那就是说他请求的每一次，是不是都会发生缓慢渗透啊，如果他请求的频率非常的高，是不是在快速的攻击我的数据库啊，这就有可能导致你的数据库宕机瘫痪啊，哎这个现象能听懂的，666告诉我。

对吧，如果发生这样一个现象，那你的数据库就有可能被攻击了。

那怎么办啊，怎么解决啊，怎么办，就如果你你你的黑客这样来攻击你。

你怎么办，怎么去解决，非常简单解决方案，解决方案非常的简单，就是把它查询出来的数据，我往raid里边再缓存一份啊。

你看啊，你第一次请求的时候去raid是不是没找到啊。

是不是接触了我mysql啊，那你去mysql里面查出来的数据，是不是也是个当值对吧。

查询出来的i d等于-1，y等于n，你再把这条数据再缓到这中，那么他接下来的请求啊，接下来的非法请求，去rise里边是不是都能拿到了，那你去除里边能拿到，是不是直接给你返回了，就不需要接触mysql了。

哎这个解决方案能听懂的。

6666告诉我，需不需要我给你们做个笔记，需不需要我给你们做个笔记，需要的同学扣一。

看来我给大伙花半分钟的时间做个笔记啊。

我怕了，你们只是盯着爽，结果听完之后忘的也差不多，什么时候缓存穿透，所谓的缓存穿透啊，就是虚拟的缓存从中，没有命中数据，没有命中数据接耳啊，进而，mysql中查询数据，这叫缓存穿透。

那。

如果现在有个黑客，黑客通过一个固定的。

非法请求，去非法请求去攻击你的数据库，我们可以采用，浪值再次缓存的解决方案来解决，来通过一个固定的，我们可以采用政治解决方案，但是黑客都没这么傻，黑客都没这么傻，那如果现在拿一个算一个征集的。

或者说已经达到入门级了啊，初级的黑客他每他每次发送请求的时候啊，这样发送id等于一个u u id。

他每次请求的是u u i d所对应的数据，那这样的话我们是防不胜防啊。

对不对，防不胜防。

比如一开始通过一个101111，这样一个i d来请求去ready之后没找到。

是不是接触了mysql，那么第二次他把尾号比如变成了二哎。

又进行一个缓存穿透，这就防不胜防了，如果这个时候你还采用第一种解决方案，就还采用这种解决方案，它会适得其反。

我不知道大伙能不能理解，他会适得其反，你想啊。

如果对于这样一个场景和攻击，我采用这种解决方案，你看来我去mysql中查询了一条数据，value是不是等于ni缓存进来，那么接下来人家换了短就去请求，是不是还是none。

最终你的rise里面存了一堆的n值，那么又因为你的redis它自带了一些内存淘汰策略，比如说l r u l f u等等内存淘汰策略，那么他就会把你曾经那些有价值的数据，直接给淘汰掉。

那么你rise里面存的都是一些某某id，对应的一个量值，所以会起到一个适得其反来，我给你推理的能听懂的66高数，我给你推理的，你能听懂的六个告诉我，给我看给我，ok好继续走。

那既然用这种解决方案，我解决不了。

怎么办啊，怎么办啊，哎我我看刚才有同学说了，我们可以采用布隆过滤器呀，布隆过滤器啊，为什么这个过滤器叫布隆过滤器，你先不用操心。

我现在从过滤器开始跟你聊，我先从过滤器开始跟你聊。

那么对于刚才这个场景，我们是不是可以在redis和mysql，中间加上这么一个过滤器，可不可以，这完全没问题啊，这个过滤器里边他得保存着，你mysql中经常被查询的那些字段的值，我再说一个大前提。

你记好了，比如说我现在的客户端啊，都是通过id这个字段来查数，不会通过其他的字段，那你说我的过滤器里面，得保存你mysql中所有数据的ip号，对不对，保存所有数据的id号在我的过滤器里边。

那么现在有了过滤器，我们再走一遍流程，来来了一个非法id，穿过了redis，到了到了过滤器，这发现你查询这条数据在我mysql里面根本没有，这时候过滤器过滤器是不是直接给你阻挡了。

稍等啊。

ok直接给你阻挡了，这样就可以来解决，而这个黑客场景下的是不是你的mysql攻击问题。

攻击的问题，但是我们要根据事实来说话。

那我们事实呢你去查询数据，又不可能说每次都通过ip，你还可能会通过其他的字段啊对吧，订单号，物流号啊等等，其他的资格，也就是说其他的资格，你是不是都要保存到过滤器里边去，我们一般来说过滤器里边的内容。

我们都要往内存中放，我们都要往内存中放，为什么呢。

快啊，如果你往磁盘上放，那它的过滤效率是不是降低了我的用户请求，这是一条链路啊，你中间某一个环节效率降低。

是不是影响到整个链路的一个效率啊，是不是。

所以我一般往内存中放，那么又因为我现实情况，不会通过这一个字段来查。

可能会通过其他的字段来查，也就是说会导致你的内存比较紧张对吧。

你mysql里面的数据量如果也很大的话。

是不是你内存紧张会更严重啊，那么现在。

进而我们这个过滤器出现了一个新的问题，就是内存紧张的问题。

来到此为止，能听明白我推理的666告诉我。

我给你推理，你能听得懂的666高速。

其实讲道理来说啊，我这个过滤器啊，它越前置越好，你发现了没。

我这个过滤器越前置越好，如果你的过滤器能够安装在每一个客户端上。

这是不是最好的，直接把非法请求扼杀在摇篮里，休想出来对吗，但是放到客户端上，这个可控性就非常的差了对吧。

可控性就非常差了。

来我们我们先不说过滤器的一个位置问题，我们先来说怎么去解决。

你过滤器的内存紧紧张问题，男性的问题转化了。

来如果你过滤器的内存紧张怎么办。

现在来解决这个问题，如果这个问题我能给你解决了。

那你说我采用这个过滤器，是不是就可以来解决。

我第二个场景下的黑客攻击问题，啊啊那么解决这个过滤器的内存紧张问题。

我们需要借助一个算法，这个算法叫不能算法。

我相信很多同学应该了解这个算法，来了解这个算法，同学扣一不了解的扣二，唉好多同学不了解啊，那你今天晚上来对了，听我来给你讲，非常的重要，这个算法面试的时候经常被问他问啊，他不是直接去问你不能算法的原理。

他会通过一些逻辑逻辑题来问你的。

好好听。

首先我先说一句话，你先好好记好了，这句话就是不能算法，它会通过一定的错率来换取空间。

系列 6：P94：布隆算法原理 - 马士兵学堂 - BV1RY4y1Q7DL

记住这句话，不能算法它是通过一定的错误率来换取空间的，先记好，我会给你一个个解释，那么不同算法的原理是什么样的呢，不能算法的原理，它是通过一个b的数组来标识我们的数据，或者说来存来存储我们的数据。

好好听不难，这个算法这个算法不难，假设我们现在过滤器里边，他需要把我们数据库中所有的id号，进行一个存储，那么之前这个过滤器啊，他很实诚实打实的，是不是存的是我们的id的具体值对吧，我再说一遍。

我们之前那个过滤器是很实，诚实打实的去存储的，你mysql里面具体的id值，那么使用这个不同算法呢，它不是存具体的i d值了，而是通过一个倍的数组来标识这个i d值，比如我现在要标识id等于十。

这个id值我说了，他是通过一个被子数组来给大家画个倍的数组，稍等啊，这个，来这是长度为四，假设我搞一个长度为20的，这是12，这个是16唉，这个是20哎，这个倍数倍数组的长度是20。

那么刚刚初始化的时候，所有的位置都为零，b的数组吧，所有的位置要么存，要么存零，要么存一对吧，那么初始化完成之后都是零二，那如果我现在要标识id等于十，这样一条数据怎么标啊。

首先他会把这个id值先传给一个哈希函数，先传给一个哈希函数，这个哈希函数可以是你自己写的，我一会儿会给你讲代码具体怎么实现啊，不管你自己写，还是去使用已经开源的那些哈希函数，总之它需要保证这么几个特点。

第一个特点，它的哈希值它的一个范围必须在数组之内，零到数组的长度减一之间，这这对他的第一个要求，对汉信函数的第二个要求，计算出来的结果，计算出来的哈，希值啊，要读过的散列，第二个条件很简单，来传给了他。

那么传给他之后啊，他会给我计算出一个哈希值，比如泰国计算的，他一直是一，这个哈希值啊，它还代表的是我们这个倍数组的一个下标，也就意味着我要在第二个位置把零变为一，初始的时候都是零啊对吧，那这样的话。

我这个b的数组中的第二个位置的一，代表的就是id等于十来，常规流程我给你讲明白的，扣一，这个非常简单，这个常规流程，来假设我现在又来了一个id号，需要我来标识一下这个id啊，假设是998。

把这个998这个id值传给哈希函数，它是不是也给我计算出一个哈希值，比如说他记得他一直是我，这就意味着在我们的第六个位置，这是第六吧，这12345对在这个位置标为一。

那么这个位置的一就代表着i d等于998，细心的同学肯定能发现啊，这肯定有错误率啊，当发生了哈希碰撞之后，一定是有错误率的对吗，比如我现在来了一个client客户端，我这个客户端啊。

他想去查一下你这个id等于100的数据啊，id等于十的数据，在你这个b的数组里边有没有存储，有没有标识，哎，他会把i d等于十传给这个哈希函数，那么刚才这个id等于十，它的哈希值是不是为一。

那么再次传给他之后，唉，值依然是一，值依然是一，这时候我再去第二个位置一看，哎这个位置为一，这个时候就可以告诉客户端i d等于十，我是标识过的，听懂了吧，i d0 时是我标识过的，但是有这种特殊情况。

比如说我要看一下i d等于100的数据，我有没有标识过把id等于100传给他，ok听我说，我问你他的计算结果有没有可能还是一啊，来觉得有可能的扣一，没可能的扣二，有可能吧，记着看这句话。

我们的哈希函数有一个特点，它的计算结果零到n4 减1b区间之内，也就是说零到19之间，但是有可能还是唯一的，如果这个时候他给我计算出来的值为一的话，我再去第二个位置一看为一，这个时候再告诉他。

i d等于100，这个数据我存在，我标识过，那这是不是就是一次错误，对不对，这就是一次错误，你看他的错误，是由于发生了哈希碰撞而导致的错误，来我给你讲清楚的，666告诉我，ok，所以再回到这句话。

它是通过一定的错误率来换取的空间，首先错误率我们知道了，哎为什么说换取了空间啊，因为b的数组它占内存实在是，太少了，我们百度1下啊，我们来查一下这个bit换算，查一个b的换算。

假设我这个被子数组的长度啊，100万来，这是100万，我们换算成gb是不是才占这么点儿，这100万来，1000万，一个亿，10亿百亿来，我们长度这么长，是不是才占1g的内存啊，来这句话听明白了。

666告诉我怎么解决，我一会儿说哈希碰撞怎么解决，我一会说，ok一演示就发现了，为什么它是通过错误率来换血的空间对吗，来还需要再进一句话，还需要再记一句话，不能算法是由于，存在，哈希碰撞。

所以导致透绿是吧，所以导致错误率来，正要的话，我就给你标个颜色，标红色，那你说我想降低我不能算法的错误率啊，就是来解决你哈希碰撞的概率啊，你哈希碰撞的概率降低了，那你的错误率就会降低对吗。

怎么去解决这个哈希碰撞的概率啊，降低它的概率啊，来咱大伙告诉我，来大伙告诉我，嗯这个写错了啊，我这个输入法它有问题，嗯老是暴露我，今天晚上可能要加钟啊，跟你们的女朋友们说一下啊，好了。

降低哈希碰撞的概率有两个手段，第一个手段加大数组的长度，增加数组的长度，第二个解决办法，增加哈希函数的个数，两个解决办法，第二个解决办法你可能不是特别理解，但第一个解决办法你肯定能理解。

你这个数组越长啊，我这个哈希值的可能性是不是更多，发生碰撞的概率就会降低啊，这个不需要说是不是，第二个为什么增加哈希函数的个数，也能降低这个错误率啊，呃也也能建立这个哈希碰撞的概率啊，举个例子啊。

比如说我现在有一条数据id等于十，等于十，然后我这个数组的长度啊，假设长度为100，随便画了啊100，然后一开始哈希函数个数只有一个，我现在增加到了三个，那也就是说我现在标识一条数据。

我需要把这条数据传给三个哈希函数，听明白了吗，那么第一个哈希函数计算结果比如说是一，第二个哈希函数计算结果比如说是三，第三个哈希函数计算结果比如说是六，那也就是说我现在要在第二个位置。

在第四个位置以及第七个位置是不是标为一，那换句话说我现在标识一条数据，我需要使用是不是三个坑来标啊，对不对啊，需要使用三个坑来标，那你使用三个坑来标一条数据，那么这一条数据就就就是发生碰撞的概率。

是不是降低了，不好理解，没关系，比如说我现在有一个客户端，client客户端，我现在要查询一条i d等于100的数据，你有没有过标，那你说你把i d等于100的数据，传给这三个哈希函数，听懂了吧。

传给这三个哈希函数，那么第一个哈希函数给你计算出来哈，希值为一的概率是不是以1%，那么传给第二个哈希函数，给你计算出值为三的概率，是不是也是1/100啊，传给第三个为六的概率是不是也是1/100。

也就是说他们这三个哈希值全发生碰撞的概率，1/100的三次方，进而降低了碰撞的概率，来听明白的，666告诉我，如果数据越来越多呢，那你就把你的倍的速度变长啊，刚才不也带你去换算了吗。

100页的长度才占一个g的内存，你怕什么嘛，对吧哎应该大伙都能理都能听懂啊，举个别的可能没听懂，你就回去看录播了，唉这个范范说了也说了一个，提了一个很好的问题，提了一个很好的问题。

就是如果啊我这个数组的长度长度只有十，这个长度啊，只有十，我的哈希函数啊，假设一共就有有有十个，我增加到了十个，来十个，我这是id等于十那个数据，我需要把这个数据是不是传给十个哈，希函数对吗。

那么假设第一个和第一个哈，希函数给我计算值为零，第二个为一，第三个为二，依次类推，最后一个为九，依次递增啊，那也就是说我在标识这一条数据的时候，他就给我把所有坑给占满了，所以q的位置是不是都是一啊。

那未来它的错误率一定是百分之百，但这个能听懂的666告诉我，那我们就可以得得到一个道理，得出来一个道理哈，希函数的个数并不是越多越好，需要与数组的长度啊，或者说需要参考，数组的长度。

这就是一个trade off，明白吧，这就是一个trade off，这就是一个调优点二，这是关于怎么去降低它的一个错误率，关于哈希函数的错误率啊，给大家补充一句啊，给大家补充一句，也是很重要。

给它标粗标红，他的错误率主要体现在，就是现在什么这个这个，布隆算法，数据存在，那么实际有可能不存在，如果他说数据不存在，那么一定不存在，来好好琢磨一下这两句话，宁可错杀3000，绝不放过一个的感觉来。

感觉来了，666告诉我，来感觉感觉有的666告诉我，就如果他告诉你，你这条数据不存在，那说明他从来都没有标过，那是真不存在，如果他说存在，它有可能不存在，有可能是发生了哈，希碰撞对吧。

好啦你看通过一个不能算法，我们就可以解决，刚才这个过滤器内存紧张的问题，内存简章的问题，那你说对于第二个场景下的黑客攻击，这不就由刃而解决了吗，迎刃而解了吗，对吧嗯老师你走神儿了嗯，我们这个不能算法。

这个不能算法嗯，它有也它也有一个弊端，它有一个弊端，什么弊端，关于删除数据的一个弊端，给大家点一下啊，就是你这个b的数组中这个位置的一，它可能代表的是好好几个id号，能听懂吧。

这个位置的一它可能代表的是一堆的i d号，所以说这个位置的一你不能轻易的变为零，对不对，这就很蹩脚啊，这就很蹩脚，那我们可以怎么办啊，我们可以搞个计数器，我们可以搞个计数器，搞一个二维的，搞个二维的。

第二维就代表的是一个计数，能听懂了吧，如果你的计数器显示值为零，计数器的值为零，这个时候你可以放心的把一变为零，咱能听懂的六六告诉我，好，了关于这个不能算法的代码。

我已经给大家写好了，在这。

快速的看一眼啊。

代码不重要，重要的是思路啊，思路决定你的出路，代码不就根据你的思路去用一个个单词，实现出来的，对不对，没啥难的，快速看一下啊，首先这里边的贝的数组啊，我们使用redis里边的bmap这个类型。

所以在这呢我也连接了一下这个redis啊，主要就是使用它这个beat map类型啊，首先在这呢我这是设置了我要存多少数据啊，以及它的一个错误率啊，这有个main函数，这是先看这吧。

我我只带你看几个重要的啊，看这个get index，get index这个方法啊，这里边就是来计算我们的哈希函数的哈希值，来计算我们的哈希值，计算我们的哈希值，首先这边有个数组的长度多长。

这里看见哈希函数的个数，因为你你有多少个哈希函数对称。

是不是要计算出来多少个哈希值啊对吧，那么这里边这就是我自己写的哈希函数，自己写的哈希函数啊，最终他把这个数组给返回了，返回了，那么这个数组里面的值，这就代表着我未来要在这个beat map数组中。

哪些位置填一，哪些位置不动，能听懂了吧，其实这个就是核心的，这个就是核心的，其他的并不重要。

好吧。

系列 6：P95：布隆过滤器的实现 - 马士兵学堂 - BV1RY4y1Q7DL

代码有同学需要的，扫这个二维码，我会发给你来扫完，同学六六告诉我，唉老师肯定不止百万，扫完了66告诉我，我会发给你，后台的小姐姐会统计啊，后台的小姐姐会统计。

我说了给你一定会给你，并且是免费给你，好吧，放心，好，这是关于这个缓存穿透，关于这个缓存穿透，我们再给大家讲一个啊，就在你的架构里边引入了缓存层，其实他除了发生缓存穿透之外啊，可能还会发生缓存的雪崩。

知道什么是缓存雪崩吗，知道好的选择吗，知道的扣一不知道扣二，ok啊，有同学知道，有同学不知道，知道的同学，你再听一遍，我可能讲的跟你理解的不一样，请以我的为准，不理解的同学，你更要好好听。

什么是缓存雪崩啊，什么是缓存雪崩啊，就你缓存从中缓存的数据，在某一个时刻，突然失效啊，或者说无法访问，导致大量的请求打向mysql数据库，这叫缓存雪崩，那你可以想一下，就在那一刻。

你的数据库有可能受不了啊，太刺激了，对不对，那一刻突然失效了，太刺激了，这叫缓存雪崩，导致缓存雪崩的原因有这么几个，你仔细听，第一个原因，有可能是你redis中的数据，red中缓存的数据。

有效期一致导致的，导致缓存雪崩的第一个原因，有可能是你热中缓存的数据，它的有效期都是一致的，比如在你的rise里边，你一共缓存了100条数据，每一条数据的有效期啊都是一天，每条数据的有效期都是一天。

那就说一天之后啊，这100条数据会集中失效啊，那么就在那一刻，所有的请求是不是都会打向你的mysq，唉这是第一个原因导致的，那如果你的缓存血崩是由于第一个原因导致的，我可以怎么解决，我可以怎么解决。

唉刚才也听说了，可以搞随机有效期，啊可以搞随机计算器，来解决方案给大家做个笔记，可以给每一条数据加上一个随机的有效期，就是不要让他们一致，其实我们解决这个问题的思路啊，是这样的，不要，突然同时失效。

这是我们的思路啊，那你加上一个随机有效期了，那你的数据是是不是陆陆续续的失效啊，对吗，比如第一条数据你需要71天，第二条数据是0。75天，第三条数据是0。5天，依次类推，0。30。1。

那么这一条数据是不是对现实一个，然后这一条数据再再实现，你既然引入了你的缓存层，说明你的访问量已经很高了，那你一定对你的mysql是做过监控的对吧，有个motor肯定有个监控器来监控了它。

那么随着你数据陆陆续续的失效，你的监控器一定能够监控到，你的数据库的访问量在逐渐的增加，这个时候你要去查看一下，你是不是rise里边有一些热门数据失效了，听懂了吧，是不是有热门数据失效了。

如果发现有热门数据失效，这个时候再把这些数据再次缓存到redis中，那么还有一个情况就是我这条数据失效啊，并不会增加你mysql的访问量，那说明你这条数据已经不火了，是一个过气的数据啊。

跟过去的明星一样不火了，那这样的话就没必要关心了对吗，换句话说，我们这个解决方案，就是给我们的程序员一定的缓冲时间，不要突然失控，突然失效，这样我很难去解决的，那这个思路是最重要的，思路能听明白的。

扣一并不是这个解决方案啊，重要的是思路啊，好这是第一个原因导致的缓存雪崩，其实还有一个原因也会导致缓存雪崩，就是我的redis数据库挂掉了，我raid数据库挂掉了，那你挂掉的话，你肯定访问不了了对吗。

肯定访问不了了，这个时候怎么解决啊，我们可以搞分布式缓存吗，是不是可以搞备胎吗，你挂了他活着，他挂了，你活着，搞分布式缓存，比如说这这是您那些hot date热门数据。

那我把这个热门数据我不只是存在一台redis，我曾在多台，ready，二里边也有，rei 3里面也有，如果你这个rise集群啊，你采用的是这个切片模式啊，切片集群模式，如果你采用的是切片集权模式。

什么叫切片集权模式，就是把你这一堆数据切成一小堆一小堆的，一小块一小块一个切片，比如说一共有1万条数据，我切成了，我切成了切，切成了切成了十个小片，那每一个小片里面是不是包含的是1000条数据，对吧。

那这样的话你这里边存一部分，这里边存一部分，这里边再存一部分这切片集群模式，那这样的话我ready一挂了，我怕吗，不怕你，ready一里边只是存了你，hot date里边一部分数据。

release 23是不是还活着，你看这一种解决问题的思路，也是这个不要同时不要突然失效，要给我们程序员一定的缓冲时间，唉还是这个思路来能get到的，666告诉我，思路都是一样的，你看到了吧。

ok如果你的hot date这个数据量不大的话，你还可以采用副本集群模式，副本集群模式，也就是说你把这些数据啊在ready一里边存一份，ready 2里边全局存一份，ready 3里边也存一份。

里边的数据都一模一样的，并且存的都是全量数据，那这样的话你red一挂了怕吗，不怕它里边还有全量的，他挂了不怕，还有它呢，它还有一个全量，这不可以解决了吗，就你这一个场景下，这两个场景下导致的缓存雪崩。

解决思路是一样的，只不过具体的解决方案还有所区，有所区别，对吧，有所区别，老师雪崩和击穿是一样的吗，不一样，击穿和雪崩不一样，来给大家讲一下这个击穿吧，在讲击穿之前啊，我觉得还有一个知知识点比较重要。

还有一个知识点比较重要，我觉得需要捎带脚的给大家讲一下，什么知识点呢，是关于这个redis集群的哈，希一致性算法，就你出去面试的时候，其实这些问题啊，面试官肯定会问你，问的概率很高啊，就是问到这儿。

他可能会问你这个哈希一致性算法，因为这是redis集群的一个，非常非常重要的一个集权思想，咱这个算法知道的同学扣一，不知道的扣二，来想听的同学666，ok啊大部分同学都想听啊，绝大部分99。999%的。

给大给大伙讲一下，哈希一致性算法其实主要应用在redis集群里面，但是它不是把哈希一致性算法，原封不动搬过去的，他是借助了这个算法的一个思想，借助这个算法一个思想，我们先从一个小问题来一步步的来推理啊。

先从一个小问题来推理这个算法思想，比如说我现在有一些数据，有些data的数据，我要把这些数据啊存在两台服务器上，这是我们的redis 1，这是我们的redis 2，这是我们的reid 2。

如果我想把这个数据，平均分到这两个数据库里面去存储，我可以采用什么策略啊，我想把数据平均分到这两台数据库里面存储，可以采用什么策略啊，ok我们可以采用哈希取模，我们可以采用哈希取模。

我们都知道redis它是一个kv段数据库建设，对数据库，也就是说我要存储的这些数据啊，它也是一个kv段，对吧，也是一个kv段，我可以计算每一条数据的哈希值，然后在膜上二，如果它的哈希值模上2=0。

那我就把这条数据存在第一台redis，如果模上2=1，那么就存在这里面，因为你模上二，它的计算结果就两种，可能要么零，要么一，那这样我们可以相对比较平均的，把数据是不存在这两台数据库上。

我们现在先不考虑数据倾斜问题，听懂了吧，先不考虑数据倾斜，那如果现在我集群新增了一台，新增了一台数据库redis 3 ready分，那就说我这个数据分发策略不是在模上二了，需要模上三了，那怎么办啊。

那怎么办，我原先在rs一和rs 2里边，是不是存储了一部分应该存储在redis 3上的数据，如果你新增一台数据库的话，新增一台数据库的话，你需要把曾经存储的数据重新拿出来，是不是再走一遍这个策略啊。

再次分发，这是不是对于集权的扩展非常的麻烦，来能听懂我给你推理的666告诉我，ok就是如果我再新增一台服务器，它会增加我扩容的成本，那么哈希一致性算法，就是来解决你集群扩展问题的，听懂了吧。

这个这个算法的作用，那么这个算法是怎么解决集群扩展的呢，哎它有一个环，它是这样来解决的，好好听，它有一个环这个环儿啊，我们给它取了个名字叫哈希环，叫哈西花，比如你最开始还是有两台redis。

还是有两台red，那么每一台redis他们都是有ip或者house，是来区分哎，我们可以把啊，我们有两台，那接下来啊我们需要把这两台映射在这个环上，因为在这个环里，在这个环上面啊，它分布着一些点。

它分布一些点，假设一共有二的32次方这么多点，环上分布着这么多点，那么每一个点啊，它有一个编号，假设第一个编号是从零开始，最后一个编号就是二的32次方减一，懂了吧啊，有这么多点，我就把它删掉了。

密密麻麻的很多，我现在要把这两台数据库映射在这个环上，怎么映射，这边有个映射策略，我们可以拿到每一个数据库的ip值，或者它的host去计算它的一个哈希，然后膜上，模上二的32次方，听懂了吧。

模上三二的32次方，那么它的计算结果，是不是0~2的32次方是不是减一啊，我就不减一了，直接是个开区间计算结果，是这个范围对吧，那么既然是这个范围，那我redis一定能够映射在我怀的某一个点上。

比如说ready一映射在这个点，ready 2映射在这一点来，到此为止，能听懂的66告诉我，我在讲的时候你就好好听好吧，啊，我们分别用过不同的颜色来标识一下，来讽刺啊，马老师好，我不是马老师。

不好意思啊，我就说一下，这时候我们把数据库已经映射在这个环上了，那么接下来我们还要把我们要存储的数据，也要映射在这个环上，我们把要存储的数据也要映射在这个环上，怎么映射，还是采用刚才的映射策略。

因为我们的数据这是一个kv对啊，我们可以拿它的k计算它的哈希值，然后模上二的32次方，模上二的32次方，那计算结果肯定还是0~2的32次方，开区间是不是这么一个值，再说我要存储的数据。

它也能够映射到这个环上，一定能够映射在某一个点上，这是一定的，来这一点换个颜色来标绿色，ok那么到此为止，我们的数据库和要存储的数据，都映射在这个环上了，那么具体我哪些数据存在哪个数据库上。

哎它又又有一个存储的策略啊，我们就叫存储策略了，它会让每一个数据顺时针去找，最先找到哪一个数据库，那么你这条数据就存在哪一哪一台数据库上，你像这一条数据瞬间找，是不是存到软上。

那么这一条数据顺时针找是不是也存在red上，这一条数据顺时针找也存到这里面，那么这两条数据顺时针找，是不是找的都是redis 2唉，就这样来存，各找各妈，各回各家，啊就是这样一个策略来整体的听明白了。

666告诉我，那我们为什么说哈希一致性算法，就我们刚才讲这个算法，它能够解决你的集群扩容问题呢，来听我说，比如我现在新来一台数据库redis 3，听我说现在来一台数据库redis 3。

那么我们使用刚才的这个策略，是不是也能给它计算出一个哈希值，也能够映射在我环的某一个点上，比如它是在这个位置唉，映射在这个位置，ok那么现在数据就发生改变了，原本你这条数据是不存在redis 2上。

那么现在这条数据是不存在redis上对吗，也就是说我rise 2，要把这一条数据是不是给人家，这条数据需要动吗，不需要动，这一条数据需要动吗，不需要动对吧，也就是说我新增一台服务器，新增一台数据库。

我只需要两台数据库之间发生数据传输，就ok和red的音没关系，你不要动，但如果使用我们刚才这一种策略的话，是不是你的集群内部会泛红啊，对不对，你raid一需要哪一部分数据给redis 3。

redis 2需要哪一部分数据给redis，三来能听懂的。

系列 6：P96：布隆过滤器应用场景 - 马士兵学堂 - BV1RY4y1Q7DL

扫完了66告诉我，我会发给你，后台的小姐姐会统计啊，后台的小姐姐会统计。

我说了给你一定会给你，并且是免费给你，好吧，放心，好，这是关于这个缓存穿透，关于这个缓存穿透，我们再给大家讲一个啊，就在你的架构里边引入了缓存层，其实他除了发生缓存穿透之外啊，可能还会发生缓存的雪崩。

知道什么是缓存雪崩吗，知道好的选择吗，知道的扣一不知道扣二，ok啊，有同学知道，有同学不知道，知道的同学，你再听一遍，我可能讲的跟你理解的不一样，请以我的为准，不理解的同学，你更要好好听。

什么是缓存雪崩啊，什么时候缓存雪崩啊，就你缓存从中缓存的数据，在某一个时刻，突然失效啊，或者说无法访问，导致大量的请求打向mysql数据库，这叫缓存雪崩，那你可以想一下，就在那一刻。

你的数据库有可能受不了啊，太刺激了，对不对，那一刻突然失效了，太刺激了，这叫缓存雪崩，导致缓存雪崩的原因有这么几个，你仔细听，第一个原因，有可能是你redis中的数据，red中缓存的数据。

有效期一致导致的，导致缓存雪崩的第一个原因，有可能是你reid这种缓存的数据，它的有效期都是一致的，比如在你的rise里边，你一共缓存了100条数据，每一条数据的有效期啊都是一天。

每条数据的效期都是一天，那就说一天之后啊，这100条数据会集中失效啊，那么就在那一刻，所有的请求是不是都会打向你的mysq，唉这是第一个原因导致的，那如果你的缓存血崩是由于第一个原因导致的。

我可以怎么解决，我可以怎么解决，唉刚才有听说了，可以搞随机有效期，啊可以搞随机计算器，来解决方案给大家做个笔记，可以给每一条数据加上一个随机的有效期，就是不要让他们一致，其实我们解决这个问题的思路啊。

是这样的，不要，突然同时失效，这是我们的思路啊，那你加上一个随机有效期了，那你的数据是是不是陆陆续续的失效啊，对吗，比如第一条数据有效期是一天，第二条数据是0。75天，第三条数据是0。5天，依次类推。

0。30。1，那么这一条数据是不是最先实现了，然后这一条数据再再实现，你既然引入了你的缓存层，说明你的访问量已经很高了，那你一定对你的mysql是做过监控的对吧。

有个monitor肯定有个监控器来监控了它，那么随着你数据陆陆续续的失效，你的监控器一定能够监控到，你的数据库的访问量在逐渐的增加，这个时候你要去查看一下，你是不是rise里边有一些热门数据失效了。

听懂了吧，是不是有热门数据失效了，如果发现有热门数据失效，这个时候再把这些数据再次缓存到redis中，那么还有一个情况就是我这条数据失效啊，并不会增加你mysql的访问量，那说明你这条数据已经不火了。

是一个过气的数据啊，跟过期的明星一样不火了，那这样的话就没必要关心了对吗，换句话说，我们这个解决方案，就是给我们的程序员一定的缓冲时间，不要突然失控，突然失效，这样我很难去解决的，那这个思路是最重要的。

思路能听明白的，扣一并不是这个解决方案啊，重要的是思路啊，嗯好这是第一个原因导致的缓存雪崩，其实还有一个原因也会导致缓存雪崩，就是我的ready的数据库挂掉了，我raid数据库挂掉了，那你挂掉的话。

你肯定访问不了了对吗，肯定访问不了了，这个时候怎么解决啊，我们可以搞分布式缓存吗，是不是可以搞备胎吗，你挂了他活着，他挂了，你活着，搞分布式缓存，比如说这这是您的那些hot date热门数据。

那我把这个热门数据啊，我不只是存在一台redis，我曾在多台，ready，二里边也有，rei 3里面也有，如果你这个rise集群啊，你采用的是这个切片模式啊，切片集群模式，如果你采用的是切片集权模式。

什么叫切片集权模式，就是把你这一堆数据切成了一小堆一小堆的，一小块一小块一个切片，比如说一共有1万条数据，我切成了，我切成了切，切成了切成了十个小片，那每一个小片里面是不包含的，是1000条数据对吧。

那这样的话你这里边存一部分，这里边存一部分，这里边再存一部分这切片集群模式，那这样的话我ready一挂了，我怕吗，不怕你ready一里边只是存了你，hot date里边一部分数据。

redis 23是不是还活着，你看这一种解决问题的思路，也是这个不要同时不要突然失效，要给我们程序员一定的缓冲时间，唉还是这个思路来能get到的，666告诉我，思路都是一样的，你看到了吧。

ok如果你的hot date这个数据量不大的话，你还可以采用副本集群模式，副本集群模式，也就是说你把这些数据啊在ready一里边存一份，ready 2里边全局存一份，ready 3里边也存一份。

里边的数据都一模一样的，并且存的都是全量数据，那这样的话你red一挂了怕吗，不怕它里边还有全量的，他挂了不怕，还有他呢，他还有一个全量，这不可以解决了吗，就你这一个场景下，这两个场景下导致的缓存雪崩。

解决思路是一样的，只不过具体的解决方案还有所区，有所区别，对吧，有所区别，老师雪崩和击穿是一样的吗，不一样，击穿和雪崩不一样，来给大家讲一下这个击穿吧，在讲击穿之前啊，我觉得还有一个知知识点比较重要。

还有一个知识点表示，这样，我觉得需要捎带脚的给大家讲一下，什么知识点呢，是关于这个redis集群的哈希一致性算法，就你出去面试的时候，其实这些问题啊，面试官肯定会问你，问的概率很高啊，就是问到这儿。

他可能会问你这个哈希一致性算法，因为这是redis集群的一个，非常非常重要的一个集权思想，咱这个算法知道的同学扣一，不知道的扣二，来想听的同学666，ok啊大部分同学都想听啊，绝大部分99。999%的。

给大给大伙讲一下，哈希一致性算法其实主要应用在red is集群里面，当然他不是把哈希一致性算法，原封不动搬过去的，他是借助了这个算法一个思想，借助这个算法一个思想，我们先从一个小问题来一步步的来推理啊。

先从一个小问题来推理这个算法思想，比如说我现在有一些数据，有一些data的数据，我要把这些数据啊存在两台服务器上，这是我们的redis 1，这是我们的redis 2，这是我们的reid 2。

如果我想把这个数据，平均分到这两个数据库里面去存储，我可以采用什么策略啊，我想把数据平均分到这两台数据库里面存储，可以采用什么策略啊，ok我们可以采用哈希取模，我们可以采用哈希取模。

我们都知道redis它是一个kv对数据库，建筑对数据库，也就是说我要存储的这些数据啊，它也是一个kv段，对吧，也是一个kv段，我可以计算每一条数据的哈希值，然后在膜上二，如果它的哈希值模上2=0。

那我就把这条数据存在第一台redis，如果模上2=1，那么就存在这里边，因为你模上二，它的计算结果就两种，可能要么零，要么一，那这样我们可以相对比较平均的，把数据是不存在这两台数据库上。

我们现在先不考虑数据倾斜问题，听懂了吧，先不考虑数据倾斜，那如果现在我集群新增了一台，新增了一台数据库redis 3 rei分，那就说我这个数据分发策略不是在模上二了，需要模上三了，那怎么办啊。

那怎么办，我原先在rs一和rs 2里边，是不是存储了一部分应该存储在redis 3上的数据，如果你新增一台数据库的话，新增一台数据库的话，你需要把曾经存储的数据重新拿出来，是不是再走一遍这个策略啊。

再次分发，这是不是对于集权的扩展非常的麻烦，来能听懂我给你推理的666告诉我，ok就是如果我再新增一台服务器，它会增加我扩容的成本，那么哈希一致性算法，就是来解决你集群扩展问题的，听懂了吧。

这就是这个算法的作用，那么这个算法是怎么解决集群扩展的呢，哎它有一个环，它是这样来解决的，好好听，它有一个环这个环啊，我们给它取了个名字叫哈希环，叫哈西花，比如你最开始还是有两台redis。

还是有两台red，那么每一台redis他们都是有ip或者house，是不是来区分的，哎我们可以把我们啊我们有两台，那接下来啊我们需要把这两台映射在这个环上，因为在这个环里，在这个环上面啊。

它分布着一些点，它分布一些点，假设一共有二的32次方这么多点，环上分布着这么多点，那么每一个点啊它有一个编号，假设第一个编号是从零开始，最后一个编号就是二的32次方减一，懂了吧啊，有这么多点。

我就把它删掉了，密密麻麻的很多，我现在要把这两台数据库映射在这个环上，怎么映射，这边有个映射策略，我们可以拿到每一个数据库的ip值，或者它的host去计算它的一个哈希，然后膜上，模上二的32次方。

听懂了吧，模上三二的32次方，那么它的计算结果，是不是0~2的32次方是不是减一啊，我就不减一了，直接是个开区间计算结果，是这个范围对吧，那么既然是这个范围。

那我redis一定能够映射在我怀的某一个点上，比如说ready一映射在这个点，ready 2映射在这一点来，到此为止，能听懂的666告诉我，我在讲的时候你就好好听好吧，我们分别用过不同的颜色来标识一下。

来讽刺啊，马老师好，我不是马老师，不好意思啊，这时候我们把数据库已经映射在这个环上了，那么接下来我们还要把我们要存储的数据，也要映射在这个环上，我们把要存储的数据也要映射在这个环上，怎么映射。

还是采用刚才的映射策略，因为我们的数据这是一个kv对啊，我们可以拿它的k计算它的哈希值，然后模上二的32次方，模上二的32次方，那计算结果肯定还是0~2的32次方，开区间是不是这么一个值啊。

再说我要存储的数据，它也能够映射到这个环上，一定能够映射在某一个点上，这是一定的，来这些点换个颜色来标绿色，嗯嗯ok那么到此为止啊，我们的数据库和要存储的数据，都映射在这个环上了。

那么具体我哪些数据存在哪个数据库上，唉它又又有一个存储的策略啊，我们就叫存储策略了，它会让每一个数据顺时针去找，最先找到哪一个数据库，那么你这条数据就存在哪一哪一台数据库上，你像这一条数据瞬间找。

是不是传到这一上，那么这一条数据顺时针找是不是也存在red上，这一条数据顺时针找也存在这里边，那么这两条数据顺时针找是不是找的都是redis 2，唉就这样来存，各找各妈，各回各家。

啊就是这样一个策略来整体的听明白了，666告诉我，那我们为什么说哈希一致性算法，就我们刚才讲这个算法，它能够解决你的集群扩容问题呢，来听我说，比如我现在新来了一台数据库redis 3。

听我说现在来一台数据库redis 3，那么我们使用刚才的这个策略，是不是也能给它计算出一个哈希值，也能够映射在我环的某一个点上，就，比如它是在这个位置啊，映射在这个位置，ok那么现在数据就发生改变了。

原本你这条数据是不存在redis 2上，那么现在这条数据是不存在redis上对吗，也就是说我rise 2，要把这一条数据是不是给人家，这条数据需要动吗，不需要动，这一条数据需要动吗，不需要动，对吧。

也就是说我新增一台服务器，新增一台数据库，我只需要两台数据库之间发生数据传输就ok，和red的音没关系，你不要动，但如果使用我们刚才这一种策略的话，是不是你的集群内部会泛红啊，对不对。

你raid一需要哪一部分数据给redis，三，redis 2需要哪一部分数据给reid，三来能听懂的。

系列 6：P97：redis和mysql分布式锁的利弊 - 马士兵学堂 - BV1RY4y1Q7DL

ok你现在把这个问题给放大。

你现在把这个集群给放大，听我说啊，把集群给放大，比如说我现在这个集群一共有1000台redis，有1000台release，我现在增加了一台release，现在就变成了1001台，我现在增加了1000。

现在就是1001台了对吗，那你新增这台数据库，你只需要与两台redis发生数据迁移，剩下的九呃999台，不需要动不需要动，来听懂的，再次六六告诉我，如果其中一台挂了一会儿再说好吧。

如果把集群放大，那么这个哈希一致性算法，它的优势非常非常的突出。

优势非常突出，其实啊哈希一致性算法，也有弊端，它容易发生数据倾斜，哈希一致性算法它容易发生数据倾斜，对。

为什么说它会发生数据倾斜呢，刚才有同学说让我简单的介绍一下。

介绍什么是是是这么不是你回去看看录播吧。

如果你中途来的话，我建议你看看看录播好吧，如果跟不上的话，为什么说会有数据倾斜，听到这个数据倾斜，大伙应该知道什么是数据倾斜吧，对于我们的存储框架来说，数据倾斜就是指，大部分的数据存在了少量的节点上。

少量的数据存在了大部分的节点上，那么对于计算框架来说，大部分的数据由局部的线程去处理，少量的数据是由大量的线程去处理对吧，那比如说我们现在redis在映射的时候这样映射的，这是我们的raid 1。

然后reid 2在这个位置，他俩挨得很近，他俩挨得很近。

那挨得很近的话，俗凡是映射在这半段的数据，是不是存在reid 2上，凡是映射在这半段的数据是不存在read一上，那这就是数据严重失衡了，这就发生数据倾斜，对吧，这个数据倾斜怎么解决啊，怎么解决啊。

应该能听懂吧，数据的存储策略是这样的，这半段它顺时针找不找的都是rider 2吗，那你这半段顺针找是不是找的都是ready，一，凡是映射在这半段的数据都存在这一上。

凡是硬是在这半段数据是不是都存在这点二上。

就这个意思怎么解决啊，这个数据倾斜，我们可以搞虚拟节点，我们可以搞虚拟节点，就你red一多虚拟出来几个，redis啊，假设就虚拟一个吧，然后redis 2啊，你也虚拟出来一个，现在是这样的。

每一个节点各虚拟出来一个节点，那也就是说这半段存在ready 2上，这半段是不存在这个虚拟的reid 2上，其实你存在这个虚拟的ring 2上，说白了是不是还是存在我这个redis 2上对吗。

然后映射在这一半段的存在它上，应该在这半段的存在它上，那说白了这半段实质是不是还是存在的意义上，这就可以来解决数据倾斜，那有同学说，我虚拟出来的节点有可能还是不均衡。

那就增加虚拟节点，这也是一个trade off，ok，啊通过哈希槽来实现的哈希一致性啊，它的哈希槽有161率多少呢，16384还是多少嗯，16384是吧，o好了哎。

这是关于这个缓存的雪崩啊，进而给大家延伸出来的。

进而延伸出来的。

那么接下来顺着刚才那位同学的问题，就是哈希啊，不是不是就这个缓存的雪崩啊，和这个缓存的击穿有什么区别，来缓存击穿，听过的扣一，没听过的扣二。

不要一部分同学听过，一部分同学没听过啊。

缓存击穿就是指在我的缓存从中，直缓存了一条数据，听好了啊，只缓存了一条数据啊，那雪崩呢它是缓存了多条数据，多条数据同时失效，我们称为雪崩，那么击穿就是缓存一条数据，你这一条数据失效所发生的问题。

叫缓存击穿问题，但它俩的区别就是一个是一条，还是另外一个是多条对吗，我把这三个概念我先给大家捋一下啊，别乱缓存，雪崩，缓存击穿，还有一个是缓存穿透，这三个概念来捋一下，记住一句话，记住一句话，缓存穿透。

缓存击穿，缓存雪崩，本质都是，它的本质都是缓存穿透，那么缓存雪崩和缓存击穿啊，它是缓存穿透的特殊表现来，这句话很重要，能听明白的扣666，来有感觉的666，他粉丝吧，粉色的。

你看不管是缓存击穿还是缓存雪崩啊。

其实是不是都是缓存穿透啊。

对不对呃，传统，我。

这个袋子说一致性哈，希虚拟间之后带扩容，是不是又回到解放前了，你要想你哪怕搞个虚拟节点，你再扩容，它也不会让你集群内部发生偏大大规模的泛红，听懂了吗，也不会发生大规模的泛红。

那么关于缓存击穿，我们再深入聊一下啊，这也是面试常问的，这个是克莱的客户端，那你说我现在这个redis里边啊，它只存了一条数据，只存了一条热门数据，并且这条热门数据是不是有条切啊。

他先去ready中查ready没有呃，里边没有，是不是再去mysql里面查对吧，如果在某一刻这条数据失效了，那么所有请求。

这条数据的请求是不是全部会打向mysql，全部打下mysql，那我问你缓存击穿问题，在一般的公司里边，我需不需要解决啊，我需不需要解决啊，你觉得需不需要解决，给我一个感性的回答，给我一个感性的回答。

不需要就是在一般的公司啊，不需要解决，为什么呢，就一般的公司，你很难有一条那么热门的数据。

能够足以让你的mysql瘫痪，来能够听懂的666告诉我，就一般的公司很难有一条那么热的数据，能够让你的数据库给瘫痪对吧，所以我建议各位你们出去面试的时候啊，希望你们回答问题，要联系上下文啊。

context，联系上下文，如果在你的简历上，你写的你上一家公司是一个并发量并不高，或者数据量并不大，用户量也不大的。

人家问你，你的缓存击穿有没有解决啊，结果你听了我今天给你讲的课之后。

啪啪啪跟人家聊出来，你不打自己脸吗。

这是一般公司不需要解决，其实有的时候面试官会拿这一道题啊，他会去校验你是否真的玩过，他会去校验你曾经工作经验的一个真实性，数据面试要也要学会避坑，ok那么对于大公司来说肯定需要解决对吧。

大公司肯定需要解决啊。

一般解决缓存机舱的方案是什么啊，我们可以使用分布式锁来解决，使用分布式锁来解决，来分布式锁，了解的同学扣一，不了解的扣二，刚才我大概估算了一下，百分之七八十的同学不了解。

我们来讲好好听，好好听，原理上的问题才是最重要的，思路上的问题，这是最重要的。

不错了，真的思路决定出路，一定记好了，什么是分布式锁啊。

先来给大家把分布式锁聊透，然后我再告诉你，怎么使用分布式锁来解决所谓的缓存击穿问题。

好吧，来从一个很简单的问题开始讲，首先锁这个东西啊，我觉得不需要给他给大伙讲了，很简单，我们上厕所睡觉是不是都需要加锁啊，比如说你们公司里边有个厕所啊，有一个厕所啊，厕所里边只有一个坑，只有一个坑。

那这时候你上厕所的时候是不是要锁门啊对吗，举个例子，比如说现在有这么三个人，马老师，朱老师，一鸣哥哎，这三个人他们晚上一起出去吃饭，去了某一个餐厅，然后吃完饭之后，老板没做没做熟，拉肚子。

厕所只有一个厕所，里边只有一个坑，那么他们就不要来抢这个厕所啊，那上面有有一把锁，他们需要来抢，那这个时候谁抢到是谁先进去，进去之后把门儿是不是在反锁上对吧，你看这个场景就需要上，就需要加锁这个场景。

这个场景啊它是具备的三个条件，你发现了没，第一个条件，在这个场景下有一个共享资源，就这个操作，第二个条件，这是一个多任务的环境对吧，第三个条件，我这个共享资源啊是互斥的，因为我只有一个坑啊，你在这蹲着。

我就不能蹲，发现了吗，请各位记好，凡是你的场景满足这三个条件，你都需要上锁啊，缺少任何一个条件都不需要加速啊，都不需要加速，你比如说我们第三个条件没有，就这个共享资源它不是互斥的，而我删掉，那你需要我。

我说需要你，你说我需要上锁吗，不需要来马老师要蹲了来蹲，这周老师又来了，哎蹲着挨着牌子蹲着啊，一鸣哥来了，哎，挨着牌蹲着哎，定对定，不需要上锁啊，对不对。

这是我删了第三个条件，如果我把第二个条件删了，现在不是这三个人要上厕所了，就马老师一个人要上，或者公司里边就马老师一个人，那你说他上厕所需要锁门吗，不需要啊，没别人啊，唉我给你解释清楚的66号数。

但凡是你的业务下。

凡是你的业务符合这三个条件都需要加锁对吧，我们抛开这些坑不说啊。

这个例子实在是太形象了，太细碎了，我们重新换一个例子，陈先再换一个例子，比如说卖票，啊这是我卖火车票票的一个窗口，就一个啊就一个窗口，然后现在有这么三个人，123所谓的人就是一个个的three的线程。

就一个个线程，这三个线程它是处于同一个jvm里面，哎处于同一个gm里面，你看到这个场景下满不满足这三个条件，能满足吧。

首先共享资源，这个共享这个窗口是不是只有一个，还说明共享资源是互斥的，这是不是也是一个多任务的环境，是的，所以他们这三个人去买票是需要加锁，能听懂了吧，唉我们可以使用jdk给我们提供那些所机制。

就可以实现这三个人挨着牌排队的去买票啊，如果现在所谓的这三个人啊，不是县城，是一个个的jvm，这个是jvm 2，这个是jvm 3，请问各位我在使用jdk给我提供的那些锁机制，能不能实现。

让他们排着队挨着牌子去买票啊，咱觉得可以的扣一，不可以的扣二，这时候就不行了，对不对，你这里可以提高那些所机制，你只能解决你当前jvm内部的排队问题，你解决不了jvm之间的排队问题对吗。

你解决不了jvm之间，那怎么办啊，唉我们可以基于jvm之上去搞一把锁，唉可以基于jvm之上搞一把锁，比如说你把这把锁是存到了mysql里边，ok这叫基于mysql的分布式锁，基于mysql的分布式锁。

ok具体来聊一下流程，你现在三个人是不是都要去买票啊，怎么办呀，来先去我mysql里边来抢所，所谓的强所就是去你mysql里边insert一个字段，谁先insert进去，代表谁抢到了锁，听懂了吗。

来三个人都来抢锁，都去音色的数据，也就是说对吧，比如说g v m一先抢到这把锁，唉这个时候他是不是就可以来买票了，当他买完了票，再去mysql中把刚才insert进去的那个值再干掉，这代表释放锁。

释放完锁之后，剩下这俩是不是又可以再继续抢了，假设j v m2 又抢到了，他又来买票，这样就可以实现一个排着队挨着牌子去买票。

这把锁就叫分布式的锁，为什么给它取个名字叫分布式的锁啊，你看不同的j v m有可能在不同的节点上，那么你多个节点我们就叫分布式，这把锁是控制多个节点上的jvm的一个一致性，或者说排队问题。

所以它叫分布式的锁，来给你讲清楚的，66告诉我，这个分布式锁很简单啊，对可以理解成就是一把大锁啊，控制的时候你多个jvm挨着旁排着队，问题，那么基于mysql的分布式锁啊，其实它有一些问题的。

它有一些问题的，它会容易存在一个死锁问题，它又存在一个死锁问题，为什么说会有死锁呢，比如说我这个gm一先抢到了所，他抢了锁之后啊，是不是来买票啊，对吧，假设就在买票的过程中，gbm一宕机了死了。

他就说我mysql里边的这个字段值，是不是永远不会被删除啊，那么jvm 2和j v m3 ，永远都不能去insert数据了，就永远抢不到锁了，这就发生了子锁，听懂了吗，来听懂的扣一为什么会有思索。

刚才给大家去分析了一下，哎我们可以怎么办啊，就针对于这个死锁问题，我们可以怎么解决啊，刚才我看有同学已经把这个答案说出来了，我们可以搞监听啊，我们可以搞监听，比如说我现在这有个j v m。

启动了这么一个进程，这个进程做什么事呢，就是来监视这把锁，来就是来监视这把锁，如果这把锁，存在的时间，超出我们设定的time out，那么这个m一就可以把这把锁给干掉，你看啊。

gm一强盗了所在买票的过程中死了怕吗，不怕他是不是在一直监视着，超过了他们是不会把这把锁给干掉，那剩下的两个g v m又可以来抢，所又可以去买票了，这就可以解决，唉强制回收可以这么说，嗯这个词很好。

我们搞了这样一个进程，在这监视着这把锁，其实又会引来新的问题，又会引来新的问题，我这个time up怎么设置啊，射多长啊，你能告诉我吗，就我这个time out设置应该怎么，我应该设多长，天津。

能说吗啊恐怕谁都说不出来，恐怕谁都说不出来，就是他们up设多长也同时设1年嗯，其实射多长谁都没有一个标准，如果你这个time out，我刚才也有个同学看也看了，有同学说设1ms，设1mm就是射的很短。

那么射的很短会有什么问题啊，g m m一先抢到锁在这买票，就在买票的过程中发生了j c，发生了jc，jc发生了一秒，这个时候你这个jvm这个监视的进程，是不是已经把你这把锁给干掉了。

但人家gbm一只是趴在这个卖票窗口那，睡了一会儿，睡着了就睡了，那么一会儿你把你就把我的锁给干掉，把我的锁给干掉，剩下的gb m2 和gbm 3，是不是又可以来抢来抢锁了，假设接下来是jvm 2强到锁。

那么j b m2 是不是又来了，这个时候在在这个时刻，就会有两个人趴在这个窗口，那么在现实场景就会打架，那么在编程环境下就会存在着一票多卖问题。

来我给你讲明白了，66告诉我，对线程不安全，所以这是我们设的过短，如果我们设的过长呢，就你们说的1年啊，我不知道这个答案是你考虑过的，还是说随随口而出的，如果设为1年会有什么问题啊。

那设备1年刚才的问题肯定能解决对吗，来gm一抢到了锁，在这买票买票过程中挂了，那么就在那一秒钟挂了。

是不需要等这么长时间，剩下两个gm是不是才能买票，本来我今年想回家，结果只能明年回家了，对吗啊，有同学说设60年，本来我想在老家安享晚年，只结果只能，你们懂了对吧。

所以说如果你设的过长，它就会存在单位时间内，不能卖出，更多的票啊。

系列 6：P98：zookeeper分布式锁的利弊 - 马士兵学堂 - BV1RY4y1Q7DL

我看。

所以说关于这个基于mysql的这个分布式锁啊。

问题很多，所以也很少有人会基于mysql去实现一个分布式锁。

一般用的比较多的都是基于这个主keeper。

基于这个组keeper去实现一个分布式锁。

主keeper了解吗，听都没听过是吧，ok。

关于这个组ker怎么去实现一个分布式锁，以及它的分布式锁原理啊。

在我之前课里边有给大家讲过啊，就给大家讲过。

我之前的一个录播行吧，那么这节课呢我就给大家分析了一下。

这个分布式锁的一些优缺点啊，实现基于这个mysql的一些问题。

那我们继续回来继续回来，那我现在知道什么是分布式锁了。

诶在哪呢。

在这儿。

稍等把这个往下移一下。

好我们现在知道什么是分布式锁了，那么怎么使用我们的分布式锁。

去解决这个缓存击穿问题啊，怎么解决这个缓存击穿问题啊。

这样来解决，我们说如果你的缓存计算问题需要解决。

说明你的并发量很大对吧，访问量访问量很高。

访问量很高，所以你这个架构啊肯定会发生改变啊，比如说你的架构变成这个样子。

这有个负载均衡器，是我们的，他们开的一，然后他后边会挂好几个服务器对吧。

可能架构就变成这个样子了，来三那我客户端发了一个请求。

先给nginx，那么n个n gx会根据一些分发策略，是不给他们开一或者二或者三。

当然分发策略有很多，有人询会基于哈希的对吧，很多分发策略啊，好，那么现在现在如果我rise里边这条数据它失效，这条数据它失效了。

过期了，那么所有的请求是不是都怼上了mysql。

就在这一刻，非常非常多的请求都怼上了mysql，那你这一刻的马sl有可能承受承受不了。

会宕机对吧，那怎么办呢。

来这边我搞一把分布式锁，搞一把分布式图。

甭管这个分布式锁是基于mysql还是读kep的，就是你如果去你的rise里边没有查到数据。

ok你来抢所，那说明我这条数据是不是失效了。

来他们都来抢所，都来抢所，那么谁先抢到了锁。

比如说他们开了一抢到了锁，那这个时候他去mysql征去查数据。

那么剩下这两个没有抢到锁的。

在那等着，那么tom cat一去mysql中查到了这条数据之后。

再把这条数据缓存到redis中。

现在raid里面是不是就有数据了，那么刚才tom cat 2和tom cat 3的这两个请求。

现在不需要在这等锁了，哎你就直接来mysql中去拿就ok了。

你看我们采用分布式锁。

如果就在你数据突然失效那一刻。

假设有1万个请求准备打向mysql。

那么现在是不是在分布式锁这一块卡卡住了。

只能允许一个人去mysql中查，查完之后再放到redis中。

那么剩下的9999个请求，是不是直接去red之后拿就ok。

虽然这种办法它的效率很低，效率很低，但是能够很好的去保护你的mysql数据库，我给你讲明白了吧，来我给你讲明白了，扣一。

呃刚才这位幸运学员说，1万个请求怎么可能k是相同的呢。

你看啊，我们刚才所说的这所有的请求。

这都是请求这条数据的请求，我们没有去聊请求其他数据的请求。

我们没有关心那些。

我们只关心请求这条数据的请求，那你请求的是其他数据，管我屁事啊对吧。

我现在解决的是缓存击穿啊，啊这种解决方案效率很低，解决方案效率很低，这样去解决的不多啊。

采用分布式锁来解决不多，而是采用了一个非常简单的办法。

一般的公司啊，会弹一个非常简单的一个解决方案。

就是直接把数据把查询出来的数据。

缓存到red。

给大家解释什么意思呢。

就是这个不用这个分布式锁了，但这些你都得会啊。

都得会，现在不用分布式锁了，比如说这里边数据是失效。

他们在这请求是请求不到，他也来也请求不到。

他也请求不到，这个时候他们是不是都集中打向mysql对吗。

那就在这一刻可能有100个请求提升打下mysql。

那这所有的请求啊，你去mysql中查询出来的数据都还算到专证。

那么第101个请求，第101个请求序列里边。

是不是就能拿到数据了对吧，就是这一整个解决方案，它没有这个分布式锁的解决方案，那么严格它允许有一部分的请求。

是不是来接受mysql，就你的数据库没那么脆弱，所以一般采用第二节要放就ok。

来我给你解释清楚的，66告诉。

ok好了。

我们来做一个复盘，来做一个复盘。

通过一个redis缓存穿透给大家引申出来很多东西。

首先给大家引申出来的是什么，是缓存穿透。

那么对于不同场景下的缓存穿透，应该怎么去解决。

当你遇到了黑客，那么黑客他会采用两种方式去攻击你的数据库。

来分别应对的方案是什么，我们进而引出来啊。

不能过滤器和不能算法对吧。

然后又跟大家聊了这个缓存的血崩。

缓存雪崩怎么解决，导致缓存雪崩原因有哪一些不同的原因，怎么去解决。

它也跟大家聊了焊锡一致性算法。

然后再往后跟大家聊的是缓存击穿，通过缓存击穿，又跟大家聊一下这个分布式锁的一些思想。

就是我们讲的这些点，其实就是围绕着缓存雪崩。

缓存穿透和缓存击穿来给你讲。

首先第一个你肯定get到了来，第一个get到66，告诉我来复一下盘，然后第二不能算算法的原理，我相信大伙应该也能听懂对吧，然后第三不能过滤器的实现代码。

我会发给你说说给你肯定给你。

然后第四分布式锁的原理以及它们的利与弊。

聊了吧，然后第五分布式锁如何解决防弹击穿也聊了。

哎我说这个解决方案一般不常用。

原来p主唱一个。

最后我希望。

大家要得到这样一个技能，最后我要给大家讲一个技能，关于面试的技能。

我觉得很有必要，正好借助于今天给大家讲的。

应该叫我希望给大家讲一个面试的技巧。

正好借助今天讲的东西给大家举个小例子来，我问一下有多少同学最近在找工作，找工作的扣一没有的扣二，还没一个人，出去面试，一般需要写一份比较精美的简历对吧。

很多同学可能会疏忽一点，就在简历里面去挖坑。

在简历里边挖坑，在精美的简历里边一定要空。

一定要挖坑，这叫残缺美，挖什么样的坑啊，你要想面试官喜欢问啥，你就把什么样的坑啊，比如说面试官喜欢问你在开发项目的过程中，遇到过哪些bug，哪些黄金bug对吧。

以及这些bug的解决方案对吧，面试官可能还喜欢问。

你在开发的时候遇到过哪些性能问题啊，以及你的优化方案。

这都有可能会问的，所以你就把这些问题。

你就主动写到你的简历上，放到你的，放到你的简历上，这里边有个小技巧啊，关于你曾经遇到过的这些bug，黄金bug你要描述的清清楚楚，关于这些bug的解决方案，要一两句话带过，你要一两句话带过。

性能问题也要描述的清清楚楚，优化方案也是一两句话带过。

这样就可以足以吊足他的他的胃口啊。

他看到你这份简历，就非常希望要见到你。

对吧。

先挖坑先挖坑，比如我们今天讲了是不是缓存。

穿透和缓存，就是缓存的一些问题。

那你基于今天讲的东西，你可以在简历里边挖一个这样的空，比如说你在上家公司接盘了一个项目啊。

刚刚接盘这个项目的时候啊，他的q p s很低啊，比如说只有10q p s。

然后经过你优化之后啊，能够达到200kp，性能提升了20倍，性能提升了20倍。

又可以把这个性能提升描述的清清楚楚。

就是性能问题描述的清清楚楚，那怎么优化，那就一两句话带过啊，比如你就简简单单的说引引用了redis做缓存对吧。

或者说做分布式缓存，就简简单单的说要吊他的胃口。

明白吧，你的简历里边要多挖这样的坑。

那么你去面试的时候，面试官所问你的第一个问题一定是。

吸引他的问题，你像这个问题就比较吸引他。

如果他不是特别low的话，它会沿着问的，他可能会问你具体是怎么优化的对吗。

这时候你就可以聊啊，我是加了一个缓存层。

我把这些热门数据我放到rise里面去，但是这个时候你要去跟他聊细节。

你当初是怎么判定热门数据的，判定标准是什么样的，你mysql中的数据是怎么迁移到raid中的。

这些细节一定要聊清楚。

你不要等着面试官问你细节，面试官问你细节的时候，恐怕你很多细节真的很难答上来。

不管你有没有做过，你，哪怕是做过有些细节，你也答不上来对吧。

所以你就主动出击，直接把细节给他聊明白了。

让他不要怀疑你，听懂了吧。

那么你在回答完这个问题之后啊，啊你说你加了一个缓存层对吧。

哎具体怎么怎么做的，在回答完之后，不要忘了你要抛出来一个新的问题。

哎你说我加了一个缓存层之后啊，他又给我引出来一系列的问题。

比如他给我引出来一个缓存雪崩问题。

听懂了吧，比如引来一个缓存雪崩问题。

如果他不是特别low的话，他可能继续研究这个问题来问你。

哎什么是缓存雪崩啊，你给我解释一下你们当初是怎么解决的。

ok那就把我给你讲的给聊出来。

对不对，那你聊聊完这个缓存雪崩之后啊，哎你可以说。

我们最终是通过分布式缓存来解决的。

哎我们说redis这个集群。

它所引用的哈希一致性算法简直是太了。

ok啊他听到这个关键词可能又吸引到他了。

如果他不是特别low的话。

可能又会问你哈希一致性算法的原理。

让你给他去解释，而解释完之后再给他抛一个新问题。

你说哈希一致性算法它也有弊端，它也容易发生数据倾斜问题。

唉他可能会问你还怎么去解决。

我说的这个思路呢，就是你每回答完一个问题。

你要抛出一个新的问题去吸引他，让他沿着新的问题继续问你。

哪怕你抛出来这个问题没有吸引住他，他也会继续通过你的简历。

是不是继续再找问题去问你啊，所以简历里边的坑和你回答之后。

抛出来的新问题就可以引导整场面试来，这个技巧能get到666，这个很重要啊，就是很多同学会去刷题。

会去背这些面经，你从来没有想过把这些题怎么串起来。

怎么去引导这个面试，你从来没有想过你背那么多题有什么用啊，你只能说你去面试的时候，面试官恰巧问到这道题了，你非常的开心，能回答上来，但是接下来下一个问题你可能又是懵逼的对吗。

我靠这这里边是不是有面试官啊，面试官，你赢了，你成功的做了一次间谍，来面试过其他同学的。

扣个一，我看看来是面试官的扣个一，我看看面试官别人的来。

大伙儿记好了哈，大伙儿记好了，就这几个人。

我只能帮你们帮帮到这儿了。

我只能帮到这儿了，记好了，成功的做了间谍，ok。

好这里边还有一个技巧啊，这边还有一个技巧。

就是我们除了要去设计这个面试，这个面试环节怎么去引导面试官。

还有一个很重要的一个细节。

很重要的一个技巧。

其实我们要学会去表演，其实我们要学会去表演。

其实我们回答的每一个问题啊，这些答案这都是我们提前准备好的对吧。

都是提前准备好的，就这些剧本都给你准备好了。

你怎么按照这个剧本去演啊，这也需要演啊，那很多同学可能面试官诶。

第一个问题正好就是你设计的问题，他正好问了，问了之后。

哎你这个答案也准备好了，就非常的开心啊，心里倍儿美。

他就滔滔不绝，如同黄河泛滥之势，一发不可收拾，恨不得五秒钟把这个答案给你背出来。

你觉得这个效果好吗，你觉得好吗，嗯这个房你们说就是如果你面试了一个人，你问他一个问题，就是连思考都不都不思考，直接给你对答案，对方案，不好吧啊。

所以我们希望在回答这些问题的时候。

在回答这些问题的时候，就是你要把这些什么磕巴，什么卡顿啊，什么卡壳，你要表表，你要表现出来。

你要给面试官一个感觉，你是一边在回忆当初一边在回答问题。

而不是说这个答案是你提前准备好的，一旦你让面试官认为。

你这你这个答案是你提前准备好的，那么他就会认为，这次面试不能很好的挖掘你的潜能，不能很好地考察你的能力对吧。

一定要给他一个感觉。

你是在一边思考，当初一边来回答问题，来get到了666。

面试官们都走了吗，所以面试成与败啊。

有很多因素来决定的，每一个细节我都要把控到位，每个细节都要把控到位。

除了你要去设计你的面试环节。

在面试的过程中，也要去设计来最重要的一个思路。

我们要引导面试。

设计我们的面试环节去引导面试。

千万不要让面试官来引导你，一旦你让面试官去引导了你。

你基本上没啥戏，一个面试官是两个独立的个体。

他擅长的不代表你擅长对吧，然后第二我们细节要到位，ok这就是我要跟大家说的。

通过今天讲解的讲解的这些知识点，给大家串联了一下。

给大串联了一下，ok了，唉有同学说ready for和to keep。

系列 6：P99：redis锁和zookeeper有什么区别 - 马士兵学堂 - BV1RY4y1Q7DL

redis锁和组keeper有什么区别，来想听的666告诉我别刷屏啊，rise和组key有什么区别，想听的666，想听就讲呗，来加个钟啊，喜欢加装吧，首先我们选择redis去做一个分布式锁。

主要就是由于我们的redis，它里边的数据可以支持有效期，数据支持有效期，喝口水啊，你们稍等，稍等我20秒好不好，稍等我20秒，嗯嗯成功未立，回来了，没有没有没有没有，找了个瓶儿没去没去，直接找个瓶。

找了个口径合适的啊，我们使用redis做分布式锁，主要就是使用主要就是因为它有一个特性，可以支持这个数据，支持有效期，哎呀你们别说这没用了，好不好，来来来来来一波666，把这些闲言碎语顶上去。

呃这样讲这样讲，比如说这里这也是我们的gbm 1，这个呢是我们的jvm 2，然后这个呢是我们的gm 3，好不好，然后这时候我们也是那个火车票，我们现在使用redis来做分布式锁。

那么redis呢我们去抢所，抢到锁之后去买票，那么所谓的强所就是插入一条数据嘛对吧，那我现在往rise里边去插入一条数据，我可以去给他设置这把锁的一个有效期，我们去可以给这把锁去设置一个有效期对吗。

这同样你去设置一个有效期，同样还会存在这个问题，就你有效期设多长，设多短，那比如说我ride一搞了搞了搞了一把锁，他先抢到了锁，给大家设计学习一秒钟，那一秒钟呢他也有可能会存在。

他在买票的时候发生jc在窗口这睡着了，是不是也会存在两个人同时趴在一个窗口啊，是不是会存在一个线程安全问题啊对吗，其实使用redis去实现一把分布式锁，和我刚才给你讲的，使用mysql实现一个分布式锁。

其实它的原理是一样的，我在讲基于mysql分布式锁的时候，已经给你聊出来了，已经给你聊出来了，当然现在redis呢我们可以使用一个redition，去给这把锁去续这个有效期啊，给这把锁去续这个有效期。

这也是可以，那么组cp他怎么去实现这个分布式锁的呢，主要来讲这个读，你就能很好的发现这个redis和duper一个区别哈，首先组keeper呢，给大家介绍一下，既然是分布式。

那说明redis这个组keeper，它是可以部署在多个节点上的，对吧，它是可以部署在多个节点上的，比如说我现在有个高端，我这个高端啊往这个节点上插入一条数据，比如说k一就差一条这样的数据。

那么组keeper这个集群内部，它会把k一这条数据同步到其他的节点上，那么它的这种同步啊，他的这种一致性啊，我们叫弱一致性啊，我们叫最终一致性，最终一致性什么意思呢，就比如我这边还有一个口端。

这个客户端二，这是客户端，一个客户端一，这客户端二，那么客户端一往这里边写的，是往这个阶段上写一条数据，它是不是需要往这些节点去同步对吗，那这个时候有可能这个节点还没有同步过来。

我client 2就来读数据了，就来读数据了，那这样的话读这条数据我是不是就读不到啊，对不对，那我这个client 2它可以发送一个命令，让你这个节点先把数据同步，同步完之后再给我返回。

所以它是一个对称一致性，并不是一个强一致性，那所谓的强一致性，就是我往这个节点上写了一条数据，必须把所有的节点全部同步完之后，我才能去读来，我给你讲明白了，66告诉我，ok讲明白了。

那么组keeper呢，它还可以做数据的存储，它的存储啊，就类似于我们的文件系统那样去存，有目录，有层级，有目录有层级，我给大家演示一下啊。

我这边机器应该也打开了，稍等啊，我现在连接上了我note 01这台虚拟机啊，也连接上了note 02，也连接上了note 03，三台都连上了哦，g p s看一下，因为它是一个gv m进程嘛。

所以gp就能看到哎，这个这个这个就是读keeper进程，然后note 02这给大家看一下，也有啊，no no，零三的也有，不等了，主keer今天已经起来了，注意看，我现在执行一个脚本。

jk client。s h，这代表我在node 01上启动起来一个客户端，我现在组keeper是部署在三个节点上，分别note 01，note 2和note 03，我现在note 01上起了一个客户端。

是一个独立进程，它连接的是我的note 01，听懂了吧，是我的note 01来回车，之后执行一个命令l s杠了，这就能看到组k方，o的目录有个叫msb对吧，l s杠msd是不是没了，我还可以创建msd。

可以买sb回车，然后l s杠，然后发现没有啊，是不是没有创建成功啊，你要注意了，在组key里边创建一个节点，你必须给它一个初始值，初始值，比如说000回车，现在我在l s杠哎，是不是有了m s b。

我还可以在msb这个节点下，再去创建一个子节点，比如说在msb下面再去创建一个，index哎，不要忘了给它一个初始值也是零零来，我们去msb下看是不是有了。

我还可以去读这个index这个节点的内容怎么读啊，直接用get回车还是不能读到这个值啊，000它还有一些原数据，下边这些是一些原数据信息啊，就不一个个详细的去说了，这个大家都能看懂长度000v3 嘛。

然后有没有子节点没有啊，我还可以在组keeper里边去创建一个这样的节点，注意看我加上一个杠一，在我的m s b下创建了一个杠e这样一个节点，e代表的是infinal临时节点。

听懂了吧，回车来msb一下。

看一下是不是有俩节点了，这个节点是一个infe临时节点。

如果你不加杠一的话，这是一个持久节点，说一下它的节点类型，有两种，一种是持久的，还有一种是临时节点，那么临时节点有什么特点，临时节点有什么特点，它的特点就是你这个客户端连接它，创建一个临时节点。

如果你这个客户端跟他断开了连接，这个临时节点会自己删除。

ok吧，它会自动删除，我们来演示一下这个效果，我们在node 02上也启动一个code进来。

我们来看一下l s m s b下是不是这俩节点啊，对吧，一致性嘛，在这里边也能看到，刚才这个tm p是我node 01上这个客户端，是不是创建临时节点了。

我把它给干掉，我ctrl c把客户端给干掉。

然后在这看，还有是吧，来多刷几遍。

多刷几遍稍等，稍等啊，练手速的时候来了，来看这tp是不是没了，是不是t a p没了，那为什么我们等了这么长时间，t i p才删除，有同学能说吗。

能回答吗，因为那组cp里边，你这个客户端跟这个节点有没有连接，或者说它的长连接是通过心跳来维持的，就我这个集群怎么知道这个客户端没了，通过心跳，什么是心跳啊，就客户端会每隔一段时间。

向他发送一个很短的一个消息，代表这个客户端还活着，那么心跳是有心跳周期的，比如说他每隔五秒发送，每隔五秒发送，那我们刚才刷了那么长时间，tm p还在说明我们是在一个心跳周期内，听懂了吧。

最长最长它会存在一个心跳心跳周期，当他过这个心跳周期，哎我集权就可以知道他已经不在了，我就可以把临时节点给删除来，我给你解释清楚的，666告诉我，这个心跳周期可以设啊。

先设置怎么设置，有配置文件在这这一讲一讲又讲多了，哦看这儿啊，你通过这个参数可以设这个参数也可以设好吧，再讲再讲点。

我们刚才说它是支持这两种节点类型，一个是19，大伙晚上不着急了，不着急，我就加装哈，我倒无所谓，那就加重啊，马是边教育，一直玩的都是良心，绝不搞虚头巴脑的东西，想听我们就来，那么这个持久的节点啊。

它又分为有序的和无序的节点，临时节点的它又分为这两种。

有序和无序演示，在这我create杠s，杠了之后呢，后边接上m z b创建这样一个节点杠salt，不要忘了给它一个初始值，零点回车，大家看看是不是给我加一个序号，002再创建003，再创建004。

005006007008009对吧，他会依次递增给我一个序号，因为我之前啊在这个m，在这个msb下创建过一个，所以他序号给我从二开始，我之前创建过，所以从二开始，因为说这个序号是一次给我递增的。

我现在再去node 01上。

我再启动一个客户端，我同样还是执行刚才的命令，在我的m sb下创建一个salt来给它一个初始值，000和刚才这个命令是一模一样的。

那么现在请问各位，下一个节点的序号是从一六开始，还是从零一开始告诉我。

来回车看结果，从一六开始，通过我刚才给你这一波操作，我可以得到一个结论，可以得到一个结论组kep，它内部会给我维护一个全局有序，并且唯一的序号来，这句话能听懂的，666，没毛病吧，老铁们嗯。

我们一会基于组cp写个分布式锁，就是使用了他这个特点啊，最主要的就是实现它这个特点，那如果我创建创建一个节点，我加上了杠e，也加上了杠s，那么这个节点就叫临时有顺序节点，如果不加杠e。

这个叫持久有顺序节点，如果不加杠s，这就是持久无顺序节点哎这，四种类型我给你讲明白了吧。