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

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

系列 1：P10：职业迷茫：外包能去吗？ - 马士兵官方号 - BV1mu411r78p

扯起来没完了，这个外包能去吗。

来同学们外包能去吗，每每天都会遇到这样的问题，老师那个外包面了一家公司啊。

周润国际这个能去吗。

有同学说不能工资高就去，还有同学说。

各位同学们，我觉得问这种问题的呢，这就是我我我我再推荐大家一本书叫批判性思维。

批判性思维。

那这不是输了，就是一种思考方式，同学们听我说那个呃你你们了解批判性思维的本质是什么吗。

就批判性思维的本质好多。

好多人说说我看到一个想法的时候，我要怀疑他到底对还是不对。

我要做一个对对对，杠精啊，这个hk说的特别对啊。

杠精批判性思维就是杠精，但实际上这不是批判性思维的本质。

批判性思维的本质叫做批判自己。

注意不是批判别人，是批判的自己。

是你自己有某一个特定想法的时候，一定要多方印证，好好考虑一下自己的想法有没有什么纰漏和bug。

是批判自己的思维。

大哥这杠精是批判别人的思维，所以好多人把批判性思维这件事情理解错了。

所谓的外包到底能不能去，我就觉得特别好玩儿。

问这问问出这句话来的人都觉得特别好玩，你知道为什么吗，我就想问你为什么不能去。

难道去外包会死人还是怎么着，所以这句话本身问的就有问题。

所有问这句话的人都被我怼回去，我说你有没有其他选择。

听懂了吗。

假如他说我有一个外包中软，我另外还有一个东南亚的机会。

那我应该选哪个，那我外包能不能去。

你得这么问，你有没有其他选择，如果你只有一个选择。

不要提外包啊，你就是凤姐儿，你也得老老实实的。

该进洞房，进洞房好吧，但是你有两个选择，一个是凤姐。

一个是杨超越，那你该选谁，老师给你提建议好。

不开玩笑，我们说外包这件事情到底能不能去。

当然能去，为什么不能去，外包的很多很多人的这个呃。

他进大厂之前的经历就是外包。

那还需要你建议，万一有人喜欢凤姐呢对吧。

嗯嗯。

外包当然能去啊，就是有好的外包的话，他做的项目也是非常不错的。

外包的技术也是锻炼人的，他的技术也不是白给的，天天还加班是吧。

给的工资又低，使劲让你加班，你说你的技术能不练吗，得使劲练。

听懂了吧，所以可以去，但是能能不能去。

其实要有对比的，就是你有没有其他选择，没有其他选择一定要去，为什么不去外包有方方面面的形式。

比较有名的。

像中阮了伯彦啊这一类的，其实好多大厂也是认可的。

当然还有一些比方说有一类外包啊，华为的ood德科。

这个大家知道吗。

德克主主知不知道。

华为的o d现在华为的社招，不好意思，都从德克总。

华为是让你想进必须先进o d必须先进那个那个外包k外包能不能去。

当然可以去，为什么不去多个选择的时候再来问这个问题好吧。

不要歧视外包外包没有问题的。

他的好多的技术用用的技术跟你真正的甲方没有区别啊。

最重要是技术过硬，就完全可以去啊。

华为社招不是停了吗。

呃准确的解读，我给你解读一下华为的社招现在什么样。

想认真听的，给老师扣个一，我给你准确的解读华为的社招。

华为社招现在是这样的啊，第一应届生没有停，985啊，呃那个常春藤好吧，第25年以上的没有停，就是那些高端岗没有停，技术专家这种级别的没有停，停的是什么，0~5年啊。

111~5年这些，那么这些如果想去的话，先去德科先去d。

然后ood呢每年有百分之多少的机会进到华为本部。

我忘了啊，大概是有百分之几十的概率进去。

系列 1：P11：马士兵深入浅出java虚拟机①GC垃圾回收预习_GC入门 - 马士兵官方号 - BV1mu411r78p

好了今天呢我们讲garbage collector和gc tune的前置内容，所谓的前置就是我后面正式开课的时候，我一般就不会再讲这些比较比较简单，比较基础的内容了啊。

在我们的vip课程里头可能就会直接讲非常非常给力的干货的内容，就不再讲这个非常基础的内容了，好看这里整个的这个内容的量应该说是比较大啊，我先给大家介绍一下整体的课程的内容。

这个整体课程内容你了解了之后呢，虚拟机的基础的概念，还有呢class文件结构啊，内存加载的过程，运行时的内存结构，什么垃圾垃圾怎么产生回收算法对应的逻辑结构对象分配垃圾回收器。

呃然后重点呢是调优的一个实战，关于调优实战呢，这里面内容也会比较多，在这儿呢我就不一一的给大家念完了，嗯。

总而言之呢，听完今天的课，你至少能够大致理解到底什么是garbage collector啊。

到底又是什么，一个入门级的内容，好了，我们开始一步一步来，首先我们聊呢到底什么是垃圾，到底什么是垃圾呢，关于这个问题，我要做一个简单解释，在如果你写过c和c加加的话。

那么在c和c加加里面需要手动回收内存的使用的，就是因为内存分配了一块区域之后，要手动进行回收，它还有多少同学是写过c和c加加c或者c加加的，有没有，有的同学是写过c或者c加加的。

那么写过c或者c加加的同学来，你能有一个反馈好吧，你来，嗯你比如说，你写过c或者c加加的同学，c语言里面申请内存是怎么申请的呀，呃memory allocation，对吧嗯没错好。

那释放这个内存呢free，对不对好，那c加加呢，六释放这个内存呢，delete好，我们聊到java，java申请内存，所谓的申请内存就是你做了一个指令之后呢，它会在在内存里面分配一块区域来给你用，是吧。

释放内存呢没有这样没有对应的释放内存的这块的问题，那好java是怎么释放内存的，java要自动回收，自动内存回收，那有同学会说呃，老师这个自动内存回收有什么好处吗，很简单，编程上简单，系统不容易出错。

为什么会系统不容易出错，为什么呀，y，因为如果你手动释放内存，会产生经常可能会产生的两类现象，容易出两种类型的错误，哪两种啊，同学们告诉我一下，第一种，忘了回收，第二种呢多次回收，好了。

那有同学可能会说老师这个忘记回收是什么意思，就是你用完了之后，你忘了忘了把它回收掉，你掉了new了，忘了掉，delete了，掉了memory allocation，忘了掉free了。

ok这个内存就是内存泄露，内存泄漏就多了，内存就整个溢出了，所以它会出现这种问题，那多次回收呢，多次回收就出的问题就更大了，多回周会出什么问题，你已经把这块内存给释放掉了，结果你不小心又释放了一次。

手工又delete一下，因为你这个delete呢在你写代码里头很可能会被封装在各种各样的if else switch，各种各样的条件语句里面，说不定就执行了两次，本来第一次呢你回收完了。

然后人家往里头装着自己有用的数据了，结果你第二次来了，光机又给人回收了一次，直接把人家数据给干掉了好了，这要多次回收，所以容易出这容易出这种问题，但是java里面是什么样的呢。

java里面是自动内存回收，自动内存回收就需要呃，这里面呢会有各种各样的这种机制来保证它自动内存回收的一个效率，可以这么说啊，呃java的这个调优呢，就jvm的这个调优。

主要就是集中在我们的垃圾回收机制的一个选择和参数设置上好了，那我们来聊呢，到底什么是，一个一个来聊啊，第一个呢我们先了解呢到底什么是垃圾，到底什么才是垃圾呢，在java里面很简单，如果有一个引用。

没有任何有一个对象啊，有呃没有任何的引用指向它了，好这个对象所占的内存就是垃圾，从这个图上来讲，我们在站空间里有一个变量new出来一个对象，这个对象里面有成员变量指向了另外一个对象。

那当我们比如说这个成员变量把它设为空，把它设成空值，now，直把这个成员变量的设置为空之后，就表示他不再指向任何引对象了哈，那这个对象就被我们称之为垃圾，当然这个呢呃只是一个一个对象的情况下啊。

这个对象就被称之为垃圾，那么还有一种情况是什么呢，还有一种情况是就是好多个对象啊，他互相之间的，有引用，互相之间有引用，但是呢没有任何的其他的引用指向这个循环的对象。

至少呢没有从我们的占空间里有任何引用，指向这三个循环引用的对象号，这叫做一堆垃圾，ok好了，所以这个就是呃垃圾的一个概念，就是没有任何应用指向的对象或者一堆对象，那好，明白了我们垃圾的概念之后呢。

下面我们来聊到底怎么样找到这个垃圾，我给大家呢做好笔记，到底什么是垃圾呢，好我们现在就可以下这个定义了啊，到底什么是垃圾呢，没有任何引用，指向的一个对象或者多个对象，这个多个对象之间呢是循环。

这些个就叫做垃圾，那怎么样才能定位这个垃圾啊，也就是说怎么才能找到这个垃圾啊，同学们两种算法啊，第一种算法呢叫reference count，引用计数，这个很容易理解，就是在我们这个对象上呢。

专门记录一个数字到底有多少个引用指向了它，比如说现在有三个引用指向这个对象，那肯定不是一个垃圾，好，这里就记住一个三，当我们有一个去掉一个应用之后，它就变一下去一个应用之后变一下去一个应用之后变一下。

什么时候变成零了，表示这个对象成为垃圾了，好这个呢叫做reference count，叫引用计数，两种方式，第一种引用技术，但是呢引用计数呢有个小小的问题，引用技术不能解决什么情况。

你比如说三个对象互相循环引用，但是没有任何其他的引用指向这里面的对象好，这个时候呢叫做三个垃圾，这三个垃圾每一个引用技术都是一，他也是一，他是一，他也是一，可是很不幸的是，你这一堆全是垃圾。

如果用引用计数的话，这种方式来找垃圾的话，这块就找不到了，就会发生什么呢，内存泄漏诶，所以，我们真真正正在hospital里面，就是在java虚拟机里面是采用什么样的方式来寻找垃圾呢。

是采用这样的方式叫做rude searching，叫更可达算法，或者叫嗯跟搜索算法说的都是一回事儿，那么这里到底是指的什么意思呢，就是我们首先通过程序找到一些跟对象，通过跟对象找到它相连接的一些对象。

这些不是垃圾，剩下那些全是垃圾，好这个是什么意思，我先给大家做好笔记，再给大家来解释，引用技术不能解决循环引用的问题，所以呢我们通常使用的叫做根可达算法，那那什么跟可达算法跟可达算法的意思是。

当我们一个程序运行起来以后，一个main方法运行起来，在main方法里面，我们说object o等于new object，那好那么你可以想象一下这个new object是在我们main方法里运行。

所以它一定是有用的，一定不是垃圾，因此根对象指的是什么呢，各位项指的是我们现在正在跑的这个县城站里面的局部变量，就是没方法里面这个局部变量，以及我们从class引进的class文件里面的这些静态变量。

还有一些常量池和jni指针引用到的那些个变量，请大家记住这个概念叫根对小，那有同学可能会说了，老师这概念我用锯子这么细吗，你如果不想进互联网，一线一线互联网大厂，就不用记那么细。

反正有人是在面试的时候被问到过的，我们也用java language specification，就是java虚拟机规范里面的话，他是这么说的，他说which instances are rts。

到底哪些个，对象是跟对象呢，局部就是那个本地方法栈里面的呃，ron constant用到的这类里面的常量池指向的那些对象，以及steady references in method area。

static method，static references in methoda，静态的变量指向那些对象，还有呢class就是你把一个一个class漏到内存，那些class的对象，它一定不是垃圾。

好这些的引用跟对象里面指向的这些个对象，再加上这些对象里面他的成员变量啊，指向的其他对象，再加上其他对象成员变量指向的其他对象好，这些全都不是垃圾，那么除此之外呢，像这种的，像这种的，通过根儿找不着的。

全是垃圾啊，这叫做根可达算法，好关于这个算法有没有同学有疑问的，不知道我说清楚没有，没问题，同学呢给老师扣一，计数法不是说不能用计数法，也有一些处理循环引用的一些方法，并不是说不能用python。

他现在用到的垃圾回收器应该就是基础法，就是reference count，但是java的hosport并不是这个方法，hosport本身它的运行效率要比要比python要高好多好多。

其中应该都有它的虚拟机的这种垃圾回收算法的功劳，我们说好，hosport垃圾回收算法肯定是要比python要稍微先进一些，好了，当我们能够定位垃圾之后呢，我们就需要对它进行回收了。

那常见的来就会说算法有哪些个呢，好看这里，常见的垃圾回收算吗，有这三种，第一种呢叫mark sweep，叫标记清除啊，第二种呢叫copy，第三种呢叫mark compact，叫标记压缩，基本就这三种。

我们一轮用脚都非常简单，一带而过mark sweep标记之后进行清除，诶，那个意思就是我找着那个不是垃圾的那部分，然后就是找到那些垃圾把它给清了，就这么简单，然后内存里面嗯。

灰色的这些个呢都是我们正常的一个对象，绿色这些个呢是没有使用的，那么黑色这些是垃圾部分，那找到这些垃圾之后呢，就把它擦掉，把它给给他一个标记，说这块呢你可以用了，标记成绿色的就ok了。

这个叫做max v标记清除好了，同学们，这是标记清除算法，这个算法呢非常的简单，找出垃圾，把它标记成为非垃圾区域搞定，那你告诉我这个算法有些什么样的问题，没有有没有什么样的问题啊，给点反馈来。

我给大家做笔记，你们给我反馈，标记清除算法，队友位置不连续，没错，产生碎片，第二种呢叫ging，叫拷贝算法啊，好我们来看拷贝算法是一个什么样的东西，拷贝算法呢也非常简单，就是你呢假如有这么大块的内存。

然后我把这块内存咔嚓分成两半，分成两半，我只用其中的一半，当我们需要进行内存回收的时候，我们就找到这些个使用的这一半里头那些个存活对象，找到了之后，就是挨着盘的，往另外一半拷贝。

不是拷过来拷过来拷过来拷过来，然后你考完之后呢，大概就是这么样的一个情况了，等你拷拷贝完成之后呢，把上面那块区域咔嚓全部都给它清除掉，往下面这块区域分配，什么时候需要回收的时候。

再把下面那块咔嚓copy回去，拷贝来拷贝去，拷贝来拷贝去啊，这个叫做拷贝算法，也很容易理解这拷贝算法的优势在哪里呢，它没有碎片，拷贝算法是没有碎片的，对不对，但是它的缺点在哪，来告诉我一下。

拷贝算盘呢是没有碎片，但是浪费空间对它没有碎片，而且效率比较高，并且呢是连续的啊，还很容易做好，后面的内存的分配很好，不过很不幸的是，它太浪费空间了，你别放了多少内存，你得准备两份是吧。

你计算一下你的系统需要五个g内存，可是你不幸的是，你得至少买个十个g浪费粘掉，所以这两种算法都要跟他缺点，那么第三种呢，第三种叫做标记压缩，叫mark compact。

my contact的意思是说一个内存里面分配的这些对象之后，我们需要进行回收的时候，怎么回收呢，这样来回收诶，就是我呢把这块内存已经标记为是一个垃圾了，然后我会把后面的这些个存活对象拷贝到这里来。

然后把后面对象的拷贝到这里来，在做标记和清除的过程之中，同时做了一次压缩，做了一次整理，做整理之后有什么好处呢，把这些个有用的对象全部都放一块空白的区域，全部都连一起，后面再申请一些个大的内存。

申请联系内存的时候容易找着地儿好，这叫做标记压缩，这个标记压缩算法肯定是最好的，又没有浪费空间，然后又让内存进行连续是吧，同学们就该联合，肯定100%是最好的，但是很不幸的是呢，这个算法它的效率偏低。

这个算法的效率是比较低的，和另外的两个算法相比，它的效率会比较低，为什么要你们想一下，为什么效率会比较低，效率表决的原因在哪里，比方说拷贝比和copy比，效率比较低的原因在哪里呢，标记压缩，没有碎片。

效率便宜，嗯首先就是你找垃圾这块所有的这三个算法呢，就是所有的算法都是一样的效率，重点呢是你找到这些垃圾之后呢，怎么进行整理的过程，呃，对于拷贝来说，他只要内存的拷贝，它速度是非常非常快的。

它就是一个线性地址的一个拷贝，他的效率非常高，但是对压缩来讲可就没那么容易了，压缩为什么没那么容易呢，很简单，因为你任何一块内存在进行移动的时候，如果是多线程都得要进行相同同步，如果是单线程。

那你单性能的效率本来就低，所以任何一块挪动都要进行相同幕布，它的效率肯定会更加低一些啊，好了，这是三种算法啊，我们再稍微录一下常见的垃圾和垃圾回收算法三种，第一种呢叫标记清除，第二种叫拷贝。

第三种叫标记压缩，这三种算法各自有各自的优点，各自有各自的缺点，在实际当中怎么使用呢，实际当中的用法是，看我们具体的各种垃圾回收，垃圾回收器啊到底是怎么运用的，在jvm里面呢，目前的站在垃圾回收的角度。

目前的这种内存的模型有两大类吧，可以说啊这个jdk嗯1。1。8和1。9是一个分界点，今天呢我们主要讲的是生产环境里头经常用的最多的，目前生产环境用的比较多的，1。8用的比较多，还有的是1。6，1。7。

用后面的更更更高一些的呢，好像还比较少啊，高版本的还比较少，所以呢我们现在要讲的话，也主要是指的这个这个只能主要是以这1。1。1。8的版本为主，好吧，那好，在1。8以前的很多个垃圾回收器看来呢。

他会把这vm呢分成很多很多不同的或者叫不同的区域啊，我们今天讲的内容是以1。8为准啊，有明显区别和1。1，有一明显和1。7有区别的呢，我会给大家讲一讲1。7的内容，好那么再强调一下啊。

需要你你你你你需要嗯要一下老师这个文档的同学啊，你可以找一下我们的小刘老师好吧，没有加小九老师微信的，后面进来的同学，你加他一下，扫他一下啊，十秒钟b勾满10 四。

下面呢我们就开始聊jvm内存的分带模型，好看这里这个内存的分带模型，主要是把内存区域呢分成这么两个代吧，两代，第一个呢叫新生代，第二个呢叫老年代，当然1。7的版本，还有一个年代叫什么呢。

叫permanent，叫永久代，permanent，generation，为大家呢写在笔记里啊，我们说dm的分类模型，首先第一点需要强调的是，在，部分垃圾回收器啊，使用的模型哎，有的人会说。

为什么部分篮球回收器使用的模型对没错，在这外面这种模模型里面呢，如果我们使用的是比较新的垃圾回收器，比如说g1 ，比如说z g c，比如说shando啊，它里面是不再分，不再区分年轻代和老年代了，好吧。

在一些比较传统的垃圾回收器啊，使用的时候，它是要把jvm的内存多内存啊分成各种各样的年代模型，部分垃圾回收器使用的模型好一会我们讲垃圾回收器的时候，会告诉大家哪些垃圾回收器使用这样的分类模型。

那放大模型里面呢，一般的情况下呢，比如说在这个这个一般一一般是分成这么一个年代，第一个叫新生代，我们叫它new或者叫药啊都可以，还有一个老年代，你叫他old或者叫tenure都可以。

那么还有一个呢叫做1。7，叫什么呢，叫永久代，给1。7啊，那么1。8呢叫做圆圆空间，原数据的空间，原数据啊，metast，这是1。8，英文那叫min space，呃有我不知道有没有同学了解这两个的区别。

就是永久的1。7和1。8的元数据区，他们俩有什么区别，同学们按照分类模型的话，有没有同学知道的给我点反馈，有没有，首先这2年的都是干嘛的呀，永久带和原数据，都是装什么内容的呀，装，class。

各种各样的class对象的，就是我们把硬盘上的那些class漏到内存的时候，装到哪里抓哪里呢，装到了，永久弹或者原数据里面，就看你使用的是哪个版本装class对象的是吧，那么这两个的区别主要是什么呢。

零九代啊，只可以指定大小，可以指定大小限制，然后这个限制到最后就会成为你的整个系统的一个限制，你比方说你指定了500兆，当我们使用了动态代理之后。

它可能会动态的给你添加好多好多的各种各样的class文件，class类类文件进来，这个时候你很可能会发生什么呢，永久代的一个内存溢出，指定大小限制，它是必须指定大小限制，应该说，但是原数据区呢。

圆柱与区是可以设也可以不设无上限，可以设置也可以不设置，就是你可以设置一个最小的，你可以不设内最大的，它是没有上限的，什么时候这这那那内存爆了，位置就是你可以充分的利用啊，你说有多少内存。

这块呢只是受限于，物理内存啊啊这是永久的和原数据区的一个区别，当然它还有一些很细节的区别啊，你比如说原来的这种呃字符串常量，这是很很很细节的一个区别了，像这种了解就行了，不知道呢关系也不大，一般也没有。

面试官问你这么细的东西，像1。7里面字符串常量是存在哪的呀，是存在永久代的perfect area，但是呢1。8之后在哪儿呢，它不会存在原数据区域，它要在堆里，这个小事情啊就不管它了好了。

这两块内容呢比较简单，我们不多说它，主要我们来聊这个新生代和老年代，低学历人士说声音是断断续续的，那么其他人呢，诶同学们，正常正常是吧啊，没有问题是吧嗯，好那刚才有朋友问我说这个方法去meca好听。

我说method area，呃我我我读那个java language specification，就是java虚拟机规范的时候，method area是一个逻辑概念，按照那本书的解释。

message a是一个逻辑概念，它在1。7上对应的就是permanenting area，就是永久代，在1。8上对应的呢就是原数据，这是一个逻辑概念好吧，它并不是一个真正物理的物物理上的分区啊。

这我我就不不带大家打开那本书读了啊，所以mega你在1。70就简单认为就是永久带就行了，然后呢在1。8上他就认为它是原数据区就ok了，呃概念这个东西呢是人们发明出来，为了更好的理解问题用的。

所以大家理解就好，不一定非得咬文嚼字的，每一个都得抠清楚，没有这个必要，那个华同学问永久代和元数据区是属于堆里面的，不属于呃，这么说啊，永久代在永久代属于1。7元数据区呢。

实际上是不再受对内存的一个管理合同，就知道虚拟机呢都不去管他，谁去管呢，整个操作系统受限于操作系统就行了啊，有什么大动，看这里下面的是堆内存的一个逻辑分区，堆内存的更详细的一个逻辑分区。

就是我们把刚才我们讲的永久代和原税区给他扔一边儿，那个呢就是专门装class各种class class类的对象，以及那些个一些部分的那种常量池的内容呢，啊呃把那个呢先扔一边，我们先来看看运行时的时候。

运行的时候，程序运行的时候需要用到的这个堆内存的一个逻辑分区，好在多内存里面，但是这里跟站是没有关系的，我主要讲的是堆的堆的内存，在堆内存里面呢分成我们刚才说了，分成新生代和老年代是吧，new和old。

这两个呢在新生代里面呢，我们先说结论啊，一会儿再来说他为什么在新生代里面呢，我们又分了两类区域，三个区域一个叫一点，一个叫survivor，survivor有两块，默认的一个比例是什么呢。

叫新生代比老年代一比三一点，比上survivor是八比一比一的一个关系，这几个区域都是干什么使的，听我说了解这几个区域干什么使的呢，你就需要知道一个对象产生的过程，当我们一new new一个对象。

这个对象在哪里进行内存分配，默认呢会去找一点区，会在这里面找区域，假如这个力量特别大，这一点区撑不开怎么办，直接进入老年代，好了，那有同学可能会说了，老师这个伊甸区和为什么里面还要分两个sweb区啊。

我们先把笔记给大家记好，新生代老年代，那么新生代等于什么呀，一点去加上两个，sliver去，他为什么要有两个survivor区，主要的原因是有利于内存的一个回收，也就是垃圾的回收，为什么要绕这两个区呢。

都你们想一下啊，这个进行垃圾回收，刚才我们分析了有好多个算法是吧，新生代有一个特点，新生代的特点是什么呢，一旦进行垃圾回收之后，一般的新生代的垃圾回收，y young年轻代码年轻代的一个回收之后。

它的特点是进行一次yg c的回收之后，大多数的对象会被回收，好什么意思啊，就是那个这个新生代理的内容，我们new出一个对象来的一个for循环里，每每每进行一次循环都要new一个对象，那就是一堆对象。

当然这对对象除了这个for循环，那可能可能没有人再引用它了，所以这类对象在一次ydc之后，这个对象里全是垃圾，我们可以这么说，就是说在没这个区域里面产生的这些对象呢，多数情况下会被回收。

百分之八九十的对象在进行垃圾回收的时候会被回收掉，那么大家想一下，用什么样的算法会更合适呢，我们前面学过的三种算法，哪种算法更合适呢，好听，我说在这里呢hosport呢设计上呢设计了survivor区。

这个算法会更合适，因为它使用的是拷贝算法，效率是非常的高，他是怎么做的呢，就是你先往一点区里面分配对象，分配了十个，然后一次回收之后回收到了九个，剩下的一个有用的对象，找到了之后。

注意我直接把它扔到survivor去，我不在这里做任何操作，我直接把它扔到survivor去，我是扔到这儿了，那用到这之后就说我们把剩余的这些所有的对象啊，活着的对象全都扔不到survivor区里面。

直接扔过来，扔过来之后呢，我整个区域咔嚓全部标记可以了，都能用了，所以这个效率非常的高，他不需要在本区域里面做什么压缩，做什么标记清除，都不需要，他只需要把这些火热对象康熙往这边一拷拷贝。

我们说过内存的拷贝的速度是相当快，相当快的好，这是第一次进行y dc之后啊，不知道说清楚没有，有的同学看看有没有同学有疑问的啊，y0 c之后，大多数定向会被回收，活着的对象，进入s1 s0 嘛。

进入s0 叫survier 0，活着真相进入s0 ，这是第一次y dc，那么在下一次y dc，再次y d c注意这次外dc的时候，除了呃我我们中间的这个伊甸区又有一些新的对象之外是吧。

然后s s0 这个区域里头也有好多好多上次回收过来的这些个是吧，好这次呢这两个区域的内容全都拷贝到s一里面，全都拷过来，这这里面可能回收了几个，拷过来拷过来拷过来拷过来好，然后这两块区域全部干掉。

全清空，全部回收，o这样呢在这次回收之后呢，我们就只有一个区域里面，这个对象有用了，谁呢，就是s一这个区域，再次外地生活，这个对象，加上s0 区的进入到哪里去呢，进入到s一区。

然后再次呢我相信后面的过程你应该拿大腿响应能能想出来了，再次a d c呢火热对象是一定区的，有一部分再加上s一的，有一部分放哪去啊，s0 里面好的，来回来回来回来去来回来去，年龄足够进入哪去。

进入old区，老年代好了，同学们什么意思，就是有一个对象呢，他这个存活的年龄特别高，这个被回收一次，它长长一岁，被回收一次，涨一岁，然后开机开机开机开机开机开机复印了很多螺丝，这哥们老是都被回收。

我们就认为这哥们是一个顽固分子，干脆啊，我不要这么频繁的老去回收它了，我把它放到一个不是那么频繁的会被回收的区域，哪个区域呢，o的区域放到这里来，好这个过程不知道说清楚没有，有没有同学有疑问的。

有问题同学你直接提，没问题，问题给老师扣一，所以它内部的设计是这么设计的，同学们，那么你们想想看他为什么这么设计呢，它这么设计的前提是什么呀，这设计的一个前提就是说我们确确信一点区里面分配的这些对象。

一次进行回收之后，百分之八九十会被回收，它设计成默认的八比一比一的比例是为什么呢，就是智智力他们差不多也就是10%左右的对象会被回收，啊sorry，不是被会被回收，而是说90%的会被回收。

只剩10%的对象存活，这一个vivo其实够使了，就假如我们自己的设计的程序里面，这个new的对象都不会被回收，那拷贝来拷贝去了肯定就会成问题了，好那那有同学可能会说，老师这拷贝过来的时候，他成不开了。

怎么办，成不开了，直接进入老年代，s区，装不下，那就是老年代，总而言之，老年代就是那个兜底了，好吧，就前面这些个操作全干不下去的时候，直接扔给老年代，好，那有同学很多说老师这什么叫年龄足够啊。

这个年龄足够呢，他细节还比较多呃，在用一些比较古老的垃圾手机，垃圾回收器的时候，这个年龄是15岁，但是如果你用的是cm的话，这个年龄是六岁，所以他还不是很一样。

所以这个事儿呢我们你得看你具体用的哪种垃圾回收器啊，这一会儿再说好吧，那有同学会说，那老师那个老年代都装不下了呢，好老年代，老年代满了怎么办呀。

老年代满了之后会触发一次f g c f g c l通常称之为叫负dc，老年代满了啊，是装food c，当然这个老年代是装什么的呀，装那些顽固分子啊，嗯既然我们聊到这一步了，对于这种垃圾分类的这些个算法。

垃圾回收算法来说，jc ti呃，我们这里假设的是分类算法啊，generation的算法分成各种干净的一个算法，这个j c tan是在调什么呢，我们的目标是一般尽量减少，f d c。

这是我们调优的一个目标，什么意思呢，我们我不知道在座的同学，你们的线上的服务器到底是一个什么样的配置，同学你们线上的服务器到底是什么样的一个配置呀，哈哈哈。

大多数的可能四核8g算是很普通的一个服务器是吧，16g对差不多吧，就类似于这样的一些个这这这样一些配置，那么大家你你你分析一下啊，假如说你在这里面给老年代分配了你16g内存，给老娘呢分配了八个g。

给他分配了九个g，给他分配了三个g好了，同学们，我们要进行一次full dc负dc是什么意思呢，就整个的对内存的一次回收12个g，12个g里面进行各种各样的算法的计算好。

这个效率实际上是非常非常非常慢的，所以这时候会产生什么叫s t w就stop the world停顿现象，你的内存越大，你停顿的时间就会越长，所以我们一般的尽量的不要让它产生f g c。

f g c的算法也比较复杂，它会找到了之后进行mark compact进行压缩，这个压缩算法也比较慢，所以产生y j c是这个避免不了的，但是yg c的效率比较高，因为它拷贝。

但是我们尽量的不要让你的系统产生f g c，当然完全不产生的可能性呢也不也不太大，就是你的频率越低越好，关于这个目标，大家大家不知道大家是不是能理解啊。

四点钟的补偿说close方法不也有试验释放资源的用法吗，你问的这个方法，你问的这些东西呢，其实那个你应该是完全没有理解或者sorry，应该说没有完全理解java本身的一个概念好吧，close是释放资源。

不是释放内存两回事啊，for dc少major dc就要多了，同学们澄清几个概念，minor gc，y d c，major gc，负离子一个概念好吧，有的人可能总不能不释放吧，假如你的系统运行的很完整。

很完美啊，那么你多数的情况下呢，你for循环里面产生对象，一次回收就直接给他干掉了，有很少的或者基本上没有对象会进入到我们的老年代，我们老年代会这个对象进来的特别少。

这是你整个系统运行的一个比较完美的情况，这不是废话吗，都得释放，你外地c不也是释放吗，就算是慢，你时间长了，7x24小时，365天不间断的运行的情况下，这个old区也会装满的，old区装满了之后会进。

行一次复dc进行释放，但是我是说尽量减少减少这个冲击，fdc，音乐产生一次没问题，这是能接受的，对不对，所以你看什么样的频率，你看你实际当中的这个业务场景啊，有的场景呢是一个月上一次很好，非常能接受。

有的场景可能是一天才上一次，我就能接受一个小时，上一次我也能接受等等，看具体的业务场景，总而言之，我们调的目标是什么，是尽量的减少好吧，不是说他们不不这东西不能避免，但是尽量减少。

有狗哥外地森有s t w呢，s t w吗，嗯你这个是前面听过这么多次课，还问这种问题，属于是非常的业余了啊，他到底有没有s t w，听我说就所有的垃有没有s t要看垃圾回收器。

按照垃圾回收的这个目前这个拷贝的算法来讲，他一定也会有s w，但是呢听我说就是有些垃圾回收器会把这个s t w呢进行更好的优化，s t w这个现象在自动垃圾回收这个区。

这个这个这个这个这个技术区域里头是少不了的，好吧，你是避免不了的，不可能没有啊，他只是尽量的把这个时间减少而已，好你们问的问题很多人其实都牵扯到后面内容了，我们现在讲后面内容好吧，关于前面我讲过的内容。

这一部分有没有同学有问题的，只问这部分，因为你们现在提的问题，只不过你是还没有了解后面部分内容而已，了解了之后，你不再会提这个问题了啊，别送别，能不能做总结，这不还没讲完吗，讲完吗，再做总结吗。

他的面问为啥不过滤第一步直接进，第二步什么意思，没理解你的意思，说清楚啊，装不下的时候，装不下的，放到老年代还是s区的，都放到老年代装不下的，这拿大腿想一想也不会把所有的全中往年带去吗，肯定是装不下的。

扔往前带啊，你把那两个桶里倒豆子，倒不下的扔，扔到那个大库房里去是吧，好不说了啊，我们来看这个常见的垃圾回收器来，好我们来看这个常见的垃圾回收器，那垃圾回收算法呢只是垃圾回收器用到的一些算法。

在目前到现在这jdk的13为止，就这十种好，这个图请来背锅的，啥也别说，你把它背过，你是不是截个截个屏吧，好不好，好看这里啊，这个垃圾回rog就是垃圾算法的垃圾回收算法的一个组合，应用在不同的年代里头。

好听我说上面这部分叫做呃新生代，下面这部分叫老年代，比如说下面这些算法是用在老年代的上面，这些算法是用在呃新生代的，跨在中间的是不再分老年的黑新生代了，整个区域不再分了。

好目前我们在线上运营的运行的系统，多数的情况下都是集中在这块区域，线上运行的系统里头，还很少有人在用这部分啊，至于后面这两个呢就用的更少了，absent是这里可以做debug的时候用的。

这个就是他自己做内部做测试的时候用的一个呃，什么事都没干，只是用来调试jdk的，所以呢这个我们一般不用你了解也好，不了解也不了解也没什么关系啊，它叫absent，所以你如果是在目前2019年。

你的重点的调优是掌握这部分内容好吧，当然我们课程里头呢所有内容都会涉及到，因为将来也许在不久的将来，大多数人都会针对于g一来进行调优了，也不再不再针对于原来这种分类方法了，那么如果是这么用的话呢。

其实你的调优的压力要减少很多，因为g一和z d c的，它它的内存模型要比现在这种分类模型要简单的多，好了，今天呢我们主要只能谈分类模型好吧，那分类模型有哪些呢，第一种呢叫呃serial，第二种呢叫pu。

第三种叫parallel scavenge，那么还有一个叫concurrent mark sweep，serial old，serial parallel old，所以其实你仔细看的话呢。

就是说这个parallel并行的，parallel，并行的serial呃，串行的串行的，其实这两个呢你可以看成是呃同样的种类，只不过应用在不同的区域上好吧，同样的种类应用在不同的区域上呃。

最早的这个只有最早的这个这个这个组合呢是这两种啊，serial加上serial old是这两种组合，就jdk最开始的时候就这两种，所谓的serial是什么意思，所谓的parallel又是什么意思啊。

认真听，这是在只要虚拟机规范里头啊，就hospital的说明里头对他的各种各样的垃圾回收器的一个说法，我这里给摘抄了下来，seo是什么呢，他说stop the world copy collector。

which uses a single regic thread，stop the world，那意思就是本来你的程序正常运行的这个蓝色的线，表示我们的程序正常运行好，运行到一定程度之后。

我的外区域满了或者一点区满了，满了满了怎么办呀，满了就要触发ygc嘛，触发y d c在y d c这时候怎么做呢，甭管什么dc，触发dc的时候怎么做呢，stop the world，停下所有的用户线程。

停下来，垃圾回收线程上场，回收完垃圾之后，程序继续运行，运行内存图又满了又满了，怎么办，停下垃圾回收上场就这么循环着来啊，不知道大家能不能理解了，当然到某一个程度，它触发的是负dc。

那如果是full dc，就看你在o的区里面用的是什么样的算法，在一样区里面用的什么算法，然后这两个算法一组合，整个执行完了之后，你的程序才能继续运行，所以在垃圾回收运行的时候。

我们的应用程序是没法运行的，这也是为什么有好多的java的程序跑一阵之后，诶，它就会产生停这个停顿现的卡顿，现象主要就在这儿，这个名词叫做stop the world s t w。

那这个叫serial好，关于cereal，看看同学们有什么有疑问的地方，常见的篮球路由器，dual serial它是用在哪个区的，年轻代的单线程的是吧，单线程垃圾回收，串行回收没错，卡顿是cpu卡顿。

哈哈，你你你你这个卡顿是cpu卡顿，cpu永远不卡顿，大哥他永远有活干好吧，就你这程序卡顿了吗，你现在跑的是一个java程序，那个java程序，你在这跑着跑着，你点点不动了，没有反应了，不就卡顿了吗。

好了别别别在这咬咬文嚼字的来，非得要整清楚这种概念，理解什么理解就行好吧，理解什么意思就行啊，串行回收没错，就是串行回收，serial，串行的意思好，这是siri的概念，好吧，好关于这个概念。

还有没有同学有疑问的，没问题，给老师扣一，我们来看parallel，parallel最早产生的是parallel scavenge，也是用于年轻代的啊，ps pal stage也是为年轻代的。

其实就是并行回收，并行回收，这图一看就明白，多个线程同时进行垃圾回收吗，并行回收它的效率显然要比单线程要高一些，好坦new又是什么意思呢，talon new。

it all the word coin collector，multiple gic threads，他和parallel govern的一个区别。

it from parlogin that it is enhancements，which makes usable with cm，好同学们，所以这个判定啊，你通过这句话就能理解pu是个什么概念呢。

就是它和cm s配合使用的，就这意思，看这里回过回过头来看这个图，这个图里面呢这一根一根的小红线，虚线的小红线不是白化的，就是每一种垃圾回收，两种垃圾回收之间是怎么组合，怎么配合的，哪种和哪种能够配合。

serial在和cms是能配合的好，pu和cms是能配合的，但是parallel coverage和cms是不能配合的，所以，为了配合cms在parallel parallel sc基础之上。

他设计了盘new parallel new啊，这个意思好吧好了，ps队形回收，那么肯定呢，配合cms的并行回收，这几个全都是年轻的啊，年轻带，年轻的，啊那个老年代的老年代的有哪些呢。

老年代的有这三种seo old片的old，我觉得这东西我都跟您解释了啊，serial old就是把这个serio的算法呢放在old区，还有呢parallel old。

好关于上面这五个有没有东西理解不了的，单线程的回收算法放在old区，单线多线程的回收算法放在old区啊，上面这五个有没有同学理解不了的，你提问如果没有什么问题给老师扣一啊，不能配合在一起用。

是否会报错了，你试试回城，你试试啊，没事我懒得试，不报错，就他告诉你这个不方便混合在一起使用，就别用了呗，你非得试试是吧，那你就试试啊，在这里呢，他为了提高效率，发明了一种特别复杂的算法。

就是concurrent max位置，好这个算法呢是用在old old区的老年代的，这个算法非常的复杂啊，我今天不打算解释它，嗯，等我们正式上vip课课的时候，专门来解释这个cm。

但这cms呢虽然它非常复杂，号称效率比较高等等，就cms呢它非常的复杂啊，这个它是concurrent，concurren的意思，它这个concurrent的主要表示的是什么呢。

在指的是在我进行垃圾回收的过程之中，我的应用程序也可以同时运行，是这意思，所谓的concurrent那个意思就是说啊我就没有，我就不需要stop the world了。

大的减轻了这个stop the world的现象啊，就是他的和呃在他的所有的阶段里头，有一部分的阶段是我们的垃圾回收器在运行，我们的应用程序也在运行，而其他的所有的那些都是应用程序运行的时候。

垃圾回收器没法运行，这是cm的一个意思，它本身算法呢非常的复杂，今天今天呢我并不打算解释它，你先记着就行了，解释cm我需要整整一节课的过程，好了，但是虽然cm呢看上去很先进。

并发的并发的垃圾回收和应用程序同时运行，降低st w的时间，这个时间呢它的官方说法是能降到200个毫秒以内，像原来的这些s d w，尤其是这种cereal年轻代的，加上co的这些要来一次复仇，dc的话。

长的可能会经过几个小时的回收，就几个小时一动不动，像到了concurrent max sweep的时候，他的号称的时间能够降到200ms之内，但是contra max sweet他的毛病也特别多。

不过呢他也是开成省前几后的这么一个这么一个垃圾回收器，在这垃圾回收器之后呢，诞生了后面的比较优秀的垃圾回收器啊，这些垃圾回收器是什么呢，第一garbage，garbage collector。

z d c叫zero copy呃，叫zero，它这个z指的是什么意思来着，这叫叫zzero zero stop，the world zero stop，就是零零停顿好，这个目标会达到多少呢。

十个毫秒以内，据他的测试好吧，十个毫秒啊啊，sorry，g一应该是十个毫秒，那么z d c呢据说是达到一个毫秒以内，那达到1ms以内什么概念，pk c加加了，就是他要跟c加加可以抢夺市场了。

非常非常的厉害，当然还有目前和他那个竞争的叫shen多啊，呃这两个z d c和shen doa其实是都处于一个实验实验过程之中，就是属于是实验期，最后是我们定z dc还是实验in door。

呃现在目前看j d k倾向于是定cdc的，也是这两个是二选一的一个关系，好用他的就不用它，用它就不用它了啊，谁能够，那么第十个呢叫excellent，这个我刚才解释过了，不多不多说了。

常见的ip由器呢就这么十种，我在vip课程里头，我给大家讲这个concur max weg e z d c神龙斗啊，这这部分内容，但是今天的我们解释不了这么多，大家先把这个结论给记着好吧。

现在其实我跟大家说一下，我们大多数的所谓的调优调的是哪部分呢，告诉你全是上面那个嗯嗯嗯画得更加的那个少一点，是这个加这个，呃为什么是一二和四五呢，原因是解释一下原因是什么呢，原因是1。

8默认的垃圾回收器，验完默默认来就没容器是什么呢，hello，sevenge，加上po，其实啊大多数的人就是在上线系统的时候，他们也不是非常的了解这个垃圾回收到底怎么调油之类的，用的全是默认的。

所谓默认的用的也就是这个多线程的年轻代，多线程的老年代啊，也也也也也也就这么来用了，他也没有用cms也更g一就更别提了，所以在这种情况下，大多数在进行调优的时候，是针对于这两个的调优，我讲到这里。

不知道大家能不能理解这个常见的垃圾回收，记过头来再看这个图，细节呢每一个解释起来每一个都比较多，但是呢我们先把这个图给记住，我们说学东西呢先把它体系化，然后再照这么个细节深入进去。

好这个图不知道大家能不能背过了，给大家十秒钟，你背过这张图好吧，今天的这篇文档需要的话，请你加小七老师啊，sorry，小九老师b勾码是004啊，好这个图背过哪几种，适用于年轻代的，哪几种是用于老年代的。

哪些是可以，他就不再分带了，没有老年代和年代之分了，记着这个图，好，我们继续啊，呃我们讲今天的最后一部分内容，今天我们最后一部分内容呢给大家讲一下呢。

你到你了解一下你生产环境这种你到底用的是什么垃圾回收器啊，我相信很多同学是不了解的，有多少同学是能够呃接触到你们生产环境之下的，这个这个这个这个呃运运维的这个环境的，有多少同学能接触到的。

你给老师扣个一，有没有，就是说你能不能在你的生产环境的机器上去运行自己的一些命令，l l啊，暗夜lucifer听的像三三十刘也啊，能看到不能改，能看到也可以啊，要陈奕瑶堂姐啊。

pk但是你们这个级别都是可以的啊，大多数的其实初级的成员是接触不到这个环境的，还是不跟你接触的好，如果你能接受的话，你们从今天开始不要去改，不要去改啊，没必要改好吧。

你们今天开始呢可以在上面执行一些命令，我来教你们怎么去了解你们现在这个生产环境运行的过程之中呢，它到底是怎么配置，怎么设置的，在这里呢我给了大家一个命令行的参考，你们自己呢去打开去看就行了。

呃说到这儿呢，我真的得吐槽一下oracle，oracle的这个文档的组织简直组织的像一滩屎一样啊，屎一样的屎一样的烂，就是你想找某些东西的这个某某某某某些内容啊，我跟你说费死劲了。

就是你想认为他应该在的位置，它全没有，那个用那个找12 13呃，这个11这些文档找不着的，没有的，练着练着就练到八去了，好吧，吐槽也没有办法啊，他现在还比较牛。

我看着我看看着我看着这个这个oracle啊，慢慢的会走向向散的这个程度了，一起有了散的那种感觉了，好不说他啊，那你说这边的一个命令的分类啊，这命令的分类在jvm里面，命令呢分成好几种，一种是标准命令。

是以杠开头的，呃，不是命令分类，对不起啊，是参数分类命令，参数分类，标准的参数，非标的参数，不稳定的参数，标准参数都是以杠开头的，举个例子吧，这里还是得举例子。

我打开一个命令行窗口啊，稍等一下拖过来，java conversion杠开头的标准命令，杠x开头的非标非标准选项，大写x。

他会告诉你那些非标的到底有哪些。

关键是你倒告诉我那些杠xx开头那些有哪些啊，没有你这你得自己去查，最关键是我还查不着，如果有谁能查着，你告诉我一声链接在哪好，这些以杠s s开头的这种多了去了好几百个，有办法能够输出。

我告诉你怎么输出，常见的一些个这个输出办法吧。

怎么输出，看这里，java杠xx冒号，记不住，找一下，用这个proflex final，看这里，应该是没有加上啊，print flags final回车有加号，我不知道你们看没看我的屏幕啊。

看看有多少这个翻，你往上翻的话就特别多，为了让大家看清楚，我是把黑屏的，就是命令行窗口的字体也扩大了啊。

还有这么多，凡是你看到的这些都可以杠s和s开头来进行设置。

这些选项多了去了好几百个，un u m a啊，又又又又没有这种cpu和内存的插槽模式是吧，ug g y g c，你有没有用这个g y g c，那等于是false表示没有用等等等等。

也就是说你如果想用g e g c g y g c怎么怎么说呢。

这样来说，举个例子啊。

看这里这个杠，如果你想用g one dc怎么写，这样写，柚子第一dc好，这样的时候呢你就呃用的是你的这个，他有时候带加号，有时候不带加号啊，必须得用账号，就是你用的你就是g e g c了。

当然我这个程序呢由于本身没有主类没有运行啊，所以他输出了一些别的，这个很正常啊，呃我的意思就是说你可以用这么几个命令来知道你的系统呢。

现在是采用的启动的时候呢，设置哪些参数，第一个呢是print flex final，就是把你最终的那些用的那些值，最终生效那些纸全给你打印出来，这里特别多，你想找里面的值的话。

在linux下用grap给它过滤一下，找出来你相应的那个值，print flexy initial，是说这些值的默认值是什么值好，还有一个经常使用的，大家把这个记住，今天呢大家把这个记住。

print common line flags，这个呢我给大家敲一下，敲到我们的笔记里常用的，杠xx，烤一下呗，他敲错了，主要是，林中森，prinly print print coconuflags。

那么这个用的是什么呢，这个指的是什么呢，这个呢指的是诶，当你你的这个系统里面运行的时候呢，它自带那些命令行参数，它启动的时候，那些命令行参数都给我打印出来，到底是什么，这是经常使用的。

所以如果你能接触到你生产环境的，你可以在这个生产环境里头执行这个命令，你放心，这个命令不会对你的环境造成什么影响，他只是来观察在你的生产环境里头，他们用了哪些个参数而已。

直接人家看看好吧，java杠x x，看这里，这是我的这个jav程序启动的时候，他又启动了哪些个命令行参数哪些呢，也没说heap size起始的时候，这个堆的大小是多少。

max heap size最大最大小是多少，command line flags，这是我自己带的这个了，压缩指针，压缩对象啊，对对象进行压缩。

use large pages in the visual allocation，大分页啊，use plogic，好，通过这里你就会知道作为这个系统里头，use parallel g c。

哈哈哈，use parallel dc指的又是什么呢。

它是parallel scavenge，加上parallel old，好，我的版本是什么呢，加了conversion，刚才可能有同学没看到1。8，所以1。8的版本默认的情况下。

他使用的是parallel c。

好了，能够接触到生产环境的同学，请你去执行这个命令好吧，还有一个给大家交出来叫print flex final，print flex final和print flex initial，这两个大家记下来。

最终参数值，默认参数值，好，今天呢我们的技术内容呢我们就讲到这里，好吧嗯后面我要介绍课程的话，我就不多做介绍了，简要介绍一下啊，两分钟绝对不超过120秒，这是目前呢我们在腾讯课堂上正在开的课程。

我们的课程呢叫做m加n可定制的，就是跟你的实际情况可以对你进行定制的这样一个课程，我觉得设计的还是很好的，是我牵头设计的，我个人认为还是很好的，以我这么多年来的教学经验，就是m个知识点加上n个项目。

我们的项目会滚动直播知识点，每年也会更新，这些报完一次性之后，只要我们活着，这个升级对你来说就是免费的，就是为大家的整体的这个技术生涯呢保驾护航，你在中间遇到任何问题的时候，老师都会来帮你解答。

像咱们的同学，然后隔一段时间就要基本上每天都要进行重启的这么一个过程啊，老师现在呢已经把它定位出来这个过程了，只不过呢就定位出来这个问题了，但是要解决这个问题的话呢，这是跟他们实际当中环境有关系。

像正在解决解决过程之中，像这样的一些实战的案例，其实对大家来说都是非常有帮助的，你写在简历里头呢也非常可信，嗯每一部分内容的量呢都其实都都都比较多，我在这就不一一解释了，如果对课程有兴趣的同学了。

希望大家加一下我们小九老师的微信，找他进行了解啊，荒唐老师，感谢老师，全程没说话，但是我全懂了，妈是吗，哇不说话都能全懂，你好牛啊，我把视频停一下啊，单机并发的百百百万级tps的，千万级的q p的。

系列 1：P12：马士兵深入浅出java虚拟机②系统上线前预估系统的内存占用情况 - 马士兵官方号 - BV1mu411r78p

想想啊嗯，呃这个呢现在变得越来越重要的一个原因就是因为大厂总是考，总是考总是考，而且越考越细，越考越深，所以如果你的简历上能够把这句话写下来，写到你的简历上，熟悉常见的垃圾收集器。

具有实际gm调整调优的实战经验，原来你的简历如果值2万，就是超过2万了，之后往两两万以上，25000这个位置走的时候，你需要加很多东西，你从15000~2万啊，你只要能干活干得比较熟，就到了。

从2万~25000，这个这个5000块钱有好多好多东西你都需要加上啊，好吧，这一句话写上去就可以了，呃我们有我们原来有一份简历是写了五句话，拿到阿里的好多的面试通知啊，其中有一句话就是这个哈。

看我看这里啊，不废话，我们先说今呃，今天呢如果两个小时不够，我们就多讲点啊，没关系，gc gc什么意思叫垃圾回收，所以呢我并不是说在这给大家呢把jvm的从头到尾的概念那个太太宽，太大了，嗯不是那么讲的。

没有意义，让这块内存重新可用好，比如说我们占领有个引用，object o等于new object，new出来一个object，这个object里面有个成员变量又指向了另外一个，什么时候这个引用消失了。

这块就是垃圾啊，就是garbage，没有引用指向的对象就是垃圾，有过c和c加加代码经验呢，一说你就了解c和c加加需要手动回收垃圾，c呢要手动分配内存，要手动回收内存，下家呢需要自己new出来。

自己再delete掉，java呢没有这个概念，java就直接new就完了，new完了就不管了，那谁来帮他回收垃圾回收器，咱们讲的就是这个垃圾回收器的过程，好，我这个速度应该没问题吧，来没问题。

同学给老师扣一，现在很多新式的语言呢也都在引入自己的垃圾回收器啊，这个呃因为c和c加加写指针的时候，写的会非常非常的烦呃，所以当你不需要自己去手动手工管理内存的时候，你这个代码写下来效率会非常高。

不是运行效率高，而是开发效率高，好吧好看，这里，在这里呢第一步呢你怎么样，你你首先得定位这个垃圾，怎么样找到一个垃圾，就是这个对象到底他算垃圾，什么情况下算垃圾啊，你怎么把它找出来啊。

第一种方式呢叫做有两种啊，第一种方式叫reference count，叫引用基数，这事也很简单啊，你比如说现在有三个引用之前这个对象了，运行的过程中，这个已经没有了，这个已经没有了，这个已经没有了。

好这哥们肯定就是垃圾了，从三把这个三变成零的时候，这个就是垃圾，当然这种方式呢有一个显而易见的缺点，就是如果有三个对象，他们之间互相，持有引用。

但是又没有另外的引用指向他们任何其中一个a指向b b指向c，c指向a唉，这三个呢叫做一组垃圾，一堆垃圾，一圈垃圾，一家子全是垃圾，a b c好，那这个怎么办，每一个引用的技术都是111。

所以呢如果你通过引用计数方式，你是找不着哪些是垃圾的，所以这个在这儿用不了，那怎么办呢，jdk里面就hot sport里面用的是什么用的，这个算法叫root searching，叫跟搜索算法。

跟搜索算法是什么概念，跟搜索算法的概念就是哎我们写一个main方法，在方法里面有一些成员变量啊，sorry，有一些那，个局部变量我new出一个对象来，这就是我们的根对象，这个对象呢会产生一些引用。

指向新的对象，新的对象也可能会产生一些引用，又指向新的对象，那么在运行的过程之中，我只要找到main方法，找到这些根对象，顺着这些引用找脚，从根儿上开始，顺着着顺藤摸瓜摸摸摸。

凡是能摸到的这些全不是垃圾，凡是摸不着的那些全都是垃圾，这个叫做根可达算法，叫root thirty，这概念也很简单，是不是，来当然大厂面试不会给你面试这么简单的，大厂面试都是说哪些是根多讨厌你说他。

但这里面牵扯的东西比较多，只要讲得非常透彻的话呢，得需要把前面的所有的那个预备性的知识全都掌握住才行，呃，听一个大概就可以了。

这段话呢是来源于这边ms就是java java的virtual machine specification，就是java虚拟机的规范里头，他自己说的啊，到底到底哪些是根呢，哪些对象是根呢，有这么几个。

第一个呢是jdk jvm站里面的站里面还存活着的，那肯定就是根native methods stack，本地方法栈，如果调用了本地方法的话，run time constant pool放在。

你的运行时常量池里头的，你那个class运行时常量池的那部分的那些个引用指向的东西，那是根儿，static static reference in method area和class就是class。

这就别说了，你漏的漏的就内存那些class哦，那些是歌，steady reference，静态的那些引用，ok这些都是根，所以当然呃如果这块不熟的话，你就略过它好吧，因为今天呢重点呢也不是讲这些东西。

能让你的简历上把我刚才那句话给你写上，两天能让你的简历粗糙的涨个两三千块钱吧，细细的能能让你涨5000好吧，绝不夸张，以前有学生验证过啊，还真听嗯，当我们找着这个垃圾之后，我们要对它进行回收。

回收的时候有几种方式呢，回收的算法三种背过，别废话，直接背过就完了好吧，因为为什么大厂直接面认为你这东西就是应该你掌握了，没掌握，你跟大厂无缘，第一个mark sweep，第二个copy。

第三个呢叫mark compact，什么意思，一看就明白，标记清除，给这块标出来，标出来垃圾垃圾垃圾这些全是垃圾，直接把它清掉，清成可用的，就这么简单，这就叫mark sweet。

这maswift呢我我我我，我相信多位同学一看就能理解他有些毛病，什么毛病啊，会产生碎片吗，产生了这些个中间，这个中间也不连着，然后你要分配那个一个大对象的时候，你发现有可能也找不到空间了。

所以这就产生碎片，这个意思叫mark sweep，好看这里，但是mark wift算法比较简单啊，所以也并不是说不能用的，这三种算法没有优劣之分，记住这三种算法没有优劣，只有你选择哪种算法。

具体的选择要看情形好，第二种叫copy，copy很简单，把内存一分为二，只用一半，你们家俩房子，两个房间，一个房间你在里边玩儿，你妈妈进来给你回收垃圾的时候，咔叽把房间给你一分为二。

你这个死孩子只能在这边玩，等什么时候玩玩了，哎你跑到这边来玩了，我把这半边一下给清理了，有用的，凡是你产生的那些有用的，比方说你在那扔线团，把那些线条复制过来就可以了啊。

然后这边就可以全部的从头到尾的一下子清掉，这叫copy copy，我想一眼就能看出他的缺点，缺点就是内存浪费了好看，这里第三种呢叫mark compact，mk compact呢也是相当简单的一个算法。

就是我标记完了之后再对它进行一个压缩，这个是这个是什么意思啊，你注意看我们找到这是一个垃圾，但是呢我们我们不管垃圾，我们干嘛呢，我们其实呢是找这个后面的一些有用的对象好，这是有用的对象。

把这个有用的对象呢直接给这个垃圾覆盖掉，都挪到前面去，反正找到的都往前挪，你知道吧，把这些这有一个空档，哎我也把我把这个挪过来，把这个挪过来，就是挪来挪去，挪到挪到最后就形成了这样的一种感觉。

一边标记清完了之后，还进行了一个顺带的，顺手进行了一个压缩，这是最好的一种内存状态，这种内存状态特别利于新对象的分配，新对象来了之后，也只用往往后往后一挪，哎我就产生了产生新对象了。

再往回印度a又产生新对象了，这是最好的一种内存状态，当然这个算法一眼看上去也很简单，因为它和标记清除相比，和copy相比，它的效率肯定会偏低，为什么，因为你得挪对象，你得对对象产生移动。

对象产生移动是一个特别复杂的过程，都是在这块下功夫，啊这是标记清楚啊，三种算法相当简单，我在这里就不跟大家多废话了啊，可以吧，能接受同学给老师扣一来，大家先跟我的思路走，你们有一些眼前的问题先扔一边儿。

有的问题你可能听着听着就明白了，所以先扔一遍，好吧好，我们先不讲这个对象的什么产生到消亡这个过程啊，也不讲这个对象的分配过程，我们先来看什么呢，先来看这个这张图，请把这张图背过。

我前面讲的东西都是让你背过的，为什么，因为面试官就直接认为这东西你应该掌握啊，当然这张图呢很多面试官可能也掌握不了，你掌握住啊，你就可以直接第四面试官了，就前面讲的概念都特别需要，特别基本啊。

你必须得掌握，那么这张图是整个我们到目前为止，jdk至少到jdk 14为止，从jdk一点零到目前的14为止，所有的垃圾回收就这么多，垃圾回收器好，垃圾回收器是什么概念，垃圾回收器就是这是房间。

你在里边玩，你跟你朋友在里边玩，扔一些小线团，这些小线团呢有的a慢慢的中间线断了就变成垃圾了，你自己不回收，谁来回收你的妈妈，你的爷爷，你的奶奶，你的姥姥和他们来回收，他们来帮你回收这东西。

他们就是垃圾回收器，帮你清理房间的，在c和c加加语言里面，你得自，己清理扔了这个线团什么时候不用了，得自己把它清理掉好，现在不用了，因为有人帮专门帮你清理，谁来帮你清理他们。

他们的名字叫做garbage collectors，扫地机器，当然它有时候也做动词，简称的时候做动词叫garbage collect，嗯，垃圾回收。

垃圾回收呢整个从jdk一点零开始到现在发展了很多很多年，然后也诞生了各种各样的垃圾回收器，它的一个发展的路线是什么路线呢，请大家记得这个路线，给大家写写两笔笔记。

垃圾回收机的路线啊，发展路线是沿着什么发展呢，是沿着，随着内存数量内存越来越大，越大的过程啊，好演技，好在这儿呢我先给大家呢做一个总纲性的胶带，我们说学任何东西都是要按照先脉络后细节来学。

一定记得这一点。

小伙伴们，就学任何东西一定是先脉络后细节，而且充满了各种各样犄角旮旯的面试题，这么一个知识体系。

那么这时候怎么办，我们要来一个总纲，这个图就是我们的总纲，关于这个图呢，我会先进行大面上的一些个讲解，好嗯能接受这么学的，来给老师扣个一啊，一定要这么学啊，这个学法才是最正确的学分。

你千万不要说学东西呢，你自己先弄一个细节，先使劲抠进去那种那种学法学起来特别，累，而且还不容易学明白，就相当于你去看庐山，然后直接到庐山脚下的某一棵树，就开始研究蚂蚁窝了，你是在玩什么。

你肯定得先乘坐飞机观，看清楚整个庐山大的脉络啊，你要有这个这个胸怀明白吗，就学技术也要有一定的胸怀啊，嗯，随着内存的越来越大，另外呢它呢还有这样一个背景，就是从，这个说法都没了，从，从什么呢。

从分带算法演化到部分带上，终于从分类算法演化到了部分类算法呃，这些个，那么这些个垃圾回收呢，我一一的先给大家交代一遍啊，你认真听呃，从jdk一点零开始啊，先诞生的是serial的垃圾回收好。

那会的垃圾回收呢都是分带的，分带是什么意思呢，就是分为年轻代和老年代好，我们先说基本概念啊，看ppt，一会儿我再给你记笔记，笔记明天会发给大家的，不要着急，因为我每每讲一次，我都会往笔记里多记一些东西。

所以你们明天拿最新版本就可以了啊，好在这里啊，嗯我们先来聊这个分带的概念，就是目前到目前为止，jk呢就是hobt，说的是hobt，因为gt有好多种，我们主要说的是hobhouse。

到现在为止它一共有十种垃圾回收器，这个图请大家记住前面的这六种叫做分带好，第一叫做概念上分带物理上不分概念，分带物理部分带这么来理解。

那么z d c和shandollar全都不分带abcellent是另外一种比较特殊的了解，回收，一会讲你听这个和其他的都不搭界，因为他什么事都不干，就他不干，他垃圾回收的活，没有人帮你清理房间。

这哥们儿叫不起来啊，啥都不干活的人嗯，空气，首先呢我们先了解这个分带的概念，在jk诞生的早期，要分配一块内存的时候，会把整个的我们java的堆空间分成两个不同的年代。

这两个不同年代呢可能应该也听说过分成叫新生代，叫老年代，是这么一个概念，新生代是干什么使的呢，新生代你看吧，刚刚new出来的对象，然后都放在新生代里，然后经过了好多好多垃圾回收，垃圾好多好多次的扫房间。

好多好多次垃圾回收之后的那些特别顽固的对象，放到老年代，他有些别的称呼，比方说老年代也叫tenure，就tenure是终身的意思啊，老外的那种tenure，processor叫终身制的教授啊。

就是这个意思，终身反正就是比较老老家伙，所以一个叫新生代，一个叫老年代，那么为什么这么分，是因为呢在不同的年代里，可以采取不同的算法，对垃圾回收采用不同的算法，这样效率上是最高的。

对于年轻的采取copy算法复制，对于老年代采用mark compact或者mark sweep，这两个都有，很多那种y就是那种原理上的东西，我们暂时先不探讨，你先了解什么意思，这个老年这个年轻代呀。

呃为什么要用copy呢，是因为呢对于程序的一个总结，总结出来的，大多数的百分之八九十的对象叫做招生熄灭，招生熄灭诶，什么意思呢，就是这寿命都不太长，一个for循环里面扭了1万个对象，除了这for循环。

他马上就死了，因为他马上就成为垃圾了，那么像这样的东西，你想想看啊，在这里分分配了，在年轻代里头分配了一堆一堆一堆一堆一堆的对象啊，总而且呢一次垃圾回收之后会回收，其中的好多好多个好，在这种情况下。

那么最有效率的算法是什么样子的呢，最有效率算法其实是这样子的，看这里年轻的又分成三块，第一块呢叫伊甸区，一点伊甸园人类诞生的地方，所以这是我们新对象诞生的地方。

系列 1：P14：马士兵深入浅出java虚拟机④根据预估值设定JVM初始参数 - 马士兵官方号 - BV1mu411r78p

现在我满了，内存已经占满了，满了之后怎么办呀，我现在要进行垃圾回收了，垃圾回收怎么做，首先第一步找到最根儿上的垃圾，这些都是那根儿上的，这些都是根儿上的啊，通过引用根儿上的找到最根儿上的那批。

由于嘴跟上那批的数量特别小，所以这次的s t w时间不会太长，接下来下一步的标记过程是我的垃圾回收，一边在这里顺着找，哪些是垃圾，哪些不是垃圾，哪些是垃圾，哪些不是垃圾，与此同时。

你的工作线程还可以进行工作，刚才我们分析过，如果你正好把这个是垃圾的，你标出来了，准备把它清掉了，但是呢工作线程工作的过程之中，又有一个引用指向台了，这个东西呢就会产生产生问题，就会产生问题好。

那这个时候呢就在最终一步下一步的时候，再下一步的时候说，你这边先别干活呢，给我停止，先让我把那些个并发标记找出来，那些你又重新连上那些个垃圾，给我找我我我我再重新梳理一遍，从根儿上再输一遍，找着了。

这个为什么速度会比较快，这个速度比较快的原因主要是这种错误产生的特别少，所以他最后这步算起来，其实速度也会非常快，最慢的过程其实是这个过程，因为堆特别大。

到最后的话就几十个g生生t你在里边找各种各样的关系，他会特别麻烦，这是最耗时间的，他把最耗时间的这部分和我们的工作线程可以同时进行，这个时候就不会产生什么的，就不会产生那种长时间的s t w。

不会产生长时间sw，你的程序就一直会有响应，你点个鼠标下个订单，你的程序会一直有响应好最后一次重新标记之后，把那些有问题的东西做了个整理之后，重新标记为哦，这个已经不是垃圾了，重新把这个错误改过来。

改过来之后并发清理，最后把他最后把这个最终的已经原来的那些这部这批给清掉，sw是啥，刚才没听是吗，stop the world，初始标记的作用是初始标记是找到我们最根上的对象，gc root吗。

这些root不会变吗，他爱变不变，s t w同学们，什么意思啊，我不允许县城工作，我在标记的过程会出错吗，我就问你，数标记单选什么对三色标记算法，我跟你说，我现在讲最初最最最根本的这个脉络。

很多人都还没听清呢，一聊三色标记不就直接就聊晕了，第一次标记是垃圾还是非垃圾啊，你找着那个非垃圾，你不就找着那垃圾了吗，好先把大体的过程理清楚吧，好不好，gc root指向的不是垃圾。

我不知道你晕在哪啊，先别着急吧，好不好，来，先把大体的懂了，知道吗，大体懂了之后再扣细节，所以这个是cm啊，我再说一遍细节，这个东西你必须先把大概大的脉络懂了之后再抠，不然没法扣啊，看这里就是cms好。

所以你会发现来，这里有一个根上的脉络，从分带到部分带，从内存越来越大，为什么会内存越来越大呢，是因为什么呢，看这里啊，原来的你诞生了这个serial的时候，这是最早的serial算法。

seo算法一般来说像这种垃圾回收的时候，分带的这种算法的时候呃，这种年轻代的算法会和老年代其中的一个算法配合使用，比如说这里头比较比较浅的线，大家可能没看太清楚，给你画一下。

其实serial是可以和cms配合使用的，zero也可以和sio o的配合使用，但是没有连线的，它不能配合，你不能说serial和separtout不行，这是不行的。

他new和cm po和parallel old它是配合这个使用的好，大家听我说zero单线程，那你妈妈一个人清理清理过来没问题，但是随着内存越来越，大堆的空间越来越大，越来越大的时候。

你一个人还清理过来吗，也可以能清理过来，原来你家三个平方，你妈妈进来三下5÷2就给它清理掉了，虽然产生了s t w stop the world，所以客户那边是感受不到的，因为你速度特别快。

你这个垃圾回收线程就停止了，你的工作线程就开始工作了，所以客户那边感知不到好，接下来呢很不幸的是呢，你家房子变大了，内存变大了，巨大个一层楼，我就问你，当这层满了之后。

你妈妈一个人进来扫这个st tw时间是不是超长，所以内存变大之后，一根线程肯定不，够这时候呢肯定得多个线程，所以这就是为什么说它随着内存越来越大的过程而演进，一般来说。

如果非得说估计一下的cereal的算法大概就几兆到几十兆的内存，也就到这样了，再大就不行了已经，所以co现在已经见不着了，听懂了吧，那么parallel呢，看了其实现在呢工作的，呃还是有挺多在用的啊。

parallel算法，这个呢是一直到现在大概有个几个g吧，几个g左右的内存啊，都可以用，它，甚至多了的话，十几个g，20个g也也有人在用，这个也没有问题啊，嗯我一会给你讲个好玩的故事，他有的人用了就用。

完了之后实在清理不过来怎么办，重启服务器，你们看到那些游戏服务器里头，说不定说啊游戏服器正在维护之中，请五分钟之后再登录，干嘛呢，重启呢，以前有一个哥们儿，他们家那服务器好像有一bug，死活查不出来。

一直不停的会产生，到最后会把内存占满，死活，查不出来怎么办，哎过一段时间重启一次，过一段时间重启一次，就这么着玩了2年，好接下来继续，你们家内存又变大了，同学们，你们想想看，你们家内存又变大了。

你就算派100个县城过来，一一百个县城过来，我就问你，就算是你这种多线程，100个线程，你来清这个天文广场，你要清一遍，你得多长时间，太长时间了好吧，超长的一个时间先上，曾经有一个，案例呃。

他们的服务器在进行一次垃圾回收，就是一次fdc的时候，整体的垃圾回收，由于内存设的特别，由于内存比较大，对空间比较大，大概是花了四个小时，三四个小时，两三个小时啊，所以拍了两小时来说。

这个对于客户来说是不可忍受的，你跟他存钱，把钱存进去，就等着看数字增长的那边正在进行垃圾回收，你能受得了吗，所以，诞生了新的，cm cms，刚才我分析过了，垃圾回收线程可以和谁一起十个g啊。

垃圾回收线程配合谁家，同学们，南京回收县城可以和我们的工作线程一起工作，我们工作线程没有停，虽然是稍微慢了一些，被别人占了一些资源，但是没关系啊，我是及时有响应的呀。

哈哈所以这个是现在的很多很多调优的一个关键，调优的量的方向，第一个叫调吞吐量，第二条响应时间，其实大多数的在呃面试官问你的时候，多数的都是让你调响应时间，就是尽量的不要让这个s t w时间变得特别长。

你的系统要保持及时的响应，ok所以cms是一个承前启后的，承上启下的非常关键的这么一个篮球回周期，当然由于呢它是第一个好多的算法呢也不是特别的完善，所以呢，这cms呢居然在所有的jdk版本里头。

没有任何一个版本的jdk默认是cms，好了来我们再来看这个图，图呢还有一个关键点没有讲，你听啊，先别着急，看这里，还有同学说老师你还没有讲，肯定我还没有讲判定呢，判定是什么呢，唉往这儿看。

肯定肯定他说是is of the world coping collector with use multiple gic threads，读一下，跟那个我刚才讲的parallel scavenge。

简称p是一模一样的，of the word cing collector，which uses multipgc threads，这是新一代的垃圾回收并行垃圾回收new new，它为什么叫呃。

和和原来的p一样呢，是因为它本身就是ps，就是我们的parallel scavenge，它只不过是一种特殊的ps，他说it the first from paralleskyangta。

parallel skyin的区别是什么呢，is that it has been concements that it makes it usable with tm，看这里它有一些增强。

让他能够和cms一起工作，它可以组合cms，就这点区别，其他没有了，好同学们来看左边边这个图基本快讲完了啊，还有最后一个点，这半边就完了，常用的组合cereal和serial old，现在已经很少见了。

paralgavge和parallel，目前1。8版本默认的就是他，同学们，你们上线的时候要是没有指定任何垃圾回收器，就是这歌呀，在问你们做垃圾回收，简称ps加po，又称parallel。

pc这就是这个意思，好给你看一个命令，先给我java版本1。8，java杠x x，那为什么java执行的时候把他的common life flag变量和参数给我打印出来，看最后一项。

use parallel dc，默认的p s加po。

所以所谓的你们大多数人的调优就是对它进行调优，其实对它进行调优的一个最简单的办法，也许你换个垃圾回收器就直接搞定了，好我刚才讲完这几段来能get到同学老师扣一，好我们再来看一遍，它的组合常用。

他俩的组合也常用p6 加cm s他俩的组合也常用好吧，所以其他的虽然说可以组合，你比如说part of cavage和sero组合可以组合，但是极少用，因此你既唉就记这三种组合就可以了，但是你发现没有。

这里头居然还有一根细细的很危险的线，就在这儿，cms居然和c o o又连在了一起，这是为什么，我再说一遍，cm是一个承上启下的啊，继往开来的这么一个垃圾回收器，但是呢它是属于前浪啊。

背后被后浪拍死在沙滩上的那种前浪，因为cms有一个巨大的缺陷，cms叫concurrent mark sweet，好，你的老年代再打mark sweep，就是叫碎片化，懂吗，碎片化碎片化产生之后。

当我们新的内存不能从年轻代升级到老年代的时候，他干了一件什么事呢，他居然用一个县城把老年代从头清理到尾，我告诉你，我有，一个学生遇到过他的线上系统卡了两天，就是cms干的，因为他们内存超大。

然后呢又运行了很长一段时间之后，很长很长的一段时间里边的产生了一些泄漏，我自己不知道，最后内存全占满了，实在弄不进去了，这时候谁谁冒出来了，居然是serial old，你看吧，他还活着，他没有死。

他还在干活儿，但是很不幸的是呢，这哥们儿卡了两天时间，客户那边一点反应没有，服务器，有的服务器是不能断电的，是不能重启的，你懂吗，有的服务器是不能重启的，军方的有些服务器能能随便重启吗，你是在搞笑吗。

跟你说有的服务器是不能重启的吗，好，嗯我有学生拿他们那个说跟你说啊，就比较好玩的事情和垃圾回收体相关的，现在大多数有用的不就是他吗，对不对，少数人的调优的时候改成了他啊。

现在基本上就是这这两个这两个比较多呃，我现在一般都建议你至少一点半，这搞成g一了，没有问题的，其实嗯有一个做游戏的哥们，游戏的服务器，他们那服务器就是基本上每天晚上24 22214点还是下午。

就是我凌晨两三点钟啊，就发个通知，各位小伙伴是吧，各各各位各位各位各位将官啊，咱，们现在先暂停打斗啊，服务器呢五分钟之内开始维护，有没有见过，应该见过吧，12306有没有有没有用过。

每天晚上11点开始到凌晨的几点不让买票，有没有，维护知道吗，有很多时候我告诉你，你调优调的再牛逼都没有用，该维护还得维护，该重启还得重启，ok还有一个小伙伴他们是做那个测试的，测试的，有个工具叫ga。

这估计可能做测试的小伙伴都会都会比较熟啊，这个gr呢其实他bug还挺多的，嗯，他们的这个服务器全球他们公司在那个越南菲律宾都有分支，所有人都在用这个服务器也不能停。

然后这个服务器三天两头的就直接频繁的f g c，你知道吧，三秒钟一次，三秒钟一次，你想三秒钟一次，fdc 3秒受不了了，肯定受不了，他们原来的采用的方案重启，不停地重启，后来他把那个日志发给老师。

然后知道了，他大概得有前前后后一个月的时间啊，终于解决了，只不过他们采取的解决方案比较土，第一扩了内存，第二换了垃圾回收器，哈哈我跟你讲，找出代码的bug来，一会儿给你演示啊，好看，这里到现在为止。

这种分带式的分带模型的你大致应该了解了，来我们来大体聊一下g one是个什么东东，大体的这里面每一个拿出来讲三个小时，两三个小时都是很正常的一件事情，好吧，g one到底是个什么东东。

先给你讲一些大题的啊，尤其是牵扯到里边的一些算法的时候啊，而且呢这算法还还特别特别有好多人还特别特特特特别爱问。

这期的讨厌，好这边有个什么东西基本没有分带了，你发现没有，这叫做逻辑上可以分，在物理上已经不再分带了，g one可以支持什么，可以支持上百g内存，这个我得我得给大家记下来。

这one其实好像支持不了g one的话，100个亿我也100个g差不多了啊，这个号称史啊，这是上百g，那么，就让后面的cdc和仙人斗，这两个呢他们能支持，这里贼是支持四个t的山洞是值多少来着。

反正就是上t了上千g啊，嗯，杨英语为什么y d c采用的算法都是复制算法，可见你刚才没有认真听，我都讲过了，不要听，先听现在的，不要纠结于过去，你在流经过去的时候。

实际上已经损失了现在正在听课的精力和时间，现在也听不着了，先听现在的啊，呃从g one开始，g one也是一个承上启下的，也是一个特别牛叉的这么一个垃圾回收器，从另外开始呢，终于开启了一个什么时代呢。

叫做分区回收呃，分region它不叫分带了，叫分区分区回收，看这里啊，那这样呢它把内存分成一小块小块的，咱们原来不是分两个区吗，年轻的老年代啊没了就这俩区没了。

当然还有一个什么matter space啊，那那个那个今天的重点不是说他先不管好，所以这样来说呢，他就把内存直接分成了一小块一小块一小块的region变成region，我相信region这个概念呢。

很多同学应该都有把屋子分成一小格一小格了吗，你你我们回收的时候就先回收优先回收了一个小格，这两个小格吧，我先回收你一边在别的小哥玩儿，我先回说这俩小格呢就这意思分成一个个的region开始终于开始。

分块了，分区了，好这个呢效率就开始慢慢提高了，同学们，你们想象一下，在一个超级大的内存里头，有一对县城在这里不停地清理它，清理的时候并不是说我要stop the world，而是说我分成一小块。

一小块一小块的，我优先去清理那些垃圾最多的小块儿，什么叫g one gb，一直，垃圾优先，什么叫垃圾优先，优先清理垃圾最多的小块，所以它的名字叫g one，叫garbage first。

嗯知道思想听懂了的给老师扣一，好看来g one没有s t w，这是一个面试题，g one有没有sw，有今晚有没有复仇dc，有，好作为这句话来说，它呢分成了一小一小区，一小区的，然后这一小区里头。

他在这个小每一个小区在逻辑上可以成为a是年轻的呀，啊伊甸区啊，还是欧的区啊，还是survivor区，或者分配大对象，用的是manus巨大的这种这种区啊，所以它逻辑上每个区都可以成为不同的。

原来的那种年代，在物理上已经不再分带了，到了z理学之后，不仅从逻辑上，而且从物理上也不再分任何代了，就这些概念在cdc这里就没了就没有了，cdc到了之后，我们调优的时候，它的参数就非常少了。

g one的参数也就几十个，如果你用p s加p o的话，大概要几百个参数，你要调优的话，所以珍惜这段我们现在还可以展示自己水平比较牛逼的时代吧，这里面的概念就太太多了啊，我们先把还是那句话。

我们先把最脉络上的东西先把握住以后，我们再慢慢扣细节好，我们来继续聊，所以g one呢开始分区，你脑子里内存里头就不再分成两个带了，然后呢g one呢但是逻辑上还是分开的好，到了cdc之后。

c d c不管是逻辑上还是物理上，就再也没有分带的概念了，这一代一代的东西到此为止，那么什么叫山人多，大家听我说，其实不管是cdc还是山人多，都是来源于一个特别牛逼公司的，特别牛逼的jvm的。

特别牛逼的垃圾回收器，它的名字叫做c four，是a a rule，呃呃呃呃a rule，他怎么拼来着，你去查一下他的一个特别牛叉的这位m叫z听着名字就特别快in，他不用你进行任何的调优啊。

它的参数好像只有一个呃，然后呢，它能够非常智能的来帮你进行垃圾回收的管理，cc four号称对外是没有任何s t w的，ns t w的垃圾回收器，但是很不幸的是啊，as you对，但是很不幸的是。

这哥们儿呢是收费的，是商业的还贼贵，所以jdk 12 sorry，这个11啊开始开始主推cdc，就是跟人家学的，听懂了吧，就这意思，这个z d c呢是oracle自己官方推出的，和c four学的好。

red hat自己也推出了另外一款垃圾回收器，叫做shining doa，也是建立在建立在就是jvm的基础之上的啊，这样的一个垃圾回收机叫神仙多，但是它主要是跑在open jdk上了。

目前这两个其实都有机会叫做转正，就是合并到主干上，下一期的这种jdk的12jdk，13jdk 14，你要用哪个，哪个是主要的哎，shindo了，有机会cdc也有机会，当然cdc机会更大，为什么。

因为这是oracle的亲儿子，所以11开始是cdc到12呢，山都在12里是可以可以设置的，他两个呢本质上是差不多的，算法也差不多，他们两个是一个竞争关系好，不知道我说清楚没有。

答题的来get到同学给老师扣一对，生产环境大多数还是用的这个这个jdk 8，所以你在简历上写，我对jvm有个调优经验，你要敢说你是对z dc调优的，面试官，一个大嘴巴子就给你糊上了。

对jdk 14 cm s已经放弃了，这哥们已经放弃了，他完成了他的历史使命啊，可以到历史的垃圾堆里去了，当然如果想了解算法，必须得从cs开始了解起啊，我看这里还有一个，我没有说这哥们是谁。

这哥们叫excellent，这哥们儿是什么呢，这哥们儿叫做啥也不干的，这啥也不干的dc就是他啥也没干，什么也没干，干什么用呢，它有两个作用，第一个你的程序做测试用，看看你的垃圾的产生过程啥样的。

反正没有垃圾回收器来干扰你，你用它，第二个你确认你有一个程序根本不用垃圾回收就能结束你内，存直接分配，分配完了之后计算，计算完了之后就直接结束了，我根本不用去惊动垃圾回收器，用它absolu，好看这里。

给大家提几笔笔记。

嗯cmon啊，承上启下，开始并发回收，这个逻辑分带，物理不分带，这里c选的多逻辑物理，都不存在。

系列 1：P15：马士兵深入浅出java虚拟机⑤根据日志解决实战问题 - 马士兵官方号 - BV1mu411r78p

啥也不敢，两种作用，第一个调试用，第二个确认不用减肥参与，就能干完活，这时候你可以你就可以用app了，好到现在为止，我觉得脉络上的东西大家是不是掌握了啊，这个脉络上的东西，来掌握同学老师勾引我们。

下面往深入一点点细节脉络，有了对面试呢好的细节，但是你记住了，我这两天练营呢叫做实战训练营，你要想听实战，我就跟你聊，实战之中会产生内存溢出，教你怎么去定位，怎么去把它揪出来，怎么去把它给干掉。

如果你要想听理论，那就全是理论了，所以我们还是实战啊，听完实战，有些理论你不懂，但是你简历上就可以写，我有实战经验了，听完理论，我估计你也记不住，好看，这里给大家多记两笔。

现在问的比较多的cms开始或者说分类算法，只要只要产生并发的时候，并发的算法从cm开始，它的算法是什么，先给大家几个名词，感兴趣的你好好去网上看看啊，三色标记对不对，它会把对象分成三种颜色，黑色的。

灰色的，白色的，黑的已经全标记完了，灰的自己标记完成员变量没标记完，孩子没标记完，白的还没标记的，三色标记算法用来干什么的，用来进行并发的时候，做并发标记用的不容易产生问题的三色标记。

三色标记里面会有产生漏标，就是我刚才所说的那种最严重的问题，就是我标完了之后，这哥们呢把它标成垃圾，但它它它又变成不是垃圾了，好这种是最严重的三色标记，要想他这个算法本身是一定会产生这种问题的。

为了避免这种问题，cms的他的干法，好c m s它的干法呢，首先第一个呢叫34标记，下面这段你一定听不懂啊，听我说你一定听不懂，我只是给你开拓一个你下一步可以去研究的东西，get到了吗。

你一定听不懂三色标记，三色标记会一定会产生错标，产生坐标之后，cm是怎么解决的，它的解决方案叫incremental，update叫增量更新，但是这个增量更新有问题。

因为在增量更新的过程之中也会产生错标大哥，所以呢，这也是为什么cm到最后一定要有一个remark的东西，好接下来，怎么把这个给挪这儿了，复制了一下啊，不小心，好，所以所以什么呢，所以第一。

所以g1 g一同样的也使用三色标记，但是它采用的算法是什么，它采用的算法叫做，ok g一的算法，g的算法叫什么呢，g一的算法叫做s a t b，哎呀牌不好，那什么了，还不好板了啊，很简单。

给大家写出来吧，好第一，第一的算法叫什么，也是三色标记，加上s a t b它就解决了这个incremental update，最后必须要进行remark这个过程，所以它效率上有所提高。

这叫natt at the beginning，好，接下来z dc是什么，c d c是最难以理解的一种算法，这种算法呢叫，color pointers，这种算法叫颜色指针，或者叫着色指针。

呃基本上不会有面试官跟你聊到这儿，因为市面上一点资料都没有，连国外的资料都没有，要想弄明白这个只有一个办法读hobo源码，很不幸的是老师读过，所以目前只有我能给你讲清楚，慢慢慢慢慢慢来吧好吧。

但是也别着急啊，因为这个东西没有人问啊，好吧，你随随便去网上找文章去，这颜色指针的也是特别复杂的一个东西，他是用c加加里面的指向java对象的那个64位的指针，其中的四位做出了一些个性的操作。

因为这里面还牵扯到操作系统的那种内存映射的问题，嗯现在呢问的面试官问的问题上呢，还目前还没有到这种水平，还到不了，所以呢你们你们先不用着急啊，另外呢如果说还要说的详细一点的话，其实这样的啊。

呃所有的分带算法，所有分带算法就除了他这种，这种的他们使用的用三次标记之外，还要加什么加写屏障，而这段呢是三次标记sb加写屏障，cdc是什么，cdc是color pointer加读屏障。

而shen dog是什么，shen door color pointer，加写屏障，好，算法里面最复杂的部分就是这些了，大家呢给大家拓展一点知识面儿，嗯你要是想学的时候呢，也可以去网上查一查好不好。

ok了咱们大体讲完理论上这个东西了，下面我们来进行调优的实战，但是大家听我说，直接实战吧，这些对面试没啥意义，你是在搞笑吗，实战才对，面试没啥意义，这些才是对面试最有意义的，你可能弄反了啊，好看这里。

我们现在来进行调优干调优的时候呢，必须指定你要调哪种垃圾回收器，我可以帮给你调g one，我也可以给你调他六cm，我也可以给你调p s加p o，所以咱们公开课上咱们的小伙伴们来讲。

大多数人的水平其实多数都没有进行过任何的垃圾回收器的替换，所以多数人用的还是什么呢，ps加po，所以我们先把最简单的调清楚，也只有你把这个能认识清楚之后，下一步你才能继续往下走，越往后会越容易。

这个是最难的，p s加po是最难的，听懂了吗，越往后是越容易的，我先来定义这个调优到底是什么概念，其实啊调休这个概念呢，很多人就就就就会理解的特别的不到位啊，这个调优这个概念呢其实。

大多数的这种面试的时候，总是问你什么om问题，那只是调优的概念之一，好吧，好看这里我们来聊这个调校的基础概念，听我说啊，这调的基础概念调优呢，其实啊那个就是大多数问面试的时候都问什么问题。

都问这个o o m多数都问这个om什么意思呢，叫out of memory，内存溢出，就是玩着玩着呢，我这个垃圾回收器呢，我觉得整个j vm呢我开始频繁的dc 3秒钟一次，三分钟一次啊。

fc频繁的f d c或者什么呢，或者直接就崩了，直接就崩溃，好崩溃，完了之后你的都崩溃完了，你这时候该怎么办，你去去里边怎么怎么怎么去找毛病，找问题啊，这种叫o o m，大家听懂我意思了吧。

那如果说从全面上来讲，到底什么时候调优呢，这也是调优的一部分，优化这般旅行环境，比如说他有时候特别慢，你觉得受不了他卡顿，你觉得受不了好这个呢其实人家没有死，也没有频繁m b c，但是呢他就算不频繁。

他也时不时的卡顿，时不时的就慢下来了，时不时内存就慢慢的变占占占用更多了，有一块内存老师释放不掉哈，这叫优化环境，这是调优的一部分，还有一个就是解决这个b运行中的各种问题，比如说oom。

这是最常见的问题，多数的面试多数人在网上说的条条指的就是这一块而已，当然我们今天实战就主要调这叫聊这块好吧。

对说不定就是代码写的烂，我告诉你。

我今天我我我给你讲完，今天那个就今明两天我给你讲完，你的面试，你的简历上会写出来，有过实战调优经验，但是面试官一定会问你怎么产生的问题，我告诉你，你要是不贴近实战的那种，面试官一眼就能看出来啊。

写了个list的，有成员不断的往里往里装，也可以太土了太简单了好吧，我回头教你十种高级的老师给你准备了十种案例，知道吧，你随便挑啊，一定让你在面试官那过得去好看，这里我们一步步来，先针对ps加p。

这个题的第一步，我们先了解jvm的常用的命令行参数。

昨天说那个老师这版本常用名号参数还有什么可了解的。

好，先注意啊，我这里环境全是linux，咱们后面聊调优，你不不要跟面试官聊，我是在windows下做调优，面试官直接大嘴巴子呼上去，你就可以撤了啊，mr demo，我是面试官，这十种我会记下来啊。

没关系，我们vip还有十种，一共有20种，哈哈哈，windows打了我这个还要我讲，有多少jdk是跑在windows上的，你告诉我，好看这里啊，我们先来聊呢。

就是这个我先先认识调优的这种最最基本的一个操作，你得认识java命令参数该怎么玩，我平时呢就是直接什么java t就直接开始执行了，但其实呢java有好多明狼参数，命令参数呢本身有好几种。

直接敲你会看出来以横杠开头的一堆参数，看到了吗，刚刚那个什么version啊，这些个说version啊，杠x等等，呃这些呢就全是这种叫做java的标准参数啊。

这些叫标准，这些哪个版本都有，哪个版本都能用，这叫标准参数。

非常标准的好，还有一种参数把windows给干掉。

有点是点了，还有一种参数就是这个参数看到了吗，这个杠x杠x开头的叫print hon nonstandard options，你跳一下java杠x回车，你会看到一杠s开头的又一堆好。

这个参数叫做非标参数。

看这里特定版本hot bt支持的特定命令版本变了，这里面的x开头的命令有可能会变，所以这叫非标。

这个大概也有个几十个吧，像我在那个这个那个前面讲完的时候给大家讲过，这个就是mixed到底是优化的，还是说是那个那个纯纯纯解释的啊，当然还有纯编译的都可以，这两个参数这里面有几个参数呢。

我希望大家记一下，大概记一下就可以了，就这个参数这两个参数，这两个参数我觉得作为调优，或者说作为那个设定，你这边参数来讲，基本上是属于必用的，自己自己看一下，xs后面跟一个size。

x max跟一个size是什么意思呢，said initial java heap size啊，所以最初始的堆大小，maximum java heap size最大堆啊，刚开始的队最最和最大堆。

当然还有m x m n之类的，那就是说年轻代好看，这里。

到现在为止，我们接触的参数前前后后，加起来就几十个吧，哎可是很不幸的是，我们大多数的调优都是要以杠xx开头的参数，太不行了啊，那么杠x x开头的参数到底有多少呢，不好意思。

你找不着他有多少，你不知道他有多少，他没有。

他没写出来，有同学说有没有一个列表给我，不好意思没有，i'm sorry，没有刘耀文档给我没有，你说oracle得多恶心，简直能他妈气死人，就当初找找这些文档，找这些命令，没有全的，没有，这两天参考。

这就这就算比较全的了，我给你自己去看就行了，但是也就讲了几十个而已，大家听我说有一个参数实际上是能够把所有的全打出来的，看这里这把，装x加上pflag规则comments好。

这个参数呢大家可以记一下这个参数呢叫print flags with comments，什么意思，with comments，解释把那些个所有参数打印出来，并且带着解释给打印出来，哇，有这个太爽了。

哎很不幸的是，只有第八组版本能用，所以同学们下一步要干嘛，唉自己去编译一个jdk，好不好，编一个jdk编译成debug版本，你就可以玩了，别着急，还有还有办法。

再看这里，标杆杠s s加上play tonline flex，这个不行，还有个办法叫什么呢，叫print，flags，then print flags，这两天睡得太晚了，脑脑筋有点不够，使对没错。

就是它啊，来print flags final，还有一个呢叫print flags initial，哎，这句话意思是什么呢，就是把所有参数都给打印出来，它的初始值是什么，就默认值是个什么。

而flex final指的是什么，就是你最终设完了整个整个你的虚拟机起来之后，那些个参数值到底是什么，来我们看看它到底有多少，变墨了，wc 3 l呃，也不多，700多个而已是吧，不算太多。

也就700多个唉，所以为什么这边调有比较值钱啊，大哥，哈这就别背了啊。

教你最常用的，因为在这个文档里头呢。

每一个常用的我都给你列出来了，看到了吗，就说两分钱值不值吧，谁都觉得吃的，那我下一步教大家使用常用的这种面料参数啊，我们直接用一个比较复杂一点的案例吧，这个案例还是太简单了啊，因为细节特别多。

我略过了很多呃，我们直奔主题而去好不好，如果时间够的话，我可以给大家讲一些什么三色标记这一类的，比较有可能比较常被考到的这些算法啊，这个明天看，明天时间好，大家看这里啊，呃在这里呢我们有一个代码。

我们是我们测试用的代码文档分享吗，分享啊，放心吧，当然分享了，老师分享的老师是特别喜欢分享的人，你没发现吗，各种都可以分享啊，这里你知道分享一个知识是学这个知识的最好的方式，好看这里啊。

我们来看这个小程序，这个小程序呢是模拟了实际当中的一个案例，这个案例呢你完全就可以写在你的简历上，跟面试官这么说，但这个案例相对复杂啊，可是我我就说越简单的案例，那那个面试官的肯定觉得越没劲。

所以你举案例一定要举得稍微复杂一些，这个案例你要好好消化一下的话，是可以做到的，好这个案例呢是什么呢，我们我们大致读一下这个代码，这个案例呢首先我说一下它的背景，这背景是什么呢，是有一个程序。

这个程序呢叫做风险控制的程序，风险评估，风险评估什么概念，比如说我们银行里头存了一堆人的信息，好这个人的信息，如果我贷给他10万块钱，我回回回不来的风险到底是多大，小额贷款。

还有这种金融这方面的这种的风险评估模型特别多，那呃对他电影会员工，当然这里面他个人的资料呢会非常非常多，我会把他的资料各种各样的都拿出来啊，比方说他是什么时候花过支付宝，什么时候还过支付宝。

花了多少钱啊，今年挣了多少钱，工资是多少啊，什么乱七八糟，各种各样的信息全有，然后呢在里面把数据拿出来，看看我能够给他贷10万，还是我能给他贷100万，还是我说我一分钱都不敢贷给他，因为他的信用太差了。

好了大家理解这个背景了吧，来get到这个背景的同学，老师可以下面我来解释这个程序是怎么写的啊，那我这种语怎么写的呢，这种语是这么写的，呃，比如说我就只考虑他的信用卡的信息，这个信用卡呢我就模拟了一下。

他的名字叫cut info，有同学可能在这里会抬杠，老师说，老师你给我们讲半天，全都是模拟的案例，来大哥，我就问你，我怎么样才能给你弄一个真实案例去，我告诉你真的弄不出来，别的我都可以给你弄一真实案例。

只有这个这种dc的模拟，我实在给你弄出真实案例来，为啥，其实你想想，如果说人家一个电商在那里运行了好长时间，然后才产生了一次这种o m，我怎么去把那个电商给你搭起来，然后再模拟给你跑个一个月。

两个月给你弄，弄出那个o m来，所以好多时候只能模拟，你只要听到这个魂儿知道吗，就听话，要听音儿，看东西，要看这个活儿，看这个根儿上的东西，你只要把这个理解了之后，回想你自己的做过的项目。

你完全可以把它套上去，一点问题没有，不在这种金融公司这么吹，明显假呀，这不是吹，你能不能把这里面的案例稍微换换呀，你就这么弱呀，大哥这学传统的教育都学死了，就得老师拎着你耳朵从头到尾给你灌进去。

你才能够接受是吗，看这里啊，这信用卡信息cadian f，比如说这是他花花的某个钱吧，big desigma price，然后呢名字年龄啊，这个生日等等，总而言之里代表的是他个人的一些信息。

当然这信息我再说一遍，实际上会非常复杂，根据这个信息，我会计算这哥们儿诶到底是能适合带多少钱，有没有风险，然后呢我们这个人开的金粉从哪里来的呢，肯定是从数据库里来。

所以呢我做了这样一个叫get get all card info，就拿到所有的cut info这样的一个信息，从数据库里头拿出来，放在一个list里面，ok我每次拿100条，我就拿了100条下来。

把这个东西放到这个list里，返回回去，别抬杠啊，不想听也可以待着，为什么要走呢，不想听哎，热热场嘛好看，这里下面我对这个模型对它进行匹配，叫model fit，看看是不是能对它进行进行匹配。

首先拿到这个list，我从数据库里拿出来一堆嘛，一堆模型拿到这个list，接下来for h每一个做循环一指的时候怎么干呢，我用一个lamba表达式，然后用一个线程池。

schedule with fixed delay，过一段来，过一段时间之后，每个人过一段时间之后再开始执行我这个方法m方法，m方法呢就是具体的来适适合呃，来匹配，来匹配我们整个这个这个这个程序的呃。

它它这个模型的这个过程啊，m方法，这个方法呢我们没写任何内容啊，因为这个匹配过程呢就没什么值得写的了，就可能匹配不匹配就行了，我们调这个方法就是每一个都拿出来，按照一个固定的时间往后delay一下。

然后就开始一个一个一个一个进行计算，接下来干了一件什么事儿呢，我在我的主方法里面，主程序里面我写了一个线程池，reer executor，呃，这个线程池里面的参数你要没学过的话，你肯定理解起来也费劲。

我就暂时不跟你解释了，很简单，就是50个线程的线程池，这是他的拒绝策略，就这意思啊，50个线程线程池开始运行，然后呢他就不停地从数据库里拿出一个list来，然后不停地进行model fit。

每隔100个毫秒拿100条出来干事，每100个每每隔100个毫秒拿一拿拿拿100 100条出来干事，就这么一个模型，这个程序呢看上去呢是没有什么问题的。

但是运行起来问题就大了，好你们不要给我带节奏啊，什么老师讲得快一些，慢一些的快，对你来说，你基础比较好，你就稍微照顾照顾基础不好呢，对不对，慢了也没有关系，你这人听上去总是总是会有收获啊。

当然这个bug呢我先不跟你说bug到底在什么地方嗯，回头你拿这个文档之后呢，你可以去查一查好不好，我们来执行一下，执行一下这个小程序。

什么编译啊，乱七八糟的这种过程我都不给你演示，已经很给很给你省时间了啊，莫急好，大家看这里啊，为了让程序能够呃运行的时间稍微长一点，能够多演示一些命令，所以我把这个内存的调的比较大，还是200兆。

当然实际当中要比这大的多，如果你那么大的话，我估计你运行两天才能看见问题，所以他们必须得稍微调到200多小一点，跟x3 m s最小200兆，最大200兆，来同学们问问大家一个问题。

为什么最小和最大是一样的，为什么，这个大家能能理解到吗，能get到吗，唉避免没必要的扩容和收缩啊，你只说说扩容了，你一个最小的是这么小，一个最大堆事这么大，那么当你不断的在里边儿产生对象的时候。

pvm得不停的花资源来计算我下一步要扩多大呀，下一步扩多大呀，然后不用了之后呢，下一步缩到多少啊，下一步缩到多少啊，所以你如果确定这个程序就会用这么多内存，直接给它指定，这也是一个小小的优化方式吧。

好像xx叫print g c，print g c呢，这个参数比较简单，然后执行这个小程序回城，我再起个终端，好每天来看这个小程序，gc education failure，多少章到多少章啊。

花了多少毫秒，没有关系，一会儿我来给大家解释dc的日志，今天没有的话，明天给大家解释清楚啊，莫及，ok gc开始了，现在我们想象一下，开始闭上眼睛，开始你的想象，这个程序是你写的程序，闭上眼睛讲啊。

所有人都close your eyes，来在你的现在，在你脑子里开始浮现这样一个场景，你写了这么一个程序，把它放到了线上，然后运行了很长很长时间了，好，谁会发现这程序有问题谁呢，谁会发现程序有问题呢。

客户不我跟你说，客户只是会反馈比较慢，比较恶心哎，一定是运维同学们对报警系统对你们说的没有错，所以在你实际的工作环境之中，比较好的公司会配专门的预警系统，运维监控系统，监控系统会发现一些问题。

那么监控会发现什么问题呢，看这里我们来看它的问题出在哪，要带一个命令叫top，这个面料比较简单，就是列出来目前整个系统之中对于系统资源消耗比较高的前面的程序，当然网管的系统一堆一堆的。

不一定是这个命令产生，也有可能是报警产生的好你仔细看，我们有一个1239的这样一个java的程序，它是占了22%的cpu，11。4%的内存，有同学说不高啊墨迹，那我再提一个终端，格里尔一个简单的命令。

我估计大家应该都见到过gps，这个大家知道什么意思吗，就是列出来我们系统里头的那些个java的进程，有哪些个，它的进程号是1239，好看，这里就是他，所以对于网管来说，它会观察到时间长了。

它会观察到这么一个现象，什么现象呢，就是这哥们儿这个程序现在注意看啊，它是11。4的内存，再来执行一遍，还是内存的增长的有点慢啊，诶算你狠，还11。4，稍微等一小会儿哈，内存它就会不断的增长。

因为这时候还没有占满我们200兆还是挺大的，我跟你说这个小程序的bug特别恶心，这个小程序会引发什么样的情况呢，它会引发有可能啊，你看啊，现在已经变成13。7了，看到了吗，刚才是11。4，现在是13。

7，营长了，啊sleep太久了对啊，先不管那个是因为我内存设的也比较大，好这个小程序啊，他会把那个你平时看到的程序可能会产生的那些严重的后果，都会有可能在这个程序再产生。

他有可能会最后的结果是频繁fdc，知道吧，也有可能最后的结果是oom，而且这两个结果是不是固定的，不一定会产生那种这小程序还是比较恶心的啊，所以我是拿它来做典型好，你看到了这个内存呢在不断增长。

并且呢它不会回收，如果一个内存它占的比较大，但是它过一段时间之后就又少了，这个就没有关系，但是这个不是这个从11。4涨到13。7，知道吧，那好了，现在，你的网管就开始来找你了，o你闭上眼睛想啊。

一个美丽的网管走到你的面前，然后跟你说，哥们儿，你写那个有bug，然后啪一大嘴巴子给你抽醒了，你弄的这个内存都快占满了，什么情况，看现在是15。3了，你让他容忍他走下去的话，很快就是90%多99了啊。

好我就我就我们就不等到那时候了好吧，那这时候你就说啊，大哥网管都是大哥，对不对，来大哥，你能不能给我开放个权限，让我上去看一眼好看，网管这个时候说可以吗，如果是在一个特别牛的公司里头上了线的系统。

绝对不让你不让你上去，你放心吧，如果是这种情况，你就只能在你做做一个模拟环境，然后在那里不停的压测哈哈来模拟实际环境，看看会产生什么，这个我教大家啊，以后当然我们假设你能开始能够能够执行的单位。

或者你交往管，你来帮我执行好吧，也可以，所以现在比较牛叉的运维都是会jvm调优的，你懂吗，真的一点不夸张，比较牛叉的运维，jvm的调优，mysql的调优，各方面的tom cat调优他们都会好看，这里。

我们下一步呢说要定位出这个程序了，你已经知道这个序有问题了，那下一步你你怎么去进行定位呢。

教大家几个比较常用的命令呃。

g p s我教过大家了啊，也不说了，我们来看这个这stg stack呢其实跟我们现在这个程序的关系并不大，但是我教给大家好，jdk是什么东东，this de的意思是打印线城站2239。

把这个进程里面的线程暂停打印出来，全打印出来了，我就不一一给你念了，这个js带的命令也是非常有用的，目前解决我们这个问题它没有用，但是它本身是非常有用的，你要理解这个jdk呢他干了些什么事。

这大概干了一些什么事呢，如果我们挑一段读一下的话，你就会发现了，这次大概干了这么件事，他说有这么一个见证，现在的名字叫pro 1 thread 33。

然后呢他就是自己内部的标号40priority优先级操作系统的优先级，tid nd waiting on condition，正在等待某一个条件，waiting on condition。

这个thread的状态是waiting，正在等待，因为我们有好多好多的县城，因为县城市里有50个，还记得吧，他正在进行等待，下面是这个县城里头呢，诶调用了哪几个方法，pk方法，这个方法，那个方法等等。

同学们，你们想想，看，来我我我我们动脑筋想一下啊，我来找一个比较标志性的行程，我来点克雷尔，嗯这是一个rable线程啊，这叫做attachlistener pthread，49啊，48等等，内线装好了。

最后面，这是我的main线程，看到了吗，我们的主线程它的呃state是time waiting，正在等着sliding，正在sleep，就是刚才我sleep的时候，正好把他这个新轮战给他抓下来了。

然后呢你看啊这个may may方法的调用了sleep方法，对不对，main调用了sleep，但是sleep如果再调别的，还会一层一层往上走，所以这个jdk干了一件什么事，大家我相信大家能get到了。

这次带的是把每一个线程揪出来，然后呢他会把这个每个县城里面哪个方法产生的这个县城，我这个县城正在执行哪个方法，这个方法又调用了哪个方法，又调用了哪个方法，目前这个线程的状态是什么。

是在waiting还是在干嘛，还是在running，还是在time的waiting，还有如果他正在waiting的话，它调用的是哪个方位上的，正在waiting object weight好。

他正在weight哪个锁，当object monitor正在位置在哪个锁上，这是那个锁的具体的编号0x是没有是什么，所以这代表有什么用，来同学们告诉我，当你看完了他的输出之后。

这back将来对你调什么样的问题会有用，能够猜得到吗，对检测思索对，没错啊，所以如果你的程序有可能会产生思索的时候，用什么来做jazz dk。

this deck，当然这个this deck呢对我们现在这个程序没什么用，我教大家而已啊，你要观察它正在哪个锁上产生的思索啊，这个锁呢是一个哪个哪个类的对象。

这个时候你就很容易定位出来你哪个程序是产生思索了，我也给你写了个例子，自己去读好吧，好这里也能再给大家扩展一个小小的知识点，大家读过阿里的规范吗，阿里的规范有一个华山版，最新的。

阿里的规范里头它有一个规定县城的名称，尤其是县城池里面的一些县城，要给他一个有意义的名称，都要写有意义的名称，当然这个你要是没学过老师的表演，程高并发你你也不知道怎么写，有一个名称。

因为你得定义three fk，这个我们先不管，就是在阿里的规范里头要求规定必须的，每一个县城都得给我写一个有意义的名字，你不能随便瞎叫，为什么能猜能猜得到啊，原因是什么。

方便定位问题，你比如说这个县城，他名字叫p1 thread 1，他现在到底干嘛呢，我靠我不知道啊，案例产生的那种，这代产生像他那种都是是成百成百成百个线程，你从这县城里头要揪出来哪些个有问题的类似你好。

所以这个文档到时候去哪领，上网搜吧，这文档去哪去去哪找份文档，还得让老师教你啊，哦看这里。

我用的就是这四个deck杠l g4 杠l可以搜索特定的思索情况，并不是所有的情况他都会嗯嗯弄出来，所以你最终呢该读还是要读啊，这个没有这个没有招好，就要带这个命令，我们再来看下一个命令。

这个命令叫这info。

看这里这一份比较简单，这infer info呢就是你那个目前这个县城啊，这个这个这个java的进程就什么1239吧，好这个进程呢它的一些个虚拟机的一些信息，唉，你比如说你的这个线程。

它的run他们的名字啊，他是谁提供的呃，它的各种的class level class path啊，就这些这些信息，这是用java可以来做的啊，你读一下，你看看它的这些参数到底是怎么做的是吧。

年龄代表多少，老年代表多少等等，读这些参数的，这里面其实有两个特别好玩的参数，我要有时间弄啊，可以给大家讲一讲，这里面参数是不是跟cm是跟那个那个那个是没有关系的，跟那个垃圾回收有关系的啊。

这个也是面试第六比较恶心的问题，大家先记着吧，如果我忘了的话，找时间问我，我给你讲给你们听，就是这道面试题，这道面试题，为什么压缩指针超过32g会失效，这是一个特别恶心的，没问题啊，好看这里。

呃这个参数其实这个命令呢也就是读一读而已，没什么太大用处，我们继续看。

第三个情况，这个是特别有用的，如果你在没有更先进工具的时候。

你用这个名字来干涉这state gdc j4 倍的杠，gc 1239就是他会干嘛呢，他会给你输出这些这些情况，老年代占了多少，被占用了多少，一定取掉了多少，survival，零占多少。

一占多少等等这些信息，只不过这些名字显示起来的让人读起来特别的不爽，可读性特别差，当然gt gtz呢它还有一个，参数是可以指定每隔多少毫秒，你给我输出一次，每隔多少毫秒输出一次。

这样的话呢你就更有意义了，大家记得有人没东西就行了。

还有同学说java东西太复杂了，我想到现在你们觉得很复杂吗，真的觉得很复杂是吗，我告诉你，你去写那个就我家姑娘半天就能学会的，那个小孩们编程用的那个语言，那个不复杂，你知道吧，唉但是不值钱。

那个叫scratch，好看，这里还有一个命令叫j mag好，关于这个命令，我们明天再讲好吧。

ok有同学说了，老师你讲了这么多命令，感觉都不是很友好啊，不是很友好的原因确实是他初始的这个命令行用起来相当的不友好，当然有同学这时候就会说，老师有没有图形化的东西，有没有来，同学们告诉我。

如果有什么要问你，你当时怎么调优的呀，你说你挂了一个图形界面，这个图形界面是什么呢，叫做j visual vm，有没有呢，当然有，有的是，一堆啊，我告诉你，我给你打开来看看。

可，这东西呢我得给你抓住主线，千万别跑偏了，一跑偏东西就多了，主要是主线没有那么难看，这里这dk一点八，java自带的工具，这visuv m，比如说，我们要是监测我们某一个java进程啊，我把它。

本地的哦，我的我的那些家用进程都没都没起来啊，这个时候呢哎你就可以本地的进程，你就可以跟上去用这种图形化的来进行监视，看到了吗，哎堆战多少了，matter space占多少啊，cpu占了多少啊。

装了多少个class啦，整个整个县城进城的这种活动的总数了等等，现成的抽样，还有呢抽样器，我现在有多少个，我现在有多少个实例啊，什么东西有多少个实例啦等等，全都显示在这里，爽不爽可以吗。

我要教你们这个可以吗，好你要跟面试官聊，说我用的图形界面调优，面试官一个大嘴巴子呼上去好吧，你见过你们家服务器有的有有在你们家服务器上装图形界面的吗，有没有，没有吧，哎我看有同学已经说了。

不是可以远程吗，没错这是你们的linux服务器，然后呢，京东的你为了远程进行对它进行监控，开了很多很多的端口和协议，以便我们的jvo vm能连上来，我问你多少个控制安全的网管，允许你这么干，有没有。

把端口给你打开，所以你跟面试官这么聊，面试官要是稍微理解一点就干就就干，你不专业，听懂了吗，这肯定不行，这是为什么我就教你命令行的原因哦，那有同学可能会说，老师我把它当p下来，你要说把它当不下来。

大嘴巴子准备好吧，直接就给你一大嘴巴子dump下来，你知道一个dump下来的文件有多大吗，大哥试过吗，你知道在你dump的时候是需要执行一个j map命令，你的整个程序要暂停的，知道吗。

一个实际的这样的一个dump文件，在那种性能稍微差一点的机上做分析，要花一天左右才能运行完，不告诉你，什么时候也可以dump，就只有一种情况，你们服务器崩了，只有这种情况下，你可以dump。

除了这种情况之外，你说我他正在运行呢，我给他当不出来，可以有这样的命令可以做到，但你不要跟面试官说，你是这么干的，难了难了啊，我告诉你，好看这里那里人怎么办呢，当然就是使用命令行，有同学可能会说。

那老师这么一大堆的这种图形界面没有用吗，我在讲vip的时候也讲过这些图形界面。

但是呢我告诉你这个这个不是说没有用，如果你说用过图形界面，用在什么地方，听我说在一种环境之下，就是上线之前的内测，比如说你游戏服务器放上去，在这里跑着，远程挂个界面，甚至在这里开个图形界面都没有关系。

你挂上他监控着它，这时候玩命给它做压测，看看它会会不会产生一些我们预料之中有可能会产生的一些问题，所以在压测上线之前的大量的压测好图形界面上没有问题，听懂了吧，那get到同学给老师扣一。

ok注意我接下来讲的东西很多都是真正实战之中的人们怎么用的啊，我告诉你网上很多讲的呢是那个理想化的，听懂了，非常理想化的，看这里这哥们已经开始复dc了，不停的复dc呃，我们先不管它呃，下面我们来看呢。

在实际当中我们用什么，实际当中呢，我推荐使用一个工具，这个工具呢刚才有小伙伴已经打印出来了啊，它为了博取我的注意力，我已经看到了这个工具叫arth好。

关于这个工具，我觉得我不想在这里跟你专门的聊他怎么安装这一类的。

好不好，没意义，office。

这是阿里的开源，阿里开源的一个工具，哎我去还防不了。

好这个我就不给你们看主主主界面了，显得有点慢，你们自己去搜office，这工具一旦扔之后，挺好用的，非常好用呃，也推荐大家使用那个阿里内部，他们也他们也用好吧，没有阿芬怎么办，运营不让装。

如果运维什么事都不让干，那你就只能用刚才我给你讲的特别土的命令来看，听懂了吗，那个都是java自带的，但是assets是可以装的，assets可以装，是为什么呢，你不用看任何的端口号。

你给我装一个程序就完了，哎那么dos安装运行下载，我不想跟你讲了，可以吧，哎可以的，同学给老师扣一下载安装，我不想讲了，ok，这个你还要老师讲的话，有点过分了就好了，那我看这里我都是都10。20了。

嗯我们把阿斯起个头，大家伙呢也可以自己装上，明天呢我再来讲详细的过程好不好，同学们，我先给大家起个头，这鸭子怎么怎么玩呢，我装好了之后呢，解压开，解压开之后呢，它是呃一个目录中不中，叫什么b3。

14版本a d a型b，然后呢我们怎么去运行它呢，这么来运行最简单的运行方式，java dj执行一个站文件，哪个文件呢，就是office不点炸，office，就等下，这是一个纯命令行的东西。

好ok他找到了一个java process，我们把它attach上去挂上去，这个是一它的编号，内部编号是一，所以我们敲个一早就挂上去了啊，try to attach，想attach上去不行。

我这程序是不是已经挂了，我怀疑，居然也太不上去了，啊已经out of memory了啊，sorry，这个挂不上去了，怎么着，我重新把它起来里先把这东西起来，我重新运行office，来挂上去。

好当你看到这个界面的时候，说明已经启动，并且挂到了你的java进程上，你看到了office目前正工作在1459这个进程上，好到现在为止，你可以用用office来干我刚才给你演示的那些命令行干的事儿了。

os呢除了具备那些命令行的所有的功能之外，当然除了一个命令行工具，就是这个g map，这个g map as是没有覆盖的，除了他之外，因此在af aths里面，大家用了一个工具就已经足够了。

以后就在它里面玩，所以你说你以后写到你简历上的时候，说我有过实战调优经验，拿什么调的，用它听懂了吧，呃今天呢已经10。20了，咱就不继续了，明天我们继续好吧，呃今天呢我留给大家一些大一的时间。

如果大家有什么问题呢，你都可以问好吧，随便问啊，这v的所有问题随便往王老师这招呼，老师长得像岳云鹏，我去，你能不能说我长得像，岳云鹏也太那什么了点儿，嗯嗯哈哈哈，开玩笑，岳云鹏就岳云鹏啊，啊别着急。

你们那我去好那个那个技术问题，技术问题慢慢聊啊，你别别刷，哎呦我的妈呀，别刷，现在老年代一比二一比三一比二，老师最近有出书，我们自己写的内部的那种呃，给学生们用的教材，除了这c多久一次正常。

这个不一定看你内存多大，还有你的应用的情况呃，有的什么一次都算正常，有的可能一小时一次都算不正常，看你内存多大吗，你你一个你一个你一个天文广场，这要是说你一小时就一次，你自己想想它正常吗，不可能啊。

一小时就以为它灌满了，他能正常吗，om怎么调u om了，那不叫调优，那叫调错，调错的过程，明天我讲给你听，我教给你怎么把它定位出来，能讲下安全点吧，杨怀大家别刷了，杨怀都已经刷过好多遍了。

杨淮是我们的vip中p，因为他是杨玉环的弟弟，名叫杨环，开玩笑开玩笑啊，呃诶哪去了，vip中心安全点cp，4号是什么概念呢，我先给你，我给你讲大体的概念，大体概念是什么概念呢，就是说你看啊。

这是我们的正常的工作线程，我们的业务逻辑线程，我们的业务逻辑要让它停下来，我们来我们垃圾工作线程才可以启动，对不对，在停这个现场的时候，二话不说，夸机所有的全从我cpu上给拿走了。

直接把我gc gc线程挪进来开始运行，不是那么回事儿，为什么呢，因为有的线程你比方说正对这个对象上锁呢，上了一半，你能让他停在这儿吗，不行所谓的safe point指的是什么呢。

指的是我们这个县城得停到一个合适的位置，他停下来的时候呢，不会对前后的一致性产生影响，这个叫c point，好吧，写屏障也是上锁嘛，这个写屏障注意就是说这位m里所提到的读写屏障。

和我们平时所说的wallet tel的那种内存上的那种内存屏障，是完全两个概念，这个读凭证写篇章的意思就是说什么呢，说的是当发现jvm在执行某一种操作的时候，我跟上去做一种背后的操作。

这个解释起来比较抽象，我给你举个例子，你就知道了，你比如说看这里，我们说一个复制算法，a对象指向了b对象，然后b对象所在的区域要被回收了，它被回收的时候，他怎么被回收到，它会把它复制到另外的区域里去。

不管是survivor是什么，把这个对象复制过去，那么同学们，你们想一下这个地儿的引用得跟着变，就是原来我这个地址值是指向这儿的，我最新的地址值得指向新的，好get到同学有点扣一，这个阶段听懂了吗。

好那指向新的是什么意思，注意这个过程对我们程序员的调用，我们乘务员正好要调用这个引用，怎么办呀，你这个引用在正正在变的怎么办呀，这个时候就是在他挪动了之后，相当于在内存里面写了个新东西。

然后这时候产生一个屏障，屏障的意思就是在他挪动了之后，我马上跟进跟进做一件什么事儿，把这块给你更新了，好，这块同步性的给你做个更新，就是任何一次的垃圾回收在挪动了对象之后，原来的引用里面的值得进行更新。

但是这个更新过程对我们用户是透明的，你是看不着的，你还可以直接访问这个引用，这个东西叫post right barrier，叫他写后的一个评论，等他写厚了之后，顺带的做一些jvm内部该做的一些操作。

这个叫凭证，这个叫post right barrier，叫完成完完事儿之后的写屏障，好这点get了是吧，为什么阿sir为什么屏蔽它，没有屏蔽他，只是没有实现这个功能啊。

现在在290废弃的原因cms毛病巨多，cm，我刚才也说过了，他一旦碎片化完蛋了之后，我告诉你一次垃圾回收就卡死你了，他用serial old的垃圾回收，你自己想想，整个服务器啥事都不能干。

其他县城全都给我看着，那什么时候都跟老太太扫完了，程序继续，哎你们别刷没刷没刷，g c a怎么判断，你这句句整个句都不通，重新来重新问，总文档的这些应该都有吧，嗯这个文档是公开课的文档。

能让你在简历上写上有一定的经验，能让你入个门呃，很多的细节的一篇文档也是装不下啊，我因为那个我给你讲一个g1 ，给你讲一个z d c的话，没两个小时基本够呛，拿不下来，十分钟啊，十分钟结束啊。

呃配合docker部署方式调30可以用这个吗，可以啊，你等会儿你也得占内存啊，你占内存它它它产生o o m他还还会会有问题吗，先生没有jdk，jdk依赖如何调整是几个意思，什么叫jdk依赖。

没听懂为什么压缩指针32g回事哦，对想给大家讲这个问题来着，首先首先首先你们知道什么叫压缩指针吗，先说这个大家知道吗，问题比较复杂，就问题讲完，估计今儿就可以下课了，这样，来看这里啊，咱们挑一个命令。

随便挑一个java杠x，嗯知道了，嗯flag the version就是交易命令之后呢，你会发现呢它有两个参数，看这里两三分是什么呢，网上很多文章把两个混在一起讲，我告诉你这两个不是一个事儿。

呃仔细读一下他的意思，这个press press这个单词啊，就是鸭的意思，它是一个词根，然后comm呢co是往里压，compress，comm是往里压的，意思是前缀，然后compressed。

你比方说还有什么啊，impress这个是往内压啊，111press，对外表达，其实它本质上就是一个词根啊，好像好像好像讲远了啊，sorry那个再说了，有机会再讲英语，我讲哪来的。

这个compressed叫往内压压缩压缩指针，画个画个图，当我们new一个对象的时候，new一个object new出来的时候，在内存之中，这个object分成四段，第一段叫mark word。

以及hash code叫mc word，这第一段占八个字节，第二段叫class pointer，这个class pointer是什么概念，class pointer的概念就是它会指向我所属的那个类。

你比如说我new出来的是t，它会体现我的t一点，class好，这个东西叫class pointers，好，这个是被压缩过的，本来正常的情况，一个64位的系统。

你想想看那大腿想想也应该知道它的指针长度一定是64位的，也就是八个字节，但是如果八个字节放在内存里的话，你的整个对象好名的呢多占了很多内存，因为你的内存呢唉也就那么小，四个字节装进去，它的寻址。

四个字节的寻址已经是四个机，其实多数情况下就够了好吧，所以所以呢好这个时候呢他就给你压缩了，这个指针是多少呢，是四个，是四个字节，是四字建，好下面这个呢是你的instant data。

就是你的那个那个那个那个成员变量装置装的部分啊，你里面有个成员变量啊什么的都装，这最后一个呢叫padding，叫对齐pin，对齐的意思是我们要对齐八字节，就是如果你整个对象不能够被八整除。

那么往往前对你，比如说你你到这，你这个对象是12个字节，不能没法整数，怎么办，加一个四变成16个字节，能够被八整除，这个叫做对齐，就是最后你这个对象大小一定是能够被八字节整除的，这是一个最基本的点。

八字节就是64位，因为你jvm的寄存器，你的机器的寄存器64位正好撞八个字节，所以特别合适，效率特别高，因此jvm读一个数据的时候，64位的要求八字节对齐，当然这里面有个参数。

你可以指定四字节还是16字节，随便你指定，但是默认八字节来get到这里的同学给老师扣一，那这个compressed class pointer指的就是把中间那个pointer那个指针给它压缩。

从八字节压到四字节，而后面这个compressed opp o p全称叫ordinary object pointers，普通对象指针，ordinary object pointers。

普通对象指针的意思就是说在你的成员变量里面，如果有一个引用，比方说spring name name等于一个字符串好，这个指针占多少，开启压缩的情况占四不，开压缩占八好，这是压缩这个压缩指针有一个限制。

这个压缩指针在你内存超过32g之后自动失效，同学们，如果你们有谁的机器真的有32g的内存，32g以上的，你们自己都有实验做什么实验呢，就是你啊我教你做这个实验，这个实验怎么做呢，我机器没有32g啊。

所以我没法给你做呃，这时间这么来做，你弄一个特别大个的list，把一堆对象装到这个list里，他永远都活着，一堆对象装进去，然后呢，你最后看一下这个list大概整体占了多少个内，占了多少的内存。

然后你设你的内存值超过32，你就堆内存超过32g，你看它占了多少，对内存不超过32g它占多少，我告诉你对内存不超32g，它经过压缩，这里面占的内存数如果是555 百兆，那么它超过32g之后。

这个可能变成750兆，你在不做任何参数指定的情况下，为什么，因为超了32g这个压缩指针自动失效了，他，到底是怎么实现，它到底为什么是32g失效啊，这个唉呀，唉复杂，尝试讲给你们听啊，最后一个题了。

讲完完事啊，今儿就到这儿，也就是说你你如果你的内存，你比方说原来你你干一件事，你们家内存32g啊，三三你们家内存20 24g，然后你觉得呢内存不够使了，你扩了一个36计。

结果你会发现呢同样的东西你多赚不了多少，因为超了32g那个压缩指针失效了，好为什么会是这样的呢，嗯是这样的啊，大家首先要理解一个指针，如果一个指针的长度压成32个字节，sorry 32位就是四个字节。

这是压缩之后它就四个字节，32位的指针来告诉我它能够寻找最大的数量是多少啊，二的32次方是四个g，四个g好，这点大家能理解吧，四个g对好，那么如果我用32位的指针。

也就是说我最多能支持的内存就是四个g多了，我支持不了了，那有同学说老师我靠，你照你这么说的话，你三你32级才不支持你这个32位指针，你压缩了32位指针，你这32位指针是怎么支持到32g的，很牛吧。

对啊怎么支持的呀，同学们，你们想想看，我是一个二的32次方，四个g的四个g的地址，但是你发现没有java的任何的对象啊，都是八字节对齐，八字节对齐啥概念，就是你这个你这个你这个对他来说呢。

你比方说01234567，你放心，这个222的这个位置一定不是个一定不是个对象的开头，你能理解吗，因为它不能被八整除，好刚才这句话能看看是不是该到了，就说我们比如有个地址，就是零个字节到七个字节这么多。

这个中间啊，我跟你说，这个字节绝对不是一个对象的开头，因为他是八字节对齐嘛，所以其实我这二转32分钟我可以用，我可以只得这个数呢，我可以零八哎，我跳着来自己看看是不是就变成32g了。

当然细节上它是补零的啊，它是补了三个零，好了好了，就到这里吧，好吧嗯，能盖到盖盖的都算了啊，这个gm知识面不是就支持的东西太多，这一时半会真说不完啊，咱们今天晚上就到这儿好吧，明天见，ok懵了。

懵了就算了啊，听懂听懂前面就行，明天咱们讲实战就就讲实战啊，算法一讲就讲蒙了，很容易很容易懵啊，明天实战实战很简单好吧，明天再见，拜拜，没关系啊，今儿听不懂的。

系列 1：P16：马士兵深入浅出java虚拟机⑥为什么一个百万级TPS系统会频繁GC？ - 马士兵官方号 - BV1mu411r78p

昨天讲的内容吧，好不好，简单回顾一下啊，我们稍微回顾一下，昨天呢我带大家呢主要是过了一遍这个东西，就是常见的垃圾回收器，垃圾回收器的一些常见组合诶，哪些呢是分带的，哪些是不分带的，哪些是逻辑上分。

在物理上不分带的，讲了这个东西嗯，然后呢我教了大家几个简单的命令来观察一下咱们这边的一些情况，观察一下dc的一些信息的给他列出来啊，交了那么几个简单的命令，然后昨天呢我运行了一个小程序。

这个小程序呢就是唉这个小程序，这个小程序呢是模拟了一个呃对于信用卡模型来做模型匹配，来做风险控制来呃做的这么一个小程序，了解小程序呢它本身是有些问题的，昨天呢呃大家伙也都看到了，然后在昨天结束之前呢。

我跟大家说过，我说呢呃在我们实际当中调优的时候呢，我们还有一个特别好用的工具，就是谁呢，阿里开源的这个arth呃，其实来教大家做操作这个事儿相对简单的多，呃我今天给大家讲完操作之后。

能让你的简历上能够大体写上有过jvm调优经验之后，看看能尝试给大家讲一点理论好吧，理论其实相对难好难好多呃，面试的时候问理论问的比较多，实际上你只要有个操作，那么别人问你的时候，你是做的什么操作呀。

什么情况下你做调优啊，这个东西能说得出来的时候，ok你这个简历唉就值钱了，今天他特别过分，我以前的学生啊，就是从做线上教育以来，学了我们课程的学生少着，大概学完课3~6月左右，少人能往上涨5000块钱。

今今天今天特别过分啊，今天有个学生只涨了2000，还好意思跟我说，太过分了，实在是太过分了吧，打破了我们一个记录，本来我们是原来的学生，差不多啊，每个月涨5000块钱，今天有一个只涨了2000。

但是他只报名，只报名了三天，哈哈哈，虽然他破了我们几个，我们还是很高兴的啊，好开玩笑啊，来看这里，那今天呢我主要给大家讲这个office的在线拍照工具。

ok回来回顾我们这个小程序怎么用啊，稍微回顾一下，我们首先呢把我们的利益程序跑起来，还是这个小程序让他跑起来，大家还记得吗，我们others怎么起来啊，就这个小程序呢，它有问题，昨天呢大家也看到了。

我们首先用top命令能观察出来它内存在不断增长，所以你的网管肯定会过来找你一个大耳刮子呼上来说，你这怎么回事，你赶紧给我调去好，你就给他调，你怎么调呢，哎你用几个命令来调。

当然昨天讲的那个几个命令都比较土，今天呢给大家也是java自带的，但它比较分散，比较土，用起来不方便，今天带大家呃用一个核武器，就是那个阿里开源的这个alice，首先所以啊这是这是原。

来我们需要需要调试的这个进程啊，需要调试的这个进程，他在这跑着，然后这个阿瑟斯怎么工作呢，阿瑟斯他自己也是个进程，他起来之后呢会attach到挂在上面去观察它里面的一些运行情况。

这里面呢是java自带的一个编程接口，叫jvm t i，如果你感兴趣可以去看一眼，就是others是拿什么写的，是这个接口叫jv m t i。

全称叫java virtumachine to interface，工具接口就是你可以为jvm写一些工具，通过这个gm ti来写的，就是就是拿这个写成的，我看这里，来不了，直接点了，这刚站。

呃os 5点站，挪一边去啊，好我们挂到这个进程上，这个进程是2176敲一，那么当你看到f4 这个界面的时候，ok你已经知道了啊，已经挂上去了，s命令有很多，我推荐大家呢，你直接到others的主页上。

就github那个主页上去看他的中文写的注释写的很详细很好，也不用去专门找找些书什么的，看，没必要，还有一个呢你就是用了一个help help，写的也不错，非常好呃，我一般就直接看help help。

它就会列出来，在下面呢你可以运行哪些个相应的与相应的这种命令，哪些命令都有这么多，还不key map s我就不一念了，特别多呃，我教大家几个好玩的，这个比较常用的，首先第一个呢叫dashboard。

dashboard仪表盘，仪表盘是什么意思，你敲回车的时候，你会发现诶出了一个用命令行模拟的图形界面，他每隔5000应该是每隔五秒钟刷新一次，如果没记错的话，当然这是可以指定的。

这里面给你显示的是什么内容呢，我想你一看就应该明白上面列出的是什么，最繁忙的县城有哪些这些现成的状态，它写成的名字，还有呢关于内存的一些信息，对诶占了百分之多少啊，一边去百分之多少。

survivor区多少，tenure的generation，昨天我讲过tenure的generation，就是o的区域，老年代占多少了，这个还有呢下面是一些运行时信息啊，操作系统的名字。

操作系统的version java version java home，这就这就不说了，好这个比较好玩儿，呃当然这个是看一个大体的情况，除了dashboard之外呢，就是dashboard。

你可以远程的去看它什么呢，哎去看动态的去观察它，看看这哥们儿老年代是不是不断的在增长啊，是不是老回收不了啊，堆的占用是不是不断在增长啊，去看这些，去看这些信息，还有哪个线程是最忙的，占了cpu占了多少。

这闲聊的名字是哪个，到底什么情况，他在干嘛，如果有人有线程不断的占占cpu诶，ok这个县城一定是有问题的，线程都占了百分之百了，查他怼的，ok这dashboard就干这个事的，来get到同学给老师扣一。

这个比较简单啊，不难，好我们再加help，然后呃在这个就是这java就是阿里的这个东西呢特别强大，他除了有一个命令没有弄完之外，其他的基本上全都全都全都完成了，好大家看这里啊，来我们再来。

我再来教大家另外一个命令，就看这个吧，jvm呃，display the target of information，大家还记得吗，昨天我教了大家一命令叫a fer，那我看出这位的相关信息。

阿里的这个gbm啊，这个命令其实比昨天我给大家教大家那个jinfer那个命令，它显示的更加的详细啊，他比那个要详细的多，呃，最好的是呢它能够显示出来，你到你现在到底用的是哪些个垃圾回收算法。

比garbage collectors，你现在用的是哪个copy market summary compact，ok你现在用的是拷贝，拷贝完了之后呢，是一个mark sweep。

再加上压缩所有有就是简单的说就是我们原来的ps加po，他的算法当然还有一些其他的信息啊，这个你自己去看就行了，这个不难，ok，啊没有clear跳，好我们说我下面我下面来教大家呢，教教他什么呢。

教大家怎么定位我们这个程序的问题啊，我们这个小程序一定是有问题的，当然他现在还没有显示出来，但是它有问题有什么问题呢，我现在教大家怎么定位，昨天大家观察这个小程序的时候。

你会发现他一会执行一段时间之后呢，对不对啊，这还得看一看，一会儿他我就一会儿等他频繁dc之后，我再来看他信息啊，你就了解了，我先教你别的命令吧，一会儿我们，回来看这个信息再看啊，呃教你一些别的命令啊。

你比如说，thread，这也是一个很有用的命令和，read的是把这个java进程里面所有的线程全给你拽出来，昨天我们讲过jdk，大家还记得吗，jdk是干嘛的，也是观察那些现成的信息的好。

阿里的这个thread和jdk的完成的功能一模一样，但是它用起来更好用一些，比方说我想观察16号这个线程，它的一堆栈的调用，并且呢thread 16 ok就可以了，你就会知道哦，这个16这个线程在干嘛。

他是在一个什么状态，它是在运行哪个方法，这个方法的标准站是什么，当然如果你一个程序里面现成非常多，你还可以进行过滤，thread说，may比方说may may may里面开的线程啊，全全都给他列出来。

ok全列出来，单位呢呃如果你像阿里的那个要求，每一个线程你都起了正确的名字的话，那么你就可以用名字来进行过滤，如果县城有谁是，比方说它是持有锁，产生了这种死锁的现象。

直接一个命令thread当b而我这是没有锁的啊，就是没有组没有会产没有产生死锁的线程，所以你杠b是看不见的，如果你产生死锁，你自己去写，你用它来挂上去的时候。

thday杠b就直接会把那个县城哪个县城搜索都给你找出来，thread呢还有一些其他的参数，任何一个命令后面调杠help回车，ok你就知道这个命令的用法，这个命令到底是什么意思。

他说display infer threstack，然后它有一些个examples，一些告诉你的用法，比方说gb gb是什么意思呢，find the threat。

who is holding a log that blocks，the most number of threads，一读就明白了是吧，find the threat，找到那个县城谁啊。

with holding log，他正在拿着一把锁，阻塞了其他人，阻塞了其他见证，它导致了思索，把这线条给我揪出来，fly刚毕a是不是用起来特别简单，感受到了没有在一个界面里面把所有的问题。

所有的问题全解决了，巴特的会影响被监控性进程的性能吗，必须得会，如果不影响他怎么去拿到那些信息呢，必须得会影响啊，好我们继续往下接受命令，等他等一会儿他要死机的时候，我们再来看他的信息，好吧。

再介绍几个啊，这里面的命令我就不完完全全的从头到尾已经介绍完了，这个就没意思了，呃我觉得多数人大多数的人应该更看外面的文档，看呃呃帮助的信息应该都能完成是吧，我觉得应该有啊。

参加过任何1年半年的工作的这些乘务员，这都不是问题，咱俩就再给大家介绍一命是什么呢，这个呢我倒是我这几个命令啊，我建议你可以了解一下这个命令还是挺好玩的呃。

第一个呢叫search classes loaded的百gb m s c c，什么也叫search class sc sc呢，当然他的命令的方式有特别多，你如果你直接求c的话，他就会把。

他就会把i c c它就会把所有的这种面，你它里边加载的这些类全都弄出来，当然你可以这么来写，扣两码是零诶，这是我们自己加载的那个类，你看到除了我们的主力之外呢，还有三个line的表达式是吧。

两两个栏目的表达式啊，两个内部类啊，一个是有名的内部类，一个是匿名内部类，ok，有人说了，老师你把这个类的名字找来，有什么有什么用吗，是因为呢它会下一个方法做准备，下一个方法叫什么呢。

下一方向sm sm别扭，这名字起的全称是什么，loaded by，这边去查什么查方法，找到那方法，你们俩那视频这样，如果是这样的话呢，它会把这个类下面的所有的方法全都给你列出来呃。

当然你要查那个main方法的话，你就可以直接按这样的格式来写com马视频j mj c啊，把这个麦给给给搞出来呃，只是查类名查方法，这个东西呢没什么意思，其实它最重要的是干嘛呢。

最重要有两个命令是跟在这两个命令之后面的，就是sc，你你有几百个类，我用sc把我关心的那个类找出来，这个是需求是经常有的，几百个类里头把这，个类给我找出来，这类里头有好多比较关键的方法。

忘了方法名叫什么了，搜完了之后主要是干嘛呢，一定是这个方法有bug或者有问题，我想观察他，你说对不对啊，同学们，这是肯定的，那下一步呢哎有几个观察的命令开始服dc了啊，这就快了，有几个观察的命令。

这几个命令值得大家拥有，你值得拥有呃，这几个命令是什么呢，第一个呢是trace，他说你看这里啊，他叫trace，the execution。

time of specified method invocation，这是什么意思啊，读一下你们理解trees，后面要跟参数的啊，如果你不知道它怎么用，很简单，敲help。

看他的examples就行了，你看啊，比方说它trees某一个类下面的is blank方法，看到了吧，这个trees是干嘛呢，这个trace是跟踪时间的。

看这里trace the execution time specifmethod of vacation，你指定一个方法的调用，它来跟踪这个执行时间，这个就是执行效率，你比方说你写了一个很关键的方法。

放上去之后，这个方法呢肯定会让用户不断的调用，不断的调用，不断的调用不调用，如果这是你的wea wea web application的话，那这个方法会不会用户不断调用，这个方法是一个很关键的方法。

要求它性能，比较高，但是你会发现这方法性能不到位怎么办，观察到位没到位啊，用这个trace直接跟他看他的方法执行了多长时间，但是我们这个小程序呢没有这种不断执行的方法啊，不停的执行。

又来一个来一个请求执行一次，来一个请求执行一次，所以这个呢目前用不到，但是在你们自己写的web application里头，一定有这样的方法，你比如说你写了一个什么service订单的service。

service里面有一个方法叫make an order是吧，设施给他成成交一个订单好，这个方法呢和数据库打交道，和硬盘打交道，和缓存打交道打交道完了之后也反馈回来，你可以跟踪这个方法的执行时间。

如果你发现他是执行时间特别长，一定有问题，有一次用这个东西跟他跟他跟晕了，真晕了，说明你不了解这，命令到底是怎么用的，这个很难吗，很简单，应该是好，讲，到这里能跟得上的同学给老师扣一来。

好那除了这个trace之外，trace很有用之外，还有一个跟踪方法也挺有用的，哪个哪个呢，知道的就简单对老师把这层窗户纸给捅破了啊，你就觉得没那么难了，有好多时候叫会诊，不难，难者不会给你捅破了。

你就觉得没那么难了，还有一个呢叫monitor，这个也挺好玩的，也挺有用的，你看一眼就是monitor method，execution，statistics，for example。

total success，fa count average，my favorite等等等等，这是干嘛的呢，它是跟踪这个方法的运行数据，这是什么意思，monitor，好简单说一下，这已经抄不进去了。

因为那边那个进程已经死掉了，呃这monitor是什么意思呢，monitor的意思是当你跟踪某一个方法的时候，这个方法是哪些值被传进去了，传进去的那些个参数值，哪些值被返回了，它的一个执行过程。

这些数据全都能给你跟踪起来，那这个对于你定位问题来说也特别特别的好玩儿是吧，也特别好用啊，spring调文章很深，你为什么要跟spring的方法呀，你不应该跟自己的方法吗。

好到现在为止呢，其实还有一个关键的命令我还没有讲莫及，下面我来讲这个关键的命令，这个关键命令是什么呢，就是一旦你的程序发生问题之后，你看啊，现在看我现在这个不停的复dc，看到了吧，不停的刷新。

不停的刷新负dc特别频繁，而且你看到了这哥们其实已经死掉了，他只不过有些遗留的线程还在不同的不停的输出而已，那个输出线程啊还还没有输出完，其实已经死掉了，已经oom了，我说这个程序的bug就已经出来了。

程序bug会是什么样的呢，内存不断增长到一定程度之后，频繁f g c评分ftc之后，再过一段就有可能产生l o m好，这是这个小程序的问题，那下面呢我们就来定位这个问题，我先把这个给停掉。

大家需要注意的，有有有一有一点呃，在这儿其实有一些细节我已经略过它了，因为呢那些细节对咱们今天的实战来说不是特别重要，在你实际的工作场合也是特别重要的，如果有面试官问你，你日志的设置的这种参数。

你要是回答的有问题的话，我告诉你面试官一眼就能看出来你的水平到底是高还是低，那什么意思呢，这个我在笔记里呢也给大家记了，主要怕大家看不懂，我多说两句，日志的话，好看，这里你设置个日制参数的时候。

一定要好好设，有很多人啊在设这个日志参数的时候，它就直接呢就指定指定一个日志文件，知道吗，然后就不管了，我告诉你，凡是指定一个日志文件都是业余干法，有面试官要问你说你们有几个日志文件。

就一个死大耳刮子直接给你抽上来，为什么，因为你自己想想看这个日志它会不断的增长，不断的增长，不断的增长，大哥的日志要是增长到四五个g的这种日志，你想分析里面的数据，你累不累啊，累死你，所以我告诉你。

真正的日志参数，按照文档里，头这么设，自己设好日志的名字，自动生成，这个日志是一个滚动日志，叫log for rotation，一共有多少个日志文件，五个，这个数你是可以自己设的啊。

五个十个你自己看着办，每个日志文件是多少，20什么意思呢，产生五个日志文件，每个日志文件最大20兆，由于它是滚动的，最后一个日志，满了之后写第一个，第一个就被覆盖了，这样的话总共就100兆。

你要搞一个日志文件不断增长，面试官肯定会问你，那是有问题的啊，好来刚才我讲的这一小段街道同学老师口音，主要是让你知道你怎么跟面试官聊天，这个日志的信息，这里给的信息叫做非常初级的信息。

如果你设日志的时候，一定要设置的特别详细的那种，我们要给大家讲日志文件的解读，主要第一比较容易，第二呢跟我们实战的关系并不是特别大，今天所以呢我们先把它放在一边，但实际上每一个不同的垃圾回收器的日志。

它实际还是还是很复杂的，呃你真正要把它看懂的话，你得确确实实了解啊，就是这里面每个日志它到底是产生了什么意思，这个我有一些整理啊。

你自己尝试看就行了，呃在这儿呢就不花时间讲那个了，比较，枯燥啊，也没什么意思，先把它放一边，当你在日志里头发现就定位一个日志问题的时候。

系列 1：P17：马士兵深入浅出java虚拟机⑦用jps定位虚拟机进程 - 马士兵官方号 - BV1mu411r78p

哦他现在已经有问题了，什么问题呢，他才不断的频繁的产生fg的，最关键的是在这，你往这儿看好，这是最关键的啊，这是什么意思呢，这个的意思就是说当经历了一次负dc之后。

整体回收内存从原来的19198015k回到了1980，198015k哎，这个是198015k回到19198014k只回收了1k，你一个f g c下来，您老人家只回收1k或者0k在干嘛，他在干什么。

基本不减少，对啊，为什么我，好这里面一定是它回收不掉，回收不掉，什么意思啊，你们分析一下，这是我们的old的区，这里面内存满了，我做回收的时候本来正常有有有的对象应该都死了，但是他回收一遍。

居然里边没有死对象，没有垃圾，没有有任何有垃圾的地儿，说明里边对象全有用全有用，就代表着有的所有的人都有引用指向的，回收不掉啊，这个叫做内存的泄漏，内存的溢出好，我这里澄清两个概念，以免有同学不了解。

第一个叫memory leak，memory league，叫内存泄漏，第二个叫out of memory，内存泄漏是什么，内存泄漏是说你你在这块内存里有一个对象站在那儿，他就站那不动了，没什么用。

但是他就跟那站着也不释放，产生了内存泄漏之后才会产生内存溢出，如果这样的对象多了，内存就溢出了，但是如果只有那么一两个，他就在内存里站着，他也不他也不释放，它就占那么大地儿，但是你其他内存还够用。

这个时候就不会产生out of the memory，所以内存溢出和内存泄漏它是两个概念，好get到同学给老师扣一，对那个毛鹏飞说的对啊，站站站着桌子不吃饭啊，属于这样的。

ok从最后的我们的分析结果来看，它一定是发生了内存的泄漏，并且泄漏越来越严重，然后产生了内存溢出，那这时候我就要分析了，到底是什么样的对象占了这么大的空间好，所以我们这个逻辑很清楚吧。

这个逻辑我们看日志日志发现他回收不了这个空间，那就分析里边有一定有泄漏，里边有泄漏的话，就是一定有对象的不断产生，在占着空间，而且还不释放啊，占占着茅坑啊是吧。

然后所以下面呢我就要看到底是哪些对象干的这件事啊，这个逻辑到现在为止应该比较清晰，对不对，那好当这个逻辑表清晰之后，下面我们就来分析到底这里面哪些对象被占了呢，在这个进程已经死了，我重新把它跑起来。

好我在另外一个窗口里教大家弄这个命令。

ok，j mac啊，昨天没给大家讲的这个命令叫什么呢，叫j map，好看这里啊，在这儿在这儿啊。

就这些命令呢我不建议大家都背过。

你手边有一条小的那个呃手册放旁边就可以了，你用多了呢，其实面试官问你，你一定能说出这个命令的名字来，但是参数你不一定记得住，这个事很正常，你要把参数都记住的话，反正这事儿就不对了，说明你背过来看这里啊。

分析哈，procedure啊，或者叫project或者叫program，或者叫什么嗯，就是分析内存用的来，j map这个命令呢，它会干一件什么事，他会干这么一件事，他会直接进去进到那个那个。

那个正在跑这个内存里面，帮你去把那个里面那些对象，一个人又给你揪出来做一个分析，这个很牛，这些零命令之前我首先得知道它的进程id号gp 2310，嗯history gram生成一个分析图，2310回撤。

当然这个，呃就就就就那它的内容太长了，所以我们给它加一个限制符，head杠20，我把前20行给打出来，ok同学们，你们仔细看，这里列出来的是什么呢。

这里列出来的就是在这个这个m里面有哪些个类所产生了多少个对象，好比如说有这么一个冷知数组，这个是数组，你不去管它，它本身只占用了344个对象，呃，我们来看这里。

在这里呢有一个scared future test，你看到了吗，好它产生多少个对象呢，14万多，而我们的abstract cute chier，这是我们的所产生了28万个，big decimal。

是我们的cut info那个类里面的成员变量产生了14万个，下面呢都一样的，14万多个最主要的类型在哪呢，其实在这儿看到了吗，cut info居然cut info在里面有，14万个对象，大家记住这个数。

目前是14万，来再执行一遍，你你会发现它已经变20万了，看到了吗，再执行一遍，你会发现它已经变21万了，嗯同学们看出问题来了吗，来get到问题，同学给老师扣一问题在哪里啊，对有一个对象在不断的充电。

这样你是不是就把它揪出来了，同学们只增加不减少，对不对，唉当然我告诉你，你只是把这个对象给揪出来之后还没完事儿，你得去查你这个程序的bug到底在哪里产生的，一直没有释放，对啊没错啊。

就是这个程序的问题在哪里呢。

图的问题在哪里，如果你没有学过线程池这个问题，你还是找不出来，所以暂时我就先给你扔在那儿好吧，你自己去查，当然你要听过老师讲的多线程高并发这个书上的内容，这个这个你，很容易一眼就看出来了。

但你要没没学过这个问题，你找你也得找半天了。

嗯，我还是那句话，昨天呢也跟大家说过这些问题了，就是另外一个问题，用这种方式呢，目前看起来并不是特别难，其实oom问题我跟你讲这个问题不难，不是很难，他的步骤也是死的，知道吧。

就是你运行起来这map一下，然后看看哪个对象占的最多诶，接下来就把这个对象呢，跟到你的代码里面看看哪里在不断的产生这个对象就行了，找你的代码的bug去已经定位出来了，这个不难。

但实际上呢呃你想找这个bug出来，也没有，你远远没有你想的那么容易，有一些业务逻辑的写得非常的复杂，所以在这个时候呢，呃bgm问题，这就是一个相对一个死的步骤了，我们来稍微回顾一下，其实相当简单啊。

别人说你你这个你们原来产生过om问题，你在简历里说，那为什么问你，你你怎么对它进行定位的呀，唉你就说你就别说你用了什么，那个那个自己的那个，java自带的那些命令，你就直接说我用了iph，用了一些命令。

然后呢我还用了什么，我还用了gmap这个命令，j map不是ars自带的os，没有这个命令，只有这个命令，它的功能没有实现，其他命令全实现了，所以用了这个就ok了，找出来哪些对象呢，在不断的占内存。

然后呢我回去回过头去找bug啊，我发现bug到底出在哪，是有一个现成的东西，线程池的东西没写，对好了，搞定，这是最简单的，最初级的，还有这个流程清楚的同学给老师扣一，那，现在的问题就又来了。

我跟你说这map这个命令，如果面试官要问到你的话，这里面坑也特别多，首先第一点，我现在堆特别小，200兆，我只剩一个j max，他花的时间很短，如果你们家堆100个g，你一个g卖不上去。

这哥们儿里面就暂停了，听懂了吗，好我再说一遍，如果你们家堆特别大，你一个j map命令直接扑上去的话，你们家这堆就直接暂停了，对j map会把你的现在的进程给你停掉，这个事儿一般是不被允许的。

所以你这个命令你如果说你用过这办法命令，你还得要好好的，把这事给圆过去好，怎么圆呢。

有好多种方式啊，这种细节老师都帮你想好了好吧，看这里啊，有四种说法，你自己挑一种灰度，对灰度也可以，你看比如说你你有很多台服务器做了高可用了，你停掉这台服务器，对其他服务器不影响，这个牛不牛，这可以吧。

唉这个可以，当然这map还能干一件事，就是直接把内存全导出来，其实它直接就是堆转出好吧，对当你说了这句话之后，a面试官一想，我靠这哥们儿可以啊，不仅懂这边的调优哎，他还在用过高可用的这样的环境啊。

做个集群嗯，可以给他讲个2000块钱，涨个2000块钱没问题啊，好看这里或者是什么，或者呢你执行了这么一个东西，设定了一个参数叫黑单on out of the memory，一般的情况。

任何的这种实际当中的运行环境，这个参数一般都要设记住了，在你实际运行一个你的应用程序的时候啊，这个参数一般都要设这个参数叫什么，看这里叫hdmp on out of memory error。

就是如果一旦产生了out of my memory error，之后呢它会直接产生一个内存转储文件，内存转储文件的意思就是说这个jvm里的堆里面的内存，原封不动的给你存到一个硬盘上，放到一个文件里以后。

你就可以拿着这个文件直接来做分析了，关于怎么分析内存转储文件这件事，网上一堆一堆又一堆的内容特别多，有讲mit的，有讲jvo vm的，有讲，当然这个讲的很少，heap alysis to，大家听我说。

你们觉得有必要给你们弄一个对文件，让你们看看吗，有必要吗，好那就弄一个，但是啊记住实际当中不是这么干的啊。

一定要听清楚，虽然可以弄一个，虽然说往上挖，把那堆车弄出来，传转出来给你弄出来，可是这个事儿你定要圆过去才可以，要理解这一点呃，生成堆转储文件呢有好多命令都可以生成啊。

比较简单，这个你就你就记就行了，就g map gdp for mgb five，等于什么p i d就完了，就特别简单，一个gmap命令就生成。

那呃除了它可以生成之外，office也可以直接生成，搬到我们的那个哦，没有来挂上，我们用os中轴好吧，我在这里啊啊，来阿萨，这里面有一个命令，你一看就明白这个命令叫啥，hit them。

就是把那堆诶你给我导出来，导成一个文件里，get down，要看他用法，he弹刚刚live什么什么什么，ok就这么用，我就不敲了，可以吗，太简单了，因为所以他不会因此for dc吗，会的。

他会把那个没用的先给你收掉，要不然的话你导出来的东西太多了，看这里，hdmp刚刚live活着的对象，转储到哪个文件里面去，tm目录下面的dmb。hp h process这个文件，这个命令会暂停线程吗。

会的会的，莫急啊，我一会给你讲这个命令呢，它背后的意思让你圆过去这件事儿，好吧好，这个命令很简单，我就不敲了，可以吧，同学们，它生成了之后，我还得从linux上下载下来，下载下来之后呢。

哎我下载到windows上，下载windows上之后呢，我在用jvo vm版打开。

对这是运维的必备课程的，很简单一件事情啊，主要是太太简单了啊，那也就是说你把这个jvo vm打开，我现在假设你已经从你的linux服务器上已经把这个文件给下，载下来了，这样这个假设大家能接受吧。

能接受同学给老师扣一啊，然后呢你就把这个文件打开来分析就可以了，文件，装入，找到下载下来的文件，找找忘了下载到哪了，就原来下载过的啊，呃work，because it。

在你组成原理操作系统好像是这里面是有一个的啊，找那个什么呢，找那个呃堆的dmp文件好，这里有一个叫tm。h process这个文件的后缀名啊，其实你用哪个都可以，用什么都可以，后缀名没有，你也可以。

选中打开好，这个时候呢他就会把这个整个堆转储文件给打开，我这个堆特别小，所以打开起来特别容易，我再跟你说一遍，一个堆特别大，这个文件就在我的机器上分析起来，一天可能都分析不完，我们曾经有一个小伙伴儿。

嗯是什么vip的学员，他是那个鸡肉，昨天我我我聊过我，我跟大家聊过，他一个对帧数文件下来，他们平分f g c，他们的办法就是重启一一直不停的重启，后来他们受不了了，说必须得把这事给解决了，然后我就说呢。

等他那个宕机之后，你一定要把那个当铺文件给我拿下来，结果呢他就把大剑拿下来了，那个弹幕文件多大了十个g，然后我教他怎么怎么样进行分析，然后呢第二天我再问他分析完了没有，他说还没执行完呢，哈哈，所以。

这段文件特别大，个的时候，你是很难很难做对他所分析的啊，我看这里呃，这是生成了一个概要吧，这就不多说了啊，好看这个lay这个图你就会发现已经从这就能看出来它的big dino，它的实力数特别大，特别多。

大小呢占了多少的内存，在这里都有显示date有多少个实例，16万个什么eagger lamba表达式，cut infer一堆，所以只要这个图一出现，你就会知道哦，哪些个类占的实在是太多了。

这个分析就很容易分析了，但文件不能限制大小吗，但文件是你的内存的堆内存里边全部给你导出来，那你堆内存多大，你当文件就得多大呀，但是我说的是那个堆内存里面占了多大吗，实例数它最好玩的，还有一个什么呢。

还有一个这个q l控制台，哎这是很好玩的一件事情，就是你完全可以通过类似于一条sql语句的东西去来查询这些个实力，我想想那个命令还记不记得你，比如说我的。

我要查里边的各种各样的string类型的那些实例，每个实例都都什么样子给我拿出来，select nbm，再挖点儿，慢点儿，spring s看是不是这样子写的啊，唉对看到了吗。

就是那个哎把你的这个string类型的各个实力全给你救出来，它是位于哪个类里面的好，这个实例里面是一个什么情况，它里面的那个属性是什么，值是什么，你怀疑哪个实力不对，你就点进去看。

这是你有了堆专属文件的一个好处，就是你可以用更先进的工具图形化的这一类的诶，来看它里边的内容。

好了，这专程文件怎么分析，大概的一个过程该到了吧，网上很多讲那个用mt的啊，那个没什么没什么先进的，我不知道为什么有很多人用mt啊，不知道为啥比jvm不比这vo vm也没有强到哪去。

其实最好的工具是叫做j profiler，不过这哥们儿收费的好像还挺贵的，所以我不太清楚网上为什么很多人讲mt啊，你可以完全可以不用，好那好，现在的问题就来了。

我到底能不能够随时的就把这个堆可以导出一个，导成一个文件导出来，在生产环境里头能不能这么干，绝大多数情况下是不被允许的，除非你们说你们整个的服务器是可以被暂停的，如果是那样的话不行。

是其他情况肯定都不行啊，你不能说淘宝这边在对外卖货呢，这边订单还在跑着呢，你直接一个j map或者一个hipdp，直接就把那个堆给干暂停了，你这边有整个暂停了，暂停在干嘛，不停的往外倒数据。

十个g32 个g，刚才有同学是19个g多少，多长时间，半个小时以上，这事儿你能这么干吗，所以你要跟面试官讲说。

我是把这个堆专属文件给导出来的，大哥你一定要圆过去，怎么圆过去啊，有几个说法可以说，最专业的是很多服务器做备份的是高可用的，你听到这台服务器对其他服务器是不影响的啊，这时候呢你需要架构的知识。

需要了解高考用的这种配置好，接下来设定了he dump on out of memory error，就我刚才说了那个东西是什么呢，那个东西是一旦产生了om之后，会自动产生对转头文件好。

这个可以说就是它确实产生om了，但是我告诉你，这个说法呢并不是非常的专业，中小公司你可以这么聊，大公司，你说oom了才会产生对专属文件，别扯所有的都有监控，他都监控到你内存在不断增长了。

马上就会告诉你有问题了，你这个时候还等他o o m呀，不是很专业，但是可以说，因为，多有，内存增长，就会破掉，但是中小型公司可以说你们中小型公司没有监控啊，没关系，o o m了之后，他才他才报警了。

这个可以，这个没有问题，我看这里在线定位，推荐大家用office进行在线定位，你怀疑哪个类，哪个哪个程序有问题了，去观察他方法的执行情况，去观察它整个那个类的各种各样的一些信息，去观察它的代码。

还有什么你在测试环境中压测，这个也可以说，你说呢你观察到了它的om，就是它内存在不断增长，但是我没有定位出来在哪，我们生产环境中又又不能够随便停，我这时候怎么办呢，我把同样的程序部署到一个服务器上。

然后呢我在测试环境中对它进行压测，压测之中发现它的内存确实在不断增长，这个时候我可以把它导出来，这是没问题了，好了，今天在听的有面试官吗，用什么做颜色，jmeter run runner。

面试官可以撤了啊，拜拜，好几种说法都可以聊好吧。

至少你让面试官知道啊，你去了解这个命令，那么大家听我说，在你生产环境之中，你怀疑一个代码有问题的时候看这里，又死了，先把屁股掉，p2310 ，好再跑下来，我们再把othy，好在过了之后呢，还有一个命令。

这个命令呢它是ars的王炸，很牛啊，这个命令超牛，这个命令是什么呢，这个命令就叫做j a d，第2j a d啊，你看看这描述是什么东西呢，叫the compleclass，这个很简单。

就是来给他干嘛的呢，做反编译，cad呢其实原来是一个工具的名称啊，他后来用了这个名字了，所以原来那个g a d呢是一个也是一个反编译工具，现在呢其实大家应该都知道啊，就是java自带都有反编译。

jav杠p就可以啊，java p就可以呃，它为什么在自带一个反编译的功能呢，这是为什么呢，我们先来看这个反编译功能是干嘛的，呃比如说我们还是，要么名称啊等等类的名称把拿下来复制，然后呢。

后面跟我们类的名称粘贴回车，诶你会发现他干了一件什么事呢，他把这个代码全给你列出来了，看到了吧，那有同学就会说了，说大哥你在搞笑呢，这代码我自己都有啊，我还用它在g a d在那列出来好，你说是不是啊。

同学们来有这个问题，同学给老师扣二，凡是扣二的都是在小p公司工作了，做的都是小p项目，为什么呢，因为大项目你一般用不上，大项目没大项目才能用得上啊，sorry，大项目才能用得上哎这是什么意思呢，同学们。

你们想想看，作为一个超级大型的项目来说，你部署到生产环境的话，你本身就会有好多好多的程序，好多程序员拿着好多的程序网上部署，而且呢我告诉你，你写的程序很可能被其他人所依赖。

也许你在这个把自己的新版本扔上去之后，结果呢其他人在网上那个什么的时候，get get get往上往上传的时候，他很可能直接把你原来那个那个老老的版本，把你现在这个版本就覆盖成老的了，push的时候啊。

对所以你，版本follow了，版本不对了，那么你现在运行的到底叫的是哪个版本啊，这时候怎么办，好用这个命令来观察你到底是哪个版本，git覆盖对大家听听懂这个意思了吗，尤其是做中小型公司小p项目的同学。

所以这个命令还是很牛的。

那我跟你讲啊，这个g的覆盖代码这件事是经常发生的。

gto是杠f嘛，是吧嗯，一个一个f管你乱七八糟的，直接就给你干掉再说，还有这个代码里头不写注释的这种，给你查一个新闻，看能不能找出来。

好玩的呢，突然想起来了啊，你咋回事，美国成员枪杀同事，来自己看看，一名成员拿一把伴奏手枪，周平四门，四名同学开火。

是因为这个程序员不写注释，不遵循驼峰规则，括号换行还天天的gto，是gf激怒了行凶者。

哈哈哈，不知道真的假的啊，就聊天聊着玩哈，应该应该是假的，开玩笑的，哈哈哈，ok ok ok好知道这两种回事就行了啊，嗯嗯同时连锁定都没有是吗，没事中国没枪，ok好不多说了，好回来回来回来回来。

所以这个命令是直接可以直a d，但是只有这个命令的话，我告诉你还不算牛，你这你你们自己想想看，我就算查出来这个代码，这个代码其中有bug，我能怎么办呀，他已经上线了，哎同学们，你们平时你们自己写个项目。

然后部署到生产环境之后，里边确实有bug了，你们怎么办，你告诉我你们怎么办，你是不是把这个代码本地改好，重新编译好，编译好之后呢，再布置上去，是这样的吗，同学们没错，打补丁哎，重新上，换下去，回滚对。

系列 1：P18：马士兵深入浅出java虚拟机⑧用jstack定位问题线程 - 马士兵官方号 - BV1mu411r78p

要回滚没错，回滚到回滚到上呃，上一个运行环境去啊，替换等等，但是所有人要是有人要是说说，我自己写个代码，马上把原来那个代码给他替换掉的，凡是这样的，全是中小公司小p项目，唉我告诉你。

大公司的这个事儿是不允许干的，你已经上线了，你还能随便的把服务器停掉，然后在部署上好多好多的部门，协调好的这些个程序上去，你在开玩笑呢，你知道大型公司一次性的部署，要花多长时间。

预备要预备一星期往上部署要花一两天，所以那里有提供了这个功能，这个功能叫做refine，诶，又死了，不会吧，还没死，这个功能叫什么，叫redefine，refine，refine什么意思啊。

refine的意思相当简单，就是你直接在内存里头，把那个源码给改过来，然后编译好又放回内存，不惊动线下的代码，演示一下好不好，内存里直接改代码对，当然这个是应急性的操作。

不是说所有的正规的操作都是这么干的，这是应急性的啊，应急我明天马上就要双11了，今天发现了一个代码，有一行写错了，本来应该是个二，要写成三的，给我给写错了，我的我的折扣要打0。99折，哎。

里边写了一个0。01折，完蛋了，我要是现在下线不行不行，不方便，那我就现在我我怎么办啊，应急用的记住了吗，所以不要太过于去苛求它，这是应急用的，我给你演示一下啊，大家看这个小程序。

我这里有一个小程序叫t4 点java，这小程序特别简单，我觉得我就不用我解释了，有一个m方法打印一个二出来，就这么简单没了，然后我还有一个小程序叫t。java，自己看，我在这个t。

java里头一个main方法，这个may方法里头不断循环，循环的时候在干嘛呢，cpdinner read，我读一个字符进来的时候，我就new一个tt调用一下他m方法，小人太简单了，就想起来这个t，回中。

但是我回一下车，他就输出一个二，我回家之后再输出一个二，回下车后他输出一个二，好这小程序到现在能理解吧，来get到同学给老师扣一小程序，很简单，就是我们扔了一个二上去，现在呢我现在上了线之后。

我发现这个二写错了，我要重新编译，再往上传，我的整个项目组，是不允许你这么重新发布的，不可以，那怎么办，我想在线的直接就把它改成，把这个二改成一，可以不可以呢，可以怎么干，这么干，原来tp点燃了。

首先你把这t点加了这个二，先改成一，改成一分半，最初叫做ca tt，转成好，编译好了，大家注意啊，这个时候是什么情况呢，你们要理解，现在有一个程序已经上线了，这个程序叫tt，这个tt里面输出的是一个二。

后来我发现这个二有问题，我现在在线下，我改了一份新的代码，这个叫tt。class，在这个t件class里面，我把它改成一了，现在我直接要把它替换掉，在不停整个服务器的情况下，直接把它给替换掉。

听清楚这个流程了吧，来听清楚同学给老师扣一，这里面其实呢如果稍微往深里讲一些的话，大家知道任何一个类呢，在jvm里面都是被class loader给漏进去的。

在指标里面可以用各种各样的class loader，给load进去，class loader，如果你听过老师课，老师是讲过class loader，怎么样自己重新定义自己的class loader。

它里面有一个方法叫什么呢，叫define，这个define的方法呢，其实你自己去读一下，就是把一个一对字节数组，给它翻译成一个类，给它定义成一个类，一个对象啊，一个类，所以我们现在要干这么一件事。

就调用在阿瑟斯里面调这个命令，其中一我在os里面调这个命令，调什么命令呢，叫re design，重新定义，重新定义是重新定义每个class root。tt的class。

我把这个新的class扔到内存里替换掉，原来那老的回车好看，这里redefine success已经成了，我回到原来这个界面去敲回车，看见了吗，这程序我可没停，直接变一了，好这是阿萨德干的事儿。

还是挺牛的，这是临时的补bug用的，那以前有同学抬杠说，老师这个里边你你要是错了，十处十个文件的100个文件全错了吗，大哥您100个文件全错了，那你还不重新发布啊，你还在线还真在线改啊。

还有同学说老师我改完这个代码之后，那老的版本还是还是有问题的，那怎么办，大集群怎么办，大集群你就不能同时替换呀，写一个脚本直接就同时替换了，没有问题的啊，不要认为大清军干不了，你直接替换掉一个类啊。

类似于热部署，热部署，你是要把那个项目停掉，再部署上去，再启动那个项目，这个是直接类级别的热部署，可以这么来理解，当然这里面呢它有一些个限制，就是有什么限制呢，你不能够修改属性，你说这个类里面有个属性。

这属性原来叫m，你给他给他删了，还这不行，你给他加一个，这也不行，现在这个这个版本不行，据说阿斯下个版本要把这事儿给加上，你给你添加了属性可以没关系，凡是涉及到的我都给他改完，你把这属性删了。

其他代码牵扯到的我都给你改的机会，据说要这么干，但是我还没见着，还有一个不能干，你不能改方法名，你说原来的m这方法叫m，你非得改成叫美眉不行不可以，为什么，因为有别的类也用到了这方法了。

人家直接调的就是m，不过据说下个版本也可以，行不行不行了好吧，这个类正在被调用，会出现什么现象，原来从二变成一了，你跟正跟着打折，刷了个0。9000。01折，你正真的美呢，一下单的时候啵变成0。99了。

这酸爽，ok，关于艾克斯，我就就讲到这里了，好不好，我们就聊到这里，呃更详细的一些其他的功能的话，大家自己去翻吧，我觉得一个工具的话，那我教给你最主要的就可以了。

而且工具这个东西没什么可教的，自学都能搞得定的东西，对不对，我主要教教你他的思想在哪里啊，他能干一些什么样的事情，那么到现在为止，我觉得你的简历上应该是可以写这件事了，不知道你们敢不敢是哪件事呢，就是。

诶跑哪去了，这件事不知道大家敢不敢写，给大家演示了，反正就是我在项目之中有过调优的实际经，验，定位jvm的这种o m的溢出，这种经验，这边是调优实战经验，可以写了吗，敢敢不敢写，好同学们，听我说。

作为一份简历来说，有的人水平是100，他敢写80哇，太牛了，任何人去面试的，你放心，因为他水平100，问你80，他就写80，大多数人问他就是80的问题，顶多问你90 100的问题好，这个时候我靠。

太牛了，他居然肯定能肯定能拿下这份岗位，这份岗位月薪25000，但是很不幸的是，这哥们本来值3万，知道吧，结果他拿了2万吧，他自己还很美好，水平就2万的水平，60写80 十个减十个，十次面试挂了八次。

这个呢是十次面试成了八次诶，这个是十次面试挂了八次好，最后成了两次，这两次拿到25000来，同学们告诉我一下，你说谁亏了，唉醍醐灌顶对吧，你为什么有的人报名了两天，他就涨了2000块钱。

为什么有的人经过我们批完面批，批完他的简历啊，他就直接涨2000块钱，你现在是不是有那么点感觉了。

好我看刚才有同学说了，说老师不是有十个案例吗，对是有十个a你自己去体会好不好，就别让我在这儿从头到尾的讲给你听了，案例汇总一堆啊，我给你讲个比较好玩儿的吗。

面试官不给面试官不给面试官看，我跟你讲比较好玩的好不好，来看这里，讲一个比较好玩的诶，这好玩的是什么呢。

这是实际当中确实发生过的，而且这家公司叫小米，这家公司有一批城有20c加加的，然后由于呢他们项目转了java，所以他们呢从c过来写java，他们写完java之后产生了频繁的g，产生了内存的溢出。

听懂了吗，那为什么，原因是什么，好你们仔细仔细思考一下，他干了这么一件事儿，他重写了类的finalize，final finalize方法，大家知道那里面有一个方法叫finalize，finalize。

有印象吗，大家知道java程序员都知道那个类，那个方法是不建议你重写它的，对不对，唉结果呢ci成员就把它重写了，第一个我问你第一个问题，第一个问题，为什么c加加乘以r会重写finalize，为什么y。

原因是什么对因为c加加是乘员，他们写惯了手动释放内存，手动释放内存，你要delete掉，要在你的类里面写析构函数，就是那个函数啊，小小小波浪线加一个名字，而他们认为java里面应该有一个函数。

也是析构函数，看到了finalize，欣喜若狂，我靠终于有析构函数了，攻击给它写进去，既然是虚构，我肯定要释放资源，在里面释放各种各样的文件，打开的内容啊，啊什么各种各样锁呀，各种各样的数据库的连接呀。

好全全放到这里头去，接下来你们自己想想看，本来这个finalize呢一个垃圾回收器，回收这个垃圾的时候，他要执行这个方法的，这方法执行的时候本来不费什么时间，结果它里边放了一大堆费时间的东西。

本来的一个对象我要回收的时候一个毫秒，结果他放了这么一堆东西之后呢，十秒钟才能回收一对象，但有点夸张，然后你内存肯定会越来越多，你分配对象速度又比较快，内存很快就占满了，这是它产生溢出的原因。

好不知道大家听清楚没有，这是实际当中有人犯过这种错误的，当然你如果还不知道，你如果还不知道面试官怎么说，你就写一最土的，你说我我有一个同事，你千万别说你自己他写了一个类似的，然后他就不断的往里装装内容。

他不释放，唉，这个可以吧，当然谁写这么土的代码啊，哈哈哈哈，当然我就不说了啊，十个案例你自己挑，自己去挑，都是相对土一些的案例啊，还有十个案例是给vip准备的，我就不说了，o，那么到现在为止呢。

没人问问你们能不called the review吗，called the review，另外一个同事，他比较睡得昏昏沉沉的啊，眼眼迷迷瞪瞪的，code review，没有review过，有什么关系吗。

好，呃其实到现在为止呢，实战部分内容呢，就大体的非常粗的一个流程，我就我就给大家讲完了，呃我们简单的稍微的回顾一下啊，这份文档的内容比较多，我只是挑了其中的比较粗的流程，来讲给大家听的。

但是至少我觉得你到现在为止，应该是有这样的一个收获，第一你弄明白了，原来垃圾会说其实有很多种，第二你调优的时候，一定是针对某种垃圾回收器回回收调优的，第3o o m的问题。

你至少应该知道用什么样的工具去定位它，面试官问到你的时候，你用什么样的说法去说服面试，官好有这方面收获的同学给老师扣一，这个文档会发吗，会的没有问题啊，那我下面讲一点比较难的，我就不讲女的了，好吧。

我讲一点比较难的，这个比较难的问题呢，呃目前面试官问的还不多，但是今天有面试官在场，所以他们可能就会问了，那这个比较难的问题是什么呢，这个比较难的问题是我昨天讲ccm的时候，有同学已经特别感兴趣了。

问了我好几遍了，追问了好几遍，说老师这个c m c m s里面不说cms里面，不是说我的工作线程和我的垃圾回收线程，是同时进行的，对不对啊，三色标记，我的工作线程和垃圾回收线程，是同时进行的。

那么我垃圾回收线程，在回收这个对象的时候，很可能被工作线程，又又把这个对象变成不是垃圾了，那这种情况怎么进行处理，目前也只有美团问到过这个问题，括阿里也没有问到好，如果说到这一点的话。

你能够说的偷偷彻彻详详细细的，那么肯定会，得高分啊，非常高的分啊，当然对不起啊，应该是也问到过，因为他这个问题呢问的不是特别直接，就是关于这类的问题，我给你看一眼啊。

呃其实这一类的问题，这类的问题呢都是比较难的，讲一个最熟悉的来就会说算法，那么你如果你讲三色标记，我去这就牛了啊，你要讲一个最熟悉的，讲一个什么拷贝，那那太简单了，还有一个其实还有一个。

我记得有一个问题是问的什么呢，就是呃，你能不能把cms和g一的这个垃圾回收算法，你你给我，你给我说一下，忘了是哪个公司问的了，就是凡是问到这一类的问题的，都是超难的，还有一个就是这一类比较葛的问题。

某个有病的企业，某个有病的面试官，就说用一句话证明你这个水平很牛，我就教他嘛，我说十种垃圾回收器，所有算法都明白，我靠太牛了，十种垃圾回收器所有算法全明白。

好吧算你狠好，估计除了老师之外，没有人敢这么说，哈哈哈哈好，下面我们讲可以加高分的这样的一个算法，好，大家看这里，嗯就是强软弱虚指针打开错误。

唉呀为了给大家讲清楚，这个专门给大家画了一个动画，动画画起来很难演示，三分钟就演示完了，好首先请大家记住这个名字，这个算法的名称叫做三色标记，好看这里三色标记，三色标记是什么概念，这是我们首先定义啊。

这个三色标记呢，就是当垃圾回收器去标记那些个对象的时，候，他得把那个对象给标出来，哪个是垃圾，哪个不是垃圾啊，这个垃圾这个飞垃圾，这个垃圾这个飞垃圾好，他得干这件事，得识别出来，那么它到底怎么实现的呢。

在尤其是这种并发级别实现，如果是那种不是并发的，说你所有的工作线程你都给我停了啊，一边给我待着去，那就随便标了对吧，每个对象还是怕他找就行了，找出来的全都不是垃圾，没找着的全都是垃圾，这就是最简单的。

但是实际当中现在的这个需求是什么，现在需求是你一边干活儿，我一边标识，那肯定会有标错的情况，这是肯定的，我们再来我们看它实际当中是怎么实现的，这种情况呢叫做三色标记，三色标记是什么概念。

首先第一点先认清楚这个概念，它会把对象在逻辑上分成三种颜色，三种颜色其实对象不是真正的一个颜色，对象全是零一了，它有一个标记位啊，你说零一代表就是黑的啊，一零代表就是灰的，零零代表就是白的等等。

就是干这个使的，那三色标记是什么，一个什么概念的逻辑概念，它分成三种类型的对象，哪哪三种，黑色的，灰色的，白色的，黑白灰三种，黑白灰三种的概念是什么，就是我在找到这个对象了，我找这个对象。

但是呢我还没有识别它，它到底是不是垃圾，我还没有识别它，我们说还没有对这个对象做标记好，这种对象称之为白色对象，好我又找到了一个对象，这个对象呢我已经识别了这个对象了，它不是垃圾，确认它已经不是垃圾了。

而且呢我确认它不是垃圾之后呢，我得顺着这个对象的成员变量去，顺着往下找，但是我还没有进行这一步，我还没有找它的成员变量，到底它是不是垃圾，成员变量指向这些对象到底是不是垃圾，我还没有找到这步，好。

这个叫灰色的，如果我找到一个对象，这个对象我已经确认它不是垃圾，并且它的成员变量我也找完了，这两个变量我也就标出来了，这两个变量找出来了，标完了，是灰色的还是白色的，全都标完了，这种的叫做黑色。

黑色对象叫黑白灰，黑的叫什么，自己标完了，儿子也标完了，这个叫做黑色，灰的叫什么，灰的叫自己标，完了指向的对象还没有标，这个叫灰色，好没有标到的对象叫白色，黑白灰，来理解的同学给老师扣一。

好这叫三色标记，那么假如说我们在整个的整个我们程序，我们g y m的线程，也就是我们垃圾回收线程，在回收的过程是做标记的过程之中，我已经标成了a啊，确实是黑色的了，b是灰色的，他的b的孩子还没有标好。

在这种情况之下，突然之间我们整个应用程序，因为应用程序也是在不断的运行的，它用运行的过程之中呢，他把b指向d的这个引用给消失了，就转成一个什么电视没了，假如发生这样一种情况，b指向d的引用消失，同学们。

你们想一下，注意啊，这个d还没有被标注呢，没，有被标注，同学们，你们这样想一下会不会产生问题，这种情况会不会产生问题，仔细想想，因为这里头相对难一些，全是算法，全是抽象的问题，会产生问题吗。

其实是不会的，唉为什么呢，为什么不会呢，因为这个东西呢叫做floating garbage，咱们的这个垃圾回收啊，它是一轮一轮的，还记得那个可中断垃圾回收吗，没处理吗，哎他是一轮一轮的一轮一轮进行。

我这轮儿标到这儿之后，然后没有把你这个地给你找出来，因为刚才你还连着呢，但是呢下一轮来了之后，我就找不着你这个d了，你这个d就变成垃，圾了我就把你给清了，所以没有关系，这是一个浮动垃圾。

浮动垃圾的意思就是诶这轮没把它给干掉，下一轮再把它给干掉，让你多活一小会儿，所以这个没事儿，这种情况下是没有任何关系的，好刚才这小段听明白了，给老师扣一，就是说他可以他早晚被清掉。

只是早一会儿晚一会儿的问题，有一种问题是什么问题呢，看这种这种就比较麻烦了，这种情况是这样的，你仔细看，假如在被垃圾回收的过程之中，标了a和ba是黑，b是灰，还没有标到d在这个过程之中。

另外我们的工作线程干了一，件事他把b指向d的引用给弄没了，与此同时a有一个引用指向d了，再看一遍，这两个是都是必要的条件啊，b指向的d的已经没了，与此同时a指向d了，看到了吗，这时候会产生什么现象。

来仔细看一眼，同学们，你们想一下a的颜色是什么颜色，a的颜色是黑色，黑色代表什么，黑色代表已经标记完了，那下一轮垃圾回收器在进行的时候，下一轮来的时候，它还会标记这个a下面的成员变量吗，还会标记吗。

不会了，结果这哥们儿就被回收了，知道吧，因为呢，垃圾回收器已经认为，没有任何引用指向性了，因为我不再会去找a下面的成员变量了，与此同时，所有指向你的其他的那些引用也都没了，再看一眼，这就是问题的所在。

只有在这种情况下好，它会产生问题，它就会产生漏标，漏标就会产生内存泄漏，b指向d的应用没了，同时增，同时a指向d的引用增加了一个，b b没关系啊，b是灰色的，如果那就b没关系啊，b它是不是灰色的吗。

灰色的，我下一次来的时候，还是要去找他的孩子们的，对不对，他的孩子没有必要呢，结果他现在孩子这个孩子已经没了，他可能有别的孩子，如果有的话，那就直接去找，如果没有的话，就把它变成黑色了。

这哥们儿就成黑了，黑的就可以直接回就可就就是弄完了，已经结束了，好了，好这个过程大家听明白了，对不对，注意还没完啊，因为这个这个里边算法特别深，我得一步一步确认，你们都明白了。

就是说灰的纸箱白的也就没了，黑的增加了一个，由于黑的已经不再被扫描他的孩子，所以这个地不会被扫描到了，再出问题了，ok我们继续可以继续同学给老师扣一，为何a添加了指向d。

那a里面有个成员变量a点小a等于d，这不很正常吗，你写这么一个代码不就完了吗，正好执行这段代码吗，这种问题还卡嗯，不对啊，喝口水，为什么执行力因为业务逻辑变了，业务逻辑在运行，你自己写代码的时候。

会不会写你自己写代码的时候，会不会写这种代码，a。b等于new什么，或者等于某list里面get什么，会不会写，好看这里，我们现在要解决这个问题，要解决这个问题怎么办，解决这个问题有两种方案。

认真听这两种方案，好第一种方案，第一种方案就是c m s的解决方案，c盘解决方案就是叫他的名字叫什么呢，叫做incremental update，所以听我说，三色标记是一种中性词，三色标记会产生问题。

cms，对于三次标题解决问题的方案，叫做incremental update，好什么意思，看他是怎么解决的，他是这么来干的，b指向d的，没了，a指向d的诞生了，好这个时候干了一件什么事呢。

他就把a标成灰色，就干这么一件事儿，很简单，那么下一轮我们的垃圾回收器，再来下一轮的时候，它会扫灰色的，因为灰色的还没他的孩子们还没扫完呢，所以他肯定会把灰色的都扫一遍，就这么简单搞定了，非常直观好。

这就是cms，对于三色标记算法的一个改进方案啊，一个更正方案叫做incremental update，搞定了，那他是怎么让黑色变成灰色，我的妈呀，你想气死我是吗。

系列 1：P19：马士兵深入浅出java虚拟机⑨手动实战 - 马士兵官方号 - BV1mu411r78p

就问这种特别触及问题的，我只能认为你的基础确实特别差，我就稍微照顾照顾你，首先黑白灰是一个逻辑裸机上的概念，并不是他那个你打开电脑，它里边真的有黑色对象，比如说它有一个标志位。

这个标志位写的零一就代表黑色，这个标志位写的一零就代表灰色，写的零零就代表白色，到这里能get到吧，怎么把黑色，把黑色变成白色，你就把零一改成一零不就完了吗，气死我，好啊，朋友也不能回答。

因为所有人都是从小白过来的啊，刚才那个小白你也不用怕老师怼了，越被老师怼的人成长越快，所以怼两下又怎么了，不就丢点人吗，谁也不认识他，对不对，那个人叫什么，你们还能看，你们还能找得出来吗。

你就找不出来人名了，都所以他丢人就丢了，也就丢到了这个小小的直播间，这有什么不能承受的，别问了，再问一遍，老师生气了，受不了了，要炸了，黑色的不会再扫描，因为黑色已经扫描过了，不是所有黑色的标记成灰色。

只有新的黑色的诞生了，指向了新的对象，有新的对象指向的时候，这个时候说明它产生了新的引用，这个黑色的就得变成灰色的了，灰色的在下一轮的时候要重新扫描，黑色的已经被扫描过了，ok看这里，这怎么完成的。

它叫做right barrier，叫写屏障，咱们先把它略过吧，那个真的有点稍难了啊，我们先把主干讲清楚，注意看incremental，实际上它有一个非常隐蔽的问题，incremental update。

由于这个方案特别简单，但实际上这个方案呢会有特别隐蔽的问题，看你能不能听听得懂，认真听啊，在并发标记的时候依然会产生漏标，what它把它变成灰色的了，居然还会产生漏标，原因是什么呢。

变成黑色的下轮就不再不再扫描了，变成灰色的下轮会继续扫描啊，我看这里为什么会产生呢，a里面，如果这时候a有两个成员变量，我分别用一和二来指代它，这个时候呢一这个成员变量指向了d。

大家都知道a要变成灰色好，a要变成规则，这个比较简单，但这个时候啊，你假如有另外一个线程，这个线程是什么呢，哎有人来就会说线程垃圾回收线程在这轮是并发的，会有好多个垃圾回收线程。

那么这个垃圾回收线程干了一件什么事呢，他正在标记这个，a呢这标题这个a标记到哪，标到什么程度呢，已经把这个一给标完了，注意它已经标完了的情况，已经标完了，然后正标那个属性二呢这个属性二指向某一个对象。

正在标这个在这个过程之中，在这个过程之中，注意一已经标完了，接下来标完了之后，又指向了这个白对象，被一个线程给标，把这个一标完了，标完了之后又指向了一个白对象。

就是另外一个另外一个线程把属性一又执行了白色对象，这个线程已经把a的属性一给标完了，哎但是呢另外一个线程又把这个一给指向了一个白色对象，然后呢另外一个线程把a标成灰色，那就会出现成标成灰色，为什么。

因为它指向白色对象了嘛，所以把它变成灰色，然后这个县城原来标这个现状，他继续，因为他标完一了，他马上又标完二了，把二标完了之后，唉又把它变成黑色了，因为他这个县城认为一个对象已经标完了，我把一也标完了。

我我把二也标完了，这个线程肯定会认为这哥们儿已经是变成黑的了，对不对，他实际上不知道，在他把一标完的这个过程之中，另外的这个一指向了一个白的，然后呢它已经变灰了。

结果呢他二话不说又把它给变成变回是纯黑色了，一个二什么成员变量，好这段没听懂就算了，好不好，有点绕，对于有经验的小伙能听懂，对于没经验小伙呢都走不走，没关系啊，呃这种问题也没人问，听懂了吗。

没有面试官问，放心啊，没有人面试官问这个面试官问他主要问什么问题，就说incremental update，为什么cm里面用，为什么g一里面不用这种解决方案了，原因就在于这儿。

因为它依然会产生漏标的问题，而在cms，cm呢他自己也知道它会产生楼标的问题，所以在cm s的最后的remark阶段，在这个阶段应该得从头把那个什么的都扫描一遍，当然由于它进行了一些个清理了。

所以这个扫描的过程呢没那么复杂啊，比原来那个简单很多好，所以他的s t w时间就没有那么长，但是如果你的内存越来越大的时候，这个阶段它依然时间会慢慢的变得非常长。

所以cms incremental update这个解决方案已经被close了，这个解决方案不再存在价值了，cms也在1。9之后被踢出去了，cm这个东西已经过时了，我这么直接讲，大家能理，解了吧，那好。

啊下面我们来看g一的解决方案，还讲了太难了，就讲到这儿吧，要不然好不好，讲完级我们就不讲，不讲那个cdc了啊，cdc有十十个阶段，那个太难了，要讲完，咱今天晚上就别睡觉了啊，好看这里啊。

积累解决方案是什么，积极的解决方案叫做i s a t b，所以请大家记住几个名词，你跟面试官聊天，名词越多，面试官越蒙，三色标记，incremental update s t b。

snapshot at the beginning，snapshot，快照at the beginning，刚开始的时候来个快照，这个呢呃这个这个这个解决方案相对就简也也比较简单，他是怎么干的呢。

他干脆就没有给a和d，就没没没在这种a指向d的这个引用上啊，这个指针上没在这上面考虑问题，他考，虑的是哪个呢，他考虑的是b指向地消失的这部分，这个指针b指向d消失了。

就是说有可能你指向d的这个东西再也不会被扫描掉了，我只要保证这个地被扫描到就可以，所以呢它采用了一种解决简单的解决方案，这种简单的解决方案是什么呢，是这个，其实指的是做个快照，当b和d消失的时候。

把这个指针注意是把这个指针给保存一下，保存到哪里去，能保存到一个站里面去，我不管你这个d有没有被别人指向，没有关系，我只需要在下次扫描的时候，我能扫描到你这个d就行了，我看你这个d有没有被别人。

有没有被别人指向，你不就行了吗，好了，这个时候呢就把这个指针放到里面去，下一轮扫描的时候呢，就要看这个里面有没有被放进去的指针呀，那么如果有的话，把它拿出来，把这个对象拿出来之后重新扫描一下。

看看这个对象有没有人指向他，如果没有人指向他，他就是垃圾了，如果有人指向他好，他就还不是垃圾，ok这个叫snapshot at the beginning，当然这里面更深的一些个理论呢就非常多了。

为什么这一会采用这种方案，因为这一点有概念叫remember set，remember that，配合这种方式配合起来特别方便，由于而且你原来有个快照，你有这个快照的时候。

你可以用那个快照里面最根儿上那些个那那些个，那那那些个只扫描对头上那几个就可以了，所以它这个效率特别高，remember set是另外一个概念，我要给你讲remember set，还得给你讲，card。

还得给你讲card table没法讲啊，这这到这吧好吧，不讲没，这真没完了，怎么被引用，扫描到自己就被引用了，这就是remember that干的事儿，ok但是我告诉你，在不久的将来。

所有关系这些个问题全都没了，不用了，所以有的时候我讲那些呢也没什么意思，但是不管怎么样，他还能撑几年好不好，所以听不懂也就听不懂了，过去也就过去了，只要你能坚持过这几年去，因为什么呢。

因为在z d c里面，它采用了更加牛叉的解决方案，这种牛叉的解决方案叫做color pointers，叫颜色指针，这个颜色指针说到这儿，我就简单给大家入个小门，颜色指针是什么概念。

其实大家知道一个java指针，64位，在16四六十四个比特里头，他把这个指针里边的内容做了一个划分，划分怎么划分的呢，真正的只有42位的指针是指向java对象的，有18位是没有用的。

42+18已经60好，其中的四位拿出来做一个状态，区分状态区分什么意思，就是当我引用到这个指针的时候，我要检查这思维的状态，看看这四位是在哪种状态之下，我要做相应的操作。

哎你比如说你是在正在移动的过程之中，你垃圾回收器要移动，你移动的过程之中，我现在也用到你了，我去检查你这个指针，发现你在移动的过程之中，ok那我就稍微等一下，等你移动完了之后，我再用你。

我再用你里边的内容，唉，如果说我现在引用的这个指针，他现在状的没，有多没有动，没有关系，我我就直接拿过来用，好了，这个叫做颜色指针，当然这里面涉及的概念那就更多了。

它会涉及到操作系统的关于内存映射的概念，再说啊咱们再说嗯，嗯有一个非常简单的面试题，叫做为什么z dc管理4t的内存不是4g是四个t，为什么呀，为什么他是四个t，看到二的42次方等于四个t o。

怎么叫移动中，怎么叫移动中，你想象这个指针它指向一个java对象，这个对象还记得我们的region吗，回收它的时候怎么回收啊，这个对象要被挪到另外一个region里拷贝算法吗。

我们记忘了g一分成一个一个的region，cdc也是分成一个一个的region对象存在region里面，回收的时候，按照这个region来回收，怎么会说啊。

把这个活着的对象拷贝到另外一个region里面去，整个region清掉就可以了，拷贝的过程要不要移动对象啊，那这个指针本来指向这里的，现在要把它指向这里了，你这个指针里面要不要动啊，做这个标志位。

那我的程序要用到这个指针啊，我就去读一下这个标志位，哥们儿，你现在在什么状态呀，正在移动中，哎呀正在移动中，那我得小心点儿，等你移动完了之后再用，好来该到同学老师扣一有那么难吗，你自己看就会很难。

老师讲给你听，就没那么难，cdc会指人家说吗，不会他都64位全用上了，你让他怎么压缩大哥4t怎么理解二的42次方啊，他用42位来代表一个真正的对象的地址，二的42次方不就是四个t吗。

老师可以推荐讲的好的g一和cdc算法的文章吗，你自己去找我跟你讲，我找遍了，没有讲，特别好的老师，这讲的还不够好，中国内的讲cdc的，凡是上面的文章你自己去翻啊，基本上没有，现在还没有讲的。

好了今天到这了，不多说了，现在已经9。40介绍我们的课程好吧，嗯今天给大家讲的内容呢是老师讲完第一版的课程中的一小部分，那么这个是哪部分呢，就是这部分，就这m调优案例是两款指导啊，这部分呃，当然了。

我是调了其中的一部分了，本来我是从最根本的概念开始讲，一直讲到最后才是jz和调优呃，我只不过呢把其中的一些个细节全给大家先略过来，教了大家的梗概性的东西呃，主要是给大家讲了调优实战的这部分啊。

就是为什么会频繁，dc到底怎么样进行设定，那么云玩dc怎么办啊等等啊，交了一些时间性的东西，上线之前怎么规划，像这一类的还没有给大家讲过，这是整个课程中的一小部分了，诶哪去了。

当然这里面呢我们课程内容比较多，先给大家简单介绍介绍这个课程，这个课程呢主要是现在呢被我们搞成了一个超级牛叉的一个巨无霸，就是我们课课程现在成长为不知不觉之中成长为巨无霸了。

这为什么我呃少给大家谈一下这个历程，就是我们现在提供什么课程呢，提供现在就是a是java后端工程师，这个是什么呢，是零基础的课程，就是反正基础稍差的，你从a开始学好吧，跟着我赵云山老师。

跟着林老师从a开始学，记住参加工作的有ss sm基础的a是什么，a a就是那个那个，那个线下的时候那个花1万多块钱，15000 6000是吧，给你教教你的东西，就是我们的a课程嗯。

然后呢有sr那么基础的，我们现在推荐的是另外一个格叫做b加c，b加c是什么，b是互联网架构师，c是单数据加构式，就是你刚才看到的这个课程，就这节课这节课呢我们就当从零到年薪百万。

一步一步对标阿里p7 的互联网大数据的声量教师，这些课呢也是我们独创的呃，这个课程呢其实前前后后经历了很多很多的发展，我简单跟大家交代一下，就这个发展呢还是比较比较那啥的，就是比比比较比较各色的呃。

我们的以前是一直做线下培训的，大家也知道啊，呃作为转到线上来之后呢，就一批老师成立了线上的那个公司啊，公司那叫马士兵教育，就是以我名字为命名好，呃，其实除了我之外呢是有一大堆的公司啊。

sorry一大堆一，大堆的我们的呃老师把这个这些老师呢我就不一一的给大家做介绍了，都是在线下很有经验的老师，除了现象很有经验的老师之外呢，其实啊一会儿我可以请这位大哥给大家见个面啊，这是我们特别牛叉的。

也是我的清华的小师弟，是周老师，他是讲那个大数据这方面的，呃，除了我们自己的这种在线下讲了很多年的这种老师之外呢，还有一些呢是在这种企业一线的老师，这个也是很宝贵的，呃。

为什么我们能请到b a t j学校的老师，就是就是你你随便找个培训机构，你说那个b a，t j的老师啊，全都聚齐了，不好意思，你随便找没有，只有这儿有别提高的老师在这全剧情了呃，腾讯的罗老师。

他是原来腾讯新闻的ai的主管，阿里的那个黄老师呃，是原阿里的常老师，是现在在阿里工作的，那么讲我们数据大数据项目的数据中台项目呢，是原来的阿里的中台死结，是一个p 10水平的。

百度的赵老师来跟我们聊推荐系统的这个京东的齐老师呢，我们讲docker cbatis，以及呢现在这个秒杀项目秒杀相比也是在京东落落地的，可是很不幸的是呢，齐老师现在就被隔离了啊，不然的话。

应该已经已经开讲了嗯，就是我在外面呢请了一大堆的老师，因为学生还是比较多的，在各种一线大厂都有，所以找到他们呢并不难，嗯，有一些也不是我学生啦，就是推荐过来的等等啊，就这样呢。

我们就成立了这么一个一大堆的老师，大概有十几位啊，这些老师的水平，清华两位老师，一位伟大的博士后，右边这哥们呢是长去的cpu，他马上要开始了，下周就开始了呃，网游后端的项目的第二版就开始了。

第一版还是广受欢迎的，这主要讲net的这个呃，海宁老师那个原来呢他是想去那边做游戏的，有好几款那个月流水过千万的游戏就是出自于他的手，刚起元帅，我不知道大家听说过没有，还有一个叫什么什么三国志来着。

我忘了啊，哎这位小姐姐呢也是特别牛的，这位小姐姐是留学北美的博士，他主要教他们什么呢，叫他们英语课，后面我和他一块儿教英语，教点英语课，主要因为好多人的英语实在太烂了，有点看不过去了，稍微教一点好呃。

然后呢我们这些人呢大概在2019年的中间，6月份等到腾讯课堂，到腾讯课堂之后呢，大概半年吧，到去年年底的时候，我们已经是在腾讯课堂的课程到了第一名了，我们已经做到第一了，也就用了半年半年左右。

当时是当腾讯课堂的时候是这样的，腾讯课堂呢有很多的已经有很多的人在讲课了，这个他们讲的课呢多数都是什么什么样子的，都是一个一个的知识点，就是类，似于什么呢，类似于张图里面的一个一个的知识点啊。

但我的知识点还是能点进去的，你自己看就行了，对这个对这个有兴趣的，呃一个一个知识点，后来说我们干脆，那那我们也就先找超凡，因为线上到底怎么讲啊，现在也当时也没摸清楚行，那就找超凡，那我们讲知识点。

后来我们就提供了一个第一版的课程，这个课程呢是一个八个月左右的一个知识点的课，然后呢多数人呢都是说每周三次课啊，每次两小时一共讲八个月啊，多数的机构都是这样子，我们当时也，都是这样子。

但是讲着讲着我就发现，因为我个人比较喜欢讲课，周老师比较喜欢讲课，讲着讲着我就发现我课的时间不够用了，我想讲的特别深，比方说我真的想给你讲到cdc的特别详细的算法，我给你讲到这些，你不给我时间。

我是肯定讲不到的，后来说算了，我们扩课程，我们第一次扩展直接就把八个月干到半年到一一，1年半到2年的，我是说按照每周三次课来讲，扩展完这个之后呢，有小伙伴当然很满意了，因为他们当初交钱是按这个来交的。

交完之后呢，我们就免费给扩成这个样子了，他们当然很爽了，但是有的小伙伴呢还是不满意，小伙伴说老师我没有项目经验，想跳槽，从传统行业跳互联网还是跳不了咋办，杨老师，后来老师说，那行吧。

我给你找那个一线的做项目的人来带你做项目好，扩了八个项目，又是免费，就给大家扣了这八个项目，这八个项目呢我觉得我就不一一的给你打开了那个，都是呃就是实际当中运行了的啊，上了线的那样的项目。

你写在简历里头绝对不会丢人，不是那种demo的项目的东西，多人在线即时对战的游戏服务器，吃鸡的后台，大体的架构就是这样的，告诉你和将于这两个呢是只针对于水平稍差一些的，那么商城大家都有。

我们就加一个像网约车项目，完车项目呢是阿里的常老师，他现在已经开始讲第三版了。

好这个项目呢也是我们一个挺好玩的项目，这项目什么项目呢。

这项目什么项目，这个项目是原来啊那个常老师进阿里的时候，对他帮助非常大的一个项目，长沙原来呢也是一个不是特别有名的一个二线互联网的，他在30多岁才进到进到了阿里，进阿里的时候呢，这个项目帮了很大的忙。

然后呢他现在把这个项目分享出来，那么这个项目主要讲什么呢，这个项目其实主要讲分布式微服务的，就是分布式微服务到底怎么落地，他学一个spring cloud，今，天今天学点儿注册，明天学点儿监控。

后天学点儿限流好，总是不会联系，到时候我实际当中到底怎么落地的呀，好这样一个项目让你来进行落地的这样一个项目，好项目的结构图给一给大家看了所有代码，二三十个人写完的代码全都给到你，你不用每个代码都敲完。

读懂就ok了，呃另外讲东西的时候讲到什么程度呢，源码原理，源码原理源码就是基本上所有的点我们都会讲到源码，凡是不嫌我们课程深的，不嫌我们课程宽的，找我们来学，除此之外呢，我们又还有一个项目。

就是这个对于，咱们结构师来说啊，java这边的结构师还有项目就是一级流量，这个项目一流量的项目解决什么问题呢，有什么很大一项目，其实目的呢就是解决你架构师这方向的理论和实践的问题。

就这个项目学校的目标是什么，京东阿里淘宝，天猫12306拼多多，他们这些架构到底怎么玩的一个项目，全让你理解，就是很很很有价值的一个项目，很多那个外面的有一些搞教学的这一个项目就卖你好多好多钱啊。

cp定理到资源的隔离怎么玩，副业服务的限流怎么玩，系统到底怎么样进行扩容和，拆分各种各样的降级方式，分布式事务怎么去落落地，各种各样的网关该怎么设计，客户端的缓存，浏览器的缓存，enginx缓存。

lue rusty rex访问，怎么样去进行register缓存，就多级的缓存该怎么样进行来实践，好高可用，怎么样进行落地，使用什么方式给你编出来好部署到阿里云上，怎么进行部署，好了，这是这个项目。

当然由于我们这是双料架构师，为什么要双料，现在玩儿架构师的，你说一点大数据的知识不懂，太开玩笑了，就没什么竞争力了，还有大数据相关的三个项目推荐系统，这就不说了，但就是说这部分的呃难度在于什么地方呢。

流式计算flink中台项目是阿里p 10的那个中台四节来带大家落地的，做一个中台的落地项目啊，这个秒杀系统呢咱们暂时先等等啊，等等等一下那个什么的呃，齐老师呢，这个这个出来了，从闭关闭关之后出来了。

所以最后就变成什么了呢，最后我们这个整个的课程就变成了一个巨无霸，这个人怎么叫巨无霸了呢，嗯，从八个月开始到18~24个月，再加了八九个项目，就是整个课程就变成了大概是1500个学时左右。

我们从来以前没有算过啊，突然一算，我靠居然居然到1500个学时了，你们知道大多数的人，如果是八个月，每每每周三次，每次两小时，你自己算一下，他们的学识是200个，200个不到192吧。

我们现在学时是多少，1500个，所以这就诞生了一个特别巨大的问题，我到底该怎么教你，我不真的不能让你从1500个学时从零，你一直学完1500个学时才能让你干，点事儿，这个我肯定是不能让你这么来学的。

总结了一下，我们叫它pp教学法，pp教学法的概念叫做project driven，项目驱动，就是我用一一个项目来驱动着，这里面到底有多少，用到了多少个支点啊，有些知识点你掌握住了，那就暂时先放一边。

有些知识点没掌握住后，优先去学这些知识点，一边学项目，一边学知识点，一边学项，目一边学知识点好，大多数的人在3~6个月左右的时候，ok每月至少涨5000好吗，我说的是至少至少涨5000唉。

本来我是说我们原来那个去年培训的学生啊，就是多数人每个人真的涨5000块钱，最少的，我们所有的案例都可以做背调的娘的，今天有一个学生就告诉我啊，我刚开始跟大家说了，说老师我工作了，我说涨了多少钱啊。

涨了2000，破了我们的金身，结果后来我查了一下，今天入职了，现在才多少，17k唉，原来原原原来挣多少，原来挣15k，原来挣15k那个我说他涨了2000，太过分了啊，直接把我们牌子给砸了，后来查了一下。

也是3月16号入的血。

系列 1：P2：JVM瞬间涨薪3K的操作：2.三色标记-并发垃圾回收算法 - 马士兵官方号 - BV1mu411r78p

一个对象产生，它首先是要进入到伊甸园区域的，然后呢经过一次垃圾回收，他没有被回收掉，好进入survivor 1，再经过一次垃圾回收，又没有回收掉，进进入svip 2，再经过垃圾回收，没有回收掉。

又回到swim 1，如果还没回收掉，又回到svip 2，那么当它长到一定年龄之后，进入老年代，这个过程大家能看懂吧，嗯，看明白老师扣个一来嗯，可以介绍一下复制年龄，复制年龄不同的垃圾回收器。

它的年龄默认值是不一样的，你可以设啊，这个年龄没关系的，你可以呃，jvm调优的时候可以对它进行调整，这个随你随你来定好吧，好了呃，当然还有一个更复杂的动画，我在这就不演示了。

主要跟我们讲今天讲的主题呢关系并不大，这里面主要讲了栈上分配啊，形成本地分配的内容，好呃我们回到呃垃圾回收器，那么通过这来看的话呢，我们的不同的垃圾回收器，它工作在不同的分带上。

那么在这个分带你看上去比较复杂，但是我告诉你啊，其实这个分带的垃圾回收器呢，是比较简单的，我呢从这个最古老的垃圾回收期serial开始，然后给你介绍，整个分带的这六种垃圾回收器啊，很快就能给你介绍完。

比较简单，你往这儿看好，大家听我说这个拉丁回收器啊，你看他的名字叫最早的啊，最古老的，从一点开始就有的就是它叫serial，这个呢叫serial old，好，这是什么意思呢，看这里。

那么这个我是原封不动的，摘自oracle所出的官方文档，siri到底是什么东西，他说i stop the world coping collector。

which uses a single gic threat，这是什么意思，你认真听就行了，他说stop the world，stop the world，简称叫s t w这词你给我记住。

stop the world，世界停止，把这词给我记住啊，这词什么意思，简称s t w，就是说当我垃圾收回收期开始干活的时候，所有的业务线程全都停止，这是你，这是你女朋友，这是你男朋友。

你们仨在房间里扔各种各样的小线团儿，这个叫业务逻辑，叫业务线程好，当你扔了一大堆的小线团，触发了我垃圾回收器开始工，作的时候你的妈妈进来来，你们仨给我停到墙角，给我站着去。

这时候叫stop the world，业务线程全部停止，垃圾回收器开始干活，把这些小线头帮你整理一遍，从你根儿上开始给你捋捋捋捋，捋到的所有的小球球全部有用，全部没有捋到的，全部帮你清掉空间。

又被重新的清理了一遍，你们仨就可以继续玩了啊，继续造你的小人儿，ok继续产生你的新对象好吧，在伊甸园区好，当又过了一段时间之后，又又满了又满了，怎么办，好了停止你妈妈又进来停止，该我干活。

ok这个呢就叫做stop the world，好了，这是我，们整个java程序所产生卡顿的巨大原因，就是有的时候你这条程序跑一段时间之后，你发现诶他很卡，跟那那个嘎吱嘎吱响，然后跟他做运算，它在干嘛呢。

大量的垃圾回收过程呃，这个呢对于网站的影响，就是有的时候呢，这个网站呢，他的对于用户的反馈不是很友好啊，你点了一个按钮之后，等半天它才有反馈好了，这东西呢叫做卡顿，ok同学们听我说。

这个s d w的时间是我们调优的，特别关键的一点，就是大多数的人所谓的对于jvm调优，它是不关注吞吐量的，它往往关注的就是s t w的时间，你一定要短，一定要及时的给我的用户做一个反馈。

这块大家能理解吧，唉能理解黑老师课文一来，这是s t w的概念，手机的垃圾回收世界原理嘛差不多类似吧，嗯这糟糕的例子，what这么形象的例子还糟糕好，大家看这里啊。

他说的也serve the world coping collector啊，使用的是那个拷贝算法是吧，which is uses a single dies thread，这块也比较关键。

就是它是使用单线程，简单说就一个人来帮你做清理呃，这个所以呢当你看这张图的时候啊，这张图呢，凡是你看到的这两个垃圾回收器，之间有连线的，看到了吧，都是互相之间可以配合使用的啊。

serial跟c m pin和serial old都可以，但是啊真正实际当中配对的时候，往往就是上下配对，就是这样的serial pico呃，old，那么parallel它配parallel old。

那么p6 呢p cms就这三种配对，很少有其他互相交叉配的好吧，这三种配对最古老的就是他，他刚才你也看到了，它是a serial吗，serial单线程的，这是最古老的，因为那会儿的内存啊特别小啊。

就跟你说你们家这房子十个平方，你妈妈进来三条，这两扫帚就基本上把它给清理完了，所以这个s t w的时间不会很长，但是随着你们家家庭条件变得越来越好，现在已经变成了200个平方了。

内存已经变成好好几百兆了，他一个人还能忙得过来吗，一个人忙不过来，那这时候怎么办，呀你拿大腿想想，无非就是多加几个县城是吧，同学们好了，后面就是多加几个线程的概念，这个就叫做parallel啊。

叫并行的，那么这个呃算法呢叫parallel scavenge，它说of the world coping collector，依然是copy算法，which uses multiple，就是多线程的。

但是我想问你啊，这个线程数量能不能无限制的增增加下去，垃圾回收的线程能不能无限制的往下增加，啊，你们家现在已经变成特别特别大了，说我能不能把爸爸妈妈，爷爷奶奶姥姥爷，全村的人一块儿过来。

所有人上就能够效率能提升吗，不行未必，因为大家学过底层原理的，应该都知道呃，线程之间呢是有切换的概念的，你的线程数量越多，那么需要切换的时间，需要切换所占用的资源就越多。

它不是说你不是一个线性增长的概念是吧，所以这个线程不能无限制的增，这个增加下去啊，这是不行的呃，在你最开始有个几十兆几百兆的时候，这个多线程的p p s p o，这个parallel的方式是可以接受的。

但是如果你们家现在是一个天安门广场，这么大个儿，现在你们家那是一天安门广场的大个儿啊，好几万个平方，你你请全村人来也没用，它的效率依然很低，那这个s t w的时间依然是超级的长，听懂了吧，那好嗯。

前面我讲的这两种啊，实际上都比较简单，单线程的多线程的就这么简单啊，单线程工作的年轻代，单线程工作的老年代，单线程多线程工作的年轻代，多线程工作老年代好，大家听我说，虽然说他看上去比较简单。

但是在你们实际当中生产环境里面，我告诉你jdk一点八默认的就这哥俩，我们简称它，ps加po默认就这哥俩1。8默认，好听我说呃，我不知道有多少同学，现在呢已经是超越1。8了，在生产环境之中超越1。8的。

有没有有的话扣扣个一，我认识一下，old的区不是老不是不是拷贝斯11版本，你们生产环境之中，这也可以，15了，都11了，哦，不错，ps可比对生产环境用的11，11是收费的呀，大哥家里集团11是收费的。

你们知道吗，1。8我们还是一点吧，对现在一点半应该是最多的，1。6有点狠了，对这这还有还有还有一点还有1。6的啊，有点意思，open dk 11哦，ok好的嗯，open jdk 11这个就可以理解了。

用的不是oracle的那个一只板，ok呃，所以呢现在啊对于这边的调优的人来说，呃，如果是1。8p s加p o，如果不够用了啊，我告诉你第一步的调优会回头，我慢慢跟你说啊。

因为呢呃后面我们要讲的这个g one，就是他，这哥哥这哥哥呢现在是1。7就有，但是不太完善，但是我告诉你啊，1。8，如果当你发现你的p s加p o，不管事儿的时候，当然你可以尝试。

这哥俩也可以直接切到g one，大家听明白了吧，而到1。9之后呢，默认就是g one，ok那么当你到达呃11应该z dc就有了啊，呃当然这个ip我们就不管不管它了，它是一个测试用的，ok一点点说呃。

我们刚才说过说这个单线程不够了，用多线程，多线程如果也不够了，这个卡顿的时间会非常的长，我该怎么办，ok我告诉你，现在呃牛逼的牛逼的哥们儿开始出现，这个牛逼的哥们儿呢，就是他，好了这个牛逼的哥们儿。

就是他，当然它的全称呢叫cms全称，整个英文的全称叫什么呢，叫这个名字啊，在这儿看它叫做a concurrent markk，刚才我们讲的是叫做什么叫parallel，还记得吧。

叫并行叫parallel啊，它叫并行啊，这个叫什么叫并发，并行和并发的区别到底到底在哪里呢，好听我说，我们只需要解释一件事情就可以了，就是当你看到我们的垃圾回收线程，和我们的正在工作的这个线程。

同时开始运行的时候，ok了，这个就叫并发，从cms往后全是并发操作，同学们，我们琢磨一下，就是我们产生卡顿的最根本的原因是什么，不就是说当我们我需要停止，我们整个业务线程，我才能进行垃圾回收，对不对。

但是如果说我垃圾回收呃，我业务线程在运行的时候啊，我不需要停止，我的业务线程不需要停止，不需要停止，我同时就能进行垃圾回收，简单说呢，就是你们哥仨在里边儿扔小线团儿玩儿，玩儿的时候呢，爸爸妈妈一块进来。

然后呢帮你直接帮你清理这些小箭头，你一边玩我一边清，一边玩，我一边清，同学们琢磨琢磨，当我的新的请求进来的时候，我还需要停止吗，其实我不需要，为什么，因为我的业务线程一直在运行呢，对不对，好了。

这个呢就叫做并发，从cms往后全是并发，当然呃关于并发概念，我就讲到这儿，这个比较简单，这个大家都应该应该应该能听懂啊，什么是并发的概念，但是问题就在于，同学们，你们好好想想。

这里面会产生很多很多的麻烦事，我不知道大家发现没有，你现在闭上眼睛，想象一个空间，你和你女朋友两个人在里面扔小仙团玩啊，你要带带你男朋友带不带随你，然后呢你们一边扔，注意这些小线团之间的。

互相之间呢会产生各种各样的关联，你只想我，我只想你，你连着我连着你，我连着你的断开了啊，我连着你的断开了，又连上了等等，产生各种各样的关联，那在这个产生关联的过程之中，居然旁边有人呢。

能帮你把这些小线条给你整理出来，好好想象一下这个过程乱不乱，需不需要把这个算法给整得特别明白，刚清理完又扔了，哈哈，小线头是啥，小线头就是一个一个的对象了，比方说你new了一个对象，就产生一个小线团。

这个对象呢，又它有一个属性指向了另外一个对象，哎那又是又是一个小线团，好这个过程比较复杂，但是我们细心细心细心下来啊，我们来分析它会产生哪些问题，我们好好琢磨一下，同学们。

你们想想看他们会产生什么样的问题呢，非常有可能是产生这样的问题，你们好好想一下，我顺着我刚刚呃我嘴跟上这个对象啊，这个mamain方法里面那个对象就是我自己，我女朋友，我男朋友好。

然后呢我找到这个对象了，这哥们儿不是垃圾，就是我标记他一下，这哥们儿不是垃圾诶，我又找一个哎，这哥们儿也不是垃圾，我标记他一下，但是呢由于我的业务线程不停在运行，也许我把它标记成为不是垃圾。

我已经标记不是垃圾了，但是我下一步业务线程呢，直接把这根线给断了，它就又变成垃圾了，想一下是不是会产生这个，这块大家能不能理解对，刚刚标记完又没引用了，同学们认真听，其实关于在大厂里面啊。

关于问的这些个所有的关于jvm的算法，就是jvm的问题，像那些个什么问你参数的呀，问你实际当中的场景的呀，那些都比较简单，我今天给大家讲的呢，是整个问题留到最难的部分，嗯，应该说是非常难的部分啊。

但是呃关于这块的话呢，呃你跟着老师好好听啊。

我后面用动画给你演示，你一定是能够把它消化掉的，呃现在呢，这是咱们21年左右，从20年开始到21年，遇到的一些新的问题啊，这是关于jvm的一系列的问题，呃，什么时候引发for dc最熟悉的就会说算法。

你不能说那个拷贝算法是吧，那个太简单了啊，呃怎么判断内存的泄漏是吧，讲一下cms的流程，g one的region不是连续的，只见有可达的引用，回收一个另一个怎么怎么处理啊等等等等。

我告诉你，这些个拳头，今天给我讲的这个内容息息相关，我们再回顾一下刚才的比较复杂的问题。

好同学们听我说，我把这块清掉，用于画图，好我们假设这个篮筐就是你们家这块空间，好在这块空间里面呢，你你女朋友，你男朋友就是我们may方法里面最根儿上，这些对象不断的扔小线团，扔小线团，扔小线团。

new对象，这个对象的属性啊，这个对象的成员变量又指向另外一个对象，这个对象成员变量又指向另外一个对象，这个大家能理解，对不对，好现在呢我的垃圾回收线程开始工作，这个是我的垃圾回收线程。

他在顺着根儿上往下捋，注意啊，县城这玩意儿是你运行一会儿，我运行一会儿，你运行一会儿，我运行一会儿，或者说我垃，圾回收线程呢在这颗cpu里运行，你的业务线程在另外一颗cpu里运行，也就意味着。

我这两个线程都可能去访问同一个对象，好我刚才讲的这段儿能跟上那老师口译来，我再说一遍，我呢在这里是两个县城，一个是业务线程，一个是垃圾回收线程，是可以访问同一个对象的，这是没有问题的。

好作为垃圾回收线程来说，它是这么工作的，它是有一个垃圾回收线程，然后睡在根上，开始往下捋捋捋捋，捋到这里了，注意它有可能就暂停回去了，放到等待队列里等着了，什么时候当他回来的时候，他会，从这里继续往下。

它不会从根儿上从头开始，那么大家你想象一下，当我们有一个垃圾回收线程，把这个标记为有用了是吧，这已经标记为有用了啊，这哥们儿有用，因为从根儿上捋捋捋到这儿了，但是轮到业务线程运行的时候。

我完全可以把这部分给给干掉的，有同学以前啊，他不理解说为什么这部分能干掉，比方说这个对象叫a，这个对象叫b那原来是这样的，a里面有个成员变量，比方说a点，它有一个成员变量叫小m等于b，这是没问题的。

对不对，那好把它干掉，怎么干掉a点小m等，于空就干掉了，它就不再指向任何东西了，这个引用就没有了好吧，那等他没有了之后，我已经把它标记成有用了，那我垃圾回收的时候，是不是就不会把它给清掉呀，等我标完了。

说这哥们儿还是有用的，因为我下次再回来的时候，垃圾回收回，现在再回来时，一定是从这儿开始好，这哥们儿有用，我就不会把它给清掉了，听懂了吗，来这会儿能听明白的，同学给老师扣个扣个一。

那这个东西呢呃这种这种这个这个毛病啊，这个这个小毛病啊，其实呢关系不是特别大，根儿上下来说我标记他有用，然后下来之后他又没用了，无无所谓，为什么呢，无非就是这一次垃圾清理的过程，没有把它清掉。

但是当我的垃圾器，这个这个下一次再清理的时候，你放心，这里已经断了，这哥们儿一定会被清掉，好这个东西呢，一般我们把它称之为叫浮动垃圾，什么叫浮动垃圾呢，唉简单说就是我这次呢标记完的。

但是我这次没没没清掉，他是真正的垃圾，但是被我当成有用的了，这个没关，系的他就是个浮动垃圾，下次干掉，所以这个问题没关系，不是很重要，不复杂，但是真正比较恶心的是另外一个问题，好听我讲。

那么另外一个问题是什么问题呢，就是看这里啊，另外一个问题是这个问题，当我们找到这个有用的了，还有一个呢是没有用的，这哥们儿是垃圾的，但是正当我准备把这个垃圾回收的时候，突然之间一个一根线连过来。

把它给连上了，能不能听懂，我再说一遍，我再说一遍，这是最复杂的，最恶心的好，我顺着跟上对象开始往下找，找找找找找找啊，这哥这哥几个都不是垃圾，那就意味着什么呢，就意味着剩下的有一哥们，他是垃圾好。

我已经标记它是垃圾了，我现在要把它清掉，那我怎么清啊，我正要垃圾回收线程刚要轻的时候，我的业务线程，给建了个连，给建立了个连接，这块大家能听明白吗，如果说这个建立了连接之后，这就完蛋了。

你就把那个有用的给干掉了，当你意味着去通过这个引用去访问他的时，候，就变成空值了，空指针错来，这块大家能听明白的，给老师扣一好，怎么建立连接对吧，下面我给你讲怎么建立连接，咋能突然找到没有引用的对象。

听我说这个是算法所带来的问题啊，大家看这里就行了，呃我刚才给大家伙讲过一个很核心的概念，就是我们整个标记的过程，它是分成好多个阶段的，整个标记过程，不是说一个线程光机一下就能给你标完。

是我一个县城标了一半，然后回来我要继续的，那这个算法是什么算法呢，这算法呢就是著名的三色标记算法啊，就这个算法呃，我能给大家解释这个三色标记算法，那个这个三色标记算法呢，我再说一遍。

它的核心在于就这个前提，你一定要记住它的，核心在于什么呢，它的核心在于我标记整个图谱，比方说这是我们整个的图谱啊，这里有一堆没有用的垃圾，我标记整个图谱的过程是分成好多步骤的。

是我第一个县城工作一小会儿，我第二线程回来继续，我第一个县城回来再继续，才能把整个图谱全部标完，那这个标记的过程，我们采用的算法叫做三色标记，这是很著名的很经典的算法，我们所学习的java语言。

我们所学习的go语言啊，go on用的算法全是这个，基本上现在很多虚拟机用的算法全是这个，那三色标记算法是怎么算的，同学，们听我说我们怎么去记录，有一些对象已经被我标记完了，我下次回来要从哪个对象开始。

它是用三种颜色来替代，这三种颜色指的是什么呢，在最开始的时候，我们所有的对象全是白色，所以白色是什么东西呢，白色是我们没有找到过的对象，从来没有从来没有接触到过的对象，好吧，这就是白色对象好。

还有一种对象呢，是我已经接触过这个对象了，但是我还没有来得及去标记他的孩子，这种呢叫灰色对象，还有一种是什么呢，还有一种是我已经把这个对象给标完了，找到他了，而且找到，了他所有的孩子好了。

这个呢叫黑色对象，同学们，你们想象一下这三次标记就是什么意思呢，当我从根儿上开始找啊，这是我的歌对象，从根上开始找诶，找到这儿了，还没有来得及找他的孩子的时候。

系列 1：P20：职业迷茫：年薪120万的java架构师简历是什么样的？需要精通哪些技术 - 马士兵官方号 - BV1mu411r78p

这是第一点，第二一点啊，我们指导简历，首先指导的实际上是你的心里，哈哈哈，问你个最简单例子，有的人的水平是十，但是他写简历只敢写成八，为什么，因为他害怕被人怼，他写成八之后面十家他成九件。

但是有的人水平就是六，他也敢写成八面十家，九家不成就成了一家，各位小伙伴们，我想问你，这哥们儿原来2万的水平，最后拿了3万，这哥们原来4万的水平，最后拿了3万来，你告诉我，本来他俩应该正常差2万。

最后拿了一样的钱，谁赚了，谁撞的呀，我这么讲，你能不能get。get到点东西啊，同学们从此转了嗯，所以其实有很多东西他不知道你真实水平的时候，只能控制你简历来，这是这个简历呢，当然拿薪水比较高。

你不用拿那么高，作为应届生来说，你可以考虑强度稍微低一些，你就不用写那么多，精通了，理解心理压力就不用那么重了，这只是一个模板，你可以摘出其中一部分来，这个简历呢是拿了60万年薪。

这是比较年轻人写的简历，既然说到简历了，有没有同学想看看比较老拉的写法呢，有没有老辣的写法，打开看一眼看在哪儿呢啊，嗯，好看这个这哥们儿是一大专大专生，5年经验，32岁了。

他明显就跟那个年轻人的写法就是不一样的，27岁从运维转过来的，看他的写法，这个简历我先告诉你最后拿了多少钱，35x15进的是融360互联网的金融公司，9000股的股票，大概他自己跟我说，算下来的话。

60~70万年薪差不多两嗯，黄老师20多岁拿676 16六七十万，但是你们不要跟他比啊，他这个呢是属于好长时间不出一个的那种，这个是比较正常的，32岁拿了六七十万年薪，这个算是比较正常，尤其是他大专啊。

能拿到这个薪水不错，最关键是呢他这个简历啊写法上非常的漂亮，你们仔细读一下这个简历，阿里大概有四五个部门都灭他了，不过对方没编进去啊，灭灭灭了，灭了别的，5年的一线开发管理经验，负责项目日活300万。

注册人数1。3亿，其实这个项目啊不是很给力，嗯这个呢叫做上天，就是你有架构的部分，对于构建高音高吞吐，低延迟分布式架构有丰富经验，架构部分，这两项都叫做比较给力的项目架构部分，这是什么，底层知识。

一般我称之为入地，就是上天部分，入地部分数据结构与算法设计模式，这你不用担心啊，老师两三天就能让你具备丰富的gm条经验，大概有10~20个案例让你跟面试官聊，今天有面试官，我就不跟你多说了，这是。

他就写了五条，他跟那个刚才那种写法就又不一样了，其实5年经验呢是可以做的，有多牛，你们想看看更牛逼的简历吗，想看吗，5年的5年左右经验的，再打开一个，这个是超牛，这个多数人是达不到的，但是通过他。

你就应该知道你的目标在哪里，我觉得再看这个简历，我先说这个简历的薪水拿了多少，这个简历呢比较特殊，这个简历呢在阿里拿了是120万年薪的，p78 80万的底薪加40万股票，4年拿完100 160万。

他应该是160万的股票，44年拿完啊，每年40万呃，当然它有一些成熟期，一些什么特殊的特殊的限制，这个我们就不多说了，大概120万年薪左右，5年java经验，3年以上大型架构系统。

分布式高可用高并发大数据量，double spring，cloud，spring，my bex源码，所以我觉得你通过阅读别人简历的时候，同学们你们知道吗，你们就知道什么东西，哪个方向现在比较值钱。

这也是我们做培训的人，整天在研究的课程里，我们主要交什么，交最值钱的内容，为什么要给大家上架构的课，因为这东西值钱，为什么要给大家讲底层，因为这东西会面值钱，看他这个人技能，我告诉你。

很多人对待自己的简历真的跟屎一样，随随便便写两句上去扔给面试官，就说我想当个高薪，你搁那扯淡呢，同学们，你们知道吗，同样的一个项目就是他字斟句酌的比较认真的人，写出来的简历就和那种纯粹的那种咋说呢。

混混事的那种简历就完全不一样，我跟你说一个最简单的理由，就算你同同样的都做过订单，订单系统，有的人就写一个在简历上写啥，我做过订单管理，做过库存管理，做过商品管理，做过啊，客服客服，客服中心等等。

就这么一列完了，那有的人就会这么说，我做过订单系统，在这个订单系统里头，我了解了to pc three pc tcc相关的分布式事务的处理方案，我设计了可靠性相关消息的最终一致性方案。

我了解了三个人它的这种分布式事务的架构，我聊我，我最终采用的是一个最大努力，通知方案来解决的这个分布式事务的问题，同学们，你们仔细分析一下，面试官更喜欢看到的是哪种，所以我不知道有多少人。

你们的简历里头还在在那写一堆的业务逻辑的逻辑，有多少人有吧，应该，有的是赶紧改好吧。

嗯既然说到这儿啊，说了说了，大专生有多少，这都还给老师扣个一课程有效期，公司活着，课程就有效，公司死了，课程就完蛋，对啊，所以我们要收一定的学费，就是保持一个正向的现金流来嗯，给大家请到更牛逼的老师啊。

嗯，759是大专生的发展啊，呃我想给大家大专生的第一个建议是合适的时间提提学历啊，为什么要提学历，我觉得不用我说，你应该能理解，这是大专生能够接受的企业范围，本科这么多，统招本科这么多。

研究生这么多更多等等，所以你在合适的时间请你提学历呃，然后还有一点大专生啊，在你技术变得越来越硬的时候，你的学历的影响就会慢慢降低，所以你一定要把自己的技术变硬，我觉得这一点特别特别重要好吧。

那么还有一个以前呢有不少同学听说过这个这个说法，叫叫这个说法，叫什么呢，叫技术搞不动了，按管理，来听说过这个说法，同学老师扣个一有吗，好听我说啊，这个说法大错而特错，谁要听这个，谁就入坑了。

这个坑坑坑坑的人坑多了，有的人呢30岁左右就直接干嘛了，直接就就就就直接转了管理了，凡是这样的，到最后你会发现招的人招招人的人，人家招过来的人比你的薪水都高，凡是很早转管理，最后全废了。

所以各位同学别这么干了，千万千万别这么干好吗，听我说，我告诉你技术，要走要，加管理要做要注意老师，我说的是加二，并不是转，我说的是家，并不是转，请大家给我记住这个词儿，我觉得我一个一个字就能提醒你了。

技术要硬，管理要硬，叫两条腿走路，你的路才能越走越宽，嗯嗯别的废话不用你多说，我还给你打开一些简历吧，也是大专的所有大专生人，认真听你看完这个简历，对你以后的发展应该是有深刻的认识。

有同学说老师你扯淡的就是硕士生吧，好仔细听这个简历呢往外投的时候40开外了，知道吧，不仅是大专还是大龄，他的呢就基本上都没有什么那个什么描述了，你懂吗，都没有那个那个技技能的一些描述，什么精通。

什么熟悉什么，他都不会那么写，个人的优势直接列出来，里边内容我就不不一一说了，往下看看他的教育经历，主要看这扬州大学第一专业热加工工艺设备大专好吧。

第二个业绩的你应用好下面这个你不用看下面这个叫简历技巧，这个老师都教给你，所有入学的同学，第一步需要看的就是老师的简历指导课，这个都是简历技巧，很容易get到，不去管它，坚持了10年多。

一直在走技术道路，走得很硬，合肥工大mba加上管理的认可好，这份简历多少钱呢，上海的架构是80_{130k的月薪，你自己去算，大概100万}160万年薪，可能有同学会说，老师40多岁有人会给吗。

有一定的机会好吧，有一定的机会，我不能说这种机会特别多，因为这个岗位一定是初级的岗位最多，中级的岗位，稍稍高级的岗位越来越少，这是肯定是倒金字塔的，但是它有一定的机会，我们我们我们去年做了很多内推。

我们晋级的一个内推，这有点小啊，比方说龙湖地产的，就有一些甲方企业特别特别喜欢那种技术和管理两条腿都硬的，那么这个这个岗位是年薪150万以上，要求你是8年以上工作经验，工作经验少了还真不行。

管理技术两条腿，第二个岗位是这个第一个leader下面的小的leader，年薪120，公会力量到位，所以在座的诸位啊，我不知道有多少同学是大龄的大龄同学，如果你意识到你的路越走越窄的时候。

同学们你们要好，大概第一次登录腾讯课堂呃，然后呢半年内我们得到了内部的第一名呃，同时呢我们也拿到了同一课堂，唯一的唯一的站在用户角度考虑的这样一个奖项，就是腾讯课堂最受欢迎奖，java领域就我们一家呃。

为什么会说大家比较欢迎，因为很简单，我们讲的比较深，比较细比较长，最开始呢我们也跟别人一样，大概呢提供八个月左右的课，每每每个每周三三节课，后来讲着讲着我就觉得我去讲不讲不爽啊，你懂吗。

我想讲的内容非常非常的多，非常非常的细，那么时间肯定不够用啊，太不够用，了怎么办呢，我就进行了拓展，直接把八个月可拓展到1年半到2年，拓展到1年半到2年之后，虽然讲上去讲内容比较多，比较爽了。

但是呢有同学说老师我没有项目经验怎么办，我们就直接拖了八个项目出来，免费的，前面全是免费的，后来有了项目之后，学生说，老师你们以后课程升级我还能听吗，免费升级目前是这样，这个后遗症比较多。

我们后面会把它去掉，目前是免费升级，所以免费升级呢是我需要你买入一张卡，目前是88块钱，这张卡是什么意思呢，我们以后所有的公司只要，活着会员牵扯到的我们我们技术的升级会给大家免费。

那今年给大家免费升了什么呢，你们可能想不到，今年给大家第一个免费升的是左程云，左老师的算法课，左老师算法哥在其他地儿买下来，大概要六七千块钱，在咱们这儿免费直接给你升了，这是第一个。

我们称之为p8 架构师，当然p8 的我一会儿专门讲给你听好吧，这个有一点市场的夸大啊，但是别人也这么叫，我们没办法，也只能这么叫，呃除了这个之外呢，我们进行了服务上的升级。

是有一对一的职业规划的指导和面试指导，我目标呢是不想做课程中的第二名呃，我还是那句话啊，就是说别人广告可能打的比我们小可以，但是质量上不打算做，不需要你来报任何课，所以到现在为止。

我们可不会成为一个什么东东呢，成了一个巨无霸，看这里，我今天给大家讲的内容，是属于多线程高并发啊，就是这其中一个小模块中的我点进去了，点进去就看到了点诶，多线程高并发这里面的一部分好吧。

就是讲srt的原理，讲lol的原理啊，这讲的是两块啊，其他的都没讲给大家听啊，自选啊，reaction log sam for safety，ma safety barrier，各种同步容器啊。

各种线程池啊，gmh怎么样去做这种这种微微微微微微观的一个一个一个性能测试啊，啊强软弱虚的类型思维logo啊等等，disruption的用法等等，呃这个呢是总而言之，这其中的每一块啊。

其中的每一块拿出来都是一堆啊，比如这vm拿出来还一堆，我就不给，大家一打开看了就这么说，别人你看到的不管线上线下讲到的内容，咱们这全有别人没有的，咱们这有没有啊，也有举个最简单例子，比如说这个东西。

比如分析源码这块儿，王老师现在呢给大家讲的hosport源码分析，其他人讲吗，基本不讲，linux内核源码分析，其他人讲吗，基本不讲好，这是第一次有人讲，就是我们呃为什么要讲这个。

很多同学可能觉得比较奇怪，老师我一做java的，我没事搞什么类的内核，为什么，why，我就想让你们挣更多钱，其实就这么简单，黄老师去阿里面试的时候，阿里p9 注意啊，不是给他p9 的职级。

是阿里p9 出来问他的问题，linux内核源码0x80 的调用过程，黄老师是怎么答的呢，只见黄老师那个左手从左屁兜啪抽一张，纸是吧，右手从右屁兜啪抽一支笔，然后把这个过程详细地画了出来，软中断的过程。

ax寄存器存的是调用号，bx cx dx si bi存的是参数返回值，存在哪个计算器里好，把这个纸把这个过程给详细地画了出来，因此p9 之后就再也没有问他技术问题，他当时学校里的时候23岁多。

所以呢最后给了他，你知道吗，没有，那怎么办呢，给了他一个p6 的职级，但是直接给了他的是p7 的薪水，嗯我就想呢各位能慢慢地达到黄老师的水平好吧，即便是我相信这句话，就是你学东西的时候呢。

一定要比跳比较难的，学难的才值钱，高度是100，你学一半儿你也有50万年薪，高度是30，你全学了也就30万年薪，这是知识点，除了知识点之外呢，我们有一堆的项目，这个项目呢适合应届生的，适合初级程序员的。

适合从传统项目转成互联网的，比如说网约车，这个就是常老师入职阿里的时候给他带来很大帮助的这个项目呃。

关于这项目啊，各位小同学们如果有意愿的话，你们可以去找我们的。

谁要呢，你打开来看一下，所以这个项目啊我们每个项目都有自己的白皮书，这项目里头有多少节课，每节课讲的什么内容，这个项目主要叫什么，spring cloud，从入门到落地呃，讲到基本都讲到源码级。

就是这里讲的所有东西都给你讲的源码级好吧，讲的非常深入的地方啊，都能给你讲到类似内核源码的话，那么其他源码的都不太不太是问题啊，嗯然后这个项目设计出来。

主要是让大家呢能够从原来的c r u d的传统状态，转到这个分分布式微服务啊，这样的一个项目在落地呃，除了这个项目之外呢，我们还有一个第一版的比较给力的项目，就是一级流量多级缓存的架构。

这是一些架构上的设计理论呃，通过这个架构的话呢，你会了解怎么样进行那种这么说吧，就是京东和淘宝啊，秒杀啊，12306啊，就这类的项目该怎么进行设计，从简单的cp定理开始，到资源怎么隔离，服务怎么限流。

到底怎么扩容到各种服务，怎么降级到分布式事务的相关的内容，到流量网关啊，各种网关吧，网关怎么设计到多级的缓存该怎么做，怎么落地，那么到呃高可用高并发这块你该怎么进行设计和落地，啊这是最关键是落地。

然后呢在阿里云上面部署一个电商的消停业的开发市场，呃，这也是非常给力的一个项目了，然后呢所以最后我们课程就形成了一个巨无霸，形成了一个酒吧，先带回去，我相信我讲到这儿呢，会有同学会有疑问了。

说老师这么多，我学得完吗，这么多我该怎么学呀，来有没有同学有这样疑问的，这周期太长了啊，学会了就老了，对对对对对，你全学会就老了嗯有这个疑问的话，听我讲给你听，这节课到目前为止，好好听啊。

老师的设计跟其他的地方全部一样，这可到目前为止，这个呢其实大概能带你到p6 ，顶多带你到p7 的水平好吧，我告诉你今年过的p8 的，如果你想听我一会讲给你听，今天过的算法的课，如果你想听我讲，你听好。

我的目标呢是把我们自己这里设计成为一个大学，进来的什么水平的人，我们会给你设计不同的路线，比如说有多少人是为了掌心跳槽，我会给你设计出来一个路线，先学这个再学这个，再学这个，加上两个项目，3~6个月。

先让你掌心跳槽，拿下来之后慢慢再学其他的做，进一步加强，不知道大家能不能get到老师的这个思路，学叫学无止境，如果说你学东西有个尽头，我跟你说这个东西就不值钱了，只有这样，你每年才能够不断地产生竞争力。

为什么有的人能够达到百万年薪，为什么你只能达到个102000 10万的，就是说如果你想短期内跳槽涨薪的，我给你设计一条路线，如果你是应届生，想进大厂的，我给你设计一条路线。

如果你是比如说你想在原公司里继续发展，但是我想要整体了解架构知识的，我告诉你你应该怎么学好吧，这个大体，的思路，不知道大家get到了没有，下面大家想听一听我们新升级的内容吗。

今年新兴新升级的我其实我讲完新升级内容之后呢，你呢应该至至少你知识体系上会有很多很多的拓展老师，就算讲广告也都是干货告诉你啊，这是我们今年新升级的内容，直播还是录播，凡是能直播的，永远建议跟直播。

但是课程体系太大，并不能保证说我讲完第一版之后，你刚进来，你想听的那个课正在直播，这一点大家能理解吗，那么如果是这样的话，你就先把原来的上一版听完，赶上直播，听直播赶不上直播，先把原来的那个听完。

那现在呢我们正在直播什么内容呢，spring cloud全家桶，好看这里这是我们最新升级的架构师的课啊，这个课是什么意思呢，其实就相当于在我们原来的m个知识点加上n个项目的里面，帮你又设计了一条路线。

这条路线是成为一个比较高级的架构师，呃其实阿里的p8 是不能够培养的好吧，多数都是从内部阿里p7 升上去的，你要理解这一点呃，关于这个架构师课呢，如果你们了解过网上的一些架构师的课程。

我觉得大多数人可能会了解过呃，其实大致也理解就是讲了很多很多的理论，很多很多呢都是p p t架构师啊，两三个月的课，每周两三次，大概嗯便宜的收你2万，贵的收你3万，知道吧，有的还分p7 p82 个。

我告诉你老师这个课是最实惠的，我们设计整个课的时候呢，目标是设计比较牛逼的课，其实这个学费上很多很多，我我我我我是拿来请请老师了啊，我们老师的水平你也看到了，超过我的应该不多，如果我们说了老师水分。

第二估计没有人敢说第一这个批发架构师的课呢，我主要讲什么内容呢，其实呢我会讲了一堆的理论，关于分布式的，关于架构师的一些大面积上的啊，但是这里面都不重要，这些都不重要，很多课也都讲很多，别人家也都讲。

我告诉你最重要的是这好这是什么内容，我是想告诉你要把整个理论落地，因为这个市面上太多太多，了不落地的架构师课程了太多了，所以我们的重点是在这儿落地，这个落地通过什么来落地。

通过一个再造淘宝的项目来进行落地，详解每一个版本的迭代，听过老师课，你应该你应该知道啊，一个版本迭代，这个更会好，这个落地怎么落地呢，当然首先从the boss开始，代码规范，从分布式id中心开始。

到配置中心到索集群，到分布式集群，到缓存到用户中心等等等等，业务上一点点来迭代，5月大概5月15号左右，第一节课开始呃，网约车的项目，五一过后就开始，所以这里最重要的是是是什么呢，是落地。

那么这个落地怎么做呢，我们计划之中应该是有100个的，200个节点才能完整的给你再造一个淘宝出来，通过这个落地项目，直接把下面的技术内容全串起来，那这个技术内容分了好多篇，给大家简单介绍一下哪些片呢。

第一个是理论的基础，分布式事务，高可用，高扩展，高性能怎么设计成互联网三高密等怎么做，第二个呢是支持面试的，就是p7 ，你要面试会面对这些内容，大家注意啊，你错了，去阿里问问就知道全面底层内容。

几个图就能给你画完，所以好多好多面的全是底层内容，所以这里技术底层开始jvm linux内核操作系统，存储系统。

依然是支持面试，我先把这关一下啊。

这样大家都看得比较清楚，依然是支持面试，左程云左老师的，从萌新到bat的算法课，从萌新到bat的算法课单独出来，现在我们现在正在讲的是基础班，基础班里头呢大概是讲的这些个算法比较简单的，基础的数据结构。

基础算法基础完成完成之后就是高频的刷题班，想进b a t吗，好参加高频这种题目的训练营好吧，上头条第三面就灭了i u的算法，l iu算法，从那个开始我就下决心为大家找到比较牛逼，的算法老师。

所以请罗老师过来，其实啊我告诉你，除了这个升级之外，我们还有google的老师在这儿啊，我刚才没有说，主要怕吓到你们，好这位小伙是在美国的谷歌上班，来给大家讲解的google的面试真题的专场。

当然这个只能是录播，直播不了，左老师呢，现在每周末都在进行直播，当然除了这种面试的算法之外，关于分布式的特殊的算法都会给大家讲，然后各种沙丁算法，各种的分布式存储算法，好，为什么，why，没错啊。

我看有同学真的知道这是什么，推荐系统，推荐系统，没错没有推荐系统的淘宝，它是没有灵魂的，当然这是第一版，第一版里头我们会推荐系统来帮你落地嗯，但是我告诉你啊，其实作为一个淘宝来说，除了以后推荐系统之外。

和ai相关的还有什么呀，机器人客服你们知道吗，机器人客服这个我们打算在第二版里头升级，对你来说是免费的吗，第二版里头实现好吧，对机器人客服，机器人问答，然后呢前面是关于面试的这些内容，后面是什么呢。

第五篇里头我们讲什么，讲分布式，分布式系统的总体设计，这是从这是开始总体的这种大面上的设计了，这单面设计呢其实比较简单的，单体的微服务，微服务到多级缓存，多级缓存到超大型的这种分布式啊。

呃这里面的内容呢我就不给大家一看了，总而言之呢理论性的东西比较多，要想落地的话，我们淘宝里面的落地呢主要是用微服务和service mesh来落地，听清楚主要用这第一版，主要用这两个来落地。

主要是微服务和service nature，为什么呢，因为现在比最火的流程最多，大家用的最多的是微服务，但是service mesh在我们判断会很快干掉它，所以我们用这两个来。

落地来帮助你跳槽的时候拿到更好的薪水，更好的经验，好讲完这个之后，大家知道作为一个分布式的架构来说，入口端是哪儿啊，物理的入口端肯定是dns，cdn基础的负载均衡，endx内测，好在这个之外。

我们决定加一篇番外篇，这篇番外篇就是专门讲engines，为什么要讲它，因为它太重要了，一个engines，一个re大，你学p h p，你觉得那个那个java啊，学python。

听我说这两个东西请你认真研究，一个是index，一个是一个是redis，这两个是架构师手里的利器，架构师手里的王牌，这俩哥们儿玩好了之后，能解决你架构的很大一部分的问题，好吧，好看这里。

然后呢我们开始设计分布式的核心服务啊，就是网关层怎么设计，我们分布式分布式的系统，不就是说网关层业务业务逻辑层有可能是用service mesh实现，有可能用那个microservice实现吗。

数据访问层持久化层bi的加成，bbbi模型，我们主要是推荐系统，然后是单独把微服务拿出来，目前现在正在直播的是这篇，现在一明老师现在正在直播的这篇微服务全栈，微服务全栈是讲的微服务全家桶。

我们的spring cloud奈奈奈飞和spring cloud，阿里巴巴都讲到，好吧，单独一篇是service mesh的落地，service mesh目前用的最多的常老师讲给大家听。

这个课目前网上也不多，我们应该是非常靠前就讲给大家听了啊，嗯如果说一个作为一个一个架构师来说，我们是站在架构整个架构师角度来理解整个大面上的系统结构，那么你如果不了解数据治理，你肯定也没戏。

所以第九篇是专门和数据相关的，大数据的存储，大数据的实时处理，大数据的流式处理，大数据的批处理好吧，好当有了数据之后，那么我就可以对它进行人工智能加成了，这一篇主要是落落地，我们的推荐系统。

从各种的召回策略，从用户画像啊，从基础的算法，大家不用不用害怕，大家听我说，就这个配件系统的话，不是你想象的那么难学，你也可以把它放到后面慢慢学，也不是说一下你就全把整个内容全全消化掉。

后面还有三篇是主要服务保障的，服务保障呢离开离部绝对离不了性能测试，绝对离不了c c d的支持，绝对离离不了韵梅，所以这三篇我就不单独打开了，那么后面还有两篇呢是比，较虚的内容就不一介绍了。

大家对于这个呃我们还有一些细节在调整啊。

还有一些细节在调整呃，大家对于这个这个这个呃课程的话呢。

如果说对对对这篇这篇大纲有需求的话。

好吧嗯我觉得我们给的课呢应该都是比较实在的课啊，嗯，这个这个课程大家觉得大家觉得值多少钱，有哪些课已经讲完的，有一些是已经讲完的啊，比如说我讲过，我一会儿讲，我一会告诉你啊，哎呀我告诉你啊。

就很多那个ppt架构师的课，人家就报2万，我们现在是多少钱呢，你现在多少钱啊，问问，这不是你想比如说短期跳槽涨薪又怎么做，其实啊呃这块非常的简单，我告诉你，我前前后后啊。

我们老师大概一对一的指导过2000左右的学生，按照去年来讲，就是去年2019年到2020年的整个面试过程，jvm多线程课前我敲过一遍了，看过你的，重新看一遍设计模式，zookeeper。

注意是mysql调优，不是mysql入门，大家千万记住是mysql调优，并不是入门，好吧好，六项基本原则加两个内容，网约车一批流量，两个项目，我们去年用这条6+2的路线。

让n多人在很短的时间内把薪水涨上来。

光说没用，看案例，自己总结了一些案例，嗯，这这哥们儿这哥们是我们比较早的一个学员，这局玩特别好玩啊，这个小学就我我老师这个案例全部都支持被被调，知道吗，全部都支持背调啊，你那你那个想见这位学生啊。

我聊个天儿啊什么的都没问题啊，诶这个学校特别好玩，他跟我工作在同一个楼，我们都是在那个马迭尔乔的华龙大厦，这个也支持各位小伙伴想过来找老师聊聊天儿的，随时疫情过去之后随时过来，好吧，就沿着一条路线走。

花了两个月拿了年薪30万的o，他原来年薪是20 20万，20万出头，后来拿了两个年薪30万的offer，还有像这小伙儿，这小伙比较比较特殊啊，这家伙是报了三天涨了2000，为什么会这样呢。

是因为他比较着急找工作，我们帮他润色了一下简历，这是我们的服务之一，就是润色了一下简历，就直接涨了2000，所以其实你们想想老师的课值还是不值，你就知道了呃，哪怕你只涨了2000块钱，1年你也涨2万多。

而且以后的升级课程对你来说还是免费的，我觉得你应该找不着比咱们这儿更加实在的课程啊，不信你随便找，所以你听到今天老师的广告是你的幸运，不然的话你可能真的会花两三万去报那种ppt架构师的课，太坑了。

像google啊，其实呢给大家录制google课程算法的，就是这位学员听懂了吗，就是我们有好多牛逼的学员，然后呢这位呢是呃帮咱们录制了一些就是进入怎么怎么怎么怎么google。

怎么进google一些专业的这种算法课，像这个这个小伙伴是在三四线的城市，它是在福州学了一个月，涨了4k就是你按照老师说的路线走就可以，我建议每个人入学之后的第一件事儿，先涨薪水，把学费赚回来。

先花3~6个月时间把薪水涨上去，把学费赚回来，听懂了吗，拿过来之后再继续沿着老师的路线慢慢学下去，对于，我们的成员来说，我们的目标宗旨是让一部分程序员先成为架构师，他是我学了一个多月，涨了4k多。

已经很满意了，嗯这个这个这个是一个女同学啊，他原来是8k多，现在涨了18，涨到18k，当然他是属于那个三四线五六线的城市啊，还有的呢像是薪水高一些的，你比如说这个毕业啊，毕业毕业了八个月啊。

拿到了百度的社招的offer，然后呢像还有比较比较典型的，这哥们也不要典型啊，这哥们儿是就听了老师的jvm，就听了老师的多线程，然后就听了李老师的mysql，就直接入职华为了啊。

刚听完这vm多线程mysql就面了华为就成功了，面试官问的都是老师讲过的是吧，呃他的年薪呢不是特别高啊，他转原来的年薪太低，大家也知道你下一个下一步找到薪水，跟你原来薪水是有关系的，就涨涨的不多。

涨了涨到40万也可以了，从30涨到40，涨了30%可以了好吧，起码你赚回老师这点学费了，是不是跟玩儿似的了，所以老师的学费是很容易，我们收上来给大家请牛逼的老师，把这个学费成倍的一辈子成一，1年乘五倍。

10年乘50倍的赚回来，最重要，这就是我们所设计的课程，不知道大家听清楚了没有，今天晚上的秒杀价格依然是4月份的价格，原因是我告诉你啊，5月5月4号开始，腾讯以腾腾讯一上班，我们价格立马涨。

本来5月1号就要找腾讯，没操作完，太讨厌了，这里还是4月份4月底的价格，11980好吧，有兴趣的进群，秒杀结束就算了啊，我觉得呢短期跳槽涨薪的可以按照这个来走，但是我应该是不同的人，也会有不同的需求呃。

下面我想花点时间呢跟跟大家聊聊呢，比较干比较干的一些一些内容，比如说我想问大家一句，有没有是应届生想进大厂的，有没有有的话给老师扣个一，进大厂有没有懂吗，刚毕业1年的都想啊，我们先说应届生。

然后我们再说社招生，大家听我说啊，应届生进大厂，沿着这条路线选7+1+1好，这是什么意思呢，就是除了下面这六项之外，我见你一定还要加一项，就是算了呃，想进大厂，可以说大厂对于这块的面试越来越多，特别多。

你如果把这块拿下的话，甚至你上面的六项内容可以不用的，不用掌握的特别详细都可以，现在啊你看啊，就就拿去年去年的面试来说，呃这个这个这个这个面试的题呢是那个字节跳动问题啊，其实他到最后他死是死在了三面上。

三面的一个算法题上，你如果看他这个题的话，你就会发现全都是非常底层的内容和算法，没有别的好吧，像那个我们去年总结的，百度的题啊，七面进到阿里那边，这些题如果你看的话，全是底层内容。

所所以线程池动态代理设计模式嘛，jvm ok全是这一类的，所以我们就给大家总结了这条路线，沿着这条路线走，就ok这条路线啊，前面这六项学的最快的同学，他是脱产脱产干的，干了15天就干完了就15天。

当然下面这两项比较难，一般来说呢我对于应届生来说，不需要大家掌握这项，不需要大家把上面这七项是七项，基本，原则，那么中间这个一是什么，对于应届生来说，你认真听，中间这个一是网络，好这个不是那么的重要。

有一些大厂特别愿意考我们这个网络是怎么交付给大家的呢，nt的越狱好，我这个nt的运用是怎么交付给大家的呢，通过项目驱动交付给大家的哪个项目呢，这个项目，这老师已经帮大家设计好了，知道吧。

这项目是什么项目，网游后端就是我们那个海宁老师带给大家的网页后端项目好，这个项目为什么特别适合大家，大家不要认为这个项目特别特别特别呃简单啊，其实他也是比较难的，你要理解那些理解a p p。

理解socket，理解protobuf，理解反射，javis，理解groovy，理解double rock m q e l k jackenzo，才可以，为什么这个项目特别适合应届生。

因为你的简历上应届生来说，应届生工程项目经验基本为零，所以被死磕占了，一般呢对于应届生项目不是那么的重要，但是这个是一个加分项目，而且这个项目写到简历上会非常可信，你说你在学校里写了一个游戏。

后端的项目比较可信，远远比你写一个商城要可信的多，所以这个老师都帮你设计好了，那么最后一个一是什么呀，最后一个e我们的简历指导，不客气的说，多数应届生写的简历跟屎一样，想看看牛逼点的简历吗。

想看的同学给老师扣一，到时候都说这个项目就基金，咱们才有多少人啊，几百人而已，你知道全国去年有多少多少毕业生吗，700多万还是800多万，你在这，你用几百个人里头在这脱颖而出，你不要叫英雄传说。

你能不能叫别的游戏后端呀，不冷啊，卑微嗯，不看就可以撤了啊，好不好。

系列 1：P21：多线程与高并发：1.计算机的历史 - 马士兵官方号 - BV1mu411r78p

别的我就不多做介绍了，呃我们开始今天的课，首先跟大家说呃，这个训练营呢也是我在今年最后一次讲纯现成的训练营了，呃为什么是这样啊，因为这个训练营呢我也讲过好长时间了。

后面的呢也就逐步的把这个训练营的内容呢会做更进一步的更新，这是今年最后一次讲了，呃希望大家伙珍惜，当然我后面还会讲其他的训练营，讲线程呢讲了好长好长时间了，呃讲到因为现场这件事啊确实挺重要。

呃尤其是你在去面试的时候，在进大厂的时候啊，在做各种各样的这种嗯，和别人去交流的时候，就关于这件县城这件事呢问的是特别特别多，那么县城的我们的课程里呢也讲了三季了，后面我想更的就是第四季了。

呃这三季的内容呢其实还是挺深入的，足以涵盖呃大厂的90%以上的这种面试的内容，呃，但是呢有很多人呢对于现场的透彻理解还不是很到位，所以在我第四季里面呢，我是打算从最根儿上啊，从最根儿上给大家讲。

现场的内容有的时候呢其实大家伙对于现场的理解不到位的时候，是因为他不懂硬件，不懂硬件，基本上就不同软件，所以呢我在后面讲的时候会从cpu的电路原理这块开始，呃，今天呢就尝试从这里开始。

这也是一个小小的尝试啊，讲的不好的话呢，大家伙多担待啊，可以开始的话，我们就开始好吧，呃给老师扣个一可，好，那么这次讲呢我会，嗯嗯，呃这次讲呢我会先从计算机的历史啊，简单跟大家伙慢慢聊，还是那句话。

你听我的，听我讲课呢，咱那会儿聊聊天，然后呃慢慢听着就成了我们简单聊一聊计算机历史，聊着玩，公开课呢大家伙呢也不要说太给自己太大压力，说我一堂公开课我就要拿到一个什么样的程度，达到一个什么样的程度。

学到多多多牛逼的知识，知识呢肯定是要学的时间来积累，所以公开课呢我们轻松一点啊，嗯，这个我们聊聊几次你简单的历史啊，那个以前有那种，尤其是现在最近一个阶段，这个好多的好多小伙伴呢。

他的民族感自豪感特别爆棚，还有说他是把把算盘当成计算机的起源，这个可以这么说，为什么呢，因为那个后面我会讲啊，有有比较牛逼的计算机的鼻祖，它的0001的来源啊，就是零一这个来源它是来源于中国。

号称是来源于中国的阴阳八卦，好吧，就是这八卦图，长长长这样的八卦图是吧，哎他是说灵灵感是来源于这儿，但是说计算机来源于算盘，我觉得这事儿其实是有点夸张的，不太靠谱，这东西历史这玩意呢是仁者见仁。

智者见智啊，我就写着玩，你可以不同意，非要追求计算机鼻祖的话，实际上最早开始的时候呢是一个机械计算机的发展历史，就是17世纪的欧洲啊，大量的工业模具需要计算，那这时候怎么就做计算呢，欧洲那时候没有算盘。

所以就催生了很多科学家自己发明的计算器，这个计算器呢它会长这样。

待会儿可以可以可以看一眼，它实际上是纯机械计算机。

好吧，长这模样啊，但是图我是随便找的。

别的抓过来，的实际当中呢可能比这个要简单一些或者更复杂一些。

但是很牛逼的，它这东西是纯机械的，就是摇齿轮就可以了。

这边齿轮摇进去，那边齿轮输出结果嗯，最早的发明人呢它叫做帕斯卡啊，我不知道多数人应该听说过这个人的名字叫帕斯卡。

就是我们平时所说的压强单位啊，怕不怕千帕等等，这些是我们的压强的单位，如果说这个你不知道你学计算机的小伙伴应该知道这门语言。

这门语言叫什么，passport好了。

这门语言就是为了计算这哥们，他是机械计算机的发明者，possible学过这门语言，能给，老师扣个一来很古老的一门语言，有没有有没有同学学过或者听过的sugar嗯，呃一般来说比较新的这些小伙伴啊。

就是比较年轻的小伙伴是没有听说过这个名字的，passgo呢是很早很早的一个计算机科学计算语言啊，我上学那会儿是学过pass pascal语言的。

后来呢这个机械计算机已经发明之后呢。

经过了五历代的这种改进啊，就是改进的特别牛叉啊。

其中有一个的改进者，我觉得值得说，这哥们儿叫什么呢，这哥们儿叫莱布尼茨，这样啊，我把这个图看看是不是能给大家放大一些。

不太好，不太容易，放一会儿再说。

这哥们儿是叫莱布尼茨，这哥们儿就更牛叉了，多数的同学应该都学过微积分，微积分应该都学过呃，著名的牛顿莱布尼茨公式，好莱布尼茨是谁说的，就是他其实很多历史上的东西说起来比较好玩儿，严格来讲。

牛顿来不及此公式很，有可能，但是历史就还是那句话，就历史是胜利者书写的，那个历史上很很有可能只有莱布尼茨一个人发明了这个公式，这个公式发明之后呢，当时牛顿这人呢，他是英国皇家学院的皇家数学院。

应该是他这时候呢权力比较大，话语权比较大，比较牛逼，他就想着把这个发明给抢过来，后来牛顿呢就发表了一篇文章，就说莱布尼茨的这个公式是抄了牛顿以前的手写的一个笔记。

莱布尼斯说我没有抄，牛顿说你又抄了，那个时候牛顿的话语权非常大。

后来莱布尼茨争不过他。

因此呢后面莱文尼茨发表的这篇论文就被牛顿抢走了一半，结果后来这个公式就叫做牛顿莱布尼茨公式，这个咱们聊着玩儿呃，我不知道大家了不了解话语权这件事，那个当今世界话语权最大的是谁，米国嘛。

那个他想把他想把新冠命名称命名成什么名字啊，这个大家知道吧，当然那是英国是抢人家的，抢人家的成果，美国是要干嘛，是要把一个差的东西强加给强加给我们是吧，我们当然是不能同意的。

当然历史上有一个病毒叫西班牙流感啊，不知道大家听说过没有，你看到这个名字的时候，你一定会认为这个是西班牙那边流行起来的，但实际上是这样吗，no是当时的美军，驻扎在西班牙的美军内部开始流行。

但是西班牙的话语权肯定是干不过米国的，所以最后这个流感居然被命名为叫西班牙流感。

当然我们现在还在争是吧。

这个不说了啊，我们说回来来了一次。

这哥们儿呢改进了计算机，机械计算机之外啊。

它还有一个非常非常重要的发明，这个发明就是大名鼎鼎的二进制。

好这里呢终于跟计算机扯上关系了，其实呢从历史来讲。

二进制是首先发明，然后才诞生了现代的计算机。

当然莱布尼茨啊，他是在一本著作里头确确实实说明了他的二进制是来源于中国的。

在中国的这个阴阴阳八卦，而且呢莱布尼斯这个人确实对中国有所了解。

他有一本书叫做论中国人的自然哲学。

这里面，就提到了阴阳八卦，然后呢他当时发明了二进制之后呢，因为他当时的那个生活的年代正好跟康熙的年代是一个年代。

呵呵挺好玩的是吧，讲了点古老的东西，零这个012进制发明之后啊。

到1946年的时候才诞生了现代的这种，我们说现代意义上的计算机呃。

这个就这个意义上的计算机呢是这种电子管计算机。

就是二极管三极，你可以理解为灯泡一类的好吧，如果你不能理解它的物理原理的话。

没关系，你就理解为什么灯泡一类的嗯，那么他的名字叫anniac啊。

现在都认为是诞生于美国的。

比起法尼亚大学，就这玩意儿呢当时呢是一个特别特别笨重的东西。

它大概呢占地是要跟一个别墅那么大。

但是呢他每个小时耗电，150度，但是每秒钟的计算量是多少次呢。

5000次好，这是什么概念，目前我们手机上的芯片的计算速度可以达到你自己数零的吧。

达到这么多次。

就这么大一家伙呃，不过呢由于它是刚刚诞生嘛。

后来经过一系列的改进才诞生了现在的我们的手机的芯片，当时的这玩意儿啊。

它的计算速度甚至比不了我们现在的菜市场上的计算器。

不过计算机飞速发展啊，那会儿的计算机呢叫做电子管，电子管呢就是你可以认为它的这个通一下电，灭一下电，通一下电，灭一下电，而且有事儿没事儿的老坏。

后来呢从发明了这种晶体管之后，就是归一归为为为为原料的这个晶体管发明了之后，我们现在的阶段你才经真正地进入到了突飞猛进的时代。

系列 1：P22：多线程与高并发：2.计算机原理 - 马士兵官方号 - BV1mu411r78p

我我在下面这个里面呢会简单跟大家讲，就是现在这种晶体管计算机的基本的原理呃。

有不少计算机系的同学啊，其实呢你们在学课本上也学过。

待会儿稍等啊，因为我我的这个水确实喝多了，主要是要养好这个嗓子，给大家讲课，那个心灵老师能不能过来一下呃，跟大家伙儿先简单聊一会儿，小天天我我我我我去排空一下膀胱好吗，好允许的同学给大家给老师扣个一。

不允许的同学，你给老师扣7564x6564的开立方，把最后结果告诉我啊，答对了我就不去了，没有一个答对的。

看来必须去啊，今天今天那个学生老师必须得尝尝露面，这个没没有办法啊，比较特殊对啊，快去。

哈喽哈喽哎呀。

哪个摄像头在哪儿，哦，不好意思哈，我先把我撤掉，哎呀马老师这鼠标怎么用，讲到哪儿了，然后大家有什么问题吗，啊今天马老师的资料可以扫一下二维码，这个二维码在哪儿呢，稍等稍等，不要着急啊，大家看一下。

然后这个这个里面有一个成员，里面有一些诶，有一些咨询老师需要马老师的资料的，可以去这个里面找一下，咨询老师，要一下这个资料，诶成员在哪呢，稍等稍等啊，这个还不太清楚，唉呀呀唉呀呀，我是马老师啊。

马老师已经结婚了，小孩都有了呃，大家需要你们加班，有工资吗，这个必须要这个必须有工资的啊，这个课有录播吗啊是这样子的啊，咱们今天晚上是听课听直播课，听完直播课之后呢，去找你们的咨询老师。

就当时你们怎么报名的，怎么来到这个直播间的，肯定是有一个小姐姐带你们来的，对不对，然后你们去找那个咨询老师，所有的笔记资料，还有回放都可以通过他们找到。

多线程的所有的笔记资料都可以找到他们心理老师都能都是你，们大事对对对，还有这个小豆，都是我们的咨询老师，都可以去找他们，马老师嗓子不太舒服啊，大家担待一下，讲的课还是没啥问题哦，所有的小姐姐。

目前除了我之外，其他所有的咨询老师都是单身，有任何的问题呢，你们都可以去找他笔记资料，说好来欢迎一下马老师啊，给你这个仿佛听见了掌声。

唉心刘老师居然没露脸吗。

太过分了啊，这不好意思。

今天有可能会多去几趟厕所啊，非常的抱歉嗯，听我说，就是这就是这个这个这个厕所去玩，最最重要的感觉是什么，爽对吧，那个，人生中的四大爽你们知道吗，多喝枸杞的，枸杞是不能喝的，枸杞得泡水。

然后喝水不能喝枸杞，人生中的四大爽叫做久旱逢甘雨，他乡遇故知，膀胱排空时是开玩笑啊，呃我还是那句话，你今天嗓子比较疼，我说话会速度会慢一些啊，那个希望大家会儿能够体谅好，不说了啊，我们继续讲。

我们讲我们讲到了说这个计算机呢它到底的原理长什么样，要想理解这个原理呢，其实你要学好多东西，深刻的原理，你要学好多东西，药学，如果你还想了解二极管，三极管的原理，那么你就必须得去了解物理学。

但是呢我们今天要讲这玩意儿，我肯定就讲的没完了，我们还是要讲现成的，会快速的加到，拉到县城这里呃，但是呢我会快速的带你简单的过一遍，一个cpu的原理到底长什么样，你就记住这一点。

县城和cpu是永远离不开的，这哥俩就是一对，一般来讲一个cpu对应一个线程，现在cpu有些比较牛叉的叫超线程，一个cpu有可能对应两个线程，四个线程，你就记住任何跟你聊线程的时候。

脑子里就浮现出cpu的概念来就行了，好认真听，嗓子不太好，大家认真听看这里现代计算机的核心是芯片，这个芯片呢到目前为止是由10亿个做个零件构成，你可以这么来理解，我肯定没有办法，但你却说。

是设计一款芯片，你也看不懂，也没有这个意义，但是呢我也不希望一个芯片对你来说是个黑盒。

你是里边儿，你什么都不懂也是不合适的，简单带大家了解一个芯片背后的故事，呃这里呢我写了一个小小的故事啊，你们自己去读一读吧，我就在这就不就不重复了啊，小时候最喜欢的同学叫什么呀，叫小芳嘛，村里有个姑娘。

村里有个姑娘叫小芳，是真的好看又善良，后来呢人们不许我跟小芳联系，那这时候怎么办，这时候呢由于有二进制的存在，我刚才说了，莱布尼茨发明了二进制，我们可以跟小方怎么通通话呢，我在可以设计一个电路。

拉根电线，把灯泡放到小方家，我来控制这个灯泡的亮和灭，然后我们自己约定好一个语言，我就可以跟小芳来通话了，比方说我b上打开，我们就发明了自己的灯泡语言啊，两两下连着量放量和灭绝灭和量等灭灭等于我。

我只要连我只要给他八个信号，我就可以给他说一句话，叫放学等我，ok在这里面呢，我相信大家，伙都能看得懂，如果量我们用一来表示灭，我们用零来表示一，一就等于方是吧啊。

一零等于说也就是说我是可以通过二进制来给小芳来传信号的，而且这个信号的复杂程度呢，你会发现呢它和我们的信号宽度是有关系的，呃如果我们拿中文来举例子的话，这是两位信号对吧啊，用用用用两两下来代表一个字儿。

那最多我们能代表几个字儿啊，二的二次方是四个字儿，那如果说我想表示更多的信息怎么办，简单没关系，我们只要加那个信号的宽度就可以了啊，我们每次发三个信号代表一个字儿，那我这时候就能代表多少。

2~3次方是吧，同学们好，假如你想交流的更加复杂呢，更加复杂怎么办，再加信号宽度，比方说我如果想用一个新号来能够代表所有的汉字，同学们，你们想想我们大概需要多多宽的宽度呢，多宽的宽度非常的简单。

你就要知道我们有多少汉字就行了，整个康熙字典差不多是47000个，1600个汉字已经足够了，所以你自己算一下二的多少次方，你自己算好吧，基本上二的16次方已经足够代表我们所有的汉字呃。

这里头呢其实就是最基本的一个概念就出来了，这个概念是什么东西呢，这个概念叫做编码，编码这玩意儿是特别好玩的一件事情，那个呃在你要说在这种编码里，我用111啊来代表放这个字儿。

我是不是自己还可以发明另外一种编码，在另外一种编码里，我用000来代表放这个字儿，可以不可以可以的，那我就想问你了，如果说我用这种编码对我的信息，最后给它编成了二进制，111110。

但是呢我用这种编码来去解析这些信息，能解析出来吗，能不能不能，比如说编码是个什么东西，编码实际上是一张表，在这张表里面存着这样的二进制，代表的是哪个数字，或者说哪，一个文字在另外一张表里面。

如果你用这张表进行的编码叫in code，用另外一张表来进行解码，这边代表的是别的，它能解开吗，解不开他解，当然它解开之后是什么呀，就是著名的乱码，所以当你的程序里头如果出现了乱码的话。

这根上的结果是在这里，你编码的码表和那个解码的码表，它不是一个我今天讲的东西呢，我从简单到复杂慢慢讲，有一些水平比较高的，你就照顾照顾咱们水平稍差的好吧，那当你理解了这件事之后，就说我们编码的宽度。

实际上跟跟你能表示的信息的这种这种呃复杂程度它是可以成正比的，好吧，我呢有了我们自己的编码的码表之后呢，开始设计我们的下一个电路是吧，就这个电路太简单了啊，那个如果往复杂里考虑的话。

我们就有了越来越复杂的电路，比如说这个电路，大家听我说，我下面呢给大家采用的这些个图都是我的一个学生，在他自己的公众号里啊，我征求了他的同意之后，给大家拿过来的，他做了一些动图，我觉得挺好的。

我拿过来拿过来用了啊，这个是他同意了的，没有关系，那个你看啊，如果你稍微学一点电路的话，你应该知道，如果这个东西啊是我们要求的一个结果，这两个东西呢是我们的两个开关，那只有两个开关连起来。

这个东西才能亮对吧，那如果你只要有一个开关断着这个东西就是断的，这时候呢实际上就有了一个什么概念呢，就是有一个输入和输出的概念了啊，你比如说我这里是连着的，就表示我这里输入的是一个一。

我这里断开的就表示我这里输出的是一个零，输入的是一个零，那么这个呢我们可以看成是它的输出，这时候我们就会有这，样的一张表输入如果是零输出，如果是零，最后输出是什么，输入零输入一输了什么。

这个这个数是什么，好听我说就这个东西呢，你也不用仔细去计算它了，这个东西就是我们的微运算，也就是说我们的电路啊，实际上是可以完成我们编程语言里面的位运算的，可以用这样的符号来表示呃，如果你学过数字电路。

那么你就会知道这个东西一般我们称之为叫什么东西呢，叫门，要么是吧叫门电路就是非常简单的做微运算的电路，一般我们称之为叫门电路好，这里就就它就是数字电路的知识，没有关系，你现在先不用管它。

因为今天主要讲的还是县城，这个我学了看着就脑壳疼啊，今天我们讲的不是数字电路啊，那个呃当然啊除了上面的这种电路之外呢，其实也也有这样的电路，就是原来这两个是串联的，现在改成并联的。

他只要有一个通了灯泡就亮了对吧，那么你也可以做这样的一张表出来，那么o同样的我们换另外一种画法来表示这个电路啊，这是另外的门电路呃，当然还有更复杂一些的门电路，它除了可以做与运算，可以做或运算。

还可以做异或电路，还可以做或非电路呃，那么在这些电路的，基础之上，同学们，我不知道你们发现了没有，其实呢它就可以开始做运算了，做做什么运算呢，做一个二进制的加法运算了，如果用这个电路。

你就完全可以做二进制的加法运算了，一我们设计一个比较复杂的电路，这边输入一边输入零好，我们最后得到的结果让它通了，ok这不就是加法运算吗，对吧，我讲到这儿呢，我中间其实省略了很多东西。

如果你想理解加法运算这件事儿好，这个电路是用来做加法运算的，它是异或电路和雨，就是异或门和与门，异或电路和与与电路的一个综合性的运用，就是简单电路连到一起的时候，就可以做成一个复杂的电路。

就可以做什么呢，就可以做一个二进制的简单的加法器，二进制简单加法器这件事儿它需要有两个输出，为什么有两个呢，你理解这样一件事，你看啊，我们说1+12进制的最后的结果，这里是零，这里是一。

你就会发现呢它有一个加和的输出，还有一个什么呀，还有一个近卫的输出，所以它有两个输出好了，这个东西就是一个加法器的存在，呃听我说，我在这儿呢给大家推荐一本书。

如果大家伙儿想简单理解计算机的电路是一步一步怎么走，成现在的这样的一个结果的，推荐大家这本书稍等给大家拿一下，计算机的说呢层出不穷，有一些经典的书啊，叫做经久不衰，这本书我推荐就叫做编码。

当然还是挺复杂的，如果你看完那本书之后，其实还是挺复杂的，当然那本书看完你还可以用手工自己做个计算机都都可以的，简单的计算机从呃这个，加法来说，加法器来说就是上面的看到这个东西叫一个半加器。

为什么叫半加器呢，是因为啊你你你两个的输入来说，你你的这个加和输出，有可能和这里的原来的另外一个一个一个加和的输入，还要做加法啊才可以，所以它叫半加七，就是半加七。

到最后呢几个电路的组合成才会组合成一个全加器，这是一位的全加器啊，注意这只能算是一位，好多个全加器的串联就会变成多少位的加法运算。

比方说全加器还全部用这种电路来串联起来，就会做成加法器，只要有了加法器，我们就有了cpu最核心的部分，cpu用来干什么的，还记得吗，用来做计算的，cpu最核心的部分用来做计算的，只要有加法器的存在。

cpu就可以做计算了，好cpu有好几部分构成最核心的部分，我们叫它a l u，全称呢叫arithmetic数学logic逻辑unit，叫数学算术逻辑单元，a arithmetic logic unit。

听我说有同学可能会说了，老师那除了加法运算之外，我们还有别的运算呀，我们要减法运算呀，减法运算可以变成加法运算，加负的就行了，我们有乘法运算呀，乘法运算可以变成多次相加，我们有除法运算呀。

除法运算我们可以变成多次相减，对不对，所以只要有加法去存在，记住一个cpu就已经出来了，我讲到现在能跟上的，给老师扣个一，这不是剧组讲的吗，对说的很对啊。

我就是简单扫扫盲，因为有很多人呢它是没有这个基础的概念。

所以他理解不了多线程的一些东西啊，那么有了这个加法器的存在之后呢，同学们，你们想想看这个加法器这玩意儿呢，你有一个输入八位的好，另外一个八位的输入两个一加，那最后一个输出是谁呢，输出在哪里。

输出我们可以放在这里，但是我每次只能计算一遍，你发现没有，如果你用电路来做计算的话，我把这个开关给它合上，把这个开关关给它打开，把这个开关合上好，最后我只能算一遍，我算一遍之后，我如果再加一个数呢。

不好意思，我又得重新输入一遍，太麻烦了，这个时候呢有另外一个电路就诞生了。

这个电路叫什么，呢这个电路叫时钟电路，时钟电路特别好玩的一件事情呢，它是不停的开关呃，如果大家伙学过电磁什么左手的左旋定律，右旋定律啊，不知道你那个高考初中初中还是高中来着学的，就是线圈一通电。

它就有磁性了，他就把这个开关给拉下来了，线圈一断电没有磁性，这个开关就上去了，所以你会发现就做成一个特别好玩的电路，叫时钟电路，使用电路什么意思，就是他不停的开关开关开关开关开关好这个东西呢。

它就会产生一个不停顿的，就不能叫不停顿的，就是通电断电，通电断电，如，果我们能设计一个电路是通电，它计算一次再通一次电，它又往下一步计算一次，再通一电一次电，它又往下一步计算机一次。

这个时候我们就产生自动化的电路了，你发现没有自动化电路就诞生了，你想象一下，因为里面他说的确实比较复杂好，也就是说这个玩意儿是驱动着我们整个cpu来做一步一步运算的核心，ok那么如果他的速度够快。

我们的cpu的速度计算速度是不是就够快，是不是这样的，所以我们所说的主频计算主频啊，我们这cpu的主频是多少，和这个玩意儿息息相关，虽然它不是说嗯完全跟这个相等的，但是跟这个玩意儿是相关的，听懂了吧。

你看啊，赵成挺说了一句话，我觉得挺挺那个什么的，挺挺挺有代表性的，跟大家交代一下，赵成景说能研究出这个的人的脑子是怎么长长的，你好好听，赵正廷，没有任何一个人一步到位能够得到现有的计算机cpu。

中间呢很可能一个人发明了二进制，另外一个人呢发明了二进制的一个电路，其他的人呢又把这个电路做了综合，然后呢做成一个完整模块之后，其他人又把这个模块做了一些综合，它是一步一步迭代出来的。

你不要想着说我们一步到位的好吧，咱们咱们现在学东西为什么累呢，是因为呢我们的课本里面会尝试着一步到位的告诉你，现在经过了成千上万人迭代之后的智慧，你好好想想，你能不累吗，有了这些个电路之后呢，还不够。

为什么为什么还不够呢，是因为你们想想看，如果我们做三个数的加法，01+1+12，我们一般是呃不不能用一二啊，1+10那个这两位做完之后啊，这两个格的中间结果一定得存储起来，听懂了吧，你不能存储的话。

你怎么样跟下一位来做计算呢。

所以我们还缺一个电路，这个电路是什么，这个电路就是著名的存储电路，好了，想去研究就研究它，这个电路就是著名的用来做存储的电路，这个电路的特点就是你在前面的输入，最后的输出会保存在这里。

不管你输出的是零还是一，就是你下一次再通电的时候，它这个边的输出它不会变，它会存储下来，ok这个呢有了这个玩意儿，我们就可以做什么的呢，用来做存储了，当然大家应该知道我们做存储的呃，最核心的点是什么。

最核心的这个这个这个这个模块是什么内存吗，有时候我们中间至至少我们可以把中间结构给存储下来了，有了这几个电路之后，经过复杂的芯片设计，我就直接告诉你，最后我们的cpu就诞生了。

这个一般我们称之为叫锁存器，它每次就这个电路这个复杂电路只能锁一位，我们把锁存器串联起来。

我们就能锁八位，我们把好多储存器串联起来。

我们就得到一条内存，同学们，这个时候你就开始可以开始琢磨了。

琢磨什么呢，一个一台，真正的计算机到底长什么样了，就是我们把我们的计算机里面，这是我们的锁存器，也就是我们的内存，在我们的内存里面，每一个内存都有它的地址，同学们，你们想想，作为内存来讲。

你总得记录着它，说我往哪个地方存了一位什么东西，对不对，我们所谓的编程就出现了，我们的程序会写成什么样子的呢，在某一些地址写一些数据进去，在另外的地址里面写一些指令进去好，这个指令有可能是加法。

有可能是减法，有可能乘法，有可能是除法，然后我们cpu怎么做计算的，cpu是我如果想往这个地址写的时候，我就把这个地址指定指定，这是地址指定指指定地址的电路，然后这里头呢是个数据。

我一按写操作就写过来了，当然我cpu还可以干嘛，指定一个地址来这里是读操作，我就把它读到cpu里了，比如说我们的现在等等，这个这个，就可以变成这样的一个结构，cpu和所存的东西构成了，这里是做计算。

这里是做存储诶，构成了一个很好的一个组合，我们的程序好啊，我们说简单做两个加法，一个数存在这一个数存在这，然后把这个加的指令放在这里，然后我们做计算的时候怎么做呢，cp从这里首先读出来哦。

这是一条加法指令，然后根据我们的格式要要求加法指令，前面两个数是用来做加法的，两个数好，我把第一个读过来，第二个读过来，通过电路做一次加法运算，再通过这样的一个方式写到后面这个地址里面去搞，定。

我不知道讲到这儿啊，大家对于嗯我们呃cpu的一个简单的计算。

一个简单的模型，是不是脑子里头有一个小小的印象了。

能有印象，能给老师扣个一当，盯着那个手指啊。

我把它凑过去啊，有点懵，有点懵，没关系啊，听我说那个我呢后面会再给大家做一个简单的总结，k好好听我说，后面我会在我们自己的课程里面呢，呃把这部分内容给大家加上，给大家把这些基础的东西都给大家扫完。

扫了盲，让你把基础打得牢牢的，基础不牢地动山摇，我们回想一下我们前面讲的几种电路，有一种时钟电路在这里不停的来回的输输入断开，输入断开驱动着我们不停地往前走，它驱动一次，我们做一次计算驱动。

第二次我们就拿第二个第二个指令驱动，第三次我们就拿第三个指令，这样的话呢我们的程序就可以做成自动化的了，由于呢我们的程序可以存储在我们的内存里面。

系列 1：P23：多线程与高并发：3.什么是进程？什么是线程？ - 马士兵官方号 - BV1mu411r78p

这是一个小小的计算机的组成，我我我呢把这个过程做一个小小的简单的总结，你认真听老师讲的太感兴趣了是吧，怎么提高cpu的利用率，这个是压榨cpu的话，县城这部分的知识是你必须得要掌握的。

嗓子已经难受五天了，大家忍一忍，看这里，我们所谓的程序最终所写的任何东西，最终一定是由01010101编译完的，这种这样来构成好这个程序，平时他静静地躺在我们的硬盘上，就在我们的硬盘上呆着。

比如说它叫做qq。e x e，当我们想让这个程序运行的时候，咔嚓一双击它就会跑到哪儿去呢，跑到我们内存里，刚才我讲过说内存里的程序啊，好只要一个程序跑到内存里，这个概念就叫做进程。

好当一个进程放到内存之后呢，实际上这进程里面是什么东西呢，在内存里面是什么样子的构成呢，无非就是有两种东西构成，第一种东西呢叫做指令，指令是什么，就说我要做加法运算还是减法运算，乘法运算，除法运算。

ok第二种东西呢叫做数据好，你就记住这一点，就成程序由什么构成呢，指令加数据搞定了，就这么简单，那有同学说老师那cpu怎么做计算的，cpu是这么来做计算的，cpu找到我们的内函数所在的位置，诶。

然后呢去看第一条指令，他发现第一条指令是相加的，指令很好，他把这，个指令读过来放到cpu里啊，发现一看，ok这条指令叫什么呀，叫加法good，然后他就去加法，后面应该按照格式的要求，应该有两个数。

第一个数把它读过来，第二个数把它读过来，做一次运算，写回去搞定，然后有下一条指令，这个是大体的过程。

不知道我说清楚没有，这个图有点小，我把图稍微放大一点给大家看，稍等啊，打开ppt。

推荐的一些书，这个再说啊，好看这里啊，我们再重复一遍刚才的这个过程，这个过程挺重要的，你好好听，认真听，我跟你说，很多的面试题，包括腾讯的，百度的，华为的，问的都是这部分内容，这是我们的qq。

e x e，然后呢我们双击它，它就跑到了我们内存里面，换个颜色，在我内存里面放进去的时候，无非是指令add加数据两个数构成，然后这个东西呢就被我们称之为一个叫进程，好一会儿我再给你讲现成的概念好吧。

那么这个进程啊需要执行的时候，刚才我说过了，cpu首先去读指令，把指令读过来，同学们，你们想过没有，把指令读过来的时候，我cpu总要存储一下这条指令的指令也是由0101构成的呀对吧。

只不过cpu把这种0101看成是一条指令而已，指令在cpu内部总有也是需要有一个存储，的地方，那它在哪儿呢，好在cpu内部用来做临时存储的东西，我们把它称之为叫寄存器，寄存中间数据或者指令的地方。

对不对好了，那个寄存器呢，其中有一个著名的寄存器，就是它叫pc，全称叫program counter，叫程序计数器，记住这一点，这个玩意儿存储指令的，指令放这儿。

我得知道我当前执行的是哪种指令运算单元呀，只负责运算，你给我我就加给我，我就加我，其他的什么都不管，我执行的是哪种指令呢，放这儿，但是相加这种指令，它是需要有别的数据的，它又需要有两个数据。

这两个数据在哪儿呢，这两个数据在这里，所以当我们发现这是一条i的指令的时候，他会把后面的两个数据一块读过来，还是那句话，我读过来的时候是需要也是需要存起来的，临时存储放哪儿呢，放在数据即存器里面。

数据寄存的就是数量比较多，这个呢我就不一不，再展开了，这属于汇编的内容了，总而言之是放到两个不同的计算器里，然后au从这一读哦，这是加法运算，直接计算这两个数的和写好了之后放到这个寄存器。

然后再把这个寄存器的内容，如果需要的话，写回到内存里的某个位置，比如说c等于a加b那么c的位置在这，a的位置在这儿，b的位置在这儿，a和b读过来，放到这个计算器，这个计算器写到的结果存到这个计算器。

再写回到c的位置上去，大概就是这样子的一个过程，program counter太抽象了，我我我讲的还很抽象吗，想象一下是吧，打，开你想象的空间o，对由于不同的人呢，他是有不同的基础啊，好我们继续。

同学们讲到这儿你就会发现cpu超级简单，他只干一件事，拿指令，拿数据做计算，写回去没有别的，所以cpu的内容就这么简单啊，就是这么的简单，没有更更复杂的内容，呃我讲到这儿之后呢。

我们下面来看看腾讯特别爱考的一道题，叫做什么叫做进程，什么叫做现场，终于我们开始接触现场，讲到这儿了，我还是想讲讲，讲一点小小的简单的这个这个这个计算机的历史啊，看这里都是近程联手，是这样的啊，因为啊。

最早的那个计算机呢它非常的简陋，电路也简陋，那个，该路呢也非常的简陋，他是一次啊，这只能计算一个程序，最早的它是都是用来做科学计算的啊，器械什么计算呀，什么导弹那个轨迹的计算呀。

就做这个我们写程序的时候呢，也就只能内存里面不能给的能落上去，这个不知道大家能不能听懂，就是最最开始的时候，我的计算机只能计算一个程序，把内存里头就就就都能运行这一个强行表。

像这种操作系统呢其实也有很多，其实最早开始连操作系统概念都没有，好吧，我就直接这么跟你说，就是他只能执行一个程序，cpu把这个程序呢你不，中间不能停，计算完就完了好了，这样的程序呢叫做一个进程。

到后来随着就普及，人们的需求也在不断地变得复杂，后来发现呢，如果说我们的计算只能计算各进程的话，好多需求我们满足不了，我给你举个最简单的例子啊，比方说我想一边做计算，一边做演，一边做展示，展示的话呢。

你这个程序还是要需要写到显示器的显存里面啊，显卡里面把数据写在显卡里面呃，那计计算的话呢，你计算你的你你的这个运算单元是需要运行起来的，这时候呢是需要两个并行的，你明白吗，就说一边做，这里做做做展示哎。

一边呢来做一个计算，或者说我说得更加的那个那个直白一点，你就更容易理解一点，我需要开两个qq是吧，我不能只有一个，ok那这时候怎么办呢，这个时候是可以的，当然这里面有一个比较复杂的过程，是内存映射。

我先略过它，你相信我，你跟老师走一遍这个计算机的基础知识，你会发现你所看到的任何的语言，任何语言你在看上去的时候都是对你来说都是透明的，就都特别简单了，那个我们说计算机的需求越来越复杂的时候。

我需要跑两个程序的时候怎么办呢，好了就诞生了这样的一个一个一个东西，就是很简单，我内存越来越变越大，我我内存是八兆，我一个程序只只占一刀，没关系啊，我可以装两个程序进去，我把两个程序也装进去。

qq两个q q，现在的计算机肯定都可以啊，就是你的你的机器肯定也可以跑两个，qq肯定没有，那就被被我们称之为叫两个进程，这时候就有了一个什么概念呢，就有了一个并发的概念，什么叫并发概念呢，就这两个进程。

但你看起来那是同时在运行的，我不是说我这个qq跑的时候，我另外一个qq没反应，他不是这样的，那么在cp的角度，同学们，你们想想看一颗cpu啊，我们说一颗cpu最早开始就只有一颗cpu嘛。

一颗cpu在同一个时间点，同一时间点一颗cpu在同一个时间是不是只能运行其中的一个qq啊，我再说一遍，一颗cpu在同一个时间点是不是只能用运行一个qq一个瞬间，对不对啊。

他是怎么能让我们看到两个cpu在这里，不是两个qq在这里都都在运行的，是什么情况呢，你拿大腿想想也应该知道是吧，他一定是说运行一会儿这个qq再运一会儿，那个qq只不过他速度特别快，你感受不到而已。

让这个运行一会儿，那个运行一会儿，是不是这样子，好，这个东西呢一般我们称之为叫切换，那个咱们小咱们小姐姐给我来点水啊，帮我帮我倒点水，谢谢，帮我接点水过来啊，或者来来来一个那个那个那个那个矿泉水。

嗓子不行了，嗯好它一定有一个切换的概念，这是cpu速度特别快的时候好了，这个最开始的时候呢实际上没有线程概念，只有进程概念，这东西呢一般我们就称之为叫进程切换，切换过程比较复杂，我在这不展开，唉。

这就有了切换的概念了，我稍微展开一点点啊，算了先不先不展开了，展开就比较复杂了，哈哈先不展开，这个我们有了这个进程，有了切换的概念之后呢，随着我们进程越来越复杂，就原来的进程就是做一个简单的计算。

后来的进程啊又有显示，又有计算，又有从网络上的输入输出，从文件读写挖太多了，突然间人们发现在一个比较复杂的进程内部，进城内部也有并行工作的需求，好q，我可以一边在这里打字输入。

另外一边不耽误我从网络上接收数据，还不耽误我做计算，我该下一步给谁说话了等等，你会发现呢，我们内部的工作任务也是同时并发在运行的，这个时候，如果你的进程的计算的过程只有一条线下来执行完这个执行。

下一个执行完这个执行下一个下一个下一个中单是不能没有分叉的话，你是不可能有两条线同时运行的好了，人们到这时候呢，终于发发明了什么呢，在一个进程内部，一个主的工作流程开始之后的main方法开始之后啊。

也许也也可以，产生分叉的，我也可以在这里产生一个新的分叉，让他去接收数据，在这里产生一个新的分叉，让他来去管理显示输入和输出，好这个东西呢就被我们称之为现场，所以你发现没有有一个，稍等我喝口水啊。

大家稍等片刻，我借一点年轻所，嗯所以啊你发现没有，这里呢就有了县城的概念了，所以县城是什么东西呢，县城啊其实是一个程序，注意是一个程序内部的不同的分支，注意这个分支不是说if else啊。

你一走这个它就不可能走另外一个分支，线程是什么，线程是同时的都可以走的，两个分支同时在运行，呃我讲到这儿了，我相信一大堆人就开始提各种各样的疑问，有疑问是谁的都还好。

说明你现在开始真真正正的关于你自己思考学习，我讲课我是喜欢启发大家伙儿进行一个自己的思考，同学们你们看看啊，到讲到现在为止，你看各种问题就都来了，你看看赵成挺说那个平时做的磁盘为啥说是内存对吧。

还有原来如此说，外界的网络输入呃，远都要经过内存，我解答一下这两个问题，听我说，你们问的这些问题呢会驱动着你们做进一步的学习，只有在这个时候，你们自己的知识才是慢慢的输入到自己的脑子里了。

呃保持你的也不要对自己压力太大，很多书讲的太枯燥，你要听我讲，他就没有那么难，你看啊，平时的磁盘磁盘是什么，磁盘是断了电，你的程序在上面都可以有内存，内存是什么，内存是断电就没了，听懂了吧。

这是最简单的，就是你你的平时的qq。e x e啊，是存在硬盘上，开机之后才会放到内存里去，ok那个你看啊，还有这个说外界的网络输入语言都要经过内存了，是的，为什么要经过呢。

输入源是就是外界的这种网络输入是是先交给谁的呀，你你们你你们有一个东西叫网卡，对不对，网卡这网卡上是不是有根线输入，是不通过这根线来的，不管它是有限的还是无线的，所以它首先这数据是到哪儿了。

是不是到网卡呀，网卡这个数据如果想被cpu用到的话，有两种方式啊，但是那个比较复杂，有的是可以直接访问到，但是大多数呢是要经过操作系统满了之后，把它复制到内存里面，这个布局啊，不知道是我大致说清楚没有。

保持你们的好奇心，记住计算机再复杂，包括我在内，没有一个人是天生娘胎里出来就懂，这玩意儿都是从零开始的，只不过我们学的时候比较枯燥，真的比较枯燥，我现在想起来那些个不燥，不想去去学，好好听我讲。

我们我们说很多讲法呢它是不对的，它是先讲原理再讲应用，实际上是反的，应该先讲应用再讲原理好了，当你理解了这件事之后呢，看这里啊，当你理解了这件事儿之后呢，理解了这个这个嗯现成的概念之后呢。

我们下面再来谈这个切换的概念，好好听，我刚才讲了，其实腾讯最最爱考的两个东西已经出来了，一个叫进城，一个叫县城，好呃，那么我们来思考一下什么叫进程，什么叫现场，我们进行一个思考，什么叫程序呢，qq。

e x e编译好的，可以运行的这个叫一个程序，那什么叫进程啊，一个程序放到内存里，就叫一个进程，放一个，这也是一个qq，在还可以再放一个qq，所以一个程序可以对应多个进程，而且这个进程放到内存之后。

你会发现呢它的空间已经设好了，他的数据已经处理好了，也许他要打开某些文件已经帮你打开好了好，所以进程这个玩意儿呢放到内存，好多资源就给它做分配了，但是它开始运行了吗，没有什么时候开始运行cpu。

找到它的主线程，就是我们main函数开始的地方，这个叫逐渐成，所以一个进程最开始就只有一个县城，它叫主线程，只有找到他cpu进去，拿到它的代码开始运行，这个时候才真正的动起来了。

所以有个说法叫进程是一个静态概念，县城才是一个动态概念，o进程是分配资源的基本单位，线程是cpu调度的基本单位，ok所以cpu呢是只能执行一个线程，讲到最后我相信大家应该理解了。

就是我们所谓的一个cpu在同一个时间点上只能执行一个线程，好这个概念能听懂的，给老师扣一，它是一个非常核心的概念，任何语言啊，java的内存，什么高原的内存本质都是一样的，进程不是动态概念。

线程才是动态概念啊，好了，我讲到这里之后呢，做一个小小的简单的动画的演示，这个动画窗格要缩小一点。

系列 1：P24：多线程与高并发：4.线程切换 - 马士兵官方号 - BV1mu411r78p

嗯下面我们来聊聊，什么叫线程切换这个概念，线程切换呢是什么概念，我刚才说了一颗cpu啊，他同一个时间点只能执行一个线程，实际上严格来讲，一颗cpu在同一个时间点上，只能执行一条指令。

这个指令属于某个线程，这个意思你们想一下呃，作为我们多线程的程序，可以多线程并发运行的时候能运行，假如说我们现在正在执行的是县城一，它的名字叫t1 ，要执行提一线，我们cpu是从t一里面读数据。

读指令开始运行，那假如说我们cp，我们t一执行到某条指令指令的指令二了，然后下，面呢t一的时间片到了，就说我我我我我我做a cpu呢，我每个星星都都要运行一次的对吧，都要运行一段时间，好到你这时间了。

你还没有执行完，到这儿了，下面我要执行t2 ，我怎么办，同学们，你们想想看怎么办呀，有的同学说简单啊，老师我就把t2 指令读过来，数据读过来，我就做t2 呗，但是你想过没有，如果第二执行时间片结束了。

又想执行t一了，t一执行到哪了呢，你还能想得起来吗，cpu没那么智能，他只是说你给我指令，我就执行，给我指令，我就执行我上次执行到哪了，我是不是得，记录下来啊，所以中间的切换过成什么样子的呢。

有一个过程叫做把纸啊，t一的现场，t一所需要保存的东西执行到哪条指令了，指令二执行到哪些是正在执行的时候，包括了哪些数据寄存器的内容，全部保存好，叫保存现场到你了，你是第五部，俩数据拿走。

你先自己抱着去好下面这个t2 ，再把t2 给放进来，那什么时候我们再想听的时候怎么办，恢复现场，把里面的数据再恢复回来，当然前提是把t2 又保存好，再把提议恢复回来，再继续执行t一好了。

我说到这儿能听明白这个过程，给老师扣一，这个东西呢被称为线程切换，有一个经典的小小的面试题问大家一下，我们说如果我们做一个复杂的计算程，需要，一个小时它可以线性被拆分开。

我们两个线程呢就有可能只需要半个小时，两个人干嘛，那是不是现成的数量越多，我们的执行效率就越高呢，很经典的面试题吧，是不是现成的数量越多，我们的执行效率就越高，当然不是，为什么，因为中间有切换的过程。

这个切换是需要时间的，是需要消耗资源的，当我们的建成数量越来越多的时候，我们很可能把大量的时间都放在消耗线程，切换上了，因为只要活着的现场，必须得保证每个县城都有时间执行，不然程序不死了吗。

1万个县城这1万秒里，头大量的时间都花在切换上了，你有没有时间去做计算了，所以它的效率不一定不一定是最高的啊，呃当然还有一个经典的东西说，如果，我们做一个任务的时候，有多怎么怎么来确定。

我给这个任务启动多少个线程呢，能听懂我说的意思吗，我再说一遍，比如说我们现在有一个程序对外服务，他后来后台有一个线程池好，这个时候我要有起多少个线程，对外的服务的效率才是最高的呢，其实这个问题吧。

cpu加一或乘二错还有吗，而n加一错还有吗，cpu密集密集，对c哥撑死你们，这这这是拍脑袋，想当然啊，这个问题我留一下啊，这个今天有时间再讲好吧，好，这里头得看你所谓，你首先得定义什么叫效率最高啊。

我简单简单说一下什么叫效率最高，效率最高什么意思，什么叫效率最高啊，效率的意思就是我压榨cpu，把cpu全都利用上，不让它闲着，这个我的执行效率一定是最高的，能听懂吗，我cpu让他闲着了。

就说明我浪费了我的计算效率，对不对，所以呢我cpu不让他闲着，这个效率才是最高的，那怎么样才让cpu不让他闲着呢，这时候你要看你一个工作任务，或者说一个线程，他的整个工作时间里头。

有多少条指令是要给cpu做运算的，有多少条指令不，用cpu做运算，我只需要去输入和输出的，听懂了吧，得需要做这个比例，我假如说啊我一个现成的任务，我有50%的时间是需要给cpu做计算。

我剩下50%的指令，只不需要cpu做计算，我只需要等网络上的输入输出，我想到这能不能理解，就是一个人在干活，一半时间在锄地，这个时候就是需要他动动动手的，另外一半时间在干嘛呢。

等着别人把那个土啊什么的给他运过来，听懂了吗，能理解这个问题了，给老师扣个一来，我刚才讲了，讲完了这个嗯，明白对不对，那同学们你们想一下，你们把cp理解成那个图，我有51%的时间用一个除。

好我说我想让一个处充分利用，利用到百分百多少个线程，两个，对不对，那如果我这个任务单元里头，有25%的时间是要用到这个图的，多少个县城，我让一个cpu让他跑满多少个县城四个。

那如果说我再我再出一个稍微更难一点的，我们现在有四个cpu，1234，好我让这四个cpu全部都跑满，但是我的任务呢只有25%的时间，用cpu来多少个线程，16个对，good没错，所以当你们老大。

或者说面试官在问你这个问题的时候，按照我的思路来说，听懂了吧，腾讯特别爱问，我就直接告诉你啊，基本上面腾讯的都被问到过，好嗯，我讲到现在为止呢，其实如果你要还往外拓展，我今天不想拓展，再往外拓展。

我怕有一些基础的同学会暂时性的受不了，记住学东西是有分层次的，可以先学浅层次，掌握浅层次之后再继续掌握深层次啊，一步一步来，我们的大多数的课本，和你平时所学的学习习惯是不管深浅，挨着牌的血。

这是效率特别低的，按我的来，你事半功倍，听我说，我们可以开展一些小小的基本的概念，比如说站在cpu的角度，我要给每一个线程需，要分配时间的，那我想问你一句，这个时间分配我按什么算法来呢。

能不能理解这个是操作作系统的核心，叫，线程调度器的调度算法，同学们，你们想想，你们如果是你的话，你会怎么做，动到把脑筋给我动起来，我现在问你的是，如果你是那颗cpu，现在有五个县城，12345。

你会怎么给他们分配时间呢，让你设计一个算法，咱们就讨论着玩儿好不好，有基础没基础的我们都可以，我用最简单的概念，就基本上把现代现代的操作系统，就给你讲清楚了啊，好你看啊，你看有好多好多人的想法，你看啊。

这个是嗯先来先做，就是排队，对不对，不合理，为什么不合理，可以做啊，就说大家你想到的任何算法，你说我先执行完第一个再置换另外一个，可以的，没有问题，任何算法都可以，但是我们现在的现在的操作系统。

这个算法是经历了多次迭代，好多好多年的迭代，所以你如果一次性的能想到，现在cpu所所所所能采用的算法，那你太牛逼了，你不用听我讲课，你给我讲课就行了，其实呢最开始的时候，不就是说我先执行完一个。

再执行完另外一个吗，但这个不合理，为什么呀，因为有的是加急的那种，你能不能听懂，有的是那个任务比较急，也就是它应该有一个权重在里面，他有的任务比较急，什么任务比较急，就跟那个医院似的，您平时是一个病人。

看完一个病人，但是有的急诊快死了，你再不处理我的电路有短路了，大哥你是不是应该处理优先处理那个呀，是不是那边发出来一个关机的程序，关机指令，结果呢，您前面做了计算关机，不好意思，关不了。

你等着等把计算做完了再关机，这玩意受得了吗，这边要取消导弹了，导弹要爆炸了，取消掉啊，不要再爆炸啊，先炸完再取消，那不可能，所以这个事儿不合理，所以这时候你就会发现哦，应该是有一个权重，权重高的。

应该往前放，对不对，good嗯，这是对的，还有另外一种呢，最容易想到的轮着来嘛，给你十个毫秒，给他十个毫秒，给他十个毫秒，给他十个毫秒，合理吗，也不太合理，为什么呢，给他十个毫秒没问题。

他正在要求你做计算，你赶紧做计算，但是你给下一个指令10ms的时候，你突然间发现这个指令在干嘛呢，在等着网络的输入，你这10ms就啥也不干，就搁这等着就行了，那你不是浪费吗，所以这个呢也不太合理。

平均分配啊，有些特殊情况，有些特殊的芯片，特殊的操作系统也是这么设计的，也可以，没问题啊，那么也不合理，那么到底什么样子的应应应应应，应该是应该怎么做呢，现代的操作系统呢。

这种的算法叫c completely，这说明脑袋脑袋都记忆力都不行了，不是l r u啊，那么这个算法呢叫cfs，考试系统特别特别爱考的叫completely，完全公平策略。

completely fair strategy，完全公平，这是linux最新版内核使用的算法，这个算法长什么样呢，第一优先级高的多分配时间片儿，但是呢有的那种那有的那种指令啊。

呃如果你你了解过那个wait方法，应该了解过v的方法是干嘛的，是说这个县城暂停，等着别人唤醒，是不是啊，同学们，你们想一下，如果有一个线程啊，它喂它了半天，然后把它唤醒了，他马上着急就想执行。

那这时候怎么办呢，现在的呢这个算法呢叫做结合了权重，权重越高的分配的时间片越长，有限执行，的可能性越越大，这是第一个，第二一个呢等待时间越长的，听懂了吗，我再说一遍，等待时间越长的越优先执行。

这个是有道理的，那个我人呢等待了时间，他你你给他个时间片，发现他等着呢，好放过他，给他一段时间，想让他执行了调度他哎，他还在wei状态，等待的越长，他醒过来的时候越优先给他执行，现在的现在的这个算法。

大概是这个这个样子啊，这个大体的过程，不知道大家听听听懂了没有，它不是完全按照权重，也不是完全按照时间，它是权重和时间的一个综合的权衡，ok，好了嗯，这个我在这就不展开。

因为这个是我后面讲那个什么内容的时候，才讲到的啊，你感兴趣的，你跟着老师的这个操作系统的课，你跟着走就成啊，它叫做cfs啊，当然还有实时进程和普通进程一说嗯，实施进程那就f先先到先先到先走啊。

或者是轮询啊，一般的普通的进程cfs，所以它内部的进程调度还比较复杂好吧，先不说这个呃，我们说呢还有一个特别好玩的概念，我不知道大家听说过没有，就是这个我是展开的技术不，技术不太好的同学呢，你听完这段。

你暂时先忘记它就行了啊，一步一步来，这个给基础稍微好一点的同学讲，这东西呢叫先成，也叫携程，来这个概念，面试中有被问到过的，给老师扣一，有被问到过的，有没有，go语言，对没错，是的。

应该会有人被被问到过啊，是的是的是，那么这个概念是什么概念呢，我简单解释给你听，这个概念呢我在讲go语言课程里面，就是我们课程里呢，mc课呢是包括了一个go语言的课程，再看一下。

这是dba的内容。

游戏的内容，啊稍等。

嗯包括了一个嗯go on课的一个简单的内容。

呃在这门课里面呢，我在这个购员面向对象里面，给大家介绍了go浪的最核心的两个概念，垃圾回收和那个呃。

和那个那个携程这个概念，这个携程这个概念呢是这样子的，你认真听我再说一遍，基础差的这部分呢你先略过好吧，我们说原来呢一台计算机是一个硬件，这是一个硬件，现在后来呢有了java之后。

我们诞生了一个虚拟机的概念，虚拟机概念什么概念，虚拟机概念，就是说我们在这个硬件的基础之上，虚拟了很多台不同计算机，你可以把它看成模拟出来的，很多不同的计算机，它有自己的cpu，有自己的cpu。

有自己的内存占，有自己的内存占，你可以看成是多台机器，但是呢它同时跑在好多台不同的物理机上，这是jvm的虚拟机，这是go on的虚拟机，好了，同学们，你们想想，如果你把它看成一台完整计算机的话。

他是不是可以有自己的线程啊，可以不可以，听懂了吗，docker算虚拟机吗，算我再说一遍，我们的物理机，我们的windows机器管着自己的操作系统，管着自己的现场，这是我们物理机的那个那个那个现场。

那么在每一台虚拟机里面，是不是也可以有自己的线程啊，ok这个一般我们称之为叫用户线程，或者叫线程或者叫携程，就说我们自己的程序，在自己的这个机器内部来模拟多线程的，那个线程，叫做西城或者携程。

这里面的所调度也好，同步也好，都是由谁来完成呢，由我们虚拟机自己来完成，但是你要记住，这个虚拟机最终的实现要靠谁来实，现要靠我们的物理机上的那个线程来实现，是它最终呢一定有一个映射过程。

这个映射指的是什么呢，就是在我虚拟机内部的线程，和我们物理机内部的线程，它是怎么样转化过来，由他来完成的呢，县城里的县城是的，这个一般我们称之为那叫做映射的概念，听我说我简单做一点拓展jvm的内容。

这里是一比一，比如说jvm里面如果有一个线程，物理机上就一定有一个线程，但是go浪不一样，go on里面如果有一个县城，有1万个县城，这里面很可能只有两个县城，go浪里面有80个携程。

这里面很可能只有一个线程，在它内部用软件模拟了它们的同步，它们的调度好，这是很粗的一个概念，想细究的话呢，没有俩小时是不行的，先放过它大体理解，所以这里面有一比一的概念，也有m b n的概念。

一般的情况下，m远远大于n，好这个过程简单听不代能大致能听懂吗，携程呢有好多叫法，有的叫kroutine，比方说go语言里面有的叫fiber，在jvm里面，专门可以有一种东西来做jvm的，携程。

给咱们的另外的类库好吧，java有第三方支持先写成的库吗，当然有，我在我的vip里也专门讲了，这部分，有咱们阿里的老师讲了，在阿里内部他们是怎么运用，加了就是jvm的这个这个这个线线程库，来提高效率的。

在这里先不展开，但是我我相信我讲到现在，别人再问你这些个概念的时候，你就没那巩固了，什么叫程序，什么叫进程，什么叫县城，什么叫现场好，这四个概念能说清楚的，给老师扣一，注意先生有他自己的问题啊。

并不是说用线程一定就好，不是的，不一定的，好吧好了，我有讲到现在呢，我把大体的硬件上的这些个脉络，给大家讲清楚了，呃当然那个如果你还想进一步了解，其实还可以了解，去去了解什么呢，去了解现在的鸿蒙系统。

鸿蒙里面又是很好玩的概念，它叫做微内核，哈哈这就不展开了，一般的我们现在的那个机器呢叫做红内核，但是呢鸿蒙呢叫做微内核啊，呃我在这儿不展开，下面呢我们开始聊什么呢，聊线程切换之后呢，更深入的一个概念。

你看这里，看这里，我们拿海胆这张图来说，嗓子真的沙哑是吧，嗯是有一点点会喝口水，那个，不过没关系啊，嗓子沙哑，那只是声音会变，但是知识结构不会变，我只不过讲的稍微慢一点而已啊，大家体谅。

那个心灵老师再来跟小小伙伴们聊一聊，我我需要排空一下膀胱，上课的ppt会分享吗。

系列 1：P25：多线程与高并发：5.CPU的并发控制 - 马士兵官方号 - BV1mu411r78p

呃下面我们讲什么概念呢，我们来聊cpu的速度和内存的速度，他们之间不匹配所产生的一系列好玩的东西，好吧，大家稍等啊，你先聊一聊一小会儿啊，小伙伴们聊一小会儿，咦哈喽哈喽呃，讲到哪儿了，是来我接着讲啊。

然后大家有没有想要这个笔记的，这个笔记是今天上完课，然后明天上完课，上课的ppt会分享吗，啊p p t可以有的，今天听完直播，明天听完直播，两天听完直播，一定要明天听完直播课，马老师的笔记资料。

还有整个视频大家都可以拿到，拿到呢是去找一下自己的那个咨询老师，不捡笔记资料，还有那个马老师之前讲过的呃，多线程的j vm的，大家都可以拿到，这些都是还有什么想要的都可以找他们，今天到几点。

今天差不多得到十点半吧，这个看马老师先请呃，除了马老老师讲完的这个课程，然后大家有任何的呃职业上的问题，或者是工作中的一些困惑，提升方面的呃，掌心方面的任何问题呢，呃马老师讲完课之后呢都可以问。

就相当于约今天直播间让马老师给你做一个私人的职业规划，球球跟我走吧，可以啊，球球完全可以带回家啊，呃球球是单身，直播间里所有的都是单身，求救可以带回去，阿静也可以啊，多线程下载文件啊，下载文件也可以啊。

带回去，我不可以带吗，可以都可以，所有的人都可以，马老师马老师这个比较难带啊，啊来马老师来了，诶你为什么每次都把这个框给拽出去呢，这颜值这么高，那就为什么没有信心呢，ok那我们继续，那个。

这个这个有时候没办法啊，这个不喝水吧，嗓子疼，喝了水吧就不停去厕所，就是这个这个凡事都有两面性，有一利必有一弊，呃，福兮祸所倚是吧，祸兮福所依啊，呃这个是事物的最根本的一些个规律，就是。

一件事情不太好的时候，其实往往会孕孕育着很好的机会，待会如果想深刻认识这个规律的话啊，深刻认识这个喝水尿尿这个规律，我建议大家呢去读一本书，建议大家读一本书，第一卷，哈哈哈，矛盾论，劳动著名的两轮。

一个叫矛盾论，一个叫实践论，有空的时候可以简单了解了解啊，这个呢是辩证主义哲学的嗯，好不展开了，以子之矛，陷子之盾何如呃，你说的很对啊，挺挺好玩的，当年秦国在造自己的矛和自己的盾的时候，他们是分成两拨。

那么造谣的人给他们下的命令是，如果你的矛刺不穿盾砍头，给造盾的人给他们的，命令是如果你的盾被矛刺穿了，砍头，所以最后呢最后发现秦秦国人最后造出来的毛也特别牛，可以刺穿其他国家的盾，盾也特别牛。

任何其他国家的矛都刺不穿，这就是管理，那你你你们你们上班的时候有没有这样的管理呃，字节跳动采用的是赛马机制，同一个类型的项目好多不同的项目组在跑，谁跑出来算谁的，腾讯也采用的是类似的机制。

最后士兵造反了，哈哈哈好吧，好了不开玩笑了啊，来我们继续嗯，在这里面呢有一个非常非常特殊的东西，这东西叫什么呢，叫做缓存，这是cpu，cpu的速度非常快，如果这里是刘翔，那么这里就是乌龟，龟字怎么写好。

这里就是乌龟，cpu的速度呢大概是内存速度的100倍，其实我讲到这里，敏感的同学应该会有疑问的啊，我再说一遍，我说的这个问题啊，就是说cpu的速度是内存速度的100倍，我讲到这里应该会有人有问题。

cpu呢确实是可以用速度来说的，它有主频，内存，内存哪有速度啊，内存是用来做存储的，它跟速度有关，完全关系吗，听我说这里的速度呢，严格意义上来讲叫做从运算单元去自己cpu内部存储器里面取一个数据。

如果需要的时间是一的话，那么从运算单元访问到我们内存取一个数据，它的速度是100，时间是100啊，不知道说清楚没有，所以速度是这个概念啊，那个那这个时候就会产生一个问题，同学们你们想一下。

如果下面呢我有两条指令，这第一条指令呢是去内存里面取个数据，第二条指令是什么呢，对自己的某个寄存器做一个加加操作，两条指令，那么这个时候呢你就会发现我要取这个数据的时候，我执行第二条数据。

第一执行第二条指令的时候，得把第一条指令执行完了，浪费花花，花一个花，浪费100个100个等待的时间才能执行下一条指令，哎呀这个速度实在是太慢了，我们能不能够提升这个存取数据的速度呢。

存取数据的速度能不能说明从上海呃，从北京往上海访问一个数据，比方说八个小时，能不能让他把这个数据离离我离我近一点，中间加一个中间层，放到中间，这个中间是哪呢，北京到上海的中间啊。

别到上海的中间应该是哪儿啊，诶北京到上海中间儿是哪儿啊，这个不查地图了，我们假设是嗯德州好，我们假设是德州，我们把这个数据往德州放一份，同学们，你们想想，我从cpu里去，我从北京取这个数据。

是不是就速度就快了，这里是八小时的话，这里四个小时就够了，但是所有小说我还嫌慢，我怎么办，告诉我还嫌慢怎么办，再往把这个数据往天津放一放，听懂了吗，唉就是我中间呢多放一些离我近的好，这种东西呢叫做缓存。

这缓存，那现在我已经来了呃，我中间建多少级缓存合适呢，多少分合适，这东西不好说，如果我中间间隔是就是说中间层数少的话，这个效率就会变高，但是呢我去取的时候效率就会变低，但是如果我中间层数比较多啊。

我有十层，那我取数据的速度会变快，但是与此同时带来的是什么呀，从这里头复制一份数据的时候，要复制十份，所以这个效率就会变低，所以凡事有一利必有一弊，对不对，福兮祸所倚，祸兮福所倚，听懂了吗。

所以为啥不直接放在天津，那你不中间就离这边近点，离这边就远嘛，这边复制就慢，这边这边复制就快了，就是凡事有毅力，一定必有一弊，所以请大家去读什么矛盾论，我建议大家读书，我我一般把我的mca课叫做成才课。

注意我不叫它架构时刻，我不叫他说成员，你高级成员这个不是我培养的目标，我把它叫做成才课，能听懂吗，成才这件事儿不是你搞定技术就能成才，你的思维方式，思维逻辑都要产生变化，你的格局都要起来好吧。

然后呢你才能称称之为这个时代的人才，21世纪什么最贵，想拿高薪，麻烦你让自己成为人才老师，我首先学生年薪过百万的已经比比皆是了，丁点儿不吹牛逼，教他的时候不是说只简简单单的教技术啊，但是先交技术啊。

先交技术，技术好了之后再慢慢来看这里嗯，所以你会看到层数多有层数多的利弊，层数少要层数少的利弊，那么到底我们用多少呢，在进行了多方向的权衡以及数据的统计之后，听我说，现在的cpu。

我们讲锁的时候用的是那个厕所的例子，在这就不展开啊，现在的cpu，看这里是由几层缓存构成的吗，中间有三层，我再说一遍，为什么三层为什么不多不少，不是四层，不是五层，可以四层吗，可以可以五层吗。

可以可以一层吗，可以可以没有吧可以，但是还是那句话，在权衡利弊的情况下，三层比较合适，所以现在用的是三层，那么这三层缓存呢很简单，被称之为l one l two和l free，嗯后面是一个大约的速度。

在这就不展开了，好三层缓存分别位于什么位置，物理上，我在这儿做一个简单的小小小的图讲给大家听，这边呢是一整颗cpu，就是你从平时如果去电子市场买一颗cpu，买到的那个完整的那一颗是一颗cpu。

但是呢现在的cpu它内部可以有好多个核构成和什么概念，相当于每一个核可以运行一个线程，所以你可以把它认为是好几颗cpu，原来的四颗cpu现在只不过是封装到了两颗里面。

ok在每一个盒里面有自己的l one l two多个核，也就是说在一颗cpu里面共享自己的l three多颗cpu去共享整个内存，好这个结构很简单的一个结构，嗯讲的我们今天要讲的也不是说硬件的内容。

我们还是要讲软件，我们就以这个图为例子啊，这个图能跟上的，给老师扣个一，对他有些硬件呢也在不断产生变化，demon说，现在a amd的zen 3把l3 合并了，可以的，没有问题，就是说你记住记住这一点。

计算机的发展的日新月异，芯片ai的芯片的结构就和现在的又不一样，显显存的这个这个这个显显卡的这个计算啊，它呃就是显示芯片的计算又和这个又不一样，我讲我讲的呢是一种普通话的普普遍性的。

很多时候呢你了解一个普遍性之后，其他的叫万变不离其宗，先把最根本的东西了解了，这个一般我们称之为叫第一性原理，做任何事情请你去，首先人追求第一性原理，感兴趣自己去搜索，在这儿再推荐大家一本书。

这本书呢叫价值，听说过你给老师扣个一，这不是价值，国内最大的投资机构的老板叫张磊，他投资了投资了京东，投资了腾讯，基本上全国国内比较牛逼的互联网，它投资了一半以上，五五千亿人民币的一个基金吧。

应该是还是5000亿美元，我忘了，非常非常的牛逼，他写一本书叫价值在里面搜索推崇的最核心的一个点叫第一性原理，我还是那句话，希望大家给大家伙儿啊，短短的一堂给大家伙打开更多的视野，好吧对，高龄集团没错。

而且，这哥们儿是哪儿的呀，驻马店同学们，你们平时听到驻马店的时候是什么样一个想法，10亿人民9亿骗教练就在驻马店是吧，哈哈哈哈哈，这是很早很早以前的了，好听我说今天如果大家伙儿对老师学生学课程比较认可。

后面如果想报名河南的同学，优惠500，对河南灾区的一个小小的慰慰问吧，好吧，中原一带的人民呢其实历来遭受的苦难比较多，所谓的说这里的人不好，那里的人不好，其实就是一个字闹的穷，待会慢慢变得富有之后。

仓廪实而知礼节，其实慢慢的人的素质也都会变高，好看这里，同学们，你们想一下，当我们有了三层缓存的概念之后，我们琢磨一件事儿，呃我刚才说了，说当我们的au需要内存里的某一个数据。

比如说这个数据x然后呢我们需要把它放到寄存器里，因为中间有缓存，那么这个寄存器会去怎么怎么去读这个x呀，他会首先去找找我们的一级缓存，如果没有的话，找我们二级缓存，如果还没有的话，往三级缓存找。

如果还没有，在内存里面把这个x拿出来，放到哪里去呢，换个颜色，放到这里放这里放这里复制一份，那么当我们下次再来想用这个x的时候，ok就可以直接从这里找到了，能听懂这个过程吧，很简单，但是你想过没有。

当我们又需要y的时候，我是不是又得再找一遍，再找一遍，再找一遍，再把这个y给放进来啊，同学们，你们发现没有，这个反而比我直接从这里读的效率变低了，因为每一次我都要重新放一遍，太累了，多了一些复制的过程。

对不对呀，为啥每次都要复制，因为你复制好了之后，下次再找就不用找那么远了，天津也有，就不要去上海找了，对不对，那我怎么样才能提高这个效率呢，很简单，老师你能不能够把x和y一次性的读进来嘛，对不对。

说对了没错啊，说的很对啊，就是说虽然说我们当前的指令可能只需要一个x，但是我可以把x所在的一整块数据一次性的放到这里，放到这里，放到这里，如果你不能理解，你就想象一下。

我们有一个程序对一个数组做一个循环，我们去我们到第一个数据的时候，我们一下把整个数组的数据全放进来了，那我们做循环的时候，小伙伴们，你们想想我们是不是每次只要访问这儿这儿就可以了。

那这个速度是不是就快多了好了，这个我们称之为叫程序的局部性原理啊，还有时间上的局部性原理，这个先不，管它你大致能理解这个意思就行了，懂了吧嗯好，那现在问题来了，我这个这一块到底是多大呢，矛盾论。

特别大有好处没有，当然有好处啊，我我命中命中的数据，所谓命中就是第一级缓存，就找我就找到这数据了，命中的数据数据的成命中的可能性就高多了，对不对，我就直接从这儿找着了，我效率肯定高。

但是与此同时带来的是我每次复制效率是不是就变低了，好如果特别小呢，我每次复制速度非常快，但是我命中率是不是就低了，所以，综合下来的又是一个权衡利弊的结果，目前的这个大小是多大呢。

这一块数据记住了64个字节，在此时此刻，在2021年的7月29号，工业界对于这块数据所采用的是64个字节，记住了，好吧好，这一块数据有一个特殊的称呼，这块数据呢就叫做缓存行，叫catch来。

那开出来记住它的大小多少，64个字节好，那现在问题就来了，有一个特别好玩的问题就出现了，我们假如说现在有两个县城，第一个县城呢在左边这里运行，第二个线程在这边这颗cpu里运小。

然后第一个线程我们用到的数据是x，第二个线程我们用到的数据是，ok听我说，当我们左边用x的时候，它会xy，我们假设啊位于同一个缓存行，也就是同一块里面，刚才我说过。

我们用x的时候会把整块数据放到我们的缓存里面，好从内存里读过来，放到l3 ，l3 ，放到l2 ，l2 放到l1 ，然后呢我们就可以用计算单元来做计算了，我们另外一颗cpu用的是谁呢，用的是y好。

他也会把同样一行读过来，读过来再开始做预算，这时候就会产生一个问题，这个问题是就是同一行数据，这行数据会在这颗cpu里面有一份，会在这颗cpu里面有一份，我讲到这儿能不能跟得上，能听明白的给老师扣一。

对就这里有一份，这里有一份，那么现在的问题是，当我改了这一整行数据的时候，我把x改了，我需不需要通知另外一颗cpu呢，要不要当我改了这边这行数据y的时候，我要不要通知他呢，听我说这个是需要的。

因为你不能说我这边改了数据，另外一边不知道，我还拿旧的数据去做计算，这肯定是不合适的好了，那怎么样才能通知呢，这个东西呢我们称之为缓存一致性协议，这个协议比较复杂，它是硬件级别的协议呃。

从现在英特尔cpu的协议所采用的协议呢叫做m e，其他的cpu所采用的协议呢有不同的名称，有的叫msi，有的叫什么呢，see synapse，有的叫什么呢，有的叫firefly，他叫什么，我没所谓。

反正就是不同的cpu采用的协议是不一样的，总而言之，在它的内部有一种机制来负责什么，负责两个位于不同cpu的缓存行之间的数据一致性，这个内容其实嗯比较复杂，我在这不想展开，什么时候才会触发这种机制呢。

有同学说volatile错了，有同学说总线嗅探又不对，你们都学歪了，其实是拿英特尔cpu来讲呢，只要你l2 这边写过了，它就会自动触发两边的一致性，其他的cpu呢机制可能会不太一样。

这个你要查不同的cpu的手册去好吧，关于这块内容，他对于底层的知识了解得非常的透彻，昨天晚上应该是他上的课吧，不知道大家有没有听过讲的是compleable future的源码哦，那个，啊听了是吧啊。

有同学听过了，说讲的挺好的，对是的，在这个基础之上，你会知道有这么一种机制存在就行了，那么就直接给干懵了是吧，哈哈，听黄老师课需要先打一点基础再听好吧，因为黄老师讲课会讲到比我更深的深度上，ok啊。

昨天听周老师是吧，嗯还有前天啊，忘了没关系啊，后面咱们老师都会讲课，好好听，我说，对黄老师讲的是黄老师呢，他是20，今年25岁，最早是在阿里，后来是在美团，他在20不到25岁的时候呃，年薪已经过百万。

那是属于大神级别的，所以，所以这个这个这个你听他课肯定是得好好的打一点，打一点基础啊，一会儿你们需要的话，我可以给你们看看黄老师的简历啊，嗯看这里啊，我我我还是那句话，就是说你你跟着学。

跟点牛逼的人学好吧，就是为什么把黄老师拉过来讲课，因为我觉得牛逼，还是那句话啊，就是他带你，你不要看年龄，他有些地方比我都牛，比我都牛啊，我服我也想跟着学，好了不说了，我还要看技术嗯。

缓存行这件事呢今天讲了很多基本的概念，待会儿听着也挺好玩的，也比较简单，那缓存行这件事能不能够说我们写一个程序能证明它的存在呢，其实是可以的哇，今天嗓子实在太难受了，也就是说九点半左右。

但是今天已经讲到十点了，我把这部分讲完，剩下的我明天再接着给大家讲好吗。

看这里啊嗯我呢。

啊这是一个那个阿里的阿里的问题，我在这儿呢把这个缓存行这件事讲给大家听啊，看这里，讲完这个程序，我们今天干火结束，然后呢我会打一点广告，但这个广告呢也就11点结束了，今天我们就讲到11点好不好。

大家看这里啊，cc说买了mc a课可不可以两个人同时观看，你只要同一个账号也没人管你，你就是不可能有两个账号啊，马老师的app上线了吧，你你你那个你什么手机啊，vivo oppo华为的。

苹果的都已经上线了，你要其他牌子的手机的话呢，从腾讯应用宝下载，好看这里啊，同学们呃，我们看一个小程序，这个小程序呢我就我们就先读，然后一会儿再探究它的原理，在这个小程序里面呢，我有一个计数器。

这个计数器呢是10亿啊，它是一个循环的计数就11次循环好，我有一个类，这个类叫t在它里面只有一个成员变量叫x什么类型的呢，是long类型呃，先问大家第一个问题，一个long类型的大小是多少。

大小多少占多少个字节，八个对吧，唉一个long类型的是八个字节，那么，一个t对象里面有一个x，然后呢我有一个数组是t类型的数组，这里面有两个t对象，而为零是一个t对象，2v一是一个t对象。

你可以想象一下啊，在内存里面的这是一个t对象，里边有个x，这是我们的a0 x0 ，这是一个t对象，呃，又里面有个x啊，这是x1 ，就是这么一个东西，好，我现在干一件事儿，干什么事儿呢，我起了两个县城。

这是第一个，在这第一个线程里面，我不停的修改2v0 的x看到了吧，2v0 点x等于i，然后我在另外一个县城里面不停的修改，而a一的x，好最后呢我做了一个计算。

就是说整个程序结束之后会花多长时间来完成这么多次的循环，跑一下看看啊，呃来这个这个小程序能跟上的老师可以，简单啊，来我们跑一下走，你，ok请大家接着数据的数据是大概800个毫秒，再跑一下。

看看800ms左右吧，嗯嗯然后呢还是同一个程序，还是同一个程序，你仔细看，在t里面呢，我增加一些没有用的数据，我在x前面增加七个long类型的数据，在x的后面增加七个alone类型的数据。

我其他程序啥都没有变，没有任何变化，我再跑一遍走，你，这个是240，再跑一下240，再跑一下，240，再跑一下243，哈哈再看一遍，我把这两行注释掉，再跑，788好不好玩，好，给大家十秒钟想想为什么。

为什么呢，其实你想想我刚才讲的缓存行的概念，你应该就能理解了，你想想作为只有一个x存在的情况下，同学们，你们好好想，我这个第一个是x0 吗，由于它两个位于同一个数组，第二个是x一好。

这两份数据的位于同一行的概率，那是相当的高，然后呢我们两个县城，第一个县城跑到这颗cpu里好，这行数据在这，第二线程跑在这个cpu里，这行数据在这儿，但是呢第一个线程只改x0 的部分。

第二线程只改x一的部分，刚才我说过，由于有缓存一致性协议的存在，我们对这里的任何修改它，要通过某种机制来统治到另外一方，我对这里的任何修改也要通知某种机制化交给另外一方，那我想问你这种机制要不要耗时间。

要不要一定要好了，换另外一种情形，我前面有七个long类型，后面有七个long类型，那么这个时候会发生一种什么情况呢，这个我看我有没有画图啊，有画图，我手工给你画一下，我在这里画了一个小图。

因为以前老有同学想不明白这件事，其实这件事挺简单的啊，同学们，你们仔细琢磨，我们说在一个long类型的x它是八个字节的情况下，在他前面放了七个，后面放了七个。

也就是说这个x无论和其他数据怎么样进行排列组合，它都不可能和另外一个x或者另外任何其他数据位于同一行，能不能听懂，为什么恰好是七个呀，因为我们一行数据是多少，64个字节不就一共是八个long类型吗。

假设我们的x前面七个加x8 个，后面七个加x8 个，对不对，既然这个x是为在这行里，另外这个x是在另外一行里，那我一颗cpu改这个我还用通知别人吗，我们效率是不是就变，是不是就变高了。

good一定变高了，来这块能听懂的，给老师扣一，那有同学说老师这跟语言有关系吗，跟语言你说有关系吗，半毛钱关系没有，你是c语言，你是c加加语言，你是java，你是go。

随便你就是我建议大家就是我们mc课里大量充斥着这一类的内容，它跟语言没有关系，它叫做架构师课，知道吧，我觉得这样的内容才是值得你好好掌握的，至于语言的语法我不知道了，查查类库不会用了，查查没有关系的。

很容易搞定好，那现在我们我们继续说，我讲到这儿呢，有同学可能会问说老师真的有人这么写程序，是的，有一个特别牛逼的框架，听说过的同学能跟老师，不是能跟面试官聊起聊，聊起来的时候呢，你能很有很大的加分项。

这个框架呢它的名字叫disrupt，disruptor，翻译过来叫闪电，嗯形容它的速度非常快，闪电是原来得过杜克奖的一个开源框架，这个框架呢那个他追求的唯一的东西叫做效率，它是一个什么东西呢。

单机最快的mq消息队列，消息队列呢多数同学应该听说过，一个容器里面装着各种各样的消息，有生产者不断的往里扔，有消费者不断的往外拿好了，这就是一个消息队列，一般的消息队列啊，要么用数组。

要么用链表链表好呃，像这种东西呢，一般数组的话两个指针头指针指尾指针链表也一样，头指针尾指针好，为了追求效率，disruptor用的东西叫环形队列环，环形队列，环形队列有一个好处。

只需要一个指针就可以了，不断地挪，挪到脑袋上之后，又继续往下挪，不断地转圈转圈转圈儿，当然它是一个首尾相连的数组环形队列，我讲到这儿呢，有同学可能会有点懵，说老师我一个环要是全装满了的时候。

我在往里头扔数据怎么办，cs方式等待消费，没听懂就算了好吧，就这里面是另外多线程的另外的概念，如果说呃今天来不及，我明天给大家讲这个概念，它是提高效率的，另外一种方式叫cs方式，等待消费。

消费完了再往里装，无了是吧，有好多同学说老师您讲完课之后，我突然间发现好东西串起来了，那就对了，因为我讲的是什么第一性原理是吧，我讲的是什么矛盾论，刚才浪费了空间，节省了时间，浪费了时间，节省了空间。

有利有一利必有一弊，有一弊也存在一例，听我说，我们说这个环形队列它的全称叫什么呢，叫做作ring buffer，ring环形buffer缓冲区，环形缓冲区，这是它的一个类，我们点进去看一看它的源码。

点进去，当你看这个rain buffer的时候，你会发现它有一个cursor value，就是指针，指针指的位置，你会发现有特别好玩儿的七个数据扔在这儿，龙龙龙龙龙奇怪奇不奇怪，我说我不跟你讲。

你一定不明白这七个数据干嘛的，你信吗，到现在我觉得大多数同学应该都明白干嘛使的，填充用的，有同学说老师那不对呀，你在这里面只填了七个，后面有七个，假设它是后面那七个，他前面应该还有七个呀，对不对。

别着急，rain buffer，它的父类叫做rain buffer fields，点进去，rebuffer fields的fly叫rebuffer padding，点进去，在他的父类里还有几个。

看懂了吗，来能get到这点，同学老师可以，是的，为了追求效率，程序员极客们无所不用其极，确实有的人会这么写，会追求这样的效力啊，要笑死，为什么要笑死啊，你跟面试官把这个事儿聊出来，50万年薪就等待你了。

知道吧，孙子和爷爷有七个，哈哈，第一次看到这样的写法，对，很好玩的，我后面给你讲的型号，你会你会看到会更加的奇怪，就以前有同学有同学说，老师听完你讲课，我都不知道该怎么写程序了，没事儿。

知识这东西是先学后再学薄，也有好多时候就跟人生的道理是一样的，有好多人说啊，我看开了，有些人是觉得自己看开了，他没有经历过什么事，看了几本书觉得自己看开了，有些人是什么样的呢。

经历了很多事情的最终的顿悟，这是两种不同的境界，慢慢来好吧，先把人声做厚了，然后很多事情呢你就看得通透了，先把书读厚了，先把知识学好了，然后你就看得通透了好吧，由繁入简，由简入繁，再由繁入简啊。

这个闪电英文名全名叫啥，disruptor，就是闪电的英文名嘛，你搜一下。

好了，我这个嗓子确实今天非常的不太好，因为因为我今天其实还可以给大家讲一些更多的内容，但是呢我今天速度稍慢。

请大家见谅，我明天继续好不好呃。

系列 1：P26：多线程与高并发：6.课程答疑 - 马士兵官方号 - BV1mu411r78p

11点钟我们结束，我留一点时间，也是我们月末了呃，做一点小小的广告，大概15分钟不会超过这个时间，我首先介绍简单介绍我们课，我想介绍这个课呢，是想通过这样的方式来介绍。

通过我们整个机构的历史的方式呃，我们我们自己的机构呢，大概是在2019年登录腾讯课堂，当时呢我们做了现有知识模块里面的，这部分内容呢你们可以去自己去读，多线程的部分呃，内存的部分，漂游的部分。

操作系统的部分，网络原理的部分呃，底层的一些东西，还有呢架构相关的一些东西，各种消息的中间件，还有能源码相关的为服务相关的优化，相关的侧开相关的5g相关的数学，相关的软性的知识。

这部分呢我把它简简称为知识点课程，就是每一部分可能它是一个完整的知识点，你可以认为什么是什么，卡夫卡克哎，各种的rabbit q，它是一个完整的知识点，这个大家能理解吧，这是19年我们上的课，这个课呢。

当时我们的目标呢是，让咱们大多数的程序员，要拿到30~50万，绝大多数通过这个课是可以是可以到的，呃但是呢就是说把握性不太高，为什么不太高呢，因为有很多人说说老师，我们知识点确实学了，但是呢我没有项目。

大家找个工作应该会了解，没有项目的情况下，你的简历很苍白，只写知识点的话，写不出技术水平来，所以呢在20年的时候，20年的前半年，我们整个课程体系做了项目的更新，项目呢我就不一谈了，网游的最近也可有。

有有一个小伙伴靠这个就进了腾讯啊，然后呢嗯何佳芸的入门级的项目微妙的嗯，网约车的啊，一级一流量的嗯，推荐系统的啊，流式计算的啊，以及中台中台这个我们打算换掉了，因为中台这个概念在阿里都快被逼引起了。

然后呢呃我们举一个小例子啊，就是拿网约车来讲，网约车呢目前是已经讲到了第四版，第四版应该讲完了，现在正在讲的是第五版的内容，嗯，这每一版主要是什么呢，用的不同的技术层面，呃。

第二版的时候我们当时用的是spring cloud奈飞呃，就是奈菲那套ring cloud微服务相关的东西，第三版的时候呢我们讲的是spring cloud，阿里巴巴国内用的比较多的啊。

就是阿里巴巴相关的，sorry，第三第三版的时候是按耐飞的，更进一步的详细的解释，以及里面的什么多些这个分布式事物啊，嗯这个这个这个各种的网关怎么怎么做，怎么做呀，各种发布怎么做啊，滚动啊。

这是第二版的一个增强版，然后呢呃第四版的时候是spring cloud，阿里巴巴也是国内最现在最流行的呃，目前我们讲的是第五版，第五版是什么呢，就是第二代微服务，它全称呢是叫做service mesh。

叫服务网格，它的落地呢落地的名字叫is steel，这个你听说过也好，没听过也好，不用担心，因为这里呢是老师带着你往前走的，呃，就是我们帮你找最流行的东西，你不用管，这两个的结合就是知识点结合上项目。

这两块知识的结合，大概基本上非常有把握的，可以让你到30~50万，好了，那么在这个基础之上呢，有些小伙伴就又不高兴了，说那个老师，我本来我现在就拿30万了，诶，今天有来的，有没有拿30万以上年薪的。

给老师扣个一，有没有报名，美版都能看吗，是的嗯，应该有啊，因为现在30万以上年薪了，就是不不太难达到了啊，不用客气，也没有人认识你啊，在30万年薪以上，我们又做了一门更深入的课呃，这个课呢叫做架构师。

全称呢叫m c a级架构师，这个课的目标是什么呢，这课的目标是构建互联网，三高相关的架构知识呃，这个呢叫做high availability，高考应用，high scalability，一块叫高并发。

一块叫低延迟，两块相辅相成，这全称叫高兴的，我们怎么样才能达到这种互联网级别的，三高架构呢，我们的双11也好，018也好，流量呢非常的大呃，12306，好那这时候我怎么怎么能撑得住呢。

好就这个架构该怎么做出来，在整个围绕这个架构的体系，我们大概做了1234567，大概14篇左右的理论课，在这嗓子关系。

我真我我我我我真就不想给你打开了，好吧，你如果感兴趣的话呢，ok，那么在这个基础之上，市面上n多的机构讲这个东西啊，不管他能不能讲，能不能落地，反正人家也讲呃，在这14篇理论的这个这个内容上呢。

很多人呢觉得自己就掌握架构了，其实不是，为什么，不是呢，因为我呢是从线下教小白开始呃，来给大家讲课的，我最希望的架构师是叫做能落地的架构师，是就是你只会画图，落不了地这事儿肯定是不合适的。

能落地的架构师，那什么样才能叫能落地的架构师，就是我们做了这样一个项目，这个项目呢叫东宝商城啊，啊这个东现在我们改名了，不叫这个咚咚咚咚锵咚了啊，现在叫，那个黄老师带队来完成，东宝商城的全方位的落地。

那么这个落地呢，就是你要从搭建分布式的d生中心，搭建分布式的配置中心，索集群事务集群啊，就各种集群搭好之后，注册中心监控mq的集群，es taning，mysql存储集群，在各种的集群的基础之上。

再来进行实际当中的代码落地呃，在目前我们这个项目已经部署到了公网，是大家是可以访问的，我找一下访问文档，我找一下访问文档啊，呃目前还没有给他配域名，目前是一个ip地址，不过没有关系。

大家挑这个ip是可以访问的，并且它是可以做到弹性的扩缩容，比如说我们现在的并发量的支撑呢，100个没关系，你如果想来1万个程序，什么都不用动，只需要在云端做扩展就可以了，呃到目前为止。

我们大概部署了五台物理机，大概应该是有七八十个逻辑节点，这个我我我这么讲，大家能听懂吗，因为有些基础确实比较弱的人啊，不知道大家能不能听得懂，嗯现在应该有数据的只有手机，应该是应该只有手机。

应该是有数据的，只有手机啊，我加入购物车。

登录一下。

叫什么，我说我跟我说，这是不是已经有了，好不掩饰了，因为这个，已经假如不购车了，我们去结算，买了两台是吧，呃做在线的支付还是快递在线支付啊，尽量提交，我选支付宝啊，支付宝来支付呃。

那个支付宝呢主要是有沙箱的存在，所以他那个服务呢一直不是很很到位，嗯，你要愿意扫个码的话，你就可以做支付了，那就算了，我就我就不做这个支付过程嗯，就是怎么说呢，我们这里的这个东西呢。

不是为了给大家展现前端，而是为了给大家展现后端呃，大家伙呢也可以在夺宝商城的嗯。

在首页的地方呃，可以直接选我们的白皮书，你可以就可以直接下载了啊，小伙伴们呃，我们后面呢还是想把整个的项目呢，大概今今年想给他做得，非常非常非常的完善，把各种层面的东西都给大家考虑到，都坐在这里。

怎么说呢，以前呢好多同学呢说，老师我我是真的很想跟完这个项目，因为更完这个项目的效果大概是，百万年薪左右这样一个水平，为为什么这么说啊，嗯看一个小小小的案例，这是我原来一个学生。

他当时呢是嗯花了90万，花了90万，那个进腾讯拿了90万年薪，那么腾讯呢问他的问题是这个问题，是这个问题，你感兴趣你可以做一做设计，就这个设计做完，那你离腾讯的90万年薪就近了一步，你明白吗。

呃那么这个东西呢，实际上它集成了集中了互联网的三高，30秒抢1亿用户数3000万，我们说并发百万吧，可以说百万到千万之间，高并发连续抢只能抢成功一次，资源评估，这个跟秒杀非常的类似。

对不对，这是他做的一个设计，这个呢我们形成了专门的一个课程，叫架构设计，那么我们这个项目呢是叫做集架构，设计和架构落地之大成者，以前呢我们在没有更完，我们自己的知识点之前，我们这个项目呢。

也是很少有同学能赶得上直播，在这里跟大家说一下，8月1号第二个版本直播课，这个项目的落地过程，8月1号落地开始呃，你放心，你跟完这个项目一定叫做物有所值，他会是以一个项目为中心。

redis那个知识点这方面，调一那个知识点相关的算法，那个知识点ai推荐那个知识点，分布式微服务，那个知识点秒杀，这些是我们原来讲过的课程内容能听懂吗，这个是我们核心中的核心，好了。

我觉得我整体的课程的内容，我就大概介绍完了，可以这么说，就是按照薪水来讲，305000 100150，我同学说了嗯，老师这个课程的价格是多少啊，今天的活动点，应该是12000多块钱。

那么有同学说老师说第一我没有这么多钱，没有关系，分期24期，一个月500块钱左右，老师那个我我还是没有那么多钱分期，另外一种分析方式，前四个月一分钱不用掏，老师我还是没有那么多钱买迷你版。

我把薪水先涨到30万再说，再往后再补后面部分，但是如果买迷你版再补，就会比这个价格更高一些，我个人是推荐一次到位，腾讯课堂上大多数跟我们讲类似课的，大多数只有这这两部分，甚至这两部分都不到。

很少有人有这部分的听懂了吗，我建议你一次到位就行了，有同学说，老师我学到一定程度是一个什么样的水平，我觉得废话呢，我也不太想跟，在这个网址上大概有接近1000个学生的，我们学完这课部分。

学完课程之后的内容，你可以一个一个一个挨着牌的看都可以，有最近的，有以前的，找出一个我们任何一个造假的来，1万块钱一赔一好吧，我直接赔，直接赔给你，这个呢可能是最近比较多的，我们可以看几个典型。

怎么说这个两个offer，这是应该是最呃。

是在年年年底那会儿，因为他当时要求说老师你要公布我的信息，麻烦你过半年我说可以，他在阿里拿的是60万年薪，阿里拿在京东拿的是70万，最后呢是选了京东，他说感谢马老师，在马老师这学了很多东西。

你们今天晚上来，我虽然讲的慢，你们应该也会也会有所收获，所以我们课程的量比较大，主要是因为呢我们确实讲的比较细，我们想讲的比较深入的内容，比较细致的内容，即便讲到这儿，我个人其实还不太满意。

所以在我们的很多的内容，目前也在动态增加，什么叫动态增加，就是说当我们感觉到感觉到，学员应该还要掌握这个知识的时候，把这个课程给加入，当然我加入新的内容的同学说，老师那还要还要不要单独收费。

需要老师怎么样单独收费呢，每年一块钱，学费是这个数，这个学费顶1年，那第2年再升了，升升了内容怎么办，给我们一块钱，你再学1年，第3年呢再给我们一块儿，写在合同里是没有问题的，呃这个大家能能听懂吗。

没问题吧，课程是没有有效期，它不是说没有有效期，有效期是1年，但是我们你后面还想继续学，我们那个更新的内容怎么办，因为我们内容经常更新的，每个月都会更新，说一下那什么吧，说一下最近的我们的更新吧。

打算呢还没有讲到更新，感觉今天是有点点累啊，我没关系啊，我们慢慢聊啊，大家只要不嫌我慢就行，今天的节奏怎么样，今天今今天那个推荐有更新啊，最近呢大概有这么几个更新。

第一个呢叫做金九银十的面试突击，每年有两个跳槽的高峰期，也是非常优秀的，涨薪的时间，一个叫做34月份，一个叫做90月份，想进一线大厂算法你是避不开的，互联网三高项目的直播课，这以前呢从来没有说。

专门把这个课程拿过来做直播，8月1号开始，嗯还有一个比较牛逼的课，是我们最近更新的，要更新的bat bat w w是什么微博，因为我们这个老师他是在微博，孙老师原来在京东，现在在微博。

他会给我们分享这样一门课，叫做大厂项目的bug处理经验课，这个是很牛逼的一门课，是绝对值得听的，以前我们买我们课程的学员，要不要再单独交费，要不要要不要有怎么调一块钱，听懂了吗，这四个课全部对对。

今天报名的小伙伴不用单独干别的，第一原来mca课不涨价的情况，万一后我们会稍微涨涨点小价格，没办法，我们把整个内容从腾讯课堂，全部搬到我们自己平台，但是带来我们成本会巨量增加，一个流量费。

一个空间费云云云，空间的好，今天晚上在老师这儿依然是这样的，这四个不单独升一分钱，还有以后的升级依然是一块钱，好了能get到这一点，同学老师可以，所以有没有有效期有1年，但是呢后面的像类似于这样的升级。

还会多的是记住了吧，因为我们升级的内容，从是从原来的那个很小版本，一直升到了现在，2019年报名的学生，到现在为止，依然可以听我们现在的更新的内容，没有单独收过一分钱啊，最近的倒计时的两天指的是什么呢。

是有一个内容要没有了，就是这个腾讯课堂，8月的7月份的活动平台，满减是700块钱，到8月份你想要都没有呃，我这么说啊，就是今天你麦克，很可能比前面的学员还便宜，比后面的学员也便宜，为什么。

因为这个优惠不是我们给的，是腾讯给的，过这个月你想找我要，他一定没有我们三榜第一的奖学金，每个榜第一奖100，三，榜第一三百，这里头有一个有一个1000块的优惠啊，至于其他的我就在这儿就不接受好吧。

化妆美容呢我大概都介绍完了吧，嗯案例呢可以看，我每次我老师啊，我直接跟你说，我每天最喜欢看到的就是这些，知道吗，关注我们，那明天再见，这个呢是从呃进，这是阿里菜鸟到阿里菜鸟，它大概涨了50%。

这是当时找我咨询那个jvm课程的时候，就调优的课，跟菜鸟谈那个入职的工资啊，34x15的一个薪水，你自己算50万年薪左右嗯，这是国美offer涨薪涨了三倍，这是我们班主任老师在跟他沟通啊。

入职了还可以三倍哈哈，他原来是8k现在是23x14，这哪值三倍，这个是老师指导之后，校招，入职阿里金子翻了倍了，就是说有的时候呢你看上去好像呃，这1万多1万块钱，但是呢其实你收回这1万多块钱呢。

叫做分分钟，还有一个我还是那句话呃，一个人来讲，他一定要不断地拓展自己的认知，我们能带给你的是20多位老师，你拿大腿想一想，你也也会比同龄人走得快得多，这个是虾皮85万年薪的，这个是两个月呢。

大概涨了百分之多少，你自己算吧，我也不知道啊，这是火币网offer翻了倍的，这是14x14的，涨了5k的啊，这个是四个月涨了30%的。

这个网址是对外公开的，呃你们自己去找好不好，嗯，呃有很多相关的大专生，这是自考大专的对日项目转过来的，这个是自考大专业性水平翻了倍的，这个是网络大专，14k涨到25的，这个是大专非科班薪水翻了倍的。

呃这个是沈阳的大专，66。5~14啊，在沈阳那边还可以啦，a哪去了，啊这是不在，呃在面试申通的时候，接没接到阿里的电话啊，不然就进阿里了，也比较倒霉，属于这是大专学历呢，收到了很多大厂的offer。

从没工资到就业的啊，呃不展开了，好了我我觉得我要说的就说到这儿呃，大家伙呢现在还有15分钟啊，对今天晚上的内容基础课嗯，对我们课程的，对我们那个那个那个那个活动的内容，你都可以跟老师聊一聊，好不好。

那就聊着玩儿，我是知无不言，言无不尽，不做夸大，也不会谦虚，想找比我们更牛逼的课，你应该是找不到的，还有女学员的对嗯，女学挺多的啊，这是非科班的女学员，5年的，找几个女学员的吧，就是你可以自己搜一搜。

我没法打开来看一看，因为很多人呢你的情况很可能是一样的。

这是女生两个月17~24了。

这是女生跳槽，就是涨了10k的。

就一个月10k啊，就一个月就涨1万了，不是说那个好多个月啊，这是25岁女生年薪30万offer的，这个不清晰的呢是原来接的啊，就去年或者前年的时候清晰一些。

都是啊，今年或者去年下半年啊，这是刚才那个结果了啊，四个月薪水就直接翻到48万了，这一点不夸张啊，我还是那句话，你通知老师，这里要找到一个假信息的一个p的老师，直接赔你，把学费赔给你啊，就是还你学费。

再赔你学费就懂了吗，我觉得他说的挺好玩的，好多知识融会贯通，这是对的啊，这个也挺挺典型的，因为这个这个这个姑娘呢是呃原来在外企，后来想再跳一他薪水，它主太凶了，你知道吗，他平时不努力嗯。

老爸老老公孩子热炕头呃，这个又重新回到行业，拿了外企的offer，还涨了薪水，而且最最关键还涨信他原来是33k，现在涨到45k。

呃呃二本的女生，小公司跳到滴滴的，年年年薪涨了13万，这是你1万的投入，这个是45岁的女生，在多伦多涨了50%，这是一个女同学，滴滴和小米2个近60万年薪的offer啊，嗯我不一一找了，好不好。

不要等着我们涨完，涨完价格，然后呢，煮完了，然后才想起来这件事，那你就亏大了，而且腾讯的这种奖学金啊，也不是说月月有的，1年可能只有一次，金九银十开始了吗，金九银19 10月份才开始啊。

但是我们现在对金九银十的突击班，已经开始准备了，明白了，这图标也是很好玩的啊，我们每一个课开的时候，并不是说我们拍脑门儿开都是有它的道理，是多年经验的总结，就是突击，为什么要突击啊，为什么要突击。

同学们是因为有些同学着急找工作，他来不及呢，把知识掌握的比较嗯扎实，那这时候怎么办呢，短期有没有办法安利，就是学员们的各种需求，促成了我们所有的这个课程，呃这是重点，只是个突击涨薪40%。

这哥们儿是报名报了七天。

学了四节面试突击课，直接收获了亨特加offer。

不是盖的啊，很很牛逼的突击课本科生嗯，这里有个链接练错了啊，哎咱们小姐姐把这个链接跟我，把那个告一下，报告报告一下啊，这个标题跟那个图片没有对上啊，他本来是本科生啊，突击了一周，涨了10k的。

就是没有对上，嗯这个是专科生。

31岁，然后两个月的面试，突击多个offer就搞定了。

什么叫突击，你想短期就想涨薪吗，突击班是不是挺好。

mc课是一个很神奇的课，就是我们在搭建自己平台的时候，我们不是搭建了自己的平台吗，我们的主打歌叫m c a，就mc课是一个很神奇的课，呃我这么跟大家说啊。

在我们整个体系课堂里面，嗯这是实战课，这是体系课，呃，可以这么说啊，就是在我们整个体系课堂里面，很多的课程都是从mc可以衍生出来的，比方说网络安全啊，这个是通过我们那个原mc可衍生出来的呃，目前嗯。

我很很可能要在后面把它给单独出来啊，对你现在购买的话，运维了呃，go on就是我们mc课，数据结构与算法的呃，前端的ai的智能物联网，嵌入式物联网测试的，然后云原生的游戏开发的啊，呃e的啊。

那个呃dba的就是说我们很多很多的课呢，其实是从mc克眼上开来，就是mc课是个，什么东西，我把它定义为程序员的人才成长课，我再说一遍，这个东西叫人才成长，就是我个人建议你扎扎实实。

以每年一块钱跟着老师把mc慢慢学完。

你会真正的体会到，别人那百万年薪是怎么达到的，从最开始的提问的智慧怎么问问题开始，教你一步一步一步一步跟着老师慢慢走，有一部分知识点的课是录播课呃，我们的项目的课是直播课o，播出很科学的一个的讲课方式。

就是讲课的效果，就是现在你看到，你去别的地儿可能就不坑，有的人可能挨过口，老师这里来，老师这里的还没有任何说，认为老师这里有坑的，听懂了吗，老师你的课太多了，能不能给我一条清晰的线路，说对了。

课不多就不能做到因材施教了，所以在这里像那种短期的内容，老师可以帮你定制路线，你可以从哪一节，哪一节，哪一节并行学，然后再汇总到哪一节，然后用几个月时间，完成一个什么样的目标啊，一个大体的演示嗯。

这就是我们现在的课，只有这样才能达到现在的这个效果，直播课会给代码吗，呃代码是公开的，当然可以给，我们是准备把它做成开源课的。

你重点体会的，其实啊今天我们顺着我们，我我今天的内容讲可以吗，今天我给大家呢也留了一些东西，比方说c a s是一个什么样的东西，我今天呢就给你讲到了，先这个这个叫，呃对这个缓存行的一致性嘛。

实际上呢保证它的可见性，这件事还是比较复杂，呃明天呢我跟你讲可见性和有序性可以吗，在后面讲多线程的赢呢，我就不再讲这个底层的内容了，其实底层内容挺好玩的，但是后面我想讲一些什么东西呢。

讲一些大厂的面试题呃，最近大厂的面试题呢又开始作妖呃，各种各样的面试题都出现了，如果你们想去领一些大厂的一些，面试题的资料，也可以去找一下我们小姐姐领，呃，我们到目前为止应该是讲解了。

大概是300左右的题，已经讲完的，预备讲的是接近1000到呃，会做那个题库，说哪道题不会了，在我们库里搜一搜，好了就到这吧，好不好，你们去骚扰骚扰小姐姐，骚扰骚扰小姐姐，给你放音乐，放点小小的音乐啊。

放身上下，我的膝盖，这么跟你说，如果你还比较年轻，做老师关门弟子，就是如果你要比你还比较年轻，想做老师关门弟子的话，其实你水平还没到东北人嘛，呃河北人，那个我最近有想收一些关门弟子的计划。

就是这些关门弟子呢，我想第一个呢要把它送进大厂，第二个呢打开它的人声空间，就这个东西还是挺难的，嗯，打开你人生空间的需要，打开你的格局和思想呃，呃，我直接这么跟你说，我大概1年我大概要读100本书。

就是我在教学管理给大家讲课，在这个之余，我大概会读完100本书，如果你们年轻的时候啊，你到老师这个年龄，你会发现你的人生很广阔，什么35岁，什么中年危机不存在的，第二个呢我我我我自己报课程。

我直接这份工就这么跟你说，基本上几10万是有的，就是你到最后你会发现，你这辈子做的最值钱的投资是叫做投资，你自己好吧，你会发现呢你去做别的投资可能会亏嗯，可能会亏得一塌糊涂，但是你花在你自己身上的钱。

十倍百倍的赚回来，负责任地向你讲，咳咳咳咳，半小桥菩提下策马，纵向后，灰黑的烟，三叶的秋吹落了3月天，风满楼游荡在心间，走啊喝点水，下下聊着玩啊，我慢慢说啊，对，嗯当然我看书也特别快，这个是练出来的。

这个最开始看书也慢，后来我慢慢发现了书的一些规律，对有时间我慢慢讲给你们听，就特好玩，其实有很大多数的书呢，是不不值得你去仔仔细细的阅读的，诶你们想听老师给你们推荐几本书嘛，想听的你给老师扣个一好不好。

有想听的，我看有多少人啊，还在，训练营的人少了一些，公开课的人还是还是有一些啊，想推想听推荐人文的，还是想听推荐技术的呀，人文是吧嗯技术好吧，这边人文这边技术呃，推荐技术的话呢其实比较简单。

我我我我我给你看，我们上vip的时候给大家推荐的几本，嗯这是原来曾经给大家推荐的几本，几本书啊，嗯有一个编码是吧，深入理解计算机系统啊，如果有语言的话，推荐这两门c和java版。

当然嗯如果你跟老师学的话，那你就不用去再看这个书，是因为呢呃在科普o c e，java数据结构与算法，算法和算法导论，这个算法导论有点太难了，还有这个计算机程序设计的艺术，我不建议看呃。

像数据结构和算法这边你什么都不要想，就跟我们的算法直播课啊，就跟我们算法课呃，算法课老师叫左成云，这个有同学听说过的吗，如果不知道的话呢，百度搜一下，中国讲算法最好的老师，没有之一。

不说话是是去百度了吗，destiny destiny，destiny，嗯嗯嗯，嗯嗯嗯嗯嗯，嗯还有活人在听老师讲课吗，没有的话，我就我就下了啊，有是吗，多大必须都有嗯，看看黄老师简历。

还有一些这个内核系统，还有tcp ip，这些都是非常经典的书，但是你像什么什么java，什么快学30天，那什么这个速成那个速成你别看了，也没什么意思啊，马老师是不是在用传说中的机械键盘啊，师弟老师。

什么轴的，我忘了，1000 1200多，用起来很爽的你值得拥有，舍得买吗，如果你自己买嗯，买个1500左右的键盘，你们舍得买吗，是的，那岂不是要做到三回事嗯，不舍得就穷吗，我有十把键盘嗯。

小小你是那个小小小富婆是吧，其实啊，这个也很简单，多多挣钱，一句话呃，如果你理解不了，更深入的说什么宽广的结局啦，宽广的格局了，什么更高的层次了，你理解不了，这个没有关系，多挣钱总能理解吧。

就是别的不敢说让你多挣点钱，老师是最有把握的，知道吧，就课程别的不敢承诺，说承诺说你跟老师学完之后，涨薪这件事基本是百分百向你承诺，就多挣点钱，总是没问题啊，看看黄老师简历，可以啊，带你看一下。

找几个典型的简历给你，你们想想看哪个黄老师是24岁，年薪60万的时候，搭档是仅阿里是60万金的，金美团是85万，小股票一共是百万多，29岁年薪120万的，32岁的60万的大专，44岁大专的百万的。

想看哪个，呃算法工程师适合报名m c a嘛，算法工程师，你是ai算法吗，ai算法报我们ai课，ai课也是全网最全的和最深的，推荐系统哎呀，推荐系统谈不上算法工程师啊，你不要不要把自己叫算法工程师。

推荐系统的叫做，但是你得看你推荐确实是研究，推荐算法的吗，保ai如果你研究ai，如果你研究工程的到mc就是推荐系统，算法工程，听懂了吗，推荐系统工程mc，专门研究推荐系统算法的保ai课好吧。

20 24岁那个是吧，ok，多数不具备这个水平了，你30可能应该也没有。

黄老师24岁的水平，纯技术，一点没改啊，黄老师的原封不动的拿，拿阿里60万年薪的时候呢，后面的一些咱就不看了，好吧，呃课程里全有放心，就是我给你展示了任何的简历，他敢写的东西放心，咱们课程里全有。

只不过你是要用多长时间，以什么样的代价把它拿到手啊，这个也看看29年薪120万的，想看的扣一有十个扣一我就看，少于十个就不看了，三个四个五个六个差不多了。

仔细看这个简历啊，最值钱的是在这儿具有分布式高并发，高可用大数据量的系统架构，设计及研发经验，拿到年薪120万，这里占了80万，这里占了40万，看一眼课程里头关于源码的部分，四人源码。

呃林老师大概讲spring源码的话呢，两个半小时，两个小时分钟，一共讲了呃34节课，然后每节课的话呢，差不多两个到三个小时之间，差不多80个小时左右，好好想清楚这是一个什么体量。

就是说为什么读了我们的源码，可以达到p7 水平，是因为源码讲完呃，基本上你就可以做到可以定制spring了，注意是定制开发啊，不是拿它来用，不是用它，而是开发的，没法好论文转账开发呃，我建议你读博。

不然的话呢你在企业竞争力不强，听懂了吗，嗯如果不读博的话呢，转java开发是可以的，呃建议你跟我们ai的老师学，这是一个方向，艾老师主讲老师姓卢，卢经，原来腾讯ai主管北大的博士后。

爱奇艺的team leader，我给你找的老师没有一个是菜的，好同学，那个不敢跟郝老师学，其实郝老师的一两句话，会顶蔡老师的一堆话，承认就好，跟点牛逼的人啊，跟对人的话，选择比努力更重要，哈哈哈。

ai可能有哪些啊，另外课，我们看一眼啊，稍等，为什么我每次都是把这个iot的给忘了，嗯稍等片哥了，大概来看看了，那我找不到最新的了啊，看一下老版本吧，这个呢是a i和i o t的一个结合。

就是a i全称叫a i o t，呃ai的部分，然后呢呃语言的部分，然后i o t的部分呃项目的实战啊，大概大概有一个40多个项目左右吧，呃我简单跟你说吧，大概涵盖了这些内容啊，就是，第三呢是那个llp。

nlp呢，就是基本上涵盖了推荐广告，搜索推广搜三部分，那么量化量化交易量化呃，cv部分，加起来也就是a i o t的部分要多，要一下那个嗯，要一下那个白皮书就可以了啊，好了好了，真的不跟大家聊了。

嗓子有点受不了了，see you tomorrow，see you tomorrow。

系列 1：P27：多线程与高并发：7.现代CPU架构给多线程编程带来了哪些挑战？ - 马士兵官方号 - BV1mu411r78p

昨天呢我们讲了一些硬件级别的东西啊。

就硬件级别的东西呃，也讲了很好玩的一些东西，就是我们的嗯缓存行，缓存行的对齐啊，这方面的内容呃，有同学说昨天老师我没来，没有关系啊，听我说今天的内容呢跟昨天没事儿啊。

没有直接的联系，你呢接着来认真的听啊，你今天照样是有巨大的收获呃我们先看这样的一张图，这个图呢我昨天展示过呃，今天呢继续，我们在作为复习也好啊，作为新人来说呢，我们给大家做一个简要的介绍也好。

呃回想一下啊，就是说呃什么样的东西呢叫一个程序对吧，昨天我们讲了好几个概念啊，什么东西什么东西叫一个程序，一个程序呢就是我们写好了，编译好了，诶，他没事的时候呢，可执行文件静静的放在哪儿啊。

放在我们的硬盘上，就我们磁盘，然后这个程序要想运行怎么办，双击咣当一下放到内存里好，放到内存里之后，它概念换了这个概念叫什么叫进程等一个程序是，不是可以起好几个进程，你起两个qq就相当于两个qq的进程。

对不对，那好呃，这个进程呢还只是一个静态的概念，他还没有开始执行，开始执行的时候怎么办，找到我们的进程里面的入口函数，没找到他的第一条指令是吧，然后开始执行好这个东西叫做主线程。

最开始的时候只有一个县城，那么在中间我们可能会以各种语言启动各种各样的多个线程，好，整个程序才真正的开始运行起来，呃昨天我们讲我们说一个程序里面装的是什么东西，两个非常重要的概念，第一个呢叫指令。

第二个叫什么，第二个叫数据，我们说一个程序的执行啊，相当的简单，cpu呢会首先从内存里头把对应的指令拿到一个计算器，这个计算器的名字叫什么呢，叫program counter，记不住也没关系。

就是首先把指令拿过来，发现这条指令还需要数据怎么办，把数据再读过来，读到哪里去，寄存器，然后呢运算单元开始对计算器里面的数据做计算，做完计算之后做存储，存储好了之后再写回到我们的内存里面去。

这就是整个计算过程啊，不难比较简单，但是昨天我讲了一个非常重要的概念，我说啊我说cpu的速度，它要比内存的速度要快得多，快多少呢，大概是100比一的关系，就是说这哥们儿跑了100步，这哥们儿才跑了一步。

他的速度非常非常非常的快，呃所以呢我们说我们所谓的啊，说我们平时所说的这个高性能，我们说怎么样才能把我的程序呢做的性能特别好，高性能这个高性能的核心是什么呢，最底上的核心。

最底层的核心叫做充分利用计算机的计算资源，什么意思啊，别让cpu闲着，我们用那个粗话说，就是别让cpu闲着，你好好的让他干事儿去好，我们现在从微观的角度，同学们，你们好好想一下。

假如说我们现在有两条指令，我们的第一条指令呢是去内存里面取一个数据或者存一个数据，这是第一条指令，那么大概需要100个时间，单位好，我第二条指令是什么呢，在自己寄存器的内部做一个加法操作。

比如说他增一个一啊，加加操作，这是第二条指令，那么当然你就想了，同学们，你们想想看，第一条指令是取内存的数据，需要100个时间单位，这个在本地操作，它很可能只需要一个时间单位好，这是两条指令，是连接的。

是已经编译好的，是上下的关系，比如说我们写程序的时候写了第一条语句，如果说你理解不了底层的质量，没关系，你写了第一个语句a等于一啊，第二个语句b等于b等三啊等等，那这个时候呢同学们你们想想看。

在微观执行的时候，这两条指令在执行的过程之中，它会造成效率上的损失，为什么呢，因为我第一条指令执行完，得等着这个数据拿回来，100个时，间单位cpu在这段时间干嘛啥事也干不了，只能等着他拿回来。

然后才做下面这个操作，那么有没有一个办法，既然上面这条指令执行的时间比较长，我能不能把下面这条指令先执行完呀，我们说我们想喝喝杯茶啊，我们先烧水泡茶好，烧水的过程之中，我能不能先把碗茶杯给洗好了。

我不用说等着烧水完了之后，我再把洗碗洗茶杯，这可以不可以听懂这个意思了吗，如果是你设计cpu的话，你会怎么做，那大腿想想也知道，在他取第一条指令的过程之中，干脆我把第二条指令给他执行了，不就完了吗。

听懂了吗，哎这个是可以的，虽然说这事儿是可以的啊，好听我说。

看这里啊，嗯嗯那个虽然说这个事儿是可以的，但是呢它在宏观上会表现出来一个什么现象呢，就是你的第一条指令还没有执行完的时候，你的第二条指令已经执行完了，听懂了吗，比如说作为上上层的一个成员来说，呃。

你会发现一个特别好玩的现象，就是说你的第一条指令还没有弄完，你的第二条指令已经执行完了，ok这种是有可能的好吧，有同学说这是什么意思，我们看一个特别好玩的程序啊，拿代码说事儿，你就看懂了，大家看这里啊。

他这样一个小程序，这个小程序是特别经典的一些程序，小程序不是我发明的，我先说一下啊，我不能把这个功劳据为己有，这个小程序是国外的某一个程序员，那他原来是用c语言写的，后来我只要换成java语言而已。

那么在张眼里面呢，我们我们先不说这个小程序干嘛，我们先看这小程序是做了一件什么事，大家看啊，在这个小程序里面呢，我做了一个循环，这个循环的次数非常的长，你可以认为它不断的循环就行了，然后在这个循环里面。

每次启动的时候有四个值，这个小程有点复杂啊，大家认真听，别走神儿，这个小程序呢一共有四个值，这四个值呢分别是x y a b拥有四个值，最开始的时候这四个值全是零，然后每一次循环呢我会起两个线程。

这是第一个，这是第二个，在这两个县城里面，他们执行的语句也很简单，两条语句a等于一，x等于b b等于一，y等于a，仔细看这就比较好玩了，我们同时同学们，你们想想看，你们想想一件事情。

就是说呃我们现在是两个线程，两个线程的执行过程呢，很可能是一个交叉并行的操作，什么叫交叉并行，就说我这个县城执行一小会儿被暂停，被拿走，被调度出去换另外一个线程执行，另外一个线程执行。

执行一小会儿再换另外一个线程执行，所以它是交叉并行的关系好，我们现在假设时间上啊，我们都在一个微观上想，那这个时候呢如果说县城是交叉并行的执行的话，那在微观上有可能是这样的执行。

就是这几条语句的执行顺序有可能是什么样子的呢，先是执行这种情况，a等于1x等于b然后呢再执行b等于一，y等于a是吧，同学们，这是没问题的啊，当然还有可能有各种各样其他的情况呃。

为了这些情况呢，我干脆我记得我做了一张表啊，主要是这个东西理解起来有点困难，所以我干脆给大家做了一张表好，关于这张表呢，我们先把这边给糊住，先不看这边我们先看这个排列和组合，同学们，你们想想看。

就是在我们时间执行的可能性上，我们有可能是这样的，a等于一，x等于b，b等于一，y等于a当然也有可能是b等于一，y等于a，a等于x等于一，也有可能是先执行的a等于一，又执行的b等于一。

再执行的x等于b在直线y等a好，也有可能是a等于一，然后第二个线程执行完了，再把最后这句x等b执行，就是你排列组合排列组合组合来组合去，最简单的啊，我给大家把这个给大家组合完成，全部都给大家列出来。

你会发现呢大概有这么几种情况，我讲到这儿还能跟上的，给老师扣一，能跟上啊，没有走神的啊，大家还在吧，应该ok好，我们计算一下各种情况的可能性的前提之下，就是最后的x值会是几，然后y值会是几。

我已经给大家计算完了，你就不用做计算了，好吧好，这个x的值01x y的值1011111111，你就不用算了，就是你发现组合来组合区域，它一定不会出现某一种情况，哪种情况呢，不会出现这种情况，x等于零。

y等于零，听明白这意思了吧，好那么会不会出现这种情况呢，这个程序我先让他跑起来，这个程序呢只要出现x等于零和y等于零的情况，我们就让它停止，如果他不出现，就让它循环，我们先让他跑起来走，你别着急。

主要是因为呢这种情况出现的可能性确实是非常的小，这事儿得慢慢等，我记得我有一次等了十分钟，所以说这事儿呢看运气，我应该刚开始就运行起来。

然后大家伙就别说能看见结果了啊，虽然是的，别急不急，而且在某种cpu的情况下，你甚至等不到这个结果，但这件事是存在的，我们在它出现之前，我们先琢磨一件事儿。

就是在什么情况下才会出现x等于零和y等于零的情况，在什么情况下才会出现这样好，我告诉你，只有这种情况，就是我们第一个线程的x等于b先执行，因为前面已经b赋值为零了，a也复制为零了，首先x等于b先执行。

a等于一呢后执行，与此同时，另外一个线程y等a先执行，b等于一后执行，只有这两种情况同时出现，什么叫两种情况同时出现，就是你会发现这两句话换了个顺序执行，这两句话与此同时也换了个顺序执行，嗯听懂了吧。

好在这种情况下，o我们才会得到x等于零，y等于零的情况，这种情况，所以发生的可能性确实比较小，因为它需要两个县城里面的同时换顺序好，我们来看看看看有没有结果了，好一共我们循环了378689次之后。

我们出现了零零的情况，好这个小程序至少可以证明一点，就是我们看到的顺序未必是cpu执行的顺序来能得到这个结论的，给老师扣个一能跟上的好吧，就是我们看到的顺序未必是真正执行的顺序好，现在问题来了。

为什么会这样呢，为什么cpu要换顺序执行啊，其实我刚开始就讲过了，是因为cpu在有的时候他换这个顺序，主要是为了提高效率，主要就是为了提高性能，我们讲性能这件事呢，可以贯穿你整个系统的从始到终呃。

性能这件事从最微小的一两句话，可以贯穿到你整个的一个庞大的100个节点以上的系统的结构，它都会关关系到性能呃，我呢后面计划会开一个专专题，就是专讲性能，从最根儿上的一直讲到我们说呃，数万台机。

器的集群应该怎么样去提升这个性能，其实我跟你讲，当你弄明白了微观之后，你会发现宏观的很多东西也就明白了，如果计算机我们说根儿上的东西有两个东西的话，其实第一个东西就是算法，与数据结构。

我就直接这么跟你说，所有的其他的东西可以都是都是从这里衍生而来的，当你去学习操作系统，当你去学习网络的一些拥塞算法，当你去学习呃各种各样的熔断的，降级的，限流的这些个算法的时候。

你突然间发现你有了这门课为基础的话，你学习把学其他的学起来的话，那真是可以说就是那个事本事本事半功倍啊。

嗯慢慢的呢就是怎么学通这件事其实是很重要的，就是融会贯通，你才能够以无招胜有招，不然的话你学的东西都是刻板和死板，好了，呃到这儿呢你呃会发，现我先下去证明了一点。

就是他确确实实呢是顺序是是是是有有有可能会发生错乱的，但有同学可能就会说老师错乱就错乱吧，有什么关系吗，跟我有半毛钱关系吗，你认真听，慢慢听我们讲经典的一些面试题，大家看这个题。

这题呢是来源于嗯对有刚才有小伙伴说他在读并翻那本书哈，这是这是那本书上的一道题，好我们来看这道题，这道题是个什么东西，你仔细看它是模拟了一个实际当中比较常见的一个情形。

这个情形是当我准备好了某个东西之后，我们就开始干某件事，什么意，思比如说当我准备好了手指，我们就开始上厕所，当我准备好了，我当我长到18岁啊，我们就开始谈恋爱，o模拟这么一件事，如果我们有一个数值。

这个数值number number这东西最开始的值是几是零，对不对，它一个默认值是零吗，好最开始的时候零的时候我还没有ready，i没有准备好，ok然后呢我有一个读这个读这个number的县城。

这个县城啊就reader thread，extends thread，然后呢在这个县城里面是well，not really啊，只要这个ready还没有准备好，我呢我就不进行下去，我就在这里循环等着他。

那什么时候我们说把这个number呢用这，个number呢好，什么时候你告诉我，你准备好了，我把这number值打印出来，ok然后在我的主线程里，我首先让这个独线程启动是吧，我启动完成之后呢。

我把number设定为42啊，我42岁之后我开始谈恋爱，然后我再把ready设为true，好我们理想的情况是，当我们这个number为42的时候啊，我们这个reader线程可以正确的读到这个值嗯。

能看懂这个意思吧，来看看明白的老师扣个一，那现在问问题，问你的是这个程序有没有毛病，有没有，sure有当然有呃，没毛病，我能问你吗，这程序有两大毛病，我们不说第一个我们先说第二个。

第二个就是我们讲的顺序问题，我想问你有没有可能性，这两句话换了个顺序，有没有太有了，我如果这两句话换了顺序执行，你打印的那只会是几，比方说我ready等于true，跑到前面执行了number。

还没有来得及，射程42，我这值是不是就有可能直接打印出零来了，那你是不是就这就不是你想要的结果了，最起码对不对，所以这东西它有问题好吧，这个是相对简单的一道面试题比较复杂，一道面试题是什么呢，是这道题。

你仔细看这道题，我们来看看这道题，这道题呢我们有一个类这个类呃，我们可以继续吗，可以继续吗，啊别的语言都一样，就说我只是拿java语言给你讲东西而已，所有的语言都逃脱不了这个规律啊，应该可以继续啊。

过来我们往这儿看这个小程序呢，它有一个成员变量，成员变量的名字叫number，number的值为八，好了，现在的问题看这里，在我们的主线程里面，我们new了它的构造方法。

在它的构造方法里面呢启动了一个线程，这个线程干了一件事，把这个number值打印出来，好了，仔细读这个小程序，好好思考，为什么这个小程序有问题啊，我也不问你有没有问题了，有问题为什么。

y如果你读过这本书，这本书呢叫做prefective，你知道吧，也是相对比较有名的一本书，那么其中有一条著名的原则，不要在构造方法里面启动线程，就是你可以在这个构造方法里头把它new出来，把它设定好。

但是一定要单独写一个方法，比如叫start，在这个里面单独启动，好了，同学们仔细看原因是什么，这里面的东西呢就比较复杂了，呃我呢，要要要解释明白这个问题呢，我们做一个先做一个小小的实验。

我们先做一小小的实验。

把我自己拖出去，我们拿这个t举例子啊，不管它叫什么，这类名叫什么，无所谓嗯，在这个t里面，比方说还有一个in等于八啊，这么一操作呃，听我说我们平时看到的这个操作t小t等于6t。

ok这个操作内部它会分成哪些个步骤呢，我们跑一下看看先走，你，程序非常的简单，但是呢大家都知道一个java语言，它编译完成之后呢是一个class文件。

那么这个class文件呢就相当于java虚拟机的汇编语言，就相当于java虚拟机内部可以直接执行的指令呃。

系列 1：P28：多线程与高并发：8.三级缓存架构造成的可见性问题如何解决？ - 马士兵官方号 - BV1mu411r78p

嗯你们想想让我告诉你那本书吗，稍等啊，顺带着给大家推荐一本书吧，books，这本书呢叫做，好它的全称叫做java virtual machine specification，当然不同的这个版本你选择呃。

具体不同的版本就可以了，嗯这本书是，呃这么跟大家说是，嗯那个oracle呢自己官方网站上，你随便可以下载的好吧，java并发编程的艺术咋样，你不用听啊，你我我就直接这么告诉你。

市面上所有的数加起来也没有老师讲的课深入和全面，往这儿看这些东西啊，如果你学过汇编语言，它就相当于是java语言里面的汇编，它我们所有的class的文件到最终它会解析成为呃。

一个一个的这样的一条一条的汇编指令，我讲到这儿应该能跟上吧，虽然你没有学过汇编啊，相当于它是一个呃直接操作硬件的语言，java虚拟机，虚拟机它也是一台机器，像这个这些语言是，可以直接操作硬件的语言。

我们直接写这种语言的代码，是不是可以，当然可以嗯，java也有这样的框架，但是呢学起来不方便，所以我们才用java语言写完了之后编译成为这种语言，好吧，他有这么多非常的多啊，大概是有255条指令o。

呃在这255条指令的前提之下，呃，像这样一条语句，它会有多少条质量构成呢，我们可以通过一个插件来观察它，这个插件呢view这插件的名字呢叫j class library，好吧呃当然你也可以，它自带的。

他也自带一个插件叫呃，是by code啊，这个也可以，但是这个呢格式不太好看，所以我换一个插件来用，这个插件呢叫做j class lab，你自己去下载，当我们打开这个插件之后，我们找到其中的方法部分。

找到其中的main方法，好在这个main方法里面，我们打开它的co，在这里大家伙看到的好吧，ok看这里啊，在这里，大家伙看到的就是汇编指令，这条汇编指令呢其中的关键部分并不多，关键部分大概是这三条牛。

invoke special以及a store，最关键是这三点，呃我呢简单给大家解释这几条到底是什么意思，这个主要是我有一个内部类，所以它多产生了一条啊，这个不用管它嗯。

在这儿呢我把这三条语句呢放在了ppt上。

小迷弟做了一个动画，我们还是用动画来演示。

哦看这里就这个小t，你能不能把这个小t它的创建过程到底什么样，嗯，我会带你把所有的语言全串起来，你慢慢跟着老师走就行了，它产生的三部分代码分别是这三部分，一是new，一是invoke special。

一是a store，其他这两条我不给你解释了啊，不展开，我在这y m课里专门讲了常用的这些汇编指令，但在这就不展开了，他第一条指令呢其实特别简单，叫做申请一块内存，再说一遍，申请一块内存。

那么申请一块内存是什么意思呀，同学们，你们想想看，我们要new一个对象出来，我们是不是得在内存里头申请一块空间呀，在座有多少位同学，凡是学过c语言或者学过c加加的呃，你给老师扣个一，我认识一下有没有。

ok ok好，学过也好，没学过也好，都没有关系，任何语言啊，他首先要做的一件事儿叫做管理内存，这件事是所有语言里面都要干的事，java语言呢它管理层简单，为什么交给垃圾收集器了，c和c加加需要手工管理。

手工管理是什么意思呢，就是我分配了这块空间，我现在需要一块地啊，我们说内存是一个大操场，我现在需要在操场上的某一块地铺一块毯子来吃饭，好，你有一块毯子突出出来，我尿完尿完这块毯子，我得想着把这毯子收走。

我得让别人继续能用这块空间，如果忘了收这个，我们就称之为内存泄漏，如果我泄露的越来越多，光掉毯子永远不回收，内存会把整个操场占满，这个一般我们称之为内存，out of memory是吧，内存溢出啊。

叫out out memory，ok叫内存溢出，当然还有一种情况也不行，什么情况呢，就是我不小心回收了两次，因为我的程序写起来的时候会非常麻烦的，我行程序写起来各种的判断，各种的if语句，各种的分支。

好，在不小心的情况下，我有可能删掉它两次，同学们，你们想想，如果删掉一块内存两次会产生什么，你把别人的内存给干掉了，能理解吗，我删掉一次之后，别人别的程序诶，这块空间可以用了，诶。

我放张床在床上谈会儿恋爱吧，这是可以的，结果呢你的程序非常暴力的把这个床给删除了，你猜猜看会发生什么，当我们想找那两个谈恋爱人的时候，突然间发现没人了，不知道去哪儿了，不知道被谁删的。

所以自己手工管理内存是c和c加加程序员的噩梦，有同学说我写c程序从来没有做过噩梦了，因为你写的简单哦，嗯，在呃这个的基础之上呢，就是给大家做一下小小的扩展好吧，就是java呢你不用去管。

你只管没你那块毯子，这块毯子什么时候回收，有专人帮你回收，这个专人就叫做垃圾回收器，叫garbage collector，我们先不管它都是第一件事呢，我们是要一定要在操场上申请一块空间的。

好现在的问题来了，当我们申请完这块空间里的空间之后啊，申请完这块毯子，毯子下面盖着东西，里边是有数据的，因为在内存里头申请一块空间，那这块内存里的装的是什么东西呢，我们用了一块t t对象。

它里面装的是什么，那，大腿想想应该知道里边一定有个小m，你说对不对，它有个成员变量，所以这个小m在里边，我想问你的是，如果你是在c或者c加的情况下，当我们申请这块空间出来之后。

这个空间里的小m的值是几呢，小m值会是几，这个大家了不了解，ok a3 个九说random，零，你们两个说的都没说对，你们两个都没说对，听我说这个m的质量会使原来的遗留值就是c和c加加，他追求效率。

你只你说这块空间归你了，没问题，我就给你做个标记就可以了，从这头开始到这里结束，这块空间属于t对象，至于中间里边装了什么乱七八糟的残羹，冷炙别人的剩饭，我不管，那是上一个程序留下的值，好讲到这儿。

我想问大家一个非常刻薄的问题，如果说正好上个程序在这里头记录的是他自己的一个password来，你告诉我他会发生什么情况，同学们，你们想想看你，你可以窃取它吗，可以吗，可以不可以，当然可以。

这个呢就是安全问题，所以我们平时所说，我们说java程序是安全的，为什么其中有一个体现就在于这就是java里面呢，当我们有一个t出来的时候，它里面的成员变量全都-0或者负控制，哈哈听明白了吧。

ok这就是它会把不仅申请完这块空间，还会把这个空间呢顺带的给你做一个初始化，把那些残羹冷炙全给你清走好了，那就是说看这条汇编码就理解了，当我们new一个对象的时候，本它里面会有一个值，这个值会是技能。

会是一个默认值，注意它不是八，他是技能，它是这是java自，带的功效，所以说java当时推出的时候说我们是一种安全的语言，除了呃其他的一些安全层面的东西之外啊，我告诉你这个也是其中之一。

嗯就是我我给大家讲东西，我是喜欢不是太看重某种语言专有的一些功能，而是说把这个东西给大家串起来，那你会慢慢的理解啊，计算机这个东西呢其实也没那么难，像它的简单也是啊好看这里呃。

但是呢由于我们给他做了一个初始值，这个初始值是嘛，是不是不是八呀，那他什么时候才会变成八呢，执行到这条指令的时候，这条指令呢叫invoke special，嗯，我，们翻译一下啊。

invoke叫调用的意思，special叫特殊特殊调用，说在这里呢我们调用了一个方法啊，调了一个函数，这个函数的名字是什么呀，它的函数名字叫initialize，你拿大腿给我想想，你说它调用了什么方法。

我说java语言里面，如果你给一个class呃，你往里头没有给它定构造方法，它是不是默认有一个构造方法，对不对，参数为空的构造方法，ok好了，他就调了那个构造方法好，只有在这个构造方法执行完成之后。

白m的值才会设为八，这时候才会变成八好，那下面这句话，但是你注意啊，因为我们在方法里面，我们说有一个局部变量啊，小t你的may方法里面有个小t局部变量，说一个方法在程序执行的时候呢，它是有一个站存在的。

这个叫县城站呃，占空间呢其中有一块是属于这个main方法，main方法里面有个小题，这个能听懂吗，哈哈哈，这个要是听不懂的，就大致理解就行了，就是说一个程序在运行的时候嗯。

我们说java程序虚拟机呢是基于那个站来运行，每一个县城都有自己的县城站，县城里面的每一个方法都有自己的，战争它的全称叫frame，嗯，叫stack frame，stack frame。

这原来在这里就没讲过这事儿，你一个方法调另外一个方法，他就起一个战争，一个一个方法结束了战争弹出去，这是整个程序的执行过程，好在这个支撑的时候呢，我们说它的局部变量小t放在哪，放在这个站里面。

那个小t t等于6t，我们把这部分执行完了，你得把这个把这个线把这个值得给到这个小t啊，这个小t是什么呀，这是个引用或者指针嘛，是不是，所以这条指令a store它的意思是什么呢，它的意思是建立关联。

这里的小t才会真正地指向，了这个对象，呃委员长这句话呢我其实解释了很长时间了，我们再稍微复习一下，当我们看到这句话的时候，首先看右半边new题，它会有这么几条指令构成。

首先申请一块空间里边的成员变量赋值为默认值负为零，接下来调用构造方法，这时候才会赋值为初始值为八，然后a store这条语句执行完，他才会建立关联来，同学们一卡一卡，像vcd受潮似的，呃。

换一个那什么吧，是不是换个换个换个刷新一下啊，刷刷一下，或者是呃换客户端来看，都在看吗，难道是我这个我这个网速的问题吗，待会都卡吗，我等待一，会儿就一小会儿好了是吧，刚才卡，好了好了好了吗。

我们可以继续吗，嗯我们可以继续吗，卡卡西老师啊，没事啊，卡的时候呢，我先等大家回家会好不好，屏幕不动了还是卡呃，客户端不卡对，大家伙可以用客户端或者用手机。

或者用那个那个那个那个那个那个那个pc端的那个客户端呃，其实用浏览器，网络不稳定，那个查一下哪位同学是不是在上传或者下载啊，稍等啊。

他先不着急，换换app好了，现在好一点，可以吗，sorry啊我呢，这是这个是我的问题啊，电脑客户端不卡对嗯，内存溢出了没有啊，这个跟内存溢出没有关系，什么情况，喂稍等一下啊，我把这些多余的乱七八糟的。

什么活动的程序全给他干掉，说明了网络不可靠，good，哈喽哈喽，现在好一点吗，嗯好多了是吧，好不错，这个是我的问题啊，i m i m valley，valley sli，呃口袋很重啊。

sorry sorry啊，我们继续啊，这个这个主要是我的问题啊，这个问题主要是什么呢，呃是因为我不小心连的是无线网，呃，我现在换我的那个网线，网线直连又卡了，我勒个去，这不应该啊。

呃楼上楼下的查一下所有的机器，谁在上传下载的都给我停掉，来咱们小姐姐去楼上楼下去看谁在上传下载的，全都给我听到，稍等啊，破音警告嗯，走起来一点都不卡呃，这边的小伙伴好像确实比较卡。

从现在丢包的情况来看的确实比较卡，登录游戏看谁在小看谁在看小电影，对，holy shit，好像还有那么一点点，呃大家稍等一下，我，确实卡了嗯，怎么会这样子呢，嗯大家稍等啊，这就给你看，听见没事嗯。

不是是公开课，这边我就这么说，关羽根本没有卡吗，大家伙把那个在上公开课的，咱们的小姐姐们也也清一清一波下来，性能，cpu 7%才性能应该没有问题啊，没有卡啊，现在嗯这个我也考公，这明显卡我能看到卡嗯。

对豆瓣比较严重，好了，同学们，我们再试一下啊，嗯嗯，把第二件关了就不卡了，应该跟那个没关系啊，嗯那个现在可以了吗，好一点吗，嗯嗯画个图可以了是吧，还是不对，靠近路由器，暴露就是嗯，内存64，我才16。

不是你们在看啥啊，我的天，3970w s线程撕裂者啊啊应该好了，我已经看见他不带丢包了，嗯应该好了啊，sorry，这不是我现在没查清楚网络的情况，我为了找我们岳维的老师给查一下啊，好了好。

系列 1：P29：多线程与高并发：9.内存屏障是如何解决代码乱序性问题的？ - 马士兵官方号 - BV1mu411r78p

我们稍稍回顾一下，中间被一段小插曲给打断了，好大家看这里啊，我们再稍微回顾一下，就是一个对象的创建过程到底什么样呢，呃首先你有一个对象出来，占一块空间，这块空间它里面的成员变量是一个默认值，它为零。

调用完构造方法才设置为初始值，它为八，调完a store才建立关联，一定给我记着这个顺序好，当你理解了这个顺序之后呢，我们再来看看这段小程序它到底有什么问题，呃这个小程序是一个著名的小程序。

它的全称呢叫this，叫类似溢出问题，我觉得这是逃逸问题，这是什么意思呢，同学们，你们想想看这是个什么东西啊，this is是个指针，它指向谁，指向我自己，对不对，指向当前对象啊，你可以理解为什么呢。

可以理解为在我们的看这里好，在我们的main方法里面，除了这个小t之外，还有一个叫this is的东西，它这个this也是指向这个对象的，好吧，是这么一个东西啊，那好同学们，你们呃思考一个问题。

翻回头来呢看着小程序在这小程序里边儿，我们说呃，这是主线程，这是我们构造方法的线程，好同学们，你们想想看，有没有可能发生一种情况，什么情况呢，就是，我这个this指针啊是上来就有好。

有没有可能发生一种什么情况呢，就是当我的对象呢用了一半，用了一半的时候，我这个this已经指向它了，只有我构造方法完成之后，知道吧，构造方法调用完了这个八才会才会才会变成八。

那有没有可能这种情况说我this指向这里的时候，他还没有变成八的时候，我就直接把它打印了，能听懂吗，这个过程不知道大家听懂听明白没有，就是由于我对象的创建过程是由好几步构成，在他还没有初始化完成的时候。

这个this就已经溢出了，this就已经逃逸了，从哪逃逸出去了，从我们的构造方法里头就已经暴露出去了，虽然说你看上去是在我构造方法里写了一个程序，写了一个线程，但实际上这个县城你记住了。

县城这玩意儿是不是在我们主线程之外执行的，他执行的时候很可能这个对象只初始化了一半好了，这就是revise一出问题啊，this逃逸逃逸问题呃，这个问题呢我刚才说了，如果大，家会有兴趣去读这本书。

如果你懒得读，听老师讲课，老师我讲一门课，会把市面上所有的书全看完，我讲这vm实际上十几本书我全看一遍，讲多线程也是一样的，呃，逃脱不了我们多线程讲的内容，放心吧，这是类似溢出的问题，就是他出了一半。

他就拿手拿去用了，当我讲到this is溢出的时候，这个还不是特别严重的问题，我们讲讲过我讲过很多遍的一道题，我由于好同学应该也是没有听过的，我再给你讲一遍，快速的给你讲一遍，仔细听，你认真听，嗯。

下面这个问题是美团问的一道问题，这个问，题呢他就更深刻看这里这个我需要打开我另外的一个项目，这个项目叫做design patter，关于design patterns，应该有同学知道什么意思吧。

看这个著名的项目呢叫做设计模式是吧，设计模式一共有多少种，就非常牛逼的一本书，这不是我在呃还在工作那会儿啊，大概四五十年前看的一本书，到现在为止经久不衰呃，一共嗯嗯ok cancel呃。

一共呢大概有23种设计模式啊，后来好多人在那抄来抄去，说这种模式，这种模式，但实际上所有的模式没逃脱这23种呃，23种设计模式我大概讲了23种，这其，中有一个著名的也是最简单的模式。

这个模式呢被称之为singleton，叫单例，我们把这个单例模式给大家找出来，讲一讲丹利丹利跑哪去了，在这它的全称叫single lion，叫丹利呃，有同学可能不知道什么叫丹利，我做一个非常简短的解释。

就是当我们有一个类存在的时候，一般的情况下我想你有多少个对象，就new多少个讲究，第二个再丢第二个，在某些特定的情况下，我只用它一个对象，我不允许他new好多个，比如说一个类的对象，你能够写一种程序。

保障它只有一个对象存在，不会有多个对象存在，好这种的写法，这种的模式被我们称之为叫单立单例模式呢，你平时可能写那个程序的时候呃，用过spring的，小伙伴应该知道spring框架吗。

他会帮我们要接管我们的对象的诞生，这个对象的诞生的话，默认是什么什么什么样的啊，单利的对不对，有什么有什么情况要用单例，情况非常多啊，比如说我们说数据库的管理者。

我们有一类叫嗯database manager，对他miss manager，你有必要弄好多个吗，没必要，然后再给你举个通俗点的例子，你有一个类叫wife，来大哥，你的wife。

你能允许别人给你弄好多个吗，这肯定不行，如果你是girl girlfriend l g b t是吧，那你你可以，你有好多girlfriend boyfriend啊，呃transgender等等。

但是呢wife你不可以，你好多个只能有一个only one，单利好，我们就不探讨这个道德和伦理上的问题，我们探讨技术上的问题，从技术角度讲呢，你要想实现一个单位最简单的写法。

就是这种这个写法是最经典也是最简单，没有什么特殊要求，你就用这种写法，不要跟我玩什么，其他有九种写法一类的啊，回字有四种写法，虽然我为了课程的完整性，我给大家讲了九种。

但是呢实际当中能用就用这一种最简单最方便，最能保证它的完整性好，这种单例呢它叫做恶汉式啊，什么意思，看这里上来二话不说，我自己先new个对象，自己先溜一个出来，还有这个对象的叫instance啊。

好然然后我把构造方法设定成为private，我说private别人不许用，只需我自己用，那别人不能new，我有我已经先溜了个单位，别人想怎么用呢，给他提供一个静态方法。

这静态方法呢叫来get instance，平时你们看到的各种的管理类啊，manager get instance啊，还有呢什么呃呃像什么一些加密算法。

那说get get get get instance啊，反正你见，到这样的这种名字的基本都是单例，我们直接拿这个单位就拿出来用，然后呢当作为我们这个类的用户来说。

不管你调用多少次的get instance，你放心，您老人家拿的永远是同一个程序，我就不演示了，我讲到这儿，单例的基本概念和基本写法能跟上的，给老师扣个一，ok good good，好呃。

那么我讲到这里之后呢，但是这个写法呢有人会吹毛求疵，他说你这个单位还没有在用到的时候，就是我还没有用的时候啊，我写不写，我都没方法，我的说法还没有用它的时候，你二话不说，先new一个。

如果你这个单位特别占内存，你这个写法是有毛病的，能不能等我用的时候，什么叫等等，用的时候不要用这个方法的时候，你再把它给我初始化了，可以不可以可以的，所以就诞生了第二种叫懒汉式，懒的，他特别懒。

刚开始不把他初始化，什么时候需要我的wife啊，在调查get wife，ok先判，断外服等空吗，如果等空，你有一个如果不等空，直接拿来用好，当你看到这里的时候，这种就叫懒汉式写法也非常的简单。

用的时候先判断，但是当我们写到这儿，对于多线程，因为今天我们讲的是线程，对于多线程敏感的同学，现在一定有点感觉了，你说在多线程访问这个方法的情况下，它能够保证你只有一个对象产生吗，当然不会是吧。

呃为了暴露出来多线程的情况，我在判断之后呢加了一个睡眠，这个比较简单，我就不解释了，那么在这里我弄了一个线程呃，100个线程i等于零，a小于100，用了100个线程。

每个线程都调用了get instance方法打印它的hash code，如果说所有对象都是一个它的hash code一定是同一个等，它会是这样吗，明显不会，845结尾，109结尾，287结尾多了去油呃。

我觉得不用我解释吧，应该非常的简单，第一个线程来了，判断等空吗，等空暂停，第二个线程来了，判断等空吗，依然为空，继续留一个，第一个线程继续用六，第二个。

所以完全可以有可能扭出好多好多个来呃既然这种写法是有毛病的，没关系啊，枷锁对呀，上锁嘛，对不对，当然当你看到这个关键字呃，面试的重灾区，这个关键字是重中之重，面试的重中之重，特别重的一个重灾区呃。

这关键字我大概花了四小时给大家讲完，但是在这儿不展开，你好好听，我告诉你，我我我讲这个关键字并不是给java讲的，而是给所有语言讲的，这个东西呢叫上所上锁，这件事比较复杂，上锁这件事，首先你得有一把锁。

然后上完锁之后呢，你还得干干一干一些事，简单说简单说你要关上厕所的门，在上面加一把锁，然后在厕所里面扑哧扑哧干完事，然后你还要从厕所出来，再把这把锁打开，其他的县城才能进来，能听懂吗，这应该能理解啊。

不然的话两个人一块进去就是屁股怼屁股，互相之间摞着这东西啊，不可想象啊，你就会破坏人家的数据一致性，可以ok当然一般的情况下啊，数据如果产生分叉的情况，如果产生分叉，一般是穿了丁字裤的原因，开个玩笑啊。

开个玩笑，开个玩笑啊，好好好，那我们说回来啊，呃看这里呃，这里呢是synchronized，这个synchronized呢非常的简单啊，就是get instance，呃在get essence的时候。

等于是我要执行下面这一大段代码的时候，其他的线程是不可以，其他的执行这个方法的线程是不可以进来的，只有等我把这个分叉的事搞搞搞定了之后啊，其他的人才能执行这段代码，是这个意思。

但是呢它会产生一种什么情形啊，这种情形是嗯是这样的，如果你的这个方法它非常的复杂，呃，你有没有必要说我在上锁的情况下去执行这些呢，实际上没有必要，你读东西也不改任何东西啊，你是没有必要的，这个。

等于什么呢，等于我们的锁的力度太粗了，什么意思呢，就是我们锁定的代码太多了，大家知道你在里边蹲的时间越长，你占别人的，别人进不来的可能性就越大，效率就越低，所以我们能不能够说只需要锁的时候上锁。

不需要锁的时候就不上锁，这个可以吗，能做到吗，你当然可以啊，完全可以做得到，那就是这种写法吗，就这种写法唉，我首先把业务代码给他让过去，然后呢判断if instance等空哥们儿，如果你为空的话。

上锁不为空，不上锁，不为不为空，指定拿来用了，上锁你有对象，ok然后如果不会控，制直接能用好，那现在问题是这种写法能不能解决数据一致性问题，会不会产生多个对象，有没有问题，当然当然有问题啊。

当然有问题嗯，我们先跑一下看看结果，你明显看到他好多个不同的对象对吧，三二结尾，264结尾是吧，很多很多287结尾，285结尾好，为什么会这样呢，我们明明上了锁呀，这就是多线程程序不好写的地方。

就是你要小心翼翼地判断哪些代码我要上锁，哪些代码不要上锁，需要小心翼地进行进行判断，第一个线程执行到这里的时候，if instance等空好，等空吗，等空没问题。

上左第一个线程暂停还没有继续往下运行的时候，第二线程来了，判断能空吗，依然为空，没问题啊，第二线程继续运行，第二线程这么运行的上锁锁定，然后new对象new出来，然后这里呢是解锁过程，把锁解开。

然后方法返回好，第一个线程继续第一个线程继续运行的时候，注意第二个线程已经把锁给释放了，那第一个县城能够上锁吗，那当然可以，所以第一个县城又上锁成功，又new了，第二个对象，听明白这意思了吧。

所以这里头是有问题的，那有这个问题之后，怎么解决这个问题呢，好用这种写法，这种写法呢是第一上来先判断哥们儿，你如果等空上锁，上完锁之后，我再判断一次，哥们儿，你是不是上完锁之后，你依然为空。

你依然留有我的记忆，你依然为空，如果你依然为空，把它尿出来，如果说中间上锁的过程已经被别人虐完了，那我就直接拿来用了，好的，你听明白这件事儿之后，看这里看这里，我们回顾一下刚才那种情景，第一个线程来了。

判断等空没问题，等空，然后第一个线程暂停，第二线程来了，判断等空吗，等空第二线程继续在第二线程继续的过程之中上锁没问题，判断依然等空没问题，然后new一个对象出来解锁没问题好第一个线程我们会继续上锁。

能成功，因为第二个线程已经解锁了，但是当它执行到这句话的时候，判断是不是还没空，发现已经不为空，因为这边已经用完了吗，所以他就不会再尿第二次了好了，这种写法呢就是比较经典的写法。

这种写法全称叫做double check，lock，简称d c l叫double check lock，这是一个check检查，这是一个check检查，中间加了加了一个。

上锁的过程主要double check lock，这是巨经典巨经典的写法，如果说这个写法你没有听说过，今天你就要把它背过，在很多很多的开源软件里面，有大量的这种用法，叫双重检查锁，双重调研所，是的啊。

呃当然双重校验锁这里面有两个问题，两个问题，好第一个问题是什么呢，第一个问题是很多同学会问，为什么外面这层检查还需要我是不需要他的，严格意义上来讲，我上锁直接上来上锁不就行了吗。

一线程过来上锁发现为空又出来，第二线程上来上锁，发现为空，不扭了，不为空了，不扭了，不就搞定了吗，能能能听能听懂我的意思吧，就是我们为什么还需要第一第一重检查，原因是什么，原因是效率性的。

就性能这个词是体现一个程序员是高级程序员还是初级程序员，最根本的一个指标，优秀的程序员总会追求非常就是使劲的压榨cpu，使劲的压榨你的整个系统，能让它达到最好的性能，比较差的程序员呢。

那就是随随便便写完完成就行了啊，我搞不定特别好的算法，我就可以拿一个大的list，把数据全都给他装上啊，内存内存让他买吗，买买买多了就行，嗯，呃看这里，这里主要是性能的问题，如果有外面这层判断。

那么一旦有一个线程已经把它弄成功的话，其他县城只要经过这次判断，不需要竞争所的过程就可以来判断出来我要不要继续运行了，能听懂吗，就是我第二线第一个显示已经用完了，我只要判断不为空了。

上锁的过程我是不需要的，但是你如果没有外层判断，所有的人二话不说上来全都要抢一把锁，强索这件事是句号，资源的是要经过操作系统的操作或者ca的操作，不管什么操作都特别耗资源，所以有了外面这层判断。

你的效率提高好多，有1万个县城很可能，有9999个县城就不需要任何的抢手操作，提高效率用的，但是第二个问题是，这种写法有没有什么毛病。

有毛病吗，有同学说看上去很完美啊。

难道这种写法还会有毛病，这样我们把这个这个sleep这事儿吧，sleep的破事呢，这都行，那个c开盘，如果代码稍微调一调的原因呢，主要是我抓取起来，让大家伙能读得更加的明确一些啊，我看这段代码啊。

直接删了吧，不要这系列了。

看这里啊，就是我把多余的代码都给你删掉。

我就看这么一小段，相当简单代码，有同学说了，老师这段代码居然还会有毛病，我直接告诉你，是的确实是有毛病的，这个毛病呢它比较的隐蔽。

讲给你听。

系列 1：P3：JVM瞬间涨薪3K的操作：3.CMS的理论与缺陷 - 马士兵官方号 - BV1mu411r78p

把它记录为灰色有什么好处，当我垃圾回收线程再次回来的时候，我只需要从灰色开始就可以了，我不需要从根上开始开始好，我这个垃圾回收线程，把这个灰色的以及他的孩子全部找到了，他有俩孩子，比如说全都找到了。

那我也就把它变成黑色好了，找到他了，还没有找到他的孩子，这哥俩是灰的，那就意味着当我下次回来的时候，我只需要从灰的开始就可以了，我没有必要从黑的开始，如果没有这个颜色的记录。

就意味着我每次都都得从头开始，这样我就不能构建整个的树的图谱了，来这块儿能听，应该能听懂吧，没问题的，老师扣一好吧，什么时候我把整个的全找，就是整个内存里的对象全找完一遍了，我就已经知道哪些是垃圾。

哪些不是垃圾了，琢磨琢磨是不是格上到这儿哎，找到他了，这次呢我找到他，找到这哥俩，找到这儿了，当我们下次垃圾回收器再回来的时候，我就顺着这哥俩就是往下找找找再找找，当我们说这哥俩都没孩子了。

那说明我们整个已经找完了，那剩下的所有的全是垃圾，ok这是三色标记算法，三色标记算法它会发生这样一种情形，往这儿看，仔细往这儿看，我们现在假设我们的内存里头站在垃圾回收器的角度，我们内存长这样。

有一个a已经找到他的孩子，b也已经被我找到，但是呢这个b的小孩d还没有来得及找我的垃圾回收器暂停，我刚才说了，垃圾回收器是有可能被暂停，那就是一个普通县城嘛，然后业务线程继续，请大家注意。

这个时候业务线程很有可能会干这么一件事儿，有一个a的引用，a的有一个属性的引用指向了d注意看，与此同时，b，指向d的引用消失了，那么从伪代码的角度来说，就是这样写，就是a里面有一个小对象啊。

比方说它叫小d等于d对象，与此同时，我们业务代码很很可能会执行这样的这样的一种情况，很正常，好那现在我问你，当我垃圾回收器再次回来的时候，根据我刚才所说的业务逻辑，那就刚才说的算法逻辑，sorry。

我的垃圾回收计现在回来了，回来了之后呢，由于a是黑色的，我还去找他的孩子吗，不找，由于b是灰色的，我去找他的孩子，但是由于他也用消失了，我还能找得到地吗，找不到。

那我想问你这个d是不是就被我们当成垃圾了，他有用，但是被我们当成垃圾了，这就是为什么我们没找到对象，会被我们造成垃圾的原因，那这样回收不慢吗，narrow，你在说啥，ok这段呢我估计有同学可能会有疑问。

我稍微暂停一小下嗯，听听大家伙的问题啊，这样业务不会有bug吗，你给我举个例子，这业务为什么会有bug呀，大哥离谱，这个算法这个bug也太loop，不是这个算法我还没有讲完呢。

三色标记算法本人是这么算的，明白吧，嗯笑傲江湖说明白了，因为都是继续上一次的地方找，搜不出来对啊，最关键的点就是在这儿他会继续上一次，你如果每次都重新找，那你对这个你这个垃圾回收算法还有什么效率可言呀。

我们每成成百上千的对象，你每次重新找，那你还不得s t w吗，是不是，d还在用，但是被清理了，没错这个不是县城所控，这跟县城所有有半毛钱关系吗，你为什么会跟县城所有关系，这个算法跟现场所没有关系。

你好好想想，无非就是在我们业务线程执行了一小会，然后垃圾回收线程执行小伙，呃面试的时候我说了三次标记算法，面试验效果，从来没有听说过三次标记融，你说了一个很很严重的问题，小小荣哥佩服诶，小龙哥去哪儿了。

一不小心把小荣哥点没了，这以前咱们同学遇到过，就是他那个呃比面试官的知识稍微丰富一些，然后呢他就上来怼了面试官一通，然后给了面试官详细地讲解了整个的知识体系，然后你猜猜看他面进去了吗，然后挂了。

对他绝对挂了，很少有那种心胸特别开阔的面试官，你比我还牛逼，你别进来了，他说没有听说过三次标记，你一定要顺着他说，你说唉对，那我可能是记错了，很多吧新生开过对，其实也有很多，开个玩笑了，嗯这个是分人的。

是的嗯，三色具体是什么数据存储的，我估计会有同学问这个问题啊，我觉得没有同学问这个问题不正常，三色具体是以什么数据存储的来，各位大哥，这是所有初级的程序员，初初级的入门级的经常会问到的。

说老师那个三色是难道是真的在上面染点颜色吗，我说别扯淡，这个对象啊，它到底是什么颜色的，其实非常非常非常的简单，它有好多种方式可以标示它，第一个我们可以存储一个颜色表，每每一位来代表一个对象，说。

这个对象呢它的颜色如果嗯有两位吧，一零代表黑色，零一代表灰色，一代表白色，可不可以，完全可以，甚至你可以存在这个对象的指针上，这个指针不是有64位吗，目前这64位用用不完，可以在他头上给他挪。

挪出两位来来代表这个对象的颜色还可以怎么办，当然cm s不是这么干的啊，c m s干法是什么，在这个对象脑袋上明白吗，听过我以前课的同学应该知道每一个对象啊，都有一个对象头，头部叫对象的header。

这个头部的话呢叫mark word，mark word标记字，mark word呢在这个mark word里面拿出两，位来来代表你到底是什么颜色的，可不可以都可以啊，具体看你这vm怎么实现了。

只要你能代表状态就行，红黑树，这跟红黑树有半毛钱关系吗，嗯好嗯，我我讲到了这种算法的问题了，可以继续的给老师扣一，好同学们听我说呃，刚才我说过了啊，说我们再看一遍这个动画，其实为了给大家想说明这个问题。

想了半天，只能做动画啊啊这是我们第一次垃圾回收的时候看到的，我们最终的一个情形，a黑色比灰色地白色，我们正常的情况下呢，应该回来之后呢，顺着b继续找到d这是最合理最完美的情况。

但是由于在我回来的过程之中，拉业务线程积蓄发生了这样一种情形，a指向了d b指向d的引用消失了，所以我再也找不到他了，那这时候怎么办呢，办法就是我们需要加一些个所谓的专业名词叫屏障。

但是这跟那个呃内存里面呢说内存乱序执行的那个屏障是两码事儿，它指的是什么呢，指的是当我一旦看到垃圾回收器啊，就是整个呃sorry，整个jvm它会观察，当我一旦看到有黑色对象的引用指向白色对象的时候。

它会加一些操作，他发现了a a的引用指向了a a的这个这个引用指向了d，然后呢a是黑色，d是白色，那这时候怎么办呢，最简单的把a标成灰色就可以了，能不能听懂，就是jvm自己帮你观察了，这，件事。

然后自己帮你把这个a给你变成灰的，所以最简单的办法就是当我们有这样产生的时候，把a变成灰的，同学们，你们想一下，把a变成灰了之后，我们垃圾回收就回收回来，发现a是灰色的，那是不是我顺着a还得继续找啊。

又找到了b又找到了d，所以这就不再会产生漏掉了，来这个解决方案就是cm s所采用的方案，它的全称呢叫incremental update，增量更新啊，简单吧，是不是很简单，对没错啊。

所以这个就是cms的所采用三色标记算法，b为什么不变白色，b为什么要变白色呀，b最后是会变成黑色的，就是说所有的对象啊，在最终的时候它一定都会变成黑色，就是当我的b找到了，他又没有孩子变黑。

当我所有对象都变黑了，那么意味着我找到了所有有用的对象了啊，跟b没关系，好吧嗯，好嘞好嘞好嘞，当我们理解了这件事之后，呃，有同学说通过写屏障，写屏障是什么意思，我刚才也解释过了，就是a。x等于d。

当我们jvm观察到这样一句话的时候，他会在后面帮你加一句话，加什么呢，就是把a。color等于black设成黑色，这射成灰色，sorry，射成灰色啊，灰色是green，ok好这块还有有没有有疑问的。

业务一直运行，找不完呀，难道一直不清理，怎么会找不完呀，为什么找不当，我们有一天一定会找完呀，把所有的东西都找完吗，那a上一个节点指向d呢，a上一个节点a上一点，看它什么颜色吗，你琢磨琢磨。

如果b的应用断了呢，be的应用断了，那说明它就是垃圾啊，b的只是说b的应用，你如果只是b的引用在这里断掉了对吧，然后这个也就没有这里断掉了，那不就是垃圾了吗，没关系的啊，无所谓啊。

这里不是正常理解的屏障啊，这个跟那个跟那个跟那个内存里面我们所说的那个屏障不是一回事，好吧，这个不用sw多少一个时间片就找完了，是的是这样的，把地变灰不是效率更高吗，把d变灰为什么效率会更高。

找到d d还有孩子呢，d得找完孩子找d，如果有孩子变灰，那地那个那个那个如果还没找到他的孩子的话，那只能是灰色，等找完之后才能变成黑色，好吧，它的关键在于是我们呃标记的整个过程跟我们业务线程。

它两个可以同时运行，这个是不是收集完一次就重新从新开始扫，为什么要重新从头开始扫，为什么是怎么理解的嗯，a b之间断掉的时候，b是灰的时候诶，那无所谓啊，那它就是垃圾了，ab之间断掉就是垃圾。

假如说你这时候b是灰色的时候断掉了，那b呢就多多找他一遍，能听懂吗，这个不就上一个问题了吗，刚才那个问题，刚才小伙说说a b啊，这时候a是黑的，b是灰的，然后呢把这部分给干掉了，那意味着回来的时候呢。

我得继续从b找，对不对，没关系啊，不就多找两次吗，找完之后呢，发现他不是垃圾，认为它不是垃圾，所以这次不清理，下一次回来就把它清掉了，这不就是上一次上个上一个问题吗，浮动垃圾。

但是中间标记就不用sl节省很多时间，是的没错好，我们可以继续吗，可以继续给老师扣，一来还没有讲完，还没有讲完，虽然看上去这个解这个解决方案看上去是如此的简单，但是呢在这个如此简单的解决方案里面。

隐藏了巨大的bug，认真听，只有理解了这件事情之后，我们才能够理解这个bug是什么，你再仔细看呃，现在呢我们垃圾回收的站在一个垃圾回收器的角度啊，呃垃圾回收线程的角度，他整个标标标标顺着刚刚开始找。

找到了，目前的时候呢，在他的眼里，整个的对象的对象图是这样的，a是黑的，b是灰的，d是白的，还没有找到，那好在他离开的这段时间，业务线程呢b指向d的影消失了，与此同时a指向d的也增加了，那么回来之后呢。

他会找不到d，所以解决方案是jvm本身，虚拟机本身，它因为它运行嘛，它是运行运行你这个语句它一定会观测到有一个语句是a的黑的，指向了一个b的白的对象，那么它在后面给你加一句，把a变成灰的。

这样的话你垃圾回收线程在回来的时候，a和b都是灰的，所以你可以顺着他们继续找，写篇章的时间是什么，就是这vm给你加的语句吗，这个有什么难以理解的吗，为什么使使劲问这个问题呢。

jvm本身是不是可以给你加汇编语言，它自己实现的不是随便加吗，就给你加上就行了，就把a变成灰的了，所以当我拉圾回收线程回来的时候，就不会漏掉d了，听懂了吧，可以继续吗，可以继续给老师扣一来。

因为这块确实比较复杂，稍微难一点点，忍受一点啊，同学们认真听，今天我给你讲的稍微难一些，明天我就给你讲，稍微容易一些的，不论什么样的人都能听懂的，就是我给你分析整个大厂的职级，这块也是非常有价值的啊。

咱们这儿阿里的老师非常多，现在给大家讲课的已经到p9 了，所以呢跟大家解释解释这个知己对你将来的升职加薪也超级重要啊，ok当你理解了这件事之后，就是把它a变灰。

这种解决方案叫incremental update，就是为了不漏标掉这个d那好，但是这个解决方案的背后隐藏了巨大的bug，下面未必所有人都能听懂了，我感觉可能会一直循环，你感觉你的感觉有问题好吧。

好认真看这个就这个bug呢不是所有人都能听懂了，但是呢能听懂就听听不懂啊，你就记住cms解决方案有巨大的bug，好巨大bug在哪儿，就在于这儿，如果a有两个属性，一个叫一，一个叫二好听。

我说比如说啊我们有一个垃圾回收线程，他现在正在标a，注意它已经标完了属性一了，也就是说通过这个一这个属性啊，已经找到他一个孩子了，但是还没有来得及标它的属性二，那我问你a现在是什么颜色，a什么颜色。

a标了一半了，还没有标完，他的所有的孩子，a什么颜色呀，对a是灰色好看，这里，好标了，他一个小孩还没来及，标二，这时候a是灰色的，这时候这个垃圾回收线程暂停，暂停好。

这时候呢我们的业务逻辑线程有一个业务逻辑线程，把这个一注意是这一指向了白色对象，然后呢大家刚才我们分析过啊，说这个一指向白色对象，然后b指向d的已经消失了，同学们，你们想象一下。

按照我们刚才的分析的东西啊，就是我们jvm啊本身是一定要把它标灰的，对不对，它本身是灰色，我现在一定要把它标灰好，假设我这个过程处理完了，我把你标灰了，但是呢我们原来那个垃圾回收显示又继续。

我们原来垃圾回收线程继续的时候呢，把二也给标完了，站在垃圾回收器的角，垃圾回收线程的角度来说，我把一个对象的一和二，所有的子属性全标完了，那么这个对象应该，变成什么颜色，应该变黑，能听懂吗。

我们再来分析一下这个过程，这个过程比较复杂，仔细听，当我有一个垃圾回收线程，把这个一啊标完了，还没有来得及标二，在他眼里，这哥们儿是灰色，然后呢，这哥们暂停业务线程一指向了d b指向了d的引用消失。

好jvm把它变成灰色，等着下一次继续扫描，要扫描这个一是吧，1v一指向的引用变了嘛，但是我这个垃圾回收线程回来继续，因为他一在他眼里看来已经标完了，该标二了，把二标完，标完之后整个变黑。

那就意味着同学们你们想想看，是不是这个地又找不着了，因为，它已经变黑了吗，d还是被漏了，现在a是黑的，好了，来这块儿，他的问题能听明白的，给老师口音，今天有点复杂是吧，本来这个a应该是灰的。

jvm也把它标灰了，但是我的第一个垃圾回收线程认为我把所有属性全标完了，我把你干成黑色，然后完蛋了，我这个引用指向的这个d又找不着了，这么多假装听懂了吗，大哥你是真的没听懂啊，我这么耐心的一点点的。

然后用动画的方式给你演示，不是每次都从第一个车厢开始检查吗，谁告诉你的，每次都从第一个，那还有什么用吗，你这个算法每次都做根上算，你这个算法有什么用吗，你你算完一遍跟没算是是一样的呀。

他怎么知道一标注了，内部有一个记录表，好吧，每个对象重新算大哥，我们是把所有的这从内存里面来说呢，它是一棵对象树，是不是稍微稍微再拧一点点，这个讲这个东西呢，每次讲这个我也我也比较头疼。

我也想给你们讲点简单的，但是好多人说简单不解渴嘛，内存里头我们在某一个瞬间，它一定是一个对象数，这个对象指向这个对象，这个对象只有对象呢已经变成垃圾了，就是它我们为了把这个对象树给找出来。

只有找到这颗对象树，剩下的那些全才能不是垃圾，那剩下那些才是垃圾，才能把它干掉，那为了找这个对象数，你不能从头每次都从头开始找啊，因为数很大，你根本找不完，内存特别大的时候，你这个数根本找不完。

那你sw时间不还是很长吗，你如果每次都从头找到尾的话，那怎么办呢，我就从每次从根儿，上找根儿上找完之后呢，我找到这一层，我就暂停一下，然后回来的时候我继续能听懂吗，所以它就是分分好多好多次的线程运行。

才能够标记完整个的这个对象数，但是在标记整个对象数的时候，对象数又在变，所以我们要解决的问题是在它变的时候还不会产生漏标，主要是考虑到这个问题啊，好，可以继续吗，老师1年多少万，你把这个问题弄明白了。

1年50万没问题，放心吧啊，好，所以呢为了解决这一系列的漏标问题，我们用了三色标记算法，那么三色标记算法呢为了解决三色标记算法里面的罗标问题，c m s呢采用了把黑色变灰的方案。

这种方案就是increment al update，但是这种方案有特别隐蔽的问题，就是我刚才给大家演示的好吧，好同学们听我说，cms后来发现了哦，原来我有特别特别隐蔽的问题，依然会产生漏标。

那这时候怎么办呢，认真听。

系列 1：P30：多线程与高并发：10.DCL单例（Double Check Lock）到底需不需要volatile - 马士兵官方号 - BV1mu411r78p

你抓那个代码吗。

知道啊，那代码抓过来。

嗯，嗯，好我把代码先贴到这儿，有同学可能就会说，我考这么简单的代码居然会有毛病，是的这段代码有毛病，毛病在于哪，你仔细判断呃，看这里啊，我们假设这个instance就是我们的小t啊。

它里面有个成员变量啊，我们叫它m等八，这个无所谓啊，大家应该记得我们对象的创建过程，稍微回顾一下，然后好几步是吧，好现在呢我们假设假设第一个县城来了，第一个线程来了之后呢，它会判断t是不是等空。

t等空吗，最开始是等空的，没有问题，上锁上锁成功没有问题，判断依然为空，没有问题，确实依然为，空好，当我们执行到这句话的时候，instance等于new new对象，new t对象。

当我们执行到这句话的时候，同学们，你们想想看，执行到这句话的时候还记得吗，另一个对象有几步，过程三步，ok，当我们执行到了第一步，new执行到这里的时候，我们的成员变量是默认值是零，我也我前面还讲过。

质量是可以换顺序的，记得吧，质量是可以换顺序的好，那在这个过程之中，指令到底怎么换顺序，如果不幸发生了下面这两句话，换顺序，大家还记得两句话的意思吗。

in works special的意思是把这个m等零变成m等八，a store的意思是t和这个对象建立关联，假如在这个时候线程暂停，然后呢发生了指令重排序，嗯，行程不暂停啊，就是发生了指令的重排序。

指令重排的时候呢，把这个a4 多少挪前面去了，也就是说这时候这个t它指向了一个初始化了一半的对象，来这个能get到的老师口音，到这里的时候，它指向了一个初始化一半的对象，当我们，看到了这个情况的话。

好记住，初始化了一半的时候，正好执行到这里的时候，我第一个线程暂停了，同学们，你们想想看，第一个线程暂停是不是有可能第二线程来了，第二个线程来了，是不是也执行这第一句话呀，他执行这句话的时候。

会判断if t等空来，你告诉我这个t目前视为空吗，是不是为空，不会空，他只不过是指向了初始化了一半的对象，但是他一定不懂空，哦我看有同学比较着急，说老师能不能讲一些线程池的这样啊，今天无论多晚，嗯。

我一定给你至少讲一道线程池相关的题可以吗，线程池呢是一个特别体系化的东西，呃如果你也想听听老师的那个关于线程池的讲解的话，要一些以前的视频好不好，我们把这个结束掉o呃县城是面试的超级重灾区。

也是你拿到高薪的很关键的一个点，呃可以这么说，在你整个生涯里面，不管你什么语言，县城这件事是你躲不过去的一道坎儿，像java语言呢除，了县城之外，还有一个很重要的东西呢，就是虚拟机。

这个也是你躲不过去的一道坎，那么对于我们开发业务业务的人来说，还有一些卡是什么呢，数据库嗯，你知道我们就是作为我来讲，但是大家可能了解我的人。

可能知道作为我们的我我我我来设计这个mc客户来把控整个的走向，呃，mc为什么是不断的扩展各种知识内容。

一个数据库从mysql开始到mango到hbase到click house the ocean base，就是一个数据库呢，就会给你扩展好多，原因是什么，就是不想让你在机上有短板呃。

但是如果从初初级程序员角度讲，其，实呢你只需要抓三个特别大的重点，第一个呢就是多线程，第二个呢虚拟机，第三个呢数据库的调优，这个是你面试的时候的强力的加分项啊，你记得我说的话好，我们继续讲。

就是当你执行到这里的时候，我们需要回顾一下第一个线程来了，初始化了一半的时候发生了指令重排，导致我们这个引用就指向了一个初始化了一半的对象，初始化一半对象的时候正好到这里，第二个线程来了，县城来的。

判断他等空吗，不等空不等空，是不是就直接拿来用了，那他是不是就用了那个初始化了一，半的对象，你的男朋友是不是就穿了，只穿了条上衣就出去了，就他穿了一半的衣裳，他就出去见人了，这合适吗，不合适，听懂了吗。

嗯来这块能跟上的，给老师扣个一，好，为啥不为空诶，为什么会有同学问这个问题，a ba be该是基础稍弱的小伙伴啊，你看这里的t已经指向一个对象了，一个引用通过它可以找到一个对象，你说他能为空吗。

天啊这个这个引用为空是什么意思呀，他引用为空不就是说通过它找不到任何对象，是不是也有引用地址了，明白吧，嗯嗯，对啊这个实例化问题实际真的会出现吗，目前只存在于面试之中呃，但理论上是会出现问题的。

那么这个理论出现问题的可能性是有的明白吗，就是问我们我们讲程序这件事呢，叫做一定要精确，你不能因为说它出现的概率很低，100万次里头只出现一次，你就是可以忽略它，这是不行的。

这个在java高版本已经解决了对但是它本质上这个问题存在，java高版本解决，指的是oracle的jvm的实现，hot bot这个版本解决了。

但是你能保证你自己看从开源下载下来的其他这vm的版本解决了吗，你不能保证这一点，所以还是要精确精确再精确o我说清楚了吧，嗯，半初始化是m有值是零，不是八对你说的很对啊，好了嗯。

当你理解了这个最根本的问题之后，我还是那句话，就是你平时调bug最简单的bug叫语法bug，一个语法直接告诉你哪行编译不通过，哈哈你语法没写对，最简单的当然语法有复杂的，c加加语法比较复杂。

rust语言语法比c加加语言还复杂，所以这个语言虽然说它有各种的优势，但是目前看起来发展性还不是太好，嗯不过没关系，想了解这门语言老师mc课里头有想了解的去了解，那个呃拿第一第一种bug最简单的语法吧。

第二种叫什么，第二种叫运行期的异常，语义上的有bug对吧，呃运行期异常这个也很简单，原因是什么呢，它会直接告诉你是哪行出的什么样的异常，调试起来比较简单，第三个呢叫语义上啊，你本来应该输出是三。

结果你永远输出是四，说明你中间的计算逻辑有问题，只要这个结果稳定没有问题，最恶心最难调的bug叫做时而对，时而不对，遇到过吗，运行一个月只有某一秒是错的，其他时间都对，这种的叫恶心死你。

因为调bug这件事一定要保证重现，你如果不能重现，你这bug叫没法调，你bug不能重现，你只能采取一种方式，就是记录无比详细的日志，然后去查询当时发生bug时候的日志，看看能不能推导出来，咳咳咳，我说。

上的还不是太好啊，sorry嗯嗯对对没错，sorry啊，我记炸了对，就是多线程遇到的对，所以多线程的bug是多线程的bug是最难调的，最难最难调的。

这就是为什么rust语言看rust的语言永远不存在多线程问题，这就是这个语言的牛逼之所在，偏生支持高并发，但是放心您老人家，只要这程序写出来，编译通过，就一定不会有多线程问题啊，就这么牛称。

好了不在这儿展开了，展开起来就没边了，我不可能通过短短的两个小时保奖十好几个小时的课，20几个小时的课全给你讲完啊，虽然你们非常想这样，但是sorry赚不到，慢慢来看这里。

当你理解了指令重排序以及它造成的严重后果，这件事，我相信你就开始应该开始问问题了啊，那个首先我觉得大多数的第一个问题应该得这么问吧，随便哪两条指令都能重排吗，随便两条指令随便重排吗，是不是，当然不是。

显然不是吗，你的第一条啊，我们说不说指令就说语句了，你的第一条语句是a等于一，第二条指令是a加加大哥，这两条能换顺序吗，能换吗，肯定不行，你的第一个操作是sleep together。

那你的第二个操作是be pregnant，你肯定不能换顺序，换了顺序，那就不是你的人了，是不是，逻辑是不对的，所以呃什么样的指令可以换叫做记住我给你记住我跟你说的名词，你看的都是不对的。

记住我跟你说的名词叫做保持现成的数据一致性，呃就是保持一个线程数据的最终一致性，好这句话什么意思，就是说两条指令a等于一，b等于二，你换过去换过来，随便你换啊，你c等于三，你随便你仨仨人爱怎么换怎么换。

不管你采取什么样的东西，当我整个线程结束之后，我再说一遍，当我整个线程结束之后，无论怎么样换顺序，最后这个线程对于内存所影响的结果是一样的，叫做保持现成的最终一致性，只要你保证成这样。

其他的还没有任何其他限制，这块大家能理解吗，有同学说了，说老师您中间这俩能随便换吗，可以的，java的虚拟机的规范并没有规定说这俩不可以换，我说的这个刚才讲的这个啊是是怎么说，是一个嗯。

我刚才讲的这个呢是一个最呃最底层的问题，就是从我们最底层的汇编语言的角度讲，你只要保证整个县城的最终一致性，就是你里边的语句，您老人家随便换好吧，除了他自己定好的规则之外，当然如果随便换的话。

会出各种各样的问题，我们我们现在站在不是站在不是站在最终那个操作系统，windows linux，不是站在这个角度讲啊，我们现在开始讲什么呢，开始聊这个jvm这事就是jvm里面的j vm。

记住它是一个规范啊，它并不是一个具体的实现，jvm规范里头会规定规定什么呢，它会规定说哪些，语句不可以换顺序，只要你符合这个规定，你的这vm就就就就就呃就是符合这个规范的哪些语句不可以或者顺序。

那么在jvm规范里头规定了哪些语句不可以换顺序呢，好这个东西呢，按这理所布局了，sorry，呃搜一下我找一下我那ppt啊，算了，不给大家展开了，你们也可以也可以也可以上网去查啊。

就是说哪些语句是不可以换顺序。

系列 1：P31：多线程与高并发：11.线程的“结束” - 马士兵官方号 - BV1mu411r78p

随便在哪换一下啊，不要看这字儿啊，这字没意义，哪些语句是不可以换顺序的，上网去搜这个名词，happens before，happens before，呃我估计不少同学应该是听说过这个名词的。

happen before在什么之间发生，就是它规定了有八种情况是不允许换顺序的，这两种情况呢你也不用记，你也不用背，它都是非常浅显的一些情况，比如说线程先要弄完了之后才能启动啊等等，就这一类的啊。

呃那个对象呢必须先溜出来才能调，才能才能回收啊等等等等这一类的，好吧，呃听我说这八种呢你也不用背，因为这是jvm虚拟机的规范规定的啊，你只有做虚拟机的人才需要去关心它，就是总而言之，你要了解的一点是。

在我们系统的最底层，我们内科cpu的硬件级别对他的一些个操作是体系，是影响到我们的高级语言的，好吧呃当然我讲到这儿呢，有同学一定会问第二个问题，说老师呢我刚才呃我认知到了啊，这个指令有可能会顺序。

并且呢它会造成不可见的一种情况，不可预测的一种情况，那你告诉我我怎么才能解决这种情况呢，就像我刚才写的这个b cl这块也是一样的，同学们想，既然他有可能读到中间的中间的值，我能不能不让他读到，可以吗。

可以做到吗，好听我说，同学们，你，们我现在先讲啊，注意就是这块的内容呢是牵扯到好几个层次的，就是从最底层的层次到虚拟机层面的层次，到源码层面的层次，到编译器层面的层次。

其实每一层都有解决自己不可换顺序的这种解决方案，我现在讲给你，先给你讲的是最根上理解的东西，你先把语言什么全给忘一边去，什么volatile，什么c语言，什么java语言先给我放一边，不用不用想这事儿。

我们现在讲的就是汇编，同学们站在一个一颗一颗cpu的角度看，你给我两条指令，我是可以换顺序的，那我现在想问你的是，我如果不想，让这两条指令换顺序，我该怎么做，这两个人排着队，我就不想让这个人插队。

我该怎么做，该怎么做，简单，我在中间竖一堵墙就行了，能听懂吗，我在中间把门给他关上，墙上只有一个门，门一关，我先让这哥们进来，他执行完了，我才放第二个人好，这堵墙指令和指令直间的这一个东西。

一般我们把它叫做屏障呃，叫屏障，英文的名字呢叫barry啊，或者叫fence，fence是里面的意思，听我说所有的cpu or cpu啊，所有的cpu啊，有一个算一个都有自己的屏障指令。

屏障是一种特殊的指令，指令一指令二中间有一个指令，虽然它比较特殊，说屏障比较特殊，但它也不是说多长和一类，它只是一种一条特殊的指令而已，你想让另另外两个人不让他换顺序啊，你在中间放个指令，no放个牌子。

就这意思啊，另外一条特殊的指令，当cpu看到这条指令的时候，他不会把上下这两条指令换顺序，这块能听懂吗，同学们来这块能听懂的，给老师扣个一，就是你先把语言，这事儿忘掉好吧，网上有很多很多很多文章。

它是把这为m级别跟硬件级别混在一起讲，所以你会听不明白啊，这事很正常，你听老师讲不就行，迷糊着就明白哈，嗯，所以如果说你想让你的这两条指令不可以换顺序的话，就非常的简单。

就是在中间放一条特殊的屏障指令就可以了，用英特尔的cpu来举例子了，英特尔cpu有好几条屏障指令，l fans，m fans，白色fans这些都是它的屏障指令，就是大家伙看到这场他指这些指令的时候。

不可以换顺序，或者里头有有有有有单词啊，我那拿这个l来举例子，l什么意思呢，l的全称叫load，load是个啥，load是读读操作，也就是说如果当你看到一个l fans的时候，上面一条读操作。

下面一条读操作，这两个操作不可以换顺序，但如果上面是一个写操作，下面是一个写操作，这俩你随便换，实际上屏障的指令它非常的特殊，它还会细化到诶到底哪两种不同的指令不可以换，其他的都可以换，哈哈9。40了。

好多同学想等着听现城池呢，要不我就把顺序和屏障这事先讲到这儿听可以吗，八种内存屏障没有天道酬勤，不要在这里搁那儿传递错误信息，没有八种内存屏障啊，线程池不急啊，这一点应该可以忽悠面试官，是的嗯，宋豪说。

m1 si协议错了，如果你要讲凭证，把m e s i带出来，除非面试官不懂，不然的话大嘴巴子抽你，哪儿凉快，哪儿呆着去屏障跟msi没有半毛钱关系，一毛钱关系，一个子儿的关系都没有，不要讲一半。

嗯听我说线程池呢我以前也讲过好多种，那个如果今天大家伙没挺爽的，讲完只讲一半，这样吧，我今天多晚呢，我会把我会把线程池的一道问题讲给大家听，我挑一道问题想办法满足12的同学们啊，老师是单线程的。

执行不了多线程，这样啊也是最近最新的最最近近刚刚遇到的这个特别经典的，就是那个来自于阿里的一个问题呃，这个问题这个问题比较好玩，我先先不讲这个啊，我们讲阿里的一道问题，讲讲这个讲这个问题吧。

就是阿里最近提问的一个问题啊，呃管理的问题是这样的，他说呢呃我要求你去做一件事，就是这件事我举个例子，比如说呢我们要求你去做一个火锅，就是我们呃去完成很多人吃火锅这样一个任务，那么要想吃到这个火锅呢。

得有好多好多的任务并行去执行，有的人呢去买菜，有的人呢要去买肉，有的人呢要去买锅，然后呢同学们你们的想象，回来之后呢，这个火锅才能吃上，能理解吧，就是一个任务会分成不同的可以并行的阶段。

分成不同的并行的阶段之后呢，现在阿里的要求是你写一个程序去模拟这个在你模拟的过程之中，假如有任何一个任务失败了，其他任务全部取消，注意要用最快的速度完成，最快的速度取消呃，这块能能能听懂这个题吗。

观察者模式不，这是著名的，你好好想，这叫做分布式事务，哈哈哈哈哈，因为你要回滚的，你这个买肉买了一半回滚，把钱给我拿回来，没底料的对，这叫做分布式事物，如果有一个取消掉的，其他的都得赶紧给我取消掉。

这个大家能听懂吗，有同学说老师这跟线城市有什么关系，县城池里面有个著名的线程池的应用，future你们听说过这个好呃，留给留给大家一个小小的那个思考题，现好吧，嗯今天我这个嗓子不行，所以我讲的速度稍慢。

不然的话我是能给大家讲完的，那个这个太难了吧，废话你讲解阿里他能有容易的，毛微尘，一不执行，对没错，如果你不不了解的，可以去听听看，老师以前讲过，老师讲过这个题，专门讲过一堂课。

呃我今天我我待会儿会给大家简单过一遍好不好，那个如果说听不听不全没挺爽的，没有关系啊，要我以前讲那堂课去，可以吧，呃我我把我把屏障这件事给大家讲完啊，屏障呢还有很多很深入的内容。

我至少给大家把一个完整性给大家过一遍，可以不可以来可以的话，给老师扣个1k，啊这实在不好意思啊，不然我肯定是在给大家讲完，就是第一次，昨天嗓子也很疼，讲的速度就比较慢，那个嗯。

那个那个后来今天嗓子也不疼啊，所以速度稍慢过，没关系啊，以前以前讲过，你可以拿去听一听，呃，我给大家讲完这个屏障，还有点费劲呢，不急嗯，嗯关于屏障这件事呢，还有一个特别经典的问题是很多同学问到他。

他是答不出来的问题，这个呢你要认真思考，呃，我们翻过头来呢，还来看这个程序啊，就这个程序，那个程序里面呢呃以前有同学呢有一个特别特别经典的问题，他的问题是这么问的，他说老师啊，你不要蒙我。

我是学过synchronized的，我是知道的，上锁这件事儿，它是可以保障可见性的，什么意思呢，就是我肯定我只有我执行完整个这个这段操作，这个操作是不是做一个原子吧，我们称之为叫原子性。

执行完这个整个整体的操作之后，那它内存里面这个new的对象一定要找肯定10000%的new完整啊，它里面一定是个八，你怎么可能说他扭了一半啊，我上锁被我锁定的代码，你能看见中间的状态，你不是扯淡吗。

能听懂吗，同学们，我再说一下这个问题，你好好思考，他说老师你不要蒙我，我是学过single dized，synchronized，是一个线程执行完整段代码之后，另外一个线程对这个线上一段代码的执行结果。

它一定是可见的，你不可能读到中间状态，你读到中间状态，那我上锁还有什么用吗，就没有任何用处了，可是您给我这讲半天，你是说另外一个县城读到了其他县城的中间状态，这怎么可能，就能听懂这个问题吧。

有同学说副本胡说八道，这哪有副本，这个副本有办法相关系吗，听我说这里头是一个核心的问题，同学们，你们想想看，确实有第一个线程用了一半，这里的值是零，第二个线程来的时候会进入到这段代码吗。

不会第二线程执行的时候是不是，首先是看这句话呀，if instance等空，那我想问你的是这句话，是被锁定的代码吗，不是能听懂吧，它不是被锁定的代码，那现在问题就是就变成了上锁的代码和不上锁的代码。

互相之间能不能读到中间状态，答案是yes，ok好了，我给你解决这个最后的疑问啊，好我们说这个屏障的问题，继续说这个凭证的问题，这是哪八条嗯，可以互换的顺序的，不可不可以互换顺序的呃，gm的需求啊。

这个不说了嗯，我们说这个屏障的问题，这个屏障是怎么解决的呢，我们讲在java里面是怎么解决的，在java里面解决这个屏障呢是有一个关键字，这个关键字叫做罗了，tell嗯，多数同学应该是听说过的。

我再说一遍，多数同学应该是听说过的，但是我有也有也有也有没有听说过的啊，下面要讲的内容呢是比较复杂，比较繁琐的，比较复杂比较繁琐，能跟上就跟跟不上啊，就当到某一个地方旅游了一番好吧。

多少有点收获就ok了，好好听认真听，就是在java里面，这哥们儿是怎么不许它的指令进行重新排序的呢，它非常的简单，java是这么做的，java是在你要修饰的这个单位前面加一个关键字。

这个关键字叫voluti，好有同学说了，volatile这么一个关键字居然就能解决冲排序的问题，这事很奇怪啊，同学你是琢磨作为一个对象，这是那个t对象，你是对某一个对象加了个修饰符。

你你的你的这个对象说红的绿的，你加了个修饰符，你告诉我说对这个对象的操作不可以重排序，你不扯淡吗，原因是什么呢，原因是站在jvm虚拟机的角度，一个变量，他都会加一些特殊的操作好，那这个操作是什么呢。

嗯看这里嗯，稍等啊，我把ppt给他调出来，好注意看，这个操作是a volatile修饰的，任何的变量在写这个变量的时候会加屏，正在读这个变量的时候也会加屏障，那有同学说了，那老师加什么屏障啊。

好jvm里面规定了任何实现的java虚拟机都必须实现以下四个屏障，我再说一遍啊，java里面的任何的虚拟机都必须实现以下四个屏障，有同学说了，我靠这怎么能记得住啊，不用记。

到目前为止也仅仅有一个小伙伴被问到过这种问题，以后从来没遇见过，所以我讲清楚你我一讲你一听就ok了，就不用记和背了，当然那个小伙伴呢他也是比较牛逼的，他当，时是灭了七面，最后杀进了阿里阿里国际。

阿里express那个呃，只有他是变了七次，一般的阿里面是3~4次啊，超过四次的很少嗯，他当时为了七次问到的问题，问问问到这种细致程度了，就是说任何的java虚拟机，如果你想实现它的话。

需要实现这四种屏障，这四种屏障呢我用一分钟就能给你讲完，而且你忘不了这四种形状叫load load store，store，load store和store load，这个东西呢，记住它是一条指令。

当我们看到这条load load指令的时候，指的就是说如果前面有一个load指令，后面有一个load指令，就是读操作嘛，对于volatile修，饰这块内存的任何的读操作。

这两个读操作中间有一个load load指令，这俩不可以换顺序，能不能听懂，稍微消化一下，那其他的还用我讲吗，你只要把我刚才讲的这段消化掉了，其他这三条凭证，你自己想拿大腿都能给我想出来，没问题吧。

其实不难，看上去难，其实不难，就是如果上面是一条斜指令，下面是一条斜指令，我不想让这哥俩换顺序怎么办，告诉我怎么办，加这条指令，store store是不是好，上面是一条lt，下面是一条s呢。

不想让他换怎么办，load store行，就这么简单，所以呢从volta的角度讲呢，就是说volatile修饰的任何的对象，如果你在对这个对象进行写操作的时候，这是一个写操作，是一个store操作。

在它前面加一个store store va，也就是说前面的store和后面的store不可以换顺序，再到后面加一个store load barrier。

也就是说前面的store和store load不可以换顺序，就是我写完你才能读其他的，原来的全写完了我才能写，毒也是一样，后面加两个加两个凭证啊，因为一元一验算的话，你自己去，验算，好好讲到这儿。

我相信jvm层面怎么解决屏障问题，为什么讲清楚了，来可以继续的同学给老师扣个一，我怎么验证呢，你验证不了，因为因为这vm不是这么实现的，所以你验证不了，哈哈哈，有同学说老师我又懵了，同学们。

你们好好琢磨，我说过好几次，我说这个屏障类问题呢，它会牵扯到好几个层次的问题，这在语言里面加了个volta，jvm里面加了屏障，但是你记住啊，所有的虚拟机也好，或者什么也好。

最终是不是得体现到我们的cpu的执行啊，是不是得体现到我们cpu层面，对不对，你就是中间加了什么乱七八糟的东西，你最终也一定是cpu的某条汇编指令，二进制一定是这样的，那现在问题就来了，记住这玩意儿啊。

你可以认为它是不存在的，为什么，因为这是一个jvm的，我再说一遍jvm的规范，什么叫规范一个标准，这个标准怎么去实现它，我是不是可以不实现它，我用其他的操作规定，全部把它给给他，给他搞定了，也可以吧。

也可以的，也没问题，我再说一遍，这是jvm的规范，但是符合这vm规范，只要保证窝了条，写了东西，我不给你换顺序，是不是就可以，我没有必要说一定是要用屏障来实现，能听懂吗，来这块能跟上的，给老师勾引。

还是没听懂是吧，就是我现在有一个规范，我规定我的女朋友必须是女的好吧，我规定必须是女的好，就说无论注意这是条规范，那谁帮我实现一个女朋友，只要他能实现成女的就可以，至于说是女的人还是女的动物还是什么。

还是转了性的，我不管，只要你能实现，这就是规范，怎么实现，最终只要是女的就行，好jm的规范是说volatile写的东西，你不能给我换指令顺序，听懂了吗，只要你最终是怎么实现，你爱怎么实现，怎么实现。

你只要保证一点，就说volatile修饰的东西你不，能给我换顺序，读和写，不能换顺序就可以来这块能听，能能可以可以了吗，可以继续了吗，来q区给老师扣个，一来，可以了是吧，过好当你理解了这件事之后呢。

那我们就来看看大家知道我们平时用的这个m是谁的，谁的视线是不是oracle自己的视线，博士口从四收购过来的是吧，它的名字叫什么，告诉我hot slot好了，这是oracle自带的那个事情。

平时我们用的就是它，那有同学说还有其他的吗，有没有其他的这vm实现，有没有这一脚，有没听说过ibm的，淘宝vm有没有听说过阿里的，呃，c four，有没有听说过号称特别牛逼的啊，叫in啊。

那个叫zc放点公司啊，他那个名字叫z吧，我忘了啊，嗯对j rocket，open jdk一堆，具体怎么实现的呀，不好意思，您得看它的具体的实现去，那我们就下面就来看一看啊，最后一个难点带大家攻下来。

我下面就来看一看hot sport到底怎么实现，关于hot pot怎么实现的，这件事又会牵扯到底层的东西，但是我尝试讲给你听，内存屏障是针对第一个线程，内存屏障是针对所有线程啊。

只要你修饰了对他的任何操作，就不是不可以换顺序好听我说呃，大家应该都知道这个我得打开我的c加加的代码，大家应该都知道hosp拿什么语言实现的呀，告诉我hob拿什么语言实现。

四加俩语言，ok嗯，这里呢如果你想读懂hot spot的代码，我们黄老师呢每个月都有一个训练营专门讲hosp代码，嗯，因为我们讲问题喜欢跟你讲到最根上最顶级的最细节的那个问题，ha本身代码是c加加实现。

但是没有关系啊，我带你读，实际上也不难呃，大家都知道java语言本身是解释执行的，那么这个解释器呢被称之为叫by code interpreter，这是c加加代码hosport的实现，就这就这个代码。

你要愿意的话呢，自己下载hospital代码，拿去读，bad code，interpreter，bad code，二进制码，interpreter解释器，这就是用来解释java语言的。

在其中有一段是这个，他说if catch is volatile，如果你修饰的这个东西是volatile的，那么它调用的是哪段代码的，是这段代码是order access的fs方法呃。

讲到现在这儿还能跟上吗，虽然说你们没学过c加加，但是能不能跟上，可以吗，ok ok good，然后听大概的啊，大概就可以好，那这个fans代码又是怎么实现的呢，好，这段fs代码是怎么实现的呢。

我在这儿就不在大家一一的讲了，你会看到load load store，store，load store和store load。

然后调用的分析方法等等等等等等，呃我在这儿呢就不一一的讲了啊，我直接呢在笔记里头呢，一会带你跳跳来跳去看c加加呀，一会儿同学们就懵了，我在笔记里呢实际上给你指出来了，就是当你你去读hob实现的时候。

第一去读这段by coding interpreter的c加加里面的这段。

我刚才给你解释过了，第二去读这一段最终的时间是在这儿啊。

我们把这个代码稍微放大一下，最终这是最终的一个时间，好这个呢是最终的一个实现，仔细看这个最终的实现是什么呢，你会发现呢它有一个小小的判断啊，这第一个判断叫做is m p。

它会首先做一个is m p的判断呃，呃你的操作系统是不是mp的，那个mp又是什么意思呀，p呢叫做multi，person多人运动啊，sorry，我主要看你们还有没有在认真听讲，mmp的意思是什么。

叫moji，proscissors，叫您老人家是不是多个cpu，多核cpu，听懂了吗，哎如果你是多核cpu，是amd 64的，是什么样子，是其他的情况是什么样子，呃我们简单看一下，如果你是多核cpu。

最终的时间是在这儿，它是一条这样的一条指令，这条指令第一个指令叫lock，第二个指令叫ad，可以这么来理解，是一条加法操作，只不过在做加法操作的时候上了一把锁，听懂了吗，哦这是一个最终的实现。

有同学说老师我讲了，你讲来讲去，实现一个屏障，就这么简单吗，是的就这么简单，这就是最终的实现，当然我讲到这儿，我估计喜欢刨根问底儿，就就那个最根儿上的同学又该问了，你们该问什么了，你们该问嗯。

就是基础差的同学会问rsp是啥，esp是啥，好先解释基础差的同学的问题，r s p e s p是cpu里面某一个寄存器的名字，可听懂了，你还记得那个cpu有是不是有寄存器，那这个i的操作有什么呀。

就是对这个寄存器他的那个值加了个零，把根拔出来，能不能跟上，跟得上，跟不上了，哈哈哈，那没跟上呀，直接干蒙了好了，我不干了行吗，就就到这就到这儿啊，勉强ok马马虎虎嗯，嗯再往后跟呢会跟到什么程度。

我直接告诉你啊，再往后跟会跟到说为什么lock指令居然可以作为屏障，用lock指令又是什么，好吧，那么logo指令是什么呢，推荐一本书是我们黄建华老师写的，叫深入理解java并发原理。

只不过呢他还没有完全出版，正在出版中，这里面详细的解释了对于cpu的并发控制，一共有关中断缓存一致性协议系统屏障啊，sorry关中断缓存一致性协议屏障，还有一个呢就是著名的总线索和缓存锁。

我们所说的lock指令指的是cpu级别的锁总线或者所缓存好，就讲到这儿，我稍稍微再帮你梳理一下，我讲到这儿，你你你基础差的，你肯定会稍微的晕晕那么一点点，但是也不会说有那么晕啊，我再帮你梳理一遍。

你会发现呢，其实它的线路很清晰，首先第一点，在今天的课程里，我教了大家什么叫做乱序执行，记得吧，所有的cpu都有乱序，你是跟你什么语言没有半毛钱关系，你汇编语言也有乱序。

乱序会产生各种各样不可能就是你可能预预估不了的一个情况，那就是控制不了情况怎么办，你就需要控制这个乱序，怎么才能控制这个乱序，我们先忘记底层，怎么才能控制这个乱序呢，控制这个乱序的方法。

如果是在java层面还记得吗，java层面是怎么做的，java层面是你只要加一个volt就可以控制乱序，为什么加volatile可以控制乱序，是因为jvm规定所有的java虚拟机必须实现四种屏障。

wallet修饰的任何东西，把这些屏障都给我加满了，这是jvm的虚拟机的规定，但实际当中是这么实现的吗，实际当中的虚拟机的实现就通过一条指令解决了上面所有问题，这条指令就是著名的lock指令。

对于其他的这种汇编指令，你可以不了解，我推荐你呢就了解这一个就可以了，这个指令叫lock lock是什么东东啊，这是一个cpu，这是一个cpu，他们两个去访问内存里面的任何一个情况，任何一个东西的时候。

这个传数据的东西叫总线，lock的意思就是锁住这条总线，lock的意思，其中的一个意思啊叫做锁住这条总线，我cpu操作它的时候，不好意思锁住这条总线来，你告诉我谁能给我读到中间值，你能吗。

你能不能任何其他的县城都不可能，其他的cpu是这边只有放开了其他cpu才能去做其他的操作，他做wallet t的操作的时候，要锁住这条指令，洛克如果深究，还有其他作用，但是我今天不是讲汇编，不展开了。

系列 1：P32：多线程与高并发：12.课程答疑 - 马士兵官方号 - BV1mu411r78p

做广告了呃，我今天呢快速过，我只想说一定月底在月底的时候，我们一般都会有课程的升级，课程升级呢嗯从今年来看。

我们已经升级升过七次了，这个升级的过程呢，如果你愿意的话，我也可以给你展，稍微展示一下，大概今年到到现在为止，我们升级了九次了啊，一共生了七个月，生了九次课，面试突击，线上招聘，大厂算法app上线。

二点升级，金九银十的突击呃，这次呢是叫做大厂的共研课，这个什么意思，如果我们已经和京东，京东独家协议，我们和京东共研课程嗯，还有呢8月1号开始的，也就是说后天开始的互联网三高项目课嗯。

我们的袁京东的老师，孙老师现在在微博给大家讲的大厂的生产事故和bug bug的处理课呃，我就直接告诉你马老师这里的很多课，你看其他机构是根本看不到和听不到的。

那个，简单说一下跟京东的合作吧，呃我们现在跟京东的合作是一个什么程度，就是说京东那边会有专门的顾问来出来来，我我我比方说我们要讲一个讲一个三高的项目啊，讲一个京东的商城啊，像这一类的啊。

这是我们已经开发完的啊，像这一类的，就是说它背后到底是怎么实现的o呃用到的是是什么样的相关的技术，京东那边都会给出对应的这样的一个一个一个一个答案啊，就是你直接学就是大厂的，大家愿意的话。

可以访问一下这个ip呃，因为现在还没有专门给他申请域名，所以现在只有一个ip，12470111231，然后在这个小海马这里可以直接下载白皮书呃，这个项目呢嗯我就不下载了，迅雷起来讨厌这个项目呢。

这个这个白皮书呢它比较厚啊，就不给大家打印了，这白皮书是应该是100 100表示六页嗯，从课程介绍到信计的知识点呃，到项目的目标，到需求的分析，到项目的设计嗯，还有一个重点，异常的日志数据库怎么设计。

release的规范该怎么做，gate怎么提交。

工程结构是什么样子，安全的规律到底什么样，呃，大家伙呢，如果你因为我今天给大家讲的实际上是很微观的内容，但是我还是那句话，我希望大家伙最后成为一个架构师，是作为一个宏观的把控者。

就是整个项目你可以站在一个leader的角度手里，还管一批人啊，你做那个最主要的东西来把这事儿做完好，这个项目呢采用的技术架构，我也想给大家伙交代一下啊，这是够浪语言，我觉得这不展开了，这个技术架构呢。

大概是这样的，第一会有分布式的i d生成中心，分布式的配置中心，分布式的锁集群，分布式的事务集群，缓存集群，网关集群，注册中心监控集群，mq的集群，e s集群事务调度，mysql的集群。

这就是数据这块呃，怎么说呢，大厂的规范，市面上有很多很多关于架构师的课，有的人抄袭我们的，有的人嗯打着大厂的名义，然后讲的多数都叫做p p t架构师，就是你想落地这件事儿，对于那些刚入门的小伙伴。

听单体版，一步一步的分层，一步一步的分布式，一步一步的每一个节点做到微服务，再给他监控，可以称入上百万上亿的流量，到底是怎么做到的，不好意思，老师这里就是完全落地，落地这件事比你想的重要的多。

画图谁都会落地就懵逼，这种人多了去了，没基础能不能学啊，可以的，没基础就是先学第一个版本，第一个版本是叫做单体版，好吧，在单体板掌握的基础之上再来学对应这个版啊，但如果只有一个项目说这个课是不是深度高。

不是在这个项目的指导之，下会讲高并发分布式的理论，cp定理啦，base啦，这些我就不念了，第二个底层技术的支撑，io克，高并发的单机jvm调优gmm linux内核操作系统相关面试题常问的嗯。

算法课我在开始的时候已经给大家讲过，在这不展开算法课的内容了，然后关键算法的支撑，泰克索斯zab raft gossip，这些都是分布式的算法啊，令牌桶啊，a e s r s6 加密的。

然后线性回归逻辑回归kn，在这个的基础之上呢，再来讲中间件的原理，剖析spring spring mvc的源码课嘛，my balance tomcat源码呃。

通看源码我们有可能是下一步要更新的一个重点呃，如果待会先看一眼，我看一眼，我们头看原版应该是排排上了嗯，就是现在不断的在更新之中啊，搜索一下，呃从tok是什么。

到这d b c这d i e g a b等等等等，就是关于tom cat的所有周期的一个内容，嗯我预计会有，预计会有差不多180多节课呃。

我讲到这儿可能有同学，可能有同学会害怕，你们会害怕吗，就是你会看到老师这边的一个治学态度，在其他机构那里看到了一门课，他们开源码很可能是两三个小时就完事儿了，这个不好意思。

在老师这里呢很可能会给你抛到极其细致的程度，呃凡是会害怕的小伙伴，一般来说呢会有一个心理，就是他其实是一个想速成的心理，我不知道同学们有没有这个心理，他的心里是这样想的。

说那个老师能不能给我个简单的东西，我就赶快进了大厂长了，心，呃是这样的心理吧，我我我我能说错吗，我说错了吗，advantl呃，说那个tk和数据库优先，哪个学哪个精，哪个学校先学数据库。

一般我都是建议先学应用再学原理，同学们记住这一点，我害怕是因为无知啊，没有对人伤情，是这样的，听我说速成这件事，老师有办法不急，就说这个课的精华就在于我们是集合了速成，集合了精通，真正的从入门到精通的。

有同学说了，老师我读一门通不开的原文，或者读一门我们已经讲完的80个小时左右的spring有什么好处，很简单，一门课让你干到p7 ，以前有些小伙伴就靠spring源码，一堂课一门课直接拿了p7 的薪水。

p7 金水是多少，你们知道吗，平均得多少，70万_{120万，70万}120了，那当然有个特别水的p7 ，有的文档类的p7 ，文档里的p7 的话有可能是50万左右啊，四五十万那种是比较水的了嗯。

如果你想理解就是说p5 是什么，p6 是什么，p7 是什么呃，去访问这个网页啊，叫m c a。i html，我们的网站那个就是屁股来说呢，它一般是定义成为20万~40万左右的一个薪水。

注意有些同学虽然你现在刚就业，拿个1万多的形式，你很可能是到不了阿里所要求的p5 水平的，知道吧，皮肤水平也是要求一定的数据结构的，也是要求一定的算法的基础的源码啊。

你比如说像什么jdk自己的那些个代码，这一类的源码实际上也是需要你掌握的啊，软件测，试基本的技术像保障的工具啊，那么这就不说了，那到p6 这个级别是什么级别呢，40万~60万的级别嗯，独当一面是吧。

它叫独当一面，当然这里面要求就会更多一些了，他会要求你了解各种各样的设计方案了，通信和调用各种缓存的中间件，消息中间件，搜索中心存储中间的四大中间件啊，各位邀请你了解分布式锁，分布式事务。

各种的分布式的配置，注册与发现网关与路由负载均衡，断路器分布的消息断路，链路追踪预警全新控制，当你到这里的时候呢，你可以非常有把握的拿下，40万~60万呃，我也练了很多东西呢，它是有一定的投机取巧的。

我一会儿教你投机取巧的办法，我们先聊正常的，你应该走的扎扎实实走的路线，我们再来聊你投机取巧的办法好不好，可以吗，路绥远行则将至，你不要想着我拿一个很好的薪水，50万~100万的薪水是很容易。

不讲多线程了，小乔啊，今天真的是讲不完，我不跟他跟你说了吗，这段远程我也讲过了，小乔啊，那么嗯这博士是我啊，我就不在这儿念了，就是说麻烦我我我我我我我大家呢先建立起来一个想法，就是你想多赚点钱。

想成为一个人才，想在你的公司里头担大梁，你首先要建立的实际上是要扎扎实实地提升自己，先建立好这个思想之后，我再来教你怎么投机取巧，有办法啊，到p7 是一个什么水平呢，大概年薪是50万~70万。

但是它有800_{1200的股票，阿里股票呢现在应该还算是比较值钱，算下来差不多是70万}120万之间，哎我说到这，你们想看看100多万的简历吗，这是p8 了，p8 呢呃p8 基本上只有我给大家讲啊。

就说这个这个年限就你就很难突破啊，空降的p8 比较少，但是老师会教你的，我能带你到p8 水平，p8 叫做格局啊，它不是一个纯技术的概念啊，这个扯的有点远了啊，我们再来把这个技术点基本看完吧。

核心的服务的设计，微服务的全站嗯，service mesh的理论和落地，别人没有问题，早就有了数据治理，人工智能的加成c c d呃，我就不在这1111给大家讲完了好吧，那么嗯，老师你属于p多少。

嗯嗯p 13，因为马云是p 14，我肯定是不如人家的，但是p 13总是要吧，嗯嗯那个，嗯有同学说老师6p 13，那我就开个玩笑了，大言不惭一下，反正我也不会去阿里，嗯想看看比较牛逼，120万的简历吗。

昨天也给大家看过一点点，这里，马老师原来在哪里高，就最早清华念书，后来基本没有，咱就是做过很多企业，我就不一一说了，后来基本是在创业，我从29岁开始就没间断过创业，看这里，这是那个120万左右。

这个是拿了p71 120万年薪，这是确确确实实拿的，你可以自己读一下，这是技术手段，因为以前上学堂吗，山学堂是我创办的啊，后来我转让转让完之后呢，做了很多其他的行业呃，早再后来还是比较喜欢教育。

从19年开始踏踏实实做线上教育。

海量数据就是你想去做什么，各种行业，想去提升格局，想去让你就是说，赚出你超越你认知的这个钱来，踏实踏实跟老师走就行好吧，呃看这里啊，就说这个小伙伴呢，目前这个情况我也告诉大家一下。

这小伙伴是目前为止我们最牛逼的一个学生了，我想跟跟他应该是一个意识亦友的关系，愿意的话你可以截个图，这个是他从企业离开之后，然后给大家的一个小小的建议，我建议你可以可以解一下，没有关系。

现在公司给了5000万的股票，他们已经套现离开公司了，扎扎实实的5000万现金已经到手，嗯怎么说呢，就是说当你一个人到了一定的技术层面之后，除了技术之外，还要有认知格局，这个层面多少岁啊。

这个学生目前因为今年应该是31岁，老师讲一下二线城市涨薪都是什么跨度，二线城市，举一个二线城市西安吧，你搜一下，刚才我看有个小伙伴在那里聊西呃，这是跟我学的西安的，五个月涨了5000，进了华为。

其实涨5000不太难，进华为比较难啊，这个是学了三个月，涨了10k，带了团队嗯，这小伙面试频道这件事是他自己说的啊，他说老板坐标西安，去年做生意赔了几10万，现在面试基本平衡。

老师说过管理应用技术用年龄就不是问题，我现在十分认可这句话，好多时候你的认知不到位，老师说的很多东西你可能听不进去，就直接跟你一点，所谓的35岁危机，所谓的40多岁我该怎么混，我直接就告诉你。

如果在这段时间你像老师一样不断的不间断的提升自己的话，这些个简直都是不是问题啊。

老师有，武汉只能算二线吧，武汉我找找啊，武汉的情况，武汉应该每个城市都会有那么一点点的那个，我们其实啊你对于二线城市来讲呢，你你你你想都不用想，你琢磨琢磨这一件事就行了。

呃就是老师的课程设计是什么样的一个设计，这个可面对的一线城市超一流公司来进行设计啊，哪怕你学个50%别多了，我觉得在二线拿前5%的薪资总是没问题的，好吧，平仓啊，你要学个78%成，基本平摊。

呃呃差多值都有它的理想结果啊，原薪资是13k直接入职武汉阿里，可以吧，马老师，我阿里的hr面了，应该是p6 ，我目前13k那边会不会压压薪资啊，没关系，教你怎么跟hr谈吗，老师让你学啥，你学啥。

让你怎么学怎么学，让你粗的掌握你粗的掌握，让你细的掌握，你细的掌握，帮你定制一条从浩瀚的学海里头知识的海洋里面，帮你定制一条独一无二的属于你的路线好，什么叫捷径，这个就叫捷径，知识的海洋呢。

你学起来总是没完没了，但是放心，老师会带给你做一条定制的专门属于你的路线。

你说老师我想一个月涨薪好，一个月让你涨薪，老师我想三个月涨3000行不行，ok没问题，老师我想半年大体的知识学到手，我能不能跳大厂来，老师我想1年把所有知识全掌握行不行，挨着牌的学。

来看几个武汉的例子吧。

这就叫捷径，13~20，原来也是13啊，最近太忙了，涨了一些7k34 个月，从13~20继续学冲大成，突击了40年12k武汉跳北京啊，这是武汉跳到北京了，武汉8k到15。

这个太简单了，应届毕业生武汉14k啊，这个基本上关于武汉的吧，年薪40万啊，这个是我印象很深刻的，他当时应该是2年没工作了，学到后半夜，最后复出拿了40万年薪啊，就是说第一你要肯干，第二你要找对人。

跟对人找对路，南京的郑州的郑州那个别找了，我还是那句话，你就记住老师这话不坑你，不蒙你，老师这样的课不用你学完百分之五六十左右，像郑州这一类的，你基本上就平衡啊，没有小姐姐咋私聊。

忘了忘了把小姐姐给你是吗，截屏实力二维码，宁波的搜一下很重要，主要有些好多二线城市的，我也没不知道有没有记录啊，宁波我不知道有没有记录，宁波没有记录啊，宁波无锡吧，无锡是跟牛魔差不多，感觉都无锡有记录。

这是江苏无锡十到14位同时跳到市里，感觉很少，很多人都嫌贵。

其实是说我们的课程规啊，呃但是呢他说我也是怎么怎么怎么样啊。

我在无锡江苏，但是呢呃他当时学完他那那那关键的话还给还给打了，说我学完之后是特别直的啊，这是无锡年经验是8k两个月就实现翻倍了啊，那个三个月啊，三个月实现了翻倍，其实差不多两个月，老马着实牛逼。

曹老师也牛逼，说实话这课太值了。

每次都是跪着看啊，能说清楚我们课程的价值了吗，好月末的月末的最后，也是我这个赢的最后一天，全国应该说最值钱的课，没有之一，走过路过，别错过，今天错你，你这辈子要是来，其实大多数人后悔都是来晚了啊。

金九银十是你冲刺的最好的时间，7月份的腾讯满减三榜第一的奖学金，我们是腾讯课堂唯一的三榜第一，腾讯课堂有几10万的学员，我们是三榜全是第一受灾地区的补贴学生的啊，你是在校的学生的，是这样的。

我不知道大家有没有任何认识到老师的课值钱，或者说它涵盖的东西比较多的，原因是在于我们确确实实实在不断的升级，你能听懂吗，就是我们会跟上课程里头就是现实之中达成的一些个需要，我们为什么和京东共研科呀。

你们知道吗，京东现在至少有三个部门追在我屁股后头，要人老师，你那有人吗，能不能给我送几个，那有人吗，能不能给我送几个，但是不好意思，好多学生啊，有些可能没准备好，另外一些现在我觉得真的挺有趣的。

不去我自己选啊，京东原来薪水稍低嘛，大城里面京东新水烧低，最近涨了，跟大厂的合作就是应该是相当的到位，在这儿也稍微的展示一下，好吧，再次一点点，我们有一个美推来着啊，呃当然这个是去年的一个情况。

因为这个我们跟字节啊，京东啊早就建立了很好的一个合作，我们字节的直线距离2百米，京东的直线距离差不多2km左右，也就2千米吧，那个所以呢它里边有我的好多学生啊，所以建立起的联系呢就会建立的比较多。

呃字节呢字节什么业务最牛逼，直播吧，字节跳动直播平台的研发负责人，看到老师的课就觉得有不错的学员推给我，直接安排面试啊，这是他自己跳动的工牌，嗯，怎么说呢，呃我个人我从来不喜欢吹。

给大家伙吹内推这件事主要的原因，我认为内推这件事是建立在你的技术过硬的前提之下，你的技术不过硬，我是不会推你的技术，不过硬推你进去砸我们自己的牌子，能理解吗，能理解的，给老师扣个一来。

大家不要把内推看得太重，内推叫做插个队，有好多人在那面，但是我们推你进去啊，你可以查提前插一个队，明白吗，提前面试里，但是他会一会因为我们内推你而降低人家的标准吗，会不会绝对不会啊。

所以内推的第一条规则叫做建立起来，你真正牛逼的知，识体系，这才是你不管去哪儿，响当当，光明磊落，站得起来啊，飞得起来的最根本的东西，其他的那个说说的简单点都是都是建立在这个基础之上。

才能够有其他的软环境的玩玩法，当然你说老师有没有说快速的办法，有，如果你想看快速的，比三个月六个月都要快的那种，这是一个半月，他说他说了，最后最后最后说了，说我们的面试突击班是神克废话，金三银四。

我们一个面试突击帮了多少人就业，就报名一个月嘛，一个多月的事儿做完了，现在距离金九银11个多月，我希望你走过路过，千万别错过，1~90月份再想跳槽的时候是比较难了，你就得等明年的金三银四了啊。

入学一个月，面试突击直接涨薪，涨了70%，仔细看啊，原封不动的聊天记录，突击40天就突击了40天，感觉面试突击的劲儿用完了，问到的比较深的东西还暂时没学到呢，慢慢学嘛。

老师的课是要从基础的带你带到百万年薪的，你能够说简简单单的几十天能全学完吗，你不要有这样的想法啊，不要对这个对自己这种那什么太过太太太要求太过了啊，这是内部掌心啊，他就是学完了之后，他没跳，内部涨薪。

10%，既有广度又有深度。

这是咱的评价，既有广度又有深度，几乎不用买什么书了，互联网技术一网打尽，好了还是那句话。

7月30号了，我训练营的最后一天，呃在8月份呢我们有一个小小的涨价，为什么要涨价，原因也很简单，他会占用腾讯课堂那边的资源，我说句实在话，不如我们自建的平台做得好。

在我们自建平台我只需要给你定好路线之后。

你按照路线学，也可以按照普世性的从头到尾的慢慢学。

也可以，啊这个需要登录了vip，中间遇到问题，直接点问题就可以提问，提问的时候工作的时间半小时以内就会有人响应，你保驾护航，有同学说，没有关系，可以的，聊会儿小天，其实在这儿我就只想问大家一句话。

想不想今年年底的时候多带点年终奖回去，1万多块钱的课确实比其他的车比其他人稍微贵那么一点点，因为我们大概每课时是五块钱，因为我们的课实在课程量比其他人大的多，我一个课讲课的老师接近20位，人家只有三位。

我一个课给大家讲的课时接近3000小时，人家只有400小时，不要看这个，不要看那个多，比较课程内容多，比较师资力量，这才是核心中的核心，30多岁还能长薪多少，大专学历，你现在心率多少。

在哪个城市这件事呢。

他每个人和每个人的情况肯定是不一样的，郑州你搜搜看有没有郑州的好不好，你其实特别简单，你就这么多找一下，看看郑州那边给的薪水比较高的有哪些，好像只有一个郑州的记录下来了嗯，郑州哪儿去了。

8k现在年薪是28万，还是马老师练课程好。

原来是15k涨到23，一个月23000，郑州这边主要得看那个人家给多少啊，因为我不可能了解每一个城市能给你的薪资到底是多少，这件事我是不掌握的，呃承诺大家一句话来老师这上课，你什么都不用带。

就带一个东西过来，把人带过来，差时照着学完，说找不到新的老师，钱原封不动，一分钱不收退给你，整心对我们这个课是叫做顺手的事儿。

难的听我说，比较难的是什么呢，比较难的是进当成这是比较难的，大厂能不能进跟我，我直接告诉你大厂的课，他面的东西不会超出我们讲的东西，课程怎么购买，十个秒杀的名额去要啊，别错过，还是那句话嗯，拿阿里来说。

这里大概有40个关于阿里的记录，呃，这个是阿里和京东的两个offer，这是阿里菜鸟进阿里菜鸟涨了50%呃，这个是入入了阿里，薪资翻了倍，那么这是三个月直冲阿里薪资翻了三倍啊，嗯就是跟曹老师在聊天吗。

阿里的p6 ，兄弟们保持自己的梦想，就我还是那句话，你自己生而有异，为什么要选择匍匐前行，拉开跟你周边人的差距，你具备这个实力，好吧嗯嗯，你过来老师就带你飞啊，你说20位老师带不动你，除非你是头猪了。

就，这是阿里的京东的话呢，39个记录，你不涨，不给你点点，别人看了，你要愿意的话，这个网址是公开的，里面没有任何一个说说我们自己人跟那p的记录一个都没有，如果你找到学费1万多块钱退给你。

再赔给你同样的学费，呃京东的字节的吧，字节有九条记录，字节确实稍微难难进一些啊，蚂蚁字节两个超年薪50万的offer，嗯嗯，跟老师的课最好的时间点大一，因为老师可以在大2l大三的时候，4号的时间点。

大三再次一点，大四快毕业，再次1。1~3年，再次1。3到五，我告诉你老师带你就会比较费劲，但是呢也能带动，44岁的大龄女程玉儿，可以吧，打零是不大零吧，38岁的大龄程玉儿，68万年薪翻倍了，我说感觉。

但是他他这个还挺谦虚，但是感觉我好菜，面试官虐的体无完肤啊，居然技术不让人事了，因为他自己觉得好菜，但经过我们的培训之后啊，其实已经在别人的眼里已经算是比较牛逼了。

35连续两次跳涨，5k连跳两次，嗯还是那句话啊，同学们，你们如果就只是想找个薪水，小小的薪水，你就扎实来，这可坑不了你，你也一定会很快的收复老师的这个学费回去，一块钱每年，哈哈哈哈。

你现在报名学的是2021~2022年这个学年，那么2022年到了2023年，给我们一块钱免费继续学，注意不是重复的东西，是升级的内容，老师可以介绍一下vip课程吗，哦你是说vip课程的具体内容是吧。

可以的，呃mc的内容比较多啊，我每次会稍微偷那么一点点懒啊，呃整个内容呢是由四大块构成，刚才我介绍了顶级的架构师这块，其实我还没有介绍完啊，因为每一个打开的话内容会更多一些，就是内容会非常的多。

但是我就直接这么跟你说，别人涵盖的，你从任何其他机构看到了，说老师人家有个机构讲的东西，你这没有，老师要是短时间内给你补不上去退费，所以不用我说内容了吧，就是你凡是在其他任何做架构师培训机构看到的内容。

如果这里没有的，我一定会给你补上，不会单独收费，我这么说能接受吗，能接受，给老师扣个，一来，现在的课程内容呢也是说一点一点的升级升到现在的啊，也不是说刚开始就是两三千个小时的课，不是这样的。

我们那个vip啊，没有gpa的内容，大哥这pa现在不怎么用了，另外呢spring data是在里面，你可能还没有学到，帅帅啊，这个呢是知识点的课程啊，对那个高并发呀，这mma调优啊，操作系统啊。

然后中间件呀，e r k啊，什么事物啊等等等等等啊啊还多配啊，have啊，不说了好，除了这个之外呢，项目课，项目课从简单到复杂，九大项目帮助你能够说在你的简历里头啊，写出很多很多的关于项目的内容呃。

举个小丽的网约车项目。

这是曹老师经呃，曹老师就是原来他在阿里工作，在拿阿里的工作的流程，带大家讲的一个网约车项目，算一说它它所所所带来的效果吧，好不好，就网约车这一毕业应届生平均网约车21k的offer，21000，刚毕啊。

小白我一说15000。

网约车找工作5k原来是25，涨到30，就靠这一个项目而已，传统项目网约车找工作，企业家家留人啊，就是不想让你走吗，因为你学了互联网比较牛逼的项目了，所以呢加价没问题啊，课程是永久可看吗，踏雪飞鸿啊。

我刚才解释半天，你还是没听懂，mc有k8 s吗，废话这必须有啊，放心你一定有可能是永久可看吗，我刚才解释半天，你还是没听懂呃，课程你享有的权限，1年，但是只要我们课程再再升级，每年你要给我们一块钱。

你才可以看，你要是乐意，我先给你交20块钱呢，先给你先给你续20年，陈红听明白了吗，多线程jvm呃，关于设计的很多内容啊，软性的很多东西嗯，因为我呃就是说以我们课程量来讲呢，不可能一个人把它全讲完。

呃每一个内容我基本上都是要找到对应的优秀的老师，嗯，左老师刚才给你看到过了，来讲算法来讲，国内超过他的很少呃，讲项目来讲巴里的呃，曹老师是在阿里啊，他做过10年，说我做项目很牛逼。

但是阿里最近是怎么做的，其实我并不是并不如他，你能理解吗，呃黄老师在离开美团的时候，当时已经拿到85万的年薪，就是以他这种水平来给大家带整个项目的架构，你放心一点问题没有啊，嗯京东的孙老师给大家讲什么。

在你实际工作制之中，大厂所遇见了哪些个线上的bug，并且他是怎么记录和调试的，很宝贵的这种经验，你面试的时候，如果能跟面试官聊这些东西，你想想看面试官会怎么看，你琢磨琢磨，看看你的感觉是不是我靠。

赶紧来，不是他带你飞，而是你带他飞啊，为啥子这没说吗，是什么意思，这个没听懂啊，拥抱生活，35了还能从零基础开始学吗，呃我建议你35学另外的课，不要学这个课了，就嗯陈老师讲的课真的好，是的啊。

听听看就知道，不是说只有我讲课，大家伙能接受其他老师讲课，你听听看就知道啊，没有差的老师，老师这没有差的老师，明白吗，就是你你你到其他地儿报课呀，或者什么也好，你可能会有坑，可能会怎么说。

就是可能会可能会啊，所以说被坑过或通过坑呃，可能前面吹的挺牛逼，后面不怎么样等等等等，都是有可能这种情况，老师这里是没有的，啊，腾讯的三榜第一的，他不是说是个人就能够拿三榜第一一类的。

这是我们这个课程的评价，叫做mc的架构师课，2643条评量百分之百的好评很深，受益很深，一种全新的授课模式，不脱离实际，即学即用，不会出现完全理论，是应用的时候无法下手，什么叫p p t架构师。

国内讲ppt架构师的太多了太多了，一个ppt架构时刻卖2万 15000，我有时候觉得，说句大言不惭的话，你交那个钱啊，真的挺亏的，用12000多块钱买一个完整的m c a，差不多你以后不用再花钱了。

感觉带你贷到百万年薪的水平，但是有很多人呢就是愿意花个六七千，或者花个15000，或者花个2万买一个，每个星期差不多三次授课，你就你就这么想啊，一周上三次课，一次两个小时，他是多长时间呢。

一个月是24个小时，那么12个月呢200多个小时，1年上200多个小时，你要上完我们这课8年，你要这么上课的话，别这么伤，让老师带你用更快速的更有效率的方法，你两个月先把薪水涨起来，你会慢慢的补充它。

不香吗，韩大数据方面内容吗，那你真是问到人了，今天晚上报名还含有一期大数据的课，这个大数据的课，那也不是水货，8月就没了，我就直接告诉你啊，老师就可以把钱退你了，我只想告诉你，你捡到便宜了而已。

那么这个大数据到什么程度，你如果有了解过2万块钱的那种大数据的课很好，就是那些其他的不看了，我们只看课程内容，这是关于大数据项目的部分，实时数仓什么的课程呢，有这么多个阶段。

前置知识中间件hdspark flink数仓体系收藏是比较多的啊，我们会建立killing to do lifi click house cattle，maxwell phoenix等技术集群的管理。

数据库，数据导数据的治理，呃，怎么说呢，如果说就这个大数据这块，我们一定是要对外单独销售的啊，后面再想要没了，薅羊毛尽快趁早，别在这浪费浪费啊，平时上课几点到几点呃，8月1号开始的直播课。

8月1号开始的直播课是八点到十点，那个录播课你就不用管了，基本上每天都有更新，然后呢我们每个月的更新的内容会告诉你哪些课程给更新了，有的官方也是这么着算大厂了，但是它属于接近大厂的一种岗位，什么意思呢。

呃每年华为在社交的时候，大多数都是从欧d来，华为其他从公开社招，除非项目比较急的情况下才会产生，不然的话多数从欧弟来，所以它是属于进大厂之前的一个跳板吧，啊啊老师学完vip后端课程，本科毕业可以拿多少。

你是刚毕业吗，第一刚毕业的时候呢，不太建议太关注薪水，但是你老师的课程来说，15000左右总是没问题的，听懂了吗，这是最保守的啊，卖白菜的钱，其实说到这儿呢，呃我们当时创立这个机构的时候。

就是说大家伙儿也都不是什么特别缺钱的人，那个能不能够说你最性价比最高的东西，最核心的把这个优优质的内容给到大家，呃，我个人呢是有一点情怀的，我是希望咱们中国人充满各种各样的人才，就成才这件事。

成才这件事呢，第一你首先成为技术人才，然后呢才能成为更优秀的综合型人才，这个才是目标，所以你先别着急，现在我只是带你成为技，术人才技术人才带你就已经到很高的高度了，想成为更好的更多的人才，跟着老师。

你扎实走，你放心，坑不了你啊，那个成才这件事来说呢，是我们一个出行，也是我们做这个平台的关键，所以从老师请老师，就是从我这儿请老师的角度，不计成本，我跟你说，你曹老师原来在阿里什么水平百万。

黄老师原来在美美团的时候出来就80万年薪加股票，以那个卢老师，卢老师是北大的博士后，我把他请过来教你，你觉得他教不教不起你吗，带不了你吗，有同学说老师那有有没有跟我们接地气一点。

的那个那个学历差一点的老师啊，有当我们民歌也是，他也是大专毕业生，但是不耽误，他已经创业好多次，卖过好多家公司，现在早就财务自由了，怎么说呢，就是各种各样的人，最后啊你想成才的话，如果说你想成才这条路。

说离了，让自己提升，让自己精进，让自己向上生长，你觉得可能吗，一批牛逼的人带着你扎实来，老师m c a具体说一下，全称就叫m c a，就这些p5 p6 p7 p8 ，全程就叫mc，刚才也说过不少了。

我不展开了行吗，嗯自己去读一下不好吗，嗯，mc是什么的缩写，mc的全称呢叫做，换一个好写的，马士兵，certified architect，yes，是我们认证的架构师，你不要跟我吹什么牛逼。

说是腾讯认证，京东认证没没写啊。

我们认证的这个架构是是全网最牛逼的架构师，没有之一，嗯分期可以分多少期，这个好像应该是24吧，最多是分24期，就一个月500块钱左右，啊462信用卡到24对嗯，有没有手把手教的，怎么着。

手把手把一行一行带你敲代码还不够，手把手吗，哈哈就是从一个非常空白的文档，手把手的带你一行一行敲代码，这个不叫能力，这就是手把手吗，有几种办法，第一种，正常时间段向我们的问答平台提问。

半小时以内必有响应，第一种跟我们的老师直接在群里问，但是这种问题建议是呃，职业相关的问题会更好啊，技术问题在这里反馈会非常的及时，职业问题在这里会非常的及时，ok呃特别隐私的那种，加老师单独微信私聊。

好，说说你的条件，一般来说如果想入门的话，年年轻一些，年纪别太大就可以了，所有课程都有录播，直播时间赶不上，当然了，所有的课都有录播，无限次回放，强调一下，12点还有一个小时，我跟你所说的这些优惠。

你就这辈子再也拿不着了，就只能单独付费了，老师这里呢如果只是向你传授一些知识，我也懒得就收你钱了，就是以前啊有有有有的人拿老师的这个视频啊，或者什么的，都没收过费，无所谓。

老师这里是苦口婆心的指导你一步一步的达到一个比较牛逼的水平，你会看到每一个聊天里面，实际上是都有我们这的老师在群里头进行一步一步的指导的，明白吧，如果是你要愿意了解了解林老师。

你就会发现他后半夜还在给学生解答问题，了解了解曹老师，你就会发现在每一个地方，他会带你教你一步一步手把手的教你怎么进阿里，能把高中生带进阿里，你想想他是什么水平，8年经验有点迷茫。

谁能指导一下油条回答我几个问题啊，人数不多了，你可以回答我这几个问题，我就可以多跟你说几句，人多的时候不敢放这放这个ppt，因为人都放这个ppt上，消息就刷不过来了啊，尤其是在嗓子不太好的情况下。

咳咳我咳咳，稍等，是很早以前啊，给跟那个同学们做规划的时候用的一个模板，你可以试试，就是说你想让老师带你，你总得告诉我你真实的一个情况呃，你要告诉我你在哪个城市，你今年多少岁，你工作多少年了。

你现在薪水多少，你是哪个大学的，是什么专业，是专科还是本科，你的目标是什么，当那这个小伙是7月20号报名，就是去年7月20号报名，金九银十，他要突破20日，10月20号跳槽达到25。

选个老师说进行一对一的把脉，这个vip呢都有啊，你不vip，如果你是vip，就不用在公开课上问了，专门找老师，老师专门有老师帮你把脉，现在公开课的说白嫖老师一把，可以的，没有问题。

但是你要给我按照这个模板来，在一段里头把这些话全敲完，不要分好多段好吗，多大算年龄比较大，你是说刚入门吧，就说你零基础丁点关丁点丁点儿，那什么都没有吗，30，3~35应该算是比较大了。

25 零基础你扎实来啊，这25 零基础太简单了吧，20突破到35家，难度大不大，对你来说可能难度大，对我来说难度不大，简单指点指点你估计就到了，你看这人跟我聊天，刚学完se确实讲的确实好。

s e你听的是珊珊老师讲的是吧，非常的细致啊，蓝色有两个版本，第一个版本叫快速版，第二个版本叫扎实慢速版，可以走快速，也可以走扎实啊，专科呢专科没问题的，专科你要是想提个薪水，那是真的不难。

就是你任何人，你别管你什么学历，你说让你长长的薪水，他真的跟玩的似的，专科做一下，专科这件事啊，他他是真的不难啊，就是掌心这件事是真的真真心不难，31岁两个月的面试突击，多加offer。

这个没谈涨薪水的事，他肯定也涨了啊，半个月专科学历涨了6k，深圳的11000的月薪，这应该是原来没工作啊，南京的专科8k到15，应届专科七天的面试突击12，这是应届专科的学历。

四个年薪40万的offer，这个就是有经有工作经验了，专科学历三个月失业到月薪25，好几个高分，不知道怎么选，怎么着，这块怎么样无所谓啊，这还不全。

还有大专大专生呃，面申通的时候，阿里给打电话，没接到八个电话，一个都没接着，倒霉没进阿里，要不然就进了大专学历，多个大厂offer，专科啊，是这样的啊，寻求掌心，你这是老来老师这儿学课讲不了心。

老师把钱退你拍胸，不是向你承诺这一点，就是说专科我们的目标是嗯带你进大厂了，但是我现在不想说这事，因为啊专科带进带进大厂这件事真的挺难挺难的，我们可以把它定为目标，你就想你最后你没有进大厂。

你说我照着进大厂学的，我没有进城，我整个薪水是不应该跟玩似的，告诉我一下是不是，有清华的学员没，唉，你自己搜去吧，小伟啊，等老让我帮你搜，没没没记录，但是肯定有啊，我的小师弟，我记得很清楚。

因为他有时候图片上写的东西呢，它是搜不着的，只能是文字，文字总结不到位的话，清华的北大的，北邮的，取法乎上得乎中，取法乎中得乎下yes，成交也没问题啊，嗯你定位你定位是涨薪，我就告诉你问题肯定不大。

定位进大厂，这个我们要好好宠，这是真的，嗯嗯老师本科毕业建议去哪个城市成交，没问题没问题啊，成交算什么问题，软工考研学有用吗，软工考研考研有用吗，是吧嗯，总比没有，总比不考强，就这个意思。

现在看到网站网址是什么，出去看，真实的学历，初中自考的专科，那不还是专科学历吗，5年经验，基础不扎实，嗯这课用来干嘛的，不就是让你把把基础砸，这是吗，杂技术本身不难，算法加底层。

其实就就就把这基础砸深了，啃下来就行啊，定位找心呀，你就扎实来啊，我刚才小姐姐提醒我，40分钟，40分钟优惠结束，今年以及以后的年，你也就再看不到这些优惠了，嗯嗯，呃我们聊天聊一会儿，聊到11点半。

十分钟好不好，需要账号登录吗，必须vip才能访问吗，哎呦你敲一下吧，你能不能自己敲一下，当然不需要，我没事啊，这个东西还要你登录访问，没没有这个必要啊，没有什么藏着掖着的好吧，吹牛逼啊，真是东西的。

我跟你说有有有有有多少个课程，你是从网上网站上都能看得到的，这是我们的学员的一个记录课程的东西的话，在这个平台里面呢，你可以点这个按最高级架构师点进去，但是不急，因为这些课还没有完全上。

还没有完全上上去，目前是95门课，但是我还是那句话，一门课很可能是八九十个小时，就短一些的二三十个小时，但是呢嗯，还是那句话，就是说这些个课呢它是不断的在更新和迭代，只要缺了哪个课啊。

你说那个说别地儿有老师，你这没有能不能帮我们跟上，不要再收费，完全没问题啊，而且比别人差了都不行，说人家讲的挺好，我们这讲的不好，必须重奖，这是我对我们团队下的铁的指令，啊截止前端线工资低。

现在转成java需两小时，半月20加这个五杀难吗，告诉我一下你现在的其他的情况，你把这些都得告诉我啊，我才能告诉你，难还是不难，有把握还是没把握啊，多敲几个字儿嗯，moses moses，moses。

moses，咳咳，hello moses，30岁大专前端3年5月20家，明年34月份嗯，能交流真是费劲，1年34月份还是大专，你你你你自己是看不出来你缺哪些信息是吗，工作几年了哦，大专3年，sorry。

对不起，是我的问题，向你道歉，3年啊，目标是20加，你今年是拿多少多少月薪，多少月薪，你现在是拿多少月薪，告诉我一下月薪8k哪个城市啊，就这种地，你就多说两句，他会死人吗，我的天。

这么这么好的模板都不能照抄吗，品种听我说啊，那个你想一步到位拿20家有没有办法放心，有保护性有多强，我预计百分之七八十左右，你能达到20，那个怎么拿，我直接告诉你路线，第一你做过前端有什么好处。

你会了解业务，也就是说当你在简历上写项目的时候，你会了解这个业务，就是你有的写这个很重要，所谓30岁的成员，如果别人问你做过什么项目，你要写不出来，你就别玩了，所以这个非常的重要。

这是你写这段需要注意的东西，第二大概用我预计应该是用一个月到两个月左右时间，把零基础内容拿下，零基础内容呢差不多是这样子的，jva入门呃，数据库mysql前端不用，你学了后端的内容。

那个s s m这a b c加上spring boot一个入门级的小项目，这个项目叫何家园，正常你应该在1~2个月左右把何佳芸囫囵吞枣的拿下，我不需要你精细的拿下，就是你大体能够开发出来。

到这儿你会知道后端是什么东西，长什么样，做后端的人都在干什么，你会你就会了解了，但到了这一步之后，第三一步，这一步你大概要也要花1_{2个月时间，你们这1}2个月你做什么。

spring cloud就是分布式微服务，就啃这个我刚才讲的这些什么底层啊，系统啊，你都不要给我啃，就直接给我啃spring cloud，把这个啃完之后做一个小小的面试的一个突击过程。

然后把我说的三门的最底层的东西背一遍搞定，20k月薪拿到，29 5年半26，玉溪师院信管本科34+9月份啊，路线有，但这个成功的概率你要降低，他刚才成功概率80%，你这成功率估计60%左右呃。

到9月份你正常的应该还有，我建议你到10月份啊，就是金九银十嘛，那你90月份应该这么来定，你差不多还有两个月左右时间好，这两个月怎么安排我，我现在只能给你安排错误的原因是什么，我没看到你简历。

我不知道你会什么，不会什么，我现在假设你会s s m，你会基础的spring cloud，在你会这两个的前提之下，这两个月主要主攻什么，面试的重灾区一共有六项，然后再加一个一级流量。

这个e级流量用来解决什么问题，架构方面的三高设计，把这个问题解决之后，你的薪资就可以打开上升空间了，26怎么打开，就是你年薪50万这件事，也就是月薪4万左右之前怎么打开，一级流量，靠高并发打开。

炙热秋水，我说清楚了吧，然后再把那个给盖了啊，油条是5年c o d 18 k大哥该涨了，你要再不涨，你就废了，掌握部分spring可巩固基础，多久可以拿高薪。

你现在c r u d我现在还只掌握了一点点spring cloud，我建议你最好的办法是应该定位在明年的34月份，这里面呢我跟你说，给学生定详细路线，需要参考的维度比较多。

其中有一个重要的维度是要仔仔细细看你简历的，因为我通过你简历我看出来你到底会什么，不会什么长处在哪儿，短板在哪，到什么程度，缺哪缺哪些东西，还有一个很重要的点，就是你跳槽跳了多少次了。

你下次应该规划在什么时间跳，不是说越快越好，现在进大厂往往有什么呀，第1年龄卡着，第253原则就有好多时候啊，你的目标要根据你的简历和你跳槽的经历来，像油条这种，我也不知道你原来跳多少次，但我建议你。

你你这种的应该是到明年的34月份，因为有半年左右时间，老师可以让你扎扎实实的把我们课程里头的四条重点路线，都掌握的差不多，词条装点软件，底层也都是经常面试问的，你差不多半年左右拿下的话，到什么水平。

p7 ，当然这个并不是说你现在18k你就直接一把能跳到50万年薪，80万年薪，很多人会看你以前的工作经验，会看你的学历，在这些个加上这些判断的基础之上，我就大致能判断出来你可以拿到一个什么样的薪水。

够专业吗，就是你有目标啊，你提老师肯定能给你找出路线来，只要他能行得通，本科30，西安时期一般性掌握大概能到多少，如果你还留在西安的话，西安的顶级薪水你拿就是了，我说的西安的顶级薪水。

就是说西安最高能给到多少，你就拿多少，因为我现在不掌握西安到底最高能给多少啊，刚才我给你看西安的记录的时候，你也看到了，进华为可能能拿25，但是你要是嗯顶级薪水都不高的话，那那那就我也没招啊。

但是我能保证你在干什么，你肯定在你们你们团队里头，那一定就是个leader，就一定是那个特别牛逼的那个啊，大40月份秋招做过spring boot小项目，可以知道项目这个不够大啊。

小伙帅帅你你你你这个吧，把你的简历好给我看，我才会告诉你，你作为大四你应该具备什么，听我说那个看你的目标是什么啊，如果说你只是说你要想当时想进枪杀大厂，你插什么，拿1万多薪水，你差什么，拿2万多薪水。

你差什么，就这个我告诉你就是了啊，但是你你这么点信息，我实在没法跟你说什么，作为应届生啊，劝你一句话呃，我希望你能听进去，第一份薪水重就是第一份工作，重要的不是薪水，薪水多少，无所谓的，薪水2000。

你倒找他2000，如果能让你进字节，你就相信我，你以后的职业规划，职业生涯根就起飞了，这叫起飞，别人是在地上爬，找个小厂子干2年，跳一个中厂子干2年，岁数大了走下坡路，这叫爬，你在第一份薪水里头。

如果能干到大厂去，你这叫职业生涯起飞，了解过有大厂背景和没大厂背景的区别吗，我们说你这辈子差出1000万来，很正常一件事情啊，每个人每人情况不一样，西安274年12科大信息本科09年十，年薪30。

年薪30的话应该是月薪25，你这个呀我还是那句话，你好好听，认真听，西安的顶级薪水，我保证让你到，就是你现在12吗，西安顶级能给到25，就一定能让你达到25，最保守最保守的，你说让你达到20。

总是跟玩儿似的，我就告诉你啊，太太太那啥了，最近西安的小伙怎么这么多，刚才我给大家看那个西安的案例的时候，你们你们都看到了吗，阿里的p6 嘛，你到时候西安那边只要有招去就是了。

像你这种的大学也够经验也够年龄，又正好你要在北京，我要送不送不，你把你送不进大城，我都要都都可以说把把把这把这个学费退给你，知道吗，也就是你在西安而已，西安大厂相对少而已啊，记住，老师开这个机构也好。

或者我们几个老师做这个课程也好，我们的目标其中有一个很朴素的需求，我们想让你成才，南京开发5年时期语言不是java，c sharp a p，玩java能用到吗，你这辈子可能会废掉，我不知道你年龄多大。

但是你5年应该28 九岁左右，抬起头来给我看路，你已经走上岔路了，再往前冲掉悬崖里了，c上我能干嘛，去了点net你觉得服务器做大型服务的有用点，net懂不，csf现在能干的叫做游戏前端脚本语言能理解吗。

pp您老人家还玩呢，go语言出来，杀了一波c语言，杀了一波java，菲律宾基本全给干趴下了，还在这玩呢，大哥你现在不是说学架构的事，赶紧给我换语言哦，换体系晚了，你就废，你不信你就等着太多了。

我遇到的太多了，32了，想起来点net开始转了那个35 六了，甚至40了，突然间想起来，卧槽我这个语言怎么他妈上不去了，天花板到了啊，走错路了啊，还有其他人吗，如果没有的话，坑不了你啊。

现在是11点半半小时，那个还有还有其他人再跟大家伙聊一会儿，如果没有其他人，我就准备下播了，成都的32岁3年11k西南科大测绘本科，目标许什么小，这是什么意思，目标是啥，老张，写全了写全了，账号不急啊。

你要是因为今天现在人也不太多了，没关系啊，只要你愿意跟老师聊，我跟你聊到底，今天写全了，把这给我写全了啊，那你扎实来就行了，这有这有什么呀，这个太简单了，你对薪资没有要求，我帮你定个薪资吧。

成都32岁3年，西南科大的测绘吗，你现在11k对不对，扎实跟老师来，明年34月份，如果不能让你翻倍，把这话给我记下来，给我截图，或者是那个给我那个录音，32岁3年，明年34月份，我让你学啥，你学啥。

我不让你学啥，你不要给我学生，你如果明年翻不了倍，在成都啊，老师退你钱，一分钱不收，7年24，南京java 11 k还在这混呢，你你你可真行，你可真是心大啊，32 三岁在很多北京来讲呢。

四五十万年薪很正常的啊，你还在成都这混呢，我的天我也是醉了，coffee，来来来来来，能看懂这个这个这个这个这个那啥嘛，这个这个这个这个模板怎么这么费劲呢，跟大家说多少遍了，写全了，不要跟我分。

你看直i也是给我分好好几条，我还得给你攒起来，那么有点同同理心行吗，每天买了课程，每天上多长时间呃，到那个呃周末的时候你要翻倍，至少翻倍啊，兄弟们，我就问你一句话，就是你这辈子想变强，要不要投入时间。

你要老想着躺着就能赚东西，那你就不要找我了，去找别人去啊，我能给你提供的就是我教你正确的路，一定不会让你走弯路，我教你证据，老牛逼的师父，我一定不让特别差的师傅带你。

5年武汉4年java 10 k本科选用20，那个哪个本科哪个学校的给我写出来，真费劲，跟你们聊天，凡是不不全都不跟你们聊了，5年java宁波13k哎呦，我的祖宗账号，东北你就告诉我你是哪个学校的。

他能死吗，30 73，年薪70javp h p，终于出现了一个新的，稍微高一些了啊，那个薪资薪资高的怎么涨涨心我我先把这个薪资高的解决掉，就是薪资高这件事怎么找心啊，他比较费劲呃。

我先说还是要仔要仔细看你简历，才能知道你在哪些点上要突破才行，薪资高呢，年龄也大，这时候不太容易整，那么这时候怎么办呢，怎么做，哦看几个高薪的好吧，我记得120万年薪的有有有有几位啊。

嗯这个是120万年薪的，嗯这个是年薪70万涨到120万的啊，这是带leader的啊，嗯那个嗯90万年薪进腾讯的啊，这个也是好，拿这个来举例子，70万年薪怎么往上涨，尤其是年龄已经接近40了。

怎么做做这件事，这是你的核心，就这四个字叫架构设计，我说清楚了吗，好除了这个之外，还有哪个，通过120万年薪的那个简历，你会看出来第一位最重要的是叫架构设计，分布式系统架构，海量数据架构。

高并发系统架构高可用架构好，除了这个分布式高并发高可用大数据量的系统设计，交流经验以及研发，那么还有什么呢，记住还能体现你技术价值的，在这儿开源框架，深度阅读过源码。

什么叫深度spring源码课老师这样的，你听完恭喜你，你可以到定制spring的水平。

通看源码，你听完虽然很长，恭喜你脾气多少水平，这是你需要攻的两个非常大的重要的方向啊，因为他心思远超大家，所以多说两句，南京37年24，南京工程通信本科目标30~35，南京有这个薪水能达到吧。

只要能达到，老师要是让你打不着钱，可以就推你了，我记得南京啊，30_{35的薪水呢应该是少数的厂子可以提供的，如果没记错的话，14}24啊，这是南京本地南京的专科学生的，南京南京。

呃这个应该大体符合三个月，南京18~30年薪是到40万。

嗯问了这些东西啊，呃河马这个当时应该是和河马河马升仙。

他当时进的是阿里系的吗，呃上海回南京新水不降反增啊，这个就是新水的问题嗯，我还是那句话啊，就是南京呢我们把它称之为叫二线城市啊，我不把它称之为叫三四线，南京是二线城市，只要你有这样的薪水能提供。

就以你的学历来说，以你的工作经验来说，一定要送你到嗯，国科大的硕士，深圳的国企，30 29岁应该跳大长安石，留着过桥时间，这是一个选择问题，这不是说技术水平问题呃，首先我建议你的第一点。

不管你做出什么样的选择，请你保持进步，老师这句话总是能听进去吧，你在国企就不需要进步了吗，你一定一定是需要进步的，ok其次29岁来讲，我29岁是属于初期创业的，你29岁如果想熬，你还得熬30多年。

看你自己，你要愿意熬扎实熬，想多挣钱，我教你怎么做副业，但是呢我个人给你一个小小的建议啊，叫做骑驴找马，别虐待那头驴，其实两码怎么找，在你29岁的这个前提的基础之上，使劲给我学互联网相关的技术。

你在深圳，比如说你你现在年薪30万，如果有一家互联网公司能够接受你，60万愿出来吗，能不能愿意吗，这时候再做决定，所以随你啊，29，上海西安航空学院电气专科4年17k想涨薪涨多少呀，我29岁不。

我帮你找吧，电气的专科4年17k粗粗的粗粗的，估计啊，就是明年34月份涨到25总是不成问题，小case啊，详细的估计得看简历，看你看完你简历再说好吧，愿意，但是感觉干不了几年呀。

我老觉着你们20多岁的在国企的人混的吧，就跟那个老年人似的，你知道吗，我举过多少次的例子，任正非44岁才创业，董明珠40多岁，褚时健，70多岁，邓老爷子，70多岁，44岁，刚才那个大龄的女生才进的外企。

哎呦我的妈呀，干不了几年是要干嘛，你是要去去怎么着去死吗，如果是这样的想法，你就扎实在国企熬着，当你熬到50多岁，五六十岁的时候呢，他也是一个很不错的选择，你体会不到那种被裁员的感觉。

也体会不到那种呃职业有危机的感觉，反正混嘛总是能混到退休的，也是可以的啊，不是不可以啊，我不是在讽刺你或者干嘛，这是两种不同的路线选择，出来选择更好的薪水。

选择拼选择的是一条带有冒险性的各种可能性的人生，在国企混着是也能望到头呢，但是非常安稳的另外一种人生，你选什么，这是选的问题，多读点书，选不出来的时候多读书，我1年读的书100本。

当你选不出什么来的时候，多读点书，活出自己，活出自己，活出心花怒放的人生，叫什么来着，他那个名字我给忘了，活着就是活法，干法向上生长，去读，所有的东西都在书里可以找到答案，不要在那里混日子，不要瞎了。

打游戏，不是做不出感觉吗，听从自己内心的召唤，听从自己的内心，就叫做你这辈子有使命感，违背自己的内心，就叫做出卖灵魂，随你好，二本就不能到20k吗，我靠你们想看个二本的牛逼的简历吗，昨天已经看过了。

偷偷摸摸告诉你，黄俊黄老师二本，曹鹏飞，曹老师二本，活出生命的意义，对活出生命的意义啊，看书比较多，曾国藩，李鸿章，苏东坡，孔子圣经，佛陀去读书，人呢有一种东西呢叫达克效应。

就是一般人我说的直白一点叫做一般人傻，它实际上自己是意识不到的，就是说一般人得需要一定的水平才能意识到自己很差很傻，我现在认为我自己也是很差很傻的，得到一定水平才能意识到，那么怎么才能到这个水平。

去经济，你会才会慢慢的走向这个level，长沙冲25，长安卓25有点费劲啊，正常主要拿25的，你可以去那个每日优先是吧，嗯应该是有可能长沙其他的那个厂子吧，给的薪水流没有不是那么的高，嗯。

黄老师的简历是吧，真的，20~24岁拿了阿里60万的年薪，啊，我这声明的意义是的，mr李安的吗，刚刚看到你的信息，南京26c加加3年17岁，中北大学我们班图22，22应该是很容易很不不不难的。

就是你你这个你这个很特殊啊，那个梅森林你还在吗，在的话给我打个招呼，不在我就不说了，6年6k 15文件信息专业目标15，我告诉你啊，就你这个半年一定让你到福建，福州吧，应该是你不要写福建。

我靠福建太太太大了，就是福建，你随便找吗，那你去厦门啊，你半年我要到这，你到不了15k一分钱不收，拿拿拿钱回拿回去啊，福州没问题的啊，福州到15还是不是很难的，老师怎么看待自学自学这件事呢。

是一定能够学成的，只不过你花的时间太长，你能理解吗，我今天给你讲内容，我如果不给你讲透彻的讲，你自己看书，你一个月能大家全全输透了，我都我都很佩服你，这么跟你说，其实就是老师们帮你是干嘛节省时间。

如果你认为你的时间很不值钱，恭喜你落入到了穷人思维，一般的穷人的思维是花时间赚钱，富人的思维叫花钱买时间，买完这个时间，花钱买经验，把别人经验很快的搞搞定，你会发现你的level又搞了，能挣的钱更多了。

这时候你的一个小时就比你原来一个小时要多值钱太多太多，不知道大家能不能理解，这是一种认知上的偏差，mr里不在了，还有玩c加加的吗，玩c加加可以多跟你聊两句，宁波35年13。

铜陵街设计师目标一二十九二十倍以上呃，然后应该是问题不大啊，但是我觉得18总是问题不大，宁波呢还是那句话，我现在不太不太掌握他最高薪水能给到多少啊，如果能给到比较到位的话，小case啊，不是应用层的。

夜好漫长，你还在吗，在跟我打个招呼，在我就跟你说，不在就不说了，28周岁机械，亲爱的是吧，嗯依然告诉我你用什么语言做底层开发，不系统时候编程有机会吗。

半年左右让你入行一线城市拿个15000左右的薪水总是没问题，那就看你自己的需求了，c加加时间应该到什么什么什么什么水平，这个c加这件事呢得看你做哪个方向啊，夜好漫长，你要告诉我你是用哪种语言呃。

如果是做c的，做c加加的，做汇编的，做嵌入式的呃，这门课呢就是c和c加加相关的，稍等我来帮你打开，咳咳咳，我告诉你，我现在给你介绍的这门课的牛逼程度不亚于我们mc，你要找到英文的课，更牛逼的。

适合c和c加加的，你随便找啊，这个课的全称呢叫做a i o t，c语言的知识，社交和算法，linux的程序，linux网络编程，数据库的编程，c加加的软件开发。

嵌入式传感器的音视频方面的5g物联网应用的开发，嵌入式linux系统的移植和驱动的开发，大概会有40个左右的项目，从推荐系统以图搜图，智能的聊天机器人，计算机的视觉，医疗搜索输入法，传染病的预测。

计算机的视觉和电商，百度飞桨短视频领域的标签知识图谱，交通标志的识别，自动化的驾驶，驾驶员表情的识别，物流仓储的w m s多媒体的播放器，网游的服务器，s t m32 的智能小车。

自动化的去嗯找到移动的轨迹，好，简单说，因为他有算法部分，所以讲了一些牌子啊，但是这个不难。

要是要这个要这个模板，不然要要要这个大纲吧，好吧呃，就是作为一个语言来讲，你c也好，c加加也好，想达到一个特别牛逼的程度，想赚更多钱，建议你挂ai好吧，把ai挂上，我还是那句话，唯一的要求，我让你学啥。

你学啥，我不让你学的，你你给我放一边去，他一定是不重要的啊，最后四分钟不聊了吧，就到这吧，就是老师也这么疼的嗓子，跟大家伙聊了这么半天，小伙们，你将面临的是你改变人生的机会，come on。

see you tomorrow。

系列 1：P33：深入多线程与高并发：1.经典老炮折学家就餐问题，绞尽脑汁 - 马士兵官方号 - BV1mu411r78p

今天呢我们主要分享三个问题，第一个问题呢是关于交替输出的问题，县城的交替输出问题，第二个问题呢是关于哲学家的就餐问题，这个呢是，应届生里面刚毕业的时候最喜欢考的问题，那么第三个问题呢。

我们分享一个来自于阿里的这种分布式的事务问题，好吧，分布式物好，我们一道题一道题慢慢说呃，首先聊点，要不我们首先要简单的吧，先聊应届生的题好不好，这个应届生的问题呢就是著名的哲学家就餐问题。

来听说过这道题的，给老师扣个一，啊我看有同学说concurrent up map说的很对啊，挺不错的，can carry map，对嗯，我觉得大多数人应该听过没没听说过，没听说过的呢，有没有没听说过的。

没听说过，扣个二出来了没有，ok ok哈哈哈，来我们来分享一下，先分享这道题啊，这题是呃历史上著名的经典问题啊，拿哲学家开涮的就是哲学家就餐问题，这个哲学家就餐问题嗯当然你也可以换成别的啊，什么科学家。

程序员就餐问题，反正那种脑筋比较轴的，凡是那种脑筋比较轴的，你都可以放在这儿啊，比方说alex一嗯，alex 2 ex 3等等啊，都都可以好不好，凡是脑筋比较轴的，你全部都可以放在这儿，那是什么意思呢。

这里面有一个呃假设，这个假设是这样来做的，就是五个人围坐在桌子旁边，然后每个人呢想吃中间的，这个菜，但是呢只有拿到两根筷子，同时拿到两根筷子，你才能加这个菜，那总共有几根筷子呢，总共只有五根筷子。

大家看这个筷子和人的排布好不好，看，这个筷子和人的排布就是他左手一根，右手一根，左手一根，右手一根，但是你就会发现呢，这个时候如果想拿到两根筷子的话，就是你左手也得抓住这根筷子，右手也得抓住这根筷子。

你才能抓得住，但是如果说你看啊，如果说你左手这根筷子被人被你被你被这哥们儿，他的右手已经给抓住了，那么你怎么办呢，你就只能等，这是关于锁的问题，这个大家能听懂吗，好那这个时候呢就会发生呃非常好玩的问题。

比如说每个人都优先的先抓住右手边这根筷子，我再说一遍，任何一个人都抓住右手边那个筷子，然后呢再去争取左边那根筷子，但这个时候就非常容易发生著名的问题，就是死锁，这哥们儿抓住右手边的。

这哥们儿先抓住右手边的，他抓住了右手边，他抓住了右手边，他抓住了右手边，好，由于等到两，个筷子才能够吃饭，所以他每个人抓住右手边之后呢，他还需要去争取左手边那个，那他这你这哥们儿拿个拿这哥们来说。

他右手抓住了他左手边那个去抢的时候不行啊，这哥们儿他抓着呢，那就等这哥们儿释放吧，就等这哥们儿释放，那么他什么时候会释放啊，他得吃完饭，他是不是他怎么样才能吃完饭呢，他得拿着左手边这个筷子才能吃上饭。

那左边这个筷子就等着这哥们儿来释放，那这哥们怎么释放啊，他得等着啊，这根筷子，那这哥们儿怎么释放，得等这根这哥们怎么失望得等这，根这哥们儿呢，他得等这个就形成了一个闭环，形成了一个锁。

最后每个人因为不知谦让的这些个哲学家，他们每个人都抓不到同不能重拾，都要两根筷子，最后怎么办，全饿死了啊，这就是著名的哲学家就餐问题，好问题是第一个，首先写程序对它进行模拟，那我想问大家一句。

写程序对它进行模拟，你在脑子里模拟一下，你怎么想，当然你可以设一个数组，五个哲学家设一个数组快字，这个是面向过程的思路，那对于面向对象的兄弟们来说，我觉得你应该能够想到的，优先级这跟优先级没有关系啊。

对于面向对象的思路，我觉得第一个你应该能想到的，当然这就涉及到一点点这种呃设计上的问题了，首先你应该建立各种各样的类和对象，先不要考虑具体算法的问题，所以我说你应该先建立这样的一个类。

这个类呢叫chopstick，叫筷子，这个没问题吧，同学们，首先你要建立一个类叫筷子是吧，那第二个类你应该你应该能想到了吧，叫第二类是什么，第二类当然就是哲学家philoser。

所以在这里呢我就用筷子和哲学家来进行模拟，当然作为每个哲学家来说，每一个人呢就是一个单独的县城，所以我偷个懒，让哲学家本身从县城继承，所以本身它就是个县城，好，我有五根筷子。

那我从零一直到四new出来好，我讲到这里能跟上吗，能跟上给老师扣个一循环链表，怎么还有循环链表啊，这跟循环链表没关系啊，好接下来我们有了筷子之后呢，我们构建这个哲学家，我们给每个哲学家呢给它起个名字。

从p01 直到p4 ，然后呢我们给每每个哲学家呀，给他一个编号好吧，给他一个索引号，从零一直到四，然后每一个哲学家由于要拿到两根筷子，他才能够吃饭，所以在构建哲学家的时候。

指定他可以他需要拿到哪两根儿才能吃饭，cs 0 cs一这时候就会发生交叉了，你看这个cs一第一个哲学家要拿到，那第二个直接也要拿到cs 2呢这个也要拿到下面这个也拿到cs呢，前四筷子，最后一根呢又循环。

回来所以这就形成了一个环，当然我们思考一下啊，就是呃作为一个线程来讲，这只是它的构造构造方法，我只是指定我要拿到哪两根，拿拿到哪两根之后，我才能够开始吃饭，当然我在内部做一个对这两根做一个区分。

一个是我左手边的left，一个是我右手边的right，好讲到这儿，面向对象没有思路的，我觉得你要初步建立起来面向对象的思路，讲到这儿应该能跟上，对不对，讲到这问题不大的，来给老师扣个一，有什么问题的话。

你直接提将面试题呢会比较复杂一些，主要这个每个人呢是参差，不齐水平啊，所以我尽量的从简单往复杂里慢慢地照顾，大家好，我们构建好了之后呢，下面你就想我这个线程怎么运行啊。

线程运行的时候是不是我首先得拿到左边这个筷子，所以我synchronized left，我把左边这个筷子锁定，然后为了能够正确的模拟思索出来，所以呢我在这儿让他睡个一点几个一啊，一秒多钟啊，一两秒钟。

然后再去拿右边那根儿，注意死锁产生的根源就在于你有多把锁，嗯，如果你只有一把锁的话呢，基本上不太会产生思索，那种死锁呢往往是阻塞造成的，它并不是唉我们在这里，我要我我拥有一把锁，等另外一把锁造成的好。

大家注意看，我首先拿左边，等右边所有的人都拿左边，等右边，等到了之后，哎我们说第几号车，哲学家已经吃完好，这是第一个最简单的小程序，我们跑一下，当然你拿大腿想一想，他也一定会锁在这里，所有的人都拿左边。

都等右边，而右边那个又是下一个人的左边，所以他拿不着好了，下面我们就来思考怎么解决这个问题，好这是第一步，模拟模拟思索，这是他第一问，第二问是什么，第二问就是怎么样解决这个问题，来给大家几十秒钟。

你稍微思考思考，你说这帮哲学家们怎么能让他不产生思索呢，好好好好琢磨琢磨，一次性分配所有筷子，有道理啊，我觉得那个这个兄弟呢提了第一个思路啊，看这个妙先生，大家听我说啊，这是很重要的一个思路。

哈哈改成串行。

拿不到另外一个筷子，释放所有筷子，这个肯定不行啊，一个人让一下。

你估具体程序怎么写呀，我看有几个思路啊，一个一个的吃，关键是程序怎么写，你这个官方提醒说的一个一个的吃，是妙先生的思路。

其实就是一次性分配所有快乐。

哈哈，还有这个是什么，我看啊，设置在等最大等待时间考一下啊。

设置最大等待时间到了。

释放锁好，还有吗。

释放left right，同时加锁，拿不到就等待。

好还有吗，错开释放时间，最后一个释放你怎么错开，好啦好啦好啦好啦，大家伙的思路呢呃千奇百怪，我们先说这种特别不靠谱的，首先第一个叫left right，同时加锁，拿不到就等待大哥怎么同时加锁。

好如果你把两根筷子设定成为一个完整对象，那就相当于这两个对象共同拥有同一根筷子，这是1号块，这是2号块，这是3号快，二三是一个对象，一二是一个对象，你想把它当成一把锁，把它当成一把锁，我理解你的意思。

但是你写写看这事儿根本完成不了，没法干，因为我们说的是这个2号，就是大家伙儿，这俩哥们儿还得去抢这个2号，明白吗，最后呢后边还得抢这个3号，后边呢还得抢这个4号，后边还得抢这个1号，所以它依然会成环。

所以这个思路绝对不行，好这块听明白的，给老师，扣个一第一个思路我给他否了，这个肯定是不行的啊，不信你自己写下去，第二个叫设置最大等待时间到了是放缩，我想问你，你设多大，你怎么你你你你怎么做。

你说我射五秒钟，那他五秒钟同时释放，又同时抓住了，你怎么办，凡是用时间来考虑线程同步问题的，基本上全是错的，我给你说个结论以后，你要是别人问你线程同步的一些问题，你跟这考虑时间基本就是错的。

凡是这么考虑，全部对，好这个也是考虑时间，我释放了，我可能做到也非常有可能同时释放又同时开始抓，时间是不行的，拿不到另一根筷子，释放占有的筷子，我拿不到了，怎么释放，我拿的时候我得排队啊。

我排队才能拿到啊，现在我还没有拿到的时候，我怎么释放，我想问你，当你不拥有的时候，你怎么释放，你说，杨幂不是你的女朋友，你怎么跟他分手，我想问问你，王力宏不是你男朋友，你怎么跟他分手。

来这块儿能听明白吗，你拿不到的时候，你释放个屁啊，你都不占有他，什么叫释放，你还轮得到你释放吗，小时候你的房子是什么，把筷子收集起来，排好排队去一次取两只，那个就不叫编号了，这个筷子是有编号的。

你那是随机取两根儿，两回事儿，好妙先生，这个思路是对的，一次分配所有会计就是它的死锁的根源在于我取一根，等另一根，取一根，等另一根，最后形成一个环，干脆呢我把所有拍的12345综合起来，当成一把大锁。

大锁好，第一个哲学家拿到一和二吃完了，释放所有，在第二个再来，第三个再来，这样的话呢我们就不去拥有两个锁，而是拥有一把锁，听懂了吧，这是第一种，但是我想，问大家这种思路有没有问题，有没有问题。

太占用资源了，对啊，你本来只需要锁定两根筷子就可以了，结果1万个哲学家，你你锁了1万根筷子，你效率是不是很低，当然很低好了，所以这些思路全部对啊，好我们说正确思路吧，不然我这个下面的题没法讲了就好。

懒得怼你了，好听我说这个正确的思路非常的简单，只需要有一个人是一个左撇子就可以了，就是在所有的人都去换一下这个思路啊，看这里这思路非常的简单呃，只需要其中的某一个特殊的人，比这哥们儿。

别人都是抓住右手边，抓住右手边，抓住右手边，抓住右手边，抓住右手边，等左手边，他呢他先抓左手边，他去等右手边儿，听懂了吗，这时候你就会看这哥们抓住右手边，由于这哥们儿不抓他的右手，所以这根筷子是空的。

所以他能同时抓住两根，所以他就吃完了，它就解锁了，他解锁了，他也就解了，他解了，他已经解了，他也解了，他也解了，最后呢他也解了，所以只要在中间放一个左撇子就可以了，来这个思路大概能听明白的。

给老师扣个一看，这题怎么写啊，这题怎么写，写起来是很简单啊，就这样写就可以了啊，这样if index等于零，如果他是0号人物，先加左手，synchronized the left，等待右手。

那如果是别的呢，先加右手，等待左手，只要有一个左撇子就可以了，我们跑一下看，10234搞定，哈哈哈，好嘞，但是这个思路你好好琢磨一下他有没有问题，有没有不足之处，琢磨琢磨，问题很大是吧。

对啊其实是有问题的，你琢磨琢磨为什么有问题啊，如果是这样一个思路，这哥们儿只有他是左撇子，其他都是右撇子，那么最后呢是大家伙顺着这个圈整个就解开了，这是没有问题，但是效率不够高，主要是效率问题。

效率不够高，效率不高在哪呢，你想想看，每次只能有一个人在这吃，但实际上呢你想想这哥们儿，我拿这两根筷子跟这哥们儿，我拿这两根筷子，他们两个是不冲突的，他们两个完全可以同时吃，其他人等着就行了。

所以有没有提升效率的办法，有没有唉，很简单了，应该能想到了，对不对，只需要做一件事儿就行了，奇数的是左撇子，奇数是左撇子，偶数是右撇子就行了，好了搞定，知道比较简单的小问题，现在有把握答出来的。

给老师扣个，一来没问题吧，嗯ok好good好，这道题咱们就过了啊，20分钟开开胃呃，下面我们来聊进一步的问题，这个小问题呢就牵扯的知识面就比较多，需要大家伙呃，现成的知识要比较扎实。

这个小问题就是著名的好多人都考过的，也许你遇到过的。

系列 1：P34：深入多线程与高并发：2.华为经典的线程交替问题，血流成河 - 马士兵官方号 - BV1mu411r78p

那什么叫交替输出问题呢，看这里现成的交替输出，好看这里啊，这是sorry a t p，看这里这道面试题就是两个线程啊，一个是输出字母的，一个是输出数字的输出字母的输出数字的交替进行输出。

1a2 b3 c4 d一直到26z，具体过程就是这样的，第一个线程先输出a然后b a1 b2 c3 d4 ，必须得是交替的输出，中间不能出现数字的连续，不能出现字母的连续，好吧，增加优先级。

凡是听我说啊，凡是关于线程问题，我直接给你说结论吧，唉呀就是你们回答多线程问题的时候，你记着老师的这个结论给你敲出来，凡是从时间角度，比方说我等多长时间，然后呢另外一个线程去做同步或者是优先级角度。

考虑解题思路的基本全部都，所以以后把这种时间角度，还有优先级角度考虑去解决多线程问题的思路，从你脑子里干脆给扔出去，听懂了吧，ok不错啊，知道这道题，这道题有好多种解法啊，我来给大家呢呃先讲几种啊。

这道题首先说呢大概有120 30种甚至是200多种解法，但是呢我给大家呢讲那么比较典型的几种，好不好，好听我说，那么第一种解法呢就是最经典的叫lock support，这个是最经典最经典的。

非常非常的简单，大家看这里，这是第一个线程t1 thread t一等空，第二等空，然后呢我们构建两个数组用来做输出，当然我在这儿呢就不构建到26个字母了，太多了。

就1234567a b c d e f g就可以了，这两个数组，然后我第一个线程，开始做输出，第二个线程开始做输出，那那么怎么让他们进行交替呢，怎么让他们进行互相之间的通知呢，看这里这样来做。

第一个线程chac ai先打印，第一个线程打印完成之后呢，叫醒t2 ，把第二个线程叫醒，说该你了，接下来第一个线程去阻塞，也就是去睡去，不能不能就睡觉去阻塞，让自己休息，这是第一个县城。

那第二线程干嘛呢，第二个线程是先阻塞，先让自己休息，等着对方叫醒，醒了之后再打印，打印完叫醒t一非常简单，但有同学可能听不太懂啊，听不太懂的，你可能是没用过log ort，这个没有关系，看这里就行了。

为了让大家看清楚，为大家做了一个小小的动画，这是第一个线程，打印1234567，第二线，程的a b c d e f g他是这样的，思路是这样的，首先第二线程上来先park park，意思是什么呢。

让自己先休息，注意任何线程休息了之后，别人只能等着别人叫醒他，他自己是叫不醒自己的，这个是现成的呃，同步的最基本的思路啊，就是所有讲关于线程的问题，从操作系统最底层的角度讲，全是这样的一个线程。

如果去阻塞了，记住必须等别人把他叫醒，没有人说自己把自己叫醒了，你们能在睡梦中把自己叫醒吗，不可能啊，就说你已经是阻塞状态了，就得等着别人叫醒，所以上来先阻塞，等谁啊，等着第一个线程叫醒它。

那第一个线程下来先干嘛呢，他先打印print 1，先把一打印出来，打印出来一之后呢，注意把第二个线程叫醒，唤醒它，然后自己去阻塞，也就自己去休息，当然休息也得等着t2 把它叫醒。

t2 什么时候把他叫醒了，这时候t t2 已经醒了，醒了之后呢，打印a然后再叫醒第一个再去休息，看懂这个过程了吧，来明白这个过程的，给老师扣一是不是很简单，这是最简单最简单的实现。

当然这里面有一些小小的问题，不知道大家是不是考虑到了，你好好思考这个问题，首先第一个问题是说这两句话能不能换，我能不能先去阻塞，然后再叫醒t2 可以不可以可以，哈哈哈哈，这是绝对不可以的，大哥你就记住。

凡是叫叫完这句话之后，这个县城就在这停了，就得等着别人把他叫醒了之后，那我问你，你在这停住了之后，你还能去叫醒t2 吧，你永远叫不醒了，所以这个事儿啊就变成了我先把自己给打死，然后再去打死敌人。

这事儿是不可能发生的啊，所以一定注意这个顺序，这是第一个，那第二个呢还有一种可能性，我不知道大家有没有思考过，比如说我们按照时间顺序来讲，理想情况下t2 是先park，这是没有问题的，先休息。

可是假如t2 还没，来得及休息的时候，t一打印了，完了之后诶，叫醒t2 ，这件事已经去做，已经已经执行完了，而且自己去阻塞了，去休息了，这个时候t2 才开始运行来，同学们。

你们告诉我这个时候p2 能够做执行吗，这时候行不行，有没有可能说俩俩人俩人都都死在那儿，输出不了了，有没有可能有可能吗，哈哈，好凡是认为有可能的说明你不了解park和rpk他的底层的原理，大家听我说。

一般的一般的情况下，按照以前的我们所说的weight，等待线程去阻塞了，然后他得先wait再去notify，他绝对不可能说先去notify，这件事是不可能发生的，这哥俩一定是有先后顺序的。

一定是先weight才notify，但是park和on park是不一样的，你完全可以先on park再去park，那有同学会说了。

如果说unpack和pk他们在执行的时候先执行了on park会是什么情况呢，他这个事比较好玩，他跟那个weight notify不太一样，on park呢只是在这个县城的内部做了个标记，原来。

这个标题是零，现在呢我把这个零改成一，然后后面在pk的时候检查一下，说这个数值是一的话，我就不挂了，我就继续往下运行了，然后呢我把它变成零，也就是说它只是内部的一个标记的意思，听听懂了吗，同学们。

如果这个不行的话，你不能这个还认为他有可能是两个都休息的话，那说明你没有理解on park和park的含义，帕克on pk最好用的，只不过这个pak on pak是jdk比较新的版本之后才增加的。

因此这道题比较经典，很老的题，他在那个时候考的并不是这个啊，下面我们讲一点关经典方面的，啊就是原来非常经典的这种解法，好不好，好，原来非常经典的解法长什么样呢，其实他长这个样。

他最开始就是wait notify，呃，这是最经典的解法，这道题原来叫填空题啊，它是让你填这个地方填东ty法，还是填weight好，我们来琢磨一下这件事怎么来完成，这是第一个线程。

我第一个线程呢搞定一把锁好，我讲到这儿了，大家注意相当于什么呢，相当于这样来写的，依然呢我们看这个动画好吧，这是自旋锁，我们让过自旋锁啊。

我们看这个比较经典的synchronized the way note版，大家看这里就说这俩这哥俩呢一定是要看同一个信号的，你不能看两个信号，看同一个信号，同一个信号是什么意思呀，我第一个线程抬头一看。

这个信号轮到我了，我来打印这个信号，如果给定的是轮到对方了，对方去打印，我打印一个更新一下信号，告诉对方，对方打印一个更新一下信号，告诉我好，那这个怎么做呢，就是你把中间的这个信号当成一把锁来运用。

首先优先运用这把锁，把它当成一把锁，拥有这把锁，我再打印，打印完了之后，释放这把锁，释放给对方就可以了，这就是一个茅坑，这边有七个男生，这边有七个王力宏，好嘞，这样的话呢就是这七个男生美人儿进去释放锁。

然后轮到王力宏进去好吧，大概就是这么一个意思，接下来具体是这样的，持有这把锁打印，然后叫醒对方，注意，这个时候一定要要让这边去休息，叫醒他，叫醒完之后呢，自己去休息，wait，然后这边几人已经醒了。

怎么办，打印叫醒对方，自己去休息，这样来交替执行，来这块能看懂的，给老师扣个一没问，题吧，那具体的程序怎么写呢，程序写法当然就是这么写了，首先我持有这把锁的时候，我去打印，打印完只要打印一个字符出来。

我写notify，就是叫醒对方，wait，让出所自己去休息好，还是那句话，这个地方一定要注意顺序，先叫醒再休息，因为你要是写反了程序就死在这了，两个都去休息了，全睡着了，哨兵没有了，好，按理来说呀。

这个题啊写到这儿就已经完成了，这个县城也是我打印，先叫醒再休息，完事儿了，就这么简单，但是呢当你运行这个程序的时候，我们来瞅一眼，他没问题啊，打印出来没有问题，但现在问题是你看见了没有。

这个程序没有停止琢磨琢磨为什么，琢磨琢磨为什么，对你想嘛，a叫醒休息，b叫醒休息，a叫醒休息，b叫醒休息，到最后的时候，无论如何，总有a或b一方自己去休息了，然后与此同时，另外一方已经执行完了。

他也没有叫醒对方，所以怎么办，在整个打印完成之后，务必要加一个叫notify，务必要加一个叫notify，如果我先结束了，叫醒对方，如果对方先结束了呢，叫醒我跑一下。

看这样的话顺利结束好讲到这里能听懂这个写法的，给老师扣个一，没问题吧，但现在有一个很棘手的问题，咳咳什么问题呢，你们琢磨一下啊，现在我要求的是先输出一，但是如果咱们这种写法的话，有没有可能先输出a。

第二个先执行了，是不是就先输出a了，第一个先执行的话，是不是就先输出一了，对吧，现在老师先输出一啊，当然你执行好多遍，有可能先输出的是a，实际上它是有可能先输出a的。

那我怎么样才能保证它先输出的一定是一，而不是a怎么办，好好好我我我因为同学们的这个基础稍弱，我来看看同学们的一些小问题，首先和平号的问题是说notify是睡眠的意思，怎么会结束呢，我不理解。

来你查一下notify啥意思，大哥weight是休息，sleep是睡眠，notify是叫醒，二进来就加个weight，大哥，如果二进来加个weight，二进来先wait，同学们。

你们琢磨琢磨琢磨这个小小小小小图标，说的啊，二进来先wait，可不可以上来先wait，最后那个note粉什么意思，我不解释过了吗，如果你最后那个不写的话，程序不能正常结束呀，join大哥。

所有的同学记住了，我应该再加一下，关于线程的问题，凡是线程同步的面试题，凡是从时间角度或者优先级就考了，基本全部对，凡是从john考虑的，99。99%的不对，除非人家考证。

你先弄明白john是什么意思再说好不好，先暂停，先去wait，上来先wait，那我问你，你先让哪个weight呢，先让这个weight啊，其实也可以，但是你先得上锁呀，上来你先上锁，锁定之后wait。

然后这个线程上来先去notify一下是吧，然后再wait啊，理论是能达到的，确实可以可以写写看啊，你们自己下去写写看，当然还有一种玩法呢，就是使用condoleo呃，顺带讲给大家听。

也认识一下con lash就行了，另外一种玩法是门栓，比方说这个线程我想让他上来，先wait怎么办，try let there await，先让他门栓把自己给拴住，而另外一个县城呢。

我打印完第一个字母之后，let the coundown，把这个门出给放下来好吧，这个，也可以，关于门栓需要我解释一下吗，挺挺简单的一个同步同步锁，同步工具，它就是个相当于这个门上面上了一个拴。

所有的县城走在这儿是过不去的，因为门上面插着门栓呢，怎么样才能过去呢，另外一个县城把这个门栓给他放下来，这个县城就过去了，听明白了吧，嗯clibarrier celebra，跟你杀鸡用牛刀。

你用什么cliberry啊，哦俗人说主线程休眠一秒二启动，合着我刚才跟大家伙敲了半天字，你你你就是没往耳朵里灌，你还是咱们vip呢，大哥怎么听课呢，来给我读一遍下去，给我默写300遍。

凡是关于现成的面试题，如果建成同步的面试题，凡是从时间角度或者优先级角度或者join考虑全不对，大哥听懂了吗，那你等这一秒你不浪费吗，我程序本来两个毫秒就执行完的事情，想啥呢，好了，当然，看这里。

关于这个wait notif呃，它是有一些小问题的，wait notify的问题在于哪呢，你认真听，这是那把锁，然后这个weight到底是什么意思，你你一定要理解啊，这个weight到底什么意思。

那weight的意思就是，进入这把锁所关联的那个等待队列，也就是说它有一个排队的地儿，我上厕所过来了，厕所里面有人怎么办，我到旁边一个排队的地儿去排队排排坐吃果果，等什么时候轮到我了，我再去上厕所。

所以这把锁附带的有一个等待队列，但是呢这个等待队列呢是所有的关于这把锁的线程都可以让自己进去，不管他是进来大号小号或者是王力宏等等等等，其他的各种操作骚操作你都可以进去，那举个最简单的例子。

我想叫醒某某些，叫醒某些特定人群，我怎么办，我没办法，我做不到，再举个简，单例子生产者著名的生产者消费者问题，这个呢是那个容器一堆的生产者往里头生产东西，一堆的消费者呢从里边往外拿东西。

然后必须对锁进行同步，因为你生产满了之后，你的生产者都得去进行休息，等待进入队列，等待消费者呢消费者消费空了都得进入队列等待，那我生产者生产满了，我想叫醒特定的那些个消费者，县城里边那些生产者。

我不想叫醒啊，先叫醒小号呢，大号的不叫醒能不能做到，可以吗，好我告诉你，notify这事儿做不到，notify的意思是说让线程调度器去选一个线程出来，他选谁，这事你管不着。

能不能理解别人说我这个如果说t一和t2 全进去了，t3 想叫醒其中的某一个是叫不醒的，它只能是随，不能说是随机的啊，就是按照特定算法去叫醒其中的一个，但是它叫醒哪个你控制不了，当然除了notic之外。

还有另外一种叫notify哦，这个方法那地方or是什么意思呢，novo的意思是说叫醒等待队列里面的所有县城，你们出来之后呢，去去抢那把锁，谁抢着算谁的。

但是你想想看有没有叫他会不会叫醒那些我不想叫醒的呀，当然有可能啊，这这是生产者，这是生产者，这是消费者，这是生产者，我能说哦，所有的人全全叫醒了，我不想叫醒生产者，只想邀请其中的某一部分能不能做到呢。

我告诉你，notify和notifall这件事是做不到的，这是一种传传统的关于所控制的，它的呃欠缺的地方，所以java里面ju c里面提供了新的锁控制这个锁能，是替代原来的老锁的。

替代那个synchronized那把锁的这把锁呢叫lock，最常用的替代synchronize里巴索的，它的全名叫reenterlock，叫可重入锁，那可重入锁里面有一个非常经典的用法。

就是condition，lock，condition，好呃，你可能搞不明白这个condition到底是什么意思，大家听我说这个condition的意思就是队列，某种条件它叫做某种条件下叫醒某些人。

他就是个队列，好，我来解释这个程序，大家看这里，这是这把锁，然后呢我有一个condition t，一有一个condition t，二，大家听我说，凡是有两个condition，意味着你有两个队列。

这是第一个队列，这是第二个队列，这个时候我在让当前线程去进入等待队列的时候，我可以选，我可以挑，我是进入这边这个队列呢，还是进入这边这个队列，听懂了吧，就一个澡堂子，大家伙都脱光光，在里边去洗澡。

你是男人，你当然要进入男人队列，你是女人，进入女人队列，我们假设规定我们轮着洗，男的女的男的一个女的一个，那我男的洗完了之后，我叫醒谁呢，我不会叫醒，notify old的。

我会叫醒对方队列的那个那个那个里面来这块能听明白的，给老师扣个一，大家都用手机在看吗，看不看不清，所以大家注意看啊，就是说如果我们想精确地控制，我们有两个队列，那么在这个队列里面呢，来反正手机看不清的。

我稍微给你放大一点，这回应该能看清了吧，听我说我打印完成之后，注意叫醒第二个队列里面的，我自己去第一个队列休息，哈哈这样我就能精确地控制我去哪个队列休息，我叫醒哪个队列的人好，当我讲到这里的时候。

我觉着另外的一道题你可以考虑怎么去做了，这道题也是一个经典的问题，这道题是abc循环十遍，输出三个线程，第一个线程只输出a，第二个线程只输出b，第三个线程只输出c每人十次，但是必须是交替的。

a b c a b c a b c a b c好了，同学们，琢磨一下，给大家几十秒钟，michael说三个对联说的很对啊，用三个condition说的太对了没错，三个condition轻松搞定。

大家听见了吧，这个你们自己去做吧，好不好，这个关于a b c的问题你们自己去做，我在这就不给你们看看程序了啊，那好呃，我我讲完了这个比较经典的，然后讲完了比较比较比较比较这个这个稍微的新潮一点点的好。

大家听我说啊，呃有一个经典的面试题，他是这么说的，他问他说synchronized和reentrant lock，reentrance log，它们的区别是什么区别。

来同学们今天讲这个vip的课程都会讲到吗，这不废话吗，一定会讲到，好好听，我说琢磨一下区别是什么，这是经典问题啊，讲点男的，为什么不能讲点女的，首先第一点retry logo，我给大家简单讲讲啊。

retrilogo可以多个队列，我已经说过了吧，然后schnet只有一个队列，ok reaction log可以做公平锁，听懂了吧，synchronized，只有非公平，没有公平可言。

ok reentry log，还可以干嘛呢，try lock尝试上锁，上不了锁去干别的，就像刚才你说的，try去踹那个筷子，try不了的话，做出一定的考虑，做出一定的处理，try lock。

但是synchront只能上来就死，等傻傻等待，等不到就死在那，底层实现全是一样的，不要跟我聊不一样啊，聊不一样的，你是不了解底层，try lo，那么第四个区别呢，刚才猜猜我是谁，说的很对。

锁可以被打断，可以被就是我在锁的过程之中，我可以让别人打断，我打折我的腿，我就醒了，这个叫look interrupt，他可以做这种这个操作，就是reentry log，但是simple net可以吗。

不可以，等着你打不断他，你不能把它打断，除非你把整个县城给他q掉，interrupt，yes，你是打断不了的，这是think和，咱们的reaction的区别。

呃至于bd说的这个不要说他误导他说的不对。

bd说的这个事是不对的啊，bd你好好去那个研究底层去重入锁底层cs实现，其实不是think，由系统及控制，首先think也是由它其中的某一个所升级过程也是cs实现的，所以本质上他们两个没有太多区别。

重锁的底层的cs实现最终依然是硬件级别lock指令实现的，汇编源的lock指令实现的，think也是啊，没有区别，它们最终到底的时候实际上都是没区别，michael说是unsafe还是不对，算了。

你们如果对于所非常底层的问题有需求，月底来我关于锁的专门的训练营，今天咱们讲的主要还是形容同步的问题啊，这个就没有办法给大家再往深里挖了，好了，我们就讲到这儿嗯。

在这儿呢我也给大家讲一点那个好玩点好玩点的吧，因为这里面呢还是有好多好多处理方式的，用pipe dream，用blocking cue，用c a s，用atomic integer，这些都可以去实现。

但是我在这儿呢教大家使用一个特别好玩的队列，用队列去实现，用同步队列，那同步队列怎么去实现呢，同步队列里面呢有好多好多的队列，我今天讲一个比较好玩的队列，这个队列呢叫做transfer q，好听。

我说transfer q最大特点是它的容量，为零，有同学说了啊，容量为零还能叫队列呢，没错是的，完全可以，这个transfq它是用来交换的场所，它不能够把一个东西存在里面。

但这transfer cure是怎么做的呢，transfer cure就是类似于我们我不知道等会有没有看过电视，电视在北方内蒙古那边，然后去那个老老的那个年代，我们去买卖牲口，说咱哥俩呢。

我认为我这牲口1000块钱，你觉得我要还个价800块钱，那怎么还价啊，拿一个套筒，你的手伸进去，你的手也伸进去，两人的手在里面跟这儿不知道白吃啥，具体什么什么手语我也不太清楚，就是总而言之，我递给你。

你接收了好了，这个套筒的作用就结束了，我们的transq类似于这个套筒，好吧，好看这里这是什么意思呢，这么来做呃，我们来做一个transfer，q等于你有一个link transfq。

然后呢在这transer q里面呢，system。out，q。take，我take从里边拿一个字符出来，我就把它打印出来，然后呢q。transfer，我再往里头第一个字符进去。

而另外一个线程呢是先递一个字符，再去拿一个打印出来，注意这两个方法，take和transfer它都是阻塞的，这是什么意思，就是说如果我take不到我的程序是不会往下继续执行的。

如果我transfer过去了，但是没有人从我手里拿走，我的程序也不会继续往下执行，所以它就类似于是这样的一个交，换场所，我第二个线程必须得把这个c拿出来打印出来，否则我第一个线程不会继续往下执行。

我第二个线程也不会继续往下执行，必须拿到，必须送出去，也就是说这两个线程必须得成对，生产者往里扔一个，一定得必须被消费掉，我的生产者才会继续，不然的话我就不继续，我就在这傻等着好。

这个东西呢被我们称之为叫transfer kill，可以想象，我把这个一递给你，你帮我打印出来，这边是我再把这个a d给你，你帮我打印出来，所以他们两个巧妙的做了个，交换你打印我的，我打印你的。

好这个挺明白的。

系列 1：P35：深入多线程与高并发：3.异步线程事务咋回滚问题，尸横遍野 - 马士兵官方号 - BV1mu411r78p

我们来看另外一个小问题，这个小问题是相对比较难的，多数人是写不出来的，巴黎的问题，他是让你现场写一个解决这样一个问题，什么问题呢，就是我有一个很大的任务，这个任务啊可以分成。

a b c3 个步骤同时进行，就是a b c3 个步骤同时进行，你就拿大腿想一想，多线程嘛，在同时进行的情况下呢，如果有一个任务被取消掉了，或者遇到错误了，然后所有的都应该结束，要求高效完成。

它的要求主要是高效好吧，如果说你说所有的那个那个，但凡是遇到错误了，等着别人全完成了之后再完再结束，那是不对的，所以这是一个严格来讲呢，它是一个分布式事物的问题，就说有一个事物，有一个事物。

这个这一段放到a级上去执行，这段放到b这段放到c，其中有一个是半截单的子事务没有完成，那整个事务取消掉好了，这个是事物的问题，举个通俗通俗一点的例子，我们现在要吃火锅，我有试过有好多步骤。

第一我要去用锅做开水，第二我要准备洗菜买菜，第三我要去请王力宏，第四呢我要去请徐若瑄，好，有一个人去锅烧水了，有一个人去买菜了，有一个人去请王力宏了，有一个人去请徐若瑄了。

ok然后其中去请徐若瑄的这个人，很快就到他那了，然后说徐若瑄已经出去了，已经被pg one约走了，所以这时候怎么办，整个任务全取消，即便是你还在飞机上去找找王力宏的，飞机上来取消，你在烧水取消停掉好了。

这个意思啊，来提听题目，听懂的，扣个一没有问题吧，嗯，怀孕，你是一个非常坏心的人，好当你听懂了这件事情之后啊，我们来考考虑考虑这个题怎么写，现在你脑子里过一过这个题目应该怎么写，多线程是没问题的。

对不对，监听某个标记，监听哪个标记啊，什么叫监听某个标记啊，这个考点在哪儿，就让你写出来，考点就是让你写出来，你写吗，你怎么写吗，好看这里我最简单最简单，一步一步带大家写，大家大家往这看。

the cyclic barrier，搞不定的，compleable future可以搞定，cyclic barrier搞不定的啊，你不信你去试就行了，好往这儿看呃，假设我们有三个任务。

t1 t2 t3 ，然后呢我们假设这是每一个任务，它的正常执行完结束之后，他应该是三秒钟，四秒钟，当然，为了模拟这个任务，我假设t1 t2 ，这两个任务都能正常执行完，所以他后面传这个。

true的意思是说让它正常执行完，那么传force的意思是说，让它执行到一秒的时候报个错，这样我们来演示整个回滚的过程好吧，然后t1 t2 t3 start，当然对于我的任务来说，name它的名字。

具体执行的时间，执行成功还是没成功好，这里是模拟整个的业务执行时间，实际时间是不固定的，他的时间可以是在计算任务，或者是计算io或者等待i o，但是实际时间是不固定的，我们是模拟嘛。

所以我给它一个固定时间，三秒四秒，一秒三秒四秒的成功执行完一秒的，到一秒之后就结束了，来这块能听明白的给老师扣一，所以我这个第一个最简单的写法啊，就是这样子的，第一个任务执行三秒，第二个任务执行四秒。

第三个任务执行一秒，但是他执行执行失败了，t1 t2 ，t3 结束，我们跑一下，看扫你首先第三秒钟之后t3 结束，然后t一结束，然后t2 结束，好呃当然同学们你们琢磨看一下，如果程序写成这个样子。

阿里肯定是不会让我进去的，对不对，为什么，因为你我不知道大家会发现没有，这个你的程序的正常的结束啊，取决于你最长的这个时间段，比方说我这里要填十秒，我们整个程序啊要想结束t2 这块。

就得等他十秒才能结束，你不信，你就等着，但是按照我们题目的要求，为什么，你说是不是，所以一秒就该结束，那怎么办，来同学们告诉我一下，想想怎么办，这没有打断其他县城sleep helper。

没有见过这个类，没事，这个类是我自己写的，你就认为他是个sleep就行了啊，就是每次你写sleep不得写try catch吗，就这个意思啊，不要纠结这玩意儿，所以我们第二个呢得是让它正常的结束，对不对。

那我正常结束的话，你们琢磨一下，我是不是得由t3 来通知大家，说我已经废了，现在我要通知各位，你们呢要需要结束掉，是这个意思吧，好，所以在这儿呢，我们给每一个任务，给他指定一个执行的结果，大家注意看。

我们看第二个版本的玩法，就是我是给大家分成一个一个版本写，如果不给你分版本，我告诉你，你很可能一次性的写不到最后那个版本，好吧好，既然是这样的话，我就需要有某一个东西来告诉我，这个县城是正常成功了。

还是没，成功它的状态还是说还没结束呢，所以我在这儿做了一个enumeration啊，做了一个枚举类型，这个枚举类型主要指代的是每一个线程，它的状态它一共有三个状态，第一个状态是not end。

也就是说现在正在运行之中，第二个状态呢是success，正常运行结束，第三个状态是failed，运行失败了，我为什么要做这件事情，因为我需要知道这个县城他执行失败了，我需要知道他的状态，如果执行失败了。

通知所有的线程结束，那我怎么做呢，我这样来做，首先我把所有的线程全装到一个list里面，然后让所有的线程启动，启动完成之后呢，我就启动一个监视程序，for循环，一直不停的监测它。

如果有某一个线程get result，它的result是failed了，整个县城失败，整个程序结束，system exit，零来，这块儿能看明白的，给老师扣个一，我觉得这是很多小白的玩法。

但是我想告诉你的是，这个玩法是绝对不能够被允许的，为什么想想为什么可见性，这跟可见性没有半毛钱关系，首先这是一个盲等待，就这个意思，盲等待，什么叫盲能耐呀，就是他自己一直在这不停的循环，不停的循环。

那不停的循环就代表着什么呢，我不停的消耗cpu，我有事没事就跟着消耗cpu，这是效率上的降低，这是肯定是不被允许的是吧，第二一个，你看这个这部分的处理，这部分system exit，零大哥。

这什么意思啊，粗暴地干掉一切线程，有一个人去找徐若瑄了，一，秒钟之后失败了，找王力宏，那哥们还在飞机上，把飞机给我打下来干掉，这边正烧火呢，把锅给我踢飞，完全有可能是不一致的状态，我打开了半截文件。

你直接就退出了，这个文件还没有close，我建立了一个连接，对方还得等着我说话，我还没说呢，直接连个拜拜都没说就close了，这能能不能被允许啊，绝对不行，所以这里面牵扯到两个问题。

第一个不要进行盲等待，不要进行监视，这件事情只有没有办法的时候，才要进行监视，第二个优雅的退出来，这块能听懂的，给老师扣个一，好嘞，那我们怎么怎么处理这个问题呢，这个问题怎么处理呢。

我们来看第三章的写法好吧，今天来的今天来没白来吧，有收获吧，应该最起码认识了好多新的累是吧，另外呢考虑问题的时候呢，也需要考虑的比较呃，到位和全面和精确啊，好我们来看下面这个玩法，这个玩法主要怎么做呢。

大家看这里，首先我们解决盲等待的问题，这次呢我们不要进行盲等，待，我们进行通知，既然你这个县城是非正常结束，那就让你这个线由你这个县城来通知，其他的线程听懂了吧，所以我们这么来做。

嗯每一个线程在运行的时候，加一个最终的处理方法叫boss。end，boss。end的意思是说我这个线程正常，我这个线程结束了，对其他人作出处理，听明白了吧，boss。end这个boss又是谁呢。

boss就是我们的最大那个管理员等于new boss，我们每一个worker都拥有一个boss的引用，我这边结束了，我这边结束了，我这边结束了，然后boss。end的时候怎么怎么去结束。

如果某一个线程结束了，线程结束之后呢，我在end里面的处理方法就是说，如果他failed了，那我准备退出，这样就解决了盲等待的问题，你看他有没有进行盲等待，没有我们处理，我们仔细考虑一下这个模型。

原来是这仨哥们儿去干事儿了，去监视这仨，知道吧，转圈转圈转圈转圈儿，现在不是这样了，现在的处理方式是，这哥们儿在这睡觉，等着大哥，你在这儿等着吧，不着急，如果中间有任何一个结束了。

不管是正常结束还是非正常结束，正常结束非正常结束，都会告诉这哥们儿一声，说哥们儿，我我完成了报告，我已经完成，我要检查一下你的后果，你最终的结果是执行成功了还是失败了，如果你失败了，我需要让别人也停止。

如果你成功了，我不做任何操作，来这个模型，大家听明白了，等于老师扣一，是吧嗯嗯，那我再问你一个问题啊，其实我中间呃给大家忽略了一个步骤，但是我觉得这个步骤，你应该是能够想得到的。

比如说我我我我可不可不可不可以，什么意思呢，我这个第一个县城要是真正要失败了，我就通知第二个，然后就自己再通知第三个，可以不可以，我的同学里头，可以吗，琢磨一下，给大家十秒钟，我去拿瓶水了，就在这。

可以吗，当然也可以，但是我想问你，它的区别点在哪，责任链，这跟责任链有什么关系啊，效率不不不，这跟效率也没有关系，因为无论如何，你都要通知其他人的，对在于可扩展，同学们，你们好好考虑一下。

这里有一大堆的县城，然后我这个县城要是非正常结束，我得通知所有其他人，然后假如说我又添加了一个任务，我得改我这个代码你能听懂吗，我这个代码我得进行修改，我得加上对这个人的处理。

然后其他的以前所有的线程都得加上，对这哥们儿的处理，所以我当我添加新的功能点的时候，我这个设计就是有问题的，不好扩展，这叫做没有scalability，没有弹性，你这个设计，那同学们换。

然后我只需要跟他打交道，告诉他就可以了，我想扩展的时候就只要改改这个代码，有必要的话改一下这个代码就ok，其他的任何一个不用改，来这块听明白的老师口音，当然这里面有好多好多种设计模式了。

这叫什么什么什么设计模式啊，我们可以把它称之为叫observer，那我原来是一个乱哄哄，互相之间都有处理的状态，这这这叫什么模式，调停者是吧，好我在这儿就就就不在这展开了啊，门面是对外的。

meditor，这是对内的啊，好了，真正设计模式的话呢，我还是要建议你听听我设计模式的课呃，关于设计模式，这部分老师我也是花了大力气的，23种设计模式，外带mvc是吧，全部的这里面比较比较难的。

比较麻烦的是代理，代理的话，我写了十个版本，有十个版本，你才真真正正的理解了，到底什么样叫动态代理啊，好嘞就到这儿，我们讲到这儿呢，大概解决了这种盲等待的问题，但是我们还需要解决一个问题。

就是我们要让我们的县城应该正常结束，各位大哥不能够说，二话不说，system exit 0，直接砍断，砍断腿的这种接触方式，这是不行的，那这时候怎么办，优雅的推出对大家记住，我讲到这儿啊。

再给大家告诉大家一个多线程题的原则，现成优雅的结束一般不用，interrupt，当然肯定不能用，stop，肯定不能用，kill是吧，reserve，resume这些东西都是不能用的，因为本身它是有毛病。

这两个是已经废了，而interrupt一般不用这个呢，我说它是一般，它并不是说呃不能用，一般不用，但是我们现在这个面试题不用就不行，原因是什么呢，原因是你你你要想稍微优雅一点，你可以用它。

当然有更优雅的解决方式啊，所有的兄弟们，大家听我说，县城要想优雅的结束，应该都是正常退出，interrupt可以用，但是你听他的名字嘛叫打断呃，当然你可以用这个名字来做正常的处理啊，但一般不用它。

尽量做正常退出，只有正常退出，解决不了的时候，考虑用它，好大家看这个看这个小程序，下面我要解释退出的问题，那怎么退出呢，好我们依然是在and这里，同学们，你们要注意一点，就是当我的某一个县城要是结束了。

我并不是说把其他县城的腿打断，而是要让他取消cancel，各位同学，我想问你，cancel这个操作它是长什么样呢，取消吗，长什么样，注意每种不同的任务，不同任务不同的cancel方法，这点大家能理解吧。

坐飞机去找王力宏的，你应该坐飞机回来，烧水的，应该把水再给我晾凉，洗菜的应该把菜再给我收好，所以每一种任务它是有不同的cancel方式的，跑步去的，再跑回来，我往数据库里插了五条记录。

如果我收到了cancel操作应该怎么做，应该做的是把那五条记录再删掉，所以每种cancel每种都不一样，那如果你写一个通用框架的话，你能够把这个cancel给写死吗，肯定不可以。

所以每一个worker有他自己的cancel方式，我这样讲大家能听懂吗，所以每个worker里面除了正常的run，它还有一种方式叫cancel，比方说我拷文件呢，不知道大家有没有遇到过a盘。

c盘拷到d盘一个大文件，考到一半的时候，整个的考呢进度条走到这儿了，我点cancel，他怎么办，他是不是得把d盘，已经考到的数据给它废掉，是不是啊，同学们，好了，所以每个线程都得写好自己的cancel。

那现在问题是自己的cancel怎么写呢，留一个接口是吧，好看，这里我们来简单聊一聊这个cancel怎么写，这个cancel的处理相对来说比较复杂，因为cancel本身，cancel本身啊。

它中间也是不能出错的，不能出错，比方说你往数据库里插了五条记录，12345，然后呢，你在删这五条记录的时候，同学们，你们好好考虑一下，你删除这五条记录的时候，你只删了三条，还有两条没有删完。

你这个程序报错了，exception，那你咋办，能不能理解，所以这个cancel没有那么好写，所以我在这里是这样来做的，我说canceling等于true，让我cancel的时候。

我就canceling等于true，就设一个标志位，我设好这个标志位之后呢，具体怎么处理呢，每种程序有每种程序不同的处理方式，那怎么处理呢，往后看，这个时候我在run方法里面，我就得这样来处理了。

我在这儿假设的是一个io密集型的任务，嗯就是我这个任务啊时间非常的长，那假如说啊你听我说我这任务时间非常长，嗯假如说我就是拿考文件来说来说这事儿，同学们，你们我不知道你们有没有见过这样的程序。

就是拷贝一个文件，它时间处理得非常的长，然后在处理的过程中，你点这个cancel，你点半天呢，它没反应，有没有遇到过，原因是什么，原因是处理文件的这个现场是后台的，然后你前面的ui线程你点完了之后。

它需要通知这个线程去处理，但是如果说这个线程啊，它中间呢就是在干嘛呢，就是二话不说i o密集跟着拷文件，你怎么打断他呀，你打断不了他，你最好让他主动去打断，所以我做出了一个主动打断的方式。

就是每隔一小段时间，我去检查一下这个can这个这个呃标志位，每隔一小段时间我检查一下，如果说cancelling，说明有人要求我停止，还有一种方式呢，就是要求我停止，我不一定马上停，我现在正打针呢。

疫苗打了一半了，你要求我停止，直接把针给我掰折了吗，肯定不行，你很可能把这一管打完，然后再把针撤掉，所以我需要做出我针对有业务逻辑的处理，我判断一下，如果你是cancel，roll back。

我需要做回滚，与此同时，我们的标志位制成cancel的，表示任务已经取消，by cancelling，置为false，打印结束，所以这里头又引出来下一个叫rowback，叫回滚。

好讲到这儿琢磨一下怎么书写这个回滚，来看看讲到这里有没有谁有疑问的，怎么书写这个回滚啊，回本这件事情啊，就是每种是每种不同的方式，好吧，就是你每一个县城有每一个县城，不同的回滚回滚的方式。

那roll back到底怎么写呢，我在这里只能模拟了，因为这个robc不同的事物是不同的，回过比如说我的整体这个大失误，他要求第一个事物是关于数据库的，那么你差五条就得给我删五条。

那么第二个事物是关于文件拷贝的，你这个文件拷贝完了，就得给我给我把它删掉，第三个呢是关于mq里面往里头发消息的，好，你发了，你发进去几条消息，然后再给我发几条取消掉的消息，这叫rob。

好了同学们这块大家能听明白，给老师扣个一，所以你说这道题很容易写吗，其实不是很容易好，那个刚才有同学就要问了。

这个说这个问题问的很对啊，就说rowback出错了怎么办。

好同学们，如果是在roll back的过程中出错了怎么办，我刚才说过了吗，差了五条，结果你删五条，删到三条，后面两条没删掉，琢磨一下，给我给我点答案，按你们的想法应该怎么办，robc，抛异常查日志。

exit 0从事从事，不提交好听我说啊，首先发出总任务的这个人一定有一个呃，最大等待时间，max with time，假如你这个在特定的这个时间内，那就说明任务失败，就处理你的任务失败的过程，失败了。

那就一定是抛异常了，这个时候你一定是记日志发告警，必须人工处理了，没有人工这个处理不了了，听懂了吗，拿那个数据库的来说，你删不掉了，说明里边有脏数据了，可能不是删除，可能是修改，对不对。

你这时候必须人工处理，报警，把运维程玉儿从睡梦中叫醒，让他们赶紧过来处理，好了同学们嗯，我就讲到这里好不好，当然呃我们呢讲一点儿先进的处理方案，对补偿任务先进的处理方案，呃。

这个处理方案呢比较简单的是呢，可以使用现成的这个compleable future，当然有同学呢应该是不太明白，这个complete theater是什么东西呢，我就没办法给你展开了。

可以使用异步任务这个线程池，completely future，supply，i think，supply，i think的意思是说，用纯异步的方式去调用第一个任务，第一个任务如果有了结果之后。

对这个结果进行处理，then except，这是它的结果，结果的处理使用call back来进行处理，这就是我们call back的处理过程，当然，写到最后的话呢。

如果用complete the future的话，大概是这么写啊，就是我的每一个任务都交给我的线程池，然后让他去异步运行，有了结果之后，用kbc处理这个结果，处理这个结果的时候。

判断这个结果如果是fail，那么让所有的任务全部cancel，那任务cancel的过程是怎么怎么cancel的呢，任务cancel的过程是synchronized this，然后让他去那个任务结束啊。

最后把cancel设为true就好了，呃这里面为什么上把锁其实不上锁呢，关系也不太大，主要是不要有什么呢，两个县城同时发出了，让我们所有人都cancel掉的，明白明白我意思吗。

所以上锁的过程主要是这样的，你比方说有你有1万个任务发出去，其中有可能有100个全部失败了，这100个呢如果说你不加这把锁的话，很有可能你这个cancel的过程是同步执行，好多粉哈哈，不知道这么说。

大家能不能理解啊，好这个使用completely future，那也不影响，是不影响，但是你没必要让它回滚，你你回滚一次就行了，你如果这样的话，你让他回滚了100次，这是没有意义的。

只要他回滚完成一次之后就不要再继续了，就是这个意思好吧，所以你要加一把锁进来，就是有多个任务同时失败，对是的，这是有，这是有可能的，对不对，工作线程在执行耗时的任务怎么做，隔一段时间检验标识。

你就到一个时间点检查一下，最简单的是每隔多长时间检查一下，复杂一点的呢，就是说你到某一个中间点上，说我拷贝完一个文件之后检查一下，这些都可以啊，对一次解决问题，其他都是多余的，是的，密等控制，yes。

嗯，好了嗯，当然你要真正写这么一个框架的话，那你需要需要去阅读什么呢，阅读c它的代码，这个的话呢咱们曹老师在讲其他的时候，也带大家读过这方面的代码，嗯我们手工写一个c，它显然是在公开课上也好。

肯定是完不成的啊，这先不去管它了，就嗯今天讲的这三道题呢，我基本上就讲完了，嗯，大家看看关于这三道题还有什么，谁有疑问的没有，大厂的面试题呢，这个是除算法之外比较难的问题，有多线程的问题。

系列 1：P36：美团面试JVM七连问：1.对象在内存中的存储布局？ - 马士兵官方号 - BV1mu411r78p

关于职业vm的一系列的问题，这类问题呢比较难非常的难，如果你没有听过或者没有接触过，基本你打出的可能性呢很低，看这里现在的大厂的很多问题，他会他会追着你一问到底。

嗯还有很多同学说我现在开始问那个源码级的内容了，对这个很很正常也很正常啊，嗯源码的课呢我们讲的也非常的多了，深入的级别呢会讲到linux内核的源码，那么软一点的，你像jdk的一些个源码呢。

肯定是要讲到的a q s了啊等等这些啊，不废话呃，我们来看这个关于这位m的原来问的这几个问题，这个，问题是什么呢，它实际上就围绕着这句话来完成，就这么简单的一句话，这句话大家伙一看都能知道是什么意思。

但是围绕这句话所诞生的七个问题，你就未必能回答的出来，看这里他是这么来问，他说第一个请你解释一下对象的创建过程，对象的创建过程不就是你扭出这个对象来，中间执行的有哪些过程好。

第二个呢叫做d c l l d c l要不要加volatile，这里是关于指令重排序的问题，同时也涉及到多线程的问题啊，同步的问题，那么第三个问题呢是在对象在内存中的存储布局到底长，什么样什么意思。

我们弄出这个对象来的时候，它在内存里面到底长什么样好，当你明白对象在内存中存储布局的时候，第一个对象该怎么定位，是直接是间接，第六一个呢是对象怎么分配，第七个呢是在内存中占有多少个字节呃。

后来又他们内部在问问题的时候又加了两个更加深入一点的问题啊，第八个问题叫做为什么hobt就不使用c加加对象来代表java对象，当然这个东西就涉及到一些，hosp的源码了会稍微更难一些，c加加。

大家都知道hosport是c加加写的，不知为什么不用c加加对象，直接来代表着对象呢，而是要采用那种oop class 2元模型，我先跟大家说一下。

hosport里面采用的是这种模型来代表着我对象叫op class，oop class 2元模型好，第九个问题，第九个问题是class对象到底是在堆啊，还是在方法区，关于这九个问题。

有多少同学能够感觉到答不出来的，你给老师扣个二，我来认识一下，好我今天呢给大家把这些问题讲清楚，由于内容比较多，大家认真听，我预计，我不一定是按照顺序来啊，我预计我在9。50左右会讲完第一波，9。

50~10。15左右，我会做一波广告，10。15啊，到十点半左右会跟大家回答一点问题，十点半之后呢，我会把剩下的问题给大家close掉，这是我们今天晚上的安排，大概11点我们下课好，现在开始看这里。

我我先把这个题啊，这样啊，我先把这题先来给大家伙儿复制一下，一会儿呢我们边看着题，我们先来回答问题啊，我们先看第一个问题，第一个问题我先回答回答大家伙，这个问题就是对象在内存中的存储布局，到底长什么样。

呃这个呢我就不卖关子了，我们直接呢来看啊，就是new出一个对象来的时候，这个对象在内存中的存储布局到底长什么样，注意看一个普通对象，new一个对象，平时我们嗯这个课程里都这么讲，说你有一个对象来的时候。

这个对象呢是往堆里头这么一扔啊，换一个方块表示一个对象，但实际上大家都知道一个对象来说就是一连串的010101好，这些零一里面每一个东西到底代表的什么意思，他问的是这个东西，认真听。

作为一个普通对象来讲，可以说它分成四部分，这，四部分，第一部分叫mark word，第二部分叫类型指针，也叫class pointer好，第三一部分叫instant data，第四部分呢叫对齐。

为了让大家深刻的认识这个东西，来听我说，我把这部分抓下来，我们来写一个程序来认知它，看这里，呃这程序呢需要用到一个小小的类库，这个类库的全称叫j o l j o l呢，我在这里就不多做解释了啊。

jo的这个类库非常的简单，你百度1下，花五分钟就能了解它怎么用，它的全称叫java object layout，object layout，layout，布局的意思，java对象的布局。

通过这样一个类库，我可以很简单的很直接的了解到一个java的对象，在它内部到底是怎么表示的，好看这里，我先把多余的乱七八糟代码给他家伙删掉，先不管它好，现在呢我们有一个非常简单的class class。

叫t哈哈，什么都没有，就叫t那好当我们另一个t对象出来的时候，它的内存布局到底长什么样，一句话就可以搞定它，怎么把它搞定呢，这样来做，class lay out，这是我们g o l类库里面用到的一个类。

class lout，点pass instance静态方法，解析对象，解析哪个对象呢，解析t这个对象，two principal转转成可以打印的字符串类型，那么呃我们先把这小程序跑一下啊。

就是我new了一个t对象，下面这句话呢对他进行了t对象进，行了一个分析输出，就这个意思很简单，往下看，好了看这里，对照我们刚才这张图啊啊对照我们刚才这张图放在这个位置，对于刚才张图来说。

这里头的010101。

这就是我们弄出来那个对象的真正的内容啊，这个这个就是我们new出来一个对象里面，在内存里面的0101的布局，当然每八位代表一个字节，每八位代表一个字节，那么大家可以数一下。

说这个对象呢哎到底是呃占了多少个字节呢。

如果按零一来看的话，就12341行，四个三行，一共12个字节，但是呢我们对着我们整个的刚才我们所说的这个对象的布局，第一部分呢叫mark word，请大家记住mark word呢占八个字节。

这里头是八字节，这个好，第二个呢叫类型指针，类型指针指的是诶，我new出来这个对象到底是属于哪个类，你可以认为这里有一个指针，它会指向谁，指向t。class，因为我们用的是t对象吗，这不ut吗。

用的t就行，所以呢通过这个指针可以找到这个class，这个占多少呢，这个占四个字节好，第三一部分叫实例数据，实例数据指的是什么呢，t这个对象的它的成员变量，比方说它内部有一个小m好。

这小m扔哪扔在了这里好，第四一部分要对齐，对齐什么概念，整个对象的大小不能被八整除，补齐能被八整除，就这个意思好，我们按这个规律来看，现在的这个输出，看大家是不是能看懂了，首先我刚才说过。

mark word站log自己八个字节对吧，从第二个到第四个字节，从第四个到第四个字节啊，往后再说，四个一共八个字节，这里对应的迈克尔的好，下面这四个字节对应的什么东西呢。

对应的是class pointer，还有同学说没有实例数据对，因为t类型它没有成员变量好，最后叫对齐，因为这里是八个，这里是四个加起来12个不能被，八整除，所以最后又补了四个字节。

所以一共加起来这个对象的大小是instant size，16个字节啊，这会能跟上的，给老师扣个一，因为我觉得比较简单，怕同学们有的认为比较复杂的啊，可以是吧，good不错。

那有同学说老师那那那那我要是那个我要往里头装点，装点那个成员变量呢，来温暖这一句，如果按照我们刚才的这个说法，我要我要我要往里头装这么一个成员变量，int m来告诉我一下整个对象到底占多少个字节。

算一下，那为什么是16呢，啊有时候16，有时候四，有说24的，我们先再跑一遍，run，好看，这里一共还是16个字节，唉为什么呢，前面的12个字节不变，分别是八个字节的mark word。

加四个字节的class pointer，最后呢我们有一个int类型的变量，int类型占多少个字节呢，占四个字节是吧，所以最后加起来16个字节，由于已经被能够被八整除了，所以没有补齐了，一共这么多好。

我再问大家一句，如果我这么写long，来告诉我整个对象有多少个字节要看大家能答对吗，long是占八个字节对，16加八二十四个对吧，这个是没问题的，打一下，我怎么没太懂，你哪没懂啊。

我总觉得讲的算比较简单了，来告诉我这个这个对象再来一遍多少个字节呢，布尔类型，好跑一下，看我们看多少个字节，布尔类型比较有意思啊，我看他怎么做的好，大家看这里啊，这个布尔类型占了多少个字节啊。

占了一个字节，所以最后给你补了七个字节，补到八个，所以四个字节加四个字节，一共八个字节的mark word，一共四个字节的class pointer，一共四个字节的m，八个字节的long。

一个字节的布尔补齐七个字节，最后加起来32个字节k，而这个4s等于hello，北京好，告诉我多少个字节，32 32，32，32，嗯，不对吧，那我走长点，一共多少个资金，有没有别的答案，往下看。

好看这里一共是32个字节，这时候你注意看这个布尔类型，直接补补到int类型，所以补三个字节，最后这个string类型是一个四个字节的对象，为什么，因为这里不要认为当我们又是一个替对象来的时候。

这个东西是存在t的对象的内部，它是在哪里呀，这个s本身是一个地址，是一个指针对吧，它是放在这儿的，但是呢这个字符串是通过这个指针指过来的啊，指到这里好了，到现在为止。

我觉得给你讲完这个呢，我们再来看呃，美团问的问题啊，来看第七题，第七题能答出来了吗，orient order，new orient内，存中占多少个字节，多少个说出来，16个对。

然后对象在内存中存储布局到底长什么样。

好把这个图给我背过就行了，八字节的mark word没有什么王八的屁股规定，只要是64位的虚拟机，它的mark word永远都是八字节，64位，glass pointer叫类型指针，默认是压缩。

它是四字节，不压缩是八字节实例数据里边你装多少算多少，反正不管你是内部棋还是外部棋，最终都得给我补齐，成被八整除，我知道大家伙还有一些细节的疑问，但是如果你给你解答这些疑问，我就给你讲不了。

剩下的问题你们是要答疑，还是要往剩下的讲，我建议我先往下讲，学东西，学框架和脉络，把框架和脉络搞定之后，再去搞这些细节，不识庐山真面目，只缘身在此山中，如果你研究一座庐山上来。

先去研究山顶上某棵树下面的蚂蚁窝，我告诉你，你跟那个庐山的整体脉络就再也没有关系了，你在你的硬盘上存了很多细碎化的知识片，但是你从来没有建立起来过知识体系，我们呢就是自己不仅是讲求给大家伙儿讲知识知识。

这玩意儿比较简单，同时呢给大家做一对一的规划，所以到现在为止，直接告诉大家，我们课程在不仅是在学生的认可了，现在是呃业界也开始认可我们的课程，这是我们最近啊刚刚8月三日，他是去年8月31号报的名。

因为他中间好多事，中间没学球球报个喜，刚面了京东哪个部门，当场直接过，面试官问我从哪学的，ok就这么直接，然后多线程里回答的比较好，直接就过了，知道吧，下周刚通过，还没有具体的嗯，还是那句话，听我的。

不要听你的，效率为什么低，因为你没听我的，我们先讲脉络，总而言之，这玩意儿它是一个死东西，这玩意儿呢如果你是64位的机器，这个mark word就是64位，如果你是一个32位的，咱们的呃jdk。

那么这里就是32位啊，这是一般的那个建对象的时候啊，做这种呃运行时对象的时候经常使用的一种技巧，看这里在这里呢呃第二部分呢叫类型指针，类型指针比较简单，我在这里就不展开了。

面试的重灾区，实际上在mark word这里，它的种灾区在这儿，听我说对象头这两部分，这两部分叫对象头，mark word加上class funter，这个叫对象头，所以当你看到呃。

我们这个对象布局的时候，他在前面12个字节里标了它叫object header，叫对象头，加上四个字节的class pointer，class pointer，指向class的对象，这个不说了。

这里是面试重灾区，我直接说答案，这东西没什么可说，背过就完了，第一个叫锁信息，第二个叫还是cold，有同学说老师我能不能看到，可以的，没问题，我跟你讲的东西都能让你看到。

看这里我们同样是我们同样是这个t对象，把它里面的成员变量给它注掉，就不展开了，一个小小的t对象，在它刚刚扭出来的时候，它的布局到底长什么样，刚才我们看过了啊，看这里刚刚溜出来这个t对象。

它的布局它布局是这样的，好我们说锁信息为什么是有锁信息，大家都知道啊，在jdk里面的java里面，我们想给某把某个对象当成一把锁来使用，怎么做，就这么来做，synchronize的t就是把这个对象当。

成一把锁，我锁定这个对象之后才可以执行里边的内容，好我这内容里面是什么呢，再把这个题的信息输出一遍，注意这时候t v是上了锁的，为了做一个对比起见，我可以把这个锁释放了之后再做一个对比。

第一个是刚刚扭出来的，第二个是上了锁的，第三个是是所释放之后的，我们来比较一下，看看哪里发生了变化，走你，仔细看，这是刚刚new出来的时候，我们主要看这个零和一的地方就可以了，往这儿看。

你会发现它第一个字节就是就是所有都是零，最后一个是1000001哦，但是比较一下，当我们给他上了锁之后，你发现它什么长什么样啊，能看懂吗，这里明显发生了变化，好听我说这里面记录了什么呢。

这里面记录的就是关于锁的信息，所有的信息就记录在这里，我还可以告诉你，这里头你看的零零，那么它就是一把轻量级锁，轻量级，所以就是自旋锁啊，所有一个升级的过程要看就看这两位嗯，这个细节呢比较多。

要要讲的话，两个小时开外去了，先把这个略过锁释放之后，你会发现ok准备对象又恢复了原来很自然的一个状态，所以平时我们讲的时候，给某某个对象来上把锁，到底是什么概念呢。

其实就是修改了对象的mac word，如果你要愿意的话，你比如说我们把这个锁的信息先给他做掉，我们打开这个还是code，只要你对它调用了任任意一次，还是code这里面的布局也会产生变化，我们跑一下。

看这里，这是刚刚new出来的状态，这是调用了hash code的状态，所以这里面hash code的信息已经被我们记录在了脑脑袋上面，所以呢由于一个对象的hash code用的特别多。

因此我们调用一个对象的hash code之后，再下次再调用的时候，都不是说重新再计算，而是直接在脑袋上拿出来就可以了，效率这就是它效率高的地方，这个对象到底是什么颜色的，这个对象到底是什么颜色。

我同学说老师这对象还分颜色，没错，垃圾回收算法叫什么叫三色标记，这个对象到底什么颜色记录在哪，记录在我们的mark word里面呃，如果你听过老师的关于三次标记的课。

那么你就会知道这两堂课实际上是有着有机的关联。

系列 1：P37：美团面试JVM七连问：2.对象怎么定位？ - 马士兵官方号 - BV1mu411r78p

把刚才的这个问题大体上给大家介绍完了。

就是对象头里面主要包括什么呀，主要就包括mark word，class pointer这两部分，mark word是八字节，class pointer 4个字节呃，那mc里面主要包括什么呀。

mc里面主要包括所信息还是code以及什么呀，g c的信息好了，这会儿还能跟上那个老师扣个一神，牛湾java中也是三次标记，是java最开始的三次标记，其他的go on是后来学的。

好嘞，那我们继续。

现在呢我们回答了两个问题，第七题和第三题和第四题啊，一共回答了三个问题，好下面我们来聊对象怎么定位的问题。

嗯，这定位问题呢相对比较简单一些，我先讲简单的再讲复杂的。

好不好，好，我们来看这个对象怎么定位这个问题，对象定位问题指的是什么，但定位问题呢，相对复杂一些，就这玩意儿呢其实是设计jvm的人才会考虑这些问题，这个问题问的并不多。

不过呢我建议大家还是要大致了解一下对象怎么定位，我们简单说两种方式，第一种呢叫直接定位，第二种叫间接定位，什么叫定位，定位指的是什么，定位指的是这个意思，认真听我写了这么一个一句话。

string s等于new string，大家都知道我们六个string才对，堆里面啊，new一个对象出来，这个没有问题，那string s是通过这个s怎么找到对应的对象，这个就叫对象的定位。

就是通过这个引用是怎么找到它的，这个叫，做对象的定位，仔细听，认真听，设计jvm的人，其实上有两种方式来对一个对象来进行定位，哪两种呢，第一种叫直接定位，第二种叫间接定位。

当然它有一些专业名词叫直接指针或者句柄，不管它，总而言之一个是直接，一个是间接，我们jvm hosport默认使用的就是这种直接定位，通过它呃，某个算法也好，或者直接内存地址也好，当然这里不是直接内存。

就从某某个算法攻击会找到直接定位，这个对象已经知道这个对象的大小，已经知道这个对象的起始地址，那么这个对象就很就很容易就被定位了，吗内存里面一大堆的零和一，我知道得从这儿开始，然后多长就结束了。

那这个对象我是不是一下就找到了，就这个定位的意思好，当然我刚我刚才分析过了，说这个对象里面呢除了包括他自己的成员变量之外，还包括了什么呢，类型的指针。

类型指针是通过这个指针可以找到你到底是属于哪个class，所以堆里面有一个对象，通过一个指针可以找到方法区里面的peter class，大概就是这个意思，这是我们呃hosport默认的一种方式。

除了这种方式之外呢，其实还有另外一种，另外一种呢叫句柄方式，也叫，间接的方式，间接的方式指的是什么呢，是通过诶这个指针啊，直接指到了这么一个结构体，这个结构体呢通过这里是两个指针啊。

这个指针才会找到对应的这个对象，有另外一个单独的指针指向的是这个地点，class好这两种方式，我通过这个图详细演示就演示到位了是吧，好了那个呃我我这块呢我就先不做细节上的解释，我看看大家伙能不能接受啊。

就这块大家能跟上吧，这两种方式应该都明白什么意思了，对不对，来能够明确的可以继续的给老师扣个一，oswald，不明不明白，明白直接提问哪不明白是吧，元旦搂人啊，不明白直接提问哪不明白。

如果大家伙呢是java的小白，这么跟你说，薪水拿在1万~2万之间，现在还不是没有没有什么没有什么基础的，甚至说还没有就业的这些呃，今天这课你听着会稍微费劲点，听到哪儿就算哪儿好不好，好听我说。

当然你给他讲明白对象怎么定位之后，他一定会问你，诶，为什么没有采用这样的方式呢，为什么不采用间接的方式呢，间接的方式有什么好处，有什么坏处，直接的方式有什么好处，有什么坏处，这个大家能想通吗。

直接的方式有什么好处吗，快一下就定位了，攻击一下就找到了，对不对，好那间接的方式有什么，有什么好处啊，间接的方式你发现没好处，你发现没有，你要找两次才能定位到这个对象，他不是速度很慢吗，他有什么好处呢。

以前有同学告诉我说，老师间接的方式省空间，你看这个这个对象变小了，因为它里面没有这个类型的指针，同学们是这样吗，思考一下，当场不会只问你是什么，他一定会问你为什么，我还有同学呢回答到了问题的关键。

能回答出这个问题来的人，说明是平时经过思考的，而且是平时注意积累了，积累了很多知识的啊，这个真不错，以前我讲这个课的时候，基本上一个同学都答不出来，现在呢你看啊，先生你好。

说对象在内存中移动的位置不用重新定位，对说的非常的对，就是如果是这种方式，那么如果这个对象在内存中移动的位置挪到这个地方来了，同学们，你想一下你个t里面的所包含的这个地址要不要跟着变啊。

你从503挪到了806楼层都挪了，你说这里的，地址变不变，务必跟着变，肯定得变，但是这种方式就不用这个对象挪过去了，没关系，这个t不用变，t不用变，所带来的好处是什么，垃圾回收效率就会比较高。

有同学说老师这事儿不对呀，有了这个垃圾回收，这玩意儿为什么会挪动地址呀，好这块就会涉及到jvm垃圾回收的它的一个过程，作为这边m来说，最普通的叫做分带模型，现在用的最新的叫分区模型。

不管是分带模型还是分区模型，内存呢一定会从一个对象，会从内存中的一个位置挪到另外一个位置，它一旦挪动，你的这个指针必，须跟着变好了，大概就是这个意思，在这儿呢我就不多说了，因为不是。

因为有很多很多同学呢可能连这班子篮球回收到底什么样不知道呃，尤其是我给大家讲这个什么叫分带模型啊，什么东西又叫分区模型，我讲这些东西的时候，如果没有一定的基础，应该是听不太懂，所以呢我就在这不展开了。

呃这个题呢无所谓的事，因为这个题问的也非常的少，把它翻过，所以到现在为止呢，我大概讲了这么几道题，我们现在下面来看第六个，第六个问题叫做对象怎么分配，认真听，现在这些题都相对，简单。

所以我过的速度非常快，句柄指向的地址不是也得变吗，你说的很对，但是呢它内部will啊，我解答为唯一解答will的一个问题就是句柄指向的地址不是也得变，是得变，但是它内部对于对象的整个维护。

这个对象要不要回收啊，到什么我就回收到什么程度了，他是把那个指针来用那个t那个指针来维护的，那个指针只要不变的话，它计算的效率就高很多很多，好了嗯，如果你你你如果想深入了解。

可以了解一下那个三色标记算法，你会发现呢在三个标记算法里面还有挪动的时候，整个是需要维护它的什么呢，维护它的内存的地址必须得维护出来，如果他来回来去老变那个维护你你的那个hash code表哈。

希表就必须老跟着，别在这不展开了，我们谈这个啊叫对象怎么分配这个过程，我希望大家伙把它背过，有很多比较复杂的过程呢，我一般喜欢做动画，这是为什么我喜欢用ppt的原因，很多人喜欢画图也好。

或者他喜欢用文字也好，无论怎么样也不，可能用动画描述的，像我用动画描述的更加精确，不信你就仔细看好看，这里，对象怎么分配，哎呦我的天呐，发现我我我最后再回答一个问题啊，我最后再回答一个问题。

这个问题之后，我们开始讲对象怎么分配，因为我每次讲到这儿呢，因为同学们呃对于这个问题的疑问会比较多一些，稍微多讲两句，就看这里，神牛蛙问了个问题，他说垃圾回收不是在蹲上，t不是在站上吗，屁我就想问你。

我写了这么一句话，叫string s等于new string，我想问你这个s一定是在战争，一定是在站上吗，哪位同学告诉我，s等于new string，这个s一定在占吗。

你这个s不能是一个对象里面的成员变量啊，大哥你拿大腿给我想想，神经蛙这么简单的问题，跟这有疑问是不是好了，不废话了啊，来看这里看对象怎么分配啊，这个过程也比较复杂，对象怎么分配，有同学可能会说了。

大哥那个对象分配，那还不简单，直接new个对象往堆上一扔嘛，很简单嘛，对不对，我看刚才有同学说声音忽高忽低，有多少同学有这个问题，有这个问题的给老师扣一，声音不高，估计就是腾讯课堂。

这个就是腾讯课堂做的这玩意儿吧，有的时候真是无语啊，我已经把降噪给关了，自动增益，给它关掉回音消除，给它关掉降噪，开成弱喂，hello，好点吗，好点了吗，更不行了呃，如果是更不行了。

你就把你那边的声音啊，那个稍微开大点，但是呢声音有点小，你可以把你那边的功放开大点好吗，他就是忽高忽低会比较难受，声音小，你可以把你的功放开大啊，来来看这里，我们来看这个对象怎么分配的问题。

这个问题呢基本上也是一一系列的jvm的一个总结性的，你才能够了解的理解的了，大家伙儿认真听，这里头的分配指的是jdk默认的垃圾回收器，呃，这这vm一共有十种垃圾回收器，这十种呢分别是serial。

serial old，parallel，parallel old c m s，然后呢parallel scavenge啊，这个g one cdc chdow和eullm一共有十种，在jdk的1。8。

这是大家伙经常使用的一个版本，线上的大多数用的都是这个版本jdk的1。8，它默认使用的垃圾回收器叫做p s加p o parallel coverage，加polo，好细节，我们不展开。

这个垃圾回收器会把对象分成啊，会把内存分成两部分，一般我们称之为叫分区模型，这个分区模型呢分成两部分，这两部分分别叫做第一部分叫年轻代，第二部分叫老年代。

那么整个对象呢会在年轻代和老年代之间的来回复制好了，同学们，我刚才讲的这一小段来能跟上的，给老师扣个一，这块需要我展开一下吗，需要我展开的，给老师扣个六吧，如果需要我展开的，就是我刚才讲的这小段。

听不明白的，我讲到这儿，我突然想起来，估计会有好多小伙伴这块跟不上。

我看这里，我告诉大家这张图，好看这张图，这张图啊，就是呃我们默使用的默认的篮球回周期叫做分带的这种垃圾回收器，它使用的一种内存模型，这种内存模型呢会把我们的整个内存分成两部分，这两部分长什么样的。

就说诶这里是新生代新生代的意思呀，很简单，就是我们刚刚弄出来的对象，刚刚new的新生儿嘛，唉放到我们的新生代里，然后呢，我们的老年代老年代在哪呢，老年代是经历了好多次的垃圾回收都干不掉的人。

比方说这个对象扔进来了，但他一直有用垃圾回收跑一次，诶，没有把你回收掉，这个时候呢，就很简单，就把你的年龄加一，垃圾回收又来了一次，又没把你回收掉，加二当你到达了一定的年龄之后，进入到老年代好了。

这里是年轻代，这里是老年代，来这个概念，大家听明白了吗，还能跟上的，给老师扣个一，就是年轻代，就是装那个新对象的，老年代呢就是装那个老对象的，当然年轻代和老年代呢采用的算法是不一样的。

垃圾回收这东西呢有好多种算法，一般来说有三种，从上个世纪五六十年代开始，到现在为止就这三种，这三种呢第一个呢叫标记清除，就是你这里是个垃圾哎，把你标出来，把你干掉，把这块空间给你空出来就行好。

第二种呢叫复制，复制是什么意思呀，我们先说这个标记清楚啊，不清楚也比较简单，你拿大腿想想，我把你，标出来把你清掉啊，时间一长，把你标出来，把你清掉，时间一长，我们的内存会产生什么呢，会产生碎片化碎片。

这这里有一个洞空出来了，这里有个洞空出来，碎片化的产生的原因，产生了之后会有什么后果呢，就是当你弄一个大对象，你发现装不进去了，为什么，因为那些个碎片化的东西加起来能够被我装进去，但是呢那碎片没连着。

所以呢如果我们在标记的时候清除完了之后，再加一个整理的过程，整理的过程指的是什么呀，指的是a，把这些个中间的这些空的东西都给它挪到一起去，把中间有用的就像全挪到前面来，在标记完了之后再做个整理。

这是第二种算法，这个算法呢叫标记整理或者叫标记压缩，特别简单，跟操作系统一样对，说的很对啊，这两种算法大家伙听明白了，对不对啊，不难好，这其中呢还有一种算法，这种算法是什么，叫复制，复制是什么意思。

复制的意思是这样的，认真听，这是我的内存啊，甭管你多大，我给你一分为二，分成两个，特别好玩，我这个里面的这个对象呀，凡是活着的我都给他拎出来，甭管他在，哪然后统一的复制到另外一边来，同时排列好啊。

这个这个速度很快的，拿过来之后，h盘的复制复制过来之后，一下把整个内存全部清掉，诶，你会发现这玩意儿的效率特别高，贼高啊，这是效率最高的一种垃圾回收的方式，但是毛病也很大，你拿大腿想想都知道是吧。

你你你你你你会一看浪费空间，甭管多大，内存只能用一半啊，是不是，好了，所以大多数的垃圾回收器都是怎么做呢，它会综合运用，咱们将刚才讲的这三种方式，那么p s p o是怎么做的呢，我给大家简单解释一下。

你认真听看这里他这么来做的，当我们刚刚调出来的第一个对象的时候，好这个对象呢会扔到我们年轻代里面，在年轻代里面会分成三块区域，第一块区域叫伊甸园，人类诞生的地方叫伊甸区，当然所有年轻的对象啊。

这是诞生的地方就扔在这儿了，一般来说这种年轻的对象呢特别容易被回收呃，这个大多数程序的一个统计呢，你你比方说你一次性产生100个对象，经过一次垃圾回收，很有可能会回收掉95个，知道吧，只有五个是活着的。

如果这事你理解不了，你就想一个for循环里面你不停的new对象，这个for出了这for循环，没有人认识他啊，他就会成为垃圾了，就很简单一件事，同学们你就想了，如果说100个对象会被回收掉95个。

那采用什么样的算法效率最高呢，当然是复制，你想想一定是复制啊，对不对，那个呃复制算法为，什么效率高呀，因为它只有五个活着的，你只用把这五个诶给复制到另外一块区域里头去，是不是就可以了。

所以年轻代里面采用的算法叫做复制算法，但是这个复制如果说你把年轻带一分为二，浪费空间，浪费的太多了，尤其是你想想我要复制过来的这块空间只有五个对象，我用得着那么大一块空间吗，用不着。

所以这个时候它的算法是怎么做的，是这么来做的，这里产生一个对象，然后如果经过垃圾，会说他还活着，他会被复制到另外一块区域里，这块区域叫做survivor，叫幸存者s0 s1 s。

1s2 from to说的都是这块区域，不管它叫什么名词无所谓，总而言之，复制到一块相对小的区域里，为什么他小就可以，因为它活着对象很少好，这块还能跟上的，给老师扣个一，我我会我认为比较简单。

对你来说未必未必简单啊，就是它在中间的设计为什么这么来设计，就在于这儿，你会发现呢，它80%的区域年轻年轻在里面，80%的区域都叫伊甸园区，10%是死，外边去。

另外的10%是另外一个survivk要这么来做的，ok那有同学会说了，那为什么需要两个斯莱克啊，很简单，因为他除了经历这次复制之外，还要经历下一次复制，什么意思，看这里，这是我们这个对象。

比如说我们整个对象啊，扭了五个对象出来，然后一次回收干掉了四个，只剩了一个活着的，这一个活着的会被我们复制到一个sler里面，接下来把整个伊甸园区全部干掉，它又可以重新使用了，特别爽。

连连续的你可以分配好多对象，一次性的，后来又来了五个对象，然后呢又被干掉了四个，只剩一个活着的，同学们，你们想一下，我下次再回收的时候，我是不是连这个对象在一块回收，如果这个对象被回，收了他们会被干掉。

如果这个对象不会被回收，注意你还能往自己的这个号里面来复制吗，你没法复制，你得去哪儿复制呢，你得把这两个活的对象都复制到第二个s vivo，接下来把这个和这个一块干掉，下一次再开始的时候呢。

把这个活着的又复制回来，然后呢把这个和这个一块干掉，你会发现这两块区域同时使用的只有一块，浪费的空间有多少，只有10%而已，不像原来一分为二，浪费50%来，这块能听明白的，给老师扣个一对。

默认比例811，但实际上jvm调优，我们讲jvm调优，是什么东西，jvm调优就是可以调整这些比例关系，你要说年轻代默认比例对，跟老年代一比二，但是如果说你那个呃你本身你的算法产生的年轻的东西比较多。

老年的东西比较少，这个很简单，你就改成二比一都没关系。

系列 1：P38：美团面试JVM七连问：3.对象在内存中如何分配？ - 马士兵官方号 - BV1mu411r78p

好了能听明白的，如果还没听明白，我给你一个动画看，仔细看一个对象从出生到消亡的过程，它到底长什么样，new一个对象最开始产生放在站上，当然这个先略过，这是一个细节，这个先略过，它会首先进入到伊甸园区。

进入到伊甸园区之后呢，如果他还活着，复制到s1 ，如果下次还活着，经历一次拉圾回收之后，还活着复制到s2 ，还活着又复制回来，还活着又复制回来，一直到年龄够了，进入到老年代为止。

当然老年代他又被回收掉了，那说明什么，他就被被干掉了，就结束了，从出生到消亡，大概是这么一个过程好，这会儿还能跟上呢，给老师扣个一啊，可以可以继续的，所以下面呢我就给大家伙补一点这个知识啊。

下面我来讲对象怎么分配的过程，这个过程是这样的，仔细听认真听，当你刚刚开始new一个对象的时候，首先会尝试在栈上分配，有同学说了，老师一直一直您讲的就是在堆上分配啊，你去问哪个线下的老师，你随便学。

他说的那一对象一定是往堆上分，对是的，但是很不幸的是，如果你能被大厂问道，你就必须把这个过程给说出来，没有一个对象的时候，首先会尝试往站上分配，有同学可能就会说大哥还能往站上分配，这是什么概念。

这是一个站站里面通常有方法的调用过程，好这是一个main方法，关于main方法的局部变量全往这儿扔，能听懂吗，比如说我在main里面声明了一个变量，int类型m等于八好。

这是放在main方法里面的一条语句，这个东西叫main方法的局部变量，它局部变量放在站里面，所以这个小m等于八就扔在这儿，接下来第二个，如果这个main方法调用了另外一个方法。

第二个方法叫m main方法执行到这儿了，还没开始继续执行的时候，去调用了另外一个方法，这个方法进入到这里面好，这是这个方法自己局部变量的空间，这个一般我们称之为叫战争，叫stack frame。

好不管他这个方法又调用了第三个方法，没关系啊，再进仔细听，当我们明白了这个过程之后，一个方法一旦结束了，你比方说这是m方法，这是n方法，m调用了n n结束了，回到了m继续往m往下执行了。

同学们告诉我一下这个里面怎么处理呢，这里面有操作系统，直接来帮我们管理，直接把它往外一弹，什么叫往外一弹，占顶指针往下一挪，这块空间就废了，好了这个叫做这，大家明白了什么叫做战的或者叫战争的概念之后。

你会发现呢，如果用战争来看管理对象，这里面对象呢放在这里有一个什么好处啊，好处就在于，只要这个战争一结束，扳机往外一弹，我们的对象自然而然就结束了，我需要垃圾回收来参与吗，不需要效率高高太高了。

垃圾回收这个玩意儿是一个咱们系统里面的线程，知道吧，需要这个线程定期的或者找时间来运行，你才能够把这个对象给回收掉，但是如果你的对象放在站里面，你会发现不需要他参与，直接往外一弹结。

束所以当你一个对象可以分别在站着的时候，有什么好处呢，好处就在于网站上一分配，再往外一谈，唉整个对象分配结束，那这块能听懂的，给老师扣个一，当然当你们用了这件事之后，你一定会问。

那为什么不是所有对象全都分配在站上啊，有这个疑问吗，肯定有这个疑问，为什么不是所有对象全部分别在站上，听我说沾上这东西，其实呢，是因为什么呢，沾上这东西，可能他有朋友，我看看他重新跟他说，热热一热。

默认不管他啊，就是说战胜这东西，第一个占的空间比较小，默认是256k，知道吗，就这么大个，所以经常我们遇到stack overflow叫占一出，如果你对象全分在上面被移除了。

还有一个有些对象不能往站上分，为什么，比如说给你举个最简单的例子，这是一个战争，它里面有个引用用到了这里面的一个对象，你这玩意儿能随便弹吗，你往外一弹的话，你好好琢磨琢磨。

我这里面的引用是不是就空指针错了，你弹完了，我找不着那对象了，不就空指针了，所以这里面呢栈上分配是需要有两个标准的，第一个标准的叫做逃逸分析，逃逸分析的意思就是说我看你有没有逃出我整个方法的执行范围。

比方说你for循环里面别人谁也没用到的对象，你可以往站上分，完全没有问题，但是如果这对象被别的方法里面的引用给用到了，或者被堆里面的某个引用给用到了，那你完蛋绝对不可能往这上分配的。

因为你这一谈别的引用就完蛋了，就用不用用不了你了，所以这叫逃逸分析，看看你的生存有没有逃出我们整个的方法范围好，第二个叫标量，替换我就不解释了，只能用最基础的数据类型才能够能够替代的对象。

才能够完成这上面分配，你说特别复杂的，有些引用类型放在上面，不好意思，这上面不能分好，不废话了，了解这个过程就可以来，可以继续的给老师扣个一，好对象怎么分配，这是第，这是第一个第一个过程好。

第二个过程是怎么样的，如果在站上分配不下，就看这个对象是不是个够大，如果是一个特别大的类型，我告诉你直接进入老年代，old old的区域，老年代，当然老年代的话是需要经过负d c叫做全量回收啊。

负几岁之后才会被回收回收掉，还有同学马上就会问老师，这个个够够不够大，是什么意思，多大是大，听我说这位m调优里面你完全可以用一个参数来控制，叫max genuine threshold。

我在这就不展开了，那现在真的有对象在这样分配吗，这不是废话吗，我给你讲半天了，我就给你讲，再加上分配吗，其实我是可以向你证明的，我只是懒得给你证明了而已啊。

战场分配。

老鸟愿意把这小程序拿走，而且呢把这些个参数都给我打开或者关闭，仔细实验一下，你就会知道哦，确实有战场分配这个概念不展开了好吧。

可以不展开吗，可以同学给老师扣一，我们继续不，可以同学给老师扣7652。63的开根号，最后得到的结果值，ok大家伙都觉得都可以。

那我们继续，哈哈哈哈哈，开个玩笑啊，看你们有没有在认真听课，我看这里他因为因为因为这东西呢细节太多，它有好几个参数，像他必须要把他的战役战役出给它关掉的话。

怎么做呢，就是逃逸分析的关掉，做逃逸分析，你必须得把这个参数给它关掉，还有一个呢必须关掉标量替换，还有一个呢必须得关掉u t r a b a thread。

local education buffer，这个我一会讲给你听，ok看这里啊，接下来我刚才说它个儿够大，直接就进入到老年代了，那它不大不小，又不能在站上分配，这种分配在哪。

这时候才会正式的进入到我们刚才讲的那个过程，进入到哪儿去呢，进入到了伊甸园区，伊甸区啊，回想我刚才给你讲那张图，但是有同学马上说说老师怎么前面还有一步啊，对这部叫做尝试在县城本地分配，什么意思。

这tr ab的全称，它是这几个单词的缩写，thread线程local本地，cation分配啊，buffer缓冲区叫县城本地分配缓冲就叫请跟我读，跟着我读。

the location buffer要读出那种英国流氓音了啊，reallocation buff买logo allegation版本，阿三的口音也可以，我看不开玩笑了，就是县城本地分配。

这到底是什么意思，认真听，如果说我们呃一个程序开始之后，好多个线程开始往那个伊甸园区开始分配对象，注意是好多个线程，那么大家想一下，你如果想分配好这个对象的话，必须得做线程同步，大家伙都看上这个位置了。

谁抢到算谁的，各个县城之间的同步必须得做好，做到位才可以，这点很容易理解，但是如果上来就给先生做同步，这个效率一定高不了，所以呢他在前面加了这么一步优化，这个优化指的是什么呢，什么意思。

这是a线程的空间，这是b线程的空间，a线程要分配对象的时候，优先往自己兜里装，b线程优先往自己兜里装，不会先用公共区域，先在自己的卧室啊，往往往往往里装，只有卧室不够使了，再去那个客厅里面去抢抢位置。

所以说你自己往我自己兜里装，你还需要线程同步，吗不需要，所以这个效率就又变高了，ok这个东西呢叫three local election buffer，如果大家感兴趣，gm调优里面这块区域也可以调。

但是这块区域本身就分配在伊甸园区，所以我们说对象在这块区域，不管你开没开启slogo啊，最终都是在一甸园区进行了分配啊，这块能跟上的可以继续的给老师扣一咳咳，这个yn代表啥，这个y叫yes。

这个n叫no，我们在这个伊甸园区为了伊甸园区之后，回想我们刚才执行的过程，那就会说清楚一点，被清掉了，那就直接结束了，如果没有被清掉会怎么样啊，回想一下是不是进入到我们的s一去了。

s一区又经过一次垃圾回收，如果被清掉了，那就又结束了，如果没有被清掉，就看你的年龄多大，如果年龄够了，是不是又进入到老年代了，如果年龄不够，会进入到s2 区，如此的循环往复，好抓图对象怎么分配的过程。

我用一张动画给大家画出来了，动画我画了两个小时给大家演，示完五分钟，讲一门好课，比较辛苦的，不是那么的容易，这张图啊，现在美团的大概有几个问题，我们现在能回答了，朝烟第七个问题，你可以回答了。

object o等于new object，内存中占占多少个字节呢，16个对象怎么分配呢，唉首先在站，然后在县城本地e甸园区o的区域中间呢，有s1 s0 s一互相之间的复制过程，对象怎么定位呢。

直接和间接两种方式主要是体现在垃圾回收的区别上，mark word class pointer啊，synchron，还有一个还是go的信息，对不对，四部分，mark word class。

pointer，instant，data和ping到现在为止，34567减完了，09：06，速度还可以吗，如果说那个时间充足的话呢，我会给你讲里面的好多好多细节，但时间不充裕，有些细节我先错过。

比如说class pointer，本质上这玩意儿呢，虽然说你你你你你认为啊，class pointer，这玩意儿啊，虽然说你认为呃它是一个一个一个四个字节，但实际上呢这里面有开启压缩和不开启压缩的区别。

这里面还有超过32g内存之后自动失效的区别，这里面比较复杂，我就不展开了，而不管怎么样，听我说，起码34567，我能打出大概来了，对不对，下面我们来聊一和二，每次讲一和二比较头疼。

所以我们要留足充裕的时间来给大家讲一和二，好可以继续的来给老师扣个一啊，该进广告了没有啊，我没有想打广告的，我们讲第一题和第二题，第一题和第二题是最复杂的，我尝试讲给你听。

第一题呢叫做解释对象的创建过程，什么叫对象的创建过程，这东西呢讲起来呢并不是并不难，我直接告诉你，我我先给你讲结论啊，认真听对象的创建过程什么样的，其实对象创建过程比较简单。

就object o等于new object，他首先往这块空间里头，你有一个对象出来是吧，刚才我们说过这个对象里面内存布局了。

系列 1：P39：美团面试JVM七连问：4.对象的创建过程 - 马士兵官方号 - BV1mu411r78p

你听我说对象的创建过程实际上它是分成三部分三步构成，如果大家会想了解一个对象的创建过程到底是哪三步，你做一个小小的操作，这个操作这么来做，这是刚才我们这个小t对象删掉，我们就执行一句话。

t小t等于new t，其他什么都不执行，跑一下的小程序，然后接下来我们去观察这个小程序所生成的字节码，这是什么意思，就是java语言的汇编代码，class字节码它到底长什么样。

我们来看怎么看view show by code，看它的生成的字节码，或者是使用一个插件，这个插件呢叫j class library，我喜欢用，这个插件。

这个插件叫robo with the class library，大家来看，他会帮你把你整个生成的class文件全部帮你分析一遍，生成的方法里面，main方法在它里面的代码到底长啥样，就在这儿。

这里面有个static class里面什么的，稍微复杂了一些，这样我把代码呢再写的再简化一些，看这里，因为这里头有一个interrupted deception，我把代码写的再简单一些，就这么简单。

object o等于new，object跑一下，好我们再来看它生成字节码，view是by code with这个class li，方法main方法code，你看一眼它生成的字节码。

生成这个字节码呢大概是有方便手机的，大概是由五个五个指令构成，这第一条指令叫new new指令，六指令是个什么概念，我先跟大家说，new就是new一个对象，那就是分配一块空间，你会发现它掉了一个对象。

这个对象呢就是java object，所以他new的是这个对象，第二条指令叫duplicate，我今天不想给大家讲java汇编码，这是在我这边破里专门讲的，先把这块儿给大家略过，这块比较复杂。

我先把它略过，第四第二步第二步叫什么，第二步叫invoke，special invoke调用special特殊叫特殊调，用特殊调用了一个方法，哪个方法呢，1号1号方法是哪个object的。

initialize方法就是它的构造方法，你调用一个对象肯定要调成构造方法，对不对，好第第三步叫做a store，a store的意思叫建立关联，我一会给你解释好。

这条指令呢叫return return就不管了，所以最核心的指令有三条，分别是new inbox special和a store，来这会儿能跟上的，给老师扣个一。

我下面向你解释这三条指令到底是个什么样的概念，我看这里。

我们解释对象的创建过程，刚才我说了new这条指令啊，就是内存里头申请一块空间，但是大家知道如果一个对象里面有成员变量的话，它的成员变量一定是要占空间的，比方说我们有这样一个class t。

它内部有一个成员变量是小m，我想问你当执行到这条指令的时候，这个小m的值是几是八吗，讲到这儿呢，有一些语言的历史，我稍微给你们展开一点点，老师我呢从最开始的时候，我们讲这个语言里面的怎么说。

就是讲这个讲这个讲这个呃，c加加语言啊，所以还是讲c加，后来讲汇编，讲c然后一直讲到java，讲了很多很多种语言，原来在那个华中科大就是左老师的母校啊，曾经讲c加加的时候，同学们都跟他震撼。

我靠原来c加加还能这么讲，认真听c加加语言呢，它也能new对象，这个大家知道c语言其实也能new对象，无非就是分配一块内存，把那个内存里面好好来组织一下就可以，但是听我说，我想问大家一句话。

如果在c加加里面，或者在c里面，当我们new出一个对象来的时候，它里面有个成员变量小m我想问你这个m的值最开始是几个，大家能知道吗，如果在c加加里面new出来一个对象，int类型的这个小m的值会是几。

怎么这么多说零的呀，这都是没学过，有没有学过c加加的，跟我说一个说零的，明显是没学过的，没学过c的，这东西叫做遗留止，遗留指能听懂吗，什么意思，什么叫遗留之啊，遗留职的意思就很简单。

就是上次有一个程序在这里面用过了一个数值，注意我们说这块区域又可用了，它只是做个在这里做个标记，说这块区域又可以用了，分配一个对象，往这一分配的话，上次留下的里面的是值是几。

这个m就是几上次用完啥这东西就是啥，所以这是遗留之，ok你前男友的吻深深的印在了你的嘴唇上，所以你的新男友印在了你前男友的，怎么这么乱啊，不说了啊，就是总而言之呢，它中间没有一个renew的过程。

ok它就是一个有一个遗留值在这里，所以遗留值就会诞生一些安全性的问题，为什么会有安全性问题，比方说这个地儿正好是个密码，你上来之后，你m等于几等于你的新程序可以直接访问这块内存，直接拿密码了。

我的天大家都知道那个汇编啊，c啊都能做什么东西呢，做逆向对不对，逆向怎么做，就是分析里面的，现在正，在跑的那个值到底是多少，直接给他改过来，正是由于这些安全性的问题，java是怎么做的呢。

java是这么做的，当我们列出来任何一块内存之后，它里面有个成员变量都给他复成默认值，所以像int类型的默认值零，波尔类型的默认值false，引用类型的默认值空o所以当我们new出来一个对象的时候。

它里面的成员变量注意是默认值是几是零，它并不是等于八的，来这块能听懂的，给老师扣个一，对他先清理了一下，等于你交了个新女朋友，他实际上把自己renew了一下，把自己遗留。

她前男友遗留的各种各样的问题呢都从身上清理了一遍，能听懂吗，所以你得到的是一个崭新的女朋友或者男朋友，开了个玩笑好不说了，所以java比较安全，大概就这个意思好。

那中间这个inbox special只有调用完构造方法之后，这个值才会被我们复制成为八，原来是零，后来它就变成八好，第三步叫a store，我来解释，看这里，第一步。

当我们执行到new new这一步指令的时候，它里面的值，执行到invoke special的时候，这个值才会变成八，那下面那个a store的意思很简单，这个小t和我们这个对象建立关联。

所以对象的创建过程有三步构成，第一步申请空间设默认值，第二步调构造方法，设初始值，第三步建立关联，很简单，所以第一题也特别简单，这是解释对象的创建过程，半出的这个题非常的简单，但是第二题就超级难。

每次讲这个题呢都都比较费劲，但是也没有办法不讲，既然承诺给大家讲，给大家听好听，我说要讲清楚第二个问题，我们先来聊一个触及灵魂的问题啊，想找个成员，需要掌握的底层知识啊，一边啊。

稍等啊，我还是得要ppt给大家演示，不然的话会比较费劲啊，听我说啊，我们现在先问大家一个小小的问题，这个问题是这样的，他说程序是真的按照顺序执行的，这是什么意思，认真听，比如说我们现在有两条指令啊。

或者有两条语句吧，说x等于x加加，或者是x等于一，y等于一，这两条指令啊，这两这两条语句到底是一定是程序真正执行的时候，是一定是先执行它，在执行它吗，一定是先执行他在执行他吗，我先说结论，结论叫做未必。

结论叫未必不一定，什么意思，就是在你程序真正开始执行两条指令的时候，很有可能是后面你写的指令先执行前面写的指令后执行，我们先我们先我们先记住这个结论，然后我们再来讲为什么原因呢，其实很简单。

我稍微给你解释一下，你就明白，比如说啊我们的cpu执行指令的时候，它的速度非常快，它是内存访问速度的100倍，如果我们现在有两条指令，第一条指令呢是去内存里面取的数据。

第二条指令就是cpu内部的一个加加操作，某个寄存器加了个一，那大家你想一下，如果说我们，强制按照cpu按照这两条语句的顺序执行，强制按照他按照顺序，那是不是会造成这么一个现象。

当我的cpu执行这条指令的时候，我发了一条指令给内存，我就得等着内存大概100个时间单位之后，就我cp就在那歇着，你懂吗，等100个时间单位等你回来了之后，我才能继续执行，第二条，这个大家能听懂吗。

就好比说我们那烧个水，想泡个茶，我烧完水，我必须等得等得等水开了，我才能去拿茶叶，洗茶壶，洗茶杯泡茶，所以cpu怎么能容忍这样的浪费呢，所以一般来说它是可以进行优化的，怎么进行优化呀。

软件优化优化的办法就是我烧水的时候，我同事就开始洗茶杯，洗茶碗不就得了嘛，所以我在发出这条指令，等这条指令还没有回来的时候，我就开始执行下面的指令，下面的指令挂机先执行完，等什么时候这条指令回来了。

我们再继续往下执行，唉这块能听明白的，给老师扣一，所以在你真正开始执行程序的时候，有可能是诶后面写的程序先执行前面写的程序后执行啊，有同学说能不能证明时间关，系我就不给你证明了，我告诉你。

我写成这个程序完全可以证明出来，vip呢我专门给大家写了证明，在这我就不单独写了，因为这个过程呢也相对复杂的解释半天，因为后面还有很多事要做，所以我们先跟大家说说清楚这件事，程序不一定是按照顺序执行。

当然有的同学呢可能会说了，说老师这事儿不对呀，你想想看，像这样的两条语句能随便换顺序吗，我想问问能换吗，这肯定不能换，这换了顺序，比方说原来的x值为零，就换了顺序，最后的结果是不对的，你现在等于x加加。

最后结果是二，你先按x加加，最后x等于最后结果是一，这能对吗，这不行，所以大家认真听我讲，程序什么时候能够乱序，最终的一条规则叫做保持，只要保持最终一致性就可以，什么意思，注意这里指的是单线程乱序。

单纯乱序的意思是，只要在一个县城里面，这两条语句随便换，不管你怎么换，换到最后最终的结果是一样的，最终的结果我们内存里面是不是这块x等于一，这块这块y等于一，无论你怎么换，无所谓吗，x等于零。

y等于y等于2。5，随，便换对不对，所以前面两条语句叫做没有产生依赖，你就可以随便换，唉别的语言也一样，对没错，来待会儿能听明白的，给老师扣个一，所以说程序不一定是按照顺序执行的。

那到底呃什么样的东西可以换顺序呢，反正保持最终一致性就可以，那如果我讲了这个问题之后啊，我想问大家一个小小的问题，这是一道面试题，也是一道面试题，比这道面试题稍微容易一些，我看看能不能打得出来，看这里。

来看这道题。

为了方便手机，等我把它复制一下，放大。

是个体贴的男人啊，仔细看，来看这小程序，我们有一个类啊，这个类呢叫t03 ，然后呢呃它有一个成员变量number等八，然后呃在我们new t03 的时候呢，启动一个线程。

这个线程呢是打印this number，让它启动，接下来呃我们在main方法里面new了这个对象，诶，你可以想一下，我new完这个对象之后，一个线程启动，然后打印这个南门等八。

来告诉我一下这个程序有没有什么问题，有没有bug存在，有bug吗，好这个程序呢叫做著名的this溢出问题，它叫做this escape这个单词，这两个单词this escape叫this e出问题。

这个就是这句话是什么意思，为什么会产生这种问题，你仔细听啊，同学们，你们回想一下，我们new一个对象是由三步构成，记得吗，new一个对象的时候，这里我们new了个对象，第一步呢是溜了a6 了一半。

刚刚申请完空间，这里面的number值是几啊，是零好，我假设我刚刚用了一半的时候，我另外一个线程启动了，另外一个线程启动了，我是不是就能读到这个中间状态啊，这个大家能能理解吗。

我这对象我过了方法还没执行完呢，我这县城是不是就已经启动完了，我现程启动完了之后，ok我是不是就读到这个中间状态了，所以你读的时候，这个this is number是有可能输出为零的。

虽然你做实验很难做出来，但是从理论上来讲，这个this只构建了一半，你就把它拿出去用了，这个叫this溢出问题来，这个问题听懂的，给老师扣个一，这个面试题相对简单。

但是美团的这道题呢实际上是相对非常复杂的一道一道题，我们翻回头来再来看美团这道题，美团这道题呢它是这么来问的，他说d cl要不要加volati呃，我我先问大家，dcl用我解释吗。

估计得解释dcl要不要加快脚，excel d cl是一种编程模型，用的特别特别多，需要解释的给老师扣，二，不需要解释的扣一，看这里啊，我们来解释d c l，这就打开我另外一门课叫设计模式。

design patter，设计模式，那我们来看这个设计模式，这门课里面我讲了一个单例模式嗯，首先解释什么叫单例，这个我就不问了，因为有同学真不明白什么叫单立减，最快速的解释。

单例呢就是保障某一个类的对象只能扭出一个来，最简单的实现方式是这种，比如说我们有一个对象major 01，然后呢我我只能允许你有manor 01的一个对象，不允许有多个对象，那我可以上来二话不说。

我先把自己的一个对象给弄出来，major 01，instance等于new major 01，同时把构造方法设成private，别人永远谁也弄不了，只有我自己能new，那当然了，我这60来个对象之后。

别人怎么用啊，我提供一个方法，这个方法叫get instance，然后呢return你在后面用的时候，不管你调用了多少次，这个方法你拿到的永远是同一个对象，来这小程序简单读一下。

读明白这个程序的基础之上，我们继续往下探讨，这个东西呢叫做单例模式，这种实践的方式叫做恶寒式的单例，上来二话不说，非常饿，二话不说，先把它尿了再说，这是你的老婆，你的老公husband，husband。

从法律上来讲，即即便你有一个class叫husband，但是法律上来讲，你只能有一个husband，有且只有一个，不然你就犯罪了，你重，婚罪，但是呢如果呃如果这个class叫做boyfriend。

就是你的男朋友，那你理论上你可以有多个，虽然说法这是法律上起码不会治你罪，所以有的时候我们是需要单例模式，就是你从语法上来直接给它规定好，就是他就只有这一个only one，就这意思好了。

呃当你理解了这件事之后呢，这个单例模式比较简单，但是呢这个单例模式的写法上会稍微有一些麻烦的地方，有人挑毛病，毛病在于哪呢，同学们，你们想想我有没有husband，有没有wife，二话不说。

先new一个出来对吧，我我我，我先先先先溜一个出来，但是我还没用上呢，我还用不着husband呢，我还用不着wife，你给我扭出来，不是占空间，占地儿，我还得养他，还得给他吃饭，累不累。

我能不能什么时候我想用的时候，我直接调get instance的时候，就表示我想用了，我想使用这个对象了，你再给我扭出来啊，这个简单对不对，这个写法特别简单。

就是我们的get instance方法里面判断一下嘛，如果instance等空，然后给你扭出来，那是那意思就是说如果你不为空，说明已经溜过一遍了，就不要再用第二遍，直接return就可以了。

这种的叫做懒汉式，当你听明白这件事之后，懒汉式也有它的问题，问题在哪呢，在于多线程访问的时候，你很可能拿到的不是同一份husband，什么意思，同学们，你们仔细想一下，现在有100个线程。

我们同时调用get instance输出它的hash code，它会是一样的吗，不会往下看就知道了，游戏中间我sleep了呃，一个毫秒，让他让这个程序呢把这个问题暴露的更加快啊，看这里。

你看这个hash code明显好多个嘛，对不对，好多个完全不一样的，所以呢在多线程访问的情况下，你这种写法是有问题的，来这块能get到的，给老师扣个一，保证不了能力，对没错，嗯好当你保证不了能力之后啊。

你该怎么做，解决方案应该是非常的简单，上锁不就完了吗，直接二话不说，在这个方法之上上把锁，synchron，这太简单了是吧，上把锁你放心，上把锁就代表着什么。

上把锁代表的是只有我一个线程执行完整的代码的时候，另外一个线程才可以开始这段代码，你知道吗，就是原来的那种并发已经变成了序列化了，所以你想想看啊，你第一个线程执行完了，同步好了，无论如何。

第二个线程再来访问的时候，这个instance一定不会空了，所以呢他拿到的永远是你弄好的，那个对象只要有你new一个就可以了，当然这是上锁，我就我就不给大家看结论了，这个肯定没问题好。

当你上完锁之后带来的问题马上又出现了，这个问题是什么呢，这个问题在于，假如说你这个代码里面有一些业务逻辑，那么这些又逻辑跟你这把锁实际上关系不大啊，从数据库里读一些数据展现出来。

你说跟上把跟这把锁有关系有多大呢，不大，你的锁的力度或者锁的范围过宽了，这个一般我们称之为critical section，叫做过宽了啊，叫做临界区过宽，这个连接给我关了，就代表你效率肯定低嘛，对不对。

你执行一段代码，你上锁的代码你肯定是执行的越快越好，你加了很多不必要的逻辑，太浪费了，那这时候怎么办怎么办呀，同学们，简单把所有的力度变细就可以了，怎么怎么变细，怎么做，很简单嘛，把业务代码放过去。

哥们儿，我就不锁你了啊，你这个互相之间同时访问没有问题，上来判断，if instance等空，唉，如果你为空上上完所有对象出来，那么如果不为空，直接拿来用啊，很简单，来这块能跟上的，给老师扣一。

我讲的速度还算是挺快的，good不错，队长说明你这个基础还可以啊，凑合我我我们继续聊，我想问大家一个问题，这段代码有没有毛病，那能不能够保证最后的数据一致性，可以吗，来看结论，找一下。

在这里我们最后看看他最后输出的结果是有多少个对象，你会看到啊，你会很明显的看到拿到的绝不只是同一个对象啊，中间有三二结尾的，也有264结尾，为什么会这样呢，我上了锁为什么不行呢，其实很简单。

问题出在这儿，我们简单思考一下，一个线程过来的时候，判断instance等空等空吗，等空没问题，一个线程先暂停，第二线程过来的时候，判断instance等空等空吗，等空好，第二线程开始上锁，锁定没问题。

因为没人跟他抢，锁定完了之后，new对象这个对象已经弄出来了成功，然后，是所释放，把锁释放掉，好到这个时候，第一个线程继续运行，注意第一个线程已经判断完了，第一个线程申请上锁，能锁定吗。

可以为什么第二个线程已经把锁释放了，锁定又new了第二个对象，所以已经列出来两个了，因此你拿到的未必就是同一个，这个问题主要出在哪儿呢，主要出在这里，好了，终于诞生了这种写法。

这种写法就是著名的dc l的写法，我们来看这个d c l的写法和上一段代码区别在哪，很简单，当我们一个线程判断完它等空之后上锁，上完锁之后再判断一遍是不是依然为，空你交了你女朋友了。

你判断了你确认了他没有和前男友藕断丝连，好在你结婚的时候再判断一遍有没有藕断丝连，然后再决定领结婚证，就这个意思啊，好了呃，上完锁之后再判断一遍，避免有有其他的线程，已经在这个时间段之内上完锁。

已经把它弄出来，ok这个东西的全称呢叫做double check lock，double check，双重检查锁，为什么要双重检查，这里检查了一遍，是不是等空，这里检查了一遍，是不是等空中间加了一把锁。

所以叫双重检查锁，double jack log，ok这就是dcl的由来，而这段代码理解一下。

我们把这个代码呢，复制一下，方便手机端，我稍微放大理解形成的代码，这段代码就是著名的double check log，很多的开源软件都用它，很多开源开源软件都用的啊，所以呢，呃这个这个以后提tcl。

你就直接脑子里浮现双重检查就可以了，当你明白了这件事之后，我们来看这个下面的这个这个这个程序，我相信呢关于双重检查呢，呃这个同学们会有一些小小的疑问啊，有什么可能会说会这么说，这个以前的同学提过说。

老师啊，这玩意儿有什么用啊，你直接把他删了不就完了吗，外面这层检查有屁用屁用没有，你上来二话不说上锁，然后再判断它是不是等空不就ok了吗，搞定干嘛要外面再判断一下需不需要来思考一下，给大家十秒钟时间。

你好好思考，如果我们把外面那行给删掉之后，会产生什么样的不利的影响，有没有一定有，为什么，同学们你们琢磨一下，如果说啊你是我们假设说1万个线程，现在1万个线程来访问这段代码，那第一个县城已经上完所了。

然后第二个线程上完锁，第一个县城上网所new出对象来了，第二个线程再来访问这个对象的时候，它就已经不为空了，如果说外面这段代码没有这1万个线程，所有的线程，1万个线程。

所有线程都得上一遍锁才能拿到这个对象来用，但是如果外面这个检查有，你会发现只要有一个线程已经把它给弄出来了，那么其他线程只需要做一个简单的判断，这个简单判断呢大概是需要几个纳，秒的时间就可以。

但是你上锁的话，这个消耗的资源就太大了，所以你发现如果有外面这个写法，外面这层检查1万个县城里，只要有一个线程上一把锁就可以，如果没有外面那层建成1万个县城，所有县城上1万遍所，效率不就变低了吗。

这块能听懂，对不对，这个问题比较容易解决，而我们说最难的问题，难的问题在于这段代码有没有什么毛病，你为什么毛病，毛病在这儿仔细听，认真听，我呢还是得把这个代码复制过来，然后。

我看这里，对象过程分三步构成六个对象，这默认值，然后调构造方法是初始值啊。

系列 1：P4：JVM瞬间涨薪3K的操作：4.G1对CMS的修正 - 马士兵官方号 - BV1mu411r78p

整个的标完了之后，由于呢它有很多颜色都已经确定了，所以它再从头再来一遍，当然这个从头再来一遍，不是说从那个哪儿再开始啊，同学们听我说，cm呢是说诶但我们找初步找到了这棵树。

由于这棵树里面呢有一些有可能被我们刚才那个特别隐蔽的东西，给漏掉的，所以呢把这棵树找完之后，cms从头再把这个数再捋一遍，当然由于我找到这棵树了啊，好多垃圾没有被我找出来。

所以这个数呢呃比我们原来从头开始找，那个在所有地方来去找这个数的时候，效率要稍微高了一些，但是，即便如此，它的效率也依然很低，这个大家都不知道大家能不能理解。

就是所以在cc我们cms的整个的整个的这个运行的过程之中啊，它是分成好几个阶段，我刚才没有给大家细聊，主要因为给大家细聊这个东西，你不理解这个算法的话是没有意义的，所以呢它是这样的。

整个cms的运行过程是是这样来运行的，首先初始标记指的是找到最根儿上对象，这是你，这是你女朋友，这是你男朋友，并发标记指的是从根儿上开始找，然后一边找业务线程，一边运行，一边找一边业务线程一边运行。

当我们把整个图捋清楚之后，他再从头再来一遍，重新标记，当然这次再来一遍的主要是哪颗有用的书，那个没用的就不管了，然后再清理，把那些没用的干掉好了，同学们不知道我说清楚没有。

所以cm啊它实际上本质在这里的时候，在这里它依然有很强的一种，很长很长很长的s t w，这是cm的巨大的一个毛病，它并不是像他想象中的那个s t w的时间很短，它的s t w时间依然很长呃。

当然会比那个单线程的多线程的纯粹的从头干到尾之后，然后所有人全停掉，那个的时间要稍微短一些，重新标记是s w的，怎么还会有漏标啊，大哥就是所有业务线程停止了。

只有我所有的业这个这个这个垃圾回收线程在干活，哪还会有漏标，不可能的，好嘞，这就是cms的大bug，cms还有其他bug，我在这就不展开了，来我讲完这个之后。

有没有哪个同学在你们生产环境之中用的是cms的，有没有，我能1年50个，大家都懂了，对有吗，有的扣个一来ocean d ok还有吗，没了呃，朱振文，我觉得应该是有的啊，那个据说现在主流是盘尼酱cm。

这是据谁说呀，余安你是听的，谁说是杨幂说吗，是高晓松说嘛，不会看用的啥，哎赵永光终于提出了个有价值的问题，一会儿教你，遇到丈母娘是吧，哈哈呃，呃所有的小伙伴听我说。

你是可以用cms的呃但是这个cm的调优啊，它特别复杂，cms的优化过程比较复杂，需要你精确地掌握cms的所有的参数，它大概有几十个参数，然后你才能对它进行精确的调优，所以一般我们现在都不太用cms。

如果你内存比较大了，我建议直接挤碗就越过cms，原来不是p吗，p s p o嘛对吧，分带直接干成分区的g one就可以了，好，我可以讲g one了吗，来可以讲g one的，给老师扣一，可以进去的啊。

ok good不错，说明今天小伙们跟的不错啊，内存多大算大，其实cms来说是不超过一个g的，当然它算法本身也是在不断的那种，就是算法算力它也是在不断的发展的。

呃所以有的时候呢你你你哪怕用现在的psp就是纯粹的分带模型的，没准看上去也还可以知道吧，呃实际所就实实际，你得看，那是就是具体问题具体具体解决好吧，我跟你简单聊几晚，然后我跟你聊呢。

g one注意他用的算法依然是三色标记，你不要认为g one有什么新用什么新鲜算法的，g one用的依然是三色，听懂了吧，但是呢呃g one本身呢它这个三色是采用的另外的解决方案。

那么这个解决方案呢叫s a t b，这我稍微要稍微的解释一下啊，呃，大家看这两个就是g one依然用的是三色，但是g one的解决方案呢叫s a t b，它并不是把a变成灰的，不是这样的，它是干嘛呢。

它是当，这个引用消失的时候就是b指向d的引用，消失的时候，它是在这个这个这个层面上解决问题，就是壁纸向d的引用消失的时候，把这个引用推到对战，这什么意思，这引用嘛就是有一个对象，另外一个对象。

然后呢他们之间有一个关联，这个关联一旦消失，发现这是灰的，这是白的，好这种这种引用一旦消失，把这种引用给它记录起来，说有一个灰对象是b，有一个白对象是d，现在呢有一个他们之行的引用消失了。

把这个引用记下来，能听懂吗，把这个引用记下来，把这引用记下来，就意味着，是不是就把这个白色的d就记录下来了，它指向的是哪个对象吗，好把这内容记下来之后呢，把这个d就做一个单独的处理，当我们做回来的时候。

发现有一个引用被记录下来了，也就意味着这个d我要单独处理，d单独处理就意味着看看有没有黑的引用指过来，如果有黑的引用指过来好了，我就不把它当垃圾，这过程不知道大家听懂没有，那要不你们想想看啊。

那个站在c m s角度的话呢，它解决的是这是把这个a给标成灰色，但是呢g one采用了另外的方案，我们整个问题的产生啊是两根引用，这个引用消失，这个引用指向所g one呢是采用的是解决这个引用。

是把这个a呢给变成黑色，但是呢呃sorry啊，就是cms用也用的是这这个引用解决问题的时候是打断这个过程，是把这个引用产生的时候，把这个a呢给它变成灰色，但是呢他有毛病有bug，那怎么办呢。

g one采用的方案就是我把这个引用我从这边下手给它记录下来，记录在一张表里，凡是这种引用消消失的时候，全给它记下来，那么当我下次垃圾回收就回来的时候，发现有好几个引用记下。

来了这边引用指的都是白白对象，白对象白对象，那我就查这个白对象，查这个白对象，看看在这个过程里头有没有黑对象指向它，如果有，不把它当垃圾，如果没有，就是垃圾好，这过程听懂了吗，能听明白，给老师扣一。

儿子找父亲，爸爸去哪儿，对他无非是两根引用嘛，整个问题的产生是两个引用同时作用的结果，那cms本身解决的是第一根g one，采用的就是第二个应用人呢，找人干嘛，what，那还是需要看黑对象吗。

他只是说有没有一个黑对象指向它就可以了，如果有指向就ok，好当然其实这里面呢这里面又有巨大的问题，但这个问题要要我要给你讲完的话呢，我估计十点半了嗯，这问题的主要原因啊，其实引用呢正着找比较方便。

就是你通过a点，你说你好好想想这件事儿啊，我给你，我给你举个例子，这个引用啊正着找比较方便，你说a。x等于d，你通过这个x找到d诶，那超级简单，但是你说d有没有其他引用指向d你怎么找思考一下。

我们平时写程序的时候，你会记录着说这个这个对象被哪些引用所指向吗，便利哎呦，我的妈呀，你便利一遍，那可费了老鼻子劲了，就是你通过儿子找爸爸这件事呢，不是很容易通过爸爸找儿子，他都记着呢啊，我有几个儿子。

老大老二老三我都记着，但是呢你通过儿子找爸爸这事儿就麻烦了，你不可能说所有指向它的全都给在这里面记录一遍，这个是不行的，当然这个东西的解决呢，为什么这个方案适合g one呢，主要因为是g one的。

它的本质对这个方案是非常的友好，那么这样的本质是什么样子的呢，我刚才说过，从g one开始就全是分区模型了，往这儿看，这个是g one的分区模型，内存里面它会分成一个一个的小格。

然后呢在这一个一个小格里面还记得吗，我们原来搞垃圾回收的时候啊，我们这个年代满了，整个年代全部干掉，但是内存特别大，个的时候干起来特别麻烦，我把它分而治之，分而治之的时候就意味着什么呢。

就意味着分而治之的时候，就意味着当我们发现诶这个分区里头诶，他比较比较那啥，这个就这个分区里头满了，我只回收这一个分区，我没有必要回收好多好多分区诶，这个分区满了，这个这两个分区满了，我只是回收这两个。

我把这两个分区的，内容给它复制过来，复制到别的地儿去，复制到有用这个其他的分区里头去，然后我只回收这两种，然后其他的分区还能正常运行，继续能听懂吗，就是我一次不回收那么多了，所以这个效率是不是提升了。

我可以一边回收部分分区，另外分区还可以继续运行，这个原理大家听明白了，刚才我讲的这小部分啊，听明白了，于老师扣一，大对象就跨越多个分区嘛，这不就大对象吗，这个无所谓啊，但是这里面也有一个复杂的问题。

今天讲复杂问题讲的有点多，你认真听，这里面有复杂问题在于什么呢，我们假设这是一个分区，当我们要回收这个对象的时候，我得知道这个对象是不是垃圾，知道这个对象是不是垃圾，就得知道有没有引用指向它。

那到底我要是记录下来说我我指向我这个引用是在这个分区里，这个分区里，这个分区里都指向了这一个引用，你说我怎么去去扫描，才能知道这些个都是有用的，我得从头扫吗，太，费劲了，所以在这个分区内部呢。

一般呢有一个专业的名词，在这个分区的脑袋上大概有10%到15%的一个空间，记录了什么东西呢，记录的是有哪些个分区里边有引用指向了这个分区，这个我们一般称之为叫r set，叫remember set。

叫记忆集，这是由于呃g one本身的设计所决定的，就是由于我扫描的时候呢，我得从这个回收这块的时候，我得知道有哪些指向我到底有没有用啊，我得去找这里面找，看看有没有有用的对象指向我有没有从根儿上过来。

对象指向我，包括从三色标记的解，决方案也是我得从儿子去推到爸爸，我去哪儿找他们呢，就从这个记忆集里面找，那这块大体上能听明白的，给老师扣一这个类似于分带的时候卡表的概念啊，但是它本质上不是卡表。

所以由于有这个记忆的存在，我们找的时候呢就没那么费劲了，另外呢我们三色标记，你们琢磨一下，他这种情形并不是很常发生的啊，很很有可能我找的事儿根本没找着，没有这白对象，没人指向他，这是大概率的情况。

所以g one它的效率高了很多，呃我讲到这里的时候呢，我觉得可以稍微给大家一点数据上的东西了，当然这个呢在我的笔记里面也给大家做了记录啊，嗯笔记里呢就给大家做了一系列的记录。

就是关于g one的日志就先不说了。

就比较复杂了。

那个，关于多大的那个内存啊。

到底你得找找啊。

关于多大内存到底应该使用什么样的解决方案啊。

垃圾回收器的内存跟内存大小啊。

呃一般来说呢serial大概能处理几十兆最大。

the palace scaveng，从集上百兆到几个g吧，差不多是这样的，c m s的号称可以处理20个g，但是我没有见过20个g用cm用的很爽的，g one号称用上百个g。

那么z d c的话号称四个t jdk，13呢把它扩展到了16个t啊，就这么牛叉啊，我说这个t啊，这是内存，不是硬盘，你不要把它当成硬盘嗯，但是呢这是一个理论数据，你实际当中得自己做测试好吧。

自己做压测必，须测测的合适再用在这个里面，我们说按停顿时间来说，这个呃cereal和p s我就不说了啊，这个我遇见过的。

我跟你说，我遇见过的，我遇见过的，做金融的，他当时买的服务器叫叫叫什么来着，我忘了，反正那个内存的话上t的，然后他们用的是ps，当时呢金融的服务器又不能随便停，当时一个有一个运算。

就是好长时间之后一个反问过来，他们那个s t w的时间，因为它内存满了，内存很大，满了听懂了吗，内存很大，但是满了，所以他开始清，他用多线程开始清，就你就想象一下天安门广场那么大。

个的一块空间，然后呢你爸爸妈妈，爷爷姥姥姥姥爷几个人就开始在那清多长时间呢，2000多，如果没记错，就是两两天多时间，大概也就意味着55 60个小时。

当然这个肯你们可你们可能没有没没有遇到过2000多。

就是这次卡顿的产生大概是2000多，约几分钟，几分钟算个啥，你你太天真了啊。

大概是2000多呃，然后cms的话遇到的超过几个小时的，也有的是听懂了吧，嗯g one啊，g one，他号称的，你可以设到多少呢，g one号称是200个毫秒，而z dc号称是十个毫秒。

这个200ms的原因呢，就是它分区嘛，它内存不是特别满的时候就马上开始回收，听懂了吧，呃cm s那么长的，主要是还有cm s，还有另外一个bug，它叫做浮动垃圾，然后上升的时候那个老年代不足。

老年代碎片化过于严重，那个bug那个bug才是致也是非常致命的，一个就是它会造成gms的卡顿。

空间的卡顿时间会更长，特别长，呃我们我我我在我在我在讲课的时候呃，有一个叫smile的同学，然后他们用的是那个gero，炙热服务器，然后去给全球做服务，当时用的时候就经常的天天的福利c就是内存不够。

内存不够回收，内存不够回收，内存不够回收，就就干这事儿呃，然后呢我记得他们那个服务器是十个g还是多少来着，我忘了呃，然后用的就是cms，说卡顿的时候卡几个小时，经常的事儿就一个月必卡一次。

一个月必卡一次。

所以由于cm的这个bug的存在啊。

我告诉你，首先第一点呢不建议大家用c m直接直接g one啊，后来我叫他调优的时候，后面我给大家讲讲讲调优就交调优的时候就建议他直接g one了，第一扩大内存，第二换g one。

g g one的那个那个那个那个垃圾回收器就搞定了啊，就这么简单呃，然后呢呃这个cms由于它这bug存在啊，虽然它1。4就产生了，就诞生了cm s诞生1。4，但是一直到后面都没有转正。

就是没有任何一个jdk版本。

它的默认垃圾回收是cms能听懂吧，就是他自己也也也也意识到这，个东西是有bug的，没有任何一个jdk的版本默认的垃圾回收器是cms，但是呢不意味着cms不重要。

因为从cms开始真正有了concurrent这个概念。

可以说他就是那个承前启后。

继往开来，就是淘宝之前的意趣。

就是被拍死在沙滩上的那个前浪，好嘞。

那你们还想听cdc吗，你们是想听z dc呢，还是想听我们我们来个实战呢。

我简单跟你们说说点cdc吧，好不好，cdc是个坑对，主要是呃主要是这个cdc啊，听说就是主要是这个z这些呢它目前要求版本比较高。

呃，11以上，而且11好像还不是特别完善哈哈基本到15吧，可能但是11就可以用了，你可以调cdc，到现在为止呢还不是用的不是特别多。

所以呢我就简单跟大家讲，cdc完完全全的是另外的思路了。

他和这个分它虽然也是分区啊。

但是呢他的这个呃标记这个对象啊。

它和和三次标记就完完全全就不是一个概念了，那么z dc呢它的概念是什么呢。

我简单给，大家解释啊，z d c，z d c全名叫zero pos dc，叫零零停顿dc，当然这属于吹牛逼，不可能零挺灵停顿，cdc号称号称是十个毫秒，如果真是到十个毫秒的话。

其实呢它就跟c和c加加是差不多了，就没有区别了，明白吗，呃但实际当中没有没有那么简单啊，那么cdc所采用的方案呢叫做颜色指针，叫coloured pointer，这过程呢本身比较复杂。

这个我给大家大体解释，这个能跟上就跟，跟不上就算了，我留点时间给大家做实战好不好，看这里啊，cdc叫颜色指针，大家都知道什么叫指针t小t等于6t是吧，我们说这是我们的内存唉，new出来一个t对象。

这是那个t对象。

系列 1：P40：美团面试JVM七连问：5.加问：DCL单例（Double Check Lock）到底需不需要volatile - 马士兵官方号 - BV1mu411r78p

好看这里我们来看这小程序，再看这段代码，在这段代码开始执行的情况下，假如我们现在有两个线程，第一个线程判断为空，没问题，上锁没问题，判断依然为空，没问题，接下来有对象。

接下来我们假设第一个线程已经执行到哪步了呢，已经执行到这步了，这是第一个线程执行的步骤，已经执行到这儿了，回想一下啊，我们new一个对象的时候是三步构成，还记得吧。

这三部分别是new invoke special和a store，好，接下来，接下来第一个线程来了，thread一执行到这句话了，执行到这句话之后，new对象new了一半。

刚刚new了一半6t这里的m值为零，本来是正常值为八，然后呢调构造方法建立关联，结果正在这个时候发生了指令重排序，刚才我说过两条指令之间是可以互相换顺序的，哪两条指令换了顺序呢。

四和七这两条指令换了顺序，指令重排好，再看一遍第一线程过来的时候，六到了一半发生了指令重排序，发生指令重排序，会把a store调到前面了，a store调到前面是什么意思。

t直接指向这个初始化了一半的对，象来这块能跟上的，给老师扣一，啊那么大，你想一下t指相了一半的对象，指向了一半的对象，好正好在这个时候，第二个线程，第二线程也是执行这段代码。

它上来之后先判断它是不是等空，诶，你告诉我，你看这个内存的图，它现在等空吗，懂不懂空t等空吗，不等空，不等空的话，后面还执行吗，不执行是不是拿到这个t就直接拿来用了。

你的男朋友刚穿了一半衣服就出来见人了，不好意思，这个值只拿到了m等于零，你本来正常是应该m等于八的，如果这记录的是一个很简单的一个呃，比如说是那个双11的期间，这里记录的100万单。

然后突然之间的不是一访问，有一个线程访问到的是零反弹，来再来看一遍，仔细看第一个建成new对象啊，判断为空，上锁依然为空，所以开始扭扭了一半，发生指令重排，结果这个t指向了一个半数，第二个线程来了。

先判断吗，判断它是不是等功，一判断不等于空了，直接拿来用，结果第二个线程就用到了初始化了一半的对象，所以这个县城是有问题的，来大家听明白这件事的同学给老师扣一，但这个bug非常的隐蔽，有同学可能会说了。

老师你讲的这事儿不对呀，你synchronized是什么概念，synchronized的可是做了内存同步的，我的天，你做内存同步，你居然说能让我看到了另一半的对象，你不扯淡吗。

有没有同学有这个有这个疑问，synchronized的本质上是一个什么概念啊，它比较复杂，其实本质它的执行比较复杂，就是synchronnet做完的一个东西呢，必须得是内存的，最后最终同步完了之后。

另外一个线程才能看见，我再说一遍，打开我们的那个刚才那段代码，我再说一遍，synchronize什么概念，schronize的概念就是说我下面必须都得执行完了，我把里边的内存呢做好同步了。

我这内存状态改完了，我才会释放锁，其他的线程才能访问到里面的内容，我已经遛完了，你怎么能访问到我中间状态，你不扯淡吗，能听懂我的我的问题吗，来这块能听明白的，给老师扣个一，就是问题在这儿。

现在的问题就在于第一synchronized的执行的线程内部能不能重排序，第二synchronized的中间状态会不会被别的变现成独到，好听，我说我们先回答第一个问题。

synchronized执行到内部的时候，它内部的指令能不能重排序，这件事超级简单，我刚才讲了，能不能重排，取决于你是不是能保证最终一致性，如果能保证最终一致性，随便你排，同学们。

你们琢磨我这个先建立关联，还是说先给他初始化，最终的结果是不一样的呀，所以中间的这几条指令，您老人家随便换，没事儿，所以synchronnet内部重排序是没问题的，认真听好吧。

这里有很多那个别地儿说说法都是有问都不对啊，完全能重排，第二个single内部的中间状态会不会被别的线程读，到会，如果另外的线程执行的是同一段synchronized代码，它一定会读不到。

必须得等一个线程执行完，另外一个线程才能读到，但是很不幸的是，我想问你的第一个线程执行到了schnet里边代码，第二个线程执行的是哪个代码啊，它是在新出来的内部还是外部没有锁定的代码，能听懂吗。

一个执行的是被锁定的代码，一个执行的是没有锁定的代码，我告诉你这两个互不冲突，你里边执行的任何状态，外面都能读到这个东西，就是大家伙都是并发执行的，好了两个问题我就解答完了，就是取决于一内一外的概念。

这个东西呢我我vip课上给大家做个实验的啊，绝对是能向大家证明这一点好了。

现在已经是09：44，我说过我9。50会打广告五分钟，当然还有两大问题啊，就是这两大问题比较复杂，hosport为什么不使用c加加class，到底是对还是方法区，我一会儿给大家讲。

这里面尤其是第二个问题，尤其是第九个问题呃，最近被问到的，你想答得很全的，不容易，ok 5分钟我答一下刚才我这个问题的答疑。

看看有没有明白了，明白了是吧，嗯什么兵法之影，刚才声音有点小，没听清，大哥，你把你的声音放大啊，其他人都能听清，没听清你那边的声音放大好不好，小岳岳比心对，最大的，因为我这边一放大，它会有杂音。

你知道吧，我给你增益一下试试，五分钟答疑，刚才我提的我讲的这些有疑问的地方，你随便问，你把老师问到了，老师这课就可以送你任何问题，关于这位m呢，您老人家随便问好讲讲怎么讲，我刚才故意略过这个结果呢。

你非得非得让老师把这个事给你调出来是吧，听我说要不要加爆了条，必须要加wallet。

什么概念，就是你你在double check里面，double check里面，你要定义这个呃呃呃这个这个代理对象的时候必须要加volatile，为什么要加volt，原因是volt能保障你两方面的作用。

第一个呢叫保持线程之间的可见性，第二个呢叫禁止指令重排序，能听懂吗，叫禁止重排序，就是您老人家那两条指令，不就是刚才换了顺序的问题吗，产生了问题没关系啊，我可以给你禁掉，就禁止重排序。

所以必须要java，当然我怎么是禁止怎么禁止的。

这个东西要讲到内存屏障，今天的时间肯定是讲不完的。

忘了在哪看，说这里可以八有优化，有什么优化，都有哪些指令执行的，一般什么顺序指令，java大概是200多条，执行的什么顺序，一共有八条规则叫不可以冒犯这八条规则，只要不犯这八条规则，其他指令随便排序。

这八条规则我就不给你背了，但是这东西你不需要背过，因为它也比较简单，比方说你new出县城来之后才能执行这种规则，类似于这种的，能听懂吗，你放心，这八条规则里面从来。

没有哪条规定说我new了一半的对象不能赋值，所以刚才我讲的指令重排序是完全没问题，x等于一，x等于会丢掉第一个吗，什么叫丢掉第一个，你说说你x等于x等于肯定会丢掉第一个。

这条规则叫八条happens before原则，如果有兴趣可以百度1下，或者找咱们的vip听老师给你讲，为了给你们讲这个课，我可以这么跟你说，为了给你讲这么这个课嗯，基本上我市面上所有关于这版本的书啊。

基本上那个不是写jvm的人都不读的，人，全给你讲，全全部读完，所以关于这位m您老人家随便了，我跟你讲的这m课呢叫做总结了十几本书，外加上各种问题，外加上jm虚拟机规范给你总结出来的。

j d k8 针对这完美体优化，那多了太多了，这没法说了，就优化太多，因为你们这个优化什么叫jm优化，你看你问的这个问题吧，你说的那个为了中国人民过上那个美好的日子，你说这玩意儿怎么跟你说。

听我说有哪些优化，有些优化是需要你自己做的，元旦老人什么叫做jvm调优，能不能理解jvm调优这件事，就是jvm里面有好多参数，你需要进行调整，调整到你g m的自由状态，j v m的调有呃。

这个参数有700多个参数，这边的参数本身有700多，个常见的调优的大概是有五六十个左右，50~60个，需要你进行组合使用才能调优，我要跟你讲这玩意儿，你说我能给你讲完吗，起码今天讲完。

面试的时候经常这么的优化调整，你问他具体的，你说哪方面的，你比如说执行层面的，还有这种git，就是那个及及及及时编译，还有呃这种c one级别的优化和c to级别的优化，dk 18完美要用沐风。

你问的这个问题是。

美团的这个第九题哦还不太一样，但是也差不了太多，你问的这个问题基本上是每天的第九题，就是class对象是对象的方法去，实际上本质上跟你这有点类似啊，最终一致性判定表述的对它变音器的优化。

系列 1：P41：美团面试JVM七连问：6.马士兵老师Java高级架构师职业规划 - 马士兵官方号 - BV1mu411r78p

好了不废话了，现在是09：50，我说过09：50，我要做一波广告，很快20分钟左右，我给你做完，今天我讲的课程，大概是我们整体课程的小小的一部分，讲这个课，我们前前后后20多位老师，到目前为止。

我们讲了2400个小时的课，就这么狠，这个2400个小时是什么概念，2400个小时，腾讯课堂让随便找任何的机构，基本上没人超过400小时，我们课程2400小时，所以我们课程定价会比其他的类似的这种课程。

定价要稍微贵那么一点点，贵的也不多，是因为我们课程量要比别人大得多得多，多得太多，全网最深最广的课程，从2019年我们登录腾讯课堂，只用了半年，做到腾讯课堂的第一名，在2019年的过程，我们只讲了。

也就是说你想跳槽涨薪，三五个月，涨点薪水，我告诉你，2019年的课都已经足以让你应付了19年的课，你像我今天给大家讲的jvm实际上是gmm gmm多线程高并方案啊，这一部分这种的案例是案例呃。

就是案例式的这种实战化指导调优，这个呢就是你刚才讲的优化的问题，好吧，那么操作系统的原理，网络的原理设计模式等等，我就不给你展开了，当然分布式的东西vs keep live的消息中间件。

四个四大消息中间件，分布式分布式事务单点登录啊，分任务调度等等，还有呢resuper源码的nt rpc a rainbow，docker k8 s mysql的优化，fd fs。

open stic团队的项目的合作，海量的数据就是大数据相关的内容，还有职业的提示软技能，别人课程大概一周直播33434个，一次两小时，基本上大家伙想涨个薪水贼easy。

超级easy呃后来随着我们整个课程体系的发展，有学员会说老师我只有掌握了高中知识体知识体系，但是呢我还没有做过一些比较牛逼的项目，原来一直做c r u d，但是我想进互联网，我们有互联网级别的这种项目。

我怎么办好，我们补了另外一条线，这条项目线呢叫做项目线或者叫项目库，项目库，目前完成的九个项目，从比较简单的大学生级别的项目到比较复杂的我们大厂级别的项目，曹老师，我刚才说过了。

他是作为阿里的一线开发人员，在阿里做了很长时间，按照阿里的标准来开发对应的项目，这个项目呢叫网约车项目，关于这个网约车项目呢，我就在这里呢，嗯如果大家有兴趣可以找去找我们要我们网约车项目的白皮书。

听我说，我们任何一个项目都有对应的白皮书存在，我们任何一个方向也都有对应的特别细节的东西给你描述出来，关于这个项目从怎么去拆分啊，怎么从需求到最终怎么去落地，怎么说，蓝绿发布怎么做，滚动发布怎么做。

实战的这种网关路由怎么做，限流怎么做，这降级啊怎么做，怎么做，报警怎么做，观察第三版呢我们使用的是spring cloud奈飞，第四版呢我们使用spring clou。

阿里巴巴第五版我们使用的是第二代微服务，也就是著名的service mesh服务网格，那么第六版纯音原声就go浪加上k8 s，目前go on的课程也在更新这个里面，那好这一个项目的效果是什么。

不跟你做任何的吹牛逼，就直接给你看效果就行了，搜一下。

我只是说的这一个效果啊，这是传统项目通过网约车找的工作。

遇到企业加价留人，就是那个企业不放了，直接给它加价啊。

然后应届毕业生网约车项目21k的offer，哥们就是一个大专的，如果没记错，应该是一个大专的应届毕业生，那天超老师专门说过这事，项目呢由于超级超级重要啊，只是没技术工作。

技术小白，网约车15k小白，第一次网约车项目薪资涨5k不用干别的，仅仅这一个项目啊，让你长个心都已经足够足够了，尤其是那些c r u d的天天crud，做传统行业业务知识的。

更不用说后面的一级流量的这种项目啊，好加了这些项目之后可以这么说，基本上30万~50万通过这个拿到的概率就很高了，在后面的我们整整2020年的1年一直在讲的一门课，叫做mc的架构师。

这门课是我们整个课程体系的一个提升和补充，这门课呢主要是从实战的角度给大家带到一个架构师的视角，什么叫做实战的角度，再带到架构师的视角，我相信有的同学呢应该是嗯遇到过那种那种ppt架构师给你画个图啊。

前面是防火墙，后面呢有一大堆的k8 s，然后还有一堆的mysql的分部分表，接下来有一堆的那个中间的缓存中间件，但是很不幸我告诉你，你看那个图看了特别爽，看完之后呢觉得自己很爽，但是看完之后想落地没有。

不过在这里在我们真正的教务师课程里面，在这个项目里面，我们会从基本的这种分布式的架构开始，带你来帮你做架构师，搭建最基础的服务，分布式的爱迪生中心配置中心，索集群，事务集群，缓存集群。

网关集群注册中心监，控集群mq的集群，es的集群，分布式任务调度集群，pen的集群，mysql的服务集群，我告诉你一个真正的那种成亿级流量的，超级高并发的这样的一个互联网项目，到底是有多少个集群构成。

任何的一块他都可以动态的扩展，在这里会有咱们专门的老师在带你进行落地，所以这叫落地版的牛逼效果时，我们为什么说，我们帮腾讯建立了整个的t4 到t9 级别的一个课程的标准体系，但是我告诉你啊。

t9 级别在咱们这儿不算什么的，因为我们的课程对标到t 11是问题不大的，对于腾讯来说，当然除了这个实际落地之外，我们还有对应的理论品，理论片，分布式系统的理论基础，从派克从cp定理到base啊。

到各种的高可用的方案，高扩展的方案，高性能的方案到技术的底层的支撑，这个技术底层的支撑呢主要就是一些原理和源码，i o端中高并发，jvm gm ux内核操作系统技术底层的支撑。

为了应付应付咱们建构师的面试，好到算法课，算法课目前为止是可以单独购买的，算法课是我们左程云左老师这一门课400个小时，超过腾讯课堂大多数的其他机构整体的课时，这个算法课从，你最萌新的小白的算法。

开始带你一直逐步地走到我们的进大厂的这种算法，如果想了解细节，我建议你可以到到我们的网站上去访问啊。

在整体算法课里面，从那个最基本的算法概念开始啊，一直讲到什么二叉树递归，快速排序等等，这算是你你你搞完这个之后呢，就正常的，你你你学了一遍计算机系的那个算法与数据结构这门课，但是这门课不算完。

会帮你透彻的整个体系建立算法的概念，亦或相关的基础的数据结构，规定相关的堆，相关的前缀数，二叉树贪心并查集图，暴力城市到动态递归，好到这里的时候，恭喜你，国内的大厂阿里京东叫你开门没问题。

但是你想进国际大厂以及那些个比较看重算法的，比如字节，继续往后学单挑战矩阵b p f p l p r t算法，k m p mineh，莫里斯便利相对少数ac自动机对数器有虚表，卡特兰数四边形不等技巧。

后缀数动态规划，猜中web信息简化，大厂刷题班绳子问题有效，括号子问题，概率调整问题，矩形最大程度问题，放零食方法的问题，二代数问题，ru内存算法，这个可以说是必问的，也是最简单的。

l i u b i l l fu要简单的多，非常不重复，子串o就不一一念了，到立刻最受欢迎100题，以及今年大厂出现的新面这个汇总，这个呢只是我们整个课程体系中的这么一小块儿了，好除了这个之外。

分布式关键算法的支撑，派克索斯zab rap gossip，一直到线性回归，逻辑回归kn为什么要讲这些推荐系统，必须要有没有推荐系统的淘宝网，你能想象吗，底层原理的剖析源码级别的课去随便找。

能超过我们李老师讲的spring源码的，几乎没有，88小时帮你透彻理解spring源码，一把给你干到p7 ，为什么，因为直接给你讲到的就是spring定制化开发这个级别了。

spring vz买alex tom cat，spring boot，spring cloud m q e r k ney houseboard，redis，lindsey和mico等等。

这方面的源码课，我就不一一念了，好吧，基本上就是各种的服务架构的演进，从单体架构到微服务架构，从微服务架构到多级缓存，到分布式，到service mesh，到sevice，到大众台，ok。

在这我就不多说了，那么基础设施的建设就是网络相关的dns s的cd n的基础设施的解决，负载温度异地多活啊，h b d n s的实战等等，番外篇主要讲的是linux。

linux呢由于它内容非常非常的多啊，这个就不一一展开了，核心服务的设计，这里主要讲的什么呢，网关层怎么做，其实说白了就是网关层怎么做，然后呢又有逻辑层怎么设计，缓存层怎么设计，高可用怎么设计这种服务。

智力层怎么设计等等，那微服务的全站主要讲的是spring cloud到奈飞啊，spring cloud奈飞到阿里巴巴到持续集成到它的一些高。

级使用咱们阿里的老师带你讲这个spring cloud的阿里巴巴，这肯定是没有任何问题的啊，然后第二代的微服务snh基本上没有人讲这门课啊，我们是从19年就开始开始讲这门课呃，怎么说呢。

就是这些个叫什么金丝雀部署a b测试，回头发布啊等等，我这么跟你说啊，就是我们对于前沿性吧，我这块想超过我们的其实也不多好讲，大数据的全站从这个呃数据的存储啊，到批批处理，到流式处理，到实时计算。

到数据库，数据库，数据库，数据导啊，深度框架的这种分析啊，离线的分析源码的分析嗯，好，吧不说了，什么离线数仓啊等等，说句这里，好到service mesh的落地实践到我们的人工智能的加成这块。

主要叫做推荐系统到服务质量的保障，csd啊，到测试到运维到我们的一些虚的东西，学的东西呢主要是留给更高级别的人听，你真到了p8 p9 级别。

这些东西也是可以给你加到你的你的你的value的课程内容比较多。

假如说从一个嗯简单一点的角度来跟大家讲一下，因为我们课程体系呢呃相对庞大一些。

我从简单一点的角度来向大家尝试解释，这个课程体系大概是一个什么样子的。

可以这么说，这么来理解整个mc的课程体系大概是分成p5 就业课。

p6 讲新课，p7 的架构和p8 的精英课，源码大师课，is stel的服务网格，可这个呢掌心来说。

那肯定是小case了，我就就就就就就就就不能说了，为什么我们讲新的架构设计是给你举个例子，所以，好这哥们儿是90万年薪概念。

腾讯，你仔细看，这是我们学生里面，你看看腾讯面的什么问题啊，架构设计看了吗，我们专门的3月冲刺班里专门讲了这个架构的设计。

这个钱90万值90万，实战落地的项目可从整个项目课来讲，九大项目今年我预计会扩充到20个项目左右以后，你说你简历上没有项目科学，没关系啊，来咱们这另一个就可以了，就业指导，我们3月的冲刺班，3月冲刺班。

4月突击版，这两个班到底有多牛逼。

还是那句话，实践来说话，大家注意，这是一些同学的聊天记录，我们做了一些那个隐私化的隐藏，但是我需要告诉你的是，你随便去找任何人做掉，对你说我们有任何ps的地方，你随便找你找出任何一个假的来。

我们十倍学费赔给你好吧，全部的利拒绝造假，我知道有很多人能去拿这玩意造假，但是咱们这儿真没有看这里，我就说这个这个这个这个土地班这事儿吧，看了吗，一个月突击涨薪70%，一个月时间一个突击就可以了。

突击40年12k武汉跳北京突击课帮助真的很难，阿丁老师，我们先拿了一个22x14的offer，暂时没有进到大厂，感觉面试突击的劲儿用完了，问的比较深的东西暂时没学到，因为他就干了40天。

就干了一个突击课，你懂吗，其他的什么都没干啊，算满意吧。

突击课真的帮助了很多，这里面呢一共有19条。

我呢就不在这里给你一开了，传统企业突击一点。

五个月涨薪4k ok，好了，特色就业指导课单元的面试冲刺课，这个一般我们称之为叫突击班e的搜索的专家课，ai基础前端课，算法的小白进阶大厂，立刻听我说，叫一次付费，持续更新。

那么除了这个一次付费持续更新的课程之外，我还送你100赠送一期单独拆分的go on的全程的就业课，测试开发的系列课。

大数据就业的系列课，python游戏前端游戏，后端成员英语和数学日常的软件能系列赠送一期一期已经足够，不要把我们赠送的一节课当成一个特别特别那种，怎么说特别水的那种东西。

有时候在老师这儿的赠送甚至会超过一个机构的差不多，总体的课作为go on来讲，也是好吧好了呃，我对于我们整体课程的介绍，我就介绍完了呃，不知道大家听清楚没有，我说过我有20~25分钟左右的一个广告时间。

差不多时间快用完了，我的广告也快介绍完了，这么跟大家说。

我刚才说了，由于我们跟腾讯这边要做那个认证，为增加了很多成本，因为腾讯要请人在腾讯内部帮你做认证，这个成本是很大的，所以呢涨价1000块钱，目标在即，大概今天还是原来的价格，从明天开始涨到涨100。

从明后天开始涨200，你信你就等着看，你试试看就知道，所以对课程有兴趣，今天晚上的送大家20个原价购买的名额，好吧，剩11个，收完为止，请大家呢找到咱们的小姐姐，加到小姐姐之后领优惠券。

在现在的14980的基础之上再减掉2500，2500块钱能听懂吗，最后的成交价12480，今晚剩11个名额，还是那句话，课程牛不牛逼，我不希望呢就是各种的细节让我说的太多。

因为细节上的东西你有很多地方可以去查，第一个我刚才讲的这个x方的图，第二个我们自己的网站，关于数据结构呢你自己去查，第三一个我们自己网站里头有关于mc的介绍，你也可以去查mc内部。

我们给大家伙简单的列举了在我们mc内部讲的关于p5 的知识，像这些知识呢你都可以自己查看，看自己对比到底是一个什么级别，其实这块呢列的不是非常的科学，因为在大厂来讲，p5 和p6 往往是一个职级。

所以你不要认为说你掌握这个预算p5 ，实际上你也需要掌握一定的p6 的知识，p5 和p6 是一个值，给它怎么划分的，应届生你就算p6 水平定级也是p5 ，好在p5 的基础之上，有3年级工作经验。

基本上就到p6 了，那么所以p5 和p6 再强调一下，是一个质地，叫两，个密不可分，所以你想让自己定位在p5 级别，你也p6 的这个内容，你也必须要掌握基础素质素养，高并发的方案，高可用方案。

高扩展的方案，通信和调用缓存中间件，消息中间件，搜索中间件，存储中间件，分布式锁事务，分布式的配置，注册与发现网关路由服务调用负载均衡登录器，分布式的消息链路追踪预警和监控权限控制。

分布式的其他专题安全问题，大数据分析算法能力的深入到这儿，你基本上到p5 级别，想到p7 继续往下看，在这儿呢我就不一一的给你给给给给大家介绍了，咱们的网站上去问。

如果你想了解某一个体系，比方说老师我就想了解go浪，你能不能给我介绍一下，找我们了解需要白皮书，每一个内容我们介绍的都比较细致，但是我要从头给你介绍这玩意儿呢。

我估计有两小时才能把我们整个课程体系给你介绍完。

没关系，我给你打开这个白皮书看看就可以了，这是我们算法和数据结构的，这里目标是混合全能型的人才培养啊，那没有做好目录，不管他那么，进去了就会收器啊。

bbc搜一下白皮书。

挑一个吧。

嗯这最近打开的我来看一下go浪的课吧，嗯在整个go on的第一第一版的课程里面，送大家在这一版里面不够基础，开始到go的各种model，go land的各种优化，主流的外部框架的对比。

这个框架的源码的解读，这框架的入门restful api啊，到那个呃，这这里主要是go web了，然后在go web的基础之上，这是go web的基础之上，项目的单体的应用。

项目的这种go的微服务的应用啊，怎么去这个docker k8 s promi普罗米修斯，然后结合起来做狗微服务的应用，到讲什么呢，到我们的呃呃k8 s的源码的解读，解读到这个深度就是一期go浪的课呢。

基本上也能让你达到go浪专家的水平，所以不要把老师这现在还暂时还送你的课。

你还能薅羊毛的课当成一个可有可无的东西，因为我呢呃是站在一个架构师的角度来帮大家设计课程，一个架构师来讲，如果只局限在说，我就会一种语言。

而不是说能够灵活地运用整个结构啊，什么样的语言该做哪块。

什么样的语言该做哪块，到这种程度的话，你的薪水实际上是高不了太多的，所以想追求那种比较高的薪水，照咱们这来做，照着我给你安排的路线来做好吧，有没有课程的内容呢。

我大概就介绍完了，然后呢别的呢我就不想多说，只看课程效果就可以，我在这里有很多有可能会问我说老师你这这么多的课，我什么时候才能学完呀，同学们听我说，我想问你一句，你从小你从八岁开始开始上小学。

从六岁开始上小学，到现在为止，知识你学完了吗，没有完，想追求一个自己的终身的发展，保持自己的竞争力，现在是一个知识非常爆炸的时代，我那天去通通去听那个腾讯的呃，这个会议啊，咱里面有一个。

他说了这么一句话，我觉得真的挺对的，他说现在这个知识啊，你昨天学完了，今天早上起来很有可能已经被淘汰了，就是这样的所有流程化的中，这个指指这个流程化的东西，就是总而言之，甚至你现在连保持都保持不住。

所以我到现在呢我也没有说想跟大家伙什么事情都做完了，没必要做完，跟着老师扎扎实实地学，我们呢对于你的短期的需求，会做那种定制化的一对一规划，什么意思，你说老师我就想一个月，我想找点薪水。

你能不能告诉我一条路线，根据我的这个自身情况，我又想一个月涨薪，老师你能不能帮我。

有的是入学一个月涨薪70%的，报名一个月，传统企业干净小米了，薪资还翻了倍了，知道吧，老师现在先到哪哪上班，恭喜与美日优先，这怎么还有这怎么还有这种人家每日优先，后天还要过来做招聘呢。

这个咱们小姐姐注意一下，这个这个还是给人家引掉比较合适啊，特别感谢我们已经推推广我们之间的同事和小伙伴了，你想想看，如果说我们课程不好，他会推荐给他的同事和小伙伴吗，我这边面钱给的也不多，然后恶搞恶搞。

但是虽然钱不多，相比之前的工资也翻倍了，你说他得多，凡尔赛，他跟我那说钱不多，但是呢比原来的工资还翻倍了一个月，知道吧，这就是我们课程的水平，offer谁给的offer是这个另外一个人给的offer。

是这个加7万股票综合考虑，所以选了小米给。

就是你想多长时间干到一个什么内容，干到一个什么水平，老师帮你设计一条路径，这条路径给你设计完了之后，你就会少走好多好多弯路，这是我们所能提供的最大的价值之所在，a大家能认可吗，是不是有任何一个行业。

如果有一个牛逼的人带你，是不是得好得得得省好多弯路，能认可的，给老师扣个一，这件事情很难很难被认可吗，对没错，就是各个人的需求情况来给我帮你制定这件事儿啊，还有啊这个你像应届生滴滴的offer。

年薪29万，这是硬件啊，你像那个嗯t3 荣耀的offer，25到年薪的35万，你像这个是45岁的一个女生，涨薪50%，老师真的超级给力，呃这么跟大家说啊，就是海外的留学生学我们课程其实也不少，也很多。

他们会过来，为什么选我们课，因为这个真的不管你是在海外还是在国内，给大家伙的帮助真心比较大，呃最近阿里的收购的那个东南亚的电商也在找我们做内推啊，说你们有没有学生，能不能帮我们推一些。

听我说所有海外的想回过来来就业的，来我们学完直接给你推阿里，当然这是阿里收购的一家企业，东南亚的电商给的薪资比阿里本部给的还高，迫切急需人才。

这个算是比较差的了，这个没办法，因为他这个学历的问题，当地20万美元的offer，当这个人家是在北美了，昨天我拿到第一个offer了，前来还愿哪家的offer，没说啊，这个就给给你盖了而已。

给他咋样满意吗，感觉还挺多的，200k我甚至还没有呃，还没面过过那些大厂一次就过了，算一下，想签就签，牛逼的人才会有更多的选择，1月份报的名。

4月进阿里，这就是我们课程的速度和，这就是为什么很多企业愿意来我们现场做招聘，你知道吗。

再跟大家说一下，24号今天报名，明天老师帮你改简历。

24号也就是后天参与我们的4月份的内推招聘会，4月份参与内推内推招聘会的企业，这么多2021年042020210424的招聘会，现场招聘的企业，京东的一堆，百度的一堆，阿里的一堆，这是大厂的。

当然也有外企的for works，有高有低，我们挑选企业的话呢，也是涵盖咱们学员的那个各种各样的一些特定的情况，不废话了，我的广告就做完了，下面答疑时间，十点半，我会继续把剩下的技术讲完。

各种各种就不用买了，然后我就不给大家做广告了啊，还有六个名额，还是那句话，就是我们呃是真心会涨价，想薅羊猫鸟抓点紧。

就我们这课我跟你说，卖2万都不觉得多。

你就这么想啊，就是400个人家那都不到400个小时，两三百小时的课就卖你6000多块钱，不信你去看啊，多希望你多做比较，我们是2400小时。

目前还在中间，我不想给你拆分了做，你要想买也可以拆分着买，所以随你啊，呃算法是可以单独售出的，出售的大数据就业也是可以单独出售的，到目前为止，这两个已经拆分了，5月份过后。

行我就大概介绍完了，我这广告打的怎么这么没激情啊，mc是啥意思，mc的全称叫马士兵，certified architect，叫马士兵认证架构师，看来主要对手这是这是谁，没看懂，没有对手。

我们的课程没有对手，任何人只是说把我们当成假想的对手而已，但是本质上差不多，希望多做比较就行了，o，马老师需要学一下直播带货的小姐，你教教我，现在是10：21啊，收完为止。

哈哈好吧，对课程有疑问的，对那个对课程有疑问的，对技术有疑问的啊，大家随便问啊，这技术能问到老师的，算你牛逼，对课程能问到老师的，当然你也问不到，哈哈哈，我等听最后两道题，十分钟以后啊，八分钟以后。

十点半我们准时开始啊，下周一面美团。

希望八人都到了，好运啊，我就我就想多说两句，结果还不如打开物料，第一个就是说我们的课程是受到厂商的认可，这一点大家能理解吗，这小伙伴直接面面京东的时候，面试官问从哪学的，就直接说的嘛，我说知道挺有名。

杜远程回答的比较好，当场知道吗，当场直接过的o估计没准面试官也是我们学生，这个有可能呃，所以呢在我们的内推里面，其实有好多厂子呢就直接找到了那个阿里的是最多的，因为我们阿里的老师比较多。

就通过他们往里往里推，成功率都会比较高，你像字节的话呢，就差不多离我们直线距离5百米，这个也是内推的渠道也是非常通畅的。

这是去年4月份的时候，就是我是字节跳动直播平台的研发负责人，看到课程资料就觉得应该有不错的学费退给我，直接安排面试，这是他负责全球所有的，直播平台研发负责人牛逼吗，核心部门我们已经有同学进去了。

这是他的一个工牌，就不展示名字了，在字节的你可以去问一下是不是后缀，是不是叫什么涛啊，就是说我再给你说一遍，内推一线大厂的渠道非常通畅呃，如果是说这种你你的目标不是什么一线大厂，其实我们帮你改完简历。

直接拿去投，效果就已经足够好，不需要你学多长时间，业余的时间，周一到周五，我希望啊我个人希望是你能学到两个小时，像周末的话，我希望你能够每天六个小时，你不需要很长时间的关键，然后你每天一个小时。

你就稍微延长一点嘛，关系不大，其实我觉得我们课程最我我最自豪的一点是什么呢，是短期就比较给力，我不需要像线下的跟着脱产学，五个月，八个月，九个月，一花钱就是三五万，再加上吃饭，甚至都到好好多好多钱花好。

多好多时间你还挣不了钱，线上你看到了吗，一个月薪水翻倍了，o那个，拿了58万年薪，这哥哥呢是传统项目到三家互联网大厂的offer，不知道该怎么选，三家offer日期的硬件的等等等等。

永旺三家offer都将近年薪百万o，报名一个月，传统企业进小米，还是那句话，你记住这一点，老师教你的路线叫做最短路径，叫做捷径，叫做每个人根据不同的情况走的一条捷径，你像嗯说一最简单的吧。

就去年我们一个一个过时的路径叫做6+2啊，这个你看到了吗，6+2干了一半，薪水到六呃，6。5~16。2呢是我们2019年推的一条路线，这个路线叫什么，叫做六个基础课加两个项目叫6+2。

其实呢你如果你想追求比较短的3+1，如果你想特殊的一个情况，你在在在在校大学生6+1，说你大三的7+1+1就是每个人每个不同的路径呃，从一些个我们过去的总结的经验来看，大概呢粗粗的我们画成了18条路径。

这18条路径你可以对号入座，大概是这些大学生等非经济专业的专科的，海归的，冲刺的，外企的，转行的，跳槽的，镀金的，大龄的，非java语言的等等，有的是三家a da，有的是四加油的什么。

还有根据你个人的最终的实际情况，需要了解到你的背景，才可以帮你定制比较科学化的路线，这就是为什么能够有的人呢他的他的他的效率特别特别高，一个月涨薪入职京东，你说这钱花的值不值，你自己琢磨吧。

涨到最低最低的哪怕就45k一年也6万，学费1万多块钱而已，应届毕业生字节跳动，成都5k到10k薪水翻倍，还是那句话，我希，望你们报老师的课是出于效果，而不是听老师说广告打的多花哨。

打花哨这事呢还真还真还真不好不好做，我有时候觉得罗永浩直播带货啊，感觉也没啥呀，发现真的自己要带货的话还是挺费劲的，c sharp转java大概需要多久，如果你是做点是学俄罗斯ring cloud。

干净用油涨了50%。

长点神他不香吗，别卡有的棋不卡，这东西呢你不能叫一个而论。

有的人人家就在乎必须得1米7以上的，你1米65的就别考虑那些就完了吗，天底下我也不说那么多，非得选他们家吊死吗，看学历，大专负债50代职大专生职业第二春，当然这个是这个这个跟学历关系并不大。

它主要是负债，大专生错过阿里入职申通，申通也不错，二线大厂嗯，干满1年再充一些吗，为什么错过了阿里，阿里打了两次，打了八个电话，他都在面，申通正好没接着，这就是天意，这个没办法，你这属于倒霉。

不然真的进阿里了，大专生嘛，大专学历，多家大厂的offer，感谢我们的课程，接触了不少东西，按照周老师讲法，就是认知偏差是吧，经过三周面试，到目前为止收到了不少的offer。

真是想不到大专学历的我也不再只是那些中小型公司。

看我去面试，艾琳大专没工资到就业，薪资翻一倍，刚才那个21k应届生大专毕业，如果你听过那天我们的直播课，这个应届生的这位同学远程还给咱们学生专门讲了，他是怎么拿到这个offer的，同学们是这样的。

学历呢是你短期内改变不了的东西，所以提能力让别人降低啊，企业看来呢来降低你的学历对你的影响，截下屏，然后那个微信打开扫一扫，打开你的图片就可以了，c语言讲什么语言都行，你这还停留在语言呢。

你这个呀我跟你说，你这境界呢就是不涨，我那个教过很多人关于境界的问题，就是你这个人呢能挣多少钱，达到什么样的一个成就，跟你的眼界那绝对是正相关的，你眼界到了，你才有资格享受这个回报，还局限在语言上的。

我再跟你说一遍，boss直聘关于北京的所有的职位的调查，薪资排名第一的叫架构师，排名第二的叫ai算法工程师，这两个是你们将来赚钱的追求，追求薪水，你比方说像这种年薪百万的这种奔着这两个方向走。

有可能会达到，如果不是这样的，你打不着达不到你c语言再牛逼，你给我找一个做c语言的，说普通的一个就是正常的，有一定的比例的人能达到年薪百万吗，记住架构师呢它本身不局限在什么语言。

你说拿一个这种互联网的流行的这种高并发的架构来讲，它前端呢一般我们就称之为叫网络接入层，然后后面呢是我们api的接口层，后面是我们微服务层，在微服务里面呢，我们就中间有什么呃。

这个监控要控制这个降级限流熔断等等，服务治理层，然后呢中间有缓存层，下面有大数据的存储层，数据库层，每一块都可以做扩展，每一块都有n多的产品做扩展，当你了解了这些玩意儿之后。

实际上呢你说这个语言到底是拿go来做的，还是p h p还是java，它重要吗，真的没那么重要，真正牛逼的架构是叫做能把这些架构采用合适的东西给搭出来，这个叫架构式，那这会儿能听明白的。

老师扣个一就这么跟你说，呃其实go语言做这样的架构也可以，java语言也可以，p p也可以，我不知道你了不了解呃，那个我记得阿里有一个特别牛逼的人，从国外facebook挖过来的，他只会一种语言。

就是菲律宾，但是在阿里研究什么东西，所以对他们这种人来说，为为为什么我们课程里讲很多的基础的内容，讲算法，讲计算机的底层知识，你说它跟语言有关系吗，关系其实真的不大，但是为什么要要讲这些基础不牢。

地动山摇，你能站多高走多远，要看你的基础有多牢靠，所以他跟语言没有关系并不大，我们虽然叫java。

以java为主，是这个，你像武汉跳北京40天涨了12k。

那薪水虽然不算很高，涨薪幅度很高的，比如说啊我们说我们说这种涨新的，就就就不说龙湖地产15x12~20x10吧，你说涨了多少。

你自己算吧，36万，原来18万张，360000等于是那个翻了一倍吗，我说找点那个绝对值高的好吧，不不不，找这个这个这个这个绝对值不高的，因为绝对值不高，让你涨个薪水，那真的跟玩儿似的。

你说你1万块钱让你涨到15000，我跟你说，我给你改改简历，给你三天时间，你就到了一点，不夸张。

但是比较难的，实际上你像这种的29天52万，涨到68万，干到80万，等我都学完了游戏，把算法学一遍，拿到80以上应该没什么问题，我们学生就是这么自信，老师教的太好是吧，原来年薪25，现在给51万。

他们公司涨近30%，这算是非常特殊，给他分配了，你们这技术教的太好，也是麻烦事，因为他担心cover不了吗，这是突击一周的面试突击课，20年的毕业生涨了4k，你说我帮你改改简历，让你从1万涨到2万。

涨到15000，你说真的很难吗，反正就看效果，小试牛刀，两个40万的offer，年薪60万的offer。

年薪120万的offer，刚才那年薪90万的我，你总说这是比较高的，有高有低，每个人情况不一样，跟自己比，今年我赚年薪15万，明年我赚年薪20，你就想想，只有他的标题带了牛逼俩字。

其他的都没带，迄今为止最牛逼的学生公司，给了5000万的股票，已经套现，全国游了一圈儿，离职了，然后进了腾讯。

这是他呢给到大家伙的一个小小的建议啊，我在这就不给他展开一一念了，怎么说呢，机遇加努力改变你自己的命运，不要在那天天煮青蛙，在那儿天天打游戏了，这么跟你说，你还停留在让自己不进步。

指望着说我跟这玩个几年，后面呢还能拿到你现有的这种这种待遇，恐怕都不容易好吧，凑个整吧，现在是22：38，不小心时间超了，我们22：40，我给大家讲剩下的两个问题啊，5000万直接财富自由，是的。

每年的理财收入接近500万，他亲口跟我说的嘛，啊想看看他的简历吗，还有两分钟有没有有有没有人想看他中间的某个阶段的一个简历，扣一把衣服扣起来，我看到满屏一，我才会给大家看这个简历。

在我们简历模板里面有一个29岁，年薪120万的简历模板，就是他的，在这个简历里面不需要你聊太多，分布式高并发高可用大数据量的系统设计经验及研发经验，我就直接告诉你，这是整个简历里最值钱的部分。

个人技能不一样了，我们课程里头全涵盖，放心老师的课，让你怼到120万以上，没有任何问题，当然在你没有学完学一部分的情况下，你说从二三十万说我涨点钱啊，涨个百分之三十五十的，那真的很轻松，ok，就到这吧。

已经2。40了，我们讲完剩下的一点点技术内容，怎么还往还带往回吐的呀，是不是有人有人往上增加了，应该是有人弄了之后没付款啊，你签完要抓紧付款啊，我估计是这样的，你的那个优惠券没有领，听懂了吧。

领完优惠券会在这个价格的基础之上再有相应便宜，便宜2000多块钱，还有一个呢需要大家了解的是，需要跟大家说清楚的事呢，现在有一个叫做零元入学的政策，就是你前面如果说你你你你你本身经经济经济比较紧张。

前面六个月不用你付钱，要3月让你把薪水涨上来，甚至你，才开始交第一笔钱。

嗯我们聊完最后遗留的两个问题啊，看这里呃，这么大家说呃，第八个问题和第九个问题呢会相对复杂，这块呢你仔细听，认真听，能听懂就听，听不懂的你就直接帮你打开一个思路就可以了。

看这个思路叫做为什么不使用c加加对象，直接表示java对象，我直接告诉大家答案，这个答案是这样的，c加加对象和java对象的主要区别，这块由于很多人没接触过企业家，我直接说结论能听懂就听听不懂。

就算是因为c加加对象里自带了一个叫做virtual table的东西，这个东西呢叫虚函数表，来学过c加加的人，能不能告诉我这东西是什么东西啊，这东西是实现c加加多肽的关键。

本质上java实现也是通过这玩意儿来实现的，只不过java里面把这个虚函数表挪到了class文件里面，好有没有理解这个虚函数表的，有的话给老师扣个一，有吗了解虚函数表的，嗯rin rin rin嗯。

不懂是吧，不懂就算了啊，总之可以这么说，c加加n的对象里面比java对象多了一个东西，所以如果还采用这种来做这件事的话，那么java对象里面他的它的大小会膨胀的比较大，java追求的叫做紧凑紧凑。

你懂吗，就是它编译出来的class文件，它会非常的紧凑，会追求字节呢相对的比较小，因为原来java设计师在网络上进行传输，那会儿带宽没有闲的这么宽，所以在c加加里面，在java里面设计了两种两种东西。

把这个虚函数表从对象里头挪走，虚数表挪哪去了，挪到了class文件里面，所以，叫做oop class 2元模型，不懂就算了啊，这个问题相对复杂一些，难一些，好，我们来看这个问题。

就是第九个问题叫class，这个实力究竟是在method area还是在hip里面，对java的实例方法都是虚方法没错，所以它的class里面全是虚方法，这个问题这个问题如果说呃一个中小厂在问你的时候。

你就直接class文件肯定是在methoda的，这个不用说了，肯定是在这儿的，但是我告诉你，在一个hosport的实现里面，比方说我们new了一个大o对象，这个对象本身是在class，是在堆里面。

这个对象指向的class文件，它会位于我们的方法去，这个方法就叫method area，但是注意的是，这里的引用指向的是一个c加加里面的一个对象，在这个对象里面又有一个引用。

这个引用指向的是堆里面的关于o。class，所以严格来讲，o。class是位于堆里面，为什么放堆里方便反射调用，方便反射，所以来讲class文件的信息由两部分构成，第一部分是c加加的内容。

这是关于这个class的一些原原数据的信息，第二部分呢是关于呃可以用来做反射的older class的内容，这部分内容放在堆里，这部分内容放在method area里面，好同学们来这块儿能听懂的。

能get到的，给老师扣个一，已经报名了，我升职加薪之路就靠你了，老师你来就是了，老师要让你升不了职，加不了薪，你任何人都不可能让你做到这一点了，就，好了，当然这里面还有一个没get，他哪没get。

你得问出来，我这几个名词你哪没明白，什么地方没明白，比方说我们常见的这种jvm的内存溢出，jvm内存溢出叫做out memory，而这些对外m内存溢出，实际上这里面的对象变多了，内存里面装不下了。

还有一种内存溢出比较特殊，这种内存溢出呢叫做mt space的溢出，有没有听说过permanent generation，永久区的溢出，好这两种东西，messaga，还是用jvm，你随便问问导老师。

算你厉害，就是哪儿没哪儿有疑问，你得你得你得你得说出来冲出来，这么不给面子吗，我这啊抢完了是吧，我确认一遍，我还说呢，这么不给面子吗，口干舌燥的十几个名额，讲不完，有点过分了，ok，什么是放射。

不是放射式反射，我有一个问题，我抢到了，但是我舍友没有抢到，怎么办，那就明天涨100块钱要呗，还有优惠吗，导致内装载三过程加载链接初始化和今天的第一行对应一下嘛，完全可以加载链接初始化。

我vip讲那个jvm的第一堂课就讲了，跟这个是一一对应的，对象创建过程你还记得吗，就是它的成员变量呀，它的成员变量中间有一个半初始化状态，对不对，类的加载过程叫做它的静态变量。

有一个半初始化状态能听懂吗，我一句话就给你解释了啊，静态变量半出手状态，一对一定制化，p8 p9 的课程强加密，我们是采用了国内一家另外一家那个专业专门做加密的，这个加密平台比较特殊。

第一绑定你的计算机，第二绑定你的人脸，就是你看我们课需要打开摄像头，让摄像头看见是你这个人在看，而不是别人，第三一对一的定制化，第四企业过来直接内推招聘课程的含义啊，t4 是什么级别。

t4 很便宜的一个级别，大概20万左右的年薪，第四大概就这样一个级别，老师咱们有内推吗，有必须有，没有听明白，能说小心点吧，老师什么地方没听明白，你说有啥问题你直接问啊，类装载的三个过程。

就是我刚才跟你说了吗，你有一个对象，他有个成员变量小m我这有个为零的状态，对不对，如果这个小m是静态的static类加载的时候，它中间有一个为零的状态，类加载完成之后，它才会变成初始化的值。

就这意思就是一个静态变量和非静态变量的区别，t4 对比p7 不是你不要千万别误导t4 ，离p7 远着呢，内推走哪推推给hr，现场内推推给直接的项目的负责人，腾讯跟阿里系的不一样。

对啊腾讯大概t4 差不多就相当于阿里的p4 左右，p4 到p5 ，像t5 到t几t5 到t t t t t左右，差不多相当于是阿里的p5 到p6 减吧，应该这么说，像那个t9 左右的话。

他们要是p6 加p t减这么一个过程，按薪水来说不就完了吗，按薪水来说，按薪水比较，t4 加给了22k22 k20 多万嘛，正常也没有什么太多问题，计时多少钱，百万左右，老师哪些企业算大厂。

在老师我的眼睛里，大概有12 三家大厂，分别是百度阿里，腾讯京东，美团滴滴拼多多，像最近的话，那么华为蚂蚁嗯，比如说还有像国际的大厂，这个微软，facebook，谷歌，亚马逊这些，这里的一线城市。

西安这边，西安这边，你就找西安那边薪水最高的二三线城市，我们课程的百分之五六十对标你们城市所在的前5%的工作岗位，一二。

35岁五个月涨5k进华为，这个还正好卡在年龄的时间点上嗯，西安的，三个月西安找金时可以带团队的28k在西安已经很好了，我不了解28k在你们虽然算算是很好了吧，应该张老师原来是吧。

三个月在西安涨10k老师的课值值吗。

应该还可以吧。

底层细节还需要慢慢消化，去年做生意赔了几10万，现在面试基本平衡，7月底数学西安阿里的p6 ，我没去p6 面，过了阿里的，但是我去不了自身原因出不了手。

不知道他因为什么没跟我说，反正就就是城市来讲呢，不是问题，就是你的应急能到位了，你觉得城市能够限制你的发展吗，是的，先28列对，那就对了嘛，家养老也不错，作为年轻人，我不知道你多大年龄了。

年纪轻轻的就想养老，我也不，我也不知道我，我这这这还能跟你说啥，作为62岁的，我还在一线拼啊，您这个倒好，年纪轻轻的就想着养老了，哎呀妈呀。

苏州微软在等我，苏州微软，我们好像还真有学生进去找找，我忘了就没了，苏州，苏州，希望20~30，25左右吧，然后简历模板看了，感觉人家是很体系化，周四的时候，20号的时候跟我说。

最近周四的时候忘了周四了，每个月差不多两个offer，还是老师特牛逼，简历没写好，面试都能过，苏州小地方大牛没有到一线城市，指评机组合上海回苏州还涨了5k涨了5000，而且是上海回苏州涨了5000。

还给我们推荐推广的过程，对嗯可能比较认可才会推广是吧，这个就比较他薪水比较低啊，所以那个涨涨到11k就太轻松了，其实工资已经涨到7000了。

基础稍弱的，让你整个心就老师这课来说，稍微指点指点就够了，嗯还是那种就是说大家伙平时花钱的时候嗯，反而是跟大家自己息息相关的，能够给你带来更好的职业发展的这样的一个机会，反而就不花钱了。

我也不知道是你们是怎么想的，这里是再重新再重复一遍，这里是二二十多位来自于一线城市，一线大厂的老师嗯，就是我们这什么竞争对手谁，您老人家随便找找出任何一个机构说。

肯为你花20多位一线大厂的老师来为您对一门课的老师，这课就可以送你，面试太难了，你就拿我们面试突击班，面完就是学完，你都不会不会觉得面试太难了，电视太难说明什么呀，基础不足吗，不够吗，简单吗，22：

56：04分钟，我今天的课就讲到这儿了，有什么需要跟老师交流的呢，你抓点紧，哎呀提前面试我就难受，难受就难受，学到了最后面试官对线，哦看看那个还有没有同学跟老师交流的啊。

当然是说老师做了3年java两年的前端，随便找一个java找找感觉，然后找到了之后操作可行吗，不可行，就你这种规划，你还是找找老师给你好好规划，优化这件事呢比你想的重要的多，规划这件事比你想的重要的多。

有的人为什么一辈子混学历挺好的，混半天混不到城区，有的人为什么学历一般般，但是老师帮你规划好，进大厂就相对容易，就是你的需求，你这个你这个基本不可行，什么情况，嗯自学看天赋，没人带，很慢的。

有学历教你们高分学学瑞说的很对啊，选比基普通21120年毕业生，大概年薪大多数，现在是13个行吗，老师了吗，如果成不了二，老师的钱退你了，就是你现在13，我我我认为你现在是在北京，我们拿拿北京来说。

如果说成不了二，然后这钱直接退，你太简单了啊，上去说是美日经济能不能直接录取，有可能，就你这个我就这么跟你说，你20年毕业吗，你跟着老师这课，这课学30岁左右，年薪百万的可能性都是比较大的。

这不是我说学生说的，找找，完了我就跟你说一下你学生原话吧，就是后悔他他挺后悔，如果从毕业开始学，从毕业开始跟着老师走到30岁左右，年薪百万的可能性极大，原画，211的学历对你来说太轻松了啊。

要学历好的也是很重要的一个竞争竞争竞争竞争点，金道长有希望，40岁16年经验，希望很渺小，希望你，我建议你把你的目标定在掌心上，而不是定在进大厂上。

如果你一定掌心，就相对容易得多，39岁大龄程序员薪水翻了将近一倍，奖金大厂，37大龄程序员，不是这个不是那个37的，37 两个月左右，55万，70万，甘地美团达成，他原来拿55万面积。

大概涨了27%，告诉你仅此一例，我为什么说可能性不高，到目前为止啊，除了没告诉过我们的仅此一例，40岁在想进大厂晚了，没学历只求掌心，当场进不去，没学历你不会补学历啊，这还不简单，不是没学历。

也不是说一辈子就没学历啊，简历模板给你看一眼，42岁，44岁的大专生，年薪100万~160万，这是他的月薪，有同学说人家学历是硕士，人家硕士怎么来的，你要知道这一点，知道吗，扬州大学的计算机大专。

南京大学的自考本科，合肥工大的moba，他的第一专业叫热加工工艺设备，第二专业才叫做计算机应用，实际他是不是第二专业，我也不知道这种这这种的，在以前这时候的这种毕业证都无所谓的事，就随便你随便你写。

保持十几年，从大专生冲到年薪百，你以为就你以为那么容易吗，你不拼能行，我现在就想找个好工作，其实你要好好理解什么叫好工作，这件事特别重要，那么什么叫做好工作，好工作的定义并不是说绝对的年年薪值有多高。

他很多时候好工作的定义在于有一个很好的起点，后面有一条比较光明的路线可以伴随你一直往上升，这叫做好工作，一个起点可能非常高，中小厂到一定年龄段之后，马上没人要开始下降，很多人的规划路线是这种。

找到这种路线就对了，第一份工作一般做多久就跳槽合适，看你具体的收入，看你的目标是什么，这个一般来说要具体问题具体分析，能久一点，一定要久一点啊，坚持久一点，就一定要坚持久一点。

小白学代数据还是java好一些，你觉得java跟大数据有冲突是吗，小白不跟你说了，java跟大数据有冲突吗，你好好琢磨解释这件事可真是够累的，我也不知道为什么。

现在很多培训机构把那个java后端跟那个大数据对立起来就学了，这个就不能学那个，那不是扯淡吗，你觉得一个牛逼的架构是不应该懂大数据，是这意思吗，为什么人家29岁，29岁年薪120万。

了解并使用过had the historm大数据相关技术，使用其他技术logo，什么规则引擎之类的，你觉得他只是懂那个一些后端的东西就可以吗，24岁年薪60万的简历模板，那除了懂这些个后端的知识之外。

你觉得他不需要懂什么，adobe hbase，jark，spark have in palace storm，卡夫卡吗，你们得到的很多信息都是错的，张老师给你纠正过来，少走弯路。

16年非计算机硕士西安19javs，不知道该怎么规划，自己先想明白自己想干嘛，想掌心还是想进到西安的某个厂子啊，有的人以前西安的，我记得有印象说我我想轻松一些，进一些什么呃，那个那个国企和甲方的厂子。

有的时候我想冲一冲进华为之类的，每个人情况不一样，而且每个人基础也不一样，就是后面的路该怎么走，哪条是捷径，哪条是最短路径，找老师做详细规划才可以，大场面是有什么套路吗，没什么套路来给你看。

大厂的没问题，百度的三轮技术面问的问题你自己看吧，百度的三轮技术面，你可以找个图问问自己能不能答得出来，美团的三轮技术面问的问题，顺风的两轮技术面，京东的两轮技术面，阿里的七轮面试，问的问题。

阿里漆面的面筋，一面二面三面四面五面六面七面，套路你说套路的话，那就是你的你你的技能有多硬，lg的简历不会有一系列简历可以看一下不，找那个咱们大数据老师周老师来给你来帮你做规划就行了。

我想给你打开了大数据的简历，大数据专门的简历，你这个都是一个模板，你抄模板没有用的，需要根据你自身的情况，老师来帮你批改简历，改好了之后再去投，效果就好多了，老师们的对于简历的理解到什么深度。

看这个案例，只修改简历，月薪涨了3k，啥事都没干，就帮他改了简历，不好意思的说，就是你们的简历呢写的跟那个屎一样，周老师讲的指导的大数据简历。

薪水50%的涨幅，改了简历果然好多了，一把过13x13到手，原来是老家7x12。

修改简历之后，面试第一件就成功25k我就想问你一句话。

你说我帮你改完简历，他不值这1万多块钱，其他的课程你就当送你的就成了改简历送课程，修改完简历两天收获十几个面试邀请。

怎么才能获得在场面试，我要看你硬件够不够，再看你简历值不值，什么时候上这个喜报网就行，我们好多学生，我们喜报都要求我们撤下来，他老说我有点隐私信息，老师怕那个什么什么查，我们有的人那什么比较。

这个想法比较多嘛，也很正常啊，不求大成，只有掌心，那就太简单了，追求整齐，老师这是不二之选，天天投简历就有大厂面试了，这个说法我也是醉了，简历写成跟屎一样，你那个先别说天天投简历，你分分钟投简历。

也没有当场面试你，我也想要高薪，呵呵想想要高薪的来找老师，老师的最牛逼的记录，有一个学生只会html css，十天之内让他搞定工作，经验而已啊，嗯已经是61了，11。11了，今儿就到这儿了。

最后一个问题吧，还有我们同学想找老师有疑问的，放歌是吧，可以想听什么歌，你这么说，我从做这2年的线上培训以来，我们的课程体系呢从短短的200多个小时扩展到2400个小时。

老师呢从两三位老师到现在的20位老师，就怼在这一个课上，从我自己来讲的，那一定是呕心沥血，那么也希望你们能够慢慢的认识到我们课程的价值之所在，如果说是传授知识的话，那也只是简简单单的其中的一小部分。

其实更重要的是老师对你的这块规划嗯，一个最简单最简单路径的教你这么跟你说多了不说，你就省个三个月时间，每个月就算5000块钱涨薪，你省三个月就是1万多了，所以不要这种事上的，千万不要想不开啊。

投资自己最值得的投资，没有之一，同时也想到了今天的名额没有了吧，娇娇你要用就得用明天的名额，今天的名额应该已经没有了，找潇潇问吧，看有没有漏掉，没有交钱的这些，因为有些呢它会往回吐的。

原因是因为领完了之后他没交没没付费啊，不知道这个没有，我刚才说过了，我们会逐步找新法，明天涨100左右，到你到月底涨到1000块钱，差不多就类似了，就是你下一次在哪，就不是12000 400万了。

下次再拿就是12000 500万了，是13000 400万，3年同志了，帮忙问了，3年是大厂最喜欢要的年龄，千万别错过，错过一定后悔，一线大厂最喜欢妖的工作年龄3~5年，明天给同事推荐一下嗯哦。

放他过来听课就行了，现在是11：14，我们今天晚上就到这里喽，有tomorrow。

系列 1：P42：50w年薪面试题：1.前言 - 马士兵官方号 - BV1mu411r78p

今天晚上要讲的内容啊，我就不在这多废话了，下面我们开始聊这个这个对象的故事啊，嗯当然有同学可能会说，嗯你把我逗乐了，马哥我是驴帝，你脑子被驴踢了是吧，hello，嗯，没有声音吗，应该有吧，好那个。

当然有同学可能会说，这天天写面向对象，面向对象对象不就new一个嘛，它背后还能有什么特殊特殊的故事吗，呃有那么一点点，我将给大家听好，下面我们就开始，嗯开始之前我稍微的做一点小的调查啊。

这个有多少同学现在还是在学校上上学的，你给老师扣个一，我看大概有多少好吗，那其他同学就都是呃参加工作了是吧嗯，呃我倒杯水，哎呀因为最近嗓子不太舒服，所以水是离不了了，好我把我自己拖出去。

然后我把编程窗口挪进来。

ok就放在这，呃今天要讲的小程序呢也超级的简单，所以呢我就原来的这个我就不多做说明了啊，我就直接直接拿手敲就可以了，好大家听我说呃，今天呢是关于讲对象的故事，那么等会儿呢我会在笔记上呢。

把今天讲的关于对象的故事呢都给大家伙儿一点点记到笔记上去。

嗯这里面呢我主要讲这么几个内容，今天晚上呃第一个呢主要跟大家聊呢和sport对象的构成，第二个呢我教大家怎么去理解对象的大小，第三一个呢哎我给大家讲的对象头的奥秘，这是一个面试中的重点的重灾区啊。

第四个，呢我我我跟大家聊一聊呢，就是关注成长这部分好，那么这是我们的枫叶云笔记呃，这个笔记软件呢感觉越来越好用了啊，还挺好的，后面呢我们会持续地用它来做相应的分享啊，好了。

首先呢我简单跟大家聊一下一个对象的构成到底什么样，当然听我说，那么这个时候呢我需要一些工具，我首先呢把这个工具列给大家比较简单，常用的工具呢叫做jl，当然它全称呢叫你知道吧。

object layout啊，java对象布局工具呃，如果你想使用它的话呢，也特别简单，我在这儿给大家复制过来，给大家之后呢，你就可以自己去做实验了，好了，这是他的没有依赖。

ok这个是我们用到的这个工具的，没问的依赖呃，到时候你就加到你的那个那个项目里头去，就可以直接用了，它全称叫j o l，除了这个g o l之外呢，我还用到一个工具呢叫嗯。

这电动啊叫j class library，嗯，诶这个这个这个格式上稍微有点别扭啊，稍等一下，j class library啊，这个工具，这个呢是一个那个idea的插件。

呃所以呢你在idea里面直接直接搜就可以，这个class library呢它是用来观察一个class文件的一些细节，ok我们用到这两个工具啊，大家去下载就可以好，大家听我说。

下面呢我们开始聊第一个问题啊，就是呃在java里面。

系列 1：P43：50w年薪面试题：2：对象头的三大作用你了解吗？ - 马士兵官方号 - BV1mu411r78p

嗯那么它到底长什么样呢，从一个普通对象角度来说呢，普通的对象角度。

他一共有四部分构成，这四部分分别叫mark word，class，pointer，instant state和padding，呃那个大家听我说啊，那么这几部分有同学可能不太理解啊。

就说老师您您这是在讲啥，一个对象，不就是你一个不就这样吗，不就new一个object吗，您那个给我讲说这个对象怎么分成四部分，是什么意思呃，为了照顾一点点，咱们就是基础比较弱的小同学们在听我说。

关于另外一个object，我想大伙应该都了解这一点啊，待会儿应该都了解这一点，就是在一个内存里面，这是我的画笔，在内存里面，当我们new出一个对象来的时候，这个对象他一定会在内存里面占一块空间。

这是没问题的，对不对，这个没问题的，给老师扣一啊，就是我们new出任何一个对象来的时候啊，他一定在内存里占一块空间，当然以前我们聊说这个对象啊，占了个空间，这个空间里头装的什么呀。

这空间里头装的是成员变量，一般我们是以前我们都这么聊啊是吧，我说new出一个对象来的时候呢，原来啊就是这个里面呢我们装的是成员变量，对象内部装有成员变量。

我觉得这个事儿大家是能接受，也很容易理解的呃但是现在问题呢是说除了成员变量之外。

还有没有其他内容，好好听，我说我今天给大家讲的是，当我们就出这个对象来之后，在这个对象的内部，除了成员变量之外，那么它有哪些部分具体来构成，那么它们都有什么用，听我说我今天讲的这堂课呢。

你有很多很多那种常见的一些小小的问题，你原来可能没有思考过或者思考不出来的那种问题，今天就统一给你解决了，好我先下结论，在hot sport这种虚拟机里面。

一个java的对象，它由四部分构成，哪四部分，第一部分我们把它称之为叫mark word。

这部分不好翻译，四部分，mark word，那么这个部分不太好翻译啊，我们把它理解为叫标记字，但这东西是什么意思，别着急，我后面会讲给大家听，那么这部分呢是八个字节，是八个字节，清过记录好。

那么第二部分是什么，第二部分呢叫做class pointer，这部分呢叫指向对象所属的class，这是什么意思，大家都知道我们java程序要想运行的时候，比方说我用到t这个对象了，我new了个t对象。

那么他首先得把t。class放内存里去好，这第二部分呢就是一个指针，这个指针呢会指向t。class。

通过这部分a b一指找到谁去了，t。class好，那么第三部分这部分才是真正的我们装实力的地方，也就是装我们的成员变量的地方，第四部分叫什么叫对齐，对齐的意思是说一定要被八整除，不能被八整除。

就给它补齐。

我先给大家记下来，一点一点给大家解释，instant data，成员变量啊，这是叫真正装成员变量的地方好，那么这部分呢一般是四个字节，这class pointer一般是四个字节啊。

这instance state它肯定不是固定的，你就放心吧，因为你装的成员变量越多，它肯定就呃那这个这个大小就越大是吧，那么第四部分叫padding，padding，什么意思，八字节对齐。

八字结尾结什么意思啊。

比方说我们前面三个部分加起来不能被八整除，我前面三个部分一加，那么它是多少呢，比如说是12个字典，那不能被完整数怎么办，再在这儿补四个四个字点，我不知道我说清楚没有，当然以前有同学问说。

老师为什么要补啊，如果你理解不了这件事呢，你就想象一下集装箱呃，当我们的大小对的比较齐的时候，像集装箱那样，我们装卸货物的效率会提高，假如说我们各个对象大小都对不太齐啊，这个11个那个七个那个七个半啊。

那个七个零一位，我告诉你，这，样的对象，你寻找起来和管理起来，它会非常非常的繁琐和麻烦，不知道我说清楚没有，来这块能跟上，给老师扣个一好吧。

咋签到，你现在就已经签了啊，不记往这儿看。

有同学说了，老师那你怎么能证明这四部分的存在吗，是可以的，我现在没向你证明这四部分的存在。

大家看这里，当我们运用了这个j o l这个工具之后呢，我们随便写个对象，比方说我们就用这个这个class啊，这个t t这个class好，下面我们写t小t等于6t然后呢。

我们怎么运用这个g o l这个工具呢，就java object layout这个工具呢这样来写，那么它有一个静态的live拿来用就可以了，叫class layout，class layout。

点pass instance，pass是解析的意思，instance是对象的意思，解析某个对象，解析哪个对象呢，解析小t这个对象，把它解析完的东西呢，to principle做成可以打印的样子。

然后呢给打印出来，哈哈刚才我应我我我再简单解释一遍，就是用它的class layout的这个类，他的pass instance静态方法，然后呢去解析t把解析出来的结果转成k大印的字符串。

然后再把它打印出来，如果不能理解的话，跑跑起来之后你看结果你就理解了。

好我们来看这个结果，好了，同学们，在这里呢我们就看到了t小t等于6t这个类，它在内存之中的所有的布局呃，如果说你要想看它二进制的一个布局的话，here看到了吗，这里面这里就是这个对象在内存中的每一位。

它到底是什么样子的，当然你这么看的话，你也看不出来它到底是什么意思是吧，我们往前慢慢看好，我刚才说过，我说在一个对象来说，他的有一部分叫mac word，还有印象吧，我这里好像做了一个设置啊。

我得把这个设置打开，不然容易引起，不然容易引起，引起误解啊，重新跑，因为我不小心把那个压缩给他关闭掉了，它默认是压缩的，这个一会我讲给你听，不着急呃，往这看啊，t小t等于6t那么在这儿呢。

这里这里是二进制的内容好，这里是16进制的内容好，这里是什么呢，这里说的是从第零个字节开始，往后数四个字节，那么这部分呢我们把它叫做object header，叫对象头，从第四个字节往后又数四个字节。

又还是对象头，我我刚才说过，我说mark word是多少个字节来着，mark word log字节八个，对不对，所以前面这八个字节好了，这里装的就是mac word，那好我刚，才说过。

我说class pointer是几个字节，四个字节对这四个字节就是class pointer，它通过它可以找到我们谁呢，找到我们t。class，当然这小t内部你看看它有成员变量吗。

所以它成员变量这部分长度为零，但是我们前面三个加起来之后呢，长度是12个字节，能被八整除吗，不能，所以这个时候呢在后面补四个，ok所以这个instance size 16个字节，就是这个对象的大小。

一共是16个字节，好了来这块儿，刚刚我讲的这一小段儿啊，能跟上那个老师扣一好吧，很小很小的一小段儿嗯，怎么还有扣六的呀，666吗，呃当你理解了这件事之后呢，我们来探索一下在这个对象的里边。

它背后的一些小秘密，首先第一点啊，我们来看看作为一个对象来说，它的大小到底是多少啊，坑问了个问题啊，他说为啥是两个mark word大哥，那不是两个，是这两部分加起来是mark word。

一共是八个字节，64位小伙儿，你是不是晕了，嗯，好这种基础的问题不解释了，在美团面试的时候，有一道著名的题，他这么问的，他问他问你，他说呃一个object在内存之中占多少个字节。

我直接告诉你跟这个t是一样的，因为它没有成员变量，那么它就有bug的，mark word，四个四个的class pointer，零个instance data补齐补四个，所以加起来一共是多少呢。

16个字节，你怎么还有说16k的，你知道16k是多少吗，k这个词你是不明白是吗，9296，我没说是16的倍数，我说是八字节的倍数，八字节能理解吗，需要我解释什么叫字节，什么叫we吗。

需要的扣7965x6543的开立方，不需要的扣个一，好既然没有开那个地方的，我们我们就直接往下讲了，啊哈哈开个玩笑，开这里啊，呃在这儿呢我们要稍微的简单的探索一下一个对象呢，到底它到底是多大。

嗯我给大家记两笔笔记啊。

就是理解对象的大小这件事，那么这一个对象到底有多大。

是由什么来决定的呢，他的脑袋是固定的啊，脑袋一共有两部分构成，一个叫mc word，一个叫class pointer，两部分加起来是12个字节，好决定它大小的主要是在于它的成员变量。

那比方说我给你举个例子，我这里写int来告诉我，当这样一个对象new出来的时候，它的大小到底是多少，我看一下答案，还有48的啊，五花八门啊，跑着玩儿，我们来考，我们来看看啊，看结果这个是多少啊。

我刚才说过了，我说前面这12个字节加起来都叫做对象头，对象头部里边有四个字节是谁呢，指向class文件的class pointer，然后前面这个八个字节是什么，这八个字节是什么东西呢。

是mark word，这是固定的好吧，所以你就记住一个对象脑袋上顶着12个字节，在这12字节后面，我们加了一个int类型，int类型，几个字典四个字节，所以12+4=16，能被八整除，还用补吗，不用补。

ok一共16个字节，好了再给大家，这就相当于考你们最基础的内容了啊，来再来一个lol来告诉我，多少个字节，24是吧，嗯这个还用我跑吗啊，这大多数都是24啊，这个是没问题的，为什么。

因为long类型是几个字节呢，八个是吧嗯好那我先跑完吧，这个确认一下啊，四个字节的long，八个字，四个字节的int，八个字节的long好考一个稍微难一点儿的小伙伴们来告诉我这个，哈哈32k。

来我来看一眼，k一共是32个是没错的，那么它内部布局什么样呢，首先12个字节的脑袋不说了，四个的int bag的lo布尔代，相传几个字节，一个字节only one啊，当然他占一位都行。

但是呢java面操作的时候呢，最小是一字节，所以一个字节那好后面要补七个，不然的话不能被八整除好，再来一个男的，好吧来谁能告诉我这个要占多少个字节，32 32还有别的吗，还有64嗯，还有问号。

ok还有40好看这里啊，先看答案，它多少是32个字节，为什么是32个，注意看它就比较好玩儿了，好前面12个字节脑袋也不说了，然后四个字节的int，八个字节的long，一个字节的布尔补三个字节。

为什么补三个，是因为呢我们后面有四个字节的s能看懂吗，我想先问我，有同学可能会说了，老师你这个怎么看也不像四个字节啊，大哥我想问你，如果一个t对象new出来了之后。

这个我们的字符串常量会装在我们t对象里面吗，不会他装谁啊，是不是装个s呀，s会指向我们常量池里面这个常量对不对，所以他就装了个地址，那个地址是多大呢，就是说这个地址四个字节引用类型吗，四字姐够了。

ok好，这块能跟上的老师扣个一，嗯嗯不错，好来再来个终终极难度，看这里boy的m来告诉我，多少个之间，你这是32图a一系统的意思吗，现在都是64位的java的虚拟机都是64位还是32，为什么。

还有40不知道不和你玩了是吧，ok好拜拜，趴一下，依然是32个字典对象，这东西在在一个对象里面会装方法进去吗，不会是吧，注意方法呀，所有的对象共享方法的字节码，所有对象共享，那么这个字节码放哪了。

这东西是放在我们class文件里面的，也就是说当一个对象产生了之后，如果你想对这个对象调用一个方法，它会通过这个class的指针找到对应的class的代码，然后，把这个对象当成this传给这个方法。

然后开始调用，能听懂吗，大学没教过是吧，嗯大学没教过，没关系啊，慢慢慢慢讲给你听吗，再重复一遍，再重复一遍方法，这玩意儿是放哪的，放在class文件里的对吧，我们不可能每个对象都放一个方法的。

那个完全没有必要啊，方法的实现不就一份吗，所以方法编译出来的字节码放哪儿，放到class文件里，这是没问题的，然后我们想对这个方法调用的时候，你比方说我t小t等于new t，然后t。

m我想调用它的时候是怎么调用的过程啊，大家知道这个小t它是，不是有四部分，第二部分是什么东西，是不是指向class的指针，这样的话我们是不是就找到这个class对象了，在这class对象内部。

是不是我们就找到了这个class对象内部的m方法了，然后呢我把这个指针这个对象的this this指向它自己嘛传给这个方法，然后就可以调用了，有同学说已经这么卷了吗，这个不算卷吧。

当然我今天讲的内容比较深入，今天讲内容大概是美团30万~50万年薪的内容，所以你们玩听认真听好吧，呃你练过你可能就拿到这个年薪了好了，class放哪变量名的情况，变量名是那个也放在class文件里的啊。

但是这个变量的内容啊，它的它的里边放的这个值是放在我们对象里边的，对一开始方法去class文件方方法去啊，好了好了，不再不再解释了，我们我们我们再继续啊，对这是java，没错好，我们再继续呃。

当然这个解释呢对于非非计算机专业的学生来说呢，可能就稍微有点深入了，不过我再强调一遍，今天讲的东西面向美团这一类大厂，30万~50万年薪呃，所以呢难一点也是正常的好吧，如果太容易了，你们所有人都拿到了。

不可能，ok好。

系列 1：P44：50w年薪面试题：3：HashCode就记录在对象内部你清楚吗？ - 马士兵官方号 - BV1mu411r78p

的话呢我们就大概知道了，我把这我我把这代码给大家复制一下，放到我们的笔记里，嗯好，好大家需要的话呢去把这个代码复制下来，你自己去做一做实验就ok了，好吧非常的简单呃，这部分呢其实不太难。

就是理解对象的大小，但是在这部分有一点点小小的坑，我想讲给你们听，大家听我说美团的第一个问题啊，他是这么问的，他说object object到底的它的大小是多少，那么我这个实验我不想给你们做了。

你们拿大腿想一想，应该能推得出来object大小是多少，来告诉我16个字典，对没错啊，说的很对，但是听我说，其实呢我们说一个对象的大小呢还不是完全固定的，我想我现在想问你们。

你们现在用到的java虚拟机，它是多少位的java虚拟机问答一个简单的小问题，64对这个东西怎么看呢。

其实非常的简单啊，你你你只要打开一个那个窗口，你敲一个，java version就可以了，他会告诉你我用的这个呢是java hosport，就是虚拟机的名字，然后64位的server server模式。

它是一个64位，那我想问你的是，在一个64位的机器里面，一个指针的长度是多少，我想大家大家了不了解什么是64位的机器啊，就原来咱们从八位机器到16位到32位到64位，64位是什么意思。

64位叫做寻址能力，注意是寻址能力什么意思啊，就是64位的机器能用多长来代表一个地址，能不能听懂，比方说我要用一位来代表一个地址的话，我我能找到几，个地址啊，一个零一个一两个能理解吧。

那我用两位来代表一个地址的话，我能寻址能选几个地址，00011014个，对不对，那以此类推，如果说我们是64位的机器，我们能寻找多大的地址呢，就是我们能找到多大的内存空间呢，就是2~64次方好了。

也就是说大家知道我们所有的变量都放在我们的内存里面，我们要找这个变量的时候，那他一定是得有一个地址告诉你这个变量的地址在哪，那这个地址呢是用64位来进行存储的，那也就意味着我能够管理的内存到底。

是多少呢，二的64次方来这块能get到的，给老师扣个一，这个应该没问题啊，非常基础的计算机的内容，那大家想问你的是呃，原来呢你们可能每个地址的大小，我的老天爷啊，64位，64位，你说每个地址的大小呢。

从零一直到2~64次方减一嘛，我零基础学web的，学web的小伙伴呢，你先补点基础内容，好吧好了，听我说，那么如果是32位机器呢，它当然就是二的32次方，二的三次方是二次方是多少，大家知道吗。

四个g所以在32位机器的时候，不知道大家还有没有印，象你们的内存条的大小最高只能四个g，不可能比4g高，那么后来才突破了四个g，然后呢你们的内存条才变成了a 16个g，64个g等等等，等，好了看这里。

那现在问题就来了，作为一个64位的虚拟机，它的地址的大小应该是多少，当然应该是64位的，64位，几个字典当然应该是八字节，同学们，我们我不知道你们注意到没有，在我们的java对象里面。

缩小一点，在我们的java对象里面，我们刚才运行的这个结果，这是jav里面的一个地址对吧，还记得这地址大小是多少吗，这个地址大小是四个字节，你不觉得奇怪吗，你应该觉得奇怪好吧，原因是什么。

因为一个64位的虚拟机，您老人家一个引用的大小应该就是八字节，你凭什么是四个字节。

这个呢也很好解释，大家看这里，是因为什么呢，我能在执行这个刚version的时候加一个参数，让他把默认的自带的那些个参数给打印出来，print，on line flags，我加上这个参数啊。

conversion，这参数是什么意思呢，这参数就是说当你运行一个java虚拟机的时候，你把这个java虚拟机默认的一个设置给我打印出来，默认一些自带的参数都打印出来啊。

command line flag回车，好，在这个command line flags里面呢，你会发现呢它这里有一个很好玩的东西。

这里把把把把把两个单词给他，那什么了啊，这里有个很好玩的东西，往这儿看，这个这是它自带的一个参数，然后它前面还有一个参数，你读一下读一下，解释一下什么意思。

use使用compress压缩的class pointers，class pointer，诶，刚才我们讲的对象的第二部分指的是什么来着，对象第二部分是不是就是class enter。

所以这里说的特别简单，因为它这里使用的是压缩的类指针嗯，还有同学说什么叫压缩类指针啊，就是原来这个类指针正常应该就是八个字节，因为您老人家是64位的虚拟机，您就应该是八个字节，可是呢由于你默认带了压缩。

所以这里它就变成了四个字节，因为四个字节就够用了，一般四个字节就已经寻址四个g了。

你的程序的大小不会有那么大个儿的。

ok好了，那有同学说老师我能把这个压缩也打开吗，完全可以来为你。

我给你演示一下，嗯好了没有说好，再来run edit，我在运行的时候加上这个参数，跟xx注意这个加号表示打开，减号表示关闭，你注意对比原来的咱们的class pointer是四个字节，对，只有美。

run，edit，刚access点，last point子少了个s啊，sorry，好往这儿看看主要看哪部分，我看这部分你们看还记得吗，原来我们的object header是多少，是不是12个字节。

现在已经变成多少了，变成16个了，发现了没有，object header，object header，object object，现在又多了一个object header的部分。

所以我们整个对象的大小已经变成40个字节了，来这块能get到的，给老师扣个一，嗯嗯，那有同学有同学可能就会问了，说老师我生产环境默认默认要打开吗，当然当然要打开，这个压缩，为什么要压缩。

压缩是因为四个g的空间已经够使了，明白吧，也就是32位的寻址空间已经够了，你干嘛非得要那么大个儿呢，能理解吧，四个g空间已经够了，ok对你运行你这个程序来说，所以他默认就给你压缩了，它省空间啊。

省一半啊，这个是省很大空间，当然有同学说老师这个s为什么还是四个字节呢。

是因为你运行的时候呢，它有两个参数来控制的，这个参数只是控制它的类指针，下面这个参数是真正控制普通对象指针的，好看这里。

在这儿呢我来把这个也给大家打开，让你再看一眼，你就理解了啊。

好，我再加号改成减号搞定，然后呢我们点run，注意看这时候的string，它的大小会变成多少，好了你看那个t。s变成多少啊，八个字节，叫ordinary。

ordinary object pointers，这里指的什么叫普通对象指针，就是你平时用到哪些指针，平时用到哪些引用，它的一个大小，由这个来控制，当然这里面还有一些血淋淋的细节，我不想再深入了。

再深入，我估计待会可能接受不了了，嗯，它主要是说32个g。

我我30 32个g过后。

他的这个压缩就就失效了，就特别好玩啊。

好。

如果32位vm在压缩指针，32个m没有压缩指针好了，我们聊完这些简单的问题之后呢，聊一点复杂的问题，我们聊聊一聊对象头，我我告诉你啊，这个对象头呢是最复杂的地方，也是面试面的最最最最最多的地方。

这个摄像头这玩意儿呢是超级超级呃，难于理解，以及那个那个那个那个特别重要的东西啊，摄像头还记得吗，大家还在，我不知道大家还记不记得，那么第一部分呢我们把它叫做mark word好了，听我说呃。

中面试的重灾区就在这，那么第二部分我们把它叫做，collect pointer，这个东西呢倒是比较简单，这个我们把它放过去看，这里对像头对象头指的是什么东西呢，对象头呢在我们这里呢我们专讲的是马克啊。

大家还记得一个mark word，它大小是多少吗，64位，对不对，好了，我这里我画了一个最简单的图，64位的图在网上你看到这张图，老师画的，在这里面呢详细的给你解释了，在一个64位的对象的脑袋上。

mark word里面到底里面装的什么东西，我先说结论，我先说结论啊，哪三个东西呢，好第一，个它叫做还是扣的，好这是第一个，那么第二个它叫做锁信息，有同学说老师这个东西能验证吗，完全也可以看这里。

我来带你验证，我先把压缩的这个都给它关掉，没用了，咳咳，好来看这里啊，呃我们把这个多余的内容也给他删掉啊，就留一个小t在留一个t啊，留个空的t在这里呃，那么大家看啊，我们t角d等于6t。

我们把他的那个布局给打印出来，你先往这看，好看看这里大家记得哪部分是mc word呢，这部分对这部分是mac word这部分啊，你记得现在这个mark word的表表现，我稍微做一点小小的动作。

你就会发现macd变了，比如说我就我就这么来了一下，t点还是cold，然后呢，我再把它打印出来，咱们上下做一个小小的对比走，你，hello，同学们，你们想知道那个特效是什么吗。

power mode to啊，不说了，看这里我们主要来对比这两个东西的，待会儿不要跟这开始玩特效了，好了，看这里，这是我们没调hash code之前的mark word。

这是我们调用完hash code之后的mark word，你发现你应该发现区别了吧，只要你长了眼睛，对不对，也就是说我们我觉得你至少应该get到一点，就是ok原来一个对象呢还是扣的信息。

一个对象呢还是靠的信息记录在哪里，记录在他的脑袋上，记录在他的mc word上，当我们调用完一次之后，下次再调用一个对象的hash code，一个对象的hash code能随便变化吗，能不能不能。

所以ok这个对象的hash code就记录在了脑袋上，当然这里面还有一个细节，它其实是叫做identity hash code，就是你没有重写之前的那个还是code，如果你把还是cod给重写了。

那不好意思，这玩意儿还是这个identity还是cold啊，ok所以我们这个节目第一个结论就来了，就是说我们的对象脑袋上会记录他的还是code，不是各位各位大哥，你们这是聊啥呢，我想问问。

class pointer肯定变不了的，你们聊啥呢，聊聊聊插件的是吗，好了，我刚才讲的技术的内容能跟上，那老师扣一，我觉得今天年轻人比较多，感觉非常，非常非常的灵动，想法挺多的嗯，98年98年老家伙了。

咱俩同岁啊，96年96年得管你叫哥呀，嗯调用调用一下hash code咋就办了，因为你hash code调用完之后，它的还是cod信息会写在脑袋上，好了好了嗯，还不太信我的，说你不信我，你过来听老师课。

那我讲的技术你也不信了，好看这里啊，91年的，难道娘娘阿姨，你先证明你是女的再说好，这是第一个信息，你会意识到哦，原来还是扣的，这个信息是记录在脑袋上的，我们来聊第二个信息，锁信息，有同学可能就会说了。

说老师这个锁信息是什么，是什么信息，同学们，你们写过量的代码吧，synchronized t来这个应该都用过，对不对，sychronized好，当你用过这个，语句之后啊，我们把它用完。

这个语句呢也给它打印出来好，这里synchronized the te指的什么意思啊，是不是把它当成一把锁，当然我们通俗的说法呢叫锁定这个对象，但是专业的讲法呢就把这把把这个对象当成一把锁。

那为什么要用锁呀，要用锁，主要是为了解决多线程访问数据不一致的问题，什么叫多线程访问数据不一致啊，我给你举个最简单的例子，多线程访问所谓的多线程访问数据不一致啊，这是，好这是这是一个马桶，马桶也姓马。

好马老师讲，马桶前面有一道门儿，那么一个人进去的时候要办事儿，哭哧哭哧在里边办事儿，那么如果你不上锁在计算机的角度呢，就是允许别人进去也同时办事儿，那就是几个白花花的屁股怼在一起，然后一起办事儿。

这个画面太美好，不敢想象，所以这个是成问题的，也是不应该的，如果你想保证在同一个时刻，只有一个人在里面办事儿，你该怎么办，是不是上厕所对上把锁的概念。

当然我们普通理解的上把锁就是我们真的拿一把锁头光机往上一锁，但是在计算机里面，它实际上这把锁是怎么构成的呢，怎么就叫一把锁呢，听我说，简单说呢就是把一个对象当成一把锁。

那把这把什么叫把一个对象当成一把锁呀，我们上下一对比，你就理解了，跑一下看，来我们前后对比，你会发现一个明显的对比，这是最开始的时候一个普通的对象，这是被我们锁定的对象，发现区别了吧。

那我想这就是下一个结论很容易就得出了，就是说我们说一个现成的关于锁的信息啊，一个一个对象的关于锁的信息记录在哪，也记录在他的脑袋的mark word上面，这块没问题吧，嗯很简单，就是说诶如果你想想看啊。

第一第一个线程来了，诶我锁定这个对象了，锁定这个对象了，就是在他脑袋上改了，改了一些东西，那么另外一个县城如果来了。

系列 1：P45：50w年薪面试题：4：线程的锁信息记录在对象脑袋上你晓得吗？ - 马士兵官方号 - BV1mu411r78p

进这个里面已经被别人锁定了，他就进不来，机制就是这么设计的，所以我们就完美地解决了马桶拉屎问题，好了，这块能get到的老师扣一，你看asshole啊，这这不是asshole啊，叫a总啊，sorry。

不是asshole，如果锁一个方法锁信息存在哪，大哥有没有同学告诉他一下，如果锁一个方法锁信息存在哪，还有class对象，this，如果非静态方法。

当前对象synchrona相当于synchronized v，synchronized the v，能听懂吗，那如果是静态方法没有this呢，synchronized当前的class对象，t。

class，搞定，好了好，我们继续，我发现今天来的小伙伴们基础是有点稍弱啊，大家看这里，下面我们聊哎呀，我都你们这基础弱的，我都我都不敢跟你们聊下一个问题了嗯，啥意思没明白是吧，嗯大概听一听嗯。

好我们来聊一个哪一点的问题啊，就是我刚才跟你聊这些问题，实际上是没有30万的大哥，我再说一遍啊，嗯，罗伊是96年的大哥是吧，嗯下面我们来聊一个真正值30万的问题。

好看这里啊，另外一个信息我刚才说过这个信息是什么信息，这个信息你不容易观察到啊，因为一个对象在它被回收的时候，你怎么去看到他脑袋呢，他都被回收了，你访问都访问不到了，但是我明确的告诉你。

它就是存在他的脑袋上的呃，当然这个东西呢会牵扯到好几个层面的东西啊，就是第一个呢它会牵扯到垃圾回收器，垃圾回收器的东西会牵扯到到底什么是垃圾，我的天哪算了，我一会儿讲这个问题吧，好不好。

我我我我我先讲一个容易点的问题，我先我们先把这个问题放过，因为主主要是今天来的小伙伴的这个基础稍微的有那么一点点弱啊，一会专门给你讲，我们先把呃关于锁的这个信息讲给大家听。

大家听我说我不知道大家听说过没有一个synchronized，关于锁，它未必全是互斥锁，它中间有一个锁升级的过程，一般来讲呢我们平时上的锁，我们把它称之为叫互斥锁，什么为什，么叫为什么把它叫互斥锁呀。

互斥锁的意思是什么意思呢，其实互斥锁的意思是说我锁定了之后，其他人再也锁不上，这叫互斥锁，除了护士所之外，还有共享锁，我锁了之后，别人还可以锁啊，就是咱确实咱俩一块儿可以上厕所，这是有可能的好吧。

就看你锁的这个东西是一把什么样的锁，锁的类型是有好多种的啊，普通的呢我们是把它当成互斥锁，但实际上呢呃这个synchront的内部呢，它有一个非常强烈的所升级的过程，这升级过程比较复杂，我先给大家上图。

你先有一个，大体的印象呃，这么跟大家说，一般来讲一个对象刚刚尿出来，刚上锁的时候会倾向于上偏向锁，上完偏向锁之后呢，才会升级成为轻量级锁，好有同学说了，老师啊，这个轻量级锁重量你所又是什么意思，好好听。

我说好听，我说仔细听，因为你了解重量，你所这件事你需要了解操作系统大哥啊，就是大家都知道我们的class文件是要放到jvm虚拟机里去运行的，那jvm虚拟机是跑在谁上面的一个职业vm虚拟机是跑谁上面。

跑在操作系统上面的，操作系统和操作系统大哥都是谁，那什么microsoft这个windows啦，呃麦克拉linux啦，unix啦这些好，我们说，现在呢jvm面临了一个管理所的问题，这里有一把锁。

有一堆县城呢都是都要去抢这把锁，jvm面临着对所得进行管理的问题，好jvm有两种选择，我再说一遍，由于jvm在操作系统看来就是一个普普通通的小程序，在jvm的内部才是我们java写的程序。

我们java写的程序又有好多线程，多线程去抢一把锁，这是我们要聊的这个问题的背景，再说一遍，jvm里面我们写了好几个线程去抢一把锁，然后jvm这个时候有两种选择，第一种选择是我自己管理这些线程。

管理这个县城对于锁的征用过程，谁抢到该轮，到谁了，谁去休息好了，这个东西呢被我们称之为是啊，jvm内部的管理，就jvm我可以选择自己管，jvm还可以偷懒，偷懒是给谁呀，偷懒是我交给操作系统去管。

jvm说我这里起了个线程，麻烦你操作系统起一个线程，这里起个线程，你你起一个线程，我这六把锁好，你帮我去管，你管好了之后说该哪个县城了，你反馈给我就可以了，好当你理解了这件事之后，就是交给。

操作系统去管理，不行好了，这是我们最终一个synchronized的上锁的过程之中，最终的一个选择就是所有的其他所都不管事儿的时候，那当然有同学可能会说了，老师那交给操作系统之前。

我是可以自己做一些努力吗，恭喜你，这个问题呢基本上大厂都有可能会问到呃，这东西呢我给大家看一个小小的面筋吧，这是我们的阿里的，原来阿里的一个漆面的面筋啊，基本上都会问到啊，关于锁的，锁的分类啊。

讲到这儿是吧，乐观锁，悲观锁，自旋锁，读写锁，排他所共享所分段所各自特点，以及他们在java中具体的实现方式，呃这个呢是阿里的七面，这小伙呢是练了七次面试，然后进了阿里，当然他进的是阿里国际。

叫阿里阿里express呃，薪水当然也贼高了，因为他讲清楚了嘛，呃除了这个之外呢，你比如说像百度美团，顺丰，京东这这这这些个面试基本都有关于srt的内容，就是synchronized的。

以及它的什么entry log的底层原理，锁的四种状态以及升级过程，就是现在我想给你听的内容啊，cmx和g one的内容都是都是在这个脑袋上的，所以你弄通脑袋之后呢，你发现你会发现很多问题你全通了嗯。

好其他我就不给你一一看了，就是总而言之，言而总之你会突然间发现呢，大厂问的问题越来越细，非常的细致好听，我说在synchronize就是这vm交出管理权之前，它实际上经过了一系列的挣扎。

这一系列的挣扎呢是从偏向所到轻量级所一系列的生长过程，但是什么叫平行线索，什么叫轻量级锁，我先给你解释什么叫轻量级锁，清掉你所在内部，在sychon内部的实现呢，就是我们俗称的自旋锁。

也就是俗称的cs叫compared swap，但有同学可能会说了，你所自旋这个这个这个这个自旋锁呀，来这块需要我解释了，老师扣个一cs，好好好，我稍微我稍微解释一下啊。

嗯关于cs这件事呢，或者叫呢compare and exchange，舌头一回事啊，就是比较并交换，它指的是同学们，你们想一下啊，当我们干一件事儿的时候，我们干一件事儿，不管你是大便也好。

嗯还是给个数加一也好，那个我们干一件事儿的时候呢，为了保证一次只有一个人在里面做，做事儿之后呢，最后的结果保证是一也是没有问题的，这个时候我们需要用到锁，对不对，我们往往用的锁就是进门我就上锁。

进门我就上锁，你听明白了吧，但是还有一种玩法叫做我不上锁，这种呢被称之为，自旋这是怎么玩的，听我说上锁的呢，大家很容易理解啊，就是上面拿钥匙，就是咔嚓给它锁上就完了。

但是像这种compared swap就是这么玩的，比如说我给大家举个例子，这里有个数，这里有一个数字零，如果我们好多个线程对它进行加加的操作，我这个线程也对它加加，这个线程也对它加加，大家都知道。

这时候如果你不上锁的话，它会出各种各样的问题，什么样的问题呢，我这个县城把零读到自己这儿来给他加加，变成一一给他写回去，但是还没有来得及写回去的时候，另外一个线程把这个零读，过来变成一，然后写回去。

这时候它会变成一，然后这边呢有已经加完了，往回写的过程，写回去还是一，就等于我加了两次，最后的结果只得到了一次，来这块没有问题，同学给老师扣个一，啊超卖对，其实类似的问题嘛，就是你不上锁的话。

你最后得到的这个东西它一定是有问题的，好吧，那那这个时候除了一种方式，有一种方式是当我改的时候，我就上一把锁，我把零读过来，改成一一写回去，我写完了之后再把这把锁打开，其他人再进来，这是一种方式。

这样的话可以保证每一次只有我一个线程在这里活动，但是还有另外一种方式，另外一种方式是什么样的方式，这种方式你仔细看，依然是这个零，现在呢我的第一个线程来了，我把这个零读过来，读到这里，然后呢我把它改成。

一好同学们注意看，就在这儿这个一往回写的时候，一往回写的时候，我比较比较一下，并且瞅一眼说哥们儿，你是不是依然为零，你是不是依然还是我想要的那个零，那么大家你想一下，如果你依然为零。

那说明在我把你零拿过来改成1万，我写的这个过程之中，没有人改过你，能不能听懂来这个能get到的，给老师可以啊，我再说一遍，就是我把这零读过来，然后改成一一往回写的过程当中，我比较一下。

我看看你是不是依然还是我期待的那个零，哎如果你是说明没有人改动过，你，太好了，我就直接把你改成一搞定，所以这个叫比较诶，比较一下，如果我们用维码来表示的话，就非常简单，就是if哥们儿。

你这个值是不是依然还为零啊，如果是的话，把你改成一，如果不是，当然如果不是呢，如果不是呢，比方说我这零拿过来改成一的过程，另外的一一堆线程早就把你改成，八了，当我往回写的时候，我发现你变成八了。

我怎么办，特别简单，我把这八重新读过来，把你改成九，用九往回写的过程之中，看看你哥们儿，你是不是依然为八，来这块能get到的老师扣个一，这时候你发现我们不用上锁了，我们只要用一个循环就可以了。

我们只要用一个循环说，when哥们，你一你只要是跟原来那个老的那个值是一样的，你只要是我想要的老的那个值，我就把你改成新纸就可以了，搞定了，你如果说不是那个老的值，那我就重新来读出来，然后改成新值。

再看你那个还是不是原来那个老那个值啊，好了，这就是一种新的玩法，这种玩法呢叫自旋锁，那么它就类似于什么呢，类似于有人在上厕所，然后呢旁边旁边人呢，他不他不会关门，那么新来的县城拎着裤子跟他转。

圈玩得转一圈看看，哥们儿你还在里边吗，林转一圈看看哎，哥们儿你还在里边吗，什么时候说哥们儿你出来了，ok我进去好，ok这东西呢叫自旋锁，就是拎着裤子转圈的过程。

当然这里面呢其实有著名的那个关于自选所的面试题啊，呃关于资源所面试题比较多，也比较深入，这个有著名的关于自旋锁的面试题，那么第一个问题呢是著名的baba问题，好，大家还在吗，还在雷老师可以了，对啊。

被别的线程改了，我就一直轮，总总会轮到我，对不对，嗯，那第一个问题就注明了a b a问题，a aba问题是什么问题啊，a aba问题也很简单，比如说我这里是个八，我把它读过来改成九的过程之中。

实际上呢有一个线程早就把这个八给改成12，另外一个线程又把这个12给改回乘八了，能听懂吗，所以这个八此八非彼八，它中间有一个从八到12又回到八的过程，当然在我眼里看来，他依然是那个八。

来如果你还是不能理解a b a问题，我给你举个形象点的例子，这是你的女朋友，然后呢你出差了，回来之后你看到的依然是你这个女朋友，这个能理解了吗，他依然是那个a，但他有没有经过b的过程。

好这就是aba问题啊，当然在这个里面有两种解决方案，有两种解决方案好，第一种解决方案是什么，第一种解决方案是我不在乎，我不在乎，ok你是零，你反正只要是个零就行，至于说你这个零中间改被别人改过多少次呢。

跟我没关系，第二种是我在乎我在乎怎么办，如果你在乎你的解决方案是在他的脑门上加一个version version，ok加一个版本，就是你出去的时候给他扣一戳，上面写一点，如果当你回来。

你发现他脑门上变成了99点，恭喜你，人在江湖飘，谁能不挨刀是吧嗯。

好了，这就是version，那有同学说了，老师真的有这种编程方式吗，yes，这里有，atomic stamp reference，这里的stamp就是在他的脑门上扣了一个sequence啊。

当然你还可以加一个time，加上时间也可以啊，随你btomic standard reference，那么每一次的更改这个sequence都会加一好吧，这里呢就是带版本号的更新o好，你理解了这件事之后。

其实还有一个比较好玩的，就这个版本号这件事就在脑门上扣扣扣版本号这件事，其实呢还有两种版本号，第一种版本号是数字12345678啊，记录着有多少次好，那么第二种版本号是true和false。

比如说你走的时候，它是一个false，经中间经历过任何事情，只要改成true就ok了，那么经，历了多少次，不管好这种的呢，被我们称之为叫markable reference。

叫markable reference，atomic markable reference，sorry这个源码没有改过来啊，我回头改改，我回头再把它改过来，这东西呢就特别简单，就是那个看这里。

你只要把它标成true和false就ok了。

好吧，好了，a aba问题能听懂的，给老师扣个一，对对对，不要太在乎啊，人生要想过得去啊。

系列 1：P46：50w年薪面试题：5：所谓的锁升级其实就是对象头信息的变化你明白吗？ - 马士兵官方号 - BV1mu411r78p

但这个问题呢实际上是那个cs里面比较简单的问题，这个问题是cs里面比较简单的问题，我们说一个cs里面比较复杂的问题，我看看我看看这个难度能不能给讲给大家听，听我说，看这里啊。

这个cs里面比较复杂的问题是这个，那么这里是个八，我们把它读过来，读过来之后呢，呃呃读过来之后呢，我们我们把它改成九九，写回去的过程呢，实际上是我刚才写了一个维码，这个维码叫做if，你哥们儿。

你是不是依然等八对吧，如果你依然等八的话，我把你改成九，那我想问你的是，如果在这个这个过程之中，比方说我判断你确实依然为八，我刚判断完，我还没有来得及把你改成九，然后这个时候你用九把12给覆盖了。

你不又把别人的值给覆盖了吗，来能听懂这个问题的老师可以，对吧，所以cs如果你想解决问题的话呢，你你你起起码保证一点，就是说这个玩意儿一定是要是原子操作。

是不是你就是你这个最底层的这个操作必须得是原子操作，大家有的约会可能会说了，对，这个就是原子性吗，嗯就这两这两个必须中间不能被人打断，那他是怎么做到的呢，这个也是这是原来阿里阿里是面试的一个问题啊。

这个不跟不是说事事听啊，提阿里，这就是他面试的一个问题呃，为了解决问题呢，实际上整个过程比较复杂，我讲给你听啊，我一点点讲，你别着急，为了让你理解这个问题，我们可以考虑去读一下jdk的源码。

通过jdk的源码来解决，呃，你想读这个cs的源代码呢，我建议你，可以读这个类，这个类呢叫做atomic integer，atomic integer，呃，像我刚才讲的举的那个例子啊。

那个对于一个对于一个一个数字来说，我们好多线程呢都对它进行加加呃，我们要想保证数据的一致性，除了用锁之外，我们还可以考虑用用它用原子类叫原子的integer，atomic injure，什么叫它。

为什么叫atomic integer，就是在这个integer里面，它所有的方法都是可以保证原子性的这个意思，所有的方法都可以保证原子性，就是中间你不用上锁，也就是说你看这儿看这儿。

我最开始的时候有一个can呢，它的初始值为零，呃然后呢我这里呢有一，个方法m在这方法m里面呢，我给这个count加了1万次，叫increment and get，就是它的一个方法。

类似于count加加好吧，然后呢我起了100个县城，100个县城，100个线程，然后呢每一个县城的那个让他执行一遍啊，然后等他结束最后的结果呢，当然它一定是100万，为什么呢。

由于atomic integer内部全是原子性的，你不需要上锁，所有的结果一定是正确的，这小程序比较简单，呃，我我我我就我就不在这过多解释了，可以吧，还可以继续给老师扣一，我们主要探究的是什么。

主要探究的是tn地址，在没有上锁的情况下，没有用synchront的情况下，它到底是怎么实现的，对不对，好看这里，看你们问的这些问题啊，叫老师现在用的这个什么时候编程需要，第一你面试的时候必须需要。

第二，如果你想写那种高效率的，比方说抢票的这样的软件，他就需要买票，不可可以不使用分布式锁吗，如果你的票数很简单，当然可以不使用分布式嗯，分布式项目，分布式项目这种分布式的锁嘛，这个不难嗯。

atomic不就是用cs吗，呃这不是废话吗，我现在给你讲的不就是cs原理吗，老师现在用的是什么编程语言，这个编程语言不就是java吗，好看这里啊，我们aaa omic engineer。

然后呢我们我们看到的这个就是，这个atomic imager他在不上锁的情况下是怎么能做到原子性的，好不好，是马老师吗，可以试啊，咳咳咳，嗯，声音这么磁性，声音明显很雄性嘛，看这两个好。

我们继续count their increment，and get好，我们点进去，我们来看看这个背后的代码，它到底是怎么实现的，结果你会发现呢，哥们儿使用了一个类，这个类呢叫unsafe啊，叫不安全。

可能return on safe，点get and and it好，我们再点进去一点点看，当你我们点到这里的时候，你会发现它使用了我们unsafe里面的另外一个方法，这个方法叫什么。

叫compare and swap，and出现了我们熟悉的cs，看到了吧，好我们再点进去，结果很不幸的是，你会发现这里到了native，ok不是你们在聊啥，我的天，来来来来来来重，新来一遍啊，看这里。

为了探究atomic energy为什么可以不使用synchronized也能做到原子性，我们去看它的源码，count the increment and get，你会发现我们调用到了unsafe。

get at end，你会发现它调用了unsafe compared sweat，and也就是cs的方法，结果很不幸的是，当你读到这个方法的时候，它变成了native，native是什么意思啊。

native就是c和c加加的代码嘛，对不对，native是c语言或者c加加语言实现的，那好，那我们就看看c和c加加的代码好吗。

因为我们毕竟得追求。

高薪嘛，好如果你还记得的话，我们用到的那个，那个lay叫什么来着，java类叫unsafe，好对应的jvm源码里面就是这个unsafe，点ppt啊，sorry，点c p p p p t了，unsafe。

cpp c加加代码，那我在这个c加加代码里面，大家还记不记得他用的是哪个方法来着，叫compare and swap in，对不对，他们搜一下。

好看这里这里就找到了我们unsafe compare and swap inc，加加方法好，讲到这儿还能跟上的，给老师扣一，c plus plus这个什么软件。

我都不知道你们在关注啥，这什么软件很重要，不就读个c加加代码的软件吗，sublime嗯，然后呢我们要稍微读一下，就是它里面到底是怎么实现的，其实呢你其他的我全部给你略过，我们主要看最细节的代码就可以了。

代码在这，实际上它调用的是atomic这个类原子c加里面那个原子类，compare and exchange方法，那好那这个东西在哪呢，好我们点过去，我直接给你点过去，就在93号。

最终我们找找找找到了这个方法的最终实现，也就是我们atomic energy最终靠的就是这个实现好，这个实现是怎么实现的呢，你往这儿看，这里面有个简单的判断。

他说首先判断你os e m p这个呢我就不给你看源码了，mp这件事特别容易解释，它的全称呢叫做，multi，persons是吧嗯，多人运动哦，sorry错了，重新耕种啊，猫体，processors。

多处理器就是说如果你的机器上有好多个处理器，好多个盒，那么它最终的实现是怎么实现的呢，是叫lock if mp，这就不用我解释了吧，就if mp，如果你是多核，前面加一条lo，最后呢是有一个这个玩意儿。

这玩意儿是什么东东呢，这个玩意儿是一条汇编指令，compare and exchange，通过这儿你可以看到哦，原来在我们的cpu级别，在我们的汇编级别。

它就有一条汇编指令叫compare and exchange，如果这事你理解不了的话，画个图你就理解了，这是一颗cpu，这是一颗cpu，这是我们内存里面的某个数据里边写了个八，我的cpu有一条。

原始的指令可以用cs的方式，也就是compare and swap的方式来改，这个八cs方式怎么改呀，把八读到这个cpu里面来改成九，往回写的过程之中会比较八，你还在不在，如果你还是八，我就把你改成九。

如果不是我，我再重新读，能听懂吧，这就是这条指令的含义，这是一条汇编指令，这是从宏观层面，从微观层面都是一样的，来这块儿还能跟上这老师课印，那我当你对他就是底层的自选指令嘛，但现在的问题依然是一样的。

依然是一样的，就说这个问题啊，哥们儿，你是不是原子性的，如果你要是原子性的，我不用做任何操作，无所谓了，就是吧，你只要原子性的哦，我就明白了，原来是atomic。

到最后无非就是底层有一条原子性的语句给他支持了嘛，就这么简单嘛，对不对，好听，我说这个呢如果你去查英特尔的汇编手册，它会明明白白的告诉你，这个东西不具备原子性，原子性的，没有啊，不对没有。

那么到底怎么样才能让整个语句能够做成原子性的实现呢，它的奥秘就在于前面那种lock if mp，那好look if mp是个什么东东呢，我们点过去，其他的你不用管，你只要看这条指令就可以了。

lock if mp是当你有多条，当你有多个盒的时候，在后面的汇编语句的前面加一个lock语句，也就是说，也就是说最终的atomic的实现叫lo compare and exchange。

我给你写出来了。

这是轻量级锁的自旋，从我们从atomic integer啊，我们读到了unsafe啊，我们又读到了unsafe，点cp啊，我们读到了，lock compare and exchange，好了。

这是这条汇编指令，也就是说我们所有的自旋锁最终的实现全是它来这块能get到的，老师可以，当然一般来说面试题问到这个程度，这个深度就差不多了，呃不过呢有的面试官还会继续往下问，说为什么洛可能实现。

为什么lock能实现原则性，lock能实现原则性的原理，这个还要听吗，还要继续往下听吗，还要听到口音了嗯，好听我说，洛克为什么能实现原子性好听，我说呃。

一般来说最简单的是说当我们做后面这个汇编语操作的时候，lock会锁总线，这是最简单的实现，这也是一般cpu的实现，我再说一遍，这是一般cpu的时间，什么意思，这是一颗cpu，这是一颗cpu。

我们总是要通过这条总线，对不对，通过总线去访问内存这个吧，那么当我这个cpu做什么操作的时候呢，做这个操作的时候就改了个八的操作的时候把总线锁住，锁住的意思是说只有我能在上面传数据，其他人谁也传不了。

听懂了吧，那这就简单了吗，反正别人也传不了，那我先那个锁锁了之后，然后改改完之后再说好了，这是一种当然其实现在当然当然你可以想象一下啊，就是说如果说cpu锁总线的话，这是cpu，就是cpu。

你把总线给锁了，那等于其他cpu谁也用不了，能不能理解效率太低了好，那这时候怎么办呢，其实往往上往往这时候我们用的是什么呢，是锁，保存行，是锁这个缓存行，ok，什么叫损，不过这里要跟你解释缓存行。

又又又比较费劲了，大药停缓存行吗，就是我给你讲就就没边儿了啊，缓存行行吧，我一会儿讲讲讲给你们听，但是呢我这个河水喝的挺多的，那个哪位小姐姐来一下，踢我一小下，我去上个锁，不是嗓子不太好啊。

帮忙上个厕所对嗯，对，行行啊，求求求老师先跟大家聊一小会儿啊，我上我上个洗手间，hello，差点翻了，马老师去个洗手间哈，然后我给大家顶一会儿，我刚才都没有看到这个评论区，我一直自己在那说。

我现在终于看到了，上不上锁嗯，这个你说老板上厕所谁敢去偷看，是不是，反正m是不敢去排队，你们这个技术学得很好呀，生活中随时要用，刚好趁着这会儿人多哈，我再放一下这个码。

今天晚上的这个笔记资料是vip里边有的哈，没有加过小姐姐的，赶紧扫个码，马老师来了，这个码我就得撤走了，然后赶紧扫一个嗯，扫到下课之后，马老师把笔记发给我们，我们第一时间就发放给大家，然后录播的话。

你问一下你的小姐姐哈，所有的资料，所有的录播，所有你想要的东西，这个简历模板，大厂面试题，技术分享资料，职业规划的指导，你想要的一切，你直接扫码加小姐姐，有了就别扫了哈，专业一点，不要做渣男啊。

专业一点加一个就行，然后呃下课了之后直接跟他沟通，对好多程序员，你们都是海王，一个人扫n个，聊得过来吗，小九漂亮吗，小九特别漂亮，你咋的，你要分手吗，你可以考虑一下，可以换一个。

当你的女朋友不支持你干啥的时候，你就把它换掉，扫了啊，大家都记得，扫一会我把码撤走了，这些上面这五个点所有的资料都可以领啊，我把这个拿走，小壮壮好看吗，那就是天仙还好看嘛，你直接跟他聊就行。

马老师回来了，我撤了啊，拜拜，如此的迅速速去而赎回啊，好看这里啊就是这个我今天没打算讲缓存好的，但是大家想听的话，一并讲给大家听嗯，关于混子王这件事呢又比较复杂，我先把ppt打开，嗯嗯，好稍等啊。

嗯就是你，嗯看这里啊，就是关于缓存行呢。

系列 1：P47：50w年薪面试题：6：一个Java对象到底有多大你衡量过吗？ - 马士兵官方号 - BV1mu411r78p

缓存啊，缓存呃指的是什么意思，那个缓存呢我先给你解释指的什么意思啊，就是这是这是cpu，这哥们儿速度特别快啊，他就是博尔特是吧，这个内存的内存速度超级慢啊，马老师啊，那博尔特比马老师快多少呢。

大概快100倍，快100倍，那这个事儿就比较麻烦了，那就意味着说我cpu如果发出一条指令，然后去内存里面取一个数据过来，我发出指令之后，我得等99个时间周期，这个数据才能取过来，这个能不能听懂。

所以呢我们想增加取数据的效率，我们怎么做呀，办法特别简单，就是在cpu和内存之间增加一些中间环节，这是北京，就是上海，我取数据取太慢了，怎么办，能不能把上海的数据先放到徐州，徐州的数据先放到济南。

然后北京取的时候先从从济南取，可不可以在中间加几层缓存啊，还有这是缓存最基本的概念了，那好那它中间有几层缓存呢，一般来讲呢从cpu到内存一共有三级缓存，但这里有一有一些简单的数据。

是近几年的测试cpu的计算单元到自己内部的寄存器，大概是小于一个纳秒cpu，内部的计算单元，如果想访问主内存，约需要80纳秒，什么情况，no不会吧，他不会把我刚才，稍等啊，我登录一下我。

我别把刚才记记了半天的笔记给弄丢了，你不要这样地看着我，我给你记了半天笔记，别到时候给弄丢了啊，我先登录一下，ok ok还健在啊，good这就是缓存的重要性，哈哈哈，你说的很对啊。

好听，我说刚才我们讲聊的是这个缓存的最基本的概念啊。

好我们继续聊呃，一般来说呢，从cpu到计算，从cpu到内存啊，中间经历了三级缓存，当我讲到这儿，很多人可能会说，老师这个中间几级缓存为什么不是四级，为什么不是二级，为什么不是一级。

这东西是一个折中的结果，是一个工业上的妥协的结果，集数越多，你要存的份数也就越多，虽然说他访问最近的访问比较比较快，但是你要存的分数就太多了，那么集数越少呢，你访问的速度会稍慢，但是存的分数也会变少。

所以有利有弊，中间是一个折中的结果，听懂了吧，spring 3级缓存啊，这跟这个关系不大啊，别往一起混，这是cpu到内存之间中间有三级缓存，那么这三级缓存呢，分别叫l one l two和three。

那好这个l one l two和three长什么样呢，我们现在的cpu呢多数都是一颗一颗的唉这是一颗唉，这也是一颗在一颗cpu内部往往有好多个盒，这是一个盒儿，这又是一个和好了。

一般来讲我们的l one位于核的内部，l two呢也位于核的内部，而l three我们位于一颗cpu，多核共享，然后多颗cpu共享内存好，这个图能看懂的，给老师扣个一，相对简单一看就能理解。

但是现在我向你提个问题啊，我们现在的运算单元现在要找一个数值i，那么根据缓存它的理论，他首先去哪里找呢，首先去l一里面找，那l一里面有i吗，去内存里面找这个i，假如它是八好，这个班呢往l3 放一份。

往l2 放一份，往l一放一份，放到寄存器开始做计算，那下次我再用到这个i的时候，我是不是直接l一里面就有了，比如说我for循环1万次，对于i加加我，用得着每次都去内存里面读一遍吗，没有这个必要。

我只要从l one里面最近的那个缓存里面找到就ok，那这样第一次骑上是不是更慢了，是的，有利有弊，是这样的啊，好了同学们来这块能听明白的，给老师扣个一，那现在又来第二个问题啊，就是说同学们你们琢磨一下。

我们取数据的时候，是我们用到一个数据取一个吗，比方说我用个布尔类型，就一个字节，我就把这一个字节弄进来，那我想用这一个字节旁边这个字节呢，那不好意思，又得来一遍，从121~23到，然后再返回去又来一遍。

那为了改进效率，我们可不可以这样做，就是当我读这个数据的时候，把它周围的周围的数据一块一块的放进来好实际当中也是这么做的，这样做的话呢会提升效率，比如说我们对一个数组的循环，如果你不能，理解的话。

这是一个数组，对一个数组循环，我们取到第一个，我们顺带着也把它周边的一块往上放进来，放到l3 里，放到l2 里，放到l一里，那我们当我们对这个数组进行循环的时候，我下次再找这个数组的第二个值。

我就不用去内存找了，我这就直接找过来了，对这个被称之为空间局部性原理啊，没错说的很对，来这块儿能听明白的，给老师口音对象都有锁上，你还讲吗，其实跟锁是这这个跟锁是息息相关的，我们一块穿过来的啊。

我们讲这个lock lock所缓存缓存行锁什么东西，就是锁这个，当然有有有同学可能会说，老师啊，那这个大小到底是多少呢，就是你你你你把这块数据读过来，这块数据到底是多大呢，是不是越大就越好呢，未必。

如果你的数据特别大，那么每一次读过来，虽然你命中率很高啊，你你访问多数情况下都在l one里呢，但是你往l one里装数据的这个过程就太费劲了，因为你数据量数据很大，另外呢如果里边没有的话。

你得用用别的一块数据把这块给替换掉，太费劲了，那如果太小呢，如果太小的话，你命中率不高，每次找都得从内存拿一遍，所以又是一个工业，折中的结果好，最终的这个数据是64个字节，好吧。

来这个呢被称之为一行数据，一行数据啊被称之为缓存行，好了，这就是缓存行最基本的概念，而one和out two有什么区别，一个慢，一个快，一个大一个小，就是中间在济南和徐州中间加了一层而已。

没有什么太大区别，嗯那这块能听明白了，我们就来琢磨一件事儿了，我们位于同一行，在一个行里面，当我一颗cpu要用x值的时候，我们会把这一行数据从这里读进来，从这里读到l3 ，l3 ，读到l2 ，l2 。

读到l1 ，这个没问题，对不对，那如果说我另外一颗cpu啊，这颗cpu它用到了这个缓存行里面的y数据，那他用到y的时候，同学们你们琢磨一下这个y的话，是不是也得把同样一行读过来，读过来读过来。

那现在问题就在于，当我把这个改了之后，我要不要通知另外一边说这个，x已经被我改了，来这块能听明白的，给老师扣个一，就这里面也会涉及到同步的问题，那要不要呢，要还是不要是要的，不用啊，有的时候不用。

有的是说要这东西呢是取决于编程，如果你程序上要求说你必须通知，那么他就会通知，如果你程序上不要求仔细听，仔细听，我说，如果你程序上不要求，那么这个时候是通过一种机制来自动化的完成同步。

这种机制被我们称之为叫缓存一致性协议，好这个词儿我觉得应该都听说过，对不对，缓存一致性协议应该都听说过吧，听说我给老师扣个一好吧，无所畏惧，说敲完msi错了，那个那个不是不是。

不是那个那个那个那个只是缓存一致性协议的一种协议啊，我们要精确一点，嗯，不严谨对啊，说的很对，我再说一遍，这里头呢跟那个我们自己写的程序里面的锁没有关系啊，就是cpu内部的自动化的机制就是这样的。

就是在它的这个机制里面呢，由于一个缓存行很可能在多颗cpu之间存在，或者多个盒之间存在，那么这个时候就意味着，我们有必要用一种机制来保持它们之间的数据一致性，好这个数据一致性用什么来保持。

呢我们把它称之为叫缓存一致性协议，这个缓存一致性协议，有同学说volatile，这跟volatile半毛钱关系都没有，你千万千万别在这上面犯糊涂，我再说一遍，wallet tel。

缓存一致性协议是196几年就出现的东西，所以缓存一致性协议跟volatile没有半毛钱关系，ok由于缓存行的存在，缓存行存在的时候，就意味着我们必须要用某一种机制，好了好了，你们别在这露怯了，我的天哪。

jeffrey carry，别说了，说的一点都不对啊，这个这个再说就丢人了，别说了啊，看这里呃，就意味着我们必须得采用一种机制，让不同的缓存行在不同的cpu核之间保持一定的数据一致性，好吧。

那好那这种机制叫什么呢，这种机制被我们称之为缓存一致性协议，但是这个缓存一致性协议在不同的cpu之间，不同的cpu采用的是不同协议，就是自己的cpu厂商自己定的，英特尔的cpu被我们称之为叫msi。

而像其他的arm的，mac的，其他的各种各样的cpu，他们都有自己的协议，有的是m o s i，有的是m s i，有的叫synapse，有的叫firefly，有的叫dragon好，他叫什么没有关系。

总而言之，大家一定不能把msi称之为缓存一致性，它只是说它是英特尔cpu的缓存一定性协议，那有同学可能会说，老师这东西跟我们编程，有什么关系吗，展示一个小小的例子，看这个小例子，你要能读懂这个小例子呢。

必须给我记着啊，这缓存一行是多少，一行是多少，64个字节记住了，把这数字先在脑子里过一遍，64个字节啊，那在64个字节里面看这里，在这儿呢我们有一个class t t里面呢只有一个long类型的数据。

这个数据是x，long类型是多少个字节，八个字节，对不对，那一行数据我们说假设一个缓存行能够装多少个浪呢，打个龙好，我们继续往下看，在这儿呢我有一个关于t的数组，这里呢有数组里面有两两个t两个t对象。

这是第一个t对象，这是第二个t对象，接下来我做了一件事儿，这个抗的值是10亿，我用两个线程，线程和cpu的和是一一对应的，我用两个线程，这是第一个线程，第一个线程我对第一个t的x改了10亿次。

第二个线程对第二个t的x改了11次，这是一个小t对象，t对象里面有个x，这是第二个小t对象，这个t对象里面有个x，有一个线程玩了命的改，他改了多少次10亿，另外一个线程玩了命的给他改了多少次呢，10亿。

这是这个小程序所完成的功能，很简单的啊。

那好剩下的这段呢，实际上就是我来计算这两个线程结束到底要花多长时间。

好这小程序能看懂的，给老师扣个一不难，来我们来看一下这个小程序到底花多长时间呢，走你呃，注意啊，这里花的时间是775个毫秒，也就是说我循环这21次，完完事儿之后，796个接近800ms。

但现在我干一件特别奇怪的事儿，你可能以前没有见过的，我把这个打开，我就在他前面放上p一到p77 个没有意义的long类型，在它后面放上七个没有意义的long类型，然后我再跑同一个程序走，你。

这个程序变成了240个毫秒走你240走你240，嘿你还回回都240，241，ok好了，这个就比较好玩了，来你们好好琢磨琢磨，为什么我把它怼上了，七个没有意义的东西，放到前后的时候。

对他的访问反而效率提升了，为什么大家再看一眼，我把这个注释掉，我把这些注释掉啊。

你放心，我把它注释掉，马上变成800个毫秒，看到了吗，原因是什么呀，一次多一行，同行要共享，其实这个程序呢很简单的证明了就是缓存一致性协议的存在，这不知道大家能不能理解啊，看这里，同学们你们想一下啊。

我们说222个t对象，这两个t对象呢在最开始的时候呢，它是前后没有任何数据的遮挡，所以呢这个t对象那个x可以位于这个位置，另外一个t对象的x可以位于这个位置，这两个大概率位于同一行。

那当我们读数据的时候呢，我的第一个线程会把这个缓存行读过来之后，玩了命的改它对不对，然后另外一个线程呢就玩了命的给他对不对，那根据我们刚才所讲的，由于他们两个为同一行，那我对任何这行数据的更改。

我得需要用一种机制通知另外的cpu也，就是说这时候我们的缓存一致性协议，由于我这个我这个是那个英特尔的cpu，所以呢m1 si协议是不是就被触发了，他被处罚的话，他要不要耗时间呀，他一定会耗时间的。

我可以告诉你啊，就是缓存一这个m e s i协议定义是，你往l r r two里面写这个东西的时候，就得做同步啊，当然这是这是cpu级别的细节了，我们先不去管它，就总而言之，由于有这个机制的存在。

我们一边改这个数据的时候，一边还要做缓存一致性，所以我们总的时间就变长了，那有同学可能会说，那老师，那你为什么，前后补上七个，这玩意儿他就不会触发了呢，这个事儿他很难理解吗，我们来看这个简单的说明。

来这是我们的x，我在他前面补了七个long，我在他后面补了七个long，由于我一行数据是多少，64个字节来，你告诉我有没有其他任何有意义的数据能跟我位于同一行，有没有，绝不可能，你想想看。

这是我那个t里面那个数据，这是一个t的t的对象，有另外的t的x能给我为同一行吗，那不可能啊，你这个x最多在这个位置吗，或者在这个位置吗，但是你怎么算也不可能跟我位于同一行的。

因为中间已经够了64个字节了，好了，这会儿能听明白的，给老师扣一，那大家明白这件事儿之后呢，有同学可能就会说说老师真的有人这么写程序是吗，哎不好意思，还真有啊，这个人叫道个理，不知道你听说过他没有。

此人名叫道格里，jdk的作者，linked blocking cue，linked blocking cue。

那个类里面就这么写的，如果你还不能理解的话。

系列 1：P48：50w年薪面试题：7：一线大厂70~100万的年薪你拿的到吗？ - 马士兵官方号 - BV1mu411r78p

另外的一个中间件。

这个中间件的名字叫disrupt。

就是他。

它的名字叫做disruptor，你可以自己去查，它是英国一家做贸易做做交易的公司，就是做那个证证券交易的公司l max所开发的一款mq，一款消息处理器，单机版的，它的速度超级超级的快。

他曾经错过一个在开源领域比较有名的一个软件的奖项，叫杜克奖，号称全世界最快的单机版mq，为什么我们讲mq什么叫m q啊，叫message q叫消息队列，对不对，消息队列无非就是一个队列啊。

一个数组或者是一个链表，我们能往里头呢不断的往里头扔消息，还扔满了之后呢，等着消费者把它拿走，这叫生产者消费者问题，那，这哥们儿设计的是一个环形队列，有同学说了。

老师环形队列和这个单向的这个队列有什么区别吗，诶你突然间发现单向队列我永远是需要两个指针的，至少需要两个头，一个尾一个，但是环形队列我只需要一个指针，我只需要指在a下一个位置上就可以了。

下一个位置转满了，那就再指下一个位置，什么时候这个这个位置装满了，等着消费者把它取走，我就又指向下一个位置好了，来这块儿能大概能听明白的，给老师扣一，这叫环形队列，这设计非常的牛逼。

当时是他们刚设计出来的时，候那确实是震惊了开源节，所以杜克讲的也实至名归，当然在这个过程之中呢，他还使用了c，就是这个环形队列，说这个纸箱的这个地儿已经满了满了怎么办，转着圈的等待，知道吧。

他不会去找操作系统老大去等着他，在这儿等，转着圈的等等啊等等啊，等什么时候，你这又空了，我就把你放进去，效率很高，不需要惊动操作系统老大好了。

大家理解了这件事之后呢，我们来看看它的内部的一个实现。

我们刚刚讲的是环形队列，就是这个类的实现，ring buffer，ring环形的buffer缓冲区叫环状缓冲区。

点进去，看当你点进来之后，你会发现这里有一个指针，最开始只在-1这个位置上，下一个位置就是零吗，下一个就是一嘛，就开始转圈了吗，然后你突然间发现哦，原来这里还有特别好玩的p一到p7 。

当然我不跟你讲，你一定不理解这个东西干什么事了，因为这个缓冲缓冲区的指针由于是生产者消费者，所以生产者要用消费者要用多线程访问它是一定的，多线程访问它一定的时候，由于有缓存一致性的关系的存在。

如果它和别的数据位于同一行程的，效率一定就会低，所以我们在编程上阻止他和别人位于同一行，怎么阻止啊，就是在他后面给他怼上，七个long，这哥们儿是个long，八个字节，后面七个long。

56个字节加起来64个，其他人绝对不可能和和这哥们唯一统一好了，因为你是64个字节之外了，对不对，来这块能跟上一个老师，可以，大家会讲到这儿，有同学一定会问，前面呢，你万万万一有数据。

你是你是后面后面没有人根据位于同一行了，那前面呢万一有数据的wave放在这儿呢，这哥俩还是有可能位于同一行呀，对不对，别着急，我们看这个rain buffer。

它的父类是叫做rain buffer fields，对不对，走你remember fields，父类叫做remember padding zoning。

结果你符文发现在他爷爷里面又装了七个狼，那么根据java对于对象的排列规则，他爷爷的数据会排在前面，他会排中间，自己的数据排后面，ok这哥们儿永远不会跟别人位于同一行。

来请把牛逼两个字打在公屏上。

这就是为什么那个，缓存行的存在啊，我只是下去证明了缓存行的存在，三级缓存也s，以及，缓存不同行的，编程技巧，那有同学说了，老师你讲半天了，不是讲了个lock的吗，现在还能回得来吗。

讲着讲着公开课嘛，我们就分分分散，属于是那个很很很开放的这个思维。

就开始慢慢的往上往往上讲是吧，讲到哪儿算哪儿，我们讲logo logo是什么，logo是叫索缓存行，记得，发散性课程对发散性讲课。

log呢叫做索缓存行，也就是说呀原来锁总宪，你所把所有人的这个通道全给锁了，大哥这个太狠了，这个不合适，人家本来不想人家，你访问的是这个数据，结果你把录一录一读，人家去访问别的数据都访问不了了。

这个效率是不是不是太低了，他肯定低，我再说一遍啊，这是这是cpu，这是cpu，你们哥俩去访问内存里的同一个数据八，但是内存人家还有别的数据呢，您您您老人家在这个这个cpu在访问这八的时候。

把这路全给堵了，我这个cpu想去访问别的数据都访问不了，能不能听懂，所以我现在改成我只锁定这一行，就锁这行好吧，对我就锁我自己的数据。

我不占用别人的数据，好了。

所以我们效率是提高了lock，这是它的底层实现。

我们再往回，因为我们从脑袋开始讲锁，讲重量级所讲轻量级锁。

讲那个交给操作系统的重量级所讲给自己管理的cas自旋锁。

我们再往回还能回得来吗。

我们得回到这张图上了。

好我们再往回再往回的问题，现在我们讲了两种类型的锁，这种类型的锁呢叫cs，这种类型的锁叫重量级，注意这个重量级未必不是cs，这个重量级只是交给操作系统老大，本来这个里面全是jvm自己管理。

这是gm自己管的o然后呢，您老人家要是交给操作系统老大，那不好意思，这个就叫重量级，因为你需要经过中，间人他就一定会中，你自己管就要轻得多，那自己管这个过程和重量级锁，这个过程。

我们你仔细想一下阿里的一个问题，为什么我们有了轻量级锁，还需要重量级锁，能不能听懂，来我把这个问题写出来。

为什么轻量级锁可以解决同步问题，自选吗，但是也需要重量级所有的存在，y原因是什么，一直自寻，他也不是个事儿啊，唉这大家伙脑子都在线啊，不错对，这里面没有跟大家交代重量，你所有一个最重要的阶段。

这个重量你所的阶段是什么呢，重量你所有一个最重要的它的机制啊，叫做排队，注意轻量级锁自旋是不排队的，什么叫不排队的呀，这个，有一哥们儿在里边儿坐着，比如说是如地如底在这坐着，然后你像其他什么海啊，坑啊。

石头人啊，爱拼才爱赢才会拼呀，来了来了之后干嘛呢，转圈儿，拎着裤子赶紧转转转转转转转转转转转转，然后谁先发现rudy出来了，谁就赶紧进去，他是不排队的，不排队，ok那不排队不排队的意思是什么呢。

它就它就是一个while循环，它是要消耗cpu资源的，while循环也是一种语句啊，它是需要消耗cpu资源的，它是一种循环，那我们所谓的重量级所在操作系统的某一个阶段上。

它是要进行现成的排队指的是什么意思呢，就是这个县城在抢不着锁的时候来给它一个队列，你去里边给我等着，什么时候我叫你，你再出来，等着叫你再出来，等着叫你再出来，我想问你当一个县城在这里等待的时候。

也就是平时我们所调用o。weight的时候，不知道你现在能不能理解这个，weight的含义了，当我们进入这个这个这个里面等待的时候，它需要消耗cpu吗，它不需要，什么时候我cpu说来。

小伙子你出来走两步，你才出来消耗cpu好吧，曹玺总说，轮到你了，来来你出来走两步，ok他才出来消耗cpu，来这块能听懂的，给老师扣个一，我给你讲所的本质，同学问你们有没有印象。

我们写我们写写写写程序的时候，我们说synchronized，t然后我们往往有的时候会使用t。weight方法，有印象唉，所谓这个t。weight是什么概念呢，什么概念，t是一把锁，刚才我说过了。

他脑袋上的改变，就是那把锁和这把所关联的，有一个队列，所谓的t。weight指当前线程，进入队列，wait就直接去排队了，等待什么时候，我叫你t点，notify。

指的是我这把锁上的队列里面随机叫醒一个线程，这个队列是在哪里，这个队列是在jvm的c加加代码里，好刚才讲的这小段能听明白了。

给老师扣一那行，那现在你回答阿里这个问题，可以随机叫醒，也可以特定叫醒，就看你程序怎么写，来回答阿里这个问题，y我轻量级锁也可以解决这个问题啊，为什么需要重量级，在什么情况下用轻量级，用清。

好其实超级简单，你们想这个事儿就行了，现在如在里边儿干活儿，干得不亦乐乎，然后呢，肠胃有点不好，一进去就半小时，外面等了1万人，1万个县城拎着裤子在这里使劲转圈儿，cpu还要在线程之间来回切换。

你告诉我，这个时候我们用自旋锁合适不合适啊，他当然不合适，太消耗资源了，线程数量多，等待时间长，这个时候不适合用自旋锁好了，如果说我们这1万个县城，这时候我们怎么办，等的时间那么长。

1万个人去排队去放到队列里，没有关系啊，什么时候rudy完事了，来喊一个哥们儿出来来到你了，进去完事儿搞定，当然如果说如，这哥们儿呢他是快男啊，非常的快，好，进去之后呢，外面等了一圈儿啊。

俩人就俩人不多，这边呢一秒完事儿，这边发现完事儿了，转两圈就就进去了，ok good，自旋锁，好大家听明白这个问题的就可以了啊。

系列 1：P49：70w年薪面试题：1：一面关于P5的难题是什么？ - 马士兵官方号 - BV1mu411r78p

好不废话了，一点点来讲啊，我们嗯用我用最通俗的方式给大家快点讲，其实这里面每一个问题我要讲起来的话呢，都是比较费时力，费时费时间的，但是我用最通俗的方式讲给大家听，大家注意看就行好。

首先我们来解释一下什么叫乐观所好吧，看这里我先给大家解释什么叫乐观锁和悲观锁，我解释这三个概念，自旋锁，悲观锁，乐观锁，自旋锁，听我说，那什么叫悲观锁，悲观锁就是干一件事呢，先往坏处想。

比如说我说一句最简单的，这时候去上厕所，要去马桶上干点事儿，但是只要他一进去，看见马桶空着，当他开始干事的时候，他会会非常悲观的，预计会有人闯进来，能听懂吗，这就是悲观锁的概念，他非常的悲观。

会有人会认为一定有人闯进来，那当然还有另外一种人，另外一种人什么样的，另外一种人是哎，我先坐下，有人闯，进来我再说，有人闯进来，我在做处理，那这种叫乐观的人，你们是悲观的人还是乐观的人，哈哈，都老师了。

我是憋不住的人，好吧，算你狠好听，我说，所以悲观的人会怎么办，悲观的人会进去之后，有人没人都上把锁，能不能听懂，这是悲观的人干的事儿，乐观的人会怎么办，乐观的人是进去之后先干事儿。

如果有人过来之后再把他推走也行，哈哈或者说有如果有人过来啊，排了点出来再给他塞回去也行，就是总而言之，你有人过来之后，我们再做进一步的处理啊，这就是悲观锁，乐观锁的概念非常的简单，那我想问大家一句。

你们平时所接触的synchronized，他这种人我们称他称它为悲观还是乐观的，就如果我写一段话的话，我这样写synchronize，什么什么什么唉，这肯定是悲观嘛，是不是就是你siri这件事来说呢。

就是二话不说，您来了之后呢，上来先上锁，我先锁定，锁定之后才能干事，我不能不锁定的时候是不能干事的，好这种就是悲观锁好，这是被关锁，乐观锁的概念很简单吧，坏事一定会发生，所以先做预防，乐观锁呢。

坏事未必会发生，所以，事后，补偿啊或者适中补偿啊，总而言之呢就是嗯未必会发生自由，我不上锁，先做预防怎么办，上锁，a sorry，先上总，那么这种呢好，我们说一种最常见的乐观锁的具体实现。

它就称之为自旋锁，所以说自旋锁这个概念如果深究的话，它是一种乐观锁的实现，好自编组什么意思，我做最简单的解释，我觉得大家应该应该能听懂，自选锁的概念是说嗯这里举个最简单例子啊，这里这里有一个零。

然后呢我们好多县城都对它进行做加加的操作，那大家知道如果不上锁的话呢，这个零加起来没准儿啊，我加了1万次，没准只能得到个1000多，2000多，这都是有可能的，好听我说。

那么第一种方式是我在加加的操作里前后上锁，synchronize，这种叫悲观锁，还有另外一种方式是我们做一个乐观的处理，乐观处理什么样呢，最简单的方式是说我把这个零读过来做加。

加操作变成一一往回血的时候做一个检查操作，这个检查操作呢被他称被称之为cs操作，叫compare and swap，当然它为什么叫自旋呢，是因为呢如果中间有人改过它了。

那么compared to swap之后呢，读新直过来，这是什么意思，你认真听就行了啊，认真听就行，这是不需要上锁的，就是把这个零拿过来，我把它变成一以往回写的过程之中，如果有其他人已经上完锁了。

已经已经已经把这个值给它加过了，比如说变成八了，同学们，你们你们能够把这个一用用这个108覆盖吗，这个肯定不行，是同学们，这是这，是不行的，那这时候怎么办呢，如果说这个过程之中，你从零已经变成八了。

变成八之后，我把这八再读过来，九再往回写，写的过程之中，如果你这个八又不小心变成100了，我把这100读过来，变成100，一，再往回写，终于有一次往往会写的过程之中，你依然还是100，依然是100。

好那说明我在这次操作的过程之中，没有任何其他人改变过，我在这次操作的过程之中，没有任何其他人进来过，所以我就把你改成101搞定，来这块能get到的，给老师扣个一，那么这块的话呢就不用上锁了。

这种的呢被我们称之为叫自旋锁，那什么叫自旋呢，就是它那个一直循环一直循环循环到有一次成功为止，哎100的过程中，你看啊玩家说100过程中变成101又变了呢，简单呀，比方说变成200了，你就继续来。

什么时候成功一次，什么时候为止，好吧好了，这种人能被我们称之为自旋锁，也叫做cs所，好大家理解这件事之后呢，当然关于自然所面试题比较多呃，关于自检所的第一道面试题是aba问题，是著名的问题啊。

那么第二道面试题就是就是就是现在这种面试官他会追问你啊，你要是深入了解的话呢，这里边东西确实还蛮多的，刚才有同学说了，说这第一道题就得打两小时是有可能的，我快速给你过，因为后面题比较多呃。

第一个问题是aba问题，第二个问题是保障，cs操作的原子性问题啊，那这个问题比较简单，这个问题是一条lock指令，是底层的lock指令汇编级别的好吧，那么a b a问题是什么问题呢。

a b a问题是说唉还是这个零变成一往回写的过程之中呢，发现它依然是零，然后我往回写写，写成一看上去很简单，但是呢这个零啊很有可能是有的线程已经把它改成八了，然后另外一个线程又把它从把改回成零了。

所以它这个零呢虽然看上去还是零，但他中间经历了一个从0~8又到零的过程，好这种呢被我们称之为a b a问题，这个能不能get到，能get到于老师扣一，来就说你看上去还是那个零啊，女朋友例子是吧。

你们非要举那个女朋友例子吗，可以举一个呃，就是这是你的女朋友，这是你的女朋友，然后呢你出差了，等你回来的时候，发现还是你的女朋友，但是这个事情呢中间是不是经历了什么操作，这个就说不说不准了啊。

那这个时候呃当然a a b a a b a问题的解决方案呢就比较多啊，我跟大家简单说一下，a b a问题解决方案其实是有两种啊，就是加其实就是一种嘛，就是加版本呃，从java的时间来看的话呢。

这个jaa版本呢它有有有有这么几，个啊，就是第一个呢是加版本号啊，version，第二个呢是布尔类型啊，就是这两种方式呃，这个如果说不能理解的话呢，你看小例子吧，嗯老师讲的多线程的课，嗯看一眼啊，第一。

就这种啊，这个是那个呃我我们说这是呃呃atomic dereference，这个东西呢是在java里面呢它的一个常用的处理版本号的一种方式，那么在这个版本号里面呢，呃一般来说做任何的操作的时候。

你都有一个sequence，就是你你可以简单理解为你走的时候，给你女朋友脑袋上的写了个一好吧，然后呢如果经历一点什么事情之后呢，这个值就要加加啊，等你回等你出差回来之后。

你发现这里变成了9900 9999，那就说明中间经历了好多好多事情啊，这个大家能不能听懂啊，这能get到的老师可以好吧，这就是使用版本号的方式来解决哈，好那么除了版本号的方式之外呢。

实际上还有另外一种这种呢叫markable markable reference，那么这种方式呢其实它采用的方式是说用一个布尔类型啊，true和false来解释，比如说那么呃这是你的男朋友。

然后呢你你你你你出差之前你啊他脑袋上写了一个写了一个false，好，等你出差回来之后，他脑袋这个false变成true了，那就说明经历了一些事情好吧，当然这个就记记录不了次数了，就是你不在乎次数的话。

你用markable，你如果在乎次数的话呢。

用version好了，这块能get到的老师可以，那如果他版本版本号不对，会干什么，这个就看你自己处理了，你发现他版本号不对，那怎么办，说明中间有人改过，那你要不要检查一下，读一下日志，或者做一下回滚啊。

或者把它踹一边去，这个是你自己处理的事情，ok这是a b a问题啊，当然下面这个问题比较复杂，我在这儿就不想展开了，这个问题的话需要跟到呃，我们汇编指令里面去啊，我在这就不展开了好吧，离婚。

这是你的男朋友女朋友啊，她她并不这个男朋友女朋友并不是单例模式诶，他不是单利，人家可以有多利的，ok啊，single at the，mitan，好这三个概念可以应该清楚了，就悲观所乐观所自旋锁啊。

好我们再来再来继续看，好不好，我们再来看一个啊，再来看一个呢，这个这个东西叫什么呢，叫读写锁啊，排他锁，共享所好读写锁排他所共享所有同学说了，老师这个东西难道还能够这几个概念是是是类似的吗，有点类似。

听我说就行了啊，第一种叫排他锁，排它锁的概念非常的简单，只有一个县城，能访问代码，这是什么意思，最简单的理解，你到一个坑里去之后，只有你一个人，不会有更多的人进来啊，除非那种非常特殊的坑。

这里有面对面的，还有这种麻将似的哈，一边一个坑，这边一个坑，这边一个坑，这边有坑，这边坑中间一桌了啊，当然还有还有这种的啊，这个都可以好不好，但是如果里边只有一个坑的那种呢，啊，特被称之为叫排他所。

只有你一个人能进好，那如果这种人呢这种的啊，你把它看成一个完整的一个坑的概念，这种就可以称之为叫共享锁嗯，还有，上下坑了算你狠啊，有上下铺共享锁哈，共享所知是什么意思啊。

共享所的意思就是说可以允许有多个线程啊，装代码，好了，这是排查所，是共享锁，很简单吧，那synchronize是排他锁吗，来你说说看我刚我刚我刚刚才那个小伙子4834问了个问题啊。

说sychronize是排查所吗，大哥你synchronized的锁定的这段代码是不是只有一个线程能访问，访问完了之后，其他线程才能继续访问，这必须是排查锁好吧，当然有同学可能会问。

那什么东西是共享所呢，我跟你说java里面的共享锁呢，呃它默认的啊，它常见的有这两种，那么第一种是什么呢，第一种我们称之为叫sam for，叫信号量呃，信号量就是你你在这里面呢，你可以。

有两个线程进来permits啊，一共有两个，当然你可以写啊，二二百个也可以随你呃，还有一种啊，还有一种比较常见的呢实际上叫读写锁，我觉得这个读写锁呢实际上是要比sumer比信号量呢更加能说明问题。

所以这里呢我举了一个读写锁的概念，那读写锁是什么意思呢，读写锁的意思呢就是这把锁里面实际上它是一个锁的管理器，它管理着两种锁，就是这个读写锁里面有两种锁，一种叫毒索。

读所的意思是说当我一个人在里面读的时候，不允许写，但是允许，同时读，那写写锁的解锁的时候是写的时候不允许写，不允许，写也不允许，那么你你你读一下这两句话，这个读锁是一个什么锁呀，是不是共享锁呀。

就是允许其他人同时读吗，那解锁呢，解锁就是一个排他锁，这个怎么理解啊，我们举个小小的例子，他的名字叫那一天，你要很幸福好，新闻讲多久，错过了吗啊有一个人叫白虎吧，白虎进坑了，呼哧呼哧排了很多东西。

然后呢白虎呢就就就就就暂停了，这个是白虎是什么，他是写是吧，往里头写了很多很多数据好，当它暂停了之后呢，当他让出这个锁之后呢，围观好，这些人都是读读，有多少人在围观都没关，都都没有任何关系，听懂了吗。

好那那就那个那个那个白虎又要往里写了呢，其他人就不许围观了啊，等我写完你再围观，因为你如果说在我写的时候，你围观的话，你很可能会看到，读解锁的概念，能不能听清楚排查锁和悲观锁的区别是什么，没有什么区别。

排查所围观所区别就是概念上的分配不同，比如说圆的事物和方的事物，这两类事物两两种叫法嘛，好鸡蛋圆的是吧，砖头方的那能吃的和不能吃的也是鸡蛋和砖头的分别，它只不过是分类方法上的不同。

脏读不是数据库里面才有的概念吗，哎哟我的大哥，脏读是任何的中间状态，只要被别人读到就可以叫脏读灵活一点啊，同学们千万别把概念给学死了，脏读本身的概念叫做我读到了别人不允许我读的中间状态能不能听懂。

就是说我一定要穿，把衣服穿好了才能见人，在我穿衣服的，整个过程之中我是不见人的，那么我的衣服穿了一半，如果出来见人，读到了我的中间状态，有一个数字，我要对它加八次，我才能允许他往外见人。

我加了四次的时候被别人读到了，不好意思，好p5 的不太难吧，应该好多人叫统一所分段锁，其实这个统一锁这个概念呢，刚才有同学问说什么叫统一所分段所，统一所这个概念呢，就是不分多少所啊，这个可以叫统一所。

可以叫大化的锁，统一所一般解决什么问题呢，一般就会解决，有大力度的大力度，分段锁呢可以叫分成一段一段的小力度锁啊，小，什么叫统一所分段，这是什么意思啊，就是那个那个一个大锁，一个小锁的意思。

大颗粒和小颗粒的意思，有同学可能会说，老师这个这还有什么大的小的区分吗，这有区分，听我说，我给你举个最简单的例子啊，比如说如果锁定a等待b我有我有一个线程锁定a，等待b还有一个呢叫锁。

还有另外一个线程呢叫锁定b，等待，等待a同学们，你们想一下啊，如果说这两个线程如果同步做的不好的话，会产生什么效果，死锁能不能理解，是不是死锁就会死锁了啊，呃那那呃我们想解决这个思索的问题。

有一种常见的解决方案是什么，是什么，是什么样子，常见的解决方案是什么样子，把a和b统一起来，做成一把大锁，就完美的解决了死锁的问题，ok这种就叫统一所或者叫大颗粒的锁，大力度锁嗯。

他一般是用来解决那个死锁的问题，当然这东西分事儿啊，就是有的时候统一所能力度太大了啊，你比如说给你举个最简单的例子啊，我那个往数据库里插一个插一条记录，我把整个库全部锁定，力度是不是太大了。

那这时候你还要拆分呢，你可以到行几所是吧，可以到表自己所户籍所，这个就看你需要做什么样的一个具体的业务了，如果我我再给你举个例子啊，如果现在我们有两张两张表，我们举两张表的例子吧，我锁定这张表。

我要等待另外一张表的锁，假如说但这种操作很少啊，一般来说是数据库事务的话，呃，数据库内部的锁的话呢，我们就整个锁定我们整个的那个那个那个一个数据库事务就搞定了啊。

然后呢另外一个操作很可能是锁定这边等待列表，那这个东西会就会造成思索，那怎么办呀，好了朋友们，这个叫统一锁，那什么叫分段索呢，就是分成一段段小粒度锁，这个最常见的代码是什么。

听我说是jdk一点七的concurrent hashmap，这叫凉了啊，concurrent hashmap，这个这个是用来干什么的，是什么意思，我给你举个最简单的例子就行了，同学们，你们想一下。

如果说我有一个我们说我们说数据结构吧，我有我我有一个我们说链表吧，链表的例子最容易举清楚啊，好我们这有一个特别长的链表啊，几万个数据，几10万个数据，甚至上亿个数据，这样一个链表。

那假如说多线程对这个链表进行访问的时候，比方说往里头插入数据，多线程进行访问的时候，多线程往往往里插入数据，是不是我每插一个数据就要锁定整个列表啊，锁定整个链表能听懂，那我如果想提高效率的话。

我可以把链表分成一段一段的，我只锁定这一段，我并不锁定整体的，那么其他的段也能同时进行插入，这种就被我被咱们称之为叫分段锁好了，这个p5 的题我就解释完了，看大家伙是不是理解了。

好可以继续，同学老师扣个一，有问题你直接提好不好，上班，有没有测试用数据库表数据库，百万数据库，用测试机构语句嗯，你自己做实验不就行了吗，有代码示例吗，我刚才给你不得看，给你看了，看了好多好多代码吗。

电器所监狱所主要解决的是这个mysql的一个，呃是mysql mysql关于事物这方面的提升效率的一个问题，交易所解决幻读的问题，对这个跟咱们jdk的还稍有区别啊，好了奸细所嗯，屁股多少年薪是吧。

好建议组先你留一下啊，天系数a组稍微复杂一点点，它主要涉及到那个，数据库的行级锁和那个几行级别的这样一种锁，我得稍微准备一下，回头我再讲给你们听啊，三分所一边一般在。

sam ford所一般在什么情况下使用，呃，比如说我给你举个例子，假如你要模拟一个这样的一个状态，这是好多车，然后呢进入到我们的收费站，我们收费站有两个口开放，那你可以用允许两个线程同时运行吗。

不就是就是我们常见的那种什么排队啊，卖票啊，这些都可以理解为是summer的一个运用，限流yes，嗯，1年多开发经验能变阿里p v p6 吗，够了嗯，好那个刚才小伙说那个p5 多少钱是吧。

p5 的话是这么多钱，p5 的话是大概。

p5 大概的钱数，大概是这样的，20万~40万呃，p5 是20万~40万，一般来说呢他们面向的是应届生，应届啊，也就是说不管你是本科还是研究生，那么本科研究生的区别呢，就是本科的他的年薪稍微低一些。

研究生的年薪稍微高一些，另外呢本科生p6 稍微的慢一些，研究生升升p6 稍微快一些，就是给你安排一个任务啊，告诉你明天下午呢把呃订单处理的这段代码给我敲完好，你把它敲完就可以了，这个是p5 的一个要求。

好吧好，我们可以继续可以继续吗，那13可以算pd 13可以就是多少多少星啊。

你自己你自己定级吗。

系列 1：P5：JVM瞬间涨薪3K的操作：5.ZGC的颜色指针算法为什么可以比G1更好？ - 马士兵官方号 - BV1mu411r78p

指针这个指针呢它里面存的是个地址，这个地址a指向这个t，这是最简单的java的语句啊，以及它的内存布局是最简单的，对不对，原来我们所谓的垃圾回收啊，都是在这里头，堆内存里头做各种各样的解决方案。

都是在这里头想办法，cdc采用了另外的思路，cdc是在这个小t上想办法，是在这儿想办法来，所以我们下面要关注的是这个指针本身，这个地址本身来，我刚才讲的这一小段能跟上的，给老师扣一。

ok那这个地址首先第一点，cdc是不支持32位的，所以cdc的指针最少是64位的指针，好吧，大家都知道这个64位的指针呢，最长的寻址空间啊是二的64次方，二的64次方，没有这么大的内存。

用不着这么大的寻址空间，只用其中的这部分就可以了，这部分是42位就够了，那么42位能寻址的空间是多少呢，二的42次方大概是四个t，后来呢cdc又加了两位，一共有44位jdk，13的时候。

大概现在寻址是16个t嗯，现在很少有这个大家见过16个t内存的，机器吗，我是没见过，我见的最多的是1。6t，我记得是1。5t左右吧，你们见过有谁见过16个t内存的机器，有没有有有有有，应该没有啊。

有结果，那就见了鬼了好吧，所以呢我们说指针长度用不了这么多，用44位就可以了，所以后面有一堆呢没有用的那个位位，怎么办呢，就在这里给做出几个标记位来，那么这几个标记位用来干什么。

用来标记我们这个指针的状态，比如说我们这个指针在所有的分区里，最开始的时候是一种状态，当然这种状态呢叫rema，然后呢当我们开始标记，的时候，我们主要解决的不就是并发标记的问题吗。

我们开始标记的时候就给它标成mark 0，m0 ，标成m0 啊，每个对象都给它标成m0 的状态，表示我我标记开始了啊，我标记开始了，然后对于这个m0 的处理，这个过程嗯比较复杂。

我只能说我今天呢就给你简单讲讲，讲原理就完了，好不好，后面我找时间，我专门给大家把这个过程给大家做成动画，你就更容易理解了，就是当我找到这个m0 对象的时候，我只要从根上开始找啊。

我垃圾回收器从根上开始找，我只要找到任何一个对象，我就，把它标成m0 ，好，我再说一遍，稍微的多说一点点，最开始的时候我们有一个对象的状态，整个整个内存里头啊，分了好多区域，首先这是第一点。

分了好多区域，好在这个区里面所有的对象都是一种状态，这种对象的叫remap，它具体是什么意思，我们不管，然后呢，我垃圾回收器十点钟开始找，我从根儿上的对象开始找你女朋友，你男朋友找到一个对象。

我就把它标成m0 ，找到一个对象，我就把它标成m0 ，所以最后就会变成什么呢，我们整个内存空间里都会变成有m0 存在，有remap的存在，凡是m，零就是活着的，凡是remap就是垃圾。

这个不知道大家能不能理解啊，然后比如说它它它在这个指针上，它只动指针，它不动内存能听懂吗，这块就简单多了，当然它中间呢把这个m0 找出来之后，如果我们决定要回收这两块空间，那这个过程也比较复杂。

他需要把这两块空间的对象，给挪到另外的一块空间里面去，那就意味着这个指针这个值是不是得变呀，所以它后面再加一个屏障，就jvm级别的屏障，只要是m0 级别正在挪动的时候，就把这个指针给它变过来。

所有的业务线程访问这个m0 的内容的时，候，就把这个指针的内容给他变过来，好不知道我说清楚没有，大概的啊，16t的硬盘都没见过，这个过程本身比较复杂啊，有m0 m1 ，cdc没有完全听明白了呢。

就先放过他，关系不太大，目前主要是目前的关系不太大，嗯现在是09：50，我从现在开始啊，来给大家讲解一点关于实战的内容，可以吗，来准备好的同学，你们还活着，还能跟上吗，还在吗，老师扣个一啊，这么恐怖。

内存地址都变了，不是杨树啊，这个杨树居然问了个，这么这么这么土的问题，大哥来，各位同学，到目前为止，你们好好思索，我们所讲过的任何的所有的垃圾回收器，有没有一个不用变内存地址的，有没有，琢磨琢磨。

我说的是所有的垃圾回收器，1+7怎么了，看见你了，有没有一个不用变内存地址呢，一个都没有，我告诉你，因为我们说年轻代的，你们想啊，就是年轻代的这个这个这个算法的时候，是需要把对象拷贝的。

对象拷贝什么意思啊，不就是把这个对象的，从这个地方拷贝到了另外一个地儿，那我想问你指向这个对象的指针，你你你你这个值不变吗，不然的话你通过原指针还能找得着吗，所有涉及到复制的地址是一定要变的。

所以这个东西跟恐怖不恐怖，有半毛钱关系吗，都要，变啊，还能跟上吗，好我讲点实战，讲点轻松的啊，理论的内容啊，确实它非常的复杂，告诉你嗯。

讲点稍微轻松的，讲点实战实战就是就就轻松多了呃。

教大家一点。

小小的实战的内容啊。

呃首先教大家第一个命令就是java conversion，我同学说这个不用交，这个都会是吧，呃大家听我说，这是检查java到底属于那个版本呃，同时呢直接就敲诈吧，什么都不敲回车。

你会看到这是jvm的所有的参数，凡是以横杠开头的参数。

这些都要标准参数，我们所谓的jvm调优。

我们调的什么东西呢，参数的值就这个意思。

凡是以横杠开头的，全部都是叫做标准参数，这里面呢我们应该也有的人是用过不少的，比如杠version，我刚才给你用了对吧。

指定class path路径等等，呃当然还有同学可能如果听我讲课，有可能用用过这个叫杠java是吧。

这是那个java编程接口啊，呃当然还有其他各种各样的杠，第323 12位的杠，第646 14位的呃，server server模式。

client client模式是吧，这都比较简单呃，有同学可能会说，我我我我去了解这种参数的时候，也太简单了。

就这么二三十个，我想调的时候非非常容易调啊，呃没那么简单，因为真正调参数的时候呢，往往有第二种参数，那么这种参数呢叫做nonstandard options。

print help on nonstandard options。

以杠s开头来瞅一眼clear。

这样的杠x回车好，那我们回车之后呢。

我们会看到以杠x开头的参数，这些参数。

那么我估计有同学应该会用过这个杠，xm堆内存的最小大小啊，你可以设我这个java程序要用多少内存，最小用多少杠x m x，最大有多少杠x s s是吧，这个是占的大小。

哎咱们小姐姐有人带吗，跟同学们聊会小天，我得喝点水，嗓子快疼死了啊，大家稍微等我一下，我我我喝点水，上个上个上个厕所好不好。

老师用的什么环境，win还是mac诶，我想问你，jvm在生产环境里头，一般运行在什么环境上，对呀，老师用的当然是linux了，我在win下面给你演示，没有意义的，听懂了吗，我在mac下面给你演示。

稍微有点意义，因为它叫做类类类unix系统啊，ok让我们九妹跟大家聊一小会儿啊。

我上省会。

ok我我我我们继续上课，呃vip课呢肯定讲的比这个要细致的多，呃，比方说每个参数什么意思都会讲给大家听，呃同时呢也跟大家说一声，今晚呃如果对课程有兴趣的，呃我们今天晚上的报名的话呢，也是双11的优惠。

那么1年之中呢最大的一次优惠了，双11呢我们今晚报名的呢，也是有那个抽奖的权利，然后的话呢报的越早的话，抽奖的概率就越高啊，就是这么设计的，ok嗯刚才呢我讲到说呃，我们进行一个jvm调优的时候啊。

没有两种参数啊，第一种呢是横杠开头的，那么这种呢是标准，参数第二种呢叫非比非标参数啊，杠x开头呃，其实我们读一下的话也就几十个，看上去也没那么复杂，但是呢实际上这里头是没有显示出来的，是另外一种呃。

另外一种参数就是以两个x开头的，是这种的java杠x这个开头的，那么这个参数呢，不知道大家同同学有没有用过呃，有用过的同学老师扣个一来有没有，有有吗，嗯不对啊，呃哼呃，戴尔好像加我微信了，还是吧。

ok笑傲江湖，ok gus开头的这个参数到底有多少呢，呃由于它没有显示出来，所以我们必须用一个命令来告诉大家，这个参数到底有多少，我们这个命令是什么呢，有两个命令啊，用其中一个就行了，print。

flex final，那这句话的意思是说，我们把java虚拟机的所有的flag，就是所有的参数，它最终的那个值全给你打印出来，由于这个数值特别多，所以我让他分个页，加一个more。

回车好，这是第一瓶从a开头的参数。

b开头的，这里我们会看到我以前讲过的偏向锁c。

ok这个到到底有多少呢。

wc杠没事嗯。

恭喜你，一共有728行啊，大概有700个参数左右吧，扣了扣了这些个。

大家都在那干嘛呢，在跟着克总吗，出来了是吧，来你们你们试过了是吧，哈哈哈，呃你的这个mv需要调优的话，大概有700个参数左右，所以当我们看到。

ppt里面，这句话的时候，来同学们看一眼，你说当我们把这句话写在我们简历上的时，候，我们是不是得多值个两三千块钱呀，熟悉常见的蓝鲸回收器，具有实际gm调优的实战经验，是不是得多值个2000块钱啊。

没问题吧，当然我们话说回来啊，这个呃如果700个参数你都需要了解，都需要调的话，这个难度也太高了是吧，没关系，老师给你记录得非常的清楚啊，我告诉你呃，大概常用的就这么几十个，我呢已经给你记录下来了。

最常用的就这么多，不需要记其他的好吧，我们ps加po常用的就这么多，所以ps加po的话，其实配合上上面参数没多少，但是cms本身比较多，而且比较复杂，所以cms一般我们不太建议用g one的。

常用参数的话呢，其实就少了很多，而且相对比较简单，关于z dc的话呢，基本上就三个参数，所以呃，这个呢就就就呃我我给你总结下来呢，大概有四五十个吧，四五十个参数，而且呢不同的垃圾回收计算下来的话呢。

20个左右就够了，是不是感觉世界又美好了一些，来有信心往这上面写这句话的同学，给老师扣个一，调调坏了，到了重装就是了，说的很对，就是你要大胆，当你把这个这句话写上去的时候，必须把该学的东西都给我学了。

要不然的话人家面试官可能会怼你啊，当然呢呃从实战的角度讲呢，其实有一个很重要的内容，就是日志这方面我没有讲，日志的格式本身也很重要，呃时间关系呢我就讲不完这个了，我给大家讲一个调优这件事情。

最常见的就是我们去找出来，是有哪些对象产生了o o m，这个呢在你简历上写调优的时候，是最容易cover得住的，而且呃讲的时候呢，你也能够讲得比较到位的啊，o o m那么关于o本身啊，内存溢出。

关于内存溢出本身呢，这个呃比较简单的方式是什么，你们你们自己能写一个，那让它内存产生溢出的程序吗，如果是你们要自己写的话，你们自己写一个最简单的，让内存溢出的程序怎么写，死循环死循环。

你能你能写得出来吗，猫那不可能啊，死锁死锁，你跟那个内存溢出没有半毛钱关系的，无限递归叫做战役出，它不叫堆一出，不叫out of memory，它叫做stack overflow，大哥，我要出括号。

你要这样能内存一出来，我就佩服你，你试试去，设一个固定的内存，一直new对象，疯狂扭list里面放list，对各位同学，你们实际写写，你们未必能把内存给弄崩了，我告诉你不是也不是那么容易的。

当然最简单的方式是什么，你你要搞一个list的，首先这是在你的main方法里面搞个list，我们看给大家写的最简单的案例吧，日志就略过不讲了啊，嗯这个案例，呃这张里面最简单的案例是是什么呢。

就是你弄你搞个list list list等于new一个link list，然后呢不停的往里头list里面加啊，这块很重要啊。

我觉得有同学可能不知道在哪，存在着一些误解。

系列 1：P50：70w年薪面试题：2：二面关于P6的难题是什么？ - 马士兵官方号 - BV1mu411r78p

我们可以聊p6 的内容了吗，可以的话，老师扣个一好吧，阿里没有13k，阿里好像是没有13k的。

不记得有13k，我们来聊这个线程池的理解和运用。

首先我先问大家一句啊，呃有没有同学不理解什么叫线程池的，这需要我解释吗，需要我解释的，老师扣个六线程池这件事应该不需要啊，不理解是吗，有这么多不理解的吗，一直半解哦，好好好好好。

我知道了好停吧停吧停吧停吧停吧，停下来停下来，关于线程池这件事情呢其实非常的简单，同学们，你们想要我给你举个简单的例子啊，呃现成的费用对说的很对，比如说啊这是一个餐厅，那么作为餐厅来说呢。

你你你进来之后呢，你是要找座位去吃饭，呃每一个线程可以理解为我们一个后台的服务员啊，我们餐厅的服务员，同学们，你们想一下，如果有一个人过来的话啊，那最容易的一个一个方式是什么呢，我给它起一个线程。

也就是有一个服务员来为这个人服务，有一个服务员来为这个人服务，那如果有1万个客人进来，那我就需要有1万个线程来对它进行服务，而且呢每一次都要new这个线程出来，就是把这个服务员给new出来。

这效率实际上是比较低的，那有没有另外一种方式呢，这种方式就是说我现在呢有20个服务员儿，但是呢我一次性的把它弄出来，一次性把它雇佣进来，放到哪儿呢，放到一个比方说数组里面。

列表里面唉这个都可以随便就总而言之呢把这些服务员全丢出来，也就是说二话不说，先new 20个线程出来，把这个thread全部给new出来，用完之后放到哪里去，放到一个水结构里面去，数组链表完成。

所以所以你放进去啊，然后有一个哥们儿过来之后，派一个人出去给他服务，完了之后再回来，下一个哥们来的时候，这个人这个县城还闲着呢，因为他已经处理完第一个第一个哥们儿的事儿了，好再给他服务区。

第二个区第二个服务，然后再回来，那这样的时候我就不用每次都new线程县城的重复使用，这个东西被称之为叫县城池。

来线程池的最基本的概念能听懂的，老师可以没问题吧，嗯这算是用内存换时间吗，啊你是有这么点意思，你说的很对，嗯，简简单单的啊，这里面其实不能说电影的那复杂的事儿比较多，呃我们讲讲真正讲vip的话呢。

实际上不是要分析到这个线程池的源码级别，它这个呢就相当于你要到p6 plus啊，接近p7 就拿比较高的薪水啊，需要的111个内容，嗯从老师这儿来讲呢，我一般不建议大家就是在你刚开始的时候。

你就去研究源码级别的内容好吧，先去研究它怎么用的，这东西有什么有，什么有什么用，有什么意思啊，所以你第一步呢先去了解什么呢，就是关于线程池这件事情啊，我构建一个自己的线程池，构建一个z的线程池。

它到底是怎么构建出来的，每个参数到底什么意思，这个东西呢是面试经常会被问到的，就是线程池的七大参数呃，七个参数呢也不太容易完完全全的理解，但是我建议你呢你就给他背过就完事了好吧，应付面试也行好。

这七个参数是什么意思呢，一共有七个参数，大家注意看就行了啊，我我记得我画过一张图，我用一张图呢差不多给大家。

把这个七个参数呢都给大家列出来吧，找一下，这样读啊，看看这里啊，这个线程池一共有七大参数讲给你听，我们先过一遍，简单过一遍，现成吃鸡大参数哪七大参数好，第一个参数呢叫做core process呃。

核心线程数，核心核心池的大小，核心池大小，第二个呢叫maximum process，叫做最大值大小呃，叫生存时间，第四个呢叫生存时间的那个单位嗯，第五个呢叫这个是非常著名的一个这个东西呢叫做任务队列呃。

第六个呢叫做线程池产生的工厂，第七个呢叫拒绝策略，我一点一点讲给你听。

你认真听，这个不难回想一下啊，第一个参数叫什么，第一个参数叫，第一层叫什么，叫核心池大小是吧嗯核心应该叫核心线程数量吧，核心线程数好，最大线程数好，第三个加第四个，这应该叫3+4吧，叫做那个生存时间。

时间单位，这里面比较麻烦的是第五个。

第六个是什么呢，呃第六个是。

县城工厂好，第七个是什么呃，第七个是拒绝策略，ok这是七个参数。

我给大家先做简单解释，你注意看什么叫核心线程数，核心线程数的概念啊，就是你的池子刚开始的时候，你不是一堆服务员吗，你刚开始的时候雇佣了多少个服务员啊，我平时我这餐馆啊有俩服务员够使了。

只有人多的时候才忙不过来，所以呢我核心的服务员就有俩啊，这个被我们称之为核心线程数，就这俩叫corpus size呃，那这时候如果来来客人了啊，来自来客人要做任务了是吧，嗯t呢被我们称之为叫一个任务。

一个rable啊，一个task呃，一个任务要扔进来了，他要点餐啊，要过来了，来来来为我服务啊，捏捏脚，点，点个餐好，这时候我们首先呢肯定是交给我们的核心的，这样的一个一个服务员去去做。

但如果是俩服务员都被占住了，都被占用了怎么办，听我说，这个时候有一个东西呢叫任务队列啊，就是它叫work you，叫任务队列，任务队列指的就是你排队把你放到哪儿去，排队门口排队去，我核心数满了。

你就得门口排队去，所以如果这时候任务再来，他去哪了，去排队去，那我排我队伍排满了，比如说我排队的这个队列最大的数量就允许四个四个人在这排着队，我，就四把椅子在门口排队，那这时候怎么办，又排满了怎么办。

没关系，所以这两个一加就叫做最大线程数，好这两个这两个概念是不是听懂了，非常的简单吧，我一餐馆就俩服务员，有俩哥们儿过来把我俩服务员全站住了，怎么办，来排队去排队，排满了怎么办，又来人了，又来人了。

这七八过来直接插队，对这七八过来直接插队，是这样的嗯，当然这东西我我直接告诉你啊，就是直接插队，不直接插队呢，实际上是取决于你线程池的具体实现，那好那同学们，你们想一下，这两个人干完活了之后。

他会他会怎么做，注意他会从任务队列里把这些人，把这些排队的人拿过来继续运行啊，t5 t6 哎，这哥这哥俩呢干完了，他把t3 t4 拿过来，能不能听懂，那这时候呢我们忙完了。

等于是啊我们等于是任务队列也没人，也没人了，好在这种情况下，在这种情况下，如果这哥俩的等待时间超过什么呢，超过第三个参数和第四个参数的组合，比如说我们第三个参数定义的生存时间是60，时间单位是秒。

当然也可以定小时啊，随你也可以定天，那随你变时间单位是秒，这哥俩消失干掉，但是核心的线程永远存在，来这前面这四个参数能听懂的，给老师扣，一是很简单，我给你讲就比较简单啊，我不跟你讲。

你要自己读就稍微麻烦点，是的。

好在这就不演示了，这样的演示其实也非常简单。

你只要定好任务，给每个任务做一个编号，然后呢定好你的cos以及maximum maximusize。

定好之后呢，再来呃详细的去运行，你观察它的特点就可以了，知道吧，这非常的简单啊，不能嗯，好了，队列长度是怎么设置的，问得很好听，我说这里面一个难点呢是这个队列的选择，注意怎么样排队，这个队列怎么选。

这是一个难点，也是一个重点，但这个东西要展开的话呢，内容就比较多了，这个队列呢第一你可以自己定义，你可以用数组，也可以用列表，第二呢你可以用现成的java里面的容器，只要是和q这个接口相关的。

q接这个接口，队列这个接口呃，这个继承下来的好吧，实现了它的你都可以用，这里面东西比较多，我在这就不展开了，就没法展开，是这十几个十几种的啊，比如说你可以用什么用concur map，如果你要愿意的话。

你也可以用copy on write list，就是呃写实复制呃，也也可以用什么concurrent q，也可以用lb q l bq就是link link blocking cu，也可以用什么呢。

a a blocking cute，也可以用什么自带那种优先级的，你懂不懂，就是嗯堆priority q自带优先级的，就是那个优先级高的往上排，优先级低的往下来，delay you。

这个往后延迟多长时间的，还可以用那种容容容容量为零的叫synonk，那就必须得我这边必须得拿走了之后，我这个生产者才能走，还有一种是什么transfer cute，这个是容量为零的啊，这是现成的，别人。

已经提供给你了，那在这个基础之上，你也可以自己去实现，你想用什么样的就用什么样随你，比如说你做一个那种q里面说这个这个编号为单数的，你你就你就扔进去，编号为双数，你给它给它，给它在这个分叉上。

或者给它给它去掉，还有还有一种比较牛逼的q是什么呢，就是这个环形的队列啊，比方说disrupter所使用的那种，所以这是一个难点，但是你记住这个东西是一个容器就可以了，在这儿刚入门的时候。

你把它记作一个容器就ok，好哇这个l o p问了一个触及灵魂的问题啊，你这个问题确确实实很很多的那个面试官会问啊，说核心线程数最大线程是怎么设，这个事儿呢，是一个一般来说，一般来说你得估计你并发量嘛。

就相当于你核心线程说的话，你要对得起你最低的这种并发量啊，你比方说日常的情况下，我这个并发100个人，那我这时候我要算一下他时间是多少，等待时间是多少，计算时间是多少。

然后呢给他算我有多少个服务员能服务过来，但是我高峰的时候呢，我很可能达到1万个人，我要请多少个临，时工我要把这个射到多长啊，要做压测，当然当然听我说嗯，这种东西的话呢，它比较复杂。

我呢在这儿给你简单给你给你聊两句啊，你认真听，只有这个事儿，只有认真听才能听得懂，认真听，假如说我们想提高整个程序的效率，什么叫提高整个程序效率啊，什么叫提高效率啊，我们能把我们的cpu占满。

能不能听懂，占满占到百分百，我现在假设我们只有一颗cpu好，我现在有一个任务，这个任务他百分百的时间都在使用，cpu是一个纯计算的任务，我想问你，我们设多少个线程，设多少个线程能充分，利用cpu跟我说。

哎呀你们都是一知半解的，别搁那儿，别搁那儿，往往往往外瞎说观点了，全都不对，我说的说一说一的都是对的啊，就说你一个一个线程数来了，就把这个cpu给占了，那这个一是对的，那假如我问你，我问你。

如果这个线程它用作运算的时候只有50%，另外的50%是io的等待时间，那我告诉你，我问你用多少个线程能让cpu占满百分百，这个时候就是两个，那如果说它的计算任务只有20%，我们设多少个线程合适。

这个时候就是五个，这块大家能理解吗，所以你设多少的线程，是跟你的任务到底是io密集还是cpu密集息息相关的，来这块能get到的，老师可以，所以不要跟那瞎说说什么二乘以几的倍数胡扯，那属于啊。

有界队列和无界队列该怎么选择啊，这里头有同学们对那个线程比较了解的呃，首首先说什么叫有界队列，什么叫无界队列啊，听我说有界队列的话呢，指的是我这个队列呢是数量有限的啊，比方说它就能装五个好了。

这是数量有限，无界队列指的什么，最常见的是链表，我这反正只要在屁股后头加就可以了，它长度多少无所谓，听我说永远使用有界队列，不要使用无界队列，嗯这个事儿呢。

这样我给你们要不要要要不给你打开阿阿里的那个那个编程规范，阿里的编程规范，编程规约，你们你们有吗，自己读过吗，自己读过吗，没有是吧，应该有吧，呃你这临时要我给你找一下啊，我看我看我放在哪儿了，嗯嗯。

不找着看啊，work boos，这这个我这版呢应该是不是很新的一版啊，但是呢呃新的一版呢你们可以去网上搜就搜了啊。

这是阿里的那个叫华山版，新的是新的，是哪一版，新的叫泰山版，还是叫什么。

就是关于并发这块啊，关于并发的处理。

就并发处理的话呢，这是关于线程池的一个它的一些规约呃。

我建议你们有空的话去读一读这些规约，想想看这是为什么好不好。

看这里看这个呢县城是不允许用executed去创建，而是要用three two execute方式支持，就是我给你刚才给你看到的源码，就是使用这种方式。

你得是手工来取，这个原因是什么呢，原因是呢呃executors它默认的一些东西啊，比如说fixed和single threpo，他这个默认的队列是多少呢，是max value。

而这个呢catch the po也是max value。

这个数量是超级大的，是什么意思，就是它这个队列呢超级超级的大个儿，这个队列啊，它不能叫无界，它有它也是有界，但是呢它超级超级大，那index max value那是多大一个数字。

也就是说你很有可能你在这里边儿，假如，说我们的呃消费者线程死了，我这县城不动了，而且呢并发量超级的高，双11的这种并发量，很快里边的消息就堆满了，能不能听懂，这就满了堆满，那堆满的话呢。

会把我们的内存全部都给你占，光，是不是出问题太长了啊，所以不要用你说有界和无界，你首先要用有界，而且要用合理的长度啊，当然你可能会说老师我们业务无所谓啊，我就是一个给成员植发的店是吧啊。

200年不来一人是吧，那好那这个时候呢你可以把这个队列设的长长的，反正我总有时间去把他的队列里面的人给消，化掉这个无所谓的事情，所以具体问题具体分析，但是尽量不要使用无界队列，这个太狠了啊。

很有可能一出问题就全全装满了，来这块儿能听明白的，老师可以，呃我们再把打开啊。

既然又讲到这儿了呢，呃我们再来看啊，你看那个其实呢他在这里面呢还有很多很多的呃。

并发处理的一些个规约，那么在并发处理的里头呢，他说创建线程或者线程池的时候，指定有意义的名称，方便出错时回溯，这个是什么意思啊。

同学们认真听呃，你们想一下，这这个是第第六个参数的含义。

这个第六个参数啊指的什么东东呢。

创建县城的工厂，有同学说了，老师大哥这事儿有问题啊，我创建一个县城不就new一个thread不就搞定了吗，是不是啊，搞定了我我我我我搞什么，其他的搞什么其他幺蛾子好听，我说听我说。

其实呢你创建这个现场的时候，我给你举个最简单的例子啊，这个new thread new出来的这个线程的时候，它的名字叫做默认的名字，如果你装在线程池里呢。

它一般叫做叫做pro 1 thread 1 pr thread，二puls pr thread 3，就这里的名字，我想问你，如果当你看到这样一个名字的时候，就好像说，一旦出了异常，exception。

exception，一旦出了一个异常，那你看到这个名字的时候，你会你你能知道它到底是处理哪方面业务的线程出的异常吗，的意义是没有名称的，就好像你变量起了一名叫a a a b b b啊。

变量叫a1 b2 ，这样的变量能不能被允许吗，绝对不可以，尤其是像阿里拉京东了这样的大厂里面，他们一个机器上跑的线程数量可能非常的多，好多人都使用线程池，那这个这个人使用的线程池叫thread一杠一。

另外的人写写写写的限制是，thread 2杠一，你说这俩出了bug之后，出了之后到底是哪个业务组产生的，这块能不能理解，所以呢在这个里面实际上你可以手工指定一个自己产生现成的工厂。

但自己选择下面的工厂的话，你就自己起名字就好了，比方说我现在处理的是凉菜业务，那可以叫凉菜，凉菜张三儿啊，凉菜李四儿啊，出了问题之后，你能找着人好，这块能理解的，给老师扣一了，只有我的线程池才敢这么写。

ok你牛逼，好了同学们，我讲到这儿呢，其实1234566个参数我基本都给你解释过了，细节呢还会比较多，尤其是像中呃任务队列啊，在这儿就没法展开了，好呃那我们说我们说下一个啊，下场只能用用英文名。

用中文也会报错，那我也很少用中文，关键你用英文名就用英文名吗，这有什么关系吗，完全可以用英文呀，就总而言之，你就是把它起个有意义的名称就可以了，好吧好，我们看这里啊，我们最后一个参数。

最后一个参数呢实际上把我们把它称之为叫拒绝策略，拒绝策略是什么意思呢，就是你再牛叉的餐馆，你服务的能力再强，也隔不住n多的流量一块涌进来啊，海底捞啊，够牛叉了，对不对，这个像什么喜茶啊这一类的。

像什么胖哥俩等等，这个服务能力已经很强了，但是，你同时能够服务的人也是有限的，好了，同学们，这时候你就琢磨了，如果在我们同时服务的人全满了的时候，又来新人了，我该怎么处理。

大概就这个意思啊，看这里我们的任务队列也满了，我们的备用服务员也用完了，好这时候又来一个，这时候怎么处理这个赶走慌了，直接我滚蛋，下次不许再来了是吧，可以是个办法嗯，这是店大了欺客，刻到了气垫。

存起来持久化可以说的很对，比方说有一些我们不能够丢掉的消息，当他要来的时候，同学们，你们琢磨琢磨，我们能不能够把它丢掉吗，这个不可以啊，这时候怎么办呢，先把它持久化起来，把直角画起来啊。

当然这里面的策略呢非常的多，默认的策略有四个，默认的我说的是那个jdk自己自己帮你实现了，有四个啊，但是不展开了，但是还有，但他这四个呢其实实际当中用的并不多，我告诉你一个最常用的啊。

就是你在这个服务外面呢可以搭一个mq的集群，卡夫卡rocky mq都可以当这个任务来的，时候实在没地儿处理了，先扔到mq里再说，就是你你有一个持久化它的地方，刚才说了，持久化说的很对。

什么时候我这边空了好，从持久化的队列里面再拿出来再用呃，这块大家能听懂吗，那都有同学可能会说了，流量太大了，直接把这个持久化就给灌满了，怎么办，动态的弹性扩缩容，能够把它给扩容，说还不行怎么办，还不行。

就限流，再不求你熔断是吧，好这第七个参数啊，现在我们回顾一下这七个参数，看大家是不是理解了，嗯，好看这里，呃第一个叫核心线程数啊，我们核心呢你在脑子里想，我们核心俩服务员哎，最大线程数最多。

我们来四个服务员是吧。

唉然后呢生存时间说那个临时的服务员多长时间，你不理它，它就自动的死掉了，那任务队列你得有一个排队的地方。

那个排队的地方呢由于是多线程要对它进行访问，所以呢要做好同步，就是各种各样的同步队列，然后呢县城工厂啊，你需要指定一个有意义的名字，或者把这个建成呢指定成为后台类型啊，那第七个呢拒绝策略常见的有四个。

这四个呢第一种是扔掉，第二种是什么套异常啊，第三种是那谁谁谁调用的，谁用啊，第四个呢再起一个新的等等，但是呢这种不太用，实际当中用的不太多，一般来说我们不会扔掉它，这时候我们不会扔掉它，怎么办呢。

做日志扔到m q里就可以了，ok来能够现在有信心能够把p6 的题答出来的同学给老师扣一来，几点了，9。10分啊，正好正好我们讲p7 好不好，0。5是吧，嗯可以可以可以，好嘞好嘞好嘞好。

系列 1：P51：70w年薪面试题：3：三面关于P7的难题是什么？ - 马士兵官方号 - BV1mu411r78p

好，到现在为止呢，我基本上粗浅的啊，为什么说是粗浅的，就是里面好多细节呢，我并没有完全展开，粗浅的给大家交代了，最近所面试到的p5 p6 p7 p8 的p5 p6 p7 的内容，这是关于线程方面的。

当然p5 p6 p7 的内容也会比较多的，不是说只有线程方面，我只是挑了县城这方面给大家讲而已，乐观锁，悲观锁，自旋锁，螺旋锁，排查锁，共享锁，通行所分段锁，这当你在看到这些概念的时候。

一定脑子里先把这个东西给他浮现出来好，那么第二个呢是关于线程池这方面的，这个就别说，了这个现关于线程池呢，这是问的，问的非常非常非常多的，你啥也别说，就给他背过就行了，线程池的七个参数啊。

核心线程想想看啊，最核心的那个服务员，最大线程最多有多少个服务员是吧，任务队列排门口排队，那哥们儿啊，那个那个那个那个队列，现在的工厂给每个县城起的时候呢，起一个自己特殊的名字，拒绝策略四种比较常见的。

但是很少用啊，也可以自定义地拒绝策略啊，呃当你理解了这件事之后呢，关于pg来说呢，我给大，家分析了什么叫线线程，它的另外一个名字叫携程，它有普通的债务线，就是不同，为什么能提高效率。

因为它节省了切换的时间，好了嗯，我在这儿给大家追问一个小问题，追问一个这样的小问题啊，是不是兼程，永远b就是可以这么说，是不是m bn模型永远优于，一比一模型啊，这我直接说答案啊，这肯定不是啊。

同学们听我说，如果你的线程数量其实等的挺多的，就等待情况特别多，嗯对不是没错，不是，你看到永远这个词儿它就肯定不对，是不是同学们，同学们听我说，同学们你们思考一下，我们说m bn模型有一个什么毛病呢。

就是它永远是消耗cpu的，能听懂这个站在操作系统的角度，这些这些个线程没有人是没有人是进入睡眠状态，或者没有人是进入等待状态的，就这些个玩意儿啊，他一定全是活着的，永远是消耗cpu的。

但是如果我们使用的是一比一模型的话，那么这些线程我是可以控制它进入等待状态的，weight它是可以释放cpu的，所以当我们有一些操作，比方说这些操作呢它的耗时非常的长，它的并发量也比较大，那这种情况下。

一比一模型实际上有可能要优于ba模型的，因为只有一个线程在工作就可以了，或者只有几个线程工作就可以了，其他线程进入等待队列，不要给我消耗cpu，来这块能听懂的，给老师扣一，当然要透彻理解这个先生的话。

阿里内部的县城是自己呃，他们是完全用过的，好吧，阿里内部的先生他们是完全用过的，但是呢呃平时可能大家伙用的少啊，不过老师这个课呢就是追求的比较全啊。

各方面的内容都都都都比较全，比较比较完整呃。

所以呢基本只能只要你能想到的啊，老师这课里头基本全都有，那我讲完p5 p5 p6 p7 ，你们想知道p5 p6 p7 拿多少钱吗，想知道的给老师扣个一好吧，好，哦sorry啊。

就就这个课啊，对不起，我这课这课名字叫携程啊。

这个叫那个高并发解决方案，只写成了，对不起，我说怎么没搜到呢。

他是那个呃是是携程啊。

名字起的叫携程讨厌，所以啊记得是油滴，嗯嗯。

哦在这儿在这门课上嗯。

mc高并发的这携程这个是咱们阿里的一个p7 的老师。

他们在实战之中呃，运用携程来解决这种高并发的问题，我觉得这个案例呢还是挺好的啊，嗯代码的场景啊，代码的解读啊，代码的答疑，io是怎么做的，并发模型是怎么做的啊，回顾一下写成killing到底是怎么做的。

呃讲解昨天的例子，阻塞的理解啊，最后是一个大一呃，当然这是我们整体课程中的一小部分了啊，我们基本上整整个的课呢是p5 p6 p7 p8 全有。

那我看有同学想了解那个p5 p6 p7 p8 到底是什么样的一个要求。

心率是多少呃，在这儿呢你们要想开这个网页的话。

我在这儿写的其实非常的清楚，这是咱们阿里的曹老师把阿里那边完整的一个要求给大家呃。

全部拿过来的，p5 的要求啊，它的年限一般是给到20万~40万。

好吧，p6 的要求是什么，p6 年年薪是40万~60万啊，他的要求是一种独挡一面，在专业领域具备辅导他人的能力，那我问你啊，这个专业领域具备辅导他人，他辅导谁啊，独当一面辅导他人，辅导谁，辅导屁股吗。

对辅导p5 是这样的啊。

然后呢嗯在站在p6 的角度，然后p7 p7 是年薪50万_{70万，他当然他时他就有股票了，是800}1200股呃，这时候它叫做领域专家，一杆到底系统性思考这个东西呢，就是他在p6 的基础之上呢。

它会变成一个领域专家，大家记住，当你看到领域专家这个词的时候，一定要有一个有有一个词儿要出现在你的眼帘里，出现在你的耳耳门里，出现在你的脑子里，这个词叫业务，好听我说当我们成为一个技术架构师。

成为一个技术的高手之后，请你一定要拥抱业务啊，我们说p7 到p8 ，它的一个跨越的点在哪。

就是这俩字儿啥业务啊，好听我说我我简单给你们解释就是什么情况下你会到p5 。

什么情况下你会回到p6 ，什么情况下能到p7 ，好认真听，一般情况下你是应届生，这个应届生呢还得是本科的应届生，然后本科也或者是研究生好，ok这个时候你的直接进你的级别，如果你能练过的话，p5 。

那么在这个基础之上，p6 是什么意思呢，p61 般情况下它和p5 的要求，所以我说p5 p6 p7 啊，实际上不分家，在我们整体课程里头呢，这三个东西呢也叫做一门课啊，就p5 p6 p7 是不分家的。

听我说，一般来说什么情况下你回到p6 呢，p6 是你一个模块的负责人，你把这个模块分解成任务之后，可以让p5 去做，你督促他去完成，就在别人的帮助之下，别人给你下达好任务之后，你能完成。

ok好你这什么叫做p6 呢，一般情况下是本科生毕业1年左右，专科生毕业3年左右，这个时候你去应聘的时候，你对应的叫p6 ，能理解吗，好这个能get到的老师扣个一来嗯，好的，那什么叫p7 呢。

p7 什么样子呢，如果你的项目组一共有20个人，他们一般会有几个p7 呢，三个两三个左右，这个p7 啊，它叫做四五个人的一个team leader，team leader。

这四个人里面很可能负责一个小模块群，一个子系统，在这个子系统里面最核心的这哥们p7 好多g，这次五个人谁要技术不懂了，找他要找他问，这个一般叫p7 ，这个一般的如果社招来说啊，基本上5年左右的。

那我在这个基础之上呢，什么叫p8 呢，还想继续听吗，阿里工作3年仍是p6 ，生脾气比较难，晋升这块是一个比较复杂的问题。

呃我我我原来曾经专门讲过晋升课啊，在我们整个体系里头，我也想把这个晋升这块给大家慢慢的讲起来，小公司管四个人特别多，你小公司的管四个人，他就成不了p7 呃，我想问你啊，就是我我就交给你。

我教你一个简单的怎么晋升的，在座的想听吗，有有没有有没有想听，想听听老哥一来就教你怎么去做晋升这件事，嗯大家听我说啊，就是说晋升这件事情呢，他第一个呢是要求你的是你的综合能力，他可能不单单要求是纯技术。

当然也有可能搞不正之风的，你跟说跟领导睡了，跟领导那个关系特别好，嗯那也也有可能，咱们除去这种情况，一般来说怎么晋升，我就想问你一句话，你好好想，现在呢有，五个p6 ，其中有一个人会升为p7 。

我们的指标就是这样的好，我问你谁会升为p7 ，同学们记着我一个答案，谁先去做p7 的事情，我再说一遍，谁先去做p7 的事情，谁升为p7 的可能性就越高，谁先站在p7 的角度考虑问题。

谁成为p7 的可能性就越高，不知道大家能不能听得懂，能不能听得进去，我是说一个人的真正的成熟，一个人真正的成熟是从他认真对待工作开始，你们可以每天都摸鱼，每天都划水，你可以不认真对待你自己的工作。

敷衍自己的工作，但是我告诉你，敷衍自己的工作等于敷衍自己的人生，敷衍工作没有关系，但是你的人生也是在同事在敷衍，这是你的时间，我希望你们能听进去，所以为什么有的职位叫p6 plus。

这个plus plus在哪，虽然他还是p6 ，但他已经开始逐步在做p7 的事情，为什么有的人叫p7 plus，虽然他还是在p7 ，但是他已经在做p8 的事情，好。

学生里有一个比较牛牛比较牛逼的脾气，你们想看看吗，来这会儿一定一定给老师听进去，好不好。

他这个这哥们儿是p7 的一个顶级薪水啊，就是他看这里，3年的大型系统架构的设计经验，团队管理经验，你就记住了，真正的团队管理其实是在p8 才有他p7 里面呢，一般这个团队呢你管理个四五个人比较简单的啊。

一般只有到p8 才有，然后分布式高并发高可用大数据量的系统架构设计经验和研发经验，对各种源码均深度阅读，和下面是一系列的关于个人技能的描述，呃我一会给你讲为什么叫p7 plus，不叫p8 。

120万年薪，大家慢慢做，大多数人现在是到不了这个年薪的，跟老师慢慢学，老师会逐步带你到这个年薪去啊，好多精通对这个课程里都有，不用不用不用担心啊，精通这个词也能用吗，嗯反正别人都在用，你可以不用。

当别人都在用精通，而你不在用的时候，你猜猜看站在面试官的角度，他会怎么看，拿大腿想想。

分布系统架构，海量数据架构，高并发的系统架构，高可用的架构，高性能的架构啊，到什么程度才算精通。

面试官问你，你能够答得出来，大老师给你今天给你讲课的程度就算精通了，能说出来怎么用，能说出来为什么这么用，你就可以叫精通了，你能能说来怎么用，能灵活使用，能说出来为什么。

这个简历能get一份吗，这个简历不能get一份，这个简历是咱们小伙伴的简历，也是我们呃最近目前在用的一个简历的模板，把他的简历真实简历当成模板了，呃，这个小伙呢。

他现有的一个状况其实是比他当时的这个状况还要牛逼的啊。

我我我给你找一下，这小伙目前是我教的最牛逼的一个学生了，跟他是一个亦亦师亦友的关系了，他大概在30岁还是31岁的时候嗯，退休了，公司给了5000万的股票，并且套现，套现5000万，退休了啊。

我的简历根本看不了，其实你简历靠不了的原因呢，这个应技能不足嘛，补上硬技能就可以了啊，呃如果大家感兴趣，也可以找个图去好好的读一读它关于p7 的，关于p6 的一个说法，呃那么能套现对，为什么不能。

如果给了5000万股票不能套现，小伙伴，这股票有屁用，虽然我在公司的最后一站了，有福之人，每次遇到不可控的过程，总有一个人站出来拉我一把，这个人谦虚嘛啊就是越牛逼的人呢会越谦虚，截个图可以截。

你不用截图，嗯老师这里都是公开的啊，这里面所有的大概1000份左右的那个就业信息，111 千份左右，没有一个是那个说给大家p过或者干嘛的，只是给大家引去了隐私的信息而已啊。

系列 1：P52：70w年薪面试题：4：跨越职级，P7和P8的巨大思维鸿沟在哪里？ - 马士兵官方号 - BV1mu411r78p

题会越来越难，这个俩学生，然后，成绩就提上去了，后来剩下的那个9998个学生，就不干了，说你俩他妈抢跑这9998个，怎么办，结果你猜猜什么题上去了，分数线，或者说题更难了哈哈能不能理解，就是说成员呢。

这个你像说一句最简单的，像那个几几年前你你你懂点什么s h哈，后来s s g就不行了，懂点什么s s m，后来又不行了，得懂点spring cloud，现在又不行了，还得懂点儿三高啊，现在又不行了。

还得懂点算法，现在又不行了，还得懂点底层知识，哎呀娘啊，ok，不断上进的人，所以其他的不不不上进的，呃，请大家伙，以动态发展的概念去看待一个问题啊，不要用静态的思维去看待问题，好吧呃。

这东西是好事也是坏事，好坏事呢是大家伙诶，就得好好花时间去努力了，逼着你去学，那么好事就在于我们会变得越来越强啊，他跟那个他跟那个什么还不太一样，好吧嗯好看这里啊，我们说什么叫线程，线程协程。

它和普通的jav线程有什么不同，为什么他能提高效率，那这个事儿呢比较复杂一点点。

解释一下啊，我要把这个图示给大家调出来，不掉图示呢比较难以解释，嗯，一sorry你多线程与高并发在另一个啊，啊嗯，这个呃，这个其实它本质上来源于腾讯的一轮面试，腾讯第一轮面试的时候，面了一个这个算法啊。

第二轮的面试面试一个release和mysql的一个内容，第三轮的时候就开始了一个，疯狂追问式的问，你先问你什么叫县城，什么叫进程，这是这这个这个这个题，一般是腾讯的开场白，什么叫线程，什么叫进程。

其实像这一类的东西呃，非计算机专业的一般都打不太好，同学们什么叫县城，什么叫进程啊，这个能能能能答得出来吗，什么叫线程，什么叫进程呃，同学们听我说啊，就是说那个一般来说我们举形，象一点的例子啊。

用用那个用那个，因为他这个不是大学里，和那种非常呃书本化的一个考试，所以呢我尽量给你举形象一点的例子嗯，大家听我说，我们我们一般说什么叫一个程序呢，这个程序呢就是你编译好的一个可执行，可执行的文件呃。

qq。e x e哈，这就是一个一个程序，一般我们称为一个程序，那同学们，你们想想这个程序平时都趴在什么地方呀，都趴在哪儿了，盘内存里胡胡说八道吗，你这个你你你一开机，你的qq。e s e是跑内存里了啊。

那是自动化的，弄进去才行啊，一般来说趴趴硬盘上说这个文件啊，一般放哪儿，注意是放硬盘上，对不对，放硬盘上，那如果说我们想执行这个程序的时候，是什么样子的呢，我们找到这个q。e x e，双击它好。

双击它操作系统就干了一件什么事呢，它会把这个程序，把整个程序从硬盘上给拎出来，拎出来之后放到哪里去，注意放到我们的内存里，放到我们的memory里面好，我们假设这是放好的那个qq。x，请大家记住。

这个东西就被我们称之为一个进程，同学们，你们想一下，我把这个程序放到内存之后，我要我要为他干一件什么事儿，我是不是得为它分配好对应的啊空间啊，我们一般把它称之为，分配好对应的进程空间。

感觉回到了基础归零，我主要其实人家想问你的是，这个携程县城其实不是归零，咱们直播间的小伙伴啊，我直接跟你们说，这个你可能听不太懂，所以我从根上给你稍微解释一下，是这个意思好吧。

来可以可以继续给老师扣个一啊，能理解的给老师扣个一，不是p7 ，又回到了那儿，是实际上人家问的是这个啊，县城县城人家问的是这个嗯好了，那同学们你们想一下，作为一个qq。e x，它是不是可以再双击一下。

再双击一下，是不是有几个呀，那也就是说，一个程序是不是可以对应多个进程，那两个进程有什么区别呢，资源对应不一样，什么意思呢，你看这个这个空间的地址，和这个空间的地址，它一定是不一样的，所以这个进程啊。

被称之为叫做分配资源的基本单位，注意它还没有运行起来，它只要放到内存里，它就可以称之为一个进程了，那这个进程要想跑起来的时候，是什么样子的呢，进程要想跑起来卡住了吗，其他人都卡吗，hello，没有是吧。

嗯，嗯我看一眼啊，是不是卡了，刷新一下啊，对卡的话，稍微刷新一下，头像卡了是吧，头像卡了无所谓了，o o那同学们，你们你们你们你们稍微思考一下，这时候是一个进程啊，那这个这个程序要想跑起来。

那真正的开始我要接受网络的一些操作了，我可以对外呃，跟其他人聊天了，那时候那时候呃是什么情况呢，怎么办呢，办法是，他会找到我们一个进程空间里面的，程序入口，什么叫程序入口，就是我们没函数开始的地方。

就找到我们的main函数开始的地方，然后呢这条指令拿过来运行，拿过来运行好了，只要他开始跑起来之后呢，唉这个程序呢就叫做开始运，行我们的主线程，我们的main函数是不是我们的主线程啊。

来这块能听懂的老师扣个一，所以呢，线程一般被我们称之为，程序运行的基本单元，也就是说进程啊是一个静态的概念，它是程序分配资源的基本单元，那程序要想运行起来呢，就是一个动态的概念，就是现成的概念。

好下面我要问你的是，一颗cpu里能跑几个线程，同时cpu能跑几个现场，一般情况下，只要不是说那个呃超线程的那种啊，线程撕裂者不是只要是那种的，就是一个一个cpu跑一个一盒啊，一个盒里就跑一个。

当然有一些超线程的一盒，你可以跑两跑三跑四个啊，跑不了三啊，一般不是三跑四个啊，这是有可能的，这个是县城，所以我们一般讲的县城和那个cpu啊，是一对应的超频，这跟超频有半毛钱关系吗，你琢磨啥呢。

需要给大家解释一下什么叫线程撕裂者，什么叫我们叫这个这个这个，现成的这种这种那什么吗，嗯，这个需要你大致理解cpu的基本构造，我们讲呃作为一颗cpu来说，它里面有一个东西呢叫做最重要的东西。

被我们称之为叫运算单元，简单认为它就是做计算的，但是除了运算单元之外呢，实际上呢它有别的用来存储数据的，存储数据的，被我们称之为叫寄存器，寄存器，好同学们听我说，一个现成的数据存到一组寄存器里。

还有一个专门的计算器，被称之为叫呃pc叫program counter，它就记录了这个线程执行到什么位置了，执行到哪哪哪条指令了，同学听我说这个事儿呢，其实超线程很简单啊，或者叫线程撕裂者，很简单。

就是一套寄存器，只能同时存一个线程的数据，那我问你，如果在我一个盒里面，我有两套寄存器，这是一套新的寄存器，我是不是就可以同时放两个线程的数据来，这块能听懂的给老师扣一，那我lu来说呢。

我算你一会儿算它，一会儿算你一会儿算它，一会儿我在盒的内部就直接切换了，那可远远比你从这个盒切到那个盒，或者从外面把这个数据再load进来，效率要高多了，所以这个东西呢就被称之为叫线程撕裂者，啥都不懂。

你们嗯，好了，我们可以继续给他，可以来，我没骂，我就觉得你们啥都不懂，好，我们回到我们，呃会嗯回到我们县城的概念啊，什么叫西城或者叫什么叫携程，这个概念呢本身比较简单，它我我呢在这儿呢给大家呢。

呃做一个对比的一个一个说明，你就你就理解了啊，好看这里啊，啊这是我们的这个，我们说这是我们的操作系统，呃操作系统的它管理的一系列的内存是吧，嗯听我说听我说，这是操作系统管理的内存啊。

那么同学们你们想一下啊，就是诶对，就是你们想一下，就是在我操作系统里面，跑着一个一个的小程序啊，这是我们的在操作系统里跑着的，一个一个的小程序，这小程序呢数量比较多了。

啊这个呢可以那么叫叫做or word啊，这个呢叫qq，后来有一个非常特殊的程序，这个程序比较特殊，这个程序叫什么啊，这个程序居然叫jvm，而这个jvm非常的奇怪，这个jvm啊。

实际上呢如果站在使用这vm的人看来，就是说使用这vm的人，也就是说往里头扔那些个class的人啊，我有一个class往里扔扔进去，站在class这个角度看，jvm他是看不到操作系统这层的。

他是看不到这里的啊，在在class看来，哎它被称之为叫做虚拟机，那这时候我就想问你了，既然它，是一台虚拟的机器，那这台机器上有没有它自己的一个线程，java的线程有没有，那肯定有嘛，这是必须有的。

你作为一台虚拟的机器，你做一个虚拟的操作系统，是不是你是不是得有自己的线程好啦，这个是你自己的线程，那现在问题就来了，当我的虚拟机里头起一个现状的时候，我们真正的操作系统会不会取一个线程，会吗。

自己琢磨一下，好就是我们jvm里面起一个线程的时候，我们操作系统里面会不会起一个线程，会的，这是我们操作系统里面的这个线程，好请大家记住，当我们的jvm里有一个线程的时候，我们操作系统有一个对应的线程。

当然有同学可能会说了，老师那我这vm起个线程，我能不能够上操作系统里面，不起那么多线程，这个可以吗，其实也可以，这个取决于你的j vm怎么实现呢，你jvm愿意怎么实现就怎么实现。

你完全可以在这里起好多个线程，起好多个jvm级别的线程，但是不起那么多操作系统对应对应的线程，这是可以实现的，这是没有问题的，好同学们听我说，现在的我们说呃，jvm的一些个实现呢。

经常我们用的最多的是oracle自，己的默认的实现，这个这个时间被我们称之为叫hot spot，不用我解释吧，你作为p7 的人，肯定是不需要我解释的啊，你要是p5 p4 的，你可能就需要我解释一下。

就是oracle自己，你下载的那个jdk那个dvm，它的名字叫hot spot，那么除了oracle的实现之外呢，其他有各种各样的实现，各种公司的实现，i b m的，淘宝的，阿里的都都有啊。

那当你理解了这件事情之后，他们听我说，在hobo里面，一个jvm的线程是对应一个操作系统线程，这个那么我称之为叫一比一模型，为什么jvm这么设计，为什么为什么这边这么设定，想想。

为什么这vm不设计自己一套，自己独有的那种那种那种现成模型啊，唉说得很对啊，懒，除了懒之外呢，还能省事，是不是还有一套通用的这种线程库，你都你都可以直接拿来拿来编写，可还可以。

其他其他系统上你编程编程也方便，唉就是懒就是懒啊，这是最简单的模型，但是这种模型呢也有它的不太好的地方，那假如说我们的同步也好啊，我们整个并发对于内容的处理也好，呃，那如果说我们每起一个这边的县城。

都要起一个操作系统线程，因为怎么说呢，你得去通过操作系统来帮你调度，说我这里申请了一把锁，操作系统对应的得有一把锁，说这个，这个这个锁上有等待队列，k操作系统上也得有一个等待队列，就是总而言之。

再给你反馈回来，你中间要经过别人的帮忙，你整个线程的这种操作，上下文的操作系统，这种切换，你是不是得经过操作系统来帮你做，所以这种模型呢比较简单，但是他呢唉严格来讲它的效率并不高偏低。

来这块能听懂的老师扣一，那我们是不是能够做一种什么样的方式，就说我这辈m里面，我干脆自己管一套行不行啊，我能不能在jvm的线程里，我模拟一个操作系，统模拟一个什么呢，模拟一个叫做线程调度器的东西。

线程调度器，就说我在我自己的jvm内部，管理自己的线程模型，但是注意这些个线程，它并不对应操作系统的线程，他只是说在我jvm内部，又设计了一套操作系统的调度算法，在这些调度算法里面呢，它所有的同步也好。

它所有的并发也好，都这类m自己来完成好，这个东西被我们称之为贤成，最早开始是谁谁做的呢，勾引罗恩语言，他们用的都是这个嗯，就是他们自己的高原的虚拟机呢，它的线程模型都被我们称之为叫gpm型啊。

就是类似于跟我这是一样的，就是在它的内部的内部的go语言，建立的这种，好多问先程或者叫携程啊，和操作系统的这种并不是完全对应的，那么这种对应关系呢，被我们称之为叫m比n模型，就是在我们这里起m个线程。

m它的内部线程，但是对我的操作系统来说，只起n个操作系统模型，一般来说m要远远大于n，比方说这里有1万个县城，但是这里头有可能只有十个线程，就帮你搞定了，这十个县城呢，来帮你负责他们之间的这一问。

线程之间的同步和并发呃，这就是现成的最基本的概念，也就是我操作系统里面，jvm这版本里面呢本来有自己的县城站，线城站，但是呢在自己的现状战基础之上，我又建立了另外的一套的现成的调度。

好这个被我们称之为fiber，java叫fiber，那么，go语言呢叫coo routine，叫携程啊，好这个概念大家能听懂的，给老师可以，好看，有同学说，那go就要优于java。

go在并发这个方面它是优于java的，因为go语言天生是为了并发而生，所以呢它是由于java的，这个概念大家能理解了是吧，那这个东西呢，所以他的第二问，我觉得你就你就应该能答得出来了，大家听我说啊。

p7 的很多时候的要求，我们说它虽然划分为p6 ，p7 ，p7 很多时候的要求对于技术来说，它实际上跟p6 呢要求的，也并不是说区别那么大，但这个时候pg更考察你的，其实是两大两个大东西。

第一个是关于项目类的，第二个是什么呢，是不是您这个人是一个好学的人，你平时都用来干嘛，你虽然是能写程序，能写程序的人多了，但是问你一些新鲜的事物，你是不能懂，所以呢他问的是这方面的一个东西。

当然它会往细节里头一遍一遍的追问，为什么呢，它和普通限流有什么区别，不是一比一的关系吗，那他为什么比他强啊，因为这个同步是轻量级的，因为这个同步，它是不需要经过操作系统的内核的，它是不它是。

它是不需要经过操作系统的这种，一对一的线程的调度的啊，那我在这儿呢给大家举简单例子，拿代码来说明问题，这个代码呢你们能看懂就看，看不懂就算了，好不好，能听懂就听，听不懂就算了啊。

把它当成一个新的事物来对待，就可以，同学们，听我说呃，在jvm来说，hosp来说，这个jvm hosport来说，对他来说他是天生不支持fiber的，如果你想利用fiber，不好意思。

这个时候呢得用java的drumentation技术啊，这我不给你不理解，是java的技术啊，instrumentation的技术，a的技术，java代理技术在这个程序运行之前呢。

前面有一个代理人通过它再再进入这个m，那么通过它的时候呢，它会把对应的线程代码给你，折算成为对应的线程代码，然后ok这个时候才可以应用线程这个东西，那么先生这个东西呢最常见的java类库。

其中有个著名的类库呢，它被称之为叫馈赠馈赠，这个类库呢，我看看啊，我们课程体系里头，我记得是有专门的一门课讲这个的，我要找一下看，嗯，边点com，你这个搜索稍微有点问题啊，只能调十连刻，规则，先从。

嗯找大哥要一下，新城那天我也看到了，一会儿找找看啊，那个是阿里的一个p7 的老师啊，他们在阿里内部使用的现成的内容，他们用的这个类库呢就是他就是quiz呃，我给大家简单解释这个馈赠啊。

因为他那个讲了很长时间的一个课，我不可能在这里给大家那个从头到尾讲完，呃，我们来做一个小小的对比就知道了，我们在这里呢有一个简单的小任务啊，这个任务呢就是一个计算任务啊，calculation。

这计算距离怎么计算的，你不用去管它，这无所谓，就是模拟了一个简单的任务而已，那么在这个任务里面呢，我们，做好多次的计算，第一种方式我们使用了什么呢，我们使用了1万个线程，是1万个线程买多计算啊，好吧。

1万个线程来做计算，ok然后这是这是第一种，你们记住，我们看一下它运行的时间就行了，跑一下好，注意看它运营的时间是965个毫秒，就是用1万个线程来做计算的话，那么它运营的时间是965个毫秒。

这个时候如果我们引用引用这个quer，这个类库就是coo parallel，universe fiers，defier，quent类库里面用到的好，我们用这个类库的话，听我说听说好。

在这个时候我们也用了fiber这个概念，你可，以认为它叫线程中的县城，就是县城的概念啊，它也是run方法啊，也是调用了calculation，他也是来了1万次的循环啊。

不是不是要要求就是1万 1万次的任务好，那这时候他的效率是什么样子的呢，看到了吗，509，亏损基本上两个在这个小案例里面，它会相差一倍，来这块能感觉到的，给老师扣一，再执行一次。

你再执行100次也是一样的，577嗯，再执行522，基本上提速能提到提到一倍左右啊，啊这但是这个例子啊，注意啊，它这个东西呢不是说适用于所有的情况，我一会儿给你慢慢解释，就说人家问p7 的时候。

一定是问到你为什么这件事，你你得要解释解释，解释透到这个这个程度，你看这个时候就是一秒多嘛，就是如果你用线程的话，就基本上在一秒左右，一秒多，一秒多，但是你同样的案例，如果是用那个线程的话。

哎他就是哎这600多，这个算时间比较长了，跑一下就400多啊，基本上我500上下就500个毫秒上下呃，能感觉到吧，那么为什么他会这样呢，大家听我说，这个里面呢有一个1万个线程，1万个线程会涉及到。

是不是会让我们操作系统不断的在这里头，做同步啊，你们想想看。

我刚才画的这个图，在这里起1万个这玩意儿，是不是操作系统对，但它们之间不断的不断的做同步，然后做切换，是不是它这个线程的切换是很呃，耗费时间呢，那如果我们把这个计算任务放在这里呢，省了切换的时间。

因为它底层很可能只有，比方说就只有两三个县城就搞定了啊，呃你像go语言里面，它有一个调优的参数，就是你可以调a操作系统级别的，这个线程起多少个，知道吧，省了切换的时间，嗯好这块儿大家大家能听懂的。

系列 1：P53：70w年薪面试题：5：做好规划，从入行到P10思维，走向财务自由的道路到底有没有？ - 马士兵官方号 - BV1mu411r78p

我看刚才有同学说说老师那个他为什么叫，但是但是你看啊，他技术技术非常的牛逼，对不对，为什么给的是最后是p7 plus，而不是p8 呢，原因是什么呢，那p7 和p8 的最主要的区别是什么，这个大家想听吗。

因为大多数人可能到不了这个级别啊，这大家想不想听，想听刘老师扣个一，我们不想听，我就不讲了，就是说当你我我我现在把我们的课程p5 p6 ，p7 呢是归结为是一门课啊。

这门课呢我们把它称之为叫mc叫马士兵，slified architect好，那么在这个基础之上呢，实际上我下一步想规划的是p8 p9 p 10 summo，这个被称之为下一个系列呃。

人的成长呢总是一步一步来的，没有任何人上来天生进来之后就是p8 p9 p 10，但是呢你是可以通过一步一步的训练，慢慢找到这一步的，在网络上呢有很多关于p8 的课，号称p8 的课。

当你在p8 这里看到任何关于基础的内容的时候，实际上这事儿是不对的，你就记住这一点就成了同学们听我说，在阿里的内部，从技术角度讲，pg等于p8 ，这个事儿是to我再说一遍，站在技术的角度。

technique p7 是等于p8 的，好吧，这个事儿是true记住那p8 和p7 的区别到底在哪呢，我们是从普通的区别来说，p8 能管二三十个人，而pg的话呢管四五个人好。

这第一步的区别我就已经出来了，这叫管理，那么第二个的区别是什么呢，第二个的区别是我说的都是那个比较能量化的啊，第二个的区别是关于设计方面的，关于业务分析和理解方面的，这两个的区别给它区分开来呃。

那么设计我给你举个最简单例子，现在最热的设计理念或者叫设计方法，这东西是什么呢，它叫做dvd啊，就是我们呃p8 里面的这门课，七六体系七体系，p8 里面的这门课啊，就是关于dd d的这门课。

这门课呢是我我我给自己挖了一坑，我打算下一次呢把这门课好好的讲给大家听，但是你严格来讲呢，明年可能就是p7 了啊，所以呢在我p5 p6 p7 的这个课程体系里面，我把p8 的内容算是赠送给大家的。

今天啊，today，那么第二个呢是关于技术管理层面，就是说你走向p8 的时候，一定有一个角色的转换，是怎么从一个技术人转向一个技术管理者啊，滴滴地址关于业务的也是关于设计的啊，设计方法论的。

那么技术管理呢是真正的开始帮你做一些实物的，嗯在这个呢是我们真正的阿里p班啊，徐克徐老师，来带大家来讲这个p8 的课程，原来呢有很多那种线上的关于p8 的内容呢。

都跑到都都实际上都是p p7 里面拎出一点来，往上写那个事都是不对的啊，老师这里讲的叫做真的真真正正的琵琶的那种啊。

认真听就是了，呃我我我讲到这儿呢稍微的做一点小小的广告，嗯我可能刚刚呢其实也大体的给大家演示了我们现在的课程，我们现在课程呢基本上会分成两两个大的体系，第一个呢是p5 p6 p7 的知己啊，嗯。

先从体系上来说，简单的说一下，我讲广告很快啊，用着急，一会儿，如果大家有问题的话，咱们再慢慢的。

跟大伙聊啊，关于p7 的，关于p8 的，关于p什么的，那一般来说呢嗯在我们整个的这个技术职级体系里面。

好技术职级体系里面有关于p5 的内容，这个设备是称之为我们的零基础的高薪的就业就业课。

这个课程内容上的话呢，如果大家想想了解的话呢，点点过来，这个高级驾驶师就是高高级工程师的就业，就这块呃，这块内容呢基本上你就挨盘学，你不用老师任何帮你做一些特殊化的处理，就是零基础这块你就爱拍学就行了。

好吧呃，这个你学完差不多就是p5 的内容，当然当然大家伙注意啊，同学们你们记住这一点呃，如果你p5 不学这门课，不学算法和数据结构，这门课你就给我记住，了你那个叫特别水的p5 。

你实际上能到大厂去做屁股的可能性是比较低的，所以这门课是比较重要的啊，当然这里面有一些那个关于前端的一些小学的课程，但是它它不多，所以ipad的从头干到尾，你就是p5 的水平，这是完全没问题的。

好在这个基础之上才是p6 和p7 的内容。

那p6 和p7 的内容就会更多一些，p6 呢我们把它叫掌心和p7 呢叫做架构，可这里面关系是涉及到的东西就会比较多了。

我刚才给大，家展示的这个这个这个链接都可以啊，p6 内容的话就会更多一些啊，高并发的各种方案啊，高可用的各种方案那么高呃，呃扩展的各种方案啊，像通信和调用的各种方案，还有呢缓存四大中间件嘛，缓存中间件。

消息中间件，搜索中间件和存储中间件好，那么关于分布式的各种东西啊，就是分布式锁了分布式事务了，分布式的配置了，注册里发现了网关路由了，服务调用负载均衡断路器这些东西，这是关于分布式和微服务的啊。

分布式的链路追踪呃，数据分析算法能力的一个深入，当我们能够到这种程度的时候，一般来说我们就到p6 了，那到p7 是什么样子的呢，p6 和p7 的区别在哪里呢，p7 会稍微加上项目相关的知识。

关于项目相关的，关于架构相关的啊，关于源码和原理相关的好吧，关于算法敏感设计相关的，关于架构设计层面的百万设计，百万设计师，为什么呢，因为一般到p7 左右就120万年薪了。

所以这个课呢我把他认为是0_{120万年薪全覆盖的一门课，0}120万年薪全覆盖的一门课，当然这课，内容我个人认为是有所偏多的，那么我同学们应该在网上见到过啊，每周三次课。

每次两小时的这种普普通通的日常的这种这种这种层面的课程呃，老师的课呢跟那个层面的课呢是不太一样的，老师这课比较特殊，老师这里的课是直播和录播的综合题，首先第一点呢第一录播课时量是比较大的。

这个课时量呢大概要3000个小时左右，呃说这个同学们可能倒吸一口凉气，我就直接告诉你啊，很多很多的那个机构呢可能加起来不到400个小时，老师这节课是3000个小时左右，这是录播课。

然后呢每年要更新1000个小时左右的录播课，这是很恐怖的一个数据量，呃，像下一步要更新的呢有三三个大的课啊，第一个是dvd的，第二个是关于管理的啊，第三个是什么东西呢。

第三个是关于spring cloud全系列，这个spring cloud全系列呢大概有几十个字模块，就是，把spring cloud那个网站上你能看到的那些东西全给你讲一遍，这是我下一步要更新了啊。

这个工作量也比较大，但是呢我觉得这个东西是有必要的，当你把spring cloud透视理解理解一遍之后，你会突然间发现好多架构你自然而然就全理解了，那么在这个的基础之上嗯，好，会有同学呢他会有一些那种。

非常呃畏难的感觉，说这个那我怎么能学得完，首先第一点，我不是让你学完的啊，老师这个课呢不是让你学完的。

老师这课有一个比较大的特点。

那什么叫定制式，我们找一个体系课啊，c的架构师，就是我们可以进行一系列的定制路线呃，这是周老师的一条定制路线啊，我打开来看一眼就行了，就是这条定制路线呢是给某一个特定的学生唉，帮你定制好。

你应该先选哪一个再选哪一个，当然他帮你定制好路线之后呢，你就挨着盘子打开来学就可以了，好吧啊，这条路线是一条完整非常完整的路线，就是你要是说来了之后呢，就想花个1年左右时间把整个体系全部都补一遍。

good i拍学就搞定，嗯当然你也可以，当然呃你也可以这个呃采用呃个人非常特殊化的，就是你自己这个人，你和其他人呢有点特殊的情况，我不太一样啊，老师我就想两个两三个月，我就想把薪水涨上来。

那我这时候怎么办呢，好我帮你换其他路线就可以了，换上其他的路线，不同的路线走下来好吧，就是每个人可以有自己非常独一无二的不同的路线，帮你分好阶段，第二阶段应该是什么，有学员的各种的参考的笔记。

你可以进行下载，有算法相关的各种知识，你可以进行系列化的，那么当然你任何一个你你你你你你，像这种突击班的东西，你直接打开来就可以了啊，choose choose，宝典的设计模式啊等等等等。

单位直接打开来就可以学了。

呃这个呢是我们正在呃，这这是我们原来讲的一个录录录播的课程，single lion，我就在这里不讲了，然后呢除了录播的课程之外，帮你定制好特定的路线之外啊，这时候它的效率就会就会特别特别高了，对不对。

帮你定好特定的路线之外，那么，你还可以做一件事情，是给我们现在正在直播的内容，现在正在直播的内容呢，请大家访问这个网站就可以了，东宝第二码是0。com好，这个是用一个互联网三高的课程。

把所有的知识点的内容全部串起来，也就是项目的落地课，ok讲到这儿，就跟大家伙。

把这个图打开好，这个呢就是项目的落地课，目前正在直播的互联网三高项目的架构班，除了项目落地课之外呢，除了正在直播的项目架构版之外，我们还有非常牛逼的一个内容，叫做在线bug经验处理课，这课很少有人有。

主要是我们当时跟那个呃原来在京东，现在新浪的孙老师啊，他跟他聊天的时候，他就说呃，他说可以跟学生分享一些我们在大厂里头遇见的各种bug，到底怎么处理的，这方面的一个课程，哎我觉得还挺好的。

所以呢就给同学们讲了这样一门课，听完的感受还是很不错的啊，然后网约车的项目，电商聚合的项目，一级流量，多级缓存的项目好，这是我们的项目架构的落地。

可，如果大家伙对项目落地非常感兴趣，大家伙可以访问这个网站，同时呢在左边小海马这个地方下载它的白皮书，这个你去下载就可以了，好吧，这是我们项目的一个白皮书的诶，下载啊，呃内容比较多，有100多页。

你好好的把这个东西读完，你会有以下几项收获，第一一个正规的大厂的项目应该怎么做，相关的文档应该怎么写，你会了解，第二你把直播听完，直播听完之后，你会知道互联网的三高高性能高，可用高扩展。

像这样的一个东西到底怎么样才能完成，第三你会理解一个真正比较牛，逼的弹性的扩缩容的在云环境里面怎么样去部署。

我直接告诉大家，为了让大家能够访问得到，能够学得到在云环境怎么部署，我们直接在是把这个东西部署在真正的云环境里面的，大概到现在为止，我们部署了六台服务器，有它的前台环境，有它的后台环境。

有它的普罗米修斯的监控环境，这方面你都能学得到。

还可以吧，其实为了准备好更好的课呢，在老师这里叫做不计成本，不计成本，好亲们，牛逼两个字打在公屏上，谢谢大家，目前这么干的基本只有只有只有我们一个啊，你去找就是了，我看弹性云应该怎么理解是吧。

7669弹性云应该怎么理解，听我说，首先你要理解什么是云网络上的一大堆的服务器，你可以不知道它有多少台你的机器呢，是可以就是你的机器的各种模块，你的业务的各种模块是可以部署在这些机上。

无缝的部署在这些机上，那么当你有一些服务已经不足以支撑访问量的时候啊，比如说你平时这个服务有几个负载呢，有四个四个负载，四个一样的负载共同对外提供服务好，那这个时候呢你四个负载不够使了，双11来了。

好这个时候我们说有一种是一件式的说我后台点一下再起40个服务，共同对外提供服务，它是不是能接的流量就更大了，这是弹性的，这就叫弹性云，来这块能get到的，给老师扣一。

当然还有一种呢叫自动化的可自适应的弹性云，一般我们都把它称之为叫ai云，这什么意思呢，就是它会自动的根据你来的流量的大小来帮你起多少个服务，或者砍掉多少个服务来帮你做这件事儿，根据历史的流量。

根据现有的压力，它会自动的来帮你做这，件事啊，自动化的弹性扩缩运，这个可以说是现在这种做运维的啊，s e工程师，set reliable engineer，这是运维里面最新的一个概念了。

做运维的工程师所必备的一项技能，弹性的副作用集群和语音是同等同的吗，可以认为可以认为是等同的，这个无非是一个通俗的话的叫法，另外一个呢是一个专业化的叫法而已啊，好了，这是咱们的项目的落地课。

那么关于项目这块啊，那个如果大家伙能理解的话呢，就是一个一个是定制化的这个路线啊。

定制化路线，特定化的项目，就是这块的话呢，呃我给你举个最简单例子啊，第一个是关于项目方面的，比如说你的网约车项目。

这是一个挺挺给力的一个项目，呃，这是原来曾经就靠网约车去去就业的几个几个小小的案例啊，他就学了几个技术点啊，这这是我们帮他定制的一条路线，这边的并发编成了release spring cloud。

网约车一级流量好，薪资基本就翻倍了，他第一份钱都是七七千三是吧，第二个是15x10，我也就是22万多了，225000，第一份是8万 8万多，现在是22万多，可以吧，当时让你报名是不是要谢谢我呀。

感谢小九嗯，掌心人找老师了，好吧，传统项目通过验车找到工作啊，遇到企业还加价留人了嗯，这个呢是也是非常特殊的一个学生，这个学生是一个大专，全是一带专生，这小伙呢是刚毕业，刚刚毕业应届生。

就靠网约车项目拿到了21k的offer，作为刚毕业的学生，你最欠缺的四个字儿项目经验，你可能会点算法，那你可能基础还不错，但是呢你欠缺的就是这个项目经验，那么这块拿下的话呢，你的起薪会高得多得多。

好嗯当然有同学说了，老师那定制化有什么好处，定制化的好处在于很简单，让你节省时间，比如说我给你举个那个时间比较短的一些个例子啊，这1年你才能涨个薪水或者跳个槽，或者进到大厂，这个就有点太慢了。

半年调到成功便利峰，这些年收入10万，现在是40万，可以吧，成都的嗯，我就在boss上简历挂了半天，300家公司联系我，吓得赶紧把简历关了，我就挑了这些电视，哈哈哈，感谢课程学到了很多，这有点离谱了吧。

为什么，会离谱，不是你们可能不知道老师们关于简历修改的这种技能和水平啊，一会儿你看到这个简历的，你就理解了哈，呃成都40万年薪啊，当然学历还可以，本科本科的一个学历，他是学了半年。

学了半年时间是实际上算是比较长的，我告诉你，如果说定位非常的准确。

基本上应该是这样的，这个才对，成都学三个月跳槽涨薪干涨，涨了1万块钱，嗯这个是在北京学了半个月，大家听我说啊，就是学半个月的都是不太正常的，学半个月的呢基本上是这个这个课的给大家，带来的。

所有学半个月能长新的，都是这个课程带来的，这个课呢叫做面试突击，金九银十讲了一波突击班，再加上我们特色的就业指导课，也就是我们帮忙改简历的课，好吧。

这个只有这个这个课才能帮你在一个月以内来帮你涨起薪水来，这就是不同的人呢，我们采用不同的路线。

他的操作带来的好处啊，我个人永远推荐的是你扎扎实实学，但是有的人就比较着急，我已经离职了，老师我还想回来，我还想找点薪水，能不能做到可以，老师这可以，如果你不理解这件事。

儿我给你举个最简单的简历的例子，这小伙没学，报了名之后改了一份简历，每个月就涨了3000块钱，我可以毫不夸张地说，在座的诸位，你把简历扔给老师，老师帮你改完，每个月多两三千，一定能涨得上去，百分百。

想看点牛逼的简历吗，抽个奖励，安卓要p7 什么水平啊，知识简历规划好，从十就直接到14了啊，呃改简历薪水涨了150%啊，修改简历和面试，第一家就成功25k的offer。

你看他自己说的就知道了。

这老师不跟你们吹牛逼，昨天到今天100个人找我，我也是没想到对，不找你，不给你改过。

你永远想不到你的潜力是多大。

简历我就不刺激你们了行吗，我我我只给大家举一个最简单的例子。

你们认真听一下，我讲简历呢大概讲了六个小时左右的简历。

我记得啊，听我说呃，关于简历这块呢，我给你们讲一个最普通最简单的道理。

看看你能不能听得进去，想问大家一句话啊，我现在假设你的真实水平是100，有同学问你们想一下，你在简历上敢写多少，那么有的人敢写150，有的人敢写80，好好想一想啊，假如说有的人敢写150。

卧槽你太牛逼了，你本人真实水平你就100，你这种打凤姐的人，你敢去打泰森，你疯了，你好灭了，时间成了一家，当然记住别人找你面试的时候，一定是按你简历的水平，你简历写得越牛逼，他一定是说认可你。

只要能面试成功，第二人求稳，80面了十家哇，过了七家，我靠太牛太牛叉了，自己信心也足，有人面，我一定能通过，因为我写的少嘛，我以我90kg的水平去打那个40kg的级别的比赛哇，那那太爽了，对不对。

我就我就问大家一句话，谁赚了，好好琢磨，原来这哥们儿正常水平都拿2万块钱，结果这哥们儿靠150蒙进了一家拿了3万，结果这哥们儿呢拿了15000，你们好好给我想想，同样水平薪资就差了这么多。

它的区别唯一在于第一简历进行了修改，第二有的人呢进行了艰苦而卓绝的面试，有的人进行了轻松而愉快的面试，就是你拼还是不拼的问题，我告诉你啊，今天听课的，今天听课的有女有女同学吗，有女同学，老师扣个一。

我认识一下，有没有，千山灵应选清楚，ok good呃，女同学可能不太多，听我说，我接触到的所有的女同学水平是100的，永远只敢写80，甚至只敢写60，同学们，你们你们女同学们好好思索一下。

就是有好多时候为什么有一些东西，有一些项目组里面女同学总是起不来，因为男生呢基本上有80%的把握，60%的把握，他就敢往前拼，而你只有百分之百把握的时候，才敢去把握那80%的内容，记住记住。

当你一件事情你能往前拼的时候，第一往前拼，第二个你考虑它的后果就可以了，同学们，你们，想一下啊，所以100的真实水平，然后拿到了150的新对应的薪资，然后到企业里头的第一件事儿。

很可能最严重的后果是什么，你告诉我一下最严重的后果是什么，是不是这个这是最严重的后果吧，没有比这个更严重了吧，会不会把你抓抓到派出所去，会不会让你坐牢，会不会打折你的腿，不会吧，好那我问你。

你有多大的概率是用去被开掉呢，有多大的概率好，我们假设假设你进去之后一点努力都不努力，你就被别人带着走好，你这时候被开头的概率很可能有60%以上哇，60%以上，你在试用期就被干掉，那又能怎么样呢。

还有40%你能留下呢，但是我现在想问你，当你认认真真准准备了这150对应的这个简历的话，然后我，们课程里都有你面进去了之后，你能不能在晚上偷偷摸摸使劲儿地猛学，能不能够说当你遇到了任何问题之后。

直接在咱们这里提问，咱们的老师，我们这的老师呢下一步的这个意愿是半小时以内必有反馈，24，基本24小时以内帮你解决，你能不能够说能在这个面试试用期间，有80%以上的概率能待得住小伙伴吗。

结果你就不知不觉的你就记住了，你不知不觉的你就一路从100跨越到150，走的是捷径而已，就说你潜力是很大的，我再给你说一个最严重的后果，比如说你第一家公司干了两周，你水不水，至少得干两周你才知道吧。

被这家公司干掉了，好这时候有两种态度去对待这件事儿，第一种态度是叫做一蹶不振，一蹶不振，娘的我再也不敢出来了，我他妈丢了大人了，好第二种态度呢，来，东山再起，其实你下一次能不能成。

取决于你使用哪种态度对待这件事，那你既然你第一个能进到150的水平，能不能再来一件150的水平，你能不能在里面待够一个月，你第一次待了两周，你第二次能不能待够一个月好，如果一个月又被干掉了。

我再来能不能再第三次再来一个，那这次能不能带够三个月呀，假如你都待过三个月，还能被人干掉，大哥我就想想不通了，说明你根本一点都没努力哈，如果你选择一蹶不振也很简单，躺平吗，回到你的上下铺的上铺。

仰头对着满是疤痕的天，花板一只蟑螂缓慢的爬过你在心里背上的想，我的天呐，两周就被人干掉了，我的领导不知道背后该怎么说，我说尾号是9707的那哥们儿，小张儿水平这么烂，还敢过来骗我，好，别多说了。

三天以后，在你走人三天以后，当别人问他被你开掉，那哥们叫啥，他可能已经忘了姓啥来着，就是你在那里丢了个大人，丢了三天时间，然后你记了一辈子，一辈子，再也一蹶不振，当你在80岁的时候，身上插着尿管。

然后开始慢慢回想当初有一个拼搏的机会，我没有把握，后不后悔，好，当你理解了这件事之后呢，我觉得你就不应该再采用80的态度来对待这件事儿了。

系列 1：P6：职业迷茫：给想进大厂的小伙伴指一条路 - 马士兵官方号 - BV1mu411r78p

嗯这机体系它怎么设计，为什么是这么什么这什么这么设计成这样的，我就不多说了，我主要聊大家比较关心的呃，就是什么样的人会是p级，然后呢他主要是那个那个那个那个主要的能力是在是在哪个层面上，好吧。

那么关于这个的话呢，嗯你可以完完全可以到我们的网站上啊，就是嗯找到我们m c a的这个课。

他的课程介绍里面嗯。

我们在这里呢做了一个自己的非常粗浅的一个总结，但是大家伙可以作为参考呃，首先我跟大家说一句啊，这个p5 是一个什么职级，p5 是一个入门，级别的大厂入门级别的直径，但是后来p4 这个直接就不招了。

现在基本上就是p5 ，p5 是什么样的人会是p5 呢，按理说应该是0~3年，他们认为你是p5 好吧，也就是说你社招3年以上的，那直接就是p6 了，但是到在目前的情况下来说呢。

大多数的情况下作为p5 是你刚刚毕业的应届生，应届生往往是定级p5 呃，不管你是本科生还是研究生啊，我这里头没有提专科，因为专科屁股这个职职级你进不去好吧，刚刚毕业的应届生，然后呢大，概在你工作。

你比方说你最开始的时候没有进到大厂里面，你进到了一家中小厂工作3年左右，哎你社招通过社招进大厂了，这个时候往往是p6 ，然后你在你项目组里头慢慢成长为带那么四五个人，这个时候你往往是p7 。

当你负责完整的整个的项目组的时候，我告诉你，你这个时候呃，大概你手底下是几十个人的这样的一个一个一个规模的时候，大概就是p8 了，当你手底下有不同的技术团队，你这个时候就是p9 。

那个如果从呃薪资的角度来说，p5 的薪资的话呢，大概是20万~40万左右，那么如果是从。

p6 的薪资来说呢，大概是40万~60万左右啊，呃如果是p7 的话呢，大概是50万~70万，但是这时候是有股票的呃，就是大部分p7 是有股票的，只有少部分没有，因为阿里有一种文档，p7 也比较好玩啊。

他专门写文档的，他那个薪资就低很多，50万_{70万，大概再加上800}1200股啊，你这个股票比较值钱的时候呢，这个差不多p7 的薪水能拿到120万左右顶薪，哎，我讲到这儿。

有没有同学想想看看那个p7 的简历的，有没有，有没有有的话给老师扣个一来，3年以上还可以练p5 吗，3年以上你就要奔p6 去了，你为什么还要练p5 啊，干嘛这么看不起自己。

我我我给大家看一个非常牛逼的简历啊，这个是顶薪的，120万年薪的简历，我找一下。

这个呃这哥们儿当时是29岁，拿到的是阿里的p7 plus，它不叫p7 ，这个叫p7 plus，我一会给你解释什么叫p7 plus，p7 plus那个呃100就是80万的正常薪资，外加40万每年的股票。

就类似于大概的估算的值啊，120万年薪呃，你们也可以呢读一读，看看看这个简历呢，呃自己能不能罩得住这个简历呢，如果你仔细读的话，其实你会看得出来那个这里面最重要的最值钱的点到底在哪儿。

5年java开发经验，其中3年以上全是大型系统架构设计经验，3年以上团队管理经验，这是最值钱的，当然目前政府的什么注册用户多少，日活多少，日访问量多少，这种的比较吹牛逼的啊。

这实际当中的数据很可能到不了这么多，嗯，对开源源码有过深度阅读好，从这儿呢你大概可以看出来p7 到底是一个什么样的水平，架构设计，源码阅读，这就是为什么我在课程里面会给大家这么设计的原因，明白吧。

就是老师的课程设计不是说随随便便给你设计的啊，为什么要读读源码，读原理，为什么要做架构的设计。

其实就在于这儿，就是希望你们能达到这样的水平，当然不是说每个人的薪资都能达到120万不是那么容易的呃，取法乎上得乎中，取法乎中得乎下，你的目标定的高一点，哪怕没有到，你跟其他人相比，你都是赚的。

你的目标本身就定得非常低，我今天就吃掉一个饺子，你就算达到了，你也就吃了一个，我今天要吃100个饺子，然后就算没吃完，我吃了50个，那我比你这一个也要牛逼的多得多好，这是他的一些个技术站。

这些技术站咱们课程体系里全有呃，可以，这么说，我的很多的课程的设计，是根据咱们同学们遇到的各种各样的问题来设计的，那个这这这这全是一堆一堆精通了啊，这个你放心啊，呃其实看上去很难。

但是呢不是想象中的那么的难，无非就是你需要掌握架构的一个技术选型是吧，当然最新的还有pose啊，然后呢搜索上的一些技术选型啊，这种那种呃这个这个持久化的一些技术选型，缓存的一些技术选型等等，就这么多。

加上一些底层的知识呃，他这个呢还没有写算法，写太多啊，其实还需要有有一点算法的知识就ok了，这背后究，竟付出了多少嗯，不要不要羡慕别人。

我有的时候会说，可以拿别人来举例子，但是呢每个人的路啊，每个人的人生路它都是不一样的，你不可能完完全全的复制另外一个人的人生，跟自己比就ok你比自己更强了，今天我比昨天强一点点，明天比今天强一点点。

时间稍微一积累都不用长，几个月的时间，你就会发现你已经脱颖而出了，其实就这么简单，那个，你你你你你们想知道那个那个那个他现在的一个状况吗。

这个这哥们儿是是咱们史上最牛逼的一个学生啊，史上最牛逼的学生，你找一下他现在的一个状况啊，呃这里是大概有1000多位我的学生，然后做的一些个小小的总结和聊天的这个过程，嗯，我找一下啊，嗯就是他，对。

呃这个呢是他那个最近然后拿了5000万的股票套现之后，然后从公司离开，做了一个小小的总结，就是p7 的一些一些一些内容啊，p7 说到底是硬通货，是个分水岭呃，这里面需要你掌握什么，需要你掌握什么。

需要你掌握什么呃，大家可以到这个网站上去访问访问看看，这里面都是很多同学非常真实的聊天啊，你们看看就会知道了，那个嗯当然还是那句话啊，就是这种的比较极端。

我也绝对不会说奢望说我们每个人都能达到这样一个水平，我在他这个年龄的时候也达不到这样的一，个水平好吧，所以大家呢也不要说太羡慕，这个也也没有意义，但是呢最起码这份简历会给你指出方向来。

我们可以朝这个方向去吧，我们今天啃下来其中的一小点儿是不是就进步了一点点，我说今天我们甭啃别的，我今天啃了一个分布式事务，这东西不难的，咱们一堂课里头呢，差不多你花个三天，顶多花个三天左右的业余时间。

就能把这搞就能就能够把这个搞定了，你知道吗，我们是不是搞定一条好，我今天不干别的，我就聊一个自动化部署，我今天不干别的，我就把docker给搞定了，你想想看这个三天，这个五天。

然后那个七天加起来的话能有多长时间，最重要的是你根本没有必要每一个都全部精通，面试的时候，我说过了十加成两家就可以了，不用面面俱到，这大家能听进去吗，天神下凡对什么学历啊，学历相对比较好，985。

浙江大学，浙江大学是985吧，嗯肯定是啊，当然我说到这儿，很多同学就开始给自己找借口了，老老哥，我是大专，所以我不如他很正常，因此我又可以安心的躺平了，我说我再给你说一遍，我说他这个案例不是要你跟他比。

而是要你建立起来跟自己比的感觉，你今天要比昨天强一点，以他的这个技术为目标，我能听进去吗，就是你天天跟比尔盖茨比，那你这辈子永远完蛋，你天天跟埃隆马斯克比啊，你这辈子就别活了，所有人都别活了，对不对。

跟自己比，我今天比昨天强一点，明天比今天强一点不就成了吗，能忽悠大钱的背景肯定背景必须放光，这就是背景背景决定论嘛，来我想问你那个马云背景怎么样，马云985的对不对，马云是杭州师范的大专生吧。

如果没记错的话，对不对，英语老师对啊，所以不要找借口，我跟你说，你所有的这些这么说的，其实都是在暗示自己，我没有他的硬件，所以我有自己的不成功的借口，其实就是这个给自己一点心理安慰嘛，我是种田的。

对嗯嗯好了，但是这个就比较夸张了啊，我们讲想想起来了，拿这个举个案例呃，这是一个p7 的薪资，那p8 的薪资的话呢，多数人应该是到不了的，呃到目前为止，我直接培训的学生里头还没有还还目前啊。

我跟大家说呃，确实我还没有能把一个人直接呃学完咱们课给，干到p8 的，i'm sorry，我这个还确实还没有干到，因为p8 呢真的就很难培养了，他的这个薪资呢大概是200万，也就是按照官方的说法。

应该是120万~200万啊，这是这样的一个薪资，那么这里面呢就有很多很多的非技术的因素了，技术层面我完全可以让你到这个水平，但是非技术层面我也在尝试呃，目前呢也有一点点好好一点的那好消息了啊。

就是这这这这种层面等于我我也在给大家做尝试，就是课程体系里面为什么给大家要增加团队的管理课，产品的管理层，其实呢就是想，让大家在你以后的职业生涯里头走到高端的时候，也能够还有空间嗯，到现在为止。

我是我们现在有一个学生啊，我在我的微信里已经把他给置顶了，我只有一个学生，他已经灭了七面了，明白吗，他现在练p8 ，他灭了七次了，已经灭完这七次之后呢，还有第八轮的交叉面。

就是为什么说那个那个那个那个那个那个哥们儿说那个我可能灭了，灭了七次了，还没这个皮八，定级太难了，确实非常的难，然后呢还有最后一轮的交叉面，因为什么，因为它要求的定级太高了，所以就一一轮面一轮面。

一轮面一轮面，然后很多人都认为你确实到这个程度之后才会给你这个知己，当然这个直接到来的时候就意味着200万年薪了o呃据我知道的，从京东呃跳到高德的，就是那个有一本书叫一级流量，我不知道你们了解过没有。

那本书，它的作者就是从京东跳到高德啊，我当时微信联系了，说给咱们来讲讲课，然后呢高德实在太忙了，高德可能是阿里里面所有最忙的bo，然后那个没没有时间讲课啊，不然的话呢把他请过来讲讲课呃，从京东跳到高德。

大概是据我了解，应该是这个数400万，嗯所以小伙伴们，你首先要敢于想，就是你要知道呢，这个世界上呢是有好多好多潜力的，你首先你你的潜力呢也不要想那么高，我现在拿12万好，我明年的目标能不能拿到18万。

听懂了吧，这就是一步一个脚印的扎扎实实的，今天比昨天强的非常科学的一个一个目标的顶级，ok怎么说呢，机会有的是啊，在这里呢大概是1000多份，1000多位的同学好，同学说，老师你做假放心。

老师这里的全部的案例要有一份是假的，十倍学费赔付给你，你随便找，你想找任何一个人说他的那个那个找他，联系方式，只要他同意，我都可以给你联系上啊，嗯怎么说呢，这里面的案例呢就是不同的人。

不同的案例都多的是有顶级的，我刚才介绍的都是顶级的案例，当然也有呢刚刚入门级别的，还有就是路是一步一步走的啊，比方说入门级别的像什么样子的呢。

嗯这种呢最开始呢原来是拿8000块钱，然后学学四个月给拿到1万 14000还可以吧，1年就7万多呀。

当然扯得远了，我们翻过头来再来看看啊，就是什么样的人可以到p5 ，什么样的人呢可以到呃p6 ，什么样的人可以到p7 ，他到底是都需要哪些哪些东西呃，我刚才呢给大家讲了一个概念，这个概念呢叫什么呢。

叫p7 plus，你们这个你们知道这个plus是什么意思吗，有没有知道这个plus是什么意思，呃我想问大家一个小小的问题，那个这里有一堆p6 ，1233个p6 ，我要在这三个p6 里面挑一个人做晋升。

升值为p7 ，来你告诉我谁会升上来，谁会升上来，who，当然有同学说就开玩笑了，开始是吧，长得漂亮的跟平跟那个考考评官有一腿的，跟考评官关系好的，首先第一点呃，高级别的晋升并不是只有一个考评官。

也不是只有你熟悉的那个呃，第一点长得漂亮更漂亮，长得漂亮确实有点优势啊，但是呢他肯定不能不是决定性的因素，好好听我说，如果我要在三个p6 里面挑一个p7 出来。

那么我一定会找那个优先已经开始做p7 事情的人，能听懂吗，我再说一遍，如果我要在一堆p6 里找一个p7 出来，我一定会找那个已经开始在做p7 事情的人，好了，这个就是p6 plus。

同理那个就是p7 plus，就是我为什么说在你们平时工作的时候，要多承担一些，多做一些，不要老搁那斤斤计较，我给我这点钱，我就干这点活，我多干点我就亏了，我我是真的遇见过这个这样的人。

这样的人最终的结果就是滚蛋，没有别的，所以让自己就是简单说提前一步好吧，来听进去的，给老师扣个一，嗯，讲点，今天感觉讲的比较碎，因为主要我没有给大家解释为什么自己体系啊，典型的这体系是什么样。

嗯以及呢他的一些个各种的说法啊，我简单跟大家说一说，这就是大概是一个什么样的，什么样的，什么样的一个一个一个，一个水平吧，就是p5 呢他大概做了一些哪些事情啊，p5 大概是这样的，它叫做。

直直级的入门就是新兵啊，给你一个模块，在别人的指导之下，我告诉你啊，这个这个东西要完成这个业务唉，然后告诉你用什么技术好了，然后呃作为p6 来说呢，就是p5 来说就是某一个模块的分支，就一个小程序啊。

那么p7 的话呢实际上就是项目整个项目级别，你可以带领团队来完成整个项目，好吧，呃基，本上大多数人呢是集中在这三个职级啊，我目前只有一个学生在冲p吧，他冲不冲得下来，冲下来我会告诉大家，冲不下来的话。

我也不会在这吹牛逼啊，作为p5 来说呢，一般来说我刚才说过了，就是应届生，所以呢你社招生呢也就别跟那玩什么这种这种这种玩玩屁股了，好大家听我说啊，呃在这呢我给大家讲一个比较大家比较关心的问题啊，就是。

如何在毕业的时候直进大厂来，有有有有多少同学毕业的时候想直进大厂的，有没有有的话，扣个一来冲屁吧，那个年龄多大了呃，冲屁吧，那哥们儿38岁，我我我找一下，找一下我微信，因为他的我已经置顶了啊，这样看啊。

你看还有这个，我不不说人名了啊，听说妈也很喜欢logo，要是一把100万以下，我就直接挂电话，这也是咱们一学生啊，他说我现在学越学越觉得一级量一级流量的项目有点意思，还在落地啊，呃。

我找一下刚才那个冲琵琶那个啊，这个是这样的，对他说那个嗯谢孟老师报了咱们课程，每次面试都心里特别有底啊，争取早日突破年薪百万，当然这个都算是相对高端的一点了，我们还是那句话，就是大家伙现在薪资比较低的。

没有关系，呃，你呢可以一点点的慢慢慢慢慢的慢慢慢慢往上涨，20万涨到40万，40万再涨到80万嘛，一点点来嘛，呃我找一下那哥们儿到底在哪里，嗯，我电脑上可能是没有缓存啊，嗯只能在手机上。

手机是没法演示的，呃他的年龄我记得应该是38岁，差不多是这样的一个年龄，呃，我算了算，我们聊回来啊，呃我们来聊这个在毕业的时候只进大厂来说到这儿，今今天今天开放开放一点儿，大家伙加微信吧，好不好。

我突然间想想到这个问题，因为我的第一个微信呢其实已经满了，然后又开发了第二个微信，我第二个微信呢是这个号，m sb 20191是吧，确认一下，你要是愿意的话，也可以加一下老师微信。

就是你报不报名报报可真的都没什么关系，我平时也比较喜欢跟学生交流，你要是愿意啊跟老师交流交流你的职业上的一些想法的，觉得愿意听听老师的意见建议的，没关系的，留个留个言啊，但是你不要跟我直连聊天就行了。

呃我一般呢就是有空的时候才会回好吧，另外呢不要寒暄，你不要说老师在吗，不要问我这种话可以在也可以不在，有啥事就直说留言就ok好吧，你要愿意的话，也可以加上老师微信m sb 201911嗯好。

我说毕业的时，候直进大厂，什么样的人能进啊，听我说呃，我说到这儿呢，可能有些大专生呢会不太开心呃，这么跟你说，大专想直进大厂呃，基本不太可能，那个一类我首先是定义什么叫大厂啊，这个大厂的话呢。

我自己的定义叫做一类互联网大厂，大概就是这些百度阿里京东，腾讯字节拼多多，美团滴滴快手，华为蚂蚁，网易，新浪微软，谷歌甲骨文尔考拉，就是下批小米az，当然如果你还觉得还还可以认为是大厂的话呢。

你也可以往里添加，比如说他投资占比超过10%的，这个基本上长的都是不错的，ok，还还还有补充的吗，vivo，i i don't think so vivivo，我觉得不算互联网一线大厂。

但vivo给的薪资据我所知还可以，请稍后再试，what，这并发量上来了，应该是，什么什么时候你想起来在家吧，好不好，嗯，没关系诶，难道是并发量上来了吗，哦有24个有24个新好友的申请啊，等我慢慢通过。

通过之后再慢慢再再再再再慢慢加吧，不急那个一般来说呃，大专和三本算一算一个层次，而这个层次呢不好意思，进，进不了，就是毕业直进这件事情，不能说百分之百的不行，但是99。99%的不行。

但是我会告诉你后面你该怎么进好吧，不着急好，只要你是二本，你就有机会了，历史一本90%以上的概率，老师送你进去，211985，基本上百分百接近百分百，99%的概率，老师能，送你进去呃，同学们听我说啊。

当然我是需要时间的，你不能说你明天面试了，今天找到老师，明天我就送送进去，这个这个不太可能，但是像211985的这种的，你只要大三找到老师，差不多就能送你进去了，呃给大家抽几个案例就成了。

给看几个字节的啊，我一会儿告诉大家是怎么怎么最容易进去，好不好，呃，这个是字节，大2l大三，这是最开心的，oppo只能算在我看来只能算二线的长，呃，听我说，如果你学历高，比方说你是一本，你。

是985211呃。

当你找到老师，基本上就板上钉钉的就送你进去了，而且呢在这儿我也跟大家说一句呃。

我们目前也已经打通了和华为的这个内推内推的渠道，但是华为要求比较高，它只要985哈哈，华为现在比较格调比较高啊，嗯那个那个我我告诉大家啊，大家听我说呃，毕业的时候直进大厂，实际上不能叫毕业的时候。

这是最合理的，也是最简单最安全的方式，听懂了吗，当然准备这件事情的时候，我希望你是从大二开始是最合适的啊，大三开始呢稍微有点晚，但也还来得及，大四就有点晚了，老师就没有那么大把握了。

好有多少人目前是在大二大三的，你扣个一，有有，大一大二嘛，大一大一大二更好了啊，对21985研究生也是可以的，完全没问题啊，大四了就是得得得得得得看运气了好不好，但你也要努力啊。

你不能说大四了我就放弃了，也不要这样，没关系啊，像这种刚毕业的，我也会告诉你后面该怎么办，年龄大的咱们往后放放，我告诉你该怎么办，呃他们听我说，是你最容易进去的，第，一个叫做你的专业课。

你认真听就是了啊，第一个叫做你的专业课，专业课有哪些呢，有同学说那个那个那个数数字电路，模拟电路啊，高数no不是用不着，我讲这个的时候，非计算机专业的同学们，你也认真听，你只要把这几门课补上。

你就跟计算机专业没有太大区别好第一门最重要的课叫做什么东西，叫做计算机组成原理啊，简称g组呃，我在讲课的时候是把机组和操作系统混在一起讲，为什么呢，严格来讲呢，如果说你只是做java后端，做软件的开发。

这里面硬件的很多东西你可以忽略掉了，我讲课的时候会给大家讲一些硬件的东西，但主要是跟软件有关系的啊，但是你像那个门电路怎么设计，门电路怎么组合，像这种的就没有必要啊，呃讲到这儿，那个推荐一本书吧。

有有有有没有有没有非计算机专业的呀，有没有我来推荐你推荐一本书吧，我看我那书在在手边上吗，有飞机的就专业的吗，非技能专业的，扣扣扣个一有吗，就是飞机算机专业，你补计计算机组成原理，你补哪本书啊。

有好多书籍肯定懂的，原理讲的太深了，你补起来也费，劲我就教大家啊，你是你，大家稍等我一下，我拿拿一下那本书，好找了，我这说扔的太乱了，不太好找，直接说吧，嗯这本书叫做编码，搜一下给大家搜一下。

ok这本书啊，你可以截图，就是编码隐匿在计算机软硬件背后的语言呃，呃所有非计算机的这种这种小伙伴们看这本书去做那个硬件的入门，听懂了吧，ok，呃说呢讲的比较有意思，也比较简单啊。

呃你像我在讲那个多线程的时候，我基本上就是就是给大家呃过过了一下这个硬件的知识，因为原来讲过一个多线程的内容，大概它里边是讲的这些东西嗯。

大概它里边讲的是什么东西呢，就是这个硬件的基础知识啊。

嗯cpu的原理就是从门电路啊，就是这些门电路到底是怎么怎么组成计算机的，这个软件是怎么驱动硬件的啊，为什么计算机一个非常硬的东西，我们居然能够用写程序的非常虚虚的东西去控制它啊。

这这件事情很神奇的啊。

呃但是呢你只要把这把这书大概6万。

系列 1：P7：课堂答疑——不同学员的不同路线(1) - 马士兵官方号 - BV1mu411r78p

在这就不多说废话了。

我们聊会儿小天儿啊，准备结束，今天啰里八嗦的聊的东西比较多，讲的有点啰嗦，主要脑子里东西太多，一讲的时候吧就容易发散，讲到一个点呢，唉想到一个案例，就想给大家说说，讲到一个点。

像这个案例跟大家说说就就会比较多啊，这个东西呢叫知识的诅咒，就脑子东西太多了，明白吗，所以讲东西反而讲不清楚了，脑子里的东西就一个1+11说就清楚啊，当然跨越这个知识的诅咒，也是需要慢慢来的。

老师一定能跨越，老师咱们网站的自测的题，麻烦赶紧添加哈哈，呃需要人力一步一步来啊，你看有有几个小同学看看他的一个情况呃，28岁的男生，硕士，上海4年，国企4年300080技术20km，竞争较慢，想涨停。

纠结确定不了下一步的发展方向，那个首先第一点要判断一下，你在你们原来的这个企业里头，有没有下一步的成长空间，那如果没有了，要就要考虑跳，那跳的时候呢，呃由于你已经在国企4年了啊。

这个呢你你要想像你这种的啊，如果想进那个一线的互联网大厂，这个基本上属于板上，钉钉的事情啊，就是百分接近百分百啊，无限接近百分百，假如说你现在这个30万，你想拿到60万嗯，大概给老师的话。

也就也就需要半年左右时间，不会超过这个这个这个年限啊，明年34月份左右就让你进去了，呃但是呢你得自己呢做出决策，有老师能提供建议啊，就国企是比较清闲的，呃，你拿这个年薪，能不能去接受一线大厂的苦啊。

一线大厂的卷，那个，或者你就甘愿在国企里面，拿一个比较低的年薪，比较清闲，这个是你自己的选择，能理解吧，嗯而且你需要你就是你需要很多细节，我就在这没法没法说太多了，就是基本上把你送进。

送你进一线互联网大厂的，应该是玩似的，很轻松啊。

32岁的男生，本科大连205000年，其他语言3年，对日呃，对日向啥要懂一些，但是不精，那个是这样的啊，那个如果你想提薪水，其实我觉得你这个年薪啊，好像在大连还是不错的呃，提醒率的空间有没有，当然是有。

这个是需要看机会了，骑驴找马，慢慢找着把技术提上来，你的机会就多了，就是这个意思呃，但是你你你你你你说你这个满足一堆日，我觉得就有点不求上进了啊，就是对日的话，那你应该知道他好多技术用的非常的古老。

而且特别的死板，他跟好多那个技术的主流都格格不，入的啊。

你这个的话你不追求技术上进，那就啥也不说，你要追求技术上进的话，那必须得搞点新东西啊，呃对日的这块，我找找我们有没有对日的小同学，这是一个自考的大专生啊，对日项目12k到23k，继续30k的文化路。

他是是不是是不是也在大连，我忘了，因为大连对日是最多的，就是你提的目标不太明确，你如果能提出明确的目标来，比方说我给你举个最简单例子啊，就是大连嘛全国的城市里头啊，呃说这个又又又想多说了。

你们想知不知道，就是说全国的按照it薪水的排名，全国城市的排名是什么样子的，你了解吗，如果想了解的，扣个一好吧，我告诉你啊，这个跟很多人想象的可能不太一样啊，他们听我说排在第一的薪水。

排在前面的叫北上深航啊，北上深航，而且这四个的排名基本上就是1234，没广州什么事儿，没有广州什么事儿啊，呃第二个呢第二类的城市就是二线的城市，所谓的二线啊，就是基本上可以算上广州了，广州南京。

然后据我所知的话呢，厦门应该这个薪水也是蛮高的啊，珠海这几个薪资都都是蛮高的，都可以给到比较不错的薪水啊，珠海那个这算是二线吧，然后你像呃武汉成都，这个武汉成都那个像什么无锡啦，苏州啦。

呃然后这一类的吧，呃基本上再往下排一节，然后你像大连大连郑州，济南青岛，然后石家庄呃，西安呃，就这一类的，ok再往下排一级，不知道大家能不能理解，所以大连呢他是这样的啊，就是凡是处在这个层面的。

就是三四线往后的，我可以这么说，不吹牛逼的说，就是老师这课，你只需要理解个50%到60%，那么在这个城市里面，排名在前5%左右的这个岗位，所需要的技术，你就基本上全部涵盖了啊，比较简单。

所以你要想提薪就简单，就看大连那边有没有机会啊，有机会的话呢，你就去去去拿这个机会就ok了，呃我记得我们在成都就业的挺多的，这个啊，这是成都的海康威视，30万年薪左右，成都好像最近的薪水还可以啊。

有一些大厂的嗯，跑跑过去了啊，呃这个成都年薪涨了20万，很牛逼吧，就是他本身年薪涨了20万，他不是说年薪是20万啊，成都翻了倍了，5k到10k，这太简单了，这是比较老的一个学员。

就学了spring cloud，成都18k的offer，当然还有一些我记得武汉武汉也不少，武汉的小同学，武汉的薪资的话也好像也也还是不错，这是涨了4k，从12k干到了20个，在武汉。

那个30万年薪在武汉呢啊，呃四涨了7k的，大连的话，我忘了有没有有没有啊，大连没有，sorry，没有案例，但基本上像什么沈阳是不是有啊，沈阳这个应该那个跟大连差不多吧，呃涨薪涨了4。5。

坐标沈阳那个这是6。5~14啊，就是怎么说呢，东北这一带呢薪资偏低，所以你32岁拿了20万年薪，他差不多每个月18k多点啊，其实还算是可以的，你明白吗，所以你要想追求更好的薪资，首先去找你们城市里面。

有没有这样的工作机会，如果有老师，就一定让你把技术达到听懂了吧。

还有2年半，大专23，学历低，但是想进大厂，刚才我已经说过，专门讲过大专怎么进了，嗯，你能应该第一步提学历，就你提上来呃，但是我觉得你薪资还可以，还是很不错的，不要轻易跳槽补技术，然后大概半年到1年。

我感觉啊我直觉上，因为你中间很可能是跳过槽，我要看你跳槽的情况，如果跳槽跳的不是很频繁，补学历补技术，你就有机会了，但是这个机会我绝对不能说百分百的保障，听懂了吧，但是你这个年龄还是很给力，比较给力啊。

你行就是路线也很简单，补学历不，计术你就有机会了。

就这么简单，二期最贵啊，2。5年有接触过，最近面试都为微服务，那你就扎实学就行了，像在贵阳来说，就是贵阳那边提供什么样的薪资，像啊你还是本科，贵阳那边最高提供什么样的分支啊，这个这个这个呃薪资。

老师就一定让你把技术站给你涵盖到。

当然贵阳薪资肯定低低好多啊，这个没什么可说的，没有办法，年薪40万，年年年跳大厂钱应该拿多少薪资，你首先大连有没有大厂啊。

应该没有，所以你应该是要从大连出来呃，你从大连出来，8k的话呢，在你跳大赏之前，我希望你能拿到18，至少是18，是我们本科没问题的，学历够拿18工作个1~2年，然后跳大厂，然后到40万不成问题。

听懂了吧。

因为我前面讲的比较多了啊，我就讲的直直直接一点好吧，行就行不行就不行就算了，37岁401000年10年不提了，大专70万保险中介呃，这个呢应该是有点儿嗯，因为这个大量的小同，大量的大量的小同学。

就大量的同学呢，我我得透彻理解了解你原来的一个背景啊，然后你跳槽的一个情况呃，如果说你原来还算是比较稳定，我就觉得特别奇怪，你37岁了，没想着把这个学历给提上来嘛，就说你这个原来原来的规划就是有问题嘛。

对不对，嗯刚才说过啊，你要想在整个的你的大龄的人，要想突破的话，尤其是这个大专的背景的话，要么就是你的技术非常的过硬，一定是架构师的级别，到不了这个级别，你就不要提，汽车，1年肯定突破不了。

那么要么呢就是你走管理岗，但是你管理岗的经验怎么样，这个不好说啊，所以怎么说呢，嗯作为你来说，提架构，然后提学历，然后提管理，恐怕你都是要面临的问题，听懂了吧，嗯，当然啊你只提架构。

其实呢从你现在的薪资也能涨上来，这个是没问题不大的，因为现在架构是给的薪资还是蛮高的，但是我说的是你长远发展这三个层面，你恐怕一个都避不过去，不要认为我37岁了，我就可以放弃了，我我我这这辈子就这样了。

不要这样啊，有的是机会。

嗯提学历，提技术就是提架构，架构层面啊，我现在不给你提算法了，算法对你来说意义就不大了好吧。

具体问题具体分析一下，大龄的小伙伴呢，我得看你非常具体的背景，青岛31岁，1万块钱，三本本科突破25嗯，青岛到25就是顶薪了，所以你要准备技术就行了，这个倒不太难，那个我们原来张洪刚老师，他就是青。

他就是青岛的，他离开青岛之前就是25k呃，在青岛那边的惠普呃，但是青岛的25k好像就是更新，你可能得去什么，像海尔海信哪，像这一类的可能都得是很，好的一个薪资才行，嗯所以呢你技术过硬才有这个机会。

技术不过硬，把把架构补上啊，你到你到青岛现在这个程度就是不架构，补什么架构呢。

我告诉你啊，说到架构呢，我也跟大家多聊两句呃，就是在整个课程体系里面嗯，在资深架构师应该掌握的技术体系啊，这里就这部分是我们下一步的一个重点，也是你将来的重中之重，我虽然把它放到了新增里面。

但是我认为这部分呢，是所有人都应该掌握的东西，这是你将来做架构的基础，这个东西就叫做云原生，当，然云原生的内容相对来说比较多，我们自己像我们自己的这个平台，就是搭载原原生的基础之上，是华为云。

华为云上相对便宜一些，呃然后呢有一部分是搭载了阿里云，阿里云比较成熟一些，你一定要理解整个云原生的架构，这是未来的架构，可以说将来你所有的架构师都避不过去的，东西是必须要理解的，听懂了吧。

那么你在青岛的话呢，嗯要理解这些个，对青岛当地的i i it人来说，可能相对观念稍微超前一点东西，那么你就能领引领整个你，你你你的整个薪资啊。

长春211 28，日本读研躲疫情，回来找到工作，10k以上大哥，如果你给老师个三个月左右搞不定，做了三个月又三个月，刚好过年过完就过完，春节，你给老师点时间，如果让你搞不定这个薪资，老师一分钱不收你的。

ok你扎实来啊，你这个一定搞定的，如果你愿意走出长春，老师90%以上送你进大厂。

你这个太简单了啊，学历又好，背景还不错，就算你以前的底子再弱。

你只要听话，老师都有办法让你提上来啊。

27男生本科16，深圳4年涨薪，写的越多，老师文化越详细，你没什么可说的了，你这你这27岁的正常的薪资是多少，最少25k以上吧，所以第一目标拿到25，这简单啊，就几个几条线就让你到了第一条线。

项目线spring cloud，现在比较流行的项目，可能网约车项目，就一个网约车项目，就让你干到这个这个这个薪资了。

这个不吹牛逼啊，就是你把这一个项目搞定，很可能就就到了，网约车，这是应届生平，网约车项目给干到了21k的offer，这哥们还是一大专，我印象比较深刻呃，这是小白。

拿网约车面试了15k的，你才16k，这是网约车，涨到了那个涨薪资涨了5k，原来是25，现在30，学了几个技术点，薪资翻倍的，所以你这个真心不难啊，这把几个点拿下可能就够了。

二本二本浙江明年这样有更高的见识，不了解，基本上只了解代码呃，你现在还在还在读书吧，读书的话，我刚才认认真真给你分析过，在读书的话，怎么杀进大厂，技术底层，外加算法是你避不过去的。

这两个是必须的重中之重的，然后项目大数据都是你的加分项，嗯细节比较多，我刚才已经透彻分析过，就不再多说了啊，如果你忘了你，好不好，lavender，那些13万，其他职业1。5年培训一下，正好开发1年。

河南科技一本，有经济大厂，你下一步的目标不就要进华为吗，当然有机会进战场了，你华为不是是不是德科呀，如果是德科的话呢，呃我就直接告诉你啊，123456，所以扎实练技术练算法，然后呢目标进进华为就ok了。

因为西安的话大长环也不多好，有阿里华为，就你就这两家吧，啊所以目标就这华为就ok了。

24岁3年11哎呀，这个新姿态在中大厂呃，几科本科二本，你听我说啊，半年涨到22，如果到不了，老师退你钱必道，你觉得你这太简单了，我都我都我都不知道该说什么了，有好多人呢可能对我说这话，他老不相信。

他说那个老师你凭什么一拍板，你就能知道我就一定能突破这个数没什么，因为我们对可能太自信了，像这种的太多了，你明白吗，你这个毕业12，刚毕业12k了，像你这种涨幅的薪资呀就太多了啊。

十几k涨到20几k的啊，我就直接告诉你啊，这个就是贼多贼多的，以前12x12，北京这很普遍的啊。

这不是不是说一星半点的那种案例，就是拿5000万的那种案例，不是这样的呃，9x12跳槽24x14上海，所以像你这种薪资涨起来，那真的是太简单了啊，你而且你学历还够二本，我都准你运气好，送你进大厂了。

都长这点心思跟玩儿似的，你这是来就是了。

北京物理本科毕业，刚毕业，43，年薪31万，30~40个电信计费核心经理，开发技术没有提升，不够系统，中国主要了解呃，你现在要想清楚呢，是你应该是走向技术管理岗，这个不用说。

如果你现在还在跟年轻人拼一线，你也拼不过，你也没前途，所以在这个年龄，你这个年薪相对比较可怜我，我有什么讲什么，所以你下面的冲的东西一定是技术管理岗，听懂了吧，技术管理岗，那么技术管理岗呢。

这里面有两个大的层面了，于是你需要了解，整个比较新鲜的架构的知识，你如果不了解的，话你根本也管理不了，然后第二个呢就是基本的管理的内容，这两块加起来就是技术加管理，就是以前你你不要认为技术管理考试。

技术转管理是技术加管理，这两个层面搞上来，我觉得你是有机会能够翻翻的，到60万年薪是问题不太大，因为你刚刚m ba也有了，你技术上再补上来，等于技术加管理就有了好，这个时候你的空间就打开了。

你其实最最吃亏的是，你43的才拿31万，就是你以前肯定是我不知道你在干嘛，或者没有从来没有抬头看过路，世界已经，在发生变化了，31万的年薪，很多刚毕业的小孩儿就直接到了啊，你赶紧突破吧。

30万年薪1年半，唉这才比较正常嘛，本科估值，因为目前已经在估值，百亿美金左右的独角兽了，明年年初50万，那p6 还没有2年经验，这个问题也不大，你这个问题也不大，第一背景很好，然后第二薪资到位。

你所缺的你所欠缺的无非就是技术了，那不基数这件事交给老师就完了，让你补啥，你补啥就完了，呃，你不到2年稍微吃点亏，最最晚最晚明年90月份，也也就让你进去了啊，你下一步就是这些个超级大厂了嘛。

很简单很简单啊，这个已经看过了，这个真的真的很简单啊，这个都可以给你签对赌协议，你到不了就一分钱不收你的，到了就多付点钱，呃29岁，安徽目标是40万，3万多吧，在上海半年，公司2年打酱油。

也就是3年没有跳过槽是吧，这是你的亮点，恭喜你。

你已经具备了杀进那个，我刚才所列的一线大厂的机会，呃，如果让我挑一个进一进一线大厂的人。

一个人呢是他技术特别好，但是跳槽特频繁，另外一个人呢是呃他的技术呢相对一般，但是35年没跳过槽，我一定挑那个没跳过槽的，那个没跳过槽的人，想送你进大厂，要相对容易得多，补技术相对容易补，你的职业规划。

我告诉你没有几年调不过来，不技术，这个从我们以前的经验角度讲啊。

就基本上就是3~6月左右，像这种是四个月了。

这是学三个月的呃，不需要你把所有东西学完啊，这是学四个月的，哎哟我去11点了，我们还聊吗，明天要不明天聊，跟我说没有聊到的呢，你要愿意也可以跟老师单独交流啊，这关系不大，老师的微信号，嗯，累了。

一老师40多岁的年龄。

讲这么长时间课，实际上是有点累的，老师的微信号就一一。

呃这是第二个微信啊，因为第一个微信已经满了，所以就第一个微信就不再加了啊，嗯有机会加，应该是有点频繁，通过一下，对但是我回聊天回的比较慢啊，那个有啥想聊的，你也不用客气，就直接留言就行，敲文字。

微信的最基本的礼仪，敲文字，你敲文字，我可以说语音，这个都懂吧，微信的最基本的礼仪，不要问老师在吗，这个应该都懂，对不对，我可以在可以不在，这个取决于你到底搁那聊啥，哈哈哈，问什么，有点频繁啊。

明明天加吧，没有关系。

5年15k太可怜了，二本28 30个音弹厂，3月份最迟9月份呃，问问问问题不大小小意思。

但是深圳的大厂啊，没有北京和杭州上海这么多，嗯我希望你能定出一个明确的来啊，就是深圳那边你能接受的大厂有哪些，据我所知呢你应该接受这几个呃，第一个呢就是腾讯，第二个呢是深圳有阿里吗，好像也有吧。

然后呃虾皮lazada啊，这东南亚的这几个电商给的薪资非常的高，好多时候比那个列的这几个，一线大厂给的薪资还高，像目前为止我们进大厂的这些小伙伴啊，薪资拿的最高的，实际上是虾皮和拼多多。

不是你想象中的阿里美团，是虾皮和拼多多，老师有技术，我就不明白。

你直接发这最基本的礼仪，跟这老师我有问题不明白，然后啥也不说，等着我问你是吗，我就不理你，南京35年经验17k还可以呃，专科生的本科不错，专业是汽车不错，专升本项目不大，提升技术涨薪资，现金大涨嗯。

我看见你们想进大厂这几个字，其实有点头疼，你是涨薪资这几个字比较简单呃，作为南京来说，找到你南京的大厂。

主要是南京呢没什么大厂，这是头疼的点，我还是那句话啊，像南京这类城市呢，基本基本上前10%吧，老师能够让你把这些技术全涵盖掉，但是呢你说他没有机会，老师也是真没有办法啊，就没有办法，巧妇难为无米之炊。

南京的话提薪资不是问题，好吧，这是涨4k的，原公司涨了3k啊，坐标南京，北京到南京14k涨到24k，这个还比较牛逼吧，原来在北京拿14，跑南京拿一二十四，年薪30万，哈哈，南京专科生了嗯。

三个月南京18~30，年薪40万还可以吧。

啊，呃南京上海啊，听我说南京上海，然后苏州呃，这几个城市呢，什么样的东西相对于可以拿比较高的薪资，架构师的体系里面一定要加入大数据，对于大数据的处理，这个是你在南京上海苏州拿高薪的。

系列 1：P8：课堂答疑——不同学员的不同路线（2） - 马士兵官方号 - BV1mu411r78p

特殊情况只想在合肥合肥30万年薪有点难呀，大哥正经4年，我只能说让你拿到合肥顶薪，二本本科现在已经18k了，我只能说老师能想办法帮助你的合肥拿到顶薪，但是合肥顶薪是多少，这件事就不好说了，29岁在合肥。

你应该不下面这几个技术点呃，面试常问的这个啥也不，啥也别说这必须的，必须得得得掌握的大概有十项左右，然后呢合肥这边呃，你要稍微领先一点，基于云原生的分布式微服务，听懂了吧。

因为我知道那个呃合肥应该是有大数据中心吧，也是云的一个基地，这块的机会应该就会你只要把这块搞定了之后呃，应该你会机会多好多好多，怎么说呢，就是前沿技术吧，跟上前沿的技术，跟上流行的技术。

行了通过差不多了啊，嗯嗯。

25岁的男生，大专生10k武汉这个挺典型的呃，3年提高薪资，提薪的话呢比较简单啊，嗯像你这种的保守说最保守最保守的，明年34月份16k以上，不知道能不能接受啊，嗯我看啊技术水平有限，前沿技术了解不多。

被框在了max行业m e s什么什么行业成熟框架哦，我知道了3年以来就是没提成的，偏业务，针对mx听我说啊，呃首先我给你做一个短期规划，呃，短期来说就是提技术，就你只要提技术就提薪了，这个肯定可以。

完全没问题，那提技术主要提哪些个呢，你自己呢也说得非，常的明确了第一个叫做流行的东西，你现在不太了解，spring cloud这条线，spring cloud这条线到网约车项目。

这个就是从传统的c r u d转向互联网的关键的点，这个好多人已经证明了的，然后第二个你用的全是成熟框架，你从来没了解过框架的底层，所以第二个读框架的源码，第三个从长远来看提学历，您把这学历给我提上来。

第四个从长远来看，对你将来的职业发展巨大的好处，然后至于架构的话，慢慢聊不着急，所以很简单很，简单你就可以把薪水提上来啊，猪小屁。

呃你要看书的话，我是真心推荐你看咱们左老师的课程，他讲的可比书讲的好听多了，你自己啃啃算法你就知道了啊，如果说你非要看书啊，第一本书叫java数据结构与算法，这本书相对比较入门级相对浅一些。

但这本书已经停，已经那个呃停板了，所以你可以找到电子书，java数据结构与算法啊，我不写了，这个第二本书就不推荐了，因为第二第二本书太难了，算法导论那本书太难了啊，对于很多专业搞算法的比较难。

所以就放过他，嗯你把这本书搞定呢，像国内的这些个普通的厂子，这个携程了什么马蜂窝了，五八了这一类的搞定没问题啊。

7年都25k成本31 4年想换工作，有什么好的建议，慎重建议很多，首先第一个不许轻易跳，你这一跳呢应该是非常关键的一跳，因为你已经在这个公司4年了，在这公司4年就意味着你对这个公司很坚定的忠贞。

就这个不不频繁跳槽，就算你学历稍微差一些，也会有进大厂的机会，所以你这一跳一定一定要跳好，做好准备，骑驴找马，找到马之后再跳，不要轻易跳，千万不要说别人给你个什么30 35你就跳了，那你就亏死了。

这一跳目标40k以上，补40k以上应该具备的技术，然后目标就是40k以上，概率很高，上次有同学跳槽，原来拿12k，别人给了15k就跳了，我也是快疯了，我基本上直接建议涨幅不超过50%的就不要跳了。

意义不大，对你职业生涯是个伤害。

java数据结构与算法是不是数据结构与算法分析，java描述不是就是java数据结构与算法就叫这名。

但是那本书比较老，但是它比较浅显容易懂呃，只有只有电子版的，你搜一下应该能找着啊，这个意思，网校202 17k税后15，只是会用底层，那就补底层，这个没什么可说的，哎哟这么正式工冷眼相看，哈哈大哥。

你这个别太脆弱。

然后呢也不要太敏感，别人看你的这种眼眼神也好。

你不要太往心里去，首先建立起来强大的心理，我已经说过这个问题了，不要那个什么，再一个呢，我认为啊你作为这个学历来说，17k的话也还凑合，也还可以，所以你下一步的该怎么办呢。

呃我斗胆在你不了解你特别细节的情况下稍作规划好不好。

你认真听啊。

我建，议你的是呃，第一个你拿下这个本科了，为什么每次都会把这个给弄出来，好第一个呢你已经拿下这个本科了，这说明你有本有本科学历了，这是你的第一步，这件事情很容易达到不难，至少涨到25k，这是至少的啊。

呃但这个事情也不难，就是这一步呢本身不是特别难补对应的技术，然后修改好简历，老师帮你做，做好准备，这不是很容易达到的呃，但是比较难达到的是，下一步就是你让自己尽量拿一个高薪水，25k是，起步价啊。

28k30 ，这是你的目标价，然后呢，在你下一步里边儿一定要待一段足够长的时间啊，大概要2~3年左右，认认真真地让自己的技术变得硬硬气起来，绝对不能够比那个本科生差，而且还要比本科生更强。

好在这种前提之下，你大概在29岁30左右的时候进到大厂呃，我跟大家说，我们陈老师进进到阿里的时候，大概是28岁，29岁来着，就是在这个年龄进去的呃，时间稍微长一点，你想直接进这件事情，概率比。

较低不是很容易，薪资还不算太高的情况下，应该有机会进到京东的那个那个本本部的吧。

就看你能不能表现了吗，你技术表现的比较牛逼，然后呃为人处事嗯又又会来事儿啊，这个晋升嘛就相对来说容易很多，其实我说到这儿啊，各位想做晋升的小伙伴呃，嗯同学们一定不要放弃对于非技术的非技术的这个追求啊。

什么意思呢，就是有好多人我们俗称叫会来事儿好，那这个时候呢他所他所面临的机会要比你这种不会来事儿的，到处都，是棱角的，升了吧唧的，这样的人，他的机会要多得多，这点大家大家同意吗，同意同学给老师扣个一。

还还有吗，还活着呢吗，没问题吧，你们想老师推荐你们几本那个教大家怎么为人处事的书，比较初级的那种好不好，第一呃，叫我不是教你炸，就是不要把自己看得特别低，也不要把自己看得特别高，不要把别人砍成敌人。

但是也不要把它当成那种完完全全的掏心窝子的嗯，所有人都可以掏心窝子的那种啊，那种傻傻的空也不行，但它是一种感觉，最关键的要去实践，你要认识到和别人打交道这件事情和技术同等重要，当你认识到这一点的时候。

你的晋升之路就打开了，说这个说的有点那什么了啊，嗯，对这个会来事儿怎么定义呢，这个确实不太好定义，你也不要刻意的去追求，说那个我就得让所有人都喜欢，我也不是这样的，他有些这方面也是有天赋的。

有些人是有这方面天赋的啊，有些人呢他天生就不太适合去搞和人际关系相关的工作，但是我认为呢你至少应该和人能够和谐相处，所谓的会来事儿，在私企里面就是我能够专注自己，做好自己的事情。

同时不跟其他不给其他人带来呃负面的这种这种这种印象好吧，积极合作不带来负面印象嗯，普通985在读非计算机专业，想转码可能性大吗，呃你需要我预计啊，你如果想转一份普通的工作，就是只是想在计算机系。

计算机这个行业里面转过来之后，拿一个普通的工作半年足矣，老师一定能让你转过来呃但是呢你如果想起点要比较高，你要给老师1年的时间，这个才才够听懂了吧，首先要补计算机的基础。

然后还要补相关的呃各种的项目点啊，然后再做好简历，这样才可以。

珠海西山马尔开二一届转闸了，目前薪资6k一点2万，广州呃小case啊，如果这个这个到不了，老师也是可以退钱的，呃你这个比较简单，而且也比较到位，你赶紧转c sharp这玩意儿没前途的。

为什么说他没前途，我不知道大家了不了解，我说了，c shop这玩意儿没前途，原因是什么呃。

c s p现在能干的工作，我给大家分析一下，第一个呢是做点net，点net本身是工作在微软平台，微软平台目前在服务器领域1%都不到，很小众，c shop能干什么，c shop能干游戏的脚本语言。

比如说你做unity 3 d的，你做，cocs的，你可以考虑用c sharp做脚本，但是你说做游戏做脚本的，你能拿多少钱，很低好，这是第二个，第三个，c上牌能干嘛，工控的上位机，公共的上位机。

但这个领域想拿很好的薪资，也很也很少换，所以我跟你说。

转过来是美是是是正正确的啊，而且必须赶紧转，你还年轻啊，你要是年龄大的，搞cp的，想转的话都费劲了。

12000，在广州的话问题不太大啊，c sharp攻控上位机，对公共客户端没错，合肥九八。

我说非科班，2022，春招再战转账，阿里别的部门和老师这么建议，诶，你这个有点意思啊哈哈那个。

呃你这属于呃别人使劲儿进不去是吧。

你这在这凡尔凡尔赛啊，觉得薪资还稍微低一点，呃其实作为2022届的应届生，明年才毕业，然后今年就已经拿到24，在合肥大哥，我认为可以了哈哈。

呃你是想秀一秀。

是不是哈哈听我说啊，如果你想寻求更好的薪资，寻求大厂里面的ssp，首先第一点呢你已经转正了，你如果再跳到别的地方就叫跳槽。

当然你想在内部阿里就想转岗，我个人认为你别动了。

因为什么呢，你就给人一种特别不踏实的感觉，娘的我，我这个部门刚收，把你收进来，然后呢还屁股还没捂热呢，你现在就想走，你别这样呃，同时呢我也告诉你薪资这件事情，你的第一份薪资绝对不是你致富的根本。

我再说一遍，无论你毕业拿多少薪资，你毕业就算拿5万，这个你这辈子也不可不可能靠你第一份薪资来支付，能听进去吗，呃我我跟你说，他也是24岁毕的业，也是念完的呃，他是念完的本科啊，也是念他念完的本科。

你说他第一份薪资有多高，估计也就跟你差不了太多，但是不阻挡他几年之后拿到上百万，这样的年薪不足，等他几年之后在一个不错的企业里头拿到这种股票的期权，所以不要太看重这一点。

不要太看重这种这么短期的几千块钱的涨幅啊，给你涨到3万，你又能多多少钱，你应该真正看重的是你这种感觉是你给人家扎扎实实的，感觉你不知道我给你看的那个简历的那个那个小伙有多扎实。

他给人的感觉就是踏实交给他，你就特别放心，你给别人这种感觉的时候，但是你给别人很机灵，很精明啊，一有好的机会我就要跳这样的感觉，你就错失了更大的人生机会。

所以我建议你别动了好不好，不知道这种年轻人能不能听得进去。

这个其实这种话吧，有时候我想我要是这么年轻，我可能连听都听听，听不太进去，你们能听进去吗，能听进去的，扣波一我也没白说。

滚雪球我能听进去，滚雪球你多大了就好多小年轻是听不进去的，知道吧，男的本科武汉5年13拿高薪，你这个简单啊，那个在武汉来说非常保守的，明年34月份拿到18吧，好不好，这就是特别保守的了。

就是可以达不到给你退钱的那种保守了好不好，嗯就是你的不成体系嘛，呃跟老师这是最容易的，就是行政体系知识体系。

这也是我们教课的一个目标啊，只要你形成体系，剩下的细节不就是钻的事儿吗，是因为他先形成了体系，为什么有人效率低。

哎呀不聊了。

太累了，明天再聊吧，明年双11，那老师也是要参加活动的，没料到的可以明天聊好不好，当然想跟细节都聊的话呢，报个名改变你的这辈子的机会啊，就在老师这儿，薪资13目标薪资20java嗯，南京4。

5成本高新视频资料容易忘嗯。

这不难啊，但是你能不能到20，把握性不太高，18如果你要接受18，这个把握基本上90%以上，因为你南京的话，上二师好像是个坎儿，我要没记错的话，18的话，那就基本给你补补技术，你就到了都不用太费劲。

好了，同学们咱们就到这里吧，好不好，今儿聊得也够多了，也够累了，有同学教我啊，嗯咱们see you tomorrow，咱们直播间的话每天都有直播，明天的双11的活动，我也在直播间嗯，但是还是那句话啊。

今天晚上的11个名额嗯，直接参与我们双11的活动，另外呢双11的抽奖，双11过后呢，像这种一块钱1年的这种这种活动，我们就不打算再提供了，好吧嗯，请大家抓住1年之中最好的活动的机会。

而且这个活动保价一整年，放心啊，在你今年双11到明年双11之前，你觉得你买贵了贵多少，十倍赔付，参与抽奖啊，南京去年毕业14000还可以吧，可，以我觉得可以，刚刚毕业14000吗，14k没问题。

然后听累了对啊，我说的也都已经很累了，听都听累了，说的就更累了，明天见，see you tomorrow。

拜拜拜拜，这个我建议你听听曹老师的建议，因为他本身是在大厂工作过好长时间呢，嗯你这个的话呢其实短板就在学历上，关于这个学历怎么样杀进大厂，我在直播间讲的非常清楚，呃恐怕呢，你现在还相当于小白。

这个目标的话，我个人认为啊，你定的呢实际上是有挑战，这个难度是相对来说有挑战的，那么前3年的道路，我在直播间已经讲得非常清楚了，那个尽量优先找一份薪资更好的一份薪水，这是第一步，然后呢待1年左右。

第二步呢提到我们进大厂之前的一个薪资，这个时候呢需要你可能要待个22~3年，这个阶段比较难熬，它是需要你长时间的一个毅力，然后进大厂的概率就高很多了呃，杀进大厂之后是另外的规划呃。

那个的时候你的这个目标，百万年薪的目标，才能够开展，所以一步一步来，先不要考虑那么远，你的详细简历，哪个学校的什么背景，s sm框架肯定是不够的。

大连腾讯子公司世纪鲲鹏，这算大厂吗，我觉得在大连可能可以算啊，大厂嘛就是薪资比较高嘛。

得给到很好的薪资才算大厂啊。

系列 1：P9：职业迷茫：年龄大、技术差、管理不行怎么办？ - 马士兵官方号 - BV1mu411r78p

权威解读啊，因为我们刚刚跟华为达成了协议。合作协议啊，给他内推。来。

老有同学说我现在年龄大了。今天聊一个大的话题，就聊最后一个吧，就是你年龄大的。我跟你说，年龄还大，技术还差，管理也不行。空间已经被挤的非常的小了，我该怎么办？哎。

同学们有没有这其中有一个或者多个问题的老师扣个一，好吧。😊，嗯。So。嗯。年龄到有多大？你们。来来来，各位各位认为自己年龄大的敲出来，我看你们有多大年龄，3033、34、22、22，你搁那扯淡呢。

46嗯29。😊，2825。4934、43。OK好好好，呃，同学们那个36岁以下的啊，你就别跟我这聊，年龄大了，好不好？那个年龄还很年轻很年轻很年轻啊。😊。

呃，我们长远别别的我就不跟你说什么褚实践啊，不跟你说什么呃邓我们*也也79岁才主政中国，对吧？然后就不跟你说，任正非40多岁才创立华为，还差点破产，对不对？那个那个那个马云CS才30多岁。

就是你正当年是正当年的时候，麻烦你不要放弃啊。有好多人说我35了，我以后怎么办，感觉就要死了似的，以后就得去开滴滴开饭馆了。大哥远远不是这么回事。😊。

呃。呃，课程底下面有两位老师啊，我推荐你们去听一听，听听一听，跟跟他们跟他们交流交流。😊。

呃，首先第一个是讲这个课，就是大型团队管理的琵琶课。他本身就是P8。然后呢，那个现在是3十八九岁了，应该快接接近40。好吧，现在依然是在那个团队里头担任很核心的角色，然后年薪依然是那牛牛逼的很啊。

这就不不跟你说了。然后这哥们是已经40多岁了。OKP9P9的老师已经40多了啊。😊。

呃，目前呢在那个也是一家大厂，我就不说他的那个那个那个背景了啊，就是离开阿里之前P9，然后到新的大厂之后，担任更加牛逼的角色，还是这句话。就是我最最开始就跟大家说过一句。

年龄大这件事情一定如果你现在有危机，一定是你原来规划的不够，学习的不够，提升的不够，这点大家能认可吗？如果你学习够了，提升够了，你现在具备了你这个年龄的人应该具备的水平，你怎么会没有空间。

他一定是有空间才对。当然有同学说，老师，我已经这样了，我下面该怎么办？首先调思想。你还要一定告诉自己，我还有的是空间。哪怕就是这对你来说，这个鸡汤它也是一种正面激励。嗯，我再加一个年龄又大，基础还差。

管理也不行，空间还小，还是女生有没有？感觉没有年轻人的活力了。还是女生。对。

看你个小案例看你个小案例啊。我找找找几个女生的案例。女生进入美团。拼多多。京东。这是35岁的40万年薪也干到了70万。还可以吧。

其实35岁呢很年轻很年轻的啊啊，这个这个超级印象深刻啊这个。😊，这个是38岁的这个这位这位这位姑娘，我们是印象超级深刻，因为是给她费了太大的劲儿了啊，才把她给带出来。但是她带出来，她现在很牛逼的。

她不仅跳了第一次槽，现在又跳第二次槽，然后还嘲笑当时他们项目组的人特别弱，你明白吗？😊，呃。这是他当时的肺腑之言，我当时那个还还还挺感动的，非常感动啊，说说这句话，就是老师的成就感就在于这。

特别想择公开课的时候，多影响一些人职业生涯中尽快走出迷茫。但是人家会以为我是托儿啊，暂时只能忍着。😊。

如果你觉得你的比他还差，那我就也就没什么太大脾气了啊那个。怎么说。这个是39岁的大龄的成员。呃，我首先给大家一点啊，给大家做一个就是大龄的小伙伴们，给大家做一个做一个呃这个这个这个小小的建议。

你们一定要听进去啊。嗯，大龄大龄的女程序员。嗯，记得应该有一个。这是大龄成员34到50的。嗯，因有1个40多岁的啊，大龄的大专生，大龄的跨行成序员。疫情的嗯。有1个40多的，点忘了是四十几来着。43。

这3万。还有一个40。四十几岁的来着。

啊，这个这个。呃，这个姐姐是44岁。女成员，然后收到外企的offer。

那个。这这是他他搞定工作之后呢，也是肺腑之言啊，我希望给大家敲响一个警钟。你可以不跟老师学没有关系，但是麻烦你保持进步好不好？这次找工作时间提醒提了醒，不会再温水煮青蛙了。

呃，他的这个。怎么说呢？

他最后啊实际上还长了星了，我不知道大家看看出来没有？鼓励一下那些大龄成员，我43岁女生薪水跟大厂不能比，生活工作更拿了外企的研发，薪水差不多，选了这个OK。

我问他就是那个薪资达到了预期没有是吧，我说达到预期了。怎么说呢？你相信我一点，就是当你开始正视自己心态放正。然后呢，放积极了之后，开始改变自己之后，你一定会有收获，这个收获可能会大可能会小。

可能你自己没有长，甚至没有长心，但是呢你是不是心态上已经放好了，人是一个很好的心态的，人这一一辈子就这么几十年的，你保持一个很好的心态，也是一很好的一种收获的。但是你只要心态好了，好多事情就会变好。

你不信你试试看。那个。嗯。作为大连的小伙伴，我给大家一个建议。😊，我我不希望大家伙。呃，年龄很大的同学，三十八九岁。找到我说老师，你能不能给我找条路线，让我进大厂。大哥，这是这这是这是非常难的。

老师目前规划了好多好多人进到大厂。这个确实是。啊，我们我我们就从这里面搜大厂的名字，你就你就能找得到啊。就比如说你就搜。阿里。嗯。这俩是55353个呃，阿阿里的就是我们公布出来的啊，搜字杰这个叫12个。

然后搜那个那个呃呃美团。这是36个啊，搜。京东啊43个就是说其实呃进到大厂这件事情，在一个合适的年龄，合适的背景的情况下，老师帮你稍做规划，稍做指点你就进了。但是呢有的人是强人所难。

他非得说我学历又不怎么样，然后技术积累还不行，现在年龄还大，三十八九岁四十多了。老师，你能不能帮我送进大厂？如果你送进大厂，哎，我就报我就报名学习。你别跟我这扯这淡，你爱报不报？你行就行不行就不行。

你不行，你报了也不行。你行的话呢，老师判断你行，他他就。概率就高的很，就一定能行。呃，同学们听我说那个理智一点啊，如果你提出这样的要求来，说明你没活明白，三十八九岁了还没活明白，你这是人生的失败。

这时候你应该对自己的最理智的说法是一个什么样子的，认真听，应该是建立在题心上。提高收入上。这是最简单的提升你生活质量的办法，就是提收入。当然还有一种呢就是你追求你下一步的呃更好的职业的规划。

比如说我想进外企，我想进到甲方企业，我想进到那个非IT类的这一类的企业里头去，然后考虑我后面养老的事情了，这个也很也很务实，也很科学。也也相对靠谱一些是吧？提收入这件事情，老师有的是办法啊，你年龄多大。

老师也能够找出办法来，能让你把收入提上来，这是比较简单的，不难。可以这么说。报名马士兵教育的还没有说薪资涨不了的。就是多少的事儿，少的也是5000以上啊，低于500的就太少了。时间维度3到6个月左右。

还可以吧。打个牛逼出来好吗？😡，没有一个啊没有一个到不了说说完完不成这个任务的。嗯。那个。怎么说呢？就是你你把你的当你把定位定位在题心上的时候，呃，老师办法和手段就多了去了，好吧。哪怕就是让你搞点副业。

你也能把心字提上来啊。当然前提是你要保持正向的进步的积极的心态，这样才可以。嗯，做出改变。有一些那个年龄比较大的小伙伴啊。每个人的情况跟每个人的情况不一样，所以年龄比较大的时候。

我就没有办法找到那种普世性的东西了。就是没有办法说，我给你一个像那个呃那个那个计计算机系的这种这种学生啊，这个呃本科的这种二本的、三本、二本的、一本的这种的进大厂的路。

我们是没有办法找到找到这么一条普适性的路的这只能是每个人的问题，每个人分析。啊。对，当然这这个就比较麻烦了，麻烦一点，好吧。进大厂不也是为了钱吗？我觉得你这个人生的格调，麻烦你稍微往上提一提。

不然你这辈子会活得很痛苦。钱是赚不完的，也是赚不够的。有多少钱你永远也是够不了的。如果只是钉在钱上，那我觉得这就是你将来痛苦的根源。呃，让你这一生活的充实一些。格调高一些，你会发现钱是自然而然就来了。

好不好？把你的目标稍微定的高一点点啊，信大厂的目标是什么呢？实际上是为了你更好的一个职业规划职业的学历。啊，就是职业的职业的一个经历。你的你从大厂出来之后，有好多中小厂抢着要。给好多钱也也要明白吗？呃。

给大家看一个内推的111个1个1个小案例。内推呢我一般都不怎么给大家展示，主要什么呢？呃内推这件事情并不能够让大家伙儿说我降低学习难度。注意这是两回事儿。呃，这是自自杰找我们做内推啊。

最近找我们做内推的其实已经非常多，就全国的一线大厂，呃，我们都有都有渠道内推。这个不是说那种吹牛逼的啊，就老师这儿不跟你们。

吹这种不靠谱的牛逼。这是我们大概3月份那会疫情还没有这么严重的时候。

我们跟那个呃微软AMD和京东联合举办了大学生的编程大赛。然后呢，这个呢是我们在给京东做培训。呃，这是呃编程大赛的现场。然后。在3月份的时候，我们和小米和百度还有京东吧，京东当时没有没有没有来人。

因为他们疫情不允许出来。当时就在我们的现场啊，我们自己公司的内部现场做的招聘会。呃，有的人呢应该是参加过啊。就是内推的渠道呢，老师这有一大堆一大堆一大堆的。就是你想进哪个大厂，只要你水平够。

我判断你水平够。这个内推的渠道非常的通畅，但是前提是你的水平要高，能听懂吗？所以内推呢我一般不太。使着劲儿的说我们有内推，我们有内推之类的，我不一般不我一般不会说这个。那个怎么说呢？

他不会降低你的学习难度，你也不要指望着说你学习的程度不够，老师能把你推进去，这不可能的。一定是建立在你硬技能过硬的基础之上啊，我刚才说的是什么呢？我刚才说的是当你有了大厂的背景之后。

像这一类的非IT类的大厂，那给的年薪是相当可观。罗湖地产年薪150万以上。team leader的年薪120万。你说他是IT类的吗？他也不是他工作会很累吗？也不会很累。但是你你要是有大厂的背景。

我是美团出来的，我是阿里出来的。我是和他这个比较相关的。比方说ERP拥有出来的OK这特定相关了，就属于。OK我是平安出来。好，你就有机会能够到这种企业里头拿很好的年薪了。

这是年龄大一些的人的另外一条比较不错的路线。不知道大家听进去没有，作为咱们年龄大的小伙伴啊。我就在直接上直接上班。嗯，那咱们离得很近啊。我在进门桥。你如果是在防洪中心这边。

那我们直线距离就两两三百米哈哈嗯。老师，联想可以算镀金吗？我个人认为不算啊，联想。I I don't think联想是一个镀金。我在学院路这边那离得很近啊，可以过来呃坐坐。聊个天喝个茶。

子杰最近离职了不少。呃，我们陈老师跟字杰的人大概住一个楼，住的比较多。嗯。TME算吗？TME是谁啊？银行算吗？嗯，银行的用的技术其实真的一般般，所以不能算。科技公司参观吗？可以啊，我们搞线下活动啊。

因为近期的也在规划线下活动，只要疫情过去。呃，我们会找一些咱们大厂里头的高P啊，P8P9P7这些人来跟大家做见面会啊，你就会知道呢深入的了解就是他们的职业发展到底什么样子的。

并不是所有人的学历都特别好啊，呃，我给大家讲那个架构设计的老师，曹老师吧，他就是二本的学生。呃，黄老师二十四五岁，今年是25岁了。黄老师25岁。呃，离开美团的时候，85万年薪。牛没有逼？

这就是技术牛的人啊，他的一个他的一个。可以达到的宽度，好吧。甜M蜜啊腾讯音乐酷狗K歌。哦。这不就腾讯吗？腾讯当然是大厂了啊。25岁对，25岁。想看看他的简历吗？他当时到阿里的时候是24岁嗯。

大概是60万年薪，那会呢嗯。嗯，打开来看看好吧。😊，呃，我我我隐蔽了一些他的那个隐私啊。当然他这个是属于纯硬核，非常硬核。OK非常硬水。超级硬啊。这个全是基本全是精通。嗯。怎么说呢？他在大学四年。

没谈恋没谈恋爱。没有出去玩，不打游戏。就学习了。听懂了吧？所以他付出努力了，当然就会有收获啊。他二十四五岁的时候，比我二十四五岁的时候，那就那那牛牛逼多了OK。哎，怎么说呢？就一分耕耘，一分收获。呃。

老师能向你提供的，就是让你少走弯路。讲到这儿呢，其实我们的课呢，其实我介绍也差不多了。我就不专门做什么特殊的广告了。

呃，简单说，你想提新的，你想进大厂的老师早就帮你想的方方面面都已经非常透彻了，你也逃不出那1000多人的案例里头去的，你也没那么特殊。想多涨点薪水的。今晚你就扎实来来找老师就完了，好吧。呃。

几句话介绍晚上的活动。然后有一些需要跟老师交流的，咱们就瞎聊瞎聊会天，好不好？简单几句话接说完。

系列 2：P1：马士兵老师JVM调优：1.什么是垃圾？ - Java视频学堂 - BV1Hy4y1t7Bo

就是我们不是聊人生怎么聊技术的，就是我们聊jvm呃，为避免有些同学对gm一丁丁丁点都不了解，所以呢我还是首先得稍微大家讲点基础的知识啊，当然我基础知识会讲的比较快，如果你听着比较费劲的话。

那你可以撤两分钱，你你就你可以去找腾讯退掉吗，开玩笑开玩笑嗯，每个人的因为他技术水平不一样，所以呢我给大家复习一下这些的基础知识，有多少人看过，要求大家看的这这咱们咱们的预习资料了，有没有。

啊有看过是吧，不错啊，有没有没看过的，没看过的，给老师扣二，看了一半儿，好好这样啊，下面这段呢就是也我我最快速的讲解，也没看过人没看过人听嗯，你就算没看过，我觉得至少也应该听说过啊。

dc这件事呢为什么现在变得比较重要，其实呢我觉得你实际当中的多数人是没有过调优经验的，可以这么说，我估计今天听课的这人数里头，十个人里头估计至少有八九个，应该没有过自己亲手在线上调优的经验。

但是呢现在一些大厂呢就玩了命的问，特别讨厌，非常的讨厌，我给你看一眼这个。

这是从2019年咱们面大厂的小伙们呃，我遇到的我摘出来的一部分呃，十秒钟你先读一下，这是大厂们问的一些关于gc的问题，他没聊别的，就聊dc好吧，扩大堆内存，你以为就这么简单吗，啊银行技术岗招聘到位了。

问了是吧，解说只会一个嗯嗯我就不一一念了好吧，你们自己看这里比较难的是哪个呢，其实这个比较难，就阿里问的问题相对都比较难呃，你比方说阿里问的这个是sro有没有内存泄漏的问题，这个呢是一个专题啊。

原来我讲过，你听过的话可能会了解，没有听过的话，应该这个地儿你是答不出来的，slogo里面主要是由，弱指针主要是弱指针的存在啊，才解决了它内存泄漏的问题，不然的话还真有，那么阿里问的这几个问题。

第二个呢是g12 个region不是连续的，而且两个之间可查的引用想回收一个，另一个怎么处理，这里头呢主要考你的是写屏障，jim的对内存的管理啊，对象分配过程，这个过程比较复杂，一会儿如果讲到的话。

我可以给你稍微说一下cm 4并发预处理和并发可中断预处理，这个是cm的非常细节的地方，特别细啊，我第一版的时候甚至没有讲到这呃，c m s呢如果简单讲它有四个阶段，如果复杂点，它有六个阶段。

讲到六个阶段就讲到这些并发预处理，并发可中断预处理，讲到这些了，到底多大对象会被直接扔到老年代，这个呢也是这个这个问题就相对容易一些呃，呃装不下的，那么它有的时候呢是不会触发呃minor gc的。

会直接给你扔到老年代，还有呢直接超过那个一点区的，那二话不说，肯定是跟金融到老年代，还有一种情况，三种情况呃，背就行了，还有一个呢啊，当然这这是真真的是有个有病的企业的，有病的面试官啊。

不知道为什么突然间就问了这么一个问题来说，用一句话证明你的gm是很牛，来来来哎，同学们，用一句话证明你，你的jvm水平很牛，哈哈哈。

你写的你咱吹牛也不能吹没边儿了，好不好，听你说完，我就感觉牛在天上飞啊，后来我后来我教了你同学一句话啊，那个我教他，我说那个呃十种gc的算法全部了解，怎么样可以吧，十种gc算法全部进攻，一句话。

想想啊嗯，jpm呢现在变得越来越重要的一个原因就是因为大厂总是考总是考，总是考，而且越考越细，越考越深，所以如果你的简历上能够把这句话写下来，嗯，写到你的简历上，熟悉jc的常用算法。

熟悉常见的垃圾收集器，具有实际gm调整调优的实战经验，原来你的简历如果值2万，就是超过2万了，之后往两两万以上，25000这个位置走的时候，你需要加很多东西，你从15000~2万啊。

你只要能干活干得比较熟，就到了，从2万~25000，这个我这个5000块钱有好多好多东西你都需要加上啊，包括dc直接就到25000了，好吧，这一句话写上去就可以了。

呃我们有我们原来有一份简历是写了五句话，拿到阿里的好多的面试通知啊，其中有一句话就是这个哈，我看这里啊，不废话，我们先说今呃今天呢如果两个小时不够，我们就多讲点啊，没关系，呃先说今天我主要讲gc啊。

gc gc是什么意思，叫垃圾回收，所以呢我并不是说在这儿给大家呢把jvm的从头到尾的概念，那个太太宽太大了，嗯不是那么讲的，没有意义，我主要讲gc，而gc到底是个什么东东。

jc叫做找到垃圾并且回收回收的意思，让这块内存重新可用好，你说比如说我们占领有个引用object o等于new object，new出来一个object。

这个object里面有个成员变量又指向了另外一个，什么时候这个引用消失了，这块就是垃圾啊，就是garbage，没有引用指向的对象就是垃圾，有过c和c加加代码经验呢。

一说你就了解c和c加加需要手动回收垃圾，c呢要手动分配内存，要手动回收内存，下家呢需要自己new出来，自己在delete掉，java呢没有这个概念，java就直接new就完了，new完了就不管了。

那谁来帮他回收垃圾回收器，咱们讲的就是这个垃圾回收器的过程，好，我这个速度应该没问题吧，来没问题，同学给老师扣一，现在很多新式的语言呢也都在引入自己的垃圾回收器啊，这个，因为c和c加加写指针的时候。

写的会非常非常的烦，呃所以当你不需要自己去手动手工管理内存的时候，你这个代码写起来效率会非常高，不是运行效率高，而是开发效率高，好吧好看，这里，是在这里呢，第一步呢你怎么样。

你你首先得定位这个垃圾怎么样找到一个垃圾，就这个对象到底他算垃圾，什么情况要算垃圾啊，你怎么把它找出来啊，第一种方式呢叫做有两种啊，第一种方式叫reference count，叫引用基数。

这事也很简单啊，你比如说现在有三个引用之前这个对象了，运行的过程中，这个已经没有了，这个已经没有了，这个已经没有了，好这个专门肯定就是垃圾了，从三把这个三变成零的时候，这个就是垃圾。

当然这种方式呢有一个显而易见的缺点，就是如果有三个对象，他们之间互相持有引用，但是又没有另外的引用指向他们任何其中一个a指向b b指向c，c指向a这三个呢叫做一组垃圾，一堆垃圾，一圈垃圾。

一家子全是垃圾，a b c好，那这个怎么办，每个引用的基数都是111，所以呢如果你通过引用计数方式，你是找不着哪些是垃圾的，所以这个在这儿用不了，那怎么办呢。

jdk里面就hot sport里面用的是什么，用这个算法叫root searching，叫跟搜索算法，跟搜索算法是什么概念，跟搜索算法的概念就是哎我们写一个main方法，在方法里面有一些成员变量啊。

sorry，有一些那个局部变量我new出一个对象来，这就是我们的根对象，这个对象呢会产生一些引用，指向新的对象，新的对象也可能会产生一些引用，又指向新的对象，那么在运行的过程之中。

我只要找到main方法，找到这些根对象，顺着这些引用找，要从根儿上开始，顺着着顺藤摸瓜摸摸摸，凡是能摸到的这些全不是垃圾，凡是摸不着的那些全都是垃圾，这个叫做根可达算法，叫root searching。

这概念也很简单，是不是，那当然大厂面试不会给你面试这么简单的，大厂面试都是说哪些是根多讨厌你说他，但这里面牵扯的东西比较多，只要讲得非常透彻的话，得需要把前面的所有的那个预备性的知识全都掌握住才行，呃。

听一个大概就可以了，这段话呢是来源于gbm，就是java java的virtual machine specification，就是java虚拟机的规范里头，他自己说的啊，到底到底哪些是根儿呢。

哪些对象是根呢，有这么几个，第一个呢是jm stack jvm站里面的站里面还存活着的，那肯定就是根native methods stack本地方法栈，如果调用了本地方法的话。

run time constant pool，放在你的运行时常量池里头的，你那个class运行时常量池的那部分的那些个引用指向的东西。

那是根static static reference in method area和class，就是class，这就别说了，你漏的漏的就内存那些class哦，那些是歌steady reference。

静态的那些引用，ok这些都是根，所以当然呃如果这块不熟的话，你就略过它好吧，因为今天的重点呢也不是讲这些东西，我们主要是讲这个jc的一个实战调优，能让你的简历上把我刚才那句话给你写上。

两天能让你的简历粗糙的涨个两三千块钱吧，细细的能能让你涨5000好吧，绝不夸张，以前有学生验证过啊，二人真听嗯，当我们找着这个垃圾之后，我们要对它进行回收，回收的时候有几种方式呢，回收的算法三种背过。

别废话，直接背过就完了好吧，因为为什么大厂直接面认为你这东西就是应该你掌握了，没掌握，你跟大厂无缘，第一个mark sweep，第二个copy，第三个呢叫mark compact，什么意思，一看就明白。

标记清除，给这块标出来，标出来垃圾垃圾垃圾这些全是垃圾，直接把它清掉，清成可用的，就这么简单，这就叫mark sweep，这maswift呢我我我我，我相信多数同学一看就能理解他有些毛病，什么毛病啊。

会产生碎片吗，产生了这些个中间，这个中间也不连着，然后你要分配那个一个大对象的时候，你发现有可能也找不着空间了，所以这就产生碎片，这个意思叫mark sweep，好看这里。

但是mark wift算法比较简单啊，所以呢也并不是说不能用的，这三种算法没有优劣之分，记住这三种算法没有优劣，只有你选择哪种算法，具体的选择看情形好，第二种叫copy，copy很简单，把内存一分为二。

只用一半，你们家俩房子，两个房间，一个房间你在里边玩，你妈妈进来给你回收垃圾的时候，咔叽把房间给你一分为二，你这个死孩子只能在这半边玩，等什么时候玩玩了诶，你跑到这边边玩来玩了，我把这半边一下给清理了。

有用的，凡是你产生的那些有用的，比方说你在那扔线团，把那些线条复制过来就可以了啊，然后这边就可以全部的从头到尾的一下子清掉，这叫copy copy，我想一眼就能看出他的缺点，缺点就是内存浪费了好看。

这里第三种呢叫mark compact，mk compact呢也是相当简单的一个算法，就是我标记完了之后再对它进行一个压缩，这个是这个是什么意思啊，你注意看我们找到这是一个垃圾，但是呢我们我们不管垃圾。

我们干嘛呢，我们其实呢是找这个后面的一些个有用的对象好，这是有用的对象，把这个有用的对象呢直接给这个垃圾覆盖掉，都挪到前面去，反正找到的都往前挪，你知道吧，把这些这有一个空档，哎我也把我把这个挪过来。

把这个挪过来，就是挪来挪去，挪到挪到最后就形成了这样的一种感觉，一边标记清完了之后，还进行了一顺带的顺手进行了一个压缩，这是最好的一种内存状态，这种内存状态特别利于新对象的分配，新对象来了之后。

也只用往往后往后一挪，哎我就产生了产生新对象了，再往回印度a又产生新对象了，这是最好的一种内存状态，当然这个算法一眼看上去也很简单，因为它和标记清除相比，和copy相比，它的效率肯定会偏低，为什么。

因为你得挪对象，你得对对象产生移动，对象产生移动是一个特别复杂的过程，后面讲那种特别复杂的那种dc算法的时候，都是在这块下功夫，啊这是标记清楚啊，三种算法相当简单，我在这里就不跟大家多废话了，可以吧。

能接受同学给老师扣一来，大家先跟我的思路走，你们有一些眼前的问题先扔一边，有的问题你可能听着听着就明白了，所以先扔一遍，好吧好，我们先不讲这个对象的什么产生到消亡这个过程啊，也不讲这个对象的分配过程。

我们先来看什么呢，先来看这个这张图，请把这张图背过，我前面讲的东西都是让你背过的，为什么，因为面试官就直接认为这东西你应该掌握啊，当然这张图呢很多面试官可能也掌握不了，你掌握住啊。

你就可以直接第四面试官了，就前面讲的概念都特别需要特别基本啊，你必须得掌握，那么这张图是整个我们到目前为止，jdk至少到jdk 14为止，从jdk一点零到目前的14为止，所有的垃圾回收就这么多。

垃圾回收器好，垃圾回收器是什么概念，垃圾回收器就是这是房间，你在里边玩，你跟你的朋友在里边玩，扔一些小线团，这些小箭头呢有的人慢慢的中间线断了就变成垃圾了，你自己不回收，谁来回收你的妈妈，你的爷爷。

你的奶奶，你的姥姥和他们来回收，他们来帮你回收这东西，他们就垃圾回收器帮你清理房间的，在c和c加加语言里面，你得自己清理，扔了这个线团什么时候不用了，得自己把它清理掉好，现在不用了。

因为有人帮专门帮你清理，谁来帮你清理他们，他们的名字叫做garbage collectors，扫地机器人，垃圾回收器简称gc啊，gc就是这个概念，当然他有时候也做动词。

简称的时候做动词叫garbage collect，嗯，垃圾回收，垃圾回收呢整个从gdp一点零开始到现在发展了很多很多年，然后也诞生了各种各样的垃圾回收期，它的一个发展的路线是什么路线呢。

请大家记住这个路线，给大家写写两笔笔记。

来你回收机的路线啊，发展路线是沿着什么发展呢，是沿着，随着内存数量内存越来越大，越大的过程啊和演进，好在这呢我先给大家做一个总纲性的胶带，我们说学任何东西都是要按照先脉络后细节来学，一定记得这一点。

小伙伴们，就学任何东西一定是先脉络后细节，当我们要学习整个的这种gc的时候，这个gc是一个特别复杂，而且充满了各种各样犄角旮旯的面试题。

这么一个知识体系，那么这时候怎么办，我们要来一个总纲，这个图就是我们的总纲，关于这个图呢，我会先进行大面上的一些个讲解，然后呢有一些细节我们再慢慢渗透进去，好嗯能接受这么学的，来给老师扣个一啊。

一定要这么学啊，这个学法才是最正确的学分，你千万不要说学东西呢，你自己先弄一个细节，先使劲抠进去那种那种学法学起来特别累，而且还不容易学明白，就相当于你去看庐山，然后直接到庐山脚下的某一棵树。

就开始研究蚂蚁窝了，你是在玩什么，你肯定得先乘坐飞机观，看清楚整个庐山大的脉络啊，你要有这个胸怀明白吗，就学技术也要有一定的胸怀啊，嗯，随着内存越来越大，另外呢它呢还有这样一个背景，就是从。

这种说法都没了，从，从什么呢，从分带算法演化到部分代表，终于从分类算法演化到了部分类算法呃。

这些个，那么这些个垃圾回收呢，我一一的先给大家交代一遍啊，你认真听呃，从jdk一点零开始啊，先诞生了，是serial的垃圾回收好，那会的垃圾回收呢都是分带的，分带是什么意思呢，就是分为年轻代和老年代好。

我们先说基本概念啊，看，一会儿我再给你记笔记，笔记明天会发给大家的，不要着急，因为我每每讲一次，我都会往笔记里多记一些东西，所以你们明天拿最新版本就可以了啊，好在这里，我们先来聊这个分带的概念。

就是目前到目前为止，jk呢就是hobd，说的是hobd，因为gd k有好多种，我们主要说的是hobhouse，到现在为止它一共有十种垃圾回收器，这个图请大家记住前面的这六种叫做分带好。

第一叫做概念上分带物理上不分概念，分带物理部分带这么来理解，那么z d c和shen door全都不分带，abcellent是另外一种比较特殊的垃圾回收，一会讲给你听，这个和其他案子都不搭界。

因为他什么事都不干，就他不干，他垃圾回收的活，没有人帮你清理房间，这哥们就来不及了啊，啥都不干活的人嗯，空气，首先呢我们先了解这个分带的概念，在jk诞生的早期，要分配一块内存的时候。

会把整个的我们java的堆空间分成两个不同的年代，这两个不同年代呢可能应该也听说过啊，分成叫新生代，叫老年代这么一个概念，新生代是干什么使的呢，新生代你看吧，刚刚new出来的对象，然后都放在新生代里。

然后经过了好多好多垃圾回收，垃圾好多好多次的扫房间，好多好多次垃圾回收之后的那些特别顽固的对象，放到老年代，他有些别的称呼，比方说老年代也叫tenure，就是尼尔是终身的意思啊。

老外的那种taire processor叫终身制的教授啊，就是这个意思，终身反正就是比较老的老家伙，所以一个叫新生代，一个叫老年代，那么为什么这么分，是因为呢在不同的年代里，可以采取不同的算法。

对垃圾回收采用不同的算法，这样效率是最高的，对于年轻的采取copy算法复制，对于老年代采用mark compact或者mark sweep，这两个都有，很多那种y就是那种原理上的东西，我们暂时先不探讨。

你先了解什么意思啊，这个老年这个年轻代啊，呃为什么要用copy呢，是因为呢对于程序的一个总结，总结出来的，大多数的百分之八九十的对象叫做招生熄灭，招生熄灭什么意思呢，就是这寿命都不太长。

一个for循环里面溜了1万个对象，除了这for循环，他马上就死了，因为他马上就成为垃圾了，那么像这样的东西，你想想看啊，在这里分分配了，在年轻代里头分配了一堆一堆一堆一堆一堆的对象啊。

而且呢一次垃圾回收之后会回收其中的好多好多个好，在这种情况下，那么最有效率的算法是什么样子的呢，最有效率算法其实是这样子的，看这里年龄段又分成三块，第一块呢叫一点区域，1。1甸园，人类诞生的地方。

所以这是我们新对象诞生的地方。

系列 2：P10：马士兵老师JVM调优：10.定位JVM问题的实用参数设置 - Java视频学堂 - BV1Hy4y1t7Bo

题不会答的时候就反问他，你这啥意思，我怎么听不懂你问的问题，你能不能再重复一下等等，你是问这方面问题吗，有些那种特别惊艳，特别不丰富的，他就他他他就连不会交流啊，连访问都不敢问，听不懂都不敢问。

别这样就是说一定反问的，问他什么呢，您指的是哪种垃圾回收器好，对于整个这个房间的管理，取决于垃圾回收器是谁，如果是你妈妈，她可能对他进行了分带，如果是你爸爸，ok他也有可能是进行了分区，完全都不一样的。

到目前为止，从jdk的一点，到目前为止gdp 14四一共诞生了十种垃圾回收器，各位小伙伴们，这十种垃圾回收器啥都别说，先把他背过再说，跟面试官先给他砍晕了，刚才有第最后一个问题，不是问吗。

说用一句话证明你的jvm水平特别牛，超级简单，你就告诉他十种垃圾回收机的算法，我都精通，go语言算是第11种，也我也明白rust的语言没有gc，我能告诉你他为什么关于gc这件事，不管你是python。

不管你是quin，不管你是scala，不管你是java，不管你是go，不管你是rust，随便说，你说我这个m水平牛不牛，这些我都知道，对今天我一堂课让你全知道，来看这里，你就等着听就行了。

我还是那句话啊，你就当傻瓜的时候，带着人来轻轻松松听好，大家看这里，作为我们先讲jvm里面这十种，这十种来自回收器呢，你就记住就行了，前面这六种用于分带模型，我一会儿告诉你什么叫分带，就是内存的区域啊。

你们家空间分两大块，一块两块两大块分带模型，这种叫后面这三种用于分区模型，分区模型就是分成一小块一小块一小块一小块的，这叫分区模型，那这种叫做一般用于debug，当然它有背后深刻的设计思想。

我们不去管它，因为这东西叫做没用，absent叫没用，他没做任何事的垃圾回收器是个摆设，一般做debug的时候用到它，就是我这个垃圾到底是怎么分配的，我先不回收它，别着急，我先用abcent。

我不回收它，我跟踪我垃圾的分配过程，这是一种，还有一种就是确认在我整个垃圾回收没有整个内存没有用完之前，我我我我整个程序肯定会退出，我不用垃圾回收器接入这种的，可以用excellent。

因此我们先排除他，这种非常简单，就是他是个摆设，啥都不干，在这里，前面六种，前面六种是哪六种呢，这六种是大多数人做gm调优的时候需要你掌握的，这六种呢适用于分带模型。

分带模型的就是把你的内存分成两个具体的区域，我会讲，你听后面讲分区，今天看时间，如果时间够的话，我可以告诉你们他的算法到底是什么样的，为什么他比分带的算法呢稍微有那么一点点，我们先来讲分带这个概念。

什么叫分带好吧，大家还能跟上吗，能跟上给老师扣个一，我略过了很多细节，但是还是那句话啊，记住先学脉络，好分带模型是把整个的内存区域分成两个大的年代，这两个大年代分别称之为新生代以及老年代。

这平时你们应该也见多了，新生代就是刚刚new出来的对象，老年代就是经过了好多次垃圾回收之后，老是回收不掉，那些老家伙老顽固，什么意思，妈妈进来一次，这个线头没有被收走，长一岁，妈妈又进来一次。

这个线头依然没有被收走，又长一岁，好当长到一定的年龄之后，够年龄了，进入老年代，所以老年老年代里面装的东西可以认为是垃圾回收，不容易回收掉的，而年轻的里面装的东西可以认为是大多数的时候。

一变垃圾就能把它回收掉的，这种的居多，正是由于这样的特点，所以决定了不同的年代里头，他用的不同的算法，好听我说在年轻代里头用的是什么算法呢，这种算法叫拷贝，拷贝算法效率是极高的，非常高。

而在老年代里头用的是mark compact或者是mark sweep，嗯我们先说年轻代，年轻代为什么要用拷贝算法，这里的年轻代呢，拷贝算法它是这么拷贝的，我们我们我们前面讲拷贝的时候。

不是说把这个内存一分为二，只用这一半儿，这边儿呃，用用完了之后需要回收的时候，把这半有用的框机拷到另外一半不，他不是这么干的，因为在整个的工业实践之中，ibm原来做过统计。

一般来讲一次垃圾回收会回收掉我们整个大多数对象的90%，接近90%到95%，你分配了100个对象，一次垃圾回收，你妈妈一次进来就能给你回收掉95个，这是工业的统计，听懂了吧，这是工业的一个统计。

所以针对于这种一次回收95个的话，我就没有必要说给他半撇，给它分成两半，完全平均的，反正你回收的剩下的就5%，我只要能够拷贝的那个空间能乘着5%实际上就可以了，所以这个时候呢在年轻代里面它是这么来分的。

怎么来分呢，它分成三个区域，这三个区域分别叫做伊甸区，伊甸园，人类诞生的地方，对象诞生的地方，另外两个叫survivor，survivor叫幸存者，我们for循环，每个每一次for循环都产生对象怎么办。

产生了十个12345678 90，然后我gc介入一次，干掉了九个，就剩了一个，这一个怎么办呢，直接拷贝到swif去，看懂了吧，然后整个伊甸区全部清除一块完整的内存，全部清除。

对计算机的操作来说就是一个指针移动的事情，超速度超级快，好看这里，在survivor来说，如果下一次dc再介入，下次bc再进入这个survival里，这个如果它依然存活怎么办呢。

你不能把它拷贝到一甸园区，这肯定不合适，那怎么办，拷贝到另外一个survivor，当然这个clever里面同时也会具备着这一次新的dc，从伊甸园区考过来的这些存活的对象，所以大家可以想一下。

就是考来考去，考来考去，当有一些对象老是回收不掉的时候，这时候怎么办呢，进入到老年代这个过程呢，老师做成了动画，为了让你们学得轻松一些，老师真是呕心沥血，我告诉你图，我知道看起来会比文字轻松那个。

但是没有动画轻松好看，这里一个对象从出生到消亡是什么样的呢，当一个对象一旦开始诞生的时候，首先new出这个对象来的时候，优先会在站上分配，但这件的时候你先不用管，一般来说他也不会问到这方面的问题。

先不抠细节，它会首先进入我们的一甸园区，进入到一点去一点，然后经过一次垃圾回收，会进入到我们swever 1，再经过一次垃圾回收进入survival 2，再经过垃圾回收进入survivor，三。

再经过垃圾回收进入survivor 4，再经过垃圾回收，k年龄够了怎么办，老年代这个过程大家看清楚了吗，应该不需要我重新演示一遍，当然我还有同学呢说了很多的细节，说我这个比例到底是多少，是一比二。

那个呢是八比一比一，还有呢参数我具体怎么设，最大的年这个比方说那个年龄值默认是几等等，我就直接告诉你，一般的默认都是15cm s，默认是六，这些东西老师记得比较熟，但是我不想跟你讲这些，因为这些不重要。

你只要知道去哪查就可以搞东，搞定原理之后去查，好吧好了，大家有同学说老师去哪查呀，像老师这么体贴的暖男，当然，我会把这些全都给你总结出来，一篇文档里就让你全插定了，真他娘的体贴，你说这女朋友能少吗。

好开个玩笑啊，来看这里，在这里啊，嗯，当然这里头有一些那个很细节很细节的概念啊，比如说什么叫minor dc，什么叫y dc，什么叫major dc，什么叫food c，这东西呢其实大家记住啊。

概念性的东西呢，不用把它看的特别重要，概念这玩意儿呢是人类发明出来互相之间交流沟通用的，你不要在这上面在那抬杠，你懂吗，尤其是好多年轻的小伙儿愣说我这个东西就叫这个，不能叫别的，这东西就叫粑粑。

不能叫别的是吧，我告诉你概念，这玩意儿就是人类发明出来互相交流沟通用的，你知道是个什么东西都可以，也许在远古，人类把这个当成就叫apple对吧，叫facebook叫trump。

ok那么这个东西呢它就一直一直一直会这么沿用下来，所以不要在这里扣这种概念，真心没有意义，不要勿虚名而处实祸，好大家看这里，当然这里面有一些细节的东西，我先给你略过，不管它还是那句话，先看脉络。

再给大家总结一个动画的图，我希望大家呢这里面有些概念我没有讲到的，讲细的，你先把它略过，当我们有一个对象出来的时候，优先的首先会在站上进行分配，以前有同学可能会说，老师不都是在new在堆上吗。

然而并不是，如果你学过c语言，你就会知道c语言里面有很多对象是可以分配在栈上的，有很多个不能说对象吧，就是有很多个数据结构都可以分配在栈上的，这完全没问题，java语言也是它是可以分配在栈上的。

对象是可以分配在栈上呃，如果能分配在栈上，这个事儿呢就简单了，分配在栈上有什么好处啊，同学们，你们告诉我一个栈弹出之后，大家知道啊，一个线程开始运行，线程里面是方法调方法，每个方法呢对应一个战争。

这个方法一旦运行结束，这个战争啪叽一下弹出去，这里面的对象是不是顺带着立马就消失了，所以不用垃圾回收器介入，你懂吗，根本就不用垃圾回收器介入，不用拉丁回收，这效率得多高，超级高。

所以如果能在栈上分配java的虚拟机，优先会分配在栈上，当然说到这儿，我稍微讲一点细节，站上分配呢有它自己的一些特性，站上分配一般来讲有两个特性，第一个呢你要进行逃逸分析，就是一定不能让他有逃逸。

第二个呢就是一定要能进行标量替换，我们我简单听我说，我一分钟给你讲清楚这两个概念，所谓的逃逸是什么意思，就是你不能有别的方法的引用指向我这对象，不然你随便没了，那我这方法不成指成空指针。

这不就成野指针了吗，著名的野指针问题，dangling pointer，著名的空指针的bug，所以你要做这种分析确认没有逃逸，第二个，什么叫标量替换呢，就是一般战胜我们是分配那种基础数据类型的。

你这个对象可以被那些分解成为基础数据类型的东西来替代，你里边俩int，我就用俩int替代你不就完了吗，搞定我说清楚了吗，有时候你看文章看半天，你也不理解到底啥意思，老师一分钟给你给你给你搞定就完了啊。

小case，还能跟上吗，可以跟上吗，可以跟上给老师扣个一嗯，老师能不能再说一遍，娘的老师说过一分钟，你非得让老师来两分钟是吧，没狗嘿嘿嘿，没关系啊，稍微讲深一点，尤其是基础稍差的没懂很正常。

因为你原来有一些基础你没打，有可能你都不知道什么是战争，什么是战，什么是标量啊等等，这些个呢也很正常，重新再来一小点儿，你看还有人带节奏，说可以快一点对吧，这东西比较牛逼的，而且想受到关注的人。

我就不给你，快开玩笑开玩笑啊，还是那句话，我们照顾基础稍差的好不好，好听我说啊，首先呢一个方法的执行，一个方法，调一个方法，再调一个方法在内存里面呢，它是不同的方法独占的一个空间叫战争。

这么来理解就可以，a方法调了b方法，b方法调了c方法，假如c方法里面new了一个对象，他new在自己的战争上，而不是new在堆空间，那么这个时候呢，什么样的条件是可以放到站上呢，非常简单。

没有别人家的引用指向，就自己用，举个最简单的例子，你一个for循环里面不停的new对象，你说别人理你吗，没人理你，没关系，像这一类的对象可以放在站上，有同学说老师你能用代码证明我来告诉你。

vip课里我专门用代码证明这一点，但由于咱们时间关系，别在这上面费费费劲好吧，因为重点的好多东西我还没给你讲完呢，ok就是没有没没有引用，就是你自己玩嘛，你自己想怎么玩怎么玩，你不用丢在这上面去。

你留在自己的空间里，这个方法没了，直接往外弹，是不是就是垃圾垃圾垃圾都不用管，既然没有引用指向它嘛，对不对，这个就叫逃逸分析，逃逸分析的意思就是有没有一个引用逃出去啊，从我这个方法里面逃出去啊，哈哈哈。

广告一波对，到处都是广告，老是广告都是干货，好看这里嗯，看成员有个什么什么教育，什么教育牛逼过我们的没有，放心吧，20多个年薪上百万的老师教你，来看这里不说了啊，嗯总而言之，在战场分配好了之后。

不用垃圾回收器介入，一谈对象就可以被回收了，这种的最爽效率最高，当然如果说在栈上分配不合适，比如逃逸分析，人家有人要引用指向它，有一个例子里面有个指针指向它了，那怎么办，你不能封到你这里，你自己私有啊。

不能放放你自己兜里，那这时候怎么办，放在堆上嘛，放堆上的时候要看这哥们儿有多大，如果这哥们儿特别大，直接放老年代，刚才我们说老年代空间比年轻再大大，对象直接放老年代好，有同学可能马上就会问老师多大是大。

很简单一个事情，有参数可以确定，我呢今天争取讲理论，然后我们开开开实战，明天我告诉你怎么样设定那些参数，听懂了吧，看看这里面，如果是大对象扔到老年代，老年代里面的垃圾怎么回收啊，负dc嘛。

f d c负dc啊，这叫这这这个应该怎么翻译，也也别翻译了，因为它呢一般都这么叫，叫负dc，年轻代回收啊，全量回收，全体回收，整体回收，年轻代老年代同时回收负d c，如果回收掉好，这个对象就结束了。

那现在问题又来了，假如说他个儿不够大，站上呢也分配不了，那这时候去哪分配呢，一般来讲没有面试问这个呃，一一般没有人问，有人问，你直接给他怼明白之后呢，他基本上就不再会问你，jvm的问题了。

这个下一步的分配呢叫做t r a b t r a b，不管你是t r a b还是分在伊甸区，我刚才说了嘛，刚进出来对象放哪儿，年轻代的一电区里面好，t r a b的概念是什么意思。

不管你是t r a b还是直接分到一点区，其实最终都是在a点区，既然图上有，我给你解释一下t r a b的全称是什么呢，t r a b的全称叫做thread local t l。

这你应该知道thread local县城本地，thread local allocation分类八分缓冲区叫县城本地分配缓冲区，threload出来的buffer，我每次读的时候都想重新读一遍。

因为它特别具有那种韵味，这个单词，就跟那个耶路撒冷那词儿似的，就luclem是读起来就特别爽的感觉，thread elegation bus，但是这是伦敦伦敦口音啊，如果说你是呃美印是吧。

three relocal legation buffer，一般就会儿化音多一些，如果你是阿三的口音的，the logo allegation bb，说教英语对吧，来成都口音slg，你个瓜娃子。

所以logo你弄啥嘞，这哥们儿真够扯了对，一般都得扯一扯，开玩笑啊，开会儿玩笑，还是那句话，学习不要把自己搞得太累，搞太累了就没劲了，我要让你轻松地学，还能让你学好，这他妈才叫索菲亚，这才叫牛叉啊。

来看这里啊，虽然local alex buff，它是一个县城本地缓冲区，这什么意思啊，我们先说一般来讲呢肯定是要new一个对象，是要6_{1点七的，6}1点区，但是你好好听我讲。

为什么还有这种叫县城本地分配缓冲区，这到底是什么东西，为什么会有这个呢，一分钟给你解释清楚，认真听这块儿哪块认真，我提前提醒你，你认真听就行了，同学们，你们想一下。

在一个程序启动好多线程都开始分配内存的时候，一定会发生线程的征用，征用的意思就是县城有可能共同抢这块空间，说我也要在这儿，你也要在这儿，那么这个时候jvm就要对这些县城做管理，做同步坑。

坑位就一个谁先进去坐下，谁就是谁的，不能所有人都进去，所以在这种情况下，对象的分配效率偏低，那这时候怎么办呢，所以为了提高效率，这么设计的这么一个机制，这个机制就是java语言启动的。

每一个线程都有自己私有的一块空间，一小块空间，这个空间呢也是放在一定区里面，私有的以后每个线程分配对象的时候，自己想new个对象怎么办，new到自己兜里听懂了吗，自己兜里站满了，再去抢公共空间。

就这么回事好了，这两个中间叫t r a b叫three local allocation buff，来get到这一点，同学老师扣个一，好我们继续一点，区里面的对象被清除的时候，这些清除一个dc来了。

妈妈来了，扫线团，线团被扫走了，那就结束了，这线头没被扫走，去哪了，还记得吗，survivor 1，survivor一里面再经过一次清除，年龄够了，老年代年龄不够，survival 2。

如此的循环往复好，回过头来再来看一遍，当我们有一个对象的时候，首先尝试站上站上分配下，就在站上，这里面有两个名词，第一个叫逃逸分析，第二个叫标量替换，刚才有同学老说，老师你再解释一下标量替换。

我再给你解释一遍，假如有这么一个对象，t一个类吧，它有两个成员变量，一个是int类型，一个是int类型，简单说这个对象完全可以用两个int类型直接替代标量替换标量。

简单认为基本数据类型能够用基本数据类型的组合来替代它，如果你学过c告诉我这个东西叫什么呀，这个东西叫结构体好看，这里总而言之，逃逸分析没有逃逸，标量替换可以替换，往站上跑，往站上放，战胜呃。

如果特别大个儿怎么办，老年代如果girl合适，然后呢站上有分配不下t l a b县城本地优先，县城本地满了，伊甸，伊甸区，伊甸区回收survivor，一survivor一再回收，年龄够了。

老年代年龄不够，survival 2循环往复，第二轮替换有什么用，说明你问这个问题，说明你不会因为站的作用，站只能放那个标量，放不了特别复杂的对象，好看，这里截个图是吧，像老师这么体贴的暖男。

还需要你截图吗，大哥，直接要整个文档，老师是不是口误了吧，对射中战，我主要是想看看你们是不是在认真听讲，开玩笑啊，来继续好，我想到现在为止呢，你应该明白什么叫做分带模型了，关于分区模型呢，嗯大多数人啊。

你们现在用的是这个线上的版本，因为很多人手头都有工作了，你们自己可以查一下你们整个线上的用到的jdk版本到底是什么，多数人应该是一点半少数1。7。6的，1。8高的很极少对吧，听我说在这个里面呢1。

8分带模型居多，但是1。8可以用g one，这是没问题的，我给大家讲这个由于时间关系，我给大家讲的时候呢，一定是讲最重点的，最常见的，好好听，我说在这里面呢分带模型里面有各种各样的垃圾回收器。

这个垃圾回收器呢由于它是分带模型，就是年轻代老年代，所以只要是分带模型，一定是成对出现，一定是这这这哥俩啊，妈妈就请这年轻代的是吧，爸爸请老年代的一定是成对出现好，那成对出现的呢包括哪些。

这都是一对儿一对儿的各种各样的组合排列，有同学可能就会说了，老师的排列组合太多了，这怎么记得住，不用记，因为常见的组合就这三种，123好，其中第三种叫1。8，默认，这个你应该掌握吧，1。

8默认的全称parallel，scange，parallel old，好简称，ps加po，你在网上查的时候，或者你们面试官问你的时候，跟你提到这些词一定要理解什么意思好，我再说一遍，1。

8可以用分带模型，也可以用不分带模型，如果是你是新建的，我优先推荐你们使用的是不分带模型，记住了，g one，这我们有时间我会给大家讲这方面的理论，但是大多数啊有那个没有这种经验的人呃。

自己的jvm都是往线上一扔，简单这哥俩的组合p p o，下面我重点给大家讲这六种，每一种到底什么意思，五分钟讲完五种，最后一种比较复杂，我们一点点讲好，我们可以继续了吗，可以继续给老师扣一，大家听我说。

第一种呢叫serial，这种已经很少用了，这种组合本身就已经非常少用了，只是存在于理论之中了，这种组合是最早的jdk的模型，jdk一点0。1的时候用的就是这种组合，这种组合叫serial serial。

年轻代，serial old cereal的老年代，所以他其实上下都都都都是serial serial，什么意思呢，来看这里，它叫做stop the world cing collection。

which uses a single dies thread，读十秒钟读一下，stop the world copy collector，which uses a single gic thread。

怎么有两个声音，你是不是开了两个窗口啊，大哥，而这里面有几个概念，第一个概念叫sw这个名词，请大家记住，凡是涉及到jc的这个名词必然存在，这叫做cw，叫stop the world，世界停止，啥意思呢。

非常简单，我刚才说了啊，你你女朋友，你男朋友在里面扔小线团玩，扔着扔着扔着垃圾回收器进来了，说你们仨都给我站墙角线，对你们来说，世界停止了，为啥工作，我们的我们的垃圾回收线程开始工作了。

这叫stop the world s t w，那如果他copy connector，就是用的算法是拷贝算法，which uses single re，简单的线程的呃，就一个一个single的dc特征。

一个单线程的通过图，很容易理解，你们哥仨在这里工作工作工作工作空间满了。

系列 2：P11：马士兵老师JVM调优：11.用top命令观察系统运行情况 - Java视频学堂 - BV1Hy4y1t7Bo

sgo的dc特征，一个单线程的通过图，很容易理解，你们哥仨在这里工作工作工作工作空间满了，触发垃圾回收怎么办，垃圾回收器一进来停止狗亭，我来干活，然后干一段时间，清除一些空间。

来alan你们仨继续停止过来干活，还有你们仨继续好，这块就叫s t w，我讲到这儿的时候呢，一定有同学有这样的感触，java语言呢有很多时候会有一种卡顿的感觉，那种卡顿的感觉来源于什么地方。

垃圾回收器在干活，我们的业务线程没有反馈，业务线程停了，你点个按钮，业务线程没工作，它停了，你说这按钮能给你反馈吗，不可能，所以这时候叫卡顿，这是我们这vm调优的时候极力避免的一个现象。

而这几个概念不知道我说清楚没有，ok还有个同学有疑问的，可以继续了吗，好看这里你们关于这些实实战中的问题，一会儿再问啊，我先讲完，回答你的问题，打乱咱们正常的听课节奏哦，你先留着啊，放心所有问题随便来。

答不出来，老师的错啊，我一般都推荐说你们调试调试一个jvm，在线调优的时候怎么调啊，先尝试老师教的方法，百度实在不行，你们互相探讨排除法，再不行，找爷找马爷啊，过来找我，最后最终解决方案，啊看这里啊。

叫做is still the world cing collector，which is这个这个非常简单，大家记住啊，从呃垃圾回收器的整个的发展历程来说，嗯。

从最开始的jdk一点零到现在的这个是14整个的发展历程，各位听我说，它是一个内存逐渐变大的过程，内存逐渐变大，啥意思呢，就是你们家的房间呢越来越大，越来越大，好原来的那种算法已经应付不了了。

才会考虑去发明新算法，我们最简单的算法呢就叫单线程处理，就一个人进来全清理掉你们家房间三个平米，三个平方，仨人很快满了，没关系，一个人进来七里宽带就扫，就就清扫完了，这种情况下给客户的感觉。

他不会有非常强烈的那种st大的现象，因为最多很快清扫一下，你就清扫完了，完全没问题的，但是你想象一下，你们家的空间越来越大，100个平方，100个平方，一个人进来清理了多长时间，有可能好几分钟。

那这时候怎么办，当然cao呢就是of the world max swift或者more compact or uc c g c re，他工作在老年代的单线程的垃圾回收，这个都很很容易理解了。

就是我回到刚才的问题，你们家这个房间越来越大，那你想提高效率，你不能跟我说那个t大多时间太长了，怎么办，你拿大腿想想也应该知道，多叫几个人呗对吗，同学们多叫几个人进来不就完了吗，爸爸妈妈。

爷爷奶奶姥姥爷一块进来跟你说，100个平方很快也就说完了，好看这里，所以在单线程回收效率不够的时候，用下面这种工作在年轻代的叫parallel scavenge，读一下，非常简单。

stop the world copy collector，which uses multiple threat to the threads，来读一看图就就就看明白了，你们哥儿仨啊。

你们不能说你们哥儿仨，你几13在这儿扔来扔去，扔线团满了，垃圾回收器进来，仨人进来帮你回收，可以吧，多线程多个人嘛，非常很容易就能理解了，我们继续parallel又是什么呢，就是多个线程工作的老年代吗。

ok这叫parallel old，所以讲到现在为止呢，其实这几种都非常简单，serial serioko，就parallecovage partout，无非就是单线程，多线程，单个人处理，多个人处理。

提升了效率而已，但是我想问大家一句，我想问大家一句，当你们家的空间越来越大的时候，是不是能够随着线程数而线性的进行效率提升，什么意思呢，就是我堆人嘛，我一个人回收不过来，俩人俩人回收不来，四个人。

四个人不行，八个人八个人不行，我16个人实在不行，我拉一个军队过来，这样行不行，可以吗，不行，为什么不行啊，为什么不行，其实牵扯到另外一个概念啊，既然说到这，我稍微稍微稍微的给大家那个拓展一点好吗。

我看我的ppt有没有打开，等下我的ppt啊，稍等片哥找一下，我的ppt，就另外一个概念啊，因为很多人呢第一个呢他是非科班，第二个呢就算有些科班能是这个基础太弱，我稍微稍微拓展一点点，并不并不多。

我不会给大家讲汇编，不会给大家讲量子计算机啊，我这里就给大家讲这个，也不会给大家讲超线程，我给大家讲什么，讲计算机的最根本的组成，为什么好多个线程，我说多线程工作一般比单线程效率高。

为什么线程到一定数量的时候，它的效率不会随着提高，原因是什么，大家看这里什么叫一个线程，什么叫一个线程啊，一个县城一个进程，听我说一个进程标准，答案是操作系统用来分配资源的基本单位，这块你要能听懂就听。

听不懂就算了啊，一个县城叫操作系统进行调度，执行的基本单位就是线程啊，是执行的基本单位，一颗cpu通常情况下，如果你没有做那种呃呃超线程的，这这这这这种结构的话，那么一颗cpu通常情况下只执行一个线程。

在同一个时间点上，那我们多线程，比方说我们有八个cpu，我们有2000个线程，我就想问你这八个cpu怎么去执行这两行，怎么去执行这两行线程很简单，就是执行你一会儿执行他一会儿你来一会儿。

他来一会儿来回来去的进行切换，这个具体的切换过程涉及到寄存器的数据的存储，数据的备份以及恢复，涉及到program counter，涉及到这种程序计数器的。

就是说你的那个那个那个执行到哪个位置上的这种的技术备份和恢复，这种的呢，我们称之为专业名词，叫context switch，全称叫connewitch，叫叫做叫做上下文切换，大家听我说。

当线程数量合适的时候，这个context switch它所占的呃呃呃呃，资源的并不是特别多，然后多线程就发挥了它的威力，它的一定比单个的线程要快很多，但是如果你随地线程数量越来越多。

那么cpu会把它的很大的资源都耗在什么呢，什么上面呢，就是线程切换上2000个线程，我得保证每个人都有机会执行，那我就能执行你一小点时间，我就得把另外一个线程给切进来。

所以更大的时间会消耗在这个context switch上面，上下文切换，所以并不是说呢你们家人多，人越多啊，你的效率就越高，不是这么回事儿，而是到一定程度的时候，我告诉你，你的效率就已经提升不了。

甚至开始下降了，所以这个时候就开始呼唤新的算法，同学们，你们想一下，当他家的房间越来越大，你100 100个平米几个人没问题，他变一层楼了，变成一个天安门广场，那么大个儿的时候，我就想问你。

你多少个县城进来都没戏，因为全把资源耗在线程切换上了，所以这个时候呢就开始要求啊呼唤新的这种，垃圾回收的这种方式，这种垃圾回收器的算法要求新的算法出现，大概在这里和1。4的时候。

诞生了一个承前启后的划时代的算法，这个算法叫cms，好在我解释cm之前，我先给大家解释什么叫pcm，我一会儿解释，这是我们的考点重点，所有复杂的地方在于这个地方，有了cms，你才能去理解g one。

才能理解这cdc才能理解谁能懂啊，所以说呢他虽然说有各种各样的毛病和bug，但是我告诉你这个东西算法你要搞不明白，jvm面试你就过不去，好我们先了解什么叫penn，大家看这里啊，每种垃圾回收器啊。

它都是配对出现的，我说常见的配对是这样的，你看到了吗，来一拍一拍，一拍一拍，很常见的配对就这三种，但是呢并不代表着说我serial不能和你c m s配。

我parallel coverage不能和你serio的配置是可以的，完全没问题，cm呢是一个划时代的，一会儿我告诉你他为什么划时代，但是呢原来原来存在的这些想跟他配对不好配，为了和他配对。

发明了一个新的pu，pu的全称就是parallel new，依然是多线程的工作，在年轻代的，但是呢他专门和c m s做配合的好看，这里所谓的朋友他跟那个parallel old的描述是一样的。

这个我都是从那个jvm虚拟机里面具体规范里面给大家摘出来的，它叫做is of the world cing collector，which uses mbodies the threat。

它的描述跟parallel old跟parallel scavenge一模一样，但是他下面说的区别，他说it defers from parallecoin，他说跟parallecoin的区别在哪里呢。

它是in that it has enhancements that makes it usable with the same as，专门做了一些增强配合cms使用，所以好好听我说。

这东西约等于我们不能说直接等于这个哥们儿约等于他，但是做了一些和cms专门配合的一些改进，为了伺候他，看不懂，所以我听听到什么程度算什么程度莫急，其实我讲的算是很很那个那个已经算是很浅显易懂了吧。

好大家能能跟上吗，下面我们就来聊c m s了，能够让老师扣一来嗯，好继续按我们来聊cms和原来的它的一个很重大的区别在哪里呢，好我们还是从线程角度直接来理解cm啊，它的全称我们先看它的全称叫什么，好吧。

它全称叫concurrent mark week，实际上这里头有两个概念，一个叫并行叫paralle，一个叫并发叫concurrent，这两个概念如果想透彻理解的话，那我也懒得跟你解释。

有一本书叫呃呃呃计算机组成原理啊，第700多页的时候专门讲这个概念算了，先先不管他听我讲就行了啊，concurrent，concurrent mark wik叫cms。

我们看一眼它的区别主要在哪里就知道了，它的区别主要在于什么地方呢，就是你发现没有看这个阶段，我们不管这个阶段是什么，我们先不管这个阶段是什么，就是在cms回收垃圾回收的整个阶段里头。

有一个阶段是什么样的呢，你会发现垃圾回收线程工作线程同时在干事儿，我们以前说过的可真没有，就是所有的你必须都得给我s t w了，我我垃圾回收线程干事的时候，其他的那些个工作线的都给我站一边去。

站墙根儿去，但是在cms里面也就是concurrent，这叫并发，并发的意思是说垃圾回收线程跟我们的工作线程同时在运行，同学们，你们想一下，如果是这样的话，有什么好处呢。

好处就在于你拿大腿想也应该知道我点个按钮，它会有反馈了，为什么，因为我工作线程在运行啊，原来怎么样啊，原来是我垃圾回收线程运行，我工作线程就运行不了，所以它按钮一定没反馈，好这个就是cms的核心。

那我下面细细的讲每一个阶段到底是几个意思好吧，并发经理的单线程少画了一个多线程，sorry啊，欢乐马，你的眼神够好的嗯，来看这里，作为，从现场的角度来讲呢，c m s呢会分成六个阶段。

但是它主要的一般跟面试官谈呢，谈这四个够了，再多说，再多学了呢，你的效率就变低了，亏了你的时间上的效率就变亏了，我觉得一个老师还有一个牛逼的点，就是我告诉你，你的最重要的效率应该花在什么地方。

有好多人呢他不知道，他会把他宝贵的时间花在那些个面试官根本不关心的地方上，那你就太浪费了，看这里这四个阶段够了，这四阶段分别叫什么呢，叫初始标记，并发标记，重新标记和并发清理。

我先给你大概讲每个阶段的意思，想透彻理解这里面的算法，我们一会儿尝试讲讲看，先不着急好，大家看这里，初始标记的意思是什么呢，就是我们这个算法你们还有印象吗，c m s是工作的老年代的。

它的全称叫mark sweep，就是从根儿上找，比如searching嘛，从根上开始捋，能捋到的这些个带着从一个县一个县开始捋，捋，能捋到这些线团，这些线团都不是垃圾，这个过程非常的复杂。

尤其是随着程序越来越大，运行时间越来越长，捋一遍这个过程非常耗时，最耗时的地方就在于这儿，以前呢都是捋这个过程的时候给我停了，其他人都给我停了，但时间太长了怎么办。

现在是这个铝这个东西的这个过程的时候是跟扔线团的人同时进行的，那这事就好玩了，你发现没有，好玩在哪里呢，我的最开始的时候可以做一个很很小的一个初始标记，初始标题就是根上那些对象。

我先给你找出来这仨人手里拎着的最直接拎着的那些个线团儿，先给你拎出来哈，这些是根儿上就行，跟上对象一般不多，所以这里确实是s t w，但是这个s t w注意是可以接受的，他大概就是个几百个毫秒而已。

这是能接受的，那有同学讲到这儿就会就会问说老师计算机运动运行速度那么快，你前面讲的那些个不管是单线程的，多线程的这种sw，难道比几百个毫秒长很多吗，我告诉你生产环境之中，老师遇到过两天以上的，两天以上。

什么概念就停在这儿，程序跟死了一模一样诶，但是呢你会后台查，你会发现这个这个这个现场这个技能还活着，你说你杀了他，万一中间有数据不一致怎么办，两天以上呃，咱们学我我学员遇见过最长的半个小时以上。

我就想问你双11正在抢单呢，正在秒杀呢，你的垃圾回收线程开始工作s t w时间也不用长十分钟，你们公司能忍吗，忍不了，不可能的，所以在后面的很多很多的垃圾回收器的算法设计里头。

它的核心思想降低s t w时间，降低卡顿时间，嗯，我讲到这儿的时候呢，刚才啊有同学问，我不知道这这这这这个同学还在不在，他会问我，他说那为什么g one的效率反而比cm s稍微低一些。

好好听我说g one本身的设计，它的运行效率就是比cm稍微低一些，但是它的设计思想是他的停顿时间比cm s又提升了一个数量级，g m s200 个毫秒左右比较长，这哥们多少十个毫秒，cdc多少一个毫秒。

好，总而言之，言而总之，整个垃圾回收器回收的过程就是内存越来越大，响应时间越来越及时，卡顿时间越来越短，它是沿着这么一条路线在演进，啊所以他第一个标记过程叫初始标记，就是他找到最根上。

他就不开始往下找了，剩下继续找的过程，它是一个并发标记，你爸爸妈妈进来在屋里头，你们仨在床上，是不是在那个屋里玩，玩着玩着产生各种各样的小垃圾，你爸爸妈妈顺手就给你清了，明白吗。

还一边在标记一边顺手就给你清了，ok very good，这种当然好，然后同学们，我们来考虑，现在来考虑面试官可能会问你的问题了，仔细听我就想问你一个垃圾回收的这个过程，我们的工作线程在同时进行。

你拿脑袋自己先想想看会不会产生混乱，会产生混乱吗，一定会你好好想想吧，争夺倒不会争夺你，比如说啊你这个线团呢，本来这个这个这个这个线团已经找到这哥们儿，它不是垃圾了，注意已经有人把它标记成它不是垃圾了。

对不对，那在你运行的过程之中，因为你的工作线程也在运行啊，很可能下一个时间段把它给剪掉，这哥们儿又变成垃圾了对吧，同学们，刚刚那个你爸妈认为它不是垃圾，但是呢过一段时间你玩着玩着它可能变成垃圾了。

这种情况会是什么样子，这种情况呀其实无所谓，为什么，大不了下一次再进行标记的时候，再再重新执行一遍的时候，这哥们儿一定会被我揪出来，等下次回首没错，所以这个的产生叫做浮动垃圾，这就是著名的浮动垃圾。

就这次没回收完，没有关系啊，正在回收的过程中所产生的标记的过程中产生的就是浮动垃圾，叫floating garbage，这没有关系，影响并不是想象中那么大，但是我告诉你，这里面比较恶心的是另外一种。

本来啊我已经标记完了，准备清除了，注意五个里头我标记了俩有用，三个没用，我正要准备清除的时候，有一根线把它连上了，能理解吗，这种的叫什么错标漏标好吧，错标本来它不是垃圾，你把当成垃圾了，你想想看。

你直接把这哥们给清了，完蛋一定出问题，所以它会产生错标，好一堆的算法就是为了高效率的解决坐标问题，我们先不讲这些算法的细节，先说一定会有这个问题，不知道大家意识到了没有，来这块还能跟上的，给老师扣个一。

那，没错，好所以就会还有一个阶段叫重新标记，重新标记是什么呢，and understand，就这些地儿呢给错标了，所以这个阶段叫重新标记，由于坐标的这种也不会太多，所以这哥们儿确实是st t w的。

但是也是依然是可以接受的啊，并发清理的过程依然会产生浮动垃圾，不过没关系，下次循环再进行处理，我想大体这个过程大家是不是能跟上啊，已经丢到了引用，怎么重新再引用呢，本来一个放在有缓存里。

你准备把它清掉了，后来缓存又命中了，可以吧，没问题吧，有那么这个有那么难想象的到吗，有缓存，没有人没有引用，指向它了，没有命中它了，可以清了，但是呢哎下一秒的时间又有又又又查询的时候，这个缓存又命中了。

方法有很多种啊，详情运动对，还是那句话，莫吉先听，大概你指望从你零基础听我一堂的这个课，你说所有细节全听明白，那不是你是神仙，就是我是神仙，不太可能墨迹，就相当于你第一天练拳击，就直接把泰森给打死了。

那是不可能的，总是要经过艰苦的训练啊，但是我想我我建议我，我呢是争取给你们讲的那个稍微的通通俗一点，让你们能多多记住就完了，我看这里，我们再来通过小小的动画来回顾一下这个过程啊，来看这个过程，来看这里。

总而言之，言而总之，第一个过程叫做initial mark，叫初始标记，初始标记的就是找到根对象，然后第二个过程叫做并发的进行标记，标记来标记去，标记来标记去。

但是标记的过程呢有可能这哥们原来已经是个垃圾，后来又变成不是垃圾了，好这种情况下会产生错标，怎么办呢，把剩下的全部清除掉，就大概是这么一个过程，呃，其实其实是不是也很简单不难吧，到现在为止还能跟上的。

来给老师扣个一好，在我们讲比较恶心的难难难，难于接受的算法之前，我想呢给大家拓展一些知识呃，这个知识呢也是第一次啊，还真是第一次讲给大家听，以前呢没有没有没有没有讲过，主要以前呢我们在升级的。

就课程升级的过程之中呢，没有升级到go语言和那个rust语言，所以这块呢是第一次讲，试着讲讲讲讲给大家听，这是特别好玩的一个东西，就这里头呢就会牵扯到各种各样的这种现这种，这种计算机的基本的理论。

就是有时候你基本就能通了，就全通了，大家都知道啊，呃我觉得go语言应该很多人都会都会了解这个语言是吧。

叫go浪对吧，它的一个模型是什么，最核心的是要支持高并发，但是呢我以前跟大家讲过，这非常的简单，其实沟炎的高并发就是相当于java里面的线程池。

就这么简单啊，一句话给你搞定就行了，但是呢go语言里面的它的内存模型是什么样的，第一个你首先需要你理解的是，购员也有垃圾回收，注意它是有垃圾回收的，第二个go语言没有虚拟机，很多同学这块老犯糊涂。

注意他没有虚拟机，它的垃圾回收就是起一个真真正正的操作系统的线程，内核线程来帮你干这事儿好，那么它的垃圾回收的算法，它的内存的管理到底什么样呢，我尝试讲一下这块，你没基础，你是确实是很难听懂。

但是他跟java的设计完全不一样，超级好玩儿，好他这个算法呢实际上是参考了操作系统的，虚拟内存和物理内存的映射，映射算法呃，由于啊我说一下。

由于我要我要v i p的给大家讲的话，那我就直接讲了，为啥呢。

因为大多数人应该会听我们的那个呃基础理论的课，听完了这块的话呢。

再讲起来就比较方便，但是作为咱们公开课的小伙伴来讲呢。

你未必有这个基础，我大概的尝试着用最简单的语言解释给你听，大家听我说，作为咱们现在的操作系统管理进程的时候，管理一个进程他到底什么样的呢，比方说我起了一个qq。e x e这样一个进程，双击它启动起来。

注意这个进程本身是工作在一个虚拟空间，虚拟空间这里面的它的程序里面所用到的数据，程序里面所用到的指令都是放在一个很大很大的，二的64次方64位嘛，这么大的一个空间里头，这里面的地址你随便用。

但是有它的规则，我们先不管这里面地址，你随便上，它是一个虚拟的空间，你如果再起一个qq。e x e，它又是一个虚拟的空间，这俩空间地址完全有可能重合的，如果你再起一个那个别的purple的ppt。

它又是一个虚拟的空间，注意是虚拟的，我再说一遍，虚拟虚拟好吧，呃这块能理解吗，就大概的理解能跟热闹给老师扣一来，但是你就想想看啊，注意虚拟空间嘛，就是你这个地址就随便用嘛。

这个这个空间整个大楼就全归你了，但是是虚的好，大家知道我们的物理内存远远没有这么大，物理内存的实际当中的这个这个这个这个这个这个它它的大小啊，远远装不下，说按照你虚拟空间全部都给你装进来，那不可能。

那怎么办啊，我们的真实内存物理内存这时候怎么办呢，它会把这个虚拟空间分成一页一页的，就是一个小单元，一个小单元，一个小单元的好，我需要用到这块儿这个虚拟空间或者这个进程的哪一块儿。

我就把它放到我的物理内存里。

系列 2：P12：马士兵老师JVM调优：12.用jps定位虚拟机进程 - Java视频学堂 - BV1Hy4y1t7Bo

那怎么办啊，我们的真实内存物理内存这时候怎么办呢，它会把这个虚拟空间分成一页一页的，就是一个小单元，一个小单元，一个小单元的好，我需要用到这块儿，这个虚拟空间或者这个进程的哪一块儿。

我就把它放到我的物理内存里，我不需要的时候我就不放，所以在他真真正正的执行的过程之中，是有好多好多的小块儿装到我们物理内存中的地址，可以同时装好多不同的程序的小块儿。

这个叫做虚拟空间到真实物理空间的映射，雪儿走了好多是吧，慢走不送，是我讲太难了吗，这不只能讲女的了，虚拟内存谁来充当，虚拟内存是虚的，所以没有谁来充当，操作系统的基本课，因为我不知道有多少人啊。

你们是非计算机专业的有吗，就非专业的有吗，现在找工作要求越来越专业了，设计等级专业考到基础理论的时候，你基本全完蛋，所以我们为什么说要给大家讲这些内容呢，就是我们大概总结出来。

如果你想短时间内跟计算机专业一模一样，好，在这个时候是怎么办呢，只要你学两门课就可以，周老师讲的还有两个就可以搞定了，你就跟计算机系的理论方面没有半毛钱区别，这是呃如果你你想跟全面性的没有任何区别。

加一个算法全部搞定，其他的像什么微机原理啊，逻辑电路，数字电路这些你全部用学，就这是老师存在的价值，你知道吧，我就是你你你你你不需要去操心，我该学啥学啥，我我我这个这个程度应该学什么。

我怎么分辨这个东西该学不该学，投入多少精力，这东西交给老师，老师告诉你学这个你就学这个，告诉你学那个学那个搞定啊，好不说了啊，来看这里，其实总而言之，go语言里面的这个内存模型完全模拟了这种算法。

这种算法特别好玩，就是go语言呢也是一个大的非常大块的一个虚拟空间，在这个虚拟空间里面，把自己的每个对象，或者说每个数据结构分成一个一个一个一个的小块儿，然后注意还这就还是那句话，这是虚拟的，虚拟的。

自然而然的操作系统管理的时候，就会把它一小块一小块一小块放到真实内存里面，你都不用去管那个真实内存的那个那个那个怎么怎么分配，这个过程你不用管，这里面会产生一些小小的浪费，你比如说这个对象只占了3/4。

但我并没有把两块全占全，没有关系，稍微有一点点浪费，很正常，但是像这种东西，有同学可能就会说了，说老师我怎么去回收它，回收它呢，只需要单单独做一个，你可以认为是一张表，这张表里面记录着哪块。

哪块已经是被扫描过，被回收了，大体的算法就是这样的，细节里面有特别多，因为这里面呢是一个big map，这样讲的话就真没完了，所以它的算法和共和那个java语言的算法叫做完全不同不一样。

同样的物理空间怎么可以写不同东西，不是我，我哪句话告诉你，不同的块会装在同一个物理空间啊，大哥就一个马桶，你坐俩人是吗，我什么时候会告诉你，这个我没有啊，我没告诉你这一点啊，虚拟的装到物理的时候。

他在做这个马桶，你你再来一块儿的时候，你做另外一个马桶就行了，听懂了吧，好所以go语言里面它的这个内存模型的参考是参考了os的虚拟内存，然后有同学会说，老师他这种算法比比单位语言算法好吗。

其实到目前为止，他的表现并不比java的强多少，它的算法上的优点在于不用挪对象，这点是和java完全不同的，java，大家知道吗，一个对象会挪来挪去，你发现没有一个对象年轻代ok不行了。

会复制到老年代复制过来，它会挪过来，但是如果是虚拟空间，你只用在虚拟空间标，他说不行了，这个没有了，我们不用去管它了，好那么在真正映射到物理内存的时候，他发现这块空间不需要往里放了，那就直接废了。

直接就废掉了，我甚至不需要动，你知道吗，装到物理空间之后，我我我我不需要动，所以它不需要挪动对象，这是它的优点，这块要是你没听懂，我只能说明你基础不够，没听懂就没听懂啊，java虚拟机不是虚拟空间吗。

不是老婆饼，不是老婆，这个虚拟机也不是虚拟空间，嗯，又是马桶，因为我姓马，马桶也姓马，啊你就是想聊会儿小晴天吗，可以聊一小会儿，没关系啊，聊个一分钟，两分钟，我们继续好吧，这块还能还能跟上吗。

能跟上给老师扣，一来直接跳跳和华为哪个前景好，诶你说到这儿特别好玩啊，我刚才有同学问我，字节跳动和华为哪个哪个前景好，我今天刚刚收到我们美国的同学，他们截的一个图，特别好玩啊，我我我给你看一眼。

我看能不能找出找出来啊。

稍等，嗯，啊拖不动。

我得用手机发过来，你们想看吗。

就是那个字节字节跳动，在美国给给美国员工的薪水，你们想看吗，想看是吧。

好稍等啊，这个你得耐心等一下，我先把那个图传过来，然后传到电脑上，然后再再给大家看呃，ok我已经传过来了啊。

来看这图，这今天我刚刚在群里看到的啊。

差距好玩儿，反正讲讲讲东西，我们讲点讲点那个那个技术内容是吧。

来聊点八卦。

看一下。

company是那个by dance呃，level是那个三杠二呃，工作年限是工作1年，在在公司里工作1年了，它的整个工作年限应该是7年了，然后他的薪水来自自己看一下，哈哈哈哈，没事。

这仅仅是84万~21年，没没没看这个呢，这个是啥，嗯嗯。

好了好了好了，大家羡慕羡慕就行了啊，年薪当然是年薪啊，人日日薪和时薪有点太过分了啊，技术人员技术人员啊呃，这个呢有一会儿有机会我们聊聊一聊好不好，嗯，呃就是我个人觉得呢你可能达不到不是这种水平。

但是我告诉你，其实自己给的蛮高的，那华为是多高呢，华为其实我也有截图哈哈我得我得我得那个一会儿给你找出来看看，这两个如果说比薪水的话，普通普通人的薪水，因为这个比较特殊，我今天觉得比较好玩，留下来了。

但是这个不代表普通人，作为普通人来说，这两个公司的薪水，我个人认为是华为更早听懂了吗，所以说如果你想你想多挣钱，我个人觉得呢华为应该比那个头条要高，华为的工资，比方说平时给你签签签协议的时候。

给你的工资拿出30万，基本上就是占你总收入的1/3~1/4，有在乘以3x4，基本上是华为的收入啊，不是说头条高吗，嗯了解到的还是华为高，当然他是加班啊，以及你到一定的级别啊，呃分红啊啊等等。

全算上这个就会就会华为更高一些好吧。

呃其实目前国内给新水给的给的比较高的有这么几家，我跟你说一下呃，第一个呢是拼拼夕夕，拼多多，上海应该是给的最高的大厂，然后是头条北京，然后接下来是华为给的比较高呃，然后剩下剩余的是其他的大厂。

阿里那个嗯什么什么什么什么腾讯啊，百度给的相对不是特别高啊，京东给的是最低的，然后再是什么美团呃，每条给的应该比京东还要高一些啊，快手啊等等，这这这这些吧，网易应该排不太上，网应该排不太上啊。

进不了大厂怎么办，没关系啊，好多中小厂给的也并不低，你知道吗，嗯，好了好了好了好了好了，我们还讲讲技术吗，不讲技术我就不讲了，那咱就先瞎聊天一聊这玩意了，你看瓜牛都说了，老师聊聊rust吧。

可以没问题啊。

我们来聊一聊rust，对八八十4万美刀的年薪是吧，哈哈太香了嗯，好聊一聊rust，rust这种牛逼的语言，为什么微软会放弃csf，拥抱rest，为什么呢，你们好好想想看，为什么呢，因为它确实太牛逼了。

开天辟地，吹牛逼逼好吧，牛逼在什么地方，看这里，没有dc，不用，手工管理内存，不会有野指针，就是我们著名的这种now pointer exception，这种特别难以调试的错误，放心不会有这玩意儿。

并发安全，因为它的核心思想叫做共享不可变可变的东西啊，好玩吗，悬垂指针对野指针或者悬垂指针的说的都是一回事儿啊，嗯巴斯美刀在美国也很高，那不废话吗，嗯java会被rush干掉，毛不会嗯。

学rust需要有go基础吗，不用rust学习学比较高，但是今天我们聊dc，我们就聊dc好吧，我想跟大家聊一聊呢，居然有一种语言，它没有dc。

还不用手工管理内存，也就是说我没有来进回收器，你懂吗。

我不用你来进回收器啊，爸爸妈妈，爷爷奶奶，你们不用进来，但而且我只管扔，understand我，我不管回收，就这么牛逼，就是这么的牛逼好，他是怎么做到的，你们想知道吗，想知道给老师扣一一分钟。

给你解释清楚，好听我说这里面最核心的概念，最核心最核心的叫做所有权，都有哪些。

如果你要自己看书这块你没有个三五天，你应该是拿不下来，所有权概念什么概念，给你举个最简单例子，大家看这里，他说object o等于new一个object，我们说它指向一个对象，内存中是什么概念。

就是一个小o指向一个大o的对象，假如说我们有o一等于o，那也就是说o一也指向这个对象，看到了吗，对不对啊，两句话我呃还是敲一下吧。

我觉得有时候我觉得简单，你们未必觉得简单，我给你敲一下啊，然后我们这么写，object o等于new object，接下来呃，public o一等于o，然后sm把这个o打印出来。

这三句话能看懂吗，我们是用java语言来模拟的。

就是另外一个能看懂对吧，呃可以继续的给老师扣个一，不要告诉我这三句话不懂，我在反馈，好听我说我们我们分析内存，内存是什么情况，内存中一定是这种情况，我new了一个对象，有一个小o指向它。

同时我o一等于o，那我o一也指向它，所以现在有两个对象，这两个这两个引用指向它，好听，我说下面这句话打印，偶记住这玩意儿在rust里面报错，这是它最核心的点报错，老师能赶紧讲dc吗，不能我想讲啥讲啥。

这也是gc，你知道吗，你好好想想这件事，一个牛逼的语言，没有jc都能干到gc能干的事儿，你还不觉得他牛逼吗，注意这地儿报错，这地儿为什么会报错，因为这里会发生一个所有权转移，什么意思呢。

就是刚刚开始这个小o拥有这个对象的所有权，说这哥们儿是我的这个风筝，我牵了根线，当有另外一根线指向这个对象的时候，前面那根线没了，就没了，只有同在同一时刻，只有一个一根线指向这个对象。

那有同学可能会说了，老师跟jc有关系吗，那这根线没了之后，他就应该回收啊，没错，那么大家你想想看，作为这种这种变量来说，如果你熟悉电源里哈哈熟悉程序的运行机制，它在运行的期间一定是放在某个战争里。

放在某个方法的局部变量里，那这个变量这个方法只要一结束，这哥们儿一定就是垃圾，10000%是垃圾，能体会到了吗，当然这里面有我刚才又说了两个名词，一个是编译原理，一个是这个这个程序运行的机制，嗯好的。

在这种时候，只要是我能够决定唯一唯一的时刻只有一个，那这哥们儿，我这个局变量一旦没了，这哥们儿一定变成垃圾了，那现在问题是我怎么释放它呢。

这个释放的就在于你们想想看，来告诉我在一个方法内部，什么时候这个局部变量会消失，告诉我，随县城跟县城有半毛钱关系吗，跟县城没关系，这是方法，对方法执行完就消失了，那我作为编译器来说。

作为compiler来说，我是不是可以干这样一件事，我这方法一旦执行结束，我这里的局部变量指向的所有的对象全给他回收掉，我加代码在里面就可以了，delete掉搞定。

所以rac语言牛逼最牛逼的点在于它的编译器比较牛逼，compiler知道我们为什么要讲编译原理了吧，我们编译原理课是能够让你自己写一个编译器来编译java的语言，编译成class文件。

delete牛逼分配是不是被催了，为什么被催，有什么悲催的，有同学刚才不是问我吗，说rust会不会干掉闸了，会不会干掉go，你放心，这哥们儿干不掉他俩，但是他会干掉c c加加，所以以后这个语言记住了。

是目前为止最悲催的语言，悲催之一是c加加，悲催之二叫p h p p h p被够干掉了，不少c加加被好多语言都在干掉他t8 讲边原理对谁来讲，编译原理，我们著名的江畔江老师，编译原理呢是一个超级难的课程。

我个人认为呢一般面试都很少，都很少玩，只是作为兴趣好吧，作为兴趣就可以了啊，反正老师这儿的课你放心，别的人不讲的东西，这全有了，枯燥无味，对是挺枯燥的，但是真正也挺好玩儿的，微软好像回文是吧，哈哈哈。

ok，他还在直回头我再介绍他好吗，我觉得很有意思，对其实真正对技术感兴趣的人，都会觉得这个东西有意思，好了我大概这个月开始讲rust。

我讲我会把rust的最主要的特点讲给大家听。

就是为什么不用这个为什么是什么叫共共享不可变，什么叫可变不共享，什么叫它的treat，它是怎么来达到高并发的，就天然支持那个高并发，他的他的注意啊。

rise的语言的运行效率牛逼死了，他是大概跟c跟c加加跟汇编，注意它的运行效率跟cc加加跟汇编是一个层级，听懂了吗，这玩意儿记住了，这哥们儿能写嵌入式好吧。

嗯实时的你像你go语言也好。

呃java语言也好，你不可能写实时系统，你说我一导弹控制系统，我不可能用那个java来写，那是绝对不行的，你延十个，别说你s w那个那个十个毫秒延迟一个毫秒，那都不能接受，但rust没关系。

rust的运行效率跟最底层，所以它优先干掉的是那些原来写系统的语言，rose现在好找工作吗，rose工作还没有开展，这个有点超前，这其实是有点超前，rust学习曲线比较高，有点超前啊，我跟你说。

现在的需求可能并不是特别高，但我个人觉得作为我的学校来说，我愿意你们站在整个技术的最前沿啊，阿里开始对大厂早就开始做研究了，好吧。

有的时候呢也许我们能够站在风口等风来，那是最好的事情，呃自己的腾讯有的叫rust，需要cc加加基础啊，这是他们一个想象吧，对其实你了解了c和c加加之后呢，你你学rust呢，那就相对简单很多了啊。

听老师讲，感觉russ必火，我也觉得是，但rush语法有点别扭，它和我们平时接触的语法完完全全的不太一样，但这东西呢你不用着急，因为语法这东西它再复杂，豆芽子长一梵高，他也是个菜，你吃熟了它该从哪头吃。

从哪头吃。

嗯这没有关系啊。

好了不说了，今天讲dc呢讲了很多那个理论性的东西啊，我我现在我现在已经是快十点钟了，你们听再听个理论还能还能听得懂吗，在听的歌难一点的理论还能听得懂吗，老师有没russ demo，看一下。

我刚刚装了新机器，我那另外一台机器还真有russ demo，因为我要讲这个肯定是有russ demo的。

再来一个是吗，再来一个再来最后一个好吧，我再来一个啊，我还回到刚才的这个的内容上来，就是我们刚才分析过说呃，在我们并发的执行垃圾回收的过程之中，并发的并发回收还是有并发回收。

什么样子并发回收执行的过程之中就是非常麻烦的，有一点会坐标坐标的意思是在我标注的过程之中，有一个原本是垃圾的对象，又变成不是垃圾了，好这个时候会产生有可能会被被我错误的干掉，大家听我说。

在java的cms和g one语言里面，和g one的这个垃圾回收器里面都是一样的，就是著名的你们应该见到过的叫三色标记，只不过cms解决三次标题问题，用的是叫做incremental update。

而g one呢用的叫s a t b叫snapshot at the beginning，好了，同学们，go语言里面就是普通的三个标记，那cdc叫颜色指针，叫color the pointer。

ok这里面也用到了操作系统的虚拟空间的概念，所以z dc和go语言里面的它的这个内存管理上还有有些许的类似，嗯讲完肯定是不可能的，我们来看cm，我刚才说了一个特别重要的话，其实你们可能没注意。

我说cm虽然有巨大的bug，但是它依然是承上启下的这么一个垃圾回收器，你们还记得吗，cms有巨大的bug，是因为它是第一款这种并发回收的这种算法，所以呢它确实是有巨大的bug，它bug在哪里。

我一会慢慢讲给你听，最大的bug超级大，实际上在号称cms能够解决sw问题，但在实际工程之中，最长时间的sw就是由它来产生的，好看这里，这玩意儿还是得给你来来动画啊，实战咱们明天讲吧，好吧。

今天我给你给你开个头，明天我们来讲实战诶，我抽奖了吗，没抽呢，别着急，一会儿抽，来我们来看这个三色标记算法，设计，还能还能坚持住吗，我看小伙伴走了不少，有时候讲男的也不是讲女的也不是太烦人了。

嗯然后来看那个三色标记算法啊，大家看这里三色标记算法里面呢第一种三种颜色这个事情很很重要，先理解什么叫三种颜色，三种颜色就是我现在要追对象嘛，从根儿上的对象开始一个一个的追，说我标记了。

这个是我们有用的标记了，这个是我们有用的，没标记到的是没用，是没用的，是垃圾，好一遍遍追，注意这个，那么假如这个对象已经标完了，知道它不是垃圾了，另外呢这个对象的成员变量知道吧，也标完了好。

这个对象叫黑，对象叫黑色，还有一个对象呢是它本身已经标完了，我知道他不是垃圾，但是呢这哥们儿的指向的对象我还没有开始找到，我还没有顺着这根线还没捋到哈，这个叫灰色，还没有捋到的白色。

首先这三色的概念先理解，注意三色是一个逻辑概念，上次有同学问我是真的拿一个东西在上面染染色吗，别搞笑了，太搞笑了，别这样好听，我说呃这三个是三个色，你才能脑子有点印象好吧，大家看这里。

在我们进行并发标记的时候，我讲过第一种情况有可能是什么呢，我标着标着呢，b指向d的引用消失了，那这说明什么呢，就是本来他应该被我顺着给我找到，所以他不不是垃圾的结果它变成垃圾了，这种的无所谓。

我还是那句话，就下一次再再来的时候，它就是个浮动垃圾的问题，比较简单好，比较难的点，注意看产生错标的点在哪里，在这儿仔细看，就是当我垃圾回收器正在工作的时候，我的业务逻辑线程与此同时正在工作好。

垃圾回收器已经标到现在这个图的时候，b指向d的引用消失了，那么大家你可以想一下垃圾回收器再回过头来再想进行标记的时候，他已经找不到d了对吧，刚才我说只是消失了，没有关系，与此同时又产生了一件事情。

就是黑色对象产生了一个引用，指向了白色对象，那玩大了，同学们，咱们分析一下，本来正常的情况下，我通过b是可以找到d，我就对它进行标记，你是有用的，但是呢正好在我标的过程中，这个引用没了，那我找不着它了。

这是肯定的，这是第一点，只是这样只是产生浮动垃圾。

系列 2：P13：马士兵老师JVM调优：13.用jmap导出内存转储文件 - Java视频学堂 - BV1Hy4y1t7Bo

年轻代一部分叫老年代，年轻代回收的时候多线程进行垃圾回收，老年代的时候多线程进行垃圾回收，好吧，这个就叫做p这个就叫做p o全称呢叫parallel scavenge，叫并行回收，并行覆盖。

parallel old并行的，在老年代回收就这么就就这个意思，就多线程回收默认就是这样，孙雷文不是cms吗，然而并不是好。

有一点点小小的呃，有一点点小小的这种这种背景知识之后呢，我们今天呢主要来看实战。

讲究实战之前呢我告诉你啊，呃我先告诉你以后你你你遇到实战问题怎么解决，你应该第一尝试自己解决，第二找百度，第三尝试用马老师教的方法解决，第四还搞不定，用得慢，问我找我问。

我呢最近呢我们每每每一次都会有一些新的这种案例出来呃，说到这儿，我稍微多说两句，一般来讲呢，当你在简历上写，说也我有过jvm调优经验，此处不留爷，自有留爷处啊，我会jvm调优。

我期望值在我原来的期望值身上加3000好，我要是面试官，我一定怼你，你实际当中遇到了什么情况，你是怎么调优的，它的现象是什么，过程是什么，当然我相信啊，那个不少同学应该是答不出来的，大家听我说。

呃为了解决这种问题啊，你不能说老在那背来背去，背来背去，那肯定不行，为了解决这种问题呢，我一般呢都在给大家总结各种各样的实战案例，到现在为止已经20多个了，最近的啊挺好玩的，有一个比较好玩的案例。

就是这个heaviness的程序不完善写法引起的om呃，关于这块呢是我们最近的一刚刚刚刚跟跟我们学员讨论出来的，一个也是他们的这种实际的场景之中运行到的啊，因为它这里面呢有一点小小的这种这种隐私信息。

所以呢我把那个隐私先给大家拉掉，在实际当中什么样呢，呃呃发我了一个整个hipdp的文件呃，他们实际上是由于什么原因引起的，最后怎么查的，就是用我教的方式查完了之后，最后的结果是这样的。

实际上他们是一个harness的问题，他在hardt这里这个呃一个query里面，一个q里面发现了28万个对象，哈哈今天还有小伙伴发现了300万个user对象的啊，挺好玩的。

嗯实际当中呢就是把这个积压过多，由于事物没有及时提交，积压过多，然后引起的om，像这样的案例呢是比较有说服力的，也就是说在你简历里写的时候，注意不要想那种不要写那种书上啊，有的这种案例你知道吗。

因为我知道各种各样的书上啊，都有都有一个一个一个一个一个的案例给到，你说最土的就是不断的往里头丢对象，我扔到list里面不回收，你要写说这种案例太土了好吧，面试官一个大嘴巴子直接抽过来，啪该干嘛干嘛去。

你逗我玩儿呢啊成员写成这样，对不对，嗯当然我们现在也有一些悬而未决的案例，比如说我再给你看一个，这个玄幻悬而未决的案例呢，哎我出去，好，哇这消息在我手机上没有同步到我们的那个电脑上来算了。

就先不要看这个了，学生会觉得案例他他现在这个案例是怎么回事呢，呃cpu总是隔一段时间就会暴增一次，隔一段时间暴增一次，然后卡了很长时间之后呢，他就下来了，最后呢我教了他方法，他现在还没有查出原因了。

因为这是一个生产环境，生产环境里查东西比较难，他不能随随便便的停止，也不能随随便便的产生卡顿，所以这个慢慢慢慢来，那个当然还有一些其他学校位，觉得啊呃我讲到这儿有可能讲的有点提前。

很多同学可能看不懂，没有关系，总而言之，言而总之，今天我教大家最简单的能在你简历上写出来。

我有jvm调优经验的这么一堂课，不知道大家听懂了没有，我们是不是可以继续了，可以继续，同学老师扣个一，好嘞，课堂豪门就不心疼钱啊，上干货，其实我跟你讲的这个真的是已经非常非常干了，没意识到而已。

看这里作为我来说呢，先教大家一些实战所必须具备的一些基本的内容，以避免的同学们不知道，首先第一点啊。

所谓的jvm调优实战是调什么东西，大家看这里，克莱尔应该能看到我的屏幕对吧，看到看到我这里敲的东西啊，呃首先第一点呢就是所谓的jvm调优的实战啊，这种调的是什么东西，调的是java的参数。

java option参数，先跟大家说第一点，java参数分三类，哪三类呢，我给你们演示就行了，第一类叫做以横杠开头的，比方说杠cp指定class path。

比方说杠server指定运行模式更d64 指指定64位还是32位等等，好这一类的叫做标准参数，所有的jvm的版本全支持，第二类参数叫什么呢，非标参数，这个nonstandard options。

杠x开头，java杠x回车，当你看到这些参数的时候，注意这些参数指的是非标准参数。

那么非标准参数里面呢没多少很少，我在vip课上讲了mixed interpreter啊。

就是那个解释还是混合混合模式啊。

讲了什么xm x s x xs等等这些比较常见的这样的一个参数的，怎么调优，讲了x log d c应该是怎么怎么怎么指定，这种我们的日志该怎么进行工业化的指定，平常你们所玩的demo级的指令它不行啊。

必须要进行工业化的指令，那么还有一个除了java横杠开头和横杠x开头的参数之外，其实java更多的调料来源于这里，java杠x x，当然这个参数的内容非常的多，如果你想了解的参数有多少的话。

flags final，就是当我启动这个java虚拟机之后呢，所有的参数都给我列出来，最终的值是多少，全给列出来，那么它到底是有多少呢，我们计算一下它的行数就知道了，它一共是有728行。

所以说如果你想看这个参数的话。

那你可以一个一个看啊，你就一页一页看就可以，我敲了很多之后，刚到b吧，布尔类型的log刚到l，好了。

不知道大家意识到没有，其实真正的调优是调哪些参数，杠xx开头的参数，而这些参数700个左右，所以为什么调油值钱，你们意识到了吗，是因为你在这700多个参数里头挑出某些具体参数，来让你的系统达到最优化。

ok中间这是最终值，如果你想知道默认值是另外一个参数，是这个print flags，the initial，好，所有同学都不需要记。

为什么，因为你老师这么体贴的人，你放心，早就给你准备好了，这篇文档里，老师已经帮你准备好了，常用的参数，p parallel，就ps加po常用的参数cm常用参数g one的常用参数。

cdc是在我下一个版本里头就直接给大家总结出来了。

怎么样还算给力吧，暖暖对，ok同学们，我们可以继续了吗。

可以分享吗，当然可以了，k问小k k问那个可以分享啊，当然可以分享，你的是对外公开的版本啊，vip版本会更加详细一些，比如说每一个具体的案例。

到现在为止，我们大概总结接近30个案例都可以写在你的简历里，随便玩。

面试官想拦住你不可能。

好了，同学们，下面呢我们来聊jvm调优这个这件事情，我们首先第一步来聊的是到底什么叫jvm调优啊，其实调优这个定义非常的宽泛，如果非要说的话，你应该是把系统调到最优环境，但是你相信这一点。

没有人能把系统调到最优那个值，就是你你你相当于你扔一个小球，你扔到山坡上去，扔到最顶点上，它固定在这，那不太可能的，你只要调到某一个范围就可以了，当然调优如果非得加个定义，它应该包括三个方向的内容。

这三个方向内容是哪些呢，看这里，作为调优来说，我告诉你，一般来讲包括三个方面的内容，第一个呢是根据需求进行jvm规划和预调，有这是什么意思，你的需求我要支撑千万级并发，那么我需要多少台机器。

每台机器内存是多少，cpu是多少，这个就叫做预先规划预调优好，第二个，假如你的机器现在产生了一些小毛病，比如说它运行的时候呢，他并不死，但是他比较慢，另外呢比较卡顿好，这个怎么优化这个环境。

比方说刚才那小伙呢cpu隔一段时间满一次，给一段时间满一次，到底哪出了问题呢，怎么去进行对它进行优化呢，好这部分叫做优化jm运行环境，第三部分呢是我们这工程环境之中经常出的这样的一个问题。

就是著名的oom问题，o o m的全称叫out of memory，out of memory，简单的说内存爆了，内存爆了是什么情况，你们想象一下，内存爆了会有各种各样的情形。

内存爆了是说明对象不断在这里产生，我的垃圾回收器回收不过来了，直接内存就爆了，叫out of memory，我的垃圾回收，你能回收过来，但是有一些对象特别顽固，就是回收不掉，这叫内存泄漏。

内存泄漏越来越多，依然会产生out of memory，今天我们挑第三类问题中的一个小问题来给大家讲好吧，不太可能会所有的全讲到啊，面面俱到是不太可能的，我挑第三类问题中一个小问题啊。

看这里这个小问题呢模拟的是一个在银行银行系统里面，从数据库里面取数据，然后进行那种风险分析，进行模型的风险分析，这么一个小程序好吧，模拟了模拟这么一个东西，ok呃具体说这个程序的问题到底在哪儿。

我们先不管，总而言之呢，我们先看看这个问题，这个这个这个系统呢，就这个小程序呢它会产生哪些不对的这种现象，好看，这里我把这小程序简单运行一下。

同时教大家几个简单的小参数，好吧，一个一个来啊。

好java一般呢我们来敲完，直接就后面跟我们的程序的名字呃，扣码是0g v m g c t l复制一些problem，零一这个小程序好，大家看这里，我呢直接带了几个参数，虽然我没有提前教过你。

但这个参数呢非常的简单，我们来读一下，看能不能读懂第一个参数叫什么呢，叫杠xm 200，杠x mx 200，这两个参数代表的是最小堆的内容和最大堆内容，什么意思，大家知道当我一个g m启动的时候。

它会要占一部分内存，这个内存叫最小占多大，最大占多大，正常的情况下呢，你开始启动的时候可以占一个比较小的内存，然后随着程序的整个运行，你可以占到最大能占到多少，他要是这么一个参数，最小200兆。

最大200兆，大家有同学可能就会说，老师你为什么把最小和最大射程一样呢，听不懂，打扰了嗯拜拜，最小和最大射程一样的，同学们，为什么呢，自旋，然后就要写成词，你在这聊天聊啥呢，防止卡顿。

不是叫做防止内存的抖动，同学们，你们拿大腿想想，他如果一个小程序刚刚起来，占这么大地儿不够，使了之后，他肯定是逐步扩大，逐步又扩大，一直扩到能够扩到最大为止，然后他又够使了之后怎么办呢。

它又减小逐步减小，注意这个逐步减小，逐步扩大，这个过程本身也要消耗资源，假如你这个java程序我已经知道我独占这事儿，就这个这个这个机器归我了，我已经知道我一定我会我会占比这么这么大的一个内存。

我就直接给你设到最大，你不要给我弹来弹去的浪费资源，所以一般在工业环境里头，直接把最小值和最大最大值设成一样好，第二个问题，第二个呢叫print g c，prinjc的意思是什么。

print g c的意思就是你把垃圾回收的日志给我打印出来，是这个意思，一般来讲呢在工业生产环境里头不会是这样的参数，工业生产环境里头什么样的参数呢。

是另外一种，生产环境里头正常的情况，日志，你要把这些个日志从日志文件里面读出来好吧，然后来分析这些日志的内容，当然呃，正常的一个情况呢，我我我要给你讲这个日志的格式的话，咱就没完了。

今天我们主要讲实战的调优。

所以呢我给你打印的这个日志呢其实是比较简单的日志，就是一个简简单单的小日志，但是通过这个小日志，我们也能读出很多问题来，好吧，好大家看这里，我们先把这些小东西执行起来，为了让大家更快的看到问题。

我先把内存的值设成20兆，那好讲到现在呢，由于有同学基础不太好，但是我也不太可能完全给你讲基础了，所以能跟上的来给老师扣个一好吗，我们开始定位这个程序的问题，我们先来看这个问题，它会产生一种什么现象。

大家永远记得啊，你你分析问题的时候，不要想当然，就是刚才有一个悬而未决的问题，我们我们的小小学员给我的，我问他什么现象，他反而没说，他只上来就说，我觉得应该是这个问题。

注意千万不要你觉得我要我觉得开玩笑一定是通过现象来定位，而不是想象来来做好看，这里回车，好这是第一次gc产生了，然后这是他的信息，这就是我们这句话，这个参数所得到的g c a产生了一次gc。

产生的原因是allocation failure，分配失败，那意思就是没空间了，然后进行了一次回收，这个回收的过程是从五兆回收完了之后，一兆总共的内存19兆，其实是接近一个值，就是20兆嘛。

然后回收的时间是多少秒场，关于这个日志我再解释一遍，首先是产生了dc，为什么产生dc分配空间不够了，回收之前是多少，回收之后是多少，总共内存是多少，好我现在就想问你，同学们，为什么我回收之前是五兆。

而不是20兆，原因是什么呢，对这里是年轻代的回收，嗯，你说的很对，嗯，年轻代的回收马上就回收了啊，好凡是你看到这样的回收的方式告诉你，这都是年轻代回收，我们来看看这个回收，这个回收内容是叫做负离子。

负离子的意思就是整体性的全部的回收，他仍然也是啊分配不下了，然后他的回收呢是从16兆回收到了13兆。

下一次18兆回收到15兆好了，我知道大家观察到没有，现在开始频繁的fdc好，我这个小程序牛逼，你就牛逼，在他可以频繁f d c，但是他就是不崩，然后呢注意看啊。

你看最后产生的信息是19839k回收到19838k，发现没有啥意思，就是我每次还能回收1k好玩吧，每次还能回收1k，但是我回收不了更多，如果回收不了更多，那么新产生的对象就找不着空间。

那么他就正常的情况下就一定会产生o o m，当然咱们的小程序比较恶心，是有的时候会产生o o m，有的时候不会好，我相信有同学现在开始奇怪了，说老师为什么会这样，它的源码是啥样，大家听我说。

很多人讲这种东西的时候，都是用那种demo级的小程序，明显你一看就知道问题出在哪的那种，拿一个类似的使劲往里装上来，你有一个list，然后不停的往里装对象，很快把内存占满了，这不是废话吗，像这种的内容。

我不想讲太简单，这个源码就算你看了，你也找不出问题之所在来，如果你感兴趣，需要我解释一下源码吗，需要吗，看看好可以，我们先把它停掉，我告诉你，这里面绝大多数人就算你看了这个源码，你也不知道问题出在哪儿。

来，我们来看这个源码。

呃这里这个源码是我们从小伙伴的生产的环境里头真实的模拟出来的，当然我不可能说把模拟它，它是它的实际生产环境之中呢，是大概一个一个周左右就会内存爆了，一个周左右内存又爆了，他们怎么办，重启好看。

这里我把这个只不过我把这个结果和它的内容呢进行了一些压缩而已，这个程序呢是从数据库中读取信用数据，然后套用模型并把结果进行记录和传输，什么意思呢，大家知道现在有一些信用卡的发货中心或者是那种p的金融。

说我要给这个人放贷，那么他的贷款额度应该定多少，他的贷款级别，信用级别应该是多少，那么这个时候呢我有一个这种叫什么呢，叫做风险的模型，套用这个模型，如果你符合这个模型，那么你的级别应该是定a。

那么你符合那个模型应该令b等等，简单来说，这个程序就是从数据库里面不断的把这个人的相关信息取出来，取完了之后呢，形成一个对象，然后把这个对象呢不断看看是不是符合这个模型，model fit。

它是一个定时任务，所以我们用了一个定时任务，线程池叫scheduled thread pool executor，好在这个线程池里面呢，每每每每三秒钟，然后就执行一次with fixed delay啊。

定时的啊，每三秒钟我们就执行一次model fit的这个方法，大概是这样的一个小程序，不知道我解释清楚没有，总而言之再解释一遍，每次从数据库里面取出100条数据装到lily。

然后把这个list扔给线程池，这个线程池每三秒钟执行一次，去这个list里面拿数据，拿数据不断的进行modifate，看看是不是符合这个风险模型，好，我就解释到这里，零基础的小白看懂代码别想了。

不太可能啊，那好了，这就是这个小程序，你试试看，你能看出来问题之所在吗，再用fix，第一个呢你要看不懂线程池，你完蛋，线程值你要不理解，你一定是看不出来，第二个就算你理解了，你能看出来问题在哪儿。

不一定的啊，好我们先不解释这个问题，我们先通先看现象，总而言之，言而总之，我会把这个人的信息放到cat info这个对象里，这个人的信息包括什么，包括呃这这这是我下定的，比方说他买过哪些个价格的。

买买过哪些价格的东西，名字是什么，年龄是什么。

什么是哪，是哪年生的啊等等好了，这小程序一旦运行就会产生这样的问题，那有同学可能会说老师呃，这样的程序，我看你写了一个死循环，真正运行程序有死循环吗，当然有，当然有啊，这个很正常。

你的服务器程序7x24小时，365天不间断运行，我今天就直接告诉你，其实jvm的问题的定位相对简单的多，它的步骤也比较死，但是你真正就算定位出来，就像就像这样啊。

我一会儿就带你定位出来这个问题到底出在哪，但是你查这个源码怎么改这个问题，这是巨大的，你的挑战定位非常简单，真正想纠正过来特别难，所以在生产环境里面最重要的一个调优的方式，你猜是是个啥，reboot。

有同学说我特我告诉你，我们以前有小伙伴找到了一个gr的bug，但是他们没办法，没有新版本怎么玩啊，哎每次重启一次，每次重启一次重启嗯，不是说所有的程序都能这么干，有一些是关关关系到金融的。

关系到那种呃交易的，你不能随便重启，但是大多数的情况下，我告诉你啊，这个这个方法叫万能方法，你实在搞不定的时候，没有人说说任何一个生产环境里头，没有人说一秒钟你服务器就完蛋了，那不可能多数都是缓慢的。

很缓慢的战争，只要是不行的时候，你就只能重启呃，最好玩的事呢是我不知道大家有没有印象，12306每个晚上的11点半到第二天晚上的七点，应该是买不了票的，为啥维护，还有一种现象。

以前有小伙伴2年没有查出他们家bug来怎么办，这2年就嗯隔一段时间重启一次，隔一段时间重启一次，比方说呃对性对性能调优比较要求比较高的，有一个叫游戏服务器游戏，不知道大家有没有遇到过这样的情况。

真的你你正在打游戏的时候，然后给你弹一条消息，说那个各位指战员，我们的游戏服务器大概在15分钟之后进行维护，在这段期间之内不能互相打，有遇到过吧，我告诉你这是这是。

所以我今天教了大家第一个实战的调优的方式，reboot，当然你不能这么回答面试官啊，那面试官直接问你，你是怎么调高的呀，我直接把机器给重启，拔了电源，面试官一个大嘴巴子直接抽上来，出门右转好看。

这里我们来定位这个小程序，在定位这个小程序的时候，我要先教大家一些常用的命令，这个时候我必须让他死的稍微慢点，把内存加大，它就会死的稍微慢一些，回车好。

教大家开始开始教大家命令。

我在一个呃shell里面来运行这个小程序，我在第二个shell里面呢来教大家定位bug。

调jvm调优常见的命令好，第一个命令呢叫gp，gps的命令叫java process，就是这个很简单，在你的系统里面列出来有哪些个java的进程能看懂吧，他的技能编号是什么，它的主类是什么。

这个比较简单，我们主要要到他的进程编号好，第二个命令看这里叫j infer，这infer这infer是什么意思，就是java的进程的它的一个信息，这infer后面要跟技能编号1958回车。

这样的话呢它就会把我们刚刚运行的那个小程序对应哪个java虚拟机。

这个java虚拟机的一些详细的信息全给你列出来了。

咱们大概看一眼，看上去很复杂，但是呢这里面信息相对简单。

一般来说作用不大，他会告诉你这个java进程的version是那个version，以及呢它常见的这个系统的属性是哪些，它的模式是什么啊，常见的系统属性我就不说了，就比较简单。

就是这种行的分隔符是什么等等。

java的class version是哪个啊，user home是哪个等等等等等。

这里面还有很重要的一项，看这里就是它会把整个java运行的时候带的那个参数值全部给你列出来，看这里实际上它默认的带了很多参数，这些参数值全给你列出来了，比如说initial hipsize，20兆。

max heaps size 26，这就是杠x mx和杠x mx对吧，friendc是我们设的old size是多少，new size是多少，这个如果要解释起来就没边了，这个牵扯到另外的内容。

也是一道巨难的面试题，不说了，use fencorcortestes使用什么样的日期格式啊等等。

这就是java进程的一些简单的信息，通过jinfer这个命令完全可以拿到两个命令了，到现在为止，一个叫什么，一个叫gp，一个叫j inf，好。

系列 2：P14：马士兵老师JVM调优：14.用jstat定位JVM问题 - Java视频学堂 - BV1Hy4y1t7Bo

这是第一点，只是这样，只是产生浮动垃圾，跟他们分析过，这无所谓，但是与此同时，我们黑色的标记里头增加了一个引用，又指向它了，那么这时候你想象一下，由于这哥们儿是黑色的，表示已经标记完。

而且成员变量都标记完了，我垃圾回收器县城回来继续运行的时候，也不会再重新标记他的孩子，所以这个d就被我们漏掉了，被我们漏掉，被垃圾回收器漏掉，有一个严重后果，垃圾归宿就会认为这哥们儿不是垃圾。

这哥们是垃圾，这不是垃圾，但是这哥们儿是垃圾，就会被他干掉，就会产生严重的问题，看你们跟他讨论是央企国企的问题呢，啊这块还能跟得上吗，就是总而言之就是灰色的引用消失了，黑色的引用诞生了，good。

懵了对，一般情况下这种可能会被蒙掉，这不出大问题了，对没错，这里就出大问题啊，我们稍微再捋一下，由于算法确实比较难，但是我觉得算法这东西呢你只要捋捋明白一遍啊，你这辈子就捋明白一遍，你放心，他不变。

好大家看这个我们再看一遍，本来正常的情况下，作为一个那个呃正在内存里头运行的对象数来说，a的成员变量指向b，b的成员变量指向d，这个能不能理解，没问题吧，就是a是什么呢，这个是一个黑色对象。

黑色对象的意思是我自己标完了，而且我的孩子们也标完了，我的孩子只有一个是b，我已经标完了，这哥们儿是一个不不是垃圾啊，接下来，运行过程之中，如果壁纸向d的已经消失了，那这个时候d就捋不到了。

捋不到没有关系，捋你做站在垃圾回收器的角度啊，站在垃圾回收器的角度，本来呢我是能够捋到这个地，把它当成不是垃圾，ok正常正常的往这儿走，正在正在正在呃标的过程之中，然后呢它消失了，它消失了，没有关系。

就是产生了一个浮动垃圾而已，下次我在旅的过程之中，我就会把它给清掉了，因为我从a指向b，我发现b没有了，那剩下的这个d肯定会被我干掉，这个完全没问题，但是呢由于b指向d消失之后，与此同时发生了一件事儿。

发生一件什么事呢，就是a指向d的引用增加了一个，那么这时候你想一下，站在垃圾回收期的角度，站在垃圾回收器的角度，同学们老师讲一下，在垃圾回收器的角度，b指向地影消失，我肯定是找不着这d了，这是肯定的。

虽然a能够捋着找到d，可是a已经被我标成黑的了，大哥黑的啥意思，就是这哥们儿的孩子们，我都已经标完了，我为什么要重新标一遍，我不会重新标一遍呢，所以这个d我我我找不着他了，我找不着他，就会把它当成垃圾。

这会儿大家能能理解了吧，啊对吧，所以这个是并发标记的时候一定会产生的问题，那后面会有一大堆的问题，是怎么解决这个问题的呢，怎么解决这个问题呢，解决这个问题呢有两大方式，第一种就是cms的解决方案。

它叫做incremental update，第二种g one的解决方案叫sa tb，叫snapchat，the beginning，好cbs解决方案叫incremental update，还讲了。

要不然算法就讲到这儿，我们我们聊点实战吧，我给你讲完这个算法，主要cms了超级复杂，什么场景会出现这种我比大哥嗯，所有的并发的垃圾回收器都会产生这种漏标啊，包括go语言的，包括java语言。

最新的这些垃圾回收器都会产生，ok把这个把这个讲完啊，把这个讲完好吧，我们我们讲完这个cm解决方叫increment update，input meal update呢，那个这个解决方案呢其实非常简单。

他就是把这个a给你变成灰色就行了，就这么简单，当有一个新的引用，你的成员变量指向一个新引用的时候，他二话不说就把你直接把你这个a给你变成灰色，让你来了之后重新再扫一遍，能听懂吧。

唉就是简直就就就这么简单，但是这里面隐藏着巨大的bug，o有同学我看有同学说了，说什么那个rberry啊，那个还有什么那个读屏障，写屏障呃，那是具体时间的手段的问题，这种呢一般是写屏障，但这个就算了啊。

先不给你扩展这些概念了，概念太多，小白就直接蒙了，先不扩展，这个我们先用图来理解好吧，所以你只要把这个颜色给它换成灰色，那么你垃圾回收器再回来的时候发现诶这哥们儿是个灰色的。

那我当然要扫描一下他的孩子们，所以这个d又被我们重新标记到了，very good，解决，这块儿还能跟上，能跟上的扣，一不能跟上扣二，啊不能跟上那么多，好，没有听懂这块儿呢，不着急不急啊。

这里面隐藏着巨大的bug，注意看我靠，这个要解释起来真的是太累了，来呃由于我们是多线程的垃圾回收c m s解决方案，有非常隐蔽的问题，叫做并发标记，产生漏标，啥意思啊，你注意看啊。

我们有一个垃圾回收线程，在标a是黑色的，正在正在标a标完属性一了，已经标完了第一个属性了，大家还记得吗，我只要标完它有两个属性，我只要标完这俩属性，这哥们就变成黑的了，这哥们儿就变黑。

我们有一个垃圾回收线程，你妈妈标完了一个属性了，好暂停垃圾回收线程，县城嘛暂停另外一个垃圾回收线程，然后那个，另外一个垃圾回收线程啊，我们哦sorry。

就是呃呃第第二个右右轮进程把属性一指向一个白色对象，就这个属性一样指向一个白白色的对象，ok注意这是业务逻辑线程，刚才我们说了b指向d的引用，消失属性一指向白色引用，所以指向白色引用。

按照我们刚才的解决方案，是不是得把这个a变成灰色呀，大哥再来说一遍啊，这里面隐含的问题超级恶心，面试其实还没有遇到过，面试其实还没有遇到过，好吧，这遇到只能说明你走狗屎运，你要把这个问题跟面试官讲清楚。

面试官说50万，你来一定一定一定不会有问题啊，听我说再看一遍，有一个垃圾回收线程，大家知道我们现在正在标记，标到a只标了一半的时候，注意他这个时候是个灰色灰色对象，因为还没有标完，然后呢我只标完一了。

我还没有标完二呢，那这时候正好一指向了d了，一指向d之后，根据我们刚才的那个分析，就说这个对象一定是个灰色对象，应该下一次标记了，回来的时候他应该依然是个灰色才对。

可是m一线程就是我们的垃圾回收线程继续运行，注意站在m一的角度，一五已经被它给标完了，就剩二没标了，然后他把二标完了之后，直接就把它干成黑的了，那么你想想看，本来正常情况下你应该是个灰的呀，为什么呀。

因为你的e已经指向一个白色对象了，你应该是个灰的，正好打个时间差，你又变成黑的了，这块儿能能理解吗，还能跟上啊，枷锁就不行了，每个对象加锁，你不累死了，大哥，结果就会发生什么结果就会发生。

当我们垃圾回收线程再来回来的时候，完蛋这个对象已经是黑的，它就不重新扫描，你一指向的这个d依然找不着，白黑灰加黑，所以你们知道来看一遍动画吧，来看一遍b指向敌的已经消失了，还是原来那个问题。

a的1a一指向d，然后m一的垃圾回收线程正在标记指标完一，然后a一指向d，按照我们刚才的说法，a应该变成灰色，m一线程继续运行，把二标完了之后，直接把它变成黑的了，注意一已经变了，二没变，完蛋还是错表。

所以你知道cms模玩的cm叫做remark阶段，从头扫描一遍，very good，哈哈，这个sw时间超级长，当然cms还有其他的问题，cms一旦产生碎片化，1。7。4之前。

单线程把所有的old区全干一遍，之后，多线程把所有old的区全干一遍，你就想一个天安门广场那么大的地方产生了碎片化，有一个风烛残年的老太太拿着小扫帚慢慢一个格一个格的慢慢扫，那种是一种什么感觉。

死菜死的心都有了，所以在我们真正的生产历史上，产生s t w时间最长的反而不是p s p o，反而不是cereal，居然是号称能够解决sw的cms，由于cms的巨大的bug的存在。

所以cms不是任何一个垃圾回收器的默认，那就会入侵，sorry，不是任何一个jdk版本都默认了，就会入侵，1。8，默认p s p o一点九，默认直接g one，没有cs cms什么事。

我个人永远建议在你们生产环境之中，如果掌握住g one，尽量用g one，g one调有简单，参数少，不容易出错，虽然它的整体的运行效率略偏低一点点，因为它里面用到了读屏障，写屏障。

但是这点损失跟你得到的收益相比要高得多，老师今天讲这段了，1。8，g one已经比较稳定了，完全没问题，很多人已经在用，放心你放心用就是了，好吧，你这dc你还用不上呢，好听我说呃。

今儿我们就技术就聊到这儿吧，行吧，我明天啊就给大家讲什么呢，给大家讲实战实战，就这vm调优实战到底啥样，我大概每天都会收到一些在实际工作场景之中遇到了什么样的，什么样什么样的问题发给。

然后大多数呢其实都太简单了，都都不好给大家拿出来，在你们的简历上，只要你写上我有过jvm调优的实战经验，大哥知道这东西值多少钱吗，少说3000，每个月，明天跟着老师走，让你搞定。

实战经验呢也不太容易能够说完完全全的罩得住，因为你实战经验的时候，面试官一定会问你，你实战能遇到什么情况啊，到底是怎么样子的呢，我呢大概在我们的给vip里头呢，其实是大概干了十几个20个左右的实战场景。

你挑一个用就行了好吧，就实战场景大概有20个，明天我们讲吧，嗯案例的汇总大概有20个左右的，你挑挑着用啊，然后像呃各种参数怎么调啊，就是jvm呢一共有我我我我今天开一开一点点时间可以吗。

今天开一点点时间，你们你们你们还能听吗，对这个上完课再发，是的嗯，好看一点点时间，好大家听我说啊，作为java来说，克里对java来说，当我们敲java的时候，就已经出现一java虚拟机了。

只要你敲一个java放心，java虚拟机一定已经启动了，而且结束了，java虚拟机调优叫做调参数，参数有好多好多好多种，在呃正常的情况下呢，大家看这里啊，就这种参数，凡是以横杠开头的字体有点小。

能看清吗，这个字体是怎么调的，稍微稍微稍微调大一些，16，a2 ，这样吧，我什么都不管啊，你看啊，它默认的情况下会以横杠开头的这些个参数，这些参数是什么东西，这些参数呢叫做标准参数。

注意在java里面除了标准参数之外，还有一个著名的非标准参数，在这叫杠x nonstandard options，叫非标参数，也就是说只要你这么敲的时候加了杠x在这好，这里显示的就叫非标准参数。

有同学可能会说，老师看上去没多少标准参数，加非标准参数几十个而已，但是完蛋我要告诉你，真正的需要你调优设置的参数是以java杠x x开头的，而且还没有成熟的文档，而这时候咋办呢。

一般我们用这个参数来把它全部打印出来，叫print flags final，好，这个到底有多少呢，你加一个more吧，让它分页来给大家看一眼到底有多少回城，一页两页，三页，四页，五页，六页，几页，八页。

五页，十页，11 12 13 14 15 16 17 18 19 20。

好了不玩了，那天来没头了，如果要计算一下的话。

那是wc杠l728 行，大概730左右吧，b m为什么调优为什么值钱，为什么之前想明白了吗，700个参数慢慢调嘛，不过作为老师这么体贴的男人，你就想了，常用的全给你列完，放心。

老师给你列的这个你已经够了，g one加上常用的十几个不到22222 20个左右够了，放心好吧，cm 20个左右够了，cao那就更少了，日志怎么设，日志怎么读，咱们明天说，一到这个时候就感觉到放落锅嗯。

我看有人问问vip啊，本来我是想明天讲给大家听的，但是腾讯今天刚给我们通知，我就我就我就直接告诉你，腾讯刚给我们通知，就我们课呢，我们课啊现在是腾讯课堂排名number one的课程。

然后呢已经遭遭忌受度很长时间，现在要拆分，我们可有课程内容太多了，我们大概每个课时是五块钱到七块钱，这么这么这么一个这么一个水平，知道吧，呃人家大多数的课程呢是20块钱到30块钱，每个课时每个小时。

所以我们课呢太便宜，同学说你们不能这么玩，你还这么玩吧，别人还干不干，比我们涨价就这么回事儿，呃课程比较复杂啊，我就算给大家聊点广告，我告诉你也是干活，你这人你这人听就是了，作为我们来说呢。

嗯一会大概要抽奖啊，其实跟技术相比，抽奖的小case啊，作为我们来说呢，我觉得啊就是这个课我在我给你介绍之前，第一个呢你可以去问小姐姐，随便哪个小姐姐问我们今天有优惠，如果今天有异象，别犹豫。

明天就涨价，就是这么回事儿，没办法啊，腾讯已经比我们好长时间，实在扛不住了，捡便宜，就今天如果说不着急，那你就等明天稍微贵点，就贵点好看，这里我就因为氪牛逼不牛逼，看效果有一个药好不好使，看效果。

这是我们大概呃总结出来的比较典型的这种这种就业。

就是学我们课之后的一个一个一个一个达到的效果吧。

嗯你们你们呢也可以找到这个网址，慢慢自己自己看去啊，这里面所有的案例呢全是支持被调，他们也在也也也在那个那个那个那个呃群里啊，支持被调，这哥们就是疫情期间离职一个月，是不是目前离职一个月了。

然后呢回来之后入一个月，一个月涨了4000块钱，有同学说老师不高啊，看时间一个月而已，这个是23岁的一小会儿，三个月学习涨了11k他原来14滴滴给offer 25，可以吧。

3月我就觉得一个牛逼的学习应该是效率要高，掌心要快，这才是牛逼的，因为我会用最关键最关键的就是老师能够告诉你们一点，你呀就带着人来，傻瓜式的老师，让你学个啥，你给我学个啥，老师让你背过啥。

你给我背过啥就行了，其他你什么都不用管，所有剩余的一切交给了，看这里文凭文凭不是个事儿，我要看一个，我要给你看看那个专科的那个那个那个那个那个那个拿的薪水，吓死你，这是没好好学啊，这哥们儿是没好好学。

三个月涨涨了8k，每每每每个月涨8k，今天跟人如果聊聊，同时被辞退，拿了6k，我这个拿20k不过分吧，凭什么涨了8k啊，正好把那8k给盖了，肯定好好学才行啊，我都没好好学，重点来这。

就是你躺着听就完了啊，辞职一天面试之后，offer形式上800，这哥们就辞了一天，上周辞职，昨天面试，今天收到一个offer，可以，收获两个offer，不知道怎么选，阿里p7 ，民营专科两周拿了五个月。

分民营专科啊，他这个专科还特别烂，我不知道大家有没有发现，就是在我们的在我们的呃截图里头呢，会有大量的老师的指导，就这也是我们服务的核心之一，就是一对一的辅导，这会儿是绝对给你送进去。

有些同学想进大厂保进的，有感兴趣的吗，保进，今天报名，但是价格上了，如果是按咱们现在的这个价格，就是还不能保你，但是你想保金呢，多交点钱，为什么，因为有一大厂的哥们儿跟我说了，说你能不能让我带几个徒弟。

我保他进大厂，就是大厂的，大概是阿里p7 到p8 的水平的，如果你没到这个水平，推荐一两个，当然要经过他面试，他觉得可以能带得动就可以，然后这个是入学半个月，年薪涨了5万，咱们这全部支持废掉假一罚十。

就说我们科为什么牛逼，时间短，见效快好吧，感冒了吗，吃个药让你搞定，没人跟钱有仇吧，好但是容能容能容许我简单介绍介绍我们课程为什么这么牛逼吗。

好简单说一下好吧，第一，课程内容好好听。

但是我希望要想报名，抓紧今天晚上的机会，12点过，腾讯就要求我们涨价，我们的整个课程我简单先给你介绍一下，叫做m个知识点加n个项目，我相信一点就是一定是知识点加项目，知识点加项目才能把整个全拿到。

有好多课就讲知识点，那不行，我今天给大家讲的内容，只是我jvm优化案例时，就是这位m按案例实战化指导中的一小部分，只是这其中的，就是第六节的理论化的内容，我们还没有聊实战。

实际上明天呢我简单跟你们聊实战的内容哈，就是案例中的一小组，整个整个这整个支点中一小个，除了这之外啊，就是我们还有n个项目，别的项目也是非常的给力，我们有两大王牌项目，第一档呢就叫做网约车的项目。

这个是什么呢，这个是一个原来你天天写c r u d国企啊，传统企天天玩c r u d，我怎么能跳到互联网呢，一个项目让你进来就是效率高，这里面主要的落地的东西叫spring cloud。

分布式微服务的设计与实现，而且这个讲法和其他的完全不一样，这讲法的这这这这这课程的讲法是这么来讲的，这大家可以去拿白皮书吧，拿白皮书会更好一些，看我的白皮书有没有啊，给大家打开一下，白皮书白皮书。

稍等我我我我我我来打开我的，白皮书啊，嗯嗯，呃这里面对面先说啊，就是说每一个每一个项目都有都有对应的白皮书，你们都可以去要嗯，作为我们飞机出行这个项目来说，我们先说讲讲课是谁，阿里的曹曹老师。

原来阿里的p6 ，其实他在升p7 的时候被我被我给拉过来了啊，你就你就你就别升p7 了，踏踏实实给给咱们同学们讲课吧，好这项目呢实际当中运行的运行了很长时间在线上，然后那个，就是非常真实的。

就不是那种demo级的，千万不要认为是demo级项目，再一个呢就像我们讲法也不太一样，想法完全就是采用了面向市场的讲法，面向市场讲法什么样的呃，原来只讲技术实现，现在是从整个项目立项开始。

从立项开始到人员配置到开发模式，到如何去开项目启动会到需求怎么评审，到设计到下架构的设计，详细的设计工程的设计，db的设计，然后才将编码，而编码所有代码都会给到大家。

还有一个每一个讲到的用到的这种分布式的模块，基本上原理源码全讲到位，呃我讲课的深度你们应该也见过，我还没给没给你讲到那个hosport源码呢，其实这么说，整个所有的培训节讲我们这么深的，没有1万测试。

怎么测试部署怎么部署，最后面试不知道怎么说怎么办，曹老师自己去面试，把场景录下来发给你，所以我们说啊，你不用其他什么都不用，带过来之后老师告诉你学学什么，学这个，你学这个学那个学那个，学完之后。

所有剩余的全交给我们，刚才有同学不是担心说那个大专行不行吗，莫急，这是我们一个原来学生的，他的简历，大专年龄还比较大了，唉这哥们儿32岁了，大专生，27岁，从运维转过来的，学完我们课程之后。

五条注意简历都是经过我们严格批改的，就是一对一的服务，帮你来批这个简历照，你该怎么写，这个年龄的该怎么玩，那个年龄的该怎么玩，你这种经历的该怎么写，那种经历的该怎么写，有一些能够把demo项目写进去的。

有一些不能把demo项目写进去的，还有这些东西全部全部教你，就五条，你自己看一眼，这就是牛逼的写法，跟你的项目跟你的那种那种那种简历一定不一样啊，这哥们儿是阿里四次面试就大专生，当然他没通过阿里。

但是他结结果并不差，他是在融3600360 60_{70万年薪，我同学说我为什么不确定，因为它是15x35+9000股股票，知道吧，所以有这个股票的在最后算的结果大概是60}70万年薪，30岁数不大。

比好多20多岁的大，比40多岁的小，但是这么一个东西，这项目学完可以写简历吗，中小厂随便写，大厂用学到的技术包装原来简历，莫及这方面，还是那句话，交给老师就行了，你不用考虑这些事儿，你唯一要干的事儿。

我让你学的东西。

系列 2：P15：马士兵老师JVM调优：15.用jmap导出内存转储文件 - Java视频学堂 - BV1Hy4y1t7Bo

教大家在工业环境里头用比较先进的工具，好吧。杀戮苍重啥意思？呃，现在还没听懂啥意思是吧？好，我们可以继续了吗？来可以继续的给老师扣个一嗯。😊，嗯。

好，看这里我们来聊下面的命令。一般来说，像这种东西呢，我肯定会给大家总结出来啊。嗯。Yeah。嗯。来看这里，我们来聊下一个命令，这个命令叫什么呢？这个命令叫Jt。

嗯。😊，Yeah。推边去。呃。这个命令呢叫jat，这个命令是非常有用的一个命令。Jtjava的对战，把java对战的信息全列出来。1958飞如说。

好。由于他的命令非常的长。clere，我重新来一遍。Jt1958。more非常长，我一点点裂给你看。

回说。

他这里面列的是什么呢？列出来的是当前我这个进程里头到底有哪些个县城。

每个县城的名字是什么？它的编号是什么？它的优先级是什么？它的状态是什么？看这是attach listener，这是是那个我们整个这个程序自带的那个attach的那个现程。

第二个呢是tol1杠thread50，这明显是现成池里面的名字是吧？编号是多少？那么它的状态是什么呢？它的状态叫time waiting，这什么意思？它正在等待某把锁。

pu one thread49又是一个。如果你往后读，一定还会有p one thread48、47、46、45。总而言之，一大堆的线程。它会把每个县城里面线成名字线成状态，线程优先级。

以及这个现城的调用的里边的tack stack trace。

县城调用的这个级别全都给你列出来。就是这个这个线城里面正在运行的是哪个方法，哪个。然后这个方法调用了哪个方法，这个方法又调用了哪个方法，A调了B，B调了CC调了D啊，最后是哪个方法在最头上。

th run调用了这个调用了这个调用了这个调用了这个一直调到un save park方法。而这个pa大家都知道。它是一个阻塞线程停止了，它为什么停止？是因为它wa了一个。

锁here这个锁的编号0X什么什么9999CB8。这块还能跟上吗？同学们。能跟上的给老师扣1。嗯，可以是吧，good嗯，小左右你还能跟上吗？双井军嗯，不错。那么大家你想一下。

这个命令既然能够把每个县城的名字，每个县城的这种。状态每个县城是不是正在所等待等等成以列出来。那这个命令有什么用呢？听我说。

对，这命令的作用呢。第一个查死索。

但是我们程序现在没有思索啊。第一个查死锁。第二个，这个命令还能查什么呢？其实能查哪个县城占的CPU比较高，我一会儿给你演示，不着急。所以这是一个非常有用的命令。

在面试中经常会问到有一个问题叫假如你们家系统CPU突然飙高，你该怎么排查，这是经常面试官会问的。排查方法是什么？这 stack命令是你第一个要考虑到的。好，大家看这里讲到这儿呢。

我我想稍微扩展一点点小小的知识。同学们啊，我不知道大家有没有读过。阿里的它的命名规范，我不知道大家有没有读过，我把它调出来，让大家看看。

阿里的命名规范。

S out the books。这个里面。嗯。呃。阿里的命名规范。Here。

哇。

好，看这里。哎，你倒是拖过来啊。嗯，这个是阿里的阿里的代码的规范的第三版呃，sorry sorry，不是第三版，11。1。5版，除了出了几册了，这个叫华山版，它每次就一名的最新的好像泰山版。

我们不管它叫什么，我们来看一眼它的第六部分的要求，并发处理。在并发处理里面呢，它说创建县城或者县城池的时候，请指定具有意义的线程名称。

所以同学们，你们想想看，小伙伴们，刚才我写的J stack里面，你看像这种现成的名称，这合适吗？

考虑一下为什么阿里要求必须得具备有意义的签程名称。

松山版出来了是吧嗯。为什么？就是你一看这个名称，你应该知道你这个线程主要的工作是什么。假如你定位是这个线程出了问题，它主要在消耗CPU那么它的业务逻辑是什么？你看这种名字你能看得出来吗？你看不出来。

所以你应该。在你起线程值的时候，定义线程池里面的每一个线程的名称。那现在问题又来了，你们知道现程池的名称，现成的名称怎么定义吗？必须自定义threread factory，这个有点远了。

这再说吧，我们今天毕竟。对，因因为你们什么都不知道。算了，我们我们还是聚焦我们的主页。我们今天主要是干嘛？主要是定位问题的啊。😊，呃，我刚刚交了交了这么几个命令了。第一个呢叫JPS，第二个叫JNfer。

😊，第三个呢叫J stack。好，还有一个很重要的命令叫jam。关于Jm，我一会儿讲给大家听。这个命令呢是呃其他的自自自自动化的自动化的这种这种程序，不能够完全替代这个命令比较重要。我一会儿讲给大家听。

那么还有一个命令呢叫jastate，我不想讲了。因为这东西呢很少用，他给的数据非常的难看，不想用。好，到现在为止，我呢想教大家呢在我们实战环境实战之中，也是我们的小伙伴，也是很多人在生产环境中用到的。

自动化的工具叫asses。在在这儿啊在介绍阿之前，我想先介绍几个大家喜闻乐见的，大家更愿意看到的这种工具。大家看这里啊。

呃，你呢？

如果你安装了java。你应该在你的java的安装目录目录下面，我这是C program filesjava JDK的1。8。0BIN目录，你会找到JDK自带的一堆命令。比方说app viewer等等啊。

JAB啊，java点EXE也在这儿。我们刚刚执行的像是像像像像像是什么Jinfer啊，Jm呀，好，全在这儿。这里面有一个大家喜闻乐见的，有两个工具啊，这里是jat，对吧？其实我们执行的就是这个命令。

这些全是java自带的。😊，大家喜欢乐见的有两个工具，第一个呢叫J console，就是这个。G console。当我们双击它可以运行，它运行起来之后，你发现它是一个图形界面，哇，太帅了，对吧？

谁不喜欢图形界面呢？命令行还得记多难呀？好，这是第一个。第二个呢，比Jconl更进一步的是另外一个图形界面的工具。这个图形界面工具叫J V VM双击运行单。好，大家看这里，这里呢也是一个图形界面。

但这个图形界面呢实际上比Jcon呃用起来更方便，更好使。而且这个图形界面一旦启动之后，你会发现它会自动的找到你当前系统里面有哪些个运行的java进程。我这里有goland，有idea，有那个vi VM。

它自己它自身。然后呢，你随便比方说我点开一个呃java的进程，然后你就可以观察它里面的内容。嗯，哪些参数给你列出来，对吧？系统属性哪些全给你列出来，就是这infr的命令用到的东西嘛？

然后你可以对进行动态监视，嗯，用了哪些内存了，内存的多少用了哪些CPU了。😊，你还可以观察它到底有哪些个县城，每个县城现在现在正在消耗的这种呃呃呃呃时时间量啊，哪个那哪个最多。

我们还可以进行各种各样的抽样。好，听我说。😊。

我相信绝大多数人都喜欢用这样的工具，没有人喜欢用命令行，对吧？没错，这是免费的嗯。

不我讲到这还能跟上吗？还能跟上吗？嗯，我刚才又讲了两个，其实我有讲了两个工具。第一工具叫jacon。我看刚才有同学就敲了啊，第二个呢叫做J呃vibM。😊，有东西肉老师，那你为什么不讲他？

听我说比这更好用的，还有，比如说japrofilr，这个是收费的，我不想讲的。你们家呃你你你你直收费还挺贵的。呃，你们公司如果说有钱土豪，那你可以去用它，没关系。好，听我说。

我下面要讲的这个呢叫做命令行界面，而不是图形界面。现在的问题就出来了，就是说一般的情况下，我们定位1个GVM的时候，可以用图形界面，可以用非常土的命令行界面。那么生产环境用哪个呢？我告诉你。

你跟面试官说说，我是用图形界面的某种工具把问题给定位出来的。面试官基本上就一种反应，一个大嘴巴子抽上来。该干嘛干嘛去嗯。ok。为什么为什么会这样？同学们，你们好好看，好好听。Yeah。嗯。

我知道网上有很多讲那个图形界面的，讲MAT的，讲Jhap的啊，讲各种各样图形界面的工具怎么进行分析的。我告诉你，你在面试的时候这么说，基本全完蛋。所以你不要不要不要不要这么说，我教你怎么说，同学们。

你们想想看一个有生产环境里面有多少人的生产环境。linux的程序，它还自带图形界面的，有吗？😊，自带图形的有吗？没有。服务器程序谁没事，还装一个图形的东西，图形的内裤没有有同学说老师。

我们不是不是可远程连它吗？没错，你说的非常对，而且我文档里还给你总结了，我告诉你各种各样的工具都可以进行远程连接。😊，但是有没有人允许？在你的服务器端开好多端口。给某个用户开权限，让你进行远程连接。

如果说你可以，那咱就咱就别说了啊，你你做的东西就是一个小屁项目，没见过大玩意儿，属于没见过世面的。对，小公司随便玩。当然我讲到这儿。你应该就明白了。正常的情况下呢，我们尽量的在服务端直接使用命令号。

我刚才讲的这几个命令行是咱们的最终的。如果说你连个其他的命令行工具都不让安装，那也没关系，就是我刚才给你讲的这几个命令GPSJ stackJJinferJ map就够使了，已经够使了。我告诉你。好。

听我说。如果你跟面试官说说，我用的图形界面，你一定能要圆的过去。同学们在什么情况下可以用图形界面呀？我告诉你一个比较牛逼的说法，就是哎你可以这么说。😊，我们公司是集群化环境，知道吧？

我可以对某一台机器进行熔断，熔断完了之后，专门对这台机器进行分析。我们是高可用的。大家伙环境都一样的。好，我对这台机器进行分析，先对它进行熔断。熔断完了之后，OK对它进行分析。分析完了之后定位出来。

大家伙再进行修改。😊，曜びは。你既然已经说出来，你是干过分布式微服务的环境的。第二个呢，你了解熔断的概念。第31个呢，你知道啊不能在服务器上装图形图形界面，你一句话就带出来了，你水平。

立立马把你的格调给拔高了，停掉这台服务器对其他服务器不产生影响。好。我告诉你，还有一种更牛逼的说法。更牛逼的说法是。资深点的面容官会问你，那我的大流量过来了才会产生问题。我大流量没过来的时候。

它不产生问题。好，你这个时候怎么玩？😡，还有一种叫TCBd。直接把每个流量都复制一份，复制到我的备用调试服务器上，我就分析这台。这块你能听懂就听懂，听不懂就算了。呃，spring说。

然后问你熔断这台机器怎么怎么熔断？😡，我们另外的课程是的，微分布式微服务，怎么熔断？很简单。这就一下就把你逼格带高了。呃，如果搞不定，采用另外的方式，你说我是在还有一种说法认真听。还有一种说法认定。

就是我是在我们上线之前，我机器还没有上线，我上线之前进行压测的时候。用的图形界面，这个完全可以。呃，这几种说法大家记下来了吗？嗯。好，我们可以继续吗？根据这位老师扣一嗯。哦。好，我们继续啊。呃。

下面我们来聊，估计他已经死了，我得重新起一遍。我们来聊呢优秀的阿里的开源的工具，一个基于命令行的，它叫做asses。再家看这里，我先把这个小程序给起来，然后我教大家呢下一个命令。

这个命令呢实际上你需要下载和安装一个工具。这个工具呢就是著名的ass叫阿尔萨斯。下载解压解压完了之后呢，大概是这样子的，最新的版本就3。1。7，比我这个新没关系，你用最新的版本就可以。CDA点。

在这儿我不太想讲说去哪儿下载，怎么下载，怎么解压这件事不想讲。

没问题吧。你说连这个都。需要老师讲给你听的话，你有点low。好，我不想讲，我就直接起。😊，java杠站它有好几种启动方式，我启动最最最常见的，然后那个。

保险的一种直接执行ja文件java杠站afs put点站回车。注意看这个时候offs已经启动了，它一旦启入之后，它就会发现在我们的系统里头运行着一个站外的进程，就是我们那个程序。

有毛病的那个它内部的编号是一在阿s内部的编号是一，它的进程号呢是2080。现在呢你要把ass attach上去，attach的意思就是挂上去，你现在这有一个程序，我直接把它挂上去，挂机挂上去。

然后观察它执行的过程，把asses挂上去，asses挂上去怎么挂敲个一就可以了，回车。好，当你看到这个界面的时候，达斯就已经进来了。关于asus怎么用asseus这件事儿，我教大家几个常见的命令。

好听我说。阿瑟斯命令有非常完善的文档，还是中文的。所以。以后大家在生产环境里头可以要求网管装这么一个简单的命令就可以，下载下来解压就就够了。嗯，看这里hel。

阿瑟斯最常见的命令有这么多。

命令非常多，功能极其强大。到现在为止，很多很多公司用的都是这个。

国外的那些开源的软件没人用，用的都是这个。

那好，我教大家几个常见的。

看这里第一个命令叫dashboard。但是不是仪表盘嘛？就是你你在那开车的时候，然后显示跟出来的仪表盘。

不是。注意它是模拟图形界面的。

咱们在我的呃微信里面跟刚才的同学交流的时候，他定位的时候用的就是这个。啊，Dashboard。dashboard会显示哪些信息，我相信大家一看一看就明白，拿拿大腿都能看明白。嗯，现城的ID号。

现城的名称属于哪个线程组，现成的状态，消耗CPU哪个县城正在消耗CPU。所以这里呢。那个面试题你就可以答了。一旦CPU开始飙高的时候，你怎么去定位它？一定有某个县城在狂战CPU某个或者某几个。

这道题我需要完善讲给大家听吗？想听完整的给老师扣个一，主要需要很多的基础知识，我怕讲我怕给你们讲了，你听不懂。好，听我说。好吧，能听懂就听，没有听懂的话呢。😊，很简单，就是你基础知识基础知识不够。

能听懂多少是多少，认真听定位一个。系统里面P这个CPU突然飙高。怎么定位？阿斯斯一把就能搞明白，就是哪个县城占的比较比较比较高，这是第一点。第二1点呢，听我说这个县城占的比较高。

一定开始分辨您老人家是业务县城。还是系统现成。当你看到这个线程是系统线程的时候，说明什么？你们想想。说明垃圾回收器在那忙忙碌碌干不了事儿，它占比比较高。好，如果是说业务线程，那啥也别说。

你看你业务现成的名字，赶紧查你业务现程里面有没有什么死循环呀这一类的问题，他在那里玩命的占CPU。不知道我说清楚没有。当然这里面有很多很多的细小的问题，比如它是GC的线程引起的CPU标高。

那它又分好多种情况。你老人家用的是哪种垃圾回收器？如果是PSPO是不是正常的产生的非常多，他已经忙不过来了。如果您用的是CMS是不是说我已经回收超了98，我都回收不过来了，整个呢基本上就全当掉了。

就开始报那种。非常特殊的一种错误。总而言之，言而总之，定位很容易找困难，就是找问题比较麻烦。好，看这里，这是dashboard的，你能观察到信息。当然下面还有很多的信息。你比如说整个堆大小是多少。

用了多少，总共多少，最大多少？现在的U戏值我们占到了多少呢？54。68%。一点区占了多少？sliver占了多少？tenure generation就是我们的old区又占多少？n非堆内存。

我的直接内存占了多少，codec占多少ok它全都给你列出来。如果你观察我们现在这个小程序，你会明显的发现，注意看就这里的usage，我们的堆内存它是在不断的再往上再往上增，知道吧？就是你观察时间长一点。

你就会发现它在不断往上增。好，这时候你基本上就能够定位出来说有东西在吃内存。这一点上基本就能确定啊。嗯。当然还有一些其他的信息了，比如说我操系统名字，操系统versionionjava的名字等等等等。

这些就比较简单了，这是我的第一个命令叫dashboard。😊。

对，有同学说top是不是可以对，top也可以啊，top命令也可以。top命令是系统的命令，并不是阿瑟斯命令。呃，linux本身呢就带了很多很多的命令，比方说top杠AP。

They are going be missing。

Up garbage。先行先先调透了。呃，你也在这个命令里面，你也能呃深切的观察到，就是它的内存都在不断增长。我们我们稍微等一点点小小的时间，我们观察它一下。这是系统的命令。

这是lininux系统的命令，CPU占多少？然后呢，我的内存占多少？刚才是2%多，现在已经是22%了。😊，继续观察。我们稍微等一下小会儿。还那一点点。时间一长，你会慢慢的观察到呢，它会粘得越来越多。

22。啊，不动了。

我这应该已经到头了，我觉得好像是已经到头了啊，没有。来再来一下。

22。4哎。

不长了。

别着急啊，一会儿就找你。

因为这个内存设的稍微大了一些，所以它动作稍微慢一些。嗯。

windows环境。大哥，你从哪你你哪只眼睛看出来这是windows环境啊？嗯。22。5，它在缓慢增长呗，我就不等他了。因为等他的话呢，时间耗的比较长。呃，总而言之，言而总之。

你用这些命令去观察它的时候，你就会定位到内存在不断的吃不断被吃掉。

嗯。我不会lininux啊，嗯不会lininux的话，那不会特别爽吗？

不会就学呗，怎么着，你还说出来很骄傲的样子，不会lininux，你想说明啥？现在呢你看已经是58点多了，刚才是44440多啊，总而言之言而总之，我们是可以通过命令不断的能够。

呃，知道他在不断的吃吃内存。好，看这里。

再看这里我刚才交了第一个命令，叫做dashboard。呃，现在呢我再教一点其他的命令。

嗯，比如说我们来看这个这个命令叫JVM。

这边。这个命令会显示什么内容呢？重新再执行一遍啊。敲的比较快，GVM回收。等同于Jinfer那个命令，他会把整个的我们这个进程的所有的详细的信息全都给你列出来。同样的啊，也是说你你你你的参数是什么？

the class pass是什么？librry pass是什么？最重要的是呢，它能给你列这个玩意儿叫garbage collectors。不是有同学一直不不知道我自己的系统上线运行了。

那么他用的哪种垃圾回收器呢？你不是不知道吗？阿s装上一个命令，搞定他的命，他的垃圾回收器，像我们这个的垃圾回收器是什么呀？gbyic letterss年轻的co比。老年代算法这里说的是算法。

算法是什么呢？叫mark swift compact。下面是memory呃manager，下面是memory是是是是是多少，然后下面一堆的呃呃不太不太重要的一些信息。总而言之，言而总之。

这个东西呢就相当于J infer那个命令。这些命令相对用起来还相对呃比较简单一些。下面我我还我还教过大家一个命令叫jat，你还记得吗？那么如果你要用ass的话，它会达到比Jt更好的一个效果。

我们来看一眼。

这个命令是哪个呢？这命令叫做thread。threadread好，O就是就是他。

好的，看这里。thread回车。

thread围着之后呢，它会把这里面所有的线程全都给你列出来啊，然后包括CPU的使用，包括线程的名称，这个跟thisthis deck差不多。那有同学说老师他没有那个调用站的信息啊，没关系。

你如果怀疑这个线程，它的线程ID号是31，有问题怎么办？

Thread。跟线成号。

31。他会把这个31号线程。名称状态。

调用站。调用的站信息全部都给你列出来。所以这个是比Jt更好用更直观。除此之外，刚才我说，如果你要用Jt定位有没有死锁的话，你得去观察它现在正在等待哪个哪把锁有多少个线程，正在等待哪把锁，等待了多长时间。

然后你怀疑这里没有思索，再去找代码。但是如果你要用。阿瑟斯一个命令搞定，注意看。

Thread。help注意看，在thread后面可以跟参数，参数是什么呢？其中有一个参数叫杠B。刚B的意思叫fin the thread who is holding a lock that blocks the most number of threads来读一下。

看能不能看得懂。他说找到这个县城。他正在那持有一把锁。阻塞着大多数的线程，抢不到这把锁。而 find thread who is holding a lock that blocks the most number of threads。

Mmhmm。所以你在这里面找哪个县城，就是有没有死锁，一个命令搞定the red钢逼。当然我这没有啊，再跟你说一遍，这这个我们我们这儿我们这程序没有死锁。你要自己写一个思索程序，拿这个命令一把就试出来。

这比你拿肉眼找哪个刚才那个号是吧，0X什么什么要爽的多。不知道大家是不是感觉生活又美好了一些，有了阿之后，来能感觉到的给老师扣个一，感觉不到的给老师扣个。3。1415926开根号再开根号的值。

开个玩笑啊。五。😊，Ha。😊，好，我们继续。大听我说。下面我回过头来教另外的命令。另外的命令是什么呢？有一个著名的命令he尔。大家看这里。刚才我们我们我我们分析过啊，就是现在不断的吃内存。

刚才是22点多，现在是26点多了。

我已经知道问题之所在了。它在不断的吃内存，导致FGC。

永远回收不掉我想要回收不到我想要的那个空间。

那这时候怎么办呢？它就会不断的频繁的FGC频繁的FGC频繁的FDC那我一定得揪出来到底是谁在那里不停的占用我们的内存。

我再说一遍，由于我们的内存不断增长，并且回收不掉，所以才会频繁FGC。

听懂了吗？再强调一遍，再说一遍，因为这里面也是一道面试题，就是你遇到你的系统频繁FDC的时候，你该怎么定位？😊。

好。由于我们系统里头有人不断的吃内存，看到了吧？内存不断增长，并且我回收不掉，你会发现每一次回收回收掉的那点东西非常的少，几兆几十兆。我们是200兆的，回收就是回收到到现在为止的，一个回收个几兆的问题。

好，所以一定有东西在不断的赤我们的内存。

。

系列 2：P16：马士兵老师面试题：1.请解释一下对象创建过程？ - Java视频学堂 - BV1Hy4y1t7Bo

先说结论，当我们new一个对象的时候，分成两部分，第一部分呢叫new这个对象的时候，先申请空间，由于这个对象内部有一个成员变量小m当我申请完这个空间之后，这个小m的值是几，这小m的值是几。

记住虽然你看上去它的这个值啊是八，但是不好意思，当你刚刚弄出这个空间来的时候，这个值并不是八，这个值是一个默认值是零，这是在java里面为了安全这件事来，考虑到有同学指令重排，导致跟他说啥呢。

有同学可能会说了，老师这跟安全有关系，我给你解释一下背后深层的意思，好玩过c加加的小伙伴告诉我，当我在c加加里面new出一个对象来的时候，这个对象里面的成员变量，这个值是几。

比如说它有一个x这个x值是几，这是几十几啊，是空里扯淡呢，c加加对象，我说的是c加对象，记住这个x的值是一个遗留值，天尊霹雳人已死，是被人遗留下来的，好吧，这是一个遗留纸，什么叫遗留纸呢。

就是上一个程序也用过这块空间，它在这里面留下了一个纸，所以这个值呢是不知道的，是不了解的，是不清楚的，当你有了这个值之后，如果说呃你忘了给这个值-1个初始值，你比方说你本来想把这只变成零。

但是呢你忘了给它-0，这个值这个x值就说不定会是几，如果这正好是个指针的话，也就是说你说不定会返回到内存里面的那块空间，这叫不安全程序，很容易崩溃，本来那块空间不让你访问，结果你关机一下一访问。

不好意思，内存一出，内存访问不了内存指针类型错误攻击，你的程序就崩溃了，就蓝屏了，来这块儿能听明白的，老师扣个一，所以这就很危险，回忆刀了是吧嗯，想起来了对不对，所以java设计就不一样了。

java设计是这样的，当我们又出来个对象的时候，java给每种不同的类型都设了一个默认值，就是你先用默认值把原来那个遗留值给它覆盖了啊，印度类型是零，所有的数值类型都是零或者零点，所有的引用类型都是空。

所有的布尔类型都是false，总而言之，言而总之，在java里面都给他附了一个默认值，有这个默认值的存在，你就不会乱用你的值了，你就不可能访问到你不想访问的地方来，可以继续的给老师扣个一。

所以所以当我们列出来一个对象的时候，这个对象里面的成员变量它有一个默认值的存在，叫做零，那什么时候它才会变成八呢，只有在调用了构造方法之后，也就是说new对象首先给它来个默认值。

然后呢调用这个对象的构造方法，还记得我们另外一个对象会自动默认调用它的构造方法，对不对，good，只有调用完构造方法，他才会把这个值变成大，ok当我变成八之后，还需要做一件事。

t小t等于6t我这个小t是要是一个指针啊，我这个指针得找找着这对象啊，所以还需要干这么一件事儿，他需要建立关联，回想一下三步构成，第一步，申请空间，默认值怼上去，第二步构造方法调上去，第三步建立关联。

这块能get到的，老师扣一三步构成，有同学说导致这三部我们能看到吗，其实也是可以的，讨厌第三步，你想看到怎么看，这样来看t小t等于6t，跑一下run，拔掉之后呢，观察它生成的字节码。

view so bad code with declass library，呃，这个插件呢你可以自己去下载，你也可以用手by code，那个比较难看一些啊，你可以用这个插件来做这个插件。

叫j class library，走，你，他会帮我们观察到你的这个main方法会生成了哪些个，java所调用的这些个指令，指令集，这个东西呢相当于，这东西相当于什么呢。

呃这东西就相当于那个我们的汇编语言，java的汇编语言，同学们，你们看到这个a const，a a connow呢，这是由于内部类的存在才会有的，我先不管它，你会看到它有这么几步构成，第一步叫new。

第二步叫duplicate，第三步呢叫inbox special，第四步叫a store。

第五叫return，这个过程呢我在这里头都给大家画出来，汇编码是这样的，首先是new new是什么意思，申请空间new的意思就是申请空间，申请好空间之后，给它附一个默认值，只有调用这个的时候。

这条指令的时候，这条指令叫invoke调用special叫特殊调用，特殊调用的是哪个方法呢，是t的initialize方法，也就是构造方法，只有执行到这一步的时候，它才会变成八。

然后呢到期啊才会a store，a store的意思是建立关联，就是t和整个对象建立关联，再看一遍，当我们执行到这条汇编码new的时候，申请一块空间，但这个时候它的值是默认值是零，调用构造方法完成之后。

复制为八，a store建立关联，记住了吧，脑子给我记住，记不住的话，你第二题是答不出来的，就不给他干啥呢，我不想跟你解释那么多，我们抓主线吧，dug是在整个运行的占空间上，刚刚弄出来这个东西。

在上面复制一份，为什么，因为in vox special需要把这个东西弹出去，不费电话了啊，公开课不给你讲这么细了，太跟你讲这么细的话，很多人是跟不上，听我说听我说。

但是呢java对象有一个很好玩的东西，sorry，java的程序有一个很好玩的东西，呃解释这件事情好困难呐，莫急，我们给你解释，我就给你纵横捭阖的。

想起想起哪儿讲到哪儿好吧，我还得再打开一个ppt。

并不是高并发的啊。

稍等片刻啊，找一下，嗯，我那个我那个给你放在了哪个ppt上，主要是不给你打印的ppt吧，给你解释起来比较困难，讲一堂公开课，我容易吗，我。

是已经打开了吗，哈哈，是已经打开了吗，多线程与高并发。

你好好听，认真听啊，那个，这里面有个小小的问题，就是并发编程呢有就有这么几个特性，一个叫可见性，一个叫有序性，嗯因为美团的这个问题啊，它主要就是牵扯到了有序性的概念，这个有序呢相对来说比较恶心。

尝试讲啊，看你能不能理解，有序，我们尝试讲这个问题啊。

看看大家是不是能理解，好听好听，我说啊，呃我先问你问你这么一个问题，这个问题是说程序真的是按照顺序执行的吗，什么意思，比方说我写了两句话，呃，我们自己写程序的时候说x等于x加加。

这两个一定是按照顺序执行的吗，然而并不是啊，这两个是这两个式啊，好这两个呢x等于一，y等于一定是按照顺序的吗，我告诉你为b仔细听我说，你看到的程序未必是按照顺序执行的，仔细听我讲啊，我再说一遍。

你看到的两个程序，虽然说这句话写在了上面，这句话写在下面，但是他未必先执行上面那句再执行下面这句，有同学说，老师啊，还有这件事情吗，是的，我给你开一个程序。

就这个小程序，看这里这小程序呢是一个很小很小的小程序，这个小程序一共有四个值，这块儿先说结论，绝对不是按顺序执行好，我们读完这个小程序，我们来运行一下，你就知道他为什么不是按照顺序顺序就行。

我先让他跑起来，避免一会儿出不了结果啊，看这里这小程序又干了一件事啊，干了一件什么事呢，我有四个值存在，这四个值分别叫做xy ab，最初始值全是零，所有的全是零四个零，然后我用一个for循环。

这for循环呢每一次循环我都起两个线程，这是第一个线程，这是第二个线程，第一个线程干这两句话，a等于一，x等于b，第二个线程干这两句话叫b等于一，y等于a，我们现在假设所有的程序全是按照顺序执行。

首先执行a等于一再执行x等b，这边呢一定是先执行b等于一再执行y等a好两个小程序，我讲到这儿，大体的语义大家看懂了吗，看明白的同学，老师扣个一，起码这块你应该看明白了，同学们你们琢磨一下啊。

我们如果说永远按照顺序执行的话，由于是两个线程互相之间有可能穿插交替执行，所以我们最终的执行的结果，他这四句话的执行顺序有各种各样的排列组合，什么样的排列组合呢，比如说啊一个程序先执行完a等于一。

x等于一，然后再执行b等于1y等a这是一种执行顺序，这种执行顺序我们来看一下a等于一，后面y等于a那y的值最后的结果一定是1x等于b，因为刚开始b等于零，所以x等于零，好这个推导过程很简单。

当然除了这种可能性之外，它还有一堆的可能性，我在ppt上呢给大家画出来了各种可能性，这种可能性啊，第一个可能性就是这种执行顺序，那么最后的结果是x等于零，y等于一，如果是下面这种顺序。

最后的结果是x等于一，y等于零，如果是这种顺序是x等于一，y等于一，如果是这种顺序都是x等于一，y等于一啊，这种的也是这种的，也是听我说你所有的排列组合排列完成之后，你绝对不会发现x等于零。

y等于零的情况啊，这个推导过程大家是不是能理解了，就是总而言之，我们首先假设反证法，反正法我们是按顺序执行的，按顺序执行来说，它最后的结果绝对不可能出现的结果是什么呢，就是这种情形，i等x等于零。

y等于零，好这块能get到的，给老师扣一，因为这会牵扯的知识非常的多啊，所以你集中精力认真真的听，至少我打开你的整个知识的这种这种这种这种呃，面宽好吧，嗯把你的知识面给你打开，那好当你理解了这件事之后。

我们再来看这个执行的结果，刚才呢他就一直开始运行了，我们最后执行的结果，看看到了吗，a在我们循环到第669232次的时候，出现了x等于零，y等于零的情况，那是什么情况下才出现x等于零，y等于零啊。

什么情况下你会发现啊，根据排列组合，你会发现只有这一种情形，只有这种情形，什么情形呢，就是第一个线程先执行了x等于以后执行y等于，同时呢第二个线程先执行y等a后执行b等于一。

只有说这俩这俩哥们儿排在这俩哥们前面，知道吧，才会出现x等于零，y等于零，所以你会发现如果是这么来执行的话，这两个换顺序了吗，你看人家原来写的顺序是什么，a等于x等于b吗，这个明显跑前行了。

不仅这个跑前面去，与此同时，另外一个也得同时跑前面去，才会出现这种情况，所以我们从程序上就能够证明一点，cpu内部执行的指令也好啊，语句也好，他绝对有可能是换了顺序，我通常我们称之为叫乱序执行。

来这是结论，我擦这一段没听明白，大哥你还没听明白，没听明白就记结果吧，听明白的给我扣个一，没听明白再给我扣个二，我看看，一多二少，给那个二呢，我给一分钟解释时间，这个小程序很简单。

就是我们通过一小段证明，我们首先假设两两条语句是按照顺序执行，那么最终的结果一定不可能出现x等于零，y等于零，根据反证法最后的结果，我们出现了x等于y等于零，那么只能说明一点，x等于b跑a等于前面去。

y等于a跑b等于前面去，至于刚才的排列组合是一种数学上的东西，你听不懂就算了，大体的推导过程就行了，总而言之，言而总之，当你理解了这件事之后，先记得结论好吧，这里面细节很多，但是我想让你先记住结论。

总之一点，两条指令在cpu内部执行，可以换顺序，也就是说cpu内部是乱序执行，当然它有规则啊，叫乱序执行，一会儿我们聊规则，有时间的话我们聊规则，好嘞好，当我们理解了这件事情之后。

我们再来看第二道题。

看第二题。

系列 2：P17：马士兵老师面试题：2.加问DCL要不要加volatile问题？(指令重排) - Java视频学堂 - BV1Hy4y1t7Bo

整个的他的一个流转过程。S1S2为啥要来回倒腾？如果你不倒腾，你不就直接进老年代了。嗯。好。我讲到这之后呢，我们再翻回头来看这个mark word。注意这mic word里面我说了，记录了GC的信息。

DC信息呢实际上本质它记了两种。GC信息里面它记了两种GC信息，一种是正在回收过程之中，您老人家是哪个颜色的哈，记录了三色标记的信息，还记录了哪个信息啊，文带年龄。在这。三代年代的意思是说，回收一次。

这里原来是0000，回收一次加个一，回收一次0010，再回收一次0100。好，总而言之呃，sorry0011啊，再回收一次。总而言之呢，每经过一次的回收，它这里就加个一什么时候变成1111了。

再经过回收。不好意思，进入老年代。也就是说你看这个分散年龄的时候，这个分担年龄最大是多少？回大是多少？最大是。111等于15吧是吧，这是最大。好，默认值。在垃圾回收器是，PS加PO的情况下就是失5。

在垃圾回收器是CMS情况下，这个值是6。这是默认值。OK。好了。gar it嗯，有同学已经ga it了，那么其他同学有没有ga it的？😡，来。收到了给老师你嘎来的。嗯。呃，现在为止人能跟上是吧？嗯。

对，不错。

呃，我们再来看这个题，我们回答了几个了。三四标记干嘛呢？三次标记是用来做并发回收用的。解决并发回收中间的错标和漏标的问题。另外的问题啊。那个。啊，我们现在明白了第五个问题和第六个问题了。

对象的门分为两种直接和间接。第六个问题叫呃。战上和现成本地的这样的一个分配过程啊。OK我们现在还遗留的呢，实际上是第一个和第二个问题，以及第8个和第九个问题。

那么我们来来看这个我们先来看这个第八个问题吧。这个问题啊大家听我说啊，这问题呢。呃，我讲一遍。能理解就理解，理解不了也没有关系。😡，好像除了但某些特别变态大厂问这个问题之外，其他的一般不问。😊。

C加加这玩意儿，因为很同学不了解C加加。C加加的对象有一特殊的东西。C加加的对象有一个特殊的东西，这个东西叫vetutable。Where word word word。T table。叫虚表。

这个对象这个东西呢是装在对象内部，用来实现呃多态的啊叫vertable。由于有这个虚函数表的存在，所以每个CI加对象如果用它来代表java对象的话，它会个特别大个。虚函数表对远古的回忆。没错啊。

你要是上学的时候学过C讲，你就应该能想得起来。

所以这个东西呢，你知道有什么回事儿就成，好吧。😊，一般来讲啊。就是由由于有虚函数表的存在，所以C加加对象的大小要大于java的对象，能听懂吗？就是同样的东西，你用C加加来做的话。

这个对象大小要比java对象要大。所以呢。不用他。真正的里边呢是把那个虚函数表在java内部呢，是把它呃是是是放到了整个机制里面，并不是放到对象里面啊。OK所以呢一般我们不用CIA对象，而用什么呢？

叫OOPclass2元指针就什么意思？就是专门有一个数据结构，用代表我们的摘va对象。然后呢，把这个java对象所属的那个class对象单独给它拎出来。我们要找对应的虚函数的时候。

去哪儿找去这个class对象里面找，而不是记录在自己的内。嗯。OK这块呢能听懂就听，听不懂就不让他过。因为有些问题不是说我们所有问题全都答出来啊，也没有也没有这个必要嗯好。我们来看最后一个问题啊。

就这个要命的问题，这个问题是这样的，叫class实力，究竟是放在met area，还是黑，是放在方法区还是在堆？如果说我不跟你讲之前。你所有的回答应该都是这个叫方法区。class对象嘛。

我们说方法区里面装什么呀？方法区里面装的方法区嘛。装的不就是col的信息吗？以前是不是是不是这么认知的，没有题吧。😊，来，这块儿有没有问题？稍微有点基础的小伙伴们给我回答一下。

以前你们认知的就说class class的信息类的信息不就装在方法区吗？有时候方法区还会溢出，对不对？方法机不是放方法的吗？子龙，你那个你你已经我连续问了两个问题，我都注意到了。

但你你问的两个问题都是特别特别特别弱的问题。我希望你慢慢先补基础，补好基础之后再来问问题，否则你问的问题都不在点子上。😡，OK听我说。这里面有几个概念，我稍微给你们纠正一下。第一个概念呢叫做。永久区。

叫永久带啊，原来的原来的称呼。它叫做perman area。Permanent。Area。第二个呢叫原数据区叫matspace。哦，这两个东东。是同一个东西，这两个东西统称叫方法局。

方法区可以认为它是个接口，这是1。7的实现，叫永久带，这是1。8以后的实现，叫原数据区。再说一遍，这两个东西都叫方法区域，1。7之前叫永久带，1。8之后叫原数据区。好，这个概念听听懂了吗？把它记住。

所以以后我说方法区指的就是永久贷或者是原数据区。嗯。啊，大家理解这件事之后。自己听。拉s水力到底放在哪？g实力实际上是这么放的。由于在ht store里面使用了OOP class的2元模型。

所以你就会发现。啊。C加加的用来代表java的那个对象。他呢实际上是放在了方法区，是放在这儿的。而这里面有个指针。通过这个指针，才会找到我们的class对象。

而这个class真正的class对象放哪了呢？放在了我们队里面。为什么放在堆里面？因为我要用到反射。我反射的时候，如果还要去找C加加对象，太麻烦，我直接在我的堆里面就能找到我们的class对象。

再是再看一遍，我们扭出来的任何一个对象大O，这是大O对象。真正我们以前啊说你指向你的class在哪呢？你直接一个指针指过去。但是本质上的指针是这样的。首先指向一个C加加对象。CI对象里面又有个指针。

指向我们的java对象。C加加对象放在方法区java对象放在堆里面。这个能听懂就听。听不懂就算了，这两个呢稍微麻烦一些。好你。讲到这里为止。除了前面两个问题。第一个问题跟第二个问题，后面3456789。

我就全讲完了。原来编程的本质是指针，哎，懵了就蒙了啊。没关系啊，八九两个问题蒙就蒙，没有关系，放过嗯。1。8还有方法去吗？你怎么这么这么轴呢？我刚才说了半天，方法区是一个统称，1。8之前。

它的名字叫permanent area。1。8之后叫met space。你说一。8有没有方法区？方宝军是个逻辑上的概念。怎么这么这块还还有谁有问题了？有问题，我就给你打开原来的最早的。

最早的我们最最最原始最原始的。

他的出处在哪里？如果你想透彻理解Java虚拟机这件事。这个东西呢。当然你就不用读了，老师帮你读过了。这本这本书叫java in thespecation。完全需要设计虚拟机的人才会读这本书。

因为这本书叫做java虚拟机的实现规范。做java虚拟机的人，必须按照这个规范来。在这个规范里边。他详细的定义了说the structure of the Java machine。

你的ja machine呢。结构到底什么样？这其中呢。有几项。叫runtime的。d area其中有一项叫ve area。好。据我说没有什么permanent data，也没有什么met space。

只有一个叫法叫met area，叫方法区。好，方法区在1。7的时间叫permanent data，叫永久的啊，permanent。permanent generation叫永久带。那么在1。

8之后叫macspace叫原原数据区。能理解了，你看看这里面它的结构里面根本就没有任何的说什么。你这个这个永永久的原数据区的概念，因为这两个概念都是一个概念，叫ma areaia。

OK。嗯。好嘞好嘞嗯。呃，记住啊，别人没有人问你这个问题的时候。你就按照我们原来的回答，一个指针指过去就行了。只有有人问你这个问题，你才把这个图画给他。好，我们来聊最难的两个问题。讲到这儿来还能跟上。

那老师扣个一。

系列 2：P18：马士兵老师面试题：3.对象在内存中的储存布局 - Java视频学堂 - BV1Hy4y1t7Bo

你就挂在挂钩了，它是什么样的呢，分成两种情况，第一种情况是普通的对象，很简单的普通对象，第二种是数组，我们先看普通对象，大家听我说普通对象你就记住，背过就完了，这是面试的高频题，大厂很多都闻好。

普通对象呢分成四部分，记住背过，第一部分叫mark word，不好翻译，你就记住他叫mark word就行了，这部分呢是八个字节，第二部分叫class pointer，这部分是四个或者八个字节啊。

一般说开启压缩之后呢，它就是四个就行了，好吧，你就记住是四字节，这部分主要是什么呢，这部分主要是class pointer，是说我弄出来这个对象到底它指向是什么样的，class。

是属于哪个class的对象，比如说我们new的是xx，那么它指向的就是xx。class好，如果我用的是t，那么它指向的就是t一点class好，如果我指向的是object，如果我用的是object。

那么它指向的就是object的点class，然后叫实例数据，实例数据叫instant，这是什么意思，比如说我new了个t，它里边有个成员变量int age，好，这个age这个对象放哪，放这里。

instant data一个对象内部的数据成员变量，最后一个叫对齐，为了让我们的数据对的比较齐，装卸起来比较方便，比如说我们装货的时候用集装箱大小一样，我们装卸作为装货单元，卸货单元装起来就比较方便。

所以让他们对齐，把数据对齐，数据怎么对齐的，如果整个的对象的大小按字节数来说不能被八整除，比方说前面三个加起来12个字节能被八整除吗，不可以，那怎么办，后面补上补多少，补偿能被八整除为止，加个四。

从12放到16÷8÷2，ok先背过同学说，有同学可能会说，老师这东西我能看得到吗，你可以的，我先把这个图放你抓下来，然后我们对比着看，我们有一个普通对象的时候啊，它就是有这么几个好，大家看这里。

呃直接敲代码做实验好吧，我们定义一个自己的class private，std class，我们就叫t，小t小t等于，ut，然后我们六个这个t来之后，我们先看一眼这个t呢在内部到底是怎么布局的，怎么做呢。

通过这样的一个插件来做这样一个类库，这个类库的全称j o l，它全称叫做java object layout，java对象布局，那么这个类库是来源于哪，你百度1下，随便百度1下就知道。

我就在这里不展开了啊，不展开就是怎么把这类库给引入进来呃，怎么装到main里啊，就不展开这个这个这个玩意儿了，那么大家听我说啊，就这个类库呢是著名的open jdk旗下的一个类库，ok我们怎么用它。

用它这个类class layout，点二class instance class liu class的布局是吧，然后pass pass是解析的意思，instance是对象的意思，解析某个对象。

解析哪个对象呢，解析小t这个对象解细胞的结果呢，把它转成to principle，叫做转成可以打印的格式，然后把它打印出，到现在为止能跟上的，给老师扣一没问题吧，比较简单，好好看这里啊，ok ok。

我插播一个小问题，主要因为呢daydream白日梦，这哥们问的问题比较典型，他说为什么是八字节对齐啊，而不是什么64字节对齐，因为八字节是多少呢，是64位，我们的虚拟机来说啊，八字节是64个比特。

那我们虚拟机所说的64位，64位虚拟机是不是就是64位啊，一次性存取64位，对他来说是最方便的好吧，所以呢它是八字节，也就是64位对齐，而不是64个字节对齐，听明白这件事之后呢，我们来继续看这个问题。

t小d等于new tm把它打印出来，对照这个来看，跑下看我走，你，好了你仔细看他把这个t这个对象给你分析了出来，前面第零个数，后面四个从0~4，这四个字节是我们的对象，头叫object header。

从第四个字节往后又数四个字节，还是我们，ohater，刚才我说过mark word这部分一共有八个字节，所以这里代表的这里，这里就是mark word，这八个字节就是mark word，一个字节。

两个字节，三个字节，四个字节，这就是具体的那个零一的表示这些个唉，这里表示的就是mad，那么第二个部分就还记得吗，后面四个字节是class pointer是吧。

class pointer指向的是到底哪个类的对象，是那个那个那个那个类的指针好，就是它，所以这四个字节通过他这内部可以找到谁呢，找到t。class，好最后四个是什么，最后四个是lows。

就to the next of the loyment，下一个对象由于对齐的关系，所以这里头是丢失的，也就是补齐用的，所以来看一眼mark word，你看到了类型指针来pointer。

你也看到了实例数据呢，由于我们这个t没有a，所以呢你是那他看不到他的啊，然后对齐你也看到了好，当我讲完这小段之后呢，再来看美团问题里头的这个问题，看看大家是不是能答得出来了啊，好看这里我们对照这个。

我们把美团的问题贴在这儿，来告诉我美团问题，解到这个问题说object o等于new object，内存之中占多少个字节，这件事能答出来了吗，告诉我一下缓存行64g，那是缓存行，又不是对象。

缓存行跟跟java对象有什么关系吗，本身它是硬件级别的，想多了啊，ok ok好嘞，16 16啊，可以可以可以来我们试验一下吧，到底是不是16呢，其实确实是16，你拿大腿想一想也应该知道，不做这实验。

你们自己下去做，你想啊，我说过了，前面八个字节mark word是必须的，后面四个字节8+4，这四个字节class pointer是必须的，但是of vide内部有成员变量吗，没有，所以第三部分加零好。

最后一部分前面12不能被八整，不能被八整除怎么办，再补四个，所以一共是16个字节，那好了，讲到这儿，我再问大家一个问题，如果我在这里写int来告诉我这个对象多少个字节，哈哈好一下，看怎么还有说八字节的。

这怎么可能多少个字节啊，记住这个a是多少多少个字节啊，int类型四个字节，对不对，看这里前面八个字节mark word少不了，后面四个字节，class pointer少不了，所以前面12个字节是不变的。

下面呢是我们的instant data，也就是这部分实例数据，现在我们这个类里面有成员变量了，所以呢它的这个成员变量就装在我们对象里了，t。a对象默认值是零，ok所以这里头呢是实例数据就出来了。

整个加起来是六个，来再来一个，我在这里写in the b告诉我多少个字节，怎么还有说32的那大腿，琢磨琢磨前面12个必须的，a占四个，已经16个了，b又占四个，已经20个了，20个能被八整除吗，不能。

所以呢再补四个，看一下看一下，a占四个，b占四个，前面是20个，不能被八整除，再补四个，不累flag，老汉告诉我这个这个占多少个资金，这就有点难了，一个真的别聊啊，别瞎聊，看这里。

首先你要理解布尔类型占多少个字节，布尔类型在java内部只占一个字节，所以前面几个加起来八个，mark word，四个class pointer，12个，a a占四个，b站四个，所以加起来是20个。

布尔类型占一个字节记住，所以是21个，补三个，24个，再来一男的，这个就真的有点难了，string，等于hello来同学们这个对象占多少个字节，好好想认真想，有时候24有说32的美团p 10有你。

看结果，好一共占32个，想想为什么我们来分析一下，刚才说过前面12个不变，这是我们的对象头叫object header，接下来a占四个，b站四个int类型，布尔类型占一个，但是呢我给他补三个。

所以它也占四个，一般来说我们所谓的布尔类型，bt类型，short类型都要转成int类型，还记得吗，怎么转的呢，就是给他补三个字节，这么转，这叫内部对齐，然后它也是一种alignment。

它也是一种ping，但是呢它叫内部对齐好，接下来关键是占占这个string是占多少个字节，大家跟我说，大家听我说这个离这个概念的理解呢，呃不太不太不太容易，尤其是对那些基础比较差的。

呃我我呢先我们先看结论啊，先看这里这个string呢它是个引用，有同学说老师他是个hello啊，这个字符串不应该放在这里吗，不是string，是这个类的成员变量，这个hello是另外一个对象，还记得吗。

它应该是放在常量区的，对不对，他应该是放在另外一个地儿的，所以说根据这里的这四个字节可以找到那个hello，它是另外一个对象，它是一个字符串对象，所以说它跟它这个字符串对象。

跟我们自己的这个t对象没有半毛线关系，这里存的只是一个指针，这个指针的长度是多少，四个字节，四个四个四个四个四个四个462 14，再加四个30能被八整除吗，24 28啊，再加四个28能被八整除吗。

不可以，所以呢再补四个32个字节，当然这里头有一道触及灵魂的问题，这个问题呢其实我要今天要想把九个问题讲完，这个问题我不应该讲给大家听，尝试讲仔细听，认真听，讲到哪儿算哪儿。

大家看这里一个一个机器的指针长度是多少，一台机器的指针长度是多少，java虚拟机也是一种虚拟机吗，指针长度是多少，由什么来决定呢，就看你这个机器，通常我们俗称的你的寻址能力是多强。

你的唉多多是多少位的机器，我们一般接触过的，你们可能没接过八位机，没接触过16位的机器，但是你们应该接触过32位的机器，现在目前用的最多的是64位的机器，所谓的多少位指的是什么意思啊。

小伙伴们指的什么意思，指的是寻址的能力，所谓寻址能力指的是什么呢，就是我64位能代表多少个地址，比方说我如果用一位的能代表几个地址啊，只能被代表零和一两个地址，两位呢011位要么是零，要么就是一对吧。

两位呢01100011这四个地址对不对，那三位呢二的三次方就八个地址，如果是64位，就代表着我们有20 64 2x64个64次方个地址，我们可以找到，如果每个地址代表一个比特的话。

记住这就是您在内存之中能够寻址的空间到底是多大，好所谓的64位的虚拟机，它的寻址空间指的是我64位虚拟机，能够支撑二的64次方个地址，从内存里头找二的64次方个小空格，每个小空格里面代表一位，要么是零。

要么是一呃，这个大体的概念我是不是应该说清楚了，这个主要是讲给那些个没有计算机基础的小伙伴们听的啊，来这块能听明白的老师扣一，我们继续，好当我们决定了你是多少位的机器之后，实际上你的内存是最大能到多大。

唉这件事呢就已经确定了呃，你比如说最简单的我们是32位机，大家应该知道我们内存是不超过四个g的，如果你原来32位机器，你内存装超过四个g之后，你就找不着了，你装不了这么大个，为什么。

因为二的32次方正好等于四个b不能比这再大了，寻址空间已经找不着了，你再大他已经找不着了，它代表不了那么那么大的地址了，32位就是64个g啊，就是就是32位就是四个g，然后64位的话呢。

当然它不是不是不是不是八个g啊，你你这个自己算的啊，33位就是八个g是吧，哎34位呢就是16个g，你自己你自己算计非常非常非常的大，当你理解了这件事之后，这就代表了它的寻址空间，那有同学说了。

老师正常的情况下，我们用的机器这v m虚拟机，我们现在用的不都是64位版吗，按理说你的一个指针记住在一个多少位的机器里面，一个指针的大小就代表着地址的大小，它就应该是64位，这里为什么只有四个字节。

4x8=32位呢，为什么呢，这是为什么呢，好听我说这里头呢代表了它的压缩存在呃，因为大多数的机器用32位的地址就已经寻址空间就已经够了，所以呢这里它进行了一个压缩压缩，为什么压缩呢。

压缩就是为了省空间嘛，有同学说老师你讲这块我还是不太理解，来我们来看虚拟机的一个参数的配置，可能稍微有点细，不过听听看吧。

呃这块有没有说跟不上的，有没有跟不上的，你给老师扣扣扣个二出来，然后呢你把你的问题啊。

你你敲出来啊，我才能知道你到底是不是跟得上啊，问题到底出在哪，好不好，应该比较清楚对，听懂了，但是记不住是吧，好在看这里，一般来讲呢我们敲一个java的时候，它会启动一个jva虚拟机，这个java基金。

这个java虚拟机启动的时候，它实际上带了一些默认的参数，同学可能在了解这一点，来，我们把这个默认参数给你打印出来，看看怎么打印xx，print，come on line in flags。

呃这个意思呢就是print打印，come on line in flags，打印命令行的各种参数出来，conversion回车来看这里啊，呃在这儿呢有一大堆的，它自带的命令行参数就带出来了。

第一个参数叫initial，his size，叫做起始堆大小，第二个叫max size，叫最大堆大小，就是刚开始占多少内存，最大我能占多少内存这个意思，然后后面是这个大家大家大家往这看。

这句话的意思是说什么呢，诶使用压缩类指针，类指针在哪呢，还记得吗，类指针是不是在这儿呢，类型指针，所以你看到没有，这个指针，正常的也应该是64位，也就是八个字节啊，这个这个指针。

这里这个指针这里这个指针正常也是八字节，但是由于它默认参数存在，所以呢这里就变成了四个字节，叫ordinary，ordinary普通，第二个o是object，普通对象，第三个p是pointer。

叫普通对象指针，这个普通对象指针指的是什么呢，就是在我们实例数据里面，我们有一个指向字符串的指针，还记得吗，就这个这个小写的string，这就是一个指向普通对象的指针，像这种指针它也进行了压缩。

好讲到这里，大家是不是看明白了，也就是说我们的这个虚拟机默认的情况下，它是对它进行了压缩的，好这块你听明白了之后呢，有同学说老师你把这个压缩能不能打开，可以的，没问题，我把这压缩给你。

打开之后你就会看到它就不一样了，大小就不一样了啊。

我把这个压缩类指针，给你关了啊，不是不是打开，而是给你关了嗯，run run edit conformation，run run run，edit我们加一个参数，这个参数呢前面是加号。

表示打开压缩类指针，换成减号，我就让它不打开，就是不压缩的意思，跑一下看，你注意需要你注意观察的就是前面的object header，大家还记得原来我们看这个object header的时候是四个字节。

四个字节，这是mark word，但是后面你发现没有从四个字节变成了八个字节，为什么，因为我把它压缩打开，它现在呢把这个给你补齐了，补成八个字节了，好到现在为止能跟上雷老师扣一。

ok ok那有同学说老师你看这个string类型现在占的是四个字节，你要把它打开的时候占多少个字节呢，看一眼就知道了吗，呃我们再加一个，再加一个参数叫杠xx，用减号叫use。

compressed o o p s，我们把这个给它关掉，普通对象，普通对象指针，你也别给我压缩了走你，好看这里我们这个ing类型它是现在是多少个字节，八个字节，ok现在呢整个对象已经变成40个字节了。

呃所以默认是压缩的，因此呢比较省空间呃，如果不进行压缩的话，空间就会膨胀的比较大，正常情况下我们一个小程序很难用到四个g的空间的，用不到的，所以呢压缩情况能够满足多大绝大多数的情况好了。

理解了这件事情之后，我们现在再来看张图，现在你是不是有一点深刻理解了啊，前面八个mark word，后面是四个或者八个，看压不压，class pointer，实际数据呢就看你压不压，如果压的话。

我们普通对象指针四个不压的话，八哥后面对齐，看看能不能被八对齐整除就行了，ok这道题我就讲到这儿，可以继续了吗，来可以继续，老师扣一。

好我们再来看别的题，继续看啊。

系列 2：P19：马士兵老师面试题：4.对象头具体包括什么？ - Java视频学堂 - BV1Hy4y1t7Bo

pointer，这个比较简单，所以人家问你说。

对象头者具体包括什么，你要说出来两部分，第一部分叫迈克尔，第二部分叫class pointer，class pointer，指向某个类的指针，你的对象是属于哪个类，就指向哪个类的指针。

重点是在这mark word，这个呢是面试的重灾区，mark word本身。

如果你要想要是透彻讲的就没完了，我大概给你看一眼mark word就行了。

好吧，在mark word内部呢，它是怎么构成的，mark word内部是这样来构成的，它大概包括三种信息，跟我说，大概包括三种信息，第一种信息是关于锁的信息，你会看到它属于哪种锁的状态。

是无锁还是偏向锁还是自旋锁还是重量级锁，第二部分叫dc的信息，dc信息是这个对象是不是正在被回收，回收的过程，由于要用到三色标记算法，所以这个对象是处于那种颜色过程之中。

在这里记录着你的对象是属于哪个哪个颜色，白色黑色还是灰色呢，在这儿记录，那好，第三部分还包括这个叫还是code。

听我说这个东西呢就比较细致了，我慢慢的给你来一个粗略的演示啊，升级过程呢我就今天在这就不多说了。

升级过程讲两小时，应该是讲讲讲讲差不多两小时，在差不多我呢嗯在这儿主要给你稍微简单演示一下呢，他的这个mark word里面呢主要记录了一些什么样的信息好看。

这里t小t等于6t我们主要看它的mark word部分，在最开始我们就出来这个对象的时候，你会发现这个对象mark word呢很简单呃，只有一个字节是001是吧，后面的所有的字节全是零。

这就是一个很普通很普通的对象，刚刚弄出来的状态啊，刚才我说过里边还包括什么内容来着，实际上是包括这个内容叫还是只要你调用过一次，它的还是code，ok这个hash code的信息记录在那。

记录在他的mark word里面，记录在他的脑袋上，我们调一下，然后重新的，重新的我们再输出他一下来做对比，你就看出来了，好接着看，好我们做对比，我们主要看mark word部分。

这是最开始new出来的状态，好下面是我们调完了还是code的状态，我讲到这儿，你是不是能看懂了，还是go的信息记录在哪，是记录在这里，来这块能get到的，给老师扣个一。

所以第一mark word里面记录了什么，还是co记住在这儿有什么好处啊，还是code计算一次之后，下次再用这个还是cold是不变的，所以从脑袋上直接拿就可以了，我就不用再计算第二次哦。

除了这个信息之外，我们再做对比，做这样一个对比，synchronized的题，大家记得吗，这synchronize t是什么意思啊，哎拿t当成一把锁，把这对象成一把锁来使用，叫锁定这个t对象。

我把它锁完了之后再来看里面信息，当然我解锁锁，把锁解开了之后再来看里面信息，我们做个对比好吧，一共做了三个状态的输出，第一个是我们刚刚进来的状态，第二个是上了锁的状态，第三个是所释放的状态，往下看。

好做个对比，这是刚刚尿出来的状态，长这样，这个是上完锁的状态，你发现了一个很重要的问题吧，上完锁之后，你发现ok别的地儿都没看出区别，但是mark word和原来不一样，所以锁的信息记录在这里。

当我们知道这个锁定机之后，我们再往再来往下看诶，锁释放了之后呢，你会发现又回到了原来的状态，所以mark word记录了锁的信息，还能get到这一点呢，给老师扣个一，当然我没有办法向你演示呃。

gc回收的信息啊，gc回收信息是他内部使用的一个三色标记算法，这算法呢也经常被被人问到呃，我在vip课里头专门给大家讲了这个三色标记算法。

在这个这个这个今天内容太多，我就在这就不展开了。

当你理解了这件事之后，所以我们再来看这个问题，你是不是就会就会答了哎，对象头者，包括什么呢，对应斗者包括的是两部分，一部分叫mark word，第二部分叫class pointer。

class pointer，指向new出来这个对象的那个具体的类，mark word里面装了三部分内容，第一部分内容叫锁信息，第二部分叫还是cod，第三部分叫gc的信息，ok所以第一题第三题。

第四题搞定，第一题还没有搞定啊，主要是第三题，第四题和第七个题，三四期我们搞定了。

我能不挨牌讲，我主要讲难易难易。

这个资料，这个这个这个按难易程度来讲比较容易的，我放在最前面讲，前面这节课呢虽然听上去有同学没听过，可能觉得稍微新鲜点，但是你只要听过一遍之后，你会知道这些都是死东西，大不了我还没过，那好。

系列 2：P20：马士兵老师面试题：5.对象怎么定位？ - Java视频学堂 - BV1Hy4y1t7Bo

我看刚才有同学说老师这个数组和其他的不一样，对数组是五分五部分构成啊，这个不难，先把它略过，看这里对象怎么定位，对象怎么定位，指的是什么意思呢，注意对象怎么定位，指的是当这么写。

说t小t等于6t指的是我们通过这个小t是怎么找到这个对象的，有同学说了，老师还不简单吗，不就是个指针吗，小t就是指指针顺着指针找到地址，知道这个对象的大小，把这块空间一截出来，ok这就是那个对象了。

我替呢找到这个首地址的这段往后数呗，好像就是整个对象，没错，你说的很对，但是啊真正的虚拟机的执行过程啊，虚拟机的设计者实际上除了这种这种方式之外，还有一种方式，这种这种方式叫直接指针。

还有一种方式叫间接指针，他叫句柄方式啊，我不记这个句柄这个词了，句柄这词好久没见过了，句柄这个词啊是最早微软发明的，那时候就叫handle嗯，但是现在呢你就把它当成一个间接指令用就可以了。

看这里有两种方式，第一种叫直接指针，通过这个t直接找到这个对象，这个对象属于哪个类类型的数据指针，实际上是记录在这个对象内部的，也是指向他，就是class pointer，就那个嘛脑就在脑袋上呢。

好找到方法区里面的题材，class整个对象的组织是这么来组织的，所以它叫class o o p2 元模型，这就是它的class单独分开唉，另外一个叫o o b就是这这个这个c加对象里面的。

专门用一个数据结构来代表它，大家看这里除了这种方式之外，实际上还有一种方式，就是这种这种方式是什么意思呢，这种方式的意思是我通过这个t他会时间会找到一个二元组，这个二元组的话呢。

第一部分代表的是这个对象，第二部分是代表的这个数据，这个对象的类型，也就是通过这个类型指针可以找到替代class，通过上面这个对象，这个指针可以直接找到这个对象，这是两种方式，有的jvm确实就是这样的。

咱们但是咱们咱们接触的这位m大多数都是这样的，直接指针，好那大家听我说这是两种方式，如果人家就问你说你对象怎么定位，有两种方式，对没错，但是肯定没完，他肯定会问你说这两种方式有什么区别，有什么好处。

有点晕，讲太快了，那这个二元组在哪里，内存里，你就算在内存里就行，这道题也不是很重要好吧，基本上现在这个m你们见到的多数都不采用这种，咱们见到的多数都是这种，只有这种，ok但是有这种设计。

他会问你这种设计的好处是什么，这种设计的缺点是什么，我相信缺点大家伙拿大腿想想都应该能想得出来，缺点还不简单，你你找你得通过找一次指针，再找一次指针才能找到这对象，而这个直接夸机就找到这对象了。

所以这个的缺点就是慢，这个的缺点就是快二次寻找对，但是这种方式就一点儿好处没有吗，省空间，我看白日梦搁那儿说说这种设计是省空间的大哥，你琢磨琢磨这省空间吗。

这两种方式不就是说这部分指针装到了这个对象里吗，空间是一样的，一点都不少，半点都不少，绝对谈不上省空间啊，注意这个呢比较深入，因为这个里面是涉及到pc回收的问题，大家应该都知道这个gc回收问题是这样的。

gc的回收问题是要修改这个地址，有同学说啊，这个指针还需要进行修改，对没错，gc的回收会涉及到对象的移动，比如说我们说最简单的，我们把一个对象从低电源去，刚刚分配好的给它放到old区老年代。

那么你需不需要移动这个对象，移动这个对象，如果我们有一个引用指向，原来是指向这个这里的，它移动了位置之后，你要不要改它的值，必须要改，所以采用这种方式，你发现这个t是不用改的，就整个回收过程。

我们在垃圾回收器回收的过程之中，我们回收的过程之中是不用频繁改动这个t的，但是这种的你就必须要改动这个t class class什么区别一样的，是不是有的人写成k开头和那个原来的那个加一点区别。

有的人呢你就直接写c开头也可以，无所谓好我们就讲到这儿好吧，这道题也不是很重要啊，实际数据指针也不变了，这个指针必须得变，但是它重点是这个这个不变，这个不变就能省省很多很多好处啊，就讲到这里啊。

系列 2：P21：马士兵老师面试题：6.对象怎么分配？ - Java视频学堂 - BV1Hy4y1t7Bo

下一个下一个叫对象怎么分配，这个相对复杂一些，我们来看这个图，为啥要移动，刚才不是说过了吗，dc为啥要移动g c g c垃圾回收的过程是需要对象移动的，如果这块你没听不懂就放一边没事。

你听不懂的主要原因是因为你对gc不了解，你对jvm的回收过程不了解，总而言之，对象不是说分配完了之后，它就不动了，在这m内部它要拷贝来回拷贝，拷贝就需要动地址，动地址就需要改指针，放过吧。

基础不够的同学先把它先把它分问题先放过，先听能听懂的好吧，带着问题来，带着收获走，看这里我们来聊对象怎么分配，这个过程也是相对复杂，我给你讲大概的意思，听我说所谓这个对象怎么分配是什么意思。

就是当我们new出这个对象来的时候，它分配在哪个空间，jdk默认的垃圾回收器，jdk默认垃圾回收器呢叫做parallel scavenge，加上parallel old啊，不管总而言之。

jdk默认的你的内存会分成两部分，第一部分叫年轻代，刚尿出来的对象放在这儿，第二部分叫老年代，到了一定年龄之后的对象挪到老年代去，什么叫年龄，垃圾回收回收一次涨一岁，回收一次涨一岁。

回收了好多次都回收不掉，你你就是老顽固，扔到老年代去做专门处理，好对象的怎么分配的，过程是这样的，我们刚刚new了一个对象的时候，它会首先尝试在站上分配，嗯，我先讲完，我一会儿给你解释好吧。

我刚进来个对象的时候，是在栈上分配，呃有同学可能会说，sdx徐海涛你来了，我们刚刚就来个对象的时候，是在栈上分配，这个以前呢你你你你你你做java程序员的时候，你可能会做简单的指导。

就是刚刚扭出来一个对象，我们肯定是这个对象放到堆上吗，我今天把这个观念给你纠正过来，如果人家问你问到这个问题了，你就必须把细节说出来，刚开始new的时候是new在栈上分配，站上分配，如果能分配成功的话。

就直接分配在站上，然后站上有一个好处，就是站往外一弹，整个对象就自动的给消失了，什么意思，听我说，大家都知道我们的整个的内存的管理啊，无论是什么语言，都是听认真听，不论任何语言，基本都把内存分成两部分。

一部分叫占，一部分叫堆，这个站呢是整个运行空间里头操作系统直接帮我们管理的，我们自己的程序不需要管理，当一个函数开始运行，这里面就有一个战争的存在，就是这个函数里面的局部变量。

哎我在main方法里头是怎么写的呀，这样写的t小t等于6t好，这个main方法里头这个方法开始运行之后占一小块空间，这就是那个main方法的空间，这个空间里面存谁存自己的局部变量。

我们这个方法里面所需要分配出来的那些临时性的这样的变量，比如说小t就放在这好，小t等于6t那这时候new出来的t放哪呢，一般我们说说放到堆里面，对不对，但是啊记住他会首先尝试在自己的这个站上分配。

这叫战争，当然我一个方法要调用另一个方，另外一个方法的话，那就再来一个战争，如果再调用一个方法的话，就再来一个战争，这么多战争操作系统是怎么管的，很简单，一个方法执行完毕，这个战争自动弹出。

这块空间完全回收，所以弹出就不就把这站顶指针往下移动一下，特别特别简单好，讲到这儿了，这是这是计算机系的最基本的基础知识啊，呃这块如果你没有听太懂的，你给老师一个反馈，听明白的，给老师扣个一，来口水喝。

那么大家认真听，当你明白了站在最基本的概念之后，你应该就会了解到，如果我这个对象是分配到这里，直接在占领战争里面分配在站上有什么好处啊，方法一结束，整个对象不跟着就没了，我用得着专门的垃圾回收器吗。

用不着，为什么操作系统帮我管了o所以在栈上分配的好处就在于这儿，就是你呢就不用管了，就回收期的事儿了啊，直接就弹弹出去就没了，那位同学可能会说了，那我为什么还往堆上分配，往往占上分配多好，不好意思。

网站上分配是有条件的，什么条件呀，网站上分配的条件主要包括两个，这个叫做第一个呢叫逃逸分析啊，叫逃逸分析，第二个呢叫标量替换，细节细节这个细节太血淋淋，我就不展开，我就要跟你聊一下这个逃逸分析。

你就理解了，那个有同学可能会说什么叫逃逸分析，其实就是这个意思啊，你比如说我如果分配了一个对象，这个战争在自己的战争内部分配一个对象，这个对象如果只是我自己的局部变量用，没关系啊，只有我自己用得上。

而一for循环里面，不断的new对象，别人家也用不着，其他方法用不着，好这样的对象弹出去就弹出去，我是方法结束了，你放心的对象一定就没用了，所以就直接弹出去，但是如果这个对象被另外的一个方法里面。

我需要用得着的话，那你能随便弹吗，你要把这个弹出去了，下面这个t是不是就空指针了，他还有用呢，人家还没结束呢，这就叫逃逸分析，什么叫逃逸呢，就是说我在这里头a指向我的指针。

有没有逃出我的战争管控范围之内，你已经逃出去了，不好意思，我就不能再这样分开了，我就只能再堆上，堆上有什么好处，我这个tk指向他哎我这个t也可以指向他，来能听懂这块的老师扣个一。

ok这个时候就可以进行占上分配，战场分配的好处很简单，占一谈整个生命周期就结束了，所以管理起来特别方便，不过它呢是要进行逃逸分析，绝大多数的是不能再这样分配的，只有少数可以，ok这就是栈上分配的好处。

站上分配不了，这时候去分配在哪儿，听说这个时候看它个够不够大，个儿够不够大的意思是说，如果你的个儿特别大，直接扔到老年代，老年代的区域，刚才我说了啊，内存分成两大块，一块年轻带一块，老年代好。

老年代的空间一般来说比较大，好个特别大的，直接给我扔，老年代你就别跟我说年龄到了才扔过去，不要这是什么意思，有的有同学可能马上就会问说老师啊，那个到底有多大呀，这个东西是通过参数来控制的。

叫max chineering threshold，我就在这里不给大家展开这个细节了，这是jvm调优里头需要控制一个参数，叫max chineering，the result，叫最大的老年代阈值。

这个意思，那总而言之到一定个头直接扔到老年代，扔到老年代的话，如果这个对象想结束结束他自己的生命周期是需要经过垃圾回收的，一般我们需要经过fully c啊，全回收才可以，那如果说个不大不小啊。

站上呢又分配不了，有逃逸，分配不了怎么办，唉这个时候呢才会进入到我们的伊甸园区，当然在伊甸园区进入之前，还有一个特殊的优化的这样的一个过程，这个过程呢叫tb t r a b的全称。

thread local allocation buffer，来跟我读一下，叫thread local allocation buffer。

threlocal叫县城本地allocation分配buffer，缓冲区叫县城本地分配，有缓冲区，这是什么意思呢，这个意思就是说同学们你们琢磨一下，如果我们所有的对象都扔到伊甸园区。

好多县城都往伊甸园区扔对象，它一定会有现成的竞争存在，我也看上第10号地址了，你也看上第10号地址了，好我这个m就必须进行管理，谁抢到了算谁的，这个叫锁竞争就必须对线程进行同步，同步的效率是比较低的。

因此在这个阶段jvm又做了一个优化，这优化是怎么优化的呢，就是给任何一个线程，首先呢给你分配一小块空间，这把空间很小，但是这块空间归你这个县城单独占用就归你了，是你的private的，是你的线程本地的。

这是你们家那房子啊，你们家自己的窝，这是大家的客厅公用，这是你们家自己的卧室使用，来一个对象的时候，优先往自己卧室里放，往自己兜里揣，先不要占公共空间，自己的对象放在自己这里，他就一定只有一个现场。

他绝对不会产生说互相竞争的问题，所以这个效率就高了，因此这个我们叫t r a b的这样一个机制，这样一个机制的话呢，其实也是可以通过参数来进行控制，它可以关闭它，可以调整它的大小，这个都可以啊。

这个机制我就讲清楚了，那能跟上那老师扣个一就可以了，讲这可以了吧，对随着现成的文件而完全消失，那只是肯定的可以跟上good，好听我说接下来t r a b本身的空间也是在伊甸园区，所以呢它也是在伊甸园区。

不管怎么样呢，总而言之是分配到伊甸园区，在伊甸园区分配过来一段时间之后，经过垃圾回收，这个dc一般我们称之为y g c叫年轻代的回收，经过年轻代的回收，这个对象如果被回收掉就结束，如果回收不掉的话。

它会跑哪去呢，它会跑到一个幸存者区域，叫savior区，这里牵扯到gc是吧，稍微讲细致一点点好，这里是年轻代，这里是老年代，那么年轻代呢有伊甸园区，这是新对象的诞生地，人类的诞生地伊甸园。

然后呢还有两个小的区域叫survivor，一个叫survivor，一，一个叫survival，二，这个对象被回收的时候扔到这里，他活着就扔到这里，然后把整个区域干掉，下次再回收的时候。

这里的火车区域扔到这里，还可以把这个区域和这一类岩区全部都干掉，内部机制是这样的，所以经过垃圾回收之后的第一次，它会进入到垃圾回收的幸存者区域，survivor 1，如果没有被回收掉的话。

那如果回收再经过下一次回收，如果回收掉结束了，如果不回收掉呢，看他的年龄大小，如果您老人家年龄够了，不好意思，进入老年代，如果你老家的年龄不够，进入到另外一个server区域，如此的循环往复再说一遍。

整个内存大小算了，给你打个例吧。

系列 2：P22：马士兵老师面试题：请解释一下对象的创建过程？（半初始化） - Java视频学堂 - BV1Hy4y1t7Bo

来。我们开始。先说第一个问题。对，解释一下对象的创建过程。好，大家听我说objectO等于new object这个对象。这一句话执行完成之后，我相信大家伙应该都知道在我们的整个的内存里面有一个小O存在。

就这个变量。那么通过它呢一个引用指向我们扭出来的这个对象。好，这个对象里面到底代表的什么意思？这里面是怎么组织的OK。指的是这个意思啊，他问的是这个意思。好，那么大家听我说，如果你想了解这一点的话呢。

这里面是怎么组织的？我直接讲结论。他是这么。😡。

系列 2：P23：马士兵老师面试题：8 (1) - Java视频学堂 - BV1Hy4y1t7Bo

按初始化，首先new对象的时候三步构成，第一步new复默认值，第二步构造方法复出是指第三步建立关联，能真正的new一个对象出来，第二个我们来聊聊cpu会乱序执行的问题，只有在这两个问题你了解的前提之下。

我们才能够聊清楚dc l要不要加vt问题。

这部分问题主要是要指令重排序。

听我说，我都后悔给你讲这道题，每次讲这道题得分卖费半天劲，为什么呢，因为很多人eco不懂，还有一部分人volatile不懂，好我们今天聊dc l，先聊dc l，聊dcl是什么东东呢，dc的全称叫。

double check lock，他怎么来的，我一会讲给你听，叫双重检查锁，叫double check lock，这是一种在开源软件里头经常使用的编程的小手段，编程的手段，为了让你理解这一点。

我们用什么东西来举例呢，那这个，认为讲的设计模式的问题，那其中一个比较简单的设计模式就叫单利好，单例是什么意思，保证某一个类的他的对象只能有一个，不可以再new第二个，所以最简单的实现方式是我二话不说。

我先new一个出来，我把构造方法给设成private，不允许别人扭，谁要用我这个自己弄出来对象的时候，调过这个get instance方法，ok这个就可以保证单例，如果你是一个wifly，必须保证单例。

如果你是一个girlfriend或者boyfriend，无所谓，你有多少个随你只是道德问题，不牵扯到不牵扯到规则和犯罪的问题，总而言之，在某些特定情况下，我们需要单例类的存在。

ok单例的最简单实现就是这么写来可以继续的给老师扣个一，就是说你调的i get instant方法，你调多少次，由于它返回的全是这个对象，所以他就是单利比较简单，但是这种单位的写法会有人挑毛病。

为什么又会有人挑毛病，说他会说我还没有用到我的wife呢，你二话不说，先给我new一个，后面我想换怎么办，能不能等我用到get instance的时候，你再把它给我弄出来，不要上来，二话不说，先扭。

我还没用着呢，你先new占了空间了，占了资源了，所以等我用到再牛，这时候怎么写，换一种写法，就是我们上来先定义，但是我们不new，什么时候new啊，等我调用get instance方法的时候。

判断你是不懂空，如果这个对象还没有被救出来，我再把你弄出来，如果弄出来了，我直接用就可以了，ok这个就是单利的懒汉式的写法，上来先不定是吧，嗯那当然这种想法有巨大的问题，什么问题，我相信你应该也知道。

当多线程来访问的时候，第一个线程判断等空暂停，第二线程判断等空继续执行new一个对象，第一个县城继续执行，又new了一个对象，所以这种情况下，多线程访问不能保证数据的一致性，来这会儿能听明白的。

给老师扣个一，为了为了向大家嗯，让大家能够更快的了解这个问题，所以我中间加了个sleep，本身没有不需要sleep，高并发的情况下，他一定会产生这种问题，所以我100个线程。

我内容来看它的hash code一致不一致，如果一样的话，那就说明是同一个对象，如果不是不一样的话，说明就不同的对象好，我弄出来之后你会发现呢，你看啊664144的，32的等等一大堆。

所以这里头是保证不了多线程访问的数据制性，当你保保障不了这件事之后，那大腿想想加synchronized，关键字很简单，single的意思就是当我要执行整个方法的时候，只允许一个线程执行一个线程。

执行完另外一个线程才可以执行，这线程执行完了另外一个线程才可以听懂了吗，我这线程执行完了，你不保证这里都存在了，你放心，另外一个线程开始的时候发现等于空存在了，不等空了，已经放心，一定直接拿来用。

所以这个是可以的，这是没问题的，不演示了，我讲的速度相对快，扣一有问题直接提，相对简单，我们加加速嘛，但是这个东西我们通过精益求精，追求完美的状态来说，这个东西呢还不够。

为什么我整个方法的代码很可能是放在业务逻辑里头会非常的多，前面一堆业务逻辑，我从某个地方读一个数据出来，我需要上锁吗，需要让多个线程只能有一个线程执行这段代码吗，不需要，我只需要让单个线程啊。

多个线程序就是序列化执行这段代码就可以了，也就是说给这段代码，简单说给这段代码上锁就可以了，前面代码没必要上锁，那我这时候怎么办呢，我呢就把锁的力度放得细一些，我不在整个方法上上锁，我在哪儿放上锁呢。

我把放过那段业务代码啊，放过那个时态，接下来呢我们只是在我们的需要上锁的地方来上锁，所以if instance等空，然后再上锁，你等空我再上锁吗，上完锁扭出来，如果不等空就能用啊，告诉我在这种情况下。

我们能不能解决数据一致性的问题，可以吗，合理你会发现啊不对，还是不同的对象，664510971461大堆是吧，为什么特简单，我问一下，第一个线程来了，判断等空没问题，暂停，第二线程来了，判断a依然为空。

没问题，第二线程执行执行上锁一个对象，释放所范围好，第二个线程执行完了，下面我们来看第一个线程好，第一个线程申请上锁可以吗，可以为什么，第二个线程已经把锁给释放了呀，我当然上锁成功，既然上锁成功。

我就又new了一个对象，所以解决不了多线程一句话的问题，当你理解了这件事之后，你会发现这个写法是不行的，那怎么办呢，办法是这样来做。

仔细看办法这样来做，我把这段代码呢给复制下来。

这种代码叫dcl的写法，这个在很多很多的开源软件里头有大量的运用，我希望你记住它，作为一个专业的程序员来说，有一些优秀的代码的写法，应该记住这种写法是这样的，首先判断等空，然后我上锁。

我上锁之后再判断一遍，你是不是依然为空，如果你依然为空，说明我在上锁的过程中没有被其他人，已经把这个对象给弄出来了，已经我们再来回顾整个过程啊，第一个线程来了，判断等空暂停，第二线程来了。

判断等空继续执行六出对象来好，第一个线程继续运行上锁，但是由于第二个线程已经执行完了，所以呢第一个线程里面这个instance它已经不为空了，所以在这种情况下呢，我再判断一遍，你是不是依然为空。

如果已经不为空了，我就不new你直接拿来用了，这样就能保障整个的数据的一致性，这样呢我们整个技能保障了锁的力度比较小，又能保障我整个数据的一致性，这就叫做double check lock。

为什么叫double check lock，你看这里检查一次，这里检查一次，两次检查中间加了一把锁，o检查一次检查一次，中间加了一把锁，所以叫double jack log，来给我记住的老师扣个一。

这叫著名的写法叫double check lock，关于double check log，最常见的会被问到的问题是这句话是说这句话我能不能去掉它，当然可以，你放心，你去掉他之后，我上来二话不说，先上锁。

上锁之后再判断，放心，一定可以，完全没问题的，但是这句话一般来说要存在，为什么，因为你琢磨一下，如果有1万个线程，我们按照现在的写法，只要有一个线程定出来，其他9999个线程上来只执行完这一句话。

判断已经不为空了，我就不用再上锁去竞争了，但是如果去掉这句话，如果去掉这句话，这1万个县城所有人上来二话不说，先抢一把锁才可以才能执行，效率是不是太低了太低了，理解了这件事情之后呢。

诶你就会发现这个写法还是很经典的啊，请你记住它，但是人家问的问题是啥呢，人家美团就认为你就应该知道，我说dc l你就应该知道是个啥东西，都不用我解释才对好，我已经给你解释半天了，但人家的问题还没完。

人家的问题是excel这种写法到底有没有问题，怎么解决这个问题，放心一定有问题。

不然他就不会问了，仔细看仔细看，这个写法是有问题的，听我说，这个写法的问题是在这里，我我把代码放在这儿，方便对照看这段代码，假如说啊我们现在来了第一个线程，一个线程上来判断instance等空。

一个线程没错，instance确实为空，所以一个线程上锁判断依然等空，开始new对象了，仔细听认真听，当我们一个线程开始new对象之后，还记得吗，new一个对象由三部构成。

第一步有对象的时候扭出来一半儿，然后给它设成一个默认的零，第二步调研过的方法，给它设成八，第三步建立关联，假如我们刚刚溜了一半，刚刚的仅仅用了一半，正在这个时候发生了指令重排序，刚才我不是说过了吗。

cpu内部执行是可以，指令是可以重排重排序的，对不对，语句都可以重排，你内部的指令绝对可以重排，放心吧，所以发生了指令的重排序，指令重排序会产生什么后果，仔细看是这两句话发生了指令重排。

这两句话指令重排的是什么东西，是先建立了关联，能听懂吗，s多不就建立关联吗，正好执行到这里的时候，还没有执行到构造方法的时候，第二个县城来了，第二个线程来，是不是，首先判断哥们儿，你是不是依然等空啊。

对不对，首先判断这个对不对，他会首先，他会首先执行这句话，对不对，哥们儿，你是不是依然等空，但是你注意啊，我执行到第一个线程，执行到这里了，已经执行到这儿了，t还等空吗，我问你t是不为空，当然不为空。

人家已经指向一个对象了，他为什么能空，只不过这个对象是一个初始化了一半的对象，只是初始化了一半，刚刚生成了左半边儿，还没有完全构成一个整个的对象，ok既然你不为空，我第二个对线程来说。

我是不是就直接拿来用了，你不为空，我还不能来用，我还什么中间上锁什么这些全部用执行了，第二个线程就用到了一个初始化了一半的对象，这个里面记录着我双11订单一百万单啊，不好意思，另外一个线程一读为零。

故太好了，帅当然一般不可能出现啊，大家能意识到这个代码的问题了吗，再看一遍，由于这个代码的写法，第一个线程来判断等空上锁new对象，new到了一半发生指令重排序，重排序只执行了建立关联的指令之后。

第二个线程来打断判断t已经不等空了，使用，ok美团一般为什么后天啊，后天咱们现场的招聘会呢是由美团的老师过来，可以现场跟他交流，呃我讲课呢运用了大量的动画，只是为了加强你的印象，我这个东西有语言说。

你肯定是搞不清楚的，我是用动画给你演示，是不是就理解了，所以必须要加volt，volatile是什么东西呢，volatile两大作用，第一个保障可见性，第二个禁止重排序，纯白去给你禁了。

系列 2：P24：马士兵老师多线程：1.线程的本质(操作系统与CPU是如何执行线程的) - Java视频学堂 - BV1Hy4y1t7Bo

虚拟机来给大家透彻讲解一下这个线程和锁的问题，县城所这件事呢在大厂的面试之中叫做必不可少，而且呢死人死的特别多，我们俗称叫是县城与所适横遍野是吧。

关于面试题呢我就不给大家一一的列了啊，就是其实挺多的。

大家可以看看呃，去年的时候，2019年的时候，大概我们在面大厂的时候所用到的一些面试题，你大概大致可以溜一遍，给大家个15秒，20秒的时间，这玩意儿怎么这么卡呢，下一个客户端就不卡了啊，乖乖乖。

你曾是少年是吧，嗯你还是那个少年，很好，我都不认识，哈哈哈哈哈哈，都是不认识，对了就对了，说明你有很大的成长空间，好了，同学们呃，这是基本上是一线大厂的一些面试题，呃，其实你弄懂这些题之后呢。

那些中小厂就已经应该是不在话下了，属于是降维打击了我呢，这个课呢其实已经讲过好多遍了，包括去年呢我专门讲了多线程高并发大概20多小时的课，但是从反馈来看，从大家伙的我又我又不断地讲了很多的公开课。

从大家伙的反馈来看呢，很多同学理解起来还是困难，我后来就反思我说为什么大家理解线程和所理解这个东西的时候。

理解特别困难，就在于呢有很多东西讲的特别晦涩，另外呢很多人实际上是它底层的知识不太够，我这一点也很重要。

所以呢我在这个2020版的这个里面。

我打算从给大家讲这个多线程的时候呢。

先从程序运行的底层原理开始讲，而并不是说直接上来就给大家讲代码呃，我呢今天来尝试着从这个层面来给大家讲线程和锁，以及先程携程管城这些东西到底是一个什么概念，现在我们就可以开始了，来准备好同学老师扣个一。

马上开始，后来，我先把我bb打开，呃在我的另外一门课里头讲的是这个计算机的底层知识，我觉得给大家讲清楚，县城之前呢需要给大家聊一点计算机的最基本的底层知识，这个以前从来没跟大家聊过这一点。

所以有很多同学理解起来特别麻，特别困难，呃我现在呢就用这个一个简单的图啊，这个图呢是来源于计算机组成原理这门课里面的一个图，大家的这个图呢也不要执念于a aru是什么，cu是什么，mu是又是什么。

先不要只念执念于这个，先从大块上开始看任何的一个东西呢，大家记住了，叫做先学脉络，我一直强调这一点，先学脉络再学细节，只要你沿着这样的一个学习方法，你的效率就会提升很多，很多有很多人学习不识庐山真面目。

到庐山里头先去找庐山，一棵树底下有一颗蚂蚁窝，跟他研究小蚂蚁，没错，你研究蚂蚁研究的很深，但是别人问你庐山啥形状呢，你根本就不知道，所以先建立知识体系，再来查漏补缺，找细节，大家记住这句话，好看。

这里作为一台计算机来说，它最核心的组件有这么几个，最核心最核心的叫cpu，那么还有一个装程序的叫内存，当然还有什么硬盘呀，显示器，鼠标键盘网卡等等，这些都叫做外围设备，大家听我说。

这里面程序运行你需要理解的最根本的东西，一个叫cpu，就叫内存，在这儿呢我想给大家简单澄清几个概念，第一个概念呢叫做什么是程序，程序是什么东西，我呢不想给大家讲什么那种。

就是特别文绉绉的那种定义化的那种语言，给大家举个例子就行，比如说你的你看到的qq。e x e，比如说你看到的powerpoint。ex e，像这一类的东西放到硬盘上，静静地躺在那里，这就叫一个程序。

那好对比的概念，什么叫进程，进程是什么概念，进程是什么，县城是什么，这是大厂在面多线程的时候特别特别喜欢问的一个起始的面试题，什么是进程，什么县城，好好听我说所谓的进程，双击qq。ex e，夸夸一。

双击背起来一程序，本来你看，这个qq。ex e呢是放在我们硬盘上对吧，然后呢我们通过浏览器能看到它一倍一双击马上起一个程序，这个程序是一个什么内容呢，实际上他把qq。e x e的一些相关的内容和资源。

放到了我们的内存里面，ok它会在内存里面分配一些资源，分配一些空间，分配好我们的什么文件的i o啊等等等等，总而言之，这个qq。ex e双击不就跑到内存里了，占了一块空间，里面装着这个程序的指令和数据。

指令指令是什么，就是诶下面要执行2+3数据是什么数据，就是那二和3k指令和数据，一个应用程序以双击跑起来的时候，这部分的东西这个叫一个进程，ok所以这个进程是一个什么概念。

就是程序以双击开始运行之后放到内存里的那部分内容，好了，这就叫一个进程，那么县城又是什么呢，线程是程序执行的基本单元，好我先说结论，如果大厂问你什么是进程，什么现场标准的回答，进程是资源分配的基本单位。

线程叫程序执行的基本单位，啥意思好听，我说大家看着依然看这张图，我们的整个的程序放到内存里之后，它有指令，有代码，有指令有代码，但是这些指令未必位于同一个县城里，它会首先找主线程。

也就是我们的main线程，然后开始执行执行的过程，有可能有其他的执行路线，ok这就是别的线程好，所以进程是什么，进程是我需要一些资源，你先在内存里头帮我分配好，所以它叫做资源分配的基本单位，线程是什么。

县城是我现在要执行这个程序了，ok从main线程开始执行，然后中间可能会有分叉，可能会有合并，可能会有同步，所以现城市叫做我们程序执行的基本单位好关于这几个概念，不知道我说清楚没有，来。

可以继续的同学给老师扣一，好这个这几个概念比较简单，那现在我们来看看下一个概念，这个程序怎么着才能开始运行，也就是cpu是怎么执行一个线程的，所有的人听我说，任何程序开始运行的时候。

cpu执行的就是一根线程，这个线程是什么，就是main线程，main线程开始之后才会启动其他线程开始运行，cpu是怎么执行一个程序的呢，cpu是这么来执行的，我们拿最简单的东西举例子啊，还是举例来说明。

你仔细听，比如我有这么一条指令叫2+3，a等于2+3，然后你要打印那个a也好，或者怎么样也好，我们不去管它，就是我们有这么一条指令，让你算一个2+3放到a里面，a可以理解为内存里面的一块空间。

2+3就理解我们程序的数据，那这些数据呢会被cpu通过系统的总线哎，总而言之就是一根线，cpu和内存之间连接的一根线，读到cpu的内部里面去，cpu内部里面，我希望今天大家记住三个最基本的东西。

第一个呢叫寄存器，第二个呢叫pc，pc也是一种寄存器，但是要把它单独为独立出来，这个pc的全称叫program counter，叫程序计数器，无所谓，你不用管，记得它的名字是什么，你听我讲就行。

我们会把这个二和这个三放到寄存器里面，放到我们cpu的寄存器里面，那么寄存器是什么意思呢，就是存数据用的，所以这个二和三原来位于内存对吧，最早是位于硬盘上，被我们装到内存里。

然后真正开始做2+3的计算的时候，怎么做计算呢，把二和三放到我们的寄存器里，好由他来做计算，你可以就认为cpu里面有一个专门做计算单元，这个这个这个单元呢叫做数学逻辑单元。

叫arithmetic logic unit，我们不去管它叫什么，名而言之，二和三放到寄存器里头开始运行，运行完之后的结果怎么办，返回内存给它放到a里面去，放进这个a里面好了，就是这么一个过程。

那有同学会说老师这个pc是个是个啥呢，这个pc就记录一件事，记录什么事儿呢，下一条指令执行到哪里了，一个程序呢就指令一指令二，指令三，指令四，最开始的时候这个pc指向第一条指令，第一条指令执行完了。

它就变成第二条指令，下一面就是第三条，第四条，第五条，第六条好，我把整个的计算机的执行程序的过程大概跟大家说了一遍，这里面有好多好多细节，好多好多特别多，细到可以，你怎么样去做这个电路。

怎么样去做cpu，怎么样去做这个芯片的设计，但是听我说，我还是那句话，学软件的人，先把最主线的内容掌握住，我们再回顾一下，假如一个程序里面，或者说精确的说一个县城里面要执行一个2+3。

然后给它放到某一个地址上去，cpu怎么做，首先把二和三拿到我们的register里面，放到我们计算器里，计算最后的结果，把最后结果写回到内存里，然后pc指向下一条指令，下一条指令可能是打印。

可能是做另外另外一个计算好，这个过程不知道我讲清楚没有，有没有同学对这块有疑问的，有疑问你直接提，没问题给老师扣一，我知道你们会有很多很多的疑问，pc怎么知道下一条指令是哪里啊。

计算器到底是怎么进行计算的呀，中间有没有缓存啊，别着急，我也强调过，好好听你呢，先建立最基本的认识，再去抠里边的细节好吧，好还是那句话啊，先建立最基本的认识，再去扣里面细节啊，au是计算单元。

它就用来做做计算的，先学脉络好，我给大家讲这个东西呢，最主要要引出来一个什么什么概念呢，其实呢嗯cpu呢是这么一个这么一个破玩意，我先把笔记给他写好啊，cpu呢是这么个破玩意儿，它就是读。

指令指令存哪存到pc里面对吧，然后读，数据存到哪，register里面，然后计算回血，然后呢下一条指令啊，它就它就是这么一个简单的东西，他就会干一件事，所以站在cpu的角度。

其实他也不知道你有多少个线程对他来说没关系，你跟我有半毛钱关系吗，没有，还能跟上吗，还能跟上吗，嗯还能跟上，他给老师扣个一来，pc叫做program counter，程序计数器存储指令地址。

你就想着就记录着我是执行了第一条指令了，下面要执行第二条指令了，就把这个指令的序号存在这里就可以了，没办法啊，现在大厂问就问底层没招，你以为我想跟你讲这些东西。

我直接给你讲那个thread new出来之后，然后run rable collib多简单，但是没办法，必须得给你讲这个，这个是dvm内存模型程序计数器，可以认为这都这都是通用的，相通的。

没关系嗯好我们继续啊，同学们，你们学东西的时候呢，不要想着一下子把细节全理解透彻，千万不要这么想，这个学习方式是不对的，我能给大家讲这个底层，我主要想引出来下一个概念，就是线程是怎么进行调度的。

这又是一个特别复杂内容，线程的调度linux理念，它有一个叫线程调度器的东西，注意这里面就会牵扯到一个概念，叫做操作系统，好我觉得操作系统这件事其实一说呢大概就明白。

我们写程序的时候，直接可以跟硬件打交道，没有问题，但是你直接跟硬件打交道，非常容易出错，而且会会把很容易把硬件搞死，很容易互相影响，所以在现在的计算机里头，一般都是这样的，我来给大家稍微画一下。

如果这个层面是我们的硬件的话，我们的cpu，我们的内存，我们的硬盘，那么在原最早开始的时候啊，我们一个一个一个a p p，一个普通的a p p是完全可以直接访问硬件的，但是特别容易出错。

特别容易出bug，这是最早最早最早的时候，你们可能都没经历过，后来呢为了管理这些好多好多的app，互相之间的竞争啊，协作呀，访问啊，他们之间的app诞生了一个软件呢，这个软件叫做操作系统。

叫operating system，所有在大厂面试的时候可以这么说啊，这部分内容属于必问的操作系统，那么作为操作系统来说，它是怎么管理这些a p p的呢，好好听我讲。

每个app都有好多好多好多的线程对吧，同学们，交到操作系统，这里操作系统会来帮你管理这些线程，什么意思，每一个app里面都有好多好多的线程，比方说啊这是所有app里面的这些个线程，我举个最简单例子呃。

我来给他换个颜色吧，线程一线二线程三，线程四，线程五啊等等等等，这些个呢，这是用户里面的a p p里面的这些个线程线程六啊，有同学说老师这个我理解不了，简单听我讲，比如说我们有一个app。

这个app是什么，这a p p叫jvm，jvm这个能理解吧，就是我们的hot spot，我们的java虚拟机，大家知道我们在java里面写一个程序，new一个thread。

然后让他start就起了一个jvm里面的现成，我再强调一下啊，再说一遍，当我们没有一个java里面，我们new了一个thread，溜了一个thread，然后掉了他的start。

是不是我们就起了一个jvm级别的线程啊，我知道你们的线程吗，好听我讲，这就是我们的a p p里面所扔出来的这些线程好，这些线程operating system对他们进行调度，调度给谁呢。

主要调度给cpu，所谓的给cpu进行调度指的是什么呢，指的是我这颗cpu，比如说，我这和cpu该执行这个县城了，还是该执行另外一个线程了，执行多长时间好，这个东西叫做线程调度。

关于这个线程调度呢是操作系统里面比较复杂的一部分，而且前前后后经历了各种各样的算法，在linux最新的算法呢叫cfs，叫completely fire，是是是schedule啊，叫做完全公平的线程调度。

这个东西呢是我在操作系统课里头讲了，但是大家基础不同，我就不跟你多说，我主要想强调什么呢，就是在你app里面启动的这些个线程是需要经过操作系统来帮你进行，在cpu上进行调度的，那有同学可能就会说了。

说老师你所谓的操作系统调度给cpu是一个什么概念，这个概念呢是这样的，操作系统说下一个线程该你了，我们有一堆的程序，每个程序里面有好多线程，操作系统来管理哪个县城，扔到哪个cpu里面去执行。

比如说操作系统说下一个县城好，该你了，这里有一个线程，这里有一个线程，小金同学，下个线程该你了，下一个线程该你了，啥意思，就是你你把你的指令扔到pc里，把你的数据扔到rely ok。

然后开始进行计算cpu，它就是一个速度特别快的这么一个接待接待员，反正你来了我就接待你，我不管你是哪个县城，站在cp角度，我是看不见县城的。

系列 2：P25：马士兵老师多线程：2.纤程的本质(go语言纤程为什么和线程池有关) - Java视频学堂 - BV1Hy4y1t7Bo

pc里面扔了条指令，register里面扔了一些数据，那我就按照指令来计算就可以了，总而言之，谁来负责扔这件事，扔指令进去，扔数据进去，谁来负责扔，记住这哥们叫做操作系统，呃我争取给大家讲的浅显一些。

不知道大家能不能跟得上，如果能跟上的话，给老师扣个一来，那下面的问题又来了，站在操作系统的角度，他会有一大堆的孩子嗷嗷待哺，大家都叫着哎到我了到我了，哥们儿，能不能让我让我执行了这么多县城。

等着我执行操作系统，说你到底该谁了呢，这个叫做调度策略，今天肯定来不及讲这个调度策略，现在linux内核最核心的其实就是这个调度策略，我们先不去管它，总而言之，言而总之，站在操作系统角度。

不会说让某一些个现成他自己的孩子老饿着，也不会说让cpu永远都是执行某其中某一个县城其他线程都执行不到位，这个这个肯定不行，所以在实际执行的时候，一定是执行你一会儿执行你一会儿的意思就是把你的指令。

把你的数据扔到计算机里执行一会儿，执行一会儿之后就换另外一个人，这是一接待员，速度特别快，接待你一会儿接待他，一会接待你，一会儿接待他一会，那现在问题就来了，我就想问你，假如在开始的时候。

我执行的是t一对吧，我这里面装的是t一的指令，t一的数据，那我现在要执行t2 了，等会儿一会儿还回来又执行t1 ，同学们，那你们想一下我中间要做一个什么操作呢，必须要做的一件事，我一定得记录下来。

t一执行到哪里了，就说我第一次执行t一的时候，我在哪里停下了，我下一条指令该执行的是谁，注意你执行t2 的时候，他会把那个指令，pc里面那个指令就已经把t一的给你给你给你冲掉了对吧，t一的就没有了。

这时候执行的是t2 的，那t一的跑到哪儿去呢，一定得保存现场，所以这个呢叫保存现场，啥意思，刚开始在执行t一的时候执行到哪里了，数据是什么，这些东西在执行t2 之前都给我保存好好。

这个一般呢会保存到catch里面，这个我们先不去管它，保存到哪里去，总而言之，言而总之得把t一的现场先保存好，保存好之后，t2 来了，t2 来了，什么意思啊，这里面执行的是t2 的内容，t2 的内容。

然后t2 执行一会儿，t一要恢复执行的话怎么执行，把原来的现场做恢复好，关于t1 t2 t3 t4 tn都是一样的，这部分内容叫什么呢，叫现成的切换，专业名词叫context switch。

指的是指的是cpu，保存现场，执行新建程，恢复现场，继续执行原线程，这样的一个过程，那有同学啊，那可能就会说老师这个你跟我讲这个到底有啥用呢，在这儿呢有一道解非常简单的面试题。

就是也也是一个非常简单的问题，大家都知道啊，呃如果一个任务采用单线程的时候，开始执行的时候，它的效率呢稍微低一些，那么我们就会说我们用多线程来执行它，嗯很多个人来帮他干这事儿。

那现在问题是是不是线程数越多越好，是不是一定是越多越好，能不能说我是他一个线性呃，这种线性效率提升的概念就是我的线程数原来是十个，那我的效率提升十倍，我要是1万个，那效率就提升1万倍，会是这样吗。

肯定不可能，绝对不可能，为什么，因为我说过cpu啊，它中间有一个切换的过程，听懂了吗，就是切换得把你把你放进来，把我放进来，你如果1万个线程的话，我要在这1万个线程下来回切换。

所以你整个把资源全浪费在线程切换上了，所以不一定线程数是越多越好。

我们再来稍微回顾一下我讲的一些基本的内容，看看大家是不是能理解，记得我画了个图看看啊，超线程呃，这里是一个小小的线程切换的概念，我记得我是做成了一个动画，为了给大家讲清楚，费了劲了，这是两个线程。

这是t一线程，它里面有指令数据，t2 线程指令数据，所谓的线程切换指的是什么呢，当我们执行t一的时候，t一的内容会装到我们cpu里，当我们要执行t2 的时候，t内容会从cpu里面挪出去。

挪到catch里面去，t2 进来执行，ok就是这样的，就是一个线程切换的过程，这个动画没有演出来，再回来，这个过程我会进下一步进一步完善它，这是线程切换的概念，现在明白了，线程切换之后。

你就会知道这个线程数量并不是越多越好，它会有一个合适的值，如果你特别多的话，它会把整个的时间全浪费在线程切换上，好了，我们回过回过头来看这张图，大家明白了现成的最基本的概念之后呢，我们回过头来看这张图。

这张图呢实际上背后有一个特别重要的问题，这只问题是什么呢，注意啊，我在这里所写的线程，这个线程是什么，这个县城是一个用户所产生的线程，就是我们我们的app自己所产生的线程，但是现在的问题是。

我们a p p产生的线程，一定和我们cpu运行的这些个线程是一一对应的吗，听我说在这儿我就讲到了go语言的最核心概念，同学说，老师您您讲这个java讲完还讲go语言，没错，所有东西都是相通的。

在老师这儿看来，无欲无我，大家都差不多，好好听，假如我们是红颜色的，圆是我们用户级别的线程，假如我们这个颜色的啊，这哥们儿换个颜色吧，好假如这个颜色的是我们操作系统级别的线程，就是俗称的内核线程。

有同学说老师我的app不能直接产生内核线程吗，听我说可以，很多app如果你写的是写的是什么呢，比如说你用c语言写的，你就直接调用了内核的接口，那你直接产生的就是内核线程，但是也有一些应用程序。

什么应用程序呢，比如jvm，jvm是一个虚拟机，虚拟机里面是我们java写出来的那个线程，好，java写出来这个线程和我们的内核线程又是一种什么关系呢，go语言里面大家都知道。

我不知道有没有同学听过这个概念啊，这个概念呢叫做呃携程，这个大家都有多少同学对购员比较熟的有吗，有的给老师扣一听，不懂是吧啊，polaris没有听懂啊，sorry，呃线程的最基本的概念。

我觉得大家伙都清楚，就是一个程序里头不同的执行路径，它并不是说从头12345这么执行完的，而说并行执行，而go语言里面你们知道是怎么起一个这种现所谓的现成的概念，单独起一个执行执行路径的吗。

我看我购物员有没有打开在这里听我说啊，你你你你你不用心教，也不用着急，因为我讲课呢，我喜欢纵横百合，把那个横的竖的都给大家讲清楚，你明白了这些个最基本的概念之后呢。

其实任何语言对你来说也就是点语法的区别而已，好好听我说，作为go语言来讲，大家看这里，这里呢我是写了一个小程序，这小程序呢有一个客户过来，我会用一个方法，这个方法叫handle去处理它。

具体的逻辑是什么，你不用管，你就可以想象成为这是一个餐厅，有一个客户进来的话，我就派一个服务员去处理它，假如我们前面不加这个关键字，那么相当于你的餐厅只有一个服务员来多少。

客户也只有这一个服务员去服务它，但是如果你在前面加了这个关键字，go就相当于有一个客户过来，我就有一个新服务员去服务它，又有一个客户过来，就有一个新服务员，这里头非常像什么。

非常像java里面的现成的概念，现状概念就是有一个客户端连接过来，我就起一个线程去处理它，有一个客户端连接，我就起一个线程，只不过在go语言里面，它这个不叫写，不叫线程，叫什么叫go routine。

叫做go语言的携程这个概念，携程o，而且呢它的这种起携程的方式，或者叫起多线程的方式，多方位处理的方式比java写起来超简单多了，就直接一个关键字就搞定了，这是go语言，叫做天生支持高并发。

哈哈听懂了这块这块大家还能跟上吗，对你就想象着原来呢我们就要起一个线程，new一个thread，调它的star的方法，而在go语言里面，你只需要加一个关键字，go后面跟个方法名就可以不用控制总量的，对。

不用控制总量，我一会儿告诉你为什么不用控制，睡着了是吧，语法糖而已，不能这么理解，大哥，这真不是语法糖，你说出这句话来，我只能说你是一一瓶子不满半瓶子，咣当，好扯得有点远了啊。

注意看这里面有个概念叫做用户级别的线程和操作系统级别的线程，内核级别的线程，它到底是一个什么样的对应关系，好好听我讲，作为java来说，站在jvm的角度，一个java的线程对应一个内核线程，什么意思。

就是一比一的一个关系，java就是这样做的，你在java里面new一个thread出来，站在那个那个那个内核的角度，它就对应的给你起一个内核级别的线程，大家记得这个这个结论好吧，再说一下。

就是操作系统管理的线程和java，现在jvm所起的这个线程是一比一的一个关系，还有同学说老师你这个是一比一，那go语言里面那个是什么呢，go语言里面这个是m比n的关系，而且m远远大于n。

它是一个m比n的关系好，这是什么意思，好听我讲，我看这个图是不是画了，我记得我有印象是画过，画过我就不重新画了啊，看这里，这是go语言里面的模型，go圆面是这么一个概念。

当我们起一个go语言的程序的时候，它会自动化的给你起来一堆的内核线程，就是内核线程已经给你起来了，好假如在go语言里面起一个携程，就是我们go handle school handle。

来一个来一个我就起一个，来一个我就起一个，这个携程是个什么概念呢，这个携程就是这么一个东西，这些节整起来之后会放到一个一个的队列里，好多好多队列放在这里，然后交由下面的这些内核线程去执行。

所以这是go的携程的概念，go携程更像是一个任务，一个task，你不是要求我处理这个任务吗，我就把这个任务弄出来之后，扔到队列里，谁去处理一堆的内核线程，去处理内核线程，而java里面线成什么样。

大家还记得吗，同学们jaa里面成什么样，java面是来一个我内核就对应一个线程，来一个对应的内核线程，那么刚才我们说过，站在操作系统的角度，如果说我管理的线程数特别多的时候，我的效率反而会降低。

所以我们说java里面你要写东西的时候，不能写特别特别多的线程，你要来1万个县城，我告诉你，你整个程序快崩了，他所有的资源都花在线程切换上了，但是go语言里面你随便玩，不限制数量，几万个没问题。

有人说我写几10万字，他是不是也会崩，也会，但是毕竟这个容量比java这个要大好多，原因是什么，原因是它真正执行程序的时候，实际上就那么十个几十个线程，而这个任务都是在这里好好的队列里头，等待着。

等到我执行你了，你就来执行，不到执行你的时候，你就你就跟我这等着，所以同学们你们想象一下，我不知道大家有没有接触过线程池，java里面有线程池的概念，线程池是一个优先启动的一堆线程。

然后呢这里面装了一系列的任务，线程池里面呢去往这个任务队列里头去拿拿拿任务，拿完一个我就执行一个，拿完一个执行一个，拿完一个执行一个，ok，所谓的java的，所谓的go里面的携程的概念。

go routine，非常类似于java里面的线程池，我只是说非常类似，但是并不是完全一致，不完全一致的原因，我尝试讲一下，有点深，不知道大家能不能跟得上，能跟上的，给老师扣个一，嗯嗯，好好听我讲啊。

我讲完你java和go基本上就全全全明白了，甚至包括后面的rest基本上也就全明白了，好地方讲，那么我们说java语言里面呢也有线程池，尤其是他的fog join pool。

就是这个线程池叫fork join pool，它的模型呢和这个图非常的类似，每一个县城都有自己的任务队列，自己的任务队列完全没问题啊，执行自己的任务队列，执行完了之后呢，再合并怎么怎么样，很类似。

有好多个任务队列，每个任务队列里面装着好多任务，但是任务和任务之间他们是不能做同步的，就是说不能说我这个任务执行完了之后，你才能执行另外一个任务后，这件事java是做不了的。

但是go语言里面做了这么一个事儿，大多了件什么事儿呢，就是任务和任务之间这哥俩是可以做同步的，我们之前说我执行完了，你才能执行，完全没问题，我执行一会儿，你执行一会，你执行到什么程度了。

到我执行完全没问题，java是控制不到这一点的，同学们，你们站在go语言的角度想象一下这一个另外一个东西，不就是一个线程的同步吗，所以这就是go语言里面的线程，它中间是要做一些同步，他怎么做到的。

其实模拟了cpu的原理，cpu大家还记得吗，不就是说把某一个里面的数据放进来，放到我们cpu里来执行，然后如果你你你你你执行你执你执行完了，或者执行到一点时时间了，或者阻塞了，把你拿出去做个备份。

把另外一个拿进来继续执行，所以它是模拟了在用户空间模拟了cpu的执行这块儿，我不知道大家听懂没有，所以不能完完全全不能直接说说它就是相当于java语言里面的线程池，就是jav里面的任务，就是一个语法糖。

真不是那么回事，这里面是有一个切换的概念，怎么模拟，大哥你问的有点太多了，这要讲起来就真没完了，怎么模拟呢，程序模拟你java虚拟机都能模拟，如果你想好好听这块，我讲的java虚拟机的内容。

认真听就能理解，就是一个占用栈来模拟就行了，好讲，到现在为止呢，基本上把腾讯问到的问题还是听我讲，这是你听不懂也正常，你因为这里讲到的问题是腾讯大概在70万左右的一个程序员问到的，现在的这样一个深度。

听不太懂呢，也是非常的正常的好吧，大概是腾讯70左右的水平，他会问到呃，整个的这个先程到底是怎么回事，县城和县城的区别又是什么，好你把这个图发给他就全明白了，好了呃。

大概的意思是我从底层开始慢慢的一点点的讲给你听，每一个每一个这个这个这个这个这个概念啊，我大概给大家讲了这个现成的这种模型啊，hospital模型呢大概是一比一go的模型是m bn，你可以写2万个。

携程完全没问题啊，当然rust语言是史上最牛逼的语言了，这个我今天不打算给大家聊这个，这个聊起来又没完了，呃，毕竟呢我们今天聊的是java的多线程，但是有同学可能到这儿可能就会问了。

说老师java里面有没有写程，这里有携程啊，就是你我我我我我已经有任务队列了，我任务和任务之间只要能做切换，是不是java里面就可以支持携程啊，好好听我讲，jav里面呢并没有天然原生的携程。

但是呢有各种各样的类库可以来扩展它，大家伙听到过的有可能是这个叫crazer，还有一个就是阿里内部直接用过，我们曾经讲过的，就是也是阿里的程老师给大家讲的。

这个部分的内容就是本身他们在阿里内部就直接这么用的，killing这块课程也都已经上线了，好，现在java呢还并不支持原生的就支持啊，也许在后面的某一个版本里头，它会原生的支持。

那么go语言相对于java语言的执行上的优势基本就没了，ok，这些基础内容讲完之后呢，下面我们来聊一聊锁，县城本身呢不是特别难，其实难的就在于县城之间的同步了，解锁这个概念好，我们可以继续吗。

可以继续给老师扣一，你们还能坚持住吗。

好我们来聊一聊锁这个概念，好听我讲啊，锁这个东西是一个什么概念呢，它是一个逻辑上的概念，它并不是一个那种一定是某一种写法上的一些概念，大家千万不要这么来理解锁是一个什么内容，锁这么一个概念。

注意第一所是一个逻辑概念，它是一个loading的概念，锁的意思是说呢，要保证一个数据的一致性，必须要采取一些的一些手段，啥意思呢，什么叫数据一致性呢，比如说你要干一件事的时候啊。

你要你要你要你要你你你你要进去干这件事，那么同一时刻访问这个马桶的注意，只能有一个人，不可能有人坐你腿上，然后再来一个在你马桶在，在你在你在你身上同时干这事儿，那你这个马桶就属于处于不一致的状态。

这个就是这个意思，总而言之，言而总之就是在某一个时刻只允许一个线程干这件事，好，这个时候我们就需要干嘛呢，需要上锁，注意这个锁的概念呢是这么一个概念，锁是一个单独的东西，你可以呃你干任何事情。

也可以用任何一把锁来进行锁定，只要是大家伙做同步的时候，锁定是同一把锁就行，从形象上来理解啊，假如说有一哥们儿，这哥们儿叫这哥们儿叫谁啊，我看看欧拉欧拉欧拉欧拉欧拉已经看饿了对吧，那就塌了。

他们要进来干这件事，他进来干这件事的时候，如果说这个马桶大家伙都可以抢，那么为了保证在同一时刻只有一个人能抢到，我们就需要干这么一件事，就是进马桶干事的时候得需要持有这把锁才可以，什么叫持有这把锁。

就是把这个锁给锁上，那有一个门口给锁上，那另外别人要来的时候，怎么就是你当你当你锁定的时候，欧啦欧啦已经进来了，他不是饿了吗，他进来了，他进来了之后呢，锁定了这把锁，然后当别人又有新的人要过来的时候。

同学们，你们想象一下，那这个时候该怎么办呀，又有新的人过来的时候啊，啥情况，ok ok ok好嘞嗯啊，刚才有点小事儿啊，我们同时过来了一下，稍微打断了一下，我们回来啊，如果有人已经持有这把锁了。

持有这把锁的概念就是已经把他给lock住了，已经给他锁住了，好持有这把锁的时候，他就可以进去干这事儿了，那别人来的时候，怎么才能干上这事呢，只有一个办法就是等着把锁打开，等他不持有这把锁的时候。

撬锁肯定是不行的，当然通过通过程序上的概念叫做什么时候叫所持有这把锁呢，我们一般是这么写的，代码synchronized什么什么，然后所谓的干一件事。

就是整个这个大括号里拉屎拉屎拉屎拉屎拉屎拉屎扑扑扑扑扑好，什么事，叫释放这把锁呢，释放这把锁就是整个这里面的事，干完了，大括号结束的时候，ok这个时候这把锁放开，那什么时候别的人进来呢。

有另外的人哥们儿过来，发现这把锁是开的，他就可以尝试去锁，他锁住了归他了，这是这把锁的最基本的概念，好这就是锁的最基本的概念，当然那个从语法的角度上来讲呢，说这把索尼锁定的到底是谁，其实你锁定的是谁。

由你自己来指定，我不知道大家伙的这种这种这种基本的概念到底是一个什么程度啊，我问大家几个小小小的问题吧，比如说我们我们我我我我简单给大家写几个事例啊，看这里就如果这么写。

object o等于new object，那我要是呃这样写的话好，谁是那把锁，这把锁是谁，对就是new出来的object，这就这就是那把锁，听懂了吗，这就是锁定这把锁，这个这个对象就被我当成锁来用了。

当然在这个理念的话呢，实际上是你在里面输出的任何内容啊，噗噗噗噗噗，你干的任何事情，这个呢就是当你持有这把锁的时候，你干的事儿保证在同一时刻只会有一个线程来干这件事儿，放心不会有第二个线程。

必须得得等你这个线程执行完了，释放了这把锁，别的线程才能进来，这个在整体上就能保证数据的一致了，那我问大家几个简单的问题啊，我想问大家这么一个问题，那么假如呢，假如我有一个方法，我是这么写的。

public void synchronized的m好，请大家告诉我，好请他告诉我这里谁是那把锁，谁是那把锁，ok这相当于什么，相当于锁定的是this对象，synchronized this。

所以this是加把锁，ok那现在我再问大家一句，假如我这么写，esthetic signalize the worm，好，这时候谁是那把锁，who对，这时候写的，这时候这把锁是什么，相当于是这么写的。

synchronized t03 ，atomic energy，class。

呃这个比较基础，不需要不需要我专门解释吧。

好既然大家理解这一点就行啊，这就是你凡是你看到sc的关键字的时候，你放心，肯定有一把锁，那么这把锁是谁，那就看你锁的是谁。

你写的是synchronized的o那就是那个o你写的是synchront方法呢，就是this你写的是srt静态方法，那就是当前的class，好了我们可以继续了吗，可以继续，老师可以。

所以大家一定要理解，确确实实，在你写完代码之后，真正的有这么一个锁对象存在的，你记住这一点，然后当然有一个专业名词呢，下面你要干那些事儿，这种在专业上我们称之为叫critical section。

叫做那个呃临界区，这个我们先不去管它，理解区的概念就是放心，总而言之言而总之，同一时刻一定只有一个线程在里边，不会有另外的别的县城，只有等这个线程执行完了，别的线程才能执行好，这个就叫上锁。

这就是锁的最基本的概念，所有各种各样的类型，乐观锁，悲观锁，读写锁，分段所等等等等，但是我们先要理解这个基本的概念开始啊，我看有同学说那个嗯感觉还没有深度讲普及还可以啊，大局为重，嗯，别着急。

还是那句话啊，得从得照顾基础稍差的同学。

系列 2：P26：马士兵老师多线程：3.并发的本质是什么？锁的本质是什么？ - Java视频学堂 - BV1Hy4y1t7Bo

嗯。好，大家看这里，我们继续。那么下面就引出来另外一个问题。当有一个人持有这把锁的时候，别的人该怎么办？这里面呢是这么一个概念。就是不持有所的现成，这时候该怎么办？好好听我讲，不持有所的现程。

一般会这么办。他有两种办法。第一种办法呢就是。这种。嗯。再看一遍，说有一哥们儿进来了，对吧？寒江雪在里边待着，他持有这把锁，陈明过来了。哥们儿，你啥时候玩呀？他在旁边拎着裤子转圈，这个叫盲等待。

O这叫自选等待。自选等待的意思就是当我。我在这里well哥们，你啥时候玩，你什么时候结束？well你不结束，我就在这里转圈，什么时候你结束了，什么时候我赶紧进去。好，这叫做盲等待，拎着裤子转圈圈。

当然还有一种方式，这种方式叫等待队列。等待队列的意思就是说这里边有哥们儿进来了。好，我另外进来的人什么时候轮到我，只要有人持有这把锁，我二话不说，我进入等待队列，我先等着。那这个时候什么时候轮到你呢？

注意，凡是有等待队列的。需要经过操作系统的调度。OK这个时候必须有人调度你才行。也就是说，如果你使用这种。锁定的方式进入等待队列的这种方式是需要经过操作系统老大的，是需要经过它调度的。

所以我们就比较这两种方式，这两种方式有什么好处呢？优势和劣势这种方式是什么？这种方式我就在这里原地转圈圈，转圈圈转圈圈转圈圈。这种方式是我来了之后呢，我就直接进入队列，由操作系统来对我进行调度。

什么时候到我了，把我拎出来，我再去抢。这两种方式。一种叫自选锁，也叫轻量级锁。这种叫轻量级。好，另外一种进队列的要经过我们的操作系统老大。来进行调度的各位，这种叫重量级。当然，轻和重是相对的。

为什么这种叫重量级啊？因为你要对锁等待的这些线程，需要经过操作系统的老大，需要经过厕所所长，需要经过另外一个人帮你调度完，你才能继续执行。所以这种锁叫做重量级锁。

而上面这种锁你是不需要经过操作性能老大的，你只需要写个外循环，在这里等着就可以。那么这种的锁叫轻量级。当然，由于它是原地转圈，我要循环跟这等着，所以它也叫自悬锁。所以到现在为止。

我觉得这几个概念应该弄清楚了，什么叫自悬锁？什么叫轻量级锁？什么叫重量级锁。来弄明白这概念的同学给老师扣个一。我们可以继续吗？好了。当然有同学说这个公平不公平，别着急，那是另外一的概念，跟这个没关系。

那现在就问了。说轻量级锁一定比重量级锁轻嘛？同学说这不是废话嘛？注意他其实背后的问题问的是这个就是轻量级锁的效率。是不是一定比重量级锁的效率高？是这样的吗？自选锁的效率一定是是比是比重量级锁的效率高吗？

当然不是。同学们，你们想一下。假如进来干事儿的这哥们儿。这个这是谁进来了啊？墨斗先生进来了，墨斗先生呢本身。他肠胃比较好，干活比较快，蹭蹭蹭就完事儿。然后别的县城在原地转圈也转不了几圈，转个两三圈。

嘣儿，我就可以进来了。这个效率当然是很高的。因为我不需要经过操作系统的老大，我还要进入队列，再经过老大把我调出来，再来抢索等等，不需要经过这个过程。我就直接抢到了，哇，very good非常好。

同时呢等的人也不是特别多。哎，我进去之后就等两三个人在旁边拎着裤子转圈圈。okK完全没问题。😊，但是现在的问题是，假如等的人特别多。锁定争超级激烈，1万个人在这里等。那么你们想象一下。

这1万个人拎着裤子在这里转圈圈。注意所谓的转圈圈，是你写了一个我要循环啊。是写了个物要循环，物要循环是要消耗CPU资源的。消耗CPU资源的话，1万个人。

CPU就拿把所有的资源都花在对这1万个线程进行线程切换上了。进行context switchitch上网。他甚至都来不及，好多都给你执行的时间都没有。那你想想看这个效率能高吗？一定不高。肯定不行。

所以这个时候我就应该采用另外的方式，发现没有？就是你一万个人人太多了怎么办？进队列进队列我就把你冻住，你老老实实搁那待着，什么时候轮到你，我再把你拎出来。😡，你消耗CPU吗？不消耗，你只扔到队列里嘛。

你有什么消可消耗的？😡，所以当竞争特别激烈。执行的代码时间特别长的时候。便秘的时候怎么办？重量你说。好，不知道我有没有说清楚这个区别，这也是一道面试题。就是自选锁的效率一定比重量机锁效率高吗？

I don't think so，并不是。不同的场景用不同的锁。好，当我讲到这里的时候。我觉得关于锁的最基本的概念，你应该已经建立了。那么下面呢我们来聊真正开始来聊 synchronized这个关键字。

嗯，我们可以继续吗？可以继续，老师可以了。这里呢是给大家打打基础啊。😊，开开胃。每个人的他的那种那种那种基础不一样，我只能招顾稍微呃基础弱一些的，好吧。

呃，下面我们来看这个关键字。

。

好，大家看这里。我们从最基础的小程序开始看，我们来了解一下呢这个signchronnet这个关键字到底是个什么内容。好好听我讲，我先说结论。呃，作为大场的面试题里头有一道经典的面试题，是这个题。

把它调出来。嗯，在这儿。

当场面试题里头呢有一个经典的面试题是这个。描述所的四种状态升级过程，描述 synchronize的重入什么 synchronize的一些东西。Synchronized。还有还有啊人车lock一同嗯。

锁的升级内存布局，vololaattile锁的四种状态啊，这种的都是下面我要讲的内容。磁悬锁一定米状的镜合效率高吗？这个我刚才讲过了。那么听我说。

关于schronize这个关键字。嗯。呃，拿这个关键字来说。这个关键字在最早的时候最早的时候指的什么时候呢？就是JDK的1。01。2这个版本的时候，这个关键字直接使用重量计算。啥意思？

就是我们说JVM不说过吗？JVM要起一个现程的话。它对应的内核线程是1比1的关系，对不对？它就会直接起一个内核线程。好，这些内核线程呢会去抢一把锁，对吧？就是就是他抢这把锁去抢它。抢它的时候。

我们说使用的是重量级锁。重量极锁的概念就是操作系统老大帮我调度。所以在最早的时候认真定最早的时候。是这样的。当我们看到这个关键字的时候。操作系统会接管。对应的线程。谁抢到了这把锁以及锁之间的同步。

以及线程之间的同步的状态？由他做好了之后反馈给JVM。GVM才能继续运行。所以它中间经过了一次倒手，你发现了没有？就JVM起了这个现程之后，得交给操系的老大帮我进行锁的管理，说到你了。

okK反馈给GVMGVM继续执行。我跟你讲，这个叫重量级。所以。synchronize最早的版本，这个关键字最早的版本，它的效率非常低。因为每一个不管锁什么样，不管有几个人竞争，他都要经过操作系统老大。

中间加一层加一层调度。本来我一个人能完成的事情。当然我就一会完成就行了，可是不不好意思，你得必须得中间加加加一老大来帮你做完这件事之后，反馈给你，你才能继续执行。所以这个叫做重量。你所最早的时候。是。

好啦。这这个奇奇奇怪怪的符号说有点不明白为什么需要内核线成强，不需不能。我不跟你说，最早的时候嘛，这是JDK最早的实现，因为这种实现最简单，你懂吗？就JVM这种实现最简单，等来该我管的事儿，我不管了。

交给谁去管，交给老大去管，你想想看我是不是省了好多事很多事儿。😊，这是最开始的时候。后来大家伙实在受不了这个schronnet的关键字了，本身用特别多，但是你效率又特别低。后来大家哎。

后来大家实在受不了了。咋办？终于。JD可以在后面的版本里头陆续对schronize这个关键词进行了优化。进行了版本更迭之后的优化，说大哥，你能不能上来，不要一下就去找老大去申请那把重量级锁，你别这样。

你不要这样，你能不能上来先。😡，做一点简单的，比如说最简单那个自悬锁，你总是能完成的吧。😡，好，这就是它的一个升级的过程。从最开始的时候，只有重量级锁，到后面呢经历了一系列的升级。

中间会产生一个自悬锁的状态。所以现在schronize真正执行的时候，它的过程比较复杂。Okay。为了讲清楚自选锁的原理以及它的升级过程。我看看啊，9。1刻，我大概需要花半小时到45分钟的时间。

来准备好的同学老扣一。嗯。好了，同学们。我们现在说这个自选锁这个概念，刚才我说过了啊，自选锁呢是在用户空间就解决问题了，就不需要经过操作系统老大了，不需要经过操作系统，用户自己就能解决问题。

那在线程数量比较少的时候，在线城执行的速度比较快的时候哈，这种方法它会非常非常的方便。所以针对于用户空间的这种锁，用户空间的这种锁。😊，这节K1。5之后。

推出了一系列的JUC的这个内裤下面的各种各样的锁。呃，为了让大家理解这个东西，我写了几个简单的小程序，大家认真听。我们先看这个小程序，这个小程序呢给大家一点点时间读一下啊，这应该比较简单。

就是我现在有一个变量，in特类型的M等于0。我呢起了100个县程，100个。每一个县城对这个数。给他加1万次M加加。最后我们得到的结果，正常的情况应该是100万。ok来。稍微给大家几十秒时间吧。

你把这小程序读一下，看能不能读懂。就干了这么一件事儿。就是我现在有一个资源。M。好多个县程，100个，每一个县程对他加了1万次，最后的结果应该是100万，这是我们理想的结果。好啦。这个程序大概能看懂吧。

有同学说latch是啥？大哥，这个叫门栓，是新型的一种锁。这如果你读不懂的话，没有关系，我就是用它来让整个线程结束的等待线程结束，好吧。嗯。当然这个小程序执行一定是有问题的。

我们把这个M的结果最终打印出来是多少？本来正常应该是100万的，我这是好3万多，我天哪，差这么多。本来应该是100万的对吧？但是他只有3万多，为什么？原因是。我分析一下就知道了。

它会找好多的呃加的加的结果。比方说M现在等于8了，那我第一个线能拿拿出来的时候。OK第一个线程拿出来，我把八变成9，把九往回写，对吧？写成写回成9。第二线程拿出来到CPU里面啊。他也把八拿出来了。

他也改成九了，8就往回写。所以呢呃本来正常的情况下，你应该是十的。但是由于呢大家伙一下子把这个八拿出来，又写到这县城一写了，在县城里大家都加成了9，最后一覆盖，最后结果还是9加了两次，最后结果还是9。

所以最后一定是达不到100万。😊，那现在问题呢。就是。怎么来解决这种问题呢？以前有同学啊当然这是我明天我明天想跟大家讲的概念啊，这个有同学说老师我加volt是不是可以？大哥。😊，我先问大家一个问题。

我在这里加vollatail，最终结果可以不可以，可以吗？😊，肯定不可以啊，注意vololaile只能保证两个东西。😊，一个是现成可见性，一个是指灵虫歪序。好好听我讲，我明天会给大家讲vollet。

但是我要求大家给我做一点小小的预习，能做到吗？就是你稍微理解一下什么叫volttail。vollettail有一个叫现成的可见性，这个也是牵扯的底层牵扯的比较深的一个概念。呃，明天的时候啊。

大家给我做一点小的预习，你起码要理解vololatile的线程可见性指的是什么？好吧。好。我们继续加vollet条肯定不行，因为你只是保障了现程可见性。我这边改了之后，另外一个线程可见。但是呢。嗯。

我需要把程序重新执行一下。嗯。没有地不啊，不去管他。但是你看到这个数字啊，96348虽然比刚才那个大了一点点，但是数字依然不对。呃。关于vollaile，如果你理解不了的话呢，咱们明天再讲。总而言之。

言而总之，你在这件事上加volatile肯定是不行的那怎么样才能行呢？画面卡了。hello hello hello hello，我还在吗？hello卡了，刷新一下啊。😊，这个是直播吗？这个不是直播啦。

这个是录不。理解吗？我就专门针你的录播。嗯嗯嗯。OK现在可以吗？我可以继续吗？可以继续给老师扣一来。😊，好，大家看这里啊看这里。要想解决这个问题呢，我觉得大多数同学都能写得出来，就是我给它上锁嘛。

就是当我要M加加的时候，必须得等我加完了。我这个线程加完了之后，另外一个才可加完写回去，另外一个线程才可以继续加。😊，啥意思？就是刚才我们分析过啊，说这里是八拿过来改成9。

但是同时呢另外一个线程也读出来了，改成9两个人一往回写，最后结果依然是9，这肯定不对。我要求是必须把这个班改成九，等我写回去了之后，另外一个线程才可以运行。

这就符合就是说我上一把锁在我这里噗噗噗拉便便的时候，另外一个人不可以继续拉，就这么回事。这个时候就用到锁了，锁的时候是怎么锁定呢？最简单的方式怎么来锁定？比如说我设计一把锁。

Object order a new object。然后我执行每一个建程的时候，持有这把锁上锁上完锁加1万次，然后另外一个线程才能运行。我们来分析一下。这就相当于。现在呢我有一把锁，就这把锁。

我现在要进行M加加1万次的时候，不好意思，我这个县程必须得拿到这把锁，记住，我拿到这把锁之后才能执行这部分。想象一下，我拿到这把锁之后才能扑噗噗噗拉便便。😊，好，只有我这个线程拉完了，我把这把锁释放了。

释放了。另外的县程才能运行。那么大家你想一下，这个时候最终的结果一定是对的。因为别的县程读到的都是我这线程执行之后的结果。他不会说存在那种数据不一致的现象。new object是全局的吗？

这不是局部的吗？大哥魅方法里面的有什么全局不全局的，记住我再跟你说一遍，这把锁锁定谁都可以，你只要锁的是同一个对象就行。你不能说这个线程锁定的是O，另外一个线程锁定的是B。😡，这个就不行。我讲完这个。

你应该会透彻的理解这个锁的意思了。当然，这样肯做肯定是可以的。100万完全没问题。现在的问题在于，我们假设现在sronet还是重量级锁。它如果中间没有升级的这个概念。好。他的效率依然很低。所以在。

JDK1。5之后诞生了这个包，这个包叫JUC叫java。呃呃呃呃。叫这吧这吧这吧concurring这吧这吧这吧。优是优是什么来着？java utility对啊。

有java的 utility concurrent啊就是并并发的这个包。在这个包里面呢有这么一个类，我不知道大家理不理解，下面我就要讲自选锁的概念了，就是自选锁的核心是什么？什么叫自选锁的核心？

到底什么叫自权锁？所谓的自权是什么意思？我就来给大家讲这个这个问题，认真盯。打概这里。所以在JUC里面增加了这么一个东东，这个东东呢叫atomicengr，叫原子的engger。

估计很多同学都听说过这个类，但是它类背后的背后的意思，我估计很少有人去钻研它。好，大家看这里啊。嗯。呃，这个attroomiceng到底怎么用呢？我们先说它的用法。

还是模拟我们刚才那程序atomic engine。小M等于缪1个at make engineer，然后它初始值设为0，然后依然是100个线程。但是我们不上锁了。

不上那个至少不上我们那个 synchronize的那把锁了。我们呢在每一个线程执行的时候，依然是给他加1万次。但是这个家我们使用的是叫做M点 increment andge。

就是对这个M increment增加and get，并且拿到这个最新的值。好，大家看这里，这叫做M increment and get。就是替代了原来的M加加。大家还记得吗？

我们写M加加的时候必须得上锁，对不对？但是呢我如果用atomic energy，我就不用上锁了。😊，不用写schronized的了，最后的结果依然是100万，没有没有任何问题。好。

听我说这里面他用到的就是自选锁。也称之为呢CAS它是怎么实现这种锁的呢？CAS是自选锁的实现方式。这个是怎么实现这种锁的呢？来。嗯。看这里我们可以继续吗？可以继续，老师可以。这是CAS的实验方式啊。

认真看。我们把它点进去看它的原码M点increment get它里边干了什么，我不需要上 synchronized。当我们点进来之后，我们这里访问的是atomiceng这个类的。

increment get方法在这个方法里面，它实际上调用的是unsafe这个类的get and at end方法。继续点。我们先不管这个unsafe是啥意思啊，我们继续点进来。😊，当点进来的时候。

你会发现呢在这个方法里面调用了这个方法。这个方法叫compare and swap and。好了，这就是CASCASCAS。Compare and s it。比较并交换。这就是他背后的原理。

这就是自选锁的实现方式。有同学说老师这里面到底怎么实现的？点进去。当然，当你再往里点的时候。不好意思，他是native nativeative什么意思啊？C加加写的嘛？就是hopot的C加加的代码了。

😊，好啦。能看吗？也能看。但是在我给你看之前，我先教大家什么叫CAS。好，可以继续吗？可以继续给老师扣1。嗯。

好，大家看这里。

。这是CAS的一张图，但是你不用换不用看这张图了，我我就直接跟你讲就行了。CAS本身的概念呢非常简单，它全称叫compare and swap。或者叫compare and exchange。

或者叫compare and set，无所谓啊，这就是CAS用来实现自悬锁，用来实现乐观锁的一种方式。这种方式是不需要经过操作系统老大的调度的。我只只需要在用户空间APP空间就可以解决。

它是怎么做到的呢？是这么来做到的。认真听。假如这里依然是我们的M的个值，这个M值它的值是0。现在有一个线程去运行它去对它进行加加。我这个线程把这个零。读到我的现成本地，就是自己的CPU里面给你们来理解。

好，把它算。加成一，再把这个一给写回去。OK这就是M加加的执行过程。那么如果在这个过程之中，我不用我上锁，不用我去锁定什么，这个时候该怎么做呢？是这样来做的，把这个零拿过来。改成一。

再往往回写的时候比较一下，比较什么呢？比较你现在的这个值跟我期望那个值是不是一样，什么意思呢？就是我看看你是不是依然是我期望的那个零，你是不是依然为0。😡，依然为零代表什么？

依然为零就代表着哥们儿在我把你拿过来做加加。往回写这个过程之中，没有任何人改变过你，这个就叫做依然为0。那好了，如果你依然为0，说明没有人动过，你没关系，那我就把你一一给你写过去。

这个我不用上锁就可以完成。我不用说非得加 synchronized，我就可以完成。我不需要经过操作系统老大的调度，我就可以完成。好了，这个就叫做CAS实现compare and swap。

我比较完了之后，我再给你设为原来的值。好，你先听理论，先听理论。先听理论，你好好听好吧，别着急。你们问的那些小屁问题，我后面都会都会给你解答。你先听理论。😡，好，那有同学说了，老师原来是0。

我把它改成一。但是在这个过程之中，如果已经有人把它改成八了，我怎么办？😊，好听我讲。很简单，你就再把这个八读过来。改成九，把九往回写的时候，看看他哥们儿是不是依然是八。如果依然是八，把你改成九完成。

如果你不是八已经变成12了。没关系，我再把十二读过来，一直到某一次成功为止，所以这是个死循啊。一直不断重试，好吧，成功为止。OK不知道我说清楚没有。这个就是CAS最基本的概念，就是我把你这个值读过来。

改完之后，我看看你是不是依然是我期望那值。如果你是okK我改了。😡，好了，这就是CAS的概念，这就是自悬锁的实现方式。当然。

作为这个咨询所来说，CAS来说面试有两大两大问题两大问题。看这里。我给大家稍微说一下。第一道问题著名的ABA问题。这个问题的核心性就是说这里原来是零，没错，我把你改成一，往回写的时候，我看见你依然是0。

但是你这个零非常有可能是别的县程把你改回8。另外一个线程又把你改回成0，也就是你中间经历了080这个过程ABA。此灵非彼灵。好，像这种问题怎么解决？你的。女朋友。跟你分手之后，又经历了别的男人。

等你回来的时候，发现你的女朋友依然是你的女朋友，但是是经历了别的男人的女朋友。那么你怎么解决？你怎么监控？很简单嘛，你加一个版本号不就可以了吗？加什么volat。你加个版本号不就OK了吗？

你在他的脑门上，在你离开的时候写1。0。经历任何一个人的时候。加一。好，当你回来的时候，发现他脑门上写了99。0，那么你就应该知道okK。你需要原谅他。所以加版本号就可以解决。这是第一个问题。

当然有同学说老师具体的那个是什么样的内容？听我说JUC里面有专门的类，有好几种，有加布尔类型的，有加数字类型的。总而言之，有加那个时间戳的都可以。总而言之，好，这个你加版本号就可以解决。那好。

第二个问题第二个问题才是最关键的。假如就是。CNS。修改值。

时候。

系列 2：P27：马士兵老师多线程：4.synchronized关键字的字节码原语 - Java视频学堂 - BV1Hy4y1t7Bo

我的原子性问题，这是啥意思啊，你听我讲，同学们，你们想想看，现在呢这个是个零，我拿过来改成一把一写回成零的过程是这样的判断，如果你哥们儿，你是不是依然为零对吧，如果你确实依然是零。

那么我这时候把你的这个零给你变成一不就这个过程吗，那现在假设我就问你，如果在你判断完依然为零，还没有改的时候，另外一个线程把它改成八了，你那时候咋办，所以这个肯定不行，如果想完成cs操作。

必须保证cas的操作是原子性的，好这两大类两大问题不知道说清楚没有，有一个我解答过了，另外一个我还没有解答，我一会儿解答给你，到底是怎么保证呢，好可以继续，同学老师可以来，你们还还还还在听吗。

还能跟上吗，ok看这里volatile行了，volt明天讲吧，为什么你们对volatile有这么多的执念呢，你觉得他能完成所有的事儿是吗，别扯volt能干的事很少好，大家看这里。

那么它到底是怎么来保证的呢，回过头来看我们的源码，刚才啊我们跟跟跟跟着cs代码，跟跟跟跟完之后跟了一会发现他是native了，这是unsafe这个类。

这个类unsafe这个类里面一个native的代码能不能看，完全可以。

如果你要看的话，打开c加加代码。

看这就是c加加代码，有同学说，老师您别这样讲完go讲java，讲完java讲c加加，这哪这哪跟得上啊，大哥你想挣七八十万，上百万，跟着我的思想思路走就行，而且真的没有你想象中的那么难。

因为难题全被我解决了，你跟着走就行，黑色看不清没关系啊。

像老师这么体贴的男人，你放心。

像老师这么体贴的男人。

肯定是都给你写在了笔记里了是吧，就是说在笔记里给你详细的记录，如果你想跟进来，跟着c加加代码的时候，去哪里跟，很简单，去哪里跟呢，诶去哪个类里面哪个方法里面，哪个方法里面哪个类里面直接去跟就可以啊。

笔记会提供吗，当然会了，明天吧，明天我修改里面修改一点里面的内容啊，可以可以没问题啊，tomorrow，这个c加代码怎么打开，这个稍微有点复杂，你得需要下载open jdk源码，然后搭建测试环境。

然后把代码给打开，我是直接给你打开的，好大家看这里我们继续继续来聊，我们刚才聊过啊，说在那个呃java的代码里面，我们已经读到什么地方了，就是当我们调用cs的时候。

实际上呃它调用的是unsafe这个类的compare and swap对吧，还记得吗，当然如果你要找c加加代码，实际上是在这里注意看它也是unsafe的cp嘛，然后找对应代码。

在这找叫compare and swap in，笔记我已经给你详细记录了他是在哪行，所以你要想读的话，跟着我笔记走就可以，我们来跟踪一下这个cs到底它是怎么实现最终比较的，原子性的这块儿还能跟上吗。

能跟上给老师扣一来，大概就是c加加，你可能不懂，但是你跟个大概就可以好，大家看这里，当我们得到这个方法的时候，compared swan，其实你往下读。

你会发现它调用的是atomic这个类的compare and exchange方法，看到了吧，compared and exchange，好，那我就跟进去呗。

看看这哥们儿里边儿due to definition，definition比较多，我就直接定位到最终的这块就行了，最终就在这儿，在这个呃头文件里面就a tonic linux x86 的实现。

原子的这个类在linux上x86 的这种架构上的一个实现，到底是怎么实现的呢，在这atomic这类的compare and exchange方法呃，我这个字体能放大吗，我看一眼放掉在哪里啊。

为大家放大一点啊，这是哪个方法，好我们来看这个方法，下面我们来看这个方法，在这个方法里面它到底是怎么实现的，它是一个汇编的实现，a s m叫ember，ok汇编，汇编语言实现。

这个汇编代码里面呢是这两条指令来实现，叫lock if mp以及compare and exchange。

好了，同学们，这个过程呢我就不直接给你这么一点点详细的演示了，你呢看我们这个笔记，在这个笔记里面跟踪来跟踪去，最终的一条实线就在这叫lock if mp。

然后后面呢是跟一条指令叫compare and exchange，我先说结论，听我说，先说结论，呃跟不上了吗，还能跟上吗，跟不上，要不然今天就，懵了是吧，呃呃呃呃ok ok我慢慢稍微回顾一下啊。

我们稍微回顾一下，大家记得吗，上来先解了现成的概念，然后讲了锁的概念，锁的话呢是一个synchronized的对吧，呃但是呢为了提高效率，除了synchront之外呢，它提供了j o c的包。

在这个dc的包里面使用的是cs的方式来上锁，c a s方式来上锁的意思，但它就是我们刚才分析过cs的概念，就是比较并交换，然后呢面试题里头呢有第二道就是比较并交换的时候，你要保证原子性，它是怎么保证的。

怎么保证原子性，我现在已经讲到这儿了，好，是不是稍微稍微就是梦梦一点的同学，是不是稍微可以继续了，不用死机，不用死记啊，好大家看这里啊，马上就要攻打山头了。

我们现在就是最核心的是我要保证c a s的原子星嘛，对不对，cs原子性怎么保证的呢，注意看最终的实现就在于就在于一条汇编语言上，这条汇编语言叫做lock呃，compare exchange。

当然呢中间呢有一个叫lock if mp，我稍微解释一下这个lock if mp，这人听我讲mp的意思叫做呃log a presence，不对，好像有问题，呃sors，哈哈哈。

mary processors k叫做多核多个盒好吧，好看这里啊多处理器啊，我是故意的，我是故意的，我看看大家有没有在认真听讲啊，好叫做多核多核处理器，前面加lock，单核处理器只需要一条指令。

所以我们先得出第一个结论，所谓的cs在最底层是由谁来支撑的，是由这条指令来支撑的，这条汇编指令，这条汇编指令叫做compare and exchange，所以我们说这么难理解。

就是一个cpu去访问内存的时候，完全可以有一种方式，这个方式就是c a s方式，就是这条指令来完成，你这里有零，把我这cpu拿过来改成一，我马上就给你写回去，比较一下好。

这个就叫做compare and exchange，但是在多核的时候，前面必须加lock，原因是什么，你们考虑一下原因是什么呢，我们再画个图，这是这颗cpu，就是另外一颗cpu。

通过一条总线去访问内存里的某个值，第一个cpu把这里拿过来的时候，注意用compare and exchange指令改成一把一往回写的时候，发现你依然是零，我就可以把这个零给你给你变成一了。

但是问题就在于，这条指令是不能保证原子性的，原子性不能保证就会发生什么情况呢，so把零拿回来改成一判断一下你依然为零，这个过程有可能另外一个cpu已经把零给改掉了，这是不行的。

那为了让它保证原子性怎么办，就干这么一件事叫lock，请大家记住这条指令，所以几乎所有cpu都支持的一条汇编指令，这条指令叫lock，lock的意思叫做锁总线，左总线是什么概念。

就是我这颗cpu在执行后面这条指令的时候，compare exchange把总线锁住，只让我来用，别人不能用，好了，这就是在汇编语言的一个实现，ok，好看这里我再说一遍，在这里面有一个误区。

有同学说老师我单核cpu就不用加lock了吗，大哥加洛克的原因主要就是说执行后面这条指令的时候，不被其他cpu打断对吧，保证原子性吗，那我就想问你一句，你自己在执行一条指令的时候，都能把自己给打断吗。

自己先把自己打死，再去打，再去打敌人是吗，先把自己杀了再去杀人，不可能，所以只有在多核cpu的时候，当然现在都是多核。

所以最终的cs的实现就是这条指令叫lock compare and exchange，呃我们稍微回顾一下，我估计讲到从讲到讲到现在呢，有小伙伴们有可能有一些些些些些许的晕菜是吧，晕菜呢也很正常。

我先跟你说一下，因为这里呢是真是少说50万年前左右的内容，所以有点云才是正常的，呃不着急，是我慢慢给你捋，我呢最开始给大家讲的呢就是现成的一个最基本的概念。

以及呢线程用户空间的线程和内个内核线程的一个对应模型，jvm是一比一，go on呢是m比n，这没有关系，多线程访问的时候需要了解锁的概念来来保障数据的一致性，最最早开始的时候，像java这个锁。

最早开始的时候要经过操作系统的老大来帮我调度，这个叫重量级锁，后来jav进行了优化，诞生了ju c这个包，这个包里面有各种各样的工具，比方说reenterlock，比方说a tomic integer。

好这些东西它背后的原理是什么，它背后的原理不是重量级，它是在用户空间解决的，这个叫做轻量级锁，也叫做自旋锁，它的实现方式是什么呢，它的实现方式是c a s cs的概念，我给大家讲了，零。

写回来比较依然为零，给你改成一，但是比较的过程会产生两个问题，第一个是aba问题，可以加版本号来解决，第二个是必须保证比较并交换这条指令的原子性怎么保障的呢。

最终我们根根根你就会发现是用这条指令来保障的，好，讲到这里的时候，任何面试官在问你关于这方面的问题，你就可以吊起来揍他了，js里面都是cs实现的，对这uc里面全都是cs实现，好了，呃我们那个可以继续吗。

我讲到现在为止问啥是cx compare exchange，compare exchange，就cs呀，比较并交换呀，刚才不说了吗，你为了50万年薪，是不是也该拼一拼，对不对，讲到现在为止呢。

我基本上讲清楚了，就是死c a s是啥意思，轻量级锁对吧，重量级锁又是啥意思，重量级锁，但是现在我还没有给大家讲所谓的锁的四种状态，就是synchronized的实现原理，听我听我说。

新版的synchronized他比较牛逼，它并不是像原来那样直接使用重量级锁，在synchronized的执行过程之中，它实际上经历了一个所升级的过程，看着脸，我们先说结论，还是那句话啊。

学东西呢先学脉络，实际上呢现在的synchronized他经历了一个偏向锁，偏向锁，偏向锁到轻量级所，也就是c a s，也就是自旋锁到重量级所的一个升级过程，今天还来不来得及给大家讲升级过程啊。

允许我来杯水了，我知道你们有各种各样的问题，主要我给你省略了很多细节，这个没招，第八大奇迹你都问了好几遍了，读一读atomic reference。

那个那个那个那个atomical stamp reference那个源码一看就明白，很简单的啊，为什么喝水让我们看着，因为我要有有段时间不说话，你以为我去世了吗，我让你看着，表示我还活着好吧。

这个过程呢相对来说也比较复杂了，讲完的话估计俩小时呃，我呢先给大家讲一点初步的内容好吧，听听听这里面有几个概念啊，第一个概念呢叫做偏向锁，第二个概念那叫轻量级锁，第三个叫重量级锁，我先解释这三个概念。

其实有两个概念，我已经解释完了，轻量级锁，完重量级锁下面还有一个锁呢叫偏向锁，偏向锁是面试的重灾区，这是面试的重灾区，这里面的细节超级多嗯但是呢我我基本上也都给大家写在了文档里啊。

你只要是愿意朝着更高的薪水去努力，稍微花点时间就把它拿下，并不难，你只要听我讲就不难，ok我可以开始了吗，今天讲的内容不难吧，是不是很多概念也就明确了嗯，聊一聊啊，今天聊最后一个内容偏向锁。

然后我们给大家演示一点小程序好吧，请开始你的表演，我就不表演，初学者能听懂，对我是争取让初学者都能听懂啊，你认真听就能听得懂，至少听力大概嗯好西瓜超人已经饿了，我们先来聊偏向锁这个概念。

所谓的偏向锁是什么概念呢，偏向锁不是一种错，他不是锁，严格来讲他不是锁，不是说要插进钥匙去把这把锁给锁定了之后，好下面的执行的时间片就归我了，只有我一个线程在这里面可以运行，不是这么回事儿。

偏向左的意思是这把锁非常非常的轻，比那个轻量级还轻，它严格来讲不是一把锁，他所谓的占有这个坑的，别的都是都是上锁对吧，它不是它是什么呢，就直接把名贴在门上就可以，比方说雨我看见了雨了是吧。

哎雨说这是我第一个人，他作为第一个县城想进来占有这个坑，想拉个便便，雨呢就直接把自己的名字往上一贴，pg往上一贴，ok搞定好了，这个坑归我了好了，这就是偏向所有同学说老师这太简单了吧。

那跟那个别人要抢那把锁有什么关系呢，认真听我讲，这把偏向锁最关键在于不用抢，只要你第一个线程过来，这把锁就是你的就偏向于第一个县城，所以偏向所最关键的是不用抢，你懂吗。

只要把这个id号把你现成的本人的名字往上一贴就可以，有同学可能就会讲了，说老师具体到底是怎么实现的，贴在哪儿呢，我一会用代码演示给你看，你就理解了好吧，我先给你讲概念，偏向锁就是把自己名字往上一贴。

不用跟其他人去抢，锁好了，这把锁归你了，那有同学可能就会说了，说老师，如果你这个名字贴在门牌上的时候，有另外一个哥们儿过来了，欢乐马来了，说你这个雨啊，怎么在里边老不出来，我来了。

你凭什么还继续再往里边怎么办，第二个奋斗也来了，田坤也来了对吧，这哥仨都来了，说不行，这个不能老偏向于偏向于你一个人，我也要抢这把锁，怎么办，升级，怎么说把你的名字给扯下来，擦撕下来，然后大家伙开始抢。

怎么抢转圈，c a s方式，自旋的方式，拎着裤子转圈，谁抢到，就算谁的，谁把自己的名字贴上去，谁持有这把锁好了，就算谁的，这个叫第一次锁升级，第一次锁升级就是从偏向锁，然后直接升级到了轻量级锁，自旋锁。

但有同学听到这儿呢可能会有疑问啊，说老师这事儿不对啊，这个为什么要有这么一个偏向锁，那我上来之后，大家自选抢不就完了吗，为什么第一个线程还要偏向他一下呢，是不是大家会会有这个疑问吧。

有这个疑问能给老师扣一，丢不掉，这里面的内容稍微深一点啊，你认真听，大家知道啊，呃有一些那个类，比如说vector，比如说hashtable。

啊比如说那个像还有什么那个那个那个那个那个那个string buff，这些类的应该都听说过吧，好这些类里面的方法有一特点，这些方法都写了synchronized。

里面有一个方法方法全写了synchronized，好，那我就想问你啊，我们先假设根据呃整个的工业界的一个调查，虽然说这些方法全上了锁了，但是在百分之七八十的情况下，实际执行的时候只有一个线程在运行它们。

你们可以自己回想一下，有的时候你们自己就调用了里边这个方法，但是真的会有多线程在抢吗，百分之七八十的时间只有一个线程在这里运行，好了，那这个时候你就想了，如果百分之七八十的时间只有一个线程在这运行的话。

当我需要synchronize的时候，我我我我我我我锁竞争的时候，我总是要竞争一下的话，这个效率就太低了，我能不能这个县城来的时候不让他有所竞争，直接往上贴一个id号就可以，你直接把自己id贴到这儿。

就可以把这些名字往上一贴，这样就省了很大时间的一个所竞争过程，省了竞争过程，效率是不是就提升了，我们再说一下，假如不存在这这把偏向锁，那么我是不是看到synchronized的，我就得动用竞争机制。

即便是你只有一个线程，我也要你参与整个竞争机制，你得上去做个演讲，竞选是你这把锁才归你，所竞争jvm内部一个管理所的过程，你可以想象一堆代码得了得帮忙让你管理整个锁的这个过程，假如没有偏向锁这个事的话。

你这个代码必须得启用，让即便你只有一个线程，你也得经历这个代码的流程之后才能拿到这把锁，所以偏向锁，严格来讲不是一把锁，就是第一个线程来了，我就假设没有竞争，假设都是你运行在百分之七八十的时间。

你就你只要直接往上一贴就是你了，不知道这个大概的意思，我说清楚没有，还有没有同学有疑问的，懂了是吧，嗯好了，这就是偏向锁，那有同学说了啊，当然这里面呢其实，有一些特别复杂的面试体验啊。

我们稍微过过过一点点，看看大家能不能接受，1p不稳定，废话当然不稳定了，你贴上你名字什么时候所升级啊，只要有人过来抢，就得进行所升级，听懂了吗，我再说一遍，只要有你把你名字贴到这儿了。

只要有一个人过来抢这个锁，就必须得升级，因为这个时候就有竞争了，听懂了吗，就俩这哥俩得抢了，谁抢到算谁的了，ok，好了，所以偏向左呢就是为了优化那些百分之七八十的时间。

只有一个线程在运行synchronized的代码所设计的一把锁，我觉得最基本的概念大家应该了解了是吧，嗯，好那下面的问题呢我们就来看一眼这个偏向所能，彭彭第一个线程来的时候，怎么知道不需要竞争大哥。

如果你是jvm，你就知道你要是jvm，你就知道听懂了吗，jvm代码里面自己判断呀，对一个线程是线性组，两个线程资源所yes，无锁，大家记住啊，无所这个词最好别用，就这个词儿是特别恶心一词儿。

无所这个词儿你们最好别用，非常容易产生歧义概念，这玩意儿啊是大家发明出来用来方便交流的，以前原始人的时候不知道这个东西是什么，只能说这这这这这个这个这个这个说不清楚，后来大家发明了一个概念。

是这叫便便好，以后一说便便知道什么意思，有人发明这个词儿叫吴所，这个词儿太讨厌了，这个词无所原来的意思叫做没有重量级锁，所以所谓的自选，所谓的cs它都叫无所，但是呢后来又又又有人把这个教程自旋锁。

那他那无所到底是不是到底是不是把所别抬这杠理解什么意思就行，你不要跟孔乙己似的，搁那纠结，回字有多少种写法，没意思好吧，我们可以继续了吗，可以继续给老师扣一哇，十点了，领会精神就行了。

对啊就是没有重量激素，原来这个意思啊，好大家看这里，我们来看，依然会回到这张图啊，我靠我都觉得讲的有点多了，你们你们还能撑得住吗，完全没问题是吧嗯，能给老师来宣传课程了，行一会给你宣传啊，很有意思。

对打开这里锁的四种状态是哪四种呢，new出来刚刚new出来，没有锁的状态，偏向锁状态，轻量级锁状态，中量级锁状态，这就是锁的四种状态，中间有一个各种各样的升级的过程，所以偏向组来说。

什么时候升级成轻量级锁呢，其实非常的简单，你好好想想就知道了，就是只要有一个人过来跟你抢，就得把你这哥们儿撕下来，不把你撕下来，撕下来之后，咱俩开始抢对吧，这时候就就就设计成轻量级锁了。

轻量级锁就是大家拎着裤子转圈在那等，你就想象形象一点，知道吗，你自己拎着裤子转圈转，转来转去的，在那等着说，轮不轮到我了，轮不轮到我了，ok这个就叫轻量级锁，重量级所示，猎人裤子的人太多了。

实在是那个cpu忙不过来了，怎么办，扔到队列里去，那现在问题就在于什么时候轻量级会生成重量级，能这个呢细节其实比较好玩，需要我讲嘛，基本上就是判断你旋转多少次，比方说你拎着裤子转了十圈都没轮到。

你不好意思进队列，等待的人太多了，我cpu最多能接待20个人，你现在都来了四个人了，不好意思进队列。

系列 2：P28：马士兵老师多线程：5.自旋锁何时升级重量级锁 - Java视频学堂 - BV1Hy4y1t7Bo

好了，这大概一个升级过程，有同学说老师这个东西能看出来吗，大哥绝对可以，当然如果让你从代码上看出来，得需要给你补充一个知识，这个这个类库呢叫j o l，请大家记住它很好用。

那个叫jl叫做java object，layout，知道吧，对象布局好，认真听我讲，这也是一道面试题，今天讲的面试题的概念就是特别密集啊，看这里，作为刚刚new出来的一个对象，它由四部分构成。

第一部分叫mark word，第二部分叫class pointer，第三部分叫instance data，第四部分叫pein，感觉讲的挺慢的，正式可以这么慢吧，正式课比这快多了。

因为正式课我都会先给你打好基础，直接给你讲了，公开课嘛，照顾还是那句话啊，照顾水平稍差的同学，大家每个人呢都是站在自己的屁股上来考虑问题的，考虑问题的，从来都只考虑自己的，对不对。

其实呢呃希望大家伙能够有一个站在对方角度，考虑问题的这么一种思维，当你建立了这种思维之后，你的人际关系就会慢慢变好，你的人脉关系也会慢慢变好，你将来的发展，现在没有那种说单兵单兵作战就全部就能完成了。

没有好吧，看这里，一般来说当你有出一个对象来的时候，它由四部分构成，还有同学说老师这四部分我能看到吗，完全可以，这四部分呢你可以用goool这个类库来看到，我给大家演示一下，大家看这里啊。

我new了一个object出来，object o等于new object system out blog，打印打印什么呢，我使用了一个类叫class layout，pause instance。

解析一个对象的布局，把它转成可以打印的类型，然后把它打印出来，就这么简单，我们来看看一个对象，就像这个new object刚刚new出来的时候，new完了之后，它到底是一个什么样的效果。

里边这个内容到底是个什么东东，这块呢稍微有点基础知识啊，我们一点点看，注意看，这是刚刚尿出来的这个对象的大小，16个字节，看到了吗，也就是说你new了一个空对象，里面没有任何任何成员变量的时候。

16个字节，这是美团那一道面试题，他说当你new一个object的时候，占多少个字节，16个，这什么鬼，这个慢慢听嘛，别着急，这是二进制，就是你new一个对象，new出来是不是扭到内存里了，对不对。

内存里分配了一块空间，装了你这个对象好，你这个对象内部是怎么布局的，就显示出来了，压缩后可以12个，你不要跟这扯淡，你给我压一个，让我看看，好了同学们，我们可以继续了吗，消消气儿，没气儿，我就喜欢怼人。

怼人有一种乐趣，大家看这里啊，前面的八个字节，这四个这四个加起来好，这部分呢叫mark word，听我说这个词儿你给我记住就行了，mark word，有同学说老师我记不住莫及，作为老师这么体贴的男人。

你猜怎么着，当然我给你的这个理念呢就全都有啊，mark word，ok放心啊，里面全有market，里面word里面装的什么，里边全写了，所以你记不住也没关系，好吧好，大家看这里，总而言之。

前面八个字节是mark word，后面四个字节是什么呢，这四个字节就是这部分，这四个字节呢是class pointer，就是new出来的这个对象啊，是属于哪个类的，你可以认为它是一个指针，它指向谁呢。

指向object，第二class，你又出一个object吗，它属于哪个类的呀，object class class，page，好，后面部分如果你有成员变量，里面装的就是成员变量。

如果没有成员变量给你对齐，对齐是什么意思呀，对齐的意思，如果你不能被八整除，给你变成被八整除，比如说咱们前面三个加起来是多少个字节，12个字节能被八整除吗，不能再加四个，变成被八整除。

也是后面四个是补出来的，关于对齐这个概念需要我解释吗，需要我解释的，给老师扣二，凡是q2 的计算机的底层的知识应该是一点都不了解的，没有关系啊，听我说形象来理解，就是你可以想象一下装一个货物的时候。

袜子电脑一堆，我们装的时候如果是散装，它实际上效率并不高，我们要往船上运的时候，往往是采用集装箱的方式，即便是你这堆货物不满意，集装箱没关系，也会还能给你一个一整个的箱子往上撞，所以这个叫对齐。

为了提高效率的，当然讲到这儿，以前有同学跟我抬杠说，老师你不是跟这扯淡，你你你你本来是二个字节，你干嘛非得往后补四个字节，你去掉四个字节不行吗，他也是八个字节呀，也能被八字节整除啊，多好大哥。

您这个思路我我我我我我算是非常的佩服，不是您您您您老买张床是吧啊，结果往往上一躺发现你诶腿出来了，人别人说都是把这个床加长，您老人家的思路是把腿给砍折了，牛逼，天才啊，开个玩笑啊，哈哈哈好。

这是对齐的概念啊，好我们这我们今天讲的并不是这个，我们主要是讲这个就是mark word这块，还有同学会说老师你注意看看，这里跑一下，重新跑一下啊，所谓的所升级在哪里进行观察呢，注意看。

当我们刚刚new出这个对象来的时候，这里面，这里面呢是它的那个mark word的内容，在这里，感觉，感觉上是没有初始化的过程啊，稍微等一下啊，我把这个清理一下，跑一下，好大家看这里。

这是我们刚刚new出来的一个崭新的对象，这是那个崭新对象，mark word的内容，看到了吧，就这部分内容，那，下面我们来观察一下，如果给这个对象上把锁，注意看啊。

这个对象上把锁的意思就是synchronized的o吗，不就是给这个对象上锁吗，那我上完锁之后，里边会产生一些什么样的变化呢，我们来比较一下，跑一下，为什么每次都让我清理一遍呢，奇怪，版本的问题吗。

哦我知道了，我看这里啊，重新跑一遍，今天最后一个知识点了啊，大家坚持住坚持住好看，这里这就是刚刚new出一个对象来的时候，内存里面的情况，这是给这个对象上完锁之后的内存的情况，同学们。

你们猜猜看这部分内容是个啥，版本号，所信息，所以所谓给一个对象上锁，你发现了没有，就是修改一个对象的mark word，就是把自己的id号贴到这个mark word上好了，就是这个概念。

还有同学说老师我能观察到这个所升级的概念吗，完全可以，但是你这个时候得认真地观察，这里面的每一位代表的是什么意思，这个的话呢，今天实在是内容太多了，今天应该是搞不定了好吧，关于所能内容还非常非常的多。

代播广告是吗，明天继续，明天继续啊，来一波广告打广告吧，老师为什么你们这么喜欢听广告，来游戏有想听广告的没，老师扣一，好吧，为什么喜欢听广告，好吧，介绍一下我们课程吧。

今天讲的课程呢是那个呃这里面的一部分啊，首先大概就是我们课程，我们课程是m个知识点，m个知识点，单个项目构成，上面这里的每一个都是一个知识点，下面这里的每一个都是一个项目，项目驱动式的知识点。

学习这样的一个方式，我今天讲的内容是多线程高并发的，其中的一部分就是关于锁的，这就是synchronize这部这部分通过方法非通方法所升级的，这个过程大概是给大家讲的这部分呃，这是去年的一版。

我今年的讲新版新版的内容呢是从底层开始讲，就是还是有同学因为因为因为有同学理解所的时候，理解不够透彻的原因是因为它底层的知识不足，他不是说那个理解能力不行啊，呃不知道今天讲的怎么样。

今天是也第一次使用量的方式，从底层开始慢慢给大家抠，呃，这块大家觉得还可以吗，有收获的同学给老师扣个一吧，好不好，ok ok呃不一定满足每个人的口味，但是我觉得呢大多数同学应该是有些收获的。

嗯关于所升机的详细过程呢，我们vip课里的专门有讲啊，呃今天我就不带大家一分析了，那个还是挺复杂的，呃我呢也都给大家记录在了我们的笔记里，这个笔记的话呢，明天我稍微做修改啊，我里边有些东西呢。

我以为做更新了吗，会有些修改，修改完之后呢，是可以发到大家的，ok，这块呢是，整个这个课程中的知识点的一小部分了，这课呢比较复杂啊，内容也比较庞大，我先简单给大家介绍一下我们的课。

我们课呢大概是有1500个课时左右呃，有同学说老师我不理解你是什么概念，这么跟你说，大多数的你在同学的同学可能看到的课，200个到300个课时是这样一个体量，我们这个课是这样一个体量，好吧。

这有一个对比，大概是他们的七位吧，价格上的话呢远远到不了他们的七倍啊，一倍多啊，111倍一点点，总而言我有同学可能会觉得奇怪，说老师你们为什么讲这么多课时，因为很简单，我要讲给你讲的细和深。

又细又深又长，只有长才可以好吧，给你讲细了，讲深了，只有把课时变长才可以，就是基本上是不惜成本吧，来给大家讲这件事，讲完之后呢，比如说有同学说老师学完你们这课到底有什么效果吗。

其实详细内容我先不给你解释啊。

我们看效果，我最喜欢看效果嗯，因为每天我基本上都能收到我们学员学完我们课程之后的，一个很好的效果，每天最希望收到的就是这样的消息，这个是我们大龄的跨行的一个成员，学了两个月，迎来世界第二春，老师周老师。

我是什么什么我就不说了啊，同事叫过评审方案评审设计评审快2年了，工作11年银行的都有，都是使用c语言加数据库的，c r u d java很渣，数次自学都被打断，然后新来的领导说架构也要编码，完蛋了。

编编不了怎么办，快抑郁了，课程的学习两个月，已经可以在中心级来讲公开课了，内容就是gmm同线程高并发锁和同步器，在领导眼里，我就是复合型人才，给大家带来了第二春是吧，我就要求大家能不能帮我做一个好评。

他给做了一个啊。

多谢他这个呢是跨行三个月涨薪5k呃，看完课程面试一点都不虚，g m g c调参数。

多线程锁a q s数据库调优redis，杀进美团涨了13万，现在美团给的最高的薪资40x15。5，62的年薪比我现在的35x14 49多了13万，他还不是特别满意，还想再试一下什么蚂蚁阿里。

我个人的对他的建议，先把美团的offer接下来，接下来之后再慢慢的来进一步的找更好的更好的地儿是吧，学了一个半月，拿到了七个offer，涨薪5k6 哥，我知道你会拿我打广告，我再给你点细节。

学习时间不到三个月，也就一个半月多，另外不止两个offer，全算上的话，应该是七个offer，大家体会到我们课程的牛逼之处了吗，这课程有好的时候呢，我给你解释半天，里边讲什么讲什么，讲什么，真心不重要。

我们课程的最重要的特点就是你呢带着脑子来就行，老师让你学啥，你学啥，老师让你干啥，你干啥好，剩下的所有的一切交给我们，考研失败后学习，疫情期间搞定三个月，两个半月京东美团的offer涨了78k。

算法学习，京东离职入职腾讯大厂里头，京东给的薪水是最低的，腾讯给的比京东高很多，原来19 三变成31年啊，1年雅信博斯的offer不知道怎么选，连易容复为重offer不知道怎么选，反正算上都快40万了。

大厂谈薪水啊，开始谈薪水了，一个多月涨薪6k离职，一个月入之后涨薪4k23 岁三个月入职滴滴，涨了11k这哥们儿就23岁，原来就是就就14k直接干到dd 25仨月没好好学。

仨月涨薪8k我都没好好学是吧好呃，也有很高的了嗯，这是入职阿里p7 的股票，也有了民营专科，干了两个月，两周拿了五个offer，半个月年薪涨5万，一个月入职滴滴。

入职平安，薪水翻了一倍，30岁干到腾讯60万年薪，好了呃，如果大家需要想了解这个每一个的细节来敲这个，自己去看这里的所有的聊天记录，所有的人没有一个不支持被调的。

所以有的时候呢我也懒得跟大家解释课程到底里边讲些什么呀，升什么级啊，这个比较比较麻烦一些，我就直接给你看效果就行了，我再稍微给大家聊一聊这个课程的内容，好我刚才说了啊，课程的时长比较长，内容比较多。

m个知识点加n个项目，关于项目关于知识点都非常多，好那现在问题是1500个学时，人家200个到300个都得学好长时间，1500个学时，我怎么学才能学得完，来有这样的疑问的同学给老师扣个一说。

我到底怎么样学习才能学习这些内容特别多的东西，认真听我讲，这是我们的核心，我们核心是这样的，那个对每个学员进行一对一定制，什么叫定制，好好听我讲，我就根据你个人的一个诉求，根据你个人的一个水平。

根据你个人的一个基础的掌握程度好，我来帮你设计学习路线，我给你举个最简单例子，比如说如果你是应届生，或者说你是大学生吧，你想进大厂实习，对不对，研一的有有好些，研一报我们科的，大二报我们科的。

他就特别想去大厂实习，很简单，7+1+1帮你搞定，我就帮你设计好这个路线，你沿着路线走就行了，你只要带着人来，我告诉你学啥，你学啥，剩下的全交给老师，你说简历怎么写，面试怎么面，所有的剩下的全交给老师。

我要求你学啥，你学啥就行了，你说社招生社招想进大厂怎么玩，6+2搞定，你说我想进头条这一类的，对算法特别看重的左老师的算法课搞定，你说我没有跳槽的压力，我也不想涨薪，我就想全系全方位提升p8 课程。

带着你所有的知识点一代多搞定，你说大哥，我零基础什么都听不懂，刚才这节课课我全都没听懂，从a课程到p课程一条路线帮你搞定，我觉得我们最牛逼的一点是在这儿学习的任何学生，第一没有一个人后悔。

第二没有任何一个人说不长心的，说我不涨薪水或者搞不定工作，放心这儿没有没有任何一个没有啊，呃这也是可以向大家推荐我们课程的原因好吧，是真的吗，马老师真的，老师对你我所说的话，任何一句话都负责放心啊。

这是我们课程的整个内容，当然如果要详细给你解释内容的话，应该比较多，大家伙啊，就可以像这些个课程的这种呃详细的内容里边打开来，每一个都都都都是什么意思，什么都呃什么意思，每一个项目的白皮书。

项目最终的落地板都有最重要的是什么呢，其实最重要的呢还有一点叫做升级，很多同学可能不理解升级什么概念，就是我们基本上年年升级，所以你最简单的例子，像网约车从传统那个去写c语言的这种。

c这个c r u d转向互联网的这样一个项目，我们已经升级到第三版了，好天天有升级，年底升级，那么有同学可能就会说了，说我升级能升成什么样呢，我想给你看看今年的升级，你们还能还能跟得上广告吗。

今天有书吗，今天已经抽完了，明天有，明天有，其实老师的广告全是干货，你往这看就知道了。

今年我们升级了是p8 架构师。

这个就是报完课，这个课也是可以给到你的，这一课叫做p8 架构师，注意这里升级的是架构师，我不知道有多少同学了解过市面上的架构师，但是我直接就告诉你啊，市面上所有的架构师的课程，我们这里全报名了。

我们就想看看，别人是怎么玩了，取长补短，结果发现很令我们失望的一点是，大多数的都是ppt架构师，而且收费还特别贵，两三个月的课，然后那个，收1万~3万吧，1万多到3万。

我们设计的架构师课程跟他们最重要的区别在于落地，ok，找找叔叔也好，在于落地好，这个落地呢大概是什么意思呢，你像很多的架构师架构的一些理论知识，架构理论知识非常多啊，在这里全有呃，比如说那个cp定理。

贝斯定理一直到密等到高可用高高扩展该怎么做呃，到什么那个底层的技术到那个算法到呃。

泰克索斯z a b这种分布式算法到推荐系统的这种机器学习算法，这种理论呢非常多，包括这种分布式应用该怎么设计，单体到微服务架构该怎么设计，微服务到多级缓存该怎么玩。

多级缓存到超大型的这种呃系统的架构的设计，到service service man是该怎么玩，到我们的这种接入层是吧，网络接入层该怎么玩，dn相关的cd a相关的资源静态化，相关的负载均衡，相关的等等。

到index到分布式微服务，比方说那个每一层该怎么说，网网关层怎么设计架构，这个这个这个业务层怎么设计，然后那个治理层怎么设计，数据层怎么设计到那个分布式微服务的具体实现，spring cloud。

nice，spring cloud，阿里巴巴啊等等等等，就是这些理论上的东西，你放心，这里全有，除了这些理论之外，还有一些比较崭新的理论，比如service mesh怎么落地。

比如说大数据数据方面的处理该怎么处理，比如说我们人工智能就推荐系统这块我们该怎么来构建画像，来怎么给大家做推荐系统，开发这边的c i c d该怎么进行保障测试，这方面该怎么样进行分布式的测试。

自动化的测试，性能方面的测试，而运维这方面要怎么进行服务性的保障，好整体性的理论，放心，这里全有，但是最重要的最重要的一点并不是理论，最重要的一点在这儿，你知道吗，最重要的一点是我们通过一个项目。

这个项目叫再造淘宝，我们做这个在淘宝并不是一个简单的商城项目，而是完完全全的支持千万级并发的超高大数据量的人工智能，进行推推荐系统的这样一个落地的项目，而进行这个落地的时候，我告诉你其实是挺难的。

挺不容易的，我会给你从那个最基本的服务开始搭起，怎么搭呢，打分布式id的生成中心，分布式锁中心，分布式配置中心，分布式事务集群，分布式缓存，缓存服务集群，网关集群，注册中心，监控中心，mq集群。

es集群，调度中心，tended服务集群，mc的服务器群，然后在这个基础之上再进行业务逻辑的搭建，有同学说老师是用虚拟机吗，不是老师，这用的是全是给你买下来的，大概花了60万左右。

我们搭这个环境是一个真实在线的几十台服务器构成，几百个节点构成的这样的一个服务器集群，我讲到这儿呢，有同学可能就会说了，说那个老师我不知道你们有，你们有没有有没有体会过，就说一个理论的话。

如果你落不了地，那很没意思，这第一点，第二点呢，采用完全的虚拟机的这种环境，你好多个集群之间互相是怎么是怎么怎么服务的，你是根本体会不到的，这也是为什么呢。

我们真是愿意花很多的这种这种这种代价来帮大家搭这个真实环境的，原因呃，当然我讲到这儿了，应该有同学会说，老师我们能在这里大真实环境吗，我们大概买阿里云的服务，大概买了60万。

我相信没有任何一个人愿意花钱去做这件事，后来老有同学说，我们能不能干能不能干，我们就投入了一些钱来帮大家做了这么一件事儿，这件事呢得采用这种限流限流的服务了，这是最最接近最近刚做完成的。

看大家能不能接受。

我们搭建了自己的云试验平台，目前我在内网访问，当然，后面会允许大家从外网直接访问。

这是我们的大字体搭建的一个私有云的平台，如果你想在这里做实验的话，比如说你有点云资源池云主机，你就可以创建我们的云主机，现在我们自己内部的云主机运维的产品，divs的产品模板机。

debus运维开发的运维的产品，研发中心的测试机，这是我们内部的私有云平台，可以对外提供服务了，这个大概花了几10万，直接告诉你啊，你如果想做实验的话，那就在这里创建云主机就可以，我就不给你创建了。

你如果想体验一下到底什么叫私有云的东西，其实呢通过大屏的监控，你大概就能观察到整个云的运行运行情况，我不知道大家能不能体会到，就是为了做好一门课，其实这边花的心思超超级大啊，大家觉得不知道你能体会到吗。

能体会到的，能体会到老师扣个一吧，好不好，还是那句话，我觉得贵点便宜点都不太重要，最重要的是呢，你呢把你脑袋带过来，你想干嘛，想涨薪，想跳槽，想进大厂，跟我说，帮你设计好路线，按着走就成。

伴着走就会得到你想要的效果，当然你要说那种不切实际的，我会告诉你这个想法不切实际，只要是你差不多的老师都能给你找出路线来，也这是我们存在的最大的目的啊，呃课程呢其实本来想明天再跟大家聊这个课程价格呀。

打广告啊之类的，但是今天同学说想听听，我们那就打开打开看，今天呢是嗯我们一个大额的优惠，这个优惠呢是放心啊，今天应该比明天便宜，我们是一天比一天贵的，这个课去年的时候6000多块钱呃。

今天呢大概是12000多块钱，实名，今晚上十十个，抢完为止，7000的优惠券，优惠券放完就没了，六期免息，我会开始讲多线程了，报完正好跟上第五期的源码课程已经开始了，报完正好跟上go语言rust。

腾讯要求我们玻璃听懂了吗，拿走，腾讯说，你们就这么点钱给了n多的课，人家别人是20块钱，30块钱，111学时，我们是五块一学时，知道吗，我们课时量是别人的七倍，价格大概都他们的两倍不到，腾讯说。

你们赶紧把你们课给我剥离出来，剥离着麦，所以大家抓紧最后的机会，想听go rust，就这一类的存着分析的这种课来，明天就没啊，报名获得内部书籍三本三本，晚上十个数完为止，还是那句话，我觉得课程贵一点。

便宜点，1万多块钱吧，那个效果为主，就是你生病了，这个药管事知道吗，你要说仨月我让你涨，不把这钱赚回来，先退你，嗯那个周老师周老师在吗，周老师陪我跟学生聊聊天，我得那个太空一下膀胱，你岁数大了是吧。

膀胱有点顶不住了啊，学生党，学生党有免息还可以分期，这个都可以啊，大概分完一个月也就一两千块钱吧，但是你记住这一点，这个数额花的这个企业投资出来给你的是一个什么效果呢，一个崭新的升级空间。

所以大家千万别犹豫，刚刚毕业的呢，刚毕业的，我建议你看你想干嘛，想跳槽，涨薪的，来仨月让你涨上去，如果说那个你想进大厂的，我帮你规划，大概得进大厂，时间时长上稍微长一些，需要学的东西比较多一些啊。

没学历，只想在现在公司有可能吗，你们公司有空间就完全没问题，你们公司没空间，啥也别说，跳槽那个赵老师没在，明哥明明哥陪大家聊会儿啊，老师这膀胱有点顶不住了，嗯，岁数有点大，大家欢迎明哥嗨，大家好。

马老师的彭公顶不住了，我得顶一下，我顶一下马老师的风格，哈哈哈哈哈哈哈喽哈喽哈喽，大家好，我是咱们马士兵教育马老师下边的一位主讲老师叫张一鸣，在咱们这个课程里呢，我也会给大伙讲好多东西。

应该有很多同学之前听过我上课吧是吧，哎对这个张一鸣和我那还不一样，恰恰是一个口一个鸟，我这个呢是一个日一个月一日1月对吧，它是一口一个说话，这个味儿就不太对呢，感觉好像在开车，其实并没有。

然后我们嗯哪天呢在腾讯课堂呢也都会给大伙上课，也是轮着老师来的，咱们这次马老师训练营嗯，这次是两天的对吧，今天呢只是头一天，也就是第一天，明天还会再有啊，明天还有嗯，对于这个。

你看我刚才有个同学说34学java还来得及吗，其实我比你应该大两岁，讲道理说应该你是86年的，对不对，我是八四，我是八四的，我今年36，日本那年34学java，如果你是零基础的话，其实有一点困难。

岁数比较大了嘛，可能也有家庭，有这个嗯负担了时间上和精力上的，可能不像咱们年轻人那样，没有家，没有这个呃这些这些牵绊的东西对吧，但是如果你要是想做这件事的话，什么时候都来得及。

褚时健搞储城的时候就已经七八十了，另外就是迈巴赫那位老爷子，也是80多岁的时候才开始搞这个迈巴赫那个品牌才开，才刚刚开始做起来的是吧，嗯所以这个真正想要做一件事，什么时候都不晚，主要是看你究竟想不想。

如果你想的话，比如说在上学的时候，咱们同桌的你对吧，我记得我上我上小学就那样暗恋同桌的小姑娘，不敢说，但是呢心里老是心心念念的去想这件事，一旦要是有一个可以可以的这种方法提供给我的话，那种暗恋的感觉。

待会儿知道吧，有点想要为他付出一切，只要你可以对吧，那如果你要是对于这个学习来说，对于你的事业来说也有这种想法的话，只要是可以对吧，那给我提供一个方法能够成功的，那我愿意付出我的一切的努力。

嗯可以啊对吧，我们现在就有这套方法，如果你愿意的话，我们赶紧来嘛对吧，成为我们的vip当中的一员，帮你一起去追求你的梦想，追求你的同桌，追求追求你的那个你是吧啊，嗯对于贵和不贵这件事来讲啊。

每件东西呢每件事大家有事他也都是有价值的，那你吃药有便宜的，200块钱一盒的药，还有2万块钱一盒的药对吧，治治病呢要看疗效，便宜不便宜的，贵不贵的，这是另一回事，马老师已经回来了是吧，王老师回来了。

我待会儿再翻译马老师吧，刚刚聊了会儿，又走了好多人，呵呵好尴尬，能不能允许我吃个瓜啊，哈哈哈哈尴尬啊，哈哈哈哈，老师比较关注大专有戏，不看这个就行了啊，那个，这是个大专生的简历，他是32岁大专。

这个简历大概是原来的时候是35000的月薪啊，sorry不是原来的时候是25000的月薪，他新找的工作呢是35x15呃，35000月薪发15个月，9000股股票，60万~70万年薪，大专没问题啊。

放心大专有的是一个大包，有结果也可以替换一下课吗，目前不行，这个大包很大，这个大包的课，如果你在线下学是10万先上6万多，今天12000多，你如果想选一门任何一个课，可以选，没问题啊。

但是你选出来的课呢未必有这个价格，未必有这个价格，知道吗，所有课还是不分课分，这里是java的，所有课怕坚持不下来，如果你连两个月三个月都坚持不下来，你想让我说啥，大哥而且你不用坚持，你知道吗。

还是那个就是你啊，人过来，我今儿告诉你一个星期把这个给我学完，另外一个星期把这个给我学完好，四五个星期之后去面试，涨5000块钱行不行，就这么简单，就这么简单啊，太没钱了，我不我还白嫖，不要脸嗯。

那个随你啊，那个其实钱这件事赚出来的呃，我说的难听和直白一点，就是人之所以穷，他想变富，哎我还在吗，哈喽还在。

系列 2：P29：马士兵老师多线程：6.02什么是CPU缓存L1 L2 L3？ - Java视频学堂 - BV1Hy4y1t7Bo

扣个一，我得给你拎出来那张图，看一下啊，在我的，能找得出来吗，来看看看这个薪水，就当老师扫盲了是吧，来吧，一到家立马开机上课，不是应该开课上机吗，学完if能听懂吗，完全没问题，字节跳动，对。

出去谈工资一般怎么定位，一般比上家涨个30%到50，我希望大家伙拿到这个薪水啊，这是字节跳动，也就是take talk在美国开的工资，当然人家是个博士，ph d，yes，84万美元，50万的股票。

24万的津贴，10万的签字费，希望大家有朝一日拿到这样的一个薪水啦，哈哈哈哈哈嗯，只要你肯学这行，能给的薪水还是蛮高的，只有在上坟的时候才看过这么多钱，其实等别人烧给你这么多钱的时候。

也许你就什么都看不到了，你就已经见我们马家门的最后一位牛逼人士，马克思通知去了，这是在这上出来的吗，然而并不是哈，我们有ai的课，但是达不到博士中水平，pp 8课程教程大概要多久，快的3月，慢的2年。

好滴小兔纸，新娘新娘考博，其实这个博士呢是已经有7年的工作经验了，你见过最快的是三个月，yes字节二杠一的飘过，二杠一是什么水平，好像听上去比较低的，p8 也是要博士学历吗，不是还有一分钟，说的很对。

8。05，我们准时开球，84万刀，也是打工仔100万刀，你在这说来说去说风凉话，你也是个人键盘侠，谁都会当那叫高级工，学spring源码，看什么书，跟连老师的spring源码课，一般人都都p7 都费劲。

肯学p7 就没那么难，普通大学刚毕业，正常多少工资，普通大学刚毕业，不要在意工资，找更好的更大的企业去做好，我们开始讲技术吧，好不好，聊了半天废话了，来准备好的同学给老师扣一，有没有第一次来到课堂的。

我简单介绍一下公司跟我自己本人了，有没有有的话给老师扣个一来，反正都是要扣一的好，我就当有人是第一次来呃，第一次呢我稍微简单介绍一下咱们的公司。

拿错ppt了，就是这么的帅气。

哎。

啊嗯第一次来到的小伙伴啊，我稍微介绍一下那个我们公司呢叫马士兵，教育好那个我我我我叫马士兵，哈哈哈喽，我们呢是编程腾讯课堂的编程类目唯一的一个最受欢迎的课程。

这也是站在站在站在学员的角度评的唯一的一个奖啊。

我们拿到了还不错，这是本人大概批了200多遍。

好就不看了，除了我个人之外呢，我们有一大堆的牛逼的老师，我觉得牛逼老师带牛逼学员在这呢我就不一一介绍了，有两位清华的老师，我和周老师都是毕业于清华，有一位北大的博士后泸定罗老师，他是前腾讯的ai的主管。

然后呃在北大的博士后毕业，掌区的cpu好，把bat歌的老师在这儿全有百度的，知道老师，阿里的黄老师，陈老师，京东齐老师和陈老师嗯，阿里还有一位那个那个那个呃徐老师，然后腾讯的呢罗老师。

那么海江老师呢是原来前掌去做游戏，月流水过千万的呃，我们的小姐姐呢是留学北美的博士，来教大家英语的一些方面的课程。

呃叫带我们算法课程的老师呢，呃此人姓左名左左，左冷禅，没有，他开个玩笑，左成云，左左老师呢是ibm，百度amazon都待过，算法教学呢已经做过6年了，带的学生进到头条，别提高tmd p的非常的多。

这位老师是那个左老师的助手，tom cat老师，这这这位老师比较严厉啊，我一般都懒得介绍他，曹鹏飞，曹老师是原来阿里的老师，他是因为阿里的一线的开发人员。

然后呢被我拉过来来给大家专门讲课，呃，就是这位老师here，他这是我们的曹鹏飞曹老师啊，目前在我们网约车第三版呃，李娜李老师呢是我们的呃，运维的老师，也是我们私有云的搭建者呃。

我们最近有一个私有云的平台已经上线了，正在搭建之中吧，也不能说完全上线，呃就是来给学员们开放我们自己的一个私有云，这个私有云呢就是你你你你你可以创建你自己的云主机，嗯，因为好多人呢在做实验的时候。

比方说几十台服务器这样的一个这样的一种一种实验环境，它实际上它在自己的机器上怎么搭都搭不出来，那这时候怎么办呢，在云上，在云上帮你的呃，你创建好了之后，就不给你不带你创建了，创建好了之后呢。

直接就从远程的那个shell上就可以执行任何操作，我看看我我我又没有权限运维的产品，互动模板机的通用性，一停止，在对面的测试环境一般是沉到它是内蒙mysql，这是我们搭建p8 的时候的一些建设的机器啊。

呃这个呢是主要由原谅李老师带着他的团队来帮咱们搭建这套东西，测试这边的老师呢姓陈，叫陈记，这个大家在网上一搜就知道他是原阿里的老师，也是现在为阿里提供测试的解决方案的老师，黄俊华老师呢是前阿里的老师。

前美团的老师，他呢24岁从美团离职的时候，差不多是百万左右的年薪，呃我觉得我请老师呢，我是想请给大家请到最牛逼的老师好吧，不仅技术牛逼，而且还能表述出来，而且呢还能有给大家的一种激励的这种机制才更好。

所以呢在这边请的老师呢都不是那种泛泛之辈，也希望大家伙能跟上他们的步伐，嗯，呃京东的呢有咱们的孙老师，他带完咱们的11月的课了，呃为什么普通普普通通的一个室友，我要请京东老师来讲，其实非常简单。

就是我想让大家伙理解呃，cho像这一类的东西在真正的大厂里头是怎么运用的啊，这个非常的重要，目前呢孙老师正在带activity的课程，呃，阿里的我们pc的程老师给他们带过killm的课程已经上线了。

kim呢是我昨天讲过的一个概念，就是携程在java里面的一个实现，我还有很多学生也是很牛逼的，其实啊但是呢他们不是非常的方便出来讲课，那这时候怎么办呢，做我们的课程顾问，从p6 到p 10。

咱们的课程顾问全都有，因此大家伙在工作之中遇到了什么各种各样的不知道的解决方案啊，找我们问就行了，丢给老师就可以，我们的是位于北京市海淀区的文教产员a117 ，等疫情过去之后。

欢迎大家在周末的时候参加我们的线下沙龙。

ok公司呢我就介绍完了，我们开始今天的内容好吧，好可以开始了吗，好可以开始的方案了，扣个一开始啊，嗯。

好今天呢是我们高薪养成计划的第二天呃，我今天主要给大家介绍这么几个概念呃，cpu的内存缓存，什么叫缓存行缓存一致性协议，for sharing和它的编程技巧，cpu乱序执行的概念，乱序执行。

我向你证明d c l为什么不能使用，不能不能乱序，那么volatile如何阻止允许内存屏障是什么概念，为什么look at lj 0能实现volt两个作用，最后一道题关于线程池的面试题呢，我们看时间。

时间如果不够的话，那么今天可能讲不了嗯，看时间吧，好不好，放轻松了啊，放轻松了听呃，今天知识呢很好玩，也是很多面试官呢特别喜欢问的问题，我们一点点来聊这件事好吧。

好了我们开始啊，首先呢我们来聊一聊呢，就是作为计算机来讲，它的一个最基本的这种结构，其实昨天呢我讲过这张图了，由于有有小同学呢可能是今天第一次过来，我稍微的再给大家复习复习。

作为计算机来说最核心的两个组件，一个叫cpu，一个叫内存，我们的一个程序静悄悄的躺在硬盘上，qq。ex e，当你想让它运行的时候，一双击它唉b它就跑跑到内存里，分配了一块空间，分配一块内存的空间。

给他分配好它相应的资源，然后开始运行进程，这就是一个进程，进程呢是我们资源调配调配的基本单位，真正开始运行的时候是线程是吧，哎线程呢是程序开始运行的基本单位，真正开始运行的时候什么样呢。

就是在我们内存里头呢，有指令，有数据通过总线传到我们cpu，数据会存到我们的register里面，指令的位置会放在我们的pc里面，然后开始计算结果，计算好的结果返回到内存里去。

这就是整个程序的一步一步的执行过程，当然这里面呢有一个很重要的一个点，就是他们两个的速度不一致，cpu的速度比内存速度大概要快100倍，这边跑了100步了，这边只走出来一步。

所以就会产生了一个什么样的一个一个一种情况呢，你们可以想象一下，cpu这边呢做了个计算，然后下一步要去内存里头拿个数据，结果呢他就得等99个空的时钟周期就得在那等着傻等着它，速度太快了，内存速度跟不上。

他为了提升这个效率，实际中工业之中是怎么做的呢，实际工作工业之中呢是在cpu和内存之间多了很多很多的线程，sorry，多了很多很多的缓存缓啊，缓冲区缓存，好看这里，这是现代工业的计算机里头呢。

关于呃缓存这块儿的一个一个最基本的结构，我就直接把它画在了ppt上，大家理解就行了，作为速度最快的单元叫做寄存器，当然速度最快的单元其实呢是我们的a l u就是呃c计计算单元。

计算单元要去访问这里面数据的时候速度最快，然后访问储存内存的时候速度比较慢，大概是慢100倍，为了提升速度，在他们中间加了一系列的缓存，这个缓存目前根据工业实践得出来的最好的结果就是三层。

有同学老是问我，老师为什么不是四层，为什么不是五层，为什么不是两层，为什么不是一层，好了，这是跟工业实践之中测试得出来的结果，你记住这个就行了，就是三层，目前用的最多的就是三层。

缓存的最基本的概念应该不需要我讲吧，我觉得应该是不需要啊，缓存的话呢就是那个用到的数据最快的放在我们最近，离离我们最近的位置，呃原来曾经有这样的一个测算，从cpu计算单元l u到寄存器访问一个数据的话。

它大概是小于一个纳秒访问访问我们的l one，也就是我们的一级缓存，它大概是一个纳秒访问，二级缓存大概是三个纳秒访问码，三级缓存大概15纳秒，访问主存的时候大概是80个纳秒。

他们之间的大概从从从最头的这开始到最后，这大概是100比一的一个关系，那好在这儿呢我给大家讲一点非常基本的一些小小的概念啊，呃以前有同学了，总是不理解说老师这个l3 在哪里啊，l2 在哪里啊。

l one在哪里啊，呃呃呃呃r一在哪里啊，等等，听我说大家看这个图，你大概就能理解，那么每一个缓存到底在什么位置，每个缓冲区缓存到底在什么位置，这是我们的主内存，读一个数据的时候，去a r u需要计算。

需要一个数据，这个数据在这他会首先去哪里取取，从lo one里面去取，如果没有到l two里面找，如果l two没有到l three里面找，如果说这没有到我们的主存里面去找，它是一级一级。

这么找出来找下来的，从物理结构上来讲，l one和l two位于一个cpu核的内部，当然有的一颗cpu里面有好几个核，比如说这颗cpu这一颗cpu整个呢它里面有两个盒。

那么每一个核都有自己的l2 缓冲区和l two缓冲区，所有的核共享一个l three就是每颗cpu里面有一个三级缓存，第三集，不知道大家能不能看清楚，来这块没有疑问，同学老师扣一，很简单，ok。

那现在问题就来了，当我们读数据的时候，从内存里头读数据，我们来分析一下，从内存里读一个数据的时候，我可以按照一位一位的来读，就只有一个位，一个比特，也可以按照一个字节来读，也可以按照一大块来读好。

我们读的时候到底怎么读呢，是用到了一位的时候，我就把这里一个小位，一小位就读到缓存，然后这小位再读到缓存，这小位在读到缓存适量的吗，并不是，它是按照一定的长度来的，一定的块儿来的。

他读的时候是从内存里头，比方说我只用到了这一个数据，我并没有用到其他的数据，但是我会把一整块都放到l3 里面，都放到l2 里面，都放到l一里面，它是按照一块一块来读的，有同学说老师为什么呀。

为什么我不能用一点，我就读一点不行吗，这个程序呢有两个原理，程序运行的时候两个原理，这两个原理呢一个叫时间局部性，这个稍微的稍微学术一点啊，大家大概一听就行，这两个原理呢一个叫做时间的局部性原理。

一个叫做空间的局部性原理，所谓时间局部性原理指的是什么呢，当我执行完这条指令的时候，挨着它的指令很快就会被执行到，空间局性原理指的是什么，当我读到这个数据的时候，挨着它的数据很快被执行的。

如果你这个想象不到的话，你可以想象一下，这有一个数组，我们对数组做一个循环，同学们，你们想象一下这个数组的循环是不是我循环完第一个马上循环，第二循环，第三循环，第四个，所以你们想象一下。

如果说我每次只拿一个数据过来，我下次再拿第二个数据的时候，我还要从内存里头找一遍，放到我们缓存，放到缓存，放到缓存，反而这个效率会变低，我还不如直接去内存拿一次，慢慢拿过来，你还要填充中间的缓存。

所以这个肯定不合适，因此空间根据空间局部性原理，每一次拿数据的时候，最好是成块的拿过来，好这个问题不知道我说清楚没有，也是按块读取，根据程序的局部原理可以提高效率啊。

同时呢充分发挥总线cpu针脚一次性读取更多数据的能力，他一个针脚一次性只能读一位，他64个针脚，那就读64位，连着读好几次就能读好多个字节，应该没问题啊，很简单，那现在问题就来了，那这一块到底是多大呢。

这一块到底是多大，好好听我说，这一块儿呢目前先说结论，目前一块的大小大概是64个字节，请大家把这个结论给我记住也很简单，64个字节，有同学又开始抬杠说老师为什么64个，为什么不是128，为什么不是两个。

为什么不是三个，这里面依然是工业实践得出来的折中值，啥意思呢，就是在实践之中，人们发现缓存行你可以定得非常大，你一次性把内存一半全读过来，那才爽呢，但是你读取的时间读了一下的话，读取的时间比较慢。

另外呢你也成不开那么大个儿，你的缓存如果能重开整个内存一半的话，那你干脆就不要内存，直接全用缓存就行了，所以缓存量越大有它的优势，也有它的劣势，缓存越小呢，缓存越小，你一次性进入读俩数据过来。

那速度是很快，但是你马上要去另外两个数据的时候，你又得读一遍，所以也有它的优势，也有它的劣势，那么怎么办呢，人们在工业实践之中发现，64个字节对目前的计算机结构来说比较合适，所以得出这个结论好了。

这里就是64个字节的来历，我们稍微回顾一下，这是一个什么概念呢，我刚刚解释了，其实就是一个按块读取的概念，由于计算单元和寄存器和我们的内存之间，它的那个速度差非常的大。

因此在中间填写填了很多很多的这种缓存缓冲区，这个缓冲区我要在读取一个数据的时候，比如说我计算单元要想读取某一块里面的这个x，我这个我这个cpu这颗cpu要想去读这个x，我读书怎么读呢。

我会优先去我的离我最近的缓存里面找，有没有啊，没有没有，这有没有没有这儿有没有没有没有，怎么办，从内存读过来读过来读过来好，这时候我开始使用这个x开始做计算，那虽然我没有用到y。

但是由于x和y位于同一个缓存行，所以我会一次性的把这个缓存行全都拿过来，ok这是缓存行的概念，同时这一小块有个专业名词啊，就叫做catch line，叫做缓存行，这就是缓存行的最基本概念啊。

所以缓存行就是一小块一小块就这么个东西，记住这点就行好，那如果我另外一个cpu要是用到里面的y呢，同学们，你们想一下，我要用到同一个缓存行里面的y呢怎么办，他会去l3 里面。

他发现这个缓存行已经在l3 了，他还用去内存里面读吗，不需要他直接从l3 里面会机拿过来就行了，换机拿过来他就可以用y了，ok我讲到现在为止，关于缓存行的概念，大家是不是清楚了，来可以继续的给老师扣一。

大家记得这个图，好那下面呢我们来聊一聊，有同学说了，老师这个缓存行真的存在吗，好大家看这里啊，我给大家调个小程序，talk is cheap show me the code是吧，总是得看点呃。

因为看看点代码，好再看这里代码比较多，我找一下啊，就在这，ok我们来读个小程序，在这小程序里面呢，我们来观察一下呃，缓存行的概念，有同学说老师这个能观察出来，可以观察在这里有一个特别好玩的程序呃。

写写看看大家能不能理解是什么意思啊，在这儿呢我有第一个小程序，这个小程序呢先给大家一点点时间，你大概大概读一下十秒钟，15秒，你大概读一下，我给你解释解释，注意啊，我要求大家脑子里先存的一个概念。

每一行每一个缓存行是多大来着，还记得吗，64个字节对吧，接着这个概念每一缓存行是64个字节，好大家看这里，我的小程序呢干了这么一件事，首先呢我定义了一个类，这个类叫这个类里面只有一个成员变量。

是一个long类型的，它是一个x我问大家一句话啊，这个long类型的它是多占多少个字节，这个大家知道吗，long类型的数据占多少个字节，八个，ok这是八字节，再提醒一遍，我们的缓存行是多少个字节。

64个字节一行数据可以装八个long，我定义了一个t类型的数组，这个数组只有两个元素，然后我把这两个元素初始化，a0 等于new t ara一等于6t内存之中呢，你可以想象一下啊，就是一个数组。

这里面装了一个a02 a0 里面有个x2 a一里面有个有个x，然后干一件什么事呢，我干了这么一件事儿，我起了两个县城，第一个县城，修改为零，看到了吗，a0 点x等于i修改了多少次呢，i小于count。

count是1亿次，那么也就是说我第一个线程是修改为零，里面那个x修改了1亿次，第二个线程修改，而a一的x修改了1亿次，你先别着急啊，你先听我讲，我们先来，然后再来看最后的这个这个这个这个结论，看这里。

我先把这个程序跑一下，这个程序最终计算的一个结果值是什么，其实就是计算这个结果呢，整个程序跑完之后，大概消耗的时间是多少，跑一下，1501哎，怎么这么快，我这就换机器了，之后啊，1501啊。

大家记着一点，15011秒五嗯好，这是第一个小程序，这小程序大家应该能消化吧，我们来看第二个小程序，第二个小程序是什么，第二个小程序我别的地儿都没变，依然是两个线程，每个线程改为零的x11 次。

但是呢我重新定义了这个class这个t我们来比较一下这个定义，定义有区别，注意看这是我第一个程序的定义，这是我第二个程序的定义，大家比较一下，这是第二个，第二个里头呢依然是这个t。

但是呢我除了这个之外呢，我前面定义了七个lp，一到p7 ，后面定义了七个lp，九到p 15，别的什么都没变，看这里我们来看它的执行时间，跑一下432诶，刚才是多少来着，1501，这是多少，432。

发生了什么，大家想想看，能理解这件事吗，为什么我在这个地儿前面填充了bug line之后，后面填充了bug line之后，它的执行时间居然比上一个快了这么多太多了，为啥我们来分析一下这个这个效果。

你仔细听看。

这里依然看到一张图，这张图看起来比较直观一些，我们现在假设刚才第一个程序，这是那个x，这是这也是那个x，你把它当成y什么的，没关系啊，总而言之呢，这哥俩非常有可能位于同一行里头。

好位于同一行里头就会发生一件什么样的事呢，就会发生这么一件事，如果你位于同一行，那么当我的计算机第一颗cpu修改完这个x之后，根据我们要保持数据一致性来说，数据的一致性，我这边这一行数据发生了改变。

现在的cpu都支持叫缓存一致性协议，所谓的缓存一致性就是缓存行这个数据一定要保持一致，我这边这个数据这个这行的数据改了，哥们，你另外一颗cpu啊，得去内存里头重新拿一遍我改过的数据。

那么就会发生这样一种情形。

系列 2：P3：马士兵老师JVM调优：3.常用垃圾回收算法 - Java视频学堂 - BV1Hy4y1t7Bo

现在我满了，内存已经占满了，满了之后怎么办呀，我现在要进行垃圾回收了，垃圾回收怎么做，首先第一步找到最根儿上的垃圾，这些都是那根儿上的，这些都是根儿上的啊，通过引用根儿上的找到最根儿上的那批。

由于嘴跟上那p的数量特别小，所以这次的s t w时间不会太长，接下来下一步的标记过程是我的垃圾回收，一边在这里顺着找，哪些是垃圾，哪些不是垃圾，哪些是垃圾，哪些不是垃圾，与此同时。

你的工作线程还可以进行工作，刚才我们分析过，如果你正好把这个是垃圾的，你标出来了，准备把它清掉了，但是呢工作线程工作的过程之中，又有一个引用指向台了，这个东西呢就会产生产生问题，就会产生问题好。

那这个时候呢就在最终一步下一步的时候，再下一步的时候说，你这边先别干活，你给我停止，先让我把那些个并发标记找出来，那些你又重新连上那些个垃圾，给我找我我我我再重新梳理一遍，从根儿上再输一遍，找着了。

这个为什么速度会比较快，这个速度比较快的原因主要是这种错误产生的特别少，所以他最后这步算起来，其实速度也会非常快，最慢的过程其实是这个过程，因为堆特别大，到最后的话就几十个g生生t死。

你在里边找各种各样的关系，他会特别麻烦，这是最耗时间的，他把最耗时间的这部分和我们的工作线程可以同时进行，这个时候就不会产生什么的，就不会产生那种长时间的s t w，不会产生长时间sw。

你的程序就一直会有响应，你点个鼠标下个订单，你的程序会一直有响应好最后一次重新标记之后，把那些有问题的东西做了个整理之后，重新标记为哦，这个已经不是垃圾了，重新把这个错误改过来，改过来之后并发清理。

最后把他最后把这个最终的已经原来的那些这部这批给清掉，cw是啥，刚才没听是吗，stop the world，初始标记的作用是初始标记是找到我们最根上的对象，gc root吗，这些root不会变吗。

他爱变不变，s t w同学们，什么意思啊，我不允许县城工作，我在标记的过程会出错吗，我就问你，数标记单线什么对，三色标记算法，我跟你说，我现在讲最初最最最根本的这个脉络，很多人都还没听清呢。

你聊三色标记不就直接就聊晕了，第一次标记是垃圾还是非垃圾啊，你找着那个非垃圾，你不就找着那垃圾了吗，好先把大体的过程理清楚吧，好不好，gc root指向的不是垃圾，不知道你晕在哪啊，先别着急吧，好不好。

来先把大体的懂了，知道吗，大体懂了之后再扣细节啊，所以这个是cms，我再说一遍细节，这个东西你必须先把大概的脉络懂了之后再扣，不然没法扣啊，看这里就是cms好，所以你会发现来，这里有一个根上的ml。

从分带到部分带，从内存越来越大，为什么会内存越来越大呢，是因为什么呢，看到你啊，原来的你诞生的这个serial的时候，这是最早的seo算法，seo算法一般来说像这种垃圾回收的时候。

分带的这种算法的时候呃，这种年轻代的算法会和老年代其中的一个算法配合使用，比如说这里头比较比较浅的线，大家可能没看太清楚，给你画一下，其实serial是可以和cms配合使用的。

zero也可以和sio的配合使用，但是没有连线的，它不能配合，你不能说serial和super old不行，这是不行的，pu和cms parallel和parallel old，它是配合这个使用的好。

大家听我说seo单线程，你就想象一下你房你家房间比较小的时候，那你妈妈一个人清理清理过来没问题，但是随着内存越来越大，堆的空间越来越大，越来越大的时候，你一个人还清理过来吗，也可以能清理过来。

原来你家三个平方，你妈妈进来三下5÷2就给它清理掉了，虽然产生了s t w stop the world，所以客户那边是感受不到的，因为你速度特别快，你这个垃圾回收线程就停止了。

你的工作线程就开始工作了，所以客户那边感知不到好，接下来呢很不幸的是呢，你家房子变大了，内存变大了，巨大个一层楼，我就问你，当这层满了之后，你妈妈一个人进来扫这个st tw时间是不是超长。

所以内存变大之后，一根线程肯定不够，这时候呢肯定得多个线程，所以这就是为什么说它随着内存越来越大的过程而演进，一般来说，如果非得说估计一下的cereal的算法，大概就几兆到几十兆的内存，也就到这样了。

再大就不行了已经，所以co现在已经见不着了，听懂了吧，那么parallel，他其实现在呢工作的，呃还是有挺多在用的parallel算法，这个呢是一直到现在大概有个几个g吧，几个g左右的内存啊，都可以用。

它，甚至多了的话，十几个g，20个g也也有人在用，这个也没有问题啊，嗯我一会儿给你讲比较好玩的故事，他有的人用了就用满了之后实在清理不过来怎么办，重启服务器，你们看到那些游戏服务器里头。

说不定说啊游戏服务器正在维护之中，请五分钟之后再登录，干嘛呢，重启呢，以前有一个哥们儿，他们家那服务器好像有一bug，死活查不出来，一直不停的会产生，到最后会把内存占满，死活查不出来怎么办。

哎过一段时间重启一次，过一段时间重启十次，就这么着玩了2年，好接下来继续，你们家内存又变大了，同学们，你们想想看，你们家内存又变大了，天安门广场这么大个儿，你就算太100个县城过来，一一百个县城过来。

你来清这个天安门广场，我就问你就算是你这种多线程，100个线程，你来清这个天文广场，你要清一遍，你得多长时间，太长时间了好吧，超长的一个时间，先生曾经有一个，案例呃，他们的服务器在进行一次垃圾回收。

就是一次f g c的时候，整体的垃圾回收，由于内存设的特别，由于内存比较大，对空间比较大，大概是花了四个小时，三四个小时，两三个小时啊，所以拍了两小时来说，这个对于客户来说是不可忍受的，你跟他存钱。

把钱存进去，就等着看数字增长的那边正在进行垃圾回收，等着吧，两三个小时之后给你显示出来，你能受得了吗，所以，诞生了新的，居然没死，cms，刚才我分析过了，垃圾回收线程可以和谁一起啊，你是个g啊。

垃圾回收线程没和谁家，同学们，南京回收线程可以和我们的工作线程一起工作，我们工作线程没有停，虽然是稍微慢了一些，被别人占了一些资源，但是没关系啊，我是及时有响应的呀。

哈哈所以这个是现在的很多很多调优的一个关键，调优到的两个方向，第一个叫调吞吐量，第二条响应时间，其实大多数的在呃面试官问你的时候，多数的都是让你调响应时间，就是尽量的不要让这个s t w时间变得特别长。

你的系统要保持及时的响应，ok所以cms是一个承前启后的，承上启下的非常关键的这么一个垃圾回收器，当然由于呢它是第一个好多的算法呢也不是特别的完善。

所以呢，这个cms呢居然在所有的jdk版本里头，没有任何一个版本的jdk默认是cms，好了来我们再来看这个图。

图呢还有一个关键点没有讲，你听啊，随便着急，看这里，还有同学说老师你还没有将肯定呢，我还没有讲判定了，判定是什么呢。

唉往这儿看肯定肯定他说是is of the word coin collector with use multipgc threads，读一下。

跟那个我刚才讲的parallel scavenge简称p是一模一样的，of the word coping collector with using multiple jc threads，好。

这是新一代的垃圾回收并行垃圾回收喷new new，它为什么叫呃和和原来的p一样呢，是因为它本身就是ps，就是我们的parallel scavenge，它只不过是一种特殊的p s。

他说it defers from parallesky engine，它和paralleskin的区别是什么呢。

is that that has concements that makes it usable with tms，看这里它有一些增强，让他能够和c m s一起工作，它可以组合cms，就这点区别。

其他没有了，好同学们来看左边边这个图，基本快点完了啊，还有最后一个点，这半边就完了，常用的组合cereal和serial old，现在已经很少见了，parallegge和parallel old。

目前1。8版本默认的就是它，同学问你们上线的时候，要是没有指定任何垃圾回收器，就是这歌呀，再问你们做垃圾回收，简称p s加p o又称parallel，pc指的就是这个意思，好给你看一个命令。

先看我java版本1。8，java杠x print tomorrow flags，那个什么java执行的时候把他的common life flags令行参数给我打印出来，看最后一项。

use parallel dc，默认的p s加po。

所以所谓的你们大多数人的调优就是对它进行调优，其实对它进行调优的一个最简单的办法，如果是因为老频繁gc的话，也许你换个垃圾回收器就直接搞定了，好我刚才讲完这几段来，那个能get到同学了，扣一。

好我们再来看一遍，它的组合常用，他俩的组合也常用pu加cm s，他俩的组合也常用好吧，所以其他的虽然说可以组合，你比如说parsevage和sero组合可以组合，但是极少用。

因此你既唉就记这三种组合就可以了，但是你发现没有，这里头居然还有一根细细的很危险的线，就在这儿，cms居然和c o o又连在了一起，这是为什么，我再说一遍，c m s是一个承上启下的啊。

但是呢它是属于前浪啊，背后被后浪拍死在沙滩上的那种前浪，因为cms有一个巨大的缺陷，cms叫concurrent mark sweet，好，你的老年代再大，mark sweep就是叫碎片化，懂吗。

碎片化碎片化产生之后，当我们新的内存不能从年轻在升级到老年代的时候，他干了一件什么事呢，他居然用一个县城把老年代从头清理到尾，我告诉你，我有一个学生遇到过他的线上系统卡了两天，就是cms干的。

因为他们内存超大，然后呢又运行了很长一段时间之后，很长很长的一段时间里边的产生了一些泄漏，自己不知道，最后内存全占满了，实在弄不进去了，这时候谁谁冒出来了，居然是serial old，你看吧，他还活着。

他没有死，他还在干活，但是很不幸的是呢，这哥们儿卡了两天时间，客户那边一点反应没有，服务器，有的服务器是不能断电的，是不能重启的，你懂吗，有的服务器是不能重启的，军房里有些服务器能随便重启吗。

你是在搞笑吗，跟你说有的服务器是不能重启的吗，好，呃我有学生拿他们那个说跟你说啊，就比较好玩的事情和垃圾回收器相关的，现在大多数人用的不就是他吗，对不对，少数人的调优的时候改成了他啊。

现在基本上就是这两个这两个比较多，呃，我现在一般都建议你至少一点半，你其实可以完全搞到搞成gc了，这搞成g一了，没有问题的，其实嗯有一个做游戏的哥们，游戏的服务器。

他们那服务器就是基本上每天晚上22二二十四点还是下午，就是我凌晨两三点钟啊，就发个通知，各位小伙伴是吧，各各各位各位各位各位将官啊，咱们现在先暂停打斗服务器呢，五分钟之内开始维护，哈哈有没有见过。

应该见过吧，12306有没有有没有用过，每天晚上11点开始到凌晨的几点不让买票，有没有，维护知道吗，有很多时候我告诉你，你调优调的再牛逼都没有用，该维护还得维护，该重启还得重启。

所以重启大法是我们必须要掌握的，ok还有一个小伙伴他们是做那个测试的，测试的，有一个工具叫ga，这估计可能做测试的小伙伴都会都会比较少，而这个gr呢其实他bug还挺多的，嗯。

他们的这个服务器全球他们公司在那个越南菲律宾都有分支，所有人都在用这个服务器也不能停，然后这个服务器三天两头的就直接频繁的f g c，你知道吧，三秒钟一次，三秒钟一次，你想三秒钟一次。

fdc 3分之四怎么受得了啊，肯定受不了他们原来的采用的方案重启，不停地重启，后来他把那个日志发给老师，然后知道了，他大概得有前前后后一个月的时间终于解决了，只不过他们采取的解决方案比较土。

第一扩了内存，第二换了垃圾回收器，哈哈我跟你讲，找出代码的bug来，一会儿给你演示啊，好看，这里到现在为止，这种分带式的分带模型的你大致应该了解了，来我们来大体聊一下g one是个什么东东。

大体的这里面每一个拿出来讲三个小时，两三个小时都是很正常的一件事情，好吧，g one到底是个什么东东，先给你讲一个大题的啊，尤其是牵扯到里边的一些算法的时候啊。

而且呢这算法还还特别特别有好多人还特别特特特特别爱问。

这期的讨厌，好这边有个什么东西基本没有分带了，你发现没有，这段叫做逻辑上可以分，在物理上已经不再分带了，g one可以支持什么，可以支持上百g内存，这个我得我得给大家记下来，基本其实好像支持不了。

这样的话，100个亿我也有100个g差不多了啊，几百号称史啊，这是上百g，呃那么，这段后面的cdc和鲜嫩多，这两个呢他们能支持，非礼谁是支持四个t的山洞是值多少来着，反正就是上t了上千g啊。

没有杨英语，为什么y d c采用的算法都是复制算法。

可见你刚才没有认真听，我都讲过了，不要听，先听现在的，不要纠结于过去，你在纠结过去的时候，实际上已经损失了现在正在听课的精力和时间，现在也听不着了，先听现在啊呃从g one开始。

g one也是一个承上启下的，也是一个特别牛叉的这么一个垃圾回收器，从另外开始，终于开启了一个什么时代呢，叫做分区回收呃，分region它不叫分带了，叫分区分区回收，看这里啊。

这g one呢他把内存分成一小块小块的，咱们原来不是分两个区吗，年轻的老年代啊，没了就这俩区没了，当然还有一个什么matter space啊，那那个那个今天的重点不是说他先不管好，所以这样来说呢。

他就把内存直接分成了一小块一小块一小块的region改成region，我相信region这个概念呢，很多同学应该都有把屋子分成一小格一小格的吗，你我们回收的时候就先回收，优先回收这一个小格。

这两个小格子我先回收，你一边在别的小哥玩儿，我先回说这俩小格呢就这意思分成一个个的region，开始终于开始分块儿了，分区了，好这个呢效率就开始慢慢提高了，同学们，你们想象一下，在一个超级大的内存里头。

天安门广场有一堆人在这里不停的扔线团，有一堆线程在这里不停地清理它，清理的时候并不是说我要stop the world，清理整个的天安门广场，而是说我分成一小块一小块一小块的。

我优先去清理那些垃圾最多的小块，什么叫g one gb，一直，垃圾优先，什么叫垃圾优先，优先清理垃圾最多的小块，所以它的名字叫g one，叫garbage first，知道思想听懂了的，给老师扣一。

好看来g one没有s t w，这是一个面试题，g one有没有sw有g one有没有负dc有，好所以这样来说它呢分成了一小一小区，一小区的，然后这一小区里头。

他在这个小每一个小区在逻辑上可以成为a是年轻代呀啊伊甸区啊，还是欧的区啊，还是survivor区啊，或者分配大对象用的among us，巨大的这种这种区啊，所以它逻辑上每个区都可以成为不同的。

原来的那种年代，在物理上已经不再分带了，到了z dc之后，不仅从逻辑上，而且从物理上也不再分任何代了，就这些概念在cdc这里就没了就没有了，cdc到了之后，我们调优的时候，它的参数就非常少了。

g one的参数也就几十个，如果你用p s加p o的话，大概要几百个参数，你要调优的话，所以珍惜这段我们现在还可以展示自己水平比较牛逼的时代吧，这里面的概念就太多了啊，我们先把还是那句话。

我们先把最脉络上的东西先把握住以后，我们再慢慢扣细节啊，好我们来继续聊，所以g one呢开始分区，你脑子里内存里头就不再分成两个带了，然后呢g one呢但是逻辑上还是分带的好，到了z d c之后。

cdc不管是逻辑上还是物理上，就再也没有分带的概念了，这一代一代的东西到此为止，那么什么叫神人多啊，大家听我说，其实不管是cg c还是sando，都是来源于一个特别牛逼公司的，特别牛逼的jvm的。

特别牛逼的垃圾回收器，它的名字叫做c four，是a a rule，a a a a a rule，怎么拼来着，你去查一下他的一个特别牛叉的这位m叫z听这名字就特别快，z他不用你进行任何的调优啊。

它的参数好像只有一个呃，然后呢，它能够非常智能的来帮你进行垃圾回收的管理，cc four号称对外是没有任何s t w的，ns t w的垃圾回收器，但是很不幸的是，as you go对，但是很不幸的是。

这哥们呢是收费的，是商业的还贼贵，所以jdk 12 sdk 11啊开始开始主推cdc，就是跟人家学的，听懂了吧，就这意思，这个z dc呢是oracle自己官方推出的，我下一代的回收记就叫cdc和谁学的。

和c four学的好，那red hat自己也推出了另外一款垃圾回收器，叫做shenandoah，也是建立在建立在就是jvm的基础之上的啊，这样的一个垃圾回收机神仙多啊。

但是它主要是跑在open jdk上了，目前这两个其实都有机会叫做转正，就是合并到主干上，下一期的这种jdk的12g dk 13 jdk 14，你要用哪个，哪个是主要的哎，shining doa有机会。

cd c也有机会，当然cdc机会会更大，为什么，因为这是oracle的亲儿子，所以11开始是cdc到12呢，shadow在12里是可以可以设置的，他两个本质上是差不多的，算法也差不多。

他们两个是一个竞争关系，好不知道说清楚没有，答题的来该到同学给老师扣一对，生产环境大多数还是用的这个tv jdk 8，所以你在简历上写，我对gv m有个调优经验，你要敢说你是对z dc调优的，面试官。

一个大嘴巴子就给你糊上了，这哥们儿已经放弃了，他完成了他的历史使命啊，可以到历史的垃圾堆里去了，当然如果想了解算法，必须得从cm开始了解起啊，好看这里还有一个我没有说这哥们是谁。

这个叫abcellent，这哥们儿是什么呢，这哥们儿叫做啥也不干的，啥也不干的dc就是他啥也没干，什么也没干，干什么用呢，它有两个作用，第一个你的程序做测试用，看看你的垃圾的产生过程啥样的。

反正没有垃圾回收器来干扰你，你用它，第二个你确认你有一个程序根本不用垃圾回收就能结束你，内存直接分配，分配完了之后计算，计算完了之后就直接结束了，我根本不用去惊动垃圾回收器，用它absolute。

我看这里，给大家提几笔笔记，嗯cm s啊，承上启下，开始并发回收，绝望逻辑存在，物理不分担，cdc选的多逻辑物理，都五分的。

系列 2：P30：马士兵老师多线程：7.什么是缓存行？为什么会有缓存行？ - Java视频学堂 - BV1Hy4y1t7Bo

好像也失效了，你得去内存里头重新再给我读一遍，所以我改了1亿次，你改了1亿次，互相通知来通知去通知来成绩，都把时间消耗在互相通知的这个消耗上了，不知道我说清楚没有，那有同学可能就会说了。

说老师那第二个程序就跟这个不一样吗，来我们来看一下第二个代码，第二个程序代码，第二程序代码什么样啊，你仔细看看第二个程序代码是我在数据前面怼了七个狼，那也就是说如果是缓存行，正好是对齐前半截的话。

那就是从p一开始一直到这个x这格八个位于同一行，那如果是往后来呢，就是这歌八个位统一好，那如果是中间的，那无非就是说我这有几个加上中间这个x再加上后面几个位于同一行，为什么是七个小伙儿。

64个字节为一行，一个long占八个字节，你要把剩下的占满，他不是七个浪吗，七个浪七个隆咚呛，好，没问题没问题吧，所以这种写法就产生了一个后果，这后果是什么呢，就是我这x啊，你放心，无论你怎么排列。

你在内存里排来排去，他绝对不可能和另外一个t里面的x位于同一行，这哥们儿绝对是单独的一行，单独一行有什么好处，单独一行的好处就在于，我这个只改我自己的这个x呀，你这个只改你的x呀。

我们不用互相通知来通知去的，保持一致，所以这个效率变高了，ok这个小程序呢我就给大家讲完了，不知道大家get到了没有，好我们可以，我们可以继续吗，不太懂啊，似懂非懂，不怎么能这样子呢，这么简单的小程序。

还似懂非懂啊，哈哈哈哈，好那个，这个小程序这个小程序还还似懂非懂啊。

其实他们两个的区别嘛，来我们我们稍微花一点点时间复习一下啊。

这是第一种写法。

好这是第二种写法。

那这是第一种写法，这是第二种写法，我们来看如果如果如果是第一种写法，这哥俩这两个x是在同一行里，会发生什么，会发生什么，cpu改完一个x之后，我得通知另外一颗cpu，说这行的数据已经失效了。

你得重新再给我读一遍，然后如果是第二种写法呢，如果是第二种写法，一定是这样的，这有只有一个x，只有1x，然后这行里头只有这个，这行里头只有这个，互相之间互不打扰，我不用互相通知，好还有没有同学有疑问呢。

这个小同学们的基础稍弱啊，最后再重新过一小遍，如果是第一种写法，由于我们是两个t，所以两个x很可能位于同一行，那么这两个x为同一行的话呢，第一个线程在这颗cpu里执行，第二个在线程在这颗cpu里执行。

第一个线程修改完这个x得通知另外一颗c，比如说哥们儿，我这边失效了，你得去重新再读一遍，第二个线程修改完这个x得通知第一个cpu说哥们我这边失效了，你这个行得重新读一遍，所以互相之间为了保持一致性。

把这个资源都耗费在这儿了，如果是采用这种写法呢，这种写法是无论你怎么排练，你放心，第一个x只是位于这一行，第二个x位于这一行，那么第一个cpu呢就只要改这一行的数据就可以了。

第二个cpu只要改这一行的数据，他们互相之间不冲突，我不用通知另外一颗cpu说这行数据失效了，为什么，因为另外一颗cpu不拥有这行数据，为啥是两个x，你怎么还会问这个问题，你是怎么想到这个问题的。

我实在是相当的佩服，为啥是两个x，因为代码里写了呗，代码里写了2a02 a11 个数组不就两个x吗，嗯好，我们可以继续了吗，可以继续给老师扣一来，好我们继续，呃那有同学可能会说啊。

你说那个老师真的有人这么来写程序吗，如果你真的读过那个jdk一点七版本的concurrent hashmap，著名的道格里，这哥们儿就是这么写的好吧，呃如果你了解过有一个著名的框架。

这个框架呢叫disrupture，有没有同学了解过，this rudder把它翻译过来的叫做闪电，它号称是单机版最快的mq，听我说它的核心是叫做一个环形缓冲区，叫环形缓冲区。

别人家的缓冲区呢都是一个数组头指针尾指针在这里面呢转来转去，缓冲区的数据呢往里装，往往外读，但是这哥们儿是一个环形缓冲区，环形缓冲区的意思是你看啊这里有两个指针，但是环形的只需要一个指针。

一个指针指在这儿，等到结尾的时候呢，又从头又开始好一个环形的缓冲区，如果你学过学过redis，其实这个也大概也能想得起来是吧，缓存一致性协议，ok看这里这个环形环形缓冲区，它有一个指针。

这个指针很可能在多线程的情况下访问，为什么你想想看，有好多人往里扔，有好多的那个呃消费者往外拿，那么为了提升它的效率，它是怎么写的呢，我们来读一下，看能不能找不着，this charter好了。

这是它的缓冲缓冲区，这个缓冲区呢叫做ring buffer，ring环状的buffer，缓冲区，ring buffer点进去啊，哥们你看看在这个缓冲缓冲区里面有一个很重要的变量。

这个变量叫做initial cursor，value cursor，就是我们那个指针游标，看到后面我怼了p一到p7 是吧，有同学说前面有吗，注意看他是从谁继承的呢。

从rebuffer fields继承下来的，所以我们看看他的父亲，从ring buffer pad，ok，这是他的父亲，你会发现他父亲前面有七个，后面有七个，所以你无论怎么排列。

这个指针绝对不可能位于同一行里面，这也就造成了它的效率非常非常快，呃这个框架呢是得过哪个奖，哪个奖来的世界的大奖，它是单机版最快最快最快的m q，所以如果你想执行我们单机的这个效率的话。

想让单机的效率做到最高的话，你可以考虑使用distructor闪电呃，黄老师打算在我们的p8 的架构师课程里面，那个再到淘宝的这个项目里来使用distructor来处理交易，这个等他们那边代码出来可以。

大家可以拿去用，好嘞，到现在为止，大家是不是知道了啊，缓存行确确实实是存在这个概念的，那有同学会说了，老师这个互相之间的缓存保持一致性这件事它叫做什么内容呢，听我说这个东西呢叫做缓存一致性协议。

我相信呢很多很多同学都听说过这个概念，就是缓存一致性协议，然后呢好多人还会听说过这个词叫msi听过同学给老师扣个一来，我认识一下，应该听过好多。

但是好多人啊会把这个msi等同于他就是一个什么呃缓存一致性协议，大哥这事儿不对，认真听啊，这个事儿不对，缓存一致性协议只是一种通用的叫法，msi只是是英特尔英特尔芯片上，英特尔的芯片。

它的缓存一致性协议的实现，好这个写英特尔在英特尔芯片上朝这个东西叫m e s i，但是在其他的这种处理器的架构上，它未必叫msi，它叫做什么呢，它还跟着叫m s i，m o s i叫synapse。

叫firefly，叫dragon和这些都是缓存一致性协议，所以你千万不要跟面试官讲缓存一致性协议，就是msi不是，其实如果你想了解整个缓存一致性协议的一些内容的话，大概大家可以去百度上查一下。

或者我给大家改出来的这个链接，你自己去找就行，m s i本身的理解呢并不是很难听，我简单给你讲几句，这个msi的全称其实就是几个单词的缩写，几个单词的首字母缩写，这几个单词分别叫做modified。

分别叫做exclusive，shared和invalid，modify，修改过了exclusive独占share的共享，invalid失效，这里呢指的是缓存行的状态，假如有一行位于这颗cpu。

它改过了之后，这一行也位于另外一颗cpu，那么这一行在这个cpu里面就叫做modify的，被修改过了，与此同时通知另外一个cpu告诉你这行的状态修改为invalid，失效了，既然你是失效了。

你是不是得去重新去内存里头读啊，你再读一遍，读过来的就是最新的数据了，好exclusive叫独占，比方说我们第二种写法，你放心，他只是独占一行，没有其他任何的cpu和它共享。

那这个时候你随便改share共享，共享的意思是我这边也也可以读另外一个cpu也可以读，这个呢就是缓存一致性协议的一个简简简简单的说法啊，但是他协议本身比较简单，但这个是牵扯到硬件级了。

我个人建议呢不要在这上面花太多时间，一般面试官问到这儿也就差不多了，到现在为止，我相信我已经讲讲清楚缓存行这个概念，还有缓存行啊，缓存一致性协议这个概念了啊，来可以继续同学老师扣一。

那有同学可能会在这里问我一个问题啊，说老师这个东西跟volatile有半毛钱关系吗，其实严格来讲啊，这个东西跟volatile关系并不是特别大，起码跟java里面的volatile关系不是特别大。

呃这个呢只是硬件层级，两颗cpu之间做数据一致性的一种实现协议，有一些还有各种各样的实现协议，我给你举个最简单的例子，有有的有的数据特别大，个儿他超跨越了一行，他一行都装不下，那你说怎么做一致性啊。

用缓存行缓存一致协议就不行了，这时候得用别的协议才行，我告诉你，一会我告诉你好吧，不着急，大家明白这个缓存行的基本的概念之后呢，我们下面来探讨另外一个概念，好看这里，我刚刚呢讲完了前三个问题啊。

我们来讲这个后面几个问题呃，我们来讲v了条这个概念，大家知道那个，java里面呢有一个关键词叫voldl是吧，这个是那个编码的问题啊，我们先不管它，好同学们，大家看这个小程序啊。

下面呢我来呃正式的开始讲这个volt这个概念，呃，volt这个概念呢，它我为什么上来先给大家讲这个缓存一致性协议呢，主要是原因是呃网上有n多n多的文章，把volatile跟那个缓存一致性协议混在一起讲。

就说volt啊，底层是通过缓存一致性协议实现的，我跟你讲真心不适，绝对不是一会儿给你讲到源码你就明白了，真的不是那么回事儿，所以我先给大家解释了什么叫做缓存一致性协议，大家听我说啊。

这个缓存一致性协议呢，不管你用不用用不用volt，他这个一致性该保持一致还是要保持一致，它这个同步的时间也并不是能够百分之百的确定在什么时间同步，嗯，你得是你的程序来控制才可以。

volt呢是完全可以控制你的两个线程之间的可见性，有两个cpu之间数据的可见性的，但是是不是一定是用缓存一致性协议来实现，真心不适，在这儿呢，你理解了这个缓存音这种协议的基本概念之后。

我们来聊volt会更好聊一些，网上的文章很多很多都是不对的，你记住这一点，记住结论就行了啊，看这里作为a voluntel来说，它有两大作用，这是面试题里头经常会被问到的啊。

volatile也是一个面试的重灾区，虽然我们你们平时写程序真真的不怎么用，很少有人用word条呃，呃你你用的类库里头可能人家用到了啊，你知道有这么回事，呃，你你你写一个锁的时候。

那个a q s里面人家可能用到了啊，你知道有这么回事，但是你自己写东西，你很少用这玩意儿，但是面试这个是一个重灾区，刚才有同学就一直问我说，老师这东西我实际当中用不着，为什么要学习它。

你学了他面试通过50万，你不学，他面试通过25万，你爱学不学，面试造火箭，入职拧螺丝，你先把造火箭的技术学了，再慢慢去拧螺丝，就差这么多，没错，大家看这里，它有两大作用，窝窝头两大作用。

第一大作用就保持现成的可见性，线程间可见，第二个叫禁止指令重排序，禁止重排，好我们一点点来讲，昨天呢我要教大家做一个小小的预习，至少你要了解volatile的线程可见是什么意思，避免有同学没预习。

我做个小小的简单的解释，大家来看看小程序，这小程序嗯非常简单，在我一个class里面有一个成员变量，成员变量呢是布尔类型的，running等于true，那么m方法里面m start呃啊打印出来m开始。

然后while running，只要是这个running等于处的话，这是一个死循环，那么他一定不会结束，所以当我有一个线程，这里有一个线程，你有一个thread执行的是t。m的那个那个那个方法。

他的名字呢是t1 ，然后让它掉之后，大家可以想象一下，这哥们儿会不停停不下来，一定是停不下来的，我想让它停下来，怎么办呀，想当然的方式就是把这个running设为false，你就应该停下来了呀。

所以我在主线程里面睡了一秒钟之后，直接把这个running设成了false，那么我想问大家一句，程序能不能结束，可以吗，来跑一下看看，大家看到了m4 ，无论你等多少秒，程序都不结束，唉为什么不结束啊。

不结束，其实跟我们刚刚讲的缓存一致性的这个协议有异曲同工之妙，大家你想象一下，这个running是位于我们的储存里面，它的值是true，那么当我一个县城去读取里面值的时候。

while running要读这个值，读到我的县城本地，也就是cpu里的寄存器里面，读到我的县城本地，然后我每次循环注意只会看这个县城本地的内容，我不会去内存里头重新再看一下的，不会的。

因为没有人通知我要去看，所以这个值永远是true，即便是有另外一个线程把你改成了false，但是对我来说我看不到，那有同学可能会说，老师我怎么才能看到呢，看到很简单，vlo条的作用就在这。

如果在前面加罗拉条调一下m4 ，这是小程序的问题，我这个idea的版本有问题，正在重装，我得重新把它编译一下才可以，跑一下m start，你看一秒钟之后，min就结束了，为什么会这样好。

这是volt的第一个作用，volatile修饰的任何一块内存，volatile修饰的一块内存，这块内存是true，你对里面做的任何改变，其他县城马上可见，这就是可见性，保持线程间的可见性。

ok这是volte的第一个作用，来能get到这一点，同学老师扣个一，来看这里，好再看这里，不知道有同学呢老有这样的疑问说老师，假如我在我不用摸了条，那么你应该是结束不掉的，假如我在while里。

我写了一个输出语句，hello，不断的输出，不断的输出，那么它会不会结束掉呢，那他就开始做实验，重新编译，跑一下他发现结束了，他会说老师你讲的不对啊，为什么这就结束了。

听我说在执行语句的时候有很多很多的语句，它中间会有一个和内存同步的过程，systemd line在这个语句执行的内部，这个方法执行内部，它会内存和我们本地缓存做同步，听懂了吗，所以如果你是打印语句。

很可能就结束了，但是这是你的运气好，如果你里边写的不是单元语句，就不一定了，叫做不一定结束，好吧，好了我们可以继续了吗，大家应该都能明白voluntel的这种线程可见性了是吧。

当然线程可见性的本身非常的简单，呃其实比较难的是另外一个就是哪个内容呢，是叫做禁止指令重排序啊，这里头有一个特别牛逼的问题，嗯每次讲这道题呢讲的都挺累的，但是没办法给大家讲讲讲讲看吧，好好听我说啊。

这是美团的一道面试题，这道面试题答出来真的是50万以上，这道面试题是这样的，叫做d c l单立要不要加volati，我这里面题很很很很同学有同学就听懵了，老师什么叫单利，我不知道什么叫dc l。

我也不知道，ok为了讲清楚这道题，所有同学都支起耳朵来好好听，讲完这道题基本就差不多了，好看这里，美团上来不会直接问你啊，会让你写单例模式，sir，要写的好看点，你说的对，你知道字为什么不能写好看吗。

原因其实非常简单，因为我用的那个画笔啊，它不好用，我如果在这写字，会写得非常的好看，比如说这个老马家的人，重新写一下，开始写字书写笔，除夕怎么竟然还用的是你啊，开个玩笑来，马化腾是吧嗯。

大家觉得这个字还可以吗，和冬梅，鸡皮疙瘩都起来了，是吧嗯，写字这件事呢，老师还是可以的啊，当时曾经也是练过书法的人，开玩笑，因为真正写的话呢，那个那种在那个哪儿，好我现在是在讲书法课吗，没有吧。

哈哈开玩笑哈哈哈，不讲书法了啊，呃这个没办法啊，因为用用用用这个东西在这画的话呢，控制控制不好笔触啊，这没招，开始干奇怪的事情，好了好好，大家放松一下啊，没有别的意思，来我们继续啊。

呃为了讲清楚这道问题啊，这个有点费劲，我呢，为了讲清楚的问题，我需要给大家补东西比较多，我需要给大家补点很多的东东啦，好看这里呃我要下面给大家讲的这个问题呢，就是这个问题啊。

就是美团一般是问你呃这么一句话，它的创建过程啥样，你答出来了之后问你tcl要不要加volati，你就很难了，我给大家讲一下这个问题啊，好好听，认真听，洗洗干净耳朵嗯，要讲清楚这个问题呢。

需要给大家打的基础比较多，我一点点来打，我们首先来聊第一件事就是什么叫做指令的乱序执行，指令的乱序执行是个什么概念，ok看这里呃，作为一颗cpu来讲，由于它的速度非常快，那么你未给他两条指令。

指令指令二你未给这颗cpu两条指令，那么在真正执行的过程中，很有可能并不是指令一先执行指令二再执行，很有可能是执行指令一的过程之中，指令二就已经在执行了，甚至指令二已经执行完了，指令一还没有执行完。

举个最简单的例子，如果你是烧烧壶水，你先洗水壶，烧开水，洗茶壶，洗茶杯，拿茶叶泡茶，那么在cpu的真正执行过程中，很可能是亮的，洗水壶烧开水的过程，它就开始洗茶壶，洗茶杯，最后拿茶叶泡茶。

所以通过这样的一个小例子，你会发现，如果cpu能够乱序执行，所谓的乱序其实也不是乱序，就是后面的一些指令提到前面来执行的时候，很有可能会提高效率，这是cpu为什么支持乱序执行的理论基础。

那么我们讲的专业一点，假如有两条指令，第一条指令是去内存里头读一个数据，刚才我说过，cpu比内存的速度大概要快100倍，如果他发出一条指令，一个时钟周期，夸机就去内存里读数据了，但是等数据回来。

他得需要干干的，等待99个时钟周期，然后才能执行，第二个大哥，你稍微想象一下，那个你这样的话，是不是浪费cpu的时间了，cpu效率就不高了，所以在cpu进行优化的时候，有可能是这样来执行的。

我第一条指令区内存读数据，在我等待返回的这个期间，我把第二个指令拿到前面来执行，当然这里面有前提，就是两条指令不能存在前后的依赖关系，你比如说你第一条第一条指令叫i等于八，第二条指令叫爱加加。

你绝对不可能把爱加加跑到前面来不行，这为什么，这个是前后存在依赖关系的，这这这个不行，这是cpu乱序执行的最基本的概念，这个概念听清的同学老师扣一，我们继续，那有同学可能会说老师这个能证明吗，这个可以。

我给你证明一下，这个是我在另外一个项目里头证明的，这证明起来有点麻烦啊，其实你知道有这么回事也行，不给你证明也可以，这个听你们的啊，证明起来稍微有点麻烦，这是一个经典的证明，超级经典呃。

先说这小程序不是我写的，也不是我设计的，这小程序最早是以老外设计的，拿c语言写的，后来国内的人把它改成java，然后呢我拿过来之后讲给大家听，这不是我的劳动成果啊，也向这位写程序的人致敬。

这个特别好玩儿，证明一件事情存在乱序执行其实很难很难证明，但是呢他设计了一个特别精巧的小程序来证明这一点，呃，理解这个小程序需要大家有一点点小小的业务逻辑，这个要逻辑呢也比较简单，你认真听我讲就行了。

好大家看这里，我们下面来证明乱序这件事情是存在的，这个小程序啊，记住这个小程序的使命叫做证明乱序存在，小程序怎么证明呢，这么来证明，现在呢我们有四个值，第一个值是x，第二个值是y。

第三个值是呃a第四个值是b然后不停的死循环，一直不停的起两个线程，这两个县城第一个县城干了一件事。

系列 2：P31：马士兵老师多线程：8.缓存行如何影响Java编程 - Java视频学堂 - BV1Hy4y1t7Bo

a第四个值是b然后不停的死循环，一直不停的起两个线程，这两个县城第一个县城干了一件事，叫a等于x等于b第二线程干了一件事叫b等于一，y等于a o给大家十秒钟消化一下这小程序，这小程序已经已经没了嗯。

那这个证明是一个反证法的证明，反证法好，根据我们刚才得出的结论，你们认真听我说，乱序啊，这两条指令之间或者两条语句之间很可能存在乱序，为什么，因为这哥俩前后没有依赖关系，你发现没有，它没有依赖关系。

那站在一颗cpu的角度，你随便乱序，你乱序来了没没有关系，最终的结果是一致的，o这个东西呢叫做as if serial，这个我一会我来给大家讲这个概念嘛，很可能好同学见到过这个词，但是不明白什么意思。

不着急，一点点来，总而言之，言而总之，这个小程序证明是这么来证明的，我们如果假设首先假设不存在反证法嘛，首先假设不存在乱序，不存在乱序，就会有一个后效果是什么呢，a等于一一定在x等于b前面。

x等于b绝对不可能跑前面去，b等于一一定在y等a前面，y等于a一定不可能跑前面去，同学们刚才讲的这小段还能跟上吗，能跟上的，给老师扣一，你继续，这个你能听懂就听，听不懂就算了，听不懂就记得结论。

乱序执行这件事存在知道这件事就行，那有同学可能就会说了，这这怎么证明啊，证明我们来分析一下这两个线程，无论你怎么排列组合两个线程吗，他们之间有可能互相之间你执行一会儿，我执行一会儿。

无论你这几条语句之间怎么排列组合，排列组合什么样的，第一种很有可能是这样，我a等于一执行完了，马上执行x等于b然后第二个线程开始执行，b等于一，y等于a好，这是一种可能性，这种可能性你计算一下x值。

即使是x值是几，y是几，你会发现x等于零，y等于一，这是一种情况，当然还有其他的可能性，就是那b等于一跑前面去，y等于a跑前面去，a等于一跑后面x等于b跑后面，这是第一个线程，这是第二个线程。

是第一个线程好最终的结果是x等于一，y等于零，当然也有可能是打断的，比方说a等于一，执行完了另外一个线程执行b等于一，然后呢x等b y等于a也有可能y等a跑到x等于b前面，总而言之言而总之。

无论你怎么执行，绝对不可能出现x等于零，y等于零的情况，你自己验算一下，我再说一遍，假如这几条语句不会发生重排序，你放心，x等于零，y等于零，绝对不可能出现，很有可能是x等于y等于x等于一，y等零。

或者是x等于一，y等于一，嗯李浩问了个初级灵魂的问题，李浩同学，你怎么那么敏锐呢，这是指令集乱序还是语句级别乱序，这是语句级别，这种语句级别的乱序不太容易出现，但是也有一定的概率。

语句级别语句不就是好几条指令吗，好几条指令之间也有可能乱序的，我向你证明指令级别的论述，我只能给你写汇编语言，大哥，你觉得我在这跟你聊汇编语言聊的通吗，虽然我的笔记里头写了汇编语言。

但是我要今天给大家聊汇编，咱们今天就别别讲课了，估计好多同学就更懵了，虽然我的笔记里啊跟大家聊了一些汇编，但是今天还是算了，这是汇编吗，因为它内核带中间的0x80 调用过程必须得用汇编来解。

所以只要你只语句级别存在乱序，你拿大腿给我想想它指令级别存不存在乱序，对啊好了不说了，当然刚根据我们刚才分析的结果，只要我这个程序有一个x等于零，y等于零的情况出现，那么一定就会存在乱序，调一下试试。

这个靠运气，有可能跑好长时间也跑不出来，有可能跑个十几秒就出来了呃，原因是呢由于它指令级，由于它是语句级别的，得好几条指令同时乱序才能出现最终的结果，所以这个东西得靠运气了，我呢大概以前执行过的。

这是呃272万次，执行完了之后出现零零，这个呢11万次运气比较好，出现零零，我今天如果运气不好，就多等会儿运气好的话呢，也许很快就能出现，太讨厌了，运气不是特别的好是吧好吧，不说了。

x的我为什么没有同学还在这儿啊，出来了一点啊，运气不错，来看这里啊，呃29万次的执行之后出现了结果零零，所以这就证明了乱序执行啊，我看有同学说x等于b y等a最先执行不就都等于零吗，你这不废话吗。

你x等于b y等a最先执行不就已经乱序了，大哥，好好想想啊，我们说假设不存在乱序，它才不会出现这种情况，出现这种情况就已经是乱序了，那你自己都已经证明了，你想啥呢，老天这是反证法，对啊。

呃不管你听听得懂没听懂，总而言之言而总之有一件事情存在，哪件事情存在呢，cpu的指令之间有可能后面你给他写的这条指令跑到前面去执行，ok得到这个结论的，给老师扣个一，我们继续注意。

我跟你讲那道题你还记得吗，叫d c l要不要加volt大哥，这里面好多东西呢啊，我只是给你讲了一个乱序，执行了，我给你点点来，好大家看这里，我给你讲完乱序执行之后呢，我还得给你讲一个概念啊，看这里呃。

我给你讲了乐趣之行之后呢，还得给你讲一个概念，这个概念呢就是第一题就是解释一下对象的创建过程，先说结论，对象创建的时候有一个半初始化状态，呃，这个是什么意思，嘿嘿嘿，看这里啊，一点点来来。

我们来看这句话，object o等于new object，这句话应该是最简单的一句话，围绕这句话，美团出过九道题，这九道题得答出一个来都不容易，我们先讲第一题，也就是我们要讲的那道大题。

需要的这个结论就是new object，这中间到底有哪些个执行步骤，好跑弹一条线，诶，怎么debug了，跑弹一下，先run，版本有点问题，rebuild一下，跑一下好，跑一下之后呢。

我们来观察一下它生成的它那个class文件生成的字节码，关于字节码这个概念应该不需要我解释，我觉得啊那个就是呃我们一个java文件编辑完了之后呢，生成的是什么呀，by code，这个叫字节码。

就是我们的点class文件，这个相当于java语言的汇编语言，java语言的汇编码，汇编码里边是什么，怎么执行的呢，它是有好几条指令来共同完成这条语句，这几条指令是什么呢。

看这里我们来观察一下view show by code with j class library这些小小的插件啊，我们用这个插件呢来观察一下这条语句生成的哪些指令，method，好了看这里。

这是这条语句生成的指令，这里第二对嗯，一共有五条指令构成，当然这个字体比较小，我担心你们看不清楚，所以呢我就给它挪到了我们的ppt上，看ppt就可以了，ok当我们写这么一个小小的程序的时候。

就这个小程序啊，class t里面有个成员变量m等八，然后当我们写这么一句话，t小t等于6t6 t的时候，真正执行的呢是五条指令，这五条指令呢分别是new指令，duplicate指令。

inbox special指令，a store指令和return指令，在这里面有两条指令不太重要，我暂时也不想跟你解释，return指令，先不管它，duplicate指令先不管它。

这里面new出一个对象来，至少需要三步，大家还能跟上吗，大家还能跟上吗，能跟上给老师扣一了，嗯跟他说是吧，嗯当我们new出一个对象来的时候啊，至少需要三步，这三步是什么呢，打开冰箱，把长颈鹿拿出来。

把大象放进去，关上冰箱，开个玩笑啊，开个玩笑好看，这里啊，第一条指令呢叫new，第二条指令呢叫invox special，第三条指令叫a store，我解释一下这三条指令的意思。

六的意思是申请一块内存空间，用来装我new出来的这个对象，还有这个空间已经申请好了，大家都知道new出来这个对象里头一定有一个成员变量，这个成员变量是小m，那这个m的值是几呢，听我说。

当你刚刚new出一个对象来的时候，这个m的值是它的默认值，default的值默认值是几呢，数值类型的都是零，double类型，flow类型，零点，引用类型都是空值。

ok所以最开始的时候这个m的值是一个零，那什么时候它才会变成八呢，我不要求它等于八吗，什么时候变成八呢，调用完下面这个方法，这个方法叫invoke，invoke，调用的意思。

special特殊调用调用了一个方法，这个方法比较特殊，哪个方法呢叫initialize，什么方法构造方法调用了它的一个默认构造方法，这个方法执行完这个m的值才会从零变成八。

所以当我们列出一个对象来的时候，它里面的成员变量是由一个从零变八的过程，有一个从默认值变成初始值的过程，好这个状态叫做半初始化状态，最后一句话叫a store，a store的意思是建立关联。

谁和谁建立关联，我们有一个局部变量小t，这个小t里面储存着一个指针，这个指针指向这个对象，好在只有在执行完这句话的时候，一个小t和我们真正地出来对象建立关联，通过小t才可以去访问它，呃。

为了让大家看得清楚，我作为小小的动画，大家认真看，当我们new出一个对象来的时候，首先new执行到new这条指令的时候，内存里头是一个默认值的情况，m值等于零，当执行到invox special的时候。

它才会变成八，当执行到a store的时候，它才会变成建立关联这个过程，所以你看上去简简单单的一句话，在汇编界呢，实际上它有三条语句构成，它有三个步骤构成，好听明白这个过程，同学来给老师扣一，我们继续。

有同学说第二行第五行大哥，我建议你呢先踏踏实实地听完主干，这些细节是我的课程，专门讲每一个指令专门讲的都给你讲完就没边了好吧，加载链接初始化，加载链接初始化是静态的过程，class的加载链接初始化。

这是new的对这个开始执行之后的对象的过程，跟那个差不多，话不多说，因为有每个同学的基础不一样，我们还照顾一下基础稍弱的好继续，呃在刚才我讲课的过程之中，我第一步给大家讲了，有乱序执行这件事存在。

有乱序存在，第二步给大家讲了，当你有一个对象的时候，它有三步构成，还记得那道问题吗，那道问题是d c l单利要不要加volatile，大哥，这里面有没有谁需要我解释一下什么叫单利的，有吗，有的话。

老师扣个一扣二吧，真有啊，呵呵呵好，我解释单例和dc l单例，你放心，我30秒给你解释完啊，你要听不懂，那就是你的你的问题了，我就不管了，关于单例呢，它是一种设计模式，这是另外一个可以把代码调出来。

23种设计模式，代码呢我都带大家写过，但是单例呢写的比较多，一共有九种写单例模式的方法，单例先说是个什么概念，单例的概念是这么一个东西，我有一个class，我只允许你溜出来一个这个class的对象。

不允许你用第二个在内存之中永远只有一个这个class对象，不会有第二个，这是啥意思，大家看这里，我有一个class叫major 01，如果我想实现这个单例的话，我这么来这么来写就行了。

ok我上来二话不说，先定义一个对象，这个对象叫instance，然后把它给弄出来，用完了之后，我不允许别人虐我，这对象我把他的构造方法设成private的，那别人就虐不了了，所以谁想用我的对象的话。

通过我提供的一个方法叫get instance，你只要调我这方法，我返回的永远是这一个对象，所以无论你调多少次这个方法，最终你拿到的对象只有一个only one，这个就叫做单例模式。

这也是单例模式的最简单的玩法，关于这块能跟上的李老师扣一，关于单例呢，我需要给你快速的过一遍啊，反射可以对你说的很对，你说的一点都对，看这里啊，作为这种写法来说，我上来二话不说，先定一个对象。

那么有人呢就会吹毛求疵，有人就会吹毛求皮是吧，嗯好谁呢，就是我们处女座的人，比如说乔布斯啊，比如说还有谁啊，不知道啊，哈哈哈哈，开玩笑啊，比如我们处女座的人，他会追求每一个细节的完美。

所以当我还没有用到这个对象的时候，你干嘛要都one 6出来，你这不是浪费内存空间吗，所以好听我讲，因此呢就诞生了第二种写法，第二种写法是什么呢，你能不能做到当我需要这个对象的时候，再给我扭出来。

我不需要他说你不要给我new，所以第二种写法就是我首先定义一个对象，但是我不给他初始化，什么时候初始化呢，有谁调我这方法的时候，get instance，要用我这方法的时候，我判断一下哥们儿。

你是不是为空啊，你为空就是没有人把你初始化，ok这时候我把你给初始化掉，最后返回给你好了，这个呢就嗯满足了处女座人的肮脏龌龊，不能这么说啊，满足了处女作人的想法要求，但是这种有问题，车有问题在什么地方。

这个程序线程不安全，为了向大家证明这一点，我能在中间睡了一秒钟，表示执行了一些业务逻辑，那么在这个情况下，如果你多线程去调用这个get instance方法的时候，他一定会出问题，淘一下。

写入计时出错而不，diary is not specified，我考代码的时候的问题，一边啊，嗯等一下，上一个版本的那个里面拷过来的，等一台机器，我先不管它那个这小程序呢，呃大家都不用给你运行。

结果你应该能想的出来是使会出什么问题，你可以想象一下啊，当第一个建成来到这里访问这个对象的时候，发现为空吗，为空好，第一个线程暂停，第二线程也来了，为空吗，为空，那第二线程来了之后呢，继续往下执行。

new了个对象，用完了之后，第一个线程继续往前执行，注意第一个线程已经判断完了，那直接又new一个对象，所以这哥俩new出来的不是同一个对象，因此这就不是单例模式了，好吧，演示也能演示啊，我给你拷过来。

重建一个项目就可以了，但是我懒了，偷个懒可以吗，代码太简单，好那怎么解决这个问题啊，太简单了是吧，解解决这问题还不简单，加锁嘛。

上锁public static synchronized的get instance，你放心，上了锁之后，昨天我讲过锁的概念，上了锁之后是什么意思，我只有持有这把锁，我才能去new这个对象。

只有等我遛完了，另外一个线程才能进来，我持有这把锁，我在里边噗噗噗便便，我便便完了，另外一个线程才能进来，另外一个线程拿到这把锁之后，由于我第一个线程执行完了，我已经把它给弄出来了，你放心。

第二个线程来判断它已经不为空了，那啥也别说，肯定拿都是同一个，所以这个上锁肯定没问题啊，这块还能跟上吗，能跟上的，给老师扣一来，但是处女座的人又来了，处女座的人说大哥，如果你这里面有些业务逻辑。

比如说你这里面写了好多好多代码，我们假设嘛写了写了好多好多好多行的代码啊，long two啊，lin three等等，来four等等，写了好多好多代码，这是你的业务逻辑，这些业务逻辑本身啊。

其实用不着上锁，用不着说我持有锁的时候才会执行这些业务逻辑，没有必要，但是你如果这样的话，你锁定的代码块就太大了，这叫做锁的粒度太粗，叫做锁太粗了，锁力度粗，所力度粗就会怎么样，效率就会变低。

持有锁的时候，你要干很多事情才能轮到另外一个线程，所以锁力度粗就会变低，就是把锁细化o看这里所细化，简单了，就这么来做嘛，业务代码有一些业务代码，然后没问题，我不给他上锁，什么时候上锁，能判断哥们儿。

你是不是等空啊，如果等空上锁，synchronize major，零五点class，上完所把你给new出来，new完了之后返回回去，好问大家一个问题，这个写法能不能保证现成的一致性，线程安全能保证吗。

依然不能，我看有人说能我们分析一下，为什么他不能，原因是啥呢，原因是你判断一下啊，第一个线程执行到这里，判断instance等空没问题，第一个线程暂停，第二个线程执行到这里判断。

注意instance依然能空，第一个线程还把它丢出来了，然后第二个线程继续执行，第二线程到这里的时候，申请这把锁没问题，只有他一个线程拿到这把锁，开始执行，把manager 05 new出来。

new一个对象扔在这没问题，然后第二个线程释放锁退出好，执行到这里的时候，第一个线程开始执行了，开始继续执行了，第一个线程开始继续执行的时候，开始又申请这把锁，我想问你这把锁他能申请下来吗，没问题。

为什么，因为第二个线程已经释放了呀，你想想我已经把锁打开了，你第一个线程想锁上，当然可以锁上了，没问题啊，我已经用完了，我已经变变变已经变完了，该你了，既然该我了，那我就继续往里走，走到这里的时候。

是不是又new了第二个，所以即便是你在这里上把锁没用，所以就诞生了dc l的写法，下面我来讲dc l这个写法是这样子的，我呢呃一个线程来了，首先判断instance是不是等空，如果等空上锁。

我上完锁之后，我再判断一遍，你是不是依然为空，刚才咱们那个过程不就是说在我上锁的过程之中，有另外一个线程已经把它给初始化了吗，我上完锁之后，我再判断一下，哥们儿，你是不是依然为空，如果你依然为空。

说明没有人改过你，ok那就完全没问题了，好这个东西叫dc l，全称叫double check lock，check一下，check两下，中间夹着一把锁，double check，中间加了个lock。

叫double check lock，但是他的问题还不是止于这里，它的问题是说哥们，你这个double check lock要这种写法的时候，你这里要不要加volatile，这是他的问题，当然我讲到这。

大家应该明白什么叫double check lock，什么叫d c l了，我相信大家呢有一堆的问题，我一点点解解释给大家听，好最基本的概念明确了的，给老师扣一，ok大家看这里。

我相信大家呢有这样一些个小问题啊，第一个问题就是说老师你干嘛要写这个if等于空啊，你直接上来直接直接拿过来上锁不就完了吗，你外面这个衣服有啥用啊，有狗屁用吗，同学们仔细分析一下。

如果去掉外面那个if会发生什么情况呢，假如有1万个线程都来抢这把锁，反正他二话不说，上来就synchronize，那么是不是上来就锁竞争啊，最终是不是只有一个线程才会把这个弄出来。

也就是说剩下9999个竞争过程必须得上来，不管你是不是你弄出来的，你得去参与锁定证，那这样效率就太低了，如果前面加一条if语句，会发生什么情况呢，只要有其中1万个里头，只要有一个new完了。

另外的人过来判断一下，我就不用参与锁竞争了，效率就提高了，这种写法啊，在很多很多的开源软件里头都用到了，我希望大家掌握住，没问题吧，嗯这第一个问题就解决了，好我们来聊第二个问题，还有还有其他问题吗。

提高性能，对没错，就是提高性能的，好我们继续，来我们继续，第二个问题是他要不要加volt，我先把这代码啊给大家，来给它切下来。

切最简单的最干练的就行了啊。

放在这儿，然后呢。

我们来看这个p p t，好，呃我们先说结论，先说结论，这个必须要加volatile，原因是什么，回想我前面讲过的内容，我讲过程序是可以乱序执行的，第二个new一个对象的时候是存在半初始化状态的。

那好下面我们来分析为什么double check log必须要加volatile，好对照代码说来看这里，假如有第一个线程过来了，判断instance等空上锁，判断它依然为空，然后就开始new对象了。

注意new对象有三步，大家还有印象吗，new对象的话是这样来做的，第一个线程来了，判断为空，开始new这个对象中间有三步构成，第一步是申请一个内存，把这个值变成零，默认值。

好我们假设它扭到一半的时候发生了指令重排序，认真看后面这条两条指令发生了重排序，再看一遍第一条第一个线程来判断等空没问题，上锁可以开始new对象也没问题，new到一半的时候发生指令重排序。

大家还记得这两条指令什么意思吗，这两条指令指令的意思是，这条指令叫建立关联，这条指令叫构造方法执行，那么他会先建立了关联，也就是说这个小t已经指向了这个初始化了一半的对象，ok正好在这个时候。

第二个线程来了，来你猜猜看第二个线程，第二个线程来会执行哪句话呀，是不是会执行if instance是不是等空这句话呀，好我就想问你这个时候这个t也就是那个instance等空吗，等不等空不等空。

不既然你不等空，我还给你上锁去拿吗，我不需要上锁了，我就直接拿过来用了，对不对啊，那么你猜猜看第二个线程用到的是一个什么状态的对象呢，他就使用了一个半初始化状态对象，半成品，你做到一半的时候。

他拿去用了这里的值，记录着双11我们成立了多少个订单，本来是100万了，不好意思。

系列 2：P32：马士兵老师多线程：9.如何证明CPU的乱序执行？ - Java视频学堂 - BV1Hy4y1t7Bo

不不可能。即便是像阿里、淘宝、美团，像他们这样的一个并发量出现的可能性都极小。但是没办法，人家面试会问。好啦。嗯，讲到现在为止，我觉得这道题我就讲清楚了啊。呃，标题值50万。如果你面过了，这这道题。

你你要是拿出这道题来，面试官，你披露啪了，你给他说清楚了。基本面试官不太会问你底层的问题了就嗯。嗯。好。好，大家看这里。好，我们继续。那现在问题又来了。那这个volet起了什么作用呢？

为什么加了它就能解决呢？😊，认真听我讲。呃，vololatile起了这么一个作用，用volattile修饰的任何内存空间。在他上面执行的这些指令。不可以乱续。我再说一遍，叫做禁止乱序。

用voluntile修饰的这块内存空间，就是扭出来这个对象，这个对象扭出来的在它上面执行的一些指令。比如说要读要写好，不可以乱序执行。既然不可以乱续，就绝对会防止住其他的县城拿到这种半初始化对象了。

你必须得初始化完了之后才建立关联。ok。现在的问题又来了，他是怎么阻止乱序执行的呢？这就是下面我们要讲的问题，叫内存屏障。今天内容已经挺多了，大家还能跟上吗？能跟上的给老师扣1。嗯。

内存屏障呢我们就聊比较简单的概念吧，其实。我直接在这缓啊。嗯。好的，看这里。呃，我们下面来聊，就是加了呃volat之后，它是怎么阻止。那这个指指令的乱序执行的，怎么阻止的呢？其实阻止一个指令的乱序执行。

也相当于这有一条指令。呃，这有一条指令，两条指令，我不允许他换顺序，那我怎么办呀？中间给他加一个障碍物就行了。两条指令之间加一条内存屏障。这是你最平常的概念，我去。Yeah。嗯，稍等片刻啊，我这个。

椅子出了点问题哟。嗯。没事没事，是我的椅子出了点问题啊。😊，呃，我这椅子差点把我给。顺他过去。嗯，椅子没锁住啊，没事儿没事儿。Okay。嗯。嗯。老师吓人，老师又不是嗯。老师又不是大姑娘生娃娃，吓什么人？

嗯呵。好，看这里啊呃我们来聊这个内存屏障这件事儿。呃，也就是说在两条指令之间呀，我们加一个内存屏障就可以了。大家好好听啊，这个内存屏障呢有各种各样的屏障。😊，我下面跟大家聊呢，在。JVM这个级别的屏整。

是什么意思？JVM级别的屏障呢，注意JVM是个什么东东啊？JVM是一个规范规范规规规规规规范。它并不是一个具体的实现，所以他要求的这个内存屏障。好好听我讲。

这东西并不是具体的操作系统级别或者是硬件级别的实现。我再说一遍。由于JVM只是一个规范，这个规范要求volattile修饰的东西得给我实现内存屏障。但是硬件级别或者我的hospport级别。

或者我操系统级别，它到底是怎么实现的。实际上跟JVM的规定并没有直接的关系。这块大家听懂了吗？懒能跟热闹给老师扣1。我们先说JVM级别的实现，网上有很多关于讲内存屏章的内容。

很多很多他讲不清楚的一个主要的原因就是因为他们混着讲。他们会把。在JVM级别的内存屏障。和硬件级别内存屏障完全混在一起讲，这俩不是一个概念。JVM级别会内存凭证只是一个规范的要求而已。GVM级别的屏障。

大家看这里。呃，JVM级别的屏障呢大概有呃4种。这四种呢我花30秒给你讲清楚。虽然你看到过，但是你不一定能理解得了。呃，这四种我花三种给你讲清楚。

这四种屏障分别是low load store store，low store和store load。听我说load是读store是写。load load的屏障是对一块内存，上面是一个读，下面是一个读。

好，中间这个屏障叫load load上面这条指令跟下面条条指令不能换顺序。load loadstore store上面是store，下面是store，不可以换顺序。好了，我觉得我讲到这儿。

剩下的应该不用我说了，来能get到的老师扣1。很简单是吧。😊，关于嗯JVM级别，对于volatile修饰的变量，它到底要加什么样的屏障呢？他是这么来加的，这块大家不需要记住。

面试也基本上不会面到这种深度，还没遇到过。好。看这里。凡是volatile修饰的内存。当你要对这块内存进行修改的时候。在JVM级别要求前面加一个store store，后面加一个store load。

啥意思呢？你这里要要注意啊，你这里头是要对它进行写了，就是store嘛。那前面的sstore必须先执行完。就是你先写完了。得到最终的结果了，我再往里写。后面等我写完了，你再开始读。保证一致性。

如果是波罗道读的话呢，上面的全读完了，我读完了，你其他人才能读。我读完了，你其他人才能写。就保证了。线程之间的可见性，你自己分析一下就行。当然我听我说这个东西是还是那句话。

是JVM层面要求规范要求的一种实现。实际是怎么实现的呢？实际不是这么实现的。Okay。哦。这块还能跟上的，给老师扣一，我们继续。嗯。😊，P。嗯。😊，来。好的，看这里。呃，我讲到这里呢讲了乱序。

讲了volttail禁止乱序。呃，我相信应该有同学呢开始问这样一些问题，到底什么样的东西允许乱续？为什么刚才先建立关联再初始化对象，他俩就可以乱续，那什么样的指令不允许乱续？

这块儿大家有这个有这个问题的，给老师扣个一来。嗯。听我说啊，这就是著名的happens。before原则。我估计如果你们稍微读一点技术文章，都应该接触过这个词，这个词呢叫happens before。

happens before的意思呢就是什么什么要求在什么什么发生之前。你比如说你这个县城的销毁，一定要是在呃县城的创建之后，你不能说现城还没创建的，你先把它给销毁了，这肯定不行。

有依赖关系的肯定不允许。大家听我说，在JVM层级规定了8种happens before原则。除了这8种之外的，随便重排序。这八种里面并不包括先建立关联才能初始化。好，这八种呢不需要你背过，别这样背。

没意思。这八种也没人问，都是非常简单的一些个概念。总而言之，言而总之。在语言规定之外的任何的其他语句可以重排。这就是happens before原则。当然我讲到这儿呢，我就顺带着给大家讲另外一个概念吧。

因为我怕你们有些同学读到。一个呃一些一些一些文章的时候啊，这个听不懂听不懂，看不懂。大家读文章有没有看到过这个词，这个词叫as if。Cereal。来看到我这词的老师扣个一，我认识一下。嗯。😊。

应该是看到过啊，这个词呢叫as if zero呃，翻译成中文的话呢，叫看上去是序列化执行的。这句话的意思呢，其实本身指的就是CPU的乱序执行。CPU呢你给他两条指令，很有可能第二条指令跑到前面去。

但是能不能跑到前面去，最终的结果一定是这样子的，不影响最终的结果值。就跟前面说的，你X等于一Y等于A这两句话，谁先执行，不影响最终的结果值。是在单线程里头一颗CPU的时候，所以单线程里头。

这两条指令不管它前后执行的顺序，看上去as if像是一个顺序执行的，就是这个概念。所以as if的概念指的是单线程里头执行最终的结果。不影响不影响改变，不论你怎么进行程序，单现程执行结果不行改。

不不进行改变，这个叫做as if serial。okK同学们，我们可以继续的老师扣个一，下面我们就来聊volattile最底层最底层到底它是怎么才能实现的这个屏障呢？好，我们稍微。看这里啊。

我们稍微回顾一下。呃，我到现在为止呢给大家讲了很多的内容了啊，我给大家讲了什么是CPU的缓存。呃，缓存和内存之间到CPO他们怎么是一个级别关系，讲了缓存行，讲了缓存一致性的协议，呃。

讲了缓存之间怎么保持一致。我讲了CPU之间的乱序执行的一个概念，向大家进行了证明。给大家讲了DCL为什么不能够允许它乱续。给大家讲了vololaile在JVM层面是如何阻止断续的？

给大家讲了内存评论的概念。但是。1个JVM的就是hot spot的实现，对于volatile，它并不是使用了那些特别精巧的内存屏障。刚才我看有同学问我说，老师硬件级别内存屏障到底怎么实现？听我说很简单。

他们有自己的对应的指令。如果是英特尔的CPU，它本身就支持好几条指令，这条指令叫S fence，叫做。写屏障store fans嘛，这条指令叫elfin叫load fence叫读屏障。

这条指令叫Ffin。就总而言之，在汇编上，它直接就支持内存屏障这件事。比如说当你前面写了一个store指令，中间你加了一个S，后面又写了一条store指令，那么这两条就不就不可以换，就是你写汇编的时候。

得自己写，这是非常精巧的效率很高的一个实现。但是听我说hopot并不是用这些指令来实现。hosbo是怎么实现的呢？大家看这里。嗯。拖个懒，我懒得给大家跟那个ho那个那个那个CI加的源码了。好，呃。

如果你真正的想了解hoport到底怎么实现的。好听我讲。hoseport实现，由于你加了任何volattile的一个东西，它都要编译成为字节码，叫backcode。而java的字解码是解释执行的。

所以你想了解的话，去这个文件里面去看这个文件呢叫baide code interpret。字解码的解释器点CP文件。嗯。

由于大家伙并不具备，多数人并不具备自己去编译。

hos能力。所以有的时候我就我我只能是直接直接拿给你看啊，这没招。基础太弱，我也只能是慢慢带喽。

这没打开。我就懒得我不给你打开了，呃，看我们的笔记就行了。笔记里呢我也给你解释的很清楚。呃，当你找到这个CI加文件的时候，找到这句话。if catch is volatile，如果这个。

是vollaile修饰的。vol修饰的时候，它实际将调用了另外一个类叫or access， order access顺序访问里面的fence方法。而这个f方法呢，faceence函数。

篱笆吗具体是怎么实现的呢？具体的实现是这样来实现的。看这里。它仍然是一条lock指令。后面跟的被锁定的那个语句叫ad L，叫ad。ad呢就是添加增加的意思，给某个寄存器，哪个寄存器呢RSP加了个0。

lock atL来实现的。呃，我讲的这块大家还能跟得上吗？😊，能跟上给老师扣个一来。嗯。是。就是总而言之，言而总之，我们跟这儿跟了半天，跟来跟去跟来跟去。实际上最终的一个实现就是这条指令来实现。

这条指令叫lock at L。昨天啊我们讲了 synchronized。它的最终的一个实现是什么？你们还记得吗？其实sernet的最终的实现呢也是一条lock指令。

那条lock指令叫lock compareare and exchange。当然，这是CAS的实现。是吧。然后今天我们讲了vollavol的时间是什么？依然是一条lock指令。

这条lock指令叫lock at L。好，听我说lock就是锁总线，就是我这个CPU在执行的时候，我把这个总线锁定，其他CPU完全谁都不能访问。后来叫锁总线。那为什么这条指令能实现？为什么这条指令？

这一条指令就能够实现voltile的两大作用，现程可见性禁止重排序。好，听我说，请大家记住我昨天和今天讲的两条指令，第一条叫look compareare and exchange。

第二条叫lock at L。呃，基本上面试官怼到这种深度的时候，除了我昨天没有讲完的内容和今天讲不到的内容之外，你基本上就可以掉下来揍他了。好。我们来分析一下。adL lock是个什么东东？

其实这个这条指令里面adL没用。好，听我说这条指令起作用的就只有这条lock指令。log指令呢它是在多处理器执行的时候，对共共享内存进行独占使用。多处理器，好多个CPU去访问这个内存，我去把总线锁住。

其他人不能访问，那我就归我独占用了。它的作用是能够当前处理器对应缓存内容刷新到内存。我这里面有一些改变，我会刷新到内存里面。是不是就保证了可见性了？并且其他对应缓对应的缓存失效。这个缓存告诉你。

你失效了，你得重新去读，我不就保证可见性了吗？所以一条lock指令就已经。执行了可见性了。另外还提供了有序的指令，无法越过这个内存屏障作用。这条lock指令只要往这一放，前面不论多少指令。

后面不论多少指令，谁都不能互相穿越。所以一条lock能搞定。那有同学有可能就会说。大哥。我你刚才在那儿牛逼吹了半天，说英特尔CPU支持什么S sense。啊。

el fence说JVM层级支持什么load loadload store，怎么到最后就一条lock令搞定了呢？为什么呢？很简单。因为好斯把偷懒。如果hobo做的比较精细化的话。

那么它应该是根据不同的CPU调用不同的汇编指令。但是housebo偷了个懒，这条指令完全可以解决所有的问题。行了，我就不用针对每颗CPU来进行优化了。锁了总信，其他CPU怎么读？张海波。有人进了厕所。

其他人怎么办？告诉我。等着呗，等人出来呀，等着解锁呗。😡，所以得有哩边嘛嗯。好啦。那有同学说老师后面的艾L有啥作用？艾L啊是没有任何作用的一条语句。但是由于英特尔的CPU规定，嗯。

是其实多是CPU都这么规定，一条lock指令后面必须跟一条语句，指的是在执行这条语句的时候锁总线。那这个语句呢又不能没有。然后又不能够说呃这个执行点任何任任何有些有些有效的东西，有用的东西。

所以他就用一条空语句。这个空语句指的是往一个寄存器里面往里边的值加了个零，等于没做没做任何操作。所以东西就是占作占位置用的。当然有人学汇编啊，汇编的控制令是哪个语句，你们知道吗？对。

lock后面必须给你条语句。对，NOP。No operation。不做任何操作。2丁韦点为什么lock不能跟这个呢？没什么为什么。😊，王八的屁股规定。lock后面不能跟LP说不定。

为什么锁总线就不能穿越了？因为。虽然条条大路通罗马，但是我的CPU访问内存只有这一条路。我把这条路给占住，除了我之外，谁也不能走。你告诉我其他CPU怎么穿越。为什么这么简单的问题非要老师来解释呢？好。

呃，这个实验的话呢比较复杂，今天不想大家做了。另外呢，昨天讲的那个所升级的过程也非常复杂。今天不想带大家做了，讲累了，已经快十点了。呃，今天就聊到这里吧，好不好？日常推课环节。对。

得介绍介绍我们课程了嗯。哦。我们先介绍先回顾一下我们今天讲的内容啊。嗯，我今天呢给大家讲了，你们稍回过一下啊，闭上眼睛想就行了。嗯，我今天给大家讲了什么叫做缓存。缓存是什么？

介于CPU和内存之间的一系列的缓存。第二个呢？什么叫缓存行。读数据的时候，一块块来读一块就叫一行一行的大小是64个字节。什么叫缓存一致性协议。

CPU为了保持互相缓存行之间的这种数据的一致性所采用的一种协议。什么叫做一些个编程技巧，就是你可以强烈的让你的小程序，呃，让你的让让让你的数据不位于统一行，就能够增强多线程情况下的效率。

什么叫做乱序执行？前后两个没有关系的语句或者没有关系的指令。它有可能不是按照前后顺序来执行的。现在家证明了这一点，讲清楚了DCL为什么不能乱续，讲清楚了volatile到底是怎么阻止乱续的。

vololaatile在java层面，JVM层级规定了一些东西，各种各样的规定，但是没用，因为最终的实现就是lock and L来实现的。好了，这是今天我们讲的内容来有收获的同学来这扣个一。嗯。😊，嗯。

嗯。😊，描有一些东西啊，就是这些个。实验啊实验因为相当复杂。呃，就不大家做了，而且里边充满了各种各样的汇编语句，你不一定能看得懂，主要得打基础啊。嗯。作为我来说呢，这个整个的今天给大家讲的东西呢。

也是我们课程中的一小部分。这课程呢我们是分了两个2块，一个叫P7，一个叫P8啊，但是无所谓，你大概理解就什么意思就行。我们这个课程呢是。总体上是这么一个系列，有M个知识点，加上N个项目，就是有知识点。

有项目，项目驱动知识点的学习项目很重要。非常的重要啊，比知识点要重要的多。我今天讲的只是知识点的内容。知识点内容呢。是在咱们的JVM课程里。啊，今天给大家讲的是JVM的一部分内容。

给大家讲了多线程的一部分内容啊。呃，这里面的每一个知识点，你呢打开来呢都是一堆的内容，我就不给你一一打开了。如果大家需要的话，找丨小丨姐姐要一下我们的课程大纲就可以了。呃，课程呢有一个很重要的特点。

就是它的时长非常的长。我们现在是差不多要到2000个小时了。有同学说这是个什么概念？呃，是这么一个概念。那个。我们。如果是你在别的地儿呃学过一个课的话啊，像那种半年左右，每周上三次课。

每次2小时那样的课。他们的课重量差不多是200到300个小时。我们大概是它的7到10倍，是这么一个课程的体量。这个没招啊，有同学可能一直问我说老师，你这个课为什么设计的时时间上这么长？呃。

原因是我想给大家讲的深入一些。同学们听我讲，嗯，就是我相信啊很多课你应该都没都没见过。就比如说像这种open openen dedicatedhopot的原码分析。就是linux内核的原码分析。呃。

咋说呢？我觉得给你讲透一点，然后你面试的时候就一定是手到擒来的事情。就像今天我给你讲的volatile，你昨天给你讲的 synchronized，其实你只要听完都已经深入到这种Hospbo原码级别了。

你怼面试官随便怼啊，当然你别真怼他。呃，就是我想给你讲的更么深入，所以必须时间要长。时间不够长，没戏，听懂了吗？嗯，有同学说老师，那你这个课内容又多，时间又长。那我怎么学，我学得过来吗？

来有这个疑问的给老师扣个一。如果别人那学半年，你这机会得学两年。听我说这课呢一个特点是。简单解释一下。一对一的一个定制化学习。注意咱们课是定制化的，是面向效果驱动的。

并不是说非得要求你所有的细节全部掌握完，你也别这样学无止境。因为我们每年还在不断的更新课程。你想学完这件事是不存在的。但是呢呃对于你来说，你只要达到效果是不就可以了。所以我们是效果驱动。

什么叫效果驱动呢？我给你举个例子。就这课呢是这样来学给你举几个例子啊，就是这种一对一的定制化的学习。刚才说了啊，课程。食堂。教程。深度。可是。怎么才能达到更好的学习效果呢？学效我就在于。一对一。

定制了学习。给你举个最简单例子，你比如说。大学生。米小金大厂。有大运种小金大成的吗？我相信有啊。我们会给你规划一条路线，学我们课程里面的7加1加1就搞定了。你只要按着来就搞定，啥都不用你想。

把你的自己的这种基础告诉我，就是你自己的基础情况，你自己的诉求、短期诉求、长期诉求。你自己的领悟能力，你自己的简历拿给我。我会告诉你，根据你的诉求来帮你设计条路线出来。比如说大学生想进大厂。

7加1加1在我们课程里帮你搞定。比如说你社招生想进大厂。你社招生的话，和和那个大学生还是不一样的。那这时候怎么办？小金大厂6加2帮你搞定。你说我想进头条字节。字杰腾讯、拼多多比较牛逼的企业怎么办？算吧。

帮你搞定。我们算法课是左成云左老师在别的地儿讲课，差不多六七千块钱的那个课。全程的帮你搞定。比如说我如果是零基础的，说我特别弱。小白，我想走到一个更高的薪水的岗位上去。从A课程到P课程。

一系列课帮你搞定。比如说你说我想全面提升怎么办？说我时间很充裕，我也没有说什么短期内非得就想跳槽涨薪。没关系，P8课程带着你帮你搞定。有人说我非常的特殊，我不仅我想学整个开发，我还想学测试。

想学这个运维等等。OK我们所有的帮你定制出来一些课程，帮你搞定。好了，这就是我们课程的一个特点。大有同学可能会说老师效课程效果怎么样？呃，在我给你详细解释课程之前啊，其实还是拿效果说话，好吧。Yeah。

还是拿效果说话就行了啊。哦，又又更新了一些内容啊，挺不错的。嗯，每天呢我们基本上都会收到学员的一些个反正向正向反馈啊。当然有些同学员比较内向，懒得跟我们说，他取得的成就其实真没必要啊。因为这里面呢。

基本上学员的隐私信息都隐去了，但是聊天记录都是全部都非常的真实，支持你做任何的被调，这是这是最最新的，这是学比昨天昨天看到的更新，这是干了两个半月，长沙涨薪5O。

呃，虽然他原来的薪水不是特别高啊，这个最近拿到offer涨了5K，月薪13K。当然这东西呢。他原来的薪水不太高，所以让他涨起来太简单了，呃体现不了我们课程的水平。

系列 2：P33：SPRING源码：01Spring从入门到放弃 - Java视频学堂 - BV1Hy4y1t7Bo

重点侧重在哪，i o c这块，我先问一个点，先问一个点，ioc ioc它底层的实现机制是什么，有人知道吗，ioc里的时间就是dna反射，对你应该答的是反射的东西，你们对反射应该是非常非常熟练了吧。

啊非常非常熟练了吗，反射是什么东西啊。

比如说我来写代码，大家来看一下到底是什么样的一个效果好吧，这就是随便一个项目，我之前做测试的一个test项目，这里面没啥啊，啥都没有啊，啥都没有，非常简单，先做这样一件事，在里面，你们在公司里怎么做的。

是不是先创建一个最基本的package，叫什么control，是不是创建这样一个包，然后在这个包下面我再创建一个包，page叫service，然后呢我在ctrl是不是要调用我们service里面的东西。

不然都删掉还是干掉，不用它这个control只有service，然后在里面假如说我写这样的东西叫什么呢，叫user series，然后呃不对，给我下边这写一个叫user control，control。

大家都这么干的吧，然后呢你需要在这个user control里面做这样一件事，什么事呢，private，然后写一个user service，再写一个er service，这个代码看了没问题了。

看没问题吧，这块儿我还是那句话，你要具备一定的spring的基础，这块才能听得懂，你每次在调的时候，我是不是直接调用我们service里面的方法去处理具体的逻辑就完事了对吧，那这里面就会涉及到一个问题。

什么问题呢，这我只是声明了一个引用，对不对，它并没有实际的一个对象，这些对象如果如果我现在要想把对象付给他怎么办，你们之前做的都是这样干的，随便写一个注解叫at auto w。

q w a r e d是这么干的，但我这个地方是一个普通的最最最普通的一个项目，里面没有引入spring任何东西，如果让你自己来实现一个这个东西能不能实现，能实现吧，能实现吗，别扭好吧。

new就没意思了，如果让你自己来实现，能不能实现，或者说或者说我不用我们oo的，我就用最基本的一个反射机制，我能不能做这样一件事，所以可能会说老师这东西到底怎么做，我不会写代码。

其实spring里面的代码非常非常简单，没大家想的那么难，只不过大家看起来比较麻烦的原因在哪，在于里面的类太多了，接口也非常非常之多，你在一层一层找的时候，看一会儿你就看懵了，所以你如何把死的源码看好。

掌握其中最核心的点好吧，记住我叫最核心的，那我现在我做这样一件事，什么事呢，这样我已经有一个service需要在control里面好吧，付付给我们的就是service这个对象，如果让你来让你来自己设置。

或者通过反射来进行这样的一个实现，能实现同学来扣个一，不能实现同学来扣个二，能实现吗，很多同学敲二啊，就如你要想把词汇原本看懂，你反思你必须要会，你跟老师，我一点反应都不会，那不好意思。

这课可能不太适合你，明白意思吧好吧，我们来写一下，看这块儿我应该怎么做，其实非常简单好吧，我创建一个my test，这可以吧，在里面我随便写一个方法。

public void test这样一个方法上面加一个at test，没问题吧，我们一会儿方便我们做测试，那这时候你要想做怎么做呀，很简单吧好吧，第一步，user control。

先创建一个user control的一个对象，这没问题吧，然后你要想拿到它整体这个映射的对象的话，是不是有三种方式，第一种class for name，就是我们之前在学gd b c的时候。

你们就用过的东西很简单，这是第一点，第二点是不是通过类名点class获取到，第三种是通过对象点get class，是不是三种方式，我这儿用的是第三种方式，所以这时候可以怎么写，可以这样写。

user control。get class，这个没问题吧，应该能看懂吧，创建了一个大写c的一个class对象，有了当前这个class对象之后，我能够非常非常方便地去访问里边的属性方法，哪怕你是私有的。

我是不是也能够进行最基本的一个访问，这块能听懂同学来给我扣个一，能听懂吧，比较简单比较简单好吧，下面我们来写一下试试吧，你注意了，你要想给我们这个controller里面的service负对象。

首先第一步我是要先创建一个对象，什么对象啊，reuser service，user service等于new一个user service，这问题吧，这是第一步，很简单的好吧，有了第一步之后。

第二步在干嘛，你要把它给复制进去吧，而本身在我们当前这个control里面，它只是一个属性，是不是一个属性，既然是属性的话，来告诉我怎么做，你是不是可以通过反射或者说获取所有的属性，属性吗。

怎么获取来着，叫class这样写吧，把这个改一下名字啊，c l a z这样写舒服一点，这样写一个class。get什么东西，是有东西叫get fs这块获取到是一个什么fs的一个集合，这没问题吧。

同时你可以获取到具体的某一个具体属性，是把这属性名字传过来，这两个方法都没问题，能拿过来，但还有一个什么呢，叫declare是啥意思来着，是不是可以获取到我们对应的一个访问权限的一些设置的东西。

所以一般我们在用都用什么叫get declare fad，然后传入一个属性的名称，这名字叫什么，是不叫user，这问题吧，我把这个拿过来啊，user叫service，四个字，非要这有异常抛出去。

小张这个时候能看懂，这很简单吧，获取到我们对应所有的一个属性值，拿到当前属性之后没完，你还要干嘛，他干什么事，我是不是最终目的是为了给这个属性要赋值了，那赋值的时候你看到了我这写的是什么私有的吧。

既然是私有，意味着不对外提供公有地方不公允的公公有的一个吸管权限，所以这时候你需要通过什么，是不是通过一个set方法，是不是来设置我们的属性值，要通过一个get方法来获取我们对应属性值。

是不是这样的东西，所以这一块我们可以直接来进行运行，get把都写好，写好没问题吧，好写好之后，我这改一下create，这可以吗，你是不是也可以把它当成private，那这个时候我这儿如果测的话。

如果测的话，我能拿到当前属性值吗，听懂我意思吗，听懂我意思啊，如果我能拿的话，能拿到吗，这时候能能拿到，不能吧，我改成什么东西了，是不是叫private，这种情况下应该是什么，应该是public的。

所以这个访问修饰符这一块一定要给他搞清楚了，千万别随便瞎写，别随便瞎写，如果你是私有的话，想拿也可以怎么办，c水怎么办，可以这么干，是不是有对应的一个这样的一个属性值，什么属性值，然后还记得吗。

叫user service fad，点set accessible，把这个值改成true，是表示说我也可以访问我们对应的一个私有属性，这样的一个值，这没问题吧，这东西啊你们应该提前学反射，都接触过了。

都接触过了，这样接触完了之后，下一步再干干嘛，在干什么事，还是那句话，属性你是没办法直接操作的，所以只有通过通过方法的名称的方法才能够设置具体的属性值，是必须要通过方法，那方法的话，我这应该怎么办。

很简单啊，我们那个set和get方法，它都是有具体的一个自己特点的啊，自己特点的，那自己特点的话可以怎么写，是不是第一步叫service failed，第二get live嘛。

是不是先把这个名字给拿过来，这没问题吧，拿这个名字拿到这个名字之后，第二波我可以干嘛呢，是不是拼接什么方法的名称，要不然是get，要不然是set，只有这两种对应的一个方式，所以这时候你可以做这样操作。

name等于什么呢，name。sub stream，是不是截取下我们字符串，因为首字母必须要进行要大写加粗，apple case，这没问题吧，然后再拼上一个什么呢，叫name，点substring。

拼上什么一逗号，name，点length，把剩下的东西给拼起来，那此时我拿到的东西说白了就是一个什么，是不是原来叫user user service。

现在呢呃现在叫什么叫大写的u然后呢the e u s e r service，是不是这样的方式就转了一个大写转大写转大写之后，第二步是不是该拼接了，怎么拼接，写一个string叫set method。

name等于set，然后呢加上我们刚刚写好这个名字，这个时候我是不是拿到我们的方法名字了，是不是拿方法名字了，拿到方法名字之后，下一步在干嘛，叫通过方法，然后呢注入属性的对象，这怎么写来着。

是不是叫class c l a ss呃zz，第二干啥玩意儿，是不是叫method，是不是要获取一个方法了，方法名字就叫set method name，第二个是要传我们对应的一个类型。

而写一个uer service，这样class整理好我们这里一个诶，大写啊，your service指定好这样一个类型，当我把这类型拿到之后，这是不是意味着我们获取了一个master的方法了。

有了这个master的方法了，那很简单了，干嘛是不是反射就行了，是不是反射型怎么做，method。invoke，然后呢把我们对象传进去叫user control。

然后逗号把user service service给传进去对吧，这块都传完成之后，我可以做一件事了，什么是s o t叫user control。get有的service，这个时候如果我能拿到具体的对象。

具对象，那意味着什么，是不是能取到具体值了，太基础了是吧，你们都觉得这东西几个基础是吧，一会儿咱们往下写好吧，就这些基础东西有多少同学看不懂，如果你觉得这东西比较基础呃，去看别的课。

不勉强不勉强明白我意思吧好吧，如果你觉得你这些东西可以忍受，接着听，好好听，ok好了，刚刚这段就是一个反射的原理，那现在我通过是什么。

是不是user controller这个对象来获取er service，你肯定也看到了，control里面有对象吗，没有吧，我是不是通过一系列的反射操作来达到对象了。

这个时候这个时候如果我能打印到具体对象，那意味着什么意思啊，是不是意味着已经成功了，好吧，来看看看看具体操作好吧，看看具操作，不要嘴里的东西，基础好吧，spring里面就这么干了。

看这是不是有一个service，这是不是拿着对象了，你甚至可以把当前这里面这对象，you are service，来，我们试一下，打俩对象，看两个对象到底是不是具体的同一个对象是吗是吧，那意味着啥。

我通过这样一堆一系列的代码就完成了我们整个对象属性的一个反射，猪进去了，和同学老师这东西比较基础，我们在学那个gdb c，一般讲到g d b c的时候，都会给大家讲反射好，都给他讲反射，讲反射的时候。

按道理说你们应该是具备这样的一个能力的，能把这段代码给写出来啊，应该能把这个代码给大家写出来啊，但是我需要强调是什么，那老师太基础了，我能写出来，但是你看到源码之后。

你能不能看懂啊，当然原版里面可能不是这么做的，因为现在你们其实很少写这种原生的这种呃反射的方式的。

更多还是用什么，是用我们对应的啥玩意儿，啥玩意儿是不是又注解了对吧，但是你要先把这块东西能理解到这块东西理解了之后，我们再用注解来实现一下，你们当时用那个at out to wr的注解。

是不是拿spring框架里面直接自己用的，我能不能自己写一个at ow，理论上来说一定是没问题的，一定没问题的，我们一会儿来带你实现好吧，来这段代码能看明白，同学主要是扣个一能看懂吗。

如果看不懂也没关系，下去之后把你反射的基本技能给补充一下，好把反射给补充一下，你只要学完反射了，知道这些方法是干嘛的了，你知道怎么回事，听到意思吧。

那这东西我不能可不可能说我再把反射里面具体信息再给大家，大家详细讲一下，这是啥意思啊，你可以看一下这是啥东西啊，有一个class的一个类。

找一下吧，这是jdk里面原生提供我们的一个class class一个对象，通过这个对象我可以做很多的事情，包括生成具体的一个实验对象，好生成具体的实际对象里面有一堆的一个解释，在当前这个类里面好。

那当然这个类里面可有什么东西啊，可以看下这个方法，看一下这个方法好吧，找get的方法有get annotation，是不是获取注解，有get class loader类加载器，有get什么。

是不是还有一些constructor获取到构造器，还有get failed，get method，也就是说当我现在如果有了一个大写的class对象之后，我可以对当前这个对象里面的所有属性方法构造器好吧。

任何东西都可以做随意的一个编写，随的一个编写，你想怎么改就怎么改，想怎么玩就怎么玩，听懂我意思吧对吧，这点就注意了，那说没明白为啥不直接调用set user service，我们这儿看这儿啊。

我们这儿在进行最基本调用的时候，你想一下你用反射是干嘛的，用反射干嘛的，你这块在写的时候，我是直接写死的，但你想一下spring里面的东西，我能直接把每一个类给你写死吗，能写死吗，不能吧。

它更多应该干嘛，这些类都是不知道的，都不知道的，我应该生成的是一个提供是什么，类似于一个模板的东西，你按照我的模板往里面套好吧，不管你传入什么类，我都能够完成最基本的一个功能，最基本的功能啊。

所以是以这样的方式来进行完成的，明白我意思吧，这大家一定要注意了，好了，来这个点能过了吗，能过同学这样的扣波六能过吗，好了，正常过之后，我们再来写写什么，刚才老师，我在公司里面不用这种方式，我用什么。

我用这样一个方法叫at auto wear，是不是这样注解，我现在里面没有这个注解好吧，因为我从来没写过这样东西，我这个一代里面也没有任何跟spring相关的一些框架的东西啊，就是最普通的一个账号项目。

那现在如果你想使用awm的，告诉我我怎么做，能做吗，肯定可以吗，你们现在用的注解是框架提供给你的，那我完全可以自己实现一个注解吧对吧，对于class叫out over，这是不是可以。

然后在前面这儿改一下，改什么东西，at interface是变成注解了，但是你在写注解的时候一定要注意了，它是不是有四个对应的属性值，是不是四个东西对应对应的属性，这四个对应的属性分别是啥。

我可以怎么写，第一个你必须要写的at里面写什么，写一下我当前这个注解它的一个运行的一个范围，是源码编译还是运行时，这有东西，reaction有个什么wrong time吧，把你属性给加上第二个属性。

还有什么东西叫target吧，比如说我当前这个属性可以作用在什么地方上，在这儿也一样的，element type，然后呢第二是failed，我是不是作用在我们的属性上面，我是不是这样的话。

我就把它定义好了，还有一个继承吧，还有一个dotomation俩东西啊，一般没用，把软工写好之后就可以了，还有什么东西at in ht对吧，还有一个at d o c o dog问题的也有四个注解。

这两个主角写不写无所谓啊，影响不大，所以我们这不写了，就写这样的东西，这都能看懂吗，好非常简单非常简单了，在写完之后，然后把这回来报好了，这里是不是已经自动到导入进来了，这导入进来之后。

你现在能直接注入了吗，肯定不行嘛，不要纠正我的发音，同学们，求求你们了，我求你们，求求你们这个翻译，我知道不标准，希望大家忍受一下，等马老师开英语课的时候，跟马老师好好学一下英语好学英语好吧。

往这看往这看，我这是不是有个out，where are，有它之后，我现在是没法直接往里面写的，那如果是spring源码的话，他会帮你做什么样的一个处理啊，来我们再创建另外一个类。

your class叫my test，2k里面写一个，还有一个botest，一样道理，at test问题吧，那这块我在写的时候，我应该怎么去写它呀，写的套路跟刚刚一模一样，user control。

然后u的ctrl等于另一个user ctrl，这没问题吧，由它之后，第二第二步干嘛，还要通过我们的ua controller。get class获取到当前class一个对象。

这改一下c l a z z太黑了。

太黑了，改一下。

现在看到了吗，现在看到了吧，来了就刺眼了，我的天呐，你们这太难搞了。

你们不管了，就黑的好吧，不适应同学没办法了好吧，看到了吗，看到了吗，ok啊，我把字放大一点，放大一点，ok呵呵，太太难搞了，太难搞了，来往这看，今天晚上看，今天晚上看，不浪费时间，不在这浪费时间。

这样获取到这个class对象之后，下一步干嘛了，一样的，我先创建好一个user service，这种啊，这个套路都是一模一样的，就是service等于另一个you a service。

是不是这样的对象有了当前对象之后，下一步开始变了，开始变什么东西一样的，你也要需要获取到我们的属性值，一样的，你要获得什么属性的一个注解值吧，是不是这些东西我都要能够给获取到。

那这个时候如果你想拿过来用的话，我应该怎么去进行最基本的一个使用啊，这玩意该怎么做，其实也比较简单，也比较简单好吧，怎么做呢，第一步你要把所有的属性都获取到这选项，获取所有的属性值怎么写。

是不是有这样一个方式，stream。off吧，应该用过class，点get啥玩意儿，是不是写一个declare files，把所有属性给拿过来，拿过来之后再写一个，第二for each。

应该有人见过这种写法，让表达式再写一个fid，ok你先可以这么写了，应该怎么写，这是第一步，我先获取一下我当前属性的一个名称，再写一个in fid点，get li，把属性值给拿过来，拿完水之后。

第二步原来你是拼接名称的方法，直接给它注入进去的，现在不再用我们对应的方法了，专业方法了，用什么，它下面是不是已经加了一个啥样l to wear的一个注解，对不对，那我能不能获取到我们这个注解。

是不是也可以叫fid，这get啥玩意，是不是叫annotation，对吧，里面写上你要获取的是什么样的一个注解，是不是叫out wor，点class，这时候可以拿到，拿完之后再声明一个变量名称吧。

叫antiquation，比如这个t键之后，我这可以注意判断了if什么东西，annotation，然后呢，不等于意味着你当前属性上面已经加了注解了，如果你不等于空，我把当前的属性值可以做一个设置。

设置什么点，set accessible，为了安全，我们还设置一个cessible，好访问我们对应的一些私有属性吗，这是第一步，第二步你要获取到什么，是不是可以获取一下我们当前这个属性的类型。

是在这儿get tap吧，点吧，再写一个获取属性的类型，有了当前的属性类型之后，我下一步可以再干嘛，可在干嘛，这是我的类型啊，有类型之后我有这样的方法叫什么，叫tap，点什么呢。

叫new instance，想一下这个属性的tap是啥，我们这儿定了your service，它是不是它类型，我有这个类型之后，我能不能通过你有instance的方法来获取到具体的一个这个对象。

是不是可以有是可以有来点有他们用完它之后。

这有个异常，让它捕获一下。

系列 2：P34：SPRING源码：02手把手带你阅读Spring源码 - Java视频学堂 - BV1Hy4y1t7Bo

只能捕获有异常之后，第二步叫什么叫fid。set，现在谁呀，把我们当前这个user control里面设置上，我们当前这个object就增加o这可以吧，可以吧，如果你把这个步骤也完成了，下一步该干嘛了。

我做这样的操作，这打一句话，s o t什么呢，builder control。get your service，看这块啊，看这块啊，我在写这块东西的时候。

还有拼接那个字符串叫set user service吗，还听这方法了吗，没拼吧，是不是没拼任何东西，这是不是只是用了一个instance，那这个时候这一段c位咱有用吗，这对象刚刚是不是又网卡了。

是不是你自己来定的，现在还需要你有一个对象吗，是不是也不需要了，这也不笑了，那我现在看一下我能不能把这个对象值给它分进去，看能不能打印出来，好吧，如果拿出来意味着没问题，如果打印不出来。

意味着就有问题了，好看一下这个对象有没有是不是立场值，这个对象是我们自己用的吗，是自己用的吗，不是吧，谁帮我们丢的，是不是这儿有一个东西啊，new instance，通过这个new instance。

我是不是得到对象，得到对象之后，我是不是可以放到我们当前这个属性里面去，是不是相当于完成这个功能了，明白我意思了吗，啊所以这时候大家已经发现了，我现在用普通的反射方式给大家实现了一本。

我又把注解的方式给大家实现一段，这两个东西你写起来你觉得难吗，what the word，没有啊，什么都没有，就变成空调的话，注解什么都没写，什么都没写，什么都没写好吧，这有一个one test。

把这个水平值给大家做一个拼接，做一个拼接好吧，你看一下是不是就完成我们最基本的功能了，是不是也能完成我们对应的一个自动入住功能，是这个时候我把这set干掉，我不要set了，来再试，能行吗行吗。

跟你的set有没有关系，没关系吧，是不是没关系，这种东西这种东西能不能看明白，能看出同学给老师扣个一，能不能看懂，我知道这块少了很多逻辑判断，少了很多完善的逻辑，没毛病。

咱现在不是要手写一个spring好吗，手写跟spring有什么意义啊，没意义好吧，别人已经写好东西，我只要能拿出来用，看懂原理就行了，你在看具体spring源码的时候，你看到底层的时候，他也是这么干的。

只不过人家创造了很多的一些属性值，加上很多非常完善的一个判断，那老师那就不用了，对确实不用了，我之前在这的时候是不是有用到我们当前这个这个name值吧，因为你要拼接，这时候还用吗，不用了吧。

stream mf啥意思，stro拉姆达表达式，lamba表达式，把它转成一个水母流，好这样spring流就是我这样，为什么要写这样两个程序来给大家带入我们的spring，原因非常非常简单非常简单。

你把这两个东西理解了，你就知道在我们整体的ioc这个容器里面，容器里面我到底是怎么完成我们功能的，你想一下你现在写代码的时候，要不然你写xml文件，要不然你写注注解好吧，要不然你用配置类。

但不管你用什么样的一个方式，是什么样的方式，最终那些对象都跟我们没关系了，这不是我们自己创建的吗，谁在创建的，是不是死人创建的，所以你一定要深刻理解反射它存在的一个意义好吧。

你要想把ioc底层东西搞明白了，就把这个反射搞明白就够了，你看他反射的时候别懵，当然我说了，这是一个最low的，而且有非常漏洞的一些程序，但是这块儿我希望你能够看明白，希望你能看明白。

因为只有这块你看明白了，你在看ioc那些对象创建的时候，好吧，就很舒服了，为什么，现在没关系了，我不是已经把set方法给注释起来了吗，是不是注起来了，你这样再往里面赋值的时候有用到set相关的东西吗。

没有了吧，对不对，但是但是如果你要用我们第一次写这个程序的话，它是需要set的方法的，你必须要往里边进行一个最基本的注入，所以这两个代码看起来非常简单，但是就是spring里面好吧。

进行反射的一个核心点，就是核心点，你把这些东西搞明白了，你就理解理解透了，明白意思吗，对老师，你这只写了一个out to word，你写的at value，at value是吧。

包括你写的那些at controller对吧，at service at component这一堆的注解，你能不能自己也做这样的实现，能够实现吗，是不是就可以啊，有同学我要手写一个spring。

没意义没意义，还是理解对应的一个本质，理解一个本质，你把本质点理解透了，这东西没大家想的那么难，很多同学为什么觉得难，就是因为你上来之后趴着稀里糊涂，从前面开始点一点点点点点点。

到最后诶我是从哪开始点进来的，一脸懵逼，往回找的时候找不找找不回去了，所以每一次从第一行代码开始往这边找，找到最后不行了，再从第一行开始找，再从第一行开始找，找完之后你就废了啊，不知道怎么回事。

不知道怎么回事，明白意思吧，所以先把这块看明白，之前老师说弄懂sm码要10年时间，10年天呐，你你你你用你用10年时间搞一个辅助源码，我的天啊，你你还学不学别的东西了，你还听不懂，你还学不学别的东西了。

别扯了好吧，别扯了好了，这块如果搞明白之后，如果搞明白之后，下面我们来说怎么看源码，怎么看源码，看源码贼简单，但是我不希望不希望你在看源码的时候，从头到尾慢慢去看这东西，为什么那样看，你看完之后就疯了。

还是一句话，你在看原版的时候，看原版的时候一定是你已经用了非常非常多spring对啪，对你们的组件你必须已经足够熟练了，这才行，你老师我一点那个spring都没用过，你让我搞搞源码，搞不了。

别搞没用好吧，那这时候怎么办呢，来给大家说一下学spring的时候。

第一件事千万别忘了去看spring的官网，这个官网真的是太宝贝了太宝贝了，是真的，里面有非常非常多的一些核心点，点开project，我们选的什么for work吧，对不对，等一下啊。

the word选择learning，选择随便也满不满无所谓啊，在词汇里面我们选call call里面介绍我们对应的一个i o c了，在o c里面你从上往下翻看到这块的时候。

就已经给过你很多的一个解释了，说什么东西有什么contest，对不对，还有个东西叫being sy，这是一个非常非常重要的一个接口，也是非常非常重要的一个对象，也非常重要的对象啊。

你在看的时候把这段东西好好看一下啊，如果你觉得还难受怎么办，也很简单，打开spring程序。

或者随便找一个spring程序啊，之前上课写代码，随便op代码，随便开一个，这样你来搜一个东西叫bb，是不是这个接口这个接口上面有非常非常多的一个解释，这个解释很重要，你可以先不看，没关系啊。

你可先不看没关系，但是我在等源码之前我会干嘛，先帮你进行整体脉络的一个梳理，刚刚通过反射，刚刚通过反射，我们也知道了，我能通过反射的方式来创建出来我们具体的一个对象对吧。

但是我们在学spring的时候，它好像没这么简单，也没这么low好吧，你想一下你当时用的时候，你是怎么用的，你怎么用的那种方式，非常简单吧好吧，第一个在老版本的时候，你刚上来可能要写一些插画文件对吧。

或者你写什么，现在的方式用一个and location，这样的一个方式对吧，不管你用什么样的一个方式，这两个里面大家想一下，你都定义了点啥，这样东西垫着点啥，这些东西其实也非常简单吧，订台分公式。

你想一下是不是就是定义了我们当前这个病对象里面，它存在的一些信息吧，再写一下往上写，点一进来再写一个并信息，比如说你的病的名字i d是啥对吧，里面有哪些包括力属性，引用了哪些引用，有有有哪些引用对吧。

包括你的初始化，初始化方法是什么，你的消费方法是什么，是不是有很多这样的东西，你都会配到这里，这里面这能看懂吗，然后配到这里面去之后，这以后下一步在干嘛，别忘了ioc，他说白了是个什么东西。

啥东西叫容器，对不对，我来看画的东西叫容器，什么叫容器啊，什么叫容器，容器怎么理解，非常非常好理解，所谓的容器好比你喝水的时候是不是用水杯，水杯是不是容器，那这块也是一样的，好，那问题来了。

我如果想要有用来装载我们当前这些并对象，这些病对象，我的病对象应该怎么进行存储，第一你要方便你进行一个查找吧，是方便进行查找啊，而且在spring里边还有一个非常非常重要的一个特点是啥来着，是啥。

记得吗，如果你没做任何判断的话，它默认情况下是单例的，对不对，你可以指定power type，power type，但更多的是不是还是single的，是不是单利的对吧，那这个时候我在存储的时候用什么存。

刚才说了，用concurrent hc代码，所以那时候我在进行定义的时候，我其实可以定义这样一个代码，放容器怎么定义，有啥东西，很简单很简单的东西来着，这写一个map，对不对。

里面写一个string对吧，那第二个我应该写什么东西啊，写啥别忘了这儿你在进行编写的时候，第二步骤里面有一个非常重要的东西，我不get了，一看就没看过源码，源码里面绝对不会直接放obs，放什么东西。

有这样一个东西，being definition，好，我不知道这是啥，没关系，单词先不重要，那叫什么叫b等信息，再写一个map，等于另一个c o r r e n t，开心了吧，可以这么写吧。

是不是这样的东西啊，变了一些定义信息，这是一个map了，我，好了，这个mac没问题吧，除了这个mac之外，你想一下，这只是放了一些定义信息，肯定写不太完整不太完整，那我再怎么办。

我是不是还应该放一个map结构，放map结构想一下放些什么，map上面有一个string，对你们刚刚说的是不是东西叫object，就是你具体的实体的类到底是啥，对不对，它就一个concer。

卡西lap是不是应该是有两个这样的一个map结构，有了这个map结构之后，有了这个map结构之后，我是不是就可以进行相关对象的一些直接存储了，但实际里面是这么存的吗，是这种存的吗。

我们可以做验证的领导老师这咋验证啊，没法验证啊，我又不知道哪些类，我还是那句话，你去看官网好不好，你去看官网好不好，你看看官网的时候，你知道了这样一个对象叫什么，叫been factory，叫病的工厂。

对不对，很明显，你们应该都知道工厂是干嘛的，生产对象对不对好吧，但是它是一个什么叫接口，接口是不能实例化的，那意味着啥东西，接口的底层实现里面一定有具体的实现类，你虽然不知道是啥，但一定有时间力。

对不对。

那这个时候打开spring的源码，别歪嘴吧，你往哪看，他说了，发展interface，such as叫lizable being factory，还有东西叫什么呢。

叫confetable being factory，是不是两个类对象干嘛了，我也不知道，不知道没关系，来点开它一类，这是不是告诉你说它也是一个接口了对吧，然后这个接口里面它一定也有什么。

是不是也应该有自己的一个时间内点开，有东西叫default，liable being factory，在这里面你往下拉来搜，我们对应一个mac结构，找办法好吧，看这是不是有一堆的那1234有卖吗，有吧。

那么干嘛了，我不知道resolved dependence啥意思，处理的依赖对不对，跟我没关系，叫bedefinition mac，想想我刚刚写的那个东西写啥来着，是不是写了一个string。

写了一个原并的一个定义，这是不是有是不是这个信息了，这有个or may be liams by tape，是不是根据类型有病名称的一个匹配，还有一个singleton bean name by太坊。

是不是按照类型进行这样的一个匹配，是不是就放了一堆map结构，我们每次取的时候，是不是就是说通过这些map我能够把具体的数据值给直接获取到。

如果我能够拿到的话，就意味着外面19有了，那这个map说白了它里面帮你做了一个封装，封装完成之后变成什么了，是不是就是我们这儿说的这个i o c容器啊，我放这边吧，哎呀就放这了。

这就是我们说的这个ioc容器，容器里面是啥，是不是就可以理解为我放了一堆map的东西啊，那里面可以用来放置我们具体的一些对象，这能不能听懂，能听懂，学来扣个一，这容器吧。

当然有的老师你这里面放map没毛病，我能听懂，我能听懂，放map，但是你这个map里面的这个对象哪来的呀，这是怎么过来的，怎么过来的，又很简单啊，怎么简单很简单啊，这有一个叉号。

有个annotation，这两个东西是干嘛的，都是用来放置我们这些病的一些相关信息的，我可以通过这样的方式把它给读取进来，或者说给加进来啊，那问题是问题是什么东西，我每次在进行加载的时候。

可以从叉l文件读，也可以从注解里面进行一个呃配置读，那我应该怎么做呀，所以在这块的时候，别忘了他是一个什么，是一个框架，好吧，有框架的时候，每一种具体的子类实现一定有自己实现的一个原理。

但是在上层的时候，你告诉我这人干嘛，大家干嘛，是不是应该有一个抽象层，等一下抽象层，上次看完了有这样一个东西叫什么呢，叫b。

definition d e f i n i t i n definition，然后呢叫rider，就这样的对象，我把这个加加加点颜色啊，好加上颜色，这个对象是干嘛的呢，这个对象的意义其实非常简单。

不管你外部的这些病信息到底是从哪读过来的，我不管我一点都不关心，但是你要想读取其他的一些配置的话，不好意思，你必须给我实现当前这样的一个接口，因为只有有了当前这个接口之后，我才能够进行具体类的一个识别。

啥意思啊，我才能够把这里面的属性值给读过来，可以是插盘文件是吧，也可以是对应的一些呃，注解配置什么方式，我不限制，我也不管，我也不，我也不关心，但是你要想实现，必须有这样的一个接口啊。

这接口你是必须要提供好了好吧，所以这块你可以写这样一句话，叫什么叫读取，搞定义信息，这没问题吧，是这没问题，但你把它读取过来之后在干嘛，这黑在干什么事，注意了，这只是一个接口，底层有具体的一个实现类。

有了实现类之后，那意味着他读过来之后啊，你注意啊，如果你是插画文件的方式的话，你注意了，这个叉号文件在我看来，在我看来它就是一堆的字符串，这能理解我想表达的意思吗，它就是一个字符串。

这个字符串在这放着一点意义都没有，所以我要把这些字符串转换成我能够识别的这些类了，是不是进行识别这一类，所以我要把这里面的一些相关信息我都给读取进来，把对进来读过来之后，把这儿会放成一堆对象。

这叫什么东西，是叫定定义信息，什么定义信息啊，比如说你定义了一个init method的一个方法，比如说定义一个distroy杠method这样的方法，比如说定义了一些property。

像这些属性是不是都是我们应该读取过来的，是读取过来的，我们把这些信息都给读取回来之后，那下一步该干嘛了，这是怎么读外的，是通过这样的方式从上面直接给迭代回来的，看这儿看这个箭头。

这个问题吧是从我这儿直接读过来的，你通过这个读取之后，这就完成了，当你这样完成之后，没完什么叫没完啊，你有了这些病的定义信息了，下一步该干嘛了，你告诉我下一步该干嘛了，有了这些病的定义信息。

那下一步我应该把这些病的定义信息是不是要转成具体的对象，也就是我们要完成一个具体的实例化的一个环节，对不对，实例化，实例化站在完成实例化的时候，其实这个过程也是比较简单的。

完成实例化很明显怎么实例化反射嘛，是不是通过反射可以进行一个实例化，可以用什么，class a new instance吧，是不是可以这样进行一个呃实例化。

实例化完成之后就能获取到我们具体的一个对象值了，那时候我拿个箭头，快下，转一圈好了，好了不能马上坐下，这我能看明白，那其实这个过程里面它所涵盖的一个意义就是什么，就是我们整体的一个实例化。

这如果是实例化的一个过程的话，那这应该是什么，是实例化之后的一个对象，找对象，这没问题吧，大家听明白吗，再换个12是对方对象，ok这样这能看懂吧，这样能看懂之后能能能看懂吗，能吧，ok这样看了之后。

这到实例化了，这个实例化这个环节是不是有点太简单了，我拿过来对象直接实例化，这么这么这么着就完成了，不对肯定不是这样的，因为你在实际这个实例化的过程中，你看到了很多，或者说看到了非常非常多一些。

你看起来非常难受的累，什么难受累啊，比如说我举个例子，你们有没有看到过一些这样的名词，你们看不上这样这样这样东西，叫processor，有人见过吗，见过吗，process干嘛的processor。

它实际的一个意义叫什么呢，叫增强器或者叫处理器，这有什么意义啊，啊这块有什么意义啊，e其实也非常简单，然后一个对象信息我直接实例化这么多，多多没意思啊好吧，我在中间这个过程里面。

我可能会牵扯到非常非常多的一些处理逻辑这块东西，所以这块你如果想完整表述的话，可以怎么做呢，这还是对象，是实例化好，在当前这个对象实例化之前，实例化之前，我在上面我要添加n多个或者n多组的一个模块。

那c2 v，啊上下啊或这样的东西，然后呢整体这a，这给个颜色，就这颜色这啥意思，并在实际化实际实例化前或实际化之后，它最终都会有一个从上往下依次执行，必须要经历这样的一个环节，把这地。

然后在这个环节里面我给它涂一个色，这个颜色好吧，这些东西全部都是啥呢，都有一个名称叫p r o processor，p o c e s s o r，还有一个processor。

这样东西有processor，有了当前那个processor之后，这其实干嘛的去干嘛的，这块东西对我们在整个类实例化的过程中，课程中可以干嘛，就是说在前在后，在前在后，我能做什么事。

是不是可以附加很多一些额外的功能，我想加什么，是不是就加什么就完事了，所以这我虽然只画了一个实例化之后定对象，但是中间这个环节里面应该是包含非常多的一个数逻辑的啊，这应该是指向到整体这个流程里面去的啊。

这应该是有一个指向性的东西的，这儿只有指过去，它才是一个完整的一个回笼，所以你看起来好像比较简单，但其实没那么简单，这块最终的目的是为了什么，是为了什么，就说为什么，要添加。

这么多p r c s s2 ，看什么东西啊，原因在哪，注意了，spring，是一个框架，作为框架首先要考虑的就是什么扩展性吧，是你必须要提供一个扩展性，如果你写的代码都是比较死的，拿到你代码之后。

别人谁也改不了，谁也动不了，那你觉得你会有这么长的一个生态吗，别人会轻易使用你当前这样一个框架吗，一定不会吧是吧，也就是说在这块有了这些processor之后，我能做什么事，可以自定义。

processor来完成整个，的实例化过程，啊增强某些功能，而至于是什么功能，而且这些是什么功能，你自己随便随便好吧，你想加什么功能，都只要你遵循它接口的规范，都能够进行这样的一个实践，能讲点时间。

这东西能不能看懂，到目前为止能看同学来给老师扣个一，能看懂吧，这如果能看懂之后，ok下面再来一个问题，什么问题，啥问题，你有没有感觉在整个环节里面少点东西，少啥了，少东西吗。

你们觉得赋值不是对a o p就是其中一个扩展是这样，依赖关系不对，依赖注入也不对，这里面少了一个非常非常关键的，也是非常非常核心的一个点，哪个点呢，给大家写一下，有人对这东西有影响吗。

有同学知道是啥监听器，在spring里面里面应该见过非常非常多的一些监听起对吧，千金干嘛的，现金干嘛的观察者模式吧，在我创建对象之前，创建对象之后，刷新容器之前，刷新容器之后。

这里面是不是有非常非常多的一些状态都是让你监听的，你监听完成之后，我是不是能触发相应的一些额外的操作，是操作是不是这个意思啊，这里面是不是少占一个环节里面，是不是都应该包含这样的一块车子的一个逻辑啊。

是不是这意思啊，好吧，所以你要想把i o c这块东西搞明白，我希望你们要注意了，最起码这个最基本的图，你要可以get到这个图，如果你理解不了，那后面的东西你别看了，看也白，看明白了吗，来这张图能消化。

同学老师扣波一能像话吗，张老师这个图的大致逻辑我已经理解透了，所谓的大家想一下，根据图我们捋捋捋捋个什么逻辑，第一步我先读取我们的配置文件，是不是要解析配置文件对吧，解析完成之后。

第二步我要有一有一堆并definition，然后呢，我要把这些bean definition的信息反射生成我们具体的一些实例化对象，有了当前这个对象之后，在对象创建之前。

我会有一堆的processor这样的一个处理机制，有了处理机制之后，我可以对我们当前并做一些增强的功能，有了这个增强功能之后，我是不是能完成很多事情了，是不是可以添加非常非常多的一些扩展功能。

来帮助我们做最基本的一个实践，注意这是一个简化版的图，这是一个简化版的图，一会儿我们再来画了一个非常非常完整的图，但是我希望你们先能够把这些简化点图搞明白。

processor很简单啊，你来看一下吧，有没有一堆post post processor，什么呢，abstract advance，ban post processor。

processor gress，什么东西是有一堆的，这些protest看看这不有接口啊，being in post post s版，有一定量的东西啊，但是啊这东西不完整不完整。

你在学spring源码的时候，我再说一点，我再说一点。

你们在看原版的时候，不要一个类一个类去看怎么看，遵循某些接口，spring里面其实就几个核心接口，你把这些核心接口只要都掌握掉了啊，百分之百你是没问题的，版本没问题的嗯。

今天今天我们不会带着你们看整个的源码debug，一步一步走，不会带你看，明天我会带你们debug，带你debug，但是我今天会帮你们梳理整个脉络，因为你只有有了当前整个的脉络，有了这个脉络。

下一步你在看原版的时候才不至于蒙明白我意思吗，为什么同学们一直感觉说老师这个东西我看不懂，我看见猫，就因为你没有一个图，你没有一个整体的一个树状图，能带着你说我一步一步往里面去看。

等你有了整体的一个脉络之后，有脉络之后，你再看的时候，你知道我看到这步是处于什么环节，看到内部处于什么环节，你知道这个环节了，这个时候你再往回找的时候，也会变得相对而相对比较容易一点，明白我意思吧。

来到目前为止，能听懂同学刷波六个老师，能听懂吗，能听懂的话，来我们写一个总结，写些什么总结这个图里面我问一个问题啊，你觉得我们除了可以在这儿加一些processor之外，还可以在哪加，没完没完。

还有一个完整图呢，除了在这儿，这是为了什么，是不提供扩展性，除了这之外，我还可以在哪儿提供扩展性，还在哪儿可以加对应的东西，抽象层解析文件，是不是相当于我在这个环节好像也可以加点扩展性的东西。

是不是这块儿这块加什么东西啊，你想一下这块是说什么，我现在是从我们的插画文件或者说注解里面呃，我直接把信息读完了，读完之后，我现在就要人为了给他进行一个强势的修改，能改吗，能吧。

你在进行修改的时候是这样，也可以提供一些额外的扩展功能，是不是意思是不是以这样的方式也可以往里面进行一个加载，那这个过程是不是就比较少，所以就比较爽了，明白我意思吧。

啊被改的体无完肤。

系列 2：P35：SPRING源码：03Spring的生命周期源码解读 - Java视频学堂 - BV1Hy4y1t7Bo

如果你对sp原码比较熟的话，你可以在sp原码里面sp原码里面为所欲为。开始想怎么班就怎么玩，想怎么搞就怎么搞。懂我意思吧？所以看到这块之后，你应该有一个具体的一个总结了。什么总结呢？

这是我们通过这个图之后，我总结出来的一点东西。想要。成为一个框架。首先。要考虑的。一定是扩展性。这一点我希望所有人能给我记记住了，完全给我记住了，这点很重要。很多同学理解不了。

就就就就在这点有了扩展线之后，扩展线之后，我们这可以思考了spring。提供。往什么扩展性？想一想通上面图，你告诉我spring提供什么样扩展器。好。来写一下吧。第一步。在对象。创建之前。能不能呃添加。

某些。功能。能做吧是吧，第二步，在容器初始化。之前。添加。某些。功能。可以吧啊，第三步，什么东西可以在不同的阶段。然后呢发出不同的事件嘛啊，然后呢完成。一些功能。是不是这意思？好，这有了之后还干嘛？

是不是可以第四步叫抽象出一堆的接口来。帮助。扩展。所以在这一块你需要理解是什么？叫面向接口。编程。把这一点给盖到。啊，这东西很重要。我希望你看完这个图之后，能理解这块的一些含义。列解这块的一些含义。

明白意思吗？啊，这儿现大家能改造。OK第三啥意思？这是我们说的监听器嘛，观察者模式吗？😡，观察这个模式，比如观察这个模式之后，我是不是就能在完成有对象初始化完成之后，我做的做什么事。

完成之前做什么事可以发出一些事件。有了事件之后就完成很多功能了，就这意思。来这地方这几个点能听吗？同学告诉客户一。好了，这问题之后，这个简略图简略图我们就过了，我们就过了啊，过完之后我再画一张。

画一张什么画一张稍微难理解那么一丢丢的一张图，或者说是一个更完善的一张图。我需要干嘛？我需要把对应的一些接口给大家说出来。比如说比如说源码源码在进行设计的时候，或跨下来进行设计的时候。

我到底要遵循什么样的一个东西？是不对到。架构设计过程。就如果你来做的话，你会怎么样来做这样的事情，好吧，或者说你会做什么样的一些扩展，完成什么样的一些基本功能。好吧，我把它改一下。好了。

这些过程在这个过程之前，首先我希望你能够干燥一点。是不是？😊，IOC的核心。核心是啥？这个图会给你们发的，好吧，图给你们发的，别别担心，这图一会都都会给你们发IOC的核心是什么？😡，通过。反射。

然后呢创建。对象嘛，然后呢是不是可以操作？对象是不是这意思？好吧，然后呢，你还需要理解一点是啥？这东西其实我们完全没必要有1个IOC的东西啊。什么意思啊？你要理解容器的一个发展历程，容器的一个发展历程。

最开始的时候最。你想一下你们刚写那边怎么写的？😡，是不是直接扭对象？每次需要什么对象，我直接拗什么对象，是不是你什么对象，扭完之后，我拿过来之后直接用什么时候不用了，然后用GVM垃圾回收完事。😡。

是不是这东西你们之前是这么做的。😡，对吧然后呢慢慢对象创建起来比较麻烦了。人们开始想了，有没有一种更简单的方式，什么简单方式？比如说有个东西叫什么叫工厂模式。是不是工厂模式啊。

我通过工厂模式里面有个东西叫get instance，是不是可以来通过工厂来创建我们具体的一个对象。但这个时候你还是需要工厂类的吧，有工厂类来帮助我们来创建具体对象。是不是这意思？然后慢慢再过渡。

过渡是什么样子？过渡层我们对应的一个容器。啊，在容器里面，特别是词文容器里面做点什么事情？就是我们对应的一个反射。加上。工厂完成具体的一个操作。所以这就是容器整个的它的一个演变过程。

也就是说我们原来你需要用对象的时候，或者你需要自己来使用对象的时候，你怎么做的？刚开始又后来有了工厂，有工厂都不够，有了容器，有了容器之后有什么好处啊，想一想。有了容器之后，你想一下。

在spring里面，你什么时候自己用过对象？验过吗？在sp里面，你自己有过对象吗？😡，啊。😮，拗过好，哪尿过。哪尿过。Got a变。完全不需要吧。说完全不需要同学不对。告诉大家。

有一个地方你可能是需要拗的，但是你们平常写代码的时候可能没这么写过什么东西呢？有一个东西叫。Fttery。b见过吗？在f对B里面是不是有一个方法叫什么？叫get object。😡，在这里面。

我是不是可以自己来拗对象？听白意思了吗？这边是不是可以有，但是一般也特别是一些初级的一些程序员，或者说呃刚接触sp的一些同学这块东西大家几乎没人这么干啊。

所以这块你不用管他你不用管它一般都是什么你配置好了并的信息，把并的信息交给我们当前sp容器，他来帮我们new帮我们复制，帮我完成一系列的一些具体操作。这块我们压根不需要再做任何的一个关心了我。

不要做任何关心了啊，一会儿我来详细讲一下那个factorory bin这样的东西啊，啥是factorory啥是factory，一会我来说一会来说O下面来我们再接着往下画。赔个啥啊，骚一点。OK好了。

下面再往下写写什么东西？我说了，把刚刚画那个简化图，简化图我们来详细画一下。它里面包含了非常非常多的东西，非常非常多的东西。好吧，需要我们深刻去理解一下。还是一样。你想一下，你在拿过S分中心之后。

第一步先干嘛，是不是先把我们的依赖加载过来，加载过之后，第二步，要不然你写注解，要不然你写配置文件，是不是两种方式，对不对？那我们可以怎么办？把这配置文件拿过来。第一种你可以用插牌文件的方式？

这没问题吧。然后呢，第二个你可以用什么用注解的方式。然后非事第3个还可有什么东西？是不是现在你在用springbo的时候，很多同学都在用什么？配置类吧。是东西？假如说后面还会有一些新的东西再写一个加点。

第二点，其他方式可以吧，但不管你用什么样的一个方式，最终我是要把对应的一些病的信息给读取出来的吧。而在读取的时候，我也说过了，怎么做来的？中间这块必须要有一个什么叫抽象层的一个逻辑。抽象层。

这上层其实我说了句好理解成像层。不讲。说啥意思来着，这东西叫什么名字？还记得吗？刚刚已经写过了，叫变，然后呢。带芬你上，然后呢。啥。这叫Bing definitionread吧。可能这个类比较陌生啊。

看你们都没看过这东西啊。

看到了吗？是不是这样一接口，看一这是干嘛的？他说simple interface for being definition readers是吧？

so specific load methods为 resource and strain location parameters干嘛的？是不是用来加载我们对应当前的一些参数了或者一些配置信息。这块。

我到时候看原版的时会带你们看，我带你们看别慌，别慌好吧。但你要知道它有这样的一个类，或者有这样的一个东西，能帮我完成具体的功能，我来标红一下。😊。

这个类是一个非常非常重要的一个接口，如果记住了哎。呃这A呀。对对，这是一个非常非常重要的接口。你记住了，这是第一个接口，这是第一个接口。有这接口之后。

我通过不同的语可以把我们对应的一些配置方式或者是配置信息都给读过来。读过来读完之后，这事儿就了了。这是我们之前那个配置类。🤧嗯。啊，这样的一个方式，但你读过来之后还是一样的，后面给谁来了。

是不是给了一个容器IOC。啊，给到一个容器，在当前容器里面在干嘛？它中间其实是有一层过渡的，什么过渡？我说了，你读过来的信息，说白了就是一堆字符串，对不对？那字符串在我们看来没啥意义没啥意义，好吧。

那既然字符串的话，我需要干嘛？把字符串进行一系列的一些解析工作，解析工作完成之后，最终会转换成什么？是并的一些实体类信息，在这写上并。信息。😊，正么问题吧。到目前为止啊。

跟我们前面看到的东西一模一样一模一样，没有任何的一个区别，就是病的一个信息。有了当前病信息之后，病信息之后，实际上来说该干嘛了，是不是该进行实例化了，是不是该进行实例化了。

但是实例化我们刚刚就直接画出来了，就直接实例化，是实例化，但其实是不对的，其实是不对的，为什么不对？你想一下，你这些病的实例化的时候，是直接来进行实例化的吗？这写一下。实例化的对象是直接进实力化的吗？

不是吧，你告诉我这里面的病是怎么来的？😡，Casloader。别忘了，你要想创建好我们距离项，必须要成为什么？是拗的一个方法，对吧？但我们现在已经不用拗了，不用拗了，不用拗的话怎么办？之前是不是说过了。

你必须要通过反射的方式来创建我们具体的一个对象了。那如果是反射的话，其实也很简单了，我怎么写反射代码。怎么先把上代码？很简单吧，如果你这里可8的话，是不是直接用plus。第二。

什么new instance。是不是完成了？如果你是99以上版本的话，他换了吧，换什么方式，我们写一下。PRUCTOcon等于。什么class点get。Constructor。然后呢。

由当前这个contract的方法，CON点6。Insタス。是这样的方法来完成我们具体的一个功能，这写一下object。OBJ等于它这行代码能不能通过这行代码来反射出，或者说能生成我们具体对象。能吗？

正张代码能看懂同学能看懂同学扣个一。能能看懂？那么好吧，是不是就直接就完成我们具体这样的一些功能了。但是在完成具体这项功能的时候，它有问题，或者说它有毛病。有什么毛病？我说过了。

你不可能不可能直接就new instance了。在new instance之前，我们一定会用到某些具体的一些操作，或者说需要使用某些具体操作。什么操作刚说了吧。

是不有一堆叫什么叫pos叫popocesor东西吧。跟我这样一样的，我也要加一些pocesor东西CAV。拿来。这道。安多一下。摸一下，然后这块呢我们画一条线贯穿下来。这是底。嗯。哇，这样一个方式。

我把这个标上。好吧，一定有这两条线关下来了吧。而这些线最终构成是什么东西，这儿该给具体的接口名称了。听马说的好吧，该给具体的接口名称了，这什么接口？来写一下。叫什么来着？叫Bpost。他在生。

应该有很多人见过这样的一些东西。如果你看过源码的话，一定有很多人见过这样的处理过程。就是这块一个逻辑。这样能看明白吗？这边有接口，都是我们对应的一个bpo post点，这有问题吗？来这儿没问题同学。

李老师扣个一。有没有问题？没吧，这儿没问题之后，来再接着看看什么东西。除了这块之外，除了这块之外，我完成具体这样的一个功能之外，还有什么东西啊？这儿你可以进行对象的一个实例化。但是这些对象的实例化。

你记住了，它属于什么？属于什么东西，属于我们自己定义的那些信息东西吧。所以这样你可以给一个名词叫什么东西，叫普通对象，这叫普通对象可以这么干嘛？我们自己定义信息叫普通对象。但除了这个普通对象之外。

你别忘了这是不是有一堆的binpost processor。这些东西也是具体的子类吧，因为此类事件里面才会有具体的一些逻辑，完成我们对应一些处理方式。是不是这样东西？那你有这个子类之后。

子里面有实现这个子类实现，它是不是也是一个对象？这个对象叫什么？😡，对啊，就这这对象叫叫什么，还能称之为朋对象吗？这是我们自己定义对象吗？😡，不能了吧，叫什么叫spring是啊内部对象OK。可以这样叫。

可以这样讲，这还有东西。叫思瑞。容器对象，我一般喜欢把叫成容器对象。当然这东西啊无处查证。啊，没有人说过这东西没有说这东西。但是你知道它代表的是什么意思就行了啊，没有人叫过这样的名字。

我在任何书上也没有查到这样一个名词解释啊，自己造了一个，你知道什么意思就行了啊，就说在此谓容器里面，它所用到的一些具体的实体类，你可以把它称之为一个东西叫容器对象。转向方向。等下。好吧。

就是这些具体东西，你知道什么意思就行了，我这不带话了，我再不带话了。OK这是这块的一个意思啊，这块的意思。所以你要把对象能做一个具体的区分，能做一个具体区分，好吧，这儿区分完成之后加个勺吧。

再继区分这区完了之后，下一步我们再来聊聊啥。还有什么东西可加的吗？有你是通过这块的并信息并信息，然后呢来实例化我们对象的。而实例化对象的时候，是通过我们反射的方式来进行实例化的这里面你没有感觉断层了吗？

这块上海下海到这块有没有个断层东西，这儿少了一个什么环节，你告诉我。😡，有没有爽环节先说。😡，少了吗？减电器哦，对，不是少减电器。参数好了，羊驼桑说对了，叫工厂不见了。工厂哪去了？

你是不是应该需要一个工厂？😡，你这些实际化是不是都通过工厂方法来进行创建的那其实大家想一下，在工厂方法里面，是不是意味着我就完成了这块对这块代码的一个逻辑了。那所以这块我可以怎么办？套一层。😡，质地。

是啥意思？可以给他起个名字。叫对象工厂。是不是要工厂这意思？这问题吧，有大家对象工厂之后，对象工厂之后，大家想一下对象工厂对应关是啥？嗯。😊，顾老师啥。

是不是就是我们说的最开始的sp容器里面最Q的一个副类啊，是不是最坑的一负类，科负类表示谁呀？很简单啦。然后C看着杯，它表示的是不是另外一个类叫B。February。是不是这接口。

这是不是就是我们那个工程方法？这没问题吧，这没问题吧。好吧，你告诉我对象工厂干一件什么事儿，对象工厂我是不是需要把这些病的信息给读取回来。读取回来之后，通过我反思的方式生成我系列对象。

并且经过一堆的binpost processor来生成，或者说实例化我们具体的这些对象，是不是这意思？那中间是不是相当于我少了具体的一个环节，而少了环节是由谁是由这个bfactor来帮我们完成的。来。

这块能听明白同学给老师扣个一。能听懂吗？所以这时候我们可以怎么办？这儿画一张图，画一箭头。对。哎，这个色不对啊，哪个色来着？按镜头，当你换完镜头之后，我们这儿是不正常指向这儿的，在指向这的时候。

注意了中间砍了一刀。😡，直现给你拦断了。被拦断。拦一下。拦一下之后这干嘛来着？刚刚在第一张图的时候，我就跟你说过这个这个扩展的过程。拿去。我说了，在第一张图是干性规你化的时候。

这块是不是可以进行一个扩展，就要什么进行扩展。这要进行扩展的话，那是回过来回归过来，是就这一块这是会进行扩展了。那这儿我在进行扩展的时候，你告诉我我扩展什么东西。😊，是相当于在我们当前这个工厂前面。

我也可以加一堆的post processor。是不是这意思啊？所以这还怎么画了？可以这样来完成当前这个操作。呃，我想想怎么做。来画一堆东西。好了，这块东西叫什么？😡。

注意了这三个东西这三个东西这三东西它实际上是指向哪的这是并port，这是创建，或者说在实例化具体的并对象之前，我要做的事儿。你告诉我这块用是干嘛的？😡，是不是在工厂方法执行之前。

我要调用的一段处理逻辑了，对不对？所以它也有对应的一个名字，什么名字？能看到吗？preport在这不对。叫啥叫定。有人见过这东西吗？Bingfactory post processoror。见过吧？

这块是不是就当把你把这块东西都给你贯穿起来了。注意啊，这个箭头并没有实际指向这块，好吧。😡，曲线这件头并没有实际指向这。没见过。

有没有点开多少次类实践，你既然说没见过。😡，你没见过这这这些东西吗？😡，一定见过的一定见过的，不可能没见过。啊，一定见过这样东西一定见过这样东西啊，所以这块大家要注意了，这块大家要注意了。

是不是这样抽样出来又是另外的一个接口。现在见过了没？😡，之前不管你见没见过，现在见过了吗？😡，见过了吧。嗯。好。票不要较真好，不要较真儿，我讲的东西一定是有的一定是有的一定是有的啊吧。

所以这块是有这样逻辑的。就说正常情况下，我们理解起来，它应该是直接指向这块的。但实际上中间是通过工厂方法来进行操作的。所以由工厂的时候创业对象的时候会经这样一个环节。那这块你告诉我我能做什么事儿。

你做什么事？啊，正常做什么事？读取。对应的病。的配置。信息是吧，但是发现需要进行。认为。的修改。是不是要进行人为修改啊，或者说我要再添加一些作员信息。此时。😡，可以在此处。完成具体操作。啊。

这块就是这东西啊，这可以把它加讲来，加完之后可以修改我们当前并的一些信息，这是不是就完成对应的功能了？是为了扩展使用吗？那肯定的都是为了扩展使用的，都是为了扩展使用。如果不扩展，这东西贼简单。😡。

这了好吧，为什么生成的死标容积对象指向并post processor。是啥意思？大注意啊，哎，可能我画画画画图的问题啊。

哎。呃，对。Pot。

我确实。你看一下当前这个接口，好吧。我只是写了一个接口的名称，在当前这个接口里面，它有两个方法，好吧，它有两个方法，一个方法叫什么？

下面这个叫post processor before inization，还有一个叫什么？叫post processorces after in，一个是前，一个是后吧，这只是一个前置后置的东西。

而我们现在这个类都叫post processor，这个类的post并不是后置的意思，明白吗？并不是后置的意思，都叫postpro。现在听白了吗？那个skiwalker。听白了吗？这这不是这个接口。

没有一个东西叫prepro，没有这样东西。这个接口里面它是不是提供了两种这样的一个方式来帮你完成这样的东西。😡。

明白我意思吧？这你要注意这你要注意了，好吧，别别别别别弄混了，别弄混了啊，千万别弄混了。O就他这么起名字的，也没招，人家就这么定义了，你能怎么办？😡，🤧好吧，没有没有没有批评啊，没有没有没有没有批评啊。

没有批评的意思。好吧，就大家有疑问就就就就发出来，好吧，就发出来。好了，这是这块的一个整体的一个配置信息。这块看完之后，大家能理解吗？来能力的同学给老师扣个一。能理解吧？啊，应该算是比较简单，对不对？

但是还没完，看一下，现在我出现几个接口了，一个、2个、3个、4个是不是出现四个接口了？有了当前这四个接口之后，下一步我再接着做做什么事情，想一下含收含少啥东西。还少什吗？他他要是啥啥东西。

卖ap mapap就IC容器里面东西吗？不是map。😡，对，监听器永远不要忘了监听器这件事情，这件事情很重要很重要。我把这个挪这来。冇的。到这好吧，到这之后下面我们画一个总体的图。这儿这个箭头不太好啊。

你知道箭头不不指向一次就行了，好吧，我先收一点。😡，藏起来好吧，这样的方式好吧，来这写一句话，什么意思呢？如果想在。不同的阶段。啊，做不同。的事情，那么怎么处理？什么东西？是不是观察者。

模式它在整个容器呃。不去吧。他在整个容器的整个初始化过程中都扮演着一个非常非常重要的一个角色啊，非常重要的角色。这块你一定要知道了一定要知道了，它是位于底下的一个底子，一个底子。有了这个底子之后。

你才能理解说为什么要有这么多疑问。他。这些疑问是干嘛的？他触犯了什么样的一个事件，我应该做什么样的一个处理，这块都要知道了，都要知道了设计模式不熟悉，尴尬设计模式不熟悉的同学，一定要去看设计模式。

你看原码，如果不懂设计模式，看起来会很难受，看起来会很难受。好吧，呃没关系，设计模式东西啊慢慢去补，你平常用不用，我不管，但是你要知道该有设计模式，你要知道，你要知道。好吧，好了，这块没问题了吧。

赵明丽之后来再接着聊，再接着聊。老师讲的这么浅，你都懂。觉得讲讲讲浅是吧？😊，讲起你你就理解一下，好吧，稍微理解一下，毕竟大部分同学的水平是不一样的OK。好了，这块聊完之后，这块聊完之后来再接着聊。

还有啥东西？还有啥？还有一个非常非常重要的一个点。非常非常非常重要的一个点。什么东西呢？在整个环节里面，我们一般创建对象的时候，都是用定factorory来创建对象的。但是你别忘了，在当前这个框架里面。

它还提供了一堆的什么叫factorory。病的东西。有一个factoractory bin的一个接口。这东西我相信在面试的时候问的相对而言也是比较多的。来。

有多少同学问过factorory bin主老师扣个一。有人被问过吗？这块怎么办？这怎么办？第一个问问你说fey病病factory他们有什么样的一个区别？对对是不是有什么样的区别？第二。

你用过f bin做过哪些事情？其实f bin这个接口非常非常简单，它里面一共提供了三个方法，哪三个方法？第一个方法叫get object。这就是为了返回一个object一个对象。好吧，第二个什么呢？

叫is single，判断一下你单应对象到底是否是单立的。s OK啊吧，第三个叫什么叫get tap获取一下我当前的一个类型。啊，就这三个对应的一个方法，别东西没有了，别东西没有了。这块我们可以怎么办？

可以在原码里面进行一个查看，好吧？

Ftter。变。在那找一下get up有吧，get up type吧，它有一 single嘛，是不是一共就三个的方法啊，这东西注意了，它的目的是为了什么？是为了做扩展啊，还是一样，为了做扩展。😡。

做。扩展。做什么扩展啊？我来问一下我来问一下呃，有多少同学，有多少同学在之前学习过程中学过spring cloud。休庭学老扣个一。

spring cloud里面那些组件有哪些组件用到这些factorory bin有吗？有没有？对，finin fame，你可以去看fin里面的。

系列 2：P36：SPRING源码：04Spring Bean的实例化过程 - Java视频学堂 - BV1Hy4y1t7Bo

他在进行突入的时候，就是用这样的方式来往里面进行装对象创建的，就这么干的好，那到底是什么样的意思，来我举个例子你就明白了，我举个例子就明白了，他非常非常好理解，没大家想的那么难，那么难好吧。

来什么例子呢，呃比如说呃大家都知道在中国的那个神话故事里面，呃中就人是谁造的，人是谁造的，女娲到了吧对吧，女娲是不是要捏那个捏人对年轻人之后，然后呢放到炉子里面烤一烤，烤完之后呢，人就出来了。

是整体上来说应该是这样的一个方式，我就说女娲好吧，不聊别的，就是女娲，你要造人的时候，大家想一下，他在刚开始创造人类的时候，它一定有固定的一个模板，是不是一个模板，那个模板有了之后。

那意味着我创建出来的模人，那个人是不是都是一模一样的对吧，但大家想一下，有一天他发现我在创建这个人那个人人的时候，发现所有人都一模一样，这很明显不合适，我们也不合适，那既然不合适，我怎么办。

我想造一些独特的人，或者说有一些特殊的人，比如说个高个胖瘦，对不对，是不是有各种各样不同的一个人，那这时候怎么办，难道说我在创建出来另外一个模板吗，假如说我就需要一个这样的人，明白我意思啊。

我就需要一个这样的人，我也有必要造一个模板吗，没必要了吧，那怎么办，你就可以使用我们当前这个factor be来创建出来我们这对象，而你在创建这个对象的时候，我说了，他每次在进行调用的时候都是什么。

都是调式，get object这个方法在你实现的时候，你实现好之后，通过get object是不是一个是一个方法，既然是方法，意味着里面可以写n多种的一个逻辑，这个逻辑你自己来判断，或者你自己来编写。

你想造什么样子的，你就造什么样子的，你想怎么玩，你就怎么玩儿，但最终我在进行调用get的时候，返回的就是你自己逻辑的一个对象，而不是我通过这个工厂方法创建好的一些标准对象，明白意思吗，这块明白了吗。

不管是ban factory还是factory be，它最终都是为了用来生产对象的，但是并factory它更多是像是一个模板的一个工厂，然后呢我按照模板生产对东西就可以了。

而我们的father bean是可以按照自己的一个需求进行独特的一些控制，你想怎么玩就怎么玩儿，好想定义什么就定义什么，想增加什么扩展性就增加什么扩展性，爱怎么做怎么做，这他们两个之间的一个区别。

看之前一个区别，所以我们在用的时候，如果就可以普通的像你用你的finder being factory，踏踏实实去干，踏踏实去干啊，然后如果你现在需要创造一些独特的东西，跟刚才的工厂没没多大意思。

没多大意思，我就想能创造一个非常独特，跟其他对象都不一样的东西，你可以用fib来进行实现，来进行实现，就这意思就这意思哦，所以不要把他想的特别特别麻烦，不要想特别的麻烦，你把这个案例如果能想明白了。

这事就了了啊，它没有特别麻烦的东西，没特别麻烦的东西啊，所以这块会出现出来另外的一个接口，什么接口叫seer，并对对象好吧，这两个东西面试的时候，再写一下吧，成分，成分理解本质好吧。

知道大概是什么意思就完事了啊，其实两东西啊，这是一个比较独特的接口，而且啊之后在用的时候，其实用的是比较多的，应用比较多的，特别是一些呃框架里，比如说分刚才说了。

比如说f飞的时候就是用这个呃father be来往里面进入的，你下去之后可以来看一下，可以看一下肺的源码，源码里面能看到这些东西，能看这个东西好吧好了，这块理解完之后来再接着往下聊，还少东西吗。

你去看黑的源码好吧，这样能看吗，我看一下。

算了，网速慢啊，诶能打开。

找一下，这样没有什么怎么搜啊，这个，open粉粉瑞克有开源项目，算了不找了，你下周自己找吧，好吧，下一周自己找吧，然后在官网里面你能看到这样的一个实现啊，这能看到这样写，我每天提前没准备这个东西啊。

没准没准备东西，或者明天我们来看一下，这东西是你大概知道什么意思就行了，大家知道什么意思就行了，来回到这张图上，我们再接着聊，还少什么东西吗，还少不少东西了，你下一次你找到好吧，找到的话。

明天我们上课说一下，还少吗，还少东西还少一个，另外非常非常关键的一个接口，什么接口呢，有这样的东西，有人见过这个接口吗，有没有这样东西，有二本的环境，对不对，环境是干嘛的，环境的东西重要吗。

告诉大家非常非常重要，这个接口什么意思，你在进行进行配置的时候，大家想一下你们之前是不是写过哦，你们之前是不是写过一系列的东西，一些配置文件，比如说写过什么配置文件，p p e r t y t e s。

叉叉点包括第四，比如写一些什么呢，叫叉叉点y a m有人写过这配置文件吧，或者说有没有人这样写过，叫system。get property，有没有这个方法吗，有吧，你在进行首先的一个创建的时候。

是不是就能看到，是不是就能看到类似这样的东西，这配置文件都是通过我们当前这样一个环境对象，环境对象环境接口来进行加载的。

在spring里面，spring里面诶。

看错了，在spring里面还有一个默认的一个实现standard，a r子弹的a n d，1v2 看了吗。

还有这样一个子类实现环境里面有什么，有system environment，system property，好吧，下面还有几个这东西，是不是这样两个环境变量它是可以进行这些这样的一些加载。

就是读取我们当前这样的一个呃系统的一个属性值，把实际值可以进行加载，这东西啊用的也很多，特别是你在进行一些变量值替换的时候，用的都很多，运动很多，这块大家要注意了，要处理好，所以你看完这张图之后。

我缩小一下来告诉我，如果现在让你在看spring源码的时候，你会怎么看，看这个图，你告诉你怎看，现在清晰了吗，对sp l对，是这样的，首先这几个123456这六个接口，你先搞明白gm 6接口之后。

改变六接口之后，下一步我是不是要进行我们整个程序的一个实现了，零七不清晰，不嫌弃的话，我一会带你们看源码实现，我们来看一下源码到底是怎么做的，我应该做什么样的一个东西，第一步先干嘛。

是不是先要读取我们这样的一系列的一个配置文件，读完配置文件之后，我一定会有一些并在分析认为的这样的对象，有了对象之后，我是要把这些并信息给拿过来，拿过来之后，我要进行n层的一个实例化。

在实例化的时候会有一些been factory post processor，还会有一些什么呢，叫being post processor这样的对象吗，这东西你们应该都见过，在哪儿见过，这哪见过。

你想一个点。

你们都知道怎么在进行初始化的时候，一定会掉一个什么，找这个类啊，有人见过这类吗，见过吧，在这个类里面有一个什么方法来着，找一下，比如这样的方法吧。

很多人都告诉你说老师reflash是一个非常非常重要的方法，不管你是spring还是spring vc啊，其实这种东西所有东西都是在整块这个流程里面都解决掉了，是不是这种东西你在这块看的时候。

第一步干嘛呢，准备先刷新，然后呢构建我们的in factory，下一步呢准备这个工厂下面呢有东西啊，post processor，being factory。

还有东西叫invoke ban factory，post processor是干嘛的，你是不是能看到我们对应这样的一些对象，post processor ban对吧，然后呢been factory。

post processor，能不能看出具体这样这样这样一些类这个方法，你点进去之后非常非常长，点进去之后非常非常长，很多同学看到这代码之后就慌了懵了，老师你在干嘛，在聊什么事情，我不知道，我看不懂。

我看不懂，所以你把这些东西如果能够拆分开，你知道这个图了。

你知道每个环节里面在做什么事儿了，你还晕吗，这东西我知道你们很多人在私下私底下的时候，一定看过非常非常多的视频源码，你得看过，你看完之后，所有人都会告诉你说，在看了之后。

一定要找到我们当前这个on reflesh方法，因为这这个refresh方法，因为这个refresh方法里面才是我们最最根本的一个核心，在这个核心里面，核心里面你要看一下具体处理的一个步骤。

在bl里面我要做什么样的一些事情，每个方法做哪些功能，完成这样一个逻辑，我应该怎么做处理，看过吧，来有多少同学看过这里面的方法。

给老师扣个一，看完就忘记了为什么忘记了，为什么忘记了。

忘记的原因就在于你看完这东西之后，就是把它看完了，你没有自己能总结出来一个流程图，如果你有一个图，如果你有个图在那画了，告诉你说第一步，第二步，第三步分别做什么事。

这是不是讲了对不对，我大概看一下，我之前在讲spring的时候找一下啊，往上放小一点，这是之前讲spring ioc容器初始化的时候，初始化的时候，下面每一系列的工作一部分怎么跳转的。

做什么样的事情应该怎么做处理，每块我都写上了，都有这东西，你如果直接把这些东西画成图一条线，然后这条线然后这个分支一条路捋下来，你还会蒙吗，你不会再梦了，你不再懵了，明白我意思吧，啊所以还是那句话。

还是那句话，你们在学习东西的时候也好，还是看源码的时候也好，大家其实并不是在呃看源码，更多的东西是什么，是你们在走代码，就是把那个代码来走一遍，走一遍之后这事了了，跟我没关系，跟我没关系。

我看完了好像懂了懂了吗，懂了懂了之后就完了，不对不对啊，所以不要把这东西想的特别特别简单，你不要把它想的特别难，你一记住一定要去总结，一定要去做总结，你好意思吗，好了，选那个图，那个图不给啊。

那个图不是他今天换了，不给啊，今天画两张图，我给那个图不给好吧，一会儿带你们看原码的时候，我再说，ok来到目前为止，还能听班同学给老师扣波六，跑32炮32在线的一个工具，再现一工具。

ok有了这个东西之后，下一步干嘛，看源码吧，是不看源码，看源码怎么看，我们就记住流程，第一步有这些配置文件，第二步读取我们对应的一些类，有了类之后读取配置信息，然后呢进行反射进行生成啊。

做完这些事情之后，我可以完事好吧，下面来我们来带一下具体的一个流程。

怎么带呀，把这些类都干掉，都干掉都不要好。

第一步开始看，首先你要找到我们当前的一个测试类，这有一个my test mett，非常简单，我这是用什么用配置文件这样的一个方式，用配置文件这样一个方式，用配置文件量方式的时候。

第一步叫class pass叉m2 ation contest，是不是这样的吗，所以在第一步这你可以打一半点，一步一步往里边进行挨个的一个1万个挨个的bug，哎你们想听下这个流程吗。

需要带你们看一下这个流程吗，记住在看的时候跟那个图去做对比好吧，去做对比，一步一步对比的，你知道哦，原来是这么回事，原来这么简单，没你想那么难好吧，来走一下，我们走就好吧。

这个代码我也不知道什么时候写的，写了很多，比如讲当时讲那个spring课的时候，带一下这个这个这个这个这个这个流程，这个流程好吧，记住了。

叫class pass travel up in contest，就这样一个东西点上去，第八个，考第一步了吧，注意了，你读了一个配置文件叫j d b c他们的长矛文件，就这个文件不用管它。

然后点f7 调这块之后，这是一个为了防止weblogic 8。1的时候一个bug问题，加这样弄东西没啥意义好吧没啥意义，连续到这儿了吧，是不是掉了一个this表示什么东西哇，再点到this到这了。

到这儿之后，第一步叫super，这个super啥意思，不用下载源码好吧，你用idea的时候，它里面那个包里面带着源码，你直接看就行了，直接看就行了，继承吧，调用父类吧。

这里面我希望再给你们灌输另外一个思想，在四本里面非常重要的东西，什么东西呢，它这里面分着容是有容器，对不对啊，但是容器的时候，容器的时候它有n多个父子关系好吧，就是说他第一个先有一个子容器好吧。

然后有一个副容器，所以你在看的时候比较容易晕，住在哪儿呢，你第一次先在子容器里面找，如果子容器里面找不到的话，再找谁，再找副容器，再找副容器，它是这样的一个一次迭代的过程，听明白意思吧。

所以不要说诶子中线没有就不看了，不要这样，最好你再看一下，既然是在学习，既然在学习，就别怕看的比较多，为啥看原版是五点几的，我们我们讲课讲的都是最新的好吧，给大家看一下5。2。3。

当时讲课的时候用的是5。2。3啊，现在已经到5。2。7了吧，这就是5。2。3啊，不讲四讲四都没意思啊，价格讲最新的加上最新的好吧，当然讲课讲的5。2。3，首先就用旧的东西，ok 5。2。5可以。

这个spring的更新是非常快的，刚给你们给你们看那个官网了，现在最新是到5。22。7了，掉5。6，当时还五点点三呢。

ok，好了来我来点一下试试好吧，第一步super你点击看看没事，点击看看好吧，看看又不浪费钱对吧，这次交流方法里面调完之后创建了一系列对象，这些对象干嘛的，我不知道，我不知道，但是我知道了。

我知道什么东西，它里面准备了一系列的历史对象，包括环境对象，一堆东西先留一边，还是那句话，注意了，你看不懂的东西先不看，听明白了吗，看不懂的东西先不看，先扔一边，别想着一口气把所有东西看明白了。

不现实不现实，第二个叫什么呢，读完之后读到那个分类里面叫abstract obligation contest，诶，这啥意思，所以这时候你在看的时候最好能怎么看，找到我们当前那个class pass。

come on in contest，等到这个类选择它右击，看一下当前这个类的一个类图，它有一系列非常非常复杂的一个继承关系吧，这是我们最下面的，还有一层一层这样的一个继承关系，但不管怎么继承。

最终到上面之后一定是谁，是不是叫being battery，是不是有他对啊，这是我们之前看的那个祖祖祖宗那个负类组的负累，好吧，留下之后下一步再怎么干，告诉我是不是直接进行，我们刚刚那个实际话讲。

这叫get resource path reserver啊，这啥意思啊，获取资源匹配的一个处理器吧，是护理资源匹配的处理器，点了这个方法里面他就用了一个对象。

叫pass matching reserve，past reserve，是不是这样，对象点进去看一下这对象构造方法走，你要有一个计算的板块，往上走走，是返回了就返回对象，这东西没有了。

拿走set pad等于空空，把直接跳过就走了，所以这块里面啥也没做，就做了一个资源的一个路径匹配，别动西没没没有没有啥好，回来之后到这儿了吧，第二步叫set config location，是啥意思。

这啥意思，这个set config location表示说我是不是读过来一个配置文件，但既然我读过来一个配置文件了，那意味着这里面应该是谁，是不是叫，g d b c template的点插板文件了。

是不是你写的配置，你可以点开我们debug，看一下康菲和鲁迅比赛有吗，没有在我们这看一下，等下string是不是叫jdbc tely trl文件，是这东西，就一个配置文件，然后点它。

他将来也告诉了微软不等于空做一些处理好吧，读了之后他接过来是一个数组吧，是不是一个可变那个否定堂的一个参数，对不对，有它之后，然后往里面进行处理处理的。

就说this表confilocation等于resolve pass是啥意思，是不是该处理我们当前这些配置文件啊，还是那句话，你需要把配置文件里面的信息都给读取过来，好都有读取过来。

一步一步一层一层挨个处理，这里一个里面我们是不是只有一个，我是只传了一个，所以这只有一个，只有一个，读过之后找我们的resolve pass，这有个东西叫get引观看看了吗，很重要吧。

刚刚我是不是带你们看了，我们刚刚写那个图里面啥图哪去了，这有没有问问他，是大家看到了，现在现在我什么都没做，刚到第一步解析配置文件的时候，他就需要去创建我们当前这样一个环境接口了吧。

这个创建的时候也很简单，它有个东西叫get，那get的时候你想一下，在之前所有操作里面，我有创建过任何跟环境相关的东西吗，没有吧，是没有没有没关系，没有的话，我就给你创建一个新的吗，有的话。

我是不是拿过来之后，我直接进行一个最基本的使用，是不是这意思啊，来到目前为止，能听白同学有点扣个一，那这样吧，所以我刚刚为什么把这个图里面这东西画到一边了。

它是整个环境，也是整个最基本的东西。

它里面包含了非常多的一些属性值，非常多属性值来点到get，他说这东西等于空吧，如果等于空，那o是不是进到里面去，create的时候是不是要创建一个新的，怎么创建新的呢。

你有一个standard environment，是创建一个新的，主要创建新的叫标准环境，那点进去有过多方法，是不是掉到我们复联里面了，所以这一块你在看的时候往上点，这是不是一个抽象的一个负累。

在抽象负类里面，你找一个东西看这块什么，看这块什么，注意啊，子类里面，子类里面是没有构造方法的，是没有构造方法的，但是但是父类里面，父类里面是有对应的构造方法的，所以这个时候你要发现了。

有时候你找属性值，你找不着跟不上，原因在什么地方，别在什么地方，就在于这些东西你没好好看，你没好好看啊，那一样的，我现在要调这个方法来调这个方法的时候，我一定是先在分类里面找的，对不对。

找一下customer property，属于source，是这个方法，这个方案里面有实现吗，没吧，这如果没实现的话，那意味着一定是在我们具体的子类里面做实现的，所以它在进行调用的时候，进行调用的时候。

这大一定要注意了，暂停调动的时候一定会掉到子类方法里面去吧，来找一下，往下走，看，那是不是找我们这个父类的构造方法一点f7 是哪一类，是跑到子列里面了，跑到子类之后干什么事。

是不是叫property source。at last，你有一个property，把properties，property source，这有两个变量点，它叫system properties。

这第一个第二个叫什么叫c where是把这些环境变量都给读取过来，那后面一样是干嘛的，这是读取一些系统属性，怎么读的，c这么点，get a properties，用过没，我之前是不是问过你们了。

就是用来加载我们当前系统里面的一些属性值这一块儿，所以你都能够进行进行验证的，不用我说get system environment也是一样的吧，释放里面判断一些这些集合值。

然后获取下盖子1v判断一下环境变量，当你把这些对象都设置完成之后没走啊，关键在往那边看了啊，点了点了点了点了点了走，做完之后对象里面是有知道environment也有对象了吧，把对象直接返回去。

返回去之后你往下看，找到我们的this，找到我们的environment，麻烦environment在哪，嗯，没有吗。

诶这儿没有啊，没有没关系啊，我们直接直接计算coc head里面有什么东西，default properties，是不是default apower source，点开看里面这些属性值，好吧。

看这sos资源了吗，里面有多少javs e one time environment，什么东西，是不是一堆的属性值，这块是不是都有了，第二个里面是不是也有点开一些属性值，是不是都读过来了。

这是不是意味着把我们当前系统里面的环境值都给拿过来进行运行，就完事儿了，是不是意思来到目前为止能看明白，同学高考个一，这是不是环境，那这个东西准备好环境之后看这个图，我现在是把环境变量都到了，得到之后。

我下一步在整个环节里面，如果我需要读取我们环节里面一些配置的话，我是不是直接拿过来读就行了，还需要做其他操作吗，不需要了吗，听不懂是吧，听不懂，可能是你第一次听，第一次听这东西啊，你一定要去多看。

一定要去多看，太难了，老师研究词汇这么通用多久，10年，用了10年，我想上厕所，所以我我我我我为什么把你画这个图，刚开始先画这个图，画完图之后，为什么要带你看下图这套东西，原因就在这儿。

就是你要有一个流程图之后，然后呢你才能去看它，才能理解它，如果不听这些东西，你听完之后你就懵了，干完之后就懵了，这些图网上都没有这东西，你马上肯定没有，但是我讲完这次课之后，网上可能就有了。

明白我意思吧，讲完这个课之后可能自由了，但是今天应该是就是到目前为止应该是没有了，但我画完之后肯定就有了，因为这东西怎么说，我们很多原创的东西都被抄出去了，无所谓无所谓好吧，知识共享吧，你们想抄就抄了。

无所谓好吧，来我们现在再往下聊。

再往下聊好吧，再往下聊那个厕所，等一下好吧，我们十点钟才下课，十点钟才下课，这块读完之后，下一步叫什么叫result required pholders是干嘛的，就替换一下我们当中的某些人变的一个值。

就这次property reserver是不是之前我们已经看到过当前这样一个对象了，对象里面就放了一些属性值，有属性值之后开始进行相关的一个处理，然后这有个东西叫create。

please hold help，这个place holder helper，有人见过吗，有没有见过，对非常非常对，就是dollar大括号见过吧对吧，context的冒号。

place holder location，实现一个配置文件是不是进行替换，替，完成之后是完成我们对应功能的拿走，点进去你有了一个当前这样一个对象吧，连进去往这里面看，有它吧。

大括号中括号小括号是不是可以进行相关的一个替换，就这块一个逻辑，所以这块是不是就能整体把它给串起来了，连续这里面会有一堆的东西往下找啊，找一个方法哪去了，放大一点放大一点放大看说了，assert。

assert，assert什么东西是不，place holder reflex，到了大括号，到了大公号，小号干嘛的，是相当于就是用来替换我们当前这样的一个变量值，所以这块会完成整个变量值的一个替换过程。

把你之前写的gdbc了，url username password这些东西都可以做一个替换，替换完成之后就了了就了了，这这块的一个逻辑好吧，然后这找到之后。

下一步叫do resolve prince holder，这个do是啥意思，注意了，上面只是创建了具体的一个对象对象，而实际干活的方法，注意了啊，你在spring里面。

你在spring里面会看到很多do开头的东西，比如说do create be，看到了吧，这才是实际具体干活的方法的，所以do的东西做东西一定是实际上活的，看到do的时候稍微留意一下。

这才是实际进行处理的一些数理逻辑这块啊，不带你们先去看了，下去之后自己来看看，自己来看看，ok好了，这边再说了，你知道这块是干嘛的就行了，好不就行了，所以这块帮我们把环境变量都做一个替换。

并且解析了我们当前这样配置文件，配置文件搞定之后，搞定之后，当然我这没带你们细看，进去之后，你看到有很多插画文件的一个读取是吧，包括d td文件的一个匹配，这都有里面细节，孩子去了。

但是我觉得刚开始啊掌握到这个程度够了，招数都够了，然后这儿有个reflesh默认值就是true true之后进来之后跳到哪儿，是不是跳到我们这个reflesh方法里面填进去到这个方法了吧。

这个方法才是整个spring的一个核心，一步一步我应该做什么操作，这块儿我相信你们很多同学看过n多遍了，但是有同学依然看不明白，来我来问一个问题，每一个问题什么问题啊，呃这块在进行整合的时候。

哪块哪个方法是用来创建单例对象的，你老跟我聊膀胱干啥，上厕所你就去嘛，对不对，拿着手机去好不好，其他问题啊，在这一系列的方法里面有十几个方法，这十几个方法里面哪个方法，哪个方法是用来创建单位对象的。

你知道吗，这号码，知道，这有个东西叫finish bin factory，insuler，是不是他说了嘛叫instance or remain，然后呢。

now lady need singleton是创建所有具体的一些单位对象，是不是有好吧，非懒加载的接单列对象，把这个方案里面都有好吧，我再问一个问题，你们在运行那个spring mvc这个程序的时候。

什么vc所有人都知道我们有问题啊，spring mvc里面它会调用这个reflesh方法吗，听完我的问题啊，听完我的问题，svc里面会调用refresh方法吗，会吧，yes，ok会的话。

它是在哪个方法来进行引入了，你们知道吗，内号码，ctrl是单位的，你说这话干嘛的，注意了，就是在这个finish refresh方法里面去，哪个这个方法它是通过什么方式注入进来的。

是通过一个事件听明白了吗，通过一个事件，通过一个事件来启动调用我们当前这个reflash这个方法的这东西啊，有时间的话，我们可以带大家接着接着往后看，接着往后看啊。

所以大家发现了里面有非常非常多的一些东西啊，没办法干嘛的，之后我会带你们详细看，但是你别忘了我说那个思路，说那个思路什么思路，当我第一次完成最基本淘宝开张图。

刚刚环境有了，没问题吧，第二个配置文件我已经读取过了，读取过程之后，下一步我该进行实例化了，但是在实例化之前，你想一下你少什么工厂，你有吗，工厂电有吗，没有吧，那是不是第一步我应该先有一个对象工程。

有了对象工厂之后，我才能把这些病的信息是不是给进行一个加载，或者进行一个实例化，明白我意思了吗，必须要先有工厂吧。

所以这块你往上看的时候，你会发现这块第一步的时候诶，第一块叫什么叫prepare reflesh，你点进去你发现里面几乎跟没啥也没做一样，第一步干嘛呢，得到一个时间。

第二个呢把close方法做了一些标志位好吧，第三个设置一些环境的一些相关操作，把相关参数设完之后没有了，就创建一些集合吧，创建一些集合这块就没有了，这个方法无所谓，好吧，来看第二个方法叫什么。

叫tfa fresh，然后呢being factory它返回值是什么，是什么，返回值叫confiable liable，being factory。

是不是也是告诉你说我返回了当前的一个bean factory吧，告诉你一个叫get ban factory，所以第二步是不是告诉你说我要先得到当前这样的一个工程。

对不对，是德国工厂，当我有了工厂之后，意味着这里面有了这样，有了之后，下一步该干嘛在干嘛，你告诉我，看这个图下边干嘛，是不是正常情况下i进行实例化了，但是你别忘了你在读取这些并配置信息的时候。

是不是有些东西叫being factory，possible呃，破processor是不是经过这些一堆processor这些相关的一些处理啊。

那有这些处理之后，你往下看往回返啊，第二步叫prepare being factory吧，这块里面啥几乎跟啥也没做一样，就设置了一些往being factory里面设置一些东西，设置啥，你先不管是啥。

先不管好吧，就设置一些东西往回返到这一步叫post processor defy，你点完之后发现里面是空的，空的就太好了吧，空的意味着什么，意味着我们可以进行相关一系列的一个扩展吧。

是不是一系列一个扩展功能啊，用来进行一个扩展好吧，再来看到invoke并factory post processor，啥意思啊，叫bin theory post processor。

这个时候你捋过来之后，你发现了是不是到下面这块了，本来有了对象之后，我在对象创建之前，我要先这要拦截一下，对不对，是先进行这样一个操作逻辑。

所以在刚刚那个方法里面，是不是仅进行了一系列这样复杂一个逻辑，没问题吧，当你把这一卸载就做完之后，做完之后，这是不是有个emove方法，当然这个方法会比较麻烦，会比较麻烦，比较麻烦你我们先不看先不看好。

先不看，我看回家之后，下一步叫register being post processor，是啥意思，注册并post processor吧，刚刚是谁叫bin factory post processor。

下面叫什么叫bin post processor。

你再回到这张图上，这事完了占完了之后在哪儿了吗，说到这儿了，是不是叫bin pos processor，看看是这张图里面画东西吗，是不是一层一层挨个往下进行一个迭代，挨个往下进行一个铝对吧。

留完之后来再往下看，这个方法下面干嘛叫你it message source是干嘛的。

这用来进行国际化相关的一些配置的，国际化相关的一些配置啊，l8 对对对，i8 好吧，那再来看一下什么叫in application event，然后mute custom是啥意思，啥意思啊。

初始化应用程序已问的事件了，是不是该进行我们整个事件的一些控制的东西了，是事件控制的东西。

这块是不是到最下面来了，观察者模式吧对吧，叫广播器或者传播器。

好多波器都行都行，无所谓，再来看一下a reflesh，点进去就是空的吧，既然是空的，又是此类实现，无所谓了，不管他对吧，再往后翻叫regilistener，上面是一个广播器，有广播器之后。

我是不是要往里面注册一下，我们当前已经有一些事件，因为不同事件会触发不同的功能，会有不同的一些扩展，对不对，这块都完成了，下一步叫finish bsary ination。

这个时候是不是该完成我们整个实例化这个功能了，是不是意思，你实例化功能完成之后。

这事不就了了了了之后，下一步叫finish reflesh，是完成我们整个这个reflesh下面的一些方法，明白我意思吧，就相当于说完成我们整个刷新功能，下面就是一些清空的一些操作了，没啥了吧。

听懂意思了吗，所以你看一下刚刚这里面这些复杂逻辑，是不是我给你们画这张图。

为什么你们看这些源代码的时候看的比较晕，看得比较懵，如果有这个图在脑海里面，你按照这个图的逻辑一步一步往里边走，你还晕吗，不用了，这东西不再会成为一个问题，明白吗，来学六位同学给老师刷波六。

所以啊你要知道你缺乏的是什么，其实不是大家不刻苦，不是大家不努力，有时候可能方法更加重要的一点，人家撞一遍，你一定要在看源码的时候自己去捋啊，自己去捋，面对日本国家可以吗，可以啊，但是但最好的是什么。

你能对里面的具体类或者具体细节，具体细节，然后呢再做一下，就是做一些细节这样的东西，这东西还是要看的啊，不是说不看也还是要看的，还是要看的，关键是你要先有这样一个概率图，有了概念图。

然后呢再来看看这块东西，懂我意思吗，所以今天咱们时间不够了，可能同学的膀胱都要炸了，膀胱都要炸了啊，明天我会带着你们去捋细节，去理细节，先讲o p话，不讲o p解码，我问一下a o p在哪实现。

a op在哪实现，谁能告诉我，你need哪，这块吧是been post processor，注意啊，a o p只是其中的一个功能，其中的一个功能啊，就在这块进行一些时间就可以了。

所以你把这里面的逻辑都捋清楚了，a o p也不是个事儿，不叫个事不叫个事，好吧好了，这是我们整个详细的一个处理逻辑，我觉得你花两分钱听这节课不亏吧，这两块钱我觉得花的很值了吧，年代refresh。

对我今天只是带你们把这个大致的流程给大家梳理一下。

明天会带入里面的具体细节，看一下细节里面你应该怎么做一些处理，懂我意思吗，哇树在哪块事物是spring里面一个声明是树，它是以一个切片的方式引入进去的，引入进去的流流程不就是这个图吗。

我画了一节半课的时间。

不就给大家画这个图吗，有了这个图不就不就ok了嘛，对不对，听了两节课，抽20的烟，哈哈哈，所有的扩展功能都是在这个的基础之上来做实现的，听明白了吗，听到了吗，好吧这大家一定要注意了，一定要注意了。

那么老师原码怎么学，其实我跟大家说，我给大家说一下实话说一下实际，我给大家说说一下，说一下实话呃，如果你要看源码的时候，同学们老师我初学者我要不要去看源码，你理论上来说，理论上来说我是不推荐出去的。

看源码看懂了，但是但是啊我在讲那个基础课的时候，我也给大家讲解码，给大家讲解码，为什么这么讲，我可以给大家来看一下这东西啊，就是呃我不看不看课了，省你们说我在卖课不卖课啊，我给大家看一下。

我之前上课写的给大家整理的这些文档好吧，加spring的时候有smart原理讲解好吧，有一些动态动态规划看一下，讲这个原理的时候，我是以面试题的方式来给大家进行讲解的，面试题。

因为这题的方式给大家进行这块的一个基本讲解的，并且这块也带同学们看对应的1v2 ，然后再讲那个spring m v c的时候，也有对应的一些源码东西，给大家写了一些注释，写了一些注解。

这个具体流程都有是吧，包括在讲my best is的时候转换，把bance，这站边啊没写文档，那边这次的时候也会有对应的一些源码的课程，也会对应源码课程这块我都是有讲到的，我来找一下啊。

应该讲的词根分work，看到了吧，spring源码讲解a o b的详细事物的一些讲解啊，这都有动态代理的源码我都讲了，包括像spring vc这块源码都讲了，然后包括像my bed编码也讲了。

好源码几乎都是给大家进行了一个基本的讲解，基本讲解，包括其实在讲spring boot的时候，bot的时候我也讲源码了，给大家看一下spring boat源码源码源码源码为什么要讲源码。

很多老师你没必要讲源码基础课，我就学习应用，能讲源码干嘛，你最开始最开始就算你没听懂，但最起码听个响儿，什么叫听个响儿，随便听个响声告诉我，你先留个印象之后，如果你看的时候，它不是一个新鲜事物，明白吗。

不是一个新鲜事物，如果你每次听到一个东西的时候，都是一个新鲜事物，这你学起来成就一定是非常非常慢的，所以为什么要给大家讲这块东西，原因就在这儿，我希望能够给你们看到这些东西。

你们也要需要自己下去之后可以好好聊一下，好好看看这个这些细节，你记住啊，记住的东西是死的，你只要肯花时间，肯花精力，这东西没有说学不会了，你只要不傻，没有学不会没有学不会听懂我意思吗，好吧。

所以这样大家要注意了，一定要注意了，k9 负的话，以前我对我以前有九负，2013年的时候，114年14年的时候好吧，还一样别人花一周一周时间搞定的东西，我花三周，别人花一个月搞定，是我花三个月总可以吧。

能搞清楚最怕是什么懒，最怕是什么，是害怕很多东西一看原版就懵了。

我是不干了，干不了这东西不是人看的，我看不了这东西没招，所以我希望在两篇课里面可以带你们梳理一下大致流程，具体的细节下去之后可以详细再看一下，ok课在哪里买，今天的资料今天的资料哇，可以呃。

一会儿那个图我会给大家发出去，发出去，我可以给你实验的，早一点比较好，那个时间是改不了的，时间是改不了的，老师我专科1年工作经验，希望他最后能拿20k吗，不敢保证，但是我能保证是什么。

是你的技术是没问题的，但是有没有这个机会看你自己了，看你自己了，这边的内容绝对是最深的，没有之一，没有之一，61，但能不能拿20，能拿20，看你自己的运气和你的表达，有些同学啥都会就说不出来，难受。

我这不难受，ok公司cpu缺你了，不要嘲讽好吧，老马应该和你讲spring，我在基础班一讲，spring不是没讲老师那一句话，说一下spring spring boss的区别吗。

spring boot它比较就用起来比较简单，你需要写出非常多的一些配置，现在自定义了一些starter，你也可以自定义starter，然后启动的时候容器这些东西都帮你自动，将来完成了。

不需要任何依赖外部的一些服务，直接进行配置就行了就可以了啊，这这这这这个很这个很简单啊，它不是微spring boot，不是微服务，它只能算是一个脚手架，只能算是一只脚手架，好吧，所以我的封装很深。

就是少了点什对，就这样的老师可以说一下怎么给面试官吹牛逼吗，吹牛逼是依托于你的技术实力的，一定是你的技术实力的，如果你的技术实力不够，你吹的牛最终都会破掉了，没有我意思吧好吧。

所以啊所以啊还是有了技术的底子，再加上点数牛逼就ok了就ok了好吧，试用期你过不去哈哈老师来波话术，什么叫话术，咱俩会教面试吗，老师会的会的会的，我可以给大家给大家看一下，老师阿里p几没见过阿里。

不好意思，比较惭愧啊，惭愧，怎么阿里就一定是大牛吗，不信阿里一定不行吗，我怎么这么不服呢，词根考不会讲吗，咱们今天可能讲不到，今天可能讲不到，但是呃课程里面是有这个词汇考拉东西的，随便可以多讲面试题吗。

你把源码看了，你还会在乎面试题的东西吗，我怎么理解不了这件事情呢，好吧嗯，我可以给大家看点东西，看下什么，有学生学生很多学生会问我们简历指导就是专门的面试课，马老师也讲过。

大家之前不知道有没有同学听过这这个马上也讲过，我们会学生入学之后也会有一些面试简历的更改，这方面的一些服务都有都有好吧，现在在马士兵教育好吧，我很骄傲。

ok面向面试编程op为什么不是在being factory post processor实现的，你先理解清楚什么叫a op再来问这个问题，他在哪个层面，你觉得适合比较好，在供应上前面就实现吗。

它是嵌套在具体对象的具体的方法里面去的，你在工厂前面做有什么用，有什么用好吧，之前有同学，老杨是之前的学生吗，心若止水，你之前认识我吗，好了好了，不聊了不聊了好吧，今天咱们就上这么多。

然后嗯明天明天我们再接着带大家做里面的一些深入的一个学习，深入学习还要明天八点准时开始，准时开始好了，今天咱们就聊这么多行。

系列 2：P37：SPRING源码：05Spring的循环依赖问题？ - Java视频学堂 - BV1Hy4y1t7Bo

我们下面来开始讲解今天的一个课程，在今天的课程刚刚我也说过了，大家在进行讲解课程的时候，需要先看一个东西什么呢，昨天上课的时候呢，给大家画了这样一张图，我说了很多同学，很多同学在看源码的时候看不太懂。

或者说理解的不是特特别透彻，原因就在于什么，你们看源码就是从第一行代码一直往下看，一直往下看，看到了某个环节不懂了，然后呢跳过去，然后呢下一遍，等第二天再看的时候再从头看，你一遍一遍从头看。

一点意义都没有，还是那句话，你先开始的是最基本的使用，等你把使用掌握好了之后，下一步就开始与对应的一个脉络，当然这个脉络一定是干嘛，你在干嘛，当你对原版有一定熟悉之后，才能看到整体这样一个脉络。

但我这提前给你们分享出来了，因为分享出来了，所以一会儿我们在讲源码课程的时候，就按照这样的一个方式来进行下面的讲解，来回顾下这张图吧，这图里面画点啥呀。

其实这张图里面主要的就是给大家抽象出来一些对应的接口吧，是不是拥有六个接口，这儿展示出来的，昨天我们也看了一部分的一个源码，对不对，也看了一部分，但是你看完整，今天我会带着你们把下面的东西都看完都看完。

但是你需要了解几个最基本的环节，一起来回顾一下什么呢，第一件事我要想引入我们对应并对象，你可以写配置文件，可以写我们的annotation，就是我们的注解，也可以引入一些配置类，但是不管怎么样。

我最终是需要把这些病的配置信息，是不是读取到我们当前ioc容器里面来，当你在进行读取的时候，也不是说我随随便便就读了，而是说中间有一层抽象，这个抽象叫什么。

叫being definition rigor，有这样一个对象，这对象人都见过吧，昨天我也带你们看过当前这样一个泪了好吧，由他之后，我能把这里面配置这些信息都读成我们的b信息，有了这些信息之后。

比如说有什么属性对吧，有什么属性，这些属性值我应该怎么来进行一个呃读取，或者放了一个对象，当我有了这些信息之后，下一步在干嘛，是不是该进行实例化了，进行实例化，但是注意了。

在spring进行实例化的时候，实例化的时候上面会有一个工厂吧，是不是对象工厂是通过工厂的方式，然后呢来实例化我们当前这个类的，但是在实例化之前，实际化之前我会添加一些额外的功能，比如说你读完信息了。

我要做一些修改，或者我要添加一些额外的配置或者统一的配置，这个时候你可以有一些东西，什么叫并factory post processor，是不是这样一个类的，或者这样一个接口，有了这个接口之后。

意味着我可以在里面完善部分的功能，然后往里面加入一些对应的信息啊，加完成之后，工厂方法拿到了，拿到工厂之后开始创建我们对应的一个实体类，在创建实体类的过程之中，我又可以引入另外的一些对象，叫什么呢。

叫be post processor，大家看到这两个名字比较相近，一个叫been postprocessor，一个叫been factory postprocessor，两个是不一样的。

一个是在并实例化的过程中进行引用的，另外一个是在工厂的时候经营用的两个不一样，一定要把它分清楚了，分清楚了，然后当我把这些实例化对象都实例化完成之后，ok我可以把这些类拿过来之后，直接使用了。

保持整体这样一个环节，一会儿我们在利用源码的时候，也是整体上大致这样一个思路好吧，然后在整个环节里面大家需要注意的，还有一件事什么来着，我说了，如果想在容器的不同阶段做不同的事情，那么怎么处理。

是不是有东西叫观察者模式啊，是不是观察者模式，这是嵌套在整个ioc容器这个各个环节里面的各个环节里面的，然后这完了之后，还有什么对象叫明不让他，它是我们整体的环境，然后呢我再读取一些配置文件对吧。

或者说生成一些或者一些系统变量的时候，可以通过当前对象来进行引用，你只需要把这些关键的接口搞明白了，这东西没大家想的那么难啊，没大家想的那么难，来，这个图能看懂，同学老师扣波一能看懂吗。

那你来如果看不懂，如果看不懂，可能需要把我昨天的课再好好听一下，但是大致这个思路应该是有的，应该是有的，因为有了这个思路之后，你再去跟我们对应源码的时候，你听起来是比较舒服的，如果你一点都没看过。

或者free一点都没接触过，那不好意思，这东西可能听不懂，听不懂不懂，我意思吧好吧，那这东西咱们不再浪费时间，下一步我们来打开源码。

直接来进行跟踪，看一下源码里面它到底是怎样的一个处理过程和处理环节，这东西啊比较简单，我在这儿打了一个debug好，打了一个debug，一个断点，然后有断点之后，我可以进行随便一个读取，但看代码不一样。

这无所谓啊，这无所谓好吧，我们右击，然后呢直接开始第八个驴肉进去之后一定会停到这块吧，是不一定会听到这块，当你停过来之后，第一步先点f7 ，能听到我们的方法里面这一个添加代码块，我说了。

这是歪不到这个8。1的时候有个小bug，一个小bug，这块你不管它啊，你不管它，然后往下走，进来之后再点f7 交往里面去，这会将我们当前对象的一个过高方法传了一系列的参数。

其实这些参数最根本的点就在于我要传入对应一个配置文件，明白吗，叫什么obligation contest，这长发文件，然后呢再点击进到我们这里面，第一个叫super pad干嘛来着。

是不是它当前这个类里面它有一个非常非常复杂的一个类图，对不对，这类图你看起来可能会稍微那么难受一点，因为它的竞争关系非常非常复杂，但是你先瞅一眼，你先瞅一眼，就算理解不了，看不懂没关系。

我看到了我的天哪，太多了，有非常非常多一些的继承关系啊，切成一边好吧，我们最终在调用的时候，刚开始是最后一层，然后一层一层往上挨个进行一个迭代，所以你在调用这个super的时候，就一层迭代。

在这里面会遇到一个什么叫property resource，resource的一个解析配置类，是不是解析配置类那一类也无所谓啊，一会儿用的时候我们再说，所以这样代码你如果不想看的话，可以不看没关系。

但是我希望你能理解一点什么呢，在spring里面好吧，有一个父子容器的一个概念，刚开始你在创建的时候会先在子容器里面找，找不到的话，会去副容器里面找，那映射到我们代码里面的话，就是什么意思。

先在子类里面找，子类找不到的话，我再去我们的父类里面找，所以一会儿我们看具体的实现类的时候，实现类的时候就会有这样的一些问题，就是你要去复制里面进行一个查找，明白我意思吗，啊这块儿大家等一下呃。

老师关一下微信提示音啊，稍等一下，就是我电脑里面登录的这个东西啊，我把你下了好吧，现在接着聊，这是第一行叫super，然后呢下面看第二行叫set confer location吧，第二步啥意思。

第二不用说了吧，叫set嘛，肯定是设置我们的配置文件好吧，这样在进行传入的时候，它应该传的是一个数组吧，这船是一个数组，但我们这儿因为只有一个配置文件，所以可以直接进行一个读取，读完之后再说了。

开始进行整体的一个解析吧，来往下走一下吧，走走走到这块儿取回来之后，就是我们当前这个配置文件叫obligation contest的插画文件，你看看见了，看不了了，等下放上去。

这有一个string是有一个string的一个数组，它的名字就叫avation，插播文件还看不了，看了不看，这有吗，看这是application contest传播文件啊，就这样一个文件，别的东西没啥。

然后调完了之后，下面在循环里面，我要循环当前数组了，这里面有一个方法叫什么啊，叫resolve pass了，这里面我也说过了，其实它并没有特别难啊，拿走趁你们看不要看走，你直接跳过去了。

那重新启动下就直接跳过去了，唉真麻烦，研究点进他进不来是吧，进不来，我们这点啊，这里边有什么东西，有get in冠是吧，是不是过去我们当前这样一个环境，这个环境我昨天已经强调过了，这干嘛来的。

这个环境其实非常简单，它会判断一下你到底是否创建了一个环境对象，如果没有的话，我帮你用一个新的，而new的c类都叫什么叫stander的，还记得一类吗，来看一下standard的a n d a r d。

然后呢ve e n vi 2是不是这样的对象好吧，那就有了对象对象之后，这是绝绝子类，它继承了我们上面一系列的一个父类，进行一系列的负累，这你不管它好，你可以点到当前方法里面来，它是能够直接进去的。

好直接进去了，这些之后先获取我们当前这样一个对象，他说了吧，第一个叫create environ，在create environment的时候是表示说我要创建一个对象，点进去。

他说你有一个三个等于五二的，这个看起来啊，这个过程都比较简单，但是我这要强调的是什么，强调是什么东西，在创建当前对象的时候，你如果直接一看到这个类就不管了，这是不对的，这是不对的，你应该做什么事。

做什么事，点一下当前方法，你发现了当前这个类里面它并没有一个保护法，他如果没有的话，你要看谁，别忘了看负累了吧，父类里面它是有一个对应的构造方法的，在构造方法里面它调了一个叫customer什么的。

property resource的一个方法，这个方法父类里面依然没有对应的一个实现，所以最终还是要跳转到子类里面来进行相关的一个处理，所以职业里边是不是这样一个方法了，加是什么呀，大家看一下。

第一个叫system properties，第二个叫system environment，也就是说我把我当前环境里的信息都给录取过来，方便我在后续整个ioc容器里面进行整体的一个使用，进行一个使用。

就这块东西，所以这块东西你看不懂，不管它，你就知道我创建了一个环境对象之后，我如果需要获取一些反应配置信息的时候，我可以直接拿了，这点能不能看懂，来到目前为止能听懂，同学老师扣过一能听懂吗。

那么你也没问题好吧，这是最基本的一个步骤，然后接下来我们往下走，走完之后，第二步叫resolve required place holder，这干嘛来着，我也说过了，我们在写spring配置文件的时候。

经常会写这样一些东西，比如说dollar大括号，大括号，到了大括号大括号这东西特别是在连接我们数据库的时候，比如说u22 等于什么东西，you are name等于什么东西。

password等于什么东西，是不是经常要进行一些替替换了，而这里面完成的功能就是把这些对应的变量值替换成，我们实际在配置文件里面写的，这些值是在这个方法里面完成的，把这些方法里面完成的。

ok所以下来之后你可以自己来看一下这东西，我们说了那个宋浩翔，如果你不想听课，可以走人好吧，没必要在这儿攻击别人，好吧，大家好听啊，大好听好，环境配置现在都有些信息啊，来看一下吧，这很简单吧。

z让我们this那找到我们的environment有吗，还没有是吧，因为我们从这看吧，直接从这看右击，然后计算这里边有一些properties，我多大一点，往下走，往下走，看到东西了吗。

比如说java wrong time name等于什么东西，然后呢some bot library pass等于什么东西，然后呢java vm的什么东西是不是有一堆这样的信息，是不是都有好。

除此之外还有什么第二个里面也会加载一些相关的一些信息，这都会帮我们给加载过来啊，这这块东西啊，这东西啊，昨天我已经演示过了，所以我们演示过了，所以这块没啥，这块没啥好吧，今天离得麦近了。

我离远点儿卖的问题吗，没东西吃了，昨天一模一样好吧，所以这块你搞完之后不管它了，我就知道什么，我这儿只是为了解析一下我们对应的一个配置文件，把配置文件都能够读取过来，读取过来，这是第二步到第二步之后。

第三步有个reflex，这个reflex啊非常简单，默认值就是true的，所以总能够进到这个reflect方法里面，你们之前很多同学看源码的时候，都得到一个最基本的说法。

说在three里面这个reflash方法是非常非常重要。

这些步骤这些步骤这些步骤提供了非常非常多的逻辑。

我说了，你如果直接上去看这些方法，看一会就懵了好吧，千万别蒙，千万别蒙，怎么看，按我刚刚打开的这张图里面的东西来留来留意是吧。

第一件事先干嘛来聊，说的是不是要读取我们当前这些配置信息，刚刚我是不是已经读取到了相关的一些配置了，是不是都遇到了，当然具体的那个插画文件的解析过程啊，我们在没没带你们看，你下去之后。

你们自己可以点一下，那个非常复杂，非常麻烦，我们先不看它了啊，当我完成这个操作之后，意味着我已经把一些病的信息给读过来了，读完之后你告诉我按照我们这个图里面画的第二步该该该干嘛了，正常情况下。

我能想到的应该是要进行实例化了，但是你注意了，在实例化之前要做什么来着，是不是先要创建出来一个对象，工厂是先有一个工厂类，当我有了工厂类之后，在工厂类处理之前，我说了可以提供很好的扩展性。

可以添加很多人为的一些补充的功能以及逻辑吧，就这些叫b factory post processor，所以这时候你再来验证的时候，验证时候能看到什么信息啊，来往这看。

打开我们刚刚那个哦源码第一步叫paper reflesh，这就是做一些最基本的准备工作，一会儿我们来看一下，第二步叫obtain reflesh，being factory，它返回的是什么。

是不是一个psy，所以这一步里面就是为了创建或者说获取到一个病的一个工厂，变成工厂，有了工厂之后，还有呢往当前工厂里面设置一堆的组件，或者设置一堆类，这个prepare设置的一个意义是，当你做完它之后。

下一步知道什么叫post processor being bor，这个名字有点熟悉啊，什么叫post processor being bor，我刚刚说过了吧，在不管实例化病之前也好。

还是你的工厂类之前也好，它都会有一些post processor的一些类，这些类是用来提供一些增强功能的，增强功能的，懂我意思吧，所以这样我们点击这里发现是空的，上面都实现这么多时间。

意味着就为此类扩展了相当一边，再往下看，叫ebok并factory post processor是干嘛的。

回到这张图上，你看一眼这是不是东西叫being factory post processor，我说了，实例化好工厂，这个累了，有了当前类之后，下一步是不是该执行这块的逻辑，当你有了这块的逻辑之后。

下一步在干嘛。

是不是该执行这些b post processor了，所以你看原版的时候，你能够进行一个发现什么呢，这是being factory post poser。

下一步就是叫register being post processor，两个类一样吗，两个名字不一样吧。

是不是上面比下面多了一个factory，那你通过这张图上，你是不是看到了，这是优先执行的，这是不是第二次执行的，是不是这样一个步骤，明白我意思吗，啊这大家注意了啊，所以我这画这样一个图。

你按照这个图的逻辑去进行一个呃思考和专题一个整理，当我把这些东西也执行完了，下一步该干嘛了，是不是该进行对象实例化的，但是你需要注意了啊。

在实例化对象之前，实例化对象之前做什么事，这儿有个东西叫in need message house，是干嘛来的，是干嘛来的，这很简单啊，这东西啊就是为了进行一些国际化的配置，比如说i18 。

它里面的信息就可以到这里面去了，进行一些初始化好吧，再往下看，还有个叫bmit application music caster是干嘛的，是不是叫啥多波器吧，或者叫广播器，对不对。

就是我们之前有事件的时候，它是需要进行广播的，这也进行了一些处处化的工作，当这儿也处处还原人生之后也有讲on reflesh，这个on reflash点进去看下，有空了吧，是不是也是留给子类进行实现的。

我们可以进行一些额外扩展，这再完了之后，大家看到reflesh listener刚刚有录波器了，我要把我们对应的一些监听器给注册进去啊，给注册进去这块的一个功能，再往下看到这一步。

刚刚从图上我们已经判断到了碰到什么东西。

每次在进行之前执行完这个步骤之后。

按道理说我要进行实例化，但是它有很多额外的小组件是帮你完成这个功能啊，所以这会有这样一个过程，这过程不重要好吧，再来看最后一个什么呢，叫finish bin factory in relation。

干嘛呢，这儿就是用来实例化，记住啊，实例化某些单利的，注意叫非懒加载的单例对象，所以这会涉及到具体的实例化过程，当你实质化完成之后，它一个finish reflash是分析日fh，就是说我已经创建好了。

完成刷新之前我要做哪些事情，最后面会有一些清楚的工作。

刚刚刚刚我把这些东西聊完之后，你想一下是不是我这画这张图。

当然这张图比较简单，它不是一个完整的图，但是关键的脉络你能不能听明白，来能听明白，同学扣个一能听懂吗，没问题吧，有了这个脉络之后，下面我们开始深入细节，看一下细节里面我应该怎么学习。

或者说我应该怎么看，很简单好吧，一层一层一步一步挨个来，第一步先点进去叫prepare reflash，这边做的事情很简单，第一步是获取一下我们当前的一个时间。

第二步设置一下我们这个close和active它们的一个标志，因为你现在刚开始运行，所以close肯定是boss的，而一定是处的，这做完之后，这有个log的一个判断。

不管它再来看叫delete property source吧，慢走是干嘛的，它也非常简单，连续有东西吗，说for subclass，是不是让我们进行一些扩展了，这扩展完成之后，不管别东西了，再往下看。

叫get environment，又看到它了吧，这个逻辑你们还记得吗，什么逻辑，我要获取当前环境的一个接口，如果有那个对象叫standard的invent，如果有的话，我拿过来直接用，如果没有的话。

我创建一个新的，那我现在有没有有吧，是不是已经有了，有的话我直接拿过来之后就可以了，点进去你可以看一下，点进去啊，很麻烦，刚才你没点就没点进去啊，不管它了啊，你可以看一下这块，大家这是一个get到1万。

问他先看看对象是否为空，如果等于空创建一个新的，如果不等于空，是不是接返回这个东西，我们之前已经看过这个逻辑了，这不再看了，再看好吧。

然后第二步有什么方法叫one day required property source，这只是对我们的属性做了一个最基本的一个验证啊，最最基本的一个验证，这块其实也没啥。

你可以看一下它对应的此类接口的一个实现啊，实现有这样一堆的一个实现，这块看不看影响不大啊，看完影响不大，只是一个验证，验证通过能怎么样，对不对，所以不管它这样做完之后先不管它。

我想看下面这块这东西很重要，这几行代码很重要，虽然看起来没什么用，但是很重要，为什么说重要，是说了叫stop pre reflesh，application listener这个注释啊。

千万不要忽略他写这书是不是白写的，这干嘛呢，叫存储什么reflash，之前的一些类似的话，是要存储一些监听器，这个时候这个值肯定是等于空的，因为我刚开始来进行一个判断嘛，所以这时候可以等于空的走下来啊。

到这儿这是不是等于空等于空，我要创建一个set集合，set的一个集合啊，这是第一步，这样做完之后，做完之后，第二个叫this在early addiction。

疑问等于你有一个link的high set up，是不是又创建了当前一个集合对象，当然现在集合对象里面只是我创建了一个空的集合，没做任何引用，在刚刚那个reflash方法的外面。

是不是有个东西叫什么叫register listener，是不是这样的方法对吧，这东西一会儿用的时候会配合使用，你知道这只是创建了一个空的集合就够了，别的东西先不管好，先不管，你先留个印象。

一会儿用到的时候，我们再说好吧，再往下走，这步是不是就要完成了，所以我说了这步你其实不看也无所谓，他好像没有做什么核心的功能，就记住我创建一个空的集合，这能听懂的同学给老师扣个一，这第一步能听懂吗。

设置了一些时间，对不对，这是第一步设置时间，第二步设置了一些标志位，第三步我创建一些空的一些集合对象，仅此而已吧，所以之前之前我在讲我们的a p课程的时候。

我还画过这样一个图，这图看起来就比较复杂了，好吧，你再看一下，这是我们整个ioc容器，它在进行初始化的时候，我要做的一些事情啊，这个东西叫set configuration，然后读取读取相关的一些信息。

idation，看这个叫prepare reflash吧，是不是这个方法这方面做什么事，第一说完成一些基础准备工作，比如设置时间设置，启动关闭标志，检查环境变量，并提供组织扩展好。

用来将属性注入到context中，并设置监事件，监听器集合，是不是就住了这么几块啊，去做这件事情。

所以都是一行代码，一行代码的东西好形成一边好先生一边这做完之后，第二这个方法很重要，把这话很重要，这方干嘛的，叫obtain fresh，然后呢being fbruary这个名字如果看不懂的话。

你应该知道它返回的是一个bean factory对象吧，我之前也说过了，你在看的时候要先看到我们这个ban factory的一个接口吧，这结构里面是不是提供了非常非常多的一些东西，上面有一堆的注释吧。

有一堆的注释啊，有一堆的注释呃，烟是什么意思啊，少两行是因为你的版本不一样，版本不一样，我用的是5。2。3，5。2。3，5。2。3好吧，这里面有一个注释下去，有时间的同学，我希望你能把这些注释都好好过。

六呃溜一遍，这注释提供了非常重要重要的作用，比如说他告诉你，他说这东西是一个root接口跟接口吧，是用来干嘛，用来访问一个spring的容器，所以它就是我们规定好的最基本的一个容器。

然后告诉你说它有两个对应的子接口引导，visible be federate，it configurable being fate，有两个对应的一个子接口，然后呢在此接口里面有一系列的子类实现。

那就告诉你说这里面有single吧，是不是我们的单位的一个对象，还有什么，是不是还有我们的property，然后还有一个quest session，是有一堆的一些作用域。

好再来看下面也是一堆的一些解释哦，还是建议你们下去之后有时间就看，没时间就算了，没时间就算了，还有一个同学之前经常问一个问题，他说老师我面试的时候经常被问一个点。

系列 2：P38：SPRING源码：06Spring的BeanFactory和FactoryBean的区别？ - Java视频学堂 - BV1Hy4y1t7Bo

生命周期吗，有没有同学被问到这个问题，被问到我同学来扣个六，有人被问到过吗，有没有你们怎么回答的，我相信大部分同学在回答这个问题的时候，都是提前准备好了一个面试的文档，然后呢我背了一下，面试官一问。

我啪一说，完事了，是这样做的，但其实你注意了，他这儿有一个非常非常非常简单而且直观的一个方式，什么意思，他会告诉你整个病是怎么做的，往下面看，他说了，being factory，实现类干嘛呢。

应该支持什么呢，叫标准的病的一个生命周期的接口吧，或者说尽可能的去支持一个标准的并生命周期好吧，他说这个完整的初始化的一个结合好吧，再让它们的顺序是下面那块东西有什么呢，内幕宾name aware。

being class，loader，aware，aware，aware，aware aware是啥，是不是设置了一些偶尔的接口，这些偶尔的接口最终目的是干啥呢，是为了设置我们对应的一些属性。

方便我在后续进行使用的时候，注意后期使用的时候，直接从我们的容器或对象里面获取到相关的一些属性值啊，或者相关的一些属性值，所以里面这是写好了。

当你把这些av的接口你都看完之后，不管它不管他到哪儿。

这儿完了吧，这有什么东西，我再往下走啊，哪去了，说post processor before midation method of being，post processor。

是不是告诉你说being的时候，你应该先执行什么东西，先执行什么方法，这个目的提示有提示之后，第二步叫什么零收来，b是不是执行这个初始化的一个病。

然后说有一些customer in need a method definition，你可以自己定义当前病的一些初始化的方法吧，这东西你们应该见过，对不对，哪儿见过，打开我们当前所里面的一个配置文件。

你这样写的时候，这样能不能写这样的东西，init method，还有什么东西，是不是有东西，descri method是这样的方法，这块你是不是都可以进行自己的一个实现，在这块说了叫a cut吗。

叫定制的，对不对，好吧，那定制就这样一个意思，就这样意思诶，哪去了，是不是有执行这样的一个方法，这这这块吧，直接完成之后又告诉你了。

我要执行being post processor里面的post processor after什么东西，这是before吧，这是after，是不是一个前置，一个后置，是不是这样的，写，再翻翻书了。

on shdown of being factory，好吧，说the follow the circle max，我看如果你要进行关闭的时候，还要执行下面这样一个顺序，干嘛呢。

叫post processor before，好dirt什么，然后他说deposable being a table destromeo。

大家看一下这个过程是不是就是我们完整的一个b的生命周期。

听懂我意思了吗，看到没有有吗，有吧，你还需要去背那些文档吗，有位表文档，这里面是不是给你写好了，没有地方比这个东西更精准了吧，这是原文里面写好的文档，写好注释，没有的地方只要更精准了吧，是不是意思。

所以你要知道在哪儿找这些东西，去哪做整理，你把这东西都说清楚了，我觉得你面试的时候那个问题可能不过吗，懂我意思吧，来听麦同学666走起，能听懂吧，这很重要啊，这很重要啊，所以为什么你们看源码。

源码里面透露出来很多关键的一个信息，关键信息哈切是什么意思，这个更难背，唉好吧，你别老想着被打好吧，没意义了，ok来这块拿完之后，我们回到我们当前的动画里面去好吧，我们开始往下接着走，接着往下走。

接着往下走啊，所以启动的周期是什么。

哎呀之前我说过了，我给大家整理过这样的一份东西，嗯哪去了，spring。

这块如果你觉得你不熟悉的话，试图找到，并在生命周期一步两步三步，每个步骤这样写好了，有需要的同学下周可以看一下，这东西，就是按照刚刚官网里面的东西来进行一些操作的好，今天步骤进行整理了。

就这块东西啊，背面特别难啊，别别特别难，ok讲这个讲不出来好吧，你要觉得讲不出来，你就算了，ok那你觉得还死记硬背还ebay，但是我要说的是什么，官网里面有没有这样的一个过程，有吧。

官网里面给你里面那个源码里面给你详细解释出来了，好吧行了，下一步来再点进去看一下当前这个工厂里面做了一件什么事情，第一步叫reflesh being battery，是干嘛的，这个文档去发吧。

一会再一会再说发发的事好吧，一会再说发发式啊，那现在方法的reflesh being f，这干嘛的，刷新工厂了，什么叫刷新工厂，点一下是吧，如果你已经有一个工厂了，怎么办，我要把你给销毁账。

把你给克鲁斯掉，是不是第一步要做这样的事，判断一下我到底有没有当前哪个工厂，如果有的话，我先销毁好吧，消费完成之后，然后呢我再进行创建，因为我们这是第一次进来，所以工厂方法是一定没有的。

所以这个步骤不会走了，不会走的，第二步叫create being battery，这是不是开始进行最终整体的一个创建了叫create，刚接到f7 里面什么东西。

你有一个default placeable being battery，所以之后你再看的时候，你在看的时候，你知道了我们所用的那些并排名字叫什么，叫default lbbf，好把这个对象给我记住了。

或者说把这个类给我记住，当然你在创建当前类的时候，它没这么简单，为什么这么简单，里面有一个方法叫get in tangle terrobin battery，干嘛呢，这是通过名字来判断，注意啊。

看源码的时候去大胆的去猜测，大胆去猜测啊，猜测完之后去验证，如果不对，你再多修改，不要不敢去猜啊，他说了获取内部的负的一些病的一些工厂吗，是不是获取内部负类的一些病病毒工厂，这有吗。

我们这有多证号算什么，点击看一下有没有进去，唉真麻烦大家看说了，判断一下这个get parent，我们想一下parent肯定是什么，肯定等于空嘛，等于空的话，可以访问什么。

反而我们当前这个pad文档一定是等于空了，一定是等于空的，明白这意思吧好吧，所以这个地方有没有无所谓，有没有无所谓，你下去之后可以自作业证，这一定等于空，刚才空之后。

第二步开始进行整体的一个创建了吧好吧，等一下，这这这这这这个这个好难受啊，那我们第八句话好你好，是不是该调到我们班级的方案里面去了，在跳到这个方法里面去之后，在干什么呢，叫super吧。

终于到我们的super了，我说了一层一层一层一层，一定要去找我们对应的一个分类，找我们对应负累，连续叫super，这有一个this，是不是还是我们当前这样一个父类啊，一点类似，你可以往上点讲。

到最后之后找到一个abstract factory，他说了创建一个新的抽象的一个兵工厂吧，那这块其他事情没做了，当然这会创建一系列对象，这对象也不会管，他走就行了，不管他暂时我们先用不到。

你就先不管先不管，然后咱俩走走走走，这东西啊，我直接跳过去了，也没啥用，也没啥用啊，做完之后，我现在其实已经有了当前这样一个类似对象吧。

叫什么叫default list for being battery，这时候里面有个叫dependency interface，是不是忽略哪些依赖的接口啊，这写的三个叫b类。

in februa were being culder，where are，这些where的接口有没有见过有没有见过，刚刚我在看你那个源码注释的时候。

是不是这几个是不是这几个接口是不是有生命周期点东西吧，这样把它设置成忽略，把它设置成忽略，这里面你可以找对应的一个集合好吧，叫一个now dependence interface，现在是不是零。

现在是零吧，你接着往上走走走走，走完之后几个是不是三个了，我把三个接口直接设置进去，完事儿，别走紧没了，这个东西叫set parent be factory，我们有parent be fantory吗。

没有下载之后，它也是等于空的，所以这里面几乎也没做啥事儿好，有没有大事，这往下走就行了啊，接着往下走，要走，走完走完之后，当前这个兵工厂就有了，当前兵工厂就有了这个病，工厂有了之后。

有了之后想想工厂有了，我不可能说我把工厂直接返回就完事了，这不对，这不对，你别忘了，这是一个框架，听到了吗，这些框架既然是框架，意味着它要提供非常友好的一些扩展性，如果是扩展性的话，那意味着什么。

意味着啥，我是不是要一步一步进行详细的一个推测，进行一个呃属性的一些设置了，是属性设置，所以里面往下走，第一步设置一个serial的一个id，不管它第二个叫customer being factory。

你通过这个名字也能做一个判断，叫什么定制化being factory，就是说你可以设置自己的一些特殊属性值的，说了，有没有叫allow badmination or a。

判断一下有没有这样一个ory的一个方法，如果有的话，我就把它设置一下，再来判断下有没有alone，什么呢，circle reference reference，因为这样一个值如果有没有的话，直接跳过。

这里面两只都是默认都是等于空了，就不管它也跳过去了，到这一步非常非常关键了，这一块也是我们整个的核心，叫low的bedefiniti，很多同学我说一下，很多同学看到这块的时候直接干懵了。

有多少同学看过这块的代码，来给我扣个一，你看过吗，有多少人把这块代码看懂吗，为什么要强一点，一会儿一会儿你会看到有n多个no的b在分析什好，这块看下去之后是比较难的，质量难的。

我们可以跟着往下第八个试试好吧，那我来看这叫being factory吧，就不用说了，是default lines for being factory，记住这个东西已经记住了，记住完了之后再往下走。

来不及，写完之后是不是叫load bean definition，这创建了一个china bean definition reader吧，我是不是看到一个reader，这个reader是干嘛的。

不用想也知道我要去读取我们对你一些参考文件了，所以这样我一定要有这些read对象，所以这也创建了一个radio对象啊，这也是直接拿过来的，不管他这直接创建好当前这样一个对象啊，有对象之后。

这有一个super，剪完之后是不是一堆的一些判断，还有东西讲pass much resource，pandora door，这完了用来处理我们当前这样一个配置文件的东西，还设置一些环境的一些属性。

反正把我需要的一些东西我都全部拿过来，好都全部拿过来，拿过来之后，我有了一个be definition reader，这个reader有没有见过没见过吧，刘老师。

我说这东西好像似曾相识，哪来着，这画图的时候，我是画的东西叫什么叫bgmajor，是不是这样一个内涵，真的吗，我说了，你在进行，你在进行读取的时候，因为你可以有多种方式。

多种方式，所以这一定会有一个抽象接口，而刚刚给大家看那个china是个啥，是不是相当于只是具体的一个子类实现，就是具体一个子类实现，当我有了这个接口之后，我是不是可以去进行相关文件的一个读取工作了。

来这块能听懂，同学不知道，扣个一能听懂吗，好吧看一下这个问题吧，比较简单好吧，有这个read对象，细节我说了啊，细节不看了好吧，细节不看了，咱没那个时间，谢谢咱不看了好吧，但你要知道这些方法是干嘛的。

第二步再往下走，设置环境，环境有没有一定有吧，之前已经创建过了对吧，第二个the set result order是不是要加在我们当前这样一个资源类，但你别忘了之前我们已经处理过那个配置文件了。

所以把当前对象加载过来之后就ok了，这里面有那个配置文件，第二个叫set nt resuler是啥意思，也就是说你最终最终你读取过来的东西都是什么，叫nt吧，是不是实体类就这样一个东西。

resource and tiresullar，还是一些包装类好吧，一些包装类，我只知道这块东西都是为了用来处理我们对那些资源的东西就够了啊，最远些东西，这做完之后。

下一步叫dnit be definition vier，是不是该进行这些breader一些初始化的操作了，连续是reader。svida vidv。

这个very d我希望大家能够注意到它并不是一个没用的值，并不是唯一的值，为什么这么说，别忘了你在写配置文件的时候，插画文件的时候问一下有几种规范，或者说有几种格式，你知道吗，你每次写配置文件的时候。

最开始的时候上面是不是一定会有一些什么呢，叫d td或者x的sd是这样文件，这叫啥，dotment type definition，还有什么东西，小叉号flame，但是你什么是不是这样的一些文件。

所以这里面会做相关的一些验证和值得判断，来判断一下你当前文件我应该用什么样的方式来进行一个解析，这只是说把它设置成除了我要进行一个解析了，一会儿在后面的时候会看到n多种标志位，比如说你用x i d好吧。

或者用ppt d，用这样的一个方式，一直不知道在干啥的，不知道干啥的，你想一下，你在读取这些配置文件的时候，他为什么能认识这些标签，他怎么认识这些病呢，他怎么认识的，这边有一堆s3 s一怎么进。

你等下看一下里面一定定义的相关的一些对象属性值吧，有这些属性值之后是不是有病变，完之后有descriptions import aleras beans这些名字啊。

我是按照这个名字进行整体配置文件的一个匹配，那这个时候我就把它读过来了，我进行验证，对不对，如果不进行验证，那不就完蛋了吗，你就完蛋了吗，好在这儿大家一定要注意了，大家注意了啊。

这这块的一个平时信息好吧，有它之后到这步了，叫漏的顶demon，是不是该进行整体的一个加载了，通过这个read对象，我要去读取我们的唱法文件啊。

就是我们对应的一个插板文件，然后点进去之后一样来看，叫get configure resource，比如说了一读到我们这样一个空，如果不等于空，走下面如果等于空的话，是获取我们的。

这是读到我们的oecontact的插画文件，读完之后叫rever，点load deadli，是不是该进行一个下载的，点进去往下走，往下走往下走，你看这方法了吗，诶老师，我之前好像见过这个方法。

有没有见过刚刚在看的时候，是不是有个这样的名字叫load being definitions，大注意了，他们的配置参数是不一样的，好配置参数是不一样的，或者说参数类型不一样的，一个是result的一类。

一个是string类啊，一个是string，它们的参数类型不一样，再点进去，这有东西漏了吧，还再往下点，写完之后这样开thresearch loader，然后呢一步一步开始进行整体的一个解析。

截到这儿之后还是一样，先获取我们当前的一个配置，配置成之后，咱low的bedepennition又到这儿了吧，是不是又看到这个名字了，所以很多同学看到这的时候很懵，诶。

老师我怎么看到好多这样相同名字的方法，不重要不重要好吧，你知道他都是为了进行这些xml文件的一个解析就够了，上面文件解析就行了，再往上点，选完之后往下走，往下走，又看到了吧，叫low的bedeton。

这是卡吧，再往上点logo吧，这就再给他加一个编码格式好吧，设置一下我们对应的编码，不管他走怎么连续啊，到这了吧，是不是有4t往上走，这都没到具体的解析的过程呢，到这一步之后开始解析了吧，是干嘛的。

是干嘛的，叫input stream，input stream是什么东西，是啥意思，它是一个外部文件，你要想把外部文件给读取过来，是不是要用到我们对应的i o流。

这一样也是用我们的io流来进行独立整体的一个处理的，把通过io流我们把文件的一些详细信息给读取进来，读过了之后，下一步人告诉我在干嘛在干嘛，这是一个非常非常关键的分数，叫什么呢，叫do漏的病。

definiti，我说过了，do是什么来着，都什么东西，在spring源码里面，你看到所有带do的方法都是什么，都是实际干活的方法，明白意思了，好实际干活的方法，所以你要看到当前这个方法里面去。

开始进来了吧，我们往回返啊，找一下往这边走走走走，来点进去，点到了吧，这创建一个document的吧，叫do load document，那这里面就是干嘛的，没我说了吧，我们这儿简单看一下好吧。

我再给大家详细看了这个the man的loader，看logo document又开始进行这样的一个加载，点完之后这样一个具体的时间内。

谁来知道dotment build gary构建我们当前这样一个到后面的一个工厂，有工厂之后叫在干嘛，是不是create dog们的builder创建这个对象，好吧，你知道了。

就是用来读取我们这个文档的，读完之后有一个price的一个方法，price是一个公共的方法，也有一堆的实现类，这些price是不是都叫道路price price，你再点到里面去之后，你就疯了。

这样代码看起来很难受很难受，为什么很难受，原因在于它就是为了把我们的配置文件都给找过来，把都给拿过来，拿过来之后我要把它封装成一个对象，因为你注意啊，我搜了插入文件，说白了它就是什么一系列的字符串。

明白吗，字符串spring是不认识这些字符串的，所以我要把这些字符串解析成对应的对象，有了对象之后，比如对象之后，我是不是就能对里面的东西进行一个配置了，是不是意思啊，这大家注意了，这大家注意了。

ok所以啊你可以一部分往这边点，我们这儿不点了，你知道这是干嘛的，就是为了解析我们当前这样一个配置文件啊，解决配置文件都过了过去了，结果了，看罚罚罚罚，这个过程比较麻烦，比较麻烦。

但是你要知道我们这没时间啊，不太浪费时间讲这些东西了，你知道是用来干嘛就行了，好干嘛就行了，这干嘛呢，是不是用来读取我们当前这样一个配置文件，当我把那些配置文件都解析完成之后。

这意味着我获取到一个document的一个对象，有了dota的这个对象之后，我能进行什么处理的，来找一下，这有吗，来找一下，找一下我们的dota有没，这能松吗，不能说是吧，有点尴尬。

就是你可以来进行战相关的一个搜索，看一下里面的一些呃道德的对象有多对象之后，我之后可以从道德道德对象里面直接来获取我们对的一个属性值了，就这块东西好吧，不用讲，大家没时间了。

ok这边走完在做完做完做完都返回来，做完做完之后，这有个get been fighter吧，那一样的判断等于空，如果不等于空的话，直接打过就完事了，所以这时候我是不是有了病工厂了啊。

同时这个病工厂里面注意这个病工厂里面有什么，是不是已经把我们对那些插板文件，插画文件已经解析到了，或者说他已经被封装成一个对象，一个什么对象叫dota的一个对象，有了dota的对象之后可以干嘛。

可以从里面获取我们对应的note，明白了吗，里面都是一个元素，一个元素的，我就可以来获取，no no no的好，来到这边为止，能听麦同学搞个扣个一看，听懂吗，所以你看到的工厂，你看到的工厂，注意了。

它不是一个简单的工厂，里面做了很多事情，这块是需要你们下去之后自己来详细了解一下，明白意思吧，我可是这部再来看这部，我说这个无所谓啊，里面也是一样，设置了一堆对象，这样就说过了吧。

设置东西你看叫ban expression reserver，ban的表达式的一个处理器对象啊，the standard ban expression reserver，并处理一些东西。

再来看第三个叫and property editor register，是不是我们当前这些属性的一个编辑器，也得把它给捉进去了，这注册完之后，下一步叫at be post processor。

终于看到这方法了吧，这干嘛啊，我现在开始往我们当前这个bin finder里面注入啥玩意儿。

being post processor吧，哪来的，看这个图是不是该注意的东西了。

后面还有很多，后面还有很多，我们这儿只讲，只是看看这个步骤，再往下看，叫nore the interface，之前是不是见过了，在刚开始创建对象的时候。

发现创建对象的时候是不是有对应的那个已经有三个接口了，这时候加入了三个派，叫register reserve definity result，你说有这样一些依赖好吧。

再加一个at be post processor，两个了吧，注意啊，这一个这一个是不是两个了，一会儿这些东西都是要进行执行的，千万不要小看他们好吧。

再来看怕的东西叫being father contents being，判断一下你到底是否有这样的一个并列项目的lotime where，你这样去想刘德华做什么事，没有德华做什么事。

就这里面啊就是一些基本属性值的一个判断，请问水平判断啊，这个一步一步往那边走就可以了啊，这里面有什么有什么作用，你可能现在还不理解不理解，还是那句话，你先扔一边，先扔一边好吧，那我们这儿直接跳过去了。

直接跳过去了，看到这块我不带，你必须行上看了，你知道这只是往里边说的一些对象，创建一些对象，什么时候用，一会再聊啊，一会再聊来，现在能听完，同学考科目一，你在这跟不上啊，能听懂吗，章子怡不要刷屏好吧。

不要刷屏了，这我觉得应该没问题吧，没录上啊，这做完之后这东西啊，下一步重复看，你把每一行代码都第八代才行啊，第八代行到下一步叫post processor，being ter，终于到这块了。

终于到这块了，叫post processor，并发掘，这干嘛来着，这方案我说过了，他是为了留给我们当前此人来进行扩展的，所以你往里边看的话，什么东西都没有，什么都没有，是不是空的，空的话。

我们这就不看了吧，无所谓了，对不对啊，往下走，走到这之后叫invoke b factory，post processor是干嘛的，这个步骤很简单。

回到这张图里面，我说了，现在并工厂也有了病，工厂有了之后，按道理说我们应该正常的话是怎么走，怎么走，是不是该创建我们这个时间化对象了，说实话的时候，我们刚才已经看好了。

我刚刚在那个prepare prepare方法的时候，是不是已经往里边设置了两个b post processor了，但是注意了，还没走到这个环节，还没走，这在执行这个环节之前，还要注执行一些什么呢。

叫并factory post processor，有这样一些东西，有这样一个东西是干嘛的，这是对我们的兵工厂是不是可以做一些扩展，也就是说你读过来读过来这些配置文件了。

我可以对这些配置文件的一些配置信息做相应的一些修改，好做参考，接修改，k老师能不能把屏幕设成白色，虽然效果了白色更亮一点。

白色更搭一点，所以把它改成黑色，好吧，呃勉勉勉强听一下，ok，稍作完之后把这个方法呢我说一下，这个方法是一个非常非常重要的方法，而且也是一个非常非常关键的方法，这个方案里面到底做什么事，叫invoke。

是执行的意思，还有个叫bin faitpost processor，这一块就是我们这儿画的这一系列的一个步骤吧。

是不是这块东西这里面逻辑看起来是比较麻烦的，但是别瞎看也别慌，没大家想的那么难，没大家想的那么难，怎么看呢，点进去瞅一眼，这里面下面只是一些基本的判断，最核心的步骤是在哪呢。

在invoke并factory post processor里面去，第一个叫什么呢，叫get看这个方法叫get been factory post processor，是不是这样的方法，你点开看一下。

计算走没有东西吗，没有吧，说明东西是等于空了吧，等于空，不在意了，第二个把并翻译给发出去了，放完之后该执行当前这个invoke的一个方法了，在invoke方法里面。

很多同学其实看到这个方法的时候就疯掉了，为什么这么说，因为这个方法非常非常多，从55行开始，一直到187行啊，而且这段代码在看的时候，你会发现它有很多很多重复的代码，很多人看重播代码之后干蒙了啊。

这干嘛呢，这是这块东西，鼠标同步代码，然后来看这，先判断一堆东西，做一个键盘呢，这是一个外部的一个if吧，你把这衣服往下拖，它几乎哪来，哪知道到这块吧，衣服有else吧，是不是对应的一个else。

在这if和else里面，它两个地块做的逻辑其实差不多啊，其实差不多好吧，但是你要知道他干了什么事，你把这个事能看明白，这事就了了，这两个好吧，怎么做来，第一步先创建一个叫post behyset。

是啥意思啊，这个集合千万不要忽略它很重要，因为我们在进行创建的时候，你会发现里面有很多对应的一些处理的病，比如说被迫活在这这些这些对象对不对，如果你之前已经处理过了，我还需要再进行处理吗，听完问题啊。

一个ban fei啊，这样写的一个并finally post processor，它可能在整体的这个逻辑里面背什么呢，能匹配到三次，那我是不是只要在三次里面，只要第一次我执行了。

我后面两次再匹配到的时候，我还有没有必要进行执行了，有必要吗，因为这块说白了也是一堆if else的一个判断，对不对，是if else的判断，既然是衣服i判断，这意味着我一个类可能被匹配到多次，有三次。

那这个时候如果我第一次匹配到了，我就把这个类做了一个处理，那我第二次第三次我再匹配到之后，我还有没有必要再进行处理呢，你们觉得呢有必要吗，啊没有必要没有吧，是没有必要了，所以同学说了，这叫什么去虫标记。

这个标题说我已经处理过并对象有哪些，我把它放到这里面去，后面会有逻辑判断好吧，ok就这块再加上之后，第二步是一个义务判断错了。

如果你这个b factory是一个been definition registry这样一个对象啊，你就执行下面的逻辑啊，如果你这样不是的话，alt呢哎哪去了，找了半麻烦，在这块els的时候。

是不是执行下面的一个逻辑，是针下面留辑，所以你先从刚刚那个55行看到137行，如果你是上面那个类，我就执行这一块中间逻辑，如果不是的话，我就走下面这个逻辑，但是你发现了走下面这个逻辑的时候。

这个方法名字一样不一样，发明的一样比较一样啊，是不一样的，但是你传递的参数是不一样，明白了吗，传递的参数是不一样的，好传递参数是不一样的，ok来再来一个，我们看一下这个东西吧，第一个它是什么。

你如果看过这个bfx类型的话，你会发现它是这样一个对象，所以这时候能进来，进来之后一样的，第一步先做一个强转，先做个强转，强转完成之后创建两个集合，一个叫什么。

regular post processor，引导reject post processor，两个名字，别去看他，你看什么，看当前类的类型，看类型，这个集合里面放的类型，第一个类型叫什么。

叫be factory post processor，没问题吧，这不就是我们要处理的东西，第二个叫什么呢，叫being definition，registrate post processor。

是不是又涉及到这个b damage是丙单位，是啥来着，这是我们注入的一些病的一个对象吧，就这儿有两个对应的一个集合，有两个对应的一个集合，有了两个集合之后，你就可以做相关的一些处理的。

刚开始的时候一定都等于空的，没空之后，我这开始进行判断了，for循环里面是一个循环判断的过程，好判断一下你当前这个processor这个bfpx等于等于什么，等于空吧，日里面能进来吗。

这些东西啊是从外面传过来的，传过来之后说了等于空，所以这个方法是进不来的，你不管它好吧，这个东西叫current registration，processor。

叫ban definition reer pro，不在这吧，别忘了上面两个集合好吧，一个叫bbruary，一个叫bean definition，把两个名字给我去分开，你必须要把这两个名字区分开。

b3 就不用说了，b3 是啥的，是我们当前类的一些定义信息，当前类的一些定义信息，明白了吗，这是我们工厂类的一些提前处理的方法，这是我们类的定义信息的接触的方法，然后就不一样了，对吧，我去混了一谈。

往下退这一步的时候，这又创建这样一个集合对象，集合对象有了定对象之后，这儿有个名字叫been fire get be by for time，这干嘛的，他要来我们当前这个工厂里面去做一个匹配的。

根据名字去做匹配，是不是根据类型去做匹配，匹配什么，看一下当前类里面。

系列 2：P39：SPRING源码：07Spring的面试常见问题 - Java视频学堂 - BV1Hy4y1t7Bo

匹配到如果匹配到我就进行处理，如果匹配到我就不进行处理了，就这意思，所以往下走走走，走完之后你发现了里面有几个值，往上翻看一下里面的值啊，呃pro有几个一个吧。

一个叫internet configuration annotation processor，是不是这样一个数据类，这一类我给大家说一下，你根本压根儿找不到它，找不到它啊，它不是我们写好的一个类。

是through里面允许创建的一个内部类，它指向的是一个什么，是一个配置类，记住了是一个配置类，你现在看不到右边就看到了，一到了，怎么看到这个东西，怎么看的东西，有人知道在哪个类里面吗，有没有人知道啊。

有没有知道这个configuration，有人知道这个变声器制器在哪个类里面吗，没有啊，都没有了，唉都没有，我们都没有了，那么大家看就行了，不知道是吧，晚上看一会就知道了吗，往下走开始循环。

我们当前这样一类是不是开始穿过这个接口类之后，他说了叫is type match，意思开放，那是干嘛，是否匹配，就是说你有这样一个类之后，我要对你进行对应的一个映射，实现有一段时间之后。

我要判断一下当前这个类到底是否记住啊，到底是否是实现了叫pay a pretty order的一个接口，这啥意思啊，有一个类啊，找一下叫叫什么来着，叫a我忘了我忘了叫lp有跳蚤l o p啊是吧。

有为什么有跳舞来都记得，我忘了那个内叫啥了，看一下，就这里往下看，叫annotation configure，your toos，是不是这样的东西，类在当前这个类里面，你找一下干嘛。

都考验着是不是叫org three four contest，annotation，internal configuration，annotation processor，你穿过a类是不是类什么问题吧。

是不是类这个类，它在进行指向的时候，你可以来看一下wifi，它匹配到是哪个类，哪个类，看见了吗，叫configuration，然后呢，class post processor是不是这样的类。

所以你刚刚看起来的时候，好像我找的是这个类，但其实是哪个是configuration，那那那去吧，那个名字我记住了，combination class post processor。

实际上处理的是这一类，所以我要判断一下这个类它到底是否具备了preparty那样一个接口，如果是的话，意味着我能够进行处理的，如果不是的话，我就不能处理明白意思吗。

而且刚刚那个这个邮票里面它封装了很多啊，所以有时候同学老师我怎么找到这个类啊，你没找对类，第一个是这个名字来翻，是不是这样的名字，看到吗，你是这样的名字，你看这个名字了吗。

这个名字如果你去spring包里面去找的话，我告诉你你一样可以找到，这样找不到好的，就定义了一些静态变量，这些静态变量下面的时候会告诉你我到底匹配的是哪些类啊，这是不是有往下翻，如果是他的话。

匹配到这个类，如果是他的话，匹配到这个类，如果是他的话，匹配到这个类，是不是下面有对应一些类了，这些类都是都是什么叫being post processor，好。

都是这些being post processor，来这块能听懂吗，果然小孩很枯燥，废话原版人都不枯燥吗，你看别人想的这块逻辑都不枯燥，对不对，你要知道在哪儿找的好吧，你要知道在哪找吗，如果你找不到的话。

很多同学你看到这块时候直接大懵了，老师这东西哪来的，我怎么样把它找这个类啊，你根本不知道怎么来的，o好了，当你把这个类取出来之后，你要判断了吧，判断一下它是否实现两个接口，对不对，这个怎么判断呀。

很简单很简单，你找到刚刚实现好的这个类，刚是不是通过它来形容这一类的，你打开这个类的类图啊，其实不用打开了，这儿也有了，看这块，看这块有这个接口吗，它是不是实现这个接口，它如果实现了这样一个接口之后。

你告诉我，我这样在做类型匹配的时候，能不能匹配上，能匹配上来选择同学扣一分，同学看二能比得上吗，可以吧，所以这时候我就能够进来了，听到了吗，这就进来了，进来之后我把它加进来，下面是把它加进去。

加完之后我把它加到那个处理过的里面，就把加那个pose of process病死，比如说我已经处理完成了，我已处理完成了，做完之后这个东西大家走是不是该shot了，好排下序。

然后呢就把这个注册里面加一个对象，然后开始进行具体执行，完了之后把它给清空，这样切完之后注意了，从这块开始，从这块开始，这是一个整体的逻辑，这是一个整体的逻辑啊，这儿执行完之后往下看，第二块。

看这块这块你是又蒙了，老师诶，这段代码跟我上面这段代码好像看起来差不太多呀，我把全屏打开啊，唉你告诉我这个代码跟着代码看起来差别大吗，不大吧，是不是上面的时候告诉你说我要匹配。

是不是being definition rejection，possible or，第二个是告诉你说我要进行验证，验证一下你是不是病，但分离散热沾水泡缩在这吧，这两个问题看起来是一模一样的。

是不是一模一样的，所以这样又要进行一个判断，这样判断完了之后没完没完，这个名字其实还是同一个名字，同一个名字，这儿做完之后，这要进行又一个match了，那是啥说了。

如果你这个post process be不包含这个东西，同时它能匹配到什么呢，叫order这个接口，那么我要进行下面处理的，如果不能，我是不是前面处理多少，所以大家发现了，为什么很多同学看起来比较乱。

原因就在于这两块东西是差不多的啊，但是你看这个的接口，这两个接口是不一样，明白了吗，两件不一样，那你告诉我，我这儿已经处理完成了，我下面这还用处理吗，这就不用处理了，你看左下这个逻辑来走一下。

走下走下走下还能进来吗，是进不来啊，进不来，我就直接跨过去了吗，那这样东西就没啥可说的了，那最后还有一个什么，还有一个翻着，你还有三个人发了什么意思啊，翻译什么意思啊，一样的来看。

又是一个been father，该能用病死，that for all time吧，好告诉你说我是否包含这些东西，也就是说我们现在在判断这些病，但是cost processor的时候。

我先判断一下你是否有一个什么呢，property order这个接口实现，如果是的话，我先处理，如果他没有的话，我判断一下你是否实现了一个order的接口，如果是的话，ok我处理，如果不是的话。

我再进行下面的一个处理逻辑，所以我说过了，这块整体的处理逻辑都是差不多的，你看起来的时候别晕，看的时候别晕，懂我意思吧啊这大家要注意了，当这些东西都执行完成之后，我要执行invoke。

这些emoe就是具体的一个处理过程去处理过程好吧，那下面这个这块呢一样的，你往下翻，刚刚是什么来着，注意啊，刚刚你取的时候转成什么了，叫being definition register，这样的对象。

下面在转的时候转成啥了，转成并factory pos pos是吧，比如说把你一个ban工厂，in factory要进行n多次的一个判断，看一下它到底能匹配到几个子类，几个此类如果在平面上进行处理。

平行不上，我就不进行处理了，那下面这块处理逻辑一样不一样一样也是是否包含，然后呢是优先级的一个排序，然后order这个排序再往下的话就没有排序的一个东西，又拍一东西，所以这块都处理完成之后，一直往下走。

就能把这些完好，所以才说了，老师这个逻辑看起来很麻烦，确实很麻烦，原因在于它里面有很多重复的一个代码，重复的一个代码好，既然是重复代码的话，好吧，你要是你清楚整体的一个处理器到底干了点啥，千万别蒙。

但是最核心的点是什么是啥，这只是整体这个逻辑有逻辑之后，下一周看了看，看完了这儿有个东西叫invoke，什么东西，invoke就是具体执行了，下面也是invoke进行具体执行啊。

所以当你把这块东西你都执行完成之后，意味着什么，意味着我这张图里面这一块的环节我已经执行完毕了。

听到了吗，这已经执行完毕了，这已经执行完毕了，ok我知道很多同学已经听懵了，能给你听懵了啊，但是我希望下去之后，你现在好好看一下李老师这个重复代码，为什么我不能把它抽象出来。

想得非常非常对，是啊，为什么不能抽象，我说的是大体的逻辑是一样的，但是你看一下具体的处理细节是一样的吗，不一样啊，不一样啊，这些东西本来就已经是一个方法了，你还能再进行抽象吗，没有了，明白意思吧。

好在这他应该注意了，ok当你把这个方法也进行完毕之后，已经完毕之后，我还我还打打打打点告诉你说什么意思啊，我刚刚那些been fport在哪，我已经执行完毕了，我执行完毕了。

到目前为止能凑合跟上的同学扣个一，凑合干啥，不要求你全跟上，我告诉你，我这给你讲完了，你立马就听懂了，你们也太看不起spring了，别想了，立马就立马能听懂，这不现实是不是现实好吧，还是一样，先捋思路。

我这也是为了带你去验证我刚刚说的那个思路，这个思路ok你要争一口气，看你在怀疑我们这些学习能力，好好，我错了，我错了，我对不起，你好吧，我没怀疑你们，你们都能登上好吧，这块也一样吧，这就是一个逻辑判断。

我接下来讲吧，当你把这块逻辑判断执行完成之后，ok往下走就完事了啊，这块东西刚刚干嘛来着，处理的是been factory post processor，下一步该干嘛了。

该been post processor了。

哇，两个环节不要给它涂上，刚刚是直到这块吧，现在不要跟这块了。

把这一块也执行完毕之后，就可以进行整体对象的一个实例化及对象实例化，点击看一下吧，连续这块有一样的叫post processor，register than a dog，register。

b post processor，再慢慢走，里面就是往里面创建了一些对象，是不是告诉你说你判断一下当前这个类是否属于并put protest，往里面进行一系列的一个术语，你发现了。

这是不是也有类似的东西，什么power the order吧，是不是有order，这个order连读是干嘛的呀，有人告诉我，谁能告诉我，这out了干嘛的，奥尔有用吗，排序排序有用吗。

我相信很多同学之前一定写过这样的一个主题，叫叫什么叫at order，是不是写过里面是不是可以写一个整数，是不是用这东西，所以他俩一定要执行对应的一个顺序好，执行了一个对应的一个顺序。

那这块逻辑理来说也是差不多的，也差不多的，只不过刚刚执行的是什么，是being fury post processor，现在是什么，是b好吧，post processor，把这两个东西过分清楚了。

还是一样，回到这张图里面，你记住了，先执行being fa，再执行being host，放在这两个东西是不一样的。

他先执行，他后执行好吧，分别是在两个不同的方法里面去执行的，只不过我在你看的时候没带你们看具体的一个处理逻辑，好怕你的猫懂我意思吧好吧，那我们这儿不再往里边挨着点了啊，你知道大腿一出游就可以了啊。

走走走走，走完他这是一个循环啊，循环很多，哎呀看到了，我找一下s上的，哪去了，reflash，找一下我的方法，start reflash，当时没能创立方案里面去了抬走，所以你记住了，第一步。

第一步是执行的是been factory post processor，第二个是being post processor，把两个东西给分清楚了，把两个分清楚了好吧，这一块也执行完成之后。

已经奖走100人了，我估计这是一个劝退课哦，估计这是个劝退课呃，这给大家说一下啊，你们别一听不懂我就走了，一听不懂我就走了，你想一件事，你随便写的东西你就都懂了，你懂了之后，市场上的人都懂了。

你凭什么拿25为三，十，35为40，这样你只要懂点别人不懂的东西，你是不是才能够达到高薪工作，你随便学点东西你都懂了，这有什么价值啊，没意义好吧，所以你要提高你的核心竞争力，哪怕你现在听不懂，没关系。

你先听个响儿之后，如果你有兴趣或有心情再重新看的时候继续说啊，好像原来李老师讲过这个东西，我好像有个印象，我大致知道一个思路是什么样子的，这也比你重新听要好很多，懂我意思吧，好吧行了。

老长时间我们接着聊好吧，再往下一方法叫什么叫in it message source，这个我说过了，他是干嘛的，知道吧啊，用来进行国际化的一些配置啊，进行国际化的一些配置啊，这样不看了没啥意思。

连之后你看一下这些国际化的配置，我消息一些配置不用管它，ok再看第三个什么叫objection event，没cast就打完了，这是用来指示我们对那个多波多波器或者那个广播器啊。

往里面设置我们具体的一些事件的一些事件的啊，这有个东西你有一个simple什么东西出现这个对象对象的时候，你给他有一个set b啊，这块你还可以怎么看，还可以看一下我们当前这一类的一个负累吧。

找一下复联，复联里面有多方法吗，网上没有什么，没有啊，那就算了，就它里面设置我们当前这样一个艾特一个b对象，往里面时候开始设置我们具体的一个对象值了好吧，这就注意了，这最终的目的是为了什么。

就是为了设置一个广播器，有当前这个广播器之后，方便我在后续的时候可以往里面添加一系列的事件，一切的一个事件好吧，什么意思呢，这东西叫application，疑问的music cast。

是不是告诉你我有这样一个对象了，有对象之后，我开始里面什么叫register singleton，是不是开始往里面注册我们这样一些单位对象了，就是一个具体的一个值，有了这个东西之后。

你以后再往里面设置事件的时候，就可以直接来进行一个编写，就来进行一个编写了，所以这也是一样，先注册一个单位对象，但调完了之后搞定了这个unreflesh，on relash，因为啥也没有。

我说老师一个空的留给子进行实现的，再来看叫register listener吧，是不是终于到这个listener这个环节了，连续看listen，那他是怎么做的。

开始循环叫get up listeners，先获取一下我们这listener到底有多少个一行，有没有没有啊，那没有的话，我要循环法肯定是等空了，再来看这又来了。

这啥玩意儿叫get big name for time这个方法，你们现在已经很熟了吧，刚刚在看的时候是不是很熟了，这干嘛呢，这东西谁能告诉我是不是去我们当前这个兵工厂里面，干嘛类型查找吧。

看一下有哪些东西符合我们的obliation listener，所以你们还有一步，这能匹配到对应的一些结构影响，是不是有一个string值能匹配到吗，给大家看一下吧，找一下。

this is my bilives，看这块这匹配到当前这个值了吗，这个值没有吧，没办法，这也进不去，进不去之后，这来了叫this early application even，还记得这玩意儿吗。

你们能记得，哪用这东西的，你们能记得，有印象吗，哪有印象，我当时在你们看当前那个方法的时候，运回来方法的时候按照，所以为什么让你去看这东西啊，看这块儿看这块儿记得吗，我是踩到过了，这是不是一个空的。

那这块是不是跟我们后面这块儿就对上了，判断一下这个值是不是等于空，如果等于空的话，然后呢做什么事，如果不等于空的话，我做什么事，是不是这意思对吧，这样虽然等于空头上有个东西啊。

early event to process，不等于空，不在于空的时候，我还要进行循环遍历，遍历的时候一直往下走，是不是也进不去，因为现在我们没有任何的一个事件，没有任何一个事件，所以里面什么都没有。

但如果你在看spacc或者spot源码的时候，你能看到很多对应的一个环节，很多对应的环节里面都有一些事件网络机制啊，你知道这是注册我们的监听器就可以了，好来到这儿能听明白，同学扣个一，能看懂吧。

美照片美照片好不好，来再来看看下面再干嘛啊，它finish b fy，你出来a吗，是啥意思，是不是该进行具体实例化了，那就一直问我老师什么时候进行实例化呀，怎么进行实例化呀，到这儿就来了。

这里面的逻辑也很复杂也很复杂，来往里边点点一下，填完之后开始告诉老师，告诉你说看他判断一下你当前并犯罪里面是否包含这样一个the啊，是否包含连续进去，大家看是否是一个内嵌的一个值的处理器啊，这也进不去。

再来看叫be factor get being names for time，又看看了吧，叫load time where while，这样class有没有，是不是也是一堆的一些循环，判断好。

它也进不去，进不去之后一直往下走走走，走到这一步的时候，这是我们对应的一个核心，这是我们对的一个核心，这还有啥叫pray neural nesingleton，是不是告诉你说。

我要进行所有的非懒加载的那些单例对象的一个什么实例化了吧，所以从这儿开始进行整体的一个实例化，上海你实际化什么实体化点进去，这就麻烦了好吧，这就麻烦了，从这开始就比较复杂了。

但最终我会带你们看到反射内部，看到反射，你知道哦，原来是这么回事，原来这么回事好吧，那往下走，第一个也是漏洞判断，不管他往下走，第二步创建一个粒子集合，原创是什么，叫并在分析成内部这儿有一个时期。

这个时期是啥，这个时期代表的是我们现在你需要创建的这些对象到底有多少个，是不是这么多东西，这是哪来的这东西啊，就是我们之前在我们的java代码里面，我写这个不到e m p t e m。

然后service book service有这些东西吗，是不是这三个类，同时我在我的配置文件里面，我是不是写了一堆，比如说被对象找一下，现在dos有没有这a b c comic。

有没有transider manager，有没有，是不是就是我们这些b类啊，这都有啊，都能被读取道，都能够读取到，ok连续这点完之后再往下走，下一步再开始进行这些病对象的一个循环了吧。

啊是不是进行循环循环的时候，我要判断一下说这些对象到底是否已经什么实体化了，如果已经实例化了，那很好，我是不是拿过来直接就行了，如果没有实例化的话，我是不是要对它进行一个实例化，这怎么实例化了呀。

往上看，这有一个非常关键的一个判断，叫判断一下它首先不是抽象的，首先它是单利的，其实它不是懒加载的，是不是有三个对应的条件，这三个条件能看的同学来扣个一，能看懂吧好吧，然后这又多了一个逻辑判断什么呢。

叫is factory，并看到这个方法了吗，黑着说，老师你给我讲一下那个那个什么factor being和been factory吧，这有问道吗，点的方法看一下判断这个病到底是不是我们的艾滋病。

如果是的话，是不是有return一个判断连续，如果是的话，我是不是调我们当前这个犯病的一个方法就行了，是不是get object，如果不是的话，我是不是就按照常规的方式进行一个处理，这是不是有判断了。

那我们自己定义的这些实体类，大家想一下，并不是fib吗，所以这里面这边能进去吗，进不去吧，这里面都进不去，好吧，都进不去，而且你在这儿的时候能看到一个东西，什么东西。

有没有同学有没有同学见过这样的名称是at一个类，有没有人见过吗，你们有没有见过你爱的看到一个类，啊没有啊，如果你用的比较多的同学应该是见过的，看着它不是and的意思好吧。

它不是and的意思是用来获取我们当前这些单并对象的时候，它前面会加一个at的标签来进行获取的，faker并不是bin fak 3倍病好吧，这样大家要注意了，这里大家要大家要注意好吧。

内部类是dollar，不是与内部类是dollar，叫对叫取地址符啊，一看这些东西啊，都用过，用过你就知道了，是从这里是不能取到，就能看到这个东西对吧，这个原版里面都有验证，都有验证好吧。

我们刚刚是取到的，取不到怎么办，是不是到get be了，它变的时候一样，我要进行整体的一个获取了，他或者有个东西叫do get be，开放了吗，我说过了度是干嘛的，都是实际干活的一个方法。

再连续人家都说了，第一个缴获取一下我们当前这个病的名称是不是叫古董，学完之后获取下当前的一个是否是一个单例吧，来咱慢慢走，这是因为我们之前没做过，所以里面一定获取不到，如果它不等于空。

并且参数等于空的话，直接下载逻辑，如果他这块判断不过的话，到这块了，是不是当l怎么了，elc也一样，先获取我们的负的工程，如果获取不到的话，往下面走，具体的一个逻辑反走的时候。

你最终要看到一个地方找一下，我就往下面看，还能干嘛，第二个跟他走，向他走，他说啥叫mark并as created，当你上面的逻辑如果都通不过的话，意味着什么，我现在要开始进行整体对象的一个创建了。

这开始创建对象了啊，所以我要制这样的一个标志，制完之后往下走，往下走拿走，第一个叫m bd点，get depends on，这干嘛的，有没有知道这码干嘛的，你知道吗，知道吧。

你在写我们对应的一个配置文件的时候，在后面是不是可以加对应的一个属性值叫depends，是不是可以指定我们当前bin的一个加载的一个顺序，是不是，当然我们并加了一个对应数据。

是不是需要我们对于一些对象的一个依赖，这是不是可以进行一个判断了，对吧，再往下走，如果这东西不等于空，我直接下载逻辑，如果等于空的话，是不是接着往下走，判断一下它是否是一个单位的，是向大家走走，哎呀呀。

过去了不好看，这块这有什么东西，这里面是不是传了一个匿名函数啊，然后等下试，然后等下试，这东西叫什么叫crazb啊，是不是从这儿开始，我要进行整体并的一个创建了，但是我也说过了，我也说过了。

这个create b的时候，它的方法前面并没有do，没有度意味着什么，他不是干活的，他不是干活的，谁是实际干活的，是不是应该有个方向，什么叫do create be，应该是吧，大胆去猜好吧，应该是吧。

正在来往上走，点进了一个直接直线，我们来往这点一下，聊这行好吧，聊这行，然后呢，我重新往这边走，重新重新重新启动一下，重新弄一下来，这小伙就刚刚跨过去了，走走。

他那是不是跳到我们这个病例方法里面去了对吧。

再create be，在create be这些方法里面去之后，下一步是不是又是一系列的一个逻辑判断是在里面，你要找了，找什么东西还挺好玩，看这个代码是什么关系吗，叫什么叫do create b。

多亏没干完了，注意啊，苏联语系的判断就玩不了了，玩不了，下一个自己看下来，自己看是吧，你让他看看这个吧，叫多亏的病，又看到度了吧，我说过了度数干嘛的，是不是实际干活了，你既然是实际干活的话。

意味着是不是应该在我们当前这个度方法里面，我要通过反射的方式来创建具体对象，这句话能听懂，同学来扣个一，就在那个方案里面，我是不是应该通过反射来说创建对象了，但中间有可能代码我这直接跨过去了。

但你要知道这是不是这样的逻辑，那我们这儿可以直接点到这块来讲下面它这块了吧，点开之后来往里边再点一步读点，在这里面的时候，看这第一步有个东西啊，being观察吧，就是变了一个包装类啊，变成一个包装类。

你不用管它啊，别管他往下走，往下走，拉倒走到这块之后，到这块吧，叫create bedience，诶，这啥玩意儿，我好像也不太懂也不太懂，但懂没关系，连续剧填完之后。

里面有个东西叫resolve been class，然后呢，md什么东西什么东西，你发现了，这里面好像没有看到我想要的东西啊，能看到吗，上面也是一系列的一个判断逻辑，你注意啊，作为一个框架。

你肯定是要有一个非常完整的一个判断逻辑的，比如这块判断什么东西，说been class is public，是告诉你说是不是public的啊，不是public的话，不允许是一些事情判断好吧。

三个头也是一系列才能判断，判断完成之后，最终你会找一个方法，这样这叫啥叫instance b吧，这啥玩意儿这啥玩意儿，来点进去看一下当天我们这个方法好吧，走了这块之后，走这块儿之后，我就直接点过来吧。

看着啊，我是真的点就行了，打到这里看看能不能调理好诶，没进来吗，这都没进来抓走啊，这k的b慢走慢走慢走慢走走，剪完之后走慢走，还没进来吗，不应该啊，那走啊，点进去，看到上面有个获取初始化的一个策略吧。

啊或者我们当前这个b边的一个对象，再拉走转换的对象，哎这怎么没看到这个方法呀，我直接直接直接直接装上看吧，直接从哪看啊，这是一个初始化病的一个对象，填写完之后，这有一个一系列的一个方法。

在什么里面还说了叫object sense，等于什么东西，说了accessible controler，什么都previlege这一系列的一个基本判断，判断完成之后再进行一些实际化，一些基本操作了。

让他点具体的时间内，咱们来找找一下我们当前这个处理过程，看这块能看这个代码吗，是什么代码，叫contract to use，是变量翻车了，这叫翻车吗。

大家看这边有个东西叫construct to use，这是个啥，是不是构造器，我们现在要进行整体实例化的时候，实例化的时候是要通过构造器来进行实例化，那坐这儿有什么东西叫class点，class。

struct是有它对吧，有它之后怎么做，叫b有tx点，instance class是把刚刚的构造器传过来，传过之后点进去里面又是一系列的复杂逻辑，什么叫reflection，有调点。

make senal允许它进行一个访问，如果允许完之后，你往下走，在这块的时候有问题，叫c t o r点，new instance是不是该进行我们整体这样一个直接化了。

new instance不用说了吧，这是哪一类的，把它看是哪一类，是不是ctrl的这类，那是不是意味着我通过我当前这个构造器来进行，整体对象的一个实例化，通过了，明白意思吗。

好这是不是我们整体对象的一个实例化，来这边能看明白吗，我是不是一步步点进来的，是不是通过我们当前的构造器来进行整体的一个实例化，实际完成之后，我就通过反射来进行实现，当然我之前啊。

我之前那天上课之前是给他写，然后代码那个反射是最基本的反射，最基本的反射，同学说老师那个代码不太严谨，确实是这样的，我们只是为了说明一个最基本的案例，这里面其实要包含一系列的一个判断逻辑。

有了这些判断逻辑之后，拍出去之后，我是不是就能够进行整体对象的一个反射了，完了完了之后我是不是生成了具体的类这块反射的东西，能看出来，同学给老师扣个一，能看懂吗。

系列 2：P4：马士兵老师JVM调优：4.系统上线前预估系统的内存占用情况 - Java视频学堂 - BV1Hy4y1t7Bo

啥也不敢，两种作用，第一个调试用，第二个确认不用dc参与，就能干完活了，这时候你可以你就可以用app了，好到现在为止，我觉得脉络上的东西大家是不是掌握了啊，这个脉络上的东西，来掌握同学老师勾引我们。

下面往深入一点点细节脉络，有了对面试能有好多细节，但是你记住了，我这两天练营呢叫做实战训练营，你要想听实战，我就跟你聊，实战之中会产生内存溢出，教你怎么去定位，怎么去把它揪出来，怎么去把它给干掉。

如果你要想听理论，那就全是理论了，所以我们还是实战啊，听完实战，有些理论你不懂，但是你简历上就可以写，我有实战经验了，听完理论，我估计你也记不住，好看，这里给大家多记两笔。

现在问的比较多的cms开始或者说分带算法，只要只要产生并发的时候，并发的算法从cms开始，它的算法是什么，先给大家几个名词，感兴趣的你好好去网上看看啊，三色标记对不对，它会把对象分成三种颜色，黑色的。

灰色的，白色的，黑的已经全标记完了，灰的自己标记完成员变量没标记吧，孩子没标记吧，白的还没标记的，三色标记算法用来干什么的，用来进行并发的时候，做并发标记用的不容易产生问题的三色标记。

三色标记里面会有产生漏标，就是我刚才所说的那种最严重的问题，就是我标完了之后，这哥们呢把它标成垃圾，但它它它又变成不是垃圾了，好这种是最严重的三色标记，要想他这个算法本身是一定会产生这种问题的。

为了避免这种问题，cms的他的干法，这个，a，好cm s的干法呢，首先第一个呢叫三色标记，下面这段你一定听不懂啊，听我说你一定听不懂，我只是给你开拓一个你下一步可以去研究的东西，get到了吗。

你一定听不懂三色标记，三色标记会一定会产生错标，产生坐标之后，cms是怎么解决的，它的解决方案叫incremental，update叫增量更新，但是这个增量更新有问题。

因为在增量更新的过程之中也会产生错标大哥，所以呢，这也是为什么cm到最后一定要有一个remark的东西，好接下来，怎么把这个给挪这儿了，复制了一下啊，不小心，好，所以所以什么呢，所以第一。

所以g1 g一同样的也使用三色标记，但是它采用的算法是什么，它采用的算法叫做，ok g一的算法，g的算法叫什么呢，g一的算法叫做s a p b，哎呀牌不好，那什么了，排排好版了啊，很简单。

给大家写出来吧，好第一第一的算法叫什么，也是三色标记，加上s a t b它就解决了这个incremental update，最后必须要进行remark这个过程，所以它效率上有所提高。

这叫natural at the beginning，好，接下来z dc是什么，c d c是最难以理解的一种算法，这种算法呢叫，color red pointers，这种算法叫颜色指针，或者叫着色指针。

呃基本上不会有面试官跟你聊到这儿，因为市面上一点资料都没有，连国外的资料都没有，要想弄明白这个只有一个办法读hobo源码，哎很不幸的是老师读过，所以目前只有我能给你讲清楚，慢慢慢慢慢慢来吧好吧。

但是也别着急啊，因为这个东西没有人问啊，好吧，你随随便去网上找文章去，这颜色指针的也是特别复杂的一个东西，他是用c加加里面的指向java对象的那个64位的指针，其中的四位做出了一些相应的操作。

因为这里面还牵扯到操作系统的那种内存映射的问题，嗯现在呢问的面试官问的问题上呢，还目前还没有到这种水平，还到不了，所以呢你们你们先不用着急啊，另外呢如果说还要说的详细一点的话，其实这样的啊。

呃所有的分带算法，所有分带算法就除了他这种，就包括cms啊这种的，他们使用的用三色标记之外，还要加什么加写篇章，而这one呢是三次了解sb加写屏障，cdc是什么。

c d c是color pointer加读屏障，shen dog是什么，shen door color pointer，加写屏障，好，算法里面最复杂的部分就是这些了，大家呢给大家拓展一点知识面嗯。

你要是想学的时候呢，也可以去网上查一查好不好，ok了咱们大体讲完理论上这个东西了，下面我们来进行调优实战，但是大家听我说，直接实战吧，这些对面试没啥意义，你是在搞笑吗，实战才对，面试没啥意义。

这些才是对面试最有意义的，你可能弄反了啊，好看这里，我们现在来进行调优，但调优的时候呢，必须指定你要调哪种垃圾回收器，我可以帮给你调g one，我也可以给你调他六cm，我也可以给你给你调p加po。

所以咱们公开课上咱们的小伙伴们来讲，大多数人的水平其实多数都没有进行过任何的垃圾回收器的替换，所以多数人用的还是什么呢，ps加po，所以我们先把最简单的调清楚，也只有你把这个能认识清楚之后。

下一步你才能继续往下走，越往后会越容易，这个是最难的，p s加p o是最难的，听懂了吗，越往后是越容易的，你先来定义这个调优到底是什么概念，其实啊调休这个概念呢，很多人就就就就会理解的特别的不到位啊。

这个调优这个概念呢，其实呃大多数的这种面试的时候，总是问你什么om问题，那只是调优的概念之一，好吧，好看这里我们来聊这个调校的基础概念，听我说啊，这个调的基础概念调优呢。

其实啊那个就是大多数问面试的时候都问什么问题，都问这个o o m多数都问这个om什么意思呢，叫out of memory，内存溢出，就是玩着玩着呢，我这个单机玩游戏呢。

我觉得整个这vm呢我开始频繁的b c3 秒钟一次，三分钟一次啊，f d c频繁的f d c或者什么呢，或者直接就崩了，直接就崩溃，好崩溃，完了之后，你个东方快完了，你这时候该怎么办。

你去去里边怎么怎么怎么去找毛病，找问题啊，这种叫o o m，大家听懂意思了吧，那如果说从全面上来讲，到底什么时候调优呢，其实这个调优呢最好是你根据这番的规划先进行预调优，这也是调优的一部分。

优化这般旅行环境，比如说他有时候特别慢，你觉得受不了他卡顿，你觉得受不了好这个呢其实人家没有死，也没有频繁m b c，但是呢他就算不频繁，他也时不时的卡顿，时不时的就慢下来了。

时不时内存就慢慢的变占占占用更多了，有一块内存老师释放不掉，这叫优化环境，这是调优的一部分，还有一个就是解决这个b运行中的各种问题，比如说o o m，这是最常见的问题。

多数的面试多数人在网上说的条条指的就是这一块而已，当然我们今天实战就主要调这叫聊这块儿好吧，对说不定就是代码写的烂，我告诉你，我今天我我我给你讲完，今天那个就今明两天我给你讲完你的面试。

你的简历上会写出来，有过实战调优经验，但是面试官一定会问你怎么产生的问题，我告诉你，你要是不贴近实战的那种，面试官一眼就能看出来啊，写了个list的，有成员不断的往里往里装啊，也可以。

太土了太简单了好吧，我回头教你十种高级的老师给你准备了十种案例，知道吧，你随便挑啊，一定让你在面试官那过得去好看，这里我们一步步来，先针对ps加p，这三条的第一步。

我们先了解jvm的长的那两行参数，等于说那个老师这版产品平行参数还有什么可了解的。

好，先注意啊，我这里环境全是linux，咱们后面聊调优，你不要跟面试官聊，我是在windows下做调优，面试官直接大嘴巴子呼上去，你就可以撤了啊，mr demo，我是面试官，这十种会记下来啊，没关系。

我们vip还有十种，一共有20种，哈哈哈哈，windows咋了，what这个还要我讲，有多少jdk是跑在windows上的，你告诉我，好看这里啊，我们先来聊呢。

就是这个我先先认识调优的这种最最基本的一个操作，你得认识java命行参数该怎么玩，平时呢就是直接什么java p就直接开执行了，但其实java有好多明狼参数，变量参数呢本身有好几种，直接敲，你没看出来。

以横杠开头的一堆参数，看到了吗，哎conserver server模式执行gc p class path啊，刚那个什么version啊，这些个说version啊，杠x等等，呃。

这些呢就全是这种叫做java的标准参数啊。

这些叫标准，这些哪个版本都有，哪个版本都能用，这叫标准参数。

非常标准的好，还有一种参数把windows给干掉。

104点，还有一种参数就是这个参数看到了吗，这个杠x杠s开头的叫print help on nonstandard options，跳一下java杠x回车，你会看到你杠x开头的又一堆好。

这个参数叫做非标参数。

看这里特定版本hobt支持的特定命令版本变了，这里面的x开团的命令有可能会变，所以这叫非标。

这个大概也有个几十个吧，像我在那个这个那个前面讲完的时候给大家讲过，这个就是mixed到底是优化的，还是说是那个那个纯纯纯解释的啊，当然还有纯编译的都可以，这两个参数这里面有几个参数呢。

我希望大家记一下，大概记一下，就可以了，就这个参数这两个参数，这两个参数我觉得呃作为调优，或者说作为那个设定，你这盘参数来讲，基本上是属于必用的，自己自己看一下x m s后面跟一个size。

xx跟一个size是什么意思呢，said initial java heap size啊，所以最初始的堆大小maximum知道吗，hip size最大堆哎，刚开始的队最最和最大堆。

当然还有m x m n之类的，就是设年轻代好看，这里。

到现在为止我们接触的参数曾经后悔，你一看包括标准的，包括非标准的，加起来就几十个吧，哎可是很不幸的是，我们大多数的调优都是要以杠xx开头的参数，太不行了啊，那么杠x x开头的参数到底有多少呢，不好意思。

你找不着他有多少，你不知道他有多少。

他没有，他没写出来，有同学说有没有一个列表给我，不好意思没有，i'm sorry，没有有没有文档给我，没有，你说oracle得多恶心，简直能他妈气死人，就当初找找这些文档，找这些命令，没有没有文档方案。

没有全的没有，这两天数三考，这就这就算比较全的了，我给你自己去看就行了，但是也就讲了几十段而已，大家听我说有一个参数实际上是能够把所有的全打出来的，看这里这把，装x加上flag规则可能吃啊。

这个参数呢大家可以记一下，这个参数呢叫print flies with comments，什么意思，with comments，解释把那些个左右才能打印出来，并且带着解释给打印出来哇，有这个太爽了。

哎很不幸的是，只有第八组版本能用，所以同学们下一步你要干嘛，哎自己去编译一个jdk，好不好，编一个jdk编译成debug版本，你就可以玩了，好那位同学真的就不行了吗，别着急，还有还有办法。

大家看这里，这个杠4s，这个print torflags，这个不行，还有个办法叫什么呢，叫print，flags，then print flags，这两天睡得太晚了，脑脑筋有点不够使了，对没错。

就是他啊，来print flags final，还有一个呢叫print flags initial，哎，这块意思是什么呢，就是把所有参数都给打印出来，它的初始值是什么，就默认值是个什么。

而flex final指的是什么，就是你最终设完了整个整个你的虚拟机起来之后，那些个参数值到底是什么，来我们看看它到底有多少，别没了，wc跟l呃，也不多，700多个而已是吧，不算太多。

也就700多个唉，所以为什么这边调有比较值钱啊，大哥，哈这就别背了啊，教你最常用的，因为在这个文档里头呢，每一个常用的我都给你列出来了，看到了吗，就说两分钱值不值吧，太他娘的吃了，谁都觉得吃。

那我下一步教大家使用常用的这种面料参数啊，我们直接用一个比较复杂一点的案例吧，这个案例还是太简单了啊，因为细节特别多，我略过了很多，我们直奔主题而去好不好，如果时间够的话。

我可以给大家讲一些什么三色标记这一类的，比较有可能比较长，被考到的这些算法啊，这个明天看，明天时间好，大家看这里啊，呃在这里呢我们有一个代码，我们是我们测试用的代码文档分享吗，分享啊，放心吧。

当然分享了，老师分享的老师是特别喜欢分享的人，你没发现吗，各种都可以分享啊，没有没有问题好看，这里你知道分享一个知识是学这个知识的最好的方式，好看这里啊，我们来看这个小程序。

这个小程序呢是模拟了实际当中的一个案例，这个案例呢你完全就可以写在你的简历上，跟面试官这么说，但这个案例是相对复杂啊，可是我我就说越简单的案例，那那个面试官的肯定觉得越没劲。

所以你举案例一定要举得稍微复杂一些，这个案例你要好好消化一下的话，是可以做到的，好这个案例呢是什么呢，我们我们大致读一下这个代码，这个案例呢首先我说一下它的背景，这个背景是什么呢，是有一个程序。

这个程序呢叫做风险控制的程序，风险评估，风险评估什么概念，比如说我们银行里头存了一堆人的信息，好这个人的信息，我现在对他进行评估，如果我贷给他10万块钱，我回回回不来的风险到底是多大的小额贷款。

还有这种金融这方面的这种的风险评估模型特别多，那呃对它进行风险员工，当然这里面他个人的资料呢会非常非常多，我会把他的资料各种各样的都拿出来啊，你说他是什么时候花过支付宝，什么时候还过支付宝。

花了多少钱啊，今年挣了多少钱，工资是多少啊，什么乱七八糟，各种各样的信息全有，然后呢在里面把数据拿出来，通过我一个模型对它进行评估，看看我能够给他贷10万，还是我能给他贷100万。

还是我说我一分钱都不敢贷给他，因为他的信用太差了，好了大家理解这个背景了吧，来get到这个背景的同学，老师扣一下，面，我来解释这个程序是怎么写的啊，那我这种语怎么写的呢，这种语是这么写的呃。

比如说我就只考虑他的信用卡的信息，这个信用卡呢我就模拟了一下，它的名字叫cui infer，有同学可能在这里会抬杠，老师说老师你给我讲半天全都是模拟的案例，来大哥，我就问你。

我怎么样才能给你弄一个真实案例去，我告诉你真的弄不出来，别的我都可以给你弄一个真实案例，只有这个这种dc的模拟，我实在给你弄出真实案例来，为啥其实你想想，如果说人家一个电商在那里运行了好长时间。

然后才产生了一次这种o o m，我怎么去把那个电商给你搭起来，然后再模拟给你跑个一个月，两个月给你弄，弄出那个o m来，所以好多时候只能模拟，但是没有没有关系，你只要听到这个魂知道吗，就听话，要听音儿。

看东西，要看这个活儿，看这个根儿什么东西，你只要把这个理解了之后，回想你自己的做过的项目，你完全可以把它套上去，一点问题没有，不在这种金融公司这么吹，明显假呀，这不是吹。

你能不能把这里面的案例稍微换换呀，你就这么弱呀，大哥这学传统的教育都学死了，就得老师拎着你耳朵从头到尾给你灌进去，你才能够接受是吗，看这里啊，这sim卡信息cart info。

比如说这是他花花的某个钱吧，big decisional price，然后呢名字年龄啊，这个生日等等，总而言之里代表的是他个人的一些信息，当然这信息我再说一遍，实际当中会非常复杂，根据这个信息。

我会计算这哥们儿诶到底是能适合带多少钱，有没有风险，然后呢我们这是开了金粉，从哪里来的呢，肯定是从数据库里来，所以呢我做了这样一个叫get get all card info。

就拿到所有的cut info这样的一个信息，从数据库里头拿出来，放在一个list里面，ok我每次拿100条，我就拿了100条下来，把这个东西放到这个list里，返回回去，别抬杠啊，不想听也可以待着。

为什么要走呢，不想听热热场嘛，好看这里下面我对这个模型对它进行匹配，叫model fit，看看是不是能对它进行进行匹配，首先拿到这个list，我从数据库里拿出来一堆嘛，一堆模型拿到这个list。

接下来for h每一个做循环抑制的时候怎么干呢，我用一个lamba表达式，然后用一个线程池，schedule with fixed delay，过一段过一段时间之后。

每个人过一段时间之后才开始执行我这个方法m方法，m方法呢就是具体的来适适合呃，来匹配，来匹配我们整个这个这个这个程序的呃，他那个模型的这个过程啊，m方法，这个方法呢我没写任何内容。

因为这个匹配过程呢就没什么值得写的了，就可能匹配不匹配就行了，我们调这个方法就是每个都拿出来，按照一个固定的时间往后delay一下，然后就开始一个一个一个一个进行计算，接下来干了一件什么事呢。

我在我的主方法里面，主程序里面我起了一个线程池，threat to executor，呃，这个线程池里面的参数你要没学过的话，你肯定理解起来也费劲，我就暂时不跟你解释了，很简单，就是50个线程的线程池。

这是他的拒绝策略，就这意思啊，50个线程线程池开始运行，然后呢它就不停地从数据库里拿出那个一个list来，然后不停的进行model fit，每隔100ms拿100条出来干事。

每100个每每隔100个毫秒拿一拿，拿100 100条出来干事，就这么一个模型，这个程序呢看上去呢是没有什么问题的。

但是运行起来问题就大了，好你们不要给我带节奏啊，什么老师讲的快一些，慢一些的快，对你来说，你基础比较好，你就稍微照顾照顾基础不好呢，对不对，慢了也没有关系，你这人听上去总是总是会有收获啊。

当然这个bug呢我先不跟你说bug到底在什么地方嗯，回头你拿这个文档之后呢，你可以去查一查好不好，我们来执行一下，执行一下这个小程序。

什么编译啊，乱七八糟的这种过程我都不给你演示，已经很给很给你省时间了啊，莫急好，大家看这里啊，为了让程序能够，运行的时间稍微长一点，能够多演示一些命令，所以我把这个内存的条件比较大，还是200兆。

但实际当中要比这大的多，如果你那么大的话，我估计运行两天才能看见问题，所以咱们必须得稍微调到200多小一点，刚x m s最小200兆，最大200兆，来同学们问问他这个问题，为什么最小和最大是一样的。

为什么，这个大家能能理解到吗，能get到吗，唉避免没必要的扩容和收缩，你只说说扩容了，你一个最小的是这么小，一个最大的事这么大，那么当你不断的在里边儿产生对象的时候。

这个m得不停的花资源来计算我下一步要扩多大呀，下一步扩多大呀，然后不用了之后呢，下一步缩到多少啊，下一步缩到多少啊，所以你如果确定这个程序就会用这么多内存，直接给他指定，这也是一个小小的优化方式吧。

好像xx叫print g c，print g c呢，这个参数比较简单，就是把gc的过程给我打印出来，然后执行这个小程序回收，或者再起一个终端，好每天来看这个小程序，现在已经有了gc的这个呃日志了啊。

gc education failure，多少兆多少兆啊，花了多少毫秒，没有关系，一会儿我来给大家解释g c的日志，今天没有的话，明天也给大家解释清楚啊，莫及，ok jc开始了，现在我们想象一下。

开始闭上眼睛，开始你的想象，这个程序是你写的程序，闭上眼睛想啊，所有人都close your eyes，来把你的现在在你脑子里开始浮现这样一个场景，你写了这么一个程序，把它放到了线上。

然后运行了很长很长时间了，好谁会发现这程序有问题，谁呢，谁会发现成语有问题呢，客户不我跟你说，客户只是会反馈比较慢，比较恶心哎，一定是运维同学们对报警系统对你们说的没有错，所以在你实际的工作环境之中。

比较好的公司会配专门的预警系统，运维监控系统，监控系统会发现一些问题，那么监控会发现什么问题呢，看这里我们来看它的问题出在哪，交大一个命令叫top，这个命令比较简单。

就是列出来目前整个系统之中对于系统资源消耗比较高的前面的程序，当然网管的系统一堆一堆的，不一定是这个命令产生，也有可能是报警产生的好，你仔细看，我们有一个1239的这样一个java的程序。

它是占了22%的cpu，11。4%的内存，有同学说不高啊，忘记，那我再提一个终端，克里一个简单的命令，我估计大家应该都见到过gps，这个大家知道什么意思吗，就是列出来我们系统里头的那些个java的进程。

有哪些个，我们会看到一个java进程叫做t15 f g c就是我们的小程序，它的进程号是1239，好看，这里就是他，所以对于网管来说，它会观察到时间长了，它会观察到这么一个现象，什么现象呢。

就是这哥们儿这个程序现在注意看啊，它是11。4的内存，再再执行一遍，还是美村的增长的有点慢啊，算你狠，还11。4，稍微等一小会儿哈，内存它就会不断的增长，因为这时候还没有占满我们200兆还是挺大的。

我跟你说这个小程序的bug特别恶心，这个小程序会引发什么样的情况呢，它会引发有可能啊，你看啊，现在已经变成13。7了，看到了吗，刚才是11。4，现在是13。7，营长了，啊sleep太久了对啊。

先不管那个是因为我内存设的一个比较大好这个小程序啊，他会把那个你平时看到的程序的可能会产生的那些严重的后果，都会有可能在这个程序在产生啊，他有可能会最后的结果是频繁fdc，知道吧。

也有可能最后的结果是oom，而且这两个结果是不是固定的，不一定会产生那种这个小程序还是比较恶心的啊，所以我是拿它来做典型好，你看到了这个内存呢在不断增长，并且呢它不会回收，如果一个内存它占的比较大。

但是它过一段时间之后就又少了，这个就没有关系，但是这个不是这个从11。4涨到13。7，它不会往回走，知道吧，那好了，现在，你的网管就开始来找你了，好你闭上眼睛，想一个美丽的网管走到你的面前，然后跟你说。

哥们，你写那个有bug，然后啪一大嘴巴子给你抽醒了，你弄的这个内存都快占满了，什么情况，看现在是15。3了，你让他容忍他走下去的话，很快就是90%多99了，我就我就我就不等到那时候了好吧。

那这时候你就说啊，大哥网管都是大哥，对不对，那网管都是老大，来大哥，你能不能给我开放个权限，让我上去看一眼，好网管，这时候说可以吗，如果是在一个特别牛的公司里头上了线的系统，绝对不让你不让你上去。

你放心吧，如果是这种情况，你就只能在你做做一个模拟环境，然后在那里不停的压测来模拟设计环境，看看会产生什么，这个我教大家啊，以后当然我们解释你能开始能够能够执行的到位，或者你交往管你来帮我执行好吧。

也可以，所以现在比较牛叉的运维都是会jvm调优的，你懂吗，真的一点不夸张，比较牛叉的运维，j vm调优，mysql调优，各方面的tom cat调优，他们都会好看，这里，我们下一步呢说要定位出这个程序了。

你已经知道这个程序有问题了，那下一步你你怎么去对待进行定位呢。

我教大家几个比较常用的命令呃。

g p s我教过大家了啊，也不说了，我们来看这个这stg stack呢其实跟我们现在这个程序的关系并不大，但是我教给大家好，this deck是什么东东，just de的意思是打印线城站2239。

把这个进程里面的线程暂停打印出来，全打印出来了，我就不一给你念了，这个这次带的命令也是非常有用的，目前解决我们这个问题它没有用，但是它本身是非常有用的，你要理解这个jdk呢他干了些什么事。

这大哥干了些什么事呢，如果我们挑一段读一下的话，你就会发现了，这次大概干了这么件事，他说有这么一个现状，现在名字叫pro 1 thread 33，然后呢他就是自己内部的标号40priority呃。

优先级操作系统的优先级，tai d n i d waiting on condition，正在等待某一个条件，waiting on condition，这个thread的状态是waiting，正在等待。

因为我们有好多好多的县城，因为县城市里有50个，还记得吧，他正在进行等待，下面是这个县城里头呢，诶调用了哪几个方法，pk方法，这个方法，那个方法等等，同学们，你们想想，看来我们动脑筋想一下啊。

我来找一个比较标志性的行程，我们来点clear，嗯这是一个rable的线程啊，这叫做attachener pthread，49啊，48等等，内线整好在最后面，这是我的main线程，看到了吗。

我们的主线程它的state是time waiting，正在等着sleting，正在sleep，就是刚才我sleep的时候，正好把他这个先锋站给他抓下来了，然后呢。

你看啊这个may may方法的调用了sleep方法，对不对，main调用了sleep，但是sleep如果再调别的，还会一层一层往上走，所以这个jdk干了一件什么事，大家我相信大家能get到了。

这次de是把每个线程揪出来，然后他会把这个每个县城里面哪个方法产生的这个县城，我这个县城正在执行哪个方法，这个方法又调用了哪个方法，又调用了哪个方法，这个现场的状态是什么，是在waiting还是在干嘛。

还是在running，还是在time的waiting，还有如果他能在waiting的话，它调用的是哪个方位上的，正在waiting object weight好，他正在wait哪个锁。

这是那个锁的具体的编号0x是没有是什么，所以这代表有什么用，来同学们告诉我，当你看完了他的输出之后，这back将来对你调什么样的问题会有用，能够猜得到吗，对检测思索对，没错啊。

所以如果你的程序有可能会产生死锁的时候，用什么来做jdk。

对this deck，当然这个this deck呢对我们现在这个程序没什么用，我教大家而已啊，而且你这次带了产生之后呢，你要观察它正在哪个锁上产生的死锁，这个锁是一个哪个哪个类的对象。

你就很容易定位出来你哪个程序是产生思索了，我也给你写了个例子，自己去读好吧，好这里能再给大家扩展一个小小的知识点，大家读过阿里的规范吗，巴里的规范有一个华山版，最新的。

阿里的规范里头它有一个规定现成的名称，尤其是线程池里面的一些县城，要给他一个有意义的名称，都要写有意义的名称，当然这个你要是没学过老师的多线程高并发，你也不知道怎么写，有一个名称。

因为你得定义这个我们先不管，在阿里的规范里头，要求规定必须的，每一个县城都得给我写一个有意义的名字，你不能随便瞎叫，为什么能猜，能猜得到吗，原因是什么。

方便定位问题，你比如说这个县城，他名字叫p1 thread一他他他现在到底干嘛呢，我靠我不知道啊，阿里产生的那种这代产生像他那种都是就是成百成百成百个县城，你从这县城里头要揪出来哪些个有问题的类似你好。

所以这文档到时候去哪领，上网搜吧，这文档去哪去哪找份文档还得让老师教你啊，哦看这里。

有人就是这四个stack杠l，这杠l可以搜索特定的思索情况，并不是所有的情况他都会嗯嗯弄出来，所以你最终能该读还是要读啊，这个没有这个没有招好，就要带这个命令，我们再来看下一个命令。

这个命令叫这这infer。

看这里这一份比较简单，这infer呢就是你那个目前这个县城啊，这个这个这个java进程就什么1239吧，好这个进程呢它的一些个虚拟机的一些信息，哎你比如说你的这个变成他的run，他们的名字啊。

他是谁提供的呃，它的各种的class lor，class path啊，包括它的一些启动的参数，就这些这些信息，这是用jifer可以来做的啊，你读一下，你看看它的这些参数到底是怎么做的是吧，年轻代表多少。

老年代表多少等等，读这些参数的，这里面其实有两个特别好玩的参数，我要有时间弄啊，可以给大家讲一讲，这里面参数是不是跟cm是跟那个那个那个什么有关系的，跟那个垃圾回收有关系的啊。

这个也是面试第六个比较恶心的问题，大家先记着吧，如果我忘了的话，找时间问我，我给你讲给你们听。

就是这道面试题，这道面试题，为什么压缩指针超过32g会失效，这是一个特别恶心的。

没问题啊，我看这里，呃这个参数其实这个命令呢也就是读一读而已，没什么太大用处，我们继续看。

大家看这个j c杠c就观察动态，第三个情况，这个是特别有用的，如果你在没有更先进工具的时候。

你用这个名字来干涉这dgg c j gg c1239 ，就是他会干嘛呢，他会给你说说这些情况，这些这些情况包括什么呢，包括你年轻代占多少，老年代占了多少，被占用了多少，去掉了多少。

survivor 0占多少，一占多少等等，这些信息，只不过这些名字显示起来的让人读起来特别的不爽，可读性特别差，当然jc杠t z呢，它还有一个，参数是可以指定每隔多少毫秒，你给我输出一次。

每隔多少毫秒输出一次，这样的话呢你就更有意义了，大家记得有人没东西就行了。

还有同学说java东西太复杂了，我只想到现在你们觉得很复杂吗，真的觉得很复杂是吗，我告诉你，你去写那个就我家姑娘半天就能学会的，那个小孩们编程用的那个语言，那个不复杂，你知道吧，但是不值钱。

那个叫scratch，好看，这里还有一个命令叫j map好，关于这个命令，我们明天再讲好吧。

ok有同学说了，老师你讲了这么多命令，感觉都不是很友好啊，不是很友好的原因确实是他初始的这个命令行用起来相当的不友好，当然有同学这时候就会说，老师有没有图形化的东西，有没有来，同学们告诉我。

如果有什么问你，你当时怎么调优的呀，你说你挂了一个图形界面，这个图形界面是什么呢，叫做j visual vm，有没有呢，当然有，有的是，一堆啊，我告诉你，我给你打开来看看，嗯这个。

这东西呢我得给你抓住主线，千万别跑偏了，跑偏东西就多了，主要是主线没有那么难看，这里这dk一点八，java自带的工具，这vio v m，比如说，我们要是监测我们某一个java进程啊，我把它，本地的哦。

我的我的那些教育进程都没怎么起来啊，这个时候呢哎你就可以本地的进程，你就可以跟上去用这种图形化的来进行监视，看到了吗，哎堆战多少了，matter space占多少了，cpu占了多少啊。

哎装了多少个class啦，整个整个县城进城的这种活动的总数了等等，现成的抽样，还有呢抽样器，我现在有多少个，我现在有多少个实例啊，什么东西有多少个实例啦等等，全都显示在这里，爽不爽可以吗。

我要教你们这个可以吗，好你要跟面试官聊，说我用的图形界面调优，面试官一个大嘴巴子呼上去好吧，你见过你们家服务器有的有有在你们家服务器上装图形界面的吗，有没有，没有了，哎我看有同学已经说了。

不是可以远程吗，没错这是你们家的linux服务器，然后呢，京东的你为了远程进行对它进行监控，开了很多很多的端口和协议，以便我们的j vu vm能连上来，我问你多少个控制安全的网管，允许你这么干，有没有。

把端口给你打开，所以你跟面试官这么聊，面试官要是稍微理解一点，就告就告诉你不专业，听懂了吗，这肯定不行，这是为什么我就教你命令行的原因哦，那有同学可能会说，老师我把它当不下来，你要说把它当不下来。

大嘴巴子准备好吧，直接就给你一大嘴巴子，当不下来，你知道一个当铺下来的文件有多大吗，大哥吃过吗，你知道在你dump的时候是需要执行一个j map命令，你的整个程序要暂停的，知道吗。

一个实际的这样的一个dmp文件，在那种性能稍微差一点的机上做分析，要花一天左右才能运行完，我告诉你，什么时候都可以dump，就只有一种情况，你们服务器崩了，只有这种情况下，你可以dump。

除了这种情况之外，你说我他正在运行呢，我给他当不出来，可以有这样的命令可以做到，但你不要跟面试官说，你是这么干的，难难太难了啊，告诉你，好看这里，那这人怎么办呢，当然就是使用命令行，有同学可能会说。

那老师这么一大堆的这种图形界面没有用吗，我在讲vp的时候。

也讲过这些图形界面，但是呢我告诉你这个这个不是说没有用，如果你说用过图形界面，用在什么地方，听我说在一种环境之下，就是上线之前的内测，比如说你游戏服务器放上去，在这里跑着，远程挂个界面。

甚至在这里开个图形界面都没有关系，你挂上他监控着他，这时候玩命给它做压测，看看它会会不会产生一些我们预料之中有可能会产生的一些问题，所以在压测上线之前的大量的压测好图形界面上没有问题，听懂了吧。

那get到同学给老师扣一，ok注意我接下来讲的东西很多都是真正实战之中的人们怎么用的啊，我告诉你，网上很多讲的呢是那个理想化的，听懂了吧，非常理想化的，看这里，这哥们儿已经开始复dc了，不停的复dc呃。

我们先不管它，下面我们来看呢，在实际当中我们用什么，实际当中呢我推荐使用一个工具，这个工具呢刚才有小伙伴已经打印出来了，他为了博取我的注意力，我已经看到了这个工具叫office好。

关于这个工具，我觉得我不想在这里跟你专门的聊他怎么安装这一类的。

好不好，没意义，office。

这是阿里的开源，阿里开源的一个工具，哎我去还防不了。

啊这个我就不给你们看主主主界面了，显得有点慢，你们自己去搜office，这工具一诞生之后，挺好用的，非常好用呃，也推荐大家使用那个阿里内部，他们也他们也用好吧，没有阿芬怎么办，运营不让装。

如果运维什么事都不让干，那你就只能用刚才我给你讲的特别土的命令来看，听懂了吗，那个都是java自带的，但是assets是可以装的，assets可以装，是为什么呢，你不用开任何的端口号。

你给我装一个程序就完了，哎，dos安装运行下载，我不想跟你讲了，可以吧，可以的，同学给老师扣一下载安装我不想讲了，ok，这个你还要老师讲的话，有点过分了，就看这里，我都是都10。20了。

我们把阿斯起个头，然后呢阿瑟斯的预习，大家伙呢也可以自己装上，明天呢我再来讲详细的过程好不好，同学们，我先给大家起个头，鸭子怎么怎么玩呢，我装好了之后呢，解压解压开之后呢，它是一个，这么说的叫什么b3。

14版本cda星连，然后呢，我们怎么去运行它呢，这么来运行最简单的运行方式，javon j执行一个占文件，哪个文件呢，就是office不点炸，office注脚下，这是一个纯命令行的东西。

好ok他找到了一个java process，我们把它attach上去挂上去，这个它的编号内部编号是一，所以我们敲个一，它挂上去了啊，try to attach，想attach上去不行。

我这程序是不是已经挂了，我怀疑，居然也踏不上去了啊，啊已经out of memory了啊，sorry，这个挂不上去了，你知道我重新把它起了，lear，先把这东西起来，我重新运行office，挂上去。

好当你看到这个界面的时候，说明已经启动，并且挂到了你的java进程上，你看到了office目前正工作在1459这个进程上，好，到现在为止，你可以用用office来干我刚才给你演示的那些命令行干的事儿了。

除了具备那些命令行的所有的功能之外，除了一个命令行工具，就是这个j map，这个g map us是没有覆盖的，除了他之外，其他的全都是aos里面全包含了，因此在alice alice里面。

大家用了一个工具就已经足够了，以后就在它里面玩，所以你说你以后写到简历上的时候，说我有个实战调优经验，拿什么调的懂，他听懂了吧，今天已经10。20了，咱就不继续了，明天我们继续好吧。

呃今天呢我留给大家一些大一的时间，如果大家有什么问题呢，你都可以问好吧，随便问啊，这v的所有问题随便王老师这招呼，老师长得像岳云鹏，我去，你能不能说我长得像，岳云鹏也太那什么了，点哈哈，开玩笑。

岳云鹏就越不，啊别着急，你们那我去好那个那个技术问题，技术问题慢慢聊啊，你别别刷，哎呦我的妈呀，别刷，现在老年代一比二一比三一比二，导致最近有出书，我们自己写的内部的那种呃。

给学生们用的教材多久一次正常，这个不一定看你内存多大，还有你的应用的情况，有的什么一次都算正常，有的可能一一小时一次都算不正常，看你内存多大吗，你你一个你一个你一个天文广场，要说你一小时就一次。

你自己想想它正常吗，不可能啊，一小时就被他灌满了，他能正常吗，怎么调优om了，那不叫调优，那叫调错了，做的过程，明天我讲给你听，我教给你怎么把它定位出来，安全点吧，杨怀大家别刷了。

杨怀都已经刷过好多遍了，是我们的v i p中p，因为他是杨玉环的弟弟，名叫杨环，开玩笑开玩笑啊，呃诶哪去了，vip中p安全点cp，换的什么概念呢，我先给你，我给你讲大体的概念，大体概念是什么概念呢。

就是说你看啊，这这是我们的正常的工作线程，我们的业务逻辑线程，我们的业务逻辑要让它停下来，我们来我们垃圾工作线程才可以启动，对不对，这是s t w，然后再停这个现场的时候，并不是说一刀切，二话不说。

夸机锁全从我cpu上给拿走了，直接把我gc gc线程挪进来开始运行，不是那么回事，为什么呢，因为有的线程你比方说正对这个对象上锁呢，上一半能让他停在这儿吗，不行，所谓的safe point指的是什么呢。

指的是我们这个县城得停到一个合适的位置啊，停下来的时候呢不会对前后的一致性产生影响，这个叫c point，好吧，写屏障也是上锁嘛，这个写屏障注意就是说。

因为m里所提到的读写屏障和我们平时所说的wallet，tel的那种内存上的那种内存屏障是完全两个概念，这个读凭证写篇章的意思就是说什么呢，说的是当发现这vm在执行某一种操作的时候。

我跟上去做一种背后的操作，这个解释起来比较抽象，我给你举个例子，你就知道了，你比如说看这里，我们说一个复制算法，a对象指向了b对象，然后b对象所在的区域要被回收了，它被回收的时候，它怎么被回收到。

它会把它复制到区域里去，不管是survivor是什么，把这个对象复制过去，那么同学们，你们想一下这个地儿的引用得跟着变，原来我这个地址值是指向这的，我最新的地址值得指向新的，get到同学有点扣一。

这个阶段听懂了吗，那指向新的是什么意思，注意这个过程对我们程序员的调用，正好要调用这个引用怎么办呀，你这个引用正正在变的，怎么办呀，这个时候就是在他挪动了之后，相当于在内存里面写了个新东西。

然后这时候产生一个屏障，屏障的意思就是在他挪动了之后，我马上跟进跟进做一件什么事儿，把这块儿给你更新了，这块儿同步性的给你做个更新，就是任何一次的垃圾回收，在挪动了对象之后，原来的引用里面的值进行更新。

但是这个更新过程对我们用户是透明的，你是看不着的，你还可以直接访问这个引用，这个东西叫post right barrier，叫他写后的一个评论，等他写厚了之后，顺带的做一些jvm不该做的一些操作。

这个叫屏障，这个叫post right barrier，叫完成完完事儿之后的写屏障，这点get了是吧，为什么阿瑟为什么屏蔽它，没有屏蔽他，只是没有实现这个功能啊，现在290废弃的原因cms毛病居多。

我刚才也说过了，他一旦碎片化完蛋了之后，我告诉你垃圾回收就卡死你了，用serial old的垃圾回收，你自己想想，你就想一个一个60多岁老太太，从头到尾他扫天安门广场服务器，啥事都不能干。

其他县城全都给我看着，都在天门城楼上给我看着，那什么时候都把老太太扫完了，程序继续，你们别刷没刷没刷，怎么判断，我说先别动g c，怎么判断什么时候s t w重新标记，你这句句整个句都不通。

重新来重新问文档的这些应该都有吧，这个文档是公开课的文档，能让你在简历上写上有一定的经验，能让你入个门呃，很多的细节这一篇文档也是装不下啊，我因为那个我给你讲一个g1 ，给你讲一个z d c的话。

没两个小时基本够呛，拿不下来，视频结束啊，配合docker部署方式调测试，可以用这个吗，可以啊，你也得占内存啊，你占内存它它它产生o o m它还是还会有问题吗，没有jdk，jdk依赖如何调用是几个意思。

什么叫jdk依赖，没听懂，压缩指针32g不是哦对，想跟大家讲这个问题了，首先首先首先你们知道什么叫压缩指针吗，先说这个大家知道吗，比较复杂，这个问题讲完，估计今儿就可以下课了，可以，嗯来看这里啊。

你挑一个命令，随便挑一个java杠x x x，in flags就是交易命令之后呢，你会发现它有两个参数，看这里是什么呢，网上很多文章把两个混在一起讲，我告诉你这两个不是一个事，仔细读一下他的意思。

这个单词啊就是压的意思，它是一个词根，com home是往里压，compress，comm是往里压的，意思是前缀，然后compress，比方说还有什么啊，impress这个是往内压一express。

对外表达，其实它本质上就是一个词根，好像好像好像讲远了啊，sorry，那个，有机会再讲英语，不讲哪来的，这个compressed叫往内压压缩压缩指针，画个图，当我们new一个对象的时候。

你有一个object new出来的时候，内存之中这个object分成四段，一段叫mark word，记录的是锁的信息和gc的信息，以及还是code叫mc word，这第一段占八个字节。

耳朵叫class pointer，这个class pointer是什么概念，class pointer的概念就是它会指向我我数的那个类，你比如说我new出来的是t，它会指向我的t一点，class好。

这个东西叫class，好这个是被压缩过的，正常的情况，一个64位的系统，你想想看那大腿想想也应该知道，指针长度一定是64位的，也就是八个字节，如果八个字节放在内存里的话。

你的整个对好名的呢多占了很多内存，因为你的内存呢也就那么小，四个字节装进去，它的寻址，四个字节的寻址已经四个g是多数情况下就够了好吧，所以呢这个时候呢他就给你压缩了，这个指针是多少呢，是四是四个字节。

下面这个呢是你的instant data，就是你的那个那个那个那个成员变量装置装的部分啊，你里面有个成员变量啊什么的都装，这这个叫padding，叫对齐，pdd对齐的意思是我们要对齐八字节。

就是如果你整个对象不能够被八图，往往前对你，比如说你到这，你这个对象是12个字节，不能没法整除，怎么办，一个四变成16个字节，能够被挖整除，这个叫做对齐，就是最后你这个对象大小一定是能够被八字节整除的。

这是一个最基本的点，也就是64位，因为你jvm的寄存器，机器的寄存器64位正好撞八个字节，所以特别合适，效率特别高，jvm读一个数据的时候，64位的八字节对齐，当然这里面有个参数。

你可以指定四字节还是16字节，随便你指定是默认八字节，get到这里的同学给老师扣一，好compressed class pointer指的就是把中间那个pointer那个指针给它压缩。

从八字节压到四字节，后面这个compressed opo全称叫ordinary object pointers，普通对象指针，object pointers，普通对象指针的意思就是说在你的成员变量里面。

如果有一个比方说spring name name等于一个字符串好，这个指针占多少，体压缩的情况占四不开，压缩占八，是压缩这个压缩指针有一个限制，这压缩指针在你内存超过32g之后自动失效，同学们。

如果你们有谁的激情，真的有32g的内存，32g以上的，你们自己都有实验什么时间吗，就是你啊你做这个实验，这个实验怎么做呢，我机器没有32g啊，所以我没法给你做，这时间这么来做。

你弄一个特别大个的list，一堆对象装到这个list里，他永远都活着，一堆对象装进去，然后你最后看一下这个list大概整体占了多少个内，占了多少的内存，然后你设你的内存值超过32，你就堆内存超过32g。

你看它占了多少，对内存不超过32g它占多少，我告诉你对内存不超32g，经过压缩，这里面占的内存数如果是555 百兆，那么它超过32g之后，这个可能变成750兆，还不做任何参数指定的情况下，为什么。

因为超了32g这个压缩指针自动失效了，它到底是怎么实现，它到底为什么是32g失效，唉呀，唉呀复杂，讲给你们听啊，最后一个题了，讲完完事啊，今儿就到这儿，就是说你你如果你的内存。

你比方说原来你你干一件事儿，你你们家内存32g啊，三三你们家内存20 24g，然后你觉得呢内存不够使了，你扩了一个16级，结果你会发现呢同样的东西你多赚不了多少，因为超了32g那个压缩指针失效了。

为什么会是这样的呢，嗯是这样的啊，你首先要理解一个指针，如果一个指针的长度压成32个字节，有32位就是四个字节，压缩之后它就四个字节，32位的指针来告诉我它能够寻找最大的是多少啊，二的32次方是四个g。

好这点大家能理解吧，四个g对，那么如果我用32位的指针，也就是说我最多能支持的内存就是四个g多了，我支持不了了，同学说，老师我靠，你照你这么说的话，你三你32级才不支持你，你这个32位指针。

你压缩了32位指针，你这32位指针是怎么支持到32g的，对啊怎么支持的呀，你们想想看，是一个二的32次方，四个g的四个g的地址，但是你发现没有任何的对象都是八字节对齐，八字节对齐啥概念。

你这个你这个你这个对他来说呢，比方说01234567，你放心，这个222的这个位置啊，一定不是个一定不是对象的开头，你能理解吗，因为它不能被八整除，刚才这句话你看看是不是该到了，就说我们比如有个地址。

就是零个字节到七个字节这么多，中间啊，我跟你说，这个字节绝对不是一个对象的，开头八字节对齐嘛，其实我这23 20分钟我可以用，我可以指责这个数吗，我可以，零八哎，我跳着来看看是不是就变成32g了。

细节上它是补零的啊，它是补了三个零，好了就到这里吧，好吧嗯，能盖到盖到盖到算了啊，这个jm知识面不是就支持的东西太多，一时半会真说不完啊，咱们今天晚上就到这吧，明天见，ok忘了就算了啊。

听懂听懂前面就行，明天咱们讲实战就就讲实战啊，一讲就讲懵了，很容易很容易懵啊，明天实战实战很简单好吧，明天再见，拜拜，今儿听不懂的，去预习一下那个office。

系列 2：P40：SPRING源码：08职业生涯 - Java视频学堂 - BV1Hy4y1t7Bo

设置了类型的判断了都有，但是你这是不是已经看到我们的反射，能看到反射了，有了反射，我能不能生成对象了，是不是能了，当我生成完全项之后，当然里面有n多个判断的逻辑，里面很多好，我们就不挨个看了。

这对象我都是要进行一个实例化的，所以东西比较多的那种，能走完吗，那走走走走走吧，走吧算了，对象太多了吧，我们直接返回到这，找一个算的，不是乐队，不是乐队啊，找新方法，哪去了，这。

刚刚是不看到这个方法里面去了，好实现，刚刚是不是通过看到我们这个gb这个这个方法了，就看ab往下点一来，你妈走走走走走吧啊走吧，因为里面对象比较多，他每次的时候都要进行实际的一个判断。

所以这块逻辑是比较复杂的，这麻烦吗，把大家都去找，嗯找一下，目标目标是，来往下走一下，再往下走嗯，看不到了吗，谁打个点啊，直接打到，哪去了好吧，重启一下，所以啊跟原版的时候可能会比较乱，比较懵。

但是别慌，但是别慌，刚刚是不是通过这个该在b方法里面听进去的，是通过改变方向里面进去的，进去之后有毒，该在b然后一系列的一些逻辑判断判断完成之后，把我们的病对象就反射成功了，反射成功之后。

你告诉我是不是意味着我这一块的逻辑就完成了是吧。

能能能看明白吗，这玩意就完成了，到我这块完成之后，意味着我已经具备了很多对应的一些单例对象了，我有了这些单对象之后，我之后取的时候，是不是就可以直接从当前对象里面取我们队的一个结果值啊，明白我意思吧。

好吧。

来这儿做完之后，下面也是一样，一系列的一些循环判断，判断完成之后，看大家说你到底是否是单列了，然后呢如果不是的话，什么叫after singleton distance。

是之后的时候再进行一些实际化操作啊，这也是一系列的一个逻辑判断，逻辑判断是做完之后最终跳到这个finish research方法里面去走完，它不是这个方法了，这些分析里面就很简单了，很简单。

你要做什么事，clear什么东西，然后呢初始化什么东西好吧，然后呢party是问是不是告诉你说我要进行一个呃事件的一个呃广播了，发布一个事件，复杂过完成之后再进行一些注册，就这块东西。

所以你把这段代码看完之后，这个最后一个清理环境的一个环节再往下走，有个reset computer catch，把所有的缓存给清空掉，大概经过完成之后，整个东西就执行完了，所以在刚刚这些方法里面。

这方法里面，这方法里面我说了啊，到东方代理a o p我们这儿没提，没讲到a o p如果讲的话，给我三四个小时之后给我们讲完，你讲清楚，把四条给讲清楚，但是时间肯定是咱们一个半小时给你讲完的。

或者两个小时给你讲完了，明白我意思吧，但是这里面我希望你能够了解几个核心的步骤，核心的步骤，什么核心步骤，看着啊，在我们当前这个reflesh这个方法里面，这个方法里面你想想看了这么多方法。

我也给你们画了这样一个图，这样一个图，你告诉我哪几个方法是最核心的。

那把就恶心了，我们一起框一下，首先第一个方法，这话抓不住很重要吧，只是为了通过获取我们当前什么，是不是那个工厂定工厂吧，所以这一步是非常非常重要的，这是第一步，大家都记住了，第一步好吧。

第二步还有谁还理方法，是不是这个方法比较重要，干嘛来着，用来执行我们对应的什么呢，叫b单腿cos coser，是不是原来一个数据逻辑这方表述了吧，第三个把这方get到这干嘛的。

这是我们的be post processor，是不是这块的一个逻辑了，是不是意思是这块东西好吧，这做完之后再往下看，还有什么方法，是不是在这一块了，这是我们完成整个实例化的一个环节，实例化的一个环节好。

因此你要想明白一件事，如果你要看这个refly方法的话，第一个第二个，第三个，第四个，这四个方法你是必须要能够看明白的，必须能看明白好吧，你看看第四个方法之后，中间都是些细枝末节，都是细枝末节。

所以把这些东西看明白啊，把这个看明白。

如果你还是找难理解的话，怎么办，来看一下我刚刚给他画这个图哪去了，这图里面是怎么做的，这里面有些被动的一些说明啊，这就说明，然后呢在右边这块我详细画一下，每个步骤里面做什么事，第一步叫资源定位。

虽然定位，第二步叫初始化的一个入口，第三步叫准备的一些基本工作好，第四个叫构建定factory的一个入口，是不是叫reflesh be fathy，第二步干嘛呢，就开始加载并对象，然后解析我们乘号文件。

乘号文件解析的一个入口或者盗墓对象，解析我们的长门配置文件构建，并在finition到完成之后，下面又是一系列一个出了金eb 5应该怎么做一个处理，出完成之后，下面就是一些分散的一些具体步骤。

明白我意思吗，好吧，下去之后你可以看一下这张图，这边的类对象，我东西写好了，方法都写好了啊，一样一步一步去捋这些东西，一定要去旅，你别指望说老师你讲一节课，我就能把这东西听懂，我告诉你，我办不到。

臣妾做不到，明白我意思吗啊，但是但是你听完这节课之后，这节课之后最起码这个图你应该是能接到，就是说我刚刚之前说这个图，说这个图我们刚刚不是验证过了，虽然那个验证的过程不是特别详细。

但是这个图有没有验证过来验证，能听明白，同学老师扣波一验证过了吗，验证过了吧，是不是就是这样一个逻辑，有了这个逻辑之后，你是不是只需要去抠我们对应的一个细节就可以了啊，但是你要知道整体的一个脉络。

有了整体的脉络之后，你再去看我们对应细节的时候就会好很多，会好很多啊，你说我老师从第一行开始往第一行，一行一行往下看，看，一会就懵了，你就疯了啊，比想象多一步一步沉下心来，踏踏实实去看你那个老师。

你看这个spring大概呃看了多长时间，昨天看完小说10年，其实你们用不了这么长时间，真的用不了这么长时间哦，没大家想象那么难，没大家想那么难啊，但是我再讲一点，我再讲一点啊，我再讲一点。

你们在看源码的时候，不要看到一个点你就放弃了，看到一个点你就放弃了，不要这样干，就好比你在大学或者呃高中的时候背单词一样，每次背单词都是从第一个字母叫abandon开始背齐的。

背到最后你还是只会一个abandon，这东西都不会是吧，第一个单词是把那个单词书里面我没记错的话，应该是吧，是这意思啊，至少学会了一个，不要这样不要这样啊，咬着牙去看啊，然后你在看的时候。

我告诉你怎么做，我告诉你怎么做，你别想着说这个大体的脉络图是不是有了，有了之后你就画一个，拿这个号再大也行，你拿拿那个s慢来就行，哪怕用最基本的最基本的那个画图工具也行，无所谓，不管是什么工具。

哪怕用笔写也是可以的，你去构建整体的一个思路图好吧，从哪个类跳哪个类，挑哪个方法应该怎么做处理好吧，你不把那个记下来，你把它记下来，当你记完一遍，你把整个事都理通了，你再去做学习的时候。

就会变得非常非常容易的明白了吗，就没大家想那么难了啊，那这个时候我我process on process on一个开源的一个一个不是开源，有免费的一个呃啊，在线的一个画图工具。

在线画图工具免费的话应该可以画几张图吧，应该是没记错，没记错的话啊，一定不要从每次从头开始掌握这样一个逻辑，这很重要，这很重要呃，不不交不交钱的话，应该是有九张图，还是其他出来的好吧。

那之前我跟大家说过了。

那个之前出过这样一个文档，这文章里面包含就是什么呢，基本上常问的一些spring的一些面试题这块都有讲到，都有给大家写一些呃，就是文字性的一些描述，这块都有啥都有呃，这个文档一会儿我发一下。

一会儿发一下，一会儿发一下好吧，呃给你们吧，无所谓好吧，反正我还一样啊，源码东西呃，下去之后一定要自己去跟，一定要自己去啃这个图，这个文档会给你们，但是我希望你们一定要去看。

别背了好吧，你现在在背埋，完蛋了，完蛋了，你背是互虎不住面试官的，为什么你们现在都去参加过面试，对不对，是都去参加过面试，你去参加过面试之后，我问一下现在在面试的时候还是说东一榔东一榔头，西一棒槌吗。

是这样的方式吗，不是了吧，面试官现在面试的时候是怎么面试的，或者你们在面试别人的时候，你们是怎面试别人的，根据项目由浅入深，我会纠正你一个点，一直往深了问，一直往深了问好吧，这时候有一个问题，什么问题。

如果你是背的话，你只能把你背的东西给说出来，往底层扣细节的时候，你就完蛋了，所以永远不要想着说老师我再去背别的东西，别讲这东西了，这事儿已经不存在了，这事已经不存在了啊，一定要去深入去理解这些东西。

不理解是不可以的，理解是不行的，一定要去理解这些细节，那我再问一个问题，为什么面试的时候要问源码，听到我的问题啊，为什么呃，面试要问源码，我说实话，咱们咱们说句良心话。

你们在面试的时候或者在课程工作中用源码用多了吗，学习能力功力深不深，我告诉我问一下，你们有几个人去扩展过spring，有几个人自己去定义过post processor，有几个定位。

这这这这些东西我不能说一个没有一个没有，可能就有点偏差了啊，但是不多，大肠里面可能会会会用的比较多一点，但是在中小企里面几乎没有，几乎没有啊，原因是啥，第一大家不清楚，不敢写啊，这是第一点。

第二点是你们不太精通对线细节不了解，所以你做完这件事情懂我意思吧啊但是面试的时候还是那句话，人太多了，你要提升你自己的一个核心竞争力，有了这些核心竞争力之后，能进力之后，你才能够把你想要的东西给拿出来。

不想要的薪资给要到，要不然的话凭什么要你不要别人啊，你比别人多长两个眼睛吗，多长两条腿吗，也没有吧，是不是这意思啊，这一定要注意了，一定要注意了好吧，所以啊这些也不是你们需要学习的好吧，这是为什么。

我之前在讲课的时候给大家说过，我在讲课的时候，在基础班的时候，我就把源码里都讲到了，不管是spring，包括像spring mvc的这些源码好，我都讲过了，之前也画过一系列的一些图四。

vc里面你是怎么一步步做的，从哪开始，进进进进的介绍一步步我是怎么样一个流程，这东西我都画过这个图，都画这个图，为什么给大家画这个图啊，然后c原版讲解可以可以给大家看一下。

这东西美里面都有详细的流程，包括一些注释都给大家写的，都给大家写到了，给大家写到了，为什么要想讲这些东西，啊为什么讲这些东西，原因是啥。

还是那句话，你还是一样，你现在在进行数据面试的时候，数据面试的时候出去面试的时候，你要知道考的是你的核心竞争力，你要把这些点都掌握到了，星空说，雷老师，你来做讲座，that spring。

你们讲的不好是吗，咱不好凑合着听，凑合听好吧，如果有啥问题的话，我们可以交流一下，ok，万箭穿心没关系，咱们那个基础班里面我都我都讲过这些东西，都讲这些东西了啊，咱们微信里面发一下吗，有那么贪心好吧。

别那么贪心，ok好了，这是我们对应的这些这些东西来，觉得这节课有收获的同学给老师客观六有收获吗，老师能加了3年级的对吧，我觉得你只要三星听完了，你看这个收获的，你看这个收获的好耶，有舒服了。

这话还是一样，跟大家说一下，这些东西其实都很关键，重的核心你要去学这些东西，那再问一个问题，你觉得除了spring之外，现在面试的时候还会有什么问题，或者面试的时候还会问啥，刚刚不是讲spring了。

你这还会问，你还会面面是啥，循环依赖，可以讲一下吗，循环依赖你看完源码之后，循环依赖怎么解决的，是不是一个是set，一个是一个是set方式注入，一个是高高区的方式进入，对不对，一个是可以解决的。

一个是不是可以解决的，那东西没啥可问的，你看原版里面它有三级缓存的方式，可以进行相关的一个处理，这东西你现在一看就是那东西是死的，它不会变的，它不会变的，明白吗，它不会变的好吧，那就来我们来说一件事。

那为什么我们要讲这些东西，来想一下我刚才讲的是什么spring源码，对不对，大家注意了，spring源码包含是什么，是全家桶的源码，你问问老师，我就会spring不够啊，就会spring不够。

你还需要啥，刚才说过了，这边误吧，是不需要必须必须要会的，是不要会了，ok再来看还是什么逻辑多线程和高并发，你出去之后你要说老师我不懂javg m里面的锁，我账号里面的锁，你别说面试了。

基本上大厂肯定过不了，不管你是社招还是一些别称都过不了，再往下看，还有什么东西，之前我讲过很多次mysql东西了，mysql我不知道有多少同学把那些东西给吸收完了，有多少同学掌握里面的一些精髓了。

应该怎么用，对不对啊，还有啥东西在想，还有啥东西还有吗，算法加数据结构，对不对，我看还有呢release加scher，对不对，再往下看，还有什么写数学线啥东西吧，能说老师设计合适。

设计模式这块东西其实是跟什么，是跟源码，你要了解到的就是你在看源码的时候，如果你设计模式比较轻松的话，是比较舒服的，是比较舒服的啊，是不是大概就这么多点啊，它是不合法的，我们放这个视频研发里面了啊。

就四门考的方式里面去了啊，包括一些对应的一些架构思想，同学老师现在要开始卖课了吗，对是这样的啊，直接告诉大家是这样的啊，原来是啥这东西我刚刚讲的那一块，刚刚我也给你们看。

我们对应的那个我给大家反复发生这些资料，这是在基础课程里面进行相关的一个讲解，相关的一个讲解啊，除了这个讲解之外，每一个点我们讲的都非常非常深，为什么要讲这些东西，原来在什么地方，原来原在什么地方。

我说老师你为什为什么每次都在卖课，你愿意在卖，是周老师也在卖课，然后所有人都在课，为什么这样，我不觉得我们是麦克好，给大家说一下我们在做的事情，什么是推销，我们对一个就是推广我们对应课程。

我们的课程是很有价值的，也希望大家能够经过通过这样的一个方式进行学习之后，你能获得比较高的一个进步，我问一下有多少同学现在是在30岁左右的女警，或者说快30岁了，或者说30多岁的年纪了。

有多少同学这样一个情况给老师扣个一有吗，很多吧我觉得很多这样的情况，为什么你们现在在找工作的时候会变得比较难，或者说不敢轻易找工作，之前我有很多同学说过。

我说你现在公司里面拿着25k拿到30k或者拿到更高的薪水，你现在敢出去面试吗，你在出去面试的时候，你能否拿到现在对应的一个薪水，有人敢保证能拿到吗，不一定吧，原因在什么地方。

就在于大家对于自己的一个知识体系这一块儿啊。

系列 2：P41：MYSQL调优：0.1 从0到1掌握mysql的索引系统 - Java视频学堂 - BV1Hy4y1t7Bo

课程讲对应的一个课程好吧，本套课程适合oracle吗，不是有只讲msl的，在最开始之前在企业里面oracle用的其实也比较多，但是就现在而言，企业里面可能用msl更多一点。

或者面试的时候问msl问的更多一点，更多一点，我希望大家把这些课好好听一下。

为什么这么说，这是刚刚有一个学生给我发了一个截图好吧，大家可以看一下，我截下来了，梁老师你好，我是谁a j，然后呢最近在看梁老师my sol优化解决了好几个线上问题，感谢感谢好吧，收获很大。

系统的学习比倒装写的好很多，这学生刚做的一个评价。

所以希望你在这几个小时之内过踏实下心来，好好学好好学，还是那句话，我这个人语速是比较快的，如果你在中间某个环节里面走神儿了，不好意思，回来之后你可能就不知道我在说啥了，好吧，集中注意力，集中注意力。

ok在讲解课程之前，我说了叫从0~1构建索引系统，这样提出了四个问题，你看下这四个问题你是否能解答出来哪四个问题的，第一个为什么要设计索引，第二如果是你的话，你会如何设计。

第三设计缩影的时候要使用什么样的数据结构，第四my sql是如何实现的，这样一共凸显了四个问题，我们把它拍掰开了，来聊一下这件事情好吧，第一个为什么用索引这件事情很好解释吧。

你们应该都知道我们用索引的目的在问最快呃，最终的目的是为了加快整个数据的一个访问，对不对，或者提高我们查询效率，那为什么加上索引之后就能做到这件事情，上学的时候都查过字典，对不对，经常拿这东西来举例子。

好查字典，你根据字典里面的编码能准确定位到某一个汉字所在的页数上面，直接就把那个字找到了，同样的在公司里面，你们在用数据库的时候，表里的记录可能是成千上万行啊，要不是呃成百万级或者千万行好千万哈。

那这个时候我如何快速的从里面定位到一条数据呢，此时就需要用我们的索引系统了，也就是说如果我能够根据某一个条件或者说某一个值，某一个值来直接定位到这条数据在哪，放着我把它取出来，是不是就完事了对吧。

这是我们最终的一个目的，如果你要达成这样的目的话，你想一下你会怎么来设计它，你会怎么样设计，就如果想拿到这项目的怎么设计，如果是我的话，我一定会这样想，数据库里面最终的所有数据一定是要落地到磁盘的。

对不对，是的，磁盘那漏掉磁盘之后一定是一个文件，那我所需要做的事情，就是说我要把一个文件里面的某一条数据给取出来，这件事情难度太大了，但是你们应该都做过文件读写，应该知道文件里面会有什么。

是不是会有一个类似于指针的东西，你们之前一定接触过一些方法，比如说叫sk有接触过吗，是干嘛的，每次你打开文件开始进行文件读取的时候，在最开始的时候是不是有一个头指针，然后随着你的读取。

这个指针是不是一直在向后进行移动，那大家想一下，如果我能够准确地定位到，或者说只是这个指针，你给我挪到第50个位置，挪到第100个位置，我是不是就能把后面指定长度的数据给读取到了。

那你想一下你来设计的话，你会怎么设计，第一我要知道我查询数据的时候是不是需要一个关键词好吧，这个关键词我们可以称之为什么称之为k，你是需要这样的东西，这肯定要吧啊，这是第一点，第二点我还需要知道啥。

好好听课好吧，不用签到了，好好听课，ok第二点我还需要什么东西，想一想还叫啥，是不是还需要定位到说当前记录应该存在于哪个文件吧，文件名称，这东西是不是也要文件名称，肯定要的好吧。

因为你的数据库文件不可能只有一个，然后第三个是不是要指定一个东西叫偏移量，因为我指定了偏量之后就可以定位到当前k是从哪个位置开始的，就是我们俗称的of set，缺这东西哎。

of set我是不是可以进行直接一个查询了，好吧，如果大家了解过大数据里面的某些技术的话，比如说have，我不知道你有没有用过have，在创建索引的时候，就是按照这种方式来进行存储的来进行存储的。

那么问题来了，mysql里面是用它来进行存储的吗，如果不是的话，如果不是的话，为什么没有，就是我为什么要用这样的一个方式，原因在哪儿，人在哪儿，这里面就会涉及到一个点，我希望大家能够注意了。

希望大家能注意了，对，就是慢的问题，就是慢的问题，这个慢的原因是啥，你要注意了，你在进行数据库方面的一些操作的时候，需要注意一件事，需要注意一件事，注意什么事，你当前的应用到底是哪种类型的应用。

如果你是来应用分类金融类型啊，比如说有这个东西o l ap，还有一个o l t p，有人知道这两个东西吗，有没有知道这东西干嘛的，来知道同学丁老师扣一不知道扣二，我母鸡不清楚是吧，来说一下两个干嘛的。

一个叫联机分析处理，一个叫联机事务处理，是这两个名词的一个定义好吧，online，然后呢，elastic process，还有online transition process。

也就是说我们现在如果你接触的是数据库层面的，特别是我们现在这种my circle了，oracle了，sql server了，像这样的数据库，他有什么要求，是不是必须要满足我们当前业务系统的一个支持。

当我输入一个sql语句之后，我要求你在尽可能短的时间范围之内把数据给我反馈回来，是不是及时性要求比较高，而o y a l o l i p什么意思，非常简单，它表示更多是什么呢，对历史数据。

比如说我之前5年的数据，我之前10年的数据，或者之前某一个时间范围数据做一个整体的分析来产生决策用的，也就是说如果你用这样的方式可以做，但是不好意思，它这个索引文件如果比较大的话，注意啊。

你的行记录比较多了，同时索引文件是不是也会变大，所有文件如果再变大的话，你读这个文件要不要时间，要不要时间，是不是也要时间，那同时大家想一下是不是又慢了，是不是用完了对吧。

所以这种方式对于我们的mysql而言可能不那么合适，可能不那么合适，大家想一下我要用什么样的方式要直接读文件，肯定不行了，那我现在就要考虑我们的基本知识了，基本知识什么基本知识。

我能不能够采用某一种数据结构来代替这样的一个方式对吧，你们应该都知道mysql里面它的索引系统用的是什么样的一个数据结构啊，b加数对不对啊，所有人都知道啊，那么问题来了。

为什么你知道数据结构有线性表对吧，有图有链表，有各种各样的东西，为什么就要用b加数，就算聊到数了，就算聊到数了，还有什么东西，还有二叉树，有b s t tr，有红黑数对吧，还有a v2 数又n种数。

那最终为什么选择了b加，对不对，这是一个面试中常问的一个点好，下面我们来看一下mico到底是怎么来进行实现的，以及他为什么要做这样一个实现，我的世界只有零和一说了三层就达到千万级别了。

你要知道这样的历程到底是为了什么，刚刚啊我看到一个同学说了，说我们在进行这个数的时，候，在进行这些数据结构选择的时候，有n多种的一个选择，为什么不是b数呢，b加数是b数的一个延伸或者是一个扩展。

除了b加数之外，还有什么，是不是还有b星数啊，是不是要离心术这块东西啊，希望你了解一下，是左老师会不定期的讲一些数据结构的一些公开课和算法公开课，希望大家能够看一下啊，看一下这个课程里面都会讲到。

ok现在我看一下mysql里面对应的一些具体实现，具体实现好吧，有没有b加，有没有b减数，注意丈夫强一件事啊，这东西b杠数有人把它叫b减数，注意了没有，这样的说法叫b杠数好吧，这东西就是一个什么念啥。

叫b不b数，很多人叫b减数是不对的，你千万不要这么念啊，这么念出去之后会被人嘲笑的，会被人无情的嘲讽，无情嘲讽的，大家注意了，ok其实这个时候你可以通过我们对应msl的一个官网来进行一个查看。

看一下官网里面它是怎么对这块东西进行整体的一个定义的，好吧，看官网里面有一个描述，这我要强调强调一下，这呃这个东西啊很重要，因为看过官网的同学应该都知道官网里面写的这个数据结构用的是啥。

他写的叫什么叫betr好吧，而没有b加数这东西，但是实际底层在进行使用的时候确实是b加数，好吧，哎这怎么了，但是官网都访问不了啊，完蛋看不了啊，算了，等他一会儿什么时候刷出来，我们再再再看吧，好吧。

你记住了，不是强势不强势，网速有问题啊，网速有问题，可能开直播占那个带宽占的比较比较大啊，所以这个网站可能刷不出来啊，看不出来，ok再来说一下官网里面有一个关于索引的一个描述，关于索引的描述。

索引这块它官网里面写了有什么有我们的b数，但是你记住了，他底层用的确实是b加数，而不是b数，一会儿一会儿我会告诉你b加数和b数它们之间的一个区别啊，这是第一个点问题再来了，除了b加数或者b数啊。

除了b加数之外，还有没有其他的还有没有其他的一些数据结构，在msl里面除了b加数，还有别的吗，好了同学提到一个名词叫哈希，那么问题来了，哈希它作用于什么样的东西，或者说在哪些地方会用到哈希索引。

哪些地方会用到它啊，memory好了，其实大家提到memory之后，memory之后就应该熟悉另外的一个名词叫什么叫存储引擎，什么叫存储引擎，谁解释一下什么叫存储引擎，它其实非常非常好理解。

所谓的存储引擎就表的是表示的是什么呢，不同的数据文件在我们物理磁盘上面的什么不同的组织形式，不同的组织形式，这点希望你能弄清楚了好吧，那么问题来了，my sql里面它到底有多少种群中引擎呢。

这我应该怎么看，看的时候非常简单好，我们来看一下吧。

我当前这个虚拟机里面用的这个my circle，用的是5。7，这个版本好吧，my circle，杠幺肉上杠p，少in jn，看到了吗，这块展示出来的都是我们my sql里面存在的一些所有存储引擎。

innod b c s v masm，好吧，本来后还有pperformance schem mg啊，什么东西，然后achieve memory是不是这些东西，这里面这里面问的比较多的。

在日常工作中问的比较多的是main db，my son和memory，这三个里面如果再选择的话，谁印度db可能问的是最多的，或者大部分在提问mysql问题的时候，默认的存储引擎都是我们的intedb。

但这个时候我希望你能认识到，当你在聊索引的时候，一定是跟我们当前的存储引擎相关的，以脱离存储引擎来聊这件事情是不对的，为什么这么说，in the db，my son用的是b加数，这没毛病。

但是memory用的是哈希哈希索引，这样东西，希望大家能够区分开了，现在区分开，那我再问一个问题，in no db，它是否支持哈希索引，这是什么，这是不支持，好了有说支持的，有说不支持的。

这儿我给你一个统一的描述，统一的描述，注意了，听我说inno db这种存储引擎，它支持的是什么叫自适应哈，希，ok什么叫自适应哈，希非常简单，也就是说我们认为是控制不了我们当前的一个索引的。

你如果想用它的话，这是由my sql的系统自动来做判断的，会把我们的b加数转成我们对应的什么叫哈希索引这件事情，用户是没办法去干预的，明白了吗，好没办法去进行干预的对吧，进行干预的，这要注意了。

这时候你可以做一个查看好吧，怎么查看柚子saka，我们来看一下数据库啊，比如说show index，from，看这个表，这个表后面有一个东西，啥是b税，这不是告诉你说我用的是b加数这样的一个数据结构了。

明白意思吧啊这你要注意了，这一定要注意了，ok好了，这样希望大家能够判断一下，希望大家能够了解了了解一下好吧，问题是为啥要用自制引发器，使用场景能给的吗，自适应还是什么意思，你要先了解哈。

希它到底有什么毛病或者有什么问题，会有什么问题，有啥问题啊，你在使用哈希索引的时候，一会儿我们再讲索引那个存数据数据结构的时候，我们来说这一点，我们来说这点好，说完这点之后。

你就理解他为什么要使用这种自适应哈，希这种方式好吧，这种方式吧好了，东方一个同学提到一个问题，就是存储引擎到底是个啥啊。

到底是个啥，所以说引擎其实非常简单，这样给大家举一个最简单的例子，你就知道了，打开我当前的一个文件，请大家打开我的c盘，c盘里面文件夹里面也装我们的mysql了，打开我们的my circle。

找到我们的program data，在这里面你可以看两个对应的数据库是吧，看这块这有这样一个文件，一组文件叫emp，是不是这样的文件对吧，这个名字是一样的，但是后缀名不一样，这个点f rm表示什么意思。

表啥意思，表示的是存储的数据的一个结构，当前表的一个结构好，而a b d才是我们实际存储的数据的，这个文件是数据文件，这个数据文件里面包含真实数据，好吧，还包含什么了，包含所以好吧，这一定要分清楚了。

这是什么，这是in no db这种存储引擎，in no db啊，这你要注意了，除此之外，除此之外再打开另外一个库，看my sql，这库里面一样有一组文件名字是一模一样，但是你看后缀变成三个文件了吧。

第2f rm还是表示我们的结构m y d m y表示什么意思，m y d表示是date数据，而m y表示的是index，所以所以在这里面你的所有文件可以数据文件是分开放的，这个东西用是啥。

叫my s这种存储引擎，所以你会发现了不同的存储引擎，它的数据组织形式是不是不一样的，是不一样的，好这希望大家能够达成一个共识啊，我们这能看不能看到，ok正常看到之后来这个点没问题，同学给老师扣个一。

没问题吧，这边内容下面我们来详细聊一下my sql的一个索引系统，msl的一个索引系统，好吧，来往这看吧，官网也打开了，打开我们的dog mission，这儿做一个查看，dogo mission。

我还想带你们看一下啊，算了算了算了，我放弃了。

这网上真的难啊，不管了不管了，来我们现在来看一下msl的一个收音系统，好吧，在聊索引系统之前，你说新系统之前是我想说一件事出现什么事呢，你在这块想要掌握的比较清楚的话。

最好能够具备一部分的操作系统的知识，我问一个问题啊，这个我们的数据啊最终都会考都会放在我们的磁盘里面，对不对，这肯定是大家的共识，放到磁盘啊，但是我在进行实际数据读取的时候，你是从磁盘直接读吗。

还是要干嘛，刚才说了，我需要把磁盘里面的数据加载到内存，走到内存之后，我是不是才从内存里面取到我们对应数据，它是有这样的一个环节的，所以这里面会涉及到一些磁盘跟内存的一些交互，那我问一下磁盘跟内存。

它们两个读写的速度是一样的吗，是不是一样的，不一样吧，什么样的量级啊，往下看，这我专门找一张图片，他说了，mean memory reference，这是它读取的叫100纳秒吧，然后再来看还有什么呢。

叫round trip with the name，什么scripter，这是50万，再来看第四个seek是我们的磁盘，往上看是多少，你看这两个值它们是一个级别吗，很明显不是一个级别吧。

是不是一个级别对吧，所以内存的速度一定是快的，一定是快的，一定是快的，因此我要做的事情是什么事，情，需要把磁盘里面的数据给加载到我们对内存里面，从内存里面取数据，这样是更好的，如果我的内存假设是无限大。

我现在的话我可以做些什么事儿，把全量数据都加载到内存对吧，然后呢直接从内存里面取数据，这个时候很明显速度快很多，但你不可否认有另外一个问题，什么问题什么问题，你放到内存了，如果断电了，怎么办。

数据是不是一定会丢失啊，这是我们不允许发生的事情，不许发生的事情，因此我还是要进行持久化放到磁盘，但是我在去数据取数据的时候，能不能把一部分比较重要的数据会优先读取到我们的内存里面，这可以吧。

也就是说我能不能怎么样呢，加快或者提升整个磁盘跟内存的一个交互过程，假如说我现在取一行记录，取一行记录，我取一行记录记住，注意我说的啊，我取一行记录，我是真的从磁盘里面只加载了一行记录，读到内存了吗。

是这样来读的吗，不是吧，大家怎么读的，你告诉我，所以这里边会有另外的一个操作系统方面的一个原理，叫什么叫啥叫磁盘预读，什么叫磁盘预读啊，这个磁盘预读它是有一个理论基石的，叫什么叫局部性原理。

这局不行是啥意思啊，我刚说了，晚上看这个专门给大家截了一张图啊，说了程序和数据的访问都有聚集成群的程序的倾向，在一个时间段之内仅使用其中一小部分叫做空间局部性，或者最近访问过的程序和代码。

数据很快又被访问的可能性很大，这叫时间局部性，时间局不行，有了这两个局部性原理之后，有的东西叫磁盘预读，也就是说每次在读取我们实际数据的时候，我就算只需要一个字节a回一个字符a啊，不好意思。

我读我们数据库的呃，读磁盘的时候也不是只读一个a的，我需要读取的是某一个块的数据，或者说某一个单位的数据，而这个单位我们统一把它称之为e，这个页大小是跟我们整个操作系统相关的，一般是4k或者8k好。

4k8 k，而你在进行数据交换的时候，数据交换的时候一般都是什么都是啥，都是这个页的整数倍，就是我们的这个配置是有人一般都叫dd的配置，很多地方你应该都看过这样的描述。

这个配置数据页一定是我们整个4k或者8k的一个整数倍，整数倍好吧，这这也写的吧，可能操作系统里边也通常是4k的好吧，储存和我们的磁盘以页为单位发生我们对应的一个数据交换这块儿，我希望你能够先了解了啊。

必须要把它给先了解到这块儿，了解好了之后，下一步我们再接着往下聊聊什么，那我怎么能够保证，或者说我用一个什么样的一个数据结构能够保证这件事情呢，每次是以4k的一个整数倍来读取我们的数据啊。

这块儿我应该怎么保证，那这里面你就要从什么，从我们当前的一个数据结构里面进行选择了吧，选啥有哈，希表有二叉树对吧，也有链表，有n多种，这样的一个方式，我应该怎么读，是不是这意思好吧。

从下面我来写了索引是什么东西好吧，所研系统必须存在文件系统里面，然后呢所以的文件存储形式与存储引擎相关，然后你要想建索引的话，可以选择这么多的方式哈，希二叉树b树和b加数是不是这么多。

为什么最终选择了b加数，来挨个来解释这块东西，我希望你把这块东西给夯实了，夯实了啊，因为数据结构这块问题啊，现在面试的时候问的很多啊，之前就有学生出去面试，被问到过，为什么my sql里面选择b加数。

那你要举论证吧，是不是说其他东西不太行，那b加数是最合适的一种方式对吧。

这块怎么看一样的。

系列 2：P42：MYSQL调优：0.2 索引系统中数据结构的抉择 - Java视频学堂 - BV1Hy4y1t7Bo

直天上课的时候给大画过很多图，我们这直接通过这些图来进行一个展示，好吧。好后看假如说现在我有这样一个表ID内两列，这是我们里面的一个数据。如果我用哈希表的话，哈希表的话也能够进行存储。

你们都是搞java的好吧，应该知道一个东西叫什么叫哈希 map。他在进行实际存储的时候，是不是KV建制对这样方式来存储的，它底层用的数据结构，什么数据结构，是不是叫数组加链表或者加红黑数。

是不是这样实现，我是勾浪，这没招了，好吧，但存尺建值都是数据，应该知道吧。什么意思？这是一个数组，对不对？这些数组，如果我把某一个值取完哈希之后，取完哈希之后。

它一定会计算出来1个01234567这样一个位置，对不对？我往指定位置里面插就行了。但是一个位置里面是不是只能放一个元素。因此当我想存储其他元素的时候，我必须要往下面堆格子。

这一系列格子里面的东西就意味着它们的哈希值是一样的吧，是不是一样的？那我如我取到这个哈希值了，我要挨个进行对比。啊，进行进行对比，这很明显，这是不合适的吧。好，来再看这个哈西这种结构，我刚刚说清楚了吧。

有个影响就行了。好吧，有影响，这不是我们的重点OK这个有影响之后，下面聊一下它有什么缺点，让mesco不选择它。说去点。第一块的缺点希望大家注意了。对，就是同学提到的碰撞或者叫冲突。是啥意思啊？哈希。

我们用一种最low最low的方式，我是不是直接可以进行一个取模。比如说模8，我取到值一定是01234567，对吧？但是你要知道，当你在用这样的方式进行实际的一个存呃。

没有没有把用这样的方式来进行实际存储的时候，实际存储的时候，会有很多什么样呢？相同的值出现在这个链表里面。而你的数据又是随机的，所以会导致一种情况，某一条链里面可能会非常非常长。

而其他链里面可能数据几乎没有，是不是几乎都没有，对吧？因此就这样情况，你应该知道了。我如果想用哈西表的话，我必须要设置一个非常非常完美的一个哈希算法，在java里面，哈希 mapap里面有一什么东西。

还记得吗？有东西叫扰动函数来听过同学在老师扣1，有没有人听过？调动函数。这么多没有啊。搞java的不应该不知道这东西啊，你要搞其他语言的无所谓，但搞java的不应该不知道什么意思？来，我解释一下。

假如说我现在这个数组的长度，数组的长度，假如说是16个格子，16格子，几个二进制位可以表示16啊。😡，几个二进制倍可以表164个吧。现在我有这样一个数据，比如说1110，然后呢，0101。

还有一个数据是01010101这样的两组数据在进行实际存储的时候，我要放到16个格子里面，我是不是只需要磨上16。当我在进行模16的时候，我其实只需要4个二进制倍就行了。那意味着我只需要后四位。

你看一下后四位一样不一样？是不是一模一样？那这两个东西是不是要放到一起的？这很明显，碰撞率比较高嘛？因此人们想一种方式，什么方式，我要把我高位向右进行移动，拍慢是移动16位啊。

把高位向右移动移动完之后让高位去尽可能的参与运算，同时还会配合一些抑货的过程啊，尽量让我们的数据散列的更加均匀一点啊，散列的更加均匀一点就是我们那一个扰动函数这样的一个意义啊，对。

计算排期值的时候要用的这些东西。听白意思吧。说哈希麦克不行不行吗？这是在进行这种高额运算的时候，计算哈希的时候，要用哈要要用这个扰扰动函数。你别说你老师，你转这些名词干啥？面试官问你个扰动函数。

你说我不知道合适吗？😡，不合适吧。对吧OK啊。好了，是这样，一会儿名词还多呢，一会儿名词还多呢，听完之后你就懵了。OK好了，这找动函数。

所以第一点你需要设置一个非常专业的或者非常一个让数据尽可能散来的一个哈希算法啊，哈希算法，这是第一点啊，它不太好的地方，因为一般哈希算法总会有一些毛病啊，这是第一点。第二点，哈有什么东西。

你在存储存储哈希 mapap的时候，我存完比如往里面放了一堆元素。当我存完里面的一个数据了，存完了，我现在取的时候，要不要要不要把哈希 mapap里面整体的数据结构都放到内存里面。

什么问题啊？呃，不要说我说话快，好吧，我知道快，所以让你们集中注意力。开课之前我已经提前说过了，好吧。就是说我们在进行数据查询的时候，哈奇 map哈奇 map你那边放了一堆数据，放完数据之后。

我要想从里面取得某一个数据的话，这个数据要不要放到内存里面？不要。你告诉我，你不放到内存里面，你的hay map去读过文件吗？😡，肯定是放内存的肯定是放内存的。好吧。

而且你要知道而且你要知道哈奇 map最大的容量是多少来着？😡，二的右移多少位来着？31还是32记不清楚了，是不是一是不是很大的一个数据量，对吧？如果我现在要把这些数据都放进去。

是不是特别的占用我们的内存空间了，内存是非常非常宝贵的资源吧。那因此这个时候它是不是也不好了，是不是比较占用我们的内存？😡，这是第二个问题吧。好，来再看第三个问题，还有什么问题？哈希。

你在进行值的查找的时候，你要怎么查找，是不是根据某一个K值，我能直接定位到某一个数据结果，是不是这样的方式？对吧但是你要注意了，如果你直接有等值查询，一定速度走走的啊，肯定很快肯定很快。但是你想一下。

如果你在公司里面做的东西都是范围查询。范围查询，你告诉我你怎么办？你是不是变成说我要挨个进行对比了。如果挨个进行对比，效率很明显就低了嘛，是不是这意思？所以我这时写的什么样呢？如果所有查询都是等值查询。

哈希确实很快。但是我们在工作中等值查询的情况其实并不是很多，更多还是范围查询，那怎么办？它是不是不合适啊，所以刚刚列了这么多问题，这是哈希表不好的原因啊，你再回想一下，谁可以用哈希作业来着？

memory吧，为什么memory用用可以用哈希作业。原到了吗？第一个占内存我不怕。第二个开机算法比较麻烦。我设置一个相对而言比较公正的一个开析算法好吧。第三个，我要保证你这儿都是等值查询。

就算你是范围查询，我一点都不在乎为什么反正都在内存嘛，是不是在内存，内存查找元素，这个整体的速呃效率跟磁盘里面完全不是一个量级吧。是不是这个意思？所以在memory的时候。

它会使用我们当前这样一个哈希表哈希表，明白我意思了吧？好吧，而我们的应用DB为什么没用？你在跟磁盘做交互的时候，这很明显不合适嘛，对不对？来这个点听白同学要2扣1。Yeah。

过了吧，好吧，过了之后来往下看第二个二叉树红黑树，这些数为什么不行？数为什么不行？数在聊数的时候，我知道很多同学你遇到数就疯了，因为这个分类太多了。二叉数BST treeAVL数，然后呢，红黑数对吧？

还有B数，还有B加数，是不是一对这样的一个数据结构。这些数都是都是可以用来进行数据存储的，好吧？但是我希望你能注意一点，注意一点，前面这些数在进行实际存储的时候，我们存的就是一个值，对不对？

是不是存就是这些数据是这样的一个值。我有了这些值之后，我能直接把我们的数据给取回来。但现在你注意了，你所有的数据是要落地到磁盘里面的。落胶磁盘。当你在落地磁盘里面的时候，你想一下。

是不是意味着你每次要从磁盘里面取一个数据块回来，比如说取一个页回来吧，而不是取一个值回来，对不对？你你大想想一下，一页里面注意啊，mycyclcle DB这种存储引擎，它默认每次取的是16K的数据。

16K的数据每一个里面放一个值，你告诉我你得放你得放多少个节点。放到节点，而且节点越多会有什么问题啊？😡，接着读。节点越多就有可能会造成你整个数的深度会无限加深，会无限加深，而数的深度越深了。

依然会有问题，依然会有问题，会有啥问题。数越深意味着你的IO太频繁了。也就是说磁盘磁盘跟内存在做交互的时候，你也需要N多次的一个访问。我之前说过磁盘机械磁盘那个呃读写速度是固定好的。

我们一般改变不了这件事情。如果你想提升你整个IO的一个效率的话，只有两种途径，两种途径好吧，什么途径？第一个第一个是减少IO的次数，第二个是减少IO的大小，IO的量。是啥意思？

为什么公司里面不让你写s莱新啊？😡，啊，为什么不让你用此来性？为什么让你必须要写这些字段，原因在哪儿？😡，原就在于数据是放在磁盘的，而my circle里面它本身有一个服务。在每次做数据交互的时候。

我需要由这个服务层去我们的存储引擎里面把数据给拉回来，拉回来之后，在这儿可能要做一些数据筛选之后，才能反馈给客户端。如果你每次都是用的是这种全标扫描，或者把全后端都取出来。那意到这个IO的交互过程里面。

数据量是非常大的。那很明显影响效率了，所以不推荐大家使用这种新的方式啊，但不管怎么样，最终到底还是什么还是IO的问题，明白了吗？还IO的问题。所以在二叉树和宏维数这块都比较麻烦都比较麻烦啊。

当然啊当然啊我说一下，很多同学啊对这些数可能会比较懵啊，可能会比较懵你别懵，一会儿啊这个东西咱们不是特别重要。因为是属于数据结构里面的东西。等咱们把今天该讲的核心的点，我给你们讲完之后。

一会儿我来带你们捋一下这个数，你们需要吗？需要我带你们捋一下刚刚写那些数吗？什么数？第一个我刚说了二叉树吧，对吧？然后还有呢红还有BST垂对吧？有AVL数，有红黑树，有B数，有B加数啊吧。

有一堆这样的方式，一会儿带你们捋一块东西啊，带你们捋这块东西，这块啊属于数据结构的，属于数据结构的。啊，一会我们再来聊他，一会再聊他好吧，先讲核心点，先讲核心点，好吧。所以呃别着急别着急。

O一会儿来讲它。好了，刚刚我已经总结过这个理论了。什么理论说了，无论二叉树还是宏黑树，都会因为树的深度过深而造成IO次数变多。IO次数如果变多的话，就会影响我们整个数据读取的一个效率。

所以就不用这样的方式了，不用这样的方式了。那为什么B数就可以啊。

啊，为啥避数就可以啊？嗯，这为什么？这为啥？其实非常简单，我问一下B数，它这东西B数的东西它到底是怎么来存数据的？好了，同学说了存的东西不一样啊，存的东西不一样。这是我们说的。除了这个多差这个区别之外。

除多差区别之外，好吧，还有一个非常非常关键点的一个区别，就在于往这看，我们给大家打开一个网站。

看这个东西啊。这是一个数据结构，我认为比较好的一个网站，好吧。

为啥深度深IO就多？假如说我现在我现在有N多个节点，对不对？假如说一个节点里面我放的是一条记录，我放的是一条记录。那这个时候大家想一下，我要把所有记录都加载回来的话，我现在有1000万条。

你在组织这个数的时候，你告诉我你要多少层。你要多少层？N多层吧，是不每层里面是不是只有这样的东西，是不是两个分支，你是要从里面N层进行一个筛选，每次取的时候都取一部分，每次取的时候都取一部分，这很慢嘛。

😡，是不是这意思？好吧，来，我们来看一下B加数它是什么样一个关系。刚刚讲了那个红黑数也好，还是那个二叉数也好，它每一个节点里面只放一个值啊，只放一个值。而我们的B数和B加数。

它放的是一个值的集合值的集合。它里面有一个概念叫什么呢？叫dgrade。

地国人在司法导论那本书里面把它叫做杜。好，我习惯把它叫成接，这个接什么意思啊？接表意思是这样的，表示说我单个节点里面可以放置多少个数据元素好，可以数据元素OK。DNS是什么数？哎，网站不能用了？我天哪。

兼职网是咋回事？

这么坑的吗？啊，系。先打开一下啊。网速嗖嗖的。我这网速不好啊。太坑了呀。

可以用。我开VP了吗？没有吧。没开啊。又是别下片了。没有提前备课，下午的时候啊打开是没问题的。这晚上不知道咋了。

这很难受啊。算了，我直接画吧，我直接画吧，我直接画吧。好吧，直接给大家画一下。呃，这个数是这样的一个方式，是这样的一个方式。好吧，不这有啥慌的，大家看一下数是这样的。

比是说原来我们在放的时候放的是一个节点，一个节点一个节点，好吧，现在在我们的B加数里面放的是这样一种组织形式，什么形式呢？我不在这画了，在这里面画吧。

他这里面有一个节点。好吧，这是第一层节点，这C口V，这第二层。第三层，然后呢每一个节点里面每个节点里面我可以放一个元素。ややそう。三个元素，假如说我这个节点里面是一个四呃四阶的。

假如是四阶的四阶的话表示意思就是说我这里面最多只能放三个对应元素，三个元素。如果如注意啊，如果我当前节点元素超过4个了，不好意思，我会把当前节点向下进行一个移动啊，出来了，出来了，来，往下看啊。

假如我这是一个四阶的，我往里边插入我们对应元素，往这看，差第一个没问题吧，插第二个。

我把这速度调快一点啊，听到了，我再往里面插第三个。来，现在这三个了，当我在插入第四个的时候，你会看到一个效果。他是不是做了一个分支，是不是把刚刚的1234分成134了吧，我现在往里边插插5。然他再查6。

看这儿了吗，是不是又变了，是不是这样的一个方式，你能看到组合方式了吧？每一个里面放的是一块数据，而不是一个节点里面的一个数据。所以我可以再往里边7。😡，是是不是七了，再往里边插8，大家想一下。

当我再插入8这个顶点的时候，这是不是超过4个了，超过4个，我要往上再过渡一个吧，查一下。😡，是不是再加一个，来再差一个9，还有啊差九的时候。😡，还没问题，再上一个十，你看十的时候有什么变化，好吧，十。

看效果了吗？差实之后，下面超过4个了，我要往上移，往上一移，上面也超过4个了。OK我还要再进行一个分裂，是这样的一个过程。每一个里面放的是一整块的数据，所以这样的方式的话，我们可以干嘛？

是不是可以表示说每一个节点我去放置一页的数据，比方说16KB，这是不是可以？啊，不能超过4个。对不能超过4个不能超过4个。因为我这定义的接触是几是4吧，比是说最多放的是deggrade。然后呢。

减一的数据减一的数据是这样的一个方式，这样一方式。为什么要向上移？这这就是B数里面规定了，这有什么为什么要向上移的，你向下移吗？好吧，注意啊，你如果一直往下移的话。

你是不是跟刚刚那个东西又跟刚刚那个二叉树是不又变成一样了。你一直往下移树的深度是不是又深了？所以它必须要保证说我上面的节点填满之后，我才会向下进行移动。如果上面的节点没填满，我就一直往上补。

这样的话能减少你对应的一个什么数的一个深度吧，是不是这意思啊，就这一块东西啊，把它往上换一下。😡，OK你们可以下一周后自己看一下，好吧，是这样东西是这样的东西。OK这就是我们的比。

这就是我们对应的一个B数啊，对应的一个B数。O我都翻了好多遍了。好了，这是这块一个B数的一个数据结构吧。再重新回到我们当前这个mycle里面my是怎么做的？它是怎么来存储我们对应的一个数据的呀。

来往这看下面这样一个图，这一图，这样画这样一个图。😊。

好吧，这是不是就跟我们刚刚那个数是一样的，是不是也是一个B加数，对不对？呃？也是一个B数，对不对？既然是一个B数的话，那意味着我可以往里边存数据，也可以往里边导出我们对应数据了。

这时候你看了里面分了3块内容，123是不是有3块信息，是不3块信息，这3块信息表示什么意思啊？你想一下，你在创建对应的一个索引值的时候，K值的时候，啊所索引的时候，是不是必须要有个K。

比如说给ID列建索引，给内部列建索引，或者给其他列来创建索引，是不是一定需要一个列，这些列里面是不是一定有值？对吧那这个子框里面紫色框里面表示的就是我们实际要存储的那个值，记住啊。

是实际那个值实际那个值。然后有了当前这样的一个值之后，当前那这样一个值之后，下边干嘛？这个值我刚刚插的时候是123是不是这样一个方式，但其实你已经发现了，这插的时候这是68是不是68，这是呃再找一下啊。

没有是吧，这是6868是连续数据吗？

不是人音数据吧，不用发网址了。那个网址现在腾讯课堂被屏蔽掉了，你们都看不到你们看不到。😡，听白意思吧？这个网址一会儿我发到咱们那个群里面，或者你们去找丨小丨姐姐去要，找丨小丨姐姐要，不要再忘了。好吧。

同学可能会屏蔽的网址，网址发不出去。听白了吗？好好听我这的课，好吧，好好听这块东西。我们现在已经知道BB数是这样一个数据结构了。我现在画了这样一个图，画了这样一个图，有了这个图之后，有这图之后，好好听。

好好听。有图之后，我这固定三个类型数据，1233种类型，三种类型，这三种类型的数据里面，它表示是我们的K等值，是某一个范围。😊。

是某一个范围。当我有了这样一个范围之后，大家想一下，假如说我现在要查询28这条数据，你告诉我我怎么找。叉28。我是不是要大家想一下，这些数据啊一定是都放在我们的磁盘里面的，一都放在磁盘里面。好吧？

第一次我要先读取1个16K过来，是不是第一个磁盘块读过来了吧？读过来之后，我判断一下我的28在哪个范围里面，如果你是在小于16，是不是根据P1是不是一个指针，是不是指向这个节点。

如果你是16跟234之间，P2。如果你大于34是不是到下面，是不是有这样一个方式啊？那因此既然这样的话，我28很明显指向是不是P2这东西，所以我找到P2这样的一个指针值，是不是把这个磁盘块三给读进来。

刚刚是1个16KB现在是不是意味着我又加了1个16KB这没问题吧。证明题的话，来磁盘框二和磁盘框4，这两个东西会不会加载，或者说会不会从我们的磁盘加载到我们对应的内存，会不会？不会吧。

因为我的指针是不是没有指向，所以这时候它是不会进下来的。😡，那下一步来，我们再接着往下看，我到这之后，我是不是又要跟28比了？我一比之后，你发现了哪个范围？😡，哪范围是不又在P2指针里面。

我是不是又把这个磁盘块八给读过来，又读了1个16KB。😡，这没问题吧。早上是86K并之后，我是不是能准确定位到我们当前这样一个数据值了。这个值当然这个磁盘块你注意了啊，磁盘块注意了，你可以有也可以没有。

如果没有的话，意味着我查询不到数据。如果有的话，我直接把当前数据进行返回，是不是这样个过程？为什么使留在最上面？这就是我们在插入数据的时候，这样一个组织形式。你可以按照这样的模式往里面插一下数据。

插一下数据，你知道是什么样的方式啊。😡，好吧，这东西啊并没有什么特别难的，并什么特别难的。刚刚那个找数据那个过程能听明白，同学跟诉科波一。可以吧？如果这样能听懂的话，你想一下，在整个的历程里面。

我一共读了多少数据？16K加16K加16K是不是一共是48K的一个数据。这个问题吧，是不是48K。好，而且大家想一下，那我这里面我可以放多少个磁盘块儿？提到问题啊，我可以放多少个磁盘块？

磁盘块跟表什么关系？表里面有数据，你的数据在进行存储的时候，数据在进行存储的时候，它都是一个亿。而那个页就是我这标的这个磁盘框，就标这个磁盘框。16K怎么算的？16K不是算的？

刚刚是不是有一个东西叫磁盘预读，是磁盘预读，每次在预读的时候，是不是都是4K的整数倍啊？每移动DB存储引擎默认就是每次读4K乘4，就是16K的一个数据，是要规定好的，是它规定好的，这没有算的过程。

第一个磁盘块1个16K，第二磁盘块是第216K第三个磁盘块，第三个16K1共48K的数据。😡，这没问题吧。好吧，下面来再聊。我们知道了，读了48K的数据，那这个接是多少啊？同学们了，刚利借了多少？

这个接我怎么去做判断？是不是看一下我们每个节点里面最多可以放几条数据，对不对？这个图啊只是一个样例图，你注意了，只是一个样例图。这样例图。那这时候我要思考一个问题，接的东西我先放一边。

假如说我这里面我可以无限去进行存储。假如啊假如先扔一边啊，假如这样说的，然后下面我读完之后这是48K数据，你告诉我我这个东西可以存储多少数据啊，这三层这个三层的B加数呃，这三层的B数可以存储多少行记录。

那这个跟什么相关了？😡，跟谁相关，是不是跟我们这个跟我们这个数据块的大小相关了，对吧？这里面16da表什么意思？😡，这16倍表示说16K等于16这行记录就是da就在那放着，da在那放着啊。

假如说我们一行为了好算是1KB。这种一果是11KB的话，你想一下这里面可以存多少条？上下东西假如说不占空间，假如说不占空间，假如不占空间。想一下这个4方块里面可以放多少记录？16没问题吧。

这是16条下面这块磁盘块可以放多少个数据？16条吧，下面这个字盘块放多少数据？16条吧，这个时候你发现了它是不是等于是16乘以16乘以16等于多少？是不是二的12次方等于4096条数据？是不是这样意思。

注意啊，这种算法是不精准的，算法是不精准的。虽然不精准，为什么不精准？我们把上面这空间是不是干掉了，是不是都没占空间，这很明显不合适嘛，肯定要占空间的，肯定要占空间的。只不过我们人为把它干掉了。

我们粗略算一下，这东西是能存4000多条数据的，你想一下，你3K，你你想一下啊，你三层的一个B数只能存4000条数据，这4000条数据不跟玩似的吗？是不是跟玩似的。

你在公司里面你的数据库不可能说我只有几千条吧，一般都是百万级千万级别这样一个数据量，那很明显问题来了，为什么这个三层的B数，它能存数据这么少啊，空间浪费在什么地方了。😡，为什么不是相加？

这里面会有N多个分支啊，我这如果把16个都补满的话，你想一下多少？😡，如果把16都补满的话，是不是意味着15个范围，那多少了，肯定是相乘嘛，对不对？肯定是相乘啊，肯定不是相加。O好了，同学说了。

浪费在date上面了，就这块是不是比较占用我们空间，对不对？所以这时候我要干嘛？是把我们当前的da给干掉。如果把date给干掉之后，下一步干嘛了，就从我们的B数演化成我们对应一个B加数了，这块还是一样。

你看一下B加数什么特点，一样，我再指定一个四阶的，指定四阶的，这是B加数，刚刚是B数，好吧，我们再插入相同的数据，你往来看有什么特点？一。😊。

2。速度快一点。34。56。你能看什么特点吗？😡，看这块。层数一样吧，但是有什么样的特点，你看一下。😡，当我这样的放在存储的时候，B数是这样的，每一个数据值，每一个数据值是不是只可能出现一次。

只会出现一次。但是你往这看，必加数里面，这个7两次吧，三两次吧，5两次吧，9两次吧，这意味着啥？意味着我们对应的这些数据块给干掉了。我们所有的数据都放在我们对应的叶子节点里面去了。

而上层这块东西我是不再放数据了，只放我们对应一个K值。如果我这只放K值的话，你想一下K不要了，get表要了，ge不要了。你想一下这块的范围是不是会越来越大。

范围是不是越来越大，对吧？这块范围如果越来越大的话，那意味着什么东西？😡，你第二层里面的节点数候是不是会越来越多是不是越来越多？那第三层是不是也会越来越多？那那个时候在计算的时候。

还是16乘16乘16吗？不是了吧，那它应该变成什么样的一个结构啊，来往回看，它慢慢变化的话，就变成这样一种结构了。😡。

然后。第一层第二层我只放K值，最后一层我再放我们实际的一个数据。如果还按照我们刚刚刚刚指定好那样个规则的话，每个块16K16K16K。你告诉我第一个里面能放多少数据。1600这不合适吧。

假如说咱家看一下P1是不是指向一个数据值，P2指向一个数据值，P3是不是指向数据值。假如说他们这样的一个方式，好吧，假如是一组，他们这一组数据假如说占10个字节可以吧？我们为了方便计算啊。

假如说占10个字节，如果这占10个字节还是16K，16的话是16000，那除以10的话，多少，是不是1600。刚刚在前面B数的时候，这些东西空间我都省掉了。现在我把这些空间给加上。

是不是意味着是1600条第一层里面。😡，这1600能听吗？同学告二扣1。你们的问题一会儿来回答好吧，先听我说。能听懂吧？这如果16的话，第二层多少1600吧，第三层多少？😡，剩多少？16吧。

是不是还是16？第三层是不是还是16，你为第三层里面是不是还要放数据的，也还是一KB嘛，对吧？还是1KB所以是多少啊？就相当于161600乘以1600乘以16，这块加起来的话变成多少了。

变成40960000。是不这样一记录呃，是这样一个技数值的。这个时候这个时候你发现了发现什么东西，跟刚刚的B数相比，B数相比比这个跟刚刚B数相比，它这个数据量是不是成指数级上升了，是不是4000万了？

是不是这意思啊？当然我们这种算法啊这种算法只是一种最low的算法，或者说最不准确的算法，但是大致可以这样估虑估算出来。

系列 2：P43：MYSQL调优：0.3 索引的分类及应用场景 - Java视频学堂 - BV1Hy4y1t7Bo

大家可以做动做做这样一个估算，明白我意思吧？这是为什么mexico里面要用成我们对应一个B加数，对应这样一个B加数。1600没整明白。每一个磁砖块是不是16KB16KB换成字节的话。

是不是16000乘以1000嘛？1K是不是1000，但一K是11024嘛，我们把24给省掉，简化就算1000是不是1000。我这一组，假如说我占10个字节，我除以十0是不是1600条？在前面B数的时候。

我把这些空间都没算，只能放16条。现在是不是把它给算上了，是不是这样的数据量？对吧那这块算完之后，你会发现是不是已经达到千万级别了。那这种方式的时候，是不是就效率比较高了？听白意思了吗？听白意思吧？

第一层为什么只有一页，你肯定要有一个根节点吧，这是不是就根节点？😡，是不是跟紧点？你不可能上来之后，就是N多个分支节点嘛，肯定是根节点，对不对？😡，第三张，为什么1616K16K1条数据占1KB。

那是不是16？是不是16？为什么十字节？我们说假设嘛假设我们把它算了十个字节嘛？😊，Good。我要崩溃了。😊，明白了吧？都是预估嘛，都是我们我们总要给一个数，对不对？总要给一个数吧。😊。

所以这儿会衍生出来一个问题，什么问题呢？所以经常们老师这个mycyclcle里面这个必加数，B加数到底是三层还是四层？听没我问题啊，mycyclcle里面必加数到底是三层还是四层？

你们有人被问我这问题吗？😡，有说三的有说四的这块我来给大家说一下给大家说一下。这个三层和四层不是规定好的，不是规定好的，也不是我们默认来进行一个设置的，不是这样的一个方式。这个层数三层和四层对。

指的深度指的深度指的深度。这个东西是取决于当前的一个数据量的？因为之前我们是不是指定了一个值叫什么？叫deggrade，是不是有个东西叫接。deg什么意思来着？如果你deg等于4的话。

意味着只能放三个数据。如果你这个d等于等于呃5的话，只能放4个数据，这只是一个量级。为了在这个图里面好展示，但我也说过了，这里面它表示的是一个磁盘块的数据，所以磁盘块数据的话，意味着是16KB，对不对？

是不是16K16KB的话，那意味着我要让这16KB尽可能多的去存储我们当前的一个数据，是不是这意思？因为里面存数据越多，那意味着我现在能存储的数据量就越大了，假如说现在你用一个ink类型的值。听我说啊。

假如现在你用了一个int类型的一个值去设置我们当前所有的K了。你告诉我这个degree是多少，degree是指定好的吗？😡，是执接好了吗？不是吧，应该怎么算。

是不是拿你当前这个数据块的总大小是不是要除以你当前一个值一个值占用的一个长度？这个之占占用的空间，你是不是算出来我们整体的一个der位了？😡，你算完之后，你想一下它是不是就能存多少个范围。

那一层一层时候马上延伸就可以了。所以三层跟四层不是人为指定的，不是人为指定的啊，决于你到底要用什么样的方式来存储。所以你们在公司里面在设计索引的时候，你告诉我。😡，int类型好吧，one叉类型。

太词类型。你告诉我你用什么类型来存。😡，用什么来型类型来说啊？肯定思吗？这是为什么很多人告诉你说，你不要去用外它类型来存储我们的索引。为什么在这儿它会占用掉我们很多很多额外的一些空间，额外的一些空间。

😡，啊吧，这会导致你的树有可能会变深。啊，所以所以越小越好，就这意思。听白意思吗？好吧，这大家一定要注意了大家要注意这大家一定要注意了。好吧，这是为什么后面的时候后面的时候。我举过这样一个例子。

举过这样一个例子，举个什么例子，我给大家看一下，在优化这有一个东西，我给你们提前看一下。好吧，这东西咱们都要讲话，咱们咱们都要讲了，别慌，好吧。

我找一下。

来往上看，咱们讲到这就说了，好吧，说了说有一个东西叫前缀缩引。这个前缀索引什么意思？签诉什作音什么意思啊？非常简单啊，我来举一下这个例子，举下例子看一下你们知道什么意思了。

觉接就看一下就知道知道什么意思了。我现在有一个数据库表，数据库表，这个表里面有一个字段叫CT字段叫CT。在当前这个CT字段里面。😊，它长度是50，长度是50，对不对？我可以干嘛？我在实际做的时候。

可以把这个50来截一部分，我把它运行一下吧，好吧。

我们讲这，我们把个例子来演示一下，好吧，演演示一下啊，大家知道都要演示的哎。可以的。对ta贝ase andB。

然我创建一下这张表啊，我直接运行了。好吧，这命令我不给你们粘了啊。

O。我们这只是为了造造数据，好吧。😡。

嗯。😊，这儿哪有问题看一下，把这一据拿过来。

表已经存在。哎，是这么干的呀，insertupdate。

CTdeCT等于。这移动不够用啊。所以试一下说哪哪哪哪哪写错，这里边是不个东西啊。

做化 database。

是。核示一下啊。

No delivery slack。又是MSB。Create database。钥匙。USB，然后瘦黑。好，没有了，下重新建一下啊。现在好了吧。In色的C demo。

Sa the city。诶。这什么问题啊？cre以的这张表因素的这张表CSCD防CT。这个表没有吗？算了，我们又会来演示吧。CTdemo。

这有Cde啊，这CD表没在啊，我等一下找一下吧，找一下这个CD表好吧，那我们这不演示了。好吧，现大家说是什么样一个什么样一个例子啊，这个例子啊非常非常简单，非常常简单给大家说一下。

就是说我们现在我们现在有1个50个字段的1个CT的一个东西。😊，不慌，好吧不慌不慌好吧，那个表里面有数据，一会儿我找一下那个数据，找一下数据，好，找一下数数据。好吧，这有1个CT表。

表里面有1个哇差的一个字段。我们每次在创建我们当前索引的时候，你可以用这样的方式来进行创建。什么东西叫left city3，这什么意思啊？

来看一下这个东西啊，我们可以这先见一下叫。要der。tableable保养的C。demo，然后呢艾 index IDDX下划线。City括号。Left。括号上写一个CT逗号3，有人写过这样的语句吗？

有没有写过这样一句？前面我们本身只是为了创建我们对应一个索引，对不对？这东西应该都见过。但是我后面指定字段的时候，你们原来写的时候都直接写1个CT完事了。但我现在引入一个什么呢？叫left的一个函数。

是啥意思？我从左只取前面的一个三位啊，你这我就有问题了。index left city。我靠，今天晚上出事不顺。艾 index ADX下线。Left。CT逗号3。这会有问题吗？不靠啊，疯了吧，1莱他。

C体 demomo。発生。有C一的字段啊。alter table C demoad index IDDSEle C3。这有啥问题？全体起立下课。这只是表啊，修改这张表里面这个索引啊啊。😡。

这这店铺我认知了啊。没收过。创建。所以。我天哪。这宇就都记错了。谢谢啊，张小天。可不。Table name。带的已经带的是。这样创建的吗？看到吗？使用这个语句，还得in in that name。

我站一下。不可能啊。找一下这改一下这名字。CITY干吗？in袋一。这写一个。City。没问题啊。left括号。C题逗号3括号。

不能用lifeft的。哦。看了吗？不用不用不用来他啊哎。😊。

不知道咋回事。这直接写。CT括号。这样写行了，这边这样写就行了。😡，2。好了吧，这样写法，刚才写错了啊，left让他看。这是不是也写了啊吧，这块呢。

这意思就是说我可以指定前三个对应的一个索引值是这样的一个方式啊，这样一个方式只取前三个是前三个只取前三个啊，那他说老师，你这儿我怎么来判断说我到底用的是前三个前四个前5个还是前六个啊。

这个东西我该怎么来确定啊？所以在这里面在这里面会引入另外的一个名称，另外的名称，什么名称呢？往上看叫它索引的选择性，所引选择性。也就是说也就是说你可以用来进行对应的一个查询，进行一个判断。

判断什么信息呢？判断一下，我当我截取多少个的时候，跟我全量的数据是一模一样的？

好，我截多少的时候跟我全量数据一模一样的。这样的话我可以来实现对应的一个方式，实现对应的一个方式。这儿我没这样提前没准备好数据啊，抱歉，没准备好数据。这儿有数据的话，我们这儿可以做一个演示。

明天我承诺啊，明天大家进来听课，明天我把这个呃我把这个东西给大家演示一下，大家演示一下，好吧。给家演示一下OK。

休息啊，咱们扔一边，好吧，扔一边。好了，接着说回我们对应索引的一个事儿。

说是我们所有的事啊。所以通过这样方式，你发现了我如果有一个三层的一个必加数的话，几乎可以支撑什么呢？叫千万级别的一个数据量啊，千万级别的一个数据量。大家想一下，有同学老师老师到底是几千万啊。

是2000万、3000万、4000万还是几千万，这个怎么确定啊？冇。啊。我要把这天东西讲完才会停播，好吧。看第个位大小好了，这块要根据你对应的一个索引大小来进行判断了，没有一个具体的准确值。

所以你们也不要去问这些准机值没有意义，听白了吗？你根据你自己的一个硬件去进行实际的一个测试和评估，测试的一个评估，评估完了之后就得到一个具体准机值了，就准确值了。这个图一会儿这个这个图一会我会发啊。

一会儿会发OK。性能测试搞定好吧，所以当你这块来计算完成之后，计算完成之后，最终我们得到一个结论，my circlecle是不是选择了B加数这样的一个方式？现在为什么选择B加数能听麦？同学给老师扣波一。

好了，这门题之后这门题之后，在毕加数里面，它还多了另外一个特点。我这儿还要强调一点，刚刚只是说我建了三层，对不对？除了这三层之外，你往这看。你往上看，你看这两个图，除了这个节点这个重复之外。

还有没有什么不同的点啊？这个B数里面它每一个块就是每一个块是单独独立的，但是在B加数里面，你发现了它是有一个箭头指向的吧。这啥意思？这啥意思？意思是这样的，也就是说在我们当前的一个mycle里面。

当你使用B加数之后，你在进行数据查找的时候，可以使用两种方式，一种方式是通过根节点一层一层往里边进行一个查找，这第一种方式，好吧，还有第二种方式什么东西呢？它底层会有一个双向链表，双向链表。

我这标的是双向好吧，标双向标双向列表，你可以从这个节点开始，然后呢，按照顺序进行整体这样一个查找。也就是说它支持两种查询方式啊，支持两种查询方式所以你要取决说我到底用什么样的方式来进行合理的一个查询了。

这不是写了是一种是对主键的范围查找和分析查找。另外一种是从根节点开始进行随意查找啊，有两种方式，两种方式。うん。🤧明白我意思吧？啊，那怎么从磁盘块四开始呢？它在读取的时候会存储这样的一个数据值。

会直接把因为这个B加数里面啊，它些数据都是有序的都是有序的。所以我可以直接把数据进行一个读取。啊，都是进行有血，写的优先级高，这个东西没有优先级。my circlecle里面有一个组件叫优化器。

优化器会选择一个合理的方式来往里面存储我们对你来执行我们的数据。到底是从根节点开始找，还是从我们下面这个呃最小节点里面，叶子节点里面开始进行查找。听白意思吧？好吧，请问排序是在存时做的吗？对。

是在存的时候做的是在存的时候做的。排序过程啊，一定不是说后期维护的时候做的，一定是说我们在插入数据之前，就把这东西给大家做到啊，可以人为干预吗？不可以不可以。不可以，好吧。不只是叶子节点吧，啥意思？

没听懂。好了，这块东西能听明白吧？来听懂同学第二个扣个一这东西。好了，这只是B加数这样一个数据结构。下面问题来了。刚刚老师跟说了老师，你刚刚讲的这个东西是my some的还是inowBB的？

是哪种数据结构的呀？这儿给大家说一下，我在下面这块，我标注的是什么叫date，看到了吗？我标是date，我并没有标一整行的数据，所以my song和inow DB他们都是采用这样的一个数据结构叫B加数。

只不过他们最终这个date里面放的东西是不一样的。date里面东西是不一样的。听白了吗？这里面数据是不一样的啊，怎么不一样，往那看。😡，inow地B这种存时引擎，它在最后面的数据里面放的是什么？

放的就是你实际的数据，注意啊，实际的整行数据，一整行数据。实际的整行数据好吧，而如果你用是my sum的话，它底层放的是什么？放的并不是整行数据的，而放的是什么？是一个地址。

我要根据这个地址去读取到数据所在行，然后把数据给读过来。这是为什么你在inDB存储引擎里面的时候，你看到是一个叫IDB的文件IDB的文件。而在我们对应的一个mysome的时候。

你看到是一个什么MYD和MYI的文件。好，这他们两个之间的一个区别，懂我意思了吧？好，懂我意思吧？这儿大家一定要区分清楚了，一定要区分清楚了，好吧。就他们俩之间区别，别东西别东西别东西没啥了啊。

别东西没啥了啊，这儿没啥之后来往这看。刘涛老师，你这里面这个K值到底指的是啥？有人把它叫做主建。是主件吗？问一个问题啊，这儿是主件吗？是不是主建？这个K。在那个书里面写的时候啊。

它翻译过来叫primary key。我们把它翻译成主件了。但这个主件这个主件给大家说一下，跟我们之前你们认知的那个主件是不一样的啊，是不一样的啊，那这东西到底是啥呀？这儿来给大家说一下。

因为我们在创建表的时候，有可能你没有制定主件。是不设置主件？如果我不设置主件的话，我应该怎么做？😡，是不是这意思好吧，所以这块你在聊的时候要牵扯到另外一个问题了。我这儿到底这个K值存的是啥？听完了说。

我这写了说如果你在进行必加数呃，应owDB这种存储引擎进行数据存储的时候，好吧，如果你有主键OK我按照主键进行主件进行这样一个索引创建。好吧，然后呢，子点里面存放记录。如果没有主键。

那ok我会选择唯一键。同说啊，唯一键如果唯一键也没有的话，怎么办？我会生成一个六字节的row IDD。而那个row IDD对于用户而言是不可见的，听明白了吗？对应化言是不可见的，你永远看不到的东西。

我永远看不到东西，但是我必须要按照这样的一个方式进行数据的一个组织。这行数据的一个组织原因是啥？别人是啥？😡，原因其实也非常非常简单，这样给大家说一下，这就是你们在面试的时候经常问的另外一个问题。

到底什么是剧促索引，什么是非剧促索引啊？这东西怎么解释？什么叫剧组？什么叫非剧组？啊，这啥意思？这是你们面试常问的问题啊？什么叫技术索引？什么叫非技索引这块给大家来说一下给大家来说一下好吧。

所谓的剧组索引和非技索引更多表的是表示什么？是你数据到底是怎么来进行存放的，进行怎么存放的。B就是技组索引用用技组索引。而my用的就是非技索引，就取决于你的数据和你的索引是不是放在一起的。

是放在一起的啊，当然放在一起的时候，那个K值可以是主键，也可以是唯一键也可以是一个六字节的roID六字节的roID。明白我意思吗？听我意思吧？啊，这块希望大家能分清楚了啊。

这个剧组索引跟非剧索引的一个区别到底什么时候应该用什么样的方式啊，老师是不是一个索引对应一个数啊？对，比就说你在往表里面插入我们对应数据的时候，如果你有主件啊，或者你不管有没有主件，我在数据插入的时候。

我就会有一个K值。就会有一个K值就会K值。而那个K值指在的可以是主键，可以是唯一键，也可以是一个roID它必须要这么放必须要这么放。每次你在进行数据值的一个查找的时候。

我要根据这个K去找到我们对应数据了。啊，这个所引是不是不是列值吧，是啥意思？你说啥？好了，新说了剧左引数据和索引放在一起inowDB非剧左引不在一起mysome。对，就这意思。啊。

那我DB创建三个索引和数据一起，岂不是放三份数据？OK这是另外的一个问题。SLTIN同学他们他说那我DB如果创建三个索引和数据一起是不是三份数据，这就是计组索引涉及到另外一个点了，什么点。

你的主件或者你的K值和数据是绑定在一起的。如果你给其他的任何一个列又创建了一个索引，又创建了一个索引，那O那O这个时候它会做一件事，做些什么事情，当你给其他列来创建索引的时候，它这颗必加数。

B加数最后面的叶子节点里面存放的就不再是数据了。那放什么放的是你在这棵主键必加树里面那个K是啥？如果你用的是主键，O这就放主键。如果你用的是唯一键，这就放唯一键。如果你什么都没有，这就用row IDD。

听白意思吗？明白意思吗？好吧，是用这样的方式来进行实际的一个存储的这是我下面往这放的这个东西，看到了吗？刚刚上面这个图是给ID建了一个主件，对ID是主件建了一个索引，这是我们数据的一个组织形式。

如果我想给内幕再建一个索引的话，会有什么方式，往家看内幕列里面这是不有列名。有个列名之后，我实际里面放式啥？是不是主建那个知道？好，主原值了吧。所以我要根据的主原值，我要查询的时候。

如果按照内幕去查询好，去查询，我先查到ID值，有了ID值之后，我再去根据这个ID值去这棵树里面找到对应的数据返回给客户端。好，是这样的一个方式发馈给我们对应的客户端。所以这大家一定要注意了。

大家要注意了。刚刚我看有同学问个问题，说，老师为什么关于数据库里面，它推荐我们要使用主件自增啊。你们推荐使用主电自动吗？没有问题。这个ID自能要不要用啊？推荐不推荐。

给大家说一下给大家说一下这个东西啊取决于你到底你的数据库是单机的还是分布式的。如果是分布式的，如果是分布式的，不建议不建议。啊，如果你就是那些单体的一个系统，非常非常建议你使用主键。

所以跟业务场景相关啊，如果你是分布式，OK不推荐啊，不是分布式的OK非常推荐。为什么？😡，当你的主件如果是自增的话，你告诉我，我现在往里边插入我们对应元素的时候，插入对应元素的时候，我怎么插？怎么唱？

你想想刚刚我们在插数据的时候怎么插的，是不是一直在向最后面这个节点里面添加数据是吗？后面直接加而如果你这不是自增的，是一个乱序的话，会有什么效果？他可能会往中间某个经验里面插数据。

英老师中间插就中间插呗，这有什么关系啊，关系大了去了。假如说你中间这一块。数据满了。满了之后，你还能往里边插数据吗？不能了吧，如果满了不能拆了，那里面会涉及到另外一个问题，什么问题？对叶分裂。

叶既然能分裂的话，那意味着还会有什么东西？还会有叶合并。老师，这个东西很简单呀，不就个分类合并吗？我把一个文件拆成两个文件不就完事了吗？告诉你没这么简单，为什么没这么简单？我刚刚在演示这个动态图的时候。

你会发现它一层二层就二层一层里面这个节点值是一直在变化的吧。😡，是不是一直在变化的。就是说你看起来好像说我直接把最后的数据页来做了一个分裂，来做了一个合并。但其实它是能够直接影响上面的这些索引页的。

你像索引业的，所以这个时候你的系统维护会变得非常非常麻烦。要师不就16KB吗？很快嘛？如果你有N多个人并行查询，你告诉我怎么做。听白意思吧？所以这件事情非常非常不推荐，一般都用是自增，都用是自增。啊。

改分布式的时候，分布式里面有自己的生层策略，你可以自己指定一个主件生层策略，也可以用循环算法啊，也可以用循环算法。这在分布式里面用的比较多的。O。那插入多了也不一定不也得做一分页页分别分裂合并吗？

是得做是得做是得做这个做是没办法。但是如果你是自增的话，如果你是自增的话，自增的话会减少整体业的一个合并和合裂合并和分裂的过程。如果你不是自增的话，可能要进行频繁。这里面就是索引的一个维护的东西了。

所以维护的东西了。听白我意思吧？好，这大家要注意了，大家要注意了。OK来刚刚描述那些点，听麦同学告着扣扣一。没有吧。啊，这东西难吗？你们觉得。咱们花了一个半小时讲清楚这这这东西你觉得难吗？还好是吧啊。

还好来上难度，这只是基础东西，好吧，就是基础东西。下面来说几个名词。呃，没关系啊，咱们两个小时课讲不完了，讲完咱们就往后拖啊，往后拖没关系的，好吧，小事儿O。😊，来上难度好吧，什么难度呢？😊。

现在提几个名词，提几个名词，什么名词呢？第一个回表。啊，第二个名词。缩紧覆盖。第三个名词，缩引下推。第四个名词。最多匹配。来这四个东西这四个东西之前听过同学扣一，没听过同学扣2。哎。好了。

现在课外人越来越多了啊。😊，是啥意思啊？来，我们挨个来解释一下这东西，介绍这东西。我告诉你这东西啊贼简单贼简单。好吧，嗯名词看起来好像很厉害的样子，我点着烟好吧，抽根烟好吧，抽根烟啊，这个烟也比较大。

okK这个东西啊特别简单。你听这些名词的时候，感觉哇塞，这都什么东西好吧，但其实很简单，好吧，一解释就说了，一解释111一解释就会了，好吧，来挨越看第一个叫回表，什么叫回表。😊。

是是汇表拉往来看在刚刚这个缩音系统里面好吧，我这是不是建了1个ID的一个主件索引，是不是主件索引好吧，同时我是不是给name给name是不是也建了另外一个索引，就是我们下面这块是不是另外一个索引，对吧？

假如说现在我写了这样一个circle语句，什么ci狗语句叫st。然后呢，星 fromtablewhere什么name。等于一个值。当我写这个语句的时候，你告诉我我是不是应该会走索引？😡，是不是所以？

因为内是一个索引链嘛，我先要根据我们当前这个内目值去这棵必加树里面找到，比如找马老师，我是不是根你这个值去找一匹秒马老师OK找到马，我返回值是谁，是不是这个ID值。当我取到ID之后。

我明明需要是星这一行记录里面可能包含了N多个列，是不是N多个列，那下面你告诉我应该怎么办？我是不是要把这N多个列要进行数据的一个查询了。所以此时会把这个一的值带回来，带回来之后找到这块。

系列 2：P44：MYSQL调优：0.4 不同存储引擎索引的区别及数据存储方式 - Java视频学堂 - BV1Hy4y1t7Bo

是不是30几50几要找到一，一是匹配到马老师是把数据直接翻了回去了，也就说当你在用这样的方式查询的时候，是不是查了两颗b加数，第一颗是内部内列的比加数，第二颗是i d这类比加数，这个过程就称之为回表。

明白意思吗，所以什么时候会触发回表，一般当你在用什么用二级索引，或者说用辅助索引的时候，才会用我们的回表，好采访有回表，注意啊，有人叫二级所言，有人叫呃那个那个二级索引啊，不是有人叫二级索引。

也有人叫辅助索引，无所谓啊，无所谓啊，就就就就就这意思这么难吗，啊会很慢吗，好了问题来了，所以解说这东西会不会很慢，会不会很慢慢不慢，取决于什么东西，你想一下你们应该有这样的一个生活经验，什么生活经验。

你现在给一个数据库建一张表表，里面有id，有内幕两列对吧，然后那id是主键，内容不是主键，现在你往里面插了20条数据，注意啊，20条或者说非常少的数据，非常少数据，这个时候你又给内部列创建了一个索引。

传言索引，现在你在用内部查询的时候，你发现了我用内部查的时候反而不如用什么，就用了内部索引之后，反而不如不用索引的速度快，是不是东西就为什么数据量小了，我也见索引啊，速度反而会非常非常的慢，为什么。

不会一定会慢的，你下一周自己去查，一定会慢远一点，就在于它触发了回表，假如说一次b加数的搜寻是要走三次i o3 次i o，而现在我要走两次b加数，是因为六次i o我就算全表扫的话。

是不是也用不了多长时间，是不是这意思啊对吧，所以这时候反而数量慢，一定是什么，一定是数据量大了之后，你的二级索引或者说你的辅助索引才会能看到对应效果，如果胸大小的话，是看不到对应效果。

就这块产生的一个原因，io的问题，明白意思吧好吧，这就要注意了，这一定要注意了好吧，刚刚是回表，来听麦同学扣一，明白了吗，好吧，听完之后来第二个概念叫索引覆盖，什么叫索引覆盖，来一样的意思一样一样都写。

我这儿再写两条sql语句，sat星from table，where name等于一个问号，再写一个swe id from table，where name等于根号，这两条sql语句，这两条sql语句。

你告诉我像我一样吗，不一样有什么不一样的地方，第一个语句刚刚说过了，是不是一定会触发回表，是一定会触发回表啊，但是第二个语句我需要触发回表吗，不需要吧，为什么不需要我在找内幕这个b加数的时候。

我是不是直接把id给取回来了，是不是id取回来了，我把id取回来了，我这个值是不是就有了，我还需要再去找那个主件b加数里面，去里面再找整个整整行记录吗，不需要了吧对吧，所以这种情况就叫什么叫索引覆盖。

这所覆盖这东西还难吗，不难吧，是很简单啊，ok就这意思就这意思好吧，来再看第三个点什么呢，叫索引下推，这又是啥玩意儿，什么叫索引下推啊，所以下推下推很容易啊，很容易很容易来给大家说一下。

所以下推是这样一个理论知识给大家说一下，现在假如你要查询这样的数据好，先先先说这个吧，先说这个最多匹配吧，最多匹配什么叫做匹配啊，最多匹配这一块，一般情况下一般情况下是不是要跟什么跟组合索引一起使用的。

组合索引之前你们在建索引的时候，可能用的都是单列i d了，name啦，制了可能是这些列啊，都是单列，但其实在工作中你发现你所有的查询语句里面，所有的查询语句里面我都用到了内部逗号age，这两列加多少。

那两列，那可以干嘛，可以把这两列共同一起来创建一个，所以叫name逗号age，好按照发射建一个缩影，按这样的方式来创建我们对应的一个索引之后，所以之后你会发现你所有sql语句执行的时候。

只要查询条件里面包含这两个条件啊，我都会来走当前的所有，那这里面就会涉及到这样一些查询语句，我不写三叉星了，好吧，你写过，什么呢，name等于问号and的地址等于问号。

然后呢where name等于问号，where age等于问号，然后呢where什么呢，age等于问号and等于问号，是不是会触发这样四种情况，当你有这样四种情况之后，有四种四种情况之后，我的问题来了。

这什么叫最多匹配来着，这东西啊就类似于你在呃淘宝网站里面，淘宝网站里边啊，你在输地址的时候是怎么说的，是不是有东西叫3d联动，你先输省才能出事，出了事之后才能出去，是不是这样的方式对吧，这也是一样的。

这是一样的，你要想是这样的方式来建索引的话，那ok我必须要先匹配到内蒙，再匹配到，必须这么干，必须这么干，先匹配内蒙再匹配值，如果匹配到name，不好意思，只是不能用的，所以如果是这样的话。

你来告诉我这四条语句里面哪几个语句会走索引，哪几个语句不会走索引，1243124，看到有人说一二，有人说124好吧，这给一个标准答案，124会走索引好，为什么大家看一下name age。

它它两个东西放大一点，name和age是不是匹配到这东西了，他肯定走name，是不是第一列呀，我匹配到第一列是不是也会走的好吧，第二列是不是匹到age的name是不是没有，那如果没有的话，不好意思。

这是不会走的，人不会走的好吧，那四为什么会走啊，还是记住了，在msl里面有些东西叫优化器，这个优化器很牛很牛的老师，我们现在不是有一些优化吗，我们现在不要做mysql调优吗。

对你做mysql调是要调整你的sql语句，调整你的架构，调整你的设计，调整你的参数，调这方面在msl本身里面也带着一个优化器啊，这句话器有两种选择模式，一个叫cbo，一个叫r b o。

刚刚我看到同学打打打这东西了，cpu什么意思，cpu叫基于成本的优化，ibo叫基于规则优化，现在大部分的这种数据库在选择的时候都会选择基于成本的优化，就说什么样的效率越高，什么效率越高，好吧。

他又会选择什么样的方式来进行执行，所以当你运行第四条sql语句的时候，第四条sql语句的时候，他会把你当前这个查询帮你做一个优化，用什么方式会选择内部和age的顺序做一个调整好。

会把内部放前放后位置方号明白我意思吧好吧，这样大家一定要注意了，大家一定要注意了好，所以124这三个都会走，所以而三不会走，而三不会走好吧，所以这就叫什么叫最左匹配原则，明白意思吗，明白了吧好吧。

my sql里面默认是cpu pole里面是有r b o和cpu的好吧，执行一下这个东西下去之后，自己演示的时候，一演示就出来了，如果你演示的结果不对，你找我保对好吧，你现在说自己可以演示。

如果你演示结果不对的话，你找我，ok，你建一个表，往表里边给这两个列建一个组合索引，建完组合索引之后，然后你写下思路语句，你查一下试试，查一下试试。

哎呀大哥们，来我见一下好吧，内部，位置啊不对，不能这样讲啊，table然后test，id逗号，这个你一眼就出来了，好吧，这样写一个十，假如我写这样一句，可以吧，然后呢。

这写一个alter table test and index i d i d下划线，test括号，是索引啊，show index from test，这是不是有一个索引了，我先查一下语句。

行from test，where name等于张三，and age等于十，看这块有用，索应了吗，用了吧好吧，然后再往下看，我把这个a值删掉，是不是有这个k值对吧，再往下看换一下，这等于十有作业吗。

没有吧，来再换a就等于它and的name等于呵呵，有没有作业出来了吗，是不是四种情况，他就做匹配了吧。

这不是出来了，别的懒得动手好吧，这个很简单啦，很简单了啊，这就叫最左匹配啊，最多匹配，ok好了，就这块来这个第一慢了吧，明白了吧，好听完之后来再接着往下聊，再接着往下聊，聊另外一个名词叫什么叫索引下推。

这个索引下推什么意思啊，它是5。6还是5。7来着，我忘了是哪个版本之后才有的一个规则，还有规则什么意思呢，就是说select行from table，写一个where name等于根号，and值等于根号。

假如说我现在是这样一个sql语句，你告诉我我实际在进行数据存储的时候，我会在我会怎么存，我会怎么存这个东西哦，一会儿再说哦，一会儿来说，算上一会儿再说好吧。

先看这块这东西在筛选数据的时候到底会怎么进行一个筛选，怎么进行筛选。

我看刚刚你这边有没有显示出来的东西啊，啊没显示出来。

还没显示啊，告诉大家这块什么意思呢，就是我们在实际数据筛选的时候是这样的过程，数据一定在磁盘里面放的数据存储磁盘好吧，然后这意味着mysql有自己的服务，是这样的方式，所以每次筛选的时候一定是干嘛的。

my sql服务要跟什么呢，磁盘发生交互吧，在原来没有这个索引下推之前，他是怎么做的，是这样做的，说select会，再写一下没有，所以下推，这时候我会怎么做，sd先从存储引擎中，中什么叫拉取数据。

这个数据什么意思，是根据name筛选的数据，是第一步好吧，再回来之后，然后呢在服务层，在msl，server，然后呢根据什么age进行数据的筛选，大家看到了是这样的一个方式啊，先根据内容把数据拿过来。

拿过来之后拉到我们的server层，在server层里面再进行a h的一个筛选，是这样的方式好吧，而如果有了，所以下推他会怎么做呢，啊会在拉取，数据的时候直接根据name逗号age来获取数据。

不需要在服务层，在给服务层了server做任何的数据筛选好吧，这个过程就会搞，所以下推大家看一下这个下推指的是推到哪儿了，什么叫下推，现在理解了吗，怎么样下推，原来是先根据一个字段。

然后呢把数据拉回来好吧，拉回来之后拉回来之后，然后再根据进行一个筛选，然后现在呢筛筛选的时候是直接根据内部和h来进行一个筛选，筛选完之后直接返回我们对应的结果，明白意思吧。

好就就就就就这这样一个意思好吧，这叫随性下推，随心下推，推到我们数据筛选环节，原来是在服务层做的，现在是在数据筛选的存储引擎层来进行一个实现的来进行实现的，他这个东西啊不是让你自己来选择的。

不是你自己选择的，是在5。6还是在5。7，我忘了哪个版本了，那个版本之后他又做了一个修改，好，哪个版本里面只做了一个修改之后，就都用到我们对应一个数，都对应一个数据下推了，我忘了一个版本了，好吧。

ok 5。60吧，ok好了，5。6这样的一个问题，那为什么不选择索引下推，给大家说一下，索引下推会有问题，所以下跌是会有问题的，有什么问题来你告诉我孙一下，有什么问题，有什么问题是这样的。

你想一下这个组合索引在我们实际数据存储的时候，实际存储的时候，它会怎么进行数据存储，怎么进行数据存储，也是组合作用，我到底是怎么存的，这怎么存档，啊数据查询不全吗，不是这意思，现在我有两个列。

我有两个列，这两个列在进行数据的一个交互的时候，你告诉我，你告诉我我这两个问题应该怎么存放器怎么存，那现在有一堆这样的数据，看着我拿整数来举例子的话，整数举例子比较比较比较容易一点对吧。

呃假如两列都是整数，两列都是整整数，两个b税不是就一个就一个就一个好了好了，r2 说对了，是这样的，比如说我现在有一层，就这层里面我写了一些数值，什么是二根号四。

然后后面呢这再有一个东西范围是三根号五这样的范围，下面这层几点里面筛选的时候，左边这块是什么，是类似于这样的形式，比如说一逗号二，然后呢呃一逗号三，然后呢二逗号三括号，然后呢二逗号四。

这是这个里面指向的一个数据，指向一个数据啊，这是这个节点指向一个数据，那中间这块可能会有什么，会有二二逗号六，然后下面呢可能会有三逗号五对吧，然后后面这儿可能还会有括号，三逗号七，四逗号八。

看到这意思了吗，跟笛卡尔积没关系，好吧，这是name，假如这是name，这是他在组织数据的时候，是按照这样方式组织组织了，所以我会先比较第一个列的值，第一列也值，有了之后。

我是不是在比较我们第二个的值是不是这样一个方式，当你在使用这样的方式进行数据存储的时候，如果你两个字段听我说啊，如果你两个字段，两个字段在进行数删选的时候，你只看后面的东西，你还能取到数据吗，取到吗。

因为你第一个根本拿不到，根本拿不到其他更多类似于什么，类似于是一个二元组，是这样的方式，必须要先比较第一个，再比较第二个，就这样的方式明白意思吧，好这个大家要注意了啊，这东西就叫索引下推，索引下推听。

麦同学给老师扣波，一能听懂吗，没懂都没理解啊，我们这里面在进行数据存储的时候，在进行数据存储的时候，上面这个值这是不是一个范围，这是不是一个范围，小于它的值，在这边放放着，在两个中间的，在那放着。

然后大于它的话是在这放着，怎么写的东西啊，是不是只让它好吧，然后中间范围是不是这样，它然后大于它的话，是不是只按这样的方式，你在考验我的画图功力啊，是不是这样的方式啊，这这这样这样东西24分别是什么。

name和a的这一列呀，这一列里面的一个值啊，这一列里面的一个值啊，它在数据组织的时候就是按照这样的方式来进行组织，原来我在进行索引下推之前，所以现在之前我应该怎么做，原来我做的时候。

我直接把这个值只要能匹配到，只要能匹配到，我直接返回去，我直接反弹回去，是把之前是不是直接把这呃这这这写错了三四这写错了啊，343434这写错了哦，34234我是不是直接匹配到第一列值之后。

我返回去返回去之后加载到我们对应一个服务里面，服务里面直接做筛选就完事儿了，好吧，现在呢现在怎么做的，现在是说我要在这个层面，我先去筛选我们的内幕，再筛选我们对应的一个值，然后返回回来之后。

我再去把数据给返回回去，他有什么缺点，有什么优点啊啊缺点和优点优点非常明显，当我没用索引下推的时候，没用索引下推的时候，很明显你这个i o量是非常非常大的，i o量是比较大的，所以你的速度会比较慢。

会比较慢，因为呃会比较慢，而现在呢当你使用索引下推之后，使用索引下推之后，他是不是要把这个东西匹配，把这东西匹配先匹配第一列，再匹配第二列，你匹配匹配完成之后，返回的数据值一定是少了吧，是不是少了。

是不是io量上面应该是少了，是不是l o l上面是少了，io量少了之后，是不是性能就有所提升了，那老师，那为什么刚开始设计的时候没有这么多设计啊，为啥刚开始做设计之前，那个时候机械磁盘的速度说反了吧。

我说反啥了，顺一下推，顺一下推，刚开始为什么没用，为什么现在用了，为什么5。6之后用了5。6之前没用啊，原来是啥，想一下26对吗，为啥不对啊，这不是24吗，这不是二四吗，24是这个范围。

26是不是表示中间的一个值对吧，就是因为我们硬件读取的一个成本，我们一直在说说磁盘慢慢慢慢慢，磁盘是不是很慢对吧，磁盘再慢，听我的问题啊，你磁盘再慢，你现在只是相对于我们的内存而言的吧。

再换句话说你能不能换成ssd，但是你想一下内存是非常非常宝贵的资源吗，如果把全量数据都加载到内存里面去了，你想一下，如果占用了其他空间，导致你其他应用程序运行慢怎么办。

是不是意思啊啊它是有一个时间年代来发展的，就好比之前你在问一个问题，说老师现在索引里面在建索引，在进行加载的时候，是指加载根节点吗，听到我的问题啊，是指加载根节点吗，我说了int类型值好写。

所以我就写成int了，不是吧，不是吧，为什么这个只加载跟腱，这种说法是在原来很早很早之前，你的内存只有照级别或者只有kb级别的时候，那个时候说的，但现在很明显已经不适用了，你现在随便随便呃，就是怎么说。

你现在随便一个电脑是不是都是16g的，是不是都是16g的对吧，现在像像我个人笔记本，我这我这笔记本32级的这个人pc啊，你服务器128g起步吧，是不是这意思啊，这大家一定要注意了，大家一定要注意了。

ok所以内存越来越也在变大了，也在变大了，所以这些东西啊是跟它的历史发展年代相关的，所以所以现在我说了半天还没明白，你在做数据筛选的时候，在做数据筛选的时候，数据筛选的时候，现在先筛选第一个。

再筛选第二个，这些数据的查找是由谁来完成的，是不是需要在磁盘磁盘里面完成的，是在磁盘里面完成的没用，所以下去之前是不是在内存里面完成内时候，内存数据不是比较宝贵，现在而言，现在而言。

你的磁盘性能是不是也可以内存，大家想一下，你内存这块东西是不是可以变大了，但你磁盘这一块还是像原来那样一样那么慢吗，不是的吧，所以他是不是把它换成了我们索引下推这样的一个方式。

所以说现在是不能在磁盘里面直接做了，而不需要把它加到内存吧，是不是减少整体的io量，而且现在更多是什么，你不要老师，我感觉没多多少吧，好像也多不了多少东西，但你别忘了别忘了现在更多是什么，是这东西。

是这东西是并发，是并发，是并发，如果变化大的话，有可能有n多客户端都需要把我们对应的一个数据加载到内存里面，你内存能给多大，就算128g的服务器，你能给多大好吧，而且还跟你的带宽是相关的。

是不是带宽相关，明白我意思吧好吧，所以这块我们就把它放到下面来做了，不要往上面去做了，就这意思就这意思好吧，但是io是不是少了，io量是不是少了，这没问题吧，再说一下现在推荐使用。

现在说一下推荐使用磁盘下推啊，不是索引下推好吧，推荐使用索引下推这些东西啊，就好比是这样一个东西，你往下看，我写这个，你看你能不能理解啊，sat t1 ，点a name，逗号t2 。

点name from t，joy，t22 t一点，id等于t2 点来，你告诉我，你告诉我这块东西，这块东西这个sql语句，这个sql语句在执行的时候有几种方式，挺好的，几种方式，两种三种还有三种的。

还有三种呢，这几种方式两种吧，第一种方式是什么，先做表连接，然后查询，需要的字段，把第二种方式呢先把需要的所有字段都拿出来，然后再做关联，是两种方式，你告诉我一和二哪种方式好，1号啊，1号啊，看数据量。

现在我们在聊的时候聊大数据量，可能聊大大大大大的数据量这块儿给大家说一下，二一定是好的，像这条sql语句，假如说我这个表里面假如说有100个列，你把100的列做一个关联。

它是要变成一张临时表或者一张虚拟表，是不是一张虚拟表对吧，现在呢我是不是只需要提出四个字段，四个字段我做完关联之后，我是把需要段是不是拿出来就行了，这个时候你是不是学四个字段。

这两个的i o量是一样的吗，这俩io量是一样的吗，不是吧，是不一样哪，还有量小，是下面还有量小对吧，这东西叫啥，这东西啊，也有一个名词，也有一个名词，什么名词叫这东西，这个东西好谓词下推，叫谓词下推。

所以啊它这儿也有一些名词这块儿，你尝试着去理解，或者说尝试着去了解这块东西，ok啊这我解释一些东西好吧，淡定老师，所以现在是人为干涉的，还是mac和mac机制，据我了解，现在我这一套参数没有参数能控制。

就是版本这个不同版本里面有这样一个方式，刚才说了是5。6，这个版本里面自带的好吧，你下一周可以自己看一下，你下一周可自己看一下，ok人生如戏，为什么搞这么复杂呢，mac就能不能自己管理。

所以智能管理数据库的发展趋势是不是会走这个发展下去，真要那么真要那么智能的话，那还有啥可说的呢，对吧，索引下推，所以下推，唯一的缺点是需要在机械或者需要磁盘上多做数据筛选，原来的筛选是放在内存中的。

现在放到了磁盘，查找数据的环节，的环节，这样做看起来成本比较，但是别忘了数据是排序的，所有的数据是聚集存放的，所以性能不会有影响，而且整体的i o量，会大大减少，反而会提升性能，听明白意思了吗。

现在我写的东西能不能理解，能理解吗，好吧，好这个问题再有这个问题再有问题，下课来找我好吧，下课来找我，ok就是你在很多同学会，很多同学可能会感觉说我在磁盘里面做那么多的一个数据筛选工作。

可能会成本会上升，可能成本会上升，就你想一下，原来我在筛选的时候，我直接匹配到这个数据之后，拉回去就完事儿了，我现在除了匹配第一个字段之外，还要匹配第二个字段，我的成本是不是可能会高。

是不是这种可能可能性会高，这也不是缺点啊，我啥时候说他有缺点，你们刚刚问的问题是什么，问题说为什么刚开始的时候没有使用索引下推，这你刚刚的问题吧，这你刚刚的问题吧，我是不是来解决这个问题，好吧好吧。

这次咱们不聊了，不聊了好吧，是谁有问题的话，下回再单单聊，我聊我ok好了，这四个名词如果同学们听明白了，听完了，下面再说一个东西，这东西很多同学可能没听过，还有个叫什么叫m22 ，这东西有多少同学听过。

都觉得简单吗，这都为啥什么叫m2 m2 ，这东西全称叫什么，muted，range read什么意思呢，啊这什么意思呢，这意思其实非常非常简单，当就是你现在要如果要进行数据回表的话。

回表你怎么进行数据回表，你想一下在进行回表之前，假如说我查询的是某一个范围的数据，比如说我匹配的是一个name，是字段，假如name字段好吧，name字段我写了一个呃，内蒙大于某一个值。

这个时候我取完之后，假如说我取到1万条记录，一比1万卡1000点吧，假如我取到1000个id值，有没有可能这东西有没有可能有可能吧，我根据name去这个条件做筛选，筛选完之后，我取到了1000条数据。

这一项数据对应过来就是1000个i d，那如果我把这些id值去一个一个一个一个去进行筛选的话，意味着我要从根节点里面是不是按照这个分支依次去进行一个查找，是不是这样的过程，是不是一个筛选。

这很明显是比较慢的，对不对，好，那我可以做点什么事，所以什么事我能不能把取出的这1000个id值肯定是放到内存里面吧，好在1000个，那这几个值这些值我先做一个排序行不行，我们先做一个排序，可以吧。

当我做完排序之后，做完排序之后，我能做什么事了，你告诉我，啊拍进去之后是不是相当于我不用一条一条再去挨个进行匹配了吧，我是不是可以走那种范围查找，这可怎么分范围查找说法。

查找时候我是不是可以一个批量的方式取出我们对应的一个数据，而不需要再从根节点里面一个一个在挨个遍历了吧，是不是这样的方式，这东西就叫标题range read，明白了吗，来这个点听白同学给老师扣一。

就相当于我中间加了一个排序的环节，当然排序可能会加内存，占内存空间，但是不会占特别多，因为你不就存了一个i d嘛，你排序在哪，排在内存排，同学们，内存排序很慢吗，这牌也很慢吗，不慢吧。

原来你在做排序的时候慢是因为什么，是因为在磁盘里面做的，这个时候你的内存和磁盘是要发生交互的，所以这时候比较慢，之前经常问一个问题，说我有一个1t的数据文件，我如果对这些数据文件这些数据一个筛选呢。

这笔是比较慢的，这比较慢的，好吧，ok这样做完之后，这个做完之后来再看另外一个名词呃，叫f c i f e fc，什么叫m i c，你知道吗，刚刚我看有同学说简单f i c好吧，这叫什么东西。

叫fast create index，好，是这样的东西，这又是啥，这里面就涉及到说我在进行数据的一个就是就是数据的一个dm合作，比如说新增啊，新增fci吗，我写错了哦，fci不c，你写错了。

人f i c吧，那那那那就下下下，下面写错了，我记得m c啊，这才对啊，这这是什么东西，f c i吧，i f i c吧，这什么意思，也就是说这东西是这样的。

每次如果我们在删除delete或者说音色的数据的时候，你是不是要修改我们对应的一个索引，在修改索引的时候，他是这样的过程，什么过程呢，我必须要先创建一张临时表，然后呢把那张表里面的数据。

包括我新增删除数据到临时表里面，然后把原始的数据表给删除，删除完成之后，删除完成之后，我再把我们的数据好给把原来那个临时文件再改一下名字，改完名字之后完成是这样的过程，有了这个fc之后，他怎么做的。

他在这个锁里面给你加了一个s锁，还是锁a组之后意味着是一个什么，是一个share的一个锁，那此时你的毒是不影响的，但是血会影响画成这样的一个机制，这样的一个机制，所以这里面的名词是非常非常之多的。

你看完这些东西之后，感觉疯掉了，感觉要疯掉了，但是这东西还是那句话不难，别把它想的特别特别难，听懂我意思吗，比他想的特别难，ok你们都总感觉说老师这些东西，你讲一节课，理论。

这些理论性的东西有必要搞懂吗，我问一下，你觉得这东西有没有必要搞懂，没必要，我给大家说一下，如果你在公司里面实际敲代码的话，说实话这点东西半毛钱用都没有，后面用都没有，因为你根本用不起来，用不起来。

但是如果你做的是某一个数据库方面的一些产品，或者说你要参加一些数一些面试的话，特别是大厂，他一定会问的，一定会问的，一定会问的db，不是db，不是里边就是程序员，就是程序员会问这些问题。

所以你这样一定要把这些点给掌握好了，一定要掌握在掌握好了，实战咱们明天的时候我会给你讲，实战会有n多个数据库，不会有n多个表，实际上给你进行演示，听明白意思吧，好吧，fs再讲一下，是这样的。

fc是这样的过程，原来我如果我再来说一下，最开始，如果你现在想做一件事，做什么事，我要去更新的插入，和删除数据，你怎么做，这个过程是这个过程是什么样的过程，先创建临时表，将数据导入到临时表中。

当然这个临时表里面就包含就包含什么东西了，就包含我们现在已经修改或者删除的数据了，添加我删除一个数据了，那这个时候第二步会干嘛，把临时表，删除好吧，不把原始表删除，然后第三步会干嘛呢。

叫修改临时表的名字，大部分来说是这样的一个过程，这个过程很明显是有问题的好吧，所以这个f i c是什么意思，叫fast嘛，更快的一个方式好更快的一个方式，这个更快的一个方式在进行实现的时候，他怎么做的。

给当前表，然后呢创建或者添加一个share，锁定一个线索好吧，然后此时注意了，不会有创建临时文件的资源消耗，发消耗，然后呢还是在原文件好吧，但是此时如果有人发起dml操作，很明显数据会不一致。

所以怎么样呢，添加cs，读取是没有问题的，但是dm操作，会有问题，明白意思吗，好是这样的一个方式，是这样的方式，ok这些东西啊，你去听一下呃，一般面试一般面试是不会问这个点的，但之前有一个学生在面试。

顺风玩啥来着，反正面临一个公司，他被问到这个问题了，所以我要给你们提一下这东西，你们提下东西，明白意思吧好吧，这一定要注意了，这一定要注意了好吧，这几个点这个点这就是发你在修改数据的时候，要不要改索引。

要不你要不要改作业，要吧是不是要改索引，你不能说我只改数据，不改索引吧，这时候你加锁之后，都会连带着把所有的东西也给你进行一个修改，也进行修改，ok好，这东西啊，下一周自己看吧，自己看吧好吧。

下一周自己看一下，ok好了，这是这方面的一个知识点，你们觉得这些东西啊，当然冷水说了，感觉也没讲啥，都是基础的东西。

它这些东西啊是比较基础的，相对而言是比较基础的，这我给大家说一下，我刚刚为什么从这个轴上开始给大家讲这些东西。

因为在优化这块前面一块往上看，文章写了很多很多东西啊，索引的优点，然后呢索引的用处，索引的分类，然后索引的技术名词，数据结构，这前面这些点都属于基本知识，我要给你们讲这些东西，如果我不讲它，我不讲他。

我下来直接给你讲，下面这些点，直接把你干蒙了，明白意思吗，所以我们要开始进行这样的一个知识点的一个铺垫，你学了这些东西之后，下面听起来才带劲，好，才能听到你听到这个东西，要不然我下面讲这个的时候。

你根本不知道在说啥，明白我意思了吗，所以我为什么拿两个小时间来讲这个东西，我到时候给你提到这些名词的时候，不知道怎么办，ok好吧，这样一定要注意了，这一定要注意了，从入门到放弃，没必要好吧。

这些东西啊慢慢学总能学完了，这个图好大啊，这个图我在课程里面讲了16个小时，16个小时好，还不算前面的基础课，基础的铺垫，基础的铺垫，ok我说了，只讲这一块，只讲这一块，这一块是能讲完的，是能讲完的。

ok下面来把刚刚讲的东西，刚刚刚讲的东西，刚刚讲的东西再说一个东西，刚刚说了，在讲完之后给你们梳理上的个数，还记得吗，还记得吧，哦我说了，我哦，后面会讲的，你别慌好吧，我找一下，这是不是有二。

这里面是不是也有哦，我哦后面会讲的好吧，你别慌好吧，你你明天接着来听课，接着来听课，我这些东西都会给你讲到的，不会落下你们什么东西不给你讲，不存在不存在。

对好了，下面我们来梳理一下这个数好吧，我承诺的东西啊，承诺你肯定会讲的，所以别着急，承诺肯定会讲，ok好了，下面来说一下那个数的一个历程，数的那个历程好吧，你们都这个数啊都比较陌生，我咱们来说一下呃。

换个轻松点的话题，ok呃什么东西呢，第一个点，第一个点刚刚说了体内很多名词嘛，第一个二叉树，然后呢后面有我们的bs t锤，然后下面呢还有我们对应的一个a v l数，还有呢叫红黑树。

然后下面呢哎我们可以说还有我们的b数，还有我们的毕加索这些东西啊，你们应该都比较熟了啊，都比较熟了，然后呢我现在把这些东西给大家梳一下，贯穿一条线，希望你们希望你们能够对它进行一个了解。

进行一个了解好吧，现在第一个二叉树，什么叫二叉树啊，二叉树这东西啊其实是比较简单的，你们都见过数，对不对，正常情况的数，这是根节点，有n多个分支，做个分支，但这种分支很明显，我在进行数据查找的时候。

数据查找的时候很明显比较麻烦，为什么要麻烦，你要挨个节点进行一个对比，对不对，在说这个分支可能太多了，分支可能太多了，所以这时候我想办法说我能不能把我们这个数的分支给进行一个减少。

比如说这样整两个之后就变成了一个二叉树，但很明显你就算减少两个了，你在进行数据查找的时候，依然要进行挨个值的一个对比，对不对，这个比依然是比较麻烦的，这个时候你可以做一个关联关三什么，在数组的时候。

数组的时候，如果我对当前的一个数组经过了一个排序，经过一个排序，你排完序之后可以用什么样的方式进行查找，传下去之后好好听好吧，好好听二分吧，对会用二分查找。

那我现在能不能保证我二叉树在进行数据插入的时候也保证它有序呢，是不是可以，如果有趣的话，是不是就是o老n了o o n对不对，这地方很简单很简单，但是你想一下二叉树它有自己的一个问题。

或者有自己的一个缺点，什么缺点，我来看一下这块这一个二叉树没有啊，那排序之后是不是叫bs t锤，叫二叉搜索数，二搜索数，你在每次往里边插入我们对应数据的据的时候，他一定会按照你当前的数据进行一个排序。

比如插一下一，然后五三，然后240看的结果了吧，这是我们当年查的比较差数对吧，其实这个时候大家已经发现了已经发现了，这是有问题的，这个左腿是比较短的，但右腿比较长，我再起一种比较极端的情况。

什么极端情况我这样来说，这样的话这个数一，坐，发现了吗，这个时候它就完全的退化成一个链表了吧，这很明显是不合适的，因为链表查成型复杂多少，跟我们的二分查找就没就没关系了，半毛钱关系都没有了啊。

所以这个东西肯定不行，没有左腿，只有右腿，这不对吧，这是它存在的一个缺点，那这时候我要思考了，为什么会造成这样的一个效果，为什么造成效果，因为在二叉排序数里面，我这有个规定说了。

我的根节点必须要大于左子数，我的根节点必须要小于右右子数，也就是说右边的节点永远是大于左边节点的，我如果是一个递增或递减的话，一定会造成一个腿长一个腿短，所以这时候我要调整调什么东西。

我要想办法把这棵树能变得相对的平衡一点吧，比较平衡，就说保证我左子树右子数你存在的今天个数差不太多，是不是就可以了，所以这时候慢慢由它开始进行过渡，有了什么，有了a v l数，这个a v2 数。

它的名字是由三个作者的首字母拼到一起的，拼到一起的a v2 数叫二叉排序数到二的平衡数，什么叫平衡数，就说我要保证我的左子数跟柚子数怎么样呢，个数尽可能保持一致，然后呢他们有一个约束说呃。

你不可能做到一个完全二叉树，不可能做到一个完全二叉树，所以只能说你的最高指数和最低指数，你的高度之差不能超过一，能超过一，所以这时候往里面插电线的时候，你看看一下，还差这些数据，一二没问题。

到差三的时候，你看一下是不是有对应的一个变化了对吧，来再差四，看到了来再插五差是不是往下延伸了，开的时候它又要进行旋转了，好你如果再往里面插678 90的话。

它依然会进行n多次的一个旋转的n多次的一个旋转，所以这时候大家发现了这儿，虽然以这样的方式能保证我这棵树的一个平衡平平衡好，那既然平衡的话，我在查找的时候，性能一定是高的，现在是不是有点高。

这高度差不是差二了吗，哪差二了，这是不是二，这是不是323差二吗，2332吗，是不是这意思好吧，所以这大家注意了，我这样的方式进行数据插入的时候会有一个问题，查性能杠杠的，但是你的插入性能会变得比较低。

也就是说我损失了大部分的一个插入性能，来保证我查询性能的一个提升，是不是系统的一个提升对吧，这肯定是有有有问题的吧，因为我们有一种需求，比如说你插入的情案例比较少，查询情况比较多，你用它没问题啊。

但是你总会想一件事什么事，如果我的插入的性能和查询不是插入的需求和查询的需求是一样的，或者说是差不多的，那这个时候你告诉我应该怎么办，现在我要取一个平衡了吧，所以慢慢的由avl数，我在想了。

是一颗严格的平衡数，我的左子树和右子树高度之差不会超过一把，这个我把这东西给放宽一点，所以慢慢有了什么，有了红黑树，这不来个水，后来出什么特点啊，是这样的，什么呢，说我的左子数要不是我的最高指数。

只要不超过最低指数的两倍即可，注意啊，最高指数主要不长了两倍，如果我的最高指数额最低的数是三，高指数是六，如果是四就是八，如果是五的话，这就是十啊，那这样的话做什么事儿，加什么效果有。

我现在不需要再经过n多次的一个旋转就能完成，我们对应这样的一个需求，他还加入了什么，加入了变色这样一个特点，它还有什么要求，又又刷出来了，那就非常简单说了，任何一个路径上面。

你所有的黑色节点个数必须要保持一致，而且每一条路径里面，每条路径里面不能有两个连续的红色节点啊，有了一堆的一个限制，有一堆的限制，一堆限制，这都是红黑树里面的一个限制。

但是它的插入和查询性能是近似于取得了一个平衡，我们依然可以看下一，三，变色了吧，旋转，然后再往下看四，五，六你下来之后可以对比一下对应的两个数好，然后再t这是不旋转了，这不是选哪一次，这时候这是二吧。

这是四，对不对，你在我们的a v要数里面，刚刚是不是到几了，差到五了是吧，再往里边插六，旋转过程大家看是不是要七，是不是还要进行n多次的一个旋转，但这块是不需要了，是不需要了侦探里面的一个性质限制。

所以我的旋转次数会降低，所有的查询和插入性能会变得足够，取得一个平衡，不像那么严格，到这儿为止能听明白吗，能听懂之后来再接着往下看，但是这个红a数它依然有问题，有什么问题有啥问题，大家想一下，有啥问题。

它这个树身会依然无限制地往下进行加深吧，数深度越深时候对我们的差异效率是有影响的，对不对，好，那既然是这样的话，我要做调整吗，做调整吗，做什么调整，这个树身变身的原因是啥，原因在于你有且仅有两个分支吧。

是不是两个分支，如果我能保证你这棵树有多个分支，就多个分支，同时你还是一棵排序的数，注意啊，有n多分支，同时是多个排序的数，那这个时候小，那是不是就高了，你的树身是不是就不会过深了，同时还倒是什么。

每一个节点里面我只要存储多个数据，不再存储一条了，存储多个范围的数据，是不是完成这件事情了，是不是就过渡到我们的b数了，明白意思吧，当然每种树里面，种里面它有自己不同的一个适用场景，你也别一棒子打死了。

是你要知道各种数之间它们存在的一些问题，存在一些缺点，根据这些缺点在合理的应用场景里面做合理的一个试验，这事就了了，明白意思吧，好这样大家要注意了，ok就是这样一个历程，所以你在学数据结构的时候。

你可以尝试以这样的方式去捋这，捋一下之后你就知道哦，原来是这么回事，他就不会那么难记了，不会那么难记了，明白我意思吧啊我也想问一下，什么时候红色，什么时候黑色，这个根节点必须是黑色的。

然后呢插入的节点必须是红色的，但但是在插入节点之前，插入节点之前，它会判断你整个分支里面，条子做的分支里面是否有相同个数的黑色节点，同时也不能出现两个连续的红色界面，他一堆的一个限制，这儿啊。

之前我也讲过这个红黑树的一些东西啊，大家看一下，找一下，是结构这个红黑树我画的这些特点好吧，他这个演变过程，包括红黑树，它的节点是什么样子的，我要怎么往里面插出去，数据的时候是怎么样的一个破坏。

怎么样一个改变，怎么样一个变色，怎么样一个旋转，下面会讲一下左旋右旋到底代表什么样的一个意思，要什么样的意思好吧，然后呢还有一些东西，比如说mysql哪去了，这还给大家画了一个预习资料，给大家发过了。

这是b加数，往里面插节点的时候，一步一步这样的一个历程啊，这样一个历程这块都有明白意思吧，所以这块大家可以好好看一下这个预习资料版，我都发过了，预习资料你都发过了。

下周可以看一下什么一些数据结构课比较好，数据结构和算法的课，现在有左声给大家讲，左成英老师给大家讲这东西我们就不再浪费时间了，好吧，你了解这个大致的带入思路好，然后细节东西下去之后，自己去抠。

自己去抠好，慢慢的就理解这些东西了，没有意思吧。

所以啊今天我们讲的时间大概就是这些基本的点，基本的这些点今天上来之后，我们就开始直接干这些优化点了，或者说我这后面都写sl语句，都有对应的案例给大家做这样的一个分析演示啊。

到时候你知道我就应该利用索引应该怎么进行优化好吧，正好完全不通不通也要去看，也要去看看，那咱们今天晚上的课，咱们就聊这么多，聊这么多，明天晚上八点准时再给大家讲这东西好，明天八点再再再聊。

ok呃那个网站那个网站如果需要的话，一会儿我会发给小姐姐，让小姐姐发给你们，那小姐发给你们好吧，ok好兄弟拜拜，ok今晚就到这么多。

系列 2：P45：MYSQL调优：0.5 索引中隐藏的知识点：索引回表、覆盖索引、索引下推 - Java视频学堂 - BV1Hy4y1t7Bo

扣个一，咱们开始进行上课，忘记扫码了，我昨天同学老师们必须是啊，不然还坏人跟你讲吗啊来还是那句话，集中注意力好好听，我们希望今天把今天的东西给讲完，来先说一下昨天讲点啥。

其实我昨天讲的东西就是跟索引相关的，然后讲了，所以里面最基本的一些实现原理和面试的时候常用的一些点，当然这些东西里面包含了我们的数据结构啊，包含了查找数据整个的一个过程和面试中常问的一些名词。

主要讲了最终多点，其实大家发现了量还是比较多的，或者说量还是比较大的，量会比较大的，今天会有更多的点等着你们好吧，来第一个优点，第二个用处，第三个分类，第四个面试技术名词，第五个结构，这五个点。

这五个点我都聊完了，昨天都已经讲完了，这东西咱们就不再赘述了，如果昨天没听的同学下去之后好好再看一下，这东西很重要好很重要，ok昨天那个cp那个实例，我一会儿会演示，我说过了。

承诺给的东西一定会给咱是个言而有信的人，好吧，别着急，后面会有用到好吧，下面来讲一下这个点叫索引匹配方式啊，索性匹配方式这啥玩意儿啊，什么叫索性匹配方式，在你们面试的时候，经常会被问到一个问题，说。

如果你发现一个sql语句执行比较慢，我应该怎么去创建索引，这第一个问题，第二个问题，在写sql语句的时候，有哪些点可能会造成索引失效，听过这两个问题，或者面试被问过这两个问题，同学给老师扣波一有问过吗。

有吧对吧，这就是具体的细节嘛，就面试的时候一定会问到这些点的，我们现在来了解一下，你想把刚刚那两个问题给解决掉，你必须要知道我有了索引之后，我应该怎么去按照我们的索引去进行数据的一个查找，经数据的查找。

所以我这练了一个模块叫索引匹配方式，昨天没有讲声音分类呀，一会儿来聊天，所以没讲顺序分类是吧，那买家二次元分类吧，分成五类，第一类叫主键索引，第二类唯一索引，第三类普通索引，第四类全文索引。

第五类组合索引，这五类表示什么意思，逐渐不用说了吧，当我给一张表创建了一个组件之后，我在组织具体数据的时候，一定会按照我们主键来进行一个创建，这东西就叫做主键索引，它关系到是什么数据的一个组织形式吧。

好这些东西，第二个唯一，所以啥意思，如果你给一个列设置了唯一的一个值，v味着当前脸面是不允许有重复值出现的，这两个东西啊，这两个东西其实说白了说白了其实表示一个点，一个三点，如果你有主键索引。

我在组织数据的时候用主键索引，如果我没有主键索引，我在进行呃数据组织的时候，用唯一索引是不是这意思，当然我自己也可以添加合影吗，昨天我也给你们写了个sql语句了，还记得吗，alter好了。

table对不，name add index，如果是普通用的话，起一个名字，i d s括号指上列只是一个普通作业，如果你是唯一作用的话，是用语和你讲unit是不是用手就完事了啊，这样一个形式啊。

这东西你们在之前学习中应该遇到过，应该遇到好吧，再来看还有一个普通索引，这个普通索引其实说白了表示什么意思，就是昨天咱们提到的一个问题叫什么叫辅助，所以吧啊或者换另外一个名词叫二级索引。

二级他们这三个名词啊表示的是一样的，意思是一样的，意思，就是说我给锤了除了主键和唯一件以外的其他列所创建的索引，叫做普通缩引，或者叫辅助索引，或者叫二级索引，三个东西是等价的，等价的，ok再往下看。

还有个东西叫全文索引，什么叫全文索引啊，我现在举一个例子，现在我要做一个比如说文档的一个管理系统，然后呢文档管理系统里面存储的全部都是文章，我把文章放到mysql里面了，放心之后，我现在要做一件事。

出什么事，我要检索一下所有文章里面，或者包含java这个关键字文章，你告诉我怎么做，听明白我的需求啊，我要把所有包含java这个关键字的文章都找找出来，你怎么找，能找吗，不能招啊，同学说了，对分词。

比如说现在年费用最好的东西是ik分词器的分蘑菇已经赖赖完，已经疯了，赖效率是最低的好吧，所以这东西更多类似于是一个什么是一个搜索吧，或者说是一个检索的一个过程，检索在最开始之前好吧。

可能有人会用loser，对不对，然后后来有了server，然后呢现在用的更多是什么，是不是用的是e啊，所以在mysql里面其实很少有人去真的见这种圈文，所以大家同学说老师1o db是不是不支持啊，5。

6之后支持了，5。6之前是不支持的，确实是这样的，这东西我们一般用e s挺好用的，而且效率比较高啊，效率比较高好，再来看主播作业，我是不是说过了啊，这就是大致的一个分类，这东西没啥都没啥。

其实你们在用的时候也没必要说，我把每一个所有的分类都描述得比较清楚，都比较清楚，也没必要招那么多，你知道怎么来进行使用就ok了，好吧，来这个分类听麦同学给老师扣个一，没问题吧，没问题。

之后我们再来说这个索引的匹配方式，所以匹配方式这我写了几个东西，全职匹配，最多匹配，然后前缀列，然后呢匹配范围值进入到匹配某一列，然后访问所谓的查询这块，是不是表示说如果你建了索引了。

我在进行数据查找的时候，应该怎么去查找我们的数据好吧，第一个叫全职全职匹配是啥意思啊，这东西更多适合一是什么，是一个组合索引这样的东西啊。

这给大家说一个点，我们现在啊一定要通过案例来给大家进行一个演示，我这是一个虚拟机里面用的这个i s o，看一下，杠p123456 啊，这种这些东西，stays版本是5。7。29，5。7。29。

是这样一个版本，然后在这里面我用了一个库，小k的，有这样一个库受tbs这个库也不是我建的，不是我建的，是msl官网里面提供给我们好的一些样例数据，明白这种东西吗，这同学扣一不知道没扣二有这东西吗。

如果你官网看的比较多的话，对这些东西应该是比较熟的，因为里面有很多对应的一个案例是从哪找啊。

来给你们看一下，找一下，我告诉你突然下载下去之后，自己可以下载一下，里面有对应的表，然后呢，所以这些东西数据这些东西都帮你创建好了，我们只需要拿过来之后直接用就行了好吧，选择automation。

在这里面有一个more，有一个more，点开这个帽之后，它里面提供了一堆的库，提供了一堆的库，我们刚用的是什么叫saka database，你把这个z i p一下载就完事，好就完事了。

你可以把里面的sql语句给直接倒过来，里面包含两个文件，一个是gm c h e m a好吧，一个是贝塔二代，好文件都执行一下，你数据库里面就有这个数据了，明白我意思吧，下去之后自己可以搞一下。

今天网好了，所以今天网好了，今天插着网线，所以用的是无线啊，这下去之后自己可以挡一下。

自己可以挡一下，那这时候我们来看一下是不是这么多表啊，表里面有什么样的字段。

有什么样的结构，你先扔一边，我们先不管它，我们先管它好，先看一下。

刚刚也是这个案例，这个案例我就直接从这儿复制语句了，好吧。

先看一个表，什么找的，这是谁呀，dsc st有这样一张表啊，id name age post s time，一共有这么多东西啊，这无疑用五个字段，然后呢可以看一下收音death from。

然后再写一个stars，可以看到这个表里面一共有几个缩影，听我的问题，这个表里面有几个缩影，几个，好几个说一两个吧，所以不要看四行径都是四个，所以你根据名字来判断k内，第一个。

这是不是还有一个组合索引列，分别是name age pose，又共有三个值，三个值，它们三个共同组合的一个组成的一个组合索引，所以我在进行使用的时候，就可以把这三个东西是不是进行一个最多匹配了。

是自动匹配，怎么匹配来着，我直接拿四口语句来运行，我是歪着写啊，太浪费时间了，a型看这一句是不是先匹配内容，再匹配，再匹配pos版，是这样的方式，来a型看一下执行计划。

他是不是用到了这个i d s n a p啊，是不是要这个东西了对吧，表示说我使用了当前这样一个主编，这是一个全匹配，全职匹配，同时后面还有一个列叫什么呢，叫k lx是啥意思，谁能告诉我这训练是干嘛的。

它表示的是索引的程度，听明白了吗，叫索引的程度，那么问题来了，既然是左引长度的话，这个140是怎么算出来的呀，啊怎么算出来的，注意这个在基因计算的时候有人知道吗，有没有会的实际长度，你就告诉我。

我通过计算之后，我怎么能得到140个值，怎么算预估吧，不是预估，不是预估你是一个组合作，意味着你是不是有三列，所以这时候你要看一下当前这个表的表结构了，内置pos是不是有三个，是不是三个东西。

这个时候24 20表示每一个字段的一个长度，然后我们在设计这个表的时候，一定会要指定一个编码，对不对，一般e都是什么，是u tf 8，一般是这样的东西吧，有的老师不是我们用的是mp 4，可以好吧。

u加八占的是三个字节好吧，j b k这是两个字节，如果你是拉丁的话，占的是一个字节，明白意思吧，所以我在进去算的时候应该是什么，24+20括起来，然后呢乘以三，这值多少值多少，是不是等于100多少。

32吧，没算错吧，一般在这儿还有还有什么，还有in吗，in是不是占四个加四，对不对，还有包含四个字是啥，四肢啥，别忘了，这里面要判断一下说我到底是否允许空，然后呢还会保留一些额外的长度计算值。

所以加起来之后等于是140，140，一会儿我们可以再做一下，其他地方，你看一下就知道了，这东西啊一般没人考，一般没人考，你知道大概的一个计算公式就行了，int不是11吗，占的是对应的一个字节长度。

就是我在存储的时候到底是占几个字节，明白吗，不是你那个意思不是11吗，不是11啊，你硬的类型最大范围是多少，你在java里面bat shot in the long，占几个字节。

你在世界存的时候是不是也要占四个字节，是按字节数算的，同学们，字节数算的不是那个长度，好吧，把这两条概念给区分开了，乘三是啥，那个是你的长度，表示说22呃，24+20是你规定好的一个长度。

规定好一个长度，每个长度需要用一个三字节来进行存储，所以要乘三，因为默认格式是ut啊，我们这儿指定是ut m8 那种格式，u t f8 ，所以这三个字节如果你设的是j b k的话。

j b k就占两个字节，如果你设的是拉丁的话，拉牛one就占一个字节，是跟你的字符编码是相关的，是相关的，好吧，这块你下去之后自己搜一下就知道了，自己做下去知道了，it里的11是什么意思。

11就是一个长度，其实就是一个长度，那个长度你就设了之后跟没事一样，没有什么影响，它最终该存的时候还是用四个字来存，还是用四个字节来存的，明白我意思吧，好吧，ok这是一块东西。

所以第一个是我们的全职匹配啊。

这注意一下，再来看第二个叫匹配，最左前缀这边啥意思啊，还有一些什么是空值所占用的一个长度，还有一个是什么。

注意啊，你这个列里面是否是允许为空的，就是这些这三类语言是否是允许为空的，如果允许为空或者不许为空，它会有一些字段值得一个判断，还会有一些标志位，还有一些标志位，这一共是占了四个对应的一个字节四不定积。

所以加起来是140，一会儿我们可以再按照这样一个公式再做一个计算，这种计算大家说一下，我来说一下，我来说一下吧，这允许没空吗，这三个列这三个链是否允许非公，听到有问题，不允许吧，是不允许为空。

如果你这样不允许围攻的话，那ok我一个字节就不加了，就不加了，那个老师，那还有四个呢，如果你是vx类型的话，它最终会在最后的长度里面再加两个字节，再加两个字节，所以这个时候变成什么了，是变成24+20。

然后乘以三，然后加上40int，再加上一个往上两个字节，两个差是不是四个字节加4=140，等于140，这是算出来它整体的一个长度，明白我意思吧，如果你在允许为空了，允许为空啊。

我还要在每一列里面再多加一个标志位，或者再多加一个字节，懂我意思吧，就是简单计算公式，我们一会儿开再多验证好吧，这是不是140，这是全职匹配，现在我按照我们的最左匹配原则，我把后面的删掉。

这是匹配两列了，是不是两列两列我应该怎么算来运行，看效果是不是也用到我们的索引了，是要我们同意了，那这个时候我应该怎么算，是不是78呀，起码哪来的啊，我刚刚的公式第一个内容占24，所以中24x3=72。

没问题吧，72再加上一个是不是有个一一的类型，是不是加4=76，对不对，如果你是画叉的话，是不是还要额外再占两个字节，再加二，是不是等于78，这就是这个78这个的由来，听白了吗，来这块儿听到同学扣一。

就是一个非常简单的一个公式去算好吧，这种假赛之后自己看什么，面试的时候不会问到这点的，不是被问到这点了，ok画叉那个那不是八叉类型吗，那不是八叉吗，对不对。

好了，加到这里好吧，加成这个样，再往下看再往下看，刚刚说了一个是全职匹配，一个是匹配最左前缀，最左前缀好吧，还有什么呢，叫匹配列前缀，这个列前缀又是什么意思啊，什么叫电子竞业前缀。

就是说我匹配其中一部分，匹配其中一部分，就好比我们经常用的这个live查询，把那个拿出来like。

什么意思，是不是模糊查询，如果你在用lab的时候，你发现了，这是不是也用到我们的索引了，它匹配的是内部这个字算值name等于什么，这是等于74啊，哪来的七二十4x3，再加上20=74。

就算出来这个长度算长度，那这个时候他会用到我们的，所以但是如果你换一种写法，怎么写法，这样加一个百分号，你再运行，你发现还会用，所以吗，不会的吧，是不会的好吧，这个时候就会造成我们的索引失效。

所以你把第一个索引失效给我记住了啊，这第一个索引失效点一定要记住它，ok好，这是什么意思啊，表示匹配某些列的一部分叫列前缀。

列前缀好吧，还在为什么你告诉我。

你写个百分号，我在进行索引查询的时候，我怎么查询你百分号是不是代表啥代表啥，一到n个字符吧，那我是不是所有东西我都能够匹配上，那你的索引还有意义吗，没意思吧，而我在前面没有百分号的话，是不是以g开头。

后面有多少无所谓，我只要能把g开头的东西，所以所以里面包含这个值取到是不是就行了，就这意思就这意思好吧。

这一定要注意了，要注意了好吧，来再往下看，第四点，还有什么叫匹配范围值，这不说了吧，范围查询是不是也可以用到我们对应的一个呃。

所以啊放一匹配，这不用我说了吧，来试一下这个语句啊，我们直接站，就昨天给你看的文档好吧，直接粘过来来运行，听到作业了吗，听到了吧啊这也会有我们对你一个索引，也就是说大于号小于号，它也会使用我们的索引。

而且这个时候效率是高的，为什么，所以在进行数据存储的时候，本身是不是就是有序的呀，既然有序，那我是不是就可以使用我们对你一个，所以明白意思吧啊这大家要注意了啊，这样的一个计算方式。

那我现在在写另外一个东西，在另外一个东西写这样的，大家一下name等于它，然后呢and的a值大于十，and的呃，真是还有一个啥来着，有name age pose是吧，pos等于20。

这个时候会不会用我们对这个索引，能说点高级的东西吗，有简单往难说好吧，会不会会吧，他会用几个索引，它会用几个索引，也就是说我们会匹配用哪些列吧，这时候你可以看一下是从哪列，78瓦。

其实法表示说我用了name，用了a是吧，也就是说当你在使用我们对应的一个组合索引的时候，一定要注意一点，如果你中间的某个环节，中间的某个环节出现了这种范围查找，ok后续的座椅直接失效。

所以这也是第二个索引失效的点，严格记住了，第二个数据是要点指纹匹配内部和a指指纹匹配内部和a啊。

这大家注意的好，这个点啊，我们大家说一下好吧，再来看还有什么呢，说精确匹配到某一列，并范围匹配到另外一列，这刚演示了吧，这就是一个范围查询啊，也会使用我们对这个索引好吧。

再来看还有什么叫只访问索引的查询，这玩意什么意思呢。

pos一前面去了，然后来看有这一个是吧，前面写多了，pose等于十and的大问题，这东西会行，所以吗，来看效果，一看昨天就没有听我讲的课，我昨天讲课怎么说的，是不是也是遵循我们作为制度原则。

是不是也会去调整我们整体这样一个顺序，我昨天有没有讲的东西，讲了吧，所以这一点啊我也讲过了好吧，所以下周还是把昨天的东西好好再听一下。

好听一下，ok来再来看最后一个说只访问所有的一个查询是啥意思啊。

这意思也非常简单，也就是说我们这个时候再进行查询的时候，看效果，看这个地方它是因为我们全部的一个缩影，看这块的话跟刚刚好像没有任何的一个区别，没有任何一个区别，但是但是你能够进行一个发现，发现啥。

你这举的例子是什么列name age pose，是不是刚刚好就等于我们对应这个名称条件的一个值，所以这个时候叫u z index了，所以覆盖对，所以覆盖啊，所以覆盖好吧。

不是我们所有负担，所以这是这使用的六种左右匹配的一个方式，这块我希望你先了解了，来这个点没问同学要通过一，没问题吧，好了这个问题之后来看第二点叫哈希作业，还有个什么意思啊，我不说了吧。

在memory移动从中引擎里面会使用我们的派系所引，以此同时印no bb in no bb是是有有有什么演的叫自适应哈，希啊叫自适应哈，希刚才说了，继续哈，这表实现只有精确匹配到。

所以所有类的查询才会有效，那mac口中只有memory曾经引擎显示支持，还是索引哈利索引自称只需要存储对应的哈希值，所以所有的结构十分紧凑，这样哈希表查到速度非常快啊，是它里面对应的一些特点。

下面呢还有一些限制，还有一些限制，这些限制就比较重要了，好我需要跟你说一下，第一个说还者也只包含哈希值和行指针，而不存储任何什么叫字段值，叫字段，之所以这也大家注意了，不存储字段值，所以不能使用。

所以啊所以不能使用，所以值的值来避免读取行，比如说我匹配到那个哈希值了，我还是要读取我们具体的行记录，才能把数据给读取出来啊，这是第一个点是限制，第二个说到哈希索引的一个数据。

并不是按照索引值数据存放的，所以无法进行排序吧，没法排序，没法排序啊，这牌不用排队，我说了，说过吧，因为你是要根据你的哈希值来计算，导说我要定位到哪个单元格里面，然后从这个单元格开始进行数据的一个大学。

下面还有排列表，不支持部分列匹配查找，还得做演示，使用所有的全部内容来计算还是值的，所以必须要做一个完整匹配，就上面这写的是不是必须是一个全职匹配啊，必须把所有东西都匹配完成之后才可以才可以。

ok刚才说哈希支持等值比较，但不支持也不知是什么呢，找任何范围查询，昨天讲数据结构的时候，这东西已经说过了，好我也说过了，第五个啊，说了有很多哈希冲突的问题，所以你要设计一个比较好的哈希冲突算法。

第六个说他承诺比较多的话，维护代价也比较高，这东西几乎都是昨天说过的点，我们这儿来做一个回顾，也做一个回顾啊，这我有一个小案例来需要给大家演示一下，就给大家演示一下，演什么东西呢。

也就是说他俩说当如果你现在有一张表表里面，我需要去存储一堆的url，你告诉我u2 怎么存，幺二怎么存，你ur 2相当于是一个非常非常长的一个什么字符串吧，我们也说过了，你在进行数据存储的时候。

尽量去减少索引字段的一个长度吧，我昨天有个强烈点，我有没有强调说这个尽量去减少所有的一个长度，说了吧对啊，为什么，因为是所有长度越多，意味着你占用的所有空间就会越大，这个时候你的数据量就越大。

所以怎么样呢，会增额会增大我们整体的i o的一个量，所以这时候越短越好，所以就说了，你如果可以干嘛呢，如果你要存储u2 的话，可以干嘛呢，把这个资本值进行一个编码。

系列 2：P46：MYSQL调优：0.6 如何创建性能最优的索引 - Java视频学堂 - BV1Hy4y1t7Bo

还有什么叫c2 c32 ，有人听过吗，有没有人听过c23 32这东西啊，叫什么，叫循环冗余校验规则，对循环冗余校验规则，就是说当你用这样的方式进行一个加密之后，或者进行一个编码之后。

它会变成一个十位的一个整数，十倍的一个整数，有了这个整数之后，你可以直接存整数了，而不需要再去存储我们其他的一些很长的一个计算值了，整数占的字节数是不是就四个，如果你存字符串的话，该多长了，是不是意思。

所以这时候你可以用哈希的方式来做这样的东西来做这种东西，这东西啊很很少用，你大概听一下，了解一下就可以了，了解就可以了，之前我在讲那个大数据课的时候，我们在设计那个hbase的时候也是一样。

hbase里面有一些rok，rok字段可能拼了很多，为了减少这个长度，我们就用了c2 c32 这种方式来进行数据交易，叫循环冗余，数据校验规则啊，这注意一下就行了啊，这些东西啊好了。

这块我们都不再多说了吧，再多说了，这也不是我们重点，重点放在下边，下边下边再重点啊，这有优化细节，这是重点，然后再往上看，还有什么叫组合作引，组合作引，还有我听到吗，昨天是不是已经聊过很多了。

不聊了很多了，聊了很多之后，这我要强调一件事，想一件事，你看一个非常神奇的东西，看非常神奇的东西好吧，来看这个图，这样我画一个图，这图是什么意思呢，我我不改答案了啊。

就说我现在有一个表标里面有abc 3列，这三列创建了一个组合索引对吧，然后呢，当我在进行数据查询的时候，是否会用到我们当前的这个索引，并且用了哪几个索引。

是不是意思对百度有百度有百度有我一会给你也是一种情况，你看一下是否是一样的，如果一样，我就没必要说这些东西了，可能有一些比较好玩的东西才会跟你说好吧，第一个a等于三会用吧，a等于三，b等五会用吧。

a等于三，b等于五，c等于四会用吧，这是不是就是我们的最左匹配原则对吧，这东西之前我已经聊过了啊，再来看这种东西叫where b等于三or这多了个where or c等于四，这个东西会不会走我们的索引。

我这同时也有一张表。

也有一张表好吧，什么表呢，叫select先from a b c啊，d i c a b c，那我们来看一个表，分别是a b c是不是33列，然后呢可以看一下叫show index from a b c走。

是不是这个点对吧，都建的是统一一个缩影对吧，那我现在运行一下叫一个select 7 from a b c，where a等于一，然后呢2b等于二，它会不会使用索引，如果使用索引的话，会用哪几列。

这其实就注意到一个问题了，昨天有同学问我说，老师or到底会不会使用，所以奥会不会这样，我们来解释，我来解释会不会会用谁ab对吧，a b来看效果走，他这个地方他用的是谁，用谁。

是不是用的是15 15是什么鬼，记住我之前说的那个计算规则，刚刚为什么要讲计算规则，现在这a b c全部都是什么类型，一个类型吧，in的类型，再来是四个字节，对不对。

四个字节你是怎么给我凑出来15这个值的，怎么做出来的，11+4，别扯了好吧，哪来的11啊，任何一行就是四个字节，哪个是我，4x3+3 int需要乘三吗，同学们这儿我告诉你怎么计算，告诉你怎么计算啊。

本身int本身int是占四个字节，这没问题，加起来是等于12，这为什么有个15这个值原因非常简单，我也说过了，如果你的列值允许为none的话，我需要多额外加一个字节吧，你看他这个表于是维护吗，允许吧。

三列为空是不是加三，刚刚是不是相当于是4+4+4+3是不是等于15了，你看蒙老老师不对啊，我现在只写了一个a，只写了一个b，你是怎么给我算出来a b c的，我都没有c那个列，你给我算出a b c了。

对不对，这东西怎么做到的，为什么会出现这样一种情况，来我再看一个东西，牛，因为用了索引，不是不是不是不是来再来看，再看另外一个东西，再看另外一个东西好吧，d e s c有一个表叫a b c2 。

这个表格刚刚表差不多啊，我多了一个字段叫内部，多了一个name字段，多内部字段，这时候你可以看下受index，from abc 2是不是还有组合作业a b c吧，是不是a b c。

这个时候我再把刚刚那个语句拿过来再运行一下，你看效果，看效果好吧，叫explan slide in from a b c2 ，where a等于一，b的二，b等于二。

这个时候我有使用我们对应的一个缩影吗，没有吧，你对比一下两张表诶，为什么呀，为什么上面这个效果是这样的效果，而下面这一条是这样的效果，这是为啥，所以这才是你思考的问题。

我如果只给你展示那样的一个情况的话，对比一下，对不对，我如果整体展开刚才那个情况的话，没意义了，所以一定是有不一样的地方，我才给你做做演示，如果一样的地方的话，我给你演示都能干啥，没意义了。

没一个明白了吗啊，所以这给大家说一点，说一点，我们一般在创建表的时候是不会出现这样这种情况的，就abc这种情况的，那啥意思啊，a b c一共这个表里面有三列，我把三列统一都做了一个组合索引。

这个时候不管你怎么去查数据，我都会去占用我们对应索引的好，都会去占用我们对应一个索引的，这时候大家不注意，大家注意是不是叫索引覆盖就等于代词吗，但如果你现在加了一个内部的列。

这个时候我用or的时候还会用，所以吗，不会的吧，那这个时候同学得到一个结论，什么阶段说老师我在使用这个奥查询的时候，他不会走，所以这句话对吗，只差a也是15吗，来实践出真知，是多少，这多少五。

你只差一个a的时候，用的是谁，又是谁，又是a吧，你这不出现其他列了，所以又猛了，老师，那为什么这就出现了，来换一个再换一个and的c等于四，看这块啊，我现在这个是组合座椅，应该是什么。

是不应该是最多匹配，这个时候我是不是应该也出来是是什么，是五吧，来看这个结果，看结果诶，这为什么又对了，他为什么对了，那老师这是什么情况啊，怎么一会动一会不动，到底啥意思，他这种情况到底是否匹配。

我们对你一个最多匹配原则起码有问题啊，这种情况是否匹配，最多免费原则，皮肤匹配，匹配吧，那这时候来往下看，我再换一种情况，再换情况，这写一个b等于四，如果b等于四的时候。

这个时候你告诉我我用的作业是哪个作业，哪个作业，来看效果十吧，这就对了吧，是不是就对了，好这时候大家能看到我们对应的一个效果了吧，那为什么上面这块儿这诶哪去了，再改一下啊，哦来看啊，我现在把它换成o。

然后换成or换成or之后，你再接着看，当你换成or之后，这会变成什么东西了，and是不是没问题，你使用and的时候是不是最遵循那种最多比例原则，但如果你使用out了，这谈遵循吗，还在学吗，不能学了吧。

做做行了吧，所以这时候在组合作业里面or是个比较特殊的东西，它会把我们这种情况都给我们做一个演示啊。

这这种特殊情况特殊情况明白了吗。

特殊特殊为什么，这哪有什么为什么呀，这东西没有啥，为什么好吧，就是我在进行数据检索的时候，当你匹配到说我有20个字段的时候，我会在我们全部的所有链接直接进行一个数据查找，我直接进行数据查到。

而如果你把它换成一个and，这时候就跟我们昨天讲的那个图匹配一模一样啊，最左匹配一模一样，一模一样，所以有的老师or到底是否要走，所以我可以这么说的，我说哦是否走，所以你要根据具体情况去做判断。

好进行了去做判断，在你如果这些列里面，在你列里面如果全部就完，如果全部都是组合索引的话，这个时候他是会走索引的，做错了，而如果你再换一下，看哪儿，我换一下，我把它换成二二，是不是多了一个内部字段。

多一个内部阻断，再看效果，这不就可以吗，不会吧，我再画再写一个and的c等于四，再一个系统会有作业吗，不会吧，不会了吧，所以当你带了你的普通列之后，带了普通列之后，如果你也是一个组合索引。

这个时候or是不会占用的，or是不会走索引的澳洲波子做一个，所以这点希望大家能够把它给分清楚了，听清楚了，如果不查普通电呢，来帮他看，他说老师我在后面看同类了，差什么，差a多少，b多少c这样的吧。

再查下来看效果，他会懂吗，会吧，这个时候就会懂了，你只差普通列是不是跟我们刚刚那个表一模一样了，是不是刚刚表现不一样了，这个没什么区别了吧，没什么区别了，所以你在查询普通其他列的时候。

这个or可能不会触发我们对的一个索引，两个a的号码是啥意思啊，好同学说这两点，你看这好，这个同学非常好啊，他应该看了一些资料，a等于三，他会不会做索引，嗯是谁问的，艾德里安，艾德里安会有关键吗，会是吧。

来看我们对应效果好吧，会吗，所以一会儿我给你解释什么时候会走索引，什么时候会走索引好，下面会显示这个情况，下面会显示这个情况，到时候演示就知道了，但最起码这个情况是不会走的吧，所以你得到一个结论。

得到一个结论表，选错了就是a b c2 ，你会把一个表里面的所有字段都建成了一种组合，所以吗不会的，不会的，你a b c的话就没意义了吗，你这有啥意义啊，那这有啥意义啊，这没意义了嘛，对不对好吧。

所以这块我希望大家能够注意了，希望大家能注意了啊，就是说如果你是一个组合索引啊，并且你的组合索引只占了你当前表的部分列，这个时候or是不会走我们对应的一个缩影的啊，不会走对应一个索引的这块东西。

你下去之后我再演示各种情况，你需要把这些东西下去之后，自己做一个总结。

如果只查询字段a呢，只差3a你还能用到on吗，你是不是用不到，用不到这个号了，是不是意思好吧，注意啊，这种情况下or是不会走索引的，一会我给你演示，刚刚同学说的，老师a等于一，二，a等于二的时候。

什么时候组合引，一会儿我们来演示，一会我们来演示好吧，我记住这记住这记住这好吧，ae就是又了解了，来看一下吧，where a in括号一，括号二那么多合理吗，后面都拿来看，这是一个页码。

跟奥运什么关系啊，这是什么a b c2 吧，是不是在内蒙一次段，这是a in一逗号二，会不会走，还说会吧，这这是走了吗，没走啊，没走吧，所以接下来同学问我说，老师我这个东西有没有走索引，我怎么判断呀。

你具备了一定的理论知识之后，你是可以做判断的，但是在数据库里面，数据库里面会有n多种的一个情况，会有n多种一个情况，你要对这些情况做一个整体的分析，明白吗，整体的分析我说了。

当你在使用这个a逗号b逗号c，如果一个表里面只有这三列，并且这三列是组合索引的时候，做作业的时候它是一种特殊情况，好一般你们在生产环境里面是看不到这样东西的，看好两东西的。

而如果你是一个a逗号b逗号c组合，所以还包含了内部或者其他类型字段的时候，这个时候你的or是不会参与整个索引的一个呃，是不会有索引的，是不是做索引的好，这里要注意的一定要注意了，ok好了，就这块东西啊。

一会儿我来跟你们说一下，为什么那个奥什么时候做作业，我也想知道y这东西是跟对应的一个优化器去做一个合理判断的，知道吗，是给你优化器去做一个判断，跟优化去做一个判断好吧，同学说了说不包含沃尔条件。

在这一点浪费时间，浪费时间够多了好吧，我们这边再多聊了，现在之后自己去演示各种情况。

演示各种情况来看一下，刚刚我给你展示这个图，同学们都说老师我知道的东西，你真的知道吗，一个or给你测出来，扯出这么多问题，接下来之后自己去看一下，自己看一下，ok现在说了，a等于三，b等于四。

是不是直走a对吧，a等于三，b等于十，c等于七，是不是只会走a和b，然后a等于3b like，然后c等于什么，是不是只会走a啊，就这样一个情况，这样一个情况，这块大家听一下就行了，大家听一下就行了啊。

这是我们对应一个组合索引，记住我说那句话，就我说那句话，当你一个表里面的全部列都是组合索引的时候，这是一种特殊情况，而且在组合索引里面all是不会走索引的，听明白了吗，刚刚那句话听懂同学给老师扣一。

我就是为了给你演示那种特殊情况，这个表其实很简单，昨天我都讲过，都演示过了，就为了说这个out的那个点，一会儿我们来演示or什么时候会走索引好，会不会一会我们来演示这个点，ok好来再接着往下看。

小一点好了，这是我们的组合作用，a b2 c呢。

倒数第二行为什么只走ab倒数第二行是谁啊，倒数第二行这个啊。

你说你说这个是吧，a等于三，b大于十，c等于七，你中间如果出现这种范围，查找了，是不是会阻断我们整个这个组合，所以是不是只会匹配前面，后面不管你写什么都不会做缩影，这东西我昨天已经提到过了啊。

就想过了好吧，这款东西昨天我聊过了，如果我们一会儿同学下一周后可以好好来看一下啊，是这块东西啊，来再来看下一个点，叫剧组缩引和非聚簇索引，分居组是啥意思，就不用我说了吧，虽然我解释过了，什么叫巨促啊。

什么叫分居促啊，它表示的意思是说我的数据跟我们的，所以所以是否是组织在一起的，是不是组在一起的，如果你做起来存储数据叫做句作业，如果你不是一起存储数据的，就是非剧组作业。

所以你发现在mysql里面innovb这种存储引擎，innovb啊，这种存储引擎它用的是什么，这不是我们对于一个剧组作业，而如果是my son的话，那就是非剧组作业，你通过它文件的一个组织形式。

也能够做到这样的一个判断，做这个判断啊，这这个点这不再多说了，ok就这个点再看下一个点叫覆盖，所以是啥意思啊，那说过了吧，如果我的查询列里面，比如flag后面这个字段。

字段里面如果包含的值刚刚好是我的索引列和查出来的那个主键值，所以啊所以如果你sl后面那个字段刚刚好是你的索引列，加上你查出来那个主键值，ok这个时候会触发我们的素性覆盖，就不会再走我们队里一个回表了。

是不是这意思啊，这我昨天已经说过了吧，好吧，这样在做的时候可以减少一次回表，也就是说会减少n多次一个i o吧，是不i o这儿也有一些。

所以覆盖的一些案例，这个文档说过了啊，我一会发一会发，写下来之后，你自己去看一下是什么，来看这个看这东西，还有案例，这什么案例啊，还是一样，我们来打开我们当前这个数据库好吧。

select，index，1v一提高看这这是一张表，这个表里面呢有有123个吧，是不是包含了三个索引，三个啊，也就是三个索引这个问题吧，一个组件，一个是单列索引。

一个是组合索引，用，包含这几个，放这几个之后，我现在写一个这样的词汇语句。

诶，没看到啊，我先再来最后一句。

那你告诉我他会不会走，我们对立一个组合作用啊，听完问题啊，这会有重新覆盖吗，会不会，会有说不会的吗，你说不会了吗，会是吧，来看具体效果，看到这儿有一个possible k等于它，然后一个k等于这个值。

这是i的，是不是我们创建了一个组合，所以这个组合索引是不是就是spd和fm，所以当我们在进行数据查询的时候，是不是直接会走我们队的一个什么复合复合索引覆盖吧，是不是用类似断了，这是我们实际的一个k值吗。

如果你这样看不舒服的话，把它干掉，这样看看，这弄好了吧，说不定到我们当前这样一个字段值啊，把它直接取出来之后，只是就掉了，这就掉了，这是我们当前这个组合缩影，只在一个组合索引啊，所以这种方式也会有的。

它不会触发我们整个的一个回表，这个战术有什么写，叫using index嘛，in death，对没有查询其他特pk有啥用，pokey表示说我在整个查询里面可能注意是可能会使用的索引。

这个时候他通过他的一个执行计划推断之后，发现说我没有什么东西可以用，因为你后面没有条件，但是我在实际取数据的时候，因为你的叶子节点里面，叶子烟里面是本身存储的，就有这些作业了。

所以我是不是可以把这些索引值直接都拿过来，是不是直接拿过来，别忘了啊，直接组合索引不是主键，所以这两个索引是不是也会建一颗b加数，那我是不是只需要把当前b加数里面这些值都取出来就可以了。

而如果在取的时候，你就发现了叶子里面本身又都是有序的吧，所以我是不是可以把e的点都取出来，我还需要回表达行吗，我还需要从上往下依次遍历吗，不需要不需要，所以这时候我推断的时候。

推断的时候不需要在适应用的时候，可以直接从我们当前叶子节里面返回数据，那这时候用到了我们的，所以时代就是这个意思啊，这希望大家能够认识到，你能认识到。

好吧好了，就这样的一个问题啊，来再往下看看有啥第二点。

第二次后一句看这一句。

还有一样叫show index，from either，他这个表里面这个表里面有几个，有几个那个索引啊，两个吧，一个是primary，一个是index actor，last name。

是不是两个这样的一个值，是不是像这样的值。

这两个作业啊，作业之后，我们现在再演示一下刚刚这个语句啊，转过来。

就是这时候你来看一下它会用我们对应的一个组合作用吗，他是谁啊，他是谁，他是谁，是不是x i d查得拉丝内容吧，这两个列是不是刚刚好正好是谁，正好是谁，是正好是这个辅助位，你看啊。

这个东西是主线作业是没问题的对吧，这是什么呢，这是那个普通座椅吧，或者说叫辅助座椅，或者叫二级作业，是不是这意思，那我再根据我们这个拉斯内普通索引区进行查找的时候，我是不是能根据它取为一个主键值。

而那个主键值我所需要的是不是刚刚好在这边，就在这里面，那这个时候你告诉我会不会又分覆盖回表，我这东西需要回表吗，这个需要回表吗，这不是都有数据吗，我根据内部查的时候是不是能返回一个ip值，id。

是不是主键，我查是不是查的是不是主键，查是不是另外一个列的值，这时候我们还需要吗，再好看是不是到这个缩进，是不是就到这个值了，那这时候不用回表啊，不用回表，不需要回表。

不需要还站着出来，这是我们所覆盖一个案例啊，所以暂时不需要我们这样一个回表。

如果我要画一下怎么画啊，能改一下，看这啊，我改成这样的方式，看到了吧，我只能force这种fm，大家把预习了，看这地方这两个语有什么区别啊，老师我都用到索引了确认方法，但你好看，最后一个列。

这一个是什么叫user index，一个是什么叫n in the index，表示用到了索引覆盖，而none表示并没有进行一个使用，所以这是它们之间的一个区别，这是不是意味着下面是不是要进行回表了。

而上面这块是不是就是不回表，明白我意思了吧，好来这个点题班同学老师扣个一，两个案例一对比就出来了啊，就这块好了，这点所以它也比较简单。

也不难好吧，来往下看上面这些点啊，都是我们昨天讲过的一些东西，只是做了一些呃详细或者更细致的一些说明，下面这些东西就是需要你们具体去掌握的什么东西呢，就是我要写的名字叫优化小细节，这里面都是细节点啊。

都是细节点。

为什么查意思不会表达啥意思，查什么意思，哪有意思了，谁说没没看看你是什么意思好吧，为什么查id不回表，你根据内部是不是能直接匹配到我们对应的一个id值了，那我还回表干啥，你根据内部是不是能匹配到id。

你告诉我还回表干啥，你要回回秒了吧，是这意思，这一看昨天昨天没听课，你看昨天没听课好吧。

就大概知道什么意思，ok这块好，来我们把这块讲完，把这块讲完好吧，这东西还是比较多的，来往下看，第一个点说，当使用索引列进行查询的时候，尽量不要使用表达式，把计算放到业务层，而不是数据库层。

这句话是什么意思，刚刚我举了两个，所以失效的一个案例，还记得吗，那两案例所以失效，你给我说一下，我刚刚讲到，所以失效的时候有什么样的一个案例，lap范围吧or吧，然后呢这个大于的时候。

是不是会把后面的一个组合组里面的东西及视角，这儿讲另外一种视角的一个方式，就这块来看这两个语句。

看两句，我要写这样一句，这肯定能查出我们对这个数据结果对不对，然后看一下我们对于一个执行计划不出来，意思好吧，等于行，这是不是就我们组建了primary，主键索引就要逐渐缩影啊，现在我在做一件事。

这写一个a d加1=4，这句话是什么意思，然后往上看，这也是我一直没有想明白的一个点，我到现在我都没想明白，我现在都没想明白，来往上看什么意思呢，说insplslid from actor。

where actor，i d加1=4，那其实相当于x的id是不是等于三，你这样是不是加表达式，加表达式之后，按道理说，按道理说听懂没有听懂没有意思啊，按道理说这个时候我是不会读索引的。

因为我这是不是有个primary，他是不会就不会有对应的缩影了，但这个时候你会发现他用了一个什么索引，有什么缩写叫i d s艾特拉内，是不是这样算是用到了组合作引，index from。

这里面你告诉我哪来的组合作业，哪来的组合作业，有懂可以吗，看我的意思啊，看这儿有多作业吗，primary内幕吧，那这样为什么在进行匹配的时候，我查的是i d值，为什么是根据我们当前这个内部。

所以去找做去去走呢，所以说老师我能猜到这是查了id吗，因为你查id，因为你查id，所以我就直接去d里面进行一个查询了，这种解释好像能说得通，但是我为什么要走这个b加数呢，对是是这样的，所以说的很对啊。

我把这个换一下，换成星是不是就不走了，是不走了，看着歇着就不走了，但你发现了，当你在查询另外一个字段的时，候，另外一个字段的时候，他反而去走另外一个缩影了，这个时候我能给到的唯一的一个解释是什么。

解释是什么解释，当我在使用这样的方式进行查询的时候，本来本来我是需要去主见b加速里面挨个去便利主见的，从根进来开始挨个进行一个便利，这很明显很麻烦是吧，现在因为我有一个辅助，所以我有一个辅助索引。

这些辅助索引里面存的就是内部和id，而本身的叶子连里面存储是不是就是当前的一个id值，所以我直接去遍历当前的一点点，我就能够把我们当前这个id值给取到，所以这个时候他告诉我说我用到了当前这个辅助作用啊。

这是我能给的唯一的一个解释，但是到底是不是我这不确定明白意思了吗，刚刚也是了吧，如果查不是s i d的话，那肯定就不会用了，就不会有分类了啊，所以这是也是一个特殊情况，也是特特特殊情况哦。

对这东西确实得看源码了，所以你们所以你们在做这种，所以判断或者做所选择的时候。

一定要去看具体的执行计划，如果你脱离一个执行计划，给我发过来一个sql语句，是老师他会不会走索引，我觉得你在耍流氓，不应该逗我，因为这里面异常情况太多了吧，光我刚刚给你演示出来多少异常异常情况。

都是不太符合我们正常的一个理解，对不对，所以这时候会有问题啊，这时候会有问题，明白我意思吧，所以这点希望大家能够认识到，明白意思了吗，所以你下垂不是讲过重新下篇了吗。

没倒数，你下去了好吧好了，这这块有东西啊，这块有东西啊，东西好了，这是第一个点，那老师，那如果这样算，这样的话，是不是用表达式了。

来往下看啊，还有同学说这样一个法什么用法呢，他这样写的还是这个值很多，a d等于4+1，这种方式算不算用组合，所以不算不算用我们的表达式这种方式算吗，告诉我好了，同学们都知道算了，这块确确实实不算。

你可以来看一下，他说会做我们专门，所以这不算好吧，这不算，这就是一个表达式，一个计算好吧，跟我们整体这个判断是不一样的，它不会造成所以失效。

所以两种情况要分清楚了，是这块来这个点过了，pass掉好，再来看下面一点说了，尽量使用主页查询，而不是使用其他索引，因此因为因此主页查询不会触发为表操作吧，这句话是什么意思，这句话什么意思。

这儿我需要强调一件事儿，就是关于主线的问题，你们在公司里面在建表的时候，一般情况下都会来设立组建，你告诉我你在创建组件的时候是怎么来创建的，u i d还有吗，自从。

系列 2：P47：MYSQL调优：0.7 索引的优化 - Java视频学堂 - BV1Hy4y1t7Bo

这样名词我希望你能够认识到什么东西？这名词一个叫自然组建。一个叫代理组建。这两东西有没有同学听过自然逐建和代理逐件，有人听过吗？没有。所以啊面试的时候可能会碰到这样的名词，这啥意思啊？大家说一下。

所谓的代理主件表示的意思非常非常简单。代理组件就表示啥跟我当前的业务系统无关的那个列做了一个主件，而如果是业务主件啊，不如果是如果是一个自然主件，表示说跟你当前的业务系统是挂钩的。比如说我们建一张表。

比如说一张person表，一般我们的电表上都会有1个ID，对不对？你告诉我为什么要加1个ID啊。为什么建ID？其实我们在建表的时候，默认情况下，我就会建1个ID谁能告诉我凭什么建ID啊，为什么？

我为什么需要这样东西？一个责都是没有ID的。是不是这意思啊？好吧，所以这块注意了，引企ID是为了建一个主件，对不对？是不是要了建一个主件唯一标识，我我拿另外一个你做为一标，唯一标识不行吗？

如果是唯一标识的话，我设成英语扣不好吗？为什么生成主件？我这给一扣行不行？为面啥有主片？所以就是为了保证跟我们业务的一个无关性，保证跟业务的一个无关性。所以这块在建主建的时候，我们推荐大家使用的是什么？

是代理组建，就是尽量不要跟我们其他的一些业务性东西挂钩。所以你们建的时候都有1个IDIDID都有1个ID。明白我意思了吗？建议建议大家使用代理逐件。来这个点听来同学要会扣1。好了，就这一点啊就这一点。

就比如说啊我现在要存一个表，那个表叫身份证表，身份证表里面你要想取唯一件的话，你是不是可以起一个东西叫ID card，身份证号肯定是唯一对吧？它是不是可以作为主件。

同时我是不是可以再建1个ID的列ID是不是也是也可以成为一个主键。那你觉得我用ID好还是用ID card的好，用哪个好？哪个好CID块是不是也可以作为组件啊？建议大家用ID建议大家用ID。

建用ID就该几样的意义。好，希望大家做这样这件事。OK就这块啊。好了，来再往下看下一个下一个叫前缀索引。这道西啊，昨天给大家演示案例，但因为那个数据表我没准备好，所以这东西没演示成功。

我们今天来看一下这东西看这个东西，其实东西也非常非常简单。在我们刚刚那个撒拉那个数据库里面受。

tables这里面有一张表的CD，是不是相当于这个表，我把这个做好。希望四 you加忙。删掉好吧，删掉删掉，删掉完了之后，删掉完了之后，我们这儿可以来做一下这件事情，把这个表创建一下。

然后呢往里边导一下数据哎。

唔色。

做道这件事情啊，走所以这块是不是明显是成功，是不明显是成功。然后这块呢我们再重复执行5次下面的scle语句。

12345看到了吗？当你建5次的时候，这个数据值是不是在翻倍啊，是在翻倍。我们尽量把我们的数据值做到稍微多一点。这样的话你能看出来我们对应的一个特点，看对应一个特点。当你把这句话也建完之后。

下一步说我可以更新一下城市的一个名称啊，随机打乱一下成个城市的一个名称，不要让它太一样好吧，我这这句话这个过程会比较慢过程会比较慢过程比较慢，这有个by这语言你们可能没见过没关系。

你就知道它是一个乱续的一个数据就行了。现多少行了，mat的19200行来查一下吧行 fromC。

demo，然后呢写一个limit。20不查宣过啊，差20个看到了吧？这里面的一些数据啊，这里面的一个数据数据里面看到了有些语句非常长，有些语句非常短吧，这时候很长，这时候很短啊，这这这块一个信息。

这块一个信息。但你把这个数据造好之后，如果现在我要给这东西建索引了，你告诉我，我怎么建这个表其实比较简单，好吧？DSC。是谢ども。这边比较简单，就1个CT列。我假如说我要给他建索引，我怎么建？

我是不是可以把完整的字符说当成一个缩引，但这个时候很明显，它是不是就长了，是不是比较长了。所以我昨也说过了，我们可以取其中的一部分来作为缩引。而取这一部分的时候，其实你很难去做一个判断，我应该取三个。

取4个，取5个还是取6个，我应该怎么取？对吧所以这里面有一个索引的选择性问题。什么叫索引选择性啊？你看这样一个搜go语，你应该能能够意识到这句干嘛的s count星。

然后ICPNC from city demog by city by什么东西。这就告诉你说，我可以统计一下说有多少个名称相同的城市能能做删选吗？能把伦敦63个，然后这个地方53个，这个地方52个。

50个，是不是这样一个值是不是这样的值。当你有了这样的一个值之后，你会发现了我现在如果按全字符串线索引很明显比较麻烦，我能不能换另外一种方式，换什么方式，我能不能只取其中的一部分来参与我们整个的预算。

可以吧？所以这时候来看这个语句。

这样一句差不多差差不多，好吧，还是count，然后这写了一个什么叫left c3left left啥意思？取左边前三个嘛，取前三个，这个时候你算出来一个量级，数据值也是这几个，你发现了，我天哪。

这是不是差距有点大，这个最多是63个，这个做到多少了？484了，这很明显，这个重复度太高了，那是不是失去了我们之前统计的一个意义。那这时候可以怎么办？你可以再做一个合理的测试，你把三改成4。走。

发现值少了吗？少了吧，是不是少了，你再乘一个改一下，改成5。看一下又少了吧，对吧？你再换换成6。是不是少了再换7。当你依次往上增长的时候，你会发现当你截取到某一个长度，某一个长度的时候。

你会发现这个的值这个的值现在是7063、66、5050几。然后跟第一次我们在查询的时候，这个数量级是不是已经差不多了？

这块是不是也差不多了，这多少条，63这53、52这块呢是不是72、66、63，这块差异不大了吧。

哎，这块能听懂同学给会扣个一。还没到，现在还。不大了吧，占不大之后，我觉得这可能不是最优的。如果再把这个长度再调高一点，改成8个，是不是就更匹配了吧？来调8，你调完八之后。

你发现了八和7这两个东西看起来效果是不是差不太多呀？看会。87一样吧，我再改一下9。看效果是不是也是一样的是不是也是一样的。那这个时候你发现什么东西？其实七就是我们最合适的一个值。

我可以把字符串的前7个长度，前7个长度是作为我们当前缩引。那这前7个肯定比我刚开始最上面这个数据要少很多吧，这多少了，是不是取7个就行了，是不是这块东西？

对吧这块跟我们实际的效果其实差别不太大的那这个时叫什么？叫做索引的选择性。也就是说也就是说我可以选择其中一部分来参与我们整体的一个数据计算数据计算明白我意思吧？好吧，这儿大家要注意了。

就是说你可以缩短我们整个索引的一个长度这块的一个东西，这块的东西啊，所以这儿有一个索引选择性，你可以用它来进行这样的一个数据值的一个选择，就这意思。这是一种方式，可一种方式，好吧。

还有一种什么方式可以通过这样方式来计算。

走。是不是也计算出来一个比率，你发现了这个比率一直在往上走的时候，当你讲到7的时候，后面是不是也是这个值，所以7是不是也可以做这样一个判断？明白我意思吧，明白我意思吧，这所以七就是一个最合适的值。

刚刚我同学一直在刷，这个没什么意义吧，数据以后还会变。

你觉得这个东西有意义吗？

刚才有五个同学一直说，这东西没啥意义，数据还会变。你数据值再怎么去进行一个变化，再怎么去进行一个变化，跟你现在建存以有关系吗？没关系吧，我是不是可以怎么样？我再做一次统计。比如说我一张00插出据。

我每次当到一个时间节点的时候，我是不是可以再重建我们当前的一个缩引。是不是这意思？但是总体上看起来的话看起来的话，你在公司里面，你告诉我，你在公司里面，你的查询和你的插入，哪个操作比较多？

你合作会比较多。查询吧。是不是查询多是不是查询多，你插入并不是特别多吧，而且你很少会出现说我在某一个范围内或者说持续不断的一直在海量增加数据，这不会吧。是不是这意思啊？啊，所以这块大家注意到。

它是有意义的它是有意义的它是有意义的。这样的话会减少我们整体的一个IO量IO量。这个时候你的索引一定是情况，一定是你的呃索引速度一定是比较快的一定是比较快的。明白我意思吧？如果你觉得东西不适用。

你可以不用，这没关系。但是你要知道my circlecle里面提供了这样一种方式，你可以用来进行使用，明白我意思了吗？

来这个点听的同学都少扣1。几千万的数据咋用？几千万的数据，你就用大数据好吧，用H base存，用have存或者用raase存OK。Yeah。有几个人的公司里面，你的myscle里面存的是几千万。

还是单机的，有人这么干吗？那时候要聊聊我们对应那个集群了，这个就分开情况多了。好吧，你不要老想那种极端情况。我们现在做这东西的时候，更多适用是那种普遍情况，懂我意思吧？如果是几千万的话。

一定是要做那种那个那那个那个叫什么做那种集群式的和分布式的，一定不能再用单机了。你也不用看单单机了，你单机的话，你崩溃了。有上亿单机，你查询慢吗？你的业务系统有没有问题吗？你上亿的数据量。

你你没没有问题。系。所以们我老师你让my circlel里面最多可以存多少数据，跟大家说myl里面最多可以存64P的数据。有多少人真的用64P的数据存储啊？64P。会长同学吗？不会的不会的，好吧。

不会的。OK嗯。好了，是这块东西啊，是这块东西我不再浪费时间了。来下一点说了利使用缩秒呃，使用索引扫描来排序。这话什么意思啊？大家都知道，排序在我们数据库里面是一个比较麻烦的一点排序。

排序比较浪费时间吧。我问一下排序为什么比较浪费时间？啊，排训为什么比较浪费时间？人时表。系。文件好CPU好了，你们要说了，你们说了非常多的一个情况吧，只说出非常多一个情况，对吧？但不管什么原因。

我得到一个结论说它一定是比较慢的那这时候你再结合我们当前索引这样的一个数据结构，你想一下索引在使用数据结构的时候，它有什么好处，你想一下有什么好处，冷水说了，有东西叫s buffer。同时你别忘了。

我们在用索引存储数据的时候，索引本身是有序的，所以你可以干嘛，是不是利用索引来进行一个排序。你如果看执行计划看的比较多的话，你经常能看到这样一个描述叫unic。fiil short。

有没有人见过这个东西？这个U那个标授什么意思啊？啊，啥意思？他表示是说我要使用我们当前的一个文件来进行排序了。如果不出现它任域的使用什么使用索引来进行一个排序。所以你在进行合理选择的时候要做一件事儿。

尽量去保证你当前的一个查询怎么样，是是不要出现UC feel来我来看。

这依然啊也一样，看一下我们刚才这张表啊。

S index。From。认同。看这个表里面看这个表里面一个组件，这是一个这是呃一个索引吧，这是一个缩引吧，这是一个索引吧，这是一个缩引啊，不对。这是一个缩引这是一个缩引吗？这是一个这是一个这是一个。

是不是意味着我现在里面有5个缩引，我现在写这样一个scle语句。还有一句啊，一句比较好玩，slat rental IDta ID from rental，然后呢where date。

然后呢in IDcus my ID这三个列，我是不是刚刚好能够匹配上我们现在存在的这个组合索引。能比配上吗？不管你按照最多比原则按什么，能不能比配上这三例，威尔和奥特曼。可以了，那这个时候来看对应效果。

比说东西呢？我来看。这儿有出现我说的那个东西叫usic feel shorter吗？有出现吗？没有吧，如果没有，那意味着什么？现在是不是可以使用我们当前的一个索引进行排序了，那我这可以改一下，怎么改。

我把这东西删掉。看这叫ren ID data和这个cus ID是不是少了中间一个列子值。那这个时候还符合我们那个组合索引的最左匹配原则吗？不符合了吧，不符合来往这儿看效果。看后面那出来这个东西。

是不是叫using？那意味着下面这种方式是不是用到了我们的文件排序，而上面这种方式是不是没有用，很明显，他用的是索引来进行排序的。而下面这个地方他没有用索引来进行排序。那你告诉我。

我们在实际做查询的时候，到底哪个比较好？

因文说老师，你这个东西都很少啊。0秒啊，都是0秒啊，这是不对的。好吧，这是不对的这是你当前执行计划的时间。如果你想看的话，可以怎么看？一晚上六。走。这是查出一个数据啊，我这边没数据是吧嗯。不者。

那有数据啊。啊，这个时间时间值不对啊，这边有个时间值，收取出取不上我们对应一个数据，收取上我们对应一个数据。好吧呃，来再再换一下换一下，换另外一个，这样写一个。啊，TOY小写太低。啊，不是这个列吗？

看列是啥，那这个列面是啥来着，看不到。往上翻往上翻往上翻这东西啊，英模特ID没写错啊走。够嘅。这时间看不出来啊这时间看不出来看不出来啊，都是0秒，因为没举到我们对应的数据。好吧，这俩色度区别是啥？

区别非常非常简单。你看这个执行计划。讲半天没讲。あ哎。不告。这样今天计划一样吗？上面看起来都是差不多的都是差不多的都差不多的。但是你看下面多了一个什么叫标er，他表示说利用文件来进行排序。

而没有他表示利用什么利用索引来进行排序，这他们两个之间的一个区别。啊，他们俩之间的一个区别。罗老师，你把时间去了，可以。我先去了。时间去了之后，那这个外间是不是没有了。这个时候再往下看。他什么意思？

是不是叫E shorter？我再换一下，换什么加一下刚刚那个存在那个列啊，这个列。好啊。他会有重新排序吗？也不会吧，别忘了组合索引是必须要遵循最多匹配原则的。我现在再加一个东西。像什么21NTL下号线。

对的。哎，写错了吗？大家来看当我在执行这样的一个东西的时候，执行这样东西的时候，为什么这儿也会使用我们当前那个文件排序？为什么？这是为啥？那老师，你这三个不是应该是一个组合索引吗？是不是都可以。

遵循最多匹配原则了呀。那为什么这个地方还是我们的Uing filterer？按说会走优化去没优化。查的不是。微交站怎叫查的不是是啥意思？来往上看，我们改一下。Yeah。这改成三的星。有关系吗？

需要一个V尔条件。接下。会啊。INT。这样下线对的等于。2005-05-2。125。这可以吧？来再看。没有看一下果。看什么效果好，你注意看效果。OK。往上看老师，我这有一个人头da。

这儿要有一个data，这有一个东西，这个反而要走了。这为什么？这为啥？所以你在使用组合索引的时候，你要注意了，你要注意了。我这儿也说了，我这也说了，看这儿说下面的查询是不会利用我们当前这样的一个索引的。

不会利用我们的索引啊，他说了，第一个看这块，我加了一个范围，后面就不会走了，后面就不会走了，后面不会走了。我们看下这个一句吧。

不这。走是不是应思这叉点，这是一个什么范围吧，是不符合我们对应的一个最多品配原则，是不是这意思？这表啥意思啊？啥意思？这是不是符合我们对应的最多比用原则了。你这如果再加一个东西。

加一个叫date呃RENTAL下划线data逗少高。看这块它是不是也会使用我们的文件排序，也不会走我们对的一个索引，是不是这意思啊，所以这块大家一定要注意了，大家一定要注意的。如果你这加这单一号。

或者说如果你的过染条件里面没有带任何的一个查询。你单是order by。注意啊，如果你单单是我们对应的一个order by里面包含了我们对应的一个组合索引。这个时候我会不会有会不会走索引也不会吧。

这也不会走。这也不会走啊，这大家一定要注意了，关键是你的索引的一个选择，所以一个选择。啊，这才可以这才可以啊吧，是这款东西啊。那再往来看还有失效情况，什么失效情况。

往那看看这东行。系。怎不能复制了那C。

来看这个语句，这个就更好玩，st还是几个列不变。然后这还是再加上我们data，然后这有个alder back这样东西，它会不会使用我们当前的索引排序？我把地址改一下，好吧，把地址改一下啊。

这可能等于他会不会走。不会。还有不同意见吗？不会来看效果。他是不会，这为什么不会啊？来换一下。我把这东西。哦AS。诶，写错了。咩啊。好。他是不是走了，这意味着啥？你在进行排序的时候，要不然全部是升序。

要不然全部是降序，你不能一个升序，一个降序，这是不可以的。因为昨天我给你们演示了他数据的一个组织形式吧，组合所引的，是不是先匹配第一列，再匹配第二列再匹配后面的列，你不能说我让他升序，让他降序。

他再降序，这不行。啊，他没有这么智能没有这么智能。明白我意思吧？啊，杠G表什么意思？杠G就表示说我们正常显示的时候，正常显示的时候，它用的是什么表格的形式。你刚你加了一个杠大G之后。

它就把它转成转成一个行的一个形式了就他们就这这种形式，这有区别，别的没啥啊，就一个展示性展展示方式东西，展示方式东西。

啊，所以这块你再去看的时候，你一定要看一下，我们推荐你在使用索引，推荐使用这个索引扫描来进行排序。但是能不能走，还要看你具体的实际情况到底是啥，到底是想，明白我意思吧？好吧，来这个点听白的同学来扣个一。

没听懂啊。其他数据库是否是适用是否是适用这东西你要根据情况来判断，加数据库我不敢多说我只敢对我们对应的一个mycyclcle做一个呃呃就是准确的一个判断。其他数据库我不敢多说，所以下去之后。

你要自己去其他数据库里面试或者做一个判断。明白意思吧。好了，再来来看它有什么个uniallinall都能够使用所引，但推现使用ing是啥意思？这儿开始聊out的事儿，这几头都别做词作引嘛？这不用都说了。

对不对？好吧，来看这个语句，刚刚我们演示一种情况，那个out走不做左引。

听到我问题啊，刚刚我们演证这种情况，他这个奥到底是否走合以？懂吗？那个ABC的时候。那个ABC那个ABC的时候，组合作用的时候不走吧。啊。😮，PL。你较。ABC2YA。A12B等于2。他这个东西吧。

他懂吗？不走吧，是不是这意思啊，有内部的时候不走，没内部的时候走，对吧？OKOK来往下看看下面这个语句，看下面这个语句，他走的一个情况。

我们来给他看一下啊。第一个。嗯，看这一句，这用了什么un尼奥吧，我说了，un尼奥也会去走我们对应的一个索引，对应索引，这不都是我们的逐渐索引这个缩引吧。还有刚刚同学们试的还是个啥来着？

YID要写一个in括号。一逗号2。是不是也会走我们对应所研，是不是也会走。再往下看还有什么东西？XID然后呢等于12X下线ID。等于2。做会业了吗？知不懂？走了吧，他这块。是不是走了是不是走了对吧？

所以你说了，你要根据你的具体情况来做一个实际的一个判断，三种情况都会走我们对应的一个索引。那这个时候我们做什么样的一个选择？刚刚不是说不走吗？我刚刚在上面这个情况是说不走，上面情况是不走。

所以你不要笼统的说哦，走不走索引，你要根据你具体的scle语句，以及你创建索引的方式来做具体判断说我到底是否会执行我们的一个索引。明白我意思吧？不要一棒子打死不要一棒子打死。这个表格不给你看过了吗？你。

是不是有这么多例，然后so indexex。From either。是不是一个主件，一个内目列啊，刚才是不是给你给你们看过了，是不是你看过了，这是走动人，是不是走的时候，我们对应的一个主件。

所以如果你是一个单列索引的话，哦就会走。对非说的非说的。啊，所以这块你要详细去看一下，要详细看下具体的情况，不要一棒子打死，明白吗？所以笼统来说的话，都是不对的。DICABCABC有啥呀？

你这不就是一个表吗？这有啥？这有啥这没啥啊。这有啥问题吗？对，ABC是组合索引。ABC组合索引组合索引这边是什么？是唯一的一个主件。所以如果你是单列索引的话，它哦是会走的，是会走的。

如果你不是单列式组合的话，它是不会走的，明白意思吧？而组合索引里面又分了你的表里面是全部列都是组合索引，还是一部分。如果是一部分的话，是不会走的。如果全部的话是会走的。而走的是什么，是全部列这个索引。

而不是其中一部分其中一部分。刚刚那句话是听明白了吗？我来写一下啊，我来写一下好吧，你再自己记一下，自己记一下，好吧，如果。是单列，所以啊会哦会使用。所以好吧如果。是组合，所以啊不会。哦啊，这要分情况。

第一种情况，啥东西，全部的列。都是组合。所以。啊，那么会使用什么全部列所。对应。啊，所以。第二种情况，如果。部分。列是组合索引啊，那么不会走索引。看白这意思了吗？这边这个情况啊。

把这些东西能对应起来就行了啊，能对应起来就可以了。好吧，哎这块听完同学给老师扣个一。能听懂吗？好，没问题啊，没问题，我们再接着往下聊往下聊，好吧。

啊，大家看说范围列可以用到我们索引，就不用说了吧，之前已经演示过了，好吧，不要觉得范围列就不可以用我们对应一个索引啊吧，但这时候就注意了，在组合索引进行使用的时候，组合使用索引进行使用的时候。

它后面的列是不能够走的，是不能够使用索引的。如果你中间你如果你中间添加了注意啊，如果你中间添加了范围条件查询。如果你是一个组合索引，后面的列是不会再做索引的。所以这一块你也要注意它。比方说上来之后。

所有的范围也都会有索引，这也不对。所以说法在说的时候，一定要好好去看它，一定要好好看它。明白意思吧？好啦。为啥？组合作业刚才不是说了吗？你写了1个ABC如果你写了一个A等于一，B大于2，C等于3。

C会用吗？C不会用吧，这是不是就组合作业的一个一个一个一个判断一个判断。之前我是不是讲过了？对吧正常情况下，如果你只有一个列的话，这是可以的这是可以的。好吧，A等于问号B等于问号C等于问号这可以吧？对。

这是可以的。你财业方案以后放到最后，这是可以的，但是必须要遵循那个从左到右的一个顺序到右的一个顺序。O。好，来再往下看下一点叫强制类型转换会触发全表扫描是啥意思啊？这儿也非常简单，来看一下案例。

我这应该有一个表吧受。

てばす。你有点吗？没见是吧？没见啊没见来，我们来看一下，我们来说一下这个这个这个这个这个情况什么意思呢？你们在做类型匹配的时候，一定要把全部的类型给完整的匹配上。这有接表语句吗？啊有啊。

来，我把这语气运行一下。

对。走，这表非常简单，好吧，show index from叫user，这里面是有一个索引链叫phone，对不对？我在做一个查询的时候，slide先 from。嗯。😊，啥啥东西？有什么了？

from user where然后呢for等于。要写一个。随便写随便写这个值好吧，随便写个值无所谓啊。

系列 2：P48：MYSQL调优：0.8 集中答疑，解决同学们学习中的问题 - Java视频学堂 - BV1Hy4y1t7Bo

列之之后来运行，他会做索引吗？别忘了我们这个袜叉是我们这个放的什么类型？是挖叉类型，这时候会不会做索引？汇总啊。对他会有缩引。但是如果你换一种写法。我把代言号给干掉。把单引号干掉，把单引号干掉之后。

他会报错吗？不会吧，是不会使用。好，来，我来看。看见你吗？但你把代码开变掉之后，他不会报错，但是他还会走索引吗？不会了吧，为什么？因为里面涉及到叫影视类型转换。啊，所以再加一个引视类型转换的时候。

也会导致我们当前索引失效当线缩引失效啊，这大家一定要格外注意的一些点啊，应该格外注意这些点，听白意思吧？今天昨天还有一个同学来问我来着，说我现在要做两个表的关联，在关联的时候，他发现一件事。

他发现一件事儿好吧，他什么事呢？因为它的类型不一致，导致索引没走了。我说这很明显，当你在发生类型转换的时候，一定不会走的，这相当于我要加一个什么是不是类型转换函数，是不是类转换函数，使用这种函数的时候。

是不是会造成我们的索引失效，这块就这个意思。只不过这个操作不是我们肉眼能看出来的或者不是我们看出来的。所以这个时候我们失效掉了。啊，所以你在写的时候要避免这种情况，他虽然不会报错。

但是有可能会导致所以失效，就这意思就这意思。

好吧，预算函数利转换都不行。对对，OK。好了，就是这样的一个类型的值。好吧，再来看还什么呢？说更新是分是频繁，数据区分度不高字断场不易串现缩引，这什么意思？这什么意思？意思非常简单，这儿记住了。

我现在表里面有一个列叫ss或者真的属这叫性别。我需要在性别上见索引吗？不需要吧。对，一定不要不要见索引，好吧。所以这里面说了，区温度不高的字段不会见索引。刘文老师。

我怎么知道我这个列到底是否区温度高不高啊？听得到吗好？这块给大家一个数据的参考值。有没有同学听过一个东西叫DV能听过吗？有没有听过DV？什么叫定位啊？DV的全称其实非常非常简单啊，叫什么呢？

Disting的。咩。第一次定单有啥意思？表示是唯一值吧，是不是唯一值是不是唯一值。就是说我可以计算一下当前这个列里面的唯一值，然后呢去除以我当前表里面所有的总行数，听白了吗？总行数。

这个值如果大于80%，可以见索引，如果小于80%啊，我们就不建议建索引嘛。当然这只是一个参考数值，参考数值没有什么实际意义，没有什么实际意义。但是你要知道了，在数据库层面经常会计算一个东西叫什么呢？

叫基数，有人听过吗？有没有同学听过这两名词叫基数。好，莫涵说了，对，就这东西。基数这个基数代表什么意思啊？什么叫基数啊？什么叫基数？基数它更多是在数据库里面起的一个预估值或者说估算值，这个值很重要。

这里面会演示出来另外的一个名词。另外一个东西它里面有一个非常非常著名的算法，你们应该听说过什么算法叫hyperlogloger，有人听过吗？这东西。有没有见过这个算法？见过同学给老师扣一，没见过同学。

给老师扣2。好了，同学说了readds对，非常非常对。raice里面也用到这个东西了。你要这么东西了。所以你会发现当我在计算类似相目这样东西的时候，它使用的方法都是一样的。

包括大数据里面的像听ing一这样的技术，它也用这个d听value了。听明白了吧？这东西很重要，它那个基数统计啊，注意了基数统计算完的值并不是一个准确值，而只是一个预估值。而这个预估值。

我表示的是某一个具体的数量级，什么样数量级1101010万不一样吧，是不是很明显不一样。对吧所以我更多表示一个数量级，而不是一个准确值，不是一个准确值。啊，这样东西啊，下在周自己看。

为什么说有些同学学东西比较快，有的人学东西比较慢，原因就在于原因就在于什么？你看到这样技术之后，你可以联想到另外的一个点或者另外一个技术里面是否运用了相同的东西。

如果应用了意味着两个底底层里面实现机制是一样的。啊，所以关于DV和cap板，下一周自己看，我这不讲了。但是这个点你要知道，建索引的时候，并不是说我所有列里面都建了，就一定是好，这不对这不对是吧？

合理去做选择，合理去做选择，这其实更加重要一点。来这个点听白同学给老师扣1。好了，再往下看，他说了。诶诶。往上看他说了，当需要进行表链接的时候，最好不要超过3张表。好吧。

因为需要重要的资产数一些必须一致。这句话什么意思啊？这是那个阿里规约里面，阿里规约里面是不是说了一句话，说你要执行表关联，最好你的状元字段不要超过3个。如果超过3个了之后。

可能会造成你的数据量查询会比较慢。对于大公司而言，确实是这样的，或者说你的表非常非常大的话，确实这样啊。但是我说一点，在使用状元的时候，有没有可能会走缩引。听吗有问题啊。

使用重要的时候会不会走会不会走缩引？会会吧，可能吧啊，但是这儿要强调一件事，就是说的，你在使用join做索引的时候，你必须要保证你的数据类型是一致的。如果你的数据类型不一致，它会造成索引失效。

所以知想那老师会不一致吗？会会昨天有个同学还问我这个问题，我可以给你找一下那个那个那个那个那个那个学生问那个问题。好吧，他就这么说的啊，不能展示啊，打马赛克不打不能展示啊。就是这样会有这种情况啊。

所以你要知道这个东西，你要知这个东西OK。不是杨理对，是这样的。好吧，来再往下看，还有个模型呢说能使用limit的时候，尽量使用limit，这边我说了吧，limit啥意思啊？我举个例子啊。

my circle里面你在进行分页的时候，经常用limit那limit它的作用是用来分页吗？啊，我一我一说来找，你们都说分页，那的作业是分页吗？不是好吧，limit的最严谨的一个解释叫什么？叫限制输出。

好吧。分页只是其中的一个用途，仅此而已。比如说我就让你帮我显示前实条记录，这跟分页有毛线关系啊。没关系没关系吧，所以叫限制输出好吧，那你在使用limit的时候，需要注意一件事儿，注意些什么事儿。

你limit5和limit1半。多5两个语句执行效率是一样的。需要了吗？不一样了，而且像limit，如果你要limit比较大的一个数量级的时候，大的一个数量级的时候，千万不要用limit这样的一个东西。

我刚说了啊，能使用的时候尽量使用，但不是一定使用，明白吗？一键使用就有问题了。您的什就有问题了。好吧，因为是啥？你需要先。顺序过滤到前面的1万条记录，然后呢才能取出后面的5条才能取出后面的5条。

如果你不用那东西的话，你是取不出来的，你就取不出来的。所以这会成为一个问题。就是前一万条记录或者你第一个值会越来越大，第一个值越大，查询效率肯定是越低的，查询效率就越低了。明白了吗？啊，这要注意了。

好吧，就这个点状元那条数据类型一致是指的二字段类型一致吗？对，就是你的连接条件，连接条件类型必须一致，那条一数据必须一致。大数据量分页怎么办？

可以通过子查询或者说un尼奥这样的方式来解决子查询和un尼奥。有人用这样方式吗？大数据量分页的时候，有没有人用过un尼奥或者子查询，也用过吧，没有。不是没准备这个案例啊没准备这个案例啊。

下之你可以你可以试试这个网上一搜一堆铁的，一堆铁的，有这样的方式，尤尼奥和子查询都能解决这样的问题，查询效率都是好过直接lim敏的直接lim敏的。你看就是子长，你不是干他吗？不是。

不一定不一定不能说不是啊不一定不一定好吧。日期类型建筑的规则一样，一样，这没这没关系的这没关系的这没关系的，好吧。啊，子查询不是查询两次了吗？是查询两次，但是你要判断你过滤的数据量是多少。

你过滤的数据量是多少，跟数据量是相关的。明白了吧？这我们准备案例啊，这个后面这有时间，我们准备一下案例给大家验验一下就知道了。我这没没有数据了，主要没数据，好吧。来再往下看下一个东西，什么呢？

说单表索引建议控制在5个以内，这个没有说了吧，这是高性能mycyclcle里面说的一句话，说单表索引控制在5个以内。但这块我要说一件事，我要说一件事儿。现在。没有太多的限制。这句话听明白了吗？

这句话什么意思？这是之前那个就是那个什么保险思后里面说这样一句话，说，单表索引建立控制在5个以内5个以内好吧。但是我说一下，其实你超过5个也无所谓，也无所谓，也无所谓。这块是没有什么限制的。

因为现在磁盘也好，内存也好，跟原来都不是一个级别了，都不是一个级别了，所以这块也不会造成太大的一个影响。但是还是建议越少越好，因为你注意一件事，你的索引越多所引越多，你所需要占用的磁盘文件就越大，越大。

意味着你的IO量可能就会越大。所以它依然会有影响，依然会有影响，依然会有影响是吧？但是呃不像原来老版本的时候影响那么大，仅此而已。好，这也拿出去了。再来看还有呢叫单索引字段数不允许超过5个。

这块呢说的就是啥？这就是我们的组合索引吧。啊，组合索引吧组合索引这块也要注意一件事，就是不要让太多的列都参与到组合索引里面，因为都参与到组合索引里面去之后会有啥问题。你想一下，你在建那个K的时候。

是不是用的是左合缩性值。那这个左合索性长度是不是会变大？K值变大之后，是不是会影响我们整体的一个效率了？对吧啊，而且后面的更新维护都会变得比较麻烦，都会变得比较麻烦。所以这种写啊稍微注意下行了。

一定记住越小越好你小越好。OK然后呢，最后一个说创建作业的时候，应该避免以下错误观念。第一个错误观念。第一个错误观键是索引越多越好。索引是越多越好吗？不是吧。所以越多，意味着你存储。

所引的数据文件就越多。所以数据文件越多，意味着你的IO量就越大。IO量越大，有可能会影响我们整体的一个查询性能。查询系能好，所以这一定要注意了。OK再来看说过早优化和在不了解实际系统的情况下进行优化。

是啥意思？之前有同学问我索引的问题，他上来啪扔给我一个搜口说老师，你告诉我这个缩口我应该怎么加索引之后能取得最好的优化效果。如果是你你怎么办？听到我问题啊，原来有学生扔过来一个搜狗语句，就问我老师。

我怎么加作业。我当时我都崩溃了，我说这事儿不对，我说你要先给我介绍下你的业务，我介绍下你当前的一个数据结构是什么样子，你要做什么样的一个查询。我对你的业务了解了之后，我才能够去创建我们队的一个索引。

是不是这意思？你上来之后就个就不对啊，所以你在建索引之前，千万不要上来之后，就说老师我要建索引，这不对。今天还有同学问我一个问题，他说老师这个东西s。星 from tablewhere然后呢，A等于一。

然后呢，B等于2C等于3order by。办ID。高老师，这东西我应该怎么建索以啊，什么样的方式更好？我说我是这么回答的，我说你在这种情况下建索引的时候，可以选择创建组合索引，也可以使用主变索引。

这东西要根据你的实际情况去做一个具体判断。我没法给你敲死，说你必须要用什么样的一个方式去公司里面看你具体的一个业务啊，来进行合理的一个判断。明白我意思吧？啊，这点很重要。所以说了。

如果你不了解你的系统上来之后就要做所有的优化，简直就是耍流氓，这不合适这不合适。明白我意思吧，好吧。好了，这是这儿存在的一些点。然后呢，除了这一点之外。

你还可以看一下你当前的系统里面所以使用情况是怎么样子的。比如说这样一个命令，我们可以运行一下。

是不是这样一些数值啊，是不是这样一个数值啊？这些数值表示的具体意思就是说你大概用了哪些什么样的一个索引。比如说读取索引第一个条目的次数，通过index获取数据的次数，读取索引最后一个条目的次数。

是不是有些参考值。这些参考值下去之后可以自己来看看，可以自己来看看啊，来做这个合理判断。但是一般这个值与我们开发人员而言是没有关系的，是没有关系的啊，我们所需要做的事儿其实非常非常简单，非常非简单。

就是合理的去创建索引的一个方式，和去创建，争取能够达到最优的一个效率。但有些情况下，有些情况下，单纯依靠加索引是解决不了根本问题的，明白了吗？

听明白我这句话好吧，有时候你单纯的就想固执的应应用索引之后来加快我们的查询是不太现实的，是不太现实的。你要根据实际情况来判断，能加索引当然好，如果不能加，你也别硬性去加，好吧，我就非要加，何必呢？

明白意思了吗？好吧，这大家定要注意了大家定要注意了。好吧，来，这是我们关于索引优化所有相关的一个知识点，知识知识点这块听懂并且感觉对自己有收获的同学给老师扣个一。嗯。嗯。拜e拜。你说话吧，应该。

听懂没记住，我说过了，这块东西一会儿下课之后我会发，我会发，你们去找自己对应的一个咨询小姐姐去要这东西就行了啊，要东西就行了。刚刚我看到有同学问了一个问题，说老师s星呃。

不是count星count一和count某一个列。哪种效率比较高啊？对。这三种情况哪容效率比较高？我告诉你，你去做实际测试三种情况一样。三种情况是一样的。

你在网上可能会看到一种帖子说count整数值速度是比较快的。你做测试去，你实际做测试，你会发现一模一样。好，都一样，没有任何区别，听明白了吗？没有任何区别，不信你就去试欢迎打点。

这个之前我上课的时候是演示过的，是演示过的，你自己去试好不好？你自己去试。OK。😊，试完知道试完之后，你就知道大概有什么样的一个区别了，大概有什么样区别了。好啊。好了，这是我们这块关于索引这块的一个点。

多一多嘛。你们觉得这样东西多吗？count大表特别慢，有特别优化吗。如果你只需要做count优化的话，你可以看一下我们对应的那个嗯你可以用my里面有一个计数器，它的自动统计总体的一个行的个数，行的个数。

好吧，这个东西跟大家说一下，这只是这块知识点的其中一小个模块，这是通过索引进行优化。除此之外，上面有什么有性能监控，有数据类型方类的一个优化，我可以把那个放小一点。哎，太小了。太小了是吧？

然后每一个点其实里面都包含了非常非常多的一些东西。可以给你们展开，你们看一下，好吧，查询优化。看东西了吗？也就是说你现在在进行使用的时候，在进行使用的时候，你需要把这些点都掌握到吗？其实说实话。

我说句良心话，我觉得这些东西啊，其实在公司里面没必要都掌握。因为你们在公司里面压根也用不到这样的一些技术。或者写搜cle的时候，其实根本不往这方面进行考虑。除非我出现问题了，我才会去考虑这件事情。

如果不出问题，我一定不会考虑这些东西的。一定会考虑个东西的。啊，但是但是你在面试的时候，你要了解他。啊，因为你不面试，因为你在面试的时候，你也不知道面试官会提出什么样的一个问题会提出什么样一个问题。

所以最好能把这些东西好好看一下，能多掌握一点是一点啊，这东西总没有坏处，总没有坏处。而且这块会加上你整个技术实现的一个底层方面的一个效果。底层方面的一个效果，这点其实更加重要。听白我意思吧？

所以这里面有很多很多你需要相关关联的一些点，下一周好好看。有同学说老师高性能那本高性能M那本书写的比较虚。我跟大家说，你沉下心来好好去看那本书。那本书我看完之后，我的收获非常大的，而且我看了不止一遍。

我看了不止一遍。我现在说的上就那本书，我现说就这本这本书，其实我可以给你们等一下啊，我给你们看一下，像这本书。行，我可以给你们看一下啊，我这就有这本书。这着说高兴能来搜搞。不是吹了。好吧。

我觉得你们真应该把这本书好好去看一下，很重要很重要。啊，因为这本书里面会聊到很多你之前没有接触过的一些细节点。当然刚开始听的时候可能会比较难受一点。但是没关系。

你坚持下来去听去看去看你看下去之后总会有对应的一些收获的。然后看这本书的时候告诉大家，你还需要做这另外一件事。

把那本书跟我们对应的一个me官网两个东西结合起来去做一个查看接着做一查看就好比我昨天在你说文档的候，说文档的时候，你要聊什么东西，比如说我们看用户点对不对？你说我要看索引从索引所以结果在哪呢？

你要对官网比较熟的话，比如这点开这有一个index里面就有一句话告诉你说my里面我到底是用的是什么样一个索引，这块都有对应的一个解释，看这most my index吧。

柚吧有些东西用的是吧memory table用的是什么叫哈西 indexdex柚什么呢？叫 index说这块都有这样的一个表示。

听白我意思吗？这个事都有。啊，再者老师，我想看一下这个执行计划到底是什么样子的，很简单，往下找。说一下，这里面一定会有对应的一个执行计划。看到query execution。嗯，拿是吧。啊，不对。

写错了。看这儿。看这块了吗？刚刚我给你看执行计划的时候，这些东西ID什么什么什么什么东西，每个列车都解释，下面都有具体的案例，你能进行查看的，这块都有，这块都有，明白我意思吗？

所以把那本书和官网结合起来，一起去做一个查看，这才是最好的一个学习方式，单看书不太好，最后两个东西都看一下。现在mycycl8。0市场环境更多嘛？我们公司现在做项目里面都是用8。0，因为8。

0据说是最快的mycyclcle的一个版本，最快的mycycl一个版本。啊，用起来的时候确实也比较舒服，而在里面做了比较大的一个改动。对就比如说现在你还能看到那些点FR文件，如果是8。0，告诉你。

你连那个点FRM这个文件都看不到都看不到。听白了吗？啊，所以不同版本之间8。0和5。几区别还是比较大，区别还是比较大的。所以你要看的话还是一样，通过官网去做一个查看，都有具体的一个解释，明白意思吧。

告诉大家如何来进行一个学习，如何来进行一个学习，这其实更加重要一点。啊，高性能卖测狗第三版是出卖家看的。啊，老师发量不错，我天哪，我了下看看，你看这个到哪了，还发量不错。你是怎么判断的？😊，啊。

你怎么判断的？只是盖一下而已好吧，只是盖一下而已。OK。所以啊呃房子这事就就就就头发这事就别聊了，好吧，聊完之后伤感情，聊完之后伤伤感情。OK没秃理就散多了。我以后肯定是朝地中海方向发展。

聊这不是我家啊，我在公司上班，好吧，这是公司，这是公司，这不是家。不是我家好吧，这是公司。OK我天哪，我家要这么这么奢华，我这这么这么大，我我是太开心了，老师来抽我的公司招人不。哎，我们公司正在招人。

我次前面了几个程序员。好啊。😊，下周可以可以看一下，10点还在公司，凌晨3点之前没回过家，没回过家，好吧，公司能抽烟过能能。好了，听完今天这两节课啊，我相信大家应该是有所收获的那下面我们来问一个问题。

这只是my circlecle其中的一个模块。今天下课之后，你们去找对应的咨询老师，我会把索引这块东西给大家发下去。但其他模块我就不发了。好这块我会给大家发下去，我给大家发下去。

下来之后把这里面的点好好去看一下，好好思考一下，我讲了两天讲两天，但是但是你注意了，你下去之后可能需要更长的一个时间，更长的时间去把这块知识做一个很好的学习，好好的学习。

明白意思吧？啊，我在一直路学老师喝茶，可以啊，随时欢迎大家来公司，公司就在北三环，随时欢迎大家过来啊，随时欢迎大家过来。这儿我再说一点，就是这些点同学在问老师面试的时候会问这么多吗？

或者说我有必要学这么多吗？我感觉好累啊，学这么多东西。对不对？这时候你可以思考一件事儿，同学们思考一件事儿，什么事儿？现在不管是大厂也好，还是中厂也好，还是小厂也好啊，你在面试的时候。

他经常问的点是哪些点？好。经常问他点哪些点，我们这儿其实可以做一个具体的一个讨论。我们应该讨论一下，就是为什么要学这些东西，有必要吗？何必呢把自己逼成这样。

不光光是聊数据库，好吧，你放眼整个程序员这个行业或者这个圈子。你现在面试的时候会问什么东西？都提到了。OK多见长高秉发。这会不会考一定会考的，这百分之百不会考。对高敏发各种锁内部实现机制是吧？

AQS会问吗？那写一下。锁。AQS。嗯，AQS。一定会问嘛，对吧？来第二点还有什么东西？数据结构。OK还有什么东西？还有啥。对。设计模式。OK然后呢。GVM吧，还有呢my circlecle吧哦。

我们换一个数据库吧。对不对？还有什么东险？Readies。还有呢算了。算法跟数据结构其实经常是放在一起的吧。上把家。算吧。还有什么东西？源码。OK还有吗？消息中间线。还有没有？そ了谁头。Yeah。

然后呢。ZK如黑。没有。现在基本上在面试的时候，常考的点式就这么多links内核这东西给大家说一下。内核这东西怎么说呢？现在呃你到面到非常非常高的一个级别之候，才会有这些东西。

如果你面子是一些初级中级这样的一个开发工程师的话，这块一般不会问到一般不会问到。明白我意思吧？好吧，OK这里面我涉到什么IOIO里面会有IO里面会有好吧。

这时候你会发现了我这么多东西我要怎么去做一个学习。我学这个东西的时候，我应该怎么会问了他他也不会跟他会不会没关系。你去面试的时候，这一点几乎都是必考的，都是必考的啊。

王阿汪说开始广告时间就是要开始广告时间，明确告诉大家，就这块东西，如果是你自己的话，你会怎么来学这套东西。早点学习，或者说你应该怎么去学。啊，我之前问过几个学生，之前几个学生给我发过一些他们聊天记录。

看那，他说了，梁老师打扰一下，这一堆这学生发给我的困惑。他说他已经报名了，报名之后呢，是91年的宝妈，他现在没工作，我现在应该怎么学习。他说最喜欢梁老师的授课方式，所以请刘老师指点一下。

我打电话再说一下怎么学。后面的学生加班一直加班非常疲劳，特别想学习，却抽出时间，有没有好的建议，我给老大打电话了，打了78分钟。打了78分钟，同学们一个半小时，我跟我媳妇都没打这长时间。面子吗？

来再来看。大好你好，看看主任投入想看工作有没有合适，想和语沟通看有什么方便。啊，这个时候也往下看，这也是一个困惑。之前有什么样的一个方式，我应该怎么做学习？这有一句话其实非常非常核心。

我觉得这句话说的太好了，叫java知识太多了，怎么样去进行知识的一个管理。啊，七八分钟是妹子男的好吧，纯盐味儿纯盐味纯银味啊，其实我给大家说一下，就是大家现在其实遇到的问题。

普遍问题都差不太多都差不太多。我会给大家看一个点，看这东西啊，你能看到屏幕吗？这是之前给学生打电话，我之前做的一个录音，一共有233个电话，而且这只是其中一部分。因为那个苹果手机没法录音。

我专门买了个安卓手机来录音。就是我们之前给很多学生都打过电话，都打过电话。打完电话之后，慢慢会发现大家其实遇到了一个瓶颈。我遇到了一个情况，大致都差不太多。他差太多。我可以可以给大家看一下。

我给我给多少打打打个电话，好吧。你往下看看这块了吗？跟进人属于联盟局。然后面呢客户翻译。你都想象不到，我给多少学生打过电话。打完电话之后，慢慢的就是总结出来说。

OK现在大部分学生他遇到的是什么样的一个困惑呢？其实面试的点逃脱不了这样的一个环节。啊，这样的一个环节情况就是学只是理论没有实践跟实践半毛钱关系都没有。之前办完就问题都没有你进他进进公司的时候。

比如说你现在要进一家互联网公司，不进一家金融公司，一定是需要你有你一定要具备金融背景吗？或者之前一定要进过金融行业吗？不对的，就大家现在学知点的时候。

更能是这一块占一块占一块这一块占一块占一块占一块占一块。你每一块都学了，每一块学都不好啊吧，你现在需要是什么？需要是整体做一个。规整规整完成之后，里面有N多个对应的一个模块，跟多我们一块。

你应该怎么去做一个学习啊，怎么块对应对应一个学习。这其实更加重要。还有就是各个知识点，他们之间的一个关联性，他们之间的个关联性关联性其实也更加重要也更加重要啊，那是老师我光写理论问题，光写理论没有实践。

这有这有什么意义呢？大家说一下，理论如果不会，你现在光会应用更没用。现在在面试的时候，刚已经说过了，他不是说问一个点，O我会了，了了，这事不聊了，是这样的吗？不是我会沿着你某一条路一直往下问问问问问问。

问到你答不上来，O这事吧。是不是这样意思，所以这些点啊都比较比较重要都比较比较重要。你应该怎么去学？刚刚我这儿给大家列的这些模块哪去了？列这些核心点，其实就是我们现在要做一件事情啊，那不是深真正深的。

都是结合实践的。