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

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

系列 3：P131：【JVM】乱序证明 - 马士兵_马小雨 - BV1zh411H79h

之外，你其他的都解释不了，为什么会产生这种情况啊。好。我们继续啊我们继续，我们这事儿还没完。我告诉你，还有一个特别恶心的实验还没完。我们来看这个实验。就是说我说这个东西是乱序执行的。你怎么才能证明呢？

好，认真听。我说这个论这个东西啊是乱序执行的。两个指令。互相之间它的顺序有可能是不一样的，有可能下面后写的这个指令先执行。那好。你怎么才能证明这一点呢？还有一个比较恶心的实验。

这个这个实验呢叫做disorder啊，GMM下面的disorder点是阿va。好，看这里。看这个小程序，这个小程序是美团的人写的啊。

不知道在座的有没有美美团的。这个呢我记得了GMM。这个下面啊。

Disorder。啊，这个dor的话就更讨厌了。

呃，桃子以前是美团的是吧嗯。好，这是合并写技术。我们说乱序执行的证明，怎么才能证明这一点？JVM下面的JMM下面的diorder这个程序。

嗯。😊，美团骑士。😊，😀，大家比较逗啊。😊，啊，不要闹啊，来看这里啊，大家看这里啊。呃，现在呢我们有两条也有dior有两条指令啊，你看这里呃int X等于0Y等于0，然后A等于0B等于0。呃。

然后用一个for循环死循环啊死循环。就是一直不停的加，然后看这里啊下面执行了4条指令，这4条指令叫做S等于Y等于0A等于B等0，这就除复属日值啊，不不不管了。呃，大家看这个啊，第一个县程。

第一个县程干了一件这么事，干了一件这样一件事，A等1X等B。

你仔细读第二线程干了一件什么呢？B等于Y等A。那么一般的情况下，我们要打印最后的X值Y值A呃A值B值要打印这个值的话啊，打印X值Y值的话，我们来分析一下。嗯，X等B，然后这里呢写的是B等1。那么Y等A。

这里写的是A等于1。好，假如。对。假如嗯。先让二先执行啊，先让这个来执行。首先执行B等一。你看啊，由于第一个呃县程呢等待了一段时间，呃，所以呢第二个线程先执行。那么由第二个线程先执行的时候呢。

它会先执行B等于一。然后呢。后面会执行的这个这个内容呢，应该是Y等于A。Y等于A，但这时候A有可能等于0是吧？A也有可能第一个线程执行完了，A有可能也有可能等于一。所以这个Y的值呢有可能是0啊。

也有可能是一。嗯。然后X就会变成几呢？呃，只要你设置成为B等于一之后。那么X等于B，那么X的值呢。我们给大家解释一下这个问题啊。好，我这么说吧，这么说啊，认真看呃，X等于B，那么B呢有可能是等于一的。

X等于B，有可能B是等于零的是吧？所以X呃这个这个X值呢有可能是0和1Y值呢也有可能是0和1。那么现在呢就会发生这样一种情况。呃，假如呢。假如这两个值啊，就这你们我们来分析一下这两句话。

就是A等于一和X等于B这两句话，他们之间呢有没有依赖关系？A等于一和X等于B有没有依赖关系啊？同学们，你们分析一下。A等于一。X等于B。是没有依赖关系的。假如说这两句话是顺序执行的。

这两句话呢也是顺序执行的。那么现在呢应该是只有什么情况呢？我们来分析一下啊。那么A等于一。也就是Y等于A。A等于一X等BB等于1Y等于A这这几句话呢，这两句话顺序执行，这两句话顺序执行。

互相之间不会换顺序的话。那么应该就只有这么几种组合，XY就只有这么几种合，0110和11。是不会产生00这种组合的啊。是吧，同学们，我们来仔细问一下啊。嗯。呃，为什么会不会产生啊？

因为你比如说你X等于B已经已经执行了这句话的话，那表示A等于一肯定执行了。对吧，同学们。那么如果I等于Y等于A，这就这句话执行完了，表示B等于一肯定执行了。所以呢在这种情况下是不会产生00种组合。

只有可能会产生011011这种组合就是X和Y的值。好，我讲到这里呃，不知道大家呃能不能理解这个问题啊。啊，我再说一遍啊我再说一遍，我们现在有一个假设的情况，就是假设什么呢？

假设A等于一X等B这两句话一定是顺序执行，不会乱序。B等于一Y等于A这两句话也会顺序执行，不会乱序。那么最后X和Y的结果呢。如果这句话执行了，表示B等于一一定执行了。如果这句话执行了。

表示A等于一一定执行了。那么所以X和Y最后的结果一定是01。1011的组合。绝对不可能是00的组合。因为A等于一和B等于一，其中有一句必定先执行了。我这么说，大家能理解吧。对，只要没发生重排。

没发生重排。就会有这种情况。所以只要我们能证明，其中有一次要是出现了00这种情况，就说明一定发生了重排。好。这个程序我告诉你啊，我运行了多长时间呢？N长N长N长时间才发生了00的情况。

但是确实证明是发生了的。呃，我估计我在这跑，咱们回家吃饭去，好吧。你可能半天你也等不来玲0那个情况。我给大家看中间我执行过的一次的结果就行了，好吧。

好，一共执行了是2728842次之后，终于出现了一次00的情。啊。这是我中间执行过的一次的结果，给大家截图截出来。所以这个程序你们拿回去自己跑，你们可你们在你机器上没准跑着跑着跑个跑跑很很短就能看见。

但是很长的话，你就吃饭得吃完饭回来之后。等着有问题就行了啊，吃完饭回来之后。看结果就OK了哈。好，所以说乱乱续这件事呢是呃被美团的工程师呢是证明过的啊，确实乱续执行。但是乱序这件事是会产生问题的。同学。

咱们说。我我我我我我我们说java里面这个volattilevolat。

他是要保证不能乱续执行的，对不对？在有些值的情况下，我必须得保证我不能先往里写，得先读才行。有些情况下呢，我必须先读，不能先写才。

系列 3：P132：【JVM】硬件级别保证有序 - 马士兵_马小雨 - BV1zh411H79h

这是乐取执行的一个证明。但是有了乱序执行之后呢。如何保证？特定情况下。不乱去。比如说walllowalllo就保证有序嘛，就是它保证了一个有序性。哎，那行了，那这个有序性是怎到底怎么保障的呢？好。

硬件层面听我说，在你保证有序性的情况下，所以硬件层面的一个指令就是汇编指令CPU的汇编指令以汇编辑。他就做了这么两两个东西。第一个呢，当然是加锁，加锁是肯定的，加锁是100%可以完成的。但是。

为了提高效率，在呃CPU的指令级别，很多CPU啊，不同的CPU都做了这么同样的一件事儿，就是加内存屏障。好，听我说这个这个就是CPU级别的内存屏障啊，我这里说的是CPU级别的内存屏障。

跟java内存屏障还没有任何关系。这是CPU级级别的一个内存屏道。那么CPU级别内存屏障，拿英特尔的CPU来说，我再强调一遍，不同的CPU它的内存屏障的指令是不一样的，而且它的逻辑也是有区别的。呃。

你你powerPC的和那个mac的这个这个CPU它的呃。CCPU内存屏障的执行执行的逻辑是不一样的，有的设计的非常复杂。但是英特尔的CPU呢，它的内存屏障设计的就比较简单，就是。它就只有三条指令。

第一个呢叫save fence， fence是屏障炸栏的意思。load fence。save存存指令啊，存屏障load啊读屏障M分就是所有的两两个加起来。那么内存指内存屏障到底什么意思呢？

就是在S分指令之前的写操作，必须在S分之要的写操作完成。就这两个你别给我重排，有两条指令，你不想让它重排。这个往里头写了个内容，这个往里头写了个内容，这两条指令你不想让他重排，你不想让他重新排怎么办？

中间加到屏障。这道屏障就叫se屏障。这四有屏障的意思是屏障两侧的指令。屏障两侧的读写就写指令啊，这是save save屏障嘛，写指令不可以重排，你不能把下面的挪到上面去，也不能把上面的挪到下面。好。

这是斜指令。那读指令呢也就理解了。前面的读操作必须在后面的读操作之前完成。就是说。有一个我我要读内存里的一个数，有一条指令读了它了，另外一条指令也读了它了。好，这两条指令不可以重排。不可以重拍怎么办？

分开。ok。那读写指令呢读写指令就是上面的读读写操作都得完成，下面才可以继续进行。好，这个是在CPU级别的内存屏障，不知道我说清楚没有？有没有同学有疑问的？因为很多文章讲内存屏障的时候。

他会把CPU级别内存屏障，就硬件级别内存屏障和java的这些虚拟机级别内存屏障混在一块儿讲。所以很多同学可能看起来比较费劲。但其实你把这两个一分开就没那么费劲了。嗯。

那有同学在这里呢可能还会有一个疑问说老师，你这个同一个这个这个CPU指令来说，如果你读第一个和读第二个有可能是会产生这个这个这个强后的关系，它是和线程之间和不同的CPU有关系吗？实际上呢它是有点关系的。

你vololattail的一个东西。这是volttail的那块内存，在java的实现这个volttail内存的时候，实际上它前后都加了屏障。前后都加了屏证。前我加的屏障的意思是什么呢？呃。

jajava内存屏障的比较复杂啊。就是各种各样的组合啊组合起来的。我们先理解CPU级别内存屏障了。CPU级的级别内存屏障就是这个意思，反正就是加了屏障之后。前后的你不能给我哄抬。

这个值呃这个名这这个值叫X。那么我第一个叫in的。A等于X，我读了一下in特。B等于X又读了一下。好，这两个指令如果我中间加了内存屏障，你不可不不可以给我进行重排，这是内存屏障的含义。啊。呃。

但其实这个有序性来讲啊，像java的vol的那个实际当中的实现，它有可能是用lock汇编指令，就是另外一条另外一条指令也可以实现。另外一条指令也可以实现有序性。这个指令呢是java的汇汇编指令。叫洛克。

log什么什么什么什么什么什么啊。java内存屏障呢是几个的组合啊，各种各样的组合。因为内存屏障呢我我跟大家说一下，你们会什么地方呢？会有那种。你看别人文章的时候，会看不懂的地方。呃。

有很多文章呢写的是什么呢？就是java虚拟机级别的这种内存屏障，什么load load barrier ，load slow barrier，像这种东西，它都是依赖于硬件去实现的。

那么这些硬件实现是怎么实现的？硬件的实现不是说只有在硬件级别上啊，并不是说只有内存屏障能够实现JVM级别的内存屏障。这有点绕啊，就是说JVM级别的这种内存屏障，或者叫JVM级别的这种有序性。

他的硬件级别的实现。并不一定是依赖于。硬件级别的内存屏障，它还可以依赖于硬件级别的lock指令。然后这个指令也是非常有用的。所以它具体的JVM级别的东西和我们硬件级别的东西，它不是一回事。

有很多文章呢主要就把这两个混在一起讲。所以你产你你读的时候就会产生问题。啊。呃，也给大家一点预习的时间，好吧，同学们。还有呢像java里面很多的描述都已经废弃了啊。会发会发，我笔记就记在这儿了啊。

同学们。笔记就在这里。你注意看。我的笔记啊就在咱们的。这位M目录下面我提交到gitthub上，你自己就能看到了。

系列 3：P133：【JVM】第三天课后总结 - 马士兵_马小雨 - BV1zh411H79h

我来稍微回顾一下今天讲的内容啊，今天呢咱们先花呃半个小时呢，讲了那个class loader遗留的一些问题。就是什么情况下呢会破坏双清委派什么怎么怎么才能指定我的parent啊。嗯。

然后呢我们今天讲了一些底层比较细致的内容，就是我们讲了半初始化问题，讲了为什么要加vololatile才能保证双重检查单粒的一个可靠性。然后呢，我们分析了。虚拟机呃，这不是虚拟机了。

就是硬件的呃层面的一些东西。缓存行的一个对齐啊，合并写技术，这都是现在CPU呢提高效率的一种做法。那么像JVM这个级别到底是怎么利用这些CPU的。呃，你像java的话呢，你要是自己写的话。

你可以用那种各种各样浪类型来对齐。那么如果说。

JVM虚拟机的这种实现去怎么样要保证它的不乱续。咱们下节课再来聊这个问题啊，它主要是JVM级别规定了一些内存屏障，但这些内存屏障的实践实际上是还是要依赖于硬件。所以咱们先了了解清楚硬件之后。

你再来看JVM级别的这个实现的时候，相对来说就会简单简单一些啊，乱续的问题呢，我给大家举了几个例子。

写合并，还有呢乱序的一个证明diorder。大家呢。今天回去之后啊，先消化一些消化消化这种现有的小代码，好吧。

呃，然后。下节课啊，我们再详细的来给大家解读到底硬件级别的。嗯。vololaile的保证有序啊，到底是硬件级别。

如何保证？那么JVM级别。JVM级别呢实际上不叫保证它叫规定如何规范。它只是一个规范，它具体的实现还是要看硬件级别啊。

折子器现成工作内存是对CPU高速缓存的抽象吧。不能不能说的这么粗粗犷。如果要严格定现成工作内存，就是。GVM规范的一个规范东西。至于你虚拟机要把什么东西抽象进去，那是你虚拟机自己自己的事儿。呃。

但是现实工作内存呢，现在。嗯，是包括可以这么认为，就是包括CPU的那些高速高速缓存的。就是他他他他他是一个虚拟机实现上的一个映射关系，好吧。这个现城工作内存就大家伙啊在在书上看到这些图啊，就这个图。

很多人呢。就把这个图呢会和物实际当中的物理内存混在一起，就这这就是麻烦事儿。就这个图啊。所以这个图呢我刚才给大家就一滑就过去了。呃，就这个图，我相信很多同学呢也看到的都是这个图是吧？

有同学呢会把这些个东西呢。和你实际当中的物理层呢是到底是什么样的混在一起，不要混，这是JVM虚拟机规定的一个模型。这个模型到底怎么实现的，是看虚拟机各自的实现。

那这个工作内存也完全可以是我们物理内存的一部分，这完全是可以的，主内存一部分啊，是看你虚拟机怎么实现了嘛。

系列 3：P134：【Linux】知识点回顾 - 马士兵_马小雨 - BV1zh411H79h

🤧好了，咱们开始上课啊。昨天呢我们一起来学习了什么是网络啊。了解了网络的定义。那么知道呢他具有啊。分布式。是吧哎，分布式把分布在。各个不同地点的计算机系统通过传输介质连接起来。Oh。

然后计算机和计算机之间通过网络协议。进行数据共享啊，达到数据共享和资源共享这样的一个目的啊，这个就是网络。所以呢对这块呢咱们要有所理解啊。那么网络中的资源，咱们也给大家呢简单的去介绍了一下啊。

比如说你的CPU。对吧哎你的算力资源啊，你的存储资源，你的网络资源等等等等。那么根据它的覆盖范围啊，我们知道网络分为局域网、程域网、广域网。好。网络基本概念。Okay。网络的分类。啊。

那么除了覆盖范围以外，还有啊从它的拓扑方式啊，交换格式等等等等几种啊进行分类。那么这里头你掌握呢覆盖范围即可。啊。那么网络呢呃一说到网络呀，这个东西呢还有更深的内容可以讲啊。

我们在这个阶段呢给大家去聊一聊啊。那么在我们安全行业呢，还有一个网啊被称之为暗网，就是大家平时看不到的啊，一般人都接触不到的。Oh。但是呢这是非常有意思的一件事儿。啊，现在呢一个暗网的账号呢都能卖个。

啊。半间房一点不夸张啊，在暗网上呢，你能够做你自己随心所欲的事儿。啊，比如说黑客呀啊，比如说买卖军火呀。走私贩毒啊。啊，嫖娼了，对吧？哎。这个。这个这个这个这个这个雇佣杀手啊啊凡是。

你想干的上边都能干啊，所以这个东西呢。And。一般的呢。也不被报道。所以在安全行业呢，大家呢也会去防范它。比如说酒店啊，比如说酒店系统。你经常看外国的这些电影，那这几个女孩去住店了啊，然后呢。

第二天呃当天晚上对吧？哎，就让人家拐走了啊。呃，有这样的事儿，所以说呢这个。啊，这我们也是一带而过啊，然后呢我们掌握了传书介指啊。传输介指知道有导向式的和非导向式的。嗯嗯，飞导像是。

这两大类型啊导向式的呢又有光纤啊，有双角线，也就是我们的网线对吧？有我们的铜轴等啊，然后呢尤其是网线里头。

啊，他又有。两种接口标准RG45的。RG11的。啊。哎，RG45的呢又分为一类线到7类线啊，1到7类线。简单的啊，在这儿呢给大家提一次。然后呢，哎根据你接线方式。

又分为。正双角线。

啊和反双角线。

八根线线序记住啊，有可能到了单位呢，公司不能上网，就得找你掐一个水晶头，这是很正常的情况。啊。Okay。橙白成绿白来蓝白绿棕白素。啊，这是正的线序啊。

反的线序呢两端A端的还是啊橙白成绿白蓝蓝白绿棕白棕啊，另外一头1326线序对调即可。啊，非导向式的呢wifi光这个这个蓝牙、红外、微波、量子通讯等等等等，都属于非导向式的啊。

所以在这儿呢要把导向式的搞明白。Oh。好。Okay。

好，然后呢在这个基础上呢，我们介绍了啊。

说网络中传输介质是吧？哎，常见的网络硬件。

啊，网卡。Oh。

Okay。あ。

。啊，网卡，那么网卡的工作原理昨天也说了啊，它叫做什么呀？调制解调气。

啊，它起两个作用，调制和解调。

那么现在呢大家呢用的都是宽带了啊，那我小时候啊嗯这个宽带普及率不高。最早的时候，我们同学之间家里要有台电脑，那真的你至少是富二代。啊，你要说谁家有电脑，就我上小学的时候，哎呀，你说我们家里有电脑。

那女孩子都蹭蹭上你们家玩去啊，真的。哎呀，所以现在呢你在跟这个女孩子说，我们家有电脑，她都不鸟你是吧？哎。那时候上网啊是一件很奢侈的事儿，网速呢只有28。6啊K比特。4。啊。那。呃。

需要通过一根电话线啊，那时候电话都不是家，每家都有，就是你要装个电话，在北京，大概你要交3000块钱安装费。然后呢，你可能得排着号等那么一两年，都是都是这种情况。啊，然后呢，这个你要上网的时候。

还不能像现在你打开电脑，想上网就上网啊，那时候网速慢步说费用还相当高，特别贵啊。一不小心你家电话费就干好几百，那都是很正常的事。所以呢这个。那里头当时有一个叫猫的东西啊，你问问你的父母都听说过啊。

有一个叫猫的，也叫调制节调气。每次拨号上网的时候叫拨号上网。Oh。就跟我们每天上课之前听唱歌一样，一拨号他儿咯哇的叫一分钟，然后突我上去了。播上去以后呢，那你有同学说说在线看视频什么的那你想什么呢？啊。

你打开个搜狐，能看一些正常的这个文字版的，或者说呃有图片呢就已经是很奢侈的一件事儿。后来电脑慢慢升级，就这个猫升级到56K啊，56K的猫。28。6到56K。Oh。再后边才有宽带。

宽带我们最最最早的呢就有同说上来就一兆没到一兆啊，你想啥呢？那宽带贼老贵啊，没有到一兆，就是从这个512K起，然后慢慢的是有一兆的啊，有有有两兆的，有四兆的，有8兆的，慢慢到10兆，最后到百兆。

现在到千兆啊百兆200兆，500兆啊，1000兆。对吧然后呢比较奢侈的呢，还有用企业宽带，用万兆的啊，当然了，那资费也吓人是吧？所以呢这个东西呢咱们简单的说一说。那么将来如果您进到这个工作单位了以后。

我们的所有服务器大部分托管在IDC机房啊，如果你是自建机房的话呢，您你还要扯一根网线。然后呢，你再去接线。那么一般IDC接线的话呢，他们在骨干网上下来都是千兆的啊，咱们中国目前都是千兆的。

也有部分网络随着5G的普及，在骨干网上现在升级到万兆了。啊，声音到万兆。然后呢哎所以说机房的速度它是非常快的啊，你要得机房里头下片去，那真的你都不用下啊，就直接一点秒开。啊，所以呢速度是非常快的啊。

所以，了解网卡的工作原理，调制和借条。那么将来呢在你实际工作中，比如说你不能上网了，这都有可能会造成啊是硬件设备的问题，可能会有一套排查的流程啊，需要大家去注意。那么调制和解调这个过程啊，您呢把它。

知道即可啊。好，那除了这些个以外呢啊那么我们还要知道呢这个网卡它有一个特点啊。Yeah。网卡的工作模式。那么咱们现在的网卡呢都叫啊千兆或百兆，或者叫百兆或到1兆啊，自适应网卡。

。Yeah。啊，一般的都是这样的网卡。

啊，所以呢网卡在工作的时候呢，有几种。

啊，单工的。

双萝的。

Oh。还有介于二者之间的。

半双攻的啊，简单了解就行了。

。Yeah。

Yeah。然后呢，了解了什么呢？啊，了解了网卡的。协商。机制。

。Oh。自适应啊，俩人会协商。

好，这个是我们上一讲介绍的一些基本内容啊。还有一个呢就是我们说的就叫构建网络的时候啊，最小的网络我们介绍了交换网络。

啊，交换网络。

交换网络里头呢，我们介绍了谁呢？我们昨天提到的一个设备啊，叫做交换机。介绍了交换机的工作原理，它里头有一个麦克地址列表。

啊。那么一说到麦克地址了啊，我们说了他叫物理地址。

啊，网卡的物理地址。全球唯一的。啊，全球唯一的。

Okay。

好。然后怎么表示呢？对吧？哎，十六进制。十六进制数。表示啊。

好，这是他的工作原理啊。好，那我们今天呢在。

系列 3：P135：【Linux】交换网络数据格式以及广播风暴 - 马士兵_马小雨 - BV1zh411H79h

好，昨天呀咱们介绍到了一个内容啊，说呢我们构成。构成我们现在。网络的一个最小单位。Okay。啊。Yeah。好，那么呢我们两台计算机啊要通讯，如果没有交换机，直接拿反双绞线接就行。啊，如果你有交换机是吧？

哎，我们也可以借助交换机啊进行。数据交换啊，构成这样的一个交换网络。好，然后通过谁呢？通过网卡。啊。通过网卡。通过传输介指。啊，然后来一根网线。插在一个孔上。这边也是通过一个网线插在一个端口上。啊。

这就是传输介指。网线k6。哦。好，那这样的话呢，我们就构成了一个最小的网络啊，通过交换机构成了这样的一个网络。那么交换机呢在这里头呢。交换网络啊。Good。好，那么局域网。通信。

那这两台电脑在刚才我们介绍的时候，它就构成了这样的一个。

小型的局域网络。

啊，那如果我有多多台电脑，比如说咱这是一个部门啊，咱们是研发部了。哎，你这有多台设备。啊，一样的，只是把他们插在不同的端口上就可以了。好，我们简单画几台啊，是那意思就得。いか。Oh。Oh。好。

他插在这个口上。啊，他插在这个口上。好，那这些所有的啊，咱们刚才在画这里头的。内容。都通过我们的传输介指啊，通过网线六类线。啊。构成了这样的一个小型的局域网。Oh。啊，小型的局域吧。Okay。好。

那么在这个网络中啊，那么如果我PC1。PCE要想发一个哈喽啊，这个信息。好，说他给谁呢？啊，我们找一个。PC2吧。啊。他把这信息发给他啊，那么这个交换机插电以后，那么他在。啊。

他的工作原理就是他每一个端口上啊要记录。啊，你这麦克地址列表，还有个麦克地址列表啊，获得到计算机一的麦克地址。然后呢，你一要给二发，那么你在传输的时候，他就会要找一个R的。

麦克地址说存不存在我这个列表中，如果存在这第二个麦克地址记录在。啊，哪个端口上，那么就通过哪个端口把数据给他转发过去啊，这个他们之间。就实现了数据通信。🤧嗯嗯。好，这样的数据过来了啊。那么在这里头呢。

大家要。需要注意的就是啊通过交换机。哎，通过交换机进行局域网内。的PC。和。PC的控隙。也不一定是PC。主机。主机。这里头的主机的概念你怎么理解啊？这里的主机可以是PC。可以是你的笔记本。啊。

可以是你的服务器。啊。对吧还可以是具备有网络功能的打印机等等等等，只要能上网就行啊。🤧。好，然后在这里头我们昨天说了麦克地址啊，这个东西需要你。掌握的。哎，需要你掌握的。那么我们说的交换机。

通常情况下啊。通常情况下，咱们这个交换机，我们说是二层设备。它对应的是OSI7层网络模型。啊，七层网络模型来的。好，那么有没有人能给我说两句，这个OSI7层网络模型呢？给我发群里头，我看看。

看看你们忘没忘。🤧。Oh。Oh。

发这儿了哈。

🤧うう。Go。好，哎，这是谁呀？我勇哥给我发了一个啊。啊，勇哥给我发了一个啊，好了，七层网络模型我们会讲啊。那么第一层。那么是什么呢？就是物理层。所谓物理层用的就是我们的物理设备。啊。

物理设备就是咱的网卡就工作在这一层。然后在它之上呢，有什么呢？哎，就是数据链路层。啊。啊，数据链路层，咱们的交换机就是在这层玩耍的。啊。那么数据电路层主要就是什么呢？哎，主要在这里头就是通过m克地址。

啊，卖的地址。也是基于它这个特点啊，所以我们说它一般情况下啊交换机是二层设备。啊，那么我们也通知为二层交换机。还有带管理功能的啊这种交换机。我们有时候啊还会见到一些三层的交换机。啊。

所以这儿呢我们简单的提一嘴，就是根据这个来的。好，然后呢他的工作原理呢，它有一个麦克地址列表。啊，那个地址列表。在麦克地址列表中，他记载了。啊，记录了。你这个端口。啊。和。😮，卖个壁纸。对应关系。Oh。

。

Oh。啊，比如是这样。然后呢，在你发送数据的时候啊，我们今天呢在这稍微啊说一说。交换数据格式。应该写在这里啊。交换数据格式。好。这个是重要的啊，交换数据格式也是重要的。那么交换数据格式。

当我一台啊计算机和另外一台计算机通讯的时候，说你一找二给他发一个hello。啊，到PC2能收到这条信息。实际上啊他在发送这个数据的时候是这样做的。目标。啊，目标地址。目标地址。加上。原地址。啊。

然后再加上。数据信息。那这样他就构成了。第一个。基本的。处理结构。好。Yeah。Yeah。啊，基本的数据结构。🤧。目标地址。啥意思？哎，我要找的啊。这个计算机。目标的麦克地址。啊。加上原信息。

圆就是从哪儿发来的？啊。原信息的那个地址。再加上数据信息，我发送了一个哈喽。啊，这个哈喽就会通过二进制，然后再通过OSI7层网络模型，每一层数据进行封包封包封包啊，到最底下物理层啊，实现了这个以太网啊。

以太的时候，到时候它是以真的形式存在。啊，然后我们在这里你就可以认为是咱们hello那条信息叫数据信息。Yeah。啊，这种形式。那么当这样的一个信息。啊，就是我们在发送一个哈喽的时候。

实际上是这么复杂的一个过程过来的。好，那这条哈lo这个信息。经过交换机时啊，从这儿过来，用这小信封，我们表示数据偷偷偷通过网线过来这条数据走走走走走走走走走到交换机。啊，交换机的话呢，它就会把。啊。

你这个数据拆开来看。到这儿，他要拆开来看，就跟我们写信要有邮编子似的，从哪收寄到哪儿。对吧哎，从哪儿记得啊，谁收。所以呢他就把这个信息啊拆开了一看啊，说你要记在那个麦克地址上，然后呢。

通过它比对里边的麦克地址列表，看看有没有啊，在哪个端口上。如果找到了他有这个记载，那么就通过这个端口把这个数据刷刷刷刷刷啊，通过这儿找到了传传传传传传传传传哎。그도 한 거야。啊，然后传给他的网卡。

网卡通过。对吧。我们说了。网卡的工作原理对不对？调制和解调对吧？哎，收到一个信号，然后开始把这个信号。拆包转化成数据，然后到内存中啊，根据OSI7层网络模型再拆逐层拆拆出来，把数据放到内存中二进制。

然后最终通过你的社交软件啊，把二进制这些数据再呈现给你的用户显示好了，这样的一个过程。啊，那如果他过来啊找不到啊，他去找找找找找。如果你的麦克地址列表存在。啊。如果。目标的麦克地址啊，在你交换机。对。

麦克地址列表中。那么。交换机就会。通过。列表啊。转发。给。该地址。对应的。端口。啊。Yeah。哎，存在就给你转发过来了。哈。那么如果。目标地。不在交换机。啊，没在。没在呢，咱们交换机。

就有一个叫广播域的。啊，广播域的存在，那么它就会通过广播的形式。什么叫广播？啊，就是对交换机上。所有的。烂口儿。啊，所有的烂口。进行转发。啊。进行转发。Okay。好，那这样呢就带来了一个问题啊。

这样就带来了一个问题。所以呢交换机啊这里头也会有一个弊端。就是广播风暴的问题。好。啊，那可能在我这个局域网里头，我不光就是PC1跟PC2聊是吧？哎，不光是你跟这小姐姐聊骚2啊。哎。

那突然间这哥们儿一看哎呀。小姐姐长得挺带劲，是不是哎她也想跟她聊。啊，这儿也聊着呢。Yeah。好，那哎这一看你们都跟他聊，他也不知道这小姐姐哪好啊，她也聊啊，这一看你们都聊他也聊。哎。那你们都聊的时候。

就有可能说你们都找他。啊，你们都发哈lo了。啊，所有人同时在工作传输信息的时候，这就有可能说你也没有他的这这个他也。找不着他他也找不着他他也找不着他。那么交换机就开始封了，他就开始全网的广播。

说你来一个啊，就相当于去村长家拿大喇叭广播。啊。是不是哎。谁谁谁又给谁挑水了啊，这又广播一遍，谁谁谁又给谁挑水了，挑水了，挑水了，挑水了是吧？哎，还带回音的这种啊。

那么大家都去用这种方式都去广播的时候呢，就造成了一个广播风暴的问题。所以呢我们就要想办法呢去抑制这个广播风暴的问题。😊，啊。好，那这个东西呢经常会有时候呢会给你问到说哎呀。

就你这个交换机交换网络里头你了不了解啊，哎，了解了解它都有哪些特点呢，是吧哎？会遇到广州风暴的问题啊。遇到广播风暴的问题呢，那咱就来说一说啊，说这广播风暴它会给咱造成啥影响？

首先第一个啊它会消耗我们大量的系统资源。啊，那么这个也可以说是它的危害。啊。那么这句话此话怎讲呢？有同人说那此话怎讲啊，啥意思呀啊。河。那么所谓消耗大量的系统资源，那你在这儿找他的时候。

是不是你你的网卡工作，他的网卡也工作呀？你们所有人在这乱发广播，我这里头比如说我这是48口的交换机，那我这48台电脑如果都开着，是不是我48台电脑都要接收到你的广播呀？😡。

那么这48台主机的网卡是不是都要？接收信息。对吧好，这样的话呢，第一个你就消耗了大量的系统资源啊。首先第一个就是你的网卡要不断的工作，网卡工作它就得耗电呀。啊。那他是咋工作呀？他接收一条信息。

不能就扔了呀。😡，是不是啊他收到这条信息，我们说了，收到这条信息，他就得把这个光信号转化成电信号，然后去处理这个事儿，对吧？一层一层的拆包去处理这件事儿。啊，他就得解条。对吧然后谁你网卡干活了。

那就是那光他干活也不行啊，你的操作系统。😡，系统也没闲着，系统是怎么跟网卡进行通信的呢？它通过驱动程序啊。啊，那你网卡接到这信息，网卡说，那你系统该干活了。是吧这收到信息了啊，有数据包了。😊，啊。

那最终系统是不是得干这件事儿啊？他把你这数据包就解包嘛。啊，解包的一个过程。解完了以后，把这数据信封拆开，看看里头有啥信息。啊，01010101对吧？哎，类似于这样的数据，二进制的数据啊。

那你这数据你得存着吧，我暂时不放硬盘上，那你是不是得。存在你的内存中啊。Oh。对吧然后你系统再调度，再调谁呀，说这个程序该谁去接收啊？对吧比如说微信。Oh。ま？啊。这玩意儿存内存里头的。Yes。嗯。

在这里头存的呢。啊，那操作系统呢又干了一件事儿，他又调度。啊，微信。告诉微信说信息来啦，姐姐微信来了啊。嗯。H。H。Yeah。好。这边就等噔。哈。提示。用户。打开。看到hello。啊。Oh。🤧嗯嗯。

这样的一个过程啊，它会消耗我们的系统资源。啊，让整个的网络变慢。啊，整个网络变论。好。可以啊。根据我们刚才说的这个哎，自己呢。去看一看啊。Oh。给2分钟，简单的呢。🤧。去记一下。嗯。呃。好。接着说啊。

说网络咋变慢的啊。那这有可能说一个网卡坏了。啊，有可能是网卡坏了。啊。说比如说一网卡烧了。对吧故障了啊，他就会一直给你交换机发送这些数据啊。好，还有哪些情况呢？啊，还有哪些情况呢？

就是大家使用的时候一定要注意啊，使用的时候注意。比如说有时候会造成你上不了网。🤧就是你网线接错了。啊，比如说你网线的两头。都接在。一台搅换机。Okay。🤧。有这种情况啊。有这种情况。

你这两头都插一台机器上了。啊，就可能造成整体没有外网。那这个其实呢就构成了一个网络的环路。啊，有这么干的。去年吧啊我就看有一个同学就这么干的。完了跟我说，老师，我不能上网啊，我说那。怎怎么弄的呀。

不知道啊，过去一看好家伙，我说你们是上不了啊，你这头插这头都在一个交换机上。所以造成网络慢或不能上网，就是因为广播风暴或者里头有环环路啊，那么这个东西呢，或者有时候中病毒了。啊，还有可能中毒。啊。

中毒造成的大量的发包。啊，造成网络风暴。🤧嗯嗯。Oh。Yeah。🤧啊，那么就整体就变慢了，网络特别卡顿。啊。好，这样的话那那你就觉得哎呀我网慢了啊。有时候啊有时候会造成你的一些业务就停了。那我们的。

这些服务器离不开网络啊离不开网络。嗯，导致。大量的带宽。啊，被占用。或者耗尽了。啊，那么如果当你的带宽耗尽的时候啊，就可能导致。你的业务不能正常运行。对吧网络瘫痪了，经常会出现这种情况啊。好。

这个是我们给大家啊说的一个广播风暴的问题啊，那么广播风暴呢出现这种情况呢，那就是很严重的啊一个网络故障。啊，严重的网络故障。Okay。所以呢我们要杜绝啊广播通暴。在这里头去大范围的产生啊。🤧嗯嗯嗯。好。

那么我们怎么去杜绝说这个广播风暴的产生呢？啊。好，第一个。啊，就是我们在接线的时候要特别的注意啊，说避免出现我们这种环路。啊。第二个呢，我们这个交换机啊啊你如果把它拆开了看，交换机里头也会有啊。芯片。

他也会有CPU，也会有我们的这个这个操作系统啊，那么所以呢我们来了以后呢哎。你大量的数据都广播，造成了就是你这个交换机。死机了。啊，就是他他的芯片比如说超过了它能承载的这个能力啊，就跟洪水一样。

瞬间的把它淹没了，它处理不过来了。🤧他可能就无响应了啊，所以我们家用的这个。家用的路由器也经常出现这种路由器的假死的情况啊，就是什么呢？啊，你买了1个100来块钱的，但是你家里头人用的比较多。

大家都下载啊，时间长了呢，就超过了他的这种负荷了。然后呢他就。司机了啊，所以呢哎我们企业级的一般会买企业级的交换机啊，企业级的交换机。嗯。🤧比如说。比如说我们企业啊，所以。可以采购。企业级的。交换机。

那么企业级的交换机有哪些呢啊？那么有国际品牌的。国内品牌的。早年间呢都用思科。啊，不管是路由器还是交换机，早年间都有4客。Okay。啊。网件。这是美国的品牌啊，但是呢你用它呢风险很大。他是美国军方的。

电信承包商啊，思科路由器有大量的后门。对吧这个东西都已经被爆出来了。所以说呢现在呢。Yeah。咱们中国大部分企业啊都已经下架思科的设备了，包括它的路由器，它的交换机啊。呃，这个通过斯诺登事件以后。

在中国的骨干网络全部剔除啊美国的这些个硬件设备。第二个呢，国内的品牌啊就是屌丝的最爱华为。啊，华为。哦。当然了，还有其他的啊，比如说。TP link。啊，我们叫普联的。啊，比如说华三的。HBC。

Book。🤧好，简单的给你们搜几个啊，咱们看一下。

🤧嗯。好。Okay。那么你上来以后呢，我们通常啊啊找一些比较大的，你看对吧？这就是千兆2十4口的，当然了啊，你像这些小玩意儿，这都是家用的啊，这都是家用的，找那大个的，看着能当板砖似的那个啊，就可以了。

那么你像这个。啊，S185028P啊，24口的交换机对吧？但是企业中呢一般不用这么便宜的啊，会用更贵的。比如说48口这样。

这个公司里头有啊公司里头有嗯，等大家来线下呢，到时候可以拿着看一看啊，就这种48口千兆的。

🤧啊，华山。

那还有呢，比如说这个TPlink啊。48口千兆式的啊，机架的。这样的啊。好了，简单的说一说啊，简单说一说。

🤧。Yeah。看你公司有没有钱了啊，有钱呢你就用这个华为的一般稍微贵一点啊，那个没钱的呢，用华三的也可以。啊，TPlink个的也可以，这都能用。🤧好了啊，这个是交换网络啊，就是采用更强的设备。

第二个呢就要引入到什么呢？哎，我们要隔离。啊，隔离。网络风暴。也就是抑制他啊。好。那么我们在抑制它的话呢，那我们在一个局域网内。进行划分。进行隔离。Oh。啊。那么尽量去规避这件事儿。

说比如说我一个部门七八个人，哎，我就在这一个上面去做。然后呢，我通过一个什么东西呢？我通过一个叫路由器的。啊，我通过一个叫路由器的。あ。好。啊。那么我加了一个路由器以后，比如说我这是一个部门。啊。

我通过一个路由器以后，我就能够把。啊，我就能够把这里头的广播风暴一直在这个路由中。Okay。好，我们先说这么多啊，下课休息会儿。

系列 3：P136：【Linux】局域网和局域网之间通信 - 马士兵_马小雨 - BV1zh411H79h

啊啊，广播风暴这个事儿呢，我们要想抑制啊，在这儿你就得买企业级的路由啊，企业级的交换机。交换机。那么企业级的交换机里头它提供一个什么好处呢？就是我们可以划分微烂。哦，可以啦。哎，化分为乱。

划分微烂以后啊，它就能够把我们个个的啊，比如说。172点16。0点。1到172点16。0。254啊，这个我画一段。比如说这个是教学的。啊，这儿我画了一个微烂。然后呢，我又画了一个172点17。0。

1到172点17。0。254。市场部的。围栏一。啊，比如说我又来1个172。18。0。1到172点18。0。254。Okay。172。19。0。1到172。19。0。254。172。20。0。

1到172。20。0。254。Okay。那么我可以认为我都是172开头的啊，我从1617181920啊，代表不同的段。比如说16给教学，17给了市场部，对吧？哎，18，我给了，我可以给什么呀？学生。啊。

给财务吧，对吧？这个19我们给什么呢？给教务啊，给教务老师20段给服务器。Okay。好，通过微烂的技术，我们也可以有效的啊来抑制这个广播风暴的问题。啊，所以呢这个东西在高级的设备里头啊，越高级。

我告诉你，没有花钱的不是。啊，没有花钱的不是你那设备越高级。它的功能就越多啊，贵有贵的道理，一分钱一分货。啊，贵有贵的道理。对吧。贵给你带来的就是用户体验相对较好。为什么我们去银行要弄VIP呀，对不对？

你不用排队啊，用户体验要好一些啊。所以通过这里头我们进行微烂划分以后。让他各个段啊各个段在不同的围栏里。啊，这样的话呢，比如说教学这个段里头你有8台电脑。🤧。我不一个个画了啊。啊。

PC1号到8号是不是有8台okK那你就在这个段里头玩，你们之间如果有啊广播风暴的话，也就是这吧台。所以我们有效的降低了每一个网段里头的PC的数量或你主机的数量。这时候就能有效的去抑制或减少广播风暴。

你要从根上解决，那它原理就是这样的，你不可能完全杜绝它。所以我们就划分网段以后，我让他尽可能的少放一些设备。啊，少放一些水。这样呢我们尽量的就能避免啊，还有就是呢如何去避免它。就是咱们这些高级的啊。

我说了企业级的，但是家用级的咱就别扯了啊，这个企业级的呢，它里头呢还会有一些啊关于拓普的一些内容。刚才我们说了一些环形网络啊，环形网络。那么环形网络呢，我在这儿呢，我给你说两句啊。环形网络。Okay。

环境网络的问题呢也得需要去解决啊，它也会造成这个广播风暴的问题啊，挺讨厌的。🤧嗯。环形网络出现两种情况。第一种呢就是刚才说了交换机接线的问题。啊，那如果一根线两头都接在一个交换机上。啊。

这个一般不会有傻逼这么操作啊，但是万一哪个傻逼晚上多喝二两啊，有可能。对吧插错线了。啊，咱们都觉得自己不会犯这个错，有时候越是你觉得你不会犯，最终你犯的越是这种低级的错误，真有这样的人啊。

满大街都是你到时候那些线头子特别乱的时候啊，你如果在布线的时候就没有一个好的习惯啊，你这线就满地汤，结果你有可能你就把这插错了，咔叽一下，大家都没网，真的就是这样的。

这就是典型的环形网络是交换机接线的问题啊。喝多的都说自己没醉，真是这样的啊，淹死的都是会水的啊，所以这些东西呢要是从习惯做起，线就要捋明白。第二个是什么呢？第二个就是在你的这个拓普啊，拓普图。啊。

你网络拓扑中。存在这种环形。就问题。这啥意思呀？说在做这个网的时候就没有规划。😡，啊，今天飞一条线，明天飞一条线，满脑袋上都是线了。어。对吧再加上你就是规划了以后，你也没有落出。

比如说这个网络拓扑图也没有人画啊，这里头主机也没有人规划IP地址，也没有人规划，所有东西乱糟都要往这一扔，那结果就出现问题了。好，再加上这哥们儿可能跟女朋友闹别扭离职了，分手了，不在这儿干了啊，走了。

交接上没有一个好的流程。所以后来人一看完全就蒙圈，所以这网络就是能将就就将就。所以一般你去这小公司基本上都是这种情况。你一看我就靠是吧？那玩意儿你就。哎，够你喝一壶的啊，所以运维人员。

你去到一个公司以后，你都先给前边这些人去填坑的啊，坑填满了你才能做自己的事儿。所以网络拓扑中存在环境问题呢，这个我们也要借助高级路由器啊，为什么叫高级呀？它里头有一个叫生成数协议的，可以做好网络拓扑的。

啊。可以有效的。有效的管理。网络。拓骨。中。存在的环形问题。Okay。Oh。那么在这种高级的设备上啊，它为啥高级啊啊，它里头有STP。STP呢是个算法。啊，通过STP算法。对交换机进行配置。哦。然后呢。

这个交换机啊，它就能够。能够给你生成。啊，生成一个你这个网络拓扑图。当里头出现环形结构的时候啊。出现这样的问题了啊。人家就可以提示你。啊，告诉你这么查不对。对吧所以从根本上消除这种环形问题的存在。啊。

这个就有效的杜绝了咱们广播风暴的问题。好，那这个真是有危害的啊，说你交换机死机也就得了啊，有时候最最最狠的是什么呢？就是它广播风暴特别多，你的网卡配置如果不够高，数据吞吐量不够的话。

那有可能造成你网卡故障。网卡就坏了。死交换机死机那都是小事啊，网卡就坏了，时间长了，交换机也有可能坏，就是这些硬件设备就坏了，然后呢造成你。整个的网络就拥堵了啊，所以这就增加了你的成本。你要买新网卡呀。

是不是啊，这都是维护成本啊，所以在交换网络中一定要认识到广播风暴的问题。好，第二个，那在这儿呢，我们就要引入到一个新的内容了。那么我就要对网络进行有效隔离。那这个就是也是交换网络中的。哦。写在这儿吧。

啊，那么刚才咱们说的是一个局域网内的啊，那么局域网。和。局域网之间。啊，他们怎么通信？哎，通过路由器。🤧。通过路由器。啊。

好，我这图我挺舍不得删了啊。

先发给你们。好，然后呢这个图我要破坏一下啊。啊。好，我们现在呢比如说我左边是一个小型的局域网络，右边是一个局域网络。啊。那么这个我们先呢画一个图啊，我给你画一个。所以在网络这块呢。

要耐心细致的去给他做规划。Oh。比如说我这坨有一个交换机。这坨我也有一个交换机。我如果不讲究说我随便我就随便一弄就就完事儿了啊，我管他那个你爱怎么着怎么着是吧？

那么这个问题啊真的有可能造成你几百台几千台服务器不能上网，都是有可能的。啊，所以左边我们是一个小型网络，右边又是一个小型的局域网络。啊。那如果我玩混的说我这儿我又拿一网线把这俩交换机连上了。啊。

当你这边发生广播风暴的问题啊，说你在这全网广播呢，这哇哇哇哇的是吧？他就会通过这一边把这边的广播风暴通过交换机，那全网广播，它又到这儿。啊，这儿又向这边去广播。所以比如说你这个是个什么呢？

你这是个教学部。对吧你这边是个销售部。那你这样一广播，哎呀，不但你这边可能上不了网，你还影响了这边也上不了网。啊。那如果说我这儿再接了一个交换机，这边又一个网络好，人家那边可能也上不了网啊。

所以这个时候我们就要有一个设备去出现了啊，我如何来隔隔离两边的网络呢？这时候我们通过一个叫路由器的东西。Okay。🤧呃。哎，我通过一个路由器的东西啊。这边接在这路由器上。这边也接在这路由器上。好吧。

咱就找个图吧啊。Oh。那路由器呢它就起到了一个作用啊，就是有效的隔离了网络。说左边教学是教学，销售是销售。啊，你这广播风暴。你这广播风暴发生时，比如说你这咔咔的这正广播呢啊这找呢。好，到这儿。Oh。

到路由器这儿啊，路由器就给你隔离了。不会把这个风暴再传递给右边的这个网络。啊。Oh。好，那这样的话呢，我们就。把路由器啊这个呢给大家简单的说一说啊。那么路由器呢，它这里头啊它的作用是什么呢？就是实现。

啊，多个。局域网。多个局域网之间。啊，之间的通信。它可以有效的。屏蔽。交换网络中。广播风暴问题。Oh。Oh。因为我们好多零基础的同学啊，你说网络吧，我们也不能上来就给大家打蒙圈啊。

所以你看我给你起的标题，我们叫网络基础啊，我们先讲点基础。好，将来有机会我们讲高级。啊。好，干这么一件事儿。啊，那么路由器他咋工作的，他怎么着他就能给他隔离了呢？啊，这咱们就得说说它的工作原理。

うんうん。Oh。路由器这个东西呢，我们也叫它。Okay。啊，我们也叫它三层设备。啊，我们也叫它三等设备。好。那么基于。三层设备我们说一下它的工作原理。啊，那么我们说到交换机，它会有一个麦克地址列表啊。

交换机有一个麦克地址列表。那么路由器有啥呢？路由器在第三层啊，第三层我们刚才给大家去介绍的时候，对吧？这七层模型第三层是属于什么呢？哎，有的同学去看了这个群里头。啊。那么我们在第三层的时候。

它实际上和我们第二层他们二者啊有区别。区别在我。第二层里头用的是麦克地址列表。啊。那么第三层就要到网络层了。啊，网络层了。啊。那么它的工作原理，网络层里头用的都是IP地址。

所以我们讲完路由马上就会讲TCPIP这些协议了啊，IP地址。所以路由器的工作原理啊，它里边有一个叫IP地址列表的。哎，IP地址列表。交换机呢是麦克地址列表。🤧嗯嗯。Oh。Okay。Oh。啊。好。

我给你放在这儿啊，就是方便你对比的去记。Yeah。那么麦克地址列表它叫物理地址。IP地址列表，它IP地址啊叫做逻辑地址。Oh。啊。物理地址不能改变。通常。不能改变。啊。逻辑地址。可以改变。2。Oh。

Okay。Okay。好，这二者对比着来记啊。那么你麦克地址的表示方式。是什么样的呢？Oh。我。好，拿一个过来啊。好，它是有多少位呀？12个。啊，12个。十六进制。字符。表示。Okay。

那么十六进制是什么？那么就是用数字0到9。啊，0到9。0到9表示几个数啊，10个数。啊，10个数。后边再跟啊字符。机。BCD。EF。啊，ABCDEF。啊，来表示到16啊这些个数。逢1榴就进一了。

那么我们IP地址是什么样的呢？IP地址啊，当然了。这个麦克地址啊。每一个每一组。之间。用。横线做分隔符。🤧共6组123456啊IP地址呢，比如说我们见的192点168点0。1。啊。

这样呢就是我们常见的IP地质。那么这叫IPV4的啊。IPV4的IP地址。那么我们还会见到一些呢IPV6的啊IPV6的IPV6的就不是这样的表示了啊。今天呢我们先了解一下IPV4到后边啊，我再会给你说。

V6和V4之间的区别。啊，那么它是由什么呢？它是由十进制数。四组。十进制数组成的。啊。十进制在我们这表示就是数字0到9。啊，数字0到9。好，那么用点儿。Okay。用点儿来隔开。

这种表示方式用点隔开的也叫做点分二进制。Oh。Oh。了解即可。每一组。做最大值啊，每一组的取值范围。0到255。啊，每一组的取值范围0。25。好，这是他们之间的一些区别和一些特点。啊。

那么工作原理它有1个IP地址列表。啊。那么在这个列表中就会记录你每台设备。啊。IP地址。与你在哪个烂口端口号啊相对应。好。好。Oh。Okay。当你这数据过来以后。啊。那么它是什么呢？目标地址。

加上原地址。再加上啊。数据内容。那么目标地址这里头是IP啊，原地址这里头也有IP的信息。啊。Okay。哎，这样的一个格式。那么路由器拿到这个数据的时候，那他把这包拆开了一看啊，路由器里头也有芯片。

有软件，他通过特殊的算法，把你这个包拆开以后，他拿掉了你的目标的IP地址。比如说192点168点0。100。啊，这是我的一个目标地址。🤧嗯嗯嗯。然后呢，我192点168点0点。102。这是我的原地址。

啊，就是我从哪发的，我从102上往100这儿去发。Oh。哦。就是这张图。Oh。比如说这台机器。嗯。192点168点0。100。他发的。啊，他发的，那么这条信息发给谁呢？102。他是102。Yeah。啊。

他是102。他是99。t酒吧。他是97。啊，每个人都有1个IP地址，不重复。啊，这边是102。那如果他发一条信息啊，那这样的网络是怎么着呢？说发一个hello。哦。发一个哈喽过来。

这101走走走走走走走啊，到这个交换机了啊，他要找这台电脑，这儿的原理是什么呀？是不是先找这个里头的麦克地址有没有啊，是不是如果有就通过这交换机，比如说就在这儿呢，那他就发过来了啊？

他到这儿这交换机过交换机。😊，交换机一处理这条信息发现，哎呀，这里头没有，我就不转发了，我就全网转发。对不对？广播了哗哗哗哗哗啊，走到这儿。然后这条信息到路由器了啊，路由器呢就把这包又拆开了啊。

三层是他工作，他就把IP这个包拆开，拆开以后发现啊，原来这条信息是101那小子发过来的。啊，然后呢他就在你这路由器的IP地址列表中找说102在我左边这坨还是在右边这坨啊，他找到了102啊，在右边这一坨。

好，那他就把这数据转发过来。啊。然后通过交换机啊，又到二层，他又解这个包啊，找这个麦克地址，这个麦克地址在他这记录着呢，然后呢他就把它传过来。啊，到这儿显示出来这样的一个过程。🤧啊，好。

这是第一种情况啊，说他知道。那如果他发送的这个IP地址啊不存在。说我来了1个200。啊。这200我也不知道在哪儿，但是我想让他发送一个，我这里头没有就200的这台机器，那怎么办？信息发出来走走走走走。

到这儿，他拆二层的这个包，拆完了以后啊，发现在左边这儿这这儿都不是好广播走走走走走到路由器这儿啊，问路由器，你认不认识这儿啊啊，路由器说我不认识啊，我这里头没有记录的一个是1921681。20这个事。

好，这条消息到路由器这，他就被丢弃了。嗯啊，丢弃了。好，所以啊他的工作原理就是这样了啊说。如果我们发送的数据。啊，我们发送的数据。目标主机在你这个IP地址列表中。那么路由器就会根据记录。转发。该调。

数据给计算机。Oh。哎，就是我第一次给你换那小信封，但是走走走的那个意思啊，如果列表有就给你转过去了。啊。如果咱们给他发的这个不在。あ。那么路由器就直接丢弃了这条数据。啊。那么这里头的一条一条。

刚才我们说了这个IP地址列表。啊。IP地址列表中记录了这个列表信息列表项，我们也称之为路由条目。Oh。Okay。啊。我们就称一条条的路由条目。Yeah。🤧好，我找一个路由条目，你看一看啊。

🤧嗯。呃。Yeah。好。🤧我通过一root杠N这条指令。来查询。啊。我。

这台。电脑上配置的路条条目。Co。Yeah。

我们看到的这一条。这就是一个旅游条目。ThePa。那么这里头啥意思呢？这上边写的叫destination0。0。0，它是表示我们任意的一个网络。说我们这台电脑通过ENS33这个网口网卡啊。

这个口要想访问。外网的地址通过什么？通过10。0。0。2这个get we，这叫网关。啊，这叫网关。好，咱们这里头的一条就叫做路由条目啊路由条目。那么它就会记载着从哪儿到哪儿，经过哪个网关，经过哪个网卡。

啊。那么这个路由条目。路由器啊。添加路由条木。Oh。Okay。啊，添加这个路由条目。有两种方式通过两种方法来实现的啊。写在这底下吧。路由协议。啊，路由协议。Oh。Yeah。Yeah。Okay。嗯嗯。

路由协议呢有两种，第一种呢叫做静态路由协议。Yeah。第二种呢叫动态路由协议啊。静态路由协议动态路由协议。🤧好，那静态路由协议我们先说一下啊。需要手动配置。哦。那么动态路由协议。那就是不需要手动配置。

啊。路由。自动。学习。Okay。Oh。Okay。啊，一个是需要手动配置，一个是可以自动学习，不需要手动配置。那么那定态路由协议呢，它的优点。他的缺点。啊。嗯。动态路由协议的优点和缺点。🤧诶。

我们一块来分析一下。Yeah。好。Yeah。那他的优点就是生效速度快。啊。执行效率高。通讯率高。说你嘎叽敲一条命令，一敲回车，啪叽就通了。如果你敲对了，马上就通。Oh。他的缺点。需要专业人士。董路游。

懂网络。啊。操作复杂。🤧好，举一生活中的例子啊。咱们家用路由。一般都是傻瓜式的。啊。都是动态路由协议。比如说你这听网课呢是吧？你这不能上网了，你离不开，你会喊，你说喊老妈，您过去把那路由器呀。

给我重启一下，把电拔了，重新上一下电。啊，这时候。老妈可以帮你。是吧啊，那你要是再出现不能上网的时候，那我们喊他说您过来给我添加一路由条目，我就能上网了。是不是非得拿着菜刀改变壮胆屋追你，对不对呀？哎。

做不了。啊，所以呢它有优点，也有缺点啊，就必须得是专业人士学这个的，他才能干这个，否则的话弄不了。那么一般在我们大型网络中，就是静态路由协议和动态路由协议，二者都是相结合的。啊。哎。

然后再往下说说正是因为我需要老师配来配去的，所以呢这个呀适用于。啊，适用于小型公司。网络不是特别复杂。啊。或大型公司。与动态路由协议。结合来使用。啊。比较复杂的那工作量太大了。哦。啊，工作量比较大。

工作量大不说，还需要专业人士，对吧？那么动态路由协议是什么呢？啊，它的优点就会自动记录。啊。自动发现。自动学习路由条目。啊。方便。吓。不需要专业人士来。配置。啊。哎，你要是设置成自动学习。

说你们家客厅一个路由器，卧室一个路由器，你要想让客厅和卧室能连上，怎么着，拿那网线口吧唧一怼行了啊，这就能上了。对吧这时候你再跟老妈说，我这头插在这儿了，您把那头随便找一个烂口，蓝色的那口插上就行了。

看见那灯闪就OK了。啊，这时候老太太能帮你，不会拿着擀面杖追着你满屋跑啊，这就叫做不需要专业人士来干。啊。那么当然了，优点就是这样比较省事儿啊，但是它的缺点也带来了啊，那么它就是生效慢。你得自动发现呢。

自动记录，自动学习呀，对不对呀？你得有一个让人学习的过程，所以是有时候效率比较低啊。不像那个静态的一敲回车，啪叽就生效了。这个你得等他，没准三五分钟以后他才学明白呢。🤧啊，生效慢效率比较低。

这是他的缺点。啊。那么。哎，学习路由条目。比较耗时。得等一会儿。啊，那么就造成了。通讯效率。比较低。啊，通电效率比较低。好。啊，所以呢它就适用于什么呢？小型网络。你可别弄那种超大型的啊。

那玩意儿操得学习一会儿呢，是不是啊，那呃怎么回事呢？咱们画一个啊，画一个把这条线去了。这条线也不要了。我这么做啊。哎，公司有钱了啊。咱在这儿呢来个三台。说公司啊有一台主路由。能上外网。啊。然后呢。

我这边这部门哎我这儿跟主路流连着，这边这部门也跟他连着。那么左边啊左边儿。比如说我这些设备啊通过路由器的时候啊，访问网络的时候，这个信息到这儿哎。我就学到了，说我这就有一个路由表。啊，就有路由杆。

对吧从哪到哪儿我就记录的去学啊，比如说我们学一条192。168。1。10是吧？1。0这个网络。啊。好，比如这边呢。啊，这边是多少呢？172。16点0。0。啊。哎，这一条啊叫一个路由条目。然后呢。

你这里头的主路由啊说你这个信息到这儿去了啊，访问网络去了，出去了。诶。😊，那他就会怎么着呢？他就会。把你。这个信息啊学习了。Yeah。好，自动的在这儿哎加一条儿。加一天儿。2。好，这路由器一会自动学。

他也自动学啊。然后呢，他发现了这一和2啊，他把它学习完了啊，他把它学习完了。如果说这里头路由条目有了，他就不再学习了啊他。这里头没有的，他就再补充一下讲啊，所以这样就是我们静态路由和动态路由啊。

两个路由协议。能自动发现，自动去学习啊。🤧嗯嗯。Oh。好啊，那么呢我们今天呀把我们这个啊。两个工作原理给大家呢介绍明白了啊，所以呢像这个静态路由动态路由协议也划重点了，回去呢好好的去看一看啊。

那么这个路由器啊这个路由器。Oh。Oh。那么我们也有有一些分类啊，简单的给大家提一下吧。常见的路由器。种类啊。有什么呢？叫soho级的。别整的这么洋了是吧哎？家用。啊。啊，家用。

还有的呢说这个soho级啊，就是这种小型的啊公司，说总共仨5人啊，董事长对吧？总经理啊，加财务加开发加什么啊，总共就俩人。哎，身兼数职，对吧？还有我们的企业级。Yeah。Good。Yeah。

所以呢一般的话呢你用一个什么呢？哎，你你你用一个家用级的就行了啊，家用级的就行，我写在这儿吧。梭学吓。不写了啊，写了我还得调。好，家用级的那你就随便了是吧？那你买个。哎呀，差不多的就可以了啊。

比如说你用个网件对吧？哎，能带。300人。Oh。啊，当然你对家里要求高一点，网速快的话呢，那你就弄一点好的啊，像网件大概几千块钱一台。那你要用普通的呢，就TPlink。啊，听不进了。

这随随便23百1二百的也能用啊，还带无线是吧？啊。🤧。华为。啊。什么水星。Yeah。啊，还有一个叫dlink的。嗯。Yeah。等啊。那么一般这样的话呢，就要求不高，能上网就行了啊，顶多拿个宽带自动拨号。

现在呢这些高级的猫上呢都直接就带路由功能，还带无线啊，所以呢这个大家呢都可以去看一看啊，我用的呢就是网件啊，我觉得。🤧嗯你如果设备多要求高的话呢，那你就用这个啊。那么现在呢我们可以买一些什么呢？

wifi6。啊，wifi6标准。你现在高级的电脑啊设备。就都支持wifi6，速度比较快。啊，老式的这些路由器呢最高支持到wifi5。那么如果你用iphone叉啊，不是不是这这这这对pro max是吧？

iphone11以上的支持wifi6的啊，那网速更快啊，就体现的快。说你就刷个抖音上个网，那没关系，wifi5也一样能凑合用啊。好，那么企业级路由啊企业级路由，那么这里头呢就带了一些特殊的功能。比如说。

🤧ARP。Oh。比如说带ARP。ARP呢可以绑定。麦克地址列表。好。啊，比如说我们有VPN。啊，比如说我们有上网行为管理。Oh。啊，比如说它内置的交换机。啊，可以对端口进行限速。啊。带宽。啊。

贷宽的控制和管理。儿子。TCP。IP。端口连接数啊。也可以进行限制和管理。啊，黑白名单。我们都放到这个行为管理啊，比如说他有黑名单。有白名单。Oh。啊。白名单里头我们要对上网啊管理的话呢，它可以分类。

分类管理。比如说可以管理你的网站。啊，网站就是通过域名。Okay。比如说星点百度。啊，所有百度的。域名的都能上。黑名单如果是星点儿。🤧谷歌哎，完了，谷歌访问不了了。听点优酷。视频看不了了。2。

所以呢我们到企业里头，你上班的时间，你会发现什么电商啊、购物啊，那些玩意子，什么小说啊、玩游戏啊，那些网站都打不开。啊，他上网行为可以进行管理。Oh。啊，那么然后呢他还可以干嘛呢？🤧可以分类。

比如说你有应用的。啊。比如这里头有百度网盘。啊，它可以通过上网行为管理啊，可以给你限速。Oh。你不下载吗？我给你1KB。对。我让你下啊，我我让你爽到极点，爽到爆就1KB，你自己就不下了。好。对吧有娱乐。

啊，有电商。有小说。嗯。😊，啊，还可以自定义。哎，就对你的上网行为进行管理。啊，包括谁下载，对他进行限速等等等等。VPN啊VPN说你有北京。北京总公司。你还有上海。你还有深圳。Yeah。啊。你这是总部。

你是分部。嗯。好，那么我如果。我这俩分部也想跟总部在一块啊，用一套网络，一套系统，那怎么办？那就得通过VPN技术。做一个虚拟网络。啊。然后你这俩分布。连到总部上。访问总部的网络。

比如说他的邮件呀啊等等等等。Yeah。交换机端口限速啊，比如说我是千兆的网。对吧。好，我保佑我的主要部门签着其他的。我给你限到百兆啊，限速。或者玩最狠的限速300K。所以在企业中这个宽带资源是有限的啊。

我们一般呢会给大家限速。你想快也快不了啊，这个速度让你打开百度听个QQ音乐就了不得的了啊，就不错了，能收个邮件。啊，带宽的管控。比如说你这带宽占用到50%啊，我就采取什么策略。

比如说限制你连接数等等等等啊。那么企业级路由呢，那你怎么办呢？你就是捡好的来。啊，就上来就这个起步就4万，就来这个。好了。明啦。Yeah。对不对啊，上来就来光高端的啊。

高端上的你企业有钱的那你就你你就整呃，企业没钱没钱来来点便宜的啊。这个啊这个哎那咋这么便宜啊，这不行。4000不行。Yeah。这这真的这这国产太不争气了，你这这卖这么便宜，这谁买呀，对吧？找贵的就这个。

啊，这也不贵这。万绕。对吧哎，这才像哪样子嘛？咋的，那你也花个2万块钱嘛，是不是八口万兆的啊，就这样。那么家用的跟民用的跟这个这个企业级还有啥特点呢？啊，家用的一般都是。在万口上。啊。

万口个数上限制了你。😡，家用一般都是一个。到两个。好。通常都是一个。啊，说一家里头装三条宽带的，这样的家庭很少。啊，一般你就装一个就够用的了。那么企业级路由呢，它支持一个什么呢？它多万口。说企业呀。

比如说咱就游戏公司吧。啊。🤧游戏公司你是不是得保证我。中国电信的能访问，中国移动的也能访问。是不是啊中国联通的也能访问。那怎么才能保证他们都访问的快呀？啊，那我就可能企业里头有。中国联通。中国电信。

中国移动。什么这个这个这个这个教育网。啊，你可能就都要考虑到。啊，当然了，IDC机房它就是BGP啊。Okay。好，多个腕口，也就是说我可以拉多个宽带。啊。多个宽带。多万口，这样的话呢。

我可以做一个链路聚合。Yeah。啊，满足我，那你中国联通的来，哎，我也能访问中国电信的用户来了，我也能访问。中国移动来了，我也能访问。教育网的来了，我也能访问啊，就是这么一个意思。😊，多万口啊多万口。

然后的话呢还有一个特点呢，就是什么呢？家用的呀，一般的就是哎百兆。啊，这是万口的区别。烂口呢。烂口呢就是连接在你电脑啊。啊。其他的4个啊，一般在家里头四个烂口。Okay。啊。那企业的多。🤧嗯。8个。啊。

6个。是吧。然后呢，这个速度。啊，家里百兆，他千兆。啊，家里千兆他万兆。好。Okay。Oh。あ。啊。速度快。是吧哎，家里个数少。白照。I。你签着。🤧嗯。好啊，那我们今天的内容呢就给大家说到这儿啊。

。

系列 3：P137：【Linux】知识概要 - 马士兵_马小雨 - BV1zh411H79h

好啦。啊，文件的基本操作。

。

目录的基本操作。Oh。Oh。Oh。咱们就不展开说了，如果展开说这里的东西就太多了。除了基本的命令，文件的权限，文件的属性，文件的压缩，文件的备份，文件的传输等等等等啊。

我们有很大的篇幅都是围绕着文件啊来展开的。

第二个呢啊就是用户的管理。

Oh。好。啊，除了文件以后，哎，系统中我们有很多的用户啊，这里我们掌握了。

管理员用户。啊。比是系统用户，是不是？哎，我们掌握了普通用户。

。Yeah。虚拟用户。Oh。

好。

哎，用户啊以及用户权限。

，啊，你单拿出来讲也没问题啊也没问题。

Okay。好，然后呢我们学习了什么呢？哎，我可以把单拿出来一块啊，我们说一下啊，权限管理是不是？

啊，权限管理。比如说这里头我们介绍了哎文件。啊，文件的权限。

用户的权限啊，然后呢再往后呢，我们介绍了什么呢？哎，我们学到了。磁盘观。

Yeah。

啊。那么再往后呢，我们还可以学习什么呢？我们再往后呢，我们要学。网络管理。Yeah。Yeah。啊。

啊，再往后呢还需要学习。进程管理。啊，所以我们到现在的这个课程都是围绕着linux操作系统啊来展开的。

好，这是我们把我们之前这几周啊之前一直从开学到现在这几周所写的内容简单的做一个概括。

系列 3：P138：【Linux】网络基础 - 马士兵_马小雨 - BV1zh411H79h

。那么今天我们主要新增的内容呢就是网络部分了。啊。那么网络呢是我们将来在运维阶段啊，将来从事安全行业非常重要的一块内容啊。那么你将来在处理故障的时候啊。50%的问题。都是。发生在。网络这部分。啊。

经常是这又不能上网了吧啊，那个路由又不通了吧，对吧？哎，出现这种情况。那么我们学习网络应该如何去学习啊？你从以下几个内容来学习。首先第一个什么是网络？啥是网络？哦。好。

那么我们一块儿呢跟大家来深入的去学习一下啊。这个网络。网络。最早诞生。最早诞生的这个理念不是为咱们普通老百姓用的。啊，那么他最早诞生。侍卫。美国军方服务的。啊。

所以我们先从宏观上从大面上让大家好接受的方式给你说啊，最早是为了美国军方服务的。所以先讲故事，这是一个故事。那么当初啊。啊。当初这个美苏冷战的时候啊，他们两个国家。都拥有相互摧毁的能力。啊。

就你能干死我，我也能干死你啊，所以美国人就怂了。美国人心想呢说，万一你这个对吧？苏联人一个核弹过来，那老毛子这是敢说敢干的是吧？哎，真要把美国几颗核弹炸没了，那怎么办？所以呢。

美国呢就要求这些科学家说你能不能啊给我创建一个具有如下特点的第一个分布式。啊。说把我这指挥中心呢。我放这一坨放那一坨啊，再放这一坨。啊，咱们老话讲叫鸡蛋不放在一个篮子里头。啊。把。指挥中心。可以放置在。

啊，各个不同的。比方。哎，你干掉我一个，我还有其他的。啊。那然后呢。哎，然后还得实现了一个什么呢啊。数据。这么小。Yeah。Yeah。啊，说你把纽约给我炸了，然后呢，我这个数据马上就能。啊。

马上就能通过网络把这个数据传输到其他的地方，其他的指挥部。啊。诶。😊，最早呢这个网络就是这么来的啊，它和我们尤尼克斯操作系统和我们C语言诞生在一个实验室里头，叫做贝尔实验室。

那么最早的我们的尤尼克斯系统是干啥使的呢？咱们最早的尤尼克斯系统是美国人啊，这这个呃做导弹啊的这个操作系统。哎。要做导弹用的。然后呢，这个导弹我们得计算弹道啊，是吧？他们又发发明了一个编程语言。

叫做C语言。所以我们现在发现这些普及率非常高的东西，最早都是军用的啊，现在才开放到我们民用领域，觉得这东西挺好。Yeah。好，那么我们概括一下啊，说啥是网络。网络就是把。分布在。不同。地理。位置上。啊。

的主机你看咱说了前半句，这句话的意思就是分布式，把分布在不同地理位置上的主机。啊。逗号。通过传输介质。啊，什么叫传输介质？比如说通过网线。啊。还可以通过卫星。啊，通过传输介质，咱们写个等。连接起来。

实现。主机之间。啊，这些主机之间。数据。能够快速啊能够。数据。共享。的目的。数据传输和共享的目的。哎，这就是网络。啊，这就是网络。Oh。好啊，这是最简单的啊，我们给大家介绍了啥是网络，哎，他是咋来的啊？

是吧哎给你介绍了啊，他是最早啊是服务军方的啊。Okay。好，第二个。哦。如何使用网络？啊，如何使用啊？Okay。Okay。网络的特点。啊。我们概括一下特点吧啊。嗯。好，那它有啥特点啊。

或者说他如何去分类，它是干啥的啊，那在咱们现在呢引入到民用的这个级别上来说，那么它就可以啊有各种各样的来使用。啊，各种各样的来使用。首先第一个啊。好，分布式，这是它的特点。第二个可以数据共享。Yeah。

啊。第3个哎，数据交换。Oh。Okay。好，哎，他有如下几个特点。啊。那么能够分布式，也就是说把。分布在不同地域。啊，简单写就是跨地域。北京跟上海两台服务器要通信怎么办？哎，你不能打个车去趟上海。

坐个高铁去上海，那怎么办？通过网络远程进行传输。啊，那么这个是他的一些基本特点。啊，那么网络在我们生活中的应用有哪些？那太多了啊太多了。那么我们一块儿来回忆一下啊。比如说。Yeah。咱们都有啥呀啊。

平时用哪些网络呀，都干啥了呀？啊。比如说我们的。宽带。我们的电话。我们的电视。啊，这是最传统的。过去我们讲哎，三网融合，三网融合干的其实就是这。啊。包括咱们现在同学哎呀，说我不行啊，我得我得上网啊。

上网呢你要干啥呢？比如有同候给我浏览信息是吧？那你浏览信息是有人发布，有人看，那这不就是数据共享吗？对不对？那什么是数据交换呀？有同学说我上个QQ，我登录个微信啊，我要。这个跟人家聊天啊。

所以这个都是社交。是吧哎，社交软件。啊。对吧哎。比如说我从网上下载。아。下载数据。是吧。看电影。听音乐。啊，等等等等。Okay。那么放到我们。运维领域咱还可以干很多事儿。啊，放到运维领域可以干很多事。

那么我们就可以通过网络啊，它的这个特点，它能跨地域啊，然后能够进行数据交换，我们就可以进行数据备份。啊，数据备份。Yeah。把我们的这个数据啊，北京。备一份儿。啊，深圳这一份啊和上海这一份。

这种备份方式啊就叫做异地备份。北京是一个地儿，上海是一个地儿，这就叫两地。啊，两地。那么通常我们讲的两地三中心啥意思呀？哎，就在北京，比如说我这有一个测试中心。啊，测试中心我有个开发中心啊。

上海呢我有一个数据中心。对吧两地三中心。那么这是一些网络的特点啊，能够快速传输。哎。就是数据交换里头啊。那么成本比较低。性价比高。啊。比较便捷，刚才说了，你不至于哈你坐个飞机，坐高铁。

再去上海去一趟去调，是不是哎，远程就处理了啊，这就是我们所说的网络的一些特点。啊，那他能干啥啊？啊，他能干啥？那么这些东西通过它的特点，咱就给大家啊介绍了一下啊，那网络的。分类。Oh。Oh。Oh。

Yeah。Yeah。好，那么网络呢我们一般是怎么去区分的啊？首先我们网络从地域上。啊，不对。系。那么这个也是我们常见的一种分类方式啊，就也就是说。网络的。覆盖范围。啊。经营分类。

那么比如说咱们常见的这个因特网啊，它就属于广域网。哎，广域网啊。全球都可以访问。Yeah。Oh。Oh。Oh。啊，还有什么呢？唉，范围比较小的啊，比如说我们全北京市的网络，哎，这个东西呢就叫做城域网。啊。

成语啊。Oh。比他的范围小一点点。啊，比他的范围小一点点。啊。那么还有什么呢？局域网啊，说我们某一个小区对吧？整个的网络哎。渔欲网。好。这个是我们从范围上啊进行的一个分类。好。如何来使用网络啊？

Yeah。还有其他的分类啊，我们回头遇到了，再给大家去介绍。如何去使用网络？啊。首先我们需要有一些充分必要条件啊。首先第一个你得有。啊，得有，也就是物理层面。啊，我们需要物理设备。

那么这个物理设备我们都需要什么呢？首先你得有一个网卡。Yeah。啊，你得有一个网卡。其次，你需要有传输介质。Oh。Oh。啊，说你这网你要想上网，必须得有网卡。啊，那要么呢你是有有限的网卡。

要么呢你用无线网卡。啊，但是必须得有网卡，没有他。你上不了。啊。那么网卡它起到了一个什么样的作用？啊，网卡起到了一个什么样的作用？网卡其实。又叫做。调制解调器。啊，网卡又叫做调制解调器。

那么他的工作就两件事儿。调制。解条。啊，调制和解调。Yeah。好，那啥是调制，啥是解调啊，它是干啥用的？好，那咱们就一块来分析一下啊，画一图。

咱们在家里头，咱那电脑是啥样的呢？哎，比如说你是个。台式机。你是个一体机。对吧啊，你还可以是笔记本电脑。你还可以是超级计算机。你还可以是个机房。啊，这里头可以放N多个主机，对吧？所以我们都把它称为主机。

A。那么我们不管你是啥样，各式各样的，还有你的笔记本啊，咱们这些个电脑要想上网，就必须得通过一个叫网卡的东西，长这样。啊。那如果是PC机，说你是DIY的这个主机，哎，那你可能把这个机箱拆了啊。

拿出来看一看。那如果是一体机，那它可能是直接在我们主板上集成的。啊，直接在主板上就集成了。所以你能看到的是一个什么？哎，你能看到的就是一个网口。啊，看到的是一个网口。啊。然后我们要想上网，那怎么办呢？

哎，我们需要通过有一个叫交换机的东西。啊啊。通过你的网卡和它进行连接。啊。然后交换机接了谁？啊。Yeah。交换机呀这头接了一个路由器。啊。Okay。Yeah。好，这路由器这头能上网。

所以呢我们家里的网络呢是这样去干。啊，这样去干。那么如果说。我们家里头啊或者咱们两台计算机要进行通讯。啊，说计算机一。嗯。想和计算机2啊，他俩。进行通信啊。一跟二说姐姐小姐姐约吗？啊，小姐姐说不约。

滚犊子。哎，那你这一个他们之间啊。Yeah。需要有网卡。啊，那么这里头传输的这个过程就是什么呢？哎，你在。你在计算机一上啊，比如说你打一一个字儿，是不是哎，哈喽。

然后啊我们的操作系统就会把你输入这个哈lo进行编码，在内存中啊，就会变成二进制数据，然后操作系统驱动网卡啊，然后把你这个二进制的内容啊，转化成电信号或者光信号啊，所以你看我们现在遇到的都是什么呀？光纤。

对不对呀？啊，我们会有一个光纤猫。啊，那么你把这个数据哎就变成了。啊，电信号通过我们的这些个网线呀，对吧？看一条条线连着呢，网线啊，通过我们的网络啊，中国联通、中国移动chander mobile是吧？

哎，把这个数据传输给他。Okay。Oh。Yeah。好，那你这里头写着hello的信息就从这走走走走走走走走走过来了啊，计算机二收到你这样的一个数据。啊，收到了一个信号。

那么呢他就把你发过来信息层层打开啊，把这个0101这个先收到一个电信号和光信号，然后把这个信息转化成二进制，最终再把这二进制信号翻译成我们能认识的hello，啊呈现给你。

那么左边啊你通过操作系统到网卡啊，把这个把这个数据逐渐分包。啊，最终把这个信号进行转变啊，我们的二进制数据变成电信号或变成光信号。这个过程我们就叫调制的过程。

啊，调制的过程。啊。8。二进制。数据。转化成。哦。电信号。或光线哈啊。哎，这个过程。啊。就是调制的过程。那么如果反过来啊。把电信号。或光线哈。啊。转化为。二进制。对吧这个过程就是解调的一个过程。啊。

协调的一个过程。我们简单的这么说，其实他的工作原理很复杂啊，便于我们的理解。好了，这个是我们所说的啊，网络里头我们需要掌握的内容啊，你得有一个网卡啊，且这个网卡得能正常工作，能调制能解调，不是坏的。啊。

第二个就是网络。我们在使用的过程中啊，我们需要有一个传输介质。哎，啥叫传输介质？啊，什么叫传输戒指？咱也得说一说。啊。传输介指就是主机和主机之间构成网络，大家能够相互连接的这个东西就叫传输介指。啊。

传输戒指。可以分类成导向式的。和非导向似的。导向式的呢，你可以理解为我看得见摸得着的。啊。比如说大家知道的这个光纤。啊，比如说大家看到的这个网线。啊，比如大家看到的铜轴电缆。啊，这些都是导向式。Oh。

那么非导向式的呢，比如说大家看到的哎，说我蓝牙。啊，红外。对吧我们看到的Wfi。啊。我们使用的手机啊，微波。啊，比如说现在最先进的啊量子通讯啊，这都是非导向式，看不见摸不着。It。啊。

那么光纤呢它又分为比如说单墨光纤。多么光鲜。啊，单模光纤和多模的光纤。

。Yeah。咱们看看啊。

单模光线。大家看到的这样的啊。大黑区去的这些线子，哎，这就是一个单模的关系啊，一般呢做什么呢？做我们室外啊。

做室外的。李根啊啊。

这单模光纤有啥特点呢？你看这里头就这这蓝色的啊，一根线外头呢这黑线呢是它的这个橡胶的皮。然后呢，他这边有两根钢丝。啊，两根钢丝。来保护这光纤的啊，防止你在拉扯的过程中，穿线的过程中一拉它断了。Yeah。

有粗的啊有细的。一般都是用于外墙布线。好。哎，你要是赶上哪个倒霉孩子，一看墙上有一根线挺好玩的，咔机拿剪子给你绞了，那完了都上不了网了啊，单模的就只了这里头一根心啊一根心。

那么通常由于什么呢？咱们家里宽带。

啊，咱家里宽带，中国联通啊、中国移动啊、中国电信呢到你们家都是啊，然后呢这个是接口。

啊，这是接口。Okay。今天下课啊，或者检验一下你们家光线猫啊。哎，那么有黑的，还有白色的啊，还有白的，像这种。

啊，哎这种。啊，都一样啊都一样，外边颜色不一样。但是里边啊你看都是一根心，有两根铜丝啊。中间这蓝色的是光纤，外边两个是保护它的，是钢丝啊。

あ。

好，这个是我们单模的啊单模的啊。

还有什么呢？还有多模的光纤。

啊，多么光鲜。

Yeah。那这个时候呢这使用起来呢就不一样了啊就不一样。

Oh。对吧那么就会遇到一些高级的地方，数据中心机房啊，比如说那里头要求的网络要求比较高，所以呢这里头啊人家用的设备也更高级啊。

这没有给我们拆开剪开的呀，我搜一张剪开的，看里边的啊。

Yeah。

Oh。没有啊没有得了啊。

好，这块呢我们有所了解啊。🤧那谁是我们的重点呢？啊，网线。这是咱的重点。啊，光纤了解网线，我们需要知道。这网线呢它又叫做双绞线。啊，什么叫双绞线？脚就是脚缠在一起的意思。那么我们拿到的网线里头是8根线。

八根线。啊。分四组。两根缠绕在一起。嗯。哎，每两根绞在一起，所以被称之为双绞线。啊。🤧。那么这个。四组线都是什么？啊。第一个是成白。成白。也就是说，橙色和白色相间的。

。

啊，那这样就是网线啊，那里头八股线啊。

🤧。

好。都是做好的了。

。

啊。这剥开了以后啊，这里头。

澄白和成。你看这个就是啊橙色白色相间的。

这儿呢啊搅在一块儿，里头好一点的有铜心的。啊，次一点的有铁的。啊，所以网线越便宜的。越不行啊，因为经常有时候我上网嘎嘎掉线了，对吧？网速慢啊，跟你的网线有直接关系。

好。

好，第一组我刚才说了啊，成白成。啊。第二组。第三组第四组啊，第二组呢绿白蓝。绿白。绿。Yeah。蓝白。懒。钟柏。中。Okay。Yeah。好啊。四组线是这样的颜色。

那么我们这个双绞线又分为正双角线和反双绞线。Oh。这指的是我们的线啊这指的是线。那么平时呢我们在使用的时候啊，还有一个东西。叫做水晶头。你光有线不行，你还得有水晶头。啊。这个水晶头儿。

在ISO国际质量体系认证里头有一个标准。啊。那么有两种，一个叫RG45。一个叫RG11。Okay。

。

RG45水晶头。

哎，这个是我们和。

啊，网线通过水晶头和我们的网卡进行连接的。啊。那么上边这8根线对应的是8根铜片啊，八根铜片。高级的还有金子座的。啊，还有镀金的，还有镀铜的，越高级的越贵。啊，一个水晶头好的，甚至卖几10块钱一个啊。啊。

也有几块钱买一堆的。啊，所以越贵，这东西就越好。啊，有的人说我这是纯金的那太好了啊，那你这个接触就非常好啊，信号损失就比较少。那么这个头啊也有不同材料的，有塑料的。啊，也有用水晶做的。啊。

所以你看比较便宜的毛毯俩的那个就是塑料做的啊，一点都不透亮。就是说你在看的时候不透明。高级的那些水晶头啊，你看到的是透明的水晶做的，要不叫水晶头，水晶头，晶莹剔透的啊。你将来要有机会去机房啊。

你抓一把水晶头啊，揣兜里都好几百。啊啊，这是水晶头。那么我们看到这样标准的就是RG45的。

啊，8根线，那还有什么呢？类似于电话线的RG11。

哎，比较小的这种。Yeah。哎，里头四根线。啊，这是RG11的。

啊，8根线的RG45的啊。

好。那么有水晶头了，有双绞线了。那么咱们用的正双绞线。

啊，就是画图，你这电脑通过网卡这一根网线连接在交换机上。那这样的水晶头啊壳。网线做成的双绞线，我们就称之为正双绞线啊。我们说一下这个线序，说完了咱再下课休息啊，你不四组线八根吗？它的线序是这样的啊。

成白城。绿白蓝。蓝白绿。棕白棕。Okay。八根线的线序。啊。Yeah。🤧うん。好，反双角线我也给你说一嘴，说完了我们。就下课休息啊。反双角线就是一头是这个。啊，另外一头。Yeah。

另外一头1324对调啊，顺序是1324对调。Okay。线续。1324。啊。注定。

系列 3：P139：【Linux】传输介质双绞线 - 马士兵_马小雨 - BV1zh411H79h

喂，好啊，我们刚才介绍了一下啊，我们这里头的网线。那么网线的分类刚才介绍了正双角线，反双角线啊，反双角线的这个1324对调体现在什么呢？啊体现在就在这儿啊，把你这个橙白和绿白。欢迎一下。啊。

24你把这城和蓝。啊。进行对调啊，1324把这个啊。搞清楚啊。

按照这个线序啊来处理。好，那么这个网线啊网线，那么在网线这里头也有啊很多的分类。说我们家里网速快不快啊，取决于你的网线和你的网卡。啊。网线。Okay。好。

我们给大家看一看啊，网线。

。

🤧。

那么我们现在啊啊机房里头以及大家使用的啊这个网线。那么我们现在起步就是什么呢？起步就是用6类线。啊，六类型。

所以这儿大家记住的就是。六类网线。啊，六类网线。凯德6。Oh。啊。好，那么如果去区分这里头的东西就多了啊，就多了，我给你写一下吧。好，咱们常见的啊一类线。二类线。🤧三类线。四类线。五类线。啊。超五类线。

六类线。超六类线。系。七类线啊就常见的网线这么多。

这么多种。Oh。啊。那么。前面几种啊不再介绍了，就比较老啊，不介绍你好奇心是吧？好奇害死猫啊，一类线80年代的时候用的，所以为啥说不介绍了，比较古老了啊，最早就是变话线。嗯。啊，干这用的。Okay。啊。

二类线啊二类线也比较早了。啊。那么最早的呢就是也是啊做这个网络用的。但是呢它的传输速率呀啊指最高。最高呢就是四丈。🤧嗯嗯。🤢，Yeah。所以呢在咱们国内啊有一些比较老的小区啊，你说你装宽带对吧？

人家告诉你对不起，我们这里头还是这个这个同轴电缆呢，最快就四兆啊，你想装个百兆千兆的装不了，所以呢这些都比较早的。啊，那么三类线呢也就是到哪儿呢？三类线呢就是百兆。After。也就是我们传说的百兆网线。

啊，百正网线。那么这个里头的传输速度呢，最大到说的好呢。啊，实兆。啊，十啊。🤧嗯嗯。好，那四类线呢啊四类线呢就比他们稍微高一高级一点了啊，一般用在局域网。但是这你都不用记啊，有所了解就行了。

那么了解这个呢，就以后你买网线的时候啊，你最起码的你知道你买什么样的网线啊，它最大传输速度16兆啊BPS。好，那现在你在啊。你再去处理这买这些网线的时候啊，起步就得是6类线了。Yeah。啊。

高级一点的就得七类了啊，这5G1来了，就直接就怼七类线啊，万兆。嗯うん。啊，我们也称之为万兆线。🤧嗯嗯。那么实际上呢啊我们六类呢就是什么呢？六类就能达到千兆。啊，千兆。Oh。Oh。啊，万兆是啥呢？

万兆就是1G币。啊，是G笔。所以说呢我们在采购网线的时候啊，你不要图便宜，你上来随便买一个啊，那么你买呢就是这种六类线啊六类线。

那么它里边这个线呀。

啊，它里边这个线。线心。啊，都是加粗的，然后都是什么呀？六类千兆纯铜啊。而且铜呢这里头还有用的是无氧铜啊，就是规格越高，它里头用的材料就越好，传输速率就越高，电信号损失就越少啊，你看纯铜的，包括水晶头。

纯铜的。

啊，一盒65个，相当于一个水晶头6。5块。啊，这才是一个超五类的水晶头，然后呢还会有什么呢？还会有这种屏蔽线，说你要求特别高啊，要求特别高。机房里头用的。

啊，机房里用的那你看机房里的我直接搜的什么呀？七类纯铜线啊，七类。

那么每股双绞线里头还带屏蔽的啊，说里头还会有什么其他的这些，比如说锡纸啊或其他的东西，它能够屏蔽电信号的干扰。因为你有电就有磁，对吧？你看这水晶头外边对吧？这都有铜线进行包裹。

所以在这线里头都会进行屏蔽的，所以它对你数据中中心啊、机房啊等这些高端用户用的。

啊，万兆线。

对吧哎就电信级的。所以这一根线，比如说你看一米卖你16块钱。

啊。10米就得小100块钱。

对吧所以等级越高啊，它的网速就越稳定，信号衰减就越少，上网就越快。所以对这种发烧级用户啊啊光设备这块就得投个几万。

啊，所以这块网线这块我们简单的跟大家说一说啊。

所以到机房里头，我告诉你，你只要能进去，全都是好东西啊，所以这个水晶头啊是吧？哎，这网线呀，带两根拿回家去，是不是哎，可得劲啊，网线分类给大家简单的说一下啊。

好，那么我们有常见的这个传输介质了，网线也给你讲了啊，所以通常我们的正双绞线是我们见到的最多的。啊，最多的。那么他有啥用呢？见到的是我们插在交换机上的。啊。插在路由器上的。

啊，那么另外一头与你的主机相连的，一头插在交换机上，一头插在你的主机上。啊。

与你主机相连的。反双角线。啊，反双角线。也叫做什么呢？也叫做双击互连线。啊，双击互连线。那么这个东西是啥时候用的啊，说当你的。啊，比如说没有交换机。

没有交换机，直接就是一端连接在。主机A上。另外一端直接就连接在主机壁上。啊，直接不通过交换机两台电脑之间进行通讯或一个电脑和一个服务器之间进行通讯。啊，就要用到反双绞线。

所以这个反双绞线它也叫做双击互连线。

。

啊。一般人都不知道有这东西的存在。啊，上来就给你白话交换机路由器，一般人他不知道没见过这东啊，所以最早的时候，那时候朗朗恶购以前我们没有大容量存储设备。比如说没有移动硬盘。

没有现在的U盘一干U盘干你128个GU盘干你一个T，没有那时候U盘非常小啊。对吧你要弄一个4个G的U盘，你都你你都老老厉害了，对不对啊？那这时候你要考大容量的视频，那怎么办呀？那你你承不下呀。

那时候硬盘也就20个G，40个G，80个G，那就是算大的。😡，啊。所以怎么办呢？哎，你可以自己做一根双击互连线，俩同学的电脑开一连啊，你那有。对吧这个小泽老师的电影啊，那有龙泽老师的电影。哎。

那你们俩一共享通过网络都哎，俩人都有了。对吧哎，你去那个宿舍了，那个宿舍哥们有日韩。哎，那你哎。一共享哎，你又有日韩的了，对吧？哎，那个哥们有欧美，哎，那你又一共享，哎，你们又有欧美是吧？哎。

再往那边的宿舍再一串，他要东南亚，哎，那那马上也有东，所以整个全球的电影你就都有了。啊，双击互连线。那么他的。现续啊，刚才咱也说了。啊，当也说了，1324对调啊1324对调。13对调了。啊，一3对调的。

好啊，然后呢后边这个线序是什么呢？啊，后边这线序。好，绿白。绿白。嗯。谂白。来。啊。好，绿白。绿。橙白蓝蓝白后边是什么呢？后边是橙。啊。Yeah。

Yeah。嗯。一头正的啊，橙白成绿白蓝，蓝白绿棕白棕，一头是反的，绿白蓝橙白蓝蓝白成棕白棕啊，这个顺序。

。啊，这是26啊26。

啊，绿白跟橙白是吧？绿白跟橙白啊，这个橙跟这个绿。1326啊，我刚刚说的24是吧？看一下雾啊看一下雾。好，这时候就能双击互联了啊，那你要去机房里头，实际上如果说您能进到机房啊，我们有两个是要常备的。

就是大家这你背了一件脑包里头你要都要放上啊，这是我们简单的做一个扩展啊。首先你带两根网线。啊，两根网线。那如果你去调一些特殊的设备呢，你比如说思科的一些设备，你还需要带ccil线啊。

你没有ccl线进去就全满。啊，所以说呢一般的话呢呃如果你调不了那么高级的设备的话呢，你就带两根网线啊，就是正双绞线，买个3米5米的，买2米就行。备一根儿永远装包里，你看我去哪儿。

我包里的从来就有一根网线啊，至少是一根，对吧？现在呢这个反双角线不常见了啊，但是我们也要知道。啊。第三个就是我们可能需要运用到一个啊外置的DVD刻录机。啊，外置的DVD刻录机。对吧第4个备1个USB2。

0的U盘，就将来不用光驱安装的的时候，用U盘启动安装，但是一定要是USB2。0的。因为有一些老的服务器，它主板上不支持3。0啊，所以你用3。0的盘，它不认。

第3个，这2。0的U盘呢，最好是8G左右的啊，别太大太大，有时候也不认啊。好啊，这是关于网线。

系列 3：P14：【多线程与高并发】线程的启动方式 - 马士兵_马小雨 - BV1zh411H79h

很多时候呢我们呃作为真正使用这些概念的人啊，不需要把概念说用特别文绉绉的方式表述表述出来，因为编程呢是一个工程学科，你能理解，能用通俗的语言表示出来就很不错就可以了啊。

这是县城的一个基本的概念，我们来看这个线程的怎么样来创建一个线程，怎么样来运行一个线程，创建一个线程的两种方式啊，这个我在原来老的课程里头也讲过，在这儿呢也是带大家复习创建线程的两种方式。

第一种呢是从thread类继承，class my thread extends，thread，thread类继承，第二种呢是你spa继承之后重写run方法好，第二种呢是你定义一个类去实现rable接口。

依然重写run方法，但是如果你用第二种想让这个线程运行起来的时候，必须new thread，然后呢把我的实现random接口的这个类的对象传进来，然后再调用start，如果你是从three类继承的。

那么你直接调用start就可以，需要注意的是，一定是调用start。

而不是调用run，那还有第三种，其实第三种呢也是第二种的一种变形，jdk 8之后呢有一个lab的表达式。

第三种就是使用lambda表达式的方式，new thread括号箭头，然后呃里边怎么写是吧，system out print line，hello，lambda，给大家20秒钟时间看着小程序能不能看懂。

有没有什么地方有疑问的，因为我默认呢你是了解过县城这个概念的哈，好那么在这呢我突然想起当面试题了，我突然想起来了呃，有的我记得有一个同学出去面试的时候被问到过，说呃请你告诉我启动线程的三种方式。

而且你告诉我几种技能的三种方式呃，需要大家注意的是呢，这三种方式并不是这三种，而是说第一种是从thre继承，第二种实现rable接口好，第三种是什么呢，第三种呢是通过线程池来启动啊。

a a a a a execute a，通过这个new catch，thread，you catch the thread啊，然后拿到一个线程池之后，然后再去通过线程池来启动一个线程。

这是他想要的第三种，但其实在这个线程池里头起线程的时候也是用的这两种之一，呃因此呢他说用三种方式来启动，有点儿有点儿吹毛求疵的意思，所以你知道理解这个意思就行了，如果有人问你这方面的东西。

你说你说第一个thread，第二个rable，这肯定没问题好，那第三个呢你要说la表达式，如果他不满意不满意，你就告诉他啊。

系列 3：P140：【Linux】常见的网络传输协议 - 马士兵_马小雨 - BV1zh411H79h

26对调啊，我刚才说的是24啊，对不起啊。好，那么传输介质有了，那么咱们还不能传输数据呢啊，咱们得往上再倒饬一下啊，我又要引出一个概念啊。

说刚才说的说网络是把分布在不同地理位置上的主机，通过传输介质联系连接起来，实现主机之间数据传输和数据共享啊或资源共享的目的。哎，没毛病。啊，那么主机和主机之间在传输数据的时候，靠什么东西来识别？

就像我说话，你能听懂你说话我能听懂一样。过了一西班牙人，过了一韩国人跟你扯犊子的时候，你就听不懂了，就该出现他说胯过肘子，你说玻璃球子，他说玻璃球子，你说城门篓子啊，就出现这种情况了。

那所以呢为了大家都能够听得懂，在国际上每个国家、每个国家的计算机，咱们都能听懂。那么咱们这里头就要通过一件事儿来进行约束。啊，大家就得有一个规范，不能你说城门楼子，我说玻璃球子，他说玻璃球子。

你说跨过肘子，他说跨过肘子，你说城门娄子啊，那不行了。那么这时候就引出一个东西叫做网络协议。啊，那么通过网络协议。

进行约束。啊，实现数据传输、数据消换资源共享的目的。

哎，这里头咱就又引出了一个东西啊，说有物理设备了，哎，这是具备了物理的基础。你要没有这个网卡连灯都不亮，那完了是吧？有同多连网卡都没有，那你上不了网。第二个东西需要用到的就是传输协议。

啊，或者网络协议。Yeah。哎，咱们所有的啊这些个主机在沟通的时候，它都需要有传输协议。啊，网络协议啊网络协议。那么常见的网络协议有哪些呢？Okay。Yeah。啊，常见的网络协议。

这里头首先第一个最重要的就是TCPIP协议。我们会讲啊最重要的就是TCPIP协议。啊，然后给我们一个域名，我们怎么着能把它转化成IP地址DNS协议。

啊，DHCP协议说怎么去给我们自动分配IP地址。

啊，然后我怎么数据下载FTP协议。

啊，数据传输是安全的还是不安全的啊，UTCP协议。啊。

UDP协议。这都是传书里头的。啊。

好，那比如说我发邮件啊，POP协议。啊。STMP协议。IMAP协议。嗯。好，这些都是对邮件的。啊。邮件。

那么包括我们访问一个网络HTTP。啊。HTTPS协议。

。啊，包括我们网络ARP协议。

哎，这个协议我非常喜欢。啊，我非常喜欢。Yeah。在一个局域网里，想让谁上不了网，就能让谁上不了网。吓。对吧哎，比如说你住宿舍的时候，哎，大家有时候呢共享一个宽带的时候啊，那这哥们在这下片儿。

那怎么办呀？啊，我们通过ARP攻击说我不问你啊，从你后边啪一瞟，对吧？或者打开路由器一看，你的流量比较大啊，直接就干你。直接就让你闪断，让你直接断网攻击，吧唧他就没了。啊。

那有同学说那你直接通过路由器给他限速不就那多没劲呀，是不是啊我让你永远都上不了网，只要我看见你，我就弄死你。对吧哎所以等吧啊这些网络协议还有很多啊还有很多。光协议咱说三天都说不完。

啊。好，那这个协议我们引出来主要的作用就是告诉你，我们通过不同的服务。

比如说咱们发邮件，哎，这是一个常见的服务。我们通过这个邮件服务，咱们通过协议，比如说POP协议是干啥的呀？啊，POP协议，咱们拿它说。POP协议就是收件协议。哎，收邮件的协议大部分都是用它。

那么STMP啊是什么呢？哎，也是邮件的，发邮件。

啊，发邮件的协议。Yeah。哎，那么制定协议以后，大家都遵守着啊我们这个网络传输协议。那这时候哎。咱们就能够说计算机之间都能听得懂的话啊，说你长这样，我也长这样啊，这时候他就能听懂了啊。

这个就是我们常见的一些协议啊，所以后边还有个等，这里东西很多。

系列 3：P141：【Linux】网卡的协商机制 - 马士兵_马小雨 - BV1zh411H79h

啊，在后边我们会详细的来介绍网络传输协议啊。Yeah。好，那么我们传输数据的时候，是靠它来传输的。啊，靠他来传输的。好，那么我们有了这些充分必要条件以后，那么咱们就该开始。

啊，就该开始。说使用这个网络了。那么构成网络的最小单位。啊，构成网络的最小单位。两台。或两台以上的计算机。Oh。两台或两台以上的计算机。你要一台主机跟那玩呢啊，那你叫单机的。😡，啊，一台叫单机。没有网。

啊。啊，单机。你需要联网了，哎，至少需要两台或两台以上的计算机才能构成一个最小的网络。啊。那么计算机和计算机。构成了网络以后，他们需要借助。硬件传输介质网络协议进行数据传输和数据共享，对吧？

以及资源共享。好。通过物理硬件。通过传输介质。通过网络协议。缺一不可。Oh。那么通过这个干了一件啥事儿。数据传输。数据共享。资源共享。好。这儿就需要我们解释一下了。数据传输。

比如说咱们用的rthink全网备份啊，从A传给B。

啊，数据共享你有我也有，这个能理解资源共享这块，那么它就比较抽象，咱就一块来给大家解释解释啊。那么在计算机中，啥叫资源呢？啊，就是你的算力。也就是你的CPU。啊。你的算力。😡，也就是你的GPU。

CPU和GPU都称之为你的算力。Yes。吓。那么有时候GPU的算力要比CPU高。速度更快。所以将来有机会你如果接触到啊区块链技术的话，你就会发现有很多虚拟币的加密算法是用GPU来挖矿。

是用GPU来提供算力。我们也称之为显卡挖矿。🤧Yeah。啊。比如说可以用啊，我们。这个这个这个NV的显卡啊，GT叉1080。啊，1080钛2080钛啊，一张网卡干好几万，一个机箱里头8K网卡。

用AMD的R叉580。啊，里头8块网卡，11不是8块显卡，11块显卡。啊，这样的设备我有我大概有二十几台，等大家呢来北京线下来学习的时候啊，单位里头我都放着呢，可以做算力机，可以做AI人工智能的学习。

等大家到北京了，我那有，你打开你看看啊，你看看亮哥土豪不土豪是吧？咱开一台机器看里头R8R580的显卡里头8张十0多台。啊。对吧这都是哎我我挣这俩钱没事干，我我都我都买这个玩了啊。

所以呢就是哎咱们做IT的不容易啊，苦逼苦逼挣点钱全投资在这些设备上啊，所以资源共享。第一个就是算力，第二个是什么玩意儿？第二个就是存储。啊。比如说后边我们讲NFS共享存储。说你这个主机。

你的存储空间特别大。😡，啊，你这动辄几十个T，对不对？P。那把你的资源共享出来吧，大家一块儿跟着用，这就叫共享存储。啊，共享存储哎，还会有一些东西，什么叫资源呀？网络也是资源。啊，网络。啊。🤧嗯嗯嗯。

那啥意思呀啊，比如说你能访问。😡，哎，你能访问谷歌，我不能。当然通过你共享了，咱俩都能。啊。Yeah。Okay。等。啊，这个意思叫资源共享。你可千万别理解成，哎呀，我就电脑上那点片儿跟人家去共享了。

不是啊，这里头的资源。指的是我们主机里头的这些个内容。当然啊当然也会有这些数据啊数据。Yeah。数据也是我们这里头存的一些资源。啊，你的data。啊。可以共享。所以这时候你反过来你再去理解网络的时候。

刚才我们说了，把分布在世界各地的这些个主机，通过传输介质连接起来。啊，通过传输介设连接起来。那这时候在跟人打仗的时候，比如一个指挥中心被人干掉了，马上另外一个。指挥中心又有。啊。

所以那么我们网络的一个特点就是能够快速分布式啊，数据共享，快速传输。资源共享啊。这些个的作用。好，这个主要让大家理解资源共享这样的一个概念啊。去理解他。嗯嗯。好，那两台以上的计算机啊。

那才能构成一个最小的网络。啊，最小的网络。好，那这样的网络啊这样的网络我们就。

可以给大家再说的说的啊，网座能干啥，这不说了。网络的分类。刚才给大家介绍了广域网、城域网、局域网啊，那么网络我们在这里头就会有网络的拓扑，对不对啊，什么叫网络的拓扑啊，其实就是网络里头的结构啊。

所以按结构网络拓扑去分类也可以啊。

Okay。は。按拓普结构。Oh。那么这一块呢啊不会要求你。

去啊做网络拓扑这一块啊，但是呢在这儿呢我们要有所了解。啊，这一块呢一般的是有专门做网络方向的。比如说网络工程师啊。哎，他们去干这些事。啊，那么我们通常呢咱们运维工程师，那我们主要是系统层面的。

啊，在这儿呢我们了解说，按照拓普结构分类有总线型的。啊。还有什么呢？环形的。啊。还有啥呢？还有。新型的。啊。对吧还有网状的啊等。了解即可。Okay。啊，那么除此以外呢，还可以按信息的交换方式来分。

啊。那么这个东西啊啊现在呢呃提的也越来越少了。现在流行的呢就是按照你的地域和啊刚才的拓普结构来分。

啊，那么还可以按照信息交换。方式分类。Oh。Okay。啊。好，比如说有电路交换。啊。比如说有豹纹交换。啊。比如说。豹纹分组交换。Oh。嗯。好。Okay。好。Okay。好，标一下重点啊，这个这个。两个。

Oh。好。Okay。Oh。Oh。Yes。嗯。对。Ha。导向式的非导向式的啊这两个。Oh。Oh。Oh。Oh。好。好，网线分类的啊至少要了解。六类线啊。六类起步。哎，我这有一个七类线，怎么弄没了呢？好。

你去机房啊，起步就是六类线啊，六类线、七类线。哎，好像跑这儿来了吧。🤧。She。

好，非导向式的啊，简单的呢你有所了解就行了。比如蓝牙呀、wifi呀。啊，微波呀对吧？哎，这些有啊。好，咱们接着往下啊接着往下说介绍完了传输协议以后啊，那么呢我们就要看看这个网络的基本构成了。

那么两台计算机。啊，这里头网卡就要进行工作了。啊，网卡的。工作模式。Oh。Oh。啊。嗯嗯。好，那网卡呢刚才我们说了啊，有这个无线网卡，有有线的网卡。对不对？啊。好。那么在不同的网卡之间。啊。

那么他们工作的方式就是不一样的。哎，比如说咱们常见的这个有线的网卡吧。好，那么网卡的工作模式啊有三种。你记住有单工的。啊。有半双攻的。哎，还有双攻的。Oh。Yeah。好，那么谁是双攻的？我们的有线网卡。

啊，就是典型的。双攻的。啊，代表工作模式。那么什么叫双攻？就是。能上传的同时能下载。啊，上传的同时能下载。就叫做双宫。啊。就叫做双攻。好。好。哎，能上传能下载啊，同时进行的。所以有同学会发现说。

哎呀说我在平时使用的时候，我感觉我这个呃我这个这个这个呃有线的啊，我插上一根网线，要比我无线的这个网卡要快得多。啊，所以这个就根据他的工作模式这个特点来的啊，一边上传的同时能下载。

那么我们无线网卡啊无线网卡它就是属于半双攻的。好，暗装工。啊的特点。说。下载的时候。不上传。啊，下载的时候上传。哎，他不同时进行。所以有时候你在使用无线的时候让，你感觉哎它就没有有线的快啊。

网速有区别就在这儿。啊。那么我们生活中说我不接触网络，我有没有这样的例子，有啊，比如说这个单供的那他就只能干一件事儿是吧？那么比如说我们在家里头都用过收音机。😡，好。啊，收音机。Okay吧。哎。

这就是单攻的模式。你是不是只能接收啊，对不对？你可以调台。换台啊，但是。你只能听。啊，你只能听。Okay。Oh。你是听88。7呀，103。5啊，90。0啊是吧？哎，那半双攻的典型代表对讲机。要么你就听。

对吧听的时候没法说。对不对？啊。这边拿着啊，喂喂喂，冲A口冲A口。对吧，哎。你关了，他说。那么双宫的代表点化。对吧哎，你拿着电话跟女朋友吵架，你骂他，他骂你。啊。可以同时骂。对不对？好啊。

这几种模式简单的有所了解啊简单有所了解。好，那么他有一个工作模式，完了以后，这个网卡还有一个意思啊，网卡。Yeah。网卡在数据传输的时候啊，他还要做一件事儿。啊，那么就是协商机制。哎。

王凯在数据传输的时候，他有一个协商机制啊，所谓的协商机制，刚才说都建立在两台或两台以上的计算机上。

啊，比如说计算机一跟计算机二，他俩要说话啊，说计算机一新买的。啊，配置比较高。计算机二用5年了。啊。5年前的呢。他们俩的配置就不一样啊，说计算机一你这个网卡啊，你这网卡。对吧。

你这个网卡用的是一个什么呀？千兆网卡。哎，这网卡是千兆网卡。它是什么呢？它是一个百兆网卡。Yeah。啊，你处理速度是它的10倍。你十句话说完了，他刚说一句话。😡，啊，你收了1条信息了，他刚收一条。

所以你的你的速度比他快。😡，当这两台计算机他俩要进行通讯的时候啊，你说你发了10条数据。好，他发了10条啊，别十条，这十条得画一会儿呢啊。不行，还真得失点啊，要不你不好理解。哎。好。

说你发了十0条数据啊，你是千兆的吗？那你是它的10倍呀，对吧？好，那它不叫慢吗？对不对？那如果说按照这个逻辑，那你发十条，我只能收一条。那我其他9条不就丢了吗？😡，对不对？万一很重要的。啊。

你这正跟小姐姐表白呢，I love you呢啊，那后边这几条人没听见，那完了。啊，姐姐生气了怎么办？所以计算机在传输的时候，那他俩就往各两个网卡之间就会有一个协商机制啊，说你不牛逼吗？啊。

你一下能发1条，对不起，人家2号机说，对不起，我一次就能接一条。啊，说大哥，你等等我吧啊，要不一会儿你一表白，后边数据全丢了，那完蛋了，你就分手了啊。所以说这计算机一一听，哎呀，那你只能收一条。

我发十条，好吧，那我就。按照你的标准。啊，我往下降，我从千兆降到百兆。这样咱们之间我发一条，你收一条啊，说hello。啊。对，小姐姐直接就说。我同意啊，你说你这个没出息的劲儿，你怎么着，你也矜持一下啊。

是不是？啊，这直接就同意了，后边不用说了。啊，有来言有去语，一条一条的说，不至于丢。啊。对不对？哎，然后你接着说啊，我有车有房，父母双亡啊。哎，他又收到了啊。好，人家又发一条啊，我妈也同意。啊。

那你这不就搞定了吗？是不是哎？ううん。😊，这是一个协商机制啊，所以我们这些网卡，我们又称之为自适应网卡。

，啊。那么。为了让大家这个数据不能丢啊，咱们就来协商。比如说你是千兆的。啊。对吧哎，他是百兆的。咱俩商量一下吧啊，用咱们生活中的案例就叫木桶原理。啊，木桶原理。木桶原理是啥意思呀？

最短的那块板决定你能盛多少水。所以计算机他们在通讯的时候，如果是两台进行通讯，它会协商。啊，他会写商。那么这个所谓的协商机制。其实就是为了保证。兼容性。啊。就要保证它的兼容性。那么你这个高端的卡。哎。

他就可以。向下兼容。啊。这才能体现你高级啊，你能向下兼容，没有向上兼容的。你的100兆到头顶天了。啊，石勾圈K尖了，顶天了。啊。所以这一块啊，大家对于这种兼容的啊这种概念了解即可。啊，了解即个。好。

这是网卡的。

系列 3：P142：【Linux】交换网络 - 马士兵_马小雨 - BV1zh411H79h

好了，那么我们也有网卡了，咱们也知道他的工作原理了啊，说有他的工作模式了，咱也知道他有协商机制了。行了，咱现在开始考片吧啊，构成一个网络吧啊，那么我们常见的网络，这里头就给大家介绍叫交换网络。

。啊，交换网络。咱们在生产生活过程中啊，最常见的网络就是交换网络。

啊，刚才咱也画了，这就是一个交换网络。咱们通过一个设备，什么设备呢？交换机啊来进行。交换。啊，来进行交换。Okay。好，所以呢这个我们在学习的过程中，这个也是一个小型的网络。

好。哎，局域网。Yeah。啊，区域网。举个例子吧，在公司就有这样的小型交换网络啊，是局域网的。比如说咱们公司有开发部门。

🤧。财务部门。

。市场部门。

当然还可以有更多的啊，比如开发部门给他一个网络，小型的局域网，它是一个独立的网络。啊，你财务部门独立的一个小型网络，市场部门，一个办公室，独立的一个小型网络。啊，那么他们都是一个局域网。🤧嗯嗯。Oh。

好，那么通过什么呢？通过啊在这一个局域网中。张三。

李四。

王五。

赵六。啊。

这些个人。每一台主机。通过传输介质啊，通过网线。Yeah。啊，通过网线。

跟谁呢？跟交换机。Yeah。进行连接。啊。那么交换机啊，通过交换机这些人啊使用的计算机可以进行数据传输、资源共享，进行计算机之间的通信。啊。局域网。之间。主机和。主机。进行。

好。那么。😡，它是怎么样进行通信的呢？那么我们就得说一说交换机的工作原理。啊。交换机我们又称之为啊二层设备。啊，那么他是在OSI网络模型中。哎，七层网络模型中工作在第二层。啊，所以我们。

就给它称之为二层设备。啊。那么二层设备呢主要是通过什么啊来。进行区分。那这时候还是跟我们网卡有关系。啊，网卡有关系，我们我们在计算机的网卡。啊，会有两个地址。一个叫物理地址。一个叫逻辑地址。

。

啊，一个叫物理地址，一个叫逻辑地址。物理地址呢又称之为mac地址。逻辑地址又称之为IP地址。麦克地址啊。每一块网卡。啊。都不同。是全球唯一的。啊，全球唯一的。每一个厂家。啊。就是你这网卡每一个厂商啊。

大家都会。

相互进行区分。不重复全球唯一的。通常状况下。麦克地址。是不能被修改的。我说的是通常状况下。

啊。通常状况下是不能被修改的。那么有通常就有不通常。

啊。对于。网络安全相关的。专业人士也能改。

啊。Okay。普通运维的就算了，他们根本就不知道怎么整啊，但是我们能够去做。啊，那么怎么去查看呢？说我咋能查看我这里的这个麦克地址啊啊，windows下也能查看啊。

Yeah。windows下输入IP。Okay。啊。没有哈。杠A。啊。哦。然后我们在你的这个网卡这儿以太网适配器啊，你会发现这儿有一个物理地址。

啊，物理地址。

例如啊windows下。windows下你输入。IP configurefi斜杠O。

Okay。

，可以获取到麦克地址啊，那么在这里头有一个物理地址。

。

。

好，这个物理地址。啊。Yeah。十六进制。方式表示。啊，16进制数的方式表示。那么有几组呢？1234566组。

。啊。六组16进制数。

表示。分为6组啊。

。每组。有。两个。16进制数。构成。每一块网卡。

之间。的麦克地址都不同。

。Okay。

啊。你看我这一块，它是DC7196D9A1杠EC下一个就是00155D683C42。啊，每一块物理的网卡的地址都不同。

Yeah。好啊，记住啊，物理地址啊不能改。

好，然后我们的交换机啊我们的交换机。

那么他是怎么工作的呢？那么他就会记录。啊，咱们每一个设备就每一个主机的麦克地址。

哎，他会有一个麦克地址列表。

。他就是通过这个麦克地址列表来管理。连接在交换机上哪一个端口，你看这个交换机啊，这里头有多少多少口？

我们通常在企业里头啊能见到1六口的。啊，32口的。24口的啊48口的。

啊。那么然后它每一个接口。啊，有一个编号，然后这个列表哎就记载着你上边这个接口。比如说我01号口对应的是这个地址。啊。我0二口对应的这个地址。啊。

通常咱们见到的企业的这些交换机啊，企业交换机。比如说有16口交换机。诶。还有什么呢？比如说有24口。

啊。48口交换机。

一般呢24口的居多啊。十6也有48也有。

啊。一般这样的较为常见，它会把每一个接口啊，这上边每一个口对应哪个地址来找。啊。当你两台计算机要通讯的时候，说你发信息了啊，要想连接给他，那么这个数据发过来，经过交换机的时候。

这交换机就会去这列表里头去找。

看你是否在麦克地址列表中。

啊。比如说这一跟二通讯啊，那你发送的时候，他一找在这麦克地址列表，它对应的是2号口。那这时候交换机就会给你。

进行数据的转发，从1到22要想找一好，他发一条信息过来，那么交换机再次通过麦克地址列表去找啊，有就通过端口直接给你转过去了。啊，这是第一个通过麦克地址列表。

那么如果我找了一个计算机3。啊，找了一个计算机3，如果这个计算机三不在这个麦克地址列表中啊，那么我们的交换机，那么它就要通过它的广播域。

如果。主机不在。交换机的。麦克地址列表中。啊。那么就通过。交换机的广播域。啊。全网。广播。

。啊，所有端口他都发。就跟咱们过去村里头那大喇叭一样，广播村东头老王家那个小寡妇，今儿谁又给他挑水了啊，这这这这大喇叭广播去了，是不是？哎，当你找不到的时候啊，他就全网广播，所有端口都发送一遍。啊。

好，那我们今天呢啊关于网络的一些基础内容啊，咱呢就先说到这儿。

系列 3：P143：【Linux】网络速度计算 - 马士兵_马小雨 - BV1zh411H79h

啊，存储单位刚才说了位啊，然后呢存储在硬盘上，我们通常基本单位是字节啊，网络传输的单位啊，这儿我们先通过我们的假宽带给大家引入一下啊引入一下。Yeah。好，那咱们琢磨琢磨。

我们经常会看到这个新闻呢啊去报道，那报道啥呢？啊，报道说这个中国联通啊、中国移动啊、中国电信呢又被告了，说他们涉嫌虚假宣传啊，你标称的这个网速达不到啊。

，But。好啊，那我们说一说啊，那么通常咱们的网速啊咱们的网速怎么去计算呢？对吧？那么它也就是说你每秒传多少位或每秒传输多少个字节。啊。所以算完了以后，要么就是。啊，比特除以秒。啊。

比特除于秒秒是时间的单位，也就是说我一秒传输多少位。啊，一秒传输多少位？

还可以表示成。啊，比如说我也可以说一秒钟传输了多少个字节。啊，一秒钟传输了多少个字节。

所以可以写成。啊，比特每秒。啊，下边就可以写成字节每秒。Oh。啊。好，那么也就是说我们标称的这个100兆1000兆。那么它比如说啊我们来一个说100兆的宽带。

啊，100兆的宽带。

他相当于是什么呢？咱们就拿它为例啊。100。乘上1024。啊，乘上1024。然后这就转化成了我们叫KB。啊，KB。K比特。每秒。啊，K比特每秒。然后我们还要转化成什么呢？字节每秒。啊，字节每秒。

所以你是这么涣算过来的。那么你字节每秒，我们说了一字节等于8位，然后你现在拿出多少位了，反过来推多少字节。那在这个基础上，你再除以8。啊，你再除以8。

所以你100兆的啊100兆。

好，我们家这宽带，你随便算啊，你除以8。12。5。啊，12。5，也就是说你100MBPS这样的一个网速的宽带啊。

它最大的下载速度啊，理论上是12。5兆。啊，12。5兆。也就是说你标称的这个百兆的这个宽带啊，这标的是百兆的。实际上你的下载速度最大啊，这是理论上的，最大就是12。5兆。但是由于你的设备，由于网络。

也由于信号的衰减啊，所以约等于。啊。约等于10张。啊，那么这个算出来的这个是什么呢？

啊。这个就是我们下行的速率。什么意思呀？那你下载的时候的速度。啊。那么我们运营商在民用，也就是家用的时候，他会在这做了限制，说你下载是这么快，你上传没有这么快啊，你上传的速度约等于。

啊，约等于两兆左右。

，所以这就是为什么你在。😡，啊，家里头使用的时候，你觉得哎呀我下载速度挺快，但是你往上传一个东西，你就发现你很慢。啊。那么有这样的一个啊真实的速度在里头。所以最早的啊，如果你那个宽带要是512K。

那完了啊，那完了，那还不如现在这百兆的啊，你到千兆的也是这样。所以千兆的理论下载最多也就到百兆。啊，也就到百兆。但是呢随着你的设备人员等等等等，最后衰减一般的能达到九十来兆啊九十来兆。好。

这儿呢我们简单的给大家去说一说啊，我们去算这个速度啊算速度。好了啊。所以咱们宽带速率的单位啊。

。就是。BPS。RBPS。

Yeah。BPS的意思就是。BPS的意思就是。Okay。表示。啊。比特每秒。啊，比特每秒。啊，可以用。BPS来表示。

可以用。B。杠S这两种表示方式。

啊。

哎，每秒传输多少位啊，后边为了方便换算啊，每秒传多少字节。啊。

好，所以呢我们现在就知道了啊，你一照EMBPS。啊，这意思就是赵。照。😡，比特每秒。啊。

。照。😡，比特每秒。啊。

注意后边这B是一个小写的B啊和EMB。PS。

一字吃叉，这俩就不是一个意思。啊，这二者不是一个意思。Oh。后边这个叫做什么？这个叫做。照。😡，字节。每秒。啊，所以呢咱们中国联通用的是第一种方式，咱们中国所有的宽带用的都是第一种标称。

忽悠普通老百姓啊，你不懂，我人说100兆100兆是后边这比特，这是字节，这俩不是一回事儿。啊，这俩不会是一回事。

好，那么这里头会有一些换算关系是需要我们知道的啊。比如说我们一个字节等于8位。啊，一个大B等于8小B，这么表示没毛病。啊，那么。一亿比特每秒就等于。8。一字节每秒等于巴比特每秒。啊。

或1BPS就等于8BPS。

这么来表示。啊。那往深了说，哎，那我们进一下是吧？那有同学说，那我要1KB呢。

啊。1KB这就等于1024。啊，1024B。Yeah。啊。所以后边哎那要1KB每秒就等于。啊，就等于1024。B除S。啊，那再往下呢。

我们就写到赵就行了啊。说一兆。啊，一兆字节等于1024KB。啊，所以我们说的。哎。😊，以照字节每秒。啊，那这个就等于。啊，1024KB每秒。所以要注意下头这个跟上头这个啊，他可真不一样啊。真不一样。

🤧虽然都叫这个，但是下边的显然更快啊，下边显然更快。好了，这儿呢我们有所了解。即可。啊。🤧嗯嗯嗯。好，这是我们数据传输啊。那么在我们数据传输的时候，我们需要通过什么？我们需要通过网络协议。

啊，网络协议。那么数据是咋传输的啊，我们这还需要通过网络模型。

Okay。

系列 3：P144：【Linux】OSI网络模型上 - 马士兵_马小雨 - BV1zh411H79h

。🤧。好。Yeah。🤧哎呀嗯嗯。Okay。咱们用这个互联网的本质啊。我们互联网的本质其实就是一个网络协议。好。网络协议。计算机之间怎么才能说话，怎么才能认识那你认识我。

我认识你咱们每一个应用之间怎么来区分，都要靠网络协议来区分。所以说呢一个应用啊，那它需要有网络协议的支撑。啊，网络协议的支撑。那么网络协议就规定了说啊我。在传输数据的时候，我有一个规范。

你在传输数据的时候有一个规范。那么这个传输数据的这个规范是由谁设定的？啊，由谁设定的，肯定不是我设定的。啊，肯定不是我设定。那么他是由谁去做的呢？啊，那么我们有一个叫做国际质量体系啊。

翻译成英文就是ISO。咱们经常听到有一个什么ISO什么9001什么9002认证。啊，那么这个ISO就叫做国际标准化。组织。由他们来制定。Oh。国际标准化组织就是全球的。啊，所有国家。统一的一个规范。哎。

举一最简单的例子，他在咱们生活中有没有影响？有RG45RG11。嗯。啊，RG45RG11。这个就是最简单的一个规范啊，它约定了什么呢？约定了咱们这个网线。水晶头。Okay。Oh。都长这样。啊。

你到日本了，你拿这网线插上也能用到美国了，插上这网线也能用。好，那么一说到网络传输的时候，这一块呢相对来说较为复杂。那么他一开始啊啊他是为什么呢？就是为我们网络开发准备。那么我们在运维的层面啊。

咱们这些同学，你其实到三层就没了。你玩的就是三层以下的这些设备。啊。如果真的开发的话，OSIIOSI的7层网络模型都要用得到。啊，都要用的呢。所以呢全球的这个国际化标准组织，人家就制定了一个叫做。啊。

开放。开放式。系统互联。啊，这样的一个模型。Yeah。🤧好，翻译成英文就是open system。Interconnect。Okay。啊，他们这帮人没事儿干，在这坐着啊，制定出来的。一个模型叫这。

简写成OSI。啊。被称为。O赛。model。🤧嗯。好。这就是大家说的OSI7层网络模型啊，在这儿。他怎么来的？在这儿。啊。那么这个OSS7层网络模型，它都约定了什么，有哪7层？啊，有哪几层？好。

这个网络模型啊，首先第一个它制定了什么，制定了所有的硬件标准。啊。所以第一层。硬件你不就是玩物理设备的吗？所以第一层又称之为物理层。Oh。啊，物理层。那这个层面啊就规定了很多的标准规范RG45。啊。

RG11。典型的啊这些个规范。那么还有一个组织啊。也是美国的啊IEE。啊，比如说802。2。对吧比如说为什么我们这里头插上这个网线以后啊，这个东西叫以太网，它为什么不叫别的？

诶。因为这些东西都是因为已经在这里头做好了规范啊，所以大家看到的。

ETH。啊，ETH。那么有很多的虚拟币。叫做以太坊，如果加上net就叫以太网。啊，你太晚。好，那么在这一层其实就有这么多的东西。🤧哦。Oh。Yeah。好，光有它也不行。那么在这上边的基础上啊。

我们要通过传输介质，把分布在世界各地的各个地方的计算机相互的连接起来，连接起来咱要干啥呀？啊。我们就要传输数据。那么传输数据的时候，我们要做的一件事儿就是构建了数据链路。所以第二层又叫做数据链路层。啊。

第三层。🤧うんうん。第三层。那么在你构成数据链路了，就要传输了。在你第三层，我们称之为网络层。啊，网络层。🤧嗯嗯。我要给你发数据，我通过什么原理发。啊，通过什么原理吧？对吧好，一会儿我们再解释啊。

第四层。传输层。第五层。绘画层。第六层。表示层。Okay。好，还有我们。跟用户进行接触的第七层。应用层。🤧嗯嗯。这七层啊。Okay。Okay。好。Oh。Yeah。Oh。🤧好。

每一层都具备有相应的标准和规范。Oh。好，由下往上我们说一说。啊，由下往上，我们说一说。🤧Yeah。好，第二层有什么？啊，第二层在构建数据链路层的时候。比如说我们这里头啊ARP协议。

那为什么我们在搞邪恶的时候说ARP协议很有用啊，能让你断网攻击啊啊，在这个数据链路头。啊，通过ARP协议，我们可以。🤧嗯嗯。做地址解析协议啊，它就叫。地址解析协议。啊。非常有意思。啊。

那么还有很多在这个数据链的链路层的，比如说。CDP。啊，CDP我们经常听说有一个设备公司啊叫思科公司。哦。Yeah。CDP协议。美国的网络通信巨头。啊，那么这个协议呢又称之为。思磕。发现协议。Okay。

斯科发现协议。啊，那么在这个二层呢还有很多啊，比如说我们的VPN啊。VPN。VPN呢大家应该了解到说有一些朋友啊想这个上网打鱼访问谷歌。啊。对吧。哎，谷歌你就有。啊，你看人家谷歌多坏呀。啊。

美国人可坏了。一艘疫情咔机中国给你排第一，其实美国挺高的。啊，让普通老百姓一看，我就靠这这中国。这么多人啊排第一，其实美国人多。好。好啊，VPN那VPN在这块呢，就咱们说的说的啊说的说的。

那么这里头呢就要介入到了你要构建虚拟的数据链路。所以说呢这里头VPN就有PPTP协议。啊，VPN里头还有LRTP协议。🤧嗯。啊。还有什么呢？还有L2F协议。啊。那么这个协议又叫做第二层。转发协议。啊。

还有什么呢？还有ATMP协议。啊、接入隧道。接入隧道。管理协议。Okay。Oh。所以如果真正的我们要把这个网络协议学明白了，我跟你说呀。啊。你给我俩月。我们不讲别的。咱就讲这个。都不一定能够啊。哎。

这里头太多了啊。那么还有很多啊数据链路层的一些协议，比如说MPLS协议。啊，比如说叉TP协议。比如说DCAP协议。啊，比如说SLE协议。啊，比如说。IP音IP协音。Okay。啊，都是哪制定的？

都是刚才我们说的啊，这个组织。制定。好。我给你标一下啊。哪些需要你？了解了。Yeah。哎，大家学习起来没有啥负担的啊。Yeah。好，这些个协议你就听我一说就行了，你就累我一个啊。

你就累傻小子一个就行了啊，您不需要有太多的负担，我就给您介绍一下啊，让你呢开拓一下演技。那么这个MPLS协议是什么呢？就是多协议标签。交换协议。嗯。啊。叉TP协议。

我们经常在用arthink全网备份的时候看到了一些参数啊，有同学说那压缩传输它咋压缩的？啊，是他自己跟这打一包吗？在传输过程中数据链路层的时候，那么他要通过传输协议，这个叉TP就是压缩传输。协议。啊。

压缩传输协议这些事儿其实在你运维的过程中，你看不见，通过操作系统底层sockit啊。链接在这里头编程实现的。哦。啊，编程实现。对吧哎，等你有时间啊，将来参加我们周末班网这个周末班或我们的网课的时候。

我在周末班会给你讲更深层次。比如说我现场给你写一个。啊，网络服务器端客户端哎，这边发一hello服务器能收到，咱们就通过编程编码看底层操作系统底层是咋回事。啊。好，DCAP协议。啊，叫什么呢？

叫数据转接客户访问协议。哦。SLE协议。啊，ISSLE协议。串行的。连接封装协议。好，IP因IP那就是IP套IP。封装协意。好。好，这就是咱们数据链路层的啊，我简单的呢给大家说一说，那么数据链路层啊。

数据链路层它主要要干一件啥事儿？啊，要一概念就是做物理寻址，同时将原始的。刚才我们说了，这叫啥呀？传输速度这儿啊。啊，每秒传多少个比特是不是啊？那这东西就叫做比特流。啊，比特流。转变为逻辑传输的线路。

Oh。好，描述一下吧，物理层就是机械。电子。定时接收啊定时接口。通信管道。通信应该叫信道是吧？哎，通信信道。啊。通讯信赏。上的原始比特流。开始。啊。好啊，第二层就是物理寻址。啊，物理心智。同时。将。

原始。比特流。转化为。逻辑传输。线路。Oh。啊，逻辑传输线路。第三层网络层啊，咱们做运维的朋友到这儿就得了啊，所以说啊你要跟人家去做开发的去扯，人家就说啊你。玩的这设备就带三趟设备，路由器就再见了。啊。

那么这个三层网络这一块啊，它有哪些协议呀？哎呦这个东西就。多了，咱们说说路由器啊，路由器它里头有芯片，它也有自己的操作系统。所以路由器里头有OSPF协议。Up。好。Okay。那这东西干啥的呀？😡，啊。

它叫做开放最短。裙止。啊，应该叫最短路径。优化协议。Okay。诶。啊，还有很多啊再举个例子，比如说VRRP协议。VRRP协议。那叫什么呢？虚拟路由啊，虚拟路由器冗于协议。啊。还有很多啊还有很多。好。

还有什么呢？啊，比如说IGIGRP协议。Okay。啊。内部。网关。啊，路由协议。好，还有什么呢？哎，我们明星该闪亮登场了，就是我们的IP和IPV6协议。好。好。啊，就是我们经常说的IP协议。叫互联网。

协议。那么V6指的是版本啊，后边写的V6就是。互联网协议的第六个版本。啊。那你见到了IPV4。第四个版本第V6第6个版本。啊，那比如说我们。在windows下。啊。我拼一个百度。Oh。我操丢人了。

百度打不开是吗？🤧嗯嗯。Okay。Yeah。

，我开着VPN呢，我找一个啊。3W点儿。百度。Oh。啊，那我们听百度以后，这儿有1个ICMP啊ICMP所以呢。

哎，在我们这一层。还有。ICMP协议。Oh。ICMP。啊，那么ICMP协议是什么呢？互联网。控制信息协议。啊，通常我们用拼命令的时候。就会有。好啊，当然了，还还还可以有啊还可以有。

所以说呢我们简单的给大家介绍这么多啊介绍这么多，这个呢是啊。我们这里头有的数据啊，其实还有还有再说一个吧，NHRP。Yeah。啊，NHRTC。因为将来有可能有一些人去做网络了啊。

所以呢我们这儿呢给大家说两嘴啊。吓一跳。啊，吓一跳。解析协议。好，当然了还有更多啊，我们这里头呢就呢暂时给大家介绍这么多啊。又11点20了啊，下课休息会儿啊。

系列 3：P145：【Linux】OSI网络模型下 - 马士兵_马小雨 - BV1zh411H79h

🤧T。She。好啊，我们看看第四层啊，传输层呃，第三层啊第三层解释一下啊，他主要干了啥啊，他主要干了。控制。子网的运行。啊，子网的进行。比如说逻辑地址。啊，这里头逻辑地址也就是IP地址。

因为你有IP地址协议嘛，对吧？IP协议啊，逻辑地址的。啊，逻辑地址还有什么呢？比如说这个分组。分组传输路由选择。都在这一层来完成。嗯。Yeah。好，第四层啊，传输层。

那么传输层呢这一块啊啊主要就是我们客户端和服务器端，它在建立连接的时候，是用TCPIP协议来建建立的啊，所以传输层这儿我们知道的典型的啊典型的。这些个。谢意啊，你比如说呃我们的。

这个这个这个TCP协议啊，IP协议啊，比如说。我们的。这个。嗯，我想想啊，说点啥呢？我们windows啊大家在用的时候呢，经常能看到，我看看我给你找一下啊，咱们找一个。

好。好啊，比如说我们这里头有一个叫netbels啊，netbellls。这里头的协议啊就在我们的第四层的传输层。那么它主要用于什么呢？啊，咱们第四层它就是接受第五层啊上一层的数据。啊。在这里头呢。

他进行一些数据的分割。啊，然后把这些数据交给下边的网络层，然后保证了这些数据啊有效的啊到达。所以呢这个在中间的时候呢，这些协议呀啊我们。

简单的跟大家说几个啊说几个。那么这里头比如说刚才说的啊。Metterbellls。啊，协议呃，那还有什么呢？比如说呃。呃，比如说我们这里还有mobil啊。No mobile IP协议。移动IP协议。啊。

移动IP协议。嗯。还有什么呢？还有比如说叫啊RU啊RUDP。啊，RUGP。叫。可靠的。用户数据。啊，豹纹啊。协议。还有什么呢？还有呢比如说TALI协议。那么就是传输适配。层。接口协议。啊。好。

还有一个啊还有一个叉OT协议。简单的介绍几个嗯，够我们了解了。那么就是基于TCP协议。之上的。啊，X点。25。协议。Okay。Okay。啊。Okay。好，传输层啊。接受上一层。的数据。在。需要的时候。

分割数据。啊，分割数据。然后。并将。这些数据。传输给网络层。啊，在这儿进行传输。第五层绘画层啊。那么绘画层这块呢，它就是不同的。主机。用户之间。建立。啊，以及。管理绘画。Okay。Okay。

干这个事儿的。啊，那绘画层呢啊那么有哪些协议呢？这里头的东西也多了去了啊。绘画层，比如说我们将来做网站的时候啊。哎，做网站。SSL协议。

那么大家在访问一个谷歌的时候，你会发现前边有一个小锁，你看。啊。那么还有的网站没有锁显示不安全。

啊。有的网站都有锁，那么有锁的这些呢，就是我们配备了啊我们配备了啥呢？我们配备了SSL协议啊，它叫做什么呢？它叫做安全套接字。

啊，安全套接字。也就是说我们在使用一些较为安全的网站，上边有小锁啊，安全套接字。从。け。Yeah。哦。那么还有什么呢？还有TL。啊。TL协议。传输层安全协议。Okay。好，那么还有我们什么呢？

比如说DAP协议。哦。叫目录访问协议。Yeah。LDAP。啊。轻量级的。目录访问协议。Okay。Yeah。啊，轻量级的。目录返问协议。那么在这里头啊还有啊还有。那么呃比如说我们远程控制啊。RPC协议。

啊。远程。过程调用。协议。好的好。啊。我们简单的在这儿给大家说这么几个啊。嗯，还有往上啊表示层，那表示层它是干啥的呢？它就是信息的语法语意。啊。以及。他们啊以及这个这个。诶。以及他们的格式。啊。

以及他们的格式。比如压缩的。啊，加密的。解密的。啊。还有什么呢？比如说嗯转格式啊。转额是。要格式转换。啊。压缩解压缩啊。到就在这儿。还有一些呢是编码。Yeah。好，表示层一般的说在这块咱们呃。常见的。

协议啊有。但是呢我觉得呢这一块呢，大家呢其实可以呃不用着重的去呃去记忆它啊。嗯，第七层第七层应用层应用层就是咱们操作系统上，大家装的这个微信呀，QQ啊，你能看到的啊，它都到应用层，就是各种应用程序协议。

啊。比如咱们HTTP。FTPSMTPPOP3。对吧SSH。啊。Oh。等啊这要一说，这里头东西多了去了啊。好。HTTP协议。啊，咱们访问网页都要靠这个。啊。HTTPS。对吧哎，他们都是一家的啊。

FTP协议。搭1个FTB下载站点。啊，SMTP。啊，POP3POP协议这种东西是邮件的。啊哈。对吧哎，SSH协议。啊，加密的隧道的远程连接的。啊，IMAP协议。也是邮件的。啊，还有什么呢？还有tnet。

啊。tailelenet协议。比如说远程连接的。啊，跟SSH协议一样。比如说我测端口通不通的等等等等都可以啊。包括呢我们log in。啊，远程连接协议，这都是。啊，包括呢我们看到的将来看到的DHCP。

啊。包括我们后边要学的。NTP。啊，我们做时间同步的。对吧哎。等等等等。这里头还有很多啊。Okay。Okay。好。Okay。好，那这样的话呢。

我们就把OSI的7层网络模型啊啊简单的给大家呢做一个呃介绍啊介绍。那么这个模型中啊这个模型中，那么他这个用户我们在使用的时候。

说。😊，这台计算机如果和右边的这台计算机进行通讯的时候，实际上啊那他们在建立连接这个过程中。他们俩的模型是一致的。啊，他俩的模型是一致。好，咱弄一个啊，把这个模型咱说一下啊。好，最底下的物理层。

Yeah。啊，数据链路。好，数据链路层啊，网络层。Okay。Yeah。传输层。啊。然后上边是什么呢？绘画层。表示层。应用层啊，那么你左边这台机器啊，左边这台机器你在发送数据的时候。Yeah。

跟右边啊这台机器。那么比如说他在建立的连接的时候，每一层都是对等的。啊，左边是啥样，右边就是啥样？好，这个是我们简单的啊给大家呢介绍了一下。我们呢。OSS7层网络模型。这块啊大家呢要把它。

呃，记住啊，那么在传输层哎传输层上啊，刚才我说的TCP啊，UDP协议。咱们念走了，没往上写啊，那么实际上这个东西。是重要的啊重要的。好，那么我们看下来这七层网络模型是非常复杂的。啊。

真正在编程的过程中说你这个这个理想确实做的挺丰满的啊，但是现实呢有时候挺骨感。那程序员再要你。

系列 3：P146：【Linux】TCPIP模型上 - 马士兵_马小雨 - BV1zh411H79h

的话那就疯了。那怎么办呢？哎，那么我们就需要把它简化一下啊，我们就需要把它简化一下。那么简化到什么程度呢？就把这七层网络模型啊给它变成TCP啊，IP的网5层模型。

。Yeah。

啊，TCPIP网络模型。

那么咱们这些程序员啊，为什么要给他简化一下懒呗啊，你天天的都这么写，那谁受了啊，对不对啊？写写的疯了，为什么这个这个这个这个。嗯这个程序员这个对吧？头发都不富裕啊，是不是啊？那你要老这样的话。

写写的就疯了啊，确实是啊。对吧所以说呢我们在哎使用的过程中啊，这些个。这个咱们这些个这个程序员呢啊在使用的过程中，我可以不完全遵照你啊的这种方式。我对它进行简单的优化啊。

那么对于7层啊就可以呢给他来简化简化。电话电话。所以在TCPIP网络模型中啊，这也是我们在面试的时候经常容易被问到的一个内容。啊，经常被问到的一个内容。那么上来以后比较经典的问题啊。

那就是TCPIP协议。他们在建立连接的时候啊，这些。模型以及建立这个连接的过程。所以经常会有些人啊上来就问你说TCPIP协议熟不熟悉啊啊，你说我会会完了以后呢，人家就开始深层次的去问你。啊。

那么实际上呢，他还是把这几层。啊，放在一起，只不过对于这些个层的叫法啊。划分用法发生了一些变化啊。嗯。那么这里头的叫法和用法呢不一样啊不一样。那么这个。

也是因为什么呢？在国际上也没有一个特殊的准则啊，说规定它到底应该是怎么着。啊，所以说呢你在看一些文献的一些资料啊啊。那么有说的是三层的啊，有说四呃，不是有说这个这个这个这个四层的啊，也有说五层的。啊。

有说四层的，也有说五五层的。那么我把这个两种模型呢，我都给你说一下。啊。

Okay。这个东西呢它容易打架。

啊，容易打架。啊，人家说我做五层的那你有五层的道理是吧？我做四层的，有四层的道理啊。好，咱先说说五层模型，人家是咋说的啊。第一层。啊，第一层。那么还是把你的物理层拿这不变。啊，第一层还是物理层隔热不变。

啊。第二层啊第二层。

数据链路层也不变。Okay。数据链路层。好，这又有一个数据链路层，在这最下边的基础，这儿没有发生变化啊没有发生变化。那么在哪儿发生变化了呢？啊，在哪发生变化了呢？在我们上边的这个应用层表示层绘画层。

你看咱们七层网络模型是吧？哎，应用表示绘画啊，那么所以说它在第五层做了一个调整。那么第五层它还叫做应用层。

啊，还叫做应用层。但是他这个应用层，他就把七层模型中的应用层。

表示层。

绘画层。啊，他把这三层搁一块儿了。

Yeah。啊，他把这三层搁一块儿了。那么我们这个第三层还对应着啊这东西叫做什么呢？网络层。啊，网络层。第四层它还叫做传输层。嗯。那你现在你看这4加3，其实还是7，它只不过把它换了一种表示方式。

啊，换了一种表示方式。

嗯。Oh。好，12345啊，说五层的，人家就基于这个理论来分的。啊。好，说四层的啊，人家四层的这儿玩的更狠啊，四层的呢就是掐头去尾。你上边五层的实际上就是把头部的这些玩意儿给合并在一块了啊。

那你说四层的呢，那更狠。他是把。啊，物理层。和数据链路层，这俩他觉得哎呀你这俩我都可以放在一块儿。

啊。他把这俩给放在一起了。啊啊。然后把他们俩放到一起，起一个名儿。叫做网络。接口。Oh。Yeah。这就是往这一坐吃饱撑的，没啥事儿干啊，就老天搞事情。是吧哎，搞了一个网络接口层。啊。那然后呢。

你你你你这就占了两层了，是不是啊？所以那就向下减一呗啊，那这就是网络层了啊，然后呢这儿呢就是传输层了啊，这儿呢就是应用层了。

啊，这么算1234啊这么算12345。

。好，那我们就通过啊这两种说法，咱都给他介绍了啊。那如果呢到了这单位里头，人家要说哎呀这个TCP是四层网络模型。那你马上对应的我说的这底下这种人家要说五层模型的那你就对应的我说上边这一种啊。

你不要跟人家白话，你说你个傻狍子四五层，你搞不明白，这叫法没有定啊，咱两种都说了。那关于网络模型这一块啊，TCPIP的OSI的咱就都说了。

系列 3：P147：【Linux】TCPIP模型下 - 马士兵_马小雨 - BV1zh411H79h

说他分了这么多层啊分了这么多层。那么主要就是让我们去了解什么呀，去了解呀这个网络协议的。

啊，去王络。

sorry啊，我接个电话。

系列 3：P148：【Linux】网关介绍 - 马士兵_马小雨 - BV1zh411H79h

网络模型中啊它体现出来的重要的信息，那就是网络协议。啊，那我们得说的说的网络协议。那么咱们最常见的网络协议。首先第一个啊，最重要的咱就得先学IP协议。Okay。IP协议干一件啥事儿？

他给咱们提供IP地址的，如果咱们不说IP协议，咱就没法往后讲IP地址。啊，所以通过IP协议，我们的目的就是咱要学IP地址了啊，那么在这上边右键点。

啊，右键点windows现在弄的怎么？

点详细信息的时候，你就能查看你本机啊。

的IP地址。啊。

那么有IPV4版本的和IPV62个版本的。

Okay。哈。那还有一种方式呢，如果在linux下啊，我们可以通过。IPA。的方式啊来获取IP地址。如果在snoOS6的系统下，可以通过IFconfi。啊，一样能获取到IP地址。在森到OS7上。

可以通过IPA的方式获得IP地址。啊。那么如果你在centOS7上，你输入if configure啊，没有或提示command not found怎么办呢？你需要ymin store杠外啊。

n tools。就是我们在安装虚拟机的时候，你有一些安装包没有选齐。啊。通过yminstore杠外net tools可以啊去安装。

Clock。好，那么这个IP协议啊，它重点的体现就是IP地址。啊，IP地址。啊。那么IP地址。Yeah。就是。IP协议提供的。啊，一种统一的。地址格式。啊。统一的地址格式，那他是干啥的呀？

IP协议是干啥的呀？他就是给咱们互联网上每一个网络中的每一台主机分配一个逻辑地址。啊，分配。一个逻辑地址。啊。所以IP地址也叫逻辑地址。Oh。哎，IP地址也叫逻辑地址。所以我们在讲交换机原理的时候。

我们就多次的我给大家提到了啊物理地址和逻辑地址。那个词候就是为了咱们现在讲这儿打着埋伏。2。哎，那么这个逻辑地址。啊，干什么呢？说乙。😮，用来屏蔽。物理地址。啊。屏蔽物理地址的差异。

这里头我们知道物理地址就是麦克地址。啊。每一个机器。都有一个编码，不带重复的。啊。那么正是因为大家都不重复，那么我们如果。啊，如果用那12个是吧，十六进日的字符表示我们的可读性很差。

所以我弄了一种大家都能够读得懂的一种方式。아。加强。可读性。就干这个的啊，那12位的那东西记起来比较麻烦。啊。Okay。对吧如果让你记1个IP地址，192168啊，0。1，你马上就记住了。

我让你记这个数，好家伙，你背5分钟可能你记不住啊，所以咱们出这些东西就是为了加强这些的可读性。这样的话。啊。不好记。啊。哎呀，有的同学好家伙要没学过英文，这字母还不认识，是不是啊哎，可读性差。好。

我就是为了屏蔽这个差异，我弄了一个可读性比较好的。啊，比如192点168。点0。1，哎，记住了。哎，那你就记住了，是不是啊哎，非常好记的一个东西。好，那么这个IP地址啊，它还有啥呢？啊，那么是32位。

啊，32位。二进制数据。啊，32位来表示。啊。分为四段。每一段那就是8位。啊，8位。如果是8位的话，它最大值是多少啊？啊，是256。啊，256。那么就是用0到255来表示。还是取值范围哈。Oh。哎。

通常。是以。十进制的方式。表示。所以你看这个数啊，192168是吧，哎，192。168。0。一啊这些数都是数字啊十进制数。中间用点格开。每一组。中间用点儿。啊。符号隔开。一个地址。

就表示网络中的一个主机。主机设备。啊。这里头的主机设备可以是。路由器。可以是。PC可以是服务器。可以是手机。啊。可以是摄像头。可以是智能门锁。啊，可以是电视。等等等等。那么凡是基于。

TCPIP协议的智能设备。都可以。被分配。IP地址。啊。啊。手机。啊，对吧能上网的，还有什么智能手表等等等等啊。那么这个东西都加一块儿，它叫做什么？这个东西就叫做IOT。啊，叫物联网。

就是所有这些玩意儿都能上网了，这东西就叫物联网。好。Yeah。好。Okay。好啊，这个就是咱们给大家介绍的啊。那么如果在一个局域网中。啊，在。同一个局域网中。啊。也就是说，本地啊本地局域网。IP地址。

是唯一的。啊。啥意思？就是咱们在一个网络的时候，在一个网段的时候，1个IP地址只能分配给一个主机。啊，你们俩不能都用一个。对吧比如说192。168点点0。1。啊，100。他不能同时分配给一个手机。啊。

再给一个ipad。这种方式是不对的啊，如果你手动去给的话，那这时候就冲突了。Oh。啊。就会有其中一个上不了网。所以一台主机就是一个啊192。168。0。100啊，那这时候我们就给的是亮的iphone。

11。pro肉 max。啊，然后下一个你再给。192点168点0点101。你给。亮ang的。IPad。Pl。啊。就是他们的这些设备啊要有所区分。一人就是一个，咱别重复，你干你的，我干我的啊。

不要重复重复就上不了网。好，这就是咱们说的啊，IP地址啊IP地址。那么这个IP协议啊IP协议。咱也说一嘴。啊。那么就是什么呢？反过来理解它就是网络之间互联。啊，网络之间互联的协议。啊，咱俩连接在一块儿。

啊。你看那个这个这个这个咱们呃开这个奥运会的时候，那个刘欢唱那个我和你啊，那说的就是咱的网络啊，我和你心连心嘛，说的就是IP协议啊，同度济球村嘛，我们在同一个网络里。啊。

对吧所以呢这个IP协议呀说的就是啊网络之间的互联协议。啊，他是咱们所有的互联网。啊，互联网。包括物联网。Yeah。包括物联网。的。😊，所有计算机网络。实现。相互通信的一套规则。啊。

说不光是你这些服务器啊，不光是这些。IOT那些智能硬件也都要遵循这套规则。啊。那么它规定了什么呢？那你规则你就得有规定啊。他规定了计算机在。啊，网络中。进行。通信是。应当。遵守的规则。哎，简单的说。

任何的这些啊IOT的设备，计算机服务器，只要遵守了IP协议，就可以与因特网互通互联。啊。所有设备。只要是。遵守IP协议。啊，就可以。在网络中。互联。互通。Yeah。你看看是不是这样的。

你现在手机如果连上你的摄像头，是不是哎，可以啊，手机能联网，摄像头也能能联网。啊。好啊，那么我们简单的呢就给大家介绍了一下这个IP协议啊。那么IP协议里头我们刚才说了。啊。

那么有IP协议来给他分配IP地址。哎，IP地址。有了IP地址完了以后呢，我们就可以进行相互的通信。啊，通信。好，然后我们还有几个概念啊，说光有IP不好使。啊，那么还有一个概念呢，叫做什么呢？叫做网关。

网关其实就是路由器。啊，路由器就是网关。Oh。啊，网关就是路由器，路由器就是网关。啊，尤其是在windows下。windows下默认就叫网关。啊。网关就是路由。陆游就是网关啊。不要蒙。那么他是干啥的啊。

所谓的网关其实啊就是一个网络。啊。通向。网络通向其他。啊，网络的。IP地址。啊。嗯。啊，所以我们比如说。咱们从一个地方到另外一个地方，从一个国家到另外一个国家。这个啊你在出国的时候是吧？哎。

我们一般的都称之为什么呀通关。啊，你从一个地儿到另外一个地儿。那么网络里头我们好比是啥呢？说你从A网络。啊，进入到B网络。哎，A网络进入到B网。啊，那么网络A的IP地址范围。

对吧有一个网络B的地址范围有一个。啊，那么如果从A到B。对不对？是不是我们就完成了？网络的通信。是不是哎，从一个网络数据到另外一个网络的数据啊，所以A如果是一个路由器的话，那它就代表了一段网络。

B是一个路由器，哎，它就代表B的一段网络。那么A就是A网络。到网关。B就是B网络的网关。啊。那么网关的IP地址一般是有特色的啊，你比如说192点168。0。1，哎，可以是一个网关地址，底下这个是172。

16。0。1OK那么上边是A网络的地址，B，下边是B网络的地址啊。他们两个。他们两个。啊。表示不同的网络。Okay。那么除此以外，我们在企业上啊在企业工作的时候，我们实际上还有另外一种表示方式。

那么我还可以用192点168点0。254。Yeah。下边还可以用172点16点0。254。啊，所以网关的特点在这个IP地址里头，我们通常可以掐头去尾。Okay。啊，掐头去尾。要么就是尾巴这占一个。

要么就头上占一个啊。所以如果你到了一个公司以后啊，你输入你要想看一个网关是吧？输入点0。1不好使的时候，那你就输点254。那么怎么判断我在哪个网关里头呢？那还是比如windows吧啊。

你看你这个网卡，你状态，你查看点详细信息，这里头就会有一个默认的网关。啊，这里的写的是192168点1点1，这就是你路由器的地址。啊，路由器的地址。所以说默认网关就是路由器的地址啊。

系列 3：P149：【Linux】OSI7层网络模型数据传输的过程 - 马士兵_马小雨 - BV1zh411H79h

好，OSI网络模型数据传输过程啊，说我们这数据啊从这儿传到那儿它是怎么一个过程。这个你必须要知道啊，为什么我们要介绍这样的模型，它实际上跟我们数据在网络中啊，在传输确实是有关系的啊。好，那我们画个图啊。

帮着大家呢一块来理解一下。

。Yeah。啊，一块来理解一下啊。那么。大家呢跟我一块儿啊大家跟我一块儿嗯，在这个我们的嗯群里头吧啊在我们的QQ群里头，大家呢可以把这个7层的模型啊来说一说我就不点名了啊。用哥吧。勇哥勇哥。

永哥家停电了是吗？啊，勇哥家停电了，看谁呀，换一个。啊，靖哥郭靖在吗？Oh。好啊，回答正确。那么在这里头啊那么我们自下而上的啊这7层。那么最底下呢是什么呢？就是想我们的网口，我们的网卡。

所以在物理层啊物理层。Okay。在它上边呢是什么呢？就是我们的麦克地址啊，就是要建立数据链路。啊，所以是数据链路层。啊。然后呢，再往上呢，哎就是第三层，你就想啊，谁在这儿工作呀。

路由器在这工作路由器的工作原理是啥呀？那不就是IP协议吗？IP协议呢就是网络层。嗯。哎，这就是第三层。啊。第四层呢对吧？那你有网络了，上边呢哎数据传输，所以叫传输层。啊。那你靠啥传输的呀？

那你靠ITCPIP协议啊这些东西进行传输的。那再往上呢，那就是哎绘画层啊。再往上呢，那就是表示层。啊。再往上呢就是应用层。好，我把他们大概的捋一下啊，大概捋一。好啊，分层吧。Okay。Yeah。好。好。

首先第一个啊，通过这个例子，我们说什么啊。通过这个例子，如果我们两台主机相同的应用啊在进行数据传输的时候，它每一层都是对等的啊。

物理层对物理层数据链路对数据链路网络对网络传输对传输绘画对绘画表示对表示应用对应用，它每一层都是对应的。那么我们如果从一个机器向另外一个机器发送数据的过程中，那么它到底是怎么样的一个过程呢。啊。

我们一块儿来看一下啊。它的底层原理就是自上而下。好。自上而下。啊，我一层一层的进行处理。啊，这就是主机A。这就是主机B。说我A想跟B发一个数据啊，他发了一个啥呢？姐姐约吗？啊。哎，那你要想传送给别人。

实际上我们看到的是人家微信上嘣弹出一条信息，但是底层的原理它可不是这样的。啊，他是这样干的。啊，比如说我们用一个。哎，用一个方块，我们表示这个数据。啊，我们表示这一条数据。大家都知道啊，那你这个应用层。

那么这时候他是不是哎就得把这条数据先放在我们这里头，是吧？啊，当然这条信息会被处理成二进制数据啊。But。好，那这一条啊，它就是一条数据。Okay。Yes。Yeah。好，他在应用层啊。他在应用层，那么。

开始啊一层一层的进行传输。那么这条数据我往上画一点啊，往上往上画一点。他到了应用层以后啊，那他做了一个什么样的处理呢？说这条数据往下走。到了应用层，咱们对应的在应用层。啊，然后在应用层的话。

那么他就给他加了一个豹文。啊，加了一个应用头的报文。Go。干不。应用。层的头部。啊，头部。Yeah。Oh。好，这个过程就是一个封包的过程啊，说我们一个小姐姐约吗？这条数据哎。

从OSI7层网络模型往下走到应用层的时候。啊，到应用层的时候，这时候就先加一个应用的头部啊，头部，然后再往下走。再往下走。啊。到表示层了。Oh。到表示层了呢，这时候啊他再给他这条数据，咱们再往下走啊。

Yeah。好，到了你表示层以后，这儿又加了一个表示层的头。Okay。对吧哎这儿又有啊，那他继续又往下走了，那又往下走了呢？😊，这回呀都到绘画层了啊，那么绘画层这儿，他继续把这条数据。处理。Yeah。

Good。好，那这个就是啥呢？哎，这个就是绘画图啊。它每下一层哎就多加一个啊头部信息，就是这就是封班啊，往下走。好，到传输层了。哎，再来一个传书层的。投信息。Yeah。Okay。Oh。Oh。好。

继续往下走啊继续往下走。就到了我们的网络层了。Okay。Okay。网络层呢，那他还是啊说你。下来。加一个网络的啊网络的头。Good。Yeah。Okay。

。好，那网络子走完了啊，接着再往下。😊，一层一层的啊添加这个封包。Yeah。Okay。数据链路。从。头。啊。最后到你这个物理层。Okay。Oh。Oh。Oh。は。好啊，这条数据你看从你发出去到下边啊。

它一层一层的加缝包，多一层多一层多一层多一层多一层啊。最终这一条数据。通过你的网卡。啊，通过你的网卡，然后实现了。啊，你这个数字信号。像电信号这样的一个转变。然后顺着网络。Oh。Oh。好。顺着网络啊。

把这个信息发出去了。当然啊这里头是双向的，你能发，你也能收。这就是传输介质。啊。然后。这条信息通过这样的一个封包啊，通过网络把数据传走了。Yeah。Oh。哎，然后呢发到哪儿了呢？发到姐姐的。电脑上了啊。

或者他的手机上。那么。人家收到这条消息以后啊，人家收到这条消息以后，会拿。咱们这条数据啊拆开来看，那么正好它在拆包的时候是一个反过程，他先拆物理层的头啊，到这儿了，对应的物理层，他把物理层的头拆掉。

然后再往上走数据链路层，他把数据链路层的头拆掉，到网络层了，他把网络层的头拆掉，到传输层了，他把传输层的头拆掉，到绘画层了，他把绘画层的头拆掉，到表示层了，把表示层的头拆掉，到应用层把应用层的拆掉。

最终啊最终。用户呈现的就是这条数据。所以这一条数据从这儿到这儿啊，两台主机之间的传输。这边走啊。这是一个封班的过程。他收到信息解班的一个过程啊，这就是基层网络模型中数据传输的这样的一个过程。

系列 3：P15：【多线程与高并发】线程的3个方法 - 马士兵_马小雨 - BV1zh411H79h

可以起一个新的建成。

ok这是现成的最基本的概念，我们来认识几个现成的最基本的方法，那么第一个方法呢叫sleep，sleep就是睡眠，所以睡眠的意思，当前线程暂停一段时间，让给别的线程去运行啊，是这个意思好。

那既然讲到这儿的话，这个睡眠让给别的县城到底是什么概念，如果从操作系统的角度来讲的话，这是我们的cpu，cpu呢是一个特别土的，特别土的这么一个元件，这个原件呢在他的概念里头，是没有现成的概念。

他只知道干嘛呢，就是他就是不断的一个死循环，这个循环啊，就是从那个内存里头把指令拿过来运行，拿下一条指令运行，再拿下一条指令运行，一直就这么不停的循环，不停的循环，不停的循环，没有指令了，歇着就这意思。

所以其实对cpu来说没有形成这个概念呃，但是我们这多线程的是什么意思呢，其实呢是有好多不同的线程，每个人在如果只有一个cpu的话，那么每个人呢就在这cpu上执行一会儿，每个人在cpu上执行一会儿。

执行一会儿之后，不是把你扔出去，把第二个线程再拿进来，然后呢波再把第三根线程哎拿进来吧。

第二线程扔出去是这么一个概念，而这个sleep的概念是什么呢。

就是说这个线程麻烦你啊，跟我这睡500个毫秒。

然后在500ms之内，你a别人别的线程可以去运行，让给别的线程去运行，是这个意思啊，test sleep，那代码我就不跑了，太简单啊，好第二个呢叫ield yield，的意思是非常谦让的退出一下。

这个代码呢我就不演示了，你们如果有没有同学对you有的有疑问的，如果有疑问，一会儿有一会儿一会儿找我问啊，我先讲好，yd是什么意思呢，比方说我一个线程在运行，另外一个线程也在运行。

然后当前这个线程在cpu上运行的，运行到某个程度的时候，它掉了个eu的方法，那e的方法意思是哎哥们，我先退出一下，我从cpu上先离开，离开之后呢，别的县城是有机会在这儿执行的，当然我离开了之后。

如果说别的线程没执行，我还可能继续回来，继续执行所有的离开，就是进入到一个等待队列里头，等着干嘛呢，哎我从本来我正在上面运行呢，结果呢我又一下又一下，就是bl又回到等待队列里，回到等待队列里。

在操作系统的这个调度算法里头呢，还是依然有可能，把你刚回去的这个县城拿回来继续执行，当然更大的可能性是，把原来等待那些拿出一个来执行，所以yd的意思本质上就是我让出一下cpu。

至于后面你们能你们能不能抢到，不好意思，那我不管。

好这是you的意思，折腾去说返回就绪状态没错，就是返回到就绪状态去，那第三个呢叫join，join的意思还是画图啊，如果这是我们第一个县城，这是第二个线程o这个中文的意思，如果这个线程叫t。

如如果这个线程呢叫t一啊，左边这线能叫t1 ，右边这个线程呢叫t2 ，他调的过程呢，如果是在t一的某个点上调了t2 点join，认真看，在某一个线程里调你自己的点，john是没有任何意义的。

掉了如果是掉了t2 点join，join的意思叫加入，那意思就是麻烦你跑到t2 去运行，t一干嘛，t一在这等着什么时候t2 运行完了，继续t一运行，所以join的意思就是诶，当我本来我这县城到这儿了。

然后我掉了个join，我就跑到另外一个县城去运行，运行完了之后，我第一个来运行，所以相当于把这个县城给加入到了，我当前县城里面，这样你常经常用来干嘛呢，经常用来等待另外一个线程的结束。

t一完了之后调t2 点join，t2 点join的意思就是诶我等t2 结束了，我t一才继续运行，所以以前有个面试题说，诶我怎么才能保证另外一个线程运行，t一运行这个t1 t2 t3 ，我起了三个线程。

怎么才能保证这三个线程能够按顺序执行，完，这个事儿太简单了，你运行完运行起来之后。

你在那个主线程里先调用t一中，再调用t2 中，再调t3 中就可以了，还有一种那个更加精确的方式呢，就是你t一里面掉t2 转，t2 里面调t3 转啊，保证是t3 。

系列 3：P150：【Linux】TCP_IP模型和协议栈介绍 - 马士兵_马小雨 - BV1zh411H79h

好啊，第一个啊OSI数据的传输模型，数据传输过程咱们给大家画明白了。

第二个TCPIP的协议站啊，说我们做编程也好，我们做这个学习也好。那么对于这一块啊，我们给大家介绍了TCPIP的模型啊，所以它的协议站里头，首先我们介绍了。TCPIP模型。对吧在这儿呢啊。

昨天已经介绍过了，不管人家说四种还是说五种，说多少种，那您都知道啊，所以这个模型很重要。好，这是第一个啊。第二个TCPIP。啊，那么都用到了哪些协议呢？啊，所以这个协议站里头都包括什么呢？主机到网络。

啊，到网络层。协议。比如说昨天我们介绍了IP协议。啊，也叫internet协议。那么IP啊就是internet protocol啊，internet就是网络part就是协议的意思啊，所以说是IP协议啊。

那么以及什么呢？我们的。Okay。我们的。呃，ICMP。叫网络控制。豹文协议。啊。好。还有哪些呢？除了ICMP以外，那么就是我们今天的重头戏。TCP协议。TCP协议。TCP协议呢叫做传输控制协议。啊。

传输控制协议。那么还有UDP协议。啊，UDP协议叫做用户数据报文协议。好，以及在这个协议促中啊，非常有意思的一个内容，就叫做ARP协议。ARP协议叫地址。解析协议。Oh。那么如果将来不搞邪恶的同学啊。

那你了解即可了。搞邪恶的同学呢，将来呢可以往深层次的去研究它啊，比如说ARP啊，这就是非常有意思的事儿。对吧哎，想让谁没网，谁就没网啊，让谁能上网，谁就能上网。好。还会在我们实际的这个网络中啊。

会遇到一些这个问题啊，比如说ARP攻击了啊。这种怎么办？好。好，这个是我们所介绍的TCPIP的协议站。哦。那么我们在这里头呢，我们就要给大家啊详细的展开来说一下。

系列 3：P151：【Linux】IP协议介绍 - 马士兵_马小雨 - BV1zh411H79h

Yeah。Yeah。嗯嗯嗯。

Okay。好，首先呢我们介绍一下。嗯。模型已经介绍完了。啊，在这里头呢你要注意啊，不管说是TCIP的5层模型。还是说是四层模型。现在在国际上有不同的叫法啊，他们正打架呢，哎，你别管啊，四层也好。

五层也好，那么我们都能够使用，也都能认识他就挺好啊，让他们打去啊，你别掺和。好，这个就是四层和五层的模型，咱要把它搞明白啊。那么然后呢，在这个协议站里头呢，刚才我们说了，我们介绍了哎不同的。协议啊。

那这里头谁重要呢？啊，IP协议是非常重要的。啊，IP协议。Yeah。好，那么这我说一下啊，主机到网络协议啊。不用掌握IP协议重要。Oh。昨天已经给大家介绍了，所以这儿呢我就不再介绍概念了啊。

IP协议是TCP。模型中。最重要。啊，最重要的协议。Oh。把这句话记住啊，最重要。没他不行。2。他为什么呢？他为咱们的PCPUDPICMPAARP啊。喂我们下边的TCPUDPICMP。协议提供了。啊。

数据传输的通路。

啊。

没有他是不行的啊。所以这个呢我们就一块得了解一下啊，我们就需要得一块了解一下，说呢它IP协议啊，它主要是在哪儿呢？啊，它在哪一层去玩呢？刚才我们说了啊，他肯定是在网络层去玩。啊。

那么它主要的作用就是提供了。子网的互联。啊。形成。那你大家子网你都能连在一块了，那就形成了一个。比较大的网络。啊。那么形成比较大的网络了，那能就能够什么呢？是不同子网之间啊的主机能够传输数据。Oh。

Oh。好。

。这话啥意思啊，这话啥意思？哎，你这边有主机，这边有主机。哦。Yes。Okay。对吧你这边就构成了两个网络啊。左边是一个子网，右边是一个子网。对吧啊，他这边的子网也这子网IP地址段可以是这样的。

比如172点16点0。0。啊，点0。0。好，比如说我来个杠24。啊，别216吧。Yeah。先不带啊先不带。一会儿我们讲这个掩码的时候再带啊。否则容易乱。好，这边是一个网。啊。这边是一个网。好。

这是一网段这是一网段啊，那么通过IP啊，然后他们都在主路由上啊，那这边的主机就可以和这边的主机进行通讯。

啊，是这样的一个意思。嗯。学。那么IP层主要啊有什么作用呢？我们可以往下去说一说啊。主要的作用。好。Oh。主要作用第一个。数据传送。哦。第二个。寻址。第三个路由选择。哦。第四个那就是数据报文。啊。

的分段。四个弓四个作用。Oh。Oh。啊，四个作用。那么数据传送。简单的说啊，就是从一个主机传送到另外一个主机。哎，一个主机到另外一个主机。啊。荀址。Oh。

，Okayello。Yeah。啊，荀址啥是荀址啊？根据子网划分。和IP地址。啊，也就是说子管延嘛啊。发现正确的。墓地主机。的主机地址。这个过程就叫做寻址。

啊。他是怎么来的？他有他算法。啊，他有套算法，回头呢我们可以给大家说的说的啊。🤧路由选择是什么？路由选择就是选择数据在互联网上的传送路径。啊，传送的路径。就指道的啊，说你怎么走。啊。村中头老王家啊。

对不对？哎，那王寡妇啊，那他们家怎么走啊，这村里的人都知道啊，那一直哎从这儿走近啊，从这儿走到后门爬窗户近也可以啊，那他们都熟。所以就是选选择数据在互联网上的传送的路径啊路径。Yeah。

数据报文的分段啊是告搞什么事儿的呢？当这个传送的数据啊，比如说我们里头会有一个叫MTU的值啊，这个东西呢你一般的。呃，你不搞底层的话呢，也也没什么用啊。但是你如果去搞了啊可能呢十年8年以后。

没准你可能会涉猎这个行业啊，因为你再练十年对吧？你也可以啊，你也可以。所以说呢当你传送的数据大一个固定值时啊，就可以将数据进行分段发送啊和接收，然后呢，再重新组装一下。当。数据啊传送的。数据。

大于MTU值。Oh。该以下课了是吧？诶。将。数据。进行分段发送和接收啊。并。😡，重新组装。这个MTU值呢啊是多少呢？回头呢我们给大家呀啊我看我找一台企业机路由啊，我家里有。我登一台啊。看一下MTU值。

嗯，改得切换一下网络。嗯，行，那我们先下课休息啊，然后回头我切换一下网络。然后因为我一切网可能。你这边就得断啊。呃，这些不做掌握啊这些不做掌握，主要掌握荀址。其他了解。

系列 3：P152：【Linux】TCP协议概述 - 马士兵_马小雨 - BV1zh411H79h

好啊，我们回来啊，接着上课。么关于IB协议啊，那么我们在运维这个阶段呢，如果你要去学呢啊那你了解这么多就行了。

🤧。Okay。🤧那么在这里头呢，如果说啊将来我们做这个想更深入的去学习啊，将来网络这块啊，通过周末班学习的同学呢，我们会啊做进一步提升的学习。那么如果呢我们在运维阶段，大家呢啊了解到这个。

交换机啊路由器原理对IB协议有所了解即可啊。IP协议呢里头会有1个IP的数据格式。Oh。

。Okay。Yeah。啊，会有1个IP的数据报文格式。

那么这里头呢，我不想说每一个人啊。你都在这一块有较深的造诣。我想告诉你的就是通过这张图啊。

啊，通过这张图，我们把IP这个报文啊，它大概的一个形式，它长啥样有所了解啊。0到300到32。什么意思呢？啊。32位。啊，32位的数据。那么在这里头我们能看到就是版本。啊，版本比如IPV4IPV4的话。

它占了。四位。啊，占了4位。但是呢IPV6它就占了6位啊，这不一样。所以在1个IP的报文啊，在发送的时候，前边有版本号，有手部的长度啊。有服务类型，有总长度，有标识，有标志啊，还有片偏移。

这些都相对于更底层的东西。所以现在让你一个beginner的一个小白啊，你刚入门，你去了解这些内容。那对于你来说，那这样的东西就过重了。啊。

但是呢如果说有至于成为说啊该行业或对啊我们网络有较深了解的同学呢，将来有机会啊，我们通过周末提高班，我们再深入的去研究哥在带你写编码，看看底下，包括哎我们底下扫K的链接是咋回事啊，我们一行行的玩啊。

生存时间协议啊，手部校验和。那普通的同学啊，普通的同学说您现在呀学习经力有限啊，您也比较辛苦，那哎你只要了解到说我这里头有一个原地址，目标地址。

数据。你知道这3块就行了。其他的不需要您再去了解啊。那么IP的首部，也就是说刚才我给你画七层网络模型的时候，你看是不是啊它就有IP啊，这就是三层网络的首部，对不对？然后这是数据部分啊，了解到这儿即可。

Hpe。这张图呢我给你保存一下啊，我给你保存一下。Oh。

🤧。

Okay。IP豹文格式。哦。不做掌握，仅了解。啊，先了解。那么就是方便让你知道啊。了解这里头有原地址。有。目目标地址或目的地址啊。有数据部分了解这个即可啊。Okay。好，这个是IP的报公格式。

那么呢对于这个协议呢，我们简单的了解即可啊，知道它很重要。那么从IP协议里头呢，我们要体现出啥呢？我们要体现出IP地址啊，我说这个的目的主要是要做IP地址用的。Book。Okay。

那么第二个呢啊这里头重要的协议呢啊IP协议咱就过去了啊。ICMP的网络协议，这里头刚才说了，那么他干什么呢？我们拼命令的时候见到了。啊，ICMP协议。用于传递。啊，传递啥呀？差错信息。差错信息。Oh。

啊。🤧这是第一个差错信息。第二个时间，第三个回显。啊。第4个还会有一些网络信息。啊，它叫做豹纹。控制。数据。这些东西都相对更底层了啊更底层了。那么呢简单的来说呢，我们也可以给你搜一个啊。

我也可以给你搜一个。

。ICMP保文。

Yeah。

Okay。🤧嗯。好。

Yeah。长这样啊。32位啊四个字节。

。好，这个报文格式呢啊我也给你呢放到笔记中也仅做了解啊。

不用做太多掌握。

好。🤧啊，报恩格式啊。Oh。Okay。好了，他这里头有很多的字段啊，豹文的类型里头有很多的字段。啊，那么比如说我们拼命令里头呢，它会有一个回应的应答，我们就看一下拼啊，简单的来了解一下拼。

Com。

。

啊。Oh。Oh。Oh。Okay。Okay。嗯。Okay。好，连上以后啊。听。百度。咱们看一下百度通不通啊。我。😮，好。好啊，那我这个因为是VPN开着啊，所以说可能会对国内的一些网站有问题啊。呃。

我就不调了，然后拼一个地址啊，这里头会有ICMP的SEQ啊，会有这个每一次的回显的值。啊。会显的值。那么呢在我们拼的时候呢，他会给我们有一个回显的应答啊回显的应答。那么一般的话呢，这里头有一些码呢。

就是比如说代码0啊0。就是一些回显的应答。那么如果啊还会有一些，比如说呃一呀、二啊、三啊、4啊、5啊、6啊，对吧？哎，它会代表着不同的意义。比如什么主机不可达呀，什么协议不可达等等等等啊。🤧嗯。

简单了解即可啊。

🤧嗯嗯。😊，第3个PCP传输控制协议。哎，这个东西啊这个东西是我们要重点花时间去讲解的。啊，去讲解的。那么其他的那些内容呢，我将来会在我们一些的这个呃。网课呀或公开课的时候再会给大家再去说啊。

这个东西非常重要啊，是要求所有人都掌握的。那么这一块呢，面试啊，包括你在将来的发展的过程中，我们都需要用到啊，它的全名叫做传输控制协议。啊。简称TCP协议。它是在我们原有的IP协议的基础上。在咱们。

IP协议。的基础上。增加了。确认。确认重发。啊。滑动窗口。啊。和。复用。啊，复用等机制。我们通常要说到网络协议的时候，最重要的两个，一个是IP协议，另外一个就是TCP协议。所以我们。

网络中你要了解的两个啊，那就是TCP和IP协议。那么它最重要的一个特点，最重要的一个特点。好。提供了。稳定的。安全的。啊，一旦安全俩字就重要了，这是企业的标配。啊，稳定的、安全的、面向连接的。自节留。

第一句话不重要啊，了解第二句话背下来。啊，它是一种稳定的安全的，就这俩字儿。很重要。那么基于这个特点嗯。啊，基于这个特点。那么我们一些。比如说SSH将来您要学习的啊，HTTP等那些个服务啊。

那些个协议都要基于这一种。啊，都要低于这一种。那么TCP协议它有哪些特点？我给你说一下，最重要的记刚才标红的这个啊。哪些特点？第一个。啊，第一个。自节流府啥叫自节流啊，那肯定就是数据呀。对不对？

那字节流就一个一个的字节啊，说使用这个TCP。协议。进行数据传输。啊，10。传输。传输时。应用程序，你比如说QQ和QQ，我们在传信息啊，微信和微信传信息。咱们现在这个叉el连接到你的服务器啊，这就是。

应用程序之间数据传输啊，比如说你发送的用户名密码，哎，这就是一个安全的链接。啊。进行数据传输时。应用程序。哎，应用程序之间。对吧。你在传输数据的时候。啊，那么我们就可以称为。可以视为啊无结构。无结构的。

直接留。啊。这个呢如果你要想深入的去学习啊，这个是。呃。深入的去学习，你差不多啊，你得在本科阶段你就学不了，你得在研究生阶段啊，你去看一看这个原来呢我去。哎。在图书馆啊，我经常去看。然后呢。

因为我我家呢在。这个清华大学，所以说我有时候没事儿，我就去清华大学图书馆，我我去看一下啊，会有很多的东西。所以这个IT行业呢，如果你要想深扎根去啊去学习的话呢，真的我们有很多的路要走啊。

那么基于自节流的服务，那这一点呢就是什么呢？基于自节流的服务。Yeah。没有字节序。问题的。困扰。啊。那么如果你在去做编程的时候啊，十0年前我去给他们讲。给企业去讲C加加编程的时候，讲C语言编程的时候。

对吧？我们还会往尤尼克斯底层的编程会讲很多。所以这一块呢我给你提一下啊，你能理解呢，你就理解理解不了呢，你就了解啊，不需要你。掌握。哦。🤧他为你将来可能的学习提供一种思路啊。

所以第二个特点呢就是面向连接的服务。其实这一块呢，我可以不给你提，提了以后你就可能会有困惑啊，但是不给你提呢，我良心上又过不去。我觉得我讲我就得提。你听不听得懂，我都得说。啊。如果不说。

那这块就没有什么价值，所以得说啊，听不懂你就把它背下来。面向连接的服务就是在数据进行传输之前，TCP啊。Oh。重要啊。Yeah。好。好。Okay。好，说在数据传输之前。啊，那么这个TCP协议。需要先。

建立连接。那么正是因为他这个特点啊，所以呢这个在面试的时候呢，人家都会问。啊，人家都会问。那么建立连接之后，它在这个基础上啊再进行数据的传输。啊，那你要是做开发的。

你说我做网络编程的scket的底层问死你啊，你说我是做运维了啊，那人家OK可能就问一些设备就得了啊，不会特别的为难你。但是呢他想体验一下，比如说你有几年工作经验。那这时候他就该问你了啊，就该问你了。

那么TCP。啊，这个协议在创建连接的时候有哪些的步骤？啊，这就是这儿我们要说的。好，那我们就说一说啊说一说。🤧。好。那么TCP。协议啊，它为啥要面向连接的服务？那么是底层来说。

它是一种面向连接的单波协议。啊。完犊子啊，这东西又多了去了。那么这就涉及到了我们在网络中的概念单薄。主播。和广播。Oh。啊。那么单波这个词儿，今天第一次见广播这个词儿已经在。交换机的时候就出现了。

主播这个词儿今天第一次见啊。那么所谓的单波啊，就是有来言有去语。啊，有来言有去语，小姐姐约吗？必须得给你回约或不约啊，同意或不同意。说出去吃个饭吧，看个电影吧。对吧啊，唱唱歌喝喝酒吧。啊。对吧哎。

这都可以啊，所以单波在这里头一定要知道，也就是在数据发送和接收前。通信的双方啊，别管你是两台主机，两台服务器，两台手机，通信的双方。必须在。彼此间。建立一条连接。아웬디。Oh。🤧。单波就是。啊。

一对一的服务。啊，一对一的服务。有来源。有趣。Okay。好。那么主播后边我给你提一下啊，今天呢我们先了解单波和广播，因为我们学了交换机了。是吧哎。广播就是一对多的。一对多的服务。Oh。啊。

大家伙大家伙大家伙注意听注意听，注意听是吧？村东头老王家那条狗丢了啊，谁看着了，赶紧的上这个这个村委会这儿，赶紧的这个有有有有有重要信息线索的，赶紧过来啊，跟老王头联系。啦，哎。

所以说呢这儿会有一个内容啊，通常我们就用在什么呢？交换机。啊，货。其他应用。🤧好，这不重要。啊，那么你需要。了解的就是需要记住的就是啊，那么它是可靠的面向连接的字节为流的传输层的服务。Oh。啊。

在传输层的服务啊，这句话重要。好。接下来这句话采用。三次握手。建立一个连接。Okay。啊，建立一个连接。下边这个断开连接的时候，采用4次挥手。断开一个连接。这里重要的。啊，三次握手，四次挥手。

所以面试的时候呢，或有一些啊过程中会问你。三卧四灰，我们简称三卧四灰啊。那么三次握手建立一个连接。啊，三次握手建立一个连接。那么这个建立连接的过程整体的都要背下来啊，掌握了，我一会儿跟你说啊。

我一会儿跟你说。那么TCP它在建立连接的时候。啊，传输数据。啊，传输数据。的3个。3个。阶段。I。啊。建立连接。数据传输。断开连接。

系列 3：P153：【Linux】TCP建立连接的过程 - 马士兵_马小雨 - BV1zh411H79h

🤧好啊，TCP3次握手的过程啊，客户端先发送SYN码SYN这个码就表示建立连接啊。

客户端先发起。给服务器端，这是第一次握手。当服务器收到你SYN请求以后，需要应答。我们说了单波，有来源有去语，这就叫来源，这就叫去语。说服务器端给你1个SYN说我确认连接。然后再给你发1个ACK码。

ACK码是确认。所以这儿发了1个SYN和ACK是两个字段。

啊，两个字段。那么当客户端收到SYN和ACK的时候，他就在这儿等待了，就已经建立连接了。

那么客户端再给服务器端发送1个ACK码。这时候服务器端啊也说了，那我就不约别人了，他也就建立了链接。

然后在你这个通道建立以后啊，我们说面向连接的对不对？通道建立以后啊，然后相互之间进行数据的传输啊，数据的传输。

系列 3：P154：【Linux】TCP连接状态转换2 - 马士兵_马小雨 - BV1zh411H79h

🤧录啊，今天怎么回事？

客户端的状态和服务器端的状态啊，4个在这儿大家记住。

那么第一次呢在客户端发送SY码的时候，它就处于SYNcent这样的一个状态啊，发送SYN。然后发送SYN码以后，服务器端收到了SYN码，它就处于SYN receiveive的状态啊。

后边给你备注了，哎，然后他接收到了，他就向客户端发送SYN加ACK。那么客户端收到了以后啊，就处于asbel就是就绪这个状态。

啊，然后他在这个阶段再发送1个ACK给服务器端，服务器端收到了以后也处于就绪状态啊。

然后就可以开心的玩耍了，可以传信息了。

系列 3：P155：【Linux】TCP报文格式和重要字段 - 马士兵_马小雨 - BV1zh411H79h

啊，这个重要。好，那么有SYN了，有ACK了，那么我们就得在这个协议中啊再给大家说的说的，那么就是。

TCP。啊。我们叫传输控制协议，我简称协议。啊，这里头叫控制位。控制位。好，那么控制位是什么？控制位是它豹文格式。豹文格式里的内容。

。

🤧嗯嗯。Oh。Oh。呃。哎，没有图吗？Okay。By。

Okay。好啊，我给你找一图。嗯。好啊，豹文格式啊，也就给你放上来啊。

Okay。报文呢这个不做重点掌握，但是豹文格式里头有一些字段，就像刚才咱说的SYN啊ACK啊，它都是啥意思啊，会在这里头可能会对你。

。

理解这个报文格式啊，就是这个关键的字字段啊有帮助。

。Okay。🤧好。这里头就会有确认号，你看这里头有ACK什么什么的啊，就是在这个报文格式里头有。那么常见的这个控制位，这个报文格式有哪些呢啊？啊，有URG啊URG咱们解释一下。URG呢就是紧急指针字段。

啊。了解。啊，ACK字段掌握。ACK字段是什么意思呀？表示确认号有效。啊，ACK的表示确认号有效。Okay。对。🤧掌握该字段啊。PSH。Okay。SYN。啊，FIN。RST是吧？🤧嗯嗯。

SYN码记住FIN码记住。其他均了解。啊。标红的是重点啊。🤧SY。刚才已经白活了半天了啊。用于。发起1个TCP链接。啊，FIN。用于断开。啊，断开。一个TCP。链接。Oh。好。

这些字段记这仨PSH说一嘴，PSH表示接收方需要尽快的将这个数据交给应用层。啊。But。不做重点掌握啊，仅了解。RST啊RST。重新链接。🤧嗯嗯嗯。Oh。

好，该了解的啊，该掌握的给你说了，这三个即可啊，状态也说了。那现在呢我们看看断开连接的过程。

系列 3：P156：【Linux】TCP断开连接4次挥手 - 马士兵_马小雨 - BV1zh411H79h

嗯。断开链接的一个过程啊，那么首先啊。你们得建立连接的基础上啊建立连接的基础上。那你没有建立连接，那你咋就断开了呢？

啊，好，我们看看啊怎么断的。

。哎，在这个基础上啊在这个基础上。吃饭了也。看电影了啊，然后回来以后。这个是吧。你觉得这妹子不行？啊。对，就是妹子一说，哎呀，我前面谈个谈过10个男朋友啊，都没成。对吧那你这玩意儿你不急了吗？

那还得了啊，这10个都没教导出来，那到你这，你不也得翻车吗？是不是？哎，所以呢在你建立连接的这个基础上，你就说再见吧啊，对不起，再见。

好，那咱们看怎么跟姐姐再见啊，那你也不能是吧？说的太直白呀，那玩意儿一会儿人家急了，打你一顿怎么办，是不是啊？🤧嗯。诶。那这时候呢，那我们首先得有一个渣男的心态啊。这儿刚最上边啊。

我们刚才已经就绪了an，对吧？所以呢刚才这是建立连接了。你断开是你已经在建立连接的基础上啊，说您俩这儿都已经建立连接了。操懒得打了。嗯。啊。不嗯。好，那这时候呢。啊，我建立连接以后。我现在这个渣男啊。

要分手。渣男提温柔。啊。呃，不行，这玩意儿太吓人了啊，他发了1个FIN了。刚才咱们是不是介绍了呀啊。

FIN断开1个TCP链接，哎，提分手了。

嗯。那这时候咱的这个。服务器端啊就收到了。人家小姐姐其实还挺中意你的啊。但是呢没想到你是这样的人。啊。那人家也不含糊啊，是不是啊人家就骂了一句渣男啊。好。发了1个ACK。哦。发了1个ACK。

这是第一次第二次。啊。Okay。好。嗯。所以呢这边就收到了一个信息。啊，小姐说同意。啊，赶紧给我滚。对不对？Oh。好，然后呢小姐姐就把一看说你是这样的人啊，你是渣男。小姐姐就把微信给你拉黑了。

手机号也删了。啊，全拉黑。Okay。嗯嗯。人家就把你。拉黑了，再见了，goby了啊， sayaygo了。Okay。就断开了哈。电话拉黑。微信。32。啊。微薄清空。哎。对吧一次、两次、三次。嗯。好。

还差最后一步啊，那你这儿还对吧？你虽然是个渣男，但是你这不也得是不是？哎呀这个哀悼一下，是不是？Yeah。啊。这儿他还没有断呢，这还留着姐姐照片呢啊这个。哎呀，这还后悔呢，那那也没办法了呀。

人家都给你拉黑了。他最终一看，哎，既然你这么狠。哎，他再给姐姐说一下。好，这时候就发现啊，你已经不是对方好友了啊，已经不是对方好友了。那么最终。ACK分就分吧啊，就是这么一回事啊。

那这时候人家已经被拉黑了。啊，你这边。诶。也就可以。关闭了啊，这就是四次挥手的这么一个过程啊，这儿你。2。三。4。Oh。好。

系列 3：P157：【Linux】TCP断开连接的7种状态 - 马士兵_马小雨 - BV1zh411H79h

是。4次呢，然后呢它还是有状态的啊，所谓状态呢，那我们就。这个了解一下渣男的心理变化啊，那说他第一个他处于叫SYN。meat杠1。第一个状态就是FYNw1等待人家确认呢。啊，你发过来1个SY。

当然这上边就表示我们三次会手已经建立连接了，这里连接建立着。啊。到这儿以后，人家直接就给你close。啊，关闭等待。是吧哎，关闭等待，那最后再聊两句啊，你们俩买那个狗买的项链，买的什么东西。

手机什么乱七八糟的，是不是？啊，财产分割一下啊。好。然后呢，你给人1个ACK确认了啊，这里头他还你看虽然是渣男，但是男的和女的心理变化是不一样的啊。他还犹豫呢。啊，他还犹豫呢。

所以他处于一个叫FNV2这样的一个状态。啊。系。好，那其实呢姐姐这边发了两条啊，说发了1个ACK，最终呢还发了1个FFIFIN的啊。啊，那这个就是人家就做决定了。last aK他就已经做决定了。

最后一次确认说我再给你最后一次机会，你现在啪叽就给我跪下，说我错了，哎呀，哎，我还能原谅你啊，给你最后一次机会。但是你没有。啊，没有人家就卡删号跑路，对不对？哎。

所以呢这个里头它就进入到了啊叫time wait。Tampade。啊， ham made。在这等。这个等待的过程中，可能你时间很长。那么我们客户端和服务器端去沟通的时候。

这里的time wait就要等等待你超时啊，它一直等有time wait一和time wait2。所以在这段的过程中，它需要等待一段时间。就你打电话不接，发短信不回，那你就等让他冷静冷静。啊。

所以这个就是readit。啊，read。没。好，实在不行了，人家就一看给你拉黑了哈，那你就close。最终才可能。Oh。这边最终也closse。4加3得7。断开的时候啊。7个状态。啊。建立连接的时候。

四个状态。所以加在一块儿11种状态。啊，那么这个东西呢，你将来你要想面试别人的时候呢，就是第一问啊，说给我简述一一下TCPIP连接三次握手四次挥手的过程。啊，咔拉基咔基写，对吧？哎。

第二问马上说在建立连接和断开连接伴随着多少种状态的转换，答11种每一种状态是什么？通过刚才这个非常悲惨的故事啊。对吧一开始高大上的白马王子最终变成了渣男啊，就这渣男的故事。11种状态啊。

汤汤汤给他写出来要1万块钱以上薪资玩的一样啊，所以这块一定要注意啊，这里头7种状态。

Okay。哎，你看。26号泥霄位啊，你看这小子肯定干过这事儿啊，你原来总结的还挺有道理，你看。是不是？啊。哎。

好了啊。😊。

系列 3：P158：【Linux】wireshark抓包分析工具 - 马士兵_马小雨 - BV1zh411H79h

好，wind sha啊winsh。那。对你就一直下一步啊一直下一步。Good。啊。默认C。啊，他抓包的时候呢，他会用一些工具啊，他有1个NP cap啊。其他的都默认。Yeah。Okay。Okay。

Yeah。Okay。同意啊。跟装。The，Okay。嗯。好，安装完了还是下一步啊，finish等它装完就行了啊。他需要你重启。啊，需要你重启，我就不重启了，我一重启就没了啊，那就到这儿。

我点finish啊，你们自己装完了，重启一下，好吧，那今天呢咱们就说到这儿啊。

系列 3：P159：【Linux】wreshark抓包分析TCP三次握手 - 马士兵_马小雨 - BV1zh411H79h

看一下啊，我们实践一下。那么这里头呢我们要用winsshaer啊，然后呢我们要抓一下哎我们的网络数据包。啊。Yeah。我们抓包分析一下啊，把TCPIP的这个哎三次握手，四次挥手，我们都抓包搞一下啊。

让我们呢把这块呢好好的哎理解一下。打开你的win12这个软件。Oh。打开它啊打开它。然后呢打开你的虚拟机。Oh。Oh。Okay。注意啊，在这一步啊在这一步。它上来以后呢，会有波形图。啊。

上来以后啊会有波形图。那个波形图呢它干什么呢？它就是检测你有多少网卡。啊，检测咱有多少网卡。然后每一个网卡它现在跑的有数据，你看有波形的就是有数据。啊。如果我们想连虚拟机抓包。

你选net8Vnet8VM worknet VMnet8。啊。那如果你想抓你本机的，就是说咱们这电脑的啊跟外边联系的那你就可以选本地连接。看你那写的是本机链接一啊，二啊，哪个有波形，你就选谁啊。

我们这里头用虚拟机来演示，就大家都选note8。双击他。啊，双击他。好啊，那你看他走了一些啊NTP的啊这些数据。首先第一步啊说一下步骤啊。第一步。安装软件。啊，我们在上一讲已经把这个软件安装了。第二步。

啊。打开软件指定网卡。Oh。好啊，这里注意，如果是虚拟机。抓Vnet8这块网卡。啊，如果是你本机上网。抓本地链接。啊，等级链接。Okay。好，这个本地链接指的就是你本地的有线网络啊。

有线网络如果是无线网。Okay。无线网，那你那无线网卡叫啥，你就抓那个名字。Okay。Yeah。好，咱们这里头统一的都选mateote8啊。

Oh。好。然后在上边这有一个显示过滤。啊，那你直接输入。TCP点port等于22。啊，在这儿有一个绿的线，这个叫过滤器。

。咱们SSH就是典型的TCPIP连接啊，咱们后边会详细的去讲这个过滤器输入TCP点破等于22。这意思是什么？是我们要抓。啊，抓包。Oh。找。啊，TCP协议。且走的是22端口。的数据。Oh。Okay。

Okay。Yeah。Okay。好，这一步很重要啊。那如果你不这么处理呢，那你后来下边就会走很多啊这个乱七八糟的数据。

指定好啊指定好。指定好22端口以后啊，这上边有一个红的是停止，绿色的是刷新。

Okay。红的是停止，绿的是刷新。

Oh。啊。好，然后打开你的终端。

叉c连接你的虚拟机。

啊。然后这时候啊我们这里头就有数据了。咱们就捕获到了数据。啊，捕获到了数据。好。在我最上边。

Oh。啊，在这个位置，我们就抓到了。Oh。TCPIP。

协议在建立连接的过程。啊，TCPIP建立的过程。那么中间这一块啊，中间这一块就是我们TCPIP的网络模型。

最下边这个啊对吧？哎，transmission controll portal头啊，什么呀？这就是传输层的协议。啊，再往上internet portable啊，port什么意思呀？IP协议。

你看这就是IP层。再往下啊，这里头有一个以太坊。😊，啊，你太网络。对吧前边是sourcece，后边是destination，这里头有m克地址，这就是我们数据链路层，二层网络。啊。

再往下这有一个frame啊，66比特on什么什么什么什么什么什么什么interface，后边这就是你的网卡驱动。

ID0，这就是你的物理层。所以这就是你的TCPIP协议的模型。啊，你的模型。那么我们看一看啊，这这个东西就是一个网络的风包啊，我们看一看是不是跟我们说的是一样的呢啊，拿我们的鼠标点到第一行。啊啲行。

第一行这里在传输层的时候啊，传输层的时候，那我们这里头有一个flag。啊，flag0叉002发的是一个什么SYN码。Oh。啊，SYN码。Oh。所以这个东西就是一个网络封包。那么就像我们说的啊。

第一句话发的是1个SYN的字段。

啊，在这里头。

SYN字段。再发SYN字段的时候，他还干了一件啥事儿啊，我们看这个数据。第一次客户端。像服务器端。Yeah。

。다。这个过程刚大家已经都画的非常明白了啊，真的非常开心啊，大家都画出来了。😊，哎。可能我们今天一激动，又多得奖10块钱了啊。那第一下这个客户端。服务器端。Oh。客户端就是原。啊，原数据或叫原地址。

服务器端就叫目标地址。啊。Oh。在我们抓包里头能不能体现出来，能体现啊能体现。那么前面这就是圆，后边这destination就是目标。

Okay。

。Yeah。Oh。好，那如果你抓到数据的同学啊，那你就可以看自己的没抓到的同学啊，你看我演示。

Oh。Yeah。Oh。Oh。Okay。は。Oh。Oh。我这里的原地址。就是客户端啊，10。0。0。1。目标地址。啊，服务器端10。0。0。132。Oh。Yeah。Okay。客户端啊服务端已经都弄出来了。

What。好，我们注意看啊，你客户端后边这个。TCP指的是走TCP协议。啊，他俩都一样，指的是走TCP协议。아。在后边啊在后边它是端口，谁到2264860到22啊，这个我们不管，那客户端我们都知道。

他首先他得发1个SYN码，没问题，没毛病啊。他发的是SYN。这时候。除了SYN以外，他还发了一个什么呢？加啊SEQ。啊，SEQ。这个也叫做ISN码。就是你客户端TC啊，在建立连接的时候。

它用于一个识别码。那么这里头SEQ的值发的是多少呢？发的是0。啊，发的是0。记住啊，客户端在发SYN码的时候，这个SEQ第一次发的是0。这就是我们第一次握手。

啊，客户端发送完了以后，服务器端收到你的链接啊，然后他发了两个字段，在这儿看中括号，我们抓到两个字段SYN逗号ACK也就是发了俩。

啊。那么他首先会给你发SYN加ACK。Yeah。发这俩字段啊，然后他也会给你发1个SEQ值。SEQ码。ISN码。啊，注意看这里头有学问。

啊，他也发了1个SEQ等于0ACK等于1。那么这里的SEQ和上边客户端发的SEQ，它俩有没有关系？SEQ的值，它俩各自是各自的，没有关系。啊，但是ACK的值等于一，它和客户端发送的信息有没有关系。

有关系。

我再说一遍啊。

，第一次的SEQ和第二次的SEQ的值，他们之间没有联系。

Oh。Oh。注意。第一次客户端和第二次服务器端。发送的。SEQ值。没有关系。啊，自己发自己的，他俩没有啥关系。Well。好，但是。注意2。Okay。第二次。服务器端发送的ACK字段的值。唯一。跟。

第一次客户端发送的SEQ值有关系。啊，是在该值的基础上。确认。加一。Oh。Oh。所以他发了两个码，一个也是ISN码啊，用于识别你这条TCP的链接，他发零，他也发零，这俩没关系，各自是自己的啊。你是你的。

我是我的两个不同的颜色来区分。啊。但是第二次他发了SYN，这是SYN发的ISN码ACK的码。ACK的码跟第一次建立SYN的。啊，请求这个码跟它有关系，是在原来的基础上，你的SEQ。加一。就等于。

ACK的值。Yeah。Oh。啊，颜色给你标一致，这个颜色这个ACK。是它的值加一。Oh。Oh。好。Oh。Oh。

好，注意看软件啊，效果是不是这样的。说第一次发了1个SEQ0啊，第二次服务器端给你发送了什么？看这flag标志SYN加ACK。啊，SN加ACK。啊，这是第二次发送的。啊。

发送的那你发送了这个ACK以后啊，发送ACK以后，那么这个ACK的值到底是多少呢？啊，多少呢？这个ACK的值就是在你原来的SEQ的基础上加一你SEQ是随机的确认码。好，我在你基础上加一，证明我应答你了。

说的是应答了你的这个请求。😡，啊。第3个。

啊，第3个收到了这个ACK以后，客户端再次的发送一个，他也发送1个ACK的。子断。Oh。啊，ACK的字段。那么这时候连接才会建立。啊，连接才会建立。那么这个ACK和谁有关系啊，这第三次发的它的ACK码。

注意看我们看抓包。

第三次的ACK也加一了啊，这个值也变成一了。那么这个ACK的值，你看这个SEQ的number。啊，SEQ的 number。Oh。啊，SEQ的number。等于一了。啊，等于一了。好。

这也就是说最后你这个ACK码也是等于S1Q加1。

啊，也是SEQ加1。这个SEQ是哪的SEQ？是你第二次服务器端给他发的。这个S1Q值加1。2。Oh。Oh。Oh。好吧，哎，这就是我们通过抓包给大家来分析他们SEQ值ACK值。啊。😮。

那么发ACK的码同时啊，它再次发了一个啊SEQ的字段。SEQ值。Yeah。这个SEQ码。由最原来的SEQ0。啊，SEQ0。变成了SEQ。二。Oh。Okay。Yeah。🤧好啊，这是专业软件啊。

是网络安全黑客入门啊，黑客要用的这些抓包的数据这些软件啊。那么我们只是让它更底层的让大家深入的来了解啊这个过程。啊，深入的来了解这个过程。好，那么呢您呢把这个过程掌握了啊。

Okay。

系列 3：P16：【多线程与高并发】线程的状态 - 马士兵_马小雨 - BV1zh411H79h

讲下一个小节呢叫做thread state，the threat state的意思是thread常见的一些个状态啊，这些状态呢有的是你能够用程序测试到的，有的那是不一定能测试到的，但实际上确实存在的。

那么这个状态呢我画了一张图，图呢在process on里面，我我就不专门打开process on了，这是，java里面的现成的状态的一个迁移图，我们来大概的，来看看一下啊。

这是我们的线程状态的一个清晰图，这个县城呢目前其实有这么几个状态，一共是几个状态呢，1234566个状态是最常见的啊，呃听我说这个状态呢叫new，当我们new一个县政府。

就是他最新创建出来还没有调用start new thread，完了之后，诶这个时候呢他是new状态，当你调用了start方法之后，它会被线程调度器来执行，也就是交给操作系来执行了，那操作来执行的时候呢。

这个整个的状态叫rav，java里是有这么一个这么一个状态的，叫rnb，所以我才会说这是1234566个绿颜色的点啊，这个大的它代表一个，然后来说是666个状态。

但实际上这个radio呢实际上它内部有两个状态，第一个呢叫ready，就是就绪状态，第二个叫running，确实在运行的状态，所谓的就绪状态指的是什么，就绪状态。

就是说嗯我们扔到cpu的等待队列里面去了，在这个等待队列里面等着他排着队，等着让cpu运行呢，就是这个概念好，这是叫ready，真正的扔到cpu上去运行的时候，这个状态呢叫running。

这两个呢都叫做rnv，所以thread ero的一旦调用的时候，会从running状态跑到ready状态去，现场被调度去选中执行的时候哎，又从ready状态跑到running状态去，这个意思。

当然你如果顺利的执行完了好，进入terminated的结束状态，大家需要注意的是，你terminate完了之后，还可不可以再调用str，回到new状态，再调用star的不行，这是不被允许的。

你完了这事就结束了，你想thread结束完了之后再调用那个thread的start方法，sorry，没有不行不行，不可能，在radio这个状态里头会有其他的一些状态的变迁，还有什么状态呢。

time waiting，等着，waiting，等着，还有block的阻塞，那什么叫用什么情况下进入阻塞，synchronized，加上同步代码块，进入到那个代码块里头的时候，没有得到那个锁的时候。

我这段代码写了synchronize，但是呢我还没有得到那把锁，阻塞状态，获得锁的时候，诶跑到就绪状态去运行，在运行的时候，如果说调用了weight，调用了join。

调用了park进入waiting状态，调动了notify，notifall或者on park又回到rable状态，这个rable状态是ready和running的两个两个状态。

好的time的规定呢其实就是说过一段时间按照时时长来等待，过这时间的自己，时间结束自己就回去了，就这意思，sleep wait join techinos以及puntil。

这些都是关于时间的等待的这些方法，ok看看这些关于线程状态里面有没有同学有疑问的点，真的是说哪些是操作系统管理的，哪些是jvm管理的，这些全是jvm管理的，因为jvm要管理这些状态的时候。

也要通过操作系统，所以呢你你你你说哪个是通，哪个是操作系统，哪个是jvm，他俩分不开，j vm是跑在操作系统上一个普通程序，现场什么时候状态会被挂起，挂起是不是也是一个状态嗯。

对这时候这个就是没有讲操作系统的一个毛病之所在，但是我讲完这个操作系统这个可这部分你也就听明白了，很简单，就是running的时候，你在一个cpu上会跑好多个线程吗。

然后cpu会隔一段时间执行这个线程一下，隔一段时间执行这个线程一下，这个是cpu内部的一个调度，把这个线程扔出去，从装那个状态扔回去，这就叫线程被挂起，cpu控制它，这就叫线程被挂起，听懂这意思了吧。

就这么简单啊，别想那么多，就这cpu路到时间了，我可能隔十个毫秒运行这个隔十个毫秒那个，然后十个毫秒呢，我把这个线程扔出去，那个线扔出去，这个县城就被挂起了，杀死县城算不算terminated，算啊。

你现程都结束了，都已经杀死他了，当然算terminated的了，这个线程和操作系统里面的线程是一对应的吗，要看你jvm的实现，gm的以前的时间是一一对应的，现在是不是一对应，不好说。

最起码先程和里面的线程10000%是不是一一对应的，所以这个东西呃，其实想想看，你也没有什么其他的方式应该来讲啊，我虽然没有读hobo源码，但是在hospital的实现里头，正常应该就是一对应的。

连体的操作系统里有贪的东西状态，你去查一查，操作系统里都看，你这个，你操作系统啊，他也现在这个课程呢也在不断地往前进，理解这个状态是什么意思就行了，他们的规定就到时间了，加一个定时器嘛。

到时间了就会刺激它，ok回去你可以继续运行了，这意思啊。

好我们来看这个小代码啊，在ths lat头写了一个小小的代码，代码呢呃，怎么样得到这个线程的状态呢，是通过这个线程的get data这个方法就可以得到这个线程的状态，ta start嗯。

你比如说你刚开始new这个thread还没有启动的时候，那在什么状态呢，就像我刚才讲的那个那个那个那个图，这时候什么状态，new状态对不对，start完了之后呢是rable状态啊，然后t。join。

join，肯定他结束了，最后是terminated的状态，好不好看，嗯得等他结束啊，612345678 90啊，上面那个。

ok那么你自己如果想说是呃waiting和time waiting block的这些状态的时候，呃，像blog的那个状态，你很难测试出来，为什么，因为他block你那个在它中间做输出的时候，啊也可以。

你用另有另外一个另外一个线程正好在他等待的时候输出，必须得正好在这个线程等待的时候，另外一个线程做输出，这时候可以达到得到这个现状的状态，那那我再说一下啊，这个线程状态啊不是很重要的一个知识点。

问到的人也极少，面试问到的也特别少，我们作为学术上的研究，只能说是这样了解就行了好吧，当然学术研究有好处，你了解了这个现状状态之后，后面我要讲操作系统的时候，其实呢九分钟这个状态呢是一样的。

只不过在操作系统层面呢，它叫做进程的状态，ok，呃在linux上的线程的实现呢是叫做轻量级的进程，所以它和一个进程的区别并不是特别大，它是一个技能的概念啊。

系列 3：P160：【Linux】4四挥手抓包分析 - 马士兵_马小雨 - BV1zh411H79h

。Yeah。没录上是吧啊，视频我补一下啊。

嗯。は。好，怎么抓啊，断开链接，那么到你的叉 shell里的ctrorl D。

断开连接。win shaer这边就抓到了。

Oh。어。那么这部分。就是。就是我们收到的啊断开链接的这么样的一个过程。Oh。Okay。

好，这里头要注意啊。🤧。🤧嗯嗯。Oh。Okay。Oh。

Yeah。Yeah。Yeah。好，你还可以干嘛呢？你还可以直接点这叉子它断开。

啊，叉子他也断开。🤧。好，这个是我们刚才说的啊，你如何去抓这个数据分班啊。🤧好，看看大家有没有问题能不能抓到这个包啊。🤧Yeah。Oh。Okay。Yeah。Okay。Okay。🤧。Yeah。Oh。

Yeah。啊，感谢啊，快挂了。Okay。Oh。

系列 3：P161：【Linux】给图 - 马士兵_马小雨 - BV1zh411H79h

Yeah。好，那这整个的这个过程它是什么样的一个状态啊，是什么样的一个状态？就是我们建立好了这个。🤧TCP链接通道以后。啊，他们要开始去传书了。啊，他们要开始去传书了。呃，有一张图啊一张图。Okay。

就是讲啊这个TCPIP的状态的啊，我把图呢发给你。

あ。Okay。好。那么通过我们的数据加图啊，我们把它好好的去深入的去学习一下啊。

Yeah。🤧。Okay。

Okay。Okay。She。Oh。这个过程是重要的啊。Oh。Oh。

Yeah。嗯嗯。

🤧。🤧嗯。😊，那么上边啊以后你再记这张图的时候，这一张图就OK了。🤧啊，他又有。三卧四灰的过程又有SEQ和ACK的值啊，然后呢又有传输过程啊，下边呢是断开连接的过程。所以呢这一张图概括我们整个的阶段。

那么第一次啊第一次断开连接的时候，是建立在你原来的基础上呢。

啊，建立在你原来的基础上。🤧嗯。你这个数据啊在发送的时候，首先它要发送1个FIN码啊，FN码。Yeah。FIN码的时候啊，它也要发送1个SEQ。

那么我们看一看这个SEQ跟他之前的啊这个SEQ是不是啊相关的。啊，是不是相关的？🤧。先下个休息会儿啊。🤧不舒服嗯嗯。好。

系列 3：P162：【Linux】TCP断开连接的四次挥手抓包介绍 - 马士兵_马小雨 - BV1zh411H79h

手啊这个抓包的过程跟你说一下，在这里头需要注意啊，我们这里抓的这个包是由服务器提出分手的。所以你看你这个数据是10。0。132，就是讲师机啊，他先发了FM码给客户端，10。0。121。

那这里呢他就完成了角色的一个转变啊，是服务器提出的断开。啊，服务器提出了状态。🤧那么如果。如果你要想啊有同学说我客户端提出断开，就是你10。0。0。1提出断开，这时候怎么办呢？啊。

这俩数据包是不一样的啊，你要注意，如果是你提出，那怎么办？你就叉 shell。Okay。啊，chcha。叉C在连接的时候，你直接把叉CL叉掉。

，啊，比如说你这连上了，直接点叉子。啊，这是你客户端。😡，掉线了。啊，就相当于它会向服务器端会发送这个请求。所以你抓包的时候，这两个数据是不一样的啊，注意看啊，我给你演示一下。Okay。

。Yeah。好，我们我们的方式只是直接断开啊，或者在这里头你直接摁cttrol加D退出了，是不是？啊，好，比如说。你看我先来一下啊，咱们先断开，先连一下，让那有数据。

啊。那这时候你看这时候，比如说你直接点这儿链接的这就是客户端发起。

啊。这就也有。Oh。Yeah。

Oh。Okay。啊。或者呢你看现在连上了。啊，连上了，那你直接在右边点那个。

窗口啊断开它。

这也是由客户端发起。哦。好。

啊，这你自己要注意啊这你自己要注意。

Yes。Oh。Okay。好，如果是你客户端发起的，和你服务器端啊，跟你断开那个链接，你抓到的包个数是不一样的。如果是客户端，你发起的，你在这里能体现出的是其实是三个包。啊，是三个包。

但是如果是客户端发起，如果是服务器端，10。0。132，它跟你断的时候，它是四个包。啊。这儿要注意。但是不管谁啊但是不管是谁。我们在分析啊这个包的过程中，那么。他的数据传输都是一样的。

啊，我们简单的说一下，断开的时候。Okay。Oh。好，四次挥手，这个四次挥手是我们形象呢给人家的一个比喻。啊，谁主动对吧？你看。我们。给大家发的这个图，这里头有这里头就有4个班。啊。

那么咱们就按照这个图来说。这个就是。服务器端提出请求跟客户端。啊，来断的。所以服务器端充当了原数据啊，你现在这个叉 shell这边充当的是。目标数据啊，你看他谁到谁。🤧。对吧首先第一个他都要发送。

FIN码。啊，FM码。好，这里头啊发送FM码以后，你注意看啊，它是有1个SEQ的值的。啊，加SEQ。Oh。啊。Okay。好，那你看这个ACK啊，也就是说我这里的还有1个ACK。啊，ICK。

这个ACK的值啊这个ACK的值是你上边建立连接的时候啊，跟它有关的这个ACK。好，那么我们关注这里头的SEQ值，那我们抓到的是多少呢？注意看啊，SEQ。这个SEQ也跟你上边有关系。你看你建立连接以后。

这个SEQ值等于169。啊，是你建立连接好了，你们传输数据那里头的这个SEQ。他就不会再从零开始了。所以这里头的SEQ，我们这里头是等于169。Okay。啊。好。😊，第二次呢，他发送什么呢？啊。

他要发送。ACK。你看这里头谁确认了的呢？10。0。0。1啊。这台主机。刚才是谁发的呢？10。0。0。132啊，他发的这个。这个主机接收到了。FIN码以后。他要回应。回应他就得确认，那就发ACK码。

这时候的ACK等于170。啊。ACK的值。就等于第一步的SEQ。加一。说我发的这个确认是你刚才的那个链接请求，我确认要断开。啊，确认断开。然后他再给他发一个。向10。0。0。132发送FIN码。啊。

Okay。Yeah。好，发送XM码。最终。と。10。0。0。132啊回应。啊，回应10。0。0。1。1个ACK。Oh。然后啊这些他们就断开了。啊，断开了。所以你看该第三步，他发送FIN码的时候。

他也给了1个SEQ。对吧。这个SEQ值。你看看是多少呢？这个SEQ值等于153。啊等于153。然后最终在断的时候啊，你这个ACK字段的值。啊。就是在153的基础上加了一。Okay。

对吧所以这儿加一的是在上面这儿加一。啊。底下这个加一。Okay。是在第三步这儿加了一。好啊，简单的通过抓包给大家呢说了一下啊。

系列 3：P163：【Linux】TCP数据封装过程 - 马士兵_马小雨 - BV1zh411H79h

好，三次握手呢和四次挥手呢就给大家说完了。

啊。Yeah。这块呢啊不要求你掌握，它是帮助你啊。对于我们前边讲的这个内容的一个理解。好了。好。然后呢，我们需要干嘛呢？我们需要介绍一下啊。说你这个UDP在传输过程的时候啊，不是这个TCP啊。

在传输数据过程的时候啊，它是怎么样的一个流程？我简单的给你说一下。主机A。主机B。应用程序。Yeah。应用程序。那么我们刚才使了啥应用程序啊？哎，我们用的就相当于是SSH。啊。那么这个应用程序它会。

通过TCP。啊，通过TCP协议。去建立这个链接啊，然后再往下。啊。再往下是什么呢？再往下就是IP。啊，就是我们那个几层模型里头的。啊。好，然后再到底下，就是我们。数据链路层。对吧哎，数据链流层。

这是啥玩意儿啊？驱动程序。啊，最终到什么呢？最终到你的。网卡。啊。也就是你的物理层。啊。这个应用层的数据，比如说这儿有一条。对吧哎，这就是一个数据。它和我们OS在7层网络模型的时候是一样的。啊。

说每道往下走一步。他都会在原来的基础上。增加一个。豹纹。啊。那么到这儿，它就增加了1个TCP的头。啊，然后数据继续往下走。好，往下走走到哪儿呢？走到IP这块，哎，再加1个IP的头。Oh。啊。Okay。

好，然后最终啊这个数据比如说再往下走啊，底下加mag是吧？最终这个数据。啊，通过网络。把它传输过来。Yeah。Yeah。啊，是这样一个简单的一个过程啊，我这个图画的比较糙，但是这意思啊。

跟OSI的那个类似啊类似。只不过呢把7层换成这么多。Oh。

系列 3：P164：【Linux】UDP协议介绍 - 马士兵_马小雨 - BV1zh411H79h

这么发的。啊，A是这么发的。那拿到B以后，这主机拿到你这个信息以后，他再一层一层的把这个包反过程，一层一层再解出来。啊，这两个其实是一样的啊，这个过程咱们简单的说一下。

好啊，那么TCP协议咱就说到这儿啊，那么剩下的协议呢，UDP协议。UDP协议呢在我们平时使用的过程中也有。啊，也有。那么TCP协议我们说是安全的协议。啊，那么UDP协议呢，我们通常在用户传输数据的时候。

传文件的时候可以开很多。所以呢它是用户数据报文协议。啊，用户数据的报文协议。需要你记的就是仨字儿。不安全。Yeah。啊，面试的时候面试官就等你说这仨字儿。不安全。啊。就行了。那么如果我们写全了以后。

它就是什么呢？就是UDP协议是基于谁的呢？哎，基于IP协议的。啊，基于IP协议的。不可靠。不可靠。网络。传输协议。为啥不可靠？有可能丢包。啊，有可能丢包了。

但是它的特点就是哎我可以建立多个啊建立多个链接。啊，建立多个链接。通常在我们一般的有时候比如说你用局域网传文件，比如飞Q啊、飞歌啊，对吧？哎，传输文件的时候可以这样啊，这样呢能够加快你传输的速度。Oh。

所以我们也简单的啊。给你弄张图。看一下它的封包格式，但不做重点掌握。

就记住不安全仨字儿就行了。Yeah。比较简单啊。

这底下有字儿啊。

。

Okay。

好啊，UDP这个报文。了解即可，不做重点掌握。

。TheYeah。好。啊。Oh。Oh。好啊，那UDP型。

系列 3：P165：【Linux】常见的端口介绍 - 马士兵_马小雨 - BV1zh411H79h

好，还有什么玩意儿呢？需要你知道的呢？那就是ARP协议啊。ARP协议呢今天呢我不想讲，因为呢它需要你建立在IP地址协议的基础上啊，我们没有去讲IP地址。

所以说呢我们今天的内容呢把IP地址给大家讲了。啊，然后我们再介绍ARP协议。

，IP地址啊和IP地址分类。

好，这个是重点啊。需要你掌握的东西可能会多一些。好，那么在我们网络中，我们有几个概念需要大家知道的。首先第一个啊。IP地址。第二个，配合IP地址一般出现的东西叫做端口。啊，也叫应用端口。

好。啊，也叫应用端口。IP地址。啊，IP地址。那么就是找到你。啊，找到你。那么具体的啊应用端口就是你每个应用对外提供服务，要求你通过IP地址TCB协议键连接的时候，你找谁？啊。好，比如说我们常见的端口。

哎。21端口。FTP服务。说我们有一下载站点，专门用于下载的，它的端口就是21。啊。22端口。SSH协议的。Oh。走22端口，你看刚才我们抓包的时候，也抓的是22这个包。啊。诶。Yes。好。

那还有什么端口呢？哎，比如说还有我们25。对吧23。啊，21222325啊80。

443。啊，3306。

。3389。等啊。Oh。好。

Yeah。那么你需要知道的就是啊这个端口是区分应用的。啊，23有没有人知道23是什么？有人晓得不？啊。23啊t net。我们可以用tnet这个命令啊，将来测某一个端口通不通。哎，tnet这样一个应用。

那25端口呢？25这个端口是邮件的端口。啊，SMTP协议的。是邮件的。发邮件的端口。那么邮件呢它是一家子啊，要说我给你说几个啊，邮件除了25，还有109。

啊，109。110。143。这几个都是邮件的端口。

，Oh。啊。标一个色给你啊标一个色儿。这一家子全是邮件。109是什么呢？109呢就是POP协议，是收件协议啊，POP2就是109。啊，就是POP收件的第二个版本啊。

POP3就是110递增的143是什么呢？143是IMAP。IMAP协议。啊。都是收件协议的，所以邮件呀四个就够了。Yeah。啊，这四个都是邮件的。邮件协议啊。那还有呢啊还有呢。那么。还有呢就是什么呢？

比如说啊我带了SSL。

啊，就是我加密的以后，那么在这里头又会发生变化，叫SMTPS加了这S以后啊，就是安全的。那安全这个端口呢465。

啊，465。995POP3的。

啊。993。

这将来你也可能用到啊，反正我多给你说10块钱的。Oh。啊，头怎么这么晕呀？😔，Okay。465啊，刚才我说了。SM。TPS加S走的就是。SSL证书。啊，就是安全的协议。Yeah。

995啊995呢就是POP3啊的安全端口就是POP3S。啊。993993呢就是IMAPPS。啊，后边都是SSL协议啊。Oh。这块呢大家有所了解即可啊。那么80端口是干啥的呀？80端口就是我们访问网站的。

哎，这俩端口你必须要搞定HTTP。啊，下边是HTTPS。Oh。啊。比较小的这些端口号啊，一般的都是系统占用的。比较大的端口号一般都是应用占用的啊，所以这个呢大家也要知道啊。

那么这个HTTPS1样的是基于安全的啊，考虑安全的链接。现在呢咱们所有的网站都强制使用。Oh。啊，强制使用。

那么你遇到一些高级的浏览器啊，这个协议里头它256位AES加密。

啊。更有狠的1024位AES加密啊，现在最狠的2048位AES加密。

像谷歌啊，现在这两种。人家都快给废弃了。现在人家谷歌玩的狠的都是底下这个。哦。所以你用谷歌浏览器的时候。他就对这个网站校验要求比较高。如果你达不到人家谷歌的要求，他直接就给你报该网站不安全。啊。

那么还有什么呢？3306的它是什么呢？哎，它是我们在下一个阶段大家要学的。比如说买circle数据库的，当然端口还有很多啊，因为时间原因我就不在这儿给你扯了啊，光这端口要都介绍完了啊，能讲一天。

3389大家都用过windows远程登录啊，windows远程桌面的。啊，远程桌面的。好吧啊，我简单的给大家写几个啊，那还有还有啊再再再说10块钱的啊。

哎，53端口。

啊，号小的往上排呗53端口。不行啊，在这儿吧。

53港口是是干啥的呢啊。DNS。默认的。好。啊，DNS服务的默认账号是53啊。还有其他的啊，在这儿呢我就先给你补充这么多啊。Okay。好啊，这些端口你呢往脑子里头啊稍微记一记啊，面试的时候呢。

他会跟你聊。所以说呢我们呢啊在讲课的过程中，我们是贴近于实战的，就是人家问你啥啊，我们都给你去介绍。如果不大常用的啊，那些玩儿咱咱就少少说啊。好，给你呢一分钟的时间。

你快速的啊把刚才咱说的这些端口记一下啊。Yes。Oh。Yes。啊。把他远了。😔，啊嗯。完蛋。

。啊，好。

。不舒服啊，赶紧讲赶紧讲，特别不舒服啊。

万一一会儿晕倒了就完蛋了。赶紧说啊，那还有哪些协议呢？啊，我再给你补充呃。再说三个啊再说三个，我觉得以后面试够用了啊，139。139。

呃，数据库的啊，他还可以问6379。

Yeah。

啊，再来个大点的8080。Oh。好，6379是谁？Rds啊，现在非常流行的啊，一个专门做缓存用的。

啊，我们就要缓存服务器。所以大家呢到后边呢也会遇到。8080啊8080可以做代理服务器。

啊，也可以做tom cat。139啊139经常会有一些漏洞SMBs共享的。

Okay。尤其是windows啊尤其是windows，经常可能会遇到这种情况啊，它是共享的。

Oh。好，长见端口我给你介绍了一遍啊。

系列 3：P166：【Linux】IP地址分类与IP地址分类开始字段 - 马士兵_马小雨 - BV1zh411H79h

好，IP地址叫逻辑地址。啊。标识网络中。主机用的。啊，原则上。Yeah。在一个网络中。主机的IP地址。是唯一的。啊。那么这个目的是防止冲突。Yeah。啊，防止IP地址冲突。

所以原则上是唯一的那有同时我就想改成一样的，行不行？行？啊，行。但是它会冲突。所以这里头也就告诉你。逻辑地址是可变的。啊，可变。好，IB地址分类。从协议上啊大的面上可以从协议上分。啊，分为IPV4。

可以分为IPV6。Okay。那么现在呢我们面临着IP地址枯竭的啊这种方式，指的就是IPV4这个协议。啊。Okay。那么IPV4呢，它是什么呢？啊它是由32位。啊，32位。十进制数。一。点儿隔开。啊。

分四段。啊，也就四部分。表示。那么这种方式也叫点分二进制。好。哎。举个例子啊。举个例子。大家见到的192。168。0。1。你见到的192。168。1。1。啊，你见到的10。0。0。1。哎。

你见到的172。0。0。1。你见到的127。0。0。1。啊，等。啊，你见到的114点114点114。啊，你见到的233。5。5。5。你见到的233。6。6。6。啊。你见到的39点105。2。1。

这些都是。啊。Okay。那么在这里头我们介绍了点分二进制。啊，每一个部分。用8位来表示。啊，每一个部分8位。啊，所以每一部分能表示最大的数。256。啊，但是从零开始，所以这值的范围就是0到255。好。

那么1个IP地址。啊。那么我们就详细的来说说IP地址的构成。Okay。I地的构成，这是重点。Good。Okay。那IP地址啊。它由三部分来构成。啊。这个东西有很多人都不知道。很多人都不知道。啊。

那么由哪三部分构成呢？首先第一部分叫做类别。Yeah。第二部分叫做网络标识。第三部分叫做主机标识。Okay。类别啊。网络标识。这个颜色有点骚啊，主机标识。啊，还好落着了啊。好。这三部分啊类别说的是啥？

用来区分。啊，IP地址的。类型。网络标识。你查一些文献，一些资料，他们也可以称之为网络位。啊，网络位主机标识也可以称之为主机位。Okay。啊。对。那么网络位是干啥的啊，我们也称之为叫nightwork。

ID。啊，主机位host IDD。Yeah。Okay。Good嘛。好。那网络ID网络位，那么就是表示。主机所在的网络。啊，house IDD。就表示。主机在。网络中的标识。哦。

这个就是我们所说的IP地址的构成。好，今天呢我们先简单的介绍IPV4啊，明天呢我再给你介绍介绍IPV6，省的呢你学多了以后容易混淆。好。第二个IP地址在分类的时候啊，需要你知道的。哎。Okay。

就是IPV4。地址还可以细分啊。Yeah。Hello。好。在这里头，通常我们IPV4的地址可以分为五大类。啊，五大类。那么被称之为。A类。啊，A类。B类。犀类。D类和E类啊。Yeah。

所以我们也可以说啊A类地址B类地址啊。こ。好，那么呢我们一个个给大家介绍一下啊，A类地址。A类地址。那么A类地址啊。Yeah。好，它的网络标识位。啊，网络标识。

那刚才我们说了IP地址不是主机网络标识和主机标识吗？对吧？哎，它的网络标识占。在。一个字节。啊，一个字节。最高位。为0。这里的最高位指的就是网络的类别。啊。好。A类的网络地址。有128个。啊，允许。

不允许。支持127个网络。每个网络。大约。啊，大于允许。有。1670万台。主机。啊，1670万。啊。这一般都是属于超大型的了啊，超大型的了。好，我们看看这个A类地址长啥样啊，A类地址长啥样。

A类地址刚才说了啊，网络标识占了一个。

Okay。好。Oh。好，画1个IP地址啊。好，这就是1个IP地址。我们说了IPV6的啊32位，从零开始，0到31表示32位。啊，表示32倍。刚才我们又说了啊，说呀他前边。用于做网络标识的占了一个字节。

啊，一个字节。一个字节是多少位呀？😡，对吧？七位啊8位所以0到7啊，0到7，这是一个字节，后边就是8到31。所以如果我这么画的话呢，0到7，这就是前八位。Okay。啊，前八位一个字节。

那么在这个一个字节里头，这八位啊，它又拿出了一个字一个位。拿一个二进制位啊。做网络标识啊，这个标识就标识成0。所以这零这就叫网络标识。啊，零这块叫网络标识。那么这个绿色部分1到7啊，这个位置。

我们就称之为网络标识。啊，网络标识。这里头7位。啊，叫网络标识。也就是我们所说的网络位。啊，后边标识。主机位。啊，主机位。也就是我们所说的。主机标识。啊，主机标识。好。

那么这个A类地址我们通常用作为啊这种超大型的网络啊，就可以用到我们的互联网上。

啊，那么通常在我们去使用的时候啊，不会分配给我们啊。你包括你的公司不会给。那么像这样的网络，一般的都是运营商啊啊然后咱们这些internet的骨干网络啊才能给你。

这样的网络IP啊，否则家用的不可能给你个A类地址，用不起啊，那是巨大的资源浪费。

。A类地址啊。通常。用于。啊。网络运营商。啊。对吧哎，internet。就是我们的互联网。主干网络。啊。或超大型公司。啊，比如谷歌。啊。比如IBM。Okay。啊，等。那这些公司人说为什么谷歌呀啊。

你像谷歌的服务器遍布全球，每个国家基本上都有。2。哎，这就是A类地址啊。那么B类地址。Wish。B类地址。Oh。还有C类地址。B类地址啊啊。😡，Yeah。B类地址呢其实呢跟A类差不多。啊，跟A类差不多。

那么也就是前两位。啊，我们也称之为。高位。啊。高位，那么也叫做高两位。🤧嗯，嗯。

从编程的角度啊，我们再给大家介绍这个网络位的时候，由右到左从低到高。所以这边啊左边这边叫高位。右边叫第一位。啊，所以一说高两位就是从左边往后数俩。啊，就是高两位的意思。

好，那么。B类地址呢就是高两位啊，是表示它的网络标识。Okay。Okay。高两位来表示网络标识。Oh。好。中间儿啊。16位。啊。那也就是说钱啊两个字节。啊，两个字节。表示。网络。哦。标识。后边两个字节。

表示。主机标识。啊。两个字节两个字节，也就是前16位。和后16位。啊。那么B类地址通常。用于。节点。比较多的网络。啊，比如说区域网。啊，所以前两类地址都用的比较大。啊，都比较大。好，那我们也画一下啊。

我简单的也给你画一下。

B类地址。哎，复制一下啊，C类的。好，咱先说B类啊，32位对半匹。好像画的不是多对半啊，是这意思吧？这边16位。这边16位。啊。0。31。啊，0321。那么中间撇这多少呢？16位。

16就是0到15表16。啊，后边这边是16到31。Okay。然后前两位啊高两位，那就。高一位。高两位。啊。一。2。Yeah。啊，12，那这就是标识，就是注意啊，它B类前边是一。后边是0。

说在它转化成二进制，在这数据存储时，一遇到这儿啊，10就是B类的啊，遇到零就是A类的。啊，然后2到15这是多少呢？16刨2，这是14。所以这前14。哎，这14位。网络标识。啊，后边这16位。主机标识。

Yeah。啊，这就是B类地址。

好，那么这个B类地址啊B类地址。我再多给你说两句啊，说10块钱的。哎。B类地址它允许有。16000个。网络。每个网络。大约啊允许有。66000台。注地。啊，所以这个东西呢66000台。

那你一时半会儿的你也用不着。啊。好，跟我们息息相关的很重要的啊C类地址。C类地址是最常见的。网络标识位。啊。也就是说，高三位。啊，高三位。用于表示类型。啊，用110。表示。网络标识占三个字节。

主机标识占一个字节。加一块儿正好是332位啊。一个字节8位。好，前边那你既然前边网络标识占三个字己啊，那就是24位，对不对？所以C类地址啊支持有多少呢？大约有。20多万个地址啊，20。啊，20。呃。

这是多少来着？这值。我记不住了啊，大概是20多万吧。啊。大约20万个。网络。啊。那么最后一个字节，那就是8位呀啊最后一个字节表示主机。啊，标志主机。那么最大值我们说了，最大值是256。

但是实际上能表示254个主机。啊，最多能表示254个。Okay。好，这句话怎么来的，怎么去理解？你不说能表示256个吗？但实际为什么又254个？因为有一些。特殊的IP地址。啊，用不了。Okay。

比如说这个值是从零开始到256啊，到255。首先第一个这个零你就用不了。啊，零就特殊。通常不能分配给主机。啊，他表示IP地址断。通常我们用来来表示一个段啊。比如说192点168。0。0啊。

这就表示这个地址断，但是它不分配给主机，所以你256这就减1。把零减去，这就剩255了。另外有一个啊255这个数也不能分配给主机啊，这个也是特殊的。啊。在网络中，这个255它是广播地址。啊，系统预留的。

他用的你也用不了，所以256又键一啊，这是254。所以192。168。0。255这样的数据啊，你用不了不分配给主机的广播地址。啊，所以你就记住啊，掐头去尾就行了。

掐头。啊，掐头去尾法。前面跑一个，后边跑一个啊就行了。哎，这是咱们说的C类地址啊。呃。呃，通常啊就是我们小型网络啊。你看你们家里头啊，对吧？哎，家里头就是。对吧比如办公室。小型局域网。啊，小型菊有啊。

别大了啊，小型局吧都可以。

那么C类呢，这个IP地址呢，我们也给大家画一下啊。大概是这样的啊，分三份嘛。前边都是标识网络的，后边是标识主机的。Yeah。Yeah。啊。那么还是那你32位呢，前边是0，这儿到31。Okay。啊。8位。

啊。那么这儿呢他占了多少呢？三个字节啊23。后边24。啊，欧罗尔斯。那么高三位啊，24减321，也就是21位。啊，表示标识去了，高三位把高三位拿出来。个二。高2。Call3。啊。那么他的代号是。1。1。

了。一。2。3。Okay。好，前边表示支持多少个网络，后边支识表示多少个主机啊，那这就是A类。B类。死咧。

。

Yeah。

哎。

。

。好，还有D类和E类啊，D类和E类。D类地址呢这个地址呢都比较新。啊，那么地类呢一般呢就用于多波地址。啊，我们也称之为多波地址。啊，E类地址呢现在基本上还没什么用。啊。所以E类呢现在都是啊此类地址。

为保留地址。Yeah。啊，E类地址呢就是保留地址啊，那根据往下推，D类呢就是在啊你C类的基础上高4位啊，就是前四位呢，它是用来表示什么呢？啊，用11。10表示。啊，表示用于主播的。

比如说做视频会议啊等应用，就得实现这个主播的技术啊。所以说呢他这里头主播地址，它这么占。啊，他这么站，就是高。高4位。表示网络。啊，标识。1110。后边啊24位。就是多波地址。啊，多个地址。

我就不给你画了。啊，我就不画了。E类呢这玩意儿现在呢那个你哎呀。了不了解，我觉得意义不大啊，也是高四位。网络标识类型啊，注意啊，高四位1111。啊，知道这儿就得了。好啊，然后哎12点正好啊。

好，然后还有一个知识点，我说完了咱就吃饭啊，你忍2分钟，一分钟就能说完。IP地址的。分类开始字段。啊。好，A类。B类。C类。D一类。E类啊，我们先说C类的啊，最重要就是什么开始啊，192。啊。

192开头的。到233。你只要见到这样的地址，开头的都是C类的。啊，A类地址呢是从什么时候开始呢？000。啊，到127。B类呢就是。128啊到191。D类啊。224。到239。E类。240到255。は。

好，重点掌握C类。啊，其他的了解即可。

好，那咱们今儿啊就说到这儿。

系列 3：P167：【Linux】IP地址开始字段 - 马士兵_马小雨 - BV1zh411H79h

好，关于IP地址啊，这个分类开始字段A类B类、C类、D类E类啊，A类呢是000到127，B类呢128到191啊，C类很重要，192到223。D类呢是224到239，E类呢是240到255啊。

那么重点呢我们掌握C类地址。

Oh。

系列 3：P168：【Linux】知识点回顾 - 马士兵_马小雨 - BV1zh411H79h

好，我们首先呢知识点回顾一下啊。那上一节课呢我们主要是什么呢？我们通过抓包软件。深入的理解了。TCPIP协议啊这样的一个封包。TCP协议。

送吧。啊。我们拿到这样的封包以后，通过封包啊来看。

PCP协议在建立连接。过程中啊。对，三四握手。

啊，三个握手。

并且呢我们能够。查看啊，断开链接，四次挥手。

啊，通过这个来看这个过程。

。

好，那昨天呢我们就给大家介绍了IP地址。啊，介绍它的分类。我们已经知道了啊，可以从协议版本上啊有IPV4。

哎，IPAV4的版本啊，还有IPV6。

得紧咩。Yeah。

啊。从IP地址的类型啊。从类型上分啊，细分对吧？通过网络位、主机位啊。

那么所以我们也介绍了。

IP地址的。定义。

Okay。类型。加上网络标识。

加上主机标识。啊。所以IP地址干干这个用的。

。

分类呢我们看了A。

B。C。D。

E。Oh。

啊，又分这么多泪。Okay。

然后呢，我们掌握了啊。IP地纸。起始自传。

Oh。

好，简单的给大家介绍了一下啊，它的起始字段，这是我们上一个节课讲的内容。

系列 3：P169：【Linux】IPv4和IPv6介绍 - 马士兵_马小雨 - BV1zh411H79h

好，在昨天的基础上啊，我们。需要深入的去学习。啊。那么今天新增的一个内容呢，首先第一个啊，那么就是对。IP地址。版本的细分啊。我们介绍了IPV4，那我们也要介绍一下IPV6。

因为现在一些大厂呢已经开始了。啊。使用它了。后边这个V4V6啊，就是IP协议的啊后边的这个版本。那么我们说到了啊IPV4呢，它是32位。啊，中间呢用点隔开。啊，分四段。来表示啊。

对吧所以我们说的点分二进制的形式给大家去表示了这个。啊。好了，这是第一个啊，咱们给大家介绍到了这个IPV4。啊，和MPV6。啊。那么除此以外呢，IPV6。啊。也已经在我们平时的啊这个工作中啊和生活中。

大家呢也能够见得到。好，那么IPV6长啥样啊，你可以呢在你的。啊，在你的这个右下角的小窗户这啊，网网卡标识这。

啊。状态。对吧哎，这里头就有IPV6的地址。好。

复制不了啊复制不了呢，我们到。终端线。输入IPconfi斜杠O。啊，斜杠O。那么本地连接的IPV6的地址。啊，IPV6的地址，这里头就有。啊。对吧哎，上边也可以啊，IPV6的地址。

你看你那note8都有IPV6。对吧。好啊，这是IPV4和IPV6的地址。好，到IPV6了呢，我们简单说一下啊，简单说一下。那么。IPV6和IPV4啊，他们在爆文格式上略微有所不同。啊，那么IPV6啊。

简化了。豹纹格式。啊。は。好，在原来的版本上进行升级。啊，那么简化了报文格式呢，它字段。只有8个。啊，只有8个。那么。好，用IPV6的好处呢能够加快。报文转发。提高。数据的。吞吐量。哦。

这是用它的一些好处啊。好，然后能够干嘛呢？能够提高安全性。身份认证。和野私。啊。我也是。呃，身份印证呢和隐私权呢是这个IPV6啊。关键的一个特性。Yeah。但是呢我们在国内啊，你见到的还是少啊还是少。

但是呢未来呢是个趋势啊。现在呢还是传统的IPV4多一些。明白吧？啊，那么在这个IPV6呢，它支持更多的服务类型。啊，所以呢我们有一些在学习的这些协议啊，将来呢它也可以继续演变啊，演变到支持这个IPV6。

那么这里头就是我们1个IPV6的一般格式啊，那么它的表示方式。它的表示方式，那么跟我们传统的表示方式是不一样的啊。那么IPV6呢，它一般采用。啊，它一般采用了什么呢？啊，这个叫冒号。十六进制表示法。

Okay。啊。十六进制表示法12345678。冒号隔开刚才不是说了吗？字段有8个啊。分。8个字段。啊，8个字段。用。冒号隔开。啊，然后他表示的这些数是十六进制数。아。哎，那我们说了说IPV4是32位啊。

IPV6是多少呢？IPV6啊是128位。啊。那么地址空间就比啊IPV4。增大了296倍。啊。所以IPV4啊，我们这么多年了，可能会面临着地址枯竭的问题。哎，IPV6就能很好的解决这个问题。哦。Okay。

好，这个是我们说的IPV4IPV6啊，你掌握这些即可。

系列 3：P17：【多线程与高并发】锁的概念 - 马士兵_马小雨 - BV1zh411H79h

下面呢我们来开始讲这个siri关键字，新的两个新出的关键字呢，估计不少同学也是那个耳熟能详了，不过呢作为复习还是要复习一下，好吧好，第一个呢是多个县城去访问同一个资源的时候，需要对这个资源上锁好。

为什么要上锁这个概念，有没有同学不能理解的啊，为什么要上锁，必须得上锁，这是一马桶，很多县城过来去访问，必须得等一个线程执行完了，另外一个县城才能执行啊，不然的话呢不然的话你自己去想象是吧，嗯o。

就是访问某一段代码或者某一个临界资源临界区的时候啊，这个时候呢是需要有一把锁的概念在这儿的，这个锁的概念呢，我估计有的同学可能又会跑个问题，没关系啊，咱们使劲儿问啊。

我看看我哪哪有问题没给大家准备到位了，什么意思呢，为什么要上锁呢，其实关于为什么要上锁这个概念估计多少同学也是知道的啊，就举一个最简单的例子呢，我们用一个对一个数字来做递增啊，这个数字最开始是零。

两个程序对它一块来做递增，这个递增的就是把这个零的往上加一了，第一个线程如果两个线程共同访问的时候，第一个线程一读它是零，然后把它加一在在这自己这个县城里面的内部内存里面算算算算啊，零比加个一变成几啊。

变成一，然后这个一还没有写回去的时候，另外一个线程来了一堆还是零，读到自己的内存里面加了个一，变成一了，好第一个线程把这一写回去了，第二个线程又把这一切回去了，本来正常加了两次。

结果呢你最后的结果只得到了一个一，所以在对这个线程对这个数字进行递增的过程中，必须得上把锁上班所怎么上呢，就是说我这个线程在对这个数字进行访问的时候是独占的，不允许别的线程来访问。

关于别的线程来对它进行计算，我必须得给他加完这个一之后，下面这个线程才能过去，拿到这个一之后继续加。

ok但是在这儿呢有一个特别特别容易让人，有一个误区吧，应该说而且呢很多的很多的文章里头，还有很多老师讲的时候啊，他就一带而过，我在这儿呢，我把这个think的，synchronized啊，给大家画个图。

这个sim到底think的是什么，呃我拿我刚才说的这个概念，就这儿有一个数字一，然后呢两个线程去访问它，那么有有的老师呢就会聊说那个这个呀就是这是第一个线程啊，呃这是第二个线程。

有老师就会聊说这个呢就是把把把这个进行锁定，把它进行锁定，听我说啊，把它进行锁定，这件事是不对的，是我们是有一把锁在这儿呢，是有一把锁的，挖一下看能不能画出来诶，a这也太不像锁了，这个壶好吧。

我不管了好，我们其实是有一把锁的，听我说，但是这把就是说我我我任何的现场去访问这个对象的时候，或者说去访问这个数字的时候，是必须得看这把锁是不是属于我，是不是有我战友，如果有我占有，我才去对它进行操作。

如果不由我占有，不再进行操作，而这把锁在内部底层上是怎么实现的呢，有的老师会说啊，直接就把这个数字进行锁定，千万别这么弹，实际上在本质上它并不是对这个数字进行锁定的，他对谁进行锁定的呢。

你可以任意指定对谁进行锁定，你想锁谁就锁谁，看这里，我的第一个小程序是这么写的，count等十，然后让count减减好，如果说你想上了把锁之后才允许对count减减进行访问。

比如说我得上把锁才允许执行下面这段代码，那这个时候是怎么做呢，你可以new一个object，object o等于new一个object，然后写synchronized的o。

这意思就是说对这个count进行访问的时候，我得去看o这把锁，所以这里锁锁的是谁，锁的是，但是我们平时也说锁定了一段代码，锁定一段代码的意思是说当我拿到这把锁之后才能执行这段代码。

所以要说的比较细致，比较到位的话，应该是这里有一把锁，这个锁是谁呢，是o o这个对象，但是拿到手表锁之后能干嘛呢。

能执行这段代码。

如果说讲的更加底层一点，我原来讲过一堂公开课，这堂公开课呢叫hash code与mark word，好在那些公开课里面我讲过这个syronized的底层是怎么实现的呢。

其实sironized的呢在底层的实现没有任何要求，就是java虚拟机规范里头没有规范说synchronized你必须得给我怎么实现，不是他没有任何要求，反正最后的结果不论你怎么实现呢。

你只要说必须得加入列表锁之后才能执行下面这个代码就ok了，那么hob实现呢，hob是在一个对象的头上面，这是我们new在堆里面的一个对象，这个对象的头上面，这个对象头呢是64位。

这个头上面呢有拿出两位来来记录着这个对象是不是被锁定了，是这个它是这么来实现的啊，这个呢叫mark word，感兴趣同学去找一下，看他怎么实现的，它是有两位啊，两位来实现。

这两位的组合呢分别是不同的锁的类型，好这是他的具体的底层实现，但是呢是需要拿到这把锁之后才去看a下面这段代码我能不能运行，所以锁定是锁定的某个对象，不管是哪个对象，你锁定它就行了，那么新时代这把锁呢。

呃而且它会有一个所升级的概念。

系列 3：P170：【Linux】特殊的IP地址介绍 - 马士兵_马小雨 - BV1zh411H79h

IPV4和IPV6啊，然后呢我们需要。

知道的内容就是哎我们在使用的过程中，我们会遇到一些特殊的IP地址。

Oh。

好。Oh。Yeah。Yeah。好，特殊的IP地址有哪些呢？啊？首先第一个我们最常见的啊。比如说我见到了一个哎广播地址。192点168点1。255。

。192点168点1点啊，不点0。255。啊，你见到这样的地址，哎，这就是他的广播地址啊，通常一般情况下啊，后边这255是。

，Okay。除了这样的广播地址以外啊，还有一些特殊的子网掩码。哦。说你经常能看到这样的，比如说255。0。0。0。

啊。255点255。0。0。

。255点255。255。0。

啊，这样也是特殊的IP地址。

。啊，还有什么呢？还有还回地址。啊。也叫本机的IP地址。说你将来在测试的时候，经常会遇到这个还回地址，127。0。0。1。哎，这些都是特殊的IP地址。

啊。然后呢，那你见表示全网断。啊，全网赚。0。0。0。0啊，所以不要觉得说0。0。0，这都不是IP了，它也是啊它表示的还特别特殊，它可以表示整个网段啊。

什么意思？通常比如说我们在阿里云上啊想表示任意一个。任意1个IP地址。就用0。0。0啊来表示。所以这一块啊，咱也给大家简单的介绍一下啊。那么还有呢啊还有。啊，还有一些呢，比如说你到这个。啊。

你到这个这个这个这个呃。宾馆。啊，或者你坐坐这个公交车，你看到这个wifi啊，经常看到这个wifi会出现问题，对吧？或这个路由器没有给你正确的分配这个IP地址。

所以你经常还会遇到什么什么169啊点254呀等等等等啊，这类的所以呢我们经常还会有一些啊比较奇葩的啊，这些个特殊的IP地址啊，特殊的IP地址。好啊，简单的介绍了几个啊。

好，还有一些啊还有一些是DNS的。也是我们平时呢遇到的啊，我也给你说一下，比如说114点儿。

114点114啊点114。

Yeah。阿里的233。5。5。5。

233。6。6。6。Oh。

那么还有比较特殊的啊比较特殊的。啊，特殊的是什么呢？一堆255，也就是32位，全是一。啊。钱是一啊，有限。啊，广播。

好。

还可能遇到这样的更狠的啊，255点255点255。255。啊。也叫限制广播地址。啊，都是255。啊。广播地址啥意思啊？大喇叭所有人都能听见啊，就是你的主机位全是一啊，那就是这样的特殊的地址啊。

。好，还有呢。啊，1。2。点4点8。啊。

8。8。8。8。

啊。202点106。0。20。

Yeah。哎，就是你去了这中国联通啊啊，哪儿的？啊，哪儿了？哎，就会遇到这样的特殊的IP地址。啊。

好。好啊，还有没有呢？还有呢啊，比如说这个169。254。哎，当你有时候你的这个这个这个这个DNS如果啊不是你去这个这个。

宾馆呀啊哪儿的，如果说他给你分配的这个IP地址啊。啊。DHCP一般都是DHCP给你分配的。分配完了这样的话呢，一般有时候你就上不了网啊，比如说169。254啊，点后边是点0。0的啊，这样的。

通常呢一看到169开头的那你肯定就上不了网。

Oh。啊，经常会出现什么呢？住宾馆。Yeah。那这种情况怎么办呢？啊，那一般的情况下出现在你那个路由器。啊，路由器假死啥意思？就不响应了啊，你重启一下。把电源重启一下啊。就可以了啊。

还有一些特殊的IP地址是什么呢？比如说主播地址啊，主播的。

你见到的比如说224点0。0。1，这就是主播地址。啊。

不需要死记硬死记硬背啊，把这个东西呢了解，混一点熟啊，说不要说这个将来看到1个IP地址长得比较奇怪。啊，直接就蒙圈了啊，这里头呢还是有用的。好，关于一些特殊的IP地址啊，我就简单的给你说这么多啊。

平时呢在大家的工作中。哎，平时你在工作中注意积累啊，注意观察。还会有很多奇怪的啊这些内容。但是这些个啊这些个就够我们用的了，哪些需要你着重的去掌握它的呢哎。

127。0。0。10。0。0。0啊，次重点这些常见的DNS。将来到单位了，如果网络慢啊，把它搞一搞子网掩码。子网掩码。啊。3个255这个C类地址的掩码把它搞明白。

啊，169254。0。0。0的这样的了解，244。0。0。1的了解。啊，8。8。8的这个谷歌的啊DNS啊了解即可啊。

呃，广播地址啊广播地址。

掌握。好，特殊的IP地址呢就给大家说这么多。

系列 3：P171：【Linux】特殊的IP地址补充 - 马士兵_马小雨 - BV1zh411H79h

哎。还得再补一个啊网关地址。

我们所说的网关地址啊，一定要注意啊，你这个网关地址啊，它也是一个主机。啊，就是你一台路由器，它也会分配1个IP地址，它也是一个主机啊，它首先它是一个可用地址，所以我们通常见到的192。168。0。1。

啊，这就是起始的第一个有效地址。

然后获者192。168。0。254。啊。

，这里头选一个。作为网关地址，我们通常是这种情况啊，通常是这种情况。那么有通常就有不通常啊，有的同学说我用一个。192168。0。2行不行？可以啊，可以，没问题，那也对。啊。

但是我们通常都用第一个或最后一个掐头去尾，这样的话呢好记。啊，主要是好记。

明白了吧，哎，主要是好记。啊。

那还有呢表示网段的啊部分网段的。

表示当前网段哎。

，说我现在IP地址是1921680。100。

那么如果要表示。当前你所在的网络。啊。那么也就是说我用192点168点0。0来表示。

这点0。0啊就表示你当前所在的网络。

系列 3：P172：【Linux】私有IP和公有IP的介绍 - 马士兵_马小雨 - BV1zh411H79h

除了从协议版本上分，我们也可以通过国际通用的办法，可以分ABCDE类。那么还可以对IP地址进行细分。比如说我们这里头从它的用途来说啊，还可以分为私有IP。

和公有IP。Oh。好，这又多了一个分类哈，私有IP和公有IP。那么我们先说说私有IP啊。公有IP。这两个东西呢就对应了两个网络啊，私有IP就对应的私有IP的网络。公有IP呢就对应着公有IP的网络。啊。

私有网络是干啥的呢？哎，就是不接入。私有网络就是自己用的。内部网络。就是我们通常的内网。不接入。啊，不接入移动互联网啊。啊。就是你通过外部的，你访问不了。好，这就是私有网络啊。

咱们所说的这A类、B类、C类，如果再细分，它们都属于啊。

像咱说的A类地址。B类地址。对吧？C类地址，这样的地址等啊等。

Okay。都可以是。啊，比如说A类的是吧，10。0。0。1的这样的哎，私有的对吧？C类的，你那192。168。0。1的啊私有的。这些IP地址你在外网去访问他的话，都不能直接去访问。啊。

都不能直接访问得到。所以这些东西都是我们自己私有的IP地址段啊，私有的IP地址。那么公有网络很显然啊，那么你就接入的是啊。就是在移动互联网啊，移动网络和互联网络啊。网中的主机。啊，有公网IP。

在全球可访问。所以如果你要有公网IP呢啊那就比较方便了。通常呢都是咱的服务器网站。

啊。比如服务器。Oh。Okay。诶。全球都可以访问。当然这是理论上的啊。在我们国内。部分网站。受限。这是人为造成的啊，其他国家都可以的。Yeah。比如说youtube你上不了，比如说谷歌你上不了。啊。

比如推wi特你上不了，比如facebook你上不了啊。那么我们就需要使用一些。科学丨上网的啊办法，你才能访问。

啊，那么这样暴露在你的互联网上，谁都可以访问，那也就是会造成你的安全问题。啊。一是安全问题，2一个是性能问题。🤧嗯。🤢，啊。哎，安全问题呢，那你电脑要这个这个配置要不够高的话啊。

可能呢你直接就被人家黑掉了，对吧？所以你这里头有什么数据啊，什么就不行。第二个呢，访问谁都可以访问，访问的人多，那你这个性能那也不行。2。所以我们怎么获得公网IP地址呢？哎。第三个就是费用问题。

也就是说成本。啊，比如自承本资费啊资费问题。说你装一个中国联通家用的都不给你报一个公网的IP地址啊，企业的才会有。那你去办这个的时候呢，特别贵。啊，费用高。一个公网IP地址。啊，一年。就一个地址。

一年应该在。4万啊左右。Oh。啊，我们也可以通过一些，比如内网的主机，让外网能够访问。比如说我们通过啊动态域名解析是吧？通过内网穿透等等等等啊。

好，我们简单介绍一下。那么如何来获取你一台电脑的公网IP地址呢啊。比如说你买一台阿里云。啊，比如说你买一台阿里云啊，然后。阿里云上的主机，那你就是公网都可以访问。他会给你1个IP地址。

比如39105点2。1。啊。哎，这样的话就典型的一个公告IP机制啊。那么我们普通老百姓这些电脑，实际上呢你映射出去呢，你也有是一个公网的IP地址啊，也有的那我们怎么来拿到自己的公网IP地址呢？

你就输百度，然后输IP。

对吧然后呢他就会啊在这儿显示出来你的IP地址。这个地址就是你的公网IP。啊，你的公网IP地址。那么或者呢你输IP138这网站通过这个网站上去以后。这儿可以进行查询。啊，这可以查询。Yeah。

对吧你获得的这些个数据啊。Yeah。就可以使。而且呢通过你的IP地址，它还能够获得到你的地理位置啊，北京市。好，还有公共的DNS，你看啊公共的DNS它会有很多啊很多。

所以大家呢如果有时间呢啊你可以呢把这个网址呃，你看一看这里头大家看到的这全是特殊的DNS。

啊，百度的也有啊180767676。Oh。啊，包括电信各省市的电信啊。联通移动是吧哎。那么找到1个最快的DNS能够加大你的上网的速度啊上网的速度。谷歌DNS8。8。8啊，对吧？8。8。4。4IBM的9。

9。9啊，这些都是啊。所以特殊的IP地址自己还可以在网上去补。

Okay。好，这儿呢给大家说了啊，如何获得公网IP地址啊，通过IP138。

啊，IP138。那么通常我们家里的电脑就做不了网站啊，家里的电脑，比如说80端口是封杀的。啊，80端口是封杀的。你进不来了。啊，进不来。进不来怎么办呢？我们平时呢可以通过内网穿透啊，可以通过其他的方式。

实际上外网也可以访问我们家里的电脑，也可以的。啊，也可以的，但是。

啊。

这个操作还是比较复杂啊操作比较复杂。好。

系列 3：P173：【Linux】子网掩码介绍 - 马士兵_马小雨 - BV1zh411H79h

今天呢新内容呢啊在这个基础上。介绍一个新。大概知万。

啊。有网源码这一块。也不这别。网络里也可以问。法律。那么主网源码呢在这一块啊。那么我们双看希望。嗯嗯。定意见。对吧。好。中网源码。他也。32个。32位。是吧。被告诉。利用这个。字段来评定。Okay。

原来网络。是。话灯。红儿。能够。获得。🤧一个范围这小的。范围较小。可以实际。有用是吧。有。

哎，这就是他。

那使用你这个指网炎嘛。你有哪些好？为什么呀？

好。第一个。年月。二地是0人。

第二个。减少。

我播。第3个。嗯。减少洗空间。说你在原来一个较大的网络中，我能给你缩小到一个较小的网络啊，较小的网络也就是说我主机之间没有进行浪费，我主机没有浪费的话啊。

那这样的话。我们能做的一件什么事？对不对？哎，那我主机就变少了，实际浪费的就减小了啊，IP地址它也是我们计算机里头的一个资源。啊，也是一种资源。对吧那我们都知道这个资源也是很宝贵的。啊，减少寻指空间。

说原来呀我这个。去做这件事的时候，可能啊你这里头200个地址，但实际上只有50个主。对吧啊这些个都是我们需要考虑的问题啊，这就是子网研码的好处。

那么常见的。子网掩码。嗯。哎，常见的子网源码。🤧我们介绍一下啊。

那么它对应的是我们什么呢？对应的是我们IP地址啊。

好，我给你介绍ABC3类啊，BE那两种，我们用的少。

所以介绍常见的。A类的子网掩码，根据他的IP地址来了。啊，说它的网络位是多少啊？前八位对不对呀？哎，所以也是它的网络位啊。255。啊，B类的那就是16位255。255点0。也就是网络位权为一。

主机位权为0。可以这么去表示。C类呢那就是255点255。255。0。啊。那么分解成二进制，那就是这样，1A111。1111啊。Yeah。啊啊，你都是一算出来数就是这么多啊，算出这事就是这么多。好。

这是ABC的。🤧好，B类和C类啊也都一样。掌握常见的C类的啊子网源码的表示方式。C类地址呢在我们平时使用的时候较常见。啊，这是第一种。啊，第一种用IP的方式去表示子网源码。

Yeah。对。

Yeah。Okay。

好啊，昨晚圆满。字圆满的表示呢两种方式啊，第一种呢就是用点分啊。减分。用点儿啊跟表示IP地址一样。啊。这是第一种。

第二种呢啊我们可以呢使用什么呢？哎。第二种表示方式，我们可以使用。这种方式表示啊，比如192。168啊，点0。1杠。斜杠24。

啊，斜杠24。这种表示方法叫做CIDR。表示方法。Yeah。这二者都重要。啊，这二者都重要给大家呢一分钟的时间，你就看这个把它往脑子中记啊，把它往脑子中记。有。P。好啊。

那么呢我们就把这两种表示方法给大家啊说了啊这个。

系列 3：P174：【Linux】子网掩码的计算方法 - 马士兵_马小雨 - BV1zh411H79h

好，那么子网掩码有什么作用？说我们通通常怎么去用它啊，企业中真实的啊要求。

啊，怎么来干？对吧那么就可以利用子网掩码子网掩码作用啊。

Yeah。好，第一个。利用子网掩码。确定网段。啊，啥意思呀？给我们1个IP啊，我们就能判断它是在哪个网络中的。所以咱们路由器在根据寻址的时候，会把你这些IP都换成二换换算成二进制的这种形式来表示。啊。

然后通过你的IP地址和子网掩码，你给我2个IP我能判断他们俩在一个网络部。啊。如果在一个网络中是不是你的路由，哎，就是吧找到这个端口，不在另外一个不在一个网络中啊，这条消息可能就会被丢弃。

所以可以利用子网掩码啊确定网段。啊，确定网段。

第二个，我们可以通过子网掩码啊。啊，来。计算。主机有哪些？

我先说第一个，因为第二个呀涉及到什么呢？涉及到我们要把一个十进制转化成二进制啊。但是他俩都重要。我们先说第一个。咱们介绍一个企业真实案例啊，我们一切以实战为主和企业真实案例。啊我录没录啊。啊，录着呢。

Okay。Yeah。Yeah。企业真实案例啊。说。我如何去确定啊？我如何去确定给我1个IP地址，比如说192点168。点0。1。啊。或点0。0。这个网段让你去计算。最多啊。容纳的。主机数。换句话说。

也就是说你有多少IP地址的个数。这里头怎么算啊，看你的那个地址啊，你的网络位和你的主机位。C类地址，你的网络位是不是24位呀？啊，看你是哪类地址啊，也就是说。

网络位占了24位，一共32位。主机位占了8位，这加一块是32。

哎呀。

Yeah。

那么你后边这是8位，拿主机位啊，二的N次方。8位，那这就是二的8次方。Yeah。对。Oh。啊，这就是256。也就是说，理论上来讲，我能放这么多。啊，这个公式二的N次方，请你把它记住容意好了。

Okay。能容纳这么多的主机数，也就是能给你分配这么多IP不代表就能分配这么多主机。

啊。所以第二步啊。网络中能够使用的IP数。啊。也就是说能放多少台主机。

第一问跟第二问有点区别，你需要弯弯绕一点点绕一丢丢啊。第一问是总共能有多少个地址告诉你有256个，那有多少主机可以用啊，注意。

二的N次方减1再减1。有同学说，那不就是减2吗？是减2，但是我们得知道为什么减一再减1。

减去第一个。再减去一个，这个叫掐头。啊，这个叫去伪。所以减两个一是掐头去尾，掐的是哪个头？啊，掐的是192。168。0。0，这个不分配给主机。啊，它是形式上的，它代表整个啊。表示一个网络。啊，它是虚的。

就相当于我们说哎人。😡，那你说到底是谁？男的女的、老的、少的啊，高的矮的、胖的瘦的、黑的白的。😡，对吧哎，他是一个泛指。啊，泛指。所以不在我们。不在我们分配主机的时候使用啊。

所以这儿在理解的时候要知道它是一个泛局，表示1921680嗯，后边一直到254啊，表示这个网络。再次强调啊，他是一个泛指。啊，我们不拿它分配主机。

听明白了吗？系。掐头去尾去尾去的是谁啊，那么每个。啊，每一个网络都有它的最大值啊，你能放256个主机，从0到255开始。啊，0开始到255就结束了。掐这个头去这个尾去的是192点168。0。255。啊。

这个表示的就是。该网络。广播地址。啊。你不能用。系统预留的。啊。所以这俩数啊咱们就要掐头去尾。

这样的话就是减一再减一。就是减2，那么就是256减去2，最终这里头啊能用的是254个IP地址。

好，那么你扣了0，那就是从192点168。0。1开始。

啊，到192点168点0。254结束。

So。从这儿开始到这儿。嗯嗯。Okay。Okay。Yeah。不。Okay。Okay。Okay。嗯。好，从这儿开始到这儿结束啊，所以你看这2个IP地址，一个是头的，一个是尾的。所以这两个地址都很很好记的。

啊，所以我们通常。会拿。开始或结束的地址作为网关地址。啊，可用里头最小的可用里头最大的。

Oh。所以。这个的网络的表示方式啊，还可以是这样写1921680。0。盖24。这个杠24的意思就是啊前边的网络位是24位，可不是说这里头就24台主机。啊。

这就叫CIDR法，这斜杠24。表示的是。这一段儿啊。这个IP地址段里头啊，网络位。占了24位。啊，三个字节。

。千万不要混淆啊，千万不要觉得哎呀，这里头是表示24台主机，不是啊，可不是表示24台主机啊。

。Yeah。

🤧。🤧。Okay。这儿很重要啊，再次强亮。好，或者呢你用表示成字网掩码255255255。0，这俩是一个意思啊。

只是表示方法不一样。这儿3个255不就表示前边三个字节都是网络位吗？都占上了啊。

这是第一个。

系列 3：P175：【Linux】10进制转二进制算法 - 马士兵_马小雨 - BV1zh411H79h

，🤧第二个，利用子网爷们儿。Oh。利用组网掩满。确认他是否在一个网站中啊。🤧好，我们看看第二个怎么用啊。好，它可以盖上，一般都是咱们路由器。路由器底层的工作原理，我们看到你家里头那路由器是吧？

它里头有芯片。啊，你那IP地址过来，人家就把你的IP地址啊。转化成二进制数的表示。因为你IPV4的时候，它是什么？它是十进制的，是不是？啊，所以十进制转二进制，这里头就是基本功。我。🤧。

那么这个转的呢有两种方式，第一种就跟小学一样，拿一张8开纸咔咔在那算。啊。🤧嗯。哎，这个叫什么呢？啊这个叫。😊，循环。啊，或者叫除二。除二。取余数。啊，所以叫除二取余法，就看你这个四则运算会不会。

啊，除法操作会不会？啊。第二种方法呢叫做权重法。

啊，第二种方法呢叫做权重吧。

对。是。第三种方法呢，这个世界上有一个东西叫做计算器啊，科学计算机还可以呢循环啊，还可以通过更底层的。啊。对吧还可以左依法。求一个数的二进制啊。

还可以诱一法。🤧。求一个数的二进制啊，这都是底层二进制底层未操作的。

啊。啊，我们脱产班的同学呢，那你就知道第一个啊就行了。对吧啊，因为我们不受到更深刻的编程。啊，周末班的同学呢，这个到时候我会在周末班呢给大家做一些提升。咱们再说一些编程的东西啊。所以呢这个对二取徐数啊。

它的过程呢就是循环对二取余。

。Yeah。啊，这都是扩展的啊，呃一不小心激动了，又多说了点东西，循环对二取余数。啊，逆序输出。🤧嗯嗯。好，那我们做一个啊循环对二取余数逆序输出，这玩意儿应该怎么做？这是数学老师的范畴啊。

小学三四年级的水平。

循环对二取余数逆序输出。咱算一个数啊，比如说。🤧。转移谁呢？算一个5。啊，算一个5，咱们算这个数。🤧。🤧Okay。我们算这个数啊。二进制，那他除谁呢？除2。Oh。🤧。啊啊5。除二啊取余数。商举与举。

Okay。商己于己啊，咱可以群里聊聊啊，考验一下我们小学数学水平。嗯。你们群里讨论一下，我就喝口水。Okay。好，我来了啊。咩。好，你看就有同学懵逼了吧，你这小学三年级这不赖我呀啊。

来我们看一下5除二商几于几，看他能不能整除。5除二除不尽，对吧？商最大的数啊，二三得六超了5了，二二得四。对吧所以底下商几呀，商2。与几呀啊，我们通常小学后边写点儿点儿点儿点儿点儿。5除2商2余1。啊。

商二于一。你琢磨琢磨是这意思吧。哎，然后这个二啊商的这个数再除啊再除2。Okay。哎，2再除2啊。2再2除2的话呢，直接就能整除了啊。直接就能整出了。🤧2除2商几于几啊。能不能整除？哎。

直到后边这是什么？直到。啊。伤为。这是几。商己于己啊。哎，你看这有的同学纳过闷儿来了啊，对，现在又智商又重新占领高地了啊，商医对不对啊？啊，商衣虞己呀。嗯。于0对不对？啊。好。那么这商一不能行啊。

在这不能停啊，说循环对二取余数直到商为0。就我一的时候，我还得再除啊，我再除2。直到最终这儿啊一除二不够除了啊，那我就商为0。啊，伤为0。啊，直到商为0。好啊，这有的同学还没纳过门来呢，没琢磨过来的。

你再琢磨一下子啊。🤧嗯。Oh。整除大哥整除啊。🤧嗯。好。我了个去，这家伙整除啊不是0。5，各位大哥哎。好，没事儿啊，我给你们点时间，你们你你们你们你们琢磨琢磨啊，你们琢磨琢磨。哦。

So。Okay。好，挺热闹啊，我把这上边这个给大家补完啊，补完。刚才呢我们这差一步是吧？哎，二除一商0，这里头写多少啊，后边。把余数补上。啊，商灵于一。好，那比如说五的二进制数怎么着逆序输出啊。

就倒着往上写，这上面往下是正的啊，倒着往上写。所以这里头啊我们要表示的时候，对吧？一个字节前边补零啊，后边是。8位啊五的二进制就是这样写。🤧Yeah。Yeah。好啊，这是第一种计算方式啊第一种计算方式。

这个练习呢你算多少都无所谓啊，就是循环对二取余数去算去啊。

第二种的权重法，那么也就是拿二的N次方来算啊，二的0次方，任何数的0次方都得1二的0次方得1。没楚。嗯。啊。二的1次方22的3次方啊，不二的1次方2啊二的2次方4。啊。Yeah。好，二的3次方。8。啊。

二的4次方16。二的5次方322的6次方64。啊，二的7次方1282的8次方256。啊。

好，这就叫权重啊，我们记住二的N次方。比如说我拿五啊，我给你说一下这个怎么算啊，就快速口算。😡，啊，拿你这个五。😡，你看五比谁大比谁小啊，比四大比八小OK那么就是5。5减4够不够减？

啊，构减就写一。好，5减4等于11减2够不够减，1减2不够减，不够减就写0。啊。那一减一够不够减，一减一够减啊。对吧构减。最终等于0，那构减就写一。

所以你快速口算的话呢，那这就是这个啊。5就是101。那么150如果我去算的话，那那我们算看150啊。

，Yeah。快速口算150，看它比谁大比谁小，介于谁之间，150啊，肯定不够256，也就是150减128。够不够减啊，够减就写一。

好，那150减128剩多少？🤧。上多少。算呗，对呗，凑十啥呀，那这22啊，对吧？22减64够不够减啊，不够减不够减写0，22减32够不够减，不够减，不够减写0，22减16够不够减，ok够减就写一。

所以22减16等于多少啊？哎，22点16，这不得6吗？对不对啊？😡，啊。6减8够不够减不够减不够减写06减4够不够减，够减够减写16减4够减了。等多少呢？等2。啊，2减2够不够减哎，够减。啊，构减写一。

那2减2最后剩多少呢？剩0。啊。所以你看你那个刚才你算的那个是不是这个数啊？啊，我们验证一下啊。计算器。

Good。计算器呢完了以后有一个程序员。啊，程序员或者说呢我们找一个科学计算器科学。

啊。科学纪能记。嗯嗯。😊，你可以跟这里头去算。啊，你可以根这里去算啊，包括程序员去用的这些都可以啊，啊，对不对？比如你二进制表示刚才我们说多少来150吧，是是这意思吧？Yeah。嗯，这我怎么不会用呢？

150。啊，150。150的那你看这个就是什么呢？底下这个BIN就是二进制。啊。10010110是不是我写这个？

Yeah。

啊。好啊，这个权重法可以快速算啊，咱们就说这么多啊，这个也挺happy的。

系列 3：P176：【Linux】企业案例计算两个IP是否在一个网络 - 马士兵_马小雨 - BV1zh411H79h

好，说你现在呢啊会第一步了啊，我们能算。然后呢，真实案例说你给我俩IP地址，说给我一个叫192。168。1。150。啊，你又给了我一个。哎，192。168。1。151说这俩IP地址。啊，这两IP地址。

那么这2个IP地址啊，我们得先把它转化成二进制的表示方式啊，十进制转二进制。我先给你打一个样，然后你算啊。哎，这150正好我们刚才算了一个，是不是？啊，那叫四段嘛。啊，150，那就是10010110。

就最后这150。啊。一直接拿它减啊。😡，对吧一直接拿它减00000001，这就是一。啊。168你算吧，算完了告诉我168是多少啊。嗯。哎。Oh。Okay。好，168我公布一下啊，怎么算啊？

168呀啊10。101后边4个0啊，这就是168。你算去吧。啊，拿咱们刚才说这数嘎嘎一减啊，快速一补。啊192呢也是这道理啊，192也这个道理，那192是多少啊？11。00。1234。好。He。是不啊。

这就是192的啊，所以说呢咱们拿到这玩意儿以后呢，咱们先把它转化成二进制啊，是这么算的啊。二进制还不行，然后呢，比如说他还得给我一个子网掩码，说这俩的子网掩码都是多少呢？

都是255点255点255点128。他俩的子网掩码都是这个嗯。好，你把255255255。128这个十进制，你也给我转换到二进制。用刚才教你的权重法嘎嘎一刨啊。🤧嗯嗯嗯。不行啊，权重法，你这数学你没没。

😡，报没了，数学不灵的啊，那你就直接用计算器吧啊，但是尽量自己算一下啊。啊，要不一会儿困了。🤧。H。咱不算此机硬背可以吗？哎。那得多累呀，得死多少脑细胞啊。好啊，那这儿7255这前三位最好算了。啊。

所以第1个255那都都是一啊，后边的也是。啊，都是一再往后都是一。啊，你只要算1个128就行了。啊，只要算1个128就行，128太好算了，那你算呗，那到这儿直接就干1个128呀，对不对呀？

所以直接128就是这样写。没毛病吗。对不对？所以这个口算啊，你刷就算出来了啊。😡，所以这个就是它的子网掩码啊子网掩码。Okay。ok。这个平时啊这个原理啊，咱们就说了一下啊。

平时呢这是咱们的路由器在那哇哇给它算的。啊，那为啥有时候你那慢呢？为什么我们要使子网掩码啊，对吧？它得进行进进行大量的计算呢？如果你对这个网络我们不进行优化的话，没有这个子网掩码的时候，你算死它。😡。

对吧，那过一会儿他就该热了，你知道吗？😡，对吧所以如果说判断这俩IP地址在不在一个网段中，就是这么算的。啊，咱们那路由器苦逼的就这么算。啊，说第一个这个结果。啊。结果。这有两个是表示结果的。嗯。啊。

所以咱们呢这个路由器就开始先第一步拿到你给的子网掩码，拿到你给的IP地址，先把它进行啊二进制的算法，然后它再进行与操作，就是你的IP地址和你的。子网掩板啊，他们进行与操作。叫按位语操作。

这不是咱们课程大纲里要求的啊，我给你扩展的。你能听懂你就听听不懂拉倒啊。反正咱也这块不收钱啊。Yeah。好，按慰语操作它有啥特点啊，按慰语操作，那它有口诀啊，有规律。所以说它如果要底层的话。

那就算死你是不是啊？那我们就说口诀吧啊，所以这样一说口诀呢你能秒懂。其实但是这个东西在计算机里头是特别复杂的一个东西啊，真的。你要不学个一年两年的玩意儿，你就听不明白。但是呢我们能用口诀让你能懂啊。😡。

吓。这个按位语操作呀啊它是一个运算符。啊，它是一个运算符，在C语言里头呢，它叫做运算符和表达式。啊，它叫运算符和表达式。那么也就是说它上下比完了以后啊，咱们这里头这个8位。

这里头的零跟一叫做啊二进制位上的数。啊，二进制位上的数。比如说我上边这是一，这对应的最高位，这是一，它下边也对应的最高位是一。啊，先把这二进制位上的数。记明白了。啊，记明白了。好，然后。这没对齐呀。

Yeah。Check。哎，是这意思吧啊，我这个这个这这个数数没对齐啊，数没对齐，你大概是这意思就就行了啊。好，那么安慰与操作呀，你要看它相同二进制数上的数是零还是一。Yeah。啊。是零还是一？好。

我给你写一个程序啊，你看看这个结果，然后呢，我们反推这个规律啊。

不议。咱们开一台主机。

这咱就干这个了，是不是一言不合，咱就写一个，这这算啥呀？五毛钱的事儿啊。

🤧嗯。对以。Yeah。啊。😮，连上啊给你写一段。

🤧嗯。

。Yeah。Yeah。看下。系。比如说我就做谁呢？五与上。啊，遇上3。啊，五语上三结果是一，咱们推一下这个规律啊。

哎呀，还得讲啊。画图吧。好。我提问一下子啊，就是看你们能不能跟得上。勇哥给我说一下五的二进之数。快点谁给我说一下五的二进制。啊，博文跟我说了啊，哎这赶我算过呀，1234啊，5，那不就是4加1嘛？

4加1那就是101啊，对不对呀？这就是5的二进制数。那刚才我们算的三的二进制数，三不就是2加1嘛？2加1不就这样吗？这不就三吗？没毛病吧啊没毛病啊。我要算错了，你们查我啊，那刚才说了。

它五与上三得一了啊，把二进制被补好，一就是这个呀，这就是一啊。所以通常呢我们用这个案位语操作啊，它的运算符叫end符。就是你那七键盘上七那数啊，这就叫无语上三。结果得一。那么总结的规律就是什么呢？

相同二进制位上的数。如果都为一。那么与操作以后。还为一。啊。这是第一句话。第二句话说，相同二进制位上的数。如果不为一。啊。如果不为一。那么与操作以后。结果就为0。啊，必须它俩相同都为一的时候。

结果才是一。如果一个是零，一个是一，你看上边是零，下边一，结果是0，上边是一，下边是0，结果是0。啊。

🤧你就这么记吧，这样的话呢那你就能明白了啊，所以与操作刚才说了，那我们就要看。看相同二进制位上的数，刚才说了，如果都为一，那结果还为一啊。如果不相同，那结果就是0。那所以这个看从咱们从左到右吧啊。

我这好排序，那一得11得1100100后边10100000。啊，所以第一段得的就是这个。好，后边还是这个，那他都是255啊。😡，对不对啊啊，哎，不是啊，不是不是这168了啊，168。

你这168与上255啊，这是什么呢？上下一啊，得一一0得0一一得一一0得零一一得一一0得零。😊，啊，这是第二个啊，没毛病。第3个哎，这好啊，1234123。二。啊。最后这个。1123。0000。🤧。哎。

这就是他们与的结果啊，他俩与操作这结果。好，我们再算一下下边这个啊下边这个。150和151啊，这个IP。🤧。这样我们只要算一下151的IP地址不就行了吗？是这意思吧啊，151呢这是多少？😡，哎。

在你后边加一个，就把最后那一位给它置上就行了。好，我们算一下这个结果啊。前边你是192255，那这儿肯定是一样的啊，你也是168嘛，对吧？你也是一嘛，只要算最后一个就行了。啊，只要算最后一个就行了。

那最后一个这是啥呀？这这这这这。啊，还是一样的啊还一样。好，拿IP地址和你的子网掩码做语操作啊，如果这俩结果相同。就表示他俩在一个网络里。哎，咱们那个路由器寻址就是按照这个算法来寻的。啊。IP地址与。

子网掩码进行与操作。啊。如果两个结果，2个IP壁址啊，计算的结果相同。就说明他们在一个网络中。啊。一个网络动。这就是路由器啊，底层的算法。啊。好啊，你晃晃神儿啊晃晃神儿，对吧？哎，这就是这么一个过程啊。

好，那么这个第二个第二个企业真实的用法啊，就是在我们这里头去算他俩在不在一个网络。

系列 3：P177：【Linux】IP地址子网划分 - 马士兵_马小雨 - BV1zh411H79h

，没。第3个，企业真实案例啊。

对。第三个企业案例呢就叫子网划分。啊。网络优化哎。网络规划优化啊，在这里头就需要你。需要知道啊，很重要。

Oh。Yeah。

Okay。好，那这个东西呢就是说提高寻址的空时这个这个这个这个这效率啊，减少时间。第二个主要是为了避免。啊，IP地址资源的浪费。这个在企业中实战的时候具备非常高的啊意义。所以这儿必须都得会认真听。

放下你手里的所有的事儿，手机扔一边啊，把这整明白了。啊，面试的时候，或者我们使用的时候，一般都是C类地址。啊，对我要是面试官，真的我问谁谁死。啊，我上来就先让你算一二进制，就得有一半人阵亡。

好。所以这儿一定要注意啊，他问你的都是C类地址。一般问你这题的都是我学生，你放心啊，你就这都是都是都是我教的啊，都是我学生还能问你这么刁端的，都是你啊，是吧？你就往点上答就行了啊，那怎么说呢？

来个企业真实案例啊，咱直接就真实案例了。

，Okay。그。啊，那你有时候你聊聊时不时的，哎呦，操太认弱了啊，你这是不是你说这不就巧了吗？这哎我也是亮哥学生，你说这操，那你不就录取了吗？是不是啊，企业真实案例呢，什么呢？说咱公司呀有50台电脑。

啊，50台电脑。然后呢，给你的是192。168。0。1啊，别点0了，点1。1啊，点1。0这个网段。问啊。如何。设计啊如何子网？划分。如何择网划分？使用。啊，IP地址最少。请写出。写出。子往掩马。

起始IP。终止IP。

🤧嗯嗯。

说遇到这样的问题，怎么怎么去操作啊，怎么操作先。

看人家咋问的。😡，啊，那首先呢他得让我写一个啥？首先我把网段。啊，网段我拿下来。网络段，那他已经给我了啊，他说了，那我这网段是192点168。1。0。

啊。然后呢，让我写起起始IP。啊。这一问白给分的192。168。1。1，肯定是从这儿开始啊。

是吧。好。结束IP。啊，结束I，我先不管，我一会儿算。对吧然后呢，他让我50台主机，那我看一下这东西我的思路应该是怎么做的啊。

遇到这种事不要慌，实际上还是考你二进制原理。如果刚才上边这个你算明白了，底下这个你口算都能算出来。

哦。我给你口算一下啊。

哎，咱们试一下啊，看看咱们自己啊，我看看你们扣活好不好啊。

来一下吧啊，说。50台电脑啊，这时候快速的想到我们权重法，50大于谁小于谁？好，大于32，小于64，这结果出来了。

就这么简单。考的就是你权重法明白明白，它介于32到64之间。啊，32到64之间。那么你64的话，它是二的几次方啊。嗯。

二的6次方是不是啊？啊，你看12345。喂。😊，0123456吓我一跳26次方。

2的6次方呢，那也就是啥意思呀？那也就是我在这个网络位，它又是C类地址是吧？C类地址C类地址呢？应嘤。😡，C类地址的特点呢就是前24位是网络位。后边8位是主机位。啊，这时候这时候我做子网划分的时候。

我实际上我这个八位能表示256个主机，可用的是254个主机。但是如果我就50台电脑，我给你254，你就是浪费的。所以你这八位应该是这么写的，00000000啊，0000，这就是8位。那么好。1234。

56。二的6次方够了。啊。那这得出来的就是64。也就是说，我如果这样表示。啊，这样表示我的主机位。啊，表示我的主机位。🤧。我能拿到64个IP。64个IP掐头去尾减一再减1。

啊，那我这里头能用的就是62个IP。

啊，所以这剩63再减完了剩62。啊。62不大于64，6662大于大于32啊，所以这个IP地址段就到这儿了。啊，就到这儿了。所以起始啊起始。1921681。1。啊，1。1。然后你的结束IP地址192。

1681。62。

啊。1。62。然后。啊，然后。还可以问，比如说你的广播地址。

啊，你的子网掩码。子网掩码呢就相当于我把主机位这左边这俩00位也给到你的网络位。

啊，00位我也给到你的网络位，所以广播地址就是192点168。1。63。啊，我的子网掩码就是前边啊24位。啊。对吧再加上这两位，也就是26位。那么如果是表示的话，那就是255点255点255。192。

啊。

或者表示成为192点168点1。0-26。啊，我把前边00这两个主机标识也往前移移给让它标识为网络位。

啊，那这样的话呢，也就是变成了。前26位啊为网络位。后边6位。啊，为主机位。

这样我们就把这个子网给它划分好了啊，用最小的IP壁纸。

好，放了这50台主机。啊。好，那到底跟我们说的对不对呢？😡，对吧哎，我们可以算。

。嗯。好啊，它有在线工具嘛，是吧？我们看一下，刚才我们提说的是10段是吧，192。1。0。啊，你的掩码默认是24位，对不对？刚才我说了，把后边借两位给他，那24加2就是26。啊，那可用IP你看62个。

第1个1。11。62结束，广播1。63。

跟我们说的这是不是一个一回事啊？系。这就验证了我们说的是对的啊，那你的掩码255255255。192，看我们是不是。

252525192。啊，表示方式可以用这种啊CIDR的方式表示杠26前26位。Yeah。哎，这样我就画了一个子网。一点都不浪费我的IP地址。啊，后边的。在用的时候再给别人啊。Yeah。

好，这就是子网。

系列 3：P178：【IO／NIO】操作系统宏观介绍 - 马士兵_马小雨 - BV1zh411H79h

宏观上呃梳理一下我们要学一个什么东西，呃，学的肯定是IO这块的东西，但是要一层层的去讲。首先一个比较宏观的一个一个拓扑图，就是在一个计算机操作性当中啊，然后非常至关重要的，有这么几个核心的东西。

一个是内存啊，一个是CPU，然后剩下的都是IO设备，啊，这个应该在前面的都已经都已经了解了。然后呢从另外一个维度，从程序的维度的话，你要知道有科呢。有一个操作性内核，这是一个程序。

内核它说白了就是一个程序。

然后呢，除了它之外，剩下的程序就是我们自己的application用用户空间的程序。

然后呢，有一个逻辑的一个图啊，就是之前课应该也说了，每个程序其实是逻辑的线性的一个内存地址。通过MIU给它转到我们的这个CPU的物理地址。

然后呢，我们的一个程序其实模拟的是使用了整个这块内存，这个内核在它的高低哪端无所谓啊，但是它的地术空间里边肯定也包含了内核的这个引用。啊，这并不重要，重要的是一个程序。如果想执行的时候。

如果想获取IO当中的数据的时候，其实数据除了有我们的这个应这个应应应用空间的东西。

然后有我们的内这个物理内存里边，这是物理表示方式啊，就是在内存里边堆了一这么一个程序，堆了这么一个程序。其实这个程序他看自己的时候是这个样子，就等于我自己整个使了这个内存条了。然后除了有内存。

有它还有我们的CPU。

还有我们的一系列的IO设备，比如说磁盘。网卡。这个这个其实还有很多的其他的IO设备。然后在我们学习的时候，关注的无非就关注这么两类的一个IO设备。

好吧，那么IO设备里边肯定是有数据的，数据呢最终是想被我们程序读取到，那程序是不能直接访问硬件的那程序只能通过调用系内核的系统调用啊，一般来说一般来说，但是它有直接IO这这个这个这个这个行为啊。

但是那个后边来说。程序想获取数据的时候，在这注意一下，有几个抽象啊，内核内核里边有哪些模块，内核到底管了一个啥事儿？内核其实它是既管我们内存的分配，又管磁盘IO，它什么都管。

这里边有一个叫做VFS的虚拟文件系统。它有一个这么一个概念叫做虚拟文件系统FS大家应该都知道，你windows上有一个文件文件系统，它里边有C盘D盘E盘F盘，每个盘里边有自己的目录数结构啊。

可以存自己的文件。只不过在linux操作系统或者类unux系当中呢，它是一个在内存里边，首先先制造起了一个VFS。然后呢一会儿我会让你看命令，看到那个那个那个结果啊。然后它里边的它其实就是一个数。啊。

一个目录数数上的不同的节点，最终可以映射到不同的物理位置。啊，树树上那个节点，那个目录可以映射到不同的物理内位位置，每个不同的物理位置可以是不同的具体的文件系统。

比如说FAT或者E叉 fourE叉 three这样不同的文件格式，然后或者是网络上的节点，或者你虚拟了一个块设备等等的啊。没错，是可以挂载。我先先宏观介绍一下，先听一遍这个这个词汇。

然后一会儿再带你实操去看那个东西啊，为什么是虚拟文件系统？首先嗯。怎么说呢？像windows你就可以理理解成是一个物理的文件系统。因为你看的C盘，那个就是你硬盘那个C盘，你看D盘就是你硬盘那个D盘。

那操作系统linux它要出一个虚拟文件系统，它其实解决上层应用程序对底层这台计算机有可能很多地方存数据。但是每个存储数据的这种硬件，它的驱动，它的实验形式不一样。那这时候如果没有一个中间的一个解耦层。

就类似于这是数据库。这是你的程序。中间如果有1个GDBC接口抽象的话，那你可以通过一个GDBC访问不同的数据库。你就把虚拟文件系统想成是给我们用红颜程序暴露的一个统一接口，它下边挂载的不同的设备。

它的实现，它的驱动可以不一样。

啊，这个能听出来，说波一就是跟你什么，咱们这个你其他不懂，但是渣我我认为你是要懂一些的，对不对？哎，有有什么我就拿扎我给你举例子。

那么有了它之后，这里面在虚拟文件系统里边，它还有一个几个层次，一个东西你要知道叫做i know。我先不带你看这个所谓的什么内核的源码之类的，还有一个定义定义格式，我们先抽象这语义卓号。

你就把它想成是一个就是一个ID，你就把它抽象成想成一个ID在虚拟文件系统当中，尤其在使用磁盘等等一系列的时候，它的每一个所谓的文件，那个文件在你打开的时候。

都会有一个安卓号来代表它唯一它然后对对应着这个安卓号在内存里边，就是如果你程序想读数据的话，通常默认的。第一步是访内核说我的这个数数当中打开哪个文件，然后呢，这个安号被加载。然后呢，它的原数据被加载。

并且你读这个文件的时候，注意文件读读到的时候，是先由内核去读，读到我们内存里边，它会开辟一个所谓的配置ch。啊，用就先把这个第一个名词数梳理梳理出来啊，这个payca就是你看可以看到叫做页缓存。

这个页缓存默认的是4K。

啊，是1个4K的这么一个大小。在这注意一下一个程序。如果有两个程序呢？

第一个知识点，如果在我的系能中有两个程序，他们想打开的是同一个文件啊，他们想打开的是同一个文件。那这个时候其实按造号要配置cash，其实是在这一个物理链当中是一份给他们共享的。这个是第一个知识点。

就是两个程序。如果打开同一个文件的话，它其实并不是每个程序都会有一个独立的一个把这文件加载的过程。他其实访问的是你的虚拟文件系统。这个虚拟文件系统如果发现加载过这个文件了，然后你想读的东西。

这内存的pay cash已经命中了。那这时候其实已经就是可以给你返回你要的那个pay cash数据了。而且在这儿还有一个点啊，我们一定要把它这个这个这个知识这个舒展开啊。这个p着c。

它是你内存里边就这个数据的一个缓存。然后还有一个东西就是。dirty脏的意思。这几个这几个维度你得你得知道啊，因为这个要不知道的话，后边很难理解。那么如果我程序。读取了这个磁盘里的文件了，那些个E。

那一个所谓的被这个这这个p cash在这这个内存里已经出现了。但是后来我改了某一个。page cache里面的数据，就是我程序现在都是和内存里交互的。虽然这个数据曾经来自于磁盘。

但是你读过之后就在这缓存，缓存之后后续的修改会变得很快。那变得很快的话，那你就会修改，修改之后，这个配这个配置它就会有一个标识做脏。这点记住了。听同学来说说一。就是程序和硬件之间隔了一个内核。

内核通过page catch液缓存来维护你曾经想读的数据在内存里边。然后你如果对它修改的话，它会标记成脏。那这时候违脏的那就会有一个。所谓的flash的过程，要书写到我们磁盘当中去，对不对？啊？

张议要书写到磁盘当中去。那么如果数输据到词文当中去的话，是什么时候书写的这这个书写形式是实其实决定了我们的IO模型。你可以程序没写的时候，没没改的时候立刻摔到磁盘，但是性能很慢。

也可以交由系统内核来决定这些脏页什么时候该书写。但是在这要注意了。这个脏的标识是内核对所有上层打开的文件的一个统一的管理。它并不是针对某一个文件的那这个时候一会儿我我也会带你看一些内核的调优参数。

它有一些阈值。比如说达到物理内存的10%或者20%，或者经历5秒或者30秒，这样的一个周期，它会整体的把增页输写到磁盘去。一个是你程序等着内核，他就他去他去刷。一个是你程序调内核，直接给我刷。

那直接刷的话，保留的多，保留的这个这个准确。如果交给内核的话，会丢的多，能丢多少？举个例子，如果你有1个30G的用这个内存，那搞不好5秒钟之内假设某一种特殊情况，极端情况。

假设你5秒就对那5秒之内对内存造成了3个G的数据。差一点，比如20。8个G5秒之内，那就是通断电了，那你可能就这2。8G数据可有可能就丢了。就是他既没有触发到脏的那个阈值，也没有触发到时间点那个阈值。

那时候还没来得及把它刷刷刷刷写出这个主机。这点。任何同学来说波一，这个就先死记死硬背啊，再给你展示。Okay。这是一个宏观的简单的先说一下这个内核里边这个这个事情。笔记的后来我都我再再给你整理啊。

然后在程序当中，那这时候其实和我们java当中概念一样。回到刚才一个知识点，那内核先说完内核内核可以帮助我们说很多程序如果打开一个文件，我可以在这里面把那个文件的这个放到内存，你们都可以读。

谁都可以写了。那这时候加左不加左的问题，对不对？不是说有点类似re持久化re的持久化也是来自于操作内核的这个约束。你买sl等等都是来自于内核的约束。所以其实这个点你学明白之后。

你再去看那些个需要持久化的东西，他们就会你会明白哦，原来内核有这个有这个bug，所以他们才会能去设计好吧，那么内核如果提供了文件的一份缓存，供所有程序去使用。

这个时候其实有点像我们java当中的代器模式。因为其实这里面还有一个维度就是这个程序想好了文件的偏量和这个程序想好了偏量不一样。也就java中为什么在集合当中会有一个代。

迭他器模式是给每一个线程一个独立的一个指针，你各自在这个机合当中使用你的指针，想取谁取谁两边的取不会影响对方。所以其实这里面还有一个概念叫做FD。

最终会还有一个一层把下面这个包装起来，就是FD。FD要叫做什么？叫做文件描述符。

filldescriptor文件描符当中会有一个什么？就是这个这个文件描符最终是交给我们程序用的。这个虽然这个文件啊这个文件有1个Iode。

但是这个这个里面对这个iode有1个FD得到了1个FD这个FD假设它的指针啊，它会有一个指针的概念。或者叫做四个。偏移这么一个一个一个一个一个一个指向。比如它偏移它平移可到8上边的就可以偏移到。20。

一会儿这个我尽量也带你去看一眼啊，都能看到这个物理的表表象，通过一些工具和和指令。那么这样的话，每个程序在读取文件的不同位置的时候，其实各自有各自的sep，各自各自自字的指针。明白什么意思吧？

所以这时候其实他们各自通过自己的偏移，找到自己那个所自己的该读写的那个配置 catchch。如果在没有修改同一个位置数据的时候，其实也不用加锁。你修八我修不修改的时候，这时候咱也不用抢锁。

但是如果大家修改的是一样的话，那这个保齐会修改到同一个位置的时候。其实这个时候如果打开同一文件的话，那肯定是加锁的一个过程。这个这个这个就有点像这个咱们ja当中，如果你修改同一数据，那肯定要先抢一个左。

谁想上来，谁去改啊，它其实把并行改成一个一种创新化，这是一个非常简单的一个宏观。

系列 3：P179：【IO／NIO】虚拟文件系统 - 马士兵_马小雨 - BV1zh411H79h

验证的第一个环节啊。我打开了一个linux的一个系统。第一个先知道什么是虚拟文件系统。什么是虚拟文件系统啊，它是一棵树状的，有一个根目录，根目录下会有一级目录。一级目录里边的每一个目录，它会有子目录。

就像一个倒着长一棵树一样啊，从一个根起，这是第一个支点，每个人应该都知道这个不难。第二个支点介绍一个命令，这个命令叫DNF。DF这个命令可以起到一个什么效果？你可以看到啊，就是内核里边。

比如内存起来之后，它维护了一个虚拟的一个目录数结构，这个目录结构很多的目录。那这个这些目录当中哪些目录啊，哪些目录它其实挂载了不同的位置。可以看到我们我们挂在的一个情况。因为这个所你看有一共三个条目。

这三个条目都是从根起的。但是它们隶属于不同的这个叶子，不同的这个子目录。像这个最开始这个这个主根是挂在了我们的DV设备目录下1个SDA3这块硬盘，就是SDA这块硬硬盘的三分区。那在这儿我给你画一下图吧。

这这个有一个最后能能能能能理解啊。

呃，如果咱们学C的同学同学多，然后大学及科学的好同学，你你忍耐一下。因为这个其实这块就是如果没有相关这方面学习的话，其实还真是不懂你你你要你要认可这这一点啊？所以这个第一节课我可能讲的特别的慢。

讲的特别的这个呃不会不会特别的深，很可能可能你会感觉这个东西你都会了，为什么还讲，对不对？这个忍耐一下。首先我有一个硬盘。我的硬盘上边有三个分区。有一个零分区。啊，一一分区吧，二分区和三分区。

这是我曾经自己规划的时候，我规我系统安装的时候这么去装的。那一分区我的大小应该是在200兆。这是我硬盘这么做的一个分区。如果在windows上你就能看到这个分区，但是在linux看不到的一个分区。

它是一个目录数代表了这个这个这个引用了。二呢是我一个swe的一个交换分区。这个交换分区我当时好像是2G。然后第三个就是我的根分区root根分区。这个入头两个词，在文件系统就是跟的意思。然后在用户的时候。

就是这个管理员的意思。

好吧，那现在可以看出这么一个现象来啊，就是在我的系统当中，这个虚拟文件文件系统当中，这是一个它有这个目录了。这个目录里边呢，注意我们观察第三行，第三行，这个有一个but目录。

就是你看到的这个所谓的文件系统的目录数，你看到他们都聚在一起了。好像来自于一个地方来自于一块一块硬一个分区里边，但是其实不然像这个bo，它就是我这块硬盘的一分区，这个200兆的引导这个一分区。

将近200兆左右。然后像我的那个根分区，就整个默认的这一个所有东西，默认所有东西其实是在我的三，那全部在三，只有里边的boot在一，有这么一个差异。

有一个覆盖，等于这条记录覆盖了上边，你这个原有这根下那一个boot，听同学来说波一。

还有人刷刷刷刷刷啊，其实这个整个根啊，如果看你的文件系统。你的根目录是来自于。三分区在计算机起祈祷那个引导的时候，内核进入内存，内核会初始化它的文件系统。这时候它初始化一个虚拟文件系统，这个文件里空的。

只有一个根，然后他把根映射到你的三分区，三分区里边，这个分区里边会有很多的目录，比如有有这个bo分目录。然后有DV目录，然后有这个。ETC目录就是这些目录其实都都这个这个三分句里边是有这些目录的。

只不过在引导的顺序里边，第一件事情是加载了它，这是第一步先加载的。先挂载了，然后挂载完它之后，第二步它又挂载了一下。这个一分区200兆这个其实这个东西可挂可不挂。因为其实真正出现的顺序。

在计算机帮当一N电的时候，一N电的时候先是bisbis完事之后，先读到的是这200兆分区，因为这里边引导程序GLB引导完了之后，把内核内核程序啊就chan是在这里边的，内核的小镜像。

Klonel啊这个小金像。是在这个200分区200兆这个分区里的，把它加载到内存之后，然后这个Kel就已经在内存展开成这个程序了。这个程序就等于这个有点有点这个。呃，这个叛这个叛逆的感觉哎我到内存了。

那我就把你弄死，然后呢我重新加载它，然后呢变到变到我科的这个虚拟文件系统里边去，能看到所有目录了。然后为了让人在后续访问这个目录数之后，能看到里边的配置啊等等一些东西，他又给它覆覆盖的一个挂载了一下。

所以这时候其实在你磁盘当中有两个目录，这边是挂载了这个bo。

然后这边其实也有一个部的。明白吧，就是这个目这个挂载覆盖了原有的那个那个不同目录，你可以看一下布的。在这个里面其实就会有关于我们引导程序的，比如GOB啊，还有我们内核的一些个这个这个这个镜像。

好吧。来这块能听的出来说波一。

还能找到原来的bo吗？这我给你演示能能能就咱先看啊，你就先先懂第一个层次，DNF是可以看到挂哪一个的那其实你可以unmount。amount我们的boot，你刚才看bo里边是不是有东西。

是不是全是这些东西。那这些东西现在问一句，根据现在的映射关系，你现在看到的bo里的所有文件，在磁盘的物理的哪个分区里，是不是在一号分区？对不对？然后这时候我把bo的一个目录如果给它卸载掉啊。

我因为在这个目录里边，现在是busy，不让不让用退出这个目录，然后再unmount。boot退出之后，先看DF是不是没有这条规则了，规则是不是少了，没有这个规则了，没有这个规则，你去看跟目录啊。😡。

根本我有没有bo的，bo还在啊，不还在，但是你去bo里边没了。

现在看就看的是这里边的bo。但是如果你挂mounttDV的SDA这块硬盘的一号分区挂载到你刚才的这个没有东西这个这个。因为你要明白内存有一份，内存里边是有一个所谓的一个boott，就给它给它覆盖上去。

那这时候你再去看boot。东西就回来了。比会我还有一更细致的一个一个一个演示，就先粗粗显的知道这个有一个。有一个虚拟文件系统就可以了。那这样的话，其实你看刚才这个挂载不挂载。

卸载不卸载这个来回的切换过程当中，你会发现。

对于程序，我们程序来说没有任何的影响。因为你的数据目录结构趋向已稳定，就是目录数。这个目录结构啊。结构是趋向于稳定的，但是其实它有一个映射的过程。

那比如说未来举一个很简单一个应用场景的例子啊，像我们根目录。USR目录是放数据的那现在你来看DF来看，唉，这个没有看到USR这个目录挂载情况，那么代表着USR是默认随着他的父目，随着他的根，随着的根。

随着他父亲是在三分区的。但是这里边如果东西多了之后，你是不是可以在你的电脑上加一块新的硬盘哎，变成SDB这块硬盘，然后就一个分区，然后几个T先给它加上来，加上来之后，先把老的数据拷贝过去。

然后再把那块硬盘挂载到你这个虚拟的目录数的这个USR给它覆盖上。那这时候未来其实你在访问这个目录里边可以存两个T的东西。能理解吧？

或者一般就是说哎root加目录或者U homemeus目录里边数据比较多的时候，我们可以给每个用户单独挂一块硬盘，对不对？哎，都无所谓。这个映射先有啊，映射有了之后，这是第一维度。

你要先知道一个虚拟目录数，这个目录数是一个趋于稳定的。没错，我们的光驱硬盘都是这么去挂它才能使用的。

收啊收这个环节到这儿就可以了。你先知道这么一个概念。另外还有一个概念，就是有了虚拟目录数结构之后。

这个有一个虚拟文件系统，呃，我想想我给你演演示完吧，再给你秀一把啊，这个是不是很多人都开始想学docker，对不对？但是现在虽然下午我演示的不是不是docker啊，但是我我我给你演示一下。

回家。😊，嗯，这样演示它的话，还需要另外一个概念。

我一会儿给你演示吧，先把这个下面的概念讲完。第一个是虚拟目录数。另外一个一般会延伸的一个知识是还有一个知识点叫做文件类型。因为要学这个的话，前面还有一句话。能跟着那这个这个这个这个这个这个逻辑吧。

首先我们要先尊重一句话，这个一句话谁说的是冯度一曼。没错啊，冯动伊曼冯动伊曼它规定了计算机操作系统的组成啊，它的组成说了有CPU。然后呢，有我们的这个库这个也不是的这个计算器。透制水。中。存储气。

然后剩下就是输入。书。设备输出设备。因为他给出了这么一个定义计算机的一个框架一个结构。那么像这里面其实计算机控制器的话就是类似于我们的CPU了。像主存储器其实就是我们的内存了。

然后输入输出设备就是所谓的我们的IO设备，先有这句话，然后这句话不白说，你要找到一种感觉，就是类un类 unit系统啊，然后基于这件事情，它做了一个抽象，效率虚拟文件系统。

然后在这个文件系统上做了一个抽象。就这虚拟文件系统既可以做映射啊，既可以做映射。还有一个就是一切接文件的一个抽象。这个抽象就是一切。接文件。这个街接是哪个接呢？仪器及文件。

这是第21个这个文件系统要做的一件事情。有时拎那盒要做一件事。那么一切接文件是什么意思？什么东西都可以是文件，你的文件磁板里的文件是文件。然后你的摄像头可以是文件，这个打印机可以是文件，只要他们是文件。

那么基于这个文件就和前面这个输入输出设备，这个输入输挂上钩了，也就是IO基于文件就可以应用到IO流。这就是和今天要讲的知识有那么一年年可以挂上勾了啊。因为今天讲的就是IO嘛。

正好他这个抽象也是为了IO这件事情。因为你光有文件，你也不读不写的话，这个本来就是一个一个一个悖论对对。那么知道它之后，一切些文件，那文件怎么区分那些东西，文件就有类型了。在linux系当中。

文件类型其实有很多很多很多很多很多啊。那在这儿说几个常用的，以及看到的和看不到的，一会儿都给你去演示一下。

第一个呢，先看一眼这个这个这个显示吧，比如在看的时候，这样有这么多东西，前面会有一些提示，就是在这行的首列的时候，每一行的详细的首列的时候，有中线和D。

中线代表的就是我们的普通文件。这个普通文件可以是什么？可以是可执行的。可以是图片，可以是文本。啊，可以是就是你常规的知道那些个普通文件。然后D。是direct目录的意思。目录文件的意思，这字小不小。

大一点啊。第是目录的意思，我现在是铺垫啊，你要呃。你要有耐心。然后还有其他的一些，比如说是B的和C的。这里面B是所谓的块设备。所以呢。这么卡。那块设备是什么意思？块设备其实就是一个。嗯。

这两个一块儿理解好理解了。如果你能够从一个设备那从一个地方读数据，可以来回自由漂移的读，不受什么约束啊，不受约束。那那个就是一个块设备。但是如果你读的时候，你读不到过去的，读不到前面的，不能随便漂移。

且读的时候还有一些比如说要要根据一些编界码或者驱动的约束的话，那这时候就是字符设备。比如说我们的键盘就是字符设备，像我们的硬盘就是块设备，像我们的socket的网卡拿到那个车的文件就是一个字符设备。

像我们的这个这个这个块设备还有什么呀？嗯。去去想吧，反正就大概这么一个区分，这两个又偏稍微偏底一点，跟程序员其实关系关系不大，一会儿给你演示就可以了。还有一个就是S开头的是socket。

真正的一个socket，还有。P开头的是管道，这两个一会儿我给你演示出来。管道。那么还有比如说之前你应该看到一个文件描符可以指向什么？Even the pull。类似于这样的一个指向。

那Epo的话代表这个文件的类型啊，它就是我们内核提供的epo的那个内存区域啊，其实还有很多啊太多了，还有太多了就不给你演示了。因为我能够让你看到的这几个应该是都能让你看得到，看得见摸得着的。好吧。

OK那这是一个那那这只是一个介绍啊，现有这么一个一个一个一个一呃，对，还有一个L开头。还有一个链接的，然后开头。链接的这么一个类型。我们一个来看啊。

这里面像所有的普通文件能打开，能读取的就是这种中线的，像目录就是D，然后DV目录下。这里面会有一些C开头的和一些B开头。啊，这个B开头就是块设备。像刚才我们看的SDA这块硬盘，它是B的。啊。C的话。

像我们那种终端TTY，比如我们所谓的终端。终端的话，其实你传的不不这个只能说是继续往后读取，而且传的时候也是传的某一种这个不能被切割的一种字符数据啊，字符级的一一种一种数据。

所以这时候它就是所谓的C啊字符型的。

其实你可以把它想成这个B想成我们type字节的，然后只不过还能自来回去切。然后这个。这个C的话其实就是一种字符的，这个往中间去。好吧，这几个非这几个应该都比较好理解。链接这个的话嗯简单给你演示一下。

链接分为软件和硬连接。比如这里面我随便写一个文件啊，马士兵点就马士兵点PIG吧。这个文件巴拉巴拉巴拉啊，随便写点东西。我可以用LN将。root然后下的马士冰点TIT。

然后变成root下的圈圈叉叉点TIT。这已经有了，那就插上新件吧。就叉叉圈圈点PIT啊，那么直接回车的话，你会看到这里面多了一个。叉叉圈圈点TIT。啊，那这个所建一个链接，但是这时候往前倒往前倒。

前面这出现了一个数字2。然后刚才的这个马士斌前面也出了一个2，这个叫做硬链接，有一个指令state，然后马氏冰点TIT。可以看到这个文件的原数据信息，这个原数据信息里边就有一个按ual的号。

它的按号是10227872。然后再state看我们刚才得到的叉叉圈圈点PIT你会发现哎他们两个的安特号是长得一样的。看到一个现象吧，就是两个文件长的是一样的。那么这个就是一个所谓的一个硬链接。

那么什么叫做硬链接？先跟我一下什么叫什么叫硬链接磁板里边其实就有这么一个文件。

磁板里边就这么一个文件。这个文件只不过在虚拟文件性当中啊，在目录当中，它有各自唯一的pass，就是从开始的根开始的根目录一直用到了它这个文件名。这个这个这个这个在内内存里边这个描述这个路径是唯一的。

但是它们指向是指向同一物理文件。

跟windows的快捷方式，那是软链接，先看先看先感觉啊，先找感觉，其实就是两个变量名，一个叫MSB点TIT，一个叫叉圈点TIT它们指向了同一个物理位置。只上同一个物理位置，这个东西是一份。

那无论软链件硬链接，它们一个特征，就是他们都是链接啊，链接是什么意思？其实就是我如果修改任意一方。叉叉娟君，我修改了它，在下边追加了一些数数字。那么这时候我去看马氏冰点TIT的时候，就能看到这个变化。

无论硬联件软件，这个特征是有的。这是硬链接。那硬链接如果我删掉，比如删掉原始的数据，RM杠F把马氏冰点TIT这个原始数据删掉会有什么后果？快速说啊没有什么后果，只不过是把刚才那个引用删掉了。

那像这个这个拆权那文件还在，只不过这个计数就降成一了。那么这一列就是这个文件硬验接被引用的数量。到这儿硬链接是啥，能听同学来说个一。哎，两个就等于两个变量引用了，一个对对立对象一样啊。

你这个拿着哪个引用去对这个对象的属性修改，另外一方都都都都能都能都能反映出来。还有一个是软链接，同样是LN，然后比如说杠Soft软。然后可以把我们的root下载，它是这个叉叉圈圈。

然后映射成root下的马氏兵点PIT回车。那这时候你可以看到很明显的一个区别啊，很明显的区别。这个这个文件就多了这么一个指向，这有点像windows了windows的快捷方式是一种软链接。

因为你要先创建一个快捷方式，它里边会一个指向，指向了某一个具体文件，且这两个文件它也是独立的state马氏冰点PIT它的按号是7871state我们的。咔嚓圈圈点TIT然后他的安顿号是7872。

1个7871个7872，且它的数量并没有被增上去。然后无论软链接硬链接，你修改任意一方，比如叉叉圈圈点TIT。然后再往下加一些字符进去。我对叉商圈改了，然后这时候VI里的马士斌点TIT能够看到这个变化。

这是链接该有的。只不过这个时候如果RM杠F删除了叉叉圈圈点TIT那这时候你的这个软链链文件指向就丢失了，就开始爆红报错了。仅此这是软链接硬链接的一个区别。

到这个链接这个类型能听回来稍边一这跟windows有点差异，对不对？

普通文件类型、目录类型的都不用不用解释，那你也可能需要给你解释一下这两个一会儿给你演示一下。sork的拍 pipeline烂待也给你演示一下。

好了。😊，演示完这个之后，我再给大家演示一个演示一个好玩的东西。把刚才我讲的所谓的一切接文件，然后所谓的块设备，然后所谓的挂载，然后所谓的跟目录这些事情都演示，演示的过程是这样的。

我还是准备一个干净的目录吧，耐克DR。

那。是非常目录。我的当天目录是空的，我准备这样一个指令叫DD啊，DD的目的是可以拷贝数据，生成文件啊，生成一块设备等等。这个死硬背也可以了。呃，它的参数第一个就是input file。它为了要创建一个。

一个一个一个设保一个一个一个类似于我们这样的一个设保文件。滴D有一个in inputput file等于什么啊，等于先看写DV zero。用我们快设备里边有一个独特的一个文件，像DV的n是黑洞。

DVDV的zero的话就是一个无限大的一个空，但是它却不占有你的这个太多的磁盘空间。然后out file输出到当前目录啊，得到一个所谓的my disk。第二image得到这样的一块磁盘文件啊，标识。

然后这文件多大呢？就是我拿多少个零去填充它呢，它这个未来是应该多大的一个文件呢？然后后边一个BS就是block的数量。这个B这b的这个这个大小，1048576学过大数据的同学告诉我这个值代表什么意思？

1048576代表什么意思？小怪兽是128兆吗？1048576，那会儿讲HDFS分布式文件性质刻意输了一下，它最小的默认参数是一兆的，一兆大小对不对？这是一个这个数值乘完是一兆啊，一兆。

也就是说这个未来这个这个这个磁盘文件里边它的块是一兆一兆。我这么去做，然后我又count。有多少个站术块组成它呢？然后这里面我准备用100，那么最终这个输出的。这个文件应该是1个100兆的。看到吗？

1048576乘以了1个100。然后它的大小啊约等于100兆。就是这步我是在磁盘上得到了这么一个文件，但是这个文件是被零被空填充的啊，全里边全是这个这个零这个电瓶听明来上边一，这是第一件事。

我就想得到这么一个文件而已啊，那得到那个文件是什么？我其实是把它要当做一个磁盘挂载到我的这个文件系统上去。那你光你我拿它做一个磁盘如何去挂载，这些都是先去经背吧。现在这个环回接口的一个一个挂载。

挂载到DVDV有一个设备目录里边1个LL loop0这么一个设备。我把我的买di挂上去。关上去之后，那么这个时候这个一切接文一切接文件都是虚拟文件系统。那这时候第一位的这个目录啊。

这个所谓的这个这个这个设备其实就不是指向一个物理的一个一个一个一个什么东西，指向的是我文件系统里边的一个文件而已，它俩一个一个关系。有了它之后，然后我利用格式化工具。

我想想是make EE叉PE叉Pwo吧，然后对我的DV的L look0。做了一个格式化，格式化的时候是会把它格式成E叉RT two的这么一个文文件类型。

这个what tab有一个fusson tab找一下。那个描述在哪？

一会儿挂上就挂挂挂的时候再给你看吧，这个就是为了要给它格式化，就是类似于你在隔你的U盘，在隔你的那个那个磁盘分区一样。好吧，就是。类似于吧，你就想成是一种跟跟那个挂的一样。

就是把我们的这个刚才这个这个设备挂到了我们那个DV这个这个这个目录上去。那我对这个设备已经把它应把这个磁盘镜验文件印到这个虚拟的环还回设备上了。然后呢，我也给它做了一个格式化。格式化之后。

那这时候其实这是一个设备啊，这是一个设备，只不过这个设备它不是物理的，它是一个虚拟的一个一个一个映射关系。那像我DF当中是没有它的一席之地的那我可不可以把它在挂到我这个虚拟目录上。

那我访问某个目录的时候，其实在访问这个虚拟的硬盘。明白什么意思吧？哎，那这时候先跟着我的先路的思路走啊，因为最后我先铺垫铺垫到最后的时候，找感觉啊，找感觉。😡，那比如说我去到一个MNT的目录。

这是一个目录啊，这个目录里边我看圈圈叉叉这个目录是空的。注意看我的虚拟文件系统里边已经有一个目录了，叫MNT的根本MNT有一个圈章是空的。我可不可以把我第一位的这个。录个零挂上去。

就像我把DEV的ID3挂到某一个目录或者SD1挂到某一个虚拟目录上一样。找这种感觉啊啊找找找找这个这个感觉。所以呢怎么去挂载mount，但是这个类型你要搞它是E叉T。

two这个刚才格式化的是这个文件格式挂在谁挂载的就是DV我准备的这个虚拟的这个环卫设备挂到哪去，挂到MNT的圈圈叉叉这个目录下。回车。那这时候先看DF啊，DF里边多了一个条目。

在你未来人或程序访问操作系统的跟目录下的MNT目录下的群间叉这个目录的时候，这个目录就再也不是你曾经的刚才创建那个在这个第三S13分区的了，而是录零这个文件里去了。这个虚拟文件里去了。

到这儿能听懂学来稍波一。😡，跟着我的思路走啊。😡，那么这个时候我们去看一眼那个目录MNT全均车边。哎，这里面是空的啊，没有什么东西。然后下边我做这么一件事情啊，注意听我做这么一件事情。

到时我一如果实在还听不懂，我看大家的一个数量，我给你画图。但是下面我演示完，你应该有这种感觉了。首先第一件事情。我where is。Blash。嗯，我觉得大家应该是不是都知道一个拜师是一个什么东西？

拜师就是我们单间那个解释程序。明解吧？就是你和lininux交互的时候，你打那个字符是哪个程序解析的，是这个拜事。这个听懂同学来说说一，这个不需要再讲了吧。Yeah。这个应该都懂啊啊。

而且他还只持脚本编程都懂啊。那么where is就是告诉我这个程序它在哪儿。你会发现他在B目录下有一个bsh，这是在我操作系统B目录下。那我现在是在哪个目录下，我现在是在我的这个虚拟目录。

虚拟文件系统的一个目录下MNT的均叉下。那这时候我做一件事情，makeDR。创建一个并目录。那就多了一个B目录，我把谁拷过来，我把操作系统跟目录下边的一个B目录下的b拷贝到这个B目录下。

那也就是说其实我是在我刚才挂载的这个虚拟这个这个这个目录下，有创建一个B目录，里边，并放了我这个拜事这个可执行程序。能明白什么意思吧？哎，有这个这个这个放了个程序了，还有一个指令就是LDD。

LDD接上我们这个be事，它可以分析。你的这个程序，它的动态链接库有哪些？就是这个程序如果启动的话，它需要其他就这个这是程序可执行的。但是它启动的时候，他可能需要一些库里边提供的一些方法函数。

可以动在架子行，这个这这些这些这个就是它的依赖，就是它阳启动的话的依赖这些东西，这个能听懂原来说ber一，然后且发现它们的规律都在lib64这个目录。😊，啊，libabary64这个目录。

所以我就返回上一集。有人是不是已经感到我要做件什么事情了？我这边目录刚才创了一个病里边放了一个b，同级的话在这里边再创建一个lab64的目录。

我其实拿这个子目录在模仿我的根目录里边的目录结构以及程序的这个摆放位置。然后做一件事情，拷贝你上面根目录la本64里边，它这里边是有这些文件的，但是这文件好几个可以用一个花国号。

然后紧贴着把这个文件名完全粘过去。一个文件我要考加一个逗号，这叫花括号扩展俩文件。因为你的他们都来自于这个一个目录，最后花号里边东西一个S去拼接它们，然后将下一个文件。还有一个文件是他。然后画框收尾。

这里边不允许出现任何的空白符，整个这个花框会上这个写法，把它这些文件一口气儿拷贝到我当前目录自个儿创建的le64这个目录下。

那你看到是不是这个里边注意这个这些文件都是我自己的在我这个目录下创建的里边放到一些东西了。到这一步呢看同学来说波一。は。然后呢，有了之后，我现在准备了一个程序存在的目录。准备了一个它的库载这个这个位置。

如果这是一个根目录。是不是启动这个成立的时候，他就固固然的去这个目录找一个库就能挂了，他他就能启动成功，对不对嗯。Change root。有这么一个指令啊，都是现在都给你演示告诉你的是一些相关知识。

其实这些跟你们没有毛关系。因为这些都是运维干的事儿，但是我告诉你系统里有这些个知识点就root。然后一个当前目录就是把跟目录切到当前目录，并把并下的b事启动走。你先看到得到了一个。

接受我们用户输入的一个一个提示框。但是这时候是跟上面这个提示框是不一样的，这显然是俩程序。他的进天I号是4278，一会儿我告诉我，一会儿我们回去看他的进天I号是多少。先记住现在这个拜是。

他的进 ID是4278。然后在这个里面你执行LOScom not found，然后执行VIcom found，然后执行com found。其实这些都第些命令都没有找到。为什么？

因为我刚才在这个目录下并没有放这些程序。我只是放了一个bash，但是放bash不怕，我是不是可以用ele，就是b事拜事自带的一个打印程序，然后打印一句。hello，马士兵将这个字符串用重定向。

这也不需要外部程序，都是拜事自带的。重定向到根目录。注意这我写了一个根，下边1个ABC点TIT回车写成功了。我打印了这么一个字符串，用重定向写到了所谓的虚拟文件系统的根目录下的ABC文件里。

到这步都能看的同学来上边一。他的进来量是4278。然后我退出这个程序，加击退出就回到了刚才外界这个程序。然后我先打印echo。ID号刚才的这个bsh是4278，是由这个闭目录启动的。然后请他之前。

其实我这个真正解释程序是4117。另外一个副blash。那现在我要验证一件事情。第一个我先去跟目录跟目录去看，刚才是不是先根目录写了一个ABC，我先去我这个物理操作的根目录看有吗？有ABC吗？

是不是没有，然后这个时候再回到。这个目录刚才我是呃这个这个去到MNT挂载这个目录，这刚刚才是在这个目录下，对不对？这个目录来看是不是多了1个ABC点TIT我是在这个目录下亲入的清了了根目录。

并把它跑起来了。那这时候程序虽然那个新的系统里边有一个b，但是我做了一个根目录里边放了一套另外的bash。然后所有他们的跟文件交互都在这一个目录下完成。啊，没错，跟切换了啊。

但是这个时候跟你们所有的docker不一样啊，跟你们所有的docker还不一样。刀cker它不止一个文件系统的一个秘密空间的一个一个一个一个一个一个一个子域。好吧，现在我只是告诉你有这一个感觉。

以上所有的回顾一下，从最开始的时候，我在我的本地磁盘里边准备了一个文件叫做买d。

点儿image。我这个文件是不用DD命令生成的啊，一个空的文件。然后我把它挂载到用L set set up，挂载到这个所谓的虚拟文件系统的DEDV模型。零这个设备上。挂上去之后，我对它进行了一个格式化。

格式完之后，然后又mountant这个东西到了我的根目录的MNT的圈均叉这个目录。那也就是其实作为上层程序，如果访问这个虚拟文件系统的圈金叉，其实访问的是谁？访问的就是这个文件。

而且我在这个文件里边又自主的创建了一些bin，拷贝了一些bsh等等的一些东西往里放。那其实我在这个目录放的所有文件，应该存在哪了，是不是存在这个文件里去了。到现在能听同学来说个一。

这个整个这个实验的演示的过程当中，就有一个所谓的虚拟一切接文件。我拿这个反正是一个文件，我可以挂载，然后可以映射，然后可以操作。

啊，那这个时候你现在看这里边有刚才这些东西啊，然后如果我退出去DF这边也有了一个映射。你现在访问他看到的就是这个这个设备，那也就是那个文件的。如果嗯。Mot。MNT全给它卸载掉，你再去访问它。就是空的。

但是如果但是但是你要注意啊，你要注意，现在看是看不到了，但是这个文件是不是还在？嗯。啊，随萍在这个共下，我刚才那个镜像文件是不还在这个镜像文件如果给你的话，你挂载之后，其实你也能看到这里边东西。

那在这个间接的去遐想啊，去假想。如果你学过docker的话，你会发现docker里边是不是第一步你要先有imageimage里边是不是要先放你的程序。docker其实是容器，容器这个虚幻的东西。

它是一个命名空间，里边跑的是进程。没有操作有内核什么之类的，他所有的docker复用的是你物理机这个统一的内核。你先有镜像，有了镜像之后，才有con它的容器的一个概念。镜像这的磁盘呢是Eage。

其实需要先挂载，挂载之后切换根目录读取里边的那个进程的那个执行文件，再准备命名空间，然后这个这个进程的空间等等的，然后再把它跑跑到个这个进程这个命名空间里边，那程序才会跑起来。

这个间接有感觉同学来刷波刷一波一，这个源于它这个整个这个虚拟文件系统的一个支撑。

系列 3：P18：【多线程与高并发】锁的特性 - 马士兵_马小雨 - BV1zh411H79h

这个所谓的最基本的概念啊，我们来谈一下synchronized的它的一些个特性，如果说你每一次都定义一个锁的对象，就是object order给它new出来，弄出来一个一个对象，那这次枷锁的时候太麻烦。

你每次都得用另一个新的新的对象出来，所以呢有一个最简单的方式就是synchronized this，锁定当前对象就行了。

那么如果你要是锁定当前对象的话呢，其实你完全可以写成public synchronized的这个方法好，所以synchronize的方法和synchronize this。

symnet的方法和synchronized this，在this里面在执行这个代码。

它是等值的，是一样的。

那么那么大家知道呢静态的方法啊，静态方法static方法它是没有那个类似对象的，因为你不需要你有一个class new出一个对象来，就跟就能执行这方法，那这时候如果我在它上面加一个static的话。

加一个synchronized的话，这sychronized代表的是什么呢，这里代表的是synchronize的t点，class，说到这个tter class，大家知道那个每一个class文件呀。

漏到内存之后呢，它会生成一个专门的对象，哪个类的对象呢，class类的对象和load到内存的这段代码相对应，所以呢这里的synchronize的t0 class就是锁的是谁呢。

锁的是t这个class的对象。

他也是个对象啊，就是class那个类的对象而已。

特殊点和其他的没有任何区别啊。

系列 3：P180：【IO／NIO】文件描述符,nodeid,脏读 - 马士兵_马小雨 - BV1zh411H79h

第第一个知点。那么下面怎么去演示，还是介绍一个都是用指令啊，今天是指令层次的应用层次的，不是那时源码级的去直接解读。因为看那个你也看不懂，我也看不懂说实在的，我们还不如用指令去去演示这个东西。

先介绍一个命令LSOF。ISOF的话是可以显示呃进程打开了哪些文件啊，打开了哪些文件。比如说杠P告诉他。这个进程两个doer，就是我当前那个b事进程。能理解吧？嗯，回折之后。

你会发现当前这个拜事的这个进程啊。它里边上边比如说current work direct当前目录是这个我现在工作的这个这个这个目录啊，然后ro的跟目录在哪？

像下边会一些这这个东西这个列的FDM完就没有没有符。但是除了我之前给你们讲过，听过的或者012，这里边还有这些概念。比如说文本域这个文本域其实说白了就是进程启动的时候加载那个可程序可程序。

可定行程序的代码段。然后下边这些mememory说白了就是你分配的内存空间，比如做了一些独态库链接的挂载。或者未来你会用M map去挂载一一些个这个文件，到你的内存，直接带成buffer可以铺的时候。

也会出现这样的一个引用。下边的012到这个环节，这个区域当中，零就是这个程序的标准输入，一就是标准输出，这个就是文件标准符了。二就是报错输出。任何程序都有0123个文件描符这个知识点。应该都知道吧啊。

知道来说波一。别蒙啊，因为使用操作系统这种命令行的时候，它打印的都是一大票的字符，你肯定蒙。但是你要知道这些东西它代表啥意思。哎，现在没听懂的也不要紧，现在我给你整体解讲一遍啊。

这个我的公公开课都没有讲过。REG是类型是啥？这个那个单词怎么翻译完了，就是基本文件的意思，就是它来自于是一个基础的一个文件。这个它是tab类型嘛。啊，这就是那个中线。

刚才我看类型当中是不是有中线。这个中线如果看的话，就是REG。然后这个叉是什么意思？就是字符设备CH2。

好吧，嗯，然后什么是文件描述符？注意我刚才说了，文件描述符，它代表的是你打开的这个文件，它里边会有什么东西，会这个文件它是在哪？啊，以及他的应该还有一个I这个就只能用那个I的号。

这这列其实是按卓的号的意思啊，只不过现在这个是我们抽象那个抽象，那个这个先不用管，待会我给你看别的东西，先先记。第一列是tap，就是这个文件标符，它代表的是哪一类。然后下边这个它的设备啊。

这个设备号以及是哪哪哪一块，这块是有一个偏移量。像这个零样呃，你可能看不懂，看我现在下边做这么一件事情。我让我担心那个程序打开一个东西，嗯，打开一个。叉叉点2494调查。

刚才是不是应该有一个提一个叉叉圈圈啊，被我删了是吧？谁看看。我先看你圈传这个文件，里边有一些乱七八糟字符的的。他有一一定的体梁，它有一定的体梁啊，然后做一件事情EIEC然后令我的8，然后呢可以去。

读取我的。圈圈叉叉这个文件回车。POC去到根目录的POC，然后。FD目录。我先给你演示啊，你没看到这个程序，它自己有012，还有一个8这个八指向了这个文件。那这时候之前给你这么演示的。

用LSOF杠P当前这个进程里边对应的这有一个程序看它FD的目录里边会有012和1个825先不用管，在这你可以看到跟刚才也不一样，有012这个读起来很麻烦。但是你看这是不是多了一个8且是读取。

刚才我说了定义的创建了一个文件描符的时候，就创建了一个8，它是读输入流读取这个文件，这就是一个读U的话就是读写都可以，后边我读的这个就是一个普通文件了。

这个文件就是这个单词REG然后它在的是这个设备的第三个就是跟目录那个第三分区，然后它的先移量，这个可以再加一个。看O啊，再加一个O啊，带偏量的。它的偏移量，因为这个文件刚打开，对于就是这个进程啊。

刚打开这个文件，它的偏移量为0，指针为0。就是一读的话，读第一个字节，它的Iode号是7564，你可以stateate。就把知刚才讲这都都串起来了。我刚才那个打开的文件是圈圈叉叉这个文件。

它的I号就是7564。这是它的文件名。那么什么叫做文件描述符，你也得想成想成就是文件描述符，它就描述了你打开的这个文件的一些具体信息，以及指针偏移。退回来刷波一。这是第一个啊。

我们先通过LOF这个指令看一个进程的时候，可以得到唉这里边有个文件描符它。然后这时候注意啊，我再给你演示一下，今天先看演示，今天先看演示，为什么是0T0。你看着看着read是读取东西的。

我可以把读到东西放到一个变量A里边去，然后read读的时候，它可以从标准输出读，也可以让它的标准就是任何程序都有012，这种输入输出流的文件描符，我让read标准输入零来自于后边加上按的符。

一个文件标符8，就是刚来自于我这个8。这个八指行了一个文件，但是readd有一个特征，它只读到换行符就不读了，所以它不会造成把整个文件都读完。这个指针偏移量到换行符的停住。后边的不读。

所以这个偏音量不会走到末尾。能明白我什么意思吧？哎，那我当执行了这一行之后，首先先看这个指令啊，从他读取了把这个文件描符指向这个文件的东西付给了A，那A就应该是可以看到读到那个文件的开头的3个A。

因为刚才看那个文件的时候，他打开那个文件啊。这个文件的第一行是不是3个A，这有一个换行符你看不到，但是它的确存在换行符。到这步能看怎学来shop波一就是read通过8读取了这个文件的三个是三个吗？

应该是4个字节，加一个黄合符，对不对？哎，加一个黄横符，一共读了4个字节。开始我创建它的时候，它的偏量是0，但是这时候LOF。杠。offset进程ID。当前那一个进程，再来看它的偏音量。

那个sick指针就指向了4了。A是一个变量，这个A是一个变量，是我当在这个环境里的一个变量。我可以用ecle打印doller A来取这个变量的值。这是重林项的事。哎呦，我操这些知识不是都讲一遍？

到这儿哎，就是咱这个没听懂的，不要紧，我到时争取的我我看时间，要不我给你把这个linux系统再给你讲一下。呃，得讲不讲的话，到是管道不好讲。那个因为你要看一个 paperline啊。

就是咱咱先一分分批来啊，分批来。所以我这个这个能听懂的同学或者嫌我讲的慢同学，你就忍一忍，咱们的确有很多还是不太。😊，不太了解这个东西的啊，首先能听懂就中间这一层能听懂的啊，不嫌弃我的啊。

然后我讲这个能不能听懂啊，就是什么是文件描述符，它里边存了一些个对这个文这个打开这个文件的一些描述故我这个进程来使用的。但是这时候注意了，我是不是还可以再开一个程序。

再开一个对这个这个这个系统的连接访问的这个程序。

这个程序它又是一个b，然后呢，它也有自己的这个CDPROC，然后呢，两个都是代代表自己的这个进态ID号，然后呢FD目录。就是4322是自己的进程，前边这个是。4117这另外一个进程等于两个程序。

然后但是这里边刚才这个程序打开了，用一个8，打开了一个文件，可以读它了。通过读立的一个文件面符的时候，然后这边这个程序还没有，那其实它也可以用1个AC，然后用随便用1个6。

然后也是想读取加目录下的圈圈叉这个文件走。那这时候前面你注意看啊，这边的应用程序已经让这个文件的偏移量到四了。那这边这个程序打开的时候，注意看LOLSOF杠OP哦这个O是outset这个P是新加记号走。

这个六是不是也是这个当前这个432这个程序，它用了一个6的文件描符，代表了这个文件，且记录了一一个对这个文件的一个使用。然后它的偏移量是不是现在为零了？

那也就是我把我刚才我讲的东西，我说了，我先讲概念，后边给你验证。开始我说了两个程序可以同时打开一个文件。但是FD里边他们会各自维护各自的指针。但是这个文件的数据是在内存里是一份的。

dollar dollar是当前这个by是进程的进程的IDID号。这个概念是不是印用过来了？哎，如果这边如果也是read的一个往往A里去写，读的时候，来自于6号文件面号符，读6就是读它偏量为0。

那它应该也是读到3个A。对不对？然后让他再多读一下，你看他再让他多读一下，再让他这个read的A来自于6号文件妙尔符。因为在这个流里边已经读完去第一行了，再读的话应该是第二行。

所以再看这个变量就读到第二行东西。然后这时候IOSOF杠OP然后当前进程它的偏量已经到16了。就是这个文件的偏量到16，但是注意了，这是这个6号文件描符这个进程里边的文件描符的偏量到16。

但是去看另外一边这个。这个进程里边对于这个文件的文件描符。还是这个4，所以他在读的时候读的是他的四后边那个数据，他读取的时候是不会受他那个偏量影响的这个有点像我们扎当当中的D代器，现在听懂了吧？哎。

其实说白了，内核为每一个进程各自维护了一套数据。这个数据里就是包含这个进程的FD文件标符FD里边维护了。一些关于这个FD指向的这个物这个虚拟这个一切金文件嘛，这个所谓的文件的啊偏移呀。

然后一些这个安号一些元素信息以及这个但是缓存p是通用的，公用的，在这没有没有看到啊。

系列 3：P181：【IO／NIO】socket pipeline - 马士兵_马小雨 - BV1zh411H79h

跟种速度啊，现在我有一个新的进程，这个解释程序就43980他的ID号。然后去PROC，然后4398看它的FD目录，这个里面只有012，它的一个程序的最基本的输入输出和报报错。然后我做一件事情。

这个在光测我还有那个前面讲我的通讯的时候，我也讲过，比如我准备一个8输入输出来自于DV的DV是一个设备目录，一切接文件，然后有1个TCP你看不到的目录，它虽然看不到。

但是有这个那这个那核里边是有这个路径的，但是这不不是给人看的，后边接3W点百度点com，然后80端口，这看似是一个目录。但是一切接文件，最终。有点慢，有点卡。最终它会变成一个文件描符8。

指向了一个所谓的一个scket，然后现在又多了1个LOF，然后杠OP到这你这能看到一个表面的一个8展scket。但是这个八指向的是谁，指向的就是一个IPV4，上面一看叉，这个就是IPV4了。

它就是一个所谓的一个socket。只不过平时我们看不到它，只有在有它产生的时候，这个文件描符才能标识出出它来。然后以及它是PCP连接的啊这样一个这个安就是不是具体的了。

因为它不是文件的某一个真的一个文件了。后边就是我那个01自己一个随机端录号，连了百度的1个80端口号，已经建立连接了。文件描述符一切接文件，任何东西都可以是文件，文件描入符都可以去描述它的。

这就是所谓的这个文件描符出现的意义。在linux操醒当中，因为它先有了一句话，一切接文件是不是一切接文件了。然后它实际上看到是文件，然后它实际上是一个scket的，但是它也是一个文件。

然后会有文件描符去描述它。这块能听回来，说个一。嗯。

这块的没有啥没有啥演示的了。set的你应该也知道了。然后呢，还有一个是管道的这个类型，一般你也看不到，像S那个类型，就前面什么S类型你看不到。因为它是程序内部可以产生的啊，那核还不让你看。

所以你看不到它。但是你可以知道得得有这么一个文文件类型，它是可以用文件描符表示的。还有一个就是管道说的管道就把你们刚才所有人不会我都给你整整体给补一遍吧，咱们从哪开始讲起。

咱们先从文件这个这个文件描符的012开始说起。首先你要知道一件事情，死记硬背，任何程序都有012，只不过你用不用的问题了。

012，然后零的话就是标准输入。一的话是标准输出。二的话是报速输出。死记硬背啊，先死记硬背这个这个概念。没有什么理由，linning就是这么对程序就这么去设计的。

都有任何程序都有零样这个三个最基本的一个程序，你写的时候，只要你你就一个你只要想创建一个ja程序，零样就有了steem点in点s点arrow，但是你还可以打开别的文件，在打开的时候就会出现45加90。

这是文件描符要描述你打开的那些个文件。

🤧然后再往下。任何都有的时候，这个时候我们还可以看到它去PLC。去到你进程所在的这个路径PLC啊，先说PLC这个目录是内核映射目录。

这是第一个知识点，任何程序都有这个它，然后怎么去看它跟目录有1个PROC。PC这个目录是。映射的我们。内核里边的一些变量属性等等的。就是虚拟文件系统吧，它的每个目录并不一定非得是磁盘上的。

像PLC这个目录，你再看你成为看开机的时候，再看到的时候里边有东西。

就像你看到的东西了，你把电导关机，你偷摸看那块硬盘那PLC里边是没有东西的。

它这个开机之后，内核里的一些变量属性等等，都会在这里边去挂载。内核有什么，内核比如说有进程管理，你看那些数字的目录，其实这每一个数字就是一个进程代例号。能明白什么意思吧？哎，就这这个就是进程代地号。

所以进程被内核管理。那进程或者内核的一些个网络等等的这个一些属性都在这个里边是可以去被被映射成文件的。一切进文件，即便是连程序内核里边的一些变量属性和对象等等都可以映射成文件。

这是这个目录可以右一切接文件这个可以挂挂上勾的到这部分听同学来刷二边一先强记啊。然后在这个目录下，然后你去到。doll了 dollar，那么do dollar，我说一下doll dollar什么意思？

doller dollar是当前。😡，bsh就是和你互动的这个拜sh的PID进常列号，这是一个特殊的一个环节变量。而且它极其特殊，一会儿我还要再说他同样获得这个PID的。还有另外一个变量叫做败是。

TID有两个变量都可以获得和你当前交互这个进程的ID号，一个是两个doller，一个是。但是PID。这个能取出来，这两个也能取出来，但是它比较特殊，它特落在哪了，一会儿讲到管道的时候你就知道了。

那么在这个目录下。PC的目录像。有1个FD的目录，就是当前这个程序的所有的文件描述符，你还可以用另外一个命令。LOF然后加上OP。带一个参数杠OP，然后到到这来看这个当前这个进程。

这个b是它所有的文件描符的细节，这个只是简单知道哦有哪些文件描符，它打它指向了什么东西了，这个是可以看到文件描述细节的偏移量指针等等的。这就是刚才我讲的一些知识的一个算一个小的一个总结。

这些都应该能听懂吧。听懂的同学来说个一。Yeah。

哎，这个能听懂之后往下走。你都能看到里边FD了，也就是在这个目录下去到doll了 dollar。他就会转成4398。啊，就进到这个4398那个目录了。4398这个目录进进进来了，进来之后啊。

这一个进程还有很多的属性参数。哎哎，我怎么挪这个窗口，还有很多手用参数都可以给你映成文件，就是一切接文件。它这里边有比如说namespace挂载的，有FD文件标符，有task现成的数量的。

然后我们去FD的目录，这个FD目录里边就是可以看到所有的这个程序当年开启的这种IO。啊，对哪些文件K加O有文件描书可以代代可以代表它了。😊，这是现在讲的知识。那么你能看到它之后有什么好处？

操作系系统基于这个的本质之上，它有一个linux有一个功能叫做重定向。注意，首先说重定向不是命令。重定不是魅量，重定向是一种机制。啊，什么机制？举一个很简单的例子。如果在你开发一个java程序的时候。

你如果new了一个fi。如果在写ja程序的时候，你你写了这个。死代码用了一个file，这个file就是你的根目录下的圈圈叉叉点TIT。那这时候你会得到一个所谓的一个fi。然后比如说这个I file。

等于它这个伪代码这个也算不伪代码了，这个代码都能看懂吧。就是你读你想打开一个文件的时候，那肯定就是你写死了。那这个程序一旦被编译的时候，请问还变得了吗？

这个程序如果未来你通过它身上I fell点get啊，是get应该什么呀？就是一个out to stream。应该扭一个扭一个啊，就是应该扭了。如果你扭一个output stream的时候。

如果放了iF的话。那这时候如果未来你你会得到一个一个out，对不对？有写尾代码了，你如果在out写出的时候。你写一些东西的时候，那代码写死了，一定会向这个文件去写。到这步能听回来，说波一是不是写死了啊。

你程序你在你程序员看自己代码的时候是这么看的，对不对？但是操作系统里边，他哎他他特特特别讨厌操作系统的时候了，你你我我我能知道你你里边怎么回事。当你要对这个文件去有一个输出写的时候。

这个过程当中其实会伴随着得到这个outt其实是什么呀？它会伴随着得到1个FD在系统的在系统里个界面里边，而且能给你能让你看出来。😊，这就是一切接文件，还能看到这个FD。

你你在ja里看的是out这个对这个这个对象。其实这个对象是谁？在操作这层面看到1个FD。

一会儿就会在这能看到1个FD。如果你这个代码里边有一个，那只不过这个FD指向什么呀？后边指向的应该是你写的这个。

学商这个文件都被暴露出来了，这句话能听出来。说波一就是你代码虽然写死了，但是这些个映out或者个FE映射这个文件这个规则会被暴露出来。暴露出来之后，它有了一个机制，这个机制叫做重定向。

它可以选择让你的IO指向别的地方去。

对吧？那个重定向机制怎么实现的？往下来啊，重定向的时候，其实我们的输我们的流的方向无非就是输入和输出，对不对？留的方向IO嘛无非就是输入和输出。那其实换到操作符上，那输输入就是小于号。输出就是大于号。

这个叫做输出重定向操作服的基本服务。但是它有很多种写法。那么重定向怎么去实现。我给你解释一下。比如说像我当前的，比如我要启动一个程序啊，我要启动一个LOSL可以读取你给出的当前目录。

并把当前内容把你打印出来，其实任何程序都有012，注意听啊，任何程序都有012，我是012。其实这个L它是个程序，它也有012它的一是标准输出，一是标准输出，那它的一指向哪。

一指向了屏幕就打印到屏幕上了。那这时候如果我LOS打印当前目录，把它的标准输出输出重定操数大于号给它指向你加目录拨浪号是加目录录，你加目录的意思，加目录下有一个LOS点out那这时候屏幕就看不到。

到这部分能看懂同学来边一整个这行参数有几部分组成。第一个是指令一个程序，后边是它的参数，再往后注意这个一大于号，这不是它的参数了。

截持了知道了哦，一大于号时触发一个机制，是让未来IOS它的标准输出一不要再指向屏幕了，换一下它映射，换到这个文件上去。那这时候换完之后，它再一执行的时候，就会把一里边标准输出打到这个文件里去了。

所以你就看到了会有1个IOS点out。

就看到这个IOS执行打印那那些内容。

好吧，这个是重定向，输出重定向，有输出重定向就输入重定向像catca。比如说可以读取一个圈圈叉叉这个文件，它这个cat里边有两个流，cat这个程序一旁，你都能写出一个cat，用加入程序。

它肯定读了一个参数，这个文件就open它了，打开这个文件之后，读了它里边内容，就是它的输入流，cat有输入流。因为它读了一个文件，它cat有输出流，并把输出的内容打印到屏幕。它有两个流的对接。

这个cat，那它就有它有流任出就有流。那我可以让cat在启中的时候，它的标准输入。它的标准输入来自于我们的圈圈叉叉这个文件，并让它的标准输出写到cat点out。

那这个时候其实你就把这个程序原来硬编码的那些东西给它改变掉了。那屏幕也没有了，那这时候你去看。看点 out。这是打印出来的，就输出两个方向，他给通过我们的人为干预已经已已经已经改变了。

这个能听明来刷波一还有一个刚才我演释了一个readd命，对不对？哎，一个rad可以后边搁一个A，对不对？哎，注意这个A是一个变量r它起到一个什么效果，注意看回车屏幕阻塞了，你在这儿随便输入点东西。

按任何字符它都不停止。但是一旦你按下回车键。哎，它退出了。那么也就是说read这个readread个这个指令，它对换行符极其敏感，读到换行符就退出自己。那么它做一件什么事情了，它通过标准输出。

就键盘的输出，这键盘的输入，通过标准输入键盘的输入，任何东西都零一样。它的零其实现在对接的键盘，你给了东西之后，它判定每一个字符是不是回车，判断回车之后停止并把读到的东西复给了A。

所以你打印A的时候就看见到刚才那个输入的东西了，就复值给他了。那这时候任何程序都有输入输出，所以read。😊，在给A读动力的时候，我可以让它标准输入来自于。一个。刚才把咱们那个cat点out这个文件。

是不是可以重名一下，本来你硬编码read的就是要来自于s点印标准输入的。零会映射到s点和它的一个一个东西，那它映映射到键盘了。但是我可以在你启动的时候给你指向到一个文件。

这作为这个文件里边内容作为你未来要读的东西。那回来之后就不会有阻塞等等待用户了。因为它已经把键盘转成文件了，所以回着之后就就直接退出了，因为它已经从这个零不是读键盘，而读文件读到东西了。但是注意看了。

我们先看VI点里边会有很多行内容，那么请问A里边存的是什么。😊，刷一下。😡，A里边会存什么东西，是整个文件内容吗？还是3个A啊？没错，他对换行符非常敏感，这叫IO流里边的所有这个文件，所有字数往里留。

它一读到换行符就结束了。所以ecle A的时候只有3个A。就第一行。这是基本的输入输出的一个原理。听同学来说分一。是。哎，除了有这个最基本的，还有一个进阶的，还有一个进阶的。我的流的对接除了可以对接到。

案的就是全部的意思嘛，到时给你解释啊，我现在就要开始讲高级的了，除了可以对接这种，就是它后边都是文件，前面都是文件描符。在这儿有一个语法格式，先强调一点啊，就是从定向操作符。

无论是输入还是输出这个重建操作符，左边放的是你要改变的这个程序，它自有的那个文件描符，且两者之间不能有空白符，在命令行当中空白符极其敏感，会做死例的切割。切开之后，它会认为零是前面它的参数。

再也不是那个文件描号符了。明白什么意思吧？这个成序都退出了，当然单单当当次有效了，就是它启动的时候，我改变了你零的位置。重电操作符左边如果你放文件标符，两者不能空白符，右边是可以有的。

默认这个这种重电操作图符，右边放的都是文件啊，都是你的数据源的，你的文件。但是其实我们有的时候可以把重电操作符对接起来。可以从内容操作对接起来。举个例子。我常给你们举个例子，比如ENEC嗯。

哎又说他又又又又又又又开始蒙了，怎么给你解解哎，就这么这么一说吧。比如说LOS我显示当前的内容，然后呢，LOS可以接两个参数，一个是显示当前目录，一个显示根目录下的圈圈叉叉回车。

那这时候注意LOS的输出有两个，一个是报错了。因为如果你看LOS圈圈叉叉这个目录的时候，是不是会给你报错不存在。能理解什么意思吧？哎，那也就是LOS在执行的时候。

它可以显示你给给定的有的这个目录里边内容或者报错，你给的目录不存在。那其实这两个输出它应该是一个走了stem点outt，一个走了sem点arrow，一个走了一，一个走了2。

这个能听同学来说边一也就是LOS如果显示既显示当前目录，又显示一个不存在的一个目录。那么这时候我可以让标准输出一，重定向到1个L01点outt。然后屏幕上就没有标准输出，但是报错。

这也可以看出来到报错还有还还被打印。所以这时候你可以再改，让二指向到LOS02点out。那这样屏幕就没有了，你可以让两个留写到独自的文件，各自的文件去，也可以让他们写到一个文件去。

但是如果要写到一个文件，比如写到三去，这个重电操作符默认是覆盖的，它并不是追加的。比如说这两一的这个LOS的标准输出一和报错输出2，他们都写到LL03那个文件回车哎，屏幕没有，但是你VNS03点out。

这里面你看到的是只有标准输出，没有那个报错，报错没有写进来被覆盖掉了。这个能听懂来，shop边一哎，那有人说可以改追加，还有一种写法，其实是可以让一个文件描入符指向另外一个文件描符。

另外一个文件描符指向一个文件是不是可以了？能理由下明达什么意思？也就是说我可以让二指向一，对不对？让一指向1个L04点outt这个文件，对不对？就这个思路能听明的同学来刷波一。但是你要注意了。

但是你要注意了，第一个只有两个只有两个bug要解决。第一个叫语法。我说了，从定向操作符左边一定放的是你某一个这个程序的文件描符，右边放的基本是文件。但是这里边它是文件。

它其实说的是这个程序的一号文件描符是标准输出。你如果右边重现操作，如果右边放的是文件描入符，重定向操作符的右边。如果放的是文件描入符，请在重定向操作符后面放一个and符。这是一个硬性约束。

如果你不写这个案，他就会认为把错误写到一这个文件名里边去。这不能听懂来刷波2。好吧，那这样写的时候，是不是可以可以完成这个程序的二合一就对接起来了呢？我们来看结果啊，回车，你会发现屏幕上依然有报错输出。

那这是重定向操作符的另外一个基本语法，从定向操作符绑定是有顺序的，它是一个一个去绑定。当二指向了一的时候，其实这时候一还没有指向文件，一指向的是屏幕，所以二指向了一又指回了屏幕。

这时候一在指向文件的时候，二依然根据刚才那个指向，它指向个屏幕去了。其实二并不是指向一了。在这个指行的时候是二指向了一的位置。一后来改了位置了，抱歉，你曾经一那位置已经被二指向了。

所以他俩应该分个个才对。就是让二指向一把一的位置先指向这个文件，一就指向这个文件了，把二指向一的位置就指向了一。刚才那个指向这个文件的位置。回车屏幕就没有了VNL04点out里边既有报错，看到了吧？

又有正常输出。这是纯定向操作符的基本语法。都能听朋学来说波一。哎，这这些应该都是。最基本的一个知识啊。重定项操作服有了之后，我们讲另外一个知识点。

学linux，你必须就是先你要先学成定项，成定项。学完之后还有一个非常至至关重要的一个支识点。这个知识点如果不学，你lininux白用，就是管道。管道式呢就是一个叹号，不是就一个竖线。Com。

什么是管道啊什么是管道？举一个很简单的例子啊，举一个很简单例子，介绍几个命令。哦。马士兵拿到这个目录，我准备一个文件VI1个tests点PIT。这应该这应该这应该这个这个太费之间讲这个知识，到是没办法。

你们这个还是给你们补吧，要么然后边没法讲。这是我准备了一个文件，这个文件有若干行。呃，比如说先介绍两个命令，这都是在我们日常生灯常用的一个命令。一个呢是had头ha头。然后呢，默认如果你接了这个文件。

它会显示这个文件前十行。当是这个文件显然不是特别的多啊。再往下追加几行。上面上面字母，下边数字好吧。这个键盘好难用。然后用head头。可以读取ts，哎，你读到它就是十行，相对应的还有一个t读这个文件。

就读到末尾的时行。这是两个指令，能听的同学同学来说边一head杠一test可以读到文件的头，连续的从头开始读出一行来。headd杠2，它可以连续的把头开始这个文件的两行hd杠3。

它可以连续读出这个文件的前三行t一样。杠一你读它就是文件最后那一行。杠2的话就是从文件持续到文件的两行给你显示出来。但是没有一个指令说我想显示文件的第八行只显示第八行。能理白什么意思吧？哎。

就是目前来说，你掌握的指令里边只有ha的头，只有这个t尾。我要想显示中间的第八行怎么显示？我想想示中间的第八行怎么去显示？那这时候用管道就对了，因为一个命令headd-8把文件的前八行取出来。

交过通过管道交给tll的留下最后一行，这就是第八行。听不明来刷波一。先看表象，就是我一个程序执行，我虽然拿不到精确的第八行，但是我可以从第一行到第八行全给它搂出来。录入来之后。

把这个八行的一个数据集交给管道留给了另外一个指令。这个指令会它的特征就是留下最后一行，那前七行就被过滤掉了。前面的管道的目的是前面的输出是作为后边的输入，这是管道的基本特征。这个特征听了之后。

那么下面进入一个非常之。这个烧脑的一个环节。😡，这还差一个知识点啊，就父子进程。我操今天失败了，这个课讲的有点疼，有有点有点疼了。这知识如果不成体系讲，我等于我其实这节课应该先讲lininux。

我把lininux操系总讲完这个使用讲完之后，我再给你讲这个。关于IO这块的知识的好好理解了。这里边还有变量和环境变量的概念啊，管道是听到这儿，先听个响，先听个响。我下边讲另外一个啊。

再来听这节课这节课咱们就改个课程名字，叫lininux基本使用啊。😊，嗯。讲另外一个知识点。嗯，先看ecle dollar dollar，当前进程的ID号是4398，这是一个bsh一个程序。然后呢。

我们还可以再启动一下并下的blash。再启动一个binmat，这就是一个什么呀？4463了。那么这时候用PS tree可以看到。我PStra是一个指令，他来自一个拜师，这个拜师又来自一个拜师。

前面这个拜师就是4398，他的儿子就是这个拜lash4463，他们这两个进程是一个父子关系。进程是有父子关系的。来听懂同学来刷波一，你还可以用PS杠FE，然后grave，这就是管道啊，前面的输出很多。

通过管道交给gravegrave抓取谁抓取一个4。398回之之后，你会看到4398这个进程就是一个bash。然后呢，4398这是父进城，就是他儿子那个进来地4463，就是4463，这是他儿子。

也是一个blash，这是他们一个父子关系。对吧啊，这也是一个前置知识。那我退出前当前这个这个拜事拜一回车，其实退出的是4463，又回到了4398。这是回到了4398啊，这是一个基本的一个常识啊。

先知道有父子进成的概念了，再来说变量。如果当前在这边定义了一个变量，比如ABCX吧，它的变量值是100回车用eical可以加doer符取一个变量值。取出X值，这是变量的知识吧。在拜式当中，它只是脚本。

你可以写一个X，注意步动空白符，空白符非常非常敏敏感。X值付成100了，ecle X取到值是100。然后这是在当前进程，如果启动一个B是。那这时候就是另外的一个进程。这个进程474了。

那这时候能不能取到X的值，负进程里边有一个X的值100，那子进程能不能取出来，能还是不能？子行能不能取出来，取不出来，进行隔离这块数据是要被清掉的。啊，是要被清掉的，取不回来。

所以才会有了一个export。定义哎呀，我去。excode定义一个X，这个这个这个词儿是什么意思？是让X具备导出能力，环境变量投动力。只要对着一个变量制了一个t之后，你再执行并下的back。

4481这个紫禁程就可以读到X值了。因为4481来自于父亲。这个也就是为什么你们在学习linux时候安装系统的时候，让你去写EDC profile profile。

这时候后边要定义变量的时候说要定义环境变量，前面加它。因为如果你没有这个关键词，这些变量是在当前进程有用。一旦启动了紫禁城，他就不知道这些变量了。那你在紫禁城工作的时候写写脚本的时候，执行的时候。

你是不是要把变量再重新定义一遍，是不是累了，人是懒惰的，促使着科技的进步，所以他琢磨出这么一个东西来。父禁城只要定义好这些东西，任何的紫禁城孙子，孙子在孙子，他们都知道有这些变量。好吧。O。😊。

知道了负子进成这个变量，这个有知道父子进程了，知道了变量了。那么再来说一件事情，加上管道的支啊，再加上管道支，内部不AWK什么就不扩展了，那个就不扩展了。咱们再说管道的这这个结合起来。

🤧如果看我下边的一个操作啊。还有一个再说再多说一个知识点，叫做指令块啊，这字指令块。也就是你可以写一个花括号，一定要加空格。花括号其实它是一个命令，一定要加空格。要结构用的。后边比如说你可以写一个。

Ele。然后巴拉巴拉，然后注意用分号结束，这是第一个指令。第二个指令再告诉他嗯，执行一个。爱口123。再写一个分号结束，再用空格，再加一个花括框，这是一个基本常识。这个花要分开的。像刚才拷贝的时候。

那个括号跟东西不能分开，直接用逗号，那叫花框扩展花号有两两两两种这个文文本解析这个这个结果回来之后你会发现这两条指令都被执行了，这叫代码块，这个能听懂回来。邵波一就在一个花括号里边。

你可以放了很多的指令。

而且注意他们会在同一进程执行，就是这个花号里边的所有的指令是在同一个。副进程里边去执行的。我要说一件什么事情啊，注意听看我下面的一个操作。如果我在当前我先告诉你啊，当前的附近城市4398里边。

我定义了一个A变量等于一。apple dollar A等于一了。那么这时候注意看我写了一个花括号，令A等于9。明白我什么意思吧？然后并，然后输出一个内容。这个这个代码肯定两条指令先后执行。

它肯定有标准输出，它的输出我可以通过管道。给到我这边的一个。看t。😡，cat是不是有输入输出的能力，它有一定有输输输出，这一定有输入。所以管道会把前面的输出作为它的输入留给他。就流出来了。

能理有什么意思吧？啊，先看这么先看这么一个一个一个这个东西看怎回来说个一。这就是管道啊，左边执行了A等于9的负值，然后打印了一个字符串。打印字符串呢会交给管道留给ca cat。读完之后。

再ca再cate出来就被打印出来了。回车，你能看到这个输出。那么请问如果我ecle dollar A，请问它的值是一还是9？请问是一还是9？它的值是一，管道可以衔接输出和输入，这是一个大家都知道的。

但是如果稍微有点工作经验，都知道管道如果你就学到刚才那个层次，你上班容易踩坑，而且死的很惨。注意听管道的机制是。首先你写的是一个文本字符串，吧叽一回车。你的解释程序拜是这种脚本，它为什么叫解释执行。

它会解释你的一个文本段，它不是编译执行。他不是说先编译完了再执行，它是解释执行。你什么时候回事什么解释。解释的时候，他看到管道。这个拜事。如果看到管道的话，他会先在左边启动一个子禁程。

右边再启动一个子禁程，并让两个禁程的。😡，输入输出通过管道。

就是另外一个类型，就是我为什么绕了半天，前面的铺垫都为了给你讲这个东西，因为这个东西看不到，但是它存在，它会用另外一个机制一个类型，一个文件管道的方式对接起来，对接完之后，左边的进程，子进程。

再去执行A等于9的负值，挨打印它，右边的子进程再去执行caca的时候，因为刚才已经连接完管道那个那个那个那个对接过来了。所以他就都把前面留过来打印出来。但是再加上刚才小五还是谁也说了。

操作系统的进程补充。😡。

就融的隔离级别很高，你A就是这边子禁程里边对A做了一个负值等于9，是那个子禁程的。它结束完这个A等于9就带走了，再没了，负进程A还是等于一。你回到现在的附进城。负近成4398里边。

这里边肯定是一个子极称，对不对？哎，4398里边这个A还是等于一这块能听出来说倍一。😡，那是不是呢？我们是不是可以验证一下，怎么验证啊。

我是不是可以ecle dollar dollar把这边的京天套打印一下，然后交给管道，通过这边t显示一下就可以了。这能看懂。是不是这样就可以了。那这样的时候注意听，看着先看结果，先看结果加击。诶。😊。

左边不是应该启动一个紫禁城，紫禁城是一个新的ID号，然后再启动ele吗？那为什么看到的这个到了到还是4398呢？这个就是刚才说了，有两个东西可以取集成ID号。

dollar dollar也可以取dolldollar办事PID也可以也可以取，然后交给cat，这个是4496输出，两次输出明显不一样。那这儿的本质区别也是一个坑。

dollar dollar的优先级高过了管道，这种一个dollar取变量名的低于管道的级别。换句话说，bsh是个解释执行的一个程序体系。它是解而行。当你吧唧一回车的时候，b是没有先看到管道。

而是先看到两个doller，它的优先级高于它，先把当前的4398给它替换过来，叫这叫这叫参数扩展，先把两个doller扩展成4398。扩展完了之后才看到管道，然后左边起了一个进程，右边起了一个进程。

但是左边进程虽然是一个紫金ID号，但是这个值已经不是do，而是一个具体4398了，它输出的就是一个字符串，给它就输出了，就是4398。但是下边这一行一回车先看到管道后看到它看到管道的时候。

左边起了一个进程，就是44964496起来之后才看到D以把ID替换成了4496被输出。😊，这块我说明白了的同学能听能能听懂同学来说波一。哎，我讲他是为了告诉你管道有坑，他是有父子进程的关系的。我告诉你。

do了到和do家变了名，他有预言级关系，我是给你讲这个吗？不是注意听，不是我是要给你讲夸框号里边可以执行多条指令吗？不是不是要我给你讲这个东西，这些东西是你你应该都会的。我这一个想讲IO。

我是告诉你拍不烂这个类型。所以下边我要做这么一件事情。啊。我的信号累对吧？eical一个。随便一个奏串，这个奏串一定会被打印。然后注意有一个叫做sleep。这个叫睡眠。这个睡眠让他睡多久呃，不让睡眠了。

用另外一个刚才readread的是不是可以发起读取啊，复制给一个X，这有一个指令，这些指令我都让它正常执行，前面是不是一定会有一个输出，后边是不是它输出完之后，是不是后边一定会有一个阻塞。

等待用户的输入，因为这没有给他成一样，然后给个管道，管道这边的时候，然后注意看啊。这边也是一个cat，可以读取你这边输出过来的东西。然后它打印完之后，后边也有一个read，然后读到一个变量里边去。

我用了一个管道操作符，衔接了两个代码块。千万其实你一些小括号也是代码块，写花块，也是代码块，花号指当前的这个进程。这个小块指是子禁城，这个知识扩展就不扩展了。现在这个代码能看懂吧？

就是两边这两个指令执行完，然后走管道，然后这两个指令执行，他们因为是管道，两边肯定有两个紫禁城先起，两个紫禁城才能执行代码代代码块。这个能看懂学来说2波一。回车。

然后哎我错了我错了错了错错了错了错了错了错了错了。不应该随便打随便打字符。我这边应该打的是doller办事PID我要看到那个今天的例号，我要带你看他紫禁城的那个管道那个对接啊。dollar但是PID。

这边是不是如果他是紫禁城，他应该照多，他那个刚才的紫金紫金台D号是不是会输入出来，然后右边的话也是开完，然后read的之前也是打印一下的。eical dollar但是PID。

能能能理解我想表达什么意思了，这两个代表段回车之后后边这个没来得及输出啊。因为前面是阻塞了，不管怎么看到1个4512，刚才自己是4398，我们双击它再开一个标页去访这台服务器。进程ID号拿到了4512。

明白什么意思吗？4512是这个管道左边这个紫禁城是4398的紫禁城，我们先来确定这件事情。PSS。杠SB。g4398，你会发现4398是个进程，他作为父亲生出了两个孩子，一个是4512，一个是4513。

对应的也就是4512是他4513是右边这个这个能看懂回来刷波一。是不是这个跟我说的是一样，它两边会启动子禁程，子禁程都是b启动器，再就解释这段文本它去执行。这个能听懂之后，我们再来看L。😊，我先去啊P。

因为它的程序没有退出，在这阻塞着呢，去到4512的FD目录，你没看到这里面就一个一，本来程序都有012，曾经的程序的一也是来自于什么呀？DLPDSR那个对着我们这个S终端的。

但是那个一他这个这个一被修改成指定了一个pa。然后你可以再去看。PROC4513。FD啊也是一个F这个零，你看一是不是标准输出，左边的输出。4512的输出一指向了它的。

0这两个就是通过一个pa围管道对接起来了。然后这时候用LSOF杠OP4512。是不是会看到4512左边4513是右边，12里边的一是不是一个先进先出的一个管道，一个pa？4513的。

零是不是一个先进出的一个管道？一个是WE写相管道写，一个是在管道里边去读。只相的是一个ilo3996839968对接上了。听同学来刷二波，666。铺垫这么多知识。

这个东西就已经能把它。

系列 3：P182：【IO／NIO】PageCache kernel - 马士兵_马小雨 - BV1zh411H79h

书的理解。P以 catch啊，先说一个宏观的一个演示，我只是给你演示它啊具体是个啥东西，我们先见到先见到猪跑了，你再说这个猪它是黑猪还是花猪啊。K edge是液缓存，是内核 kernel。啊。

那个科呢啊它是一个折中方案。可以没有配置 catch，那也就是操作系统当中的这个进程。如果想读取数据的时候。只是调到内核的方法，内核调驱动，驱动直接导找硬件，把数据返回，然后直接给你程序。

程序拿着玩着吧。但是这时候其实你的收IO的这个延迟比较多啊。能明吧？所以在操作流程中加了一个padc，其实加了一个缓存，也就是程序。其实这个缓存就在这就开始说缓存啊，缓存有多个地方可以缓存。

我们依然要宏观去说。首先在拓普描述这张图的时候，我们用applicationapplication里边其实是可以有一个缓冲区的。Aplication里边就有可以缓冲区域，有一个buffer。

这个这个应该都知道，因为你在使用IO的时候，你们是不是都喜欢使用buffer的什么什么IO，对不对？那么，为什么巴弗莱欧比不使用巴弗莱欧快呢？这个时候描述要准确了，可能跟你们之前。感觉的不一样。

然后再来看啊，这就是你的应用程序，应用程序肯定要访问内核，内核其实也是个程序。但是你应用程序和内核之间通信的时候，这里边夹杂了一个东西叫做sstem call系统调用。这个我就不给你复习了。

这是前面操作系统刚讲完的，对不对？嗯sstem call有一个性标用steme call怎么实现的呀？系统方怎么实现的？系统调用怎么实现的？印差。80对不吧？你的80in the80是一个啥？

这个这个你你只需要知道in的80是啥，什么意思。int80是啥？是中断再说的准确一点。你看的80的值是128，一个字节就是0。这样的一个特征，因为它是十六进制的对啊，0S80十6进制。

十0进制是1228，2进制的话就是1000000这么一个特殊。嗯，那他们它其实是一个值。它是一个值。它这个值这个值干什么用的呀？是这个首先这个值是要放到CPU的寄存器里的。是要放到计算器里去的。

计算器计计算器里边存储值干什么用的，它是和你内核里边的中断限量表。中断描述符或者叫向量表。去做匹配的这个表里边会有。0号、1号、2号到128号到255号。258，因为一个字节可以表示范围就是0到255。

明白什么意思吧？嗯，1828这有一个call back。就是这个表里边它的key表里边的key是这个一个数值，它的value你们就通俗想称，就key是这个数值，是这个数值。

这个call back就是一个地址，这个地址就是一个函数。一个方法。一个方法靠白一个方法。那这时候如果在程序里边注意在程序的。里边是在用空间的程序里边。如果你想调用内核的某一个系统调用的时候。

其实是完成了一个int80。然后在其其他计算器里边一经放了那个系统调用的单参数里名字了。但是这条指令一旦被CPU读到之后，这时候就开始走什么呀？哎，读到了128ca backca back之后。

这时候开始保护现场恢复现场，然后从用户 side切到内核态或一个t的切换。因为这时候这个call back在哪儿？这个这个这个所有过程在哪儿？这个东西在内核里。就是CPU是。CPU是要读程序的去执行。

对吧通俗来说，然后也会去读那核里边的指令去执行，就是CPU。不能停着，它一直在转，一直在执行，读出它读它读出他的指令了，帮读它了，咣当开始其他读它里边指令，它里边应该读哪开始呢？

就靠ca back那个地址，告诉他从那个方法开始执行吧，里边就调度了，或者有这个这个这个要调哪个那个方法了。😡，那这里边其实是会有一个保护现场。然后切换。用户太内。这一个过程这是一个通俗的一个描述啊。

这个这个这个描述没问题吧，能接受吧。你先对列有一个有一个概念，先对列有一个概念，因为这个东西和IO有关系。这是你所有人必须要知道的。因为我怕又好多人前面没看，有但又又又又全蒙蒙了。唉。

感觉还要回看马老师的操作系统啊，前面是要看的啊，前面是要看知识这东西是有体系的，没有体系的话，你很难去做啊。嗯。然后调内核的时候，比如说你要调的什么？

调的是比如说你你程序里边想调的是read的读取某一个硬件，没没描描符，那描符代表了某一个硬件。你想读取的话，然后其实这里面在内核 kernelnal里边，它你调的是这个，比如说你调的是这个read。

假设你调的是这个readd，然后读的是某一个文件描符。FD就是读的D8，你要你要你要读它。然后其实你调它读取的时候。这是内核啊，科。我就用画图这种方式更清晰一些吧。你调的是这个读取。

然后内核其实会真的去读你的硬件。硬盘。硬盘是我们的硬件了，硬件读取的时候这个好多层次啊好多层次。注意在内核里边会分配配置cash，把读到东西。就是你你读的时候，你可能读的是想读一个字节。

但是你的内核依然是要读一个pagec，也就是4K回来。4KB回来，这是一个缓冲区，内核缓冲区。又因为其实我讲了，那会缓冲区是基本上是压榨你的内存。这种pay cash会很多。他是优先往那头里堆堆堆堆堆。

他是不会去。主动释放。你读的东西越多，他缓存的东西越多啊，然后这时候读读读的时候，但是这时候读取的这个过程啊，其实想真的你这个掉的是readd，但是那核里边的方法，这个硬盘的数据怎么读回来的？

这个过程往回去读的时候。这里边还有细湖，首先硬盘上也有。缓出去。硬盘也有缓冲机，就是缓冲机分这么大几地儿。啊，硬盘上也有一个缓冲区，那么读取的时候还分为什么呀？这个还有一个东西，这个东西叫做。鞋处理器。

这用要DMA。它是一个斜处理器。他不是不是给你擦鞋的啊。啊。开始组成原理了嘛？这这这这这哪这个很简单的一个一个过程。就是你如果没有斜处理器的话，你去想一个事情。数据啊其实整个计算机的心脏是CPU。

无论数据在哪儿，其实都是要先走指令，走数据，先走它的寄存器里边，就CPU里边是有寄存器的。这是一个常识。就是有有有一组计算器啊，如果你想读的是这个。想读一个字节，他如果想放4K的话。

这时候有可能是如果都没有这些优化的过程。那其实是CPU通过读取。硬件读一个字节过来，然后读完之后，然后放到cch里去。这想这个这个动动小指的一响，这这条线走起来，那简直缓慢的不行了。能明有什么意思吧？

😡，能不能听懂？是不是啊，就是数据如果从磁盘先走到CPU，然后再走到内存里边去，然后从内存的开始，然后再给你拷贝到你的buber里去。这数据拷贝这么多次好麻烦。所以现代化都不是现代化。

就是从我很小的时候啊，就是我那会儿碰特别古老的计算机的时候。看bos的时候都会有DMA这个词儿。斜处理器就你CPU其实不需要让他数据走这，你的深圳这数据是可以走DMA直接去走到这个经过DMA吧。

但是但是其实不是真正真正经过这个DMA，只不过是内存可以分配，可以直接访问这个这个这个区域，直接把数据拷得过去了。等于这时候其实把CPU这个过程切出来之后，然后有低时总线低时总线可以交叉使用。

您是否我是否您是否我是否这个这个这个数据数据数数这个数据总线。那这样的话，其实就他只是要技数告控制好你这个这个硬件，把这个数据光拷到那去。

CP这时候还可以忙着别的那这个整个系统的话就趋向于比这种方式什么程序都停了。CP一直在搬数据，这个过程要快很多。就应该放到这边好好好好好看一点。这所以它管它叫斜处理器。这个很通俗易懂吧，截张图。

IO等待的时候就是等待处理器把IO。准备好吗？这个IO等待这个词描述的太抽象了。地铁马上没了，几点下课，明天你可以看录播呀，咱们现在的录播应该都是高清的。啊，别别别这个。别耽我回家。

你再打个车这就不知道了。🤧好了，这个东西描述清了之后，我们再来做一个演示。这样我就做一个演示，然后呢，我把代码发给你们，回去自己演示，然后找一下感觉就可以了。好吧，我先去做一个。

今天我就在讲一会儿，呢就咱咱们咱们就可以就就可以下课了。我讲一个事儿讲一个啥事儿。嗯，我现在把我虚拟机调出来。熏机，我现在刚才注意这个这个连的不是不太记较，我现在连了一个note01。啊。

我现在有这一个note01，这个note01是。看啊。就弄弄了01这台讯机是85。111。因为我说到这儿，我指的连老师啊，像刚才前面那两个讯拟机是连的我另外一台。

就通过网络连到我另外一台机器那个那个那个虚拟机啊。这台虚拟机。我要让你知道我在做件什么事情，123456。这台虚拟机的地址就是85。111，就8。11。所以我如果在这台操作的时候。我让他写文件。

写写写写，我可以让这台虚拟机注意vivo有这么一个功能，它有一个电源，电源里边有两个关机，一个关机摁它就等于在你电脑上摁了一下电源。这个电源会产生一个中断，会告诉CPU你的老板想关机了。

开始掉内核里边关机的过程，开始把那个系统正常关机，会有这种脏的缓存。这个p这个页面回写磁盘的过程会保存所有的数据，这是正常关机。就是如果你轻摁了一下，你关机。你看它一步步走完操点的关机。

这时候曾经内存里的这种脏页会写到磁盘上去。这个能听懂学来刷波一。对吧然后下面还有一个关机，这个关机就约等于在主机上啪把那个电源线给薅掉了。能明白我啥意思吧？哎，薅掉的时候，其实这时候就趁你不注意。

电就断了。那这时候其实他来不及把内存的脏液给它刷出去啊，都不是强制关键，就直接耗电源。因为前制关键你要数数秒数5秒。😡。

所以这个事儿能听明白的话，然后看我做一件事情，做一件啥事儿。我这一个test file这么一个目录。然后里边我写了一个小脚本，这个脚本很简单啊，我先看一眼啊买SAD小脚本。这个脚本一启动的时候。

删除我当前目录里边包含out的所有的文件。然后并用JDK1。8的java C编译我OSfiIO点java这个文件，编译成这个字节码文件，并用str追踪。这个后边来讲，最主要的就是把它它跑起来。

后边用java启动OSOOS file这个IO这个文件。并给传一个参数去，就是这个脚本知道什么意思嘛？其实就是就是为了把我这个就最重要的就是把它跑起来。前面只不过加了一些这个这个这个这个这个这个。处理。

因为每次我不想每次都手工去山里乱八糟东西啊。原始文件是java这个文件，编译完就是它我不是用java自个儿跑这个编译完这个文件，我是通过这脚本。那这个java文件里边写的啥？能跟得上吧？

我们先验证一个东西啊。实验证一个东西。我写了一个很简单的一个。写法。这是一个方法叫test basic file IO。然后呢，这个文件是passpass就会在当前目录生成一个outt文件。然后呢。

外循环就是打开new output stream，打开这个文件，得到一个out out，就没有任何的包装，就是一个文件的基本的一个输出流s流out时我写了一个死循环，然后每时毫秒，然后。做一次写的操作。

out right。但是使他的话其实看不太出来，我把这房线住了嘛。先住掉了也也也没有10毫秒睡眠了，就是玩命的死循环，玩命的去向文件里追加一起一个date date date。这个date是什么？

注意看啊文这个文目录就是我当前这个目下为out点TIT写的内容就是1234989换行，就是这么一行一行往里追。听我们来说波一，很简单的一个啊。😡，然后呢，多开几个窗口，我待会去给你抓看一眼啊。

这边这边先给你演示它会有的现象，然后从那台机子来给你演示它会有什么结果。也是我再看一眼O Sfi点java。这个零如果传参的时候为零的话，就执行的是这个函数。也就是当前目录执行它给一个参数0。

参数零啪跑起来之后，它就会输出。奥点TST这个文件，我们盯着它长大长大长大，然后呢咣当再一重启就可以了。然后重启完之后，不对把它关机，关机完之后再给它重启，然后看看它起来之后，那数据它有没有存盘。

能理白什么意思吧？这个虽然很基准啊，但是也挺有意思的。走。开始疯狂的写。写出来了，然后再去把它关机虚拟机。哎呀，这个慢了这个慢了这个慢了关掉，啪它关关掉了，关掉之后再把它起起来。

刚才最少已经写了这么多了，1011120，对不对？啊，已经写了这么多了，就是。K10K百K写了一兆多了。这已经写了一道多了，对不吧。刚才加了一会儿，其实不止是这一道多。能看懂我想表达什么意思吧？同学们。

😡，然后这个可能都得重新连接。

看到大小了吗？都是零，对不对？

是不是大小都是0啊，那这个就跟我这个图画这概念一样。这个图当中其实程序我刚才还没有使用buffer，都不是buffer的，程序里边拿了一个数据就开始调s，开始写一个切换。

然后写之后其实是放在了pay cash缓存页里边，这个时候其实并没有去刷写的。是并没有去刷写的，而且我代码当中也没有flash刷写的一个操作，对不对？能没我先表达什么意思吧？

然后这是一个啊这是一个。然后。嗯。

下节课再讲吧，你你就先知道这么这么一个事儿了，因为再讲的话，下面要下面的其实成体系的啊。

下面的这这个再讲，我得把这整个这个文件给你全部跑一遍。

到所有的测试，这个时间太长了。你就先知道没有刷写这个事儿就可以了。这张图先有一个概念。好呗。😊，嗯。有个问题，一个县城遇到毒请求，会IO阻塞。CPU线程切换。就去干别的事儿。

了这个阻塞线程LO准备的过程是斜处理器干的。下次县城切回来就能继续执行了，我理解对吗？对堆，非常对，他说这啥意思啊？这个你看抽象的描述就是这1个APP。A1。然后进程是有状态的，马老师应该讲过了吧。

这个没有不懂的去往上翻，进程是有状态。俩程序，然后呢有1个CPU。然后呢，这是你的内核。🤧。然后呢，这是你的硬盘。如果这个程序现在是running状态。然后他如果帮当调了系统调要用了。

说我要读的是他的东西。那这时候其实就会有一个就首先他你要调它内核调用了。这时候其实这里边已经调了int80了，他已经知道就是他已经知道in80这事儿了。要触发性这个呃切换到内核这一个过程。

这走这么一个流程，要切从哪妈切过来，切过来之后，这个钛也转过来了。然后它其实已经是被保护线差不了。保现场什么意思？就是曾经你这个CPU的缓存，123级缓存里边数据都给你搁到你的内存站里面去储存回去了。

存去之后，然后CPU的这个态也从这个用态接到内核态，然后呢开始执行它里边的相应系统调用进统调用的时候会你要读的数据，注意看他先那核先分一件事情，先找有没有有的时候发触发缺液，触发缺液那个页还没有。

那这时候给人反馈不了。这时候可以走我们的DMA协处理器。斜处理器去完成了数据的获取的过。然后最主要的是这里面有一个概念，就是你的进程就会进入一个t，这个态就是挂起状态。就是从一种阻塞的状态就被挂起。

你你就不在内核的系统调这个技能调度。进程调度，它里边允许调度的是那些个活跃的，活着的是活跃的。那你这个进程就不属于活跃进程，就是未来调度也不会调度你了。那未来调度肯定要是调度人家其他的进程。

在所有的时间片产生的时候，就别人在轮循在执行，你就一直不执行。他把数据考完之后，他会有一个所谓的中断。中断给了之后，这个中断就知道哦这个。曾经你在你给你给你挂起的时候。

注册过关关注过这个中断那个那个数据想要那个数据，中断过来之后，才会把你的状态可运行。切换一下，切换之后，未来在一某个视间片才才能把你调度回来。这时候你再一执行的时候，恢复现场也已经有了数据拷贝方案执行。

你就可以继续执行了。听懂什么意思了吧。😡，好吧，OK那就是一个一个一个一个一个一个逻逻辑过程。行吧，今就讲这么多吧。中断是什么意思嗯。😀ふふふ。😊，回去看前面的课吧，大哥就前两节不不不不是很多。

马老师讲的这个操作系统原理的课。就是很简单的一个道理。如果现在你在吃饭呢。你在吃饭呢，你凭什么要去？就是你不会思考啊，我让你干嘛你就干嘛。我说你吃饭，你就一直在吃饭。😡。

然后这时候你怎么知道要不要去干别的事儿呢？如果说我爸打了你一下，你看了我一眼，我说去这个喝水去，你就去喝水吧。那我爸打了你一下，让你干别的事儿，我打了你一下，这就是中断。😡，但是谁都可以打你。

我可以打你我是键盘，我可以打你。😡，软件也可以打你DMA可以打你网卡可以打你，谁都可以打你，但谁不同人打了你，让你干不同的事儿。😡，能力有什么意思吧？那就是不同的中断。😊，这个每个人打你的时候。

那你这个你怎么知道他他是谁呢？他让你干干什么事呢？这个该干的事儿在哪呢？我并没有说，我只打了你，然后量一下一个数字，这个数字终端号。😡，你怎么知道？其实有个小本本，就中断下量表。😡，你一翻表哦。

这个80啊128啊。好，那你要你要切换程序了，不是你要发生竞标用了。如果其他的就其他其他的事，好吧，啊，通俗来说就这么一个就是CPU如果没有中断的话，CPU会汉死在一个进程啥事干不了了。

他就一直跑这个程序，他不可能切就切切换程序，或者或者发生任何的事情。键盘你摁了它CPU不理你键盘那个输入，整个计算机CPU就在忙这一个事儿，你键盘。😡。

系列 3：P183：【IO／NIO】pagecache - 马士兵_马小雨 - BV1zh411H79h

IO我是一直会顶到网络IO。然后呢，我把多路服用器的Epo这块，我会给你讲的很细。好吧，好，收了啊，开始开始讲了。那么这是给你铺垫一个前前置你就要去看的一个东西啊啊，有兴趣可以看。另外一个问题就是。呃。

物理内存把p这个概念再再强调一点，我们有物理内存。其实前面马老师也稍微讲过了，在这我就重复再啰嗦一下，找找那种感觉。物理内存是一个线性地址，就是0。37小时，这是地址。然后呢，我们里边会有内核。

然后有程序啊，这是这是一个内核。然后还有我们其他的这个他们的摆放原理啊，然后上边我也讲过了。就关于他的这个用泰那个太用空间内核空间呢，然后GPT呀，然后这个终态线量表等等。这个这些知识我都讲过了。

物理上看的话，这个内存里边会有 kernelnal有不同的程序。其实这程序啊，然后应该也是在这个物理内存当中碎片的。比如说APP1，然后呢它的一部分。一部分数据是在这儿在物里存的这个位置。

然后APP1的另外一部分数据有可能会在这个位置。因为在分配内存的时候，你的程序不是一口气儿把这这一辈子知道的这个数据，这个内存代小都都是下都分配完了，是随用随分配的。くな？对不对？

可就是有可能会出现碎片的这一个概念啊，就是一个程序，其实它真在物理上是不连续的。然后但是每一个程序在运行的时候，它其实是会有一个概念叫做虚拟地址。这现行地址。一个程序其实看自己的话，这个我也讲过了。

他就看自己就认为自己直接占用这个物理空间。好吧，哎，它有一个线性地址空间0。37910，在这里面就牵扯到一个东西，它线性地址到你物理地址。比如说这个程序APP它的数这个这个数据本来是这个连续放的。

在他程序里的物理地址，可能APP1的X段和Y段，它们连续的，但是他们却指向了物理地址的分配的不同的位置，就这么一个映射关系，这就是线性地址和物理地址的一个映射。

这个映射的过程是需要你CPU里边有1个MVU单元，就CPU里边。有1个MMU就是内存管理单元啊，然后呢，且我们的程序里边是有一个。这个。就是提供给MU这个单元去换算这个数据在哪？那个数据换在哪？

一个映射的一个对应关系啊，那个那个表这个东西它整个这套系统，这个映射关系有硬件的MMU啊，也及是转换。那么它依赖的是哪个单位，这个单位叫做配置。就是E。一页的话，在性能中默认4KB啊，4KB。

其实说白了就是在管理个物理内存的线地址的时候啊，你的内核是会把它分成很多很多4K4K4K4K4K的。啊，全都是一堆4K的小格子，小格子小小格子，你程序用谁了？那这个找一个空的4K，然后给它映射上。

然后你的数据其实就放在这个格子里了。然后下次你的程序再想申请空间的时候，那这时候可能申请到这块这个4K或者连续几个4K。好吧，这是1个4K的这个页，然后成进程里边其实映射，然后通过CPU的MMU去转换。

然后这个过程当中一定要记住了，操作系统它是一个。是一个灵活的一个系统，就我们GVM也是一个灵活的。然后这里面有一个概念就是随用随申请。可以预分配，但是不会全量分配。尽量的不会做全量分贝。

而且一个程序它启动的时候，也不知道未来自己可能会用多少内存。所以在在这个位这个环节上才会有一个问题，就是当一个程序可能开始就申请了这个一个G的数据这个空间。但是后来又又想写东西，所以会有缺液。

就程序如果再想申请一个空间，就再想再就程序跑跑的时候，我想访问这段地址了，就前面这0。37小1想访问11了，11这时候其实还没有页去映射呢，这时候就产生一个缺液。

缺液的话会在你的CPU在执行你这段程序里边代码的时候，会做一个缺液异常，也是一个类似一个软路断，然后跑到我们的内核里边，然后开始建立页的映射关系，然后再漂移回来，让CPU再继续执行的指令。

就是在你只只要执行那个访问那个地址的时候，没有会一个缺液啊，这时候就过来了。先把业补上，你才能继续执行啊。那么讲它有什么意义？其实这个知识马老师前面已经讲过了，在这儿有一个概念要强调一下。

既然如果这个能接受，就是现在这么一个通俗讲法，就计算机里边用业的分配方式来让我们的程序动态他慢慢慢慢慢的去使用这个一口一口的使用这个内存。这个能理解的同学来说波是一是一个基础的知识。其实前面已经讲过了。

什么导致缺陷？你程序里边分配了，比如说程序里边有一张表啊，一个table。他已经比如把我线性地址，程序线性地址，比如1到10，假设啊1到10，然后指向了你物理内存的。然后这个30。就把把把把一吧。

1到10这个指向30到408。我用我用我用这个，因为你要我要按照官方给你讲的话，这个太费时间了，我就给你抽象讲程序里边刚记了一个1到10只行了30到40。但是你程序代码却想访问。80这个地址的时候。

但是这个程序进程中间是虚拟线性地址，它是从零一直到满这个44G可能都有。但是80的时候，其实在这张表里边还没有1个80，就是线性地址，80映射到哪个物理了。那访问80，这时候产生一个异常。

这个异常这个这个这个异常叫做。缺页。一た。这个缺异常异常其实就会产生软中断，然后这时候就会跑内核，就是由用这个CPU就不执行。因为你代码执行不下去了嘛，然后这时候就开始那用太切内核太切到内核上。

内核先去分配啊，给据这个程序去分配。说咱们再拿出一个空间来，比如这个这个就是80那个位置开始没有。那我先给你在物理内存当中找到一个位置，申请一个页啊，分分配出一个页来。

然后在你这个表里边映射了你的80其实指向了物理这个位置。那表里就有这个这个80指向了。80比如指向了线性地址的222这个地址就是线性地址指向了物理地址22。那这时候从内核菜再回到你的用户态。

你的这个否则80这个事儿就可以继续往下执行了。好吧，OK那这不不做太多的那个扩展了，有点浪费时间了。你先知道这么一回事儿啊，就是我程序跑的时候，肯定是一口一口的把这个内存就分配到这个物理上了。

而且这个配置要再强化一点啊，这个配置强化点。也就是说全局其实整个整个内核起来之后。是你程序的啊任何的位置。啊，任何的位置其实都是但只要使用内存的时候，基本上都是按照这个配置去做的。比如说什么东西。

一个程序，这还有一个基本概念，就是在我们一个程序跑起来的时候。只有这个。在一个程序，只要它运行起来了，程序它的内存其实分分成了就是一个程序的内存空间，它有一部分一些东西组成。

就像GBM它的内存有哪几部几部分组成，由我们的代码段KIT。有我们的数据段。就初始化的静态数据。然后呢，还有我们的站和堆。对不予。这是C的C的程序操作系统进程啊，这不是我们GVM的，然后呢，还有站。

你用来。好吧，那整个一个程序这边一个进程，它在内存里跑起来的时候，其实它的经历的步骤是先从我们的硬盘。硬盘里边有一个程序，比如说这个程序是APP，然后W你的程序是在硬盘上有一个文件啊，这个文件是APP。

W。没。这个文件是我们程序的所有可执行啊，就是这个这个一个数据结构20制的，它里边包含了我们这个这个这个这个尤其包含我们这个代码段啊，这个咱扣扣去。你的CPU里边计存器，其实你CPU里边有一些寄存器。

这个寄存器就指向了这几段的机地址，手地址会埋到这个寄存器里边。在执行这个程序的时候，只需要访问某一个断领的，给出偏移，就能找找到那个指令了啊。

PC计数器其实就是说我在这个code的代码段已经执行到哪哪哪哪行哪行指令了。那么这个文件被就是一个程一个程序变成内存进程的时候，其实也会触发配置啊，也会触发配置。也就是这个文件是读4K，先放进来。

假设这个文件假设这个文件是10个4K。假设啊是10个4KB，那可能加载的时候刚把4K先放进来。但是这个空间多大，这个空间是10个4K。就是未来它大小是10个4K。

但是在我内存里边可能是刚放进来1个4K进来。然后随着使用啊随着使用我去访问到你这个第一个4给后边数据的时候，这个文件的字给再往上放。も系。这个能听懂同学来说波一能听懂吗？就是一切都是按照这个配置走的啊。

程序加载就是一个进程加载的时候，其实这里边的所有数据本来都是按4倍去分配，4倍分配是一个最基础的。我用一个简单的意思给你解释一下。

。比如说我们现在这个程序。当前那个程序是1287这个竞争I例号啊，这是一个程序。我们那个程序是啥？PST。这个税。哎，这种还有紫的lash，没有没有没有没有结束的，等我我把别的这先结束一下。

Q杠91630。把对。平安市公安费。因。先不管了吧。这应该是我在另外一台远程登到这这台服务器了。就是我你看我执行PS的时候，这是一个程序，它的附进程是一个b。这个b就当天我这个拜ashb它是一个进程。

它已经跑起了叫1287。那这个进程它的可执行程序文件是什么？就是我们的并下的这个文件，好吧，然后跟跟跟着我的思路走啊。

大家这种思路走我给给过你们上传这个这个程序就age里边这个PC state给你们编译完这个用它PC这个PC就是配置cachstate用这个命令接并下的ash。一定要记住啊。

就咱们操作系统里边磁盘上变下有一个拜事，这是磁盘里边的一个文件。然后这个命令是在做一件什么事情，他在询问我们操作系统内核。这个文件有没有就是它里边这个文件会有很多很多4K的这个数据块。

在那这个内核里边有没有填充那些个页，就是没有被加载啊，有没有被加载。所以这时候你会看到beb是。这个程序的大小字节数是903336，它的页数消耗了221个页。

但是因为对这个程序在我们现在的这个我这个我这个操作型里边，对它可能使用的不是特别多。

其实常用的可能他就已经cach到了194个页。不是百分之百，这个能能看懂这个输出结果。同学来说波一，就是我给你演示的就跟我刚才讲的一样，我的一个程序大小可能10个4K。

但是我并不是说一口气把它全部加载进进来了，我用的就放进来了，能解吧？哎，然后有一些不不常用的，一会还会说比如说我可能随着我的用给它用的很多。但是可能随着我这个其他的程序的使用，可能会会有一个淘汰的过程。

淘汰出去啊，就是你们说的LLRU。

这是一个概念啊，这这是明前的一个进程。然后在这儿再多加一个。我上次上节课讲的一个概念。其实配置就是操作系统内核里边会维持维护着一个配置。也就是配置其实它属于什么配这个配置。

它属于我们真正纯数据的这个硬件设备。和我真正这个运营的进程。他们之间的一个抽象层一个抽象层。数据真正在哪？数据真正的是在磁盘上，但是我们内核里边也有这个数据。

这个数据其实可以未来给给到我们这个进程去去使用，去访问，按配置去分配。这是第一个支点。第二个支点就是哎如果再启动一个程序。其实你刚才也看到了咱们这个我现在这个操作系统里边，其实启中了两个blash。

其中两个bush。那么其实这两个代码段里边是共享了你内核里边这个配置的，就这个尤其这个代码这个这个环节。其实这个也是算是一个一个一个一个什么概念？就是在操作系统当中算是一种优化啊，内存优化。因为什么？

因为如果我跑一个b程序，我可以把这个磁盘这个文件读这个这个程序读到内存里边，就给我这个这个程序去执行了。我在我在执行相同程序的时候，如果操作系统中没有这个抽象层，没有这个配置。

这个这个缓这个缓缓缓存这个层次的话，那我这个文件要重复加载进内存跑跑100个这个bash程序的话，那我这个文件等于在内存里边要消耗100100倍的这个内存空间。但是如果住在我内核里边维护了啊。

维护了这么一个配agecach是在内核里边。那这时候其实每个程序，它的映射，它只需要相同的这个只要这两个程序，这两个这个这两个进程，它是来自于同一个程序，它们仿同一个同一个配配 catch。能列吧？

这是代码这个区域，然后剩下的这个数据区和未来我们牵扯到IO的时候，因为你其实进程变成程序这过程已经牵扯到IO了。那未来如果我一个程序再想打开其他的文件，比如这两个进这两个程这两个进程。

WappW和appX这两个进程如果都想要访问磁盘里边的另外一个文件，这个文件，比如说PID。想反这个文件，这个文件最终其实也是要先放到那内核，这个被内核先做一个page catch一个缓缓存。

存进来之后，然后这两个程序虽然都是要去访问这个page cache。这其实是上节课讲的，但是这在现在整体给你复习一下，就是无论你的代码段少，然后还是你的这个数据，你要访问这个文件IO啊。

然后想访问他们的时候，他们其实都是使用到同一个共享的一个区域。然后再加上其实他们各自会有各自的。sick拼音量就是文件描符这个这个上节课讲的文件描符这个章节，这个图就画通了。

然后这个只是在上节课我讲的一个概念上，因为上节课只讲了你在IO上面打开文件的时候。这两个其实复用了它啊，复用了这个这个物理文件到内核这个配置p catch缓存。复用它。

其实他们里边各自维护了一个基于这个文件文件标符的一个4个音量，就是他们可以各自访问这个数据的不同的偏音量这个位置。不是，只有1个FD不是只有FD这个配置是一啊，这个配置是一个。

这个在这一文件在物理上是一个。然后内核你上面有多个程序访问这个文件的时候，这个文件里边的每一笔数据它会占填充不同的一个page catch，就是它可能由4个页组成的。在这里边开第四个页。

这四个页是唯一的。但是你可以有很多的程程序进程去想都想去打开这个文件。那么这时候他们的FD。他们FD啊这边的FD进程里边的那个对对文件的FD的一个抽象啊，这个FD是独立的，这有点像我们编台器模式。

因为每个FD里边会有一个指针seick。这个sick会维护着他们每个程序对同一个文件访问的不不同的位置。把我上节课最后讲的段，其实你看完的话啊，这个应该能知道，好吧，这块都能接受，同学来刷波一。

就这个概念应经ge到啊。Yeahello。在这里边你其实要总结一件事情，就是哎这样的话是比较省内存的。然后你在其实这个如果在扩展的话，f进程的时候也也可以理解。

比如如果这个进程想创建一个子禁程还是还是他那fog的时候，其实这个程序只要在内存里边再开辟一个新息地址空间，把PCB啊进程的这个这个这个相应的这个属性创建出来。

其实这里边全是指针指向了底层的那个相跟他之前那个进程相同的数据。就是在系统里边有很多都是东西指向了同一个位置。能理解吧？嗯，那这里面其实如果聊到这儿，还有什么考这个喜事复制，那个就待会再说了。

把这个概念串起来是有一个什么目的啊？总结现在我给你总结一句话，因为我后边讲后边的知识，就这个我给你带一把，给你带一把啊，然后只需要总结出一句话来，也就是配置。Catch。是内核的内核。

维护的啊一个算是一个中间层。从那个中间层，那pagec它可以满足我们程序啊代码段啊，然后IO的文件的访问数据的一个缓存等等一系列的这个一个一个一个中间的一个一个缓存区。那pagec它使用多大内存。

使用多大内存。因为你现在从图上可以get到哦，就是我这两个程序啊，都可以访这文件，或者一个程序可以访问这个文件，都是通过这个pay catch了。那么这个pay catch使用多大内存去缓存呢？

就是我文件如果我内存如果10个G，我这文件如果8个G，我是把8个G的数据都放到这个内存里面全填满呢？还是说它里边我用多少就放多少，不用的西，我立刻淘汰掉淘汰掉呢？其实这个时候要牵扯到使用的环节。

就是使用多大内存啊，然后这个消这个这个这个这个就是淘汰是否淘汰。对吧如果你对这个修改的时候，程序如果修改了数据的时候，那是修改配置cash。那配置c修改是立刻写到我们的这个文件当中，立刻持久化呢。

还是说它有一个延时，还是说它会丢数据啊，也就是说是否延时。啊，是否丢数据？为什么？因为只要你知道这个东西，它不是一一口气顶到这儿，中间只要就是计算机软件工程学，只要中间加了一层，这一层有好处。

可以让你数据访更清亮，内存开销更大更更少。但是它反而会带来副作用。这个副作用就是从这个点到端点之间加了这个层次，它的一致性等等的可可靠性就是会出现问题。能理解同学来说波一啊，这个都是铺垫啊，这个别走啊。

ZDC不不千千万别说这个这个这个没有意义啊，因为我后边是有事，别慌，我后边是要上代码的啊，因为OS这里边我会给你演示，就是就咱们之前写的代码，它为什么会有这一个变化。

🤧好了，为了为了把这些事情，现在这个模型制作制好，基于这个模型我们去抛我们代码，然后来推导一个这个所有的这个问题的过程。然后。没错，一切VIO因为IO就是pay cash这上边才是。

你要学的这个IO这个知识点。我为了把它讲明白了它的依赖是什么。IO的依赖一大类依赖是依赖我们的page cache。虽然我们进程可以就C里边可以开启directIO，就跳过那核的pay cache。

但是java没有，只有C有java里边是没有directrIO的。啊，java基本上连mM map也使用的是pad cash啊，好吧，先说，我们直接来看看这个这个这个案例。

Yeahello。讲这个案例的时候呢。我先介绍一个东西，CsCTL。杠A。这个是3层S里边，你回车的话，它会显示我们内核当中的很多的控制项啊，会显示很多的控制项，连网络的等等的。

在我们虚拟文件系统操作系统。🤧我3316，然后把它加一个管道，通过grape，然后去查什么，查dirty。下意思。把这几个配置项。我们先把它摘出来。

然后我先把这个值给你放大，放大之后我们回头再说。怎么回事？我先给你粘出来啊。这几个配置项里边注意这你看这俩长得一样，只不过是一个阈值和一个by by这个字节数，这个两个长得一样。

只不过是一个阈值和一个字节数。下边是两个关于时间上的啊一个定义。啊，也就是我们脏页是5秒还是50秒还是怎么着的。这个配置项我要给它做一个修改这个修改怎么去修改啊，我我先我先去做做完。

我刚直接告诉你是VIATC写的ss cTL点com。

好到最后这个我之前加过这些东西了，我先把它全删掉。

我们只用什么？只用先把这个阈纸background，就是后台的脏液的，从内核向磁盘去同步写，把它拿出来。

然后阈值多少，我定一个90%，9%，90%什么意思？内核如果里边就是内核这个内核计算这个内存，内存假设啊是10个G。那假设可用是10个G啊，刨出那个别人被分配走的，剩下还有10个G可用。

那你这个在读取文件的时候，在使用IO的时候，那一个所谓的缓存的页。如果把10个G占了90%的时候，就9个G的时候才会由内核完成，从内存到磁盘的去写的过程，同步的过程。这个能听懂的来稍个一。

我先给它发到90%。那我我的内存多大，待我告诉我内存3个G粗的说就是其实我们的程序像磁盘写两个多G之后才会真正写到磁盘，那这个可能就丢很多，跟swipe没有关系啊，所以说是另外你要这个描描述不精准的。

然后另外一个值也有一个阈值，这就不是不是background就是前台的了。前台是什么意思？我把它值跟它做的一样，你先不要管它合理性，我只不过是把一个东西放大，看到它的一个特征，其实真正用的时候。

你是要跟你的业务场景和你的这个省的不同程序，你来调调它的一个特征的。

这是后台的，也就是内核其实也有现成啊，它会后台去触发啊，达90%就开始一写了。还有一个就是有一钱在阻塞。如果说你这个程序在往内核写的时候，分配页，分配页分配页，分配页已经分配到内存的90%了。

其实这个值啊，这个值应该是小于这个这个值的小于这个值的这个值应该稍高一点，这个应该稍低一点。假设就是你程序完疯狂的向内核写写写这个写数据，在疯狂的分配这个配置ca，因为会缺液嘛。

你你访问一写数据就开始分配。那一达到了可用内存的90%，这时候就阻塞你程序了。上面这个是不会阻塞你的程序，你程序还继续向内存写着写写那剩下的10%，然后会起一个线程。

然后这个这个这后台一个线程会把这90%向磁盘去写。其实这个值应该是你要去调U的。果你程序写的它的。这时候内存不会爆满不会出错。但但但是这个这这是后这种方式这是前台在什意思？

就是你程序使用内核要去写数据开始分配个只达到这个值了，那你程序别动了别写了内存我得保证内核个这个空间的利用率紧先把这里边增页的数据写到这个磁盘如果再写再分配的话。

触发LU这两个都把老那个没怎么用给淘汰出去就保证你新的数据一直能写到我这个内存这两个阈值的设定个出来是值的一个出发点就触发我们就是其实白了程序是先写内存后磁盘，只不过写的问题这两个。😊。

识点关联到哪些知识点。比如说你学read的时候，readies里边做持久化，尤其那个AUF日志文件。你学myscle调优的时候，这个binlock和and那个relog andlog这个这个日志。

他们有三个级别，他们都是有三个级别可以调这三个级别里边有两个级别，一个级别是你每秒钟就给我写一次。能明白吧？要不就是随内核啊，还有一个就是每操作都要写一次，他为什么会定义出这三种啊，为什么会定义这三种？

就是因为啊就是因为我们内核你你写给内核的东西，它不会立刻给你保存，而有有可能丢很多啊，有可能丢很多。这是一个出发点。再来看还有两个。

呵。

这两个是他后台的这个任务线程的一个时间的一个维度。上面这个我的这个本来是这个是要这个除以除除以这个这个除100啊啊除以100。因为它可以控制到毫秒级呃，不是这个11秒啊，11秒。如果你写一个一的话。

就是11秒就要做一次这个写写写back，就是把这个脏页写回这个事儿啊，然后下边这个是脏业的这个生命周期的可以存多久，我把这个值都先放大，我把时间这个事儿给它放大，这就这个等于就是50秒。啊。

这就等于300秒的一个延时，就是时间上肯定不会自主的去触发。向这个磁盘丢这个这个这个保存数据这个过程。我现在只考虑到内存消耗。也为我一会儿如果光灯关机了，真正能丢多能丢多少数据。

这四个配置项能看出来刷边一。真的我的我这个件绍能听懂。哎，你看折字器说丢一秒丢一条和丢一个缓冲区，关键是丢一个缓冲区，你的面试官会问你这个一个缓冲区是丢多大呢？是4K呢，还是4兆呢，还是4G呢，对吧？

哎，其实这个看你的你可以定义字节或者是定义阈值。

没错，一个页被创被刚分刚分配出来，就是你程序刚要申请一个页。那这时候这个页申请完了之后把数据完了一放，这个数据就是脏的，就申请过来就是脏的。因为这个页未未来肯定要还得把把它写出去嘛。

写过的就不是脏页了啊，然后不是脏的页，可以直接被LRU或LFU直接淘汰掉。但是如果是一个脏的页，不能直接在内存给它抹杀掉，是要先给它写到磁盘中去，才能给它淘汰掉。

这是一个基本的一个符合人人类思维的一个逻辑，对吧？😊。

然后在这个里面是OS fileO这个文件就是我给你们同步的OS fileIO这个这里面有几个就是在主方法跑的时候会接入几个参数。012我们常用的自测的这三个就可以了。

3不要写我到时候给你演示这个ffer用的012这3个我给你示演示的就是无ffer的有buffer的和random直接的直接里边还分为这个MM直接的这个内存映射和对外内存的几种几种对IO的这种使用方式。

然后最基本的fill写啊最基本fill写就是直接打开文件啊，这个pass就是我我这个文件啊，我这个文件直接放在了我的root，你回去之后到你那要改成你的那个路径。然后打开文件之后。

然后得到了一个输出流out，然后死循环。我那个代码当中我会把它给注释掉，不让得这个睡眠了。因为睡眠会产生很多的其他的所的那个系统都要用那个接口。然后我我我直接把它B掉，然后让他尽量快点。

然后直接把这个ddta向这个文件去写，写的这data是什么？这个data就是123789加一个换行符，等于10个10个字10个字节向外去写，就是这个最基本的这个第一个测试的内容的。

就是开启了一个普通普通的输出流，疯狂的向外去写这个逻辑能看能跟大同学来说边一，就这么一个事啊，就这么一个事儿。

然后注意听啊注意听我一会儿跑起来之后啊，我会用str追踪。然后呢会首先这里面是str这个str追踪到的这个性调用的文件out点什么什么。然后它输出的这个文件啊。

输出这个文件直接叫out点IT就是数据文件，这是数据文件这个数据文件注意看啊，你比如说这是我曾经啊曾经跑了一个跑了一个这一个out点IT你要记住了。

我给了你这个命令叫做PC page catchstate来查询这个文件的被p catch缓存的这个状态回车，你会发现这个文件是我曾经跑的，已经被淘汰开的时候，它肯定填了好多填了好多开到好好多。

哦，对，这个这个现在它只有一个只有一个啊，只有一个已经被被配这个配置被被ca开住了。所以现在是被开也是100。当然一会我写的时候会写的很大啊，我们来就是通过PCstate来看一个文件从0到1的过程。

它的缓存率，然后以及它如果超过了内存之后，它是不是会淘汰掉一些配置。就是通过他可以可以看到一些东西。然后也可以通过LOS这个LL杠H人类可读的一个单位机制。我看这个文件长多大了。

因为那个我一会儿我执行这脚本的时候，我这个程序会一直死循环所以综合考虑，我就用LL杠H，然后同时再给我执行1个PC state，然后是out点TIT这样的话，我既可以看到这个文件长多大了。

又知道它被分被从内核就是它它一共有多少多少个页啊，在内核里边缓存了多少个页啊，百分比是多少，这这个这个输出的个这个样式能get到同学来说波一。

现个你。

好吧，那我再开一个标签页啊，再开一个标签页。ches their file这里面，然后我的这个脚本my shell这个脚本里边默认写了s追踪后边我这个java1。

8那个java程序的所有的线程以及输出成outt点什么什么那个文文件跑的就是我OSel这个IO这个这个文件接收一个参数012听的一个，我们先测0。呵。然后给一个参数零，给了参数零之后啊。

刚才忘了看了这个文件，他会先把之前的历史这些数据删掉。就是每次跑这个脚本的时候，他都先把里边那个所有out包含out连数据文件在那个追踪文件都删掉，很干净。所以每次你只要看新鲜的就可以了。

跑它给一个参数零，参数零加G给之后，那么好，我这个java这个程序就跑起来了。然后这些东西全变成一套新的。然后这时候你来执行这个这个指令，你会发现哎我这个文件outt已经3。2兆了，先看啊再执行6兆了。

7兆7兆8兆。9账。11。12。长得快嘛？先告诉我长得快嘛？这种这种我刚才写的这个是一个死循环啊。是不是长得不快啊，一会儿我给你解释它为什么不快。一会儿我换buffer的时候，而且这里面没记住了。

我的所有代码都没有掉flash，没有掉这个刷写的个过程，它一直写。而且我在那我那这个lin里边，其实我把那个sli睡眠的事一个注掉了，一个住掉了。😡。

兄弟吧？然后你可以看到它的分布离配置一直在 catch，一直在ca。而且一直是百分之百啊一直是百分之百。找到我讲那个感觉找到我讲那个感觉。看到吧？是不是一直往上涨，为什么？

因为它不是说cach只是你用谁给你ca，谁，剩下直接淘汰了，因为它会根据你内存，我内存是3个多G。您现在刚使用35兆，我可用的内存空间很多，那我cach就玩命的去给你分配这个这个剩余的。

就一直保证你的程序，你现在访问的数据一直都在内存里常驻，除非未来会有一个竞争机制给它淘汰掉。好吧，这是第一个知识点。看懂同学shop边一就是在一个程序访问一个文件的时候，只要内存够。

这个cat就一直给你给你给给你在内存里缓存。也就是未来如果你偏移到想读这个文件投的时候，不需要产生任何磁带哦咣当这个数据就就就就可以读到了。刚才那个C4CTL，我刚才改完了啊，改完了之后。

我忘了1个杠P执行它，我得把它执行一下。啊，这个阈值9090%90%，我先执行一下，然后再把它重新跑一下。可能是。先第一步先在你找到了感觉，就是一个程序使用文件的时候，即便它临时创建很多。

他也是给你缓存这个这这这一页了。另外一个这个因为把刚才这个加载这个应用啊，这个刚P之后给它应应用起来了。然后下一步我们来看它能丢多少数据，丢多少数据。还是抛这个零啊。重新来啊重新来两兆三兆。好。

9兆多了，将近99兆多了。然后这时候打开你的虚拟机，虚拟机里边有一个电源，然后点关机有俩关机。这个关机是它自主关机，它会保存你内存没有flash。我所有的这个操作，我给你演示。

今天演示东西都不带用户端强强制flash，就靠内核什么时候给你写啊。然后我直接点关机，咣当就等于啪嗒就断电了，就是来不及保存，内核都来不及保存。好吧，刚才已经写了好几兆了，那这时候再把它开机。插没错。

这刚刚总经拔电源了啊，再给他再给他插过来电源，再给他开机。😊，我。嗯。呃，这些知识点用用这么讲吗？用这么细的讲吗？因为我感觉咱们以因为以前咱们比如这个。这个介绍的时候，好多学生说老师不是季组的。

不是没不是本专业的，好多知识这个不太不太不太不太熟，所以我就讲的有点。有点碎啊。没错，我其实就是想给这个咱们不是本专业的这种小白去讲。其实咱们这有有很多这个。比较优秀的学生。对。

其实他们是应该是不用听这些东西的啊，然后再把那个链接打开弄01。再复制一个。O。test file来今天看刚才是不是写了好几道了？是不是都丢了？是不是都丢了？因为我内核允许你跟我，你调我。

你调我的给你暴露的系统端用写，你就写吧，你写的其实写在我内存里去了，给你缓存了。但是我因为内核参数赔的太高了，我没有来得及给你保存。对吧这是一个，然后呢先不着急啊先不着急。

再来看再来看在我的这个java从从这看这看清楚点。在我架当中啊，我一会儿给你分析他们的性能差啊，这有一个basic的 fileO还有一个是ffer的 bufferffer的话。

其实还是同样这个要往这个pass这个out文件去输出，就是out点TID但是这时候我给它套了一个buffer的out stream，然后得了一个out，然后呢我也是一个外循环。

我也会把这个10这个10秒说眠那给注掉，因为减少镜调用这个用上那个切换。然后就疯狂的开始写。那先第一个基本常识，你出去面试的时候，这是java肯定会会问的。

就是八分的IO和普通的IO属于快。就第一个问题属于快。哎，大家都知道8分的。那么8分的为什么快？😡，八分的为什么快？且八分的。是。就先告诉我为什么快，大不知道为什么快。😡。

就就是就是人家就怕问你这个问题，少IO什么叫什么叫少IO次数？不认。嗯，这个说到聊到系统调用才对啊，聊到系统调用才对。8分IO待会我会给你演示，你就看其实8分IO是在JVM里边，它默认多大。

是不是8KB。就在GM进程，在我程序里边，你这虽然每次可能只写一个10个字节，这个data是不是10个字节，每次你掉了我这个巴来写10个字节，写10个字节，但是这十个字节没有交给内核，是在GVM里边啊。

就是在GVGVM里边，它开了1个8KB的一个数组字节数组，把这个数据先放到这个GVM里边8KB满了之后，调一次内核的，就st callll。的一个right把这个数组写出去，这个8KB的一个数组。

也就是说这个8K之后才调一次系统调用，但是上面的时候是什么呀？是不是每每次read的时候，这个直接顶到底，就是你只写十个字节就调了一次系统调用。所以他们俩切换的次数，就是那个在应户在切换的次数。

这个数量不一样，做以一个快慢的一个问题。好吧，到时候但但去追踪啊，我们回来看。

因为一会儿看到那个现象，你就不知道怎么回事了。但是我先来去演演示最开始这个现象，就是通过我的买。我先把这个命令搞出来。然后再加上PCstate，同样还是看这个TSE点po out。

现在只不过这是历史的一个数据啊，这边再去跑它。

这时跑一了，一就是我们的巴ffer的了，这个验证了啊，走跑起来之后，注意这边看，你看他们长大的这个。でど。看到这个长大的那个这个速度了吧。这就是本质区别了。为什么扎了就一定得使。😡，大分来了都对。

是吧然后这时候再来再来观察，我们先观察底这个缓存那个。因为现在刚2。5个G，我内内存3个多G啊，3个多G啊，然后再往上走哎，到3个G了，然后再看再看再看先盯这个缓存那个，你看这降低了哎。看到效果了吧。

就是我这个文件已经超过很大了，超过我内存剩余空间了。我文件是这么多页，但是我内存空间只能放这么多页。这个感觉找到了吧。就是内核会充分利用自己的可用空间，尽量的为你去维护你访问过的数据在内存里边。

这个配置会给你给你维护到好吧，但是这已经超过了，它肯定会像磁盘已经因为你你这个百分比是不是命中这个这个ca已经小于它了。那曾经那一页，其实已经被淘汰掉在内存里边，所以就被淘汰的，必然就已经产生过什么呀。

像磁盘去写的过程了，就有一部数据已经被持久化了，只不过后边还没有被持久化。好吧，我把它ctrl C结束一下。重来再重新跑啊重来重新跑。但是不止是重新跑啊，这已经有一个outt文件好大了啊。

一个文件好大了。16个G啊16个G。然后呢，我们先来看PC。state杠这个我们的out点TIT。记住他现在的缓存的页数的百分比是17。087。啊，我我这边啊这边没介束啊，这边。出兰怎么上来？

再来看一眼。是15%，这个应该是百分百，反正就是这么多啊，这是被缓存住的了。我这个程序也结束了。这文件这个outt文件已经写结束了，能明我什么意思吧？写结束之后也看你的大小啊，跟着我思路走啊。

现在是221个G叫outt点TIT，然后给它重命名outt点TIT变成圈圈叉叉点TIT。然后其实只不过是pass的文件名变了，那个数据没有变，相应的内存的缓存都没有变。它只是改了一个原数据。

就是它的那个在目录里边那个名字变了，相应的配置没有丢失。为什么P你先看是不是就是由outt跟outtTIT变成圈叉叉点TT了。然后你去PCstate，然后看圈圈叉叉点TIT它依然是还是缓存这么多东西。

这是第一个现象啊，第一个现象就是这个文件曾经被用过了，那核只要它改名字也不怕，只要这个物理文件这个数据缓存过的就依依然还在。然后注意听注意听啊，下边的下下边下边的这个这个这个现象啊，这就开始淘汰了。

如果我再重新跑起我这个程序。掉一一这个这个测试分了，它会疯狂的产生一个al文件，对不对？因为它里边写死了，产生一个outt文件，这outt文件会疯常疯狂的它是一个活动的一个进程。

这个文件已经是曾经被用过，曾经被缓存了。如果未来再打开这个文件的时候用到了这个这些这个页的时候，就可以从内存直接可以用了，能明白我什么意思吧？但是现在如果再跑一个程序，这个程序玩命的去创建另外一个文件。

然后呢再申请这核的这个页。那这时候其实那边这个新的活动程序太快了，就会把这个没有被引用这个这个这个这个页给它淘汰掉，一会这个圈叉，它即便被缓存15%，就给淘汰成0，这个理论能听。说边一。りま？

所以我待会儿跑起来之后，第一个先看他长大。同时看PCstate。看我们的out，它那个那个新的那个java程序输出那个它的那个业的增长以及百分比缓存百分比，以及在观察这个老的它是否开始被产生淘汰。对吧。

先来看啊，目前来说哎这个老的文件圈刷它还是被缓存了15%。好，这边抛弃。看上面的是不是已经开开始分配了，下边是不是开始被挤出了？是不是被淘汰掉了？能看的同学来说个一。哎，哪这人。保证你上面这个有。好。

把这个结束，这这个线在也抓也抓到了啊，就是现在你知道了那这个。程序啊其实由不得自己啊，程序由不得自己，他很多是受那核去影响的，对不对？好，这几个点验证完之后，最终还得跑它，为什么还要跑它？

我们要看丢多少数据。outt点TIT。目前来说缓存了这么多了啊，然后不是现在是这个历史的，当我跑去之后肯定还从零开始涨。我就是看它涨到一个多G不到两个G的时候，我在光灯给它把电源关掉，看那两个G里边。

它是不是给你保存了，保存了几百兆，还是保存了一个G能不能保存，还是最终倾向于0。也就是说我开始的内核参数，因为那个参数是不是six cTL我杠A的时候，gra dirty的时候。我知道。

就是T的时候是不是定义了内存要使的，使用到90%才会由内核触发泄。然后我内存大小是3个多G啊3个多G。呵。😊，所以。我在做下一个验证。就是一会儿我跑起来之后，达到一个多G的时候，我就直接薅电源。

180300400。900了，然后开始电源开始关机。其实这时候已经写了将近一个多G了，我再把E给关掉。那这时候其实起码说已经大于90兆这个文件能理解吧？哎，然后有这么多页已经被分配了，已经被cat了。

那这时候再把它跑起来。那其实这时候如果说就现在这台服务器，我装了一个readdis，我将redis或者买circle，它的持久化级别选成由交给操作系统的缓这个缓存级别来帮我保证这个持久化。

那这时候你就可想而知它要丢多少数据了。能ge到这个点和S一。

2。好。有啊。就是没关上，还是还是还是我刚他起没起啊，起了。嗯。确定。抛起来了，然后重新连进来。你说啊。快到线上了吧啊，咱们直接给你验验证验证本质验证现象东西是不是都丢了，好好难受的一件事情。

所以一般一般我们都会选择什么呀？就是为什么reis默认像是他没有给你选成那个完全信任内核这件事情，他选了一个一秒，就是他丢也丢丢丢掉你最近一秒它的刷写速率，丢那些数据。Okay。

这圈叉是历史文件，跟刚才那个操作，跟我那个java这个跑这个java文件已经没有用了。因为java指会输哦奥点PIT曾经的时候，其实我已经给他，因为他已经这个新生的文件已经把它那个页给它淘汰掉。

淘汰掉的时候，脏页它一定会保存下来。这服务刚才那个验证了对。能能能理解了吧，这个你那个名字是有枪有什么那个这个星三个星的那个这个这个同学，就是你你你说这个他啊现在现在都明白了吧。

因为第后来几次实验的时候，因为他有疯狂疯疯狂开毕业嘛，所以他虽然没保保留住，但是就因为你也老使用内存，你把别人的这个内存的脏液。给给刷写到4板上去了啊，人人人家就就给保保存住了。🤧。好。以上这点东西啊。

最主要的其实说白了我是给你演示这些东西，你你开发时候用吗？你也不会这么去去做。首先先记住了一个一个概念，就是我得出了一个结论啊，得出了一个结论，也就是其实配age catch。

推我们的。是。P catch。是一种呃内核本来是要做一件好事，是优化。IO性能的，他本来是要想优化这个IO的性能，就是优先走内存对吧？优先走内存，但是它要一个弊端，什么弊端，弊端就就是会什么呀丢失数据。

他一常多电的时候，对吧？好，那么给几分钟休息一下，把刚才这个东西找下感觉。

系列 3：P184：【IO／NIO】 磁盘IO - 马士兵_马小雨 - BV1zh411H79h

那接着讲啊接着讲讲啥。把刚才那个追踪那个事他给你演示一下啊。从来刚才那个流程，我要从来刚才是给你讲pa cash，现在给你讲的是我们就是最终咱们扎入程序员，对不对？

你得知道你写的代码当中为什么不推荐使用这种直接IO这直接使防IO的方式要使用8分的对吧？

Okay。然后是执行我买需。去导相的木啊。买需深直灵使用基本L的方式。然后呢，我我不不去追踪pa cash了，我追踪的是让他们去生成这些文件之后。

我去追踪他这个追踪系统调用这个这个里边怎么怎么去执行的啊，让他跑起来，跑一会儿，我就给他结束了，结束之后跟着我的思路走啊。然后这时候你会发现out一系列的后边搭搭上的是现成的ID号。

这个应该是一个基本的一个常识。就是我们GVM跑起来之后，ja个程序跑起来之后，它是一个多线程的。啊，那么这个1350就是它的主方案的主线程，我们代码也在主线程里，这个能听懂来，稍波一。

其他的还有什么GC线程等等的啊。🤧然后我们打开VN1350off点1350。打开这个文件。这个文件里我们找啥，开始是不是输出了123456789。

来，我在我们那个程序代码当中啊。他他第一大嘛，第二个嘛就是嗯。在我们的成序代码当中，是不是你写了一个死循环，一直要调，就是我们调的是我们那个output stream。

然后out点right写data这个data是啥？这个data就是123789，然后换行。所以你会看到从2248行起，然后就一直是rightite123489，然后写的字节数量是10，一直这么写。

一直这么写一直这么写，一直这么写，一直这么写。

然后这个东西现在你看到的是啥？现在你看到的是通过str追踪的应用程序，对内核的系统调用，其中每一行都是一次系统调用。也就是用户态到内核态切换的过程，这个能听懂同学来稍边一。

你听了前面马老师讲的机组就应该知道这一过程会有计存器保护现场，一系列复杂的消耗CPU指令机时间的事情。所以像现在第一种我们的基于IO直接写。不使用8ffer的时候，其为什么写的那个数量变化的有点慢。

体长的比较慢，就是因为单位时间内这个燃脂了太多的用在那个内在切切换这个这个浪费的时间，好吧，这应该都知道，不不多过多的扩展了。对吧这个这个认可同学来刷666。没问题吧。

🤧这是刚才第一个啊第一第第一种方式。然后同比啊同比，其实我可以拷贝一下outt点1350变成base点out。这个base点outt其实存的就是刚才那个很，你看大小在这摆着呢。

然后他就是疯狂掉这个这个性标用。我把这个文件先删一下。这圈着圈。我看到这个大小好大。挺挺挺心疼的，因为占有硬盘空间啊，然后再来执行。

这个时候给的参数一给的参数一什么意思？参数为一的时候是要测试我8分。8分刚才已经说了，它其实长得比较快，它肯定比上面那个那个那个体长的比较快。因为说了它里边其实是有1个8K的那么一个缓冲的。

所以这时候我们来看啊走。

好一会儿crl C结束它，然后他把所有文件删除，重新生成。啊，个我我的个 base呢，一个删了是吗？我这被子给带了一个out也给删了，不好意思啊，但是不管咱们体积数不去比刚才那小一点了。

是不是outt点1389，这是另外一个了VI out点1389，打开这个文件。😊，然后注意看也搜123456789搜它。但是这时候注意看。这个rightite里边还是只写1个123789吗？😡。

就是你看啊在我们java代码当中，你是不是死循环r写了date，这个date是不是就是123789啊，但是现在它写的是一个缓冲区大小。

890。这个跟刚才的比法就是同样也是必须要调right，但是这个就比它少了很多次right调用，减少了来回切换，只不过单位传输的数据多一点点。す个。

对吧啊，这块能听懂同学来刷波666，这是两种方式。曾经你可能只知道说。啊，我们的使用8分的8分的。啊，当然现在知道了buffer其实不是说什么缓冲不缓冲的问题。

是应用了缓冲而去解决系统调用这种损耗这种损耗。其实后边讲到网络IO的时候，也是要减少系用调用，才有了多路复用器。因为没有多路容器的话，你有1万个连接，1万个都要调1万次receive和read啊。

有了多路服务器只需要掉一次，我就知道哪些了。然后我就可能就是只调了6次或者几有有限次数的一个read和receive，对不对？

其实这些技术这些技术知识啊都是都是相通的，好吧。

🤧OK那么像这些啊。这个这些个IO，他们其实在的包啊，在他们所在的包都是java点IO的包下。啊，都是javaIO的保险。那么其实。咱们现在开始测试GDK新的它是不是有1个NIO了？

对NIO你一定要理解啊这NIO什么意思？是newIO新的IO体系。在新的要体系当中，其实有有现在目前说，现在我们只讲文件，有两个概念，一个是channel，一个是ba buffer。也就是换言之。

其实从以上普通IO当中，我们总结到了这个尽量使用buffer形式的。IO形式。所以NL当中啊，它其实是首先抽现时channel，没有抽现这ch之前，它有输入输出。有了chnel之后。

channel把输入输出合并成一个了。然后其实它也是基于8分的。他并没有超越所谓的这个前面这个形式，只不过在AP上给我们提供新的。然后他扩展了一些新的。

比如说m这个mped bufferffer的或者是direct bufferffer啊，这个后边来说先我们先去看一个什么东西啊。

再讲这个random file它这个NLO这种文件的这种channel的访访问方式之前，我们先去讲另外一个东西，就是因为它会用了一个ba bufferfferbut bufferffer是一个啥东西。

ba bufferffer是一个字节的一个数组。你这么想就可以了。啊，直接数度。这个字节数组，然后围绕它有一些指令啊，像我可以往里put填充东西，然后就翻转东西，然后get获得东西啊。

然后等等cleer清除等等一些一一系列的概念。然后呢，我们直接把它先运行起来吧，然后一边描述1111一边说啊跑下，我现在直直直点示它。我怎么去做的bed bufferffer，然后我分配了1个1024。

这点错了吗？Okay。哦，应该使的是这个。对。要了。Yeah。系啊。对。嗯。有什么主方法？就ts没有持持跑起来吗？没有。不是我这要跑这个test。你个收过。算了，我给他传一个三传三吧。这样这个。

不在这浪费时间了。2在下午再看X0。等于算。就是默认我给他传了一个三啊，默认给他传了一个3三的话就走到我这个back个buffer，好吧，先不先给先给他跑起来啊，我们先给他跑起来。这个金额不让我们。て。

对。我这么发不行。这。系唔这啊。这个静态吗？有什么的办法。你度我な。啊，对应该前面加了一个静态啊。对对吧，是。除掉。这该是。就是真个。是这个。大概点用。全大。有。其な。对吧。这又是啥？

T space fan。你这么费劲的。不需要。有我。不我。不去了。也是吧？根据方呢是。こ。我跑完了啊跑完了。うん。其实其实应该这个这块应该大家大家都知道吧，我就得我就快点讲了。

就是这有一个b bufferffer，然后我分配了一个大小是1024，在这分配的时候注意注意听啊，你可以这么去分配，还可以。嗯个。他有另外一种分配方式。可以普通的分配，这个分配在堆上，也可以分配在堆外。

就是它的分配方式有两种，这两种分配方式不影响它的执行的。执行的这个这个这个API的这个这个这个过程啊，这是先说两种，还有一个就是基于random Excelel拿channel。

拿那个fi channelnel的时候那个。麦y的这个。mabe这个 bad bufferffer现在我只是说的是最普通的在堆上分配，或者是在对外分配。然后分配的是1024，你就想成它就是一个字节数组。

字节数组有了之后，然后上面我打印了12344个，这四个代表就是这个数组，它其实有4个维度，这个有4个指针，一个是偏移指针，一个是它的大小限制，limit1024啊，一个是总大小1024啊。

然后打印了这个。其实其实其实直接攒8分的话，会带出它这个这个尤其得最最重要的三个维度。然后我们简单画一个图。

就是如果你分配了一个ba bufferer。わ。这是一个position。啊，只否。默认的话，position是指向零的，然后呢，还有一个limit。还有一个是它的总大小。现在是我们这个执行的时候。

上面我们看到的它的一个状态。好吧。

别别嫌这个浪费时间啊，因为这块我想讲的一个比相对比较完整的一个一个一个过程。然后下边是哎我对buffer点putput的时候，我添加了1233个字节，get the balance放进去了。

那put的话其实它是沿着左边沿文里放了三个字节。那这个position其实会往后移动三个位置。

啊，一共三个位置，所以这是候put完了，你要put123了，然后再去打印这个ba bufferffer，to position就为3limit就是1024。然后这个大小从大小1024。

然后最终一个flip翻转，翻转什么意思？翻转的意思就是一个bed bufferffer其实我们是可以往里放。但是它不能只往里放而不去读取它，读的时候，其实你要让它回到你position就是偏移。

就是要回到开始的位置，但是又怕读超过了它，所以这时候limit就要去占它那个position那个位置。所以flip这个flip是什么什么概念啊，所以我调了f之后。

然后你再去看它的position为零limit为3。

所以往里放的时候，它会往后走。但是如果想读它的时候，这是分为这个这个形态了，就往你放的时候这这么走的，想读的时候必须要先flip一下，把它搁到前面去，把limit移动到它曾经写到那个位置。

这是为什么使用bbuffer的时候，它要翻转一下，翻转的目的其实是为了就是在读写行为的一个交替过程当中。

五万。多一个交替，先简单介绍一下，然后ge你只有交替完之后才能getget的时候，你的get会让你的这个position向后移动。你get一个了还是get所有了，这会有一个向后移动的过程。

就是putput和get都会移动它。

到这能听懂来shopber一啊，因为你get完了之后，po你get的时候，我只get了一个字节，在这在这个这这只掉了一个字节，读读了一下，然后再打印呢，打印就get之后再打印的话。

它的position就唯一了。然后向后的话是一个。comit这个在调的时候，是把你的position标成2，把limit再调到后边去。然后其实是一个。

就你读完一次之后到这儿了，然后再去调compact的话，然后再去把它置到后边去，然后呢把它移动到后边这个位置。因为你前面那个已经读过了01，然后挪到2这个位置，然后往往往挤压一下。

然后剩下这个空间是前面是你曾经往里写，然后没有get完的，后边是剩余可用的。

就是就仅仅的靠了这个尤其 the position limitit，然后一个是flip，一个是compact来达到了让你使用它的剩余空间或者读取他已写的东西。还有一个。

你来看，就是你ge之后开始是不是012写了3个，我get了一个这position为一了。那这个里边还剩谁，是不是剩下两个两个字节没读了。两个字节没读之后，然后这个你compact之后。

你的posation为下标为2，那就是01，那两个没读的排排在最前面了，然后limit放到了1024。

现在。明白什么意思吧？啊，就是我再给你画的精准一点，开始我这里边有仨东西。有三个字节。そ。那接。开始po，就是fep之后啊，就是先往里放哎，放到这儿了。这往里铺的put的3个，然后浮了之后。

然后它是不是回回零，limit是不是在这儿了，在这之后，然后我盖了之后是不是取出了一个，然后pos指针是不是往前移动一下到一了，compy之后什么意思？哎，把前面挤压掉。然后呢，comide之后是交换。

把指针交换到外边。因为com麦代表你要是从读取到写入状态，然后要拿到一个剩余空间limit再回到结束这个位置。然后这时候你可以往里写了。想写的时候comp一下，想读的时候le一下。分天来说。

好吧，这个这个理解了吧。啊，其实你就就就就这个代码嘛，你你就拿我的代码，其实你都跑一遍，你把所有方码调一遍，然后都打开它那个偏移，你一看就是这么回事啊，肯定就清除一下啊，都都都归位。好吧。

这个理解了之后啊，这是第一步啊，butta bufferffer，他其实对这个自己数组这块怎么怎么去操作。然后再往上导导到回来之后，我们来看。😊，NIO里边的基于文件的啊，基于基于文件的NILO测试。

后边的话我会讲基于scket的NIO的测试，这就是几个分支了。先说文件的文件的时候怎么去做，你有一个random x file还是读取一个这个out这个文件，然后注意你要给出它的读写啊。

或者只读或者只写或者读写都有，然后给出这个权限，然后你得到了这个random s这个这个这个这个对象，然后注意先我先捋一下这个逻辑都做哪些事情，基这个文件。拿到这个对象之后，直接写啊。

直接写写了一个hello空格马士兵换行符。那我对应的文件当中就会出现这一行写搭了一个换行符。然后我继续再写第二行hello肖婉珠，这是我的名字，然后再一换行符。那文件当中应该出现两行字符串。

然后我给屏幕上提示一下，我readite写完了，然后这时候sim点 in点read那程序在这阻塞着，这是第一个阶段创建了它，并调用了普通的写。这普通的写是怎么回事？待时候我们去看一看这个这是第一个环节。

能理解的同学来上边一。理解吧嗯，很简单一个事情啊。你周。出了写之后，这个为什么它它叫做random access file，就是随机读写的。因为其实这个你之前如果没有这个随机读写的话。

之前使用IO要写东西。如果这个文件你往上写写写，你只能往后追加写。你说我再从头写，我写一半了，我再从头开始写，不行。它有一个方法叫sick。就修改你的指针的写那个偏移。我说了。

其实就刚新画图的时候也说了，每一个文件标符就是一个程序，两个程序或者一个程序可以打开这个文件。就是它是有一个sigsig一般就是你用用到哪儿了，它还可以移动这个sig到前面的pagec。

如果你学过大数据的话，就应该知道HDFS里边也有一个sick这个sick就支撑起了它的分布式并行计算。因为每一个程序打开同相同的文件，它们各自sick到自己的那个数据段里边。

去并行拿着自己的N分之1数据去计算，这块能定回来2边一。就店出。不有。然后注意看偏音量是4。🤧你可以理解成断点虚传，这个偏音量是40米，就没错，这也也就是因为s个可以实现断点续传。

没有4个没有这个sig能不能实现断点去传也可以，只不过重新打开重新走嘛。有了四个只不过分便点嘛。这个四什么意思是下标啊，这个字节那个那个偏音量，那也就是说0123到这比就是从这个位置，第四个这个位置。

然后我先移动过去，然后又写了群圈叉叉，而我们又重新打开文件。所以这时候如果这步完了之后，我告诉你sick了。我再再等着录入的时候，我们就偷窥那个文件，你会会发现就不是哈lo马是冰，而是HEL。

然后应该圈圈叉叉，然后马是兵，就就就被这个这个覆盖掉了。这就是它很灵活的一个特点。第一个特点，random S file，它就是像我们之前写的那那种那种LU一样，可以写。第二个支识点，它可以自个修改。

指针偏移，很方便。然后这个事完了之后再往下，你可以通过这个对象get channel拿到了NL的最重要的角色，这时候才开始真正NL的讲解。final这是一个fi channel。文件的通道。

且这个通道在我们上次上来创建的时候，是读写两两个方向的。那么拿到它之后，注意它身上啊只有只有文件的通道上有map。如果是server soet或者scket上边是没有这个map方法的。明白？

只有文件上可以做做内存映射。因为文件被称为块设备，块设备可以什么叫块设备。我上次上节课讲文件系统时候也说了，你可以来回自由寻址，读读历史的前面的某一块，读后面某一块这数据去趋向于都有，你们都能读到。

明白吧？所以只有文件才会做内存映射，就是把内存的那个配置c内核的那个配置c和文件的那个那个这个数据也映射起来。那个地址空间映映射起来。这不能听出来说边一就是只有文件的通道才会有M map。

咱拎这个这个内核里边。🤧啊，其他流逝的自负性的是没有的。那么这这一步mve的时候，然后模型是读写啊模式，然后是映什么？映射的是文件0到4096。其实这时候你还一会儿还要验证一件事情。

就是在这上面验证的时候，这个文件我只写了这么一点。你先看这个文件的体积是多大，体积是多大。但是如果做完这步之后，其实这时候体积就被就被扩展成4个字节4096。然后得到了一个map。注意这个map叫什么。

叫做mpe的 bad buffer，只有文件系统有map，只有map可以得到一个mpe的 bad buffer。如果从bed buffer去获取，你只能获取。堆上的和堆外的。独立的内存空间。

但是只有文件系统的fin the channel可以调map。这个map其实通过的是M，那就是内核的性调用M map得到了一个对外的，注意听是对外的。面向java的是对外的且核文件。映射的。

一个拜拜拜拜的八分。到这步能听的同学来说波一，这是一个极特殊的一个一个一个一个场景。什么时候用对外内存啊，一会我一会儿给你解释啊，尤其讲到后面边sry的时候，我都会让你看。你即便你在java程序里边。

你想分配一个。堆内的1624，你会发现使用s给的血的时候，他会脱了裤子放屁，他再弄一个堆外的那个字接数组，做一次拷贝之后，拿着对外的再去调内核的血。那你还不如上来直接分配对外。あの。咁啊。

这是为什么java，你是要先从堆内的数据拷到java进程的堆里边，就是从GVM的那个虚拟堆里边，拷到java进程的C的堆这个程序堆里边，然后再拷虑到内核的空间里边，然后再拷拷到相关设备里去。Yeah。

好吧，所以对外这个事儿是大数据也好，后端工程师高级这个支撑的时候，或做系统调度的时候，都得要去想着对外尽量去调对对外这件事情。个通司。还有。这个这这这就是搞死您的思想吗？高司令，你是说高司令的思想吗？

还是说之前的思想落后了，不是思想落后了。因为对外注意听对外，你看现在啊所有特征都是拜的buffer。只有ban。Not or be jack。没有对象的概念啊堆内的时没有对象对象的概念啊。大い？对啊。

然后再往下捋，然后我得到了一个map之后，注意之前我们都是通过r IO去写什么数据。但是你得了by buffer之后，我说了b bufferffer下边给你演示了。

它是可以通过调一个bed bufferffer字节数组的put往里放。但是这时候注意它不是系统调用。不是系统调用，这一定要记住了，就是你得到b bufferer之后，往buffer里放东西。

这个不是系统调用了，像下面普通的就是像堆里或像堆外的内存里边放了一些个字节数字字字节。但是这种特殊的通过finfi file channel里边得到这个 bad bufferffer你这个put表面上也是像你的这个字节数组里边。

这个b buffer里边去放了一些字节。但是这个字节又因为是映核文件映射了，其实就映射到了内核的配置cach。但是数据会到达。内核的配置catch。那么曾经我们是需要注意跟写啊。曾经我们。

是需要dot点儿。Right。这样的系统调用。才能让程序的data。进入内核的pager catch。这曾经是这样才能进入这个pay。要这也是换言之，这曾经必须有。用户太内核太切换。

那现在如果使用了这种my的 bad buffer，它只有映射了，就减少了系统交用了。但是数据也能到pa cache里边。但是。MVP的内存映射依然是内核的。配age catch。体系。所约束的。

能看懂吧。换言之。丢出据。呢个。都能都能都能听懂的，来刷波一。就是现在你没有现在你使用java目前来说，GDK没有能力让你逃离内核的p cache。目前的所有的AAPIun什么东西的。

都没有这个这个能力。你可以去G去找一些关于就是你可以。去ge他。Hub上找一些。其他的C。程序员。写的JNI。扩展。库。然后使用linux内核的。directIO这个内核的directIO什么？

直接IO直接IO是忽略。是忽略。linux的。Pr catch。どの？是忽略了一个pay catch，但是不是说忽略pay catch，这东西就特别快了，是把pa catch一定要正确描述啊。

别为面试规台节奏，是把配置。Catch。交给了程序自己开立。嗯，那这样的一个间接间接想法就是pre cash的好处是我内核把这个数据放在p cash里边，仨程序访问这个文件。

你们从pay cash都能都能拿到。但是如果使用directO跳过的那个pay cash。那这个同样这个文件的数据被拷到我的内存的时候，是不是交给内核的共享，而是交给了你程序的p cash是你私有的。

但是你依然要去动用代码量。一致性。脏等等一系列的复杂问题。あめ老。对。我相信现在因为我给你讲过了page cash的工作原理，然后再跟你说Dri虽然咱们没有API去可以模拟，但是现在应该能听懂了。

相当于自己管理了payage cash吧？没错。自是了。就自己开辟啊自己开辟一个字节数组。这是最通俗的，就是你自己开辟一个字节数组，开辟1个4K的。然后呢，通过DL的方式。

直接把数据通过DMA直接拿到你程序的一个字节数组里去了。还有说都是。自节受讼。对吧该丢也丢，只要你不晚血，你不维护脏，你不晚不使用DI，直接把数据写为那那那个硬盘，该丢也丢。啊，你去频繁写为内盘。

频频繁写写写向那这个字盘性能依然很低，也受也受IO影响。其实说白了你程序自己维护和你使用配没毛区别，该丢丢该慢卖。只不过你可以控制的细力度更多一些。因为那核的话。

你要一改刚才咱们改过这个这个配置这个配置项的话，它是全局的。它是对整个系统当中所有的这个这个IO就是统一管理的。但是现在的话，其实如果这个系统别人没怎么用的话。

你就可以完全细粒度的可以控制自己的这个这个程序的这个性能了。仅此而已。像操作系统不是像DDB数据库一般会使用DYIO。仅此而已，好吧。🤧Yeah。ma bad buffer能flash吗？啊。

你看看着看着来啊，你看着来啊，我下边都给你演示的呀。现在知道了，这个现在给你讲完了吧，这个IO模型这叫IO模型，你现在剪一上就可以感写精通IO模型了，对吧？😊，你在高。对不对？现花在哪儿啊。

666在哪儿？对不对？啊，还你还不能敢写，为啥一一票的soc you，你还不懂呢，你敢写。😡，ま。还差一堆scket的那个那个那个在弄完了之后就就就就改写了啊。但在这儿注意了，以上所所依据的。

也就是文件在我们使用file channel之后，然后可以达到它拿到map。但是这东西它依然走p catch，所以它依然会要么等系统帮你去刷写，要么就是map点for这个叫forse。

它类似于我们的flash。就程序我们自己可以强制刷写。这就类似于我们的flash。你刚才那个同学问的就是他。对。或。对不现在现在现在听清楚了吧？这是my，然后也会就整个代码，我给你演示它的普通写。

演示它的随机写，然后演示它的对外映射写，然后对外映射写之后，然后在下边再给s文件开始再s文件开始上面不是直接内存映射写了吗？那下边再使用普通的 buffer，我可以堆上分配，可以对外分配，得到八分。

然后这是把八下面我讲的8ffer直连应用到这个channel连接起来时候，因为把刚才刚才给你给你举个例子，现在咱们就直接给它用起来了，用起来之后，我先分配了一个堆上的或者一个对外的拿到一个八分。

这个八ffer注意，我是通过因为之前这个文件上面已经写过一些东西了。然后我给它偏量为零了，然后这时我通过这个文件，然后读取文件的内容，通过这个对象读取文内容。put到buffer里这个读写文件内容。

把buffer作为参数去是，其实是这个运等于。8号。点铺子了啊，往里往往往里去添东西了。bffer里put了，put完了之后，然后读到了多少东西。然后这个时候这一步是要翻转，因为从读就是从从往里放东西。

到后来你如果想对着它去读取东西的话，那这个时候其实你要给它做一个翻转的。翻转完之后，然后开始复循环，复循之后，然后开始对着我的这个buffer点get。啊，就取出它的每一个字节。

这个字节来自于它limit，因为翻转完之后就知道它的limit的这个控制大小了。这就是把be bufferffer给你演示逻辑，以及b bufferffer在我通道的联合使用的一个演示。

这是整个的一个rdom X five这个演示的一个案案例的一个一个逻辑。逻辑上清楚同学来说边一。

对对。这个是。演示好吧，就开始演示。啊。然后就。啊，不用删，他自己会删。妈把它跑跑的是012，开以跑2了，2二度测试啊。第一个注意看啊，该机执行。

提示了一个right，他现在等着这我我输入呢，我先不摁啊，就到这步了，然后我们去开一个窗口去看一眼。

哎，outt点KID大小31个字节，我们来看一眼它里边写了啥。chat out点填加T它里边是不是写了hello马士兵，hello需周。当然这个你看到这个东西在磁盘上吗？如果现在面试官问你。

现在你看到的东西，他在磁盘上吗？前面写了。没错，还没有，他现在是是是配置K这里的，他是不在你磁盘上的，因为还没有做刷写这一件事情啊。

那么这步写完之后，然后我摁摁了个回车，它就开始往下走啊，你也知道这个数据长什么样子了。那我开始摁一个回车啊，哎8摁一个回车告诉你sick完了，它能sick完。

其实这里边也代表着他完里边又写了一个圈圈叉叉s到4写了一个圈圈叉。所以这时候你看能sick完之后就写了完之后，你再去ca out点TIT是不是HERL圈圈叉叉士兵，这个就是它的随机读写能力。

这个能看出出来，上边一赵勇还是这这。

好吧，那这个完了之后又又开始等着我，我找一回车之后。下面就没有太多的，这还有一个read这还read。那这个这个过程当中，这个就是在上面这个read之间到这个read之间，它会触发一个MMP映射。

对不对？哎，这是MMP映射这个M映射怎么去验证然后开一下另外一个窗口GPS一下我们的这个程序加进程是1440注意看是140。

用我之前教你的这个东西都是之前教你的LOF让P1440来看它的所有文件标符以及内存映射。你会看到它现在文件标符012是标准的输入输出报错。

然后这里面三是加载运营时的time点账包4就是开启的对这个文件的一个文件标符普通的读写。然后我说了上面这个MEM呢是它做过所有内存分配。

开启的目前这个里边是看不到奥点PIT。都是一些炸包，到这步能听出来，这就是他的那个代码段。加载咱们这个java的可执行程序，就是代码段KIT。对吧啊，这现在还看不到，但是注意看，如果我一旦摁下回车。

map put完了，先不看结果，再来看。因为你刚才开过一次fifin点map了，再来看这个程序，它就多了一个。就在这儿。memory一个内存映射4096大小。这。还有一个4号是普通的文件面符。

有两个都可以对这个文件开始操作了。你要么使用buffer put往里写东西，要么基于继续使用这个文件标符right read读写到这步能听懂同学说边一。就让你看到，让你看到。是不是看到了嗯。

然后且这时候再来看那个文件。😊。

是不是又在前面加了三个艾？

是不是前面加了3个艾 put的进去了啊。😀ふ。😊，然后再看那个文件大小。文天大小是不是涨到了4096对，没有。对吧。所有理论的东西都让你能看到一个实际的一个实物啊。那这个瑞德兰之后。

那接下来其实使用的是。

不是使用上面这个ba那个m bad bufferffer，是自己随便分分配一个一个buffer，然后呢C个为0，然后读啊读取这个这个相应的数据，然后再把它打印出来。这段其实没啥可以演示的了。

就是最后最后就告诉你他能这么操作，主要主要是给给你演示那个ba bufferer怎么使用的，往往下走，然后这时候开始就看这两个开始读这个。

是读完了之后，读了1个4096啊，然后但是他读到多少是一个数值的。然后f利分成之后，从零开始limit4096。然后因为我分配了892，但是我那个磁盘那个那个缓缓存页是4K。所以这个读完之后。

啊，这个瑞子没有没有没有没有没有用气啊。

系下。但是不管怎么样，是不是也有足导东西也被打印出来了。我者。Yeah。mpper put会用到 page看什么？会呀会呀。

我说了这个就总结一下总结一下总结一下，把刚才的总结一下，尤其到这个redom X five这。首先第一个指点这这个我之前你听过公开课的，我也说过这件事情。但是今天我再说，你就听懂我在说什么东西了。

首先扎了。它是一个用C或C加言开发的一个普通的一个程序啊，它的级别，它的level是linux系统下的一个进程。这个能听的同学来说个一，就java进程跑起来之后，你就像刚才咱们看这。

你java是个程序，它的二0制编译完的这个二0制代码段是你的这个进程里边的这个代码段TIT。

🤧然后也就是他的TIT是。java，然后它会分配，就是这个程序里边还有data，还有这个堆。然后这些个概念都是操作系统进程该有的。只不过在堆里边，它可以根据我们给定的差。

这里边可以根据我们给定的一个配置项。就是你启动。到时候杠叉。M叉吧啊M叉比如说EG。那这时候其实你的这源代码会跟系统分申请分配一个。系い。Yeah。と部。反正你。分配这么一个。

这就是我们所谓的javaJVM里的。Heap。哦。是线下对就是分配了一个堆上的一个分为了一个堆了。堆了之后，然后如果你用的是bad bufferffer。

我。然后分配的时候，我就直接抄了，单词老记不住。

真的不见到。这种分配方式是把你的字节数组。分配到了堆上。哇。

对吧但是如果你使用的是另外一种分配方式。

然后。那个。是分配到了你不是GVM里边的，是分配到你这个java进程的堆空间里边啊，他申请了这么一个区域，这是你的这个babuer。Yeah。这是这是unhi，然后这个是onhi。对于面向java来说。

unhi这是of hip。尤其你学大数据，学sk，这点一定要是分清楚了啊。然后对于程序来说，对我们的C程序来说，访问这段代码是直接访问。因为这段代码所在的这个字节数组的这个线性地址。

就是你进程的线性地址空间。但是这这段字节数组的地址，它不是你的这个G进程的线性地址空间，是你乘GVM的线性地址空间。它需要一次这个这个这个这个翻译，或者把它拷贝出来，再给你直接使用。

然后如果你不是用的这个b bufferer去分配的。还有一种分一共三种分配方式对呗，有第一种对上分配，第二种对外分配，这只是分配。这个这个作用域是只是分配了字节数组，可以往里填东西。但是数组的东西。

如果想交给系统的话，想交给系统的话，依然是要通过你channel的right写和读。也就是我最后re后边，就是如果你想你想用这个but bufferffer。

你肯定是要通过channel去读它或者是chan去写它啊，这个channel点right写这个ffer，所以你肯定还得是去要通过别的那个FD就调那个系统系统调用给它写出去，它只不过是一个缓中区。

它类似于你咱们传统的那个自己定义的那个字节数组。

对不对。这个hiap是进程的，是你这个java进程的，黄色的才是GVM的off hip说的是GVM的堆外onhi是说的GVM的堆内，这是一个堆，这是一个这个hi。我这不写了吗？下面的这个这一行。

这不写了吗？就GVM的黑。但系可。这个是你就写成写想成是linux。都黑。Yeah。清楚了吗？脑子一定要一定要一定要一别别别等片，一定要一定要想明这个事儿。多人。当日会打。反呢佢。我你好。

然后但是有一个对象叫做fill channel。它里边会有一个。麦克方法。麦克风法会分配一个ba by。my bad buffer就在java里边，是叫做m by bad buffer。

但是其实它也是一个字节数组。啊，这个东西就是my的。这个mag什么意思？这个magit首先它也是一个直接数组，就是在一个操一个操作操作性统的一个普通技能里边，你可以有代码段数据段堆段。

然后或者是通过MMAP系统调用。分配的空间。然后还有就是映射空间嘛，还有战区，有几个内存区域嘛，还有战区。这怎么写来着？这样吧。啊，战区这是一个进程里边可以有的几个区域啊，是这个。好吧，这是这个区域。

就是你通过内存映射M就其实你反正这个就掉了MVP了。映射之后，然后他做了一件什么事？这个映射这个映射它的线性地址空间。就是在用户的性引率空间，其实到达了内核的。这是你个。空间是可以直接访问的。这些。ふ。

Yeah。あ这个。这里边的逻辑地址，然后呢是直接映射到了我们内核的逻辑地址。就内核在这个这块怎么说呢？就是内核里边的配配agec啊，应该说是内核的pc。当る。这个。嗯，这样说就好说了，可着开。

然后且这个pagec，最终这个pc它应射到哪去了？根据上面的这个这个这个这个描述啊，这个p置开内核里边这个pagec它是来自于如果它是脏的话，在未来你要写的话，如果它是脏的话，你要写的话。

它依然是受内核的胚盖的影响，最终是要落掉到我们的磁盘里边去。1班的文件。但是文件因为在你map的时候，可以给出参数，说我这个参数是从文件的从哪儿到哪儿做多少多少结束。其实它映射的是某一个区域。

文件的某一个区域，这个区域你可以来再自己定。🤧只不过在这个应用区域里边啊在这个应用区里边，这个是通过铺的方法。就是我们的程序里边只需要写put。且这个铺的方法，它不会产生系统调用。

但是后边这个从dirty到这儿是受内核影响。现在能看到了吧？就这几个区域一个。两个。3个。你要记住了，只有five channel map完了之后，你这个m的 bad buffer。

这个字节数组的地址空间对应了page catch，它是配 catch的。然后你这个分配的堆内对外这个。虽然他们也是在你的page catch里边，但是它不会一一对应上啊，不会一一对应上。

而且这是在你的绝对的用空间，如果这些字节数组里边的数据想要达到内核的那个page catch里边，就是内核肯定还有如果是。想写到文件的pca里边，就是他们与他们之间的过渡里边是要通过必然调一个方法。

这个方法就是channel点read或read。就在他们之间一定加了一个channel点right或read。也就是必然有系统调用，也就是必然有系统调用这个方向。

这个方案仅使用堆内对外的bed bufferffer，必然有有系统调用，使用m就减少了系统调用，速度更快一些，减少系统调用。但是他们都是在payca这个级别都会丢数据。

然后堆内堆外只不过是使用堆外的divide buffer，它的性能要大于。就是减少了性能好。就他们两就他们两者比起来，他就一样两者比起来，它的性能稍高一些。就能收购一些。

那就是说为什么还存在这种方式这种方式？因为这个。如果是你纯手写的代码，就是你从obB get。注意听啊，就是如果OBJ取决于OBJ。如果OBje。是谁？如果这个OBI的对象是你的。

你就可以直接让他你直接可以分配一个对外的，就是OBD是你能控制的。就在逻辑代码当中，你的方法里传入了一1个obBJ，你可以给他们多序列化，转能字接数组，那你就开辟对外。但是这个obBJ如果不是你的。

他这个obB被别人的炸包先转成了一个。因外这个这个这个bag一个数组怎么说呢？就是你能控制的时候，你是可以控制对外的。但是有的有的时候你可能是只能让他去这块怎么能给你解释，我给给我自个讲晕了。

大家帮我想一想，就什么的时候你只能使用对外的，然后必须要完成一次拷贝的过程。🤧。然后。Yeah。对。嗯，这块我还没有想到太多的。对。没错，就是OBG可能它是要先序列化，序列化之后呢。

还不能放到堆外直接去往外发送，它可能需要加工。但是基于字节数组加工的话都加工了，那什么时候就必须得分配一个堆内的。而不能使用对外的。だね。对，这个这头对。反正这边就是你方法能接收能控制的。

这个是明非常明确的。Yeah。就先写一个，你不能控制吧，先先留留留留个断留留个断点吧。🤧当是这个描述不太准确，肯定不太准确。大家一块儿集思广益，想到了，你可以帮我补补充一点啊，先这么放着，没错。好吧。

OK。😊，还行吧，这节课讲这么多可以吗？教是。🤧onhi是不是先传到进城里，再传到皮利看onhi是。是你GVM要分要拗一个自觉数组，然后放到你的堆里边。那个自觉数组其实也是一个也是一个对象啊。

是先放在这里面。如果要往往外去写的pca的话，没错，是要其实是要走一个对外的过程的，这个线还不能直接这么过来，不是但是这这这这个这条线我想表示的什么意思啊？就这两线怎么走什么意思？就是想表示的嗯。

是要走他。是这个级别，就是这两条就是你堆内的对外的。如果想到pay cash都是要走系统调用的。只不过这个系统调用的话，它可能是要先其实先往对外走一下。

这他能啊就他先先从这里边去到外边才能走走走走出去啊，这条线应该是虚的这条线应该是虚的。这现实了。这东西。我是。呢个。

🤧这样我也不太清楚，我们可以看一下，当你写一个东西，通过redom x file这上看看看原文嘛，你要写的时候别须走写写readd by balance，你给了一个字节数组，他要写。

8进来这个进来说native啊，这就看不出来了。但是从哪能看出它拷贝的过程。我来了。其实这个应该是可以看出来一个所这这个这没有写出来。

这已经叫nty native ninety的话，其实nive是。

这很难看出来技能怎么掉的对。Yeah。对有。但如果看一个。いや。我这边没有没有那个那个DDK的源码。然后在这面我还有输出秒，稍费点输出。对即经。

算了，不带你聚了，太麻烦了。你先记住这一点嘛，这个肯定是有一个拷贝的过程啊，肯定一个拷贝的过程。从里边到外边一个传输一个一个一个一个比较比较影响性的这么一个过程。そなはい。

堆内是在GVM进城里的堆空间里的，堆外是内存是GVM进程里的。而。别课。对我给你写，我给你把文本写出来啊。嗯。这方。堆内的。说的是。GVM。的对。理的。数组。我就少写一个字节啊，写上么字节数据。有けな。

然后。堆于外子。注意对外的也是面向对也是面向GVM的说的。是。GVM。对外。也就是。java进程的堆里的。有都。不明我。有时。然后前面有一句话。然我公司这。这是这。不太准确的一个描述啊。

你就想成你就想你就想成。你就想成。GVM的堆。在java的堆立。好吧，你这么去想一件事情。然后另外一个就是my的映射M映射。对。是通过是m的映射是。这个调用。或者这个。这点么。进城。好。那会儿。共享。

嚟。区内存区域，然后且。这个内存区且。区域是配置开。然后。到文件。应用社。映射就这个区这个这个你想是逻辑上是一个区域卖卖这个M卖MAP的，然后呢，且和p cash是1比1的关系。

且直接和我们的文件有一个映射关系。我好月。那横面一个应射关系，然后最终就是。性能来说，onhi。小于of hip，然后小于mype。但是只限。文件。现在我因为我只给你讲了文件系统，这些文件。

为什么会容易丢失数据讲讲呗，这是不是前面配置开的内容吗？这节课可能信量比较大，你前面断片了。那没有什么明了？条件反射没有了。是不是陈建海盛没有了嗯。这。Yeah。先先去先去攒这个吧啊，后边我再给你。

穿起来再给你讲一遍，再给你总复习的时候再讲一下，好吧。像场景使用啊场景使用的话嗯。比如nty。nty它里边可以onhi也可以。就是那里边拜的八ffer，就跟文件没有关系。因为那偏偏骚给的偏网络多一些。

为什么现在不要给你总结，因为差东西呢。然后两个都可以，然后最终其实他更优胜一些。啊，讲到netty时候我可以带你看到原码。你即便开备了一个unhi。

但是它net底层也是要把那个那个耳拷贝拷贝到这个ophi里边去。然后像卡夫卡啊，然后它的log它的log是用的MMAP麦。啊文件的这个方式。然后在这儿顶多呃场景的话，其实看这个没有那么太细的场景。

这本来想后边跟你说的，非得要问，我先给你写，但是我不知道我网络通信啊，我点没讲，我不知道能理解啊。我告诉你一个最值钱的一个答法，这是在面试面试的时候，你要必须会答的一个问题。首先你听了这样的一个。

就是你如果学过记组，有了像样这样的基础知识，其实你可以给出一个结论，这个结论就是这个计算机。就是我们的操作系统啊OS。没有。绝对的数据可靠性。最少他肯定丢一条啊，你刚刚写。

然后那个那个数据肯能肯定丢一条，最少最少多少他肯能肯定丢一条，就绝没有绝对可靠性。而且你要知道了，就是他为了他就是为什么开辟。为什么要就为什么要设计配置catch。来回说这事啊。

为什么说得pay着 cash，因为就是减少。减少IO的调用，就是是减少硬件的调用，减少硬件。无论网卡还是这个磁板，就减少硬件的IO的真正那个那个那个调用，他们是想提速。啊，优先。使用内存。很简单，这个。

比如说你我就想对着我这个文件，这文件就就几百个字符，先改这个后改那个后频的改拼的频频频的改，你如果能改一下就存下来。因为他连4K都没到。这个时候如果隔一个时间窗的给你往往往下搞的话。

其实你中间操作变化的结果给你写写下去了，能理白什么意思吧？啊，就是优先使用内存。😊，😀H。如果你追求性能的话，那这个时候其实你是要在可靠性、一致性和性能之间做权衡了。说这些东西是一个基本常识。

最终你要说出哪一句话，注意听做哎，没错，你看卡牌也丢出去，绕WQ丢出去，只要使用操作系统，使用IO就绝对会丢数据，你要性能高就丢的越越多，但是这时候怎么办？你即便你注意听，这是你要换位思考。

再往上升高一级别，再往上升高一级别。即便你想要可靠性。调成。最慢的。方式就是没写一条是flash没条flash。但是。单点。问题会让你的性能。损耗。一毛钱收益都没有。这句话能听明白来，说边一。

就是你要辛辛苦苦，你学了所有的机计算机组成知识了，你也知道了该调整哪个级别了。但是你辛辛苦苦的把所有性能损耗就全搭进去了。但是单点故障让你的一收益一毛钱收益都没有，这机子整个全挂挂没了炸成灰了。

所以尤其在现在的封水情况当中啊，都会做一件事情。😊，就是什么呀？主存复制。准备。A3。我不会。🤧这就是为什么？尤其你比如说。为什么卡夫卡他要让你去做一个就是卡夫卡和ES测试啊，就先给你说到的卡夫卡。

你举个例子，或者ES测试，它里边都得有一个这个副本的概念。但是这个副本你知道这个我还没讲呢，这个副本肯定通通过哪儿得到这个副本的呀，socket。sorry的是什么？他也是IO。

但是没有办法综合考虑多机多副本性能调到差不多的一个合适点上就OK了。那么在副本的时候又分为同步和异步。一步的区别，巴拉巴这个支识点就很多了。就是架构师为什么之前你的知识体系得堆堆堆堆堆堆掉。

你知道所有的所有的知识点之后，往那一往那一扔，我把所有的细节都想一想，可能出现的问题都想一想，我得调一个我认可的我的需求可以接受的一个合适的一个点上。能有吧嗯。Yeah。好吧，周这课讲那么多，可不可以？

😊，啊，回去好好看啊，这个课没天着讲，就是给你一周的时间回去可以复习一下。啊。这视频过个两三遍吧，行吧嗯。好，下课了。

系列 3：P185：【IO／NIO】 TCPIP - 马士兵_马小雨 - BV1zh411H79h

这先其实还是老掉牙的那些工具命令，我先把工具命令给你梳梳理一下。

一个命令是LOSOF这个命令是可以看到我们的某一个进程，它里面的文件描述符是否已经有了。那么就网络这一环节的话。

一会儿我们去看它通过它什么时候你才可以看看得到啊这个一个关代表网络scu的通信的一个文件描入符。就是这文件描符什么是候有的。还有还有几次课，嗯，应该下节课或者再顶顶多顶尖都有两节课。

还有一个是n state。杠NATP这个是他他主要是我我想叫教你用这个命令来看内核里边的scket的这个建立的过程。然后这个一会儿给你展示，他们两者其实是一个建职对的一个关系。

就是一个你可以只有scket，但是没有文件描符。那什么时候有的这个过程它的依赖关系，就是内核和用用空间的程序的一一个依赖关系。还有一个是TCP。这样这是一个抓取网络通讯数据包的。嗯，在这个过程当中。

你去演示一下其他的门令随讲随用吧。这是一会儿要用他的命令。另外一个程序的一个范本。

换门我就用这儿给你演示了啊。这是一个升级一点的一个代码，就是socketIO的这是1个BLO的方式。B，然后多线程的方式。你听了我上节课就知道资料都都在哪去领取了。然后这个这周吧。

应该是他们更新完VIP页面，应该有地址，那个资料可以下载。往下捋这个sockcket的IO是BO的一种方式。然后上边会有一些关于在使用网络通信的时候，sockcket的时候会有哪些参数？啊。

比如说keep alive心跳，那这个是不是它是是否代表长链接，还是说为 false的时候，它就不是长链接这一个有一个语义的纠正。因为这是面试的时候会问的。然后像断开的。

不是这个是否优先发一个子符量发过去试探一下啊，然后receive buffer就是在使用一些指令的时候，我们可以看到一个。

nettter state杠NATP你会看到有一些receiveQ和Q。啊，那这里面这一个Q代表什么意思？如果用户给给到这个reive buffer跟那个Q有什么关系？

还有reuse address是否重新地址，然后send buffersendq，然后还有一个是断开连接的速度。再往下是一个。用客户端读取的时候，在我们读取数据的时候，我们说在必要下是一直阻塞的。

但是你可以加一个超时。也就是我只想读你3秒3秒。如果不发数据的话，我就开始抛异常做做其他的处理。然后还有就是一个比较重要的一个参数，一个no delay，这是一个TCB上的一个优化算法。

也就是在发送数据比较少的时候，它可以利用缓冲的一个概念。但是你开启不开启它对于你的业务的数据量的大小和规模和特征是有关系的。

还有一个常配的配置就是这个backlogbacklog就是当我的一个服务起来之后，如果有很多连接过来了。但是我线程不够了，资源不够了，我不分配了。那这时候排队的我还认为你几个人在那少的。一会我释放了。

可以把立刻就处理你剩下的超过这个的，我就开始全拒绝了。啊，等等这些这些参数到会候给你演示出来。然后剩下的主逻辑啊，主主逻辑就是在主方法当前现程当中，在当前当中准备一个server。

这个server起来之后，我让他绑定了9090端口，然后backlog现在是V2V2，也就是说这个分配剩余的等待着就是不不处理的只能有两个啊，就是不分配文件标符有两个。然后。剩下的这个参数一会再说啊。

现在那个t out都是为0上面的，无论你的这个接收的这个接收客户端等待，那个就accept的是为零的，还有你的客户端读取数据的都为0，就一直场永永久阻塞。当有了一个so在主线程起来之后，然后开始死循环。

死循环里边，然后在这注意下边这个循环循环，这有一个注意点啊，我掉了一个sean点 in点read，这是一个分水岭，这个代码要强烈一点，这是一个分水岭。这个分有什么意思？上面我只是得到了server。

现在注意听了，上面我只得到了serverser有了之后，其实我拿server想调accept，但是在调accept接收客户端之前，无论你是BLNL。

但是在这个在他之前我被一个read通过用户想输入一个东西，这个被阻塞住了，也就是这这条代码肯定不不会不会触发。那么就在这个被阻塞住，但是这个程序前面已经有了的状态，如果别人咣灯咣灯连起来。

能不能和我这台服器进行连接，就是三次握手能不能走通和TCB什么关系？也就是内核里边会不会有什么事发生，也就是什么什么是锁谓连接。之前只是跟你说过，连接就是为了开辟双方资源。那内核里是不是要开辟资源。

有没有所谓的队列，可以在没有接收客户端的情况下，你客户端就已经可以发数据了。接收之后可以连数据都给给给你处理清楚了。能流解白达什么意思吧？哎，这个这个一会儿要注意这个这这行代码的一个特殊性啊。

这是一个分水岭。也就是我拍了回来之后，他才走这一步。那可能别人连连接过来了，然后也发了数据，然后之前没有处理，这时候还还来得及去处理。有了客户端之后也会设置一些参数。

这个参数一会我会在lin客户端给你去调，然后不同的每次启动调一个参数，然后找一下感觉，然后用TCB多包来抓一下这个特征。然后现在的模型是当你得到了一个客户端，因为是阻塞的嘛，就是肯定会等到一个客户端。

得到一个客户端之后，我下边是抛出了一个线程。这个线程里边拉的表达式写了一个逻辑代码，它软方法，这里面就是从客户端这个链接里边拿到输入流读取东西。然后。把你读到的可能性啊，读到了多少内容是啥。

给你本地打印一下，然后为零的话，就continue继续继续等待这个客户端的这个这个发来的信息。如果读到负一的那什么时候负一，客户端那边动开的时候，可能会出现负一了，那直接跳出这个循环。

这个线上就可以结束了，这star起来了好吧，这段代码其实如果你之前听过公开课呀，或者看看过前面的东西，这这个逻辑应该都没问题。那么现在如果第一次听这段的。这个课的这个逻辑能ge到同学稍不一。

这是一个服务端代码，除了一个服务端代码，还有一个是客户端代码。在客户端代码当中比较简单，客户端代码就是用一个scket，然后呢我要连啊某一台机器，然后顿号是刚才那个那个那个服务端等号。

得到一个cl得到cle之后呢，我可以设置它的send bufferffer，就是发送这个缓冲区是20个字节，然后这个no delay是te还是 falsese，一会我调这个参数给你演示。

然后最终我是要拿从它身上拿到一个输出流。但是这个注意是一个ult stream一个基本的输出流。然后呢，我开启了一个s点 in，然后拿到一个输入流，然后包装成一个reader，然后写一个死循环。

一直在等待着我就每循环一次等待等待着我用户敲一些字母，敲完的内容如果为空的话，把它转成字节数组。因为上边这个和服梯建立这个s连接，一个字节，一个字节的去rite。但是这里面注意了没有flash。

这里面是没有flash的啊，这是一个客户端的一个我写了这么一个看上去是有争议的这么一个写法。就是你不是说输出流由都得掉flash，不不叫flash不输出嘛？一会我们来演示看一眼这个效果。好吧。

这一个客户端，客户端代码也能看东西来s微一。

好，那退回到我们的这个窗口，我会把一系列之前可能会讲的东西再给你梳理一遍，总结一遍。首先我们先来。找到服务端，服务端就是我这个sockcket的IO properties点java打开它。

这个就是刚才我写的这个这个代码啊，在这只不过把刚才那个地址绑定给去了，就变成一个逗号了。一样，也是也是这单要要起1个990。其他的我们来看一眼参数的默认值，现在我给的默认值啊。

验证一下我的backlog是两个，可以登两个。然后呢。一系列的Q关关闭了。然后第一个手手手手字节发送关闭了。然后全部重用关闭了，但是receive的这个接收的8分20，发送的8分是20，这个我更新了。

然后立刻关闭，我开启了。因为一会儿我会ctl C结束这个结束之后呢，我希望把这个9099090立刻释放掉，不在这堆积。然后no delay是为fse。

就no no no delay这个为 falsese是什么意思？就多说一句，就是如果你它默认就是为fse。啊，这个no delay就是不优化，不优化为fose就是负责症优化优化什么意思？

如果你发的数据量比较小的话，它会积攒一下，然后充分的利用你那个缓冲发更多的东西。但是如果你为处的话，你有多少他发多少。啊，就发的被这个在缓冲上使用的时候，它不会突破你那个上面的一个缓冲区。

一会儿演示出来就看到效果了。好，服务端先给他简单解演演示一下java C给它。编译一下。编译成功之后，然后我再用java。调起这个服务端。🤧我先拍了一个命啊，一会儿我回头把它跑起来。

然后用另外一个窗口也是note01。我们先来看一眼网络状态，net state杠NATP。现在里边你能看到的都是一些什么22、25、22、22、25这样一个登口号啊。然后在另外一台，这是一啊。

一还没有起，我告诉你到这么去起。在二这台服务器上，我要起一个。客户端啊起一个客户端。这个客户端，我们先来看一眼它里边的属性。看看刚才我有没有乱改啊。那这里面我要连的是10。11，就前面那台。

然后9090和它建立连接，连接有了之后。这个发送的缓冲区是20，然后呢优化不优化这事为fose就是默认也是优化的方式来发送数据。然后呢，首字节快速发送也也关闭了，然后得到输入流，下面逻辑是一样的。

OK是一个扣分好，也是java C吧，然后编译我们的sockit clientjava编译成功之后，java调起socket client。这两个一会儿服务端先起，然后我们来追踪它的所有的状态。

还有一个我在开启一个窗口，是打开TCB监控TCBdump杠NN杠。哎，监控ET20这个接口，然后端口号是9090。好吧，开这个这个窗口上开启了监听抓取数据包，然后我们一个个来起。

先把服务端这个java的服务端程序跑起来回车好了，它已经提起来了，用到了909的这个端口号。那么通过网络连接这块，我们来看lets由前面什么都没有，没有相关的东西。

这出现了一个对于909的leasen状态，这是第一个知识点，服务端啊，服务端会开启listen状态申请这个端口号。

通过你给那个顿号，它会监建立一个监听。未来所有的客户端通信的时候分成两两类两个阶段。进来连接的时候，就是三次握手的时候走listen。找到他找到这找找找到这个进程，但是监听这个三次部手之后。

他肯定会抛出现城或者是。分配到文文件描符交给某一个县场，那是后后边就是在在在发送数据的时候，是走另外的一个环节。我们先来看，先记住了，服务端的第一步是要先监听1个9090有了这个监听之后。

那么你的客户端就可以连进来了。但是先看抓包包这边是任何事情没有发生的。因为你只是本地被动的被动的去要监听了别人还没数据包没有发过来。那么除了可以看到有一个9090。

然后listen状态还要把别的命令再使用一下GPS得到我们那个服务端的静态电号是7932用LSOF这个之前已经用了很多了杠7看一眼7932，它的文件描述服务分配情况回车。

你会看到这里面分配了一个文件描述服5他在做一件什么事情，就是list状态。因为现在没有客户端连接，所以没有6没有7到这个环节都就是一个初始环节，我刚起了一个服务，就刚起了一个服务，你会看。

哦他有一个文件面符占了监听，然后用另外一个命令也可以看到这个所谓scket的这个状态。离森，然后呢，TCB也没抓到任何东西，因为他是刚刚起来，这些都能听懂同学同学来说波一，没问题吧。

我讲稍微的讲慢一点啊，就是咱们以前我讲过很多遍，类似的，你听过就听过了。咱们主要是因为有很多新报名的学员，我得把这个整个给你串一遍，也保证咱们这个系统L流可程的完整性。这是第一个大环节启动了。

该监控该该看得看了。那这时候来完成啊back是啥，我我马上给你演示啊，注意看现在现在如果我一旦启动了我的客户端，我的客户端里边逻辑代码是要和它建立连接的对不对？那这时候能不能建立连接呢？来注意看啊。

一定要记住了，我我再强调一点一定要强调一点，我就用给你演示了，在我刚才那个代码里边，我刚才是不是打印server up use了9090，也就是这行代码被执行了。但是一旦进到这个循环。

它一踹这一块里边光当是sstem点 in点read等待着用户的输入，也就是其实在我的主服务这这是在等着用户输入呢？如果我这不按任何的操作。

这行代码就会在这死死死很久下边代码是逻辑根本是跑不起来的那也就是说下边的这根本就没有到accept在这那我这边客户端如果起的话，能不能和服务端有一个所谓的建立。

一个过程。大家伙儿可以刷一下啊参与这个这个思考的过程。能理解我想表达什么意思吧？啊，就能不能建立上这个链接。😡，好。竞猜结束啊，然后注意看看啊，注意看看看看看细节，加低回车。回车之后。

那么这个程序它首先没有说8唧一回车，包包括这种错误之后，这个程序结束了，又回到这个这个这个这个等待输入这。所以这个程序现在是运行着的。第一，程序已经跑起来了。第二，看抓包这，你抓到了三次握手。

是不是抓到了三次握手，是我们的1012那台子一个随机定的号，对我90。哎，我要跟你建立连接，握了一次手，90有轮还给人回了。回了1个ACK，行行行，然后呢，这个12的台的随准号1990回了一句。行。

我也我也知道了。咱在俩可以愉快了。但是注意听啊大家注意听。😊，看前面的监控，我们依次来获取。第一个先看的是nancy杠NATB走，你会发现在这个网络连接状态里边，曾经对9090啊。

只有一个服务端自己的一个监听。然后呢，我服务端也没有执行accept。但是客户端连过来之后，注意在内核状态当中，你看到了一个socket。是9690和12的47513，它建立起连接。

但是这个scket的有分配给谁去使用的吗？没有被谁接收。但是内核里边已经有它了，这个能看懂同学来刷边一就有它了。但是在内核太里边有它了，你的程序还没有接受它，不只是有它了。

如注意看前面是不是还有receive这个这个scket里边有没有收到的数据包和发送的这个这个数据包在这堆积，对不对？然后我这边哎我给你所建立所有连接了，即便你不要我，但是我也悄悄的给你发点发点东西。

我发四四个一加记回车，然后你会看到哎这个后续的书，这个发送数据包，哎，客户端服务端还能有好的交互，还有确认ACK。然后再来主要看那个抓取。网络这，即便这个set的没有谁去。没有分配给谁去使用的。

没有文件面是对应的。但是前面会出现一个4个，已经就是有4个字节，已经被内核收到了。但是你想一想，我们代码里边进城式外卖还还没有接收这个ser链接，但是内核里边已经完成了资源的一个初步的一个使用。

这个就是我常说的，什么叫做TCP协议是面向连接的，走完三次握手。刚才是不是走完三次握手了，双方是不是要开辟资源，是不是有资源的开辟，有缓冲区，对不对？然后这时候即便你程序不要我。

但是我也在内核里边会有资源去帮你接收或者等待等等的。那么这就是什么叫做连接？连接不是物理的。双方通过三次握手，开辟了资源，可以为对方提供服务了。那这个连接就已经有了，他是看不见摸不着的。

但是靠资源来代表的，听懂同学来说波666。先记住这个级别，就是内核里边是干点事的，对不对？啊，然后但是这时候再来找我说了socky，待会给你解释scket的这个资源组这个事情，它必须是4元组的。

然后再来看一个东西，它其实还是一个建职段的LSOF杠P刚才这个进程的ID号是java listen这个是。7932对不对？哎，7932。你会发现内核里边有这个set的，还没有被分配。

然后在我java的程序里边，文件描说还是指到5V。listen状态。也就是也就是说程序其实不是通过scket要使用sockcket的那程序其实在等一个东西，等一个文件描符。但是这个excel没掉。

所以它没有反回文文件描符。

明白我什么意思吧？那这时候其实我只要让我的代码这个s点 in点read这，我编击一回车输入点东西，让它跳过这个阻塞，那accept就一定会执行。一执行其实就为了分配一个文件标符，下边一定要注意看。

看完我摁一下回车，加G摁回车c port47513，代表我程序收到它了。然后呢，你看啊不止说我接收到它了。后续那个内核里边缓冲的数据，我四个字节我也读到了，这是我程序代码可以打印出来的。

能能理解吧？那关键看哪，关键还要看这这段这这一段的监控，先看那NATP你没看到刚才的那个这段ser连接没有被分配给谁，但现在已经被分配给7932了。这个联通的状态已经分分类给他了。

且再看LOSOLP6这个accept6已经得到了文键标符。到这儿都能看出来说个一。要总结一下啊总结一下，其实就是我常说的第一个问题。

对。TCB是什么？TCB的第一个知识点，它是面向连接的。可靠的。传输协议。这都已经被我讲的烂大街了，谁都知道。但是今天我让你实质的去看到这一过程了。那么什么叫做面向连接？什么叫做可靠传输协议？

那么连接首先是它是不是物理的啊，不是真正的说要建一根网线。这个连接的过程是要通过三次握手。三次握手我帮你抓包也抓到了，关键是三次握手之后啊，这个双方的内核级要开辟资源。

这个资源其实说白了就是我们所谓的那个连接。曾经我画的图，就是如果你有一个客户端。有一个so端。然后三次我手势我给你发一个数据包，这个数据包里边的那个状态位是SYNone和你握手。

然后回送的数据包是SN加ACKacled。然后你再给我回送1个ACK收到了刚才我给你回那个确认ACK那么这个图三次握手谁都会换。但是你听过我的课，跟别人不一样。你要告诉对方之后三次握手之后。

双方开辟了资源。Okay。这个资源代表了所谓的连接，就是客户端服务端都会去开辟相应资源。Yeah。Thank。这是。嗯。对。不我我我这个我还是强调一点啊，因为这有有些知识我之前是讲过的。

但是我今天细化一点。这个别烦啊，我争取把这个课讲的这个成体系一点，好吧，就是留成一个绝对的一个模板课。未来新人老人复习，看这个这节课就没有盲点，好吧。好吧。

这开辟资源其实中间的这个呃这这个不应该虚不应该用虚线，因为于实现中间的这个所谓三次握手，这是一一瞬间的事儿。这这都是虚无的，关键这个资源要为对方提供服务，好吧。Yeah。下个戴耳机啊。好了。

那么这是开始说的第一个三次握手啊，内核第一要开辟资源，就完成了这个所谓的这个面向连接这个过程。可靠承输协议就是靠的这个确认确认机制，acknowledgeacledge。好吧，这是考成人协议。

那么除了这一点，另外一点，现下除了TCP，你另外需要支持一个知识点就是socket。刚才我给你演示的时候，还刻意跟你说了一下这个socket的过程。这个这个这个语义socket的是什么？

我再给你精准的定一下。socket是什么？socket是一个4元组，记住了，sockcket是一个4元组。Yeah。你们知道资源组代表什么意思吗？思源组代表的意思是你客户端的IP地址。

加上你客户端的端口号，然后对应到你服务端的IP地址，然后和服务端的端口号。必须是4个啊必须是4个。而且这是一个内核级的啊，它也是在内核级完成的。

就是因为在这个现在s的是在你TCP传输控制层TCPtrans，然后clpro这个pro这个还是pro这个proty就是传输控制协议啊。他依然也是内盒机的。因为刚才在代码当中啊。

就是你这个握手的过程在那根完成，即便你不掉，即便你。不调用。accept其实你的内核当中也会根据上面的资源啊，然后还有接收队列等等去去去完成这个建立和就是这个这个连接的建立和数据的接收的过程。好吧。

那么在这儿继续向下扩展。既然它是资源组，那么怎么去理解它？啊，孙子怎么去理解他？一般会有一个常用的一个面试题。这个面其是什么意思？也就是在我的网络拓普情况下是这样的，你有一个客户端有一个矩形吧。对。

因为一个客户端。然后呢，会有一个服务端。然后客户端的IP地址是AIP。然后服务端的IP地址是XIP那IP地址是在互联网当中取一个什么目的？它是要定位你的主机。啊。

IP地址是为了群描述一台主机的一个操作系统的那这一个主机里边它。除了IP之外，还有一些进程，真正想通信的是两个进程想通信。那两个进程想通信的话，那IP只能代表主机主机里有很多的进程。

你怎么能找到那个真正想通信的进程呢？所以这里面还有一个端口号的概念，就是一台主机里边每一个想参与网络的，都会有一个端口号，对吧？那基于这个有IP有端口号，这个资源组就这样去描述啊？如果你有一个服务。

它的IP就是叉。IP然后它的端口号是Xport呃，Xport起了这么一个进程。那这一个serv端里边，它的IP地址是XIP。请问它的进程，请它的进程可不可以有export或者外port？这个抽象点。

比如说80端口号和1个9090，可不可以起两个服务，这是肯定的。一台服务器是可以启动很多的服务进进进进行一个lea森，对吧？就是你可以启动一个topom再启动一个ex都可以，你你想起几起几个。

但是这个口号是不能冲突的啊，不能就是leaen状态是不能冲突的啊，listn状态这个号的数量就是665535个，这是服务端啊，这是服务端，然后再来听你的客户端，客户端里边我的IP是AIP。

然后如果我启动了一个程序，这个程序啊，如果想参与网络通信去访问某一其中的每台服务，它会随机申请一个登录号。比如说就是一个C part。这个Cport的比如说123。那如果这里边起了一个程序。

它随身申请到了一个顿号是123。然后他想建立连接的，比如就想和这个80建里连接。那这时候其实他们这个连接有了之后会得到一个资源组，这个资源组是谁？是AIP。然后和本机的Cport。

对应到了我们这边的X负端XIP和它的Xport。这是一个4元组，到这步能听回来。稍边一。对。然后我再多说一句啊，最近有一个有一个学生追着我问了好几天这个问题就是也有一个不太懂的地方。

如果面试工问你一个客户端和一个服务端建立三通过三4五建立建立连接之后，服务端需不需要为这个客户端，除了他自己的监听80之外，再分配一个随机端口号，需不需要？就是服务端接入客户端之后。是否需要物位？

为cl的连接。分配一个。需要还是不需要？就是注意听是不需要的。现在现在咱们也有人犯蒙啊，是不需要的。你来看这个过程，你的服务端有1个80的端口号是叫80，对不对？你的客户端和它连接进来之后，我说了。

双方开辟资源，这个资源里边其实包含了这个条目，这个条目是在你客户端的内核里边有这么一个对应关系，一个记录有了。那你服务端里边也有这么一个记录，在那核已经有了。

而且记这个记录线下还会开辟内存缓冲区receive或者s bufferffer里边都会开开辟 bufferffer，其实这时候你会发现，无论站在任何的一方，只要我这个记录，有这个记录是一个唯一标识。

我就没有必要再给他再拼上一个顿口号，再拼成一个最端端号。比如说这个333服务端没必要再开辟这个口号。那，其实晚下我给你再演示，你就知道了。那现在是一个客户端，一个客户端的一个连接过来了。

那么服务端我先告诉你是不需要开闭的，就是这80为了有这个连接就可以了。那么这个同样的一个客户端可不可以开启很多的线程连一台服务器？就是一个主机里的一个进程，申请很多的端口号。建立很多的连接。

对一台服器是可以的，就像你的。😊，你的一个windows上的一个浏览器，开很多的标签，连百度一样，对不对？那这时候其实你会发现有一个地方是不一样的。就是你会建立很多的锁的连接。在建个连接当中。

你的服务器的IP地址和逗号一成不变，你的主机自己的IP一成不变。但是你每一个端口号是唯一区别的，就是CB。ACBX嘛CBA。就这个口号这个位置会会会会变化。那这时候你会发现在4源组里边。

其实最少最少只要有一个维度能够区分他们三者。那这三条连接是可以被明确区分的。这三条连接，无论是出现在了客户端。你说数据包来了，它是属于某一个这个连接里边的，是不是可以正确的交给你某个线程或某个进程。

服务端是不是也不需要再开辟一个数据口号了。因为每一个4源组，就是一个数据包里边是包含IP原IP目标IP的数据包里是包含原号和目目标口号的，只要这数据包带着其中的某一个四源组过来了。

根据这个四源组的映射关系，就可以交给相应的线程和进程。所以这时候就不会去开辟。就是服务端就不需要再开辟这个口号了。为什么是6535，他就用了两个字节嘛？好吧，就现在到现在这个这到就现在到这个环节。

服务端不需要开辟动口号。什么是扫给的是4元组，4元组可以让连接变得很清晰。唯一这件事情能听懂同学来说边一。😡，对吧哎不着急不着急啊不着急。😡，如果啊如果在你的客户端当中，客户端当中，对着这一台服务器啊。

对这一台服务器，我已经建立完了65535个端口号的这样的一个连接，就6万多条连接过去了，就是这一台服务器。但是这里边还有另外一台服务器。那请问我这一个程序。已已经申请完6万多个动号了。

那么访问外这个动号还能不能再进来连接，就这两台服务器还能不能？或者从另外一台阿里的服务器，或者那个淘宝的，还能不能再开辟66566万多个连接。可以还是不可以。那。

我告诉你是可以的是可以的这就是一定要记住它是4元组这件事情。这就是sy的定义啊。为什么就是这个事情上要研究出一个sock给来？那其实如果你再呃就是还是得这个这个这个这个这个客户端这个IP地址，然后呢。

你再申请重复的一套的这样的一个端口号，换言之是长成一个什么样子啊？比如比如说上面这个经建立完了，然后呢，你再来一趟，但是这时候注意了，后边连的是虽然是XIPD台服务器和IP地址。

但是它的端口号会变成Y端口号。能找到感觉吧，是不是多这个测的服务的那侧段号换了，换了另外一个服务器了。😡，就是可能来自于客户端相同的端口号，但是他却访问的是不同的服务端端口号。那这时候请问这6条记录。

每一条是不是都是唯一的？是不是都是唯一的，是唯一的。那么这个记录如果交给两端的话，如果帮当来了一个数据包，这个数据包里边的4个维度。

它的原IP目标IP原端口I那个目标端口是不是就可以找到相应的对应的那个自己那个scket就能找到自己自己那个条目了，是不是这个它里边带的那个data那个数据可以放到那个条目对应的那个缓冲区里了。

到这步可以听筒学来稍边一。就是说不在不关闭的情况下，你一个主机里的操作系统的一个程序先把持住6万个连接。对着这个Xport的这这个这个服务进程。在不关闭的情况下。

你还可以再申请6万个登口号去同时对外进行连接。可以开启将近10万多个。为什么？因为他这个条目是唯一的，这点一定要记住了一定要记住了。😡，一台服务器可以保持和653以上的客客户机，保持长链接通讯吗？

一台服务器可以保持和可以啊，一哎你这这这这这这个这个问题正好正正不科学，怎么不科学了，很科学。我讲完下边你明白了。首先先把第一个消消这个问题。

一台服务器可不可以保持和65以就是6万多个以上的客户端保持长链接可以的，可基本上可以调到百万连接以上都可以，就连接，咱俩连上百万连接内核开闭所有的sky的缓冲率都开好了，只要内存够，这些都不是问题。

明白吧？啊，就是因为你服务端不需要为每一个单独再分配一个C端广号。因为只要我们的四源组是唯一就可以了。好吧，UDB的事待会儿再说。😡，接下来有一步，哎，先跟着我的思路走啊，先跟着我的思路走。

接下来这步才最值钱。根据我刚才的演示，在我代码没有就read的这个阻塞的时候，没有走到exac的时候，别人是不是可以连到这台服务器，完成内核及四层的传输共制层的三字握手开辟资源。

只不过你没有你发现它四源组有啊，但是它没有分配给某个进程，对不对？也就是某个进程，某个县程还没有accept。😡。

也就是那个时候又用L这个LSOFU看到也没有对应的文件描符。那换言之是什么意思？其实最终啊如果一个就是你的服务端的一个进程，如果内核虽然完成成4元组，但是你的程序如果想访问使用这个socket的时候。

它会为它开辟1个FD一假设一个F3吧，FD3，如果再想是接受再accept另外一个sockcket，那么这个时候他会为它在系统层面分配1个FD4。然后这个时候再想接住另外一个什么时候想接受。

你就再再去接受它会分为一个FD5。那么这个时候你要记住了，连接两点的连接这个scket前面这个叫set4元组是唯一的。然后你的这个进程里边对不同的scket他们的分配的文件描符是唯一的。

那这时候其实这个文件描符是你程序内部在使用流。

时候用的这个代表。就抽象对他的一个代表映射关系能听懂白来说个一。你另外一个进程，这个外泡的是不是另外就是9090了它。😡，这个进程里边可以有FD3代表这个链接，因为这两个进程已经隔离了。就资源这块。

你自个儿在脑子里边一定要把它想的特别清楚。其实说白了，这就是一个游戏，只要路标通信全部唯一正确，那数据包就不会发不就不会发乱。进城内的FD唯一嘛，肯定是唯一的。😡，如果是同一个进程呢，就线性往上增呗。

就一直三4567891112344521到到很大一直往上增。只要你能给我开辟一起。比如这个这个AIP来了6万多个连接，BIP又来了6万多个连接CIP又来了6万多个连接，这就是三六十8万。

那你这个前面FD的话就会有18万个。到这儿能听懂同学来刷波一，就是如果站在一个就是站在一个服务，80这个这个角，80端口来说，它可以接入多少个客户端，那就看IP和端口号，只要这边没有重复的。啊。

你有你有1万个IP，每个IP里边有6万个连接，那是1万乘6万，这么多个连接都可以建立成功。只要你内存线有资源资源够，那个参数只要配配够了就可以了。好吧，先找到对应关系。

所以其实到嗯你这个服务端是有这FDFD的，其实你客户端那边也是客户端也是会得到相当FFD，只不过两这个这个都是两个物理机的。这边你可能三那边可能是7。但是无关无关这个怎要最重要的你要知道。

当accept之后是会拿到内核sckit的抽象那个代表FD在java里边FD又被包成了对象sockit。

啊，这个内核参数是可以改的，可以改啊，可以可以调大一些的。ser soockcket和socket是不是两码事，的确是两码事啊，的确两码事。s socket是你建立listen状态的一个。

它他只关心别人和我建立三次word之后，我掉一下accept，就会把那个三次 word的事拿过来，然后把就是最终是要so soocket是只调accept。但是sockcket。

你得到这个scket这个对象要干什么事情，它是要最终要去read和right，就是读写。

只拿到输入流和拿到输出流。啊，是为了完成这个这个建连接传输这件事情，服务端的80和9090的LD3同名不会冲突吗？我说了，你服务端这个时候如果是在两个进程里边，这个FD不怕啊。

这个这下面应该变成345啊。因为它系统级的进程的隔离机是这个进程是隔离级的。而且你在学过docker的时候，你也知道，其实docker里边还有一个命名空间的一个隔离啊。不管怎么样，如果两个进程。

它内部的文件描符都有3都你你比如说最基本的随便一个进程都有012零是标准输入，一是标准输出，二是包错输出。那平常报端口号被占用是啥情况？我一会给你举给你写出来啊，就是在如果如果是在服务端。

你在服务端当你起服务的时候，会报你刚才描述的端口号被占用，是为什么？因为服务端其实要起的是ser socket。ser soet它是一个什么特征？就类似于0。0。0。0，然后0，然后和我本机的这个0。

0。0。0的。比如说你是80动口号，如果你的第一个服务启动的时候，假设。在没有任何的约束的情况下，他可以接受。任何IP地址的任何端网号，通过我本地的任何IP和我的80来通信，这就是一个listen状态。

对吧你起了一个服务了，当你如果想起第二个服务的，知道服务器，他得先有listson，对不对？他得先监听起来。那你监听的时候，如果别人也使用80，那这个时候在你内核里边。

这两条这两个条目listen的条目能区分出来吗？未来如果光机真来了一个数据包是这这个这个数据包，前面这些个都他都他他都填好了，但是他最终都都就最终不断号是80。

你说这数据包是给他还是给他是不是区分不出来了。这很简单的一个什么呀？唯一性的一个问题，对不对？这个能听出来说个一。这个时候如果你是先启动一个服务，他占了80了，别人再提就就不行了。😡。

这就是我刚才讲的服务端leason状态断个号起的服务就6535个。

是。对吧因为你可以看刚才我们这个n state。

，这里面listen你比如说SSD99994的一个进程，它是listen状态，它是不是本地的任何IP就是访你从可以通过本机的任意IP地址进来。你的数据包里边是我本机的任意IP地址。但是我多号是2事。

你得写出来，你可以是来自于互联网的任何的IP地址，任何多号。但是这时候如果994这个SZ起了起了的话，你能再起1个998的1个SG的一个进程吗？变成listen状态是起不来的。

因为这个20他如果再起一个涨了涨leaen22的话，别人已经被占了。如果再让他启动成功，来一个数据包22，目标况22就不知道怎么分了。😡，没错，可以认为只要sockcket的4元组不同。

就可以创建一个连接。yes就这意思。现在能ge到这个点了吧。这就是我为什么强调的？就是你你之前跟别人学什么叫sockcket叫插销啊，叫套节字，叫这叫那的。我给你区限点scket就四元组。

这是在计算机软件工程学当中，通过这个四元组可以代表唯一性。因为你的连接就是一个唯一的。

只要他满足唯一性，这个连接就能够被创建出来。这个这个这个通讯过程就可以被允许。唯一性这个词很重要，现在能get到能听懂同学来说波一吧，没问题了吧。记住了，服务端一个客户端来了之后。

服务端是不需要给他开辟一个段号的。服务端就我这我是这80服务，那我的所有的和我建立的连接，任不无论10个人百个人，1万个人，在我这一侧的段号就是80。我这这我的一测就是80，你那边随便变，你只要客户端。

你客户端，你你IP地址多少里随便变，只要咱俩这个最终这个条目是唯一的这个就能建立起来，我就能跟很多人去通信。因为只要数据包来户交互的时候，跟着这个条目就能进到对应的内存的缓冲区。

然后你程序里边又有一个文件面符代表了每一个那你程序如果读FD3就代表的是在那份里找他的缓冲区里边有没有数据。如果程序想读FD4的时候，就看他这个条目的那个缓冲区里边有没有数据。

拿过来就有就有没有就在那阻塞着，或者后边的NL没有是负1。对吧我再给你画的清楚一点啊，就是如果这是一个application程序，程序里边它需要持有一个东东，这个东东是啥？就是文件描述符啊。

一个小索引FD比如说FD8，这FD8程序里边，如这个程序如果想动这ID8想独特的东西。这FD8代表什么意思？它是抽象的，它指向了你内核里边。在你内核里边啊内核这这是我们的内核。

在那个盒里边你会有一个sockcket这个scket，比如说客户端是这个C。100的IP地址，然后这个。123这面一个端口号。然后到我本地的servword的。这个1这个200GIP地址。

假设假设然后1个80的1个多稿号。如果FD8代表的是是这个，就是他自己肯定是这个abplication，他的自己的是你这个例子多少是80。如果来了一个客户端，和它建立连接之后，有这个映射关系了。

那么这个映射关系条目下边它还会挂一个东西，挂两个东西，我就用统一一个来表示了，就是一个buffer。缓中区。啊，有一个buer。那如果再来一个客户外接再来一个客户端，就是这个你可以想成是另外一一个。

我就直接用一个客户端plan。这个客户端如果从互联网连过来之后，肯定走内核，先走权输控制层。然后这边这个内核就会为他开辟一个8ffer，然后为为为他建立一个sockcket那这个客户端里边的地址是什么？

它的地址是100，它的随机端号号是123，然后他的IP地址是200，然后它断号是80，如果再来一个客户端，这个客户端有可能是从一台主机，有可能另外一台主机，它的IP地址肯定换了，换成换成这个300了。

但是他有可能这台主机也又6过3个号，这个客户端是不是也有可能随这个随机性呢123这个这个这个端口号，然后他走完三次握手之后，注意这条线是要先完成三次握手。三次握手就是一个瞬瞬时的过程。有了之后。

那这个站在服务端上面这个服务端啊，服务端那个服务器里边一定也会给他开辟一个内存缓冲区内核，对不对？是不是这道理？然后呢，并为他在那核里边维护一个。你像刚才。

我们也看到了内核里边是先有一个所谓的sockcket，但是这sockcket可能没有被分配给谁，因为它可能还没有accept它呢，它只是连接连接有了，但是它还没有这个这个进程还没有调性调用accept。

但是一旦调用了之后，那么accept一定会从系统里边申请到一个文件标符，就是动态给你演示了。比如申请到一个9。这酒就代表了。这个sockcket这个叫sockcket，这个叫文件描符。

程序application，用文件描符，文件描符会找到sockcket，找到socket找个buffer。你来了数据到这儿，我就可以读取到。八分满了会有数据丢弃，一会我给你演示，就到这步连接关系这块。

能听懂同学来说个一。啊，C300啊，C300啊，C300。你看这里边这两个ser里边口哎俩客户端号一样啊，服务端的IP里顿号都一样。但是它肯定一个能区分的1个C1001个C300。

就是s里边绝对会有一个能唯一区分他们。如果这俩要长得一样，那这个你这这个数据来了之后，数据包就就肯定乱了，没法放了。🤧。嗯。其实这个画的再精准点，应该是类似于剑。就是飘出来。映射关系是这么走的。

然后这个socket的会用到一个缓冲区，因为缓冲区可以读写两个方向嘛。Oh。Yeah。好吧，我讲的是有点那个有点碎嘴，有点慢了。但是这样应该很清楚了吧。其实如果再画的再勇敢一点的话。

客户端那边画法跟他一样的。因为你客户端也是一个application，它也是有一个内核的，我给你画出来了，我给你画出来更完整一些。其实在你。客户端那台主机里边。😡，长什么样啊？如果这两个这两个是客户端。

它也是application，那他也有他自己的内核，它那核里边是不是也会有和他长得一模一样。这个所谓这个三次握手连接的这个sockcket。就是这个连接这个这个在两端看都有。能有什么意思吧？😡。

就中间是靠三传输控制层，内核里的传输控制层完成三组握手，就开备了资源，开备了资源，开备了资源，他们就一一锁定映射关系了。然后这时候双方的application其实也会您这边。

如果这个稍谓的这个建立完之后，会给他一个文件描符，在这个application里边会拿到一个文件描符。比如他的文件标符可能就是FD。FD6。如果看完整一点的话。

这个哎这个客户端申这个申请和这个服务端去通信的时候，这是一个客户端想和服务端去通信的时候，他们先内核级完成三次握手，建立开辟资源，然后双方对那个所谓的s的这边叫FD8，那这边可能叫FD6。

这个没必要是一样的。但是他们如果两端application想使用那个连接的时候，都是都是动自己的FD，然后就找到内核的缓冲区数据读写就可以完成。这边的来1个FD。这边可能要22。好吧，这个过程是。

顺时完成抽象的。啊。一个进程能监听多个端口号吗？可以啊。Okay。呃。复用这个事儿复用这个事儿先不聊，这个一聊就晕了啊，这个一聊着真晕了。有有有这个这个这个监听复用的一个概念，但是先先把那事忘了。

先先不聊啊，后边咱们扩展再说，到这个是完成。因为后边很很多的这个这个课这个这个支点，这是最最基本的。如果想聊到通信IO这块，就是网络通讯这块，这是最基本的一个模型，这块会了，刚才给你演演示出来，对不对？

然后也看到buer缓冲区这个这个过程。

接着来我们接着来演示。countl C结束的。う。是。然后把这边监听的也结束了，然后把这边的code连接给它结束了。我下面给你演示一个什么东西，就是。在nty和这个所有的编程当中常用那个backlog。

好吧，程序呢依然把它跑起来，就是服务端哎，光东又跑起来了，这是服务端跑起来了。我为什么要把它重启，我们要看到一个干净的一个一个一个样式啊，用net state看NATP现在里边只有一个listen。

到9090，这是我这个java唯一的一个在内核里能看到的一个所谓的一个监听的一个scket，别人没有连接，对不对？然后用TCP这边也把它抓包抓起来，然后注意看我二上面再开一个被射页，开俩倍射页了。

注意看下面的特征，在我开始我这个server的时候，我的我用ideder给你看一眼啊，我给它的配置项是backlog应该是为2。

就是backlog只能有两个，那这是什么意思？服务已经起来了，然后我服务端的代码里边有一个阻塞ex这个在这阻塞着accept一定不会调用。就是这个内核你即便可以有连接。

但是我服务端如果不accept的话，这个东西到我程序里不用它。那那核到底会不会玩命的帮你的一个进程，在这攒了10万个人的连接，但是你却一个不用，那核把这个资源全给浪费掉，能能理解我什么意思吧？啊。

行白什么意思吧？那刚才我backlog那个到底是一个什么语义，我配的是二，那么来注意细节，我现在启动一个客户端。😊。

哎，起了一个客户端，这个客户端是java写的。刚到我那java那个客户端代码就一定会连我服务端。我服务端在这阻塞了，我没办法回车，那肯定不呃不accept。

所以这边你去看哎也能看到有客户端和我服务端的内核级的数据包的一个三次握手的过程。😊，有三次握手了，然后呢，用nice来看，的确也内核机也看到了4元组。但是这个4元组还没有被一个进程领领走。

也就是那个经理还就是他还没有分配文件符给到某一个进程，对吧？到这步都能听懂出来。刷倍一这是对刚才质点的一个验证。然后可以跑一个，我是不是还可以再跑一个？😡，能理解我想白达什么意思吧。😡。

这里面我是不是可以用java直接跑起来，我的代码是不是就可以了。哎，我标辑跑，你看三次握手是不是又又有了。哎，另外一个客户端，这上面是4747514，下面47515，又来了一个客户端连接。

然后也是依然是指在内核已完成了。是不是四人组都有了是不是四人组都有了，只不过是没有被某一个进程接收，对不对？这俩都成了，这俩都成了，这俩都成了。然后我还可以什么呀？我可以发点数据。

比如发1个123第一个客户端，然后数据包能发第二个客户端发一个数据包发点数据包机也也能发。然后呢这个监控的包也能抓到，就是内核里边这俩在玩挺开心的。然后你用这个命令来看，哎。

他们这两个虽然没有进程去收养他们。但是他们的内存的的这个缓冲区的数据已经收到了。这俩都可以，这两个这两个都可以。因为他还在那个数值的范围之内，但是如果我想开第三个看啊。😊，喂，有翻车。

这是开了一个第三个，然后数据包也过来了。三次握手。然后但是我看以看这let's sit走。发怎么能建立三个呢？我再开一个。这个有有有有有点要翻车的感觉啊。看到三个了，第四个呃。

应该三个应该三个是应该三个是可可以的。然后第第4个啊。哎，也成了，我勒个去。但是这时候你注意。应该会有应该会有变化了。走。看到这个状态了吗？看了吧。我配置白克老是2，但是这能有仨能有仨攒。

但是第一再来一个看这个这个这个状态，在socket的连接里边。注意listen是坚定起来的，这个这个单词是已经建立完，就是走完深自握手内存缓能序都开完的。但是S文 receiveceive什么意思？

S文 receiveceive什么意思？在我服务端，如果看到某一个sockcket，你看到这个了，尤其在我讲LVS的时候也讲过，在负载均衡的时候，也就是我哎我这个服务端，客户端的SN握手来了。

但是呢我再也没有收到确认的一个事情，也就代表着我没有我可能没有给他发，我给他那个确认，就是我不去，我不care他你来可以，但是我只有对，只有一次。第二次我可能没有给你发，或者我发了发丢了。

这两种都有可能只抓到了这个状态。就是不理他了。能理有什么意思吗？哎，那你再开的话，其实后续的都是这个状态了。因为什么？因为我已经在我的成序代码当中告诉那核一件事情。

就是back lock后续队列里边给我放两个人。😡。

我程序我目前那个监听的端口里，端口号里边，我后续啊就备胎可以有两个。他有两个备胎，就别给我开更多的备胎，因为我可能一会儿忙不过来，那存内存就被占占占爆了。😡，他这个能听懂，这是这个选项的意义意义。

这个配置项的意义能听这是在我们serv soet的 listen丝这这个上面起作用的，能听出学来说波一。Yeah。默认我我默认你可以用，因为现在都我都是set进去的，其实你是可以get。

它默认好像是50还是多少个可以配，那时候都可以调的啊，那时候都可以调的。但是一般我们都会去根据我们业务的特征去做这个设置。因为内核可以接收更多的。但是你限流也好，保证你的客户端的这个用户体验度也好。

因为你肯定是微服务的负载均衡的。我这台实在忙不过来了。我就先在这手头有有来来30个备胎，我一会能都给他处理好，谁也发发现不了谁。然后这个30亿满了之后，那尽量的它前面的个负载均衡就会向别的服务器去漂移。

这样整体对你的用户的感官度还是不错的。嗯。

那有人说了，一个，如果我们再再来看这个。对，刚才那个连接的已经失败了已经失败了。Yeah。是。看一眼啊。已经没有了，连不过来了。那个。先不说那个备胎之外的事情，备胎之外的肯定就是最好不让他还在这儿。

如果你说备胎之外的，如果我有一个所的连接建立完这个推退掉之后，那个还可以用。其实你根本就没有没有没有理解为什么一个白开白这个。这个这个这个这个意义背要就是最好就是我哎我允许有俩备胎。那我这个备胎之外的。

你就不要再跟我再变成一个备胎，是备胎的备胎了，就不要了。这个这个这个玩法太太狗血了，明白什么意思吧？肯定就是刚才那个就不行了。那这里面最重要就是哎有备胎之后，然后这个你看我这边如果。

忙完了从从一个很很强的一个阻塞结束之后，加机是可以收到。刚才这三个里边的，第一个你看。是不是就已经因为这个这个这个代码可能写的写的问题吧，就是最终他是可以把这些收到的，有应该还断开连接了。

Soockcket is closed。先看这吧，前面那个代码写的问题，但是不管怎么样，java这有一个过来了，剩的应该超时了。java有一个。9090。另外两个应该应该是超时了吧。2。

这边连接已经断了，这边连接。有问题。这是开始发的这个现在只剩第一个，第一个那个数据还能发过来。但是后两个已经不行了，这个所以最好设置一个合理的一个backlog，以及是面向你这个业务处理的速度。

你不能说我设置bu道无无限的设置一个很大，但是我这个业务CPU资源也好，跑的很慢，造成了很多的bu道的这个堆积。然后结果到最后其实这个连接已经出问题了。好吧。

这是一个选项参数backlog这个听同学来说个一。啊，你如果去看一些nT的案例，他们都会去手工去配置这个。这个这个参数啊，这这个就已经懂了。

然后这个还有在这个你监听s so的监听这一侧可以设置一个time out。然后在客户端鉴定内测也可以设置一个time out，这个time out什么意思？就是在你调用了except的时候，默认的话。

其实它会永久组册等一个客户端来。但是如果你在上面给了一个so端的一个，就是so里边设置了一个time out的话，你如果定义成3秒，那么它在这会等3秒，3秒之后再抛一个异常。但是他不会让你他只叫异常。

他不是致命性错误。回来之后还可以继续等，只不过会解中断它。就类似于加加了一个时间的一个中断啊，一个一个一个一个一个一个一个定时器，只不过用异常的方式来处理。这个能听的同学来说个一。

就是你在你的sword listen的时候，可以对accept设置一个超时时间。时间到了之后，那个阻塞就会抛一个异常，但是你该出往单独往下走，还能回来，还能继续。然后在读取客户端数据的时候。

也可以做一个抛一个时间到。一般像我们比如说web server，你比如连百度的时候，我可以和你建立连接。但是我就不给你发请求头。但是你过了一会儿的时候，你发那个连接也不也失效了。为什么？

因为其实它那边也会做一个超时的一个设置，就保证不会有一个恶意的连接，一直消耗你那个资源。这些配置都是这些配置，这些配置都是你看这些配置项都是在我们sk的一个级别去设置的。

都这个都是在内核的TCB协站里边的。啊，不是GVM是lin那操作系统去做的。这是现在其实这块还是关联到呃TCB协议当中的一些选项参数。好吧，这个也能懂，剩下的两几个参数，我们休息几分钟。好吧。

你把前面这个捋一捋过一过。尤其刚才这张图。

系列 3：P186：【IO／NIO】tcpip内核数据遗失 - 马士兵_马小雨 - BV1zh411H79h

另外一个小知识点。开始抓包，抓包的时候在三次握手里边啊。这边已经停了吗？哦负担提起来。然后张包这边。重新抓一下。招包，然后呢，我就用一个程序来NC啊。连local host9090。为什么要连上？

就能用。Yeah。应该绑定地址了，1就218。150。11，行不行任？连过来了，然后呢，我们先来看三次握手的包啊。现在握手肯定是我刚才那个NC的随机程序，随机登个号，猴子就能想握想做一个握手的包。

这个握手的包里边在TCB通信的时候，会有几个维度，一个是窗口大小。然后在握手的时候，其实就是在三次握手，两两者想去见连接的时候会删量很多的事情。有各自带的我自己发了那个序列号，然后呢。

对方会在这个序列号上去加一，再回AK的时候会给加一，自己会带上自己的这个序列号，然后呢会有窗口大小，窗口大小是什么意思？其实滑动窗口啊，你如果学过流式计算都有这个窗口的概念。很简单一个道理。

就跟我讲那个啤酒理论一样。或者是我之前有一个老师，我看过他的一个课啊，讲讲这个网络通信。

如果两个节点想通信，比如说就以扔馒头来说，一个人喂一个人吃馒头，这是一个一个一个端给到另外一个端。嗯，我可以给你扔一个馒头过去。你给我回一个确认，然后我等你的确认之后，我再给你扔一个馒子过去。

然后我才等你再给我回一个确认。那么这样的话就没有所谓的窗口的概念。因为他们之间都是之间的传输的这个常数是一，就是只有一个数据包过去，然后回一个确认，这是基本基本协议的规定。这个能听同学来稍个一。

Yeah。Yeah。然后这个过程其实就跟你我之前讲的PU理论也好，这个很很费劲，对不对？因为之前有很多时间是消耗了的。那这时候其实做窗口机制是什么意思？也就是说我这边要发送的数据啊。

其实是最终被变成了豹文或者叫个数据包。第一个知识点，数据包应该多大。数据包多大？那么怎么知道你的系统的数据包多大呢？可以发的。首先没错，MTU那你怎么知道你的MPU多大？很简单一个道理啊。

你看if con。

呃告诉你了。从这块往法发的时候，它的MTU是E500。记住了，if can看你的接口的时候是可以看到这在这个网卡上，如果向外发送的话，它那个数据包的总大小是1500。啊。

是总的那个数据报的那个报文的大小是1500个字节，就是1。5K1。5K。但是注意看刚才是不是抓招过包，抓包的时候注意看这里面会有一个optionions。这是在你的数据的就是封数据包的时候。

有这个数据包的包头，包头里边还有一个可编长的可选项的一个一个一个一个区域。这里面会有1个MMSS那它的给出的值是1460。这个其实约等于你的数据的真实大小。啊。

就除去了你包头的那个IP和顿号的个IP应该有20个字节，然后登我号应该有20个字节，家里用40个字节全刨掉之后，你里边可以放的数据大小是1460个。听同学来刷波一。

就你的数据包里边，你的数据包多大MTU是你的整个数据包的大小。然后MS是你的数据内容大小。然后如果你要传输的数据比较大好大，它最终肯定会切成很多个MSS，然后拼成很多个MTU这样的一个包要往外发。

那你手里会攒着很多想发的东西。那么根据刚才的理论，你可以发一个等一个确认之后，再把第二个发出去，或者用另外一种方式，也就是在其实在三次握手的时候可以协商回一个windows的一个窗口大小。

就是客户端两端啊，它的网卡的配置啊，缓冲区啊，也就是内核的给定一个一个一个大小。像这个时候这哥们啊客户端直接连服务端，张嘴就说啊14600。然后但是后来协商的时候，其实1448，然后但是服务端。

就是最后最终写上这个这个这个称数来表是1115115，后续如果再发送数据，我接收一下，接收完了，然后再把客户端的数据再发一下。发了一些再发一些再发一些，他有很多数据包交互啊。

然后这时候你观察这个窗口协商之后的大小，这两端给的大小就不一样了。一端说我的窗口是是是是115，一一端说我这边还有12个。可可以可以使用。哎，别没错，TCBU塞控制，先不提U塞啊。

先知道就是两边还有一个窗口大小这么一个概念，就是有多少个格子可以放多少个包。根据我们协商那个包，根据我们协商的包的大小MS。

到这步能听明白来，邵边一就两边可能他他俩的这个窗口大这个队列不一样。嗯。对吧啊他俩可能不一样，但是在通计的双方的时候都汇报自己啊，这里边放了几个还剩多少。然后这时候传输的时候，当你的数据量很大的时候。

那么就可以通用这种这种窗口地址。也就是我可以你如果你这个这个窗口这么大，那明显你放三个是绝对没问题的那我就可以一口气给你多，把这三个都给你发出去。让他们在路上，然后最终啊你肯定是收两个也好，收一个也好。

收三个收三个也好，你再给我回确认。我根据我回你回的确认，我决定这个窗，你回在给我回的去里边，你说你窗还剩多少，我再给你继续发包，快速的发减少了很多阻塞等待这个确认包这个过程。这是所谓的窗口机制。

它解决了UC。这个能听懂来刷波一。啊，这就很通俗很通俗一个，你就知道有这么一回事儿啊，面试的时候，基本上如果面腾讯的话，都会问到这一点，就是问你TCP当中什么叫做U塞U塞的话。

其实就是如果这个窗口被填满了。那这时候怎么办？回的那个数据包里边确认那个ACK里边一定会告诉他没有余量了。对吧然后这时候客户端就可以先阻塞自己不发了，等着对方把这个他的应用内核把这个全处理处理一点之后。

然后后续他再给补一个包，说有了，你再给我发。这个能听的同学来说个一，这就是所谓的庸塞控制。嗯。就既要提升性能，我还能别给你发爆了。为什么？因为本质上来说，这个东西如果全填满，你继续发就开始要丢弃了。

一味的发是要丢弃的。

我可以给你演示一个一个现象。那也是一个现象。把我的服务端停掉。把服务端跑起来了。跑起来之后呢，然后我们来用mattter state这NATP去看。然后再用一个。我把这招包现给它关了。用NC连192。

168。150。11，然后9090把那一个客户端帮都连进来了。连进来之后呢，然后这边我去接收它8这个客户端42588接进来了。就是我这个连接已经和它建立好了，也接受了，接受之后，然后来看啊。啊。

不不应不应该接受错错错错重重来啊，不应该接受，应该让们阻塞住。就为了。压压榨出他那个接收队列。然后这边重新连，连完之后，我这边不问回车。那这时候其实只看nstate。

那这个时候你会发现哎这个内核里边连接已经有了，然后缓冲区也开了，接收的队列已经开了。那这时候只不过程序还没有接受它那数据是不不可能给到你的应用应用程序的那这时候完全就靠底层内核的各级。

还有网卡的各级缓冲去接收这个这边客户端发的东西了。那么客端发东西的话，注意来看，发一个发一个发一个发一个发一个程序还没有接收这个连接，所以这个数据只最多是顶到内核的缓冲区了。O学吧？

就这么别别别发发的时候，你会发现它的接入队列是一直要涨。😊，对吧，然后我们把它。复制一下。粘贴粘贴粘贴粘贴粘贴粘贴粘贴粘贴粘贴粘贴，这是咣机咣机，客户端还在发到这步能看懂未来说不一就客户端一直在发。

一直在发，一直玩命的发玩命的发命的发玩命的发玩命的发。但是你那盒里边不可能无限收，对不对？那存就充爆了1920了，然后呢再来发一下，看还能收吗？然后再来看。😊，还是120，这个东西不往上涨了。

然后这时候我注意啊，我发。派对一。走过去之后，然后他其实还是不涨。然后这时候注意你那会儿已经帮我攒了一些数据了，那是攒的头的还是尾的呢？客户端开始接收，接收完了之后，他一定会读数据，对不对？走。

读到了前面的东西，后边人就被丢弃了。

可以设置。后边我再讲那些具体的这个讲到那个内核配置，我再跟你说，我先告诉你这么回事儿。

系列 3：P187：【IO／NIO】tcpip 参数 - 马士兵_马小雨 - BV1zh411H79h

接下来还是把我想要怎么给你演示啊，还得抓包，不抓包，你光给你讲，你根本听不懂我在说啥。还是得把它抛起来。哎，编译了一下，然后又把它跑起来了，服务端啊，现在又跑起来了。当跑起来了之后啊，我们开始抓包。😊。

其实抓不抓抓不抓也呃，抓不抓，就抓着吧。啊，先给他抓抓，然后呢，是这样的。我客户端这边啊。课端代码是要做这么一个里边有一些配置。有这么三个维度，第一个维度啊。

我s这个set send buffer分 size，我给了一个所谓的一个发送的缓冲区大小是20，但是呢还有两个配置。这两个配置我先给它全部制成foralse。一个是no delay优化这块啊。

这个如果就是如果单看这个单词，这个优化是什么意思？如果你发的东西很小很小，他宁可是给你攒一攒再发。也不是绝对说不发出去啊，就是或者你的数据量比较大的时候，你能看出这个特征来了。

它是不是按照2020去发的，还是可以突破20这个概念，就是有没有优化，就是本地攒不攒那么多东西。为什么你一定要记住了，我这边发送的时候是写rightite的时候是一个字节，一个字节的。

就是我在命令行敲的时候，这个readland的时候，我可能一一口劲敲50个或者60个字节。先别想那么多，跟着我的思路走，拼包什么的都别想，你会的东西都先忘掉，先跟着我的思路走。因为这叫冷知识。

就是我在命令行，我可能敲50个字节，60个的70个字节或者三个字节，一个字节。无论我敲了多少个字节，在IO使用上，它是一个字节，一个字节的调内核，就是从过程序里调内核。要我我我每次调是写一个字节。

而且我不调flash，关键是以下这两个参数，尤其中间那个参数，还有这个缓冲区，它是怎么用用起来的。😊，啊，他是最多发20还是可以发6080或者100。我如果写的多的情况下。

到这个能听同学来说波一就是传输的频率。因为如果我本来有100个字节给你发，我可以变成一个包发出去。因为一个包可可以放1000个字节，对不对？😡，但是我这100个也可以给你分成按20分成5个包。

那我传输5次跟传输一次都是这100个字节。你说谁更谁更省劲儿，就是先表达这个意思，这就是这是delay是不是优化这件事情，no delay是不优化，我还给它关了，那就是开开启优化。😡，这就是负负得正嘛。

明白什么意思吧？这是默认配置，就是默认它是开启的一个优化的。😡，然后下面这个fose关掉，先不用管，这其实是是不是会把第一个你的数据的第一个字节砰掉就发出去了。啊，是不是一个着急的这么一个事儿。

一会儿演示你就知道怎么回事了。我们把这个这个这个配置先记住了啊嗯，知道之后呢，我把它关闭掉，然后用java。😊，C去编译它。编译成功之后，把它跑起来了。黄灯先先是建立一个连接啊，建立一个连接。

这边我把这链接还给它收到。哎，建定好了，那现在就开始等传输了。当我想传输的时候，注意听啊，想传输的时候，注意我先发送一个字节走起。😊，这边收到的是一个字节啊，是内容是一。能看懂吧？然后呢我再多发一点。

如果发3个123发三个走起，我发了三个字节，注意这是read这个read line，它读到了一个字符串啊，读到了一个字符串，但是它是不是一个字节，一个字节，一个字节的rightite。

然后这时候再来看它收到了，你看这有一个特征啊，这个第一个一着急先发出来了。然后呢，后边又收到2个23。😊，小的时候你可能看的不太清楚，没有没有没有什么优化呀，我们再多一点。

刚才我定义的缓冲区是201234567891012345678910。再来1个1232三个字节走。有没有发现它可以我换成缓成器不是20吗？是不是22个，除了第一个着急的，22个是不是过来了。

如果再放大一点。😡，走。也就一个包的大小是可以超过缓冲那个8ffer的缓冲区的。听同学来说波一，就是在刚才这个配置情况下，我舍得默认的起优化的这种这种状态。好，把我的客户端结束。😡。

然后再来去编辑这个文件，我将配置项改掉，把new delay的这个事给它开启为tto别优化了。着急发送，别给我攒着，别攒成一个包，有多少？缓冲区满了就给我出发，或者能给我能给我发，就赶紧给我发出去。

然后再把它跑起来，能能理解我想把它什么意思吧，是不是就改了一个参数走。😡，喂。怎么报错了。用管他再来一遍。诶。数字开始。前面是出错了吗？要reuse了。re失败了。再来一遍啊。没错，我把这边结束一下。

服务端重跑一下啊，90677起来，然后这边。那个结束一下，换另外一个。C。这个他抛起来。好，连上来了，连上来之后呢，我给他接收一下，走接收了1个47526。刚才是不是又改了一个参数，着急了。

别给我优化了，nodelay为 true了呃，没有delay了。然后这时候注意我发1个123效果是看不出来的。对吧哎，收了仨效果看不出来。然后但是如果一多。这样。

我这很多已经超过了我那个二0那个缓冲区了。走。

看到效果了吧。之前有优化的时候，是不是会攒成一个包，一口一发过来。现在是不是随着我产生的速度，他该发的尽量的根据内核的调度，该该发的赶紧发出去了。😡。

到这儿能看同学来说个一。也就是说其实在于你怎么去设计啊，你着急发东西的时候，不想走这个优化。你比如说很简单的，咱们这个。😡，L我使用SSH我编辑回车，我才按了俩字母。😡。

对吧就是如果你平时传的东西不是很大的时候，就用就而且复用一个连接的时候，这个链接里边传很多的东西，还不是使用多个连接。然后很多东西的话，每个东西还独立执行，然后体验不大的时候，就不要开启优化了。

因为别让后边的拼了一块一块出去，它毕竟有一个延时，你别小看那点延时啊，这个这个这个这个小小你这个这个前后这个这个延时，如果这个就是这个就是这些东西如果攒到等到后边这个东西再发出去的话。

那这个这个过程可能会整体的这个感官，就是整个系统的吞吐量就下去了。

啊有的时候你要根据自己特征来选是吧？开启这个快速传输，这个就是这个load这事，是不是要开解关闭。😀。好吧，都是用你肉眼可以看到的一个效果哎来给你演示。再接着来还有一个是这个其实不太重要啊。对。

这是为foalse，然后给它开启。为 true。编译完，前边这块搞定。然后再去把它抛起来。又不让凉了。没 you。欢 you。N state。服务端只有一个现程，不是的。Yeah。我是重用了那个啥了。

重用了那个断号了，应该。reuse开启了吧，我看一眼啊。Yeah。没有开reuse。没有在这一个配置线，然后再服我再看一下服务端代码。对。不错怎么关了。服务端没啥问题，我服务端，你看服务端。

如果我ctrl C断开连接之后。刚才也读到了负一了。就close掉了一个扣端了，然后再把它重启，应该是可以重启。起来，然后刚才改改过配置了。然后走再连进来，连接之后呢，然后先把这个客户端。

你看飞机接录到了47528已经过来了。过来之后，然后开始输入123走。看那个这个收到了3啊，然后我再给你演示。然后1234567，然后走都是传一些小的数据包。然后你会发现像这个G是一个。

就是是那R是一个。R哪去了？对对这，可能可能是刚才。因为他一个写了嘛，但是基本上会保证你这个单机传输这个最短的这个111个1个一个证圈的一个轮询。他没有着急把第一个字接打出去。能看这现象吧？

因为你记着刚才是不是有一个现象在传输的时候。先记住这些啊，就是现在啊我客户端的这个代码我给它结束了，crl C。结束掉之后，然后这边就为负一了。正在报了一个错，那s一个字s is close。

我是不是服务端代码真的有问题？No。是。读取它，然后接收它接收完了之后起了一个线程，一个线程起来之后，然后我能读到-一，然后把它close掉，然后break。

break是要跳出这个循环的。然后这个链接也会给它关闭掉，关闭掉之后，他为什么还要报那个异常呢？

Yes。是现在阻塞现程，这个线程结束了。因为这个放这个这个循环只要结束，这个lemon的表达式，这个大括号就结束了，这个线程就消失了。线程消失之后，然后其实那就那个客户端就没有了。然后这边循环的时候。

它会拿到一个新的客户端，新的客户端会抛出一个。如果再再来连接的话，是会抛出一个新的线程。

说哪资源改过配置吧。不管怎么样，我先把刚才那个演示啊。先给那个演示那个finly是整个结束的时吧。你看这个分斗率是在整个这个tck cap的时候。上那里写错，写错位置了吗？哦，我翻到里是不是写错位置了？

啊，我说的还真是。但你不写他的话，我想想把它写哪去合适这个。啊，很难真是这个问题，这是一个catch，它的try是在。就这个位置。没毛病。哦，不行不行不行不行不行。啊，的的确的确的确。

应该是对整个的这道代码，整个加一个tryca值，在整个的就把这个cach的给它移移到后边去。对吧是吧这这这三行3DD要挪到。我Y我循环结束之后。就是我class类主方法，然后在这儿，然后粘粘过来。

走到这儿来。是这意思吧，哦，知道了。掉行了，那这时候就没问题了。刚才的确是把那个自个儿那个soer给他端端端端掉了。😊，其其实不是翻车，我就是告诉你啊，这个哎这个翻的里你写对位置。不断跑起来了。

跑起来了，然后在我这边继续刚才改了配置文件了。老演员了啊，我把那个。😊，刚才为 true的时候，就这个这个选项为 true的时候啊，它是你会发现你写啥，他就给你把这个包发发回啥了。

但是如果改成false。然后优化不需要优化，直接发送。先看先来看一眼啊。客户端的跑起来，然后服务端接收它。服务端再去发送数据。123走发过去了。三个这为啥演的不出来呢？发点发点发点都发一些超过一个的。

只有只有D和F是一个字节的。这有D和F这有一个D这有个D这个F这不明显，可能他还得他还得结合这个no delay的这个方式。这两种如果结合在一起的话。保存。java编译再重新跑起来，客户端再去接收它。

服务端发发一些比较短的东西。然后你看他都是先发一个比较着急的，然后再给你拼后边，再发一个着急，再给你拼后边的，再发一个着急的，给给你拼拼后边的。

啊，就大概理解这么一个选项一个参数。就是如果嗯。就这个选项嘛，这个选项其实我也一直没没弄么明白他为什么这有这么一个东西啊，我只告诉你有这么一个东西就可以了。没啥用没啥用。

但是有的时候是可以起到一定的作用。为啥？因为你如果第一个包发出去了，对方没给你啥反应，其实后边可有时候可以不用这个不需要再重复的，就是可以过早的去秀探出秀探出。这个不重要。像剩下的参数的话。

这个关闭这事不不重要。no delay也给你讲过了，te out你也知道了，还有个keep alivekeep alive那个keep alive什么意思？再把它演示一下。

服务端结束。嗯。把服务端那边的keep left换成te。在这儿有一个先把它跑起来，跑起来之后TCP抓包这我给它清掉。靠TCB招包能看得出来，但是那个时间有点长，但是不要紧，到时候给你画图的时候。

正好正好跟他演这个演示一下。如果再把我的这边的这个扣户端连进来。关机啊，客户端建立三次握手，这三次握手已经有了。有了之后呢，然后我接收它，然后呢，咱俩我俩谁也不说话了，先把它标在这儿不动了。

那么什么叫做keep live？ keepep left这个词，你应该在很多地方听说过在这要标记一下，keep live。

有一个概念，就是在TCP这个呃。协议当中规定的就是双方如果建立了连接。如果双方。建立了。连接首先根据上面的描述，这连接是虚无的，它不是不是物理存在的。那只是双方主机里有这个资源而已。

他们之间并没有一个物真正的一个物连线给他给它连起来。那首先第一个知识点第一个知识点，如果很久都不说话。其实这个时候你能你能确定对方还活着吗？Yeah。能确定这件事情吗？是绝对是不可能的啊。

因为对方可能光机断电了啊，或者那个城市被炸了啊，或者整个他那边运营商的都瘫痪了。但是你这边的网络，你那边的你的下游那个物理设备，那个那个网线那个灯那个电都还在。但是就是外界不行了啊外界不行了。😡。

能理白什么意思吧？就肯定不不你不能确定他是不还活着。所以在这种情况下啊，在这种情况下他提出了一个keep alive。这是TCB级的，在HTTP级别当中，也有一个keep alive。

然后在附载军里边还有一个keep alive的那样的一个一个高可用，一个进程啊，这三个东西千万不要给它弄混了，不同层级的。

能理解什么意思，能理解什么意思吧？哎，那这时候再来看，哎，你看我是不是双刚才是给你高量到这个位置了。😡，开启了keep了就开启了心跳了。那这时候他自个儿会，两边会。😊，说话。发的包L死没有数据。

只传输共程层要发一些确认包来。

做这种所谓的心跳啊悄悄化来判定对方是否活着可以了。这样的话会为呃周期性做这件事情，会为你后续资源的把控和效率性能有一定的这个这个帮助。为什么？如果说你有5000个连接。他们都挂掉了。

但是你却没有把这个没有心跳，也不是他们挂掉了，你的内存一直保持这000连接，其实是很消耗资源的。虽然我们可以让网络当中消耗一些数据包周期性的，但是起码说可以让我的内存相对的来说。

发现他没回应了，超过我多少次之后给他踢掉，内存起码可以省出来啊，这个能理解同学来说个一。嗯对。

好吧，就是一些很简单的一个知识啊。😊，用我用了很多的时间给你讲解了一些东西。好，那么现在只是讲了一个。简单的socket就之前咱们在公开课讲IO之类的。

是讲讲的这版scketIO就告诉你我是是一个阻塞的，我得先起监听，然后呢，我得等着别人连接，然后再等着别人发数据啊，仅此而已，是我是在这个版本的情况下给你扩了一些关于参数的配置。

而且这些参数配置其实只一部分。后边到nty的时候可能还会更多一些。但是这个参数已经。起起码面试的时候能聊了，好吧。🤧，但是不管怎么样，他现在是隶属的是BLO环节，就是会有阻塞的事情发生。

会有这个开辟县程对应某每一个连接，会有资源的消耗的问题。

好吧，是这节课讲的，还是下节课讲的，我想想啊。喂。从那一课开始讲吧。刚才给你们演示的是关于。

其实更偏重于。

系列 3：P188：【IO／NIO】网络io变化 模型 - 马士兵_马小雨 - BV1zh411H79h

爱我的一个眼睛和病。或者模型模型。他讲网络IO变化模型的时候，我们先来呃在面试的时候常问的一些问题和一些关键的一个语义和词汇，在这梳理一下。目的是要把这些东西学明白了。首先你会听到的有同步。

E部在关关于IO模型这块啊有同步，有异步，有阻塞，有非阻塞。好吧，这人面试常问的。嗯他的组合模型有几种。等等的啊，比如同步阻塞，同步非阻塞。对吧还有异步啊，有异步阻塞模型吗？同学们有异步阻塞模型吗？W。

そ。注意是没有的嗯，没有没有异步阻塞模型，你异步阻塞，那就是灵异事件了。你都异步来还阻塞干嘛？没错，但是异步在令令当中基本上目前的版本是没有实现。在在这个商商商用这个版本当中。

相当于这这几个概念你就知道那这几个到底是怎么回事。那么接下来的学习方式当中会用到的指令是strs。3D。用t来追踪我们的性雕用，尤其关注那些个IO的实现啊。

lininux很难实现AL不不不不不linux的程序员，就是linux的内核的开发的程序员的数量一定比微软的程序员的数量要多。因为它是开源的，面向全球的大牛。能明白什么意思吧？就是就就拿开发人员的素质。

质量和这个经验能力上来说，肯定是大于这个微软的。只不过这件事他要不要做，想不想做这件事情，就是如何去定位自己的内核。啊，没错，linnuux是linux这个内核的缔造者。

然后但是他也不是说绝对具备一票否决权。这里面其实有很多的资本运作在里边，就是各个厂商有自己的这个AIO的想法。因为这个你就可以想成啊，内核是一个。那个是管家。但是内核就因为它是管家。

它是一个属于社会最底层的，你知道吧？底层的。这么一个角色，然后上层那些华丽的applicationAPP比如oracle，比如说IBM，他们都有自己的数据库，都有自己的一些程序。

他们都想使用一些网络的IO上的事情。所以这时候你内核虽然在我程序的权限上，你可以管理我资源上你可以管理我。但是这个内核你是毕竟底层嘛，你这个相对底层一些这个记住一些。

但是这个各个厂商其实就想因为因为你开源的，就开始想动它里边这个底层代码实现一些所谓的异步的IO模型来让自己那套程序跑的更好。但是。你你IBM的AL框架，可能你的这种DB two啊跑的特别爽。

这种C开发的。但是可能到oracle或者GBM或者其他的程序都是跑，就不那不那么。不那么爽了，然后然后人家那边也也想来一套AL的标准。然后这个时候琳娜斯就很尴尬，说哥里可别这么玩啊，咱咱这是内核啊。

咱们是服务级啊，这个东西得安全啊。然后带领的一票人，就是这个阵营啊很多不同的阵营，其实都里边都有利益或或者开源或者是精神精神在里边，就是来把控这件事情。所以他没有一直没有统一而已。能听同学来刷波一。

但是微软虽然的程序员没有那么强。😡，啊，程序员没那么强，但是微软人家说了算，说内核就得给变胖一点，变臃肿一点。内核干的事就得多一点，我得让我的程序跑到这个开发上面简单一点。啊。

我那个安全上面可以可以可以可以可以放弃，就跟CP1样，我就调整某一个级别就可以了。哎，所以这个时候其实windows是可可以实现异步的，因为它有很多IO程序，在windows的程序啊。

它不管这个IO的这个状态和这个读取，这个事就先交给内核了，内核有现程。连去接收数据，然后放到缓冲区所有的事儿。全做完了之后，最后就告诉程序读完了。那对于成来说，呦这事儿读这事儿什么发生的。

我也我也没具体去调这个这个这个读，也没等这个读完那个结果。你突然就告诉我读完了，这事好一步啊，这叫一步。😡，不是我这个成语自个读的，像Ling当中，你即便有读了附文器我我我知道了某一个文件描述可以读了。

某一个网络链接可以读了。但是我只知道了能读，我还得自个去调读读的事我还得等着，还得组组这个让我这个成序在这在这在在这在这守着，就是同步的，我得去做这件事情，所以这个lining当中，它就是属于同步的。

只不过这件事情它可以是阻塞，可以是非阻塞。因为你不来的时候，就你这是俩事儿啊，这同步异步左侧飞组，这这两个维度，两个概念。就当我当我这个想想想去读的时候，我可以一直等到你数据到达，我就读到结果。

我也可以读，发现没有之后继续忙别的。然后我一会儿我再我再读一下试试。这就是主说非组说的概念。好吧，对一个通俗的一个描述，你对它有一个宏观感之后，然后一会儿我们把代码跑一跑，通过str追踪一下。

然后把它的IO模型变化再给你梳理一遍。这个在其他课程当中虽然有讲，但是我说了还是为了保证咱们这个操IO这个章节的这个完整性啊，就是后来新人来的时候，他可以直接看这个章节就可以获取相应的知识点。

所以会的同学就别嫌麻烦，好吧，这怎么还一直出现这种。来，任何同学来刷波一啊，我开始讲课。

Yeah。像在这儿提醒一下，呃，尤其后边来的小伙伴什么可能没听的小伙伴，你最好先去把马老师讲的。寄组我觉得你组成那块去去听一听。什么是中断啊，什么是进程啊，什么内存管理啊，把这块的先去补一补一补。

很简单啊，稍微有点概念就可以了。然后我们来聊到。还要变成这一块。Yeah。这边我有很多的代码啊，先从最基本的tex socket。t old就就就从t sorry这个这个代码看起。这个代码是一个精简版。

刚才给你演示的是那个带proport参数的，这是一个不带参数的，一切都使用默认参数。然后呢，newserv so的时候使用的是8090。在javajava语言当中啊，我们用java言写的时候。

想想网络编程的时候，new的是一个serv so8090得到一个server。然后这个时候根据刚才讲解，在TCB层面，其实其实就起了一个监听了。啊，就绑定了8090监听那个状态已经有了。

然后也打印了提示的用户啊，这个80990已经开始已经第一步已经完成了。然后进入一个死循环，死循环当中啊，调accept等待客户端的连接，连过来之后才会得到客户端。那么没有人连接在这一直会阻塞。

这是阻塞的第一个点，当某一时间点有一个客户端连进来了。这个方法从内核就从先入内核到返回，得到了一个客户端的文件面符，也就是在内核当中四源组已经有了缓冲区域都构构建完了，文件面符也构建好了。

那这时候给用户提示，哎，这客户端，的端口号多少，已经连进来了。😊，这和刚才的知识已经挂上钩了。然后这个时候你有一个s，你一个线程啊，你一个reable，然后用一个线程当中。

把这个客户端在这个线程当中与到的run方法当中啊。往下走。う。这里面是我在调它的时候，这个怎么写的？SN点ge input这SS是谁？SN等于SSS。呃，我因为在下边掉了一个s，把客客户端传进去了。啊。

把Cllan传进去，传进去之后，这个SS其实就是这个客户端。那在这付付了一个值。复制之后，其实这S的客户端我从这个县城里边。从那个客户端里拿到输入流，然后包装一下，想去读它。但是读的时候这有一个阻塞点。

比如我的接受客户端连接是一个阻塞，读是一个阻塞。但是现在我使用多线程模型。然后注意下边代码的演示方式，这个代码能看懂学来说个一。文件描入符是什么？看我前第一节课IO的第一节课里边会讲了文件描入符。啊。

我给你演示LSOF。这里面可以看到所有的你还可以看P dollar dollar，这就是文件描符，就一个数字，数字一定会代表了某一个东西。某一个文件，某1个IO，这就是所的界面服务。

逻辑代码能听懂这个sockcket。那么注意在这有两个概念。第一个概念我们先用一个版本。用USRjavaJDJ twoSDK。变下的java C这个编译器。🤧java它的是分版本的。用java C。

这是J two1。4的版本的编译器去编译我们的t so。这样va？编译完之后得到它的class，然后把它跑起来，是你用跑运行的时候，也要用这个1点1。4。2的。但是这时候要用str这个命令接入了。

杠FF是抓取你未来跑那个commond，它所有的线程杠O，然后给出一个输出的文件的前缀，是追踪每一个线程，它对内核的系统调用。前面计算机组成也讲过什么是系统调用了，也讲过8年中断了。

追踪一个程序对内核的所有系统调用，并每一个线程都独立输出，后边会带着一个现程的线程ID号。那是哪一个命令呢？你这给的也是USRjava，然后J two S1。4闭幕下的可java可征程于这个这个讯机。

后边跟的是test sock。啊，把这个字源码加载进来，开始开始运行。当你摁下回着之后，它很快打印了第一步。然后根据我之前讲过课的。

你现在应该就知道了nicestate杠NATP一定能看到一个list绑定在8090上了，只不过现在没有任何他的建建建立任何的连接。😊，对吧然后你还可以用LOSOF。

然后杠P来显示你这个8384这个java。然后看到文件面符，任何成语都有012标准输出标准输入标准输这个这个标标准输入标准输出和报错输出。然后这个3。是1个TCB绑定liston8090了，这是3号。

什么叫文件描符？它代表了某一个东西，一切金文件，你的输入终端，你的程序，然后你的真正的文件，还有你的sockcket，还有你的这个pe plan都是文件，都可以用一个文件描符表示。

现在只得到了一个监听状态啊，那么我用s要做一件什么事情，重点来了，看刚才那个目录test soet。得到了一堆out。😡，现在你数下outt文件有几个，12345678有8个，那么代表着java。

我这个程序GVM密启动，它就是多线程的。啊，它就是多线程的每一个线程干的设计部不一样。像这里面，因为这个J two1。4的时候，它的第一个主线程out8384这个线程。其实说白了就是它的主方法。

那个线程剩剩余的线程就是一些功能线程可以你GM叉或者是呃通过这个GC垃圾回收监控。Okay。那么我们只需要关注8384这个主线程。8391。不是你可以看2。8384。Size number。

因为在主线程里边，我是不是写了一句话叫做sstem点out点pre这个step一点newso so8090，对不对？啊，那所以这时候我们去从这里面去搜一下。是不是你会看到哎。

这个就是这个8384里边掉了一个right，这是一个内核的系统调用打印写这个一就是标准输出写了一什么，就标准出就是屏幕嘛，写了啥东西了，写了一个step一new8。9就O了。

到这步都能跟得上同学来ber一就是现在要知道做件什么事情，我再用s来追踪我们java程序，它和内核有哪些交互交互了哪些内核的系统调用，对吧。😊，那在这里面。先看到最后一行。啊，最后一行是accept。

那这个accept就是在我java当中跑的时候，我可以用。用另外一个窗窗口给你演示吧。我那个代码也打打出来了。就是第一步，这已经打印了。然后程序进入死循环，然后但是到这一步，java当中的server。

这个server就是我们那个server soet点accept的时候，java到这儿java阻塞了，其实它是怎么组，就是我们的java是怎么组阻塞的？java只是一堆字节码，它跑在一个。

lin令系统的一个进程里边，就GVM里边GVM其实用到了内核性交用的except。是受内核系统要用的阻塞，而java代码也也被阻塞了。那accept在做一件什么事情，accept语音就是接收嘛。

接收谁括号里边一个3，这个三是谁？根据刚才的描述。😊，GPS我们的那个就是第二台，我要切到第一台去。看一下。就是开的窗口稍微多一点GPS。是8384这个主主主的这个这个线程组。

这个技能的ID号LOSOF你现在现在就找找到感觉了。8384这三是什么？这三就是一个TCP的1一个scket8090监听。然后accept监听谁得接受谁，accept就再接受这个三，这个三是谁。

你其实可以往上倒。😊，哎，你看这个三在accept时用了，在绑定办的时候也用了，把三绑定到了8090，所以你这才会出现一个。三是接听8090这个文件标符，然后再往上除了这绑定了3。

然后往上还有一个scket的调用，它的的值是一个3，也就是说我的。java代码当中是想有一个server socket绑定8090，并accept，其实换成系统调用的流水线，就是调了内核的scket。

得到了一个3号文件描符，代表这个你这个这个这个要监听谁，并给它绑定到8090，并做了listen，把三监听起来，这是三个最重要的。任何的程序，如果做服务端，这三个是必调。无论你在什么IO模型下。

这三个调完之后可以调accept句。接收在这个三上这个listson上接收有没有客端连进来到这步分们看懂同看懂同学来刷波一。Yeah。就是用VI去显示这个文件记录的东西。然后你可以用t杠F。

一般自动日志都用这个命令。然后追踪outt点8384。记住了，现在所有线程最后结果是8391，对不对？一共1234567，一共8个线程。你用t阻塞这个文件，它会一直显示这个文件的后十行啊。

一直到acap也的也的确在这阻塞着呢。然后这时候注意听，我用另外一个去模拟连接它。随便找一台用NC啊NC先做第一步连接，再做数据传输的第二件事情。就是在IO上其实分为两个环节，第一个是建力连接。

第二个发送数据NC连谁连的是192。168点150点11这一台的8090。去建立一个连接，注意看啊，前面是的这个t追踪日志，我的主线程就阻塞在这儿了。但是当我的客户端加机一连过来。

你会发现刚才那个阻塞就往下就往下。跑了，在这儿开始在这儿。然后就开始往下面出来一堆的这个代码执行的这个这个痕迹。但是在这里边面你去读，它会读到哎有1个34178，这是另外一个刚才这个他的随机登口号。

地址是来自于150。12，我这台是note01是11，是来自于note02150。12的1个随机单号34178和我这个3list上建立一个连接，并asap给它连接，得到了一个文件描符5。

这个5就是一个新的连接了一个客户端的，你可以继续用LOF杠P8384来看上次看的时候指到只到那个34对不对？现在你看的是不是多了一个5，这个5是不是note01note02的一个已连通的状态。

一个sockcket这个五就代表了这个这个4元组到这步能看同学来说个一。就得到了一个连接。5。那么当前我扎个程序里边有一个三是listen状态，有一个5就是联通状态了。有了联通状态之后，那这时候注意听。

现在是BLO我的是种多线程模型。首先在主线程里边，它执行到这一行，打印了这个step2。也就是在accept接收到一个客户端之后，哎，打印了。打印完之后，注意向下边它要扭一个stride。

并把它runable跑起来，这最终叫做这个start。😡，所以那现程是一个什么什么概念？那继续追踪我们这个打印完箱后的这个代码当中，你会看到有一个。代码叫做。你你去再再一做啊。有个克隆啊，到这一行。

克隆是linux暴露的一个性统调用啊，他在做一件什么事情，看他的返回值，双击这一个他的返回值返回1个8447啊，8447。其实克隆是在克隆，就是你new spread现成的时候。这是一个技础知识。

就java当中的一个线程是什么东西？它就是操作系统的一个子禁程或者叫子线程，就是通过克隆方式得到了一个具体的一个实一个单独的一个一个一个线程。84级是系统级的。那么刚才我让你数过了，我说你数一数啊。

它一共有多少个县城来着？开始看那out的时候只有8个12345678，就到就到这儿，你看是不是多了一个out点8447，这out点847怎么来的？其实就是来于8384里边做过了一个克隆。

得到了一个新的县程，这现城就跑起来了。那新的县程跑起来，注注意这样，因为它叫做轻量级进程，但是它是有这个数据共享共享的这个标志位里边标志了，我会有我的这个这个这个尤其这个文件系统啊，打开的文件等等的。

啊，那些内存区域的一个共享。所以在当前主线城里边的三也好，还有这个五也好，上面得到那个535这些文件描符打开的一个文件描符。在另外一个县城里边，就是当前这个县城里边有的，它被它被它被共享了。

所以在847里可以看到。

这个能听出来，上面一克隆和fo克啥区别？通俗来说。f是本质。这个事就就fo这个调用。只不过基于f参数，我可以包装出很多的具体的这个工职能的，就要不要共享一些内存的东西。

要不要最后再调1个ESC执执行新的指令啊，fo才是本质。其他的其实就是一个包装的一个一个一个间接的这么一个一个参数的一个一个一个包装啊，装饰这个如果能看懂的话，我就去看8447。因为什么？

因为在你new在我们java代码当中，你new了side之后，这个sride基本叫做异步了。因为这另外一个线程，这个sr的代码，尤其是run方法是在另外一个线程去执行的。

这里面会用到了clan去读取数据。当前线程这个这个这个这个new类事情一完事事一完事之后，3月之后光能调度回来又到这个死循环we要住着，然后又开始accept了。所以你会发现在克隆之后。😊。

得到现成之后，他马上到下面又到了except，也就是主线程只做一件事情，疯狂的等待客户端连接来了客户端就抛出线程。现程因为里边有东西共享，所以那个线程就一定可以访问到共享的东西。那我们直接去看8447。

🤧VIout点8447。打开这个文件之后，这是另外一个线程。你会看到里边，尤其看到最后啊，是不是在主线程里有三有5这两个文件标符。在这个847线程里边，是它是不是用了receive叫读取5的数据了？

这个5它为什么可以用？因为这就要现程把一部分东西，尤其文件或文件这个这个缓缓冲区papge，还有一些东西给它共享过去了，到这儿都能听同学来shopber一，这就是所谓的。多线程的方式来接收客户端连接。

看看。嗯。那以上这些东西其实还有一个学习方法啊，刚才什么看到了sockcket呀，看到了band啊，看到listen，看到了receive，看到了克隆这些东西你只要手里有linux都可以去学。

用manu，这是一个指导手册的这么一个程序，这叫帮助程序，然后可以跟一个数字2，它后边可以跟12345678，你比如说TCP你想学你想学TCP的话。TCB打开啊，这里面关于TCB的一些相关的知识和这个。

这里边都都会有一些知识啊，然后但是它属于七类杂项，就看那个文档一打开之后，左上角这个括号里边它是哪类的，或者是menuIP。但是IP之后，你看有个8类啊，这是IP的那个管理的一个命令。啊。

你可以用ifcon，也可以用IP那管理的命令。然后你还可以告诉他，我想看的是7类那个IP。

Good。

相关的维度的一些一些讲解。没错，不会就manu，然后还可以看ASCII阿玛。七类的也可以可以去看UTF杠8，就真的推推荐你们有些东西你宁可拿着它去做百度翻译，去理解，都比你去看一些。

那个所谓的文章博客更体系更完整，想学好linux看哪个帮助最重要man bash。就是你一直在交互的那个命令行，它其实是这个程序bsh。这个拜是有中文的，我要告诉你是有中文的，你最好去看英文。

因为英文当中有一些语义是对得上的。往后学的时候，我有时候给你们讲课，受的一个重定向啊，一个什么参数扩展啊，所有的知识，那并不是我生下就会的，就是在这个文档慢慢去学的。你像有时候我是不是会用and符。

然后表达式啊，然后写些脚本啊等等的，都是都是其实都是在这个文章当中去学的。🤧那么要我现在要讲什么？他123456788类文档。如果你不行的话，你。看一看这个慢他是不是扒类文档，对不对？就就是看这过程啊。

哎自个自个儿自个儿帮助一下自己啊，就自自己自己给自己那啥一下。😊，这里面比如说一类文档是用户并令，二类是是cos。系统调用啊，三类是这个C library的 functions。啊。

四类是开发和什么什么文件，五类是文件格式化什么的，六类是游戏，七类是杂项，八类是系统管理员的一些工具和后台的一些一一些指令。なか。那所以你看二就可以了。

像strs这个指令追踪到的是这个strs这个指令追踪到的都是你后边这个可执行程序的对内核的系统调用啊，所以你看到这些关键词，你看到这些关键词都叫做系统调用，所以都是stem call。

所以你就按照这个顺序学man two，比如说第一个sock it。现在会了吧，就是不需要我，其实你也可以完全自主学习了，整套东西打通了，对不对？主要是通的这个感觉啊。那sy的话，你看什么叫系统调用。

新调用你不用想的很害怕。什么叫做函数调用啊，什么叫系统调用。他们只不过是调的时候，在内存的控制上有一些区别而已。有的是直接就是给地址啊，就PP这个PC这个计计存器，我就可以直接下一个就调出就可以了。

要么就是用80中断啊，我就就走走一下这个用态那个net切换，再把这个函数调起来。😊，其实最终最终都是调起，那最终就是方法的调用。你看socket就是一个方法，它有返回值，int类型，然后呢会有参数啊。

有方法名，有签名。那这里面我们先看一眼返回值是啥。范回值有一个re value，如果执行成功的话。a file descriptor文件描述符。但是你会发现返回值不就一个数值嘛，这个数值就叫文件描符嘛。

哎，OK你可以这么去理解。😡，这文件描书是一是一件什么事情？for the new socket is retain retain。就返回了。但是这时候注意了啊。

是要返回的是一个未来你要准备开启listen状态。第一个sockcket，你会得到一个文件面符，然后关键往下看，是不是socket得到了一个文件描符，比如得到了一个数字5或者一个数字3。

这时候你再来去看man two，然后看bandd绑定绑定的时候，它是要给出一个相应的这个scket的地址和动口号。绑定上之后，刚才就看到的就是绑定808090。再去看还有一个listen。😊。

🤧listen的时候是要给出你刚才那个scket的文件描符，listsen给出它。然后这你看这里一个backlog，可以给参数的。其实在ja当中，你刚才刚才咱们看，你可以手手动去设置啊，也可以去。

在你搜 sorry的时候，就直接给出。就在这步的时候，你用一个s circuitet的时候，后边可以给出bllo。比如给1个20。啊，是不是有这个东西，你也可以像我刚才那种写法。

就是我得到了我先弄一个soc，啥都不给绑定的时候，我可以绑定动口号，以及给出backlog。

你java上写的东西，其实java嘛，它自身并不是一个真正的一个东西，它是一个虚拟。它最终你他只给了一个语法，给了1个GVM的一个字己码的一个执行的一个环境和底层脱拖脱节。但是他最终还要调到底层去。

这个能听回来上边一，是不是长得很像，因为最终调的就是他嘛。所以有有有好多人，你看网网上有很多的这个文章就说了，说学java要不要学学C。其实你会发现ja永你都会了，往C就是走半步的事儿。对吧换言之。

如果你C会了学java，其实就很头疼的把明向对象这关过了就可以了。但是如果你CC加都都会的话，学java太容易了。就在你的完全在你的掌控之中。所以学CC加加肯定是你有生之年。当然了，先学java挣钱。

😊，啊，捞到一定的这个收入之之后，那，如果C懂的多一点的话，那肯定就是啊这个加分很高的。🤧呵。关键啊这个帮助手措还有一个特点，连空格往下走。哎，你看有这叫examp还是ex，还有这个样例啊。

他让你看C去看啊band这个系统都要用。所以你要看man two band。然后往下走，走到它的exampble这个这个章节。来，这有一个 exampleample。

这个 exampleample当中其实它就是C的，咱们叫inport，它叫incclo啊，导头文件等等的。本来之后，哎它有一个主方法啊，只不过人主方法返回值啊。主风啊里边往下走的时候。

你注意看它第一个是要掉socket，然后得到了一个socket文件标符。刚刚才看它的时候，他其实就反了一个数值，它就是一个整数in。有了它之后，他判断是不是负一负一的话就报错了。如果不是负一。

然后肯定是趋向于得到一个正整数，那就是得得到了一个先先得到了一个s。有了它之后，下一步步事情肯定是对他做了一个，你看绑定。😊，绑定这个到某一个地址上，绑定完了之后，开始listen，监听他。

并给出了backlog。监听如果都成功，都没有报错的话，那往后才是要去做。accept从他accept去去从他身上获得。刚才也看到ac这个调用了。所以man two ACCEPT。

accept里边它也需要你刚才那个sck文件面。啊，那它的返回值是什么？往下找reachturn value。Okay。哪去了来了？啊，这4860如果成功的话，就会返回一个。呃。

一个文一个一个描符for the accept接收的scket。

好吧，以上这些汇总一下。汇总一下，就目前刚才我给讲的东西，计算机里边有application应用程序，有操作系统内核。未来无论我讲哪种IO模型，无论哪种IO模型。

只要是想通过网络IO通信和外界通信你的application。和你的 kernelel内核之间有一个固定的一个环节是不被破坏。啊，只能做修正，不能被破坏。

这个环节就是完成刚才那一套基本的性统调用socket。会给你返回一个文件面符，比如说FD3。这是第一步。有了MT3之后，你要对它进行淡的绑定。绑定到比如8090。放年之后肯定还有listen。

监听我们的LD3。之后。你必须要先就是这串性调用执行完之后才能得到你的next state。我这给你做一个笔记。就这个执行完之后才可以得到一个结果。这个结果就是你通过n state去看。

到NATP去看就会看到一个local的本地的1个0点。0。0。0，然后1个8090。然后对端任何地方呢0。0。0。的任何顿号都可以连我，然后它是一个listen的状态。就是你为什么用nancy的？

可以看到这个这个这个条目，就是因为你的成绩代码中必然执行了这三步。听我同学来刷二波一。大家注意了，这些叫做性能，它是内核实现，它是内核有这些功能。这么讲课行吗？其实说白了这个我讲的这个有点偏细。

有就浪费时间。你说这个东西没必要讲这么细，因为他们学C的未必有我。不我讲的那么细，你可以上网找一些关于讲C课程。就那种所谓的培训啊。其实你就当你就把我现在我和马老师讲的一套计算机组成和IO等等这些课。

你就当一个茶余饭后。俩小时你去看博客或者俩小时来看这一个我们讲这个视频，呃，看视频可能就更生动一些。对吧。Okay。好，这就是应用程序必须要走完这几步才能拿到这个状态。这个状态有了之后。

那么接下来你的程序会调一个系调用。因为listson有了之后开始要调一个一个调用了，这个调用就是。Accept。然后从你刚才那个LD三身上，他想得到点啥？就是在等待客户端的连接。

那这时候就进入了阻塞状态。就开始进入一个组合状态了。对吧这是第一个组合点。如果这个组织状态过去了。那你得到了一个新的连接，这这你脑子一定一定有概念了。在你的一个程序的生命周期里，尤其服务端。

有两类scket，一个是server socket的，就是listen。就是这个3FD一类就是别人和你就是就是客户端那个联通的那个连接啊，比如说得到了1个ID5。这是两类嗯，listen呢可能只有一个。

但是面向这个listen的FD3连就是这个s给连进来的，就是面向这个8090连进来的FD5678910可以有很多连接。这个数可以很多。那第一步这可能会有一个阻塞。Blocky。但是组册过了之后。

就一定会有一个返回值，一个一个客户端连接。当有了客户端连接之后，下一步你要想读它，想读它读的时候注意就是receive。想读这个ID5的时候，它又有可能进入一个阻塞状态。

那也就是说在现在我刚才那个java代码当中，有两处可以阻塞，一个是客户端连接阻塞，一个是独取阻塞。我是怎么解决这两个阻塞的，怎么解决两个阻侧的，是用的现成的方式，也就是说抛出去一个现程。

这个县城里做了一件事情，把因为这两个组册如果在这个同一个县城里边，那我在等待别人输入东西的时候，我就不能做接收客新的客户端。那新的客户端要等很久才能接进来。所以我把这两类事情拆开了。

主线程里边就永远着做一个死循环，接受和克隆接受和克隆接受和克隆。然后克隆里边去每一个克隆书的线程去读取。阻塞在某一个连接上。お。对。Okay。对吧这里面只需要做克隆就可以了。对的。

这就是我刚才那个java在BL模型下的代码逻辑啊，如果转这使用完转圈回来之后又接收1个FD6，那这时候再再去抛出一个新的线程。这个时代叫做BIO时代听同学来说波一。是以。好。好吧，那么。十0点半了。

今天不能就讲这么多，就讲到BIO的开始，主要是把上面TCB的东西讲完了，然后BLO又开始下节课我们就全部趴在NLO上。也算也算隔的隔的比较干净，好吧。行吧？同学们。嗯。你。同步阻塞的情况。

s给的同步调用s的阻阻阻阻塞，你是发送阻塞对不对？呃，是这样的，发送一般不会阻塞，什么时候发送会阻塞就是。资源消耗来不及动了，那个时候会有一个阻塞。很难模拟出发送啊啊，对，没错，发送队列如果如果慢了。

发送队列怎么制造出摊慢嘞？我就要把对方的。发送慢。我我我我想想吧我想想吧，好吧。没有。对。nike卡夫卡能经典讲讲吗？呃，知识是有依赖的。我下节课讲完NIO，我可以给你讲n。但是这节课没有必要。

因为你现在依赖的东西还不不不不多。别着急啊，慢慢学慢慢学来了，我就踏踏实实学这样东西都能给你讲明白。连服务器的同一端口号，同1个80端口，客户端可以连比6535更多的连接吗？你等会儿啊。

这个这个我来我来来答一下疑啊。连服器的同1个80端口。客户端可以比665535更多的点，这是啥意思？你们给我讲谁谁谁谁能听懂了，给我给我解释一下。嗯。你们回答行和不行的，你们是怎么读懂他这句话？😡，え。

Yes对。Yeah。有个80服务，同一个客户端能超过6535个连接吗？首先我知道你什么意思了，你要对这个。客户端这个词儿能有什么意思吧？哎，找到这个一级痛点一级痛点。就是你怎么理解clant。

这个语义的。对吧你怎么理解cllan那个语义的？你如果对clan这个语义能听明白了，那这个事就好理解了。你比如说像我这张图当中，我的server application。这是一个一个server。

但是你看我下边把什么描述的，我刚才你如果回去翻我的视频，你去听啊。我说如果有一个客户端。连完之后，我说还有一个客户端，我说但是我说了这个客户端可能和它是同一个物理主机的。也可以不是一个物理主机的。

但是它是一个独立的连接，这个连接可以被抽象成客户端。你这样去理解这个client。然后其实你想表示的一个是一个什么意思？你想表示的是就是一个进程，对不对？或者你很模糊客户端的一个概念。

你说好像就是一个主机，这一个主机里边的一个进程能不能对一个服务端超过6535。的连接数。啊，就是一个主机，一个电脑，对不对？啊。

一个操作系统内因为他都不他说的应该都不是一个可以理解成一个一个电脑或者一个进程。啊，这个这个这个我这个理解对了，这个。对吧但是我这给你讲怎么回事啊？你只要保证4元组为一就可以了。比如说这台主机上。

你可以做绑定的嘛，在连接的时候，然后你的你看if con。我现在的IP地址有1个1。118150。11。如果你是公网IP的话，你你你或者你在通信的时候，这个网络是不需要地址转换的。

你是可以做一个if con。在ATH0。这个子端口下。设置1个192。168。160。1211。让24。160。11150。11，他们两个各拿到655356万多个端6万多个端款号实际申请连同一台服务器。

通过这两个就可以起10多万了。

你只要保证4元组为一就可以了，能区别能区别出来，这就是TCB的语义。sock it你给我保证那一点就可以了。对吧。刚才那个问问题呢那小伙伴呢。听懂了？听懂你就敲个一。如果你IP都不能改的话。

这事这事甭想。我。对。Yeah。好吧，那今天咱咱们就讲到这儿，然后再把资料同步一下，放到KT up上。嗯。

系列 3：P189：【IO／NIO】C10K - 马士兵_马小雨 - BV1zh411H79h

Yes。这。首先。有两件事你要做。第一个事儿有一个。帖子吧给你们发一下。嗯几篇文章啊。就是架构师嘛得得懂这个东西，有1个C10K的问题，尤其在IO的。

因为我上节课讲的是BIO甚至讲BOBO是你们应该都容易理解的，最容最最容易理解的。因为它是一种朴素的一种线性思维，就是来了一个链接，我认识出一个线程就来了一个链接，扔出一个现程现城自个往自个。

🤧随时给这一个自己去看一下，然后说看不懂的话，你给他翻译一下。我我可以很坦然的告诉你了，我也看不懂那些那些字母。然后我也是翻翻译，翻完之后，其实你从上往下读读读读一遍，读两遍，从三遍读四遍。

反正一些单词进入大脑。然后呢，我可能要去查，你就听我给你讲就可以了，好吧。哎，这个这个都大家一定要去看要去看，肯定百分之七八十是你看不懂的。但是你要看他那个因果关系，看因果关系。

比它里边描述的是一个什么事儿，你可以把它当当做故事。来完成你对碎片知识的一个穿插。C时K是啥问题？说的就是在互联网蓬勃发展的过程当中，对于单机服务器来说，连接数从一个2个10个百个千个万个C10K的话。

K就是100010的话，那就是10乘以1000是1万，那一万个客端连接会会促触发很多技术，我们让你一万个连接能进来，其实能给他们提供更快的处理，但是现在都不是C10K了。

C10K或者C10兆的问题百万连接，几十万连接，但是需求都会有。就是如果单机能力强了。即便单机能力有上限。但是如果你把强悍的单机每台机都都是很强悍，组建的分布式，这个时候才有意义。

如果你一味的做多机分布式，每台机能连5个人。那其实你要付出很多的成本。那在在做巨大的是什么？这事可能就不做了，能理解吧？啊，所以单机为什么强调你们要学设计模式，学DVM学调优单机能力强的人才符合。

和这个软件工程学当中那个职位。好吧，这个这说说说这些都没没用啊，这一个这个事自己去学，当故事听就可以了。另外一个简单回顾一下。上节课我们讲的是网络IO。

然后整个变化和模型的推导当中的第一个环节BLOBIO呢是大家非常容易理解的。就是当用新的连接进来之后，然后呢，我的主线程然后去接收accept接收得到我们的这个连接，这个客户端。

然后并克隆出一个新的线程，由这个新的线程当中去receive或者read去读取那个连接未来发送的数据，因为accept是阻塞的，然后读取数据就是得到等等待连接的建立是阻塞的，一直等着。

然后呢读取数据是阻塞的。所以在并发的情况下，由由一个线程去等着别人的来，然后排队的挨个处理每一个到到到达的人，然后并把每一个人的发来的数据由绑定到独立的线程当中。那这样的话，他们即便有发生阻塞的时候。

也会阻塞其他的这个这个这个操作。好吧，这个很简单就可以得到1个BL的一个模型，这个都都容易理解的。这块没问题，来敲波一。但是随着刚才我抛这个C10K的问题的话，那随着连接数的变大，随着连接数的变大。

那么开始抛问题啊。如果就说C1K。也就是说会有1万个人连接进来，想和你的服务器建立连接啊，那你是不是要抛出1万个线程呢？那抛出1万个线程的话，由前面讲机组的知识，计算机组成的知识啊。

你应该知道现程抛的越多。其实这时候资源消耗越多，浪费在内核调度，然后浪费在用户台内下的切换。然后浪费内存的空间这样的等等资源的消耗反而越多啊，性能更低。那这个低不低呢？但是我我刻意写了一个小代码，啊。

我刻意的写了一段小代码。

这个代码什么意思？就能先过一下。正好把前面这些知识给你固化一下。前面我讲这个。

通信的时候，我说过有一个4元组的概念，还有印象吗？就set的是4元组。啊，资源组也就是资源组当中只要有一个东西能够唯一区分，这个suffage就会成立。然后在这儿我写了一个小程序。

是在我windows当中写了一个主线程，并没有抛出更多的线程。

在这一个windows的一个物理主机里的一个物理进程里边，这是现程或者进程。这一个现程里边。然后我要做一件什么事情？我准备了一个对端，就是服务端的地址是150。11，端口号是9090。

一会我会在我的linux操作系当中去启启动一个9090的这样的一个进程端号绑定上这是对端，那在我windows上做一件事情，复循环起始值是1万终止值是665000。

那么也就是说循环一遍会有55000的循环次数。那在505000的循环次数里做一件什么事情，我准每循环一次准备两个客户端，这两个客户端，一个绑定windows上的一个150。1的IP地址。

一个绑定的是110。100的地址。注意这是客户端，对，这不是sck channel，这是scket，也就是我的客户端，我我把他们两个就是个。

之后绑定完各自的IP地址之后，我会让他们去conect个连接我这个serv。也就是每循环一次会有相同的端口号和不同的IP地址连接相同的IP和端口号的服务。那这样的话。

55000的循环次数乘以2会也就是我会用windows的单机单进程对一台服务器发起11万的连接。也就是突破了端号的65535的限制。这个能听懂同学拉刷er一，这是我之前讲过的资源组的概念，对不对？

然后呢，用这样的一个很大量的一个循环快速循环，然后去创建连接这件事情，我会把BLONL和多路服务器的三种IO模型都用它去连接，然后感受一下他们在接受连接这个行为上的性能和速度。对吧就是有两个知识点。

第一个知识点我会让我会我会告诉你验证思源组这个事儿找什么就可以。但是这里边会一个网络上的一个小bug，我也会给你演示。然后另外一个知识点就是那我咱们为什么要学不同的IO模型。

那么IO模型其实带来的是性能？行为是会让你用肉眼看到。那么下面同学们问了一些问题，说自己设置的IP是啥意思？绑定IP啥意思。Yeah。在我这台windows主机上啊在我这台windows主机上。

我呢其实有一块有线网卡是10。100。

打开本地连接。然后找到你的以太网，然后更改适配器，然后看啊就是大家电脑上面就是这个支点，大家都知道自己会一块网卡网卡呢会有自己的一个地址。比如110。100啊，这是你连接外网用的。

然后当你装了vi more虚拟机之后，注意听啊，当你如果你装了vi more虚拟机之后，它有一个它除了能帮你帮你创建虚拟虚拟服务器，也能帮你创建虚拟网络，在虚拟网络里边。

我们的主机使用的都是net网卡这个这个网络模式。所以所有的主机都会接入到这个微net8这块网卡上是net模式。它的这个网段，我的网段是150。2，写在我的windows上会有一个net8的这么一块网卡。

windows上会有一个地址是15。1。也就是你不要想外接啊，你就想window自己是一个人，他地端看自己，它自己是不是有俩地址，一个是150。1，一个是是不是100。1。那我自己想往外发数据包的话。

我可以把我的数据包无论发给。内网和外网，无论分为哪，我其实的原IP地址可以在在这两个地址当中随便挑一个作为我的原地址。这个理论能听出来。邵边一就是你只需要看一台物理主机，它持有多少块网卡。

上面有多少个IP地址，它的数据包的原地址可以在里边随便挑一个都可以。因为这个地址就是他自己的，无论在里块网卡上。

对吧那这点也要盖到。所以你再看我代码当中你就不稀奇了。在我windows上有一段代码，他期望的就是哎我有两个socket要创建，并且两个socket，一个是原地址设置成我已有的10。

1另一另外一个socket设置设置的是我已有的110。100，这两个都是我自己的IP地址，只不过登录号，我会让他们使用相同的登号，且连接的服务器是相同的服务器的IP地址和登号，那也就先验证。

那在相一台windows上，比如都是都是1万都是1万动号，那目标都是相同的地址和登号。那么只不过你使用windows同的IP地址，这连接能不能创建出来，对不对？这就是所谓的只要4元组当中一个不一样。

是不是可以创建。这个整个我这代码的逻辑需求能听出来说边一。🤧150。2是相当于V微 more的那个路由器，然后呢并在里边发生了一个net及时转换，这就是一个坑，一会儿给你演示出来，好吧。

这个代码也能理解啊，这个代码能也能理解。然后再来看这张图啊。

回回归咱们这张图，这一会儿验验这个四元组，回归到这IO的这个模型的变化当中。现在是BL是多多现成的方式。一会儿我会把这版代码跑起来作为服务端，然后用我刚才那个C0K代码去压它一下，看性能如何。然后呢。

我们得出它的快慢的感受。啊，我们来得到他的一个快慢的这个这个感受。然后先去验证一把吧。因为后边我在讲NIO和多路复容器的模型，这三个IO模型的时候，我都会用相同的客户端代码，就是这个代码。

去压测，然后去找到他们的这种这种这种速度的差异。

先来先来搞一版吧，先来搞一版，眼见为实。

来晚了一丢丢不急呀，有流波的。那么在我手里边会有t呃，有tcket，测试我们的sockcket有测试我们NL的，有测试我们多路复云器单线程的，有测试我们多路复云器多线程。啊。

还有这个传统的这个这个不用管。我们先看那个t soft代，很简单的一个。这是基于上节课的知识，所以这个应该都是你能看懂的。它就是在当前主线当中启动之后，得到了一个sloof绑定这是8090，这应该也是。

我用另外一个。Soocket。helello。Aportice，这是我们上节课的代码。这个代码当中是。啊，这个是用了一个so socket，然后下边会有一个循环。循环里边会有s点accept。

然后并扭出现程，在现城里边要去读取。好吧，这是多线程BIO的多线程在一个主线程里边会去accept并得到的客户端会全全部抛出线程。每一个县程持有一个客户端，这个代码能看懂同学来说说一，就这个逻辑啊。

你可能上一课没没没看到，但是这个BIO逻辑应该都懂。那我第一件事情先把这个服务端跑起来，把服务端跑起来，用java C去编译st IOproport编译成功之后，用java调起st IOpro这个类。

但是这个时候注意听啊，它跑起来之后，它绑定的端口是9090。然后呢，我们来看用抓包来看一眼我的数据包能不能过来了，就用TCP。杠杠NN杠IETH0。然后抓的是号号，端我号9090。

用这个特征去抓在这个网卡上。回车，然后抓包的程序在这阻塞着，然后我们把我们的服务单机跑起来，跑起来之后，然后去执行我的这个后端代码，就这个CJ的这个测试这个这个这个这个代码，他会拿着两个ID址去去连啊。

然后我们来走待机开始启动。

启动之后，然后再来看代码这边的提示。啊，这边你看一万是不是连一个客户端连进来，哎，但是没有出现很多的连接进来。然后我们来看抓包里边，你能够看到的是150。1。

这个是我windows那个vivo8的那个网卡，拿这个地址绑定一个1万过来的。然后它也会尝试拿10。1001万进来，想去做连接。也就是说真的我的客户端windows里边会拿两个绑定地址。

会拿相同的端口号，会拿相同端口号去尝试和我的服务器的相目外地和端号去连接。这个资源组织成立了。只不过这里面会出现一个问题。

你没看到连接过来的客户端是1万10011002，不是1万两次，1万01两次，1002两次。先不要管那个慢的事啊，这里边有一个小bug，能听懂我小办达什么意思呢？按理来说，是不是我每巡你看这边还报错了。

超时这个超时了，是不是按理来说我循环一次会拿着15。1连1个1万。然后10100连1个1万。所以我服务器里边应该打印的话，是一个客户端1万，一个客户端1万会赚两次。这个问题发现了一个问题。

同学来说2边一。

对吧那那个问题是啥？你会发现我把这边今天这个事给他结束一下。在我1。1。到服务端连接S握手，然后成功了。然后100。1万过来之后，然后你会看来了。然后我们11这台服务器也给人回了。

但是这时候却发现后边并没有那个ACK确认这件事情。并不有ACK确认件事，又又想重新给你们这个这个尝试握手一下。那其实这里边会断片了，为什么断片儿？可能说不在同一个网段。那这时候来就发现一个问题啊。

就是我windows的客户端会拿着100110。100。这个作为原IP地址目标IP地址是10。11，会去访问它访问台服务器。那也就是说回去的包有没有回到windows上，那我们来庆一下。

你们发现这个通路是不是通的？啊，跟着我思路，待会我给你画图啊，那个你先跟着我思路走，也就是我lininux是可以并通1。1816。100，那也就是代表着客户端如果拿着这个地址的数据包过来，应该也能回去。

对不对？是不是应该能回去？但是为什么10。100这个地址的连接却没有被创建上呢，却没有被创建成功的，只有10。1的那个345成功了。这里面有一个知识点，就是看路表。跟他搜索啊，看路由表。

在我的路由条目当中，你要明白网络啊，明白IO这块你一定要明白。面向我这台linux操作系统。他呢有一块王卡。网卡的地址是150。11，言码是3。51个0，也就是它的网络号是150。0。

也就是通过lininux是可以直接访问150这个网络的。但是就看这个路由表，你来告诉我这台lininux和1。18110那个网络是直连关系吗？是直连关系吗？就是如果P192点168点110。100。

是不是它不是直连关系，因为没有专这个条目，对不对？那这时候如果相反他其实是走了默认的这个网关，也就是数据包可以进来，也就是一个原地址是10。100的数据包可以进到这台主机，我返回的时候以它为目标地址。

我还能给你返回。但是返回一定要看路径，返回的时候，它只能走这个默认无关的一这个这个这个条目走默认无关就会以谁为下一跳，是以150。2为下下一跳。那么150。2是谁？150。2。

就是我们微 more的虚拟网络当中的那个。的8里边呢，看啊它的网关。这个网关是谁？这个15。R是谁？其实这个网络叫net，其实就是windows上的一个进程。这个进程在完成一个nett地址转换。

看网络分布式，我讲reads的时候，不是讲负高频发负载均衡的时候，我已经讲过n地址转换，这块不懂了去回去那去补一下。好吧，那么知道这个知识点的同学就应该现在明白了。

其实windows客户登数据包进到了linux主机，只不过回去的包走了10。2，1么要做了地址转换，它会把原地址换成什么呀？换成150。2。

听懂这句话的同学上边一，其实在我来的数据包当中是客户端是以什么呀？192。168点110。100回元地值，目标地是151。168。点150。11作为目标地址。

这么这样的数据包紧进到我的wininux主机了。但是这个数据包如果以10。100返回给客户端的时候，那么它是目标地址，它就变成原地址了。它作为原地址。

但是这个是目标地址只能走这个路由条子就扔给了这个10。2扔给他之后，他会做net地址转换，会把150。11换成10。2。那这时候回到windowswinds就不会认他。

因为wind度从来是想曾曾经是10100和15。1，而不是和15。2，所以不对称。所以三次握手第二次回去的包被windows丢弃了，所以这个连接根本就没有被建立上。听懂学来说个一。

那么如何解决这个问题啊？哎，如果解决个问题，就是不让他走这个net转换这个条目，这个默认网关。其实走只要能因为我windows上是不是有个10。1，然后我的下一跳不是10。2是10。1。

只要扔到windows上，是不是windows就可以根据本地的路路由条目交给我对应那个那个回送的一个客户端，对不对？只要加一个路由条目，你看ro条。ad杠house添加一个主题条目，这个主题条目是谁？

就是192。168。150。点1我想10谁后端谁啊，11这个10110。1的，因为你的目标回的目标地址是不是这个地址？就是你你刚才咱们这个数据包，如果回去的目是10。100，那这个数据包扔给谁不能走他。

那他的吓一跳应该是谁？他的吓一跳是KTV网关是谁呢？是1。2。168。150。1。0。1就是windows上那个网卡。因为linux自己在150那个网络，linux自己的是11。那我的下一跳是谁？

和我同局网的windows那块网卡，一是作为我的吓一跳。然后只要是目标地址是这个数据包的，就往那个windows网卡去扔，就进了windows了，进了windows就会找到我曾经那个客户端添加。

先看我到儿给你话筒你就明白了，但你要先跟着速度走，你先看到这个东西，你现在看到了是不是会有一个路由路由条目，就是。直达10。18的是要扔给10。1，对不对？能看到这个这个这个条目吗？这个条目能看懂之后。

我们再把服务端启动一下。把服务端又跑起来了，你看这时候进来了，是不是？是不是就两个两个叠加进来了，然后把它整个整整体结束一下，重新走一遍，就只加了一个路由条问题就解决了这个问题。啊，服务端那边也停掉。

跑起来哎，他已经跑起来，他就能已经跑起来了，然后这边再去执行。

然后看哎1万100110023456，他们会有一个差，但是也也基本上程度出现了，是不是程度出现了，不光是程度出现了，你再用这边的。

net state杠NATP看连接连接里边是不是会有同样是我服务端的一这个10。11，然后9090的会有来自于110100的，会有来自于10。1的。只要保证4元组中有一个是唯一的。

有一个是唯一的这个sty就会成立就能区分出来。现在能get到这个点回来说不一也就是说，其实这个东西如果一直让他跑，虽然很慢，虽然很慢。我一直让他跑一直执行下去，我这边的一个进程。

就可以对一个服务器发起11万的连接。

嗯。就突破了6535，其实6535还是针对于什么呀？就是一套资源组里边的啊，那么这个客户端端口号就是剩下三个维度都一样。那端口号的变化的变化的这个区间就是6535，对不对？

而且从现在可以看出啊，速度并不是很快。发了吗？速度的连接的间变速度并不是很快，为什么并不是很快？第一个问题解决了，就是同一个我可以建立实施，就是只要深组唯一，我可以建立很多，对不对？

文件文件文件标书没有上线这个事儿，我但是用另外一个例子给你演示啊，这个这个等到那个达到那个突过了1024的话，有点慢，待会我给你演示的。主塞嗯。是完全是阻塞的问题吗？这对我给画图啊啊，看个C。

就是你把这事儿想把IO这事儿一定要想明白了，好多事你可以理解了。

系列 3：P19：【多线程与高并发】设计小程序验证锁的问题 - 马士兵_马小雨 - BV1zh411H79h

还有同学给我们继续啊，嗯后面代码呢前面几个几个小代码也不难，我讲的速度呢稍微快一些啊，看这里嗯，我们来分析一下这个小程序，它的输出有没有什么问题，sorry，will they go。

啊是这个啊005这小程序的输出，你仔细读一下，看着小程序的输出又没什么问题啊，另一个thread是吧，然后呢start start呢让count呢不停的减减，好，这小程序的主要的问题在哪呢。

主要问题呢有两个，刚才那个我看有同学说没有写过，他对嗯，这是一个啊嗯但是，严格来讲呢，这个小程序呢，其实跟那个沃坦没有太大关系，就是另外一个呢，他有可能嗯读不到别的线程，已经改过的内容，这是很有可能的。

除了这一点之外呢，其实它本身还有问题，问题在哪儿呢，就是这个count剪完了之后呢，下面这个count的输出，和你看的剪完之后的结果不对，这很容易分析，如果有一个线程从十把它减到九了。

然后另外一个线程在第一个前面的县城，还没输出呢，另外一个线程进来了，把九又减到了八，前面这些能继续输出，就把这个八给输出出来了是吧，他输出的那个不是不是不是九啊，所以他呃这个呢是有这样的一些个毛病。

那第一个呢是上面加volatile，这边改了之后，另外一个呢马上得到，除了这个之外呢，其实最关键的呢，你还是要在这里加synchronized是吧，这程序比较简单，就不多说了。

加synchronized呃，那我问大家一句，加了sronized的，我还用加volatile吗，当然现在还没有讲vlta，所以我简单提一句啊，加了synchronize就没有必要加播了，巧了啊。

为什么呢，因为civilized既保证了原子性，又保证了可见性好，我们讲volt的时候再说，嗯就是这个小程序啊，来看第七个c007 里面的这个小程序，呃这也是会被有有可能会被问到的。

就是同步方法和非同步方法，是否可以同时调用，诶什么意思呢，就是我有一方法看见了吗，m1 sychronized，我掉点mv的时候能不能调m2 可以吗，这个可以不可以，你拿大腿想想，其实就能想出来。

你都不用不用试，这肯定可以啊，必须得可以啊，你本来这个县城里面访问，访问m一的时候呢，需要加个锁，可是访问m2 的时候我又不需要加锁，所以你还不如不让我不允许我真想m2 啊。

所以问这问题的人脑子都进水了是吧，开玩笑啊，你本来在这儿正在运行，你往这一坐，正在运行是吧，你是不是也上个锁，前面得把这门锁上，这是必须的，可是人家有别的方法，别的方法是什么呢，人家后面有一擦马桶的。

擦马桶的不需要这把锁，直接就可以擦，是不是，所以你运行这是m一啊，运行你自己的事，这是m1 ，人家参考筒，这事是m2 m2 不需要加这把锁，在你运行的时候，人家直接就可以在后面参考桶啊，没问题。

当然呃讲到这儿呢，听我说啊，有很多的那个呃原理性的东西啊，这原理性的东西，还有一些细节上的那些状态的迁移等等，关于这些东西呢，你如果能够写程序去模拟，让它显示出来，这是一个很好的能力。

呃，所以很多时候呢，你要去想办法去做这个方向呢，做这方面的模拟，你能把这个模拟的程序想象出来，怎么写，对你也是一个很好的锻炼，所以以后呢有什么别人给你讲的，什么的知识，你都想要想办法去写程序。

模拟它下好吧，只要能模拟出来的就是一个很好的锻炼啊，呃不然的话你只能说老师告诉你是什么，你就认为是什么，你是没有办法做实验去验证它的，我写的小程序期间，中大这小程序m一是枷锁的方法。

然后在枷锁的方法里边m m e n，呃中间睡了是10000ms，然后m2 呢是睡了5000个毫秒，输出来的一个m2 ，那么大家可以想一下，如果说我对m一加了锁之后，它不允许m2 执行的话。

那它必须这肯定是m一结束了之后，才会显示这m2 ，如果中间显示出来了，那就说明肯定是允许m2 执行的，是不是啊，同学们，所以我是这么来设计这个小实验的啊，这小时间的设计也比较考验功力的，同学们。

所以你们我告诉你们的，任何的这种这种多线程的，或者是这个虚拟机的等等，各方面的这些个理论上的东西之后呢，你要自己去想办法去写程序去实现它呃，你比如说我我，我说那个你一点区对象满了之后呢。

它就会产生y d c，那我怎么去验证它，你得写程序能去验证它，好吧，这其实是比较有功利的，然后写了两个小程序啊，new thread t一执行m1 ，t2 执行m2 ，运行一下，看结果。

t e m e start是吧，你看m2 出来了，接下来md才结束，说明什么，当然允许人家在后面擦马桶，啊这个小程序有没有同学有疑问的。

等你是吧，好继续啊，好如果没问题，我们继续，我们再来看一个synchronize的应用的例子，这是模拟一个银行账户对业务方法的枷锁，对业务写方法加锁，什么意思呢，看这里。

我这里定义了一个class叫account账户，账户有一名称，有一个余额，balance name和balance，写方法set给哪个用户设他多少余额啊，the surname name。

the balance，balance，读方法，get balance，通过这个名字去得到这个balance的值，方法呢都相当简单，那好如果我们给写方法加锁，给读方法不加锁，会不会有问题，其实这个呢。

好这个过程呢其实呃，不能说它有没有问题，而是说你的业务呀，容允不允许你产生这种问题，如果你的业务说呃，我中间读到了那些不太好的数据，也没关系好，那这个时候呢其实也就没问题啊，如果说你不允许客户读到那个。

中间的不好的数据，那这个就有问题，这，因为呢我们加了锁的方法，和没有解锁的方法是可以同时运行的，同时运行的是什么概念呢，就是说如果有的人啊，你比方说张三诶，你给他设了100钱启动了是吧。

然后睡了一个毫秒之后呢，去读它的值啊，然后再睡个两秒钟之后又有多大的值，这个我需要，要做这个实验的话呢，需要把中间打开啊，set的时候呢先设好它名字，然后两秒钟之后再设它的值，才能模拟到这个效果啊。

实验一下，这个问题呢肯定会有，你会你会看到你读到的呢，你本来说的是100，但是你读到的呢是一个零呃，多零的原因是什么呢，是因为呢你那个在设定的过程之中，这点内幕完了之后呢，你中间睡了一下。

然后在中间这个过程我模拟了一个线程，在这个时候来堵，这时候来读的时候调的是get balance方法，而调这个方法的时候是不需要加锁的，所以呢我不需要等你整个过程执行完。

我就可以来读到你中间结果产生的内容，那么这个现象的叫做曾读，叫dirty read，叫脏读，如果你想解决这个问题，这个问题的产生就在于，sirnet方法和非siri方法是可以同时运行的。

想解决这个问题怎么办，简单你就把get balance也加上synchronized，就可以了，啊关于这个小程序，看有没有同学有疑问的，当然我再说，我再强调一下啊，如果你的业务逻辑允许，没问题啊。

读到中间结果啊，没有关系，我读完了之后，反正我也不做任何重要的业务逻辑，我就读一下就就ok了，也可以也没问题，你就不用加锁，能不加锁就不加锁，加完锁之后的效率低100倍好吧。

有逻辑允许不加足，那就别加了，如果不允许就加上sn，但这个小实验，记住呃，看着这个面试题来写。

你不要看着我的代码来写，你们那个做这个面做这个题的时候呢，不要拿我的代码在旁边跟着这么来做参考，而是自己想象着自己手动的把它写出来，因为你去面试的时候，不可能说你旁边有代码啊。

系列 3：P190：【IO／NIO】拓扑结构 - 马士兵_马小雨 - BV1zh411H79h

首先我先画一下我的to结构，我是不是有一个linux。这么讲，没问题吧，我是不是另了一个地址，192。168点150。11，这是他的地址。那么这个地址其实我说了，我的整个还有一个windows。

系个 windows。加我我这个。我琢磨了半天啊，我我我您可我讲的慢一点，这节课讲的累一点慢一点，讲的东西不多。但是我一定要给你讲明白了。因为通过最近大家问问题，我发现了网络，尤其IO这个环节。

大家很多问题都想不明白。所以我这块我宁天给你讲明白了啊，你烦也不我我我也不看啊，那那个一块网卡，然后我windows上有2块网卡，一块网卡是1。2。168点。150点1这个案子地址。

然后还有一个地址是192。168。110。100。Yeah。有两个，然后呢，我们会有一个东东，这个东东是微莫尔。它是一个软件，它除了能给我们模拟虚拟机，还能模拟虚拟网络。所以它呢模拟出了一个网络。

这个网络是什么？这个网络是1个192。168。150。0这个网络网络号是150。0。他不止给你维护这么一个一个网络。这在网络当中，它有一个东东，这个东东叫做网关，也就是它的net。一个地址，192。

168点150。2。有这么一个所谓的网关。那也就是说其实不应该拿过来画。あ。今。终于看了一个对应关系。如果vivo有虚拟这么一个网络，然后网这个网络里边还有虚，还有windows上还有一个软件。

一个一个进程。这个进程其实就是15。2持有，就是vivo的那个net服务啊，vimo的net服务。那个service。带你看一眼吧，就是找你的电脑，然后管理。管理里边你可以找你的服务，然后服务。嗯。

V到we more，它是不是一个net service啊，we morenet service它也能运行着它其实持有的就是我们19219216815。2这个地方。然后这个时候它是有这么一个过过程的。

那么它转完之后，注意我们windows上一块网卡，这块网卡是连接的物理网络。啊，那个物流网络。然后呢，10。1就是vimnet8那块网卡是进到这个网络了，linux已进进到这个网络了。

所以这时候其实为什么你的windows上如果有一个程序。你的windows程序程序可以是叉 shell，可以是你的浏览器。为什么可以访你linlin linux里面那个进程？

就是你windows上有一块网卡，这边是可以把数据包传递过去的。🤧先讲nty啊，你可以把这节课关闭。然后到后边讲ny的时候，你一听哎，新讲的nty对不对？但是你会发现好多事听不懂。

所以你要回来补这这这节课的视频，好吧。那么window的程序可以通过这网卡把数据包传递过去。但是这时候刚才我的程序当中有这样的一个设置。这个重序设试当中是192点，我会绑定我192168点150。

1作为圆，然后加上一个随机断口号，这个逗号比如说1万。我还会产生另外一个所谓sockcket的，就是我想拿着110。100，然后加上1个1万，这是我windows这个程序在这个。

这边创建创建绑定那个sD客端的时候，会有15。1和100这两种绑定方式。然后他们目标都想去访问谁，都想去访问我这边的一个。

9090，那这时候看其实winds也有也有路路由条嘛，就是这个如果他的目标地址。就是这个不管怎么样，只要目标地址是1。2118150。119090。这时其实你看路由条目的判定嘛。

windows也会做路由条目的判定。windows上是不是会有一块网卡直连了150这个网络，就是windows有一块网卡，所以windows直连了这个网络，所以目标地址是10。11。那么10。

11就在这个网络。所以无论你客户这个这个用程序，你的原地址绑定哪个你windows自有地址，这两个数据包就一定会从这个程序，通过windows。

然后通过这个虚拟网络发到这个linux上就是过去这个过程是靠windows有一块网卡进入这个网络。所以它的路由条目就一定发过来，这个能听出来，稍微一就过去的时候是肯定能过去。对吧那么当过去之后，哎。

这两个都过去了，过去完了事之后，是不是比如握手第一个包过去了，过去之后是不是得返回包，返回包的时候注意他俩叫三个个。那如果目的。地址是10。1和目的地址。就特殊标准来啊，这目的值是110。100。

这两个返回的时候概念就不一样了。因为你这个如果这个数据包返回的时候是10。1的话，那15。0这个网络是不是自己直连的，它是不是直接把它扔扔的这个网络，然后直接就交换到这台机子上就就就回来了。

所以握手的包过去握手包返回再确认的包都能来回走，就是基于这个地址绑定。但是你要这里面难受的是谁，难受的是110。100。如果以这个地址。作为目标地址的话，那这时候会触发windows路由条目。

让他走什样。就是走到。吓一跳是10。2就走到这儿去。明白吧？就是让这个数据包会走到这儿，但是走到这儿之后，也就是如果这个数据包走到了net地址转换，比是下一跳是1。2话，交给他就是吓一跳。

并没有并没有他而走他就是ma地址绑定是他的骂地址直接扔给他了，扔给他之后，他其实会变换一下，变换成原地址是目标里还是1110。10，但是这会被net转换成2，就转成他地址，证号号可能还还要随机的换一下。

比如换成了19090。这是所谓的地址转换，就转成这个这这这个效果。但是这个效果转回来之后，它即便说能够进到我这个windows里边来，因为windows里边有了一些东西嘛，就即便能进到windows里。

但是这个数据包在windows录入表一判定的时候，就是windows通过这个软件收到了这样一个包被转换出来的。但windows一看。这交给谁呀？因为所有的程序当中都没有一个set。

说来自于110100和1。2的那个sulet。所以这个包都被丢弃了。windows windowsdows不接受，因为没有任何的程序，曾经有这个期望。因为他们都是和15。11的，也就是为什么回包会丢。

为什么我加了一个路由条嘛他又能回来？

系列 3：P191：【IO／NIO】Linux速度慢的原因 - 马士兵_马小雨 - BV1zh411H79h

对吧OK那么这是第一个知识点啊，给你补全一下。另外一个就是它的速度为什么慢，速度为什么慢？这里边你要明白，就是把这块要放大了，这块要放大，刚才是整个网络拓谱。那么把它放大之后，你要理解了。

在我的整个程序代码当中，我会有一个服务端。有一个服务端，服务端，我代码逻辑是就是类似我上面这个这个代码逻辑啊。但是整个逻辑你要想明白了，服务端它先是一个主线程。我把内核服务端的内核标出来。

内核那其实一个客户端，我们先说一个客户端，你把它是在放大嘛。如果一个客户端来了。so这个s有事都不用管了，这客户端反正已也来了。当一个客户端。连进来伸走三次握手。un似work这事儿。

无论你什么IO模型，这块是必走，它是必走，这个没有什么争议。但是un似wo之后注意注意听啊，是你这个主线程当中是不是在一个死循环要accept。这一个死菌丸，他准备的。

except并当你这个accept这个由就是他村子口来了之后，时间到达之后，except有返回值了。但是这个返回值注意他要做一件什么事情，要抛出一个线程去，要克隆得到一个线程。Sund。

那么抛出一个线程，这个得到side这个过程当中，其实它这里面完成了那核，就是这里面这个线不应该这么去掉。就是在这个位置要得到这个线程，它这个程序和内核当中又一次系统交用，就accept是一个系统交流。

这个走掉，但是关键是exccept接收一个图端之后，它要多发生一个。克隆的性交用来得到我们的这个现程。这才是弊弊端。就是抛线程这个事儿速度有点慢了，有心得用，那用上也没再切换。然后呢。

那会儿还要去做做线上那件事情。啊，创建线路创建线成之后再回回回回回过头来，它才才能回到你主线程。你主要人才能去接收其他的口端连接。因为这里面是一个循环，一个阻塞的。

accept是一个循环阻塞的过程线性的。就是慢就慢到这儿，这是主要的罪魁祸首，就是会一个克隆线的过程。到这儿能听懂您来说个一。这一个是这样的，另外一个客户端来，是不是也是走这个流程。

走这个流程前面这段是抹不掉的，关键后面这段是重复操作，重复操作，不是工作现制啊，这这个慢了。好，我们找到弊端之后。啊就是抛现的这个事儿有点慢。那有人说啊我们可以持化，比如说在服务启动之后。

我是不是可以先创建出11万个线程？假假设都能创建成功，我先创建出11万个线程，你来一个，我就分配给一个县城，来一个分配线城，这这就是所谓我讲过的一个池化的概念，对不对？就是这个现线城池先准备好。

那来一个我就可以不用就少这个发生克种这件事情，因为现场已被创建好。啊，这样虽然可以提速，但是后来如果这只是接收啊，如果后来想去读数据的时候，那么更多的线程他们其实又进入一个问题。你这个线程在内。

你如果CPU合适就4颗的话，那么他们可能切换来切完去。啊，那调度这些线程，他们可能我正在调度前面挨个切换呢，那么排到第11万的那个那个那个那个线程里边来来数据，你还得等等到前面能切换到你这儿的时候。

你才能去读，还得等一个时间。这这是一期课的基础知识，是这并不是四级课，是一级课基础知识。好吧，整理这块啊知道知道为什么BLO慢这块能ge造的同学来说个一。其实在这儿你可以刚才有人说四级课。

你有的时候你去听四级课啊，其实四级课里边的很多。知识啊完完全来自于前面这一个课，有时，但是你不要认为四级课所谓的P8很表。其实前面咱们课讲的也是很深也是很深的啊。那么为了解决这个问题。

你要找到弊端是什么？整个BIO的弊端是啥？整个BLO的弊端是啥？那的问题是啥？来了。哎，我就垂直往下写啊，就横向来了。B端整体来回顾的话，就是因为刚才说了em阻塞，然后呢，你的readd读取也是阻塞。

弊端就是因为阻塞。要不然我们这你这个弊端如果找不到的话，我后边的课没哪讲。walking。对吧因为你阻塞了，你才会抛出这么多县程，每一个县城去拿着一个自己的IO在那自个组你别你的阻塞不响到别人。对吧啊。

你那边接收的时候，你自个儿阻塞了，你别用到别的人读取那个那个事，大家每个县城自个忙自个儿的，大家自己玩，所以最魁或者阻塞。那么想调优这件事情的话，那就必须要解决阻塞的一些问题。那阻塞是谁造成阻塞的。

谁的能力有问题才会造成阻塞是内核。啊，就是内核提供给我们程序在使用IO的所有的API所有的调用里边，现在是阻塞的调用模型。那只有内核提供给我们的A片，可以是非组册了，这事才能延延伸一步。

那非组册这件事情怎么实现呢？其实是像。

在那核系统调用的时候，来看一下。

menu如因为这些知识前面你要先把我前面课程听完了，我前面课已经讲过了，在准备IO的时候有哪些性交用。you accept有 receive的软态。那他们对针对的都是这个得到这个网络连接那个文件标服务。

那这时候我们可以去看sing二类的。

sit的看系统调用。这上节课已经讲过了。那么在准备sute的时候，新的版本内核当中会提供这样的一个选性参数。Yeah。就是会有一个socket name blocking这么一个参数。numb参数啊。

你可以在scket的时候可以通过参数传。那得到的这个文件面符监听的它就是非读做的。而且你其他的得到客户端的，还可以通过F这个fil文件控制这么一个二类个性调用来设置namemb block。不管怎么样。

你的监听的文件描符，你的客户端连接的文件描符都可以设置成非组色。那有人说了，那非阻色到底具具象这个非组合到底是一个什么东西？我们先是用实实例去看，用实例去看，打开我们代码，用java呢。

我写了一个非组色的这么一个代码版本NIO的。

好吧。但是在这儿这个老生长谈啊，一提到NIO的时候，这个N字有两个维度。一个是你看java当中的这个GDK的点当中有点NL。

啊，那刚才看这的时候，这个。这里面还有一个。

n block啊非主塞有两个。所以在这儿他头上我给你做笔记，这块一定要记清楚了。

YO的N。诶。一个是在KDK里边。是应用IO的意思。一个是在操作系统。投案当中很难locking。的意思。刘慌啊，这个我知道我之前在reice和网峰制当中去讲过这个东西。但是为了咱们IO这个课的完整性。

我还是这么去讲，好吧。

哎，那么有了个IO那这个怎么去操作它？首先啊你用的是DPK的NIO新的IO这种这种东西，那就出现了。其实在前面讲文件IO的时候，也带过这些东西，它里边有channel的概念，只不过现在不是fi参。

是s channelnel。然后呢，其实还有ffer啊，还有都是复文器概念。那现在先简单演示一下这个这个代码。现在是以基于网络的通信上的一个face子册，怎么去做的。是准备的，你看之前你有serv。

现在是serv点channel，这就是新新的API的使用方式点open，你会得到一个serv channel一个通道。其实有我们之前在追踪底层代码时候发现了linux的文件描符，它是可读可写双向的。

他是可读可写双享写错了吗？那少一个。

那像嗯这个类这个java当中，它分布了一个channel，这个channel是不是也是可读可解双向？对吧其实这个绑定的就有点这个十年河东，十年河西，以前是把IO输入输出两个分开了。

其实到channel里边把IO这个事给你淡化了合在一起了，就是channel就有点像文件描述符一个初相层。那么得到了一个s channelnelSS那这时候下边做一件事情绑定，绑定端口了啊。

绑定一个端口号是9090。然后关键看下面这一步SS点confi blocking false，这就是重点。我们的API是java的NIO这个N新的API。

但是confige blocking force是OS的numb blocking。这个两个你都见到了，这块能听明来说ber一，那就是在设置我们那个listen监听的。

因为server circuit嘛，它是监听的，监听的也不要阻塞。那么监听不要阻塞的语义是什么意思？也就是到下边，如果拿着这个SS这个serv so。第二accept的时候，它就不会在这一直阻塞着。

那不阻塞代表着一掉就会有返回。那返回的时候，别人如果不见连接的话，你得到这个客户端就会出问题。它不代表任何后户端。那这时候其实就是在操作性层面是负一在招务名对象里边那。如果得到了。

那就得到了某一个客户端的具体一个文件面符一个数值。设置为te就回到了blocking原始的一个状态。这点excel是在这阻塞，就回到了BIO。如果设置成fis，就是NIO。听我同学来说波一啊。

这个很简单的一个事儿，对不对？啊，那注意这是listen状态啊，这是leaen状态。就是你 sorry监听的一个状态。那当得到一个客户端之后，那你看下面分支判断的时候，如果客户端为空。

那就是掉了except没有阻塞，告诉你现在没有没有人，那就它为。那现在没有没有没有客端连进来。然后另外一种情况就是我掉了ex，这会刚才有人已经建立个握了。

你就把那个那端创建了一个文件描绑定它就是4源组有一个key，这个 key就是文件描代表它得到绑到这个客户端那客户端就不是就不是那就有了有了之后你除了可以给list状态的设置 blocking为 false。

也可以给你的一个连接的客户端设置comp blocking为 false，这个也是重点。那么。如果我客户端连接设置成非阻塞了，它的目的是啥？先不用管这个先看整整整体的概念。那么下边如果拿到客户端的时候。

它的read的读取客户端数据的时候，那么以前是要人家发了数据你才能读到，人家不发，你一直在那阻塞着，你上边做了非阻侧了，连接非组侧了，客户端非组侧了。所以这时候就不会阻塞，不会阻塞的话。

那你要么就是别人已经发了，你调了正好读到别人发的东西，那就是大于零的一个读到字节数，像那个b里去读，要么就是什么呀？你读为零或者读为-一，对方已经断开了。就是这么几种独到的可能。所以下边会判定。

如果它大于零做一件什么事情，然后其他其他盘景没有做，这只不过演示一个连接。在这里面NIO就是JDK的NL新IO里边，其实这就发现了一个8ffer8ffer这个分配的方式b bufferffer。

然后可以直接内存分配，你可以在堆里分配，可以在对外分配。这个其实在前面IO课里边已经讲过了，它是不重复给你提个下。这些是DDK的new有的东西，像confige locking force。

这是操作系统。当中的face子色的意思，整个逻辑代码其实是完全在一个县城里整规捋一遍啊，准备了一个link list，在一个县城里准备了一个link list class。然后呢准备了监听的SSS。

并设置了非阻塞，然后向下死循环在当前县程做了一个完最大化的一个死循环。这个死循环里边上来就从SSso里边去接收客户端，可能接收到，可能没接收到。如果你假设接收到了。那么这个时候就就得到这个客户端了。

那就把客户端也设置成非阻塞，并将客户端艾特到我上面这个link list里边去。为什么？因为你现在是一个线程，随着你服务器运营时间可能连了一个10个摆个1000个客户端。未来你上面这个这个循环里边。

上面这个环节，循环的前头部是要接收客户端，但是这个客户端你只。添到了例子里边，你下边还要再用一个循环去便利那个例子，再用空间去挨个去问每一个客户端，谁有没有发数据呢？

这就是这就是非阻塞在单线程里边接收是接收便利数据是便利数据，分成2块，在一个死循环里，这个逻辑现在能get到的同学来说边一，这就是所谓的非组塞代码。

。Okay。

那么这个field代码呢，在我的linux上也有。

首先先去验证一个东西。

这是s的NIO啊，就是他我们先去验证一个知识点，非独特到底是怎么实现的，还记得怎么去追踪吗？这个在性用交用上。啊，不要关注注意啊不要关注我代码里边的一些逻辑的这个处理。

我把代码尽量的只写出我需要那个代码逻辑。然后呢，肯定有bug。其实我之前发过这个这个ki代，已经发过这些代码。我今天在在我讲过之前，我还发现还有bug，但你们从来没有我反反应过。

那证明其实代码里们没有看过。

这这并不重要，重要的是先去琢磨原理，后边代码写的这个明细这个这个环节。其实这些版本代码里根本未来没有机会去写。

未来就直接去写nty的API就可以了。现在指的是明白原理的过程。用 screen。随时追踪让FF追踪所有线程，然后杠O输入的out开头的，然后追踪什么追踪java，然后执行的是我们的。

socket的NIO这样的一个类，但是这个还没有编译，所以在它执行之前，我要javaC去编译我们socketNIO点java编译成功之后再去追踪它，我就整个压在一行去写了。这是Lux的命令的衔接。

前面执行成功，后面的才才执行。好吧。😊，好，我们先把那会好起来加低。😊，从这个哎怎么不打印？怎么睡啊？效果不是特别好，我你先删掉。分青掉，我得改一下这个蛋。哦，我把电话电行杜掉，注是给你解开。

因为如果他每一秒钟循环一次，每一秒钟循环一次。如果循环一下的时候没有扩堂连接的话，那这个后端就应该为闹，我就要打一个闹成这样，让你看看这个效果。下来。好。一秒又一秒哎，就是代表我的循环。

我的循环是没有被阻塞住。对吧循环没有被阻塞住，听出来说说一。这不是还是在阻塞吗？

小朋友想明白，well循环在这个循环拟当中有一句话叫s pen line，它它前边会发生一个accept。如果它阻塞的话，它是阻就上面阻塞行为的话，那这一块一直阻的导的不动，代码不会往下走。

你就看不到闹的这个点。

来。口说无凭。我把这个连接这块的非堵色给你制成处，好不好？就是看 blocklocking为 true就是阻塞行为，现在是阻塞行为。我水。然后再去重新编译啊，重新编译，重新执行走动吗？是不是不动了？

嗯。是不是不动那个点这点是不是打不出来了，为什么它挡不打不出来了，他就在这阻塞住了。

好吧，我们还可以给它取消一下，然后把木单的目布清一下。没事，有问题就问我这节个争取咱就讲一个比较细的版本。未来你们或者谁听了一个课的时候，就完全听明白就可以了。重新考刚才那个追踪这个这个这个过程。

该机一执行在这阻塞着，是不是阻塞呢？空空空口说无凭去到探 soet。这一个追踪的日志文件是不已经有了？哎，这个比较大的就是我们主线程2732VIO点2732。这是之前课程这个应用的能力啊，把前补全了。

你就会这会这些东西了。诶。诶。😊，今嘛。好，那么打开这个文件。我爸是VVM。你来到这个文件，追踪这个文件的最后一行，2855行，是不是调，就我GDK就java当中我们写的accept。

你写了一个acccept，是不是掉了底层操作性的accept，就这4分那秒符，他应该在这阻塞了。

对吧嗯。这样看阻塞还是有好处的，不阻塞一直在输出，不是浪费性能啊，我不知道这么说清楚了没有，一会儿我给你解释，你先带着你个小文号，我一会儿给你解释啊。好，这个阻侧这事盖盖造之后，我们删掉所有东西。

然后再看你非组塞，它是怎么区域就行。你见到阻侧了，杠tC。然后呢，将那个目录清一下。Yeah。没关系啊。这就是你们能有很多的问号，并且你们的所有的问题都问错了。其实这个就我的预期就达到了。

因为的确和我想的一样，很多人在这块犯迷糊。在跑之前我还得编译一下。🤧就是我为什么不用VIM啊？是用VIM的时候，它有一些东西注射是蓝色的，在客户端看的时候它看不清楚。然后我不喜欢用带色。

带色的不带色的话全是白色，你啥都看不见，这个我也是为你们去考虑啊。false啊老阻塞吗？foalse不阻塞是成不阻塞了，黑堵塞了。然后再保存。Okay。那先跟种思路吧，先跟种思路吧啊，走待机。哎。

你看是不是开始出现闹闹了，对不对？那我们再来看那边。然后还是制作那个2804，因为新跑了一批奥VO点28。804。打这个文件，然后你会发现下边这里面是不是就是会有一个accept，看返回值了吗？

是不是掉了accept，它并没有阻塞，返回了-一，也就代表着没有人连进来。听懂来说说一。那重点来了，有人说这有什么意义啊，有什么意义。注意看效果啊，现在是11111堆打那闹那那对不对？啊。

我随便开一个连接进来。比如说。NC连local house。9090注意听这是不是要有一个客户端，这个NC就是netnetnet connection或net要去连接我们才台服务器ID连进去了。

因为它是非主塞的，它在某一次循环的时候，它可以接受这个客端连接，并且因为它是非主塞的。它是非组侧文。即便你在一圈循环之后，到accept的时候，别人没有连，但是你不会阻得住。

所以的循环下边的读取数据就可以在当前现程当中被有机会被执行到。

这个逻辑转过的同学来说个一，曾经你是要抛出去一个县这excel之后，你要抛出一个现场把这都能扔出去，那不需要抛县城了，完全有一个县城完完全全有一个县城。大家注意看啊，你演示。

这第连进来是不是已经连进了一个客户端了，然后我是不是还可以再来一个客户端？单击是不是又连接一个客户端，两个客户端都都连进来了。那现在两个客户端连进来了，一会儿我要发数据，且这个在一个县城里边。

它既要满足excel接收，我后边还要便利，我另外两个客户端有没有读数据，有没有数据发送过来。你说如果它是阻塞的话，现在执行到外部循环BID循环回来之后，直行到这一行它阻塞别人发数据，他接得到吗？

代码是不是来不到这这这这这这这个区域，是不是代码来不到这个区域，他就不能够读取别人。

是不是单心能解决了这个问题，能听能来少数一。所以你看啊我去发数据，这个客户端发点字母的，那个客户端发点数字的，你看是不是在一个线程里边既可以解决接收客户端，又可以解决读取的事情。

只不过他们是被一个循环当中线性挨个去便于处理的。Yeah。现在能明白为什么要这个这个木兰N2是什么意思？木兰把你的问题抛出来。你先泡着，我给大家画图总结。

我给大家画个总结。那么其实要进入NL这个环节，你怎么去理解这件事情？其实你要明白是nblelog是内核当中增加了功能。那么再来去思考上面这张图。还是这样的一个逻辑。嗯，我怎么把它挪下来？Yeah。

我说个事。这个时候是NL，这不是BL。还没有多到多录复文器啊，那么还是我的application，还是我要去设置我的这个想先确进监听的。只不过在这里面这个逻辑上发生了一些变化。

他首先不需要抛出更多的线程，因为你要解决的BLB端就是不blocking。然后很多线程NLO里边是不需要更多的线程，你可以用一个线程或者用个别几个县程来处理一件事情。然后呢。

你的application逻为代码是先得到listen监听。当得到监听之后。注看把你的。MD3。3。设置成n blocklock。我们对这个监听的文件面符设置了一个非注塞，然后下边用了一个死循环。

循环里边accept。当从FD3去接收客户端的时候，这个东西就酷出色了。到这步就是这个循环里边啊，这个循环里边接收这个事儿不会阻塞，所以它就会有返回值。只不过这个返回值的可能性有可能是-一啊。

就是没有得到客户端。比如说ja人的有可能返回了1个FD4作为一个得到一个客户端，这两种可能。对不对？得到之后，其实你还可以再继续对FD4进行一个number。的一个设置。

那如果你给他设设置numbb locking，那么未来这是一个循环里边，你就有机会可以补选FP4，就是receieive。读取接收我们的FD4的数据。只不过我在java里边，因为你这个循环每循每循环。

一会FD418这5F66，你每次循环的时候，既要接收新的，又要把456所有客端便利。所以我用了一个liing list来接收给持有很多的客户端。那么在下面的时候，其实读取数据的时候是要做一个。

再做一个循环。就是两层循环，一个大循环里边，既要满足excel接收和所有客户端读取的便利，完全都在一个线能里执行成功了，它就不需要再抛出线头了。嗯。这只知道哎，我还没有到多了复讼器，我来处理一下。

系列 3：P192：【IO／NIO】答疑 - 马士兵_马小雨 - BV1zh411H79h

来处理一下咱们的小伙伴的答疑的问题啊。我现看不兰的，能再说一下一个县城怎么就在不阻塞的情况下管理read或者right。在传统IO我有点忘了，我不知道我说清楚了没。

嗯，在这儿。看，我再给你对比一下传统的IO代码。传统的IO代码，我们就用的DDK的IO对不对？没有NL啊，我们也没有设置blocking为 false。所以这时候在主线程当中，注意看。

在当天的主线程当中，我得到了一个这个serv soet啊，会new它，得到一个serv，得到serv。然后注意看呃到下边一个死循环，在主线程当中一个死循环会去accept接收一个后端。

但是在这注意它现在是阻塞的。因为你没有设置，没有配嘛，对不对？这个阻色的阻色是什么意思？也就是他没有飞机。没有负一的返围的可能性，因为他一直。卡着不动。刚才我给你演示了，调到底层API的时候。

系统标用的时候呃accept。比如说根据64逗号就没有返回值，就一直在那卡着。什么时候一个客户端帮都连到那台服务器上了，他才会有返回值，得到那个客户端的文件面服务。这个叫木啥嘞？木来到这一步。听懂了吧？

哎，这会阻塞。那这时候假设阻塞，有一层能连接之后，得到一个客户端。那这时候你去想啊，如果这个客户端不抛出线程，你在下边就直接想这个客户端去read的读取数据，假设我写备代码。

如果就直接在这想这个plan这read的读数据了。那这时候其实这个客户端这个连接，你也没有设置设置这个非阻塞，那么它就一定会进入一个状态叫阻塞。因为对方你的客户端没有发来数据嘛，你在这读的时候。

他也没有负一，就这个组字的话就没有负一返为值，就是我没有读到东西。那这个也没有也不没有没有非没人的概念。那读的时候就在那阻塞，阻塞的话，代表着整个这个循环就被堵住了。

那这时候如果你想把这个图端读却在这阻塞，别人没有发，但是恰恰又来了一个客户端，想让你接收一下这个外循环回得来嘛？木兰回的来嘛，代码是不是执行不动？这一个县城是不是不可以在阻塞读的时候还能记住别人。

不能干两件事儿，是不是回不来，所以这这个怎么办？就把这阻塞这个事扔到哪去，扔到一个县城里边去新的县城里边去做。所要搞一个新县程，抛出去在新县那里边去读。对吧这个BO木兰听懂听懂了，你就敲一波一，对吧？

都其他人你应该能都都都都能听懂了吧。哎，那么这是他的弊端，也抛出很多的线程。那为什么要抛出线城，根根在哪，是不是根在组侧上？最大的根源数据在阻塞，因为阻塞，所以抛线程。这句话记住了。BIO因为阻塞。

所以抛现程才能满足一个服务端接收更多的客户端去处理。那这时候那么抛出很多线程成本就比较高，那怎么办？你再来看NL的代码，在NL当中完完全全就一个县程，全局就这一个显主主方案。

因为你没有看到任何news的过程。对吧那么在一个情市是怎么去做的？我还是要得到一个server so。只不过我对serv circuit做了一个什么呀？

做了一个confige blocking force阻塞吗？foralse不阻塞。设置了一个非组塞啊，这个就重点，重点是搜搜的listen的时候，因为你设置了非组塞，所以在exccept的时候。

它就有可能返回负一，因为别人没有连，那这个横点可以跳过，接着往下走。木兰这个能看同学能看懂来说说12一木兰。我是针对木兰，其实也给讲未来所有在这个点上迷用的人一块来听的。木兰应该能听懂的话。

其他都没问题了。木兰能听懂吧？木兰。啊，你要你要积极的和我互动啊。Yeah。搁这听不懂。😀H。为什么听不懂？首先刚才他主塞你能听不懂？到这听不懂？我给你再给你说一遍。

就是因为我上面掉了sof的一个confige blocklocking为 force。啊，blocking为 false就是不阻塞，不阻的什么意思？调方法，这个方法是调到内核去了。标内核了。

那么这时候乘以一。没有Q端链接。没有可能离你进来，那么返围值是多少？有没有返为主？有没有反回值？在变化的时候。一直卡着。我们刚才那个那个那个那个话术是不是一直卡着，这个摸完应该能应该能听懂。

就是掉那except掉内核了。哎，第一个场景没有扩端链接进来的时候，其实有防位值吗？在BL时候一直卡着，对不对？但是。但是在NL的时候，因为你上面设置设置了老铁没cos了，不能阻侧。

那NL的时候没有可能来，它就不卡它。不卡着，但是有没有可存来怎么办？我都给你我得给你返回呀。😡，返于-一，这是在OS那ja当中就是那。也就是这条代码就不会不不会被阻塞。木兰听懂了吗？听懂就是2121。

对吧嗯。那这方不不能往下走，但是这时候有可能性了呀，是不是有可能性了？那另外一种可能就是来了，对不位？如果来了。如果来了扣端。我这是基础课，所以我讲的讲成这样。如果是来了客户端的话。

那这时候其实accept。返回的。是。这个客户端叫FD比如说5啊java当中就是一个可研的一个对象。因为OB价把它包装了一下嘛。对不对？啊包装了一下，那就返回这plan，也就是返回的clan。

有可能是那，有可能是具体的一个ob贝亚的一个can。所以代码直接到这儿的时候，是不是会做一个分支的判断，ifcl等等的或者是不等的，就是具体的某一个对象。对吧木兰到这儿能听懂学来说出那个来来刷一。

就因为你上边是不组做了，那就有两种情况。嗯，那代码是不是起码说代码可以往下走？飞度多的时候，兄弟们嗯嗯俺不老平。不要就很为值。那走这之，如果c等等的话，那就直接打印。我我这用打印了。

其实你可以不用处理这个这个这个场景，你就直接判断if不等于那的时候把它加进去是不是可以了。我只不过让你们知道说每秒一循环哎，即便没有人来，但是我每秒这事发生了因为每秒会打印一次。

所以你不要把它作为这个性能消耗去去思访它，你可以不处理它。那就是每每一一秒钟接收一次客户端，每一秒钟接收一次客户端。那即即便只要你接收到了客户端，他有这个对象有这个实际的客户端到了。

那这时候confi blocking再给客户端连接为foalse，这是重点，而且你们一定要记住一个事，就是在s的领域当中。算了中有两个东西，一个是服务端的。Li生烧。

这就是在我前面的课程一定强调的leason software的是消费的，然后连接。烧饼。他说 cK b。他也是曹废我。到这步能这个能听同学，邵波一木兰能能听懂吗？哎那哎你lea似的s就是s的。

你连这个s也是s。所以我lea似的s要成这个fe有色，我我要解决到这exect不就是。俩有啥区别？listen呢就是只是这个这个接收，就是数据包来了之后往我身上拽。然后呢。

我我去except连接的是啊这个连接的数据就是连接是在list森之后得到的serv啊，那这个事面就是有数据的传递了。使用的set这个例子so就是。往往这里扔。我去放电。我去登过ACCCDT。得到。

连接的sing，就它有一个因果关系啊，它有一个因果关系。listens是别人跟我这次握手啊，就把我这扔扔完之后，我accept，然后得到了一个连接的sing，就是得到了后边的这个sing。

得到后面这个al这个连接se。等当得到后面连al之后，我本来要从那个连接se里面去读写数据的。也就是说accept得到的客户端，得到之后，我未来是要在这个客户端当中要去根据这个客户端去在下面编历的时候。

我从这这个客户端里边拿到客户端，从身上去读东西，就是这个一个应用关系。接着来走，如果ser soet accept非阻塞了，我们得到客户端有两种情况啊，如果说客户端已经建立连接了。

得到它我要对socket这个连接set也要做一个非阻塞。那么这个face组的目的是为了后边我读取的时候读取行为不堵塞。卡吗？应该不卡吧。不管了，哎，咱们就接接接着晚接着往下聊啊。

如果你对连接的客户端也是非主色的话，然后这里边我只不过在我这个单线程里边，因为你未来可能会有很多人连进来。我在一个死循环里边，我既要解决头部的连接，有没有看有没有人连进来。

我要做另外一件事情是便利所有人去读取数据。所以我准备了一个link listcls。然后呢在这连接成功之后就是excend客户端成功之后，我要把它艾特到的clans里边。

while要循环的第一件事情是接收客户端。每循环的时候接收口端。第二件事情就是。电力已经连接进来了。能不能读写。好吧，就是就就就是一个循环在一个线城里边的一每一次循环里面做两件事情，一个人接收。

看看能不能接受不组册。然后便利所有人读取不组册。这就是所谓的不阻塞，可以让一个线程的所有代码不阻塞住。对吧木兰现在能。能敲一吧，你就敲一，不能敲，你敲二。行了吧呃。

我相信未来所有人都这个这这块知是不是不是很很那个体系的时候，来到这儿应该基本都都能明白吧，那就收。

嗯，我这个事儿聊明白了。那么好。郑总来了，刚才我们是用BL的时候，用这个CHK去压了一下。那这时候我们用。找到随时可有的代码，用NL来压一下，我还是把我的服务器跑起来了。你看这次我在跑的时候。扔表。

VIscket NIO点java。我做一件事情，我把那个打印叠点那事儿给他注注释掉，我就不打印标点。因为我要快速看他有没有多少多少个连接进来。跟着思路走要做一件事试。现在对各种速路走。

我要让sockNO点java编译，然后把它跑起来。其实不用追踪了不用追踪了，就直接。叫socked哎，木兰，你是女孩吗？我也不知道啊。把这服务一旦跑起来之后，它是不是单线程非组色。

然后那我如果单线成非组色，我能用C10K去压的话，我这11万个连接是以什么速度被接收被处理的？对吧哎老这个这个需求能听出来，稍微一跟着我思路走啊。好加机跑起来了。哎呀，这个no no no no。

我忘了编译了，忘了编译了，重新编译一下dava Cset重新编译一下。dava得到一个新版的源代码，然后再javas NL。那抛进来。有点小激动。跑起来，其实这时虽然不打那闹闹着点点。

但是其实它也是在一个循环，在每一秒except下，每一秒except上每一秒accept下。然后这时候注意看啊，好我的扣端连接找你。是不是梁静，哎，他是你说这个速度是不是好慢，为什么好慢？他为什么好慢？

😡，是不是我循环当中有一个一秒1秒1次一秒一次那么一个一秒，是不是？我可以把这个再去掉，说C。把这个客户端给它停掉。很聪明啊很聪明。把1一秒的事儿再给它丢掉。但是这个时候就有点恶心了。有点。

首先先重新编编译下，加le C，然后s。等高了。因为这样的话，等于我这边如果不连的话，它就是一个玩命的一个。一个空状的过程，但是其实也会有一个性用标的切换的过程。sockingNIL。

能能理解我什么意思吧？我把一秒注射那个去掉了，现在就是单线程就用一个线程接收并发这个那边一个线程来疯狂的去建连接连接这个事，都是线性的，没有没有用多机的并发这种这种就是多客户端这种压测。

是单单客户端10万11万连接的这个压测。因为你那边也是一个线程里边去建立。所以这个不要太追求那个这个实际这个特特快派一个速度啊。但是先找感觉，早这边已经开始玩玩命的去去等等等待了，也没有那个睡眠。

这边去建立连接。

这个速度是比比刚才快的快很多了。不是服务器的连接上线。像这个如果你不不考虑时间的话，这这个这个这个跑个几这个一两百万两两30百万相港连接都都是可以就连接是连接。你处理处理处理那个事是后后边的事。

请问我现在慢是因为什么？什么请问我呀，我请问现在慢是因为什么？😡，有人说普打印。呃，你要想到他代码当中一个一个循，一个大熊里面做了哪些事儿？这里边会有现成开密的事吗？没有系能开开辟的时候。

会有一个看代码呢，这里面会有一个就是在我NLO代码当中。

每循环一次，你看刚开始这个连接不多的时候，那调查系统的调用有没有接受啊，然后呢便利一下有限的cl的数量。但是当你的客户端连接数变多的时候，这个便利的时间是很长的。因为每次都要调一次系统调用锐。

都一次用台那个再切换。随着这越来越多，那这时候其实调的越来越多。而且这到最后报了一个错，这个错什么？

哎，终于看到这个错了，我一直让他跑跑到，现在就是为了让你看这个东西。

先不管他就是前面为什么慢，是因为我每一个一个线制里面你说一个一个线城里边既要负责接收，又要在接收的穿插之间，就是每接收那个动作之间要穿插的便利我所有客端的数据。

读取的事看有没有读到。这是不是货影响的速度对不对？呃，这是一个点，这个点能听明同学来说个一。然后另外一个知识点，另外一点就是出现了一个东西的tooo many open files。啊。

超出了我open files文件名服的数量。啊，超出了文件标述，这个怎去设置SS这个UOlim。然后杠A这有一个设置啊，我的open files是1024。啊，1024，那这为什么是2044。

这为什么是2044？是1024，这为什么是2044？喂，为什么？我我打开的文字面书不是一这个限制的是1024个吗？那这好好像对这个不了解，我先先讲一下open files，然后为1024是什么意思？

他说的是我的。一个进程可以打开多少个。文件描述符啊文件描述符。这串建多少个文件描服跟县城没有关系啊，不是说多少个县制是多少个文件描符，每一个连接可以对应上是一个文描符。但是这道为什么是1万这个2044。

不是应该到这个。这个2044这应该是一个什么概念？因为2044他还是成对的，对不对？还是成对的，应该就是40。4088了4000多。0家4000多是他4倍了，这是因为啥？

其实我们那会儿应该看一眼LSOF的时候应该看一眼。我们要去掉。比如说四盒。Yeah。来看我的规模第一台。Yeah。Yeah。我是处理器的数，有两个物理CPU每个处理器有6个核心，一共总12个核。

看他们那边好，什么要看他们那面。我先给你调吧，有 limit。那怎么又又撞态了，又liming。然后杠临时调啊SH软硬的N就是文件标识符杠N，就是杠N然后杠S杠H就是软设置硬是同样设置。

把进程的这个可以打开这个文件标符的数量给它标上去，比如标成一个。50万走回车。那这时候呢用limit杠N。就是可以接收50万或者杠A。open files这个值接就打上去了。客户单金一直活着啊。

客户端金是一直活着，我没有断开过没有断开过。就是到这步啊，我先把这个open fast打到50万，然后再去跑我这个测试。跑起来，然后这边再拿我这边的代码去往上去压。

我任为又跑了。PCP no delay。No support。哦，这这这这个我应该跑到随时K这个随时K。

这边是不是开始开始创建起来了，创建起来之后，然后我们从另外一端，刚才始说想看我那边二幅啊呃GPS。稍然是3004LSOF然后杠T3004高。文件描符的数量，你看是不是1348这个文件描符。

是note01的。是不是很多东金要服？对吧然后有一的有100的，一的100都进来了，这是文件面符用ice是不是也可以看。然后这边的话，你等着往上标，也不也也它肯定不会出错。

因为文件符这个上线已经给突破了。用m state到NATP，然后去看一眼。连接的是连接的关系都是连接本机的150。1999990。然后但是有一的某一个C段号，100的，我给你断个号。

是不是都都都第一个链接都有了，关键看前面。哦。比人说到6万的是会报吗，你还没有get到地点嘛？你看服务端，你看啊这边服务服务端有消耗顿号，服务端是不是就是占用了1个9090，这边是客户机的。

就是这个windows里边的150。1的M消耗了客户端的1个10190，消耗了1个1100的10681，服务端只消耗了1个90，没有没有消耗更多的顿号。对吧。Yeah。啊，没错。

客户端系统又开始跑也也有点消耗。这个因为windows上你要开辟那么多连接，也开始受这个这这个受不住了。

H。Yeah。内核是如如何那核是怎么实现非阻塞？啊。怎么实现非堵色的？你把前面记组那块想想明白一件事情，就是其实呃网卡上面别人来了东西，会有这个中断，中断会把来的东西放到那个那个缓冲区里边。然后呢。

你的这个调用，其实就有想要问问缓冲区里面的东西，就相应文件面符有没有有没有事件，有没有有没有东西到达，有没有这个可以读的数据。然后这时候其实对应的缓冲区如果为空。如果连接里面没有没有人件连接的话。

那这时候你要么在那等着，要么直接返回-一嘛，注意听啊，我现在这个模型是一个程一个进程和另外我现在是一个一个windows上的一个进程，是一个一个java进程，玩命的在windows上调资源，开开辟连接。

这是一个客户端，是一个客户端想建立更多的连接数，而不是说有真正的这么多客户端，每个户端就建立一个连接，模拟互联网的一个并发。

这是一个真实并牌，这不是一个真实并牌。我只是说它能够建立这么多。那么一个进程可以把这个这么多建建这这么多连接建立起来的话，那这时候其实你考虑的只是说。把这每一个连接放到互联网的每一台机器里边。

一台机器就创建一个连接那个速度快卖。而且他们是不是可以同时在多台机子里边并行发过了同网卡网卡涌进来。现在你现在你的这个windows和linux是2块网卡里边的一根网线。

然后由windows上边线性的往里去施加这个先三次握手，成功之后，我再建立第二个三次握手，而不是说并行的三次握手。因为我们并不有在windows上使用多线程。

这如果我先先准备了这个55万个这个这个县程，每个县城发两个连接，这个这个速度肯定是要超过现在这个速度的。

对吧。好吧，先找感觉这个不管怎么样，这是比刚才BLO的这个你现在收是不已经突破上来了，对不对？我们就不在这等时间，再等到说他具已把11万个连接建起来了。

系列 3：P193：【IO／NIO】连接数超过1024的原因 - 马士兵_马小雨 - BV1zh411H79h

那会儿的4K为啥还没忘？对啊，4K这个事儿。Yes。是不是想问那个问题？She。Yeah。一緒に。这个问题。😀呵。😊，下就我查查的告诉你们好吧，我刚才也一脸懵，听出来了吧，我也在这，哎，我说4K哈是吧？

想明白吧？😊，嗯。Oh。

呃，这样啊。反正歇歇会儿，让让计算机别闲着。G已经存在了SU switch到get。现在是一个普通用户，看到吧？现在是一个普通用户。有limit表N。我看跟root有没有关系啊。还得不行，还得收拾回来。

image。1。24，然后再switch下。这个limit这样。现在现在一个普通用户约束了普通用户启动进程，他的完全服就是1024。然后粘了是s的NIO。然C的没有编译了吗？然C。

我猜的我猜的好像是跟入ot关系，知道吧？要不然说不通这个事儿。没有这个权限。甚体争议样。哦，这个不行，我这个目录啊，我这个目录是录的，还得把它挪挪走。宝贝。socketNIO点class。

到TMP目录CD到PMP日干。嗯。哎，我去这没问题。然后再让我们的gavastock的NIO把它跑起来，然后再去压测，看这个数能不能上去走。他他他特别闲着我我我们来让我们来休息，让他来跑起来。

So。NIO是java的NIO是newIO里边的多路复容器select用的。

哎呀，这话怎么没说呢？准备连上了。oo many哎哎哎哎哎哎哎哎哎哎，看到没看到没看到没？小小伙伴们看到没？是不是这都是双的，都成对的，这是不是已经101几了，是不是已经101几了。

是不是 too many open files了，是不是是不是现在是不是普通用户，对不对？普通用户是不是完全受制于受制约束，但是你的路途用户其实有的时候是可以跳出一些限制。屌不屌屌不屌？

好了，不用我下去查了，我现在可以告诉你啊。😊，这个理论是对的，只不过要看用户。而且。公司。收少方便。等电。是 they。启动。所以这个理论是暂住讲。Yes。你咋拍的，我咋拍不到，因为那个。

因为我意识里边意意意识里边有这么一个有这么一个事儿，就是root就全限在root面前是。

呃，等于虚设就这么一句话，然后很多资源的约束，其实在root这也是相对放放开的。

Yeah。为啥是成对？成对？因为我是我是在客户端代码的时候，我其实就是你看我客端C0K代码的时候，我I比如1万的时候，我是准备了两个客户端一扣户端2。然后客户端一的时候。

我是用1万这个端口号windows的1万。

就是等于约等于windows上用了1个1。2。668。150。1，正好21万。然后呢，连了我们的这个上面这个服务器。去02192168点150。11的9090。然后又下边用用第二个cl。

就这做了一个connect连锁。然后第二个cllan。陈二又去绑定的是我客户端那边的。192。168点110。100，正好是1万。因为这两个变量I是一样的。

也就是都使用windows相同的1万弄号直播使用windows不同IP地址。但是他们访问相同的服务端。这9090。那这时候其实这这边是windows暂时制造的那翻回来其实就是在什么呀？linux当中。

系列 3：P194：【IO／NIO】压测 - 马士兵_马小雨 - BV1zh411H79h

把11万个人接建起来了。对吧我就对用个图给你补充一下。那在这个压测的过程当中啊，我给你用一张图，其实是windows上边。

是在windows上。windows上有一个程序。然后通过网卡。我用破骨来表示啊。应该你能看懂，除了windows之还有一台linux，我用拓扑图了，不用那个。实际这个图吧。然后你还有一个Lingux。

然后这边有一个servver。还有一个serv，他们两个之间连接之后，然后注意看啊我这个app application里边是一个循环，这个程序是一个循环。比如说10万次。那每一次循环这个循环是一个线性。

你定明白，循环是一个线性，就是每循环每循环每循环这线性一个线性里边完成什么事情，三次握手。这是重点。先完成一个三次卧收，再完成一个三次卧收，再完成一个三次卧收。这是我windows逻辑代码？

就是你这个程序先完成一个三次握手，建立完一个连接，回来循环循环一下，再建立一个三次握。这是我windows一个逻辑，这是一个拓扑。window中是不是循环一次，这只只不过建立建立两个连接。

先建立一个再建立一个。

然后再循回来，这简例子，他们是现性的，他们并不是并发的。到这儿呢，想跟同学来说个一。

好吧，你看这还在还在建立，还在建两，这建立，就是还还还还能走，不然我就结束了，在这就没有没有必要浪费时间了，这只是一个过渡。现在基本上你也不会去用这个NIO的编程方式去解决这个连接性能问题。

因为这个性能还是不够快。这样我先给你看这个就是我们先把问题梳理出来。你就要知道问题的时候，就是它还不是特别的快，并没有并没有看到修修咻修疯狂的这个过程，即便是这种模型，这个模型这样的。

我先让你看到看到疯狂啊，要想使其灭亡，必然先让其疯狂路过。我们先来看疯狂的一个地方。

Yeah。我说你看什么？这里面我会有一个多路复云器。因为下一个NL讲完之后，它的下一个就是多路复云器了。那么我们先来看多路复云器的这个代码。而且还是单线程的啊，也是单线程的。刚才NIL是不是单线程的？

我现在那个sockcket的那个多路服容器也是单线程的，它的代码当中也没有6时的线程，它只不过用了一个seelection这种多路服容器JD的包装，然后也是在一个线程里边，代码逻辑你不用看。

我们只先要只需要先去看性能，好吧，加va C。Soockcky的。单线程的编译编译完之后，然后java淘我们的socket。单现程。现在逻辑啊就是我们还没有讲多路速分器。

但是多路复分器是NL的延伸的1个LO模型，以及这个多路速文器，N也是支撑易炮的。就是它底层其实用的就就其实其实它底层就用用的易炮啊，其实它是呃ny底层其实就是用的易po。那也就代表如果这个性能很快的话。

也是代表着后边我们的。这个都是数分器，也就是netty的性能应该是也是比这个应该还还要再快一点。因为它毕竟单线程，现载体还是一个多线程的。先来看效果吧，我为它跑起了，跑起来之后呢。

我还是会用我的这个CGK去连接它去测去测这个压力。好吧，能能听懂小白达什么意思吧？它也是单线程的啊，把它跑起来，服务器已经启动了，它的顿号也是9090。注意看，我要看看这个这也是一个单线程啊。

windows上也是一个单子线程，也是线性的去建立连接。然后看其实这windows建连接可以有多快呢。

这已经4000多。哦。看到吗？8000多。快不快2万多了，比刚才的所有的BLNLO是不是都要快，只能都路空气这种。这种事件呢是不是快很多了？那就哎这这东西它为什么这么快？小小问号能重新出现了。

我说太快了，那这这个都不行，快对对。这这东西为什么快，对不对？为啥？你看你有问号了吧。Okay。没事，让他快一会。Yeah。为什么要让他快是吧？我们看看到他能不能突破6万6万多个那个连接，对不对？啊。

没有突破6万多，这是hoto memory space。Yeah。嗯，我现在内存是多大？这个没有没有没有没有没有没有ge得到这个点，他这边内存还会预出呢。数字。Yeah。

不对啊。那个那边的号已经滚不到这了，其实并没有导置，我就关闭。

最好没有。再来一页。嗯。是。嗯。哎，对，这时候其实已经已经标出那个数量了，因为它是成对，它就成对。这能如果能出现3万，其实已经有6万个链接了。听朋学来刷波一，就是3万的时候，其实有6万的连接数了。

只不过说登我号还没有涨到6666没有账出66535对不对？林数其实已经占上去了。Yeah。

已经6万多了，是十多万的连接了，这已经十0多万的链接了。

6499结束，我客户端那边结束了，一共是100099954，中间是有一些这个erread use，就被被被我这边windows有些占用了，没有使用上有些断码能理解吧？

但是这时候其实已经我单就是在这个单线程，就是单单单单进单进程单进程线性处理的一个模型当中，已经对那边保持了一个10万的一个连接啊，已经有10万连接已经已经打过去了。

了不了？你你你去互联网网上搜没你这样的课，这样的文章你都搜不到。信不信信不信？

Yeah。

好，哎，他为什么？🤧啊，他为什么就刚才我们讲的是NLNL这块这这个速度。那为什么我没讲多服器，但是我一演示多服器，而得用JDK的编编程方式。它它为什么可以如此之快？

系列 3：P195：【IO／NIO】答疑 - 马士兵_马小雨 - BV1zh411H79h

哎，你们的小问号这么多呢？都是都是非本专业的吗？还还有一个疑惑，多路复用这个技术毕竟是一门很早的技术。为啥lining在一开始的时候没有直接用viero版本开始才开始采用了。

难道他们不知道用多路复用这块吗？毕竟开发linux内核的大神应该是很厉害的，应该比咱们想的都长远吧。啊。

我勒个去，我像知道你会问这个问题。所以看C10K这篇文章。他们的时这个多路分析这个时间就你你想2。6这个内核的版本应该是2000年还是几一年的时候才出现。你看1999年的时候。

最繁忙的FGP网站Y千兆网卡同时处理1万个客户端，从时一开始，你家FP多Y，就你去读啊，它的时间线是推到很早很早的。我们就直接看sck多了复音器吧。这块没有具体写它的时间，时间的时间轴出现啊，在这儿。

呃，破破的这个是在2000年的时候才被提出的。那2000年之前，他封的U软件能能能能能能能去开发出这接入连接，对不对？就2000年的时候，大家才想这个事儿，2000年之前没想，因为啥？

200年之前上的人还不多。这个注意看啊，fi max啊注意看啊，这有一个问题，区便那核参数PCFSF max这个你可以看一眼这个那个参数啊。首先我们来看一个值，跟着我思路走啊，我们的虚拟机内存是多大？

14G，然后默认情况下，fial max应该是在40万左右的一个文件面服务，是40万左右的一个文件面服务。

我们可以看一下。退出页什么root，然后cat PLOC，然后sFSbell max。385915。这个是另内核，根据物理内存。在内核级别估算出的，我4G内就是一G内存，一般是对应10万个金10。

然后这是OS kernel级的啊可以开辟的文件标符的数量。听同学来说个一。好吧，这事儿可以交给木兰同学，你把我这节课下去做再看一遍，把问题写个笔记出来。你就当咱们班的IO客的这个课代表，好吧。

我再给你启记这个事儿，我有点懒，我我就说了，我有点懒。这是 kernelel级别的啊这是 kernelel级别的。然后还有一个东西叫做you limit。这个有limit是什么意思？

是user limit。

应该是这意思吧。嗯，不是，应该是去去。没意事。怎么怎么怎么怎么找到他那个名字来着？hel。我忘了是不是是user了，反正这个unit的设置的是这个。用户进程啊就级别不一样的啊。

fell max是整个内核可以创文字mail服。因limit是你可以控制不同用户，它的进程可以申请的文件mail上线。看。没问题了吧。50了。嘿50了。嗯。大哥别加装啊。

后边这个是个是个是个是个大东西这个。这个加下去的话，今天得得得干到11点半12点。Sure。是这样，你可以VIETC，然后有一个lining，我想在哪个上是有一个s。ECC目录是哪个配置文件来着？

你是你。See you。Yeah。Yeah。这个是配配这个配置。有limit那个那个嗯配置文件突然突然突然突然卡壳想不起来了。哦，对对对，where it is secret。Secretty。

然后会有一个。啊，这么意思叫com。那这里边可以做，刚才我那个是普通的配置，其实你看看这个文件就知道应该怎么去配置，这里面可以配什么东西啊，往下走。嗯，你看配置的时候，你可以配置它的软设置和硬设置。

然后再往上的话，这你看这是我对ES如果你要配ES的话，你ES要试试它的这个。这个number啊number open files，这就是杠恩，然后还有process这个线成的数量。

这两个是你要做EM集群搭建的时候，这个是要配置。啊，你要可以打开文件面符调大一点，然后可以请的限程数调大一点。明码还是艾O克。然后上面你可以调控中有很多有内存限制open files。

然后打开了最大的这个线程数。有的时候你的ja这jajava破这个创建线能创创建不出来了，为啥这这还有一个限制？对吧这个这个处如果不打开的话，你连现你的普通用户连现城用现城的事弄弄不出那么多来。

要不要？

系列 3：P196：【IO／NIO】GitHub移库 - 马士兵_马小雨 - BV1zh411H79h

咱们的代码迁移了。啊，咱们代码迁移了，知道吧，咱们自己有一个自己的那个get啊，然后呢，我的代码也先同步一下，因为我写了好多的注释，对不对？

然后你就在你这样啊，你在我接下来就是用idea可以同直接同步，你你可以不用装那个de desktop，就是在ss里边，然后呢搜。Beat赖。然后不不不是在这个ppls里边，然后去搜。不。Yeah。

然后把d这个product给它inst，然后重启一下你来列。明白吧？就把getab装一下，装完之后呢，你就get lab，你装上giab就可以了。装上gt lab之后呢。

然后你可以把你的项目这个这个close掉。Cl protect dad。

然后呢，在这儿，然后选择get，然后把咱们那个。然后像products里边，想想是在哪来着。To over her death。然后找到。哎，我在IO呢。啊，在这儿，比如马兵CLO，然后克隆。

复制一下地址。然后到这粘贴。然后找一个地儿给他克隆，克隆完了之后啊，你打开你下面打开了，然后你的me要配好，然后呢alto自动导入就构建好了。构建好了之后啊，你看我是老师端，我能提交。

我会先去在我的有一个在这get里边，我commit啊，提交我的所有的修改。

我去提交，你们未来就是等着吃就可以了。然后我把它commit一下。commit，然后呢我还可以对着它，然后找get，然后呢找repostory，然后给他push往上推这个推啊。

这个推就推到咱们的get lab上去了。啊，然后你们未来就是直接在这个右键上面在get reposory里边，然后给它破ll就可以了。能白吧？这样的话。

你就不需要再再再找这个d一top考过来复制器的过程。反正这个idea一定要记住它叫什么呀？集成工具，它能集成很多东西。🤧Yeah。能看一下所有的NLO吗你的代码吗？有个疑问，比如前一秒。

如果有一群刚来的下午，有一批毒的，有一批血的，还有一群没来的在路上。想法挺好啊，一个线程扔那里exapp就搞定，是这样的，你看。呃，看NO这代码，我知道你什么意思。

这种LO的一般不推荐你们直接写LOLO是B端的。因为你在一个循环，如果它的内核里边接收了10个客户端，你accept只能把10个客户端排在第一个接接收到，那9个没有接收，就是等于10个到达接收了一个。

然后把历史的便利，看看有没有读。翻头来接收第二个。所以NL的代码写起来的话，这个这里边是不太推荐的，因为它毕竟还是属于一种。现性代码这法。这是它的弊端，所以才会有多多复剂，才会有才会有这个实践。

这个后边的se炮或者是epo这个这个过程。

系列 3：P197：【IO／NIO】多路复用器引入 - 马士兵_马小雨 - BV1zh411H79h

造就了你的不同业务场景下，你对IO和现程池的分配的啊这样的一个关系。Yeah。好了，人也差不多了，我们来开始讲课了。8个04。🤧嗯。今天今天周日啊，明天周一好多人其实是。比比比较忙。M。嗯。

今晚核心nike前戏嘛差不多吧，今天其实聊一聊的话，nike我不讲你你查资料也能听懂这个他在说啥事儿。

就是IO这块不懂的话，其实你上来升学nike。其实有的时候你你get到它的精髓。好了，不不不不说那么多那么多废话了，我们来讲课。😊。

L模型从BL模型到NL模型已经讲完了。然后呢，NL也这个昨天也这个昨天课也压了一下。其实这个在访问速度上。

肯定下一个模型多路复云器快一点。但是这个时候其实模型的过渡，这是一个时间轴流过渡，先有的BLO后有的NLO，然后才会有多路复云器。那么NLO为什么要向多路复云器去过渡，且多路复云器为什么比NL快？

那NLO到底慢在了哪里？相对于多路复云器NL肯定会比BLO更省资源，某些证件下，它的速度更快一些。那NLO的问题出现在哪里了？啊，这个是这节课骑手要做的一件讨论这件事情？

首先，to步模型你要懂IO呢最简单的就是单线程模型，一个线程里边，它的接收行为和它的读取行为都不是阻塞的了。所以我就可以用一个循环在里边把接收和读取这两件事情给它便利一下。啊。

这样可以保证一个线程处理所有。但是这个时候其实你要放大一件事情。既然我们谈到C10K了，那我们就开始放大。

NO的问题在哪里？Yeah。え？当你找到了NIO的问题，然后紧接着就可以找到多路复务器的感觉。不是线条，是这个。这个在前面的课和工业课也讲过，但是在这儿为了完整性，我们再来讨论一下。🤧H。

那么他的问题是什么？在NLO的时候，虽然我一个线程可以解决所有的事情，但是注意听你每一个操作都要触发一个系统调用，是由软件程序主动的。无论去接收我们的客户端，这个行为，这个调用。

还是说每一个客户端的尝试读取，有没有读到有没有读到有或者没有读到这样的一个操作都是由程序向内核去调用，由内核给他反馈。那这样的话，其实你问题你怎么去设置这个问题啊，你只需要把C10K这个问题引进来。

那C10K是什么意思？也就是说当我的客户端连接的数量，就是IO的连IO的这个连接的数量已经达到了1万个了。那么这样的话，其实会引出一个问题，每循环，就是你的你这个单线程啊，每循环一次。

每循完一次，它的成本是一个什么成本？那么将近是有1个ON的。不大度。什么叫有一个ON的复杂度？如果你有一万个连接的话，那么每循环一次都会有O1万的这样的一个receive的调用。

每一个连接都要问你的程序都要问问一点那核说数据到了吗？数据到了吗？数据到了吗会有1万次的这个这个这个系统调用。但是其实其实真正到达数据的就是IO里边数据来了。

你可以读你可以通过这次receive调用拿到数据的连接的数量，就这个这个有数据到达的连接的数量并不多，可能就三五条数据到了，你这个receive调了有意义。那间接着可能有9000多个调用是没有意义。

所以这个这里面会一个浪费。

是无意的浪费的。因为在这种调用的时候。这个调用就牵扯到一个机组的知识。回去往前翻马老师讲的基组的知识，这个叫做系统调用。系统调用里边会牵扯到啊这个所谓的软中断，然后用泰n个ad保护现场恢复现场。

然后进程调度的这样一个等等一系列的事情。🤧所以成本比较高啊，那所以成本比较高啊，那到这个环节能听的同学来说波一，这就是NO的一个问题。NO行，我担心我可以解决现成的问题，这是它的优势。

把前面优势写一下优势。哎O的优势啊是可以通过。一个货。几个县成。来解决。温管是。N格海鸥。处理。你可以用一个线程，也可以用多个线程。你比如像上边，我如果1万个连接的话，我把1万个连接放到一个数组里边啊。

那这如果你有4个县程，那这个111万个这个数组可以切成四段，一个县程负责一段的便利。第二个县程负责另外一段的便利。

对吧这样你可以使用若干个线程，但是绝对不会一连接一线程，就是把现程开的很多，对吧？那这就是NLO相对BLO的一个优势。但是它的弊端就是无论是你一个县程还是多个县程，你每个县城持有了大量的文件面入符。

你都要去调用一次，通过返回复一来知道啊你没每你没有数据到达。但我再去再去询问别询问别的，那么无用无用的调用太多，所以浪费。🤧这是问题。那么要解决这个问题的话，其实向下引申这个问题如果想解决的话。

那线下引申的话，就是要找到多路复文器的这个实现的这个过程。那么多路复文器的实现过程是什么意思？我们简单解释一下。

没错，read德系统调要用是瓶颈。没错，其实其实不是不是啊，这句话不标准。你看有有有同学说了这么一句话啊，我给你打个星号啊，他说了read。这个NL的问题是因为re德的系统调用是瓶颈。不太精确。

因为嗯瑞的自身是无无罪的。就是你你read也好，reivereive也好，你必须要通过这个调用，才能把数据读回来，这就是同步模型。现在我们还没有这个AA这个这个讲到异补，也没有异步。d当中。

在同步模型下，你的程序最终一定是要通过read或reive去读取数据的。所以它并没有罪，只不过你让它有一些无效啊，没错，无效的和无用的。被吊起，那这个就就有问题了。啊。

这个思维一定要一定要想明白这个事儿啊就是你你你如果我调4次readd，我就可以完成真正到达数据了。那9000个，我不调，这是最优的。但是现在这个模型情况下，你是一万个都得调啊，这是弊端。

找到这个之后，其实我们可以简单画一张图啊。

清晰吗？这样这样这样去聊，如果每1个IO啊每1个IO。如果每1个IO你想成是一条路，为什么管它多路服用器？我先把这个路这个事儿关联到我们IO上。如果每1个IO是一条路。然后这个路上有没有数据。

有没有data？发送过来，假设其中某一1个L有有数据，但是这些个路是先扎在哪儿的，这些个路啊是扎在内核上。你的程序肯定是不知道这个每条路有没有数据到达的，然后你的application。

在目前NLO的模型下。使用它的这个编程模型的时候，你NIO当中要融入代码，且代码自身要完慢的去便利。便利某每每条路。喺许许许许喺许呀呀许呀呀。对吧就是你的application是要一个一个去便利。啊。

自己去编历便历的时候，它的成本是在这儿发生的。第一个其实全量。便利。然后写这个便利是用户太内核太。切换。才能实现。相应的成本成本复杂度比较高，有些浪费有些浪费。那是现在的一个模型。

这这个就是你一个人要去问很多条路。但是这时候其实你发现了这个模型当中啊。

🤧路上路上有没有数据到达这个事儿，谁第一个先知道的，那肯定是内核先知道的，内核肯定是这个事儿。然后呢，你从远端挨一个一个的。就是每一次调用是O一的调，只能调一个资源。那这时候如果换成我程序。

和你那盒之间不是打一个电话问一个人，而是我想打一个电话问所有人谁到没到。那么通过一次调用访问所有的路的状态，那就是多路被一个调用复用了。就这一个调用访问了所有的路，就是多路复用了一个系统调用。

现在是每条路有要消耗一次系统调用，多路复用器就是多条路的状态被一个调用所获取。这能听懂出来说个一，也就是说你需要一个多路复音器。多路的路是谁？多路的路就是每一个IO。复用这个复用什么意思？

这个复用器或复用什么意思？他说的是我们。一次调用。把很多条路的状态就是用内核。来获取每一条路的状态的结果题给你这个用程序返回。Yeah。对吧我们先从拓扑上来理解这个事情。那这边的描述就是多条路。

也就是IO。通过一个系统。调用。或者通过一次性调用。获得。提供。あ5か。或者其中的IO状态啊，你一次OE的一次就可以了。但是注意听啊，就是你前面在读取它的时候，既访问他想读。

然后他告诉你结果可读或者不可读，或者能不能读回来，就是把状态和读取的行为放在了一个每一个调用压在了每一个路上。那使用多路复用器的之后，多路复用器只负责注意注意听啊，这重点来了。

那么这里面状态这个词很重要，就是你通过多路复印器只能获取状态。然后。然后由。程序自己。对着。有状态的IO进行。读写啊进行读写，就是最终还是由程序自己去读取他们。所以你最终还是你的application。

比如说他他啊他这个有有数据，这状态就通过这一次调用，虽然复用问了3个，但是给他返回的是这一个IO上有状态了。那么有你的abplication自己要去最终去读取它。Yeah。线条颜色。就自己读去。

所以在这种模型下得出一个结论来，只要程序自己读。自己读写，那么。注意听你的IO模型就是同步的。注意听啊，是你的IO模型是同步的，不是说的你读完了IO的数据，好多的IO的数据读出来之后。

在多个县城里或者在一个县城里处理，那叫处理的同步或异步。好吧，那么就讲到这儿有问题，有没都能不能都都听懂，这就是所谓的多鲁夫尼。那多鲁夫尼是啥？一会给你讲，它有几个实现。

而且它的实现的时候还可以有快速的有消有相对的消耗资源的。😊。

有通用所有系统都支撑的，还有这个个别系统独立实现的。🤧刚才那句话能再说一遍吗？哪句话，我看看木兰啊，主要咱们盯着木兰，木兰如果能搞懂。名词明白，这有啥有啥好处？

什么处理啊，就这个啊，就是我知道你你卡在哪了？就是同步和异步是面向IO尤其这我说了，你的IO模型是同步的那这里其实很简单啊，如果说假设这里面有两个IO都有数据了，都有数据了。

如果这一个县程把他俩的数据读出来之后，把读到的数据抛到两个县城里边去。

抛到两个线程里去执行了。就是你调了方法，这个方法其实底层拿着数据去那边的线程去处理这一个数据了。比如解析集到里边数据的那个那个意义是要连接了一个数据库，然后取出数据再给你返回。

你等着那个方法的返回给你返回回来。你可以阻塞等着，你也可以说调完之后，然后通过放里边放一个回调函数，你的函数是是在堆里边，然后它那边处理完再去调那个函数。

那这时候其实就是同步和就是这个组组这个同步阻塞和同步非阻塞，不是这个这个异步啊，异步，因为交出去了嘛，不是在当前那个县城里边，你线程就直接往下走了。嗯。能理解吧？啊，就是如果我调了我我我读到的数据。

就是把IO这事过完之后，IO模型现在是同步的。但是我LO读到读到的数据读读进来之后，这个结果的数据数据肯定要计算。我这个计算我可以放到我当前那个线城里边，我也可以调一个方法，这个方法。

然后扔扔到另外一个县城，然后我在里边放回调也好，或者我不等下我这个当前程继续往下走，就叫异步了，就是没有在我当前线城处理那个处理可是异步像n等等，其他就可以构建一个事情，或者我们自己写也可以啊。

你先先这样吧，你先去把这个。记一下先先去记一下，一会儿我我用代码给你演示，咱们有这个几种呃有这个IO加上现成的模型的这个这个这个演示但。

系列 3：P198：互联网架构的演变之路 - 马士兵_马小雨 - BV1zh411H79h

好了，同学们，咱们开始准备上那个Spbo了。好吧，来能听到我声音同学扣个一。呃，今天啊咱们开始那个讲spring，呃，很多同学一直在问说那个ringbo讲到什么程度？呃，我希望讲一个完整性的课。

就是说从基础，然后呢到后面的一个精通包括到源码，我们这边都会讲的所以些基础东西啊，大家可能听得很烦。因为之前你们在公司里面已用到了。但是我这还是希望把这些东西啊整体再做一个回顾，很重要一点信息。

好吧咱们ring课大概我的计划是6到8节课，有可能时间会更长啊，这不一定在最少也要上6次课。懂我意思吧？sp还讲不会的spring啊是我们基础班的一个课spring从基础班的一个时间一个课呃。

基础班的时候也是一样的，我也会从基础东西开始讲，然后讲到源码呃，还是一样，我希望就是把这个整体的知识点啊都做一个整体的完整的一个学习。这样的话对大家的一个好处更明显一点。

如果你所有东西都听一半或听一阶段可能不太好O大数据是不是要上的呃，大数据讲了还要维，包括那个。日志的那个小小小项目，然后后续的话可能会讲麒麟啊，基本上三门课我都讲了啊。呃。

大家还是根据自己的一个需要说我到底要学什么东西。基术班随还没开始，刚刚讲到GS啊，刚讲到GS呃JS这块我没去讲，然后请了一个专业的一个老师来讲解的，后面的话都给大家补起来，这个大家放心啊，呃。

刚刚很多同学提到大数这件大数据这件事情啊，呃，我再说一下大数据东西啊，怎么说呢。😊，呃，很多同学说老师我没时间看哦，没时间看或者怎么怎么样。好吧，呃，还是一样，大数据应该是一个必备技能。

你们现在买的课没时间看没关系啊，没关没关系，后续的话啊有时间了，一定要把大数据课补起来。因为你往后看3到5年大数据一定会像java一样来大街，它会成为一个必备技能。而且咱们这边大数据课啊。

大数据课应该是比较专业的光嗨对跑，周老师讲了14节课。😊，懂我意思吧？应该有很多很多这方面的一个东西非常非常完整。所以你需要哪一块听哪听哪块就可以了，不叫大不要求大家说，每天必须要跟某一门课。

你根据自己的需求来决定就O了。懂我意思吧？今天集合项目嘛，看情况看能不能讲到这块，但应该讲不到，我们只是一个刚开始的一个基础课好吧，行了，废话不多说，我们开始讲解springspring然后再说一下啊。

呃大家看到了，我上课的时候，首页打开了spring官网，之前我在讲课的时候也是一样，非常喜欢啊，非常喜欢或者带大家看一下我们spring的一些包括一些其他框架一些官方网站啊，官方网站呃。

为什么官网永远是我们第一手的一个学习资料，所以我希望你们以后学知识也是一样的，所有东西从官网里面直接去看这些点，很重要的信息。好吧，韩江雪说腾讯课堂目录有点乱。呃，这个应该不会特别乱。

因为之前给大家做了一个整理。那天有学生反馈之后，我这专门做了一个整理啊，大家可以看一下。😊。

其实啊只是家校课里面稍微有点乱，因为家校课里面我们加了很多的一些怎么说呢？很多的一些加了很多餐，所以这块可能会稍微呃乱一点。然后这块都大家做做好整理的网络分布式。

然后s cloud多线能高并发s源码nikeNIO然后呢JVM以及流量的项目，包麦测度条优架构师的前置知识，这块都给大家做做了总结。😊，听白意思吧？所以这一块几乎后面的东西啊也都会一直更新的。

不用担心啊，大数据的顺序有吗？大数据就按照课程顺序往里边写就行了，往里边学习就OK了，懂我意思吧？就按照我们课程的一个呃正正确目录顺序。

呃，SS来说了，非物流冰说质检吗？呃，没关系啊，你们能够找出来问题或者提出来bug，这很正常。我们是人不是神，我们也会有这自己认知错误的地方。如果有问题，希望大家能够及时反馈好，及时反馈，没问题啊。😊。

现在没有意义，根本跟不上，慢慢就跟上了。总之一点，你记住一定是要学的就可以了，懂我意思吧？架构室里没有有没有中台项目啊，呃，这个怎么说呢？呃，看情况吧，大家如果对中台有有兴趣的话，可以学一下呃。

给大家说一下中台项目，我们是请的一个现在已经投产的，已经在呃产生一些商业商业价值的一个项目，对公司CTO来进行讲解的。所以咱们的中台才是正儿八经的一个中台项目啊，到时候你们期待就可以了，一定会有的啊。

😊，好了，废话不多说。来先聊一下我们的springbo。😊，啊吧，很多同学在公司里面一直在用sringbo吧。来在公司里面，现在没有接触过sringbo同学扣1，没有接触过的。😊。

别说接触过没有接触过扣1。这么多吗？不可能吧。是我认知错误了吗？😡，嗯。来给大家说一下，呃，现现在还有很多传统项目，很都还是SSM呃，那我们就更要从刚开始来进行一个讲解了。刚开始来进行讲解了。

还是一样先说一下我们的SSM其实在SSM之前，应该是什么叫SSH对不对？它是有一个整体的过渡阶段的。在SSA之前可能还有和GSP对吧？他们几乎都是一脉相承的一个东西，这块，我希望从刚开始第一节课的时候。

能够帮大家拔高我们整个架构的一个认知啊，架构的一个认知。大家想一下，在我们的项目或者我们的IT行业发展起来之前，最开始的架构。😊，最开始的架构。没人知道好吧，叫单一架构好吧。

单一架构这块给大家看一个东西，看什么呀？我们看一下double的一个官网，double官网里面有这样的一个描述，我不知道你们有没有没有看过我们架构师根本不信这些拍胡照东西，呃，要信好吧。

这些东西设计还是非常有意义的啊。我们来找一个文档。😊。

在档里面有一个背景，大家可以看一下这样的一个描述。我们今天不讲大ou宝吧，不讲大宝没关系。然后这单这边我们要看一下互联网的一个发展趋势，说随着互联网的一个发展，网站应用的规模不断扩大。

常规的垂直应用架构已无法应对分布式服务架构以及流动计算架构势在必行。急需一个治理系统来确保架构有条不紊的进行演进。所以这里面几乎画了这样一个学习路线图，或者说一个架构的演变过程的一个图。

这个图我不知道你们能不能看懂好吧，但大部分应该是没问题的往看上面放了work什么框架吧后我们的架构后面有我们的表示我们的集群好吧，它就是这样的一条时间线的这个图我不知道你们有没有见过，没见过没关系。

我这带着你们看好吧，刚开始OMMACRPOA对不对？刚开始是什么呢？叫all in one就是我们说的单一应用架构。说了当网站流量非常非常小的时候，只需一个应用将所有的功能都部署在一起。

以减少部署节点和成本。此时。😊，简化增山改查工作量的数据访问框架OM是关键。这个里面描述了一个什么信息啊。就好比你们在刚刚接触java的时候好，一般在学到serv之后啊。

很多人可能说老师我终于学我可以做一个前后端交互的一个项目了。所以一般情况都开发一个常简单项目。当你这个项目开完成之后。

一般都会部属一个包放到我们的一个top容器里面或者其他一些呃动态的一个 web容器里面，然后进行一个运行。这个时候你看到你的浏览器可以进行访问，然后说后面呢有一些数据交互，这是最开始这样一个过程。

但是你要注意一点，这是最最最开始的时，一个架构思想，然后呢随着技术的一个演变以及用户量的一个激增，慢慢的说这种单一应用架构不太符合我们实际的一个情况了，那怎么办？有了叫垂直应用架构。

大家其实可以看一下这个图看这个图来做一个对比，什么图对比刚开始叫 in one后面呢叫垂直的应用架构什么意思？这个图是没有任何变化刚开始一个蓝色块后变成三个蓝色块。😊。

然后下面集训规模由1到10台变成10到1000台，这表示都是我们的应用程序。也就是说当用户的一个访问量逐渐增大的时候，单一应用增加机器带来的加速度是越来越小，为什么你想一件事啊，你想一件事什么事情？

你注意了任何一个硬件，它都是有自己的一个性能上限的。你所有东西都不是在里面的话，就算你扩架或者增加你的硬件的一个效率，它其实对带来速度影响也是非常非常小的。

然后说了将应用拆成互不相干的几个应用以提升效率。因为我现在需要把单一的一个应用拆分成123或者说N多个应用了，这样的话就变成一个什么呢？叫垂直应用架构。然后页面之后说了在垂直应用架构中。

此时用于加速前端页面开发的外部框架的MVC是关键什么叫MVC啊，modeltl了，包括你们现在写项目的时候，一般都怎么写，现定一个controlll用来接收我们用户的一个请求，对吧？

然后第一个model，我们实体类好吧，然后还有我们的呃MV。😊，试图是我们的一些浏览器页面，是不是经营这样一个方式。你们现在做的时候依然是一样的。只不过现在我们用spring也好。

还spring book也好，他帮我们做了一个整体的整合啊，整体整合。这个大家注意了好之后我们再来说我们再说这块然呢由垂直架构之又做了一个演变叫什么呢？

叫分布式架构di什么意思一样的也是说当垂直应用架构越来越多应用之间交互不可避免，将核心业务抽离出来作为独立的服务逐渐形成稳定的服务中心。这个时候你注意了，当你形成N多个服务中心之后，会存在什么问题啊。

他们之间一定要产生数据的一个整体交互过程体交过程这个交互的时候通过什么这通过我们的RPC了什么RPC是不叫远程过程调用这样的东西。

远程过程用这样西这后面这说程过程调用来进行一个演变后还没完又往下进行一个演变怎么演变说当服务越来越多的时，容量的。😊，小资源服务的浪费等问题逐渐明显明显。此时需要增加一个调度中心，给于访问压力。

实时管理集群容量，提高集行利用率。此时，用于提高集行利益率资源调度和治理中心就成为了关键，就是我们的SOA是不是大家看到了这段有一个基本的描述。这个描述里面就阐述了我们整个互联网架构的一个演变之路。

当然很多同学可能年纪还比较小，好吧，你可能没有接触过前面这些架构的一个演变过程。好吧，你下来之后可能直接学smebo搞定了或者直接学飞服务。对不对？但是前面的这些历史你要有一个感知，会有一个认知。

它一定是要不断进行发展的，好吧？而发展的最终的目的是为了什么？是不是使我们第一开发效率提升。第二，我们对应的一个应用程序，它执行的一个效率要做一个提升。所以人们怎么样呢？会发挥自己的想象力。好吧。

创造出来各种各样的一个东西，好吧，来达到我们想要的一个效果，这块要注意了。所以刚刚这个架构演变之路能听明白的同学来扣个一，这同能看懂吧？Yeah。你们要不要想老师，你这个图你是怎么知道的，我还是那句话。

你多去看官网，你不一定说我学什么技术，就一定要看什么官网啊，没必要。但是你要知道一件事儿，当你看官网之后，他们其实可以交叉进行学习的大包里面东西是不是介这个架构演变之路。

我们在spring就可以进行一个使用了。而且现在在企业里面几乎没有spring没有公司不用springspring它有一个全家桶理工里面提供了非常非常多的一个服务吧。这块希望大家能够认知到好吧。

往下看这是spring的一个官网，我刚上来打开就是这官网好吧，springring cloud和spring cloud flow它这3块表示什么意思呀？什么意思？第一个叫biild叫构建一切好吧。

第二个呢叫协调一切吧。第三个呢叫连接一切，这是spring它想做的一件事情，然后里面分了N多组件来进行一个描述。第一个spring5就是我们spring框架这东西咱们加构课里面可能不会再讲了。

后续的话基础课里面会讲吧，基础课里面会讲，然后呢讲完之后。😊。

会把那个课单独拿出来成了一个小课。之前我也说过了，我们有自己的一个视频网站。这个视频网站我还在开发，好吧，大概在1月1号的时候会重新给大家进行见面。包括我们整个网站的一个设计。

整个网站的一个设计都会呃进行一个更新啊，其实现在也在做，我可以给大家提前看一个东西看啥呀？呃，给家找一下。就我们后面一直在做升级，很多同学可能有平常问问题的时候。

可能找不到我为什么一般都在开发这个推开发这个项目啊，大家看一下叫web杠test。诶。😊，没了吗？t杠外杠 index的HTR。大家看到了啊，这个现在这样看起来，这个图现在还没在做，好吧。

之后的时候别老想着翻车，好不好？之后的时候我们会把网站进行整体的一个升级。好吧，这是我们后续的一个网站这边的一个规划，应该比我们现在官网要好好看很多吧，好吧，大家今天等着以后啊。

还是一那句话会提供越来越多越来越好的一服务给大家。你们从官网里面或通过我们的视频网站都能看到很多信息，但这开发啊只不过呃需要一段时间，所以希望大家能给我一段时间。好吧，一人就是一支军队啊，不是啊。

我们肯定要呃做这块东西的。懂我意思吧。😊。

用的技术你们就不用管了吧，用的技术你就不用管了，前端也是一手包备包干嘛，呃，基本上都在自己做，好吧，基本上都是在都都在自己做。所以有时候可能回答问题不太及不太及时，原因在这就在这一块，要是招人物。

我可以去招啊，可以投简历，好吧，欢迎大家投简历，反正你能想到东西，我还是那句话，你能想到东西，我能做的都帮你做了。所以希望大家能够争惜自己的时间，抓紧时间学习就够。懂我意思吧？

不知道企业头像有没有没有了，没有了。😊，没几天了是没几天了，我们后续这些东西都都都都在做啊，不是不给你们看其他页面了，没有意义啊呃，做完之后你们等着。😊。

系列 3：P2：【多线程】什么是CAS？（基本概念） - 马士兵_马小雨 - BV1zh411H79h

ok那么今天讲什么呢，我们今天讲这个synchronized，主要是讲synchronized volatile，今天讲不到位，今天讲的内容是超级难，如果就算你以前听过啊，你今天再听估计也会感觉比较难。

依然比较难好吧，所以不知道synchronize是什么东西的，你可以撤了，wallet tel，今天讲不到位，我们先不讲。

好关于synchronize这块呢，我估计今天今天晚上三个小时能给你讲清就不错，schronize这块各种大厂问的问题特别特别特别多，所以就这块的话呢，你要掌握住的话。

基本上能够压中大多数大厂的其中的一道题吧。

好吧呃，为什么大厂喜欢问这些用不到的东西呢，我觉得大肠有他自己的考虑，第一个呢是骗自己能显自己牛哈哈，有的面试官是有这样的想法，我觉得这种就非常的幼稚呃，第二种呢就是想看看你对待技术的态度。

看你在技术方向的潜力，你对待技术这块呢，你有没有这种深挖的这种态度，技术潜力，这方面有没有朝底层方向发展的潜力啊，还有一种呢，其实本质上最最根本的其实就竞争太激烈了，筛不出来，选一厨师大会都会切菜。

刀工都不错，那咋办，我怎么选啊，a也a也行，b也行，我得调一个更牛的呀，我就问点儿平时用不着的，比如说胡萝卜，它到底营养营养素方面是在哪方面好，谁答出来谁来，所以呢ok就就就就就变成这样了。

好多好多特别其实平时用不着的东西，他都开始问啊，比如说锁升级，你说你用得着吗，基本也用不着，你说它的效率怎么样，其实也很简单，你你写几个程序呃，做一下压测不就行了吗，没有必要看它的原理，但是没办法。

他就问这是今天我们要讲的内容，好，今天我们讲什么，就讲一个词，就是synchronized啊，俗称就是辛苦辛辛辛辛苦了的啊，辛苦了的啊，sychronized，今天我尝试着会讲得更加的稍微细致一些啊。

呃大家先听我说啊，如果说想了解synchronize的话呢，首先要补几个基础，你认真听基础，第一个基础呢叫c a s。

什么叫cs，我们先说这件事，cs要不了解，我跟你讲c空战的基础，你肯定听不懂，我们先聊什么叫cs，cs全称是叫做compare and swap，或者叫compare and set。

或者叫compare and exchange，那这句话的意思就是比较并交换，比较并设置等等，呃举个例子，我们举例子说明内存里头有这么一块内存，这里面有个值是零，我现在多线程去访问这个值。

每个线程都想把这个数给它加上个一，平时呢我们知道如果想做到现成的数据一致，这时候你得对它对它进行加锁，加synchronized，但是这uc的包出现之后增加了一种新的方式，这种方式叫cas操作。

所谓的cs操作是什么意思呢，好是这么来做的，我的第一个线程把这个零拿过来，在自己的县城本地区域里头做计算，知道了哦，原来加一之后，这个值会变成一，然后呢再把这个一给写回去好了，这是一个线程执行的过程。

那么如果我想做到不加锁，就能够实现数据一致性，我再说一遍，不加锁就能实现数据一致性，原来我们不是得加锁吗，加锁的意思就是我在我加一的这个过程之中，任何其他线程不能访问这个值，呃不不不叫不能访问。

就是在我枷锁的这个给加一的这个过程，只有一个线程能能能执行这个操作，但是现在我不想加速，不加速能不能完成，可以用什么方式呢，用cs cs方式怎么做呢，把这个零拿出来，放到自己形成内部加成一。

把这个一写回去的过程之中，要进行比较比较，拿什么比较呢，比较的意思就是说看看这个值是不是依然为零，大家还记得吗，我把它读出来的时候，他这个值是零，然后我给他加上个一，如果我会写的时候，他依然还是零。

那说明什么，说明这哥们儿中间没有被人打断过，比如说啊在我拿出来把零变成一这个过程之中，有另外一个线程又拿了这个零，自己回到这个一，又给他写回来了，这时候它的值已经变成一了，那这种情况会发生什么呢。

我第一个线程就会说哦，我拿出来是零，你现在已经是一了，说明有人动过你了，有人动过你了，我就不能够把这个值把新的一给你写回去，我怎么办呢，我重新再来一遍，你现在不是一吗，我把一拿出来改成二。

再把这二写回去，写回去的过程中，我再比较比较什么呢，比较我拿这个一写回去的过程中，你依然是不是还为一啊，如果你依然唯一说明没有人变过，那在这个过程中，如果又有人把你变成二了或者变成五了。

那这时候怎么办呢，那我就重新再来把这个五拿出来，改成六，把六写回去的过程之中，看看你是不是依然为五，那如果依然为伍的话，说明没有人动过，我就把这个六写回去，这样我就不需要上锁了，如果中间有人动过。

我就不断循环不断循环不断循环，直到我这个加一操作成功为止，ok这个东西叫做c a s叫compare and swap，专业一点读取当前这个值计算结果比较当前新的这个值。

就是你原来内存那块的值和我原来读出来那个值是不一样的，那如果一样，说明没有人变过，没有人变过的话，我就把你更新成新值，ok就结束了，如果说有人变过，我就重新再来读你最新的值，再计算结果再来，好了好了。

这个cs大概的意思来get到同学老师扣个一，这里面会有一些细节莫及，那这里面呢会有一些什么问题呢，首先我们说cs的话，它中间有一个著名的a b a问题，面试的时候经常会被问到什么叫aba问题。

依然是这个值，这个值是五，我拿出来之后把它改成七，我想把这个七写回去的时候，看他依然是不是我，但是在我拿出来做计算，往回写这个中间过程有可能有一个人把这个五拿去，把它改成三了。

有另外一个线程又把这个三拿拿出来，又改回成五了，你的女朋友跟你分手之后经历了别的男人，明白吗，哎等你回来的时候发现啊，他依然是你那个女朋友，但是他中间已经经历别的男人了，好在这种情况下。

这个叫a aba问题，原来是a中间曾经改成过b，后来又又换回成a了好了，这个就是有可能会产生a b a问题，那么a b a问题怎么解决呀，这个办法呢其实很容易解决呃，加个版本号就可以了，什么意思呢。

比如说任何一次改变都给它版本号加一，原来是版本号一点，改过一次就变成二点，再改一次变成三点啊，等你你一点的时候离开你女朋友回来的时候，发现你女朋友上面写着99点啊，你就会知道经历了多少次。

ok然后你采取什么样的措施来处理，这个是你自己的事情啊，当然是原谅他了好了，所以这就是aba问题怎么解决，就是加版本号呃，这个版本号呢还有两种，第一种呢是数值型的，第二种是布尔类型的。

这个我就不详细讲了，总而言之cs是有这种问题的，好吧，那个不能叫绿了，人家又没有跟你在一起的时候是吧，那个不能叫绿了啊，有些概念必须得澄清，那讲到现在为止。

关于这个cs的基本概念。

系列 3：P20：【多线程与高并发】锁的可重入属性 - 马士兵_马小雨 - BV1zh411H79h

下面我们来看sychronized等等等，另外一个属性，这个属性是什么呢，就这个属性叫做可重入，这可重入也是secret的必须的一个概念啊，不然的话就没法使用它了，辛格代词叫可重入，可重入是什么概念呢。

如果说一个同步方法调另外一个同步方法，有一个方法加了锁了，另外一个方法也需要加速，加的是同一把锁，也是同一个线程，那这个时候申请仍然会得到该对象的锁，也就是说c是可重入的。

什么意思，有一方法m一它是synchronized的，有一方法m2 它也是synchronized的，m一里能不能调m2 可不可以，如果它不可重入，会产生什么现象，你分析一下，c ronized。

我们m一开始的时候是这个线程得到了一把锁，然后在m一里面调m2 ，如果说这个时候不允许任何一个县城再来拿这把锁的时候就死锁了，这是不可能的，这时候如果再掉m2 的时候，他发现还是同一个线程。

因为你m2 也需要生成这把锁，结果他发现掉m2 的时候呢，我需要设计这把锁的时候，发现哦，原来是同一个线程申请的这把锁允许可以没问题，这就叫可重入锁，所以sronized是可重入锁啊。

synchronized的必须是可重入锁，以前有个同学会被问到了，问到了面试的时候，问到这么一个问题，simple是可不可重入的，为什么它必须是可重入锁，原因是什么呢，你比方说你有一个父类。

parent，它里面有个方法m有一个子类child，它里面有个方法m重写了它，但是呢它掉了super。m，如果你上面是synchronized，ok这里也是synchronized的，你说掉super。

m，这个很正常啊，我就负类的这个m方法，但是如果他不能够重复的话，你就直接负了父子类之间的这种继承，就直接死锁了，这肯定不行。

好了。

这是simple代的可重入的概念。

好看这里啊。

这个呢就是我刚才模拟的一个父类子类的概念，负类srt是吧，子类调用super。m的时候必须得可重入，如果不可重入的话，那肯定戳你了，调父类的还是同一把锁嘛，必须的呀。

你看synchronized是锁的谁啊，锁的this this类项。

这个cma也说的是this对象嘛。

还是同一把锁啊，估计有同学可能会在这儿有疑问，说我这个sronized到底锁的是负类的this对象还是子类this对象，我记得我原来画那个父子类的这个图的时候。

你弄出来这个对象叫tt在它里面呢有两种方式啊，第一个就是说基本上就只有这种实验方式吧，就是它有一个他有一个那个那个呃parent的这个指针，指向的是他的父类的对象，但是锁对象的时候。

你想想看你调的这个方法，symphonized的，他说的是谁，锁的是this，这个例子是谁啊，都是他吗对吧，当你调跑到这个方法去掉的时候，super。m他锁的还是要this吗，这才是谁，还是他。

所以锁的是同一个对象啊，呃所有的重入锁就是那个你自己拿到这把锁之后，自己不停的加锁加锁加锁加锁加好几道，但是锁的还是同一个对象，还是你自己锁的，你去一到就减个一。

系列 3：P21：【多线程与高并发】异常跟锁 - 马士兵_马小雨 - BV1zh411H79h

啊如果没问题，那我们来看这个异常跟锁啊，这个也是也是需要你小心一点的概念，这异常跟锁的概念，异常跟锁的概念是什么意思呢，就程序之中如果出现异常温的情况下，锁是会被释放的，再说一下。

记住这一点就行了，程序之中如果出现异常，默认情况下会被释放，看这个小程序加了锁。

secret void的m while处不断执行线程，启动com加加嗯，等com sleep，如果看到no 5的时候，我让他人人为产生了异常，i等于1÷0，这肯定会产生异常，除零异常锁将被释放。

如果不想释放，让循环继续，本来我们是well true，一个服务器程序在这里不停地运行，然后呢还加了锁，synchronized的别的方法进不来。

这个时候你如果产生了任何的异常的话。

ok中间产生了任何的异常，就有可能会被会产生一种什么情况呢。

会被原来的另外的那些个，准备拿到这把锁的程序乱冲进来了，乱入程序乱入是吧，本来，我要执行象征性的代码，要拿到这把锁诶，但是呢我中间产生了异常，然后我就把这锁给释放了，另外的所有的那个程序诶。

正等着往里头运行呢。

马上我就拿了这把锁，有可能会对你的数据产生不致，好这个叫做异常，会释放锁。

所以一个web application的处理过程，多个surface线程，异常处理不合适，抛出异常之后，其他的就有可能进到这个同步区，会产会访问到你异常产生，去出的那些中间的那些数据啊，这要非常小心。

嗯，这我就不演示了好吧，本来你看上面那个县城，我要出门不停的运行，但是一旦抛出异常之后，这个就会被其他线程所运行了，上面呢是我们的，t小t等于6t呀，t。m都是叫t。m方法。

那么第一个线条呢是去掉它的tdm方法，第二个线程是t2 ，也是叫tdm方法，输出的是每一个线程的名字，本来正常情况下是t一运行，t2 不可能运行的，不过呢它一旦产生异常之后。

t2 这个可能运行来看一下结果，第一次第二的啊，你看你这里产生了一个异常by zero，结果马上t2 就得到了执行执行结果了，看到了吧，得到了执行的机会啊，你的程序呢本来正常是不允许他执行的。

ok好，这里呢是异常和锁的概念。

系列 3：P22：【多线程与高并发】锁的底层实现 - 马士兵_马小雨 - BV1zh411H79h

好看这里啊，ok同学们呃，那么讲到这儿呢，我觉得有必要呢跟大家谈一下，这个synchronized的这个具体的底层的实现。

啊看这里我那个建了一个新的package包啊，4001201，我觉得我好像少跟大家谈了一点小问题啊，我把这个siri的具体的实现在这儿呢，跟大家交代一下，这个cironized的具体的实现呢。

有他经历了好几个阶段，可以这么说啊，就原来呢最早的时候，在jdk比较早期的时候吧，这个也不太记得到底是哪个版本了，总而言之是这这dk比较早期的时候，这个sima的实现是重量级的。

信用代时间是非常重量级的，他所有非常重量级的一个概念，是什么概念呢，就是它这个synchonized，都是要去找操作系统去申请，所然后就会造成superman的效率非常低，后来呢嗯就是要java。

后来越越来越开始处理那些高，并发展这些方面的这些程序的时候，可能那个成员就特别不满意，说你sirnas这个方法，这期简直用的是实实实在是太重了啊，我没办法，我就得开发新的框架，不用你原来原生的了。

后来做了一些改进，后来的改进后来改进成什么样了呢，其实siri呢是有一个所升级的概念，关于这个所升级的概念啊，我还专门写过一个文章，叫做我就是厕所所长，大家去找一下啊，我的我的那个公众号里面也有呃。

然后那个网上你搜一下，应该网上也有啊，两个一共是两个一和二啊，我专门用小说的形式讲了这个所升级诶，到底是怎么样的一个概念，我不带白读了好吧，两篇文章还是有点长的啊，在这里我跟大家交代一下。

这个锁升级是什么概念呢，这个锁升级的概念呢是这样的呃，原来呢都是去找那个操作，都要找操作系统，要找内核去申请这把锁重量级的到啊，转向系数1。51。5之后是吧，嗯好。

到后期呢进行了一些对simple做了一些改进，它的效率呢变得比原来要高不少，改天在什么地方呢，当我们使用super nt的时候，hosport的实现是这样的啊，上来之后第一个去访问某把锁的线程。

你比如说synchronized的某一个project，上来之后呢，先在这个object的头上面，mark word记录这个现场，就记录一下这个线程的线程号就行了，就往这个object上一记录。

什么也不干，没给他加锁，我再说一遍，如果只有第一个线程访问的时候，实际上是没有这个给这个obj加速的，在内部实现的时候，只是记录这个线程的i d，这叫什么呢，叫偏向左，所以偏向组的概念。

就是说你你是我的第一个，我骗了你一些，我默认将来呢不会有来第二个县城唉，来抢这把锁，ok这个时候使用的是偏向锁，只记住这个线程id效率非常高，如果还是这个线程回来访问，诶，一看这就是我的那个对象得了。

我也不用申请什么锁了，乱七八糟的了，我直接开始执行就完了，所以它效率非常高，而且大多数情况下呢，也都是一个线程来执行啊，这是偏向锁，然后偏向锁如果有现场征用的话，如果有现成争论，好这个时候就升级。

为什么呢，自旋锁，自旋锁什么概念，自旋锁的概念就是诶你蹲在马桶旁边，这个这个有有有一哥们儿在这蹲马桶呢，对不对，这哥们儿在这儿蹲着马桶呢，好另外来了一个哥们，他干嘛呢，他在旁边等着。

他不会去跑到那个我刚才说的那个在cpu上，那个就绪队列里面去，不会他就在这等着占用cpu，用一个while的循环，while true是吧之类的，类似的这种循环在这转圈，玩转了好多圈之后。

发现这哥们儿你还不行吗，得这种情况下，整个锁才会再进一步升级，自觉所选默认的情况下是选多少次呢，是选十次之后，两个县城，一个县城在那站着锁，另外一个县城跟他自旋，悬了十次以后，如果还得到这把锁，升级为。

重量级锁，所谓重量级锁，就是去操作系统那里去申请资源，来加这把锁啊，这里呢是经过一个所升级的概念，有了这个新生代的改进之后呢，原来曾经有一些个文章哈，还有一些那个其他的那个那个那个啊，讲法也好。

说说这个seized啊，比atomic原子类的那些操作慢不少啊，等等这样的一些个说法啊，但实际上我告诉大家，经过了这些个所升级的这些概念之后，siri用的偏向锁自旋锁，然后呢重量级锁你如果做测试的话。

你会发现大多数的情况下，siri的并不比那些a tomic慢，原子类哈，不不比那些慢啊，好了，所以这是一个所升级的过程啊，好看看这一小块儿呢，有没有同学有疑问的地方，折子戏中好像还有一个cs的过程。

大哥自旋锁在干嘛，october，自选十次不夜战的cpu，别人也释放不了锁呀，如果释放不了，再去升级为重量级锁的时候，这个线程就成为等待状态，就不占cpu了，october，锁好像只能升级不能降级。

对没错是的，所以好像是没法降级的嗯，唉jonas，你提的这个问题还是很尖锐啊，这个说的非常的非常的到位啊，就是说你本来这个锁大家伙的征用，征用来征用去诶，然后呢它升级为重量级锁了，升级为重量级锁之后呢。

后来这个中央下来了，就只剩那么一两个线程，这时候呢如果你再回来，效率会更高，但是呢你回不来了，其实能不能回来，我想啊，如果你的你的虚拟机实现写的到位，也可以做到能回来，我再说一遍。

synchronnet这个东西，java虚拟机实现里面并没有规定，他到底该怎么实现，所以我说的这些全都是hob实现，就oracle的这个虚拟机的实现，假如oracle虚拟机实现不是这么实现的。

我也没法跟你这么讲啊，哦tober，感觉自旋没有用啊，你再感觉感觉我给你三分钟，四分钟，五分钟之后啊，十分钟之后，如果你再感觉感觉，如果你还不能不能理解我，再讲给你听，自选组啊，呃既然讲到这儿了。

我们讨论一个问题啊，在什么情况下我们使用自旋锁比较好，因为atomic以及包括后面的很多锁啊，这各种的lock，其实他用的呢全都是那个自旋锁，用的自旋锁，基本上用的全都是自旋锁，这个他人口有一个特点。

它是占cpu，但是他不访问，操作系统，所以呢它是在用户态，在用户态去解决这个锁的问题，它不经过内核态，因此它的效率上，这个枷锁和解锁，这个效率上，其实要比那个经过内核态这个效率要高，但是呢你分析一下。

在什么情况下用自旋锁会更好一些，在什么情况下用重量级锁会更好一些，经过内核的要要要好一些，你们分析一下，在什么情况下呢，自旋锁由于它是要占用cpu的，而os这把锁呢实际上是不占cpu的。

所谓的不占cpu的，意思是说，在旁边竞争的那些个县城，是进入的等待队列里，等待队列呢就是说你在那等着不占cpu，什么时候cpu让你运行了，你才把你把你叫起来，你才运行，所以什么情况还用自旋锁。

什么情况还用这种锁，你分析一下，执行时间长的，用系统锁没错，说的非常对，这个问题你们要好好思考，像这个问题，如果在面试的时候能跟面试官谈清楚，肯定会高看你一眼啊，没错啊，这writer说的非常对啊。

直行时间长，尽量的用系统锁，执行时间特别短，另外除此之外支撑时间除了短之外，你的这个线程还不能太多，2万个县城跟这等着自选，我告诉你，这事儿也受不了，一个县城正在执行，19999个，在那自选。

你觉得你cpu受得了，所以，是执行时间比较短，这是第一点，就是说枷锁代码执行的时间比较短，他别人经过这14自旋，这个别的这个锁可能已经就已经拿到了，好在这种情况下，直播时间短，线程数比较少。

用自旋锁执行时间比较长，线程数呢比较多，用系统锁啊，ok，那就给大家写出来，这里指的是枷锁代码啊，用自旋，执行时间长，线人数多用什么系统手，就是你用siri，就这意思啊，o。

好四分钟也过了啊，刚才那个刚才是谁有问题了，october是吧，o小鬼懂了是吗，好啊很好啊。

系列 3：P23：【多线程与高并发】第一天课后总结 - 马士兵_马小雨 - BV1zh411H79h

好那我们呢稍微回顾一下今天讲的内容好吧。

稍微回顾一下今天讲的内容啊，今天呢实际上就讲了哎，到底什么是现场，现场的概念，启动方式嗯，常用的方法，sleep join，常用方法，嗯然后呢我们讲了线程同步的概念，主要讲的是什么。

synchronized，我们稍微问一下这个synchronized到底什么意思，首先synchronized锁的是谁啊，锁的是一个对象，锁的是对象，不是代码，这是必须要搞清楚的，第二一个呢。

如果你在一个方法上，如果不加任何锁的话，锁的是呃，不加不加任何指令的话，锁的是this，好呃，除了这个之外呢，你可以锁静态的，所静态的锁是什么，锁的是什么什么点，class，是不是所认为嗯。

还有一个呢就是synchronize呢是锁定方法和非锁定方法，可以同时执行，ok，除了这个概念之外啊，就是所升级它本身有所升级的概念，所升级呢是经历了三个过程啊，第一个过程呢是偏向左支线索。

就是那个你来了之后，我就进你个号就行了，开门还是你还是你，那你就进来了，这意思，第二个呢是自旋锁，我先不尝试去找操系统申请那把大锁，先申请这个小锁，先自己悬着在旁边转圈玩，然后呢才是重量级锁。

就是像操作系统申请的重量级锁，然后呢我给大家讲了在什么情况下用自旋锁，什么情况下用重量级锁，ok这是我们今天讲的内容，呃sorry啊，我想起来了，我想给大家讲了一个小问题，就是讲一首我少讲点什么问题呢。

呃锁定就是synchronized，你锁定这个对象的时候啊，这个object不能用什么，不能用string，不能用integer，不能用long这些基础的数据类型，不能用string的概念主要是什么呢。

因为呃不能用string的常量，严格来讲应该是这么说的，你尽量的连那个死神对象都不要用就行了，不能用spring常量，为什么不能用spring常量啊，你分析一下。

如果你super ized的一个比方说是super ized，是这么一个玩意儿，是这个对象，字符串常量，那字符串常量大家都知道那个所有用到这个字符串常量的地方，其实用的都是同一个，对不对，好。

假如你某一个线程锁定了这个字符串常量的话，而且很不幸的是，这是一个类库，一个library，别人用的一个炸包里面，你写的某一段程序，你锁定了这个字符串常量。

然后你的用户的现成的人呢又尝试着去锁这个字符常量，结果就会发生什么呢，用到这个类库的那些的代码诶，不小心给给这个给锁定了，结但是呢当你用到这个类库的时候，又需要锁定这个，你发现你一不小心。

别人写的代码跟你写的代码之间竟然锁定的是同一个对象，中间会产生什么奇怪的现象，我就不知道了，放下也不记得说重录了，你给我哪凉快哪待着去，重物一定是同一个线程啊，sorry你我我我我来我打两回。

打点钱哈哈这个也有可能你跟你用的那个类库的确实是同一个县城，但也有可能不是同一个县城，如果不是同一个县城，很可能就死锁了，如果是同一个选择，很可能重录了，重录了也不一定是想你想要的那个结果。

所以记住这一点就行了，你不要用这个磁针常量也不integer，因为image它内部做了一些特殊处理，你每产生这个integer，只要那个里边那个对象稍微变一下那个值，它就会变成一个新对象，ok所以。

记得这个结论就行了，不要用死真常量，不要用这些基础的数据类型，听懂了吧，所以就别废话。

系列 3：P24：【多线程与高并发】第二天课前复习 - 马士兵_马小雨 - BV1zh411H79h

ok不多说了，我们稍微回顾一下上节课我们讲的多线程和高并发的传闻，内容回顾一下啊，讲了县城的概念是非常简单，启动的方式嗯，有一个thread st，用rable来启动。

用executor来启动常用的一些方法，sleep with join，线程，如果需要同步加synchronized sega，不能用常量，不能用spirit类型的常量啊，不能用基础数据类型。

integer long等等，好线轴的同步，他呢锁的是对象，而不是代码，这一定要记清楚，你说的是某一个对象，是通过这个对象的对象头上面的两位来控制是不是加了锁，加了什么类型的锁。

锁呢一般来说默认的或者说this所当前对象所什么什么的class，所找个这个class类的对象，什么时候呢，如果你是普通的方法，sychronized的m普通方法锁的是this。

如果是esthetic synchronized，那么说的就是什么什么class，锁定的方法和非锁定的方法是可以同时执行的，非锁定方法人家本身就不需要去访问这个锁，所以呢你所不所动而没有任何关系。

所以你要想如果说你的某一个类想知道多线程的话，你得特别特别小心翼翼的来进行设计的，什么样的，哪些方法要加锁，哪些方法呢，不加速所升级的概念呢，就是synchronized的内部呢进行了一些相应的优化。

所升级的概念，我们稍微回顾一下这个从阿里的这种面试的变态来看的话呢，这种题后面也会慢慢的会被问到，什么叫所升级的概念呢，所升级的概念就是呃你比如说你要锁定某一个对象，那么前面有说过。

我是在这个对象头上的某两位来指定它到底锁的什么类型的锁，在对象头上还记录着当前县城，哪个县城啊，哪个县城申请了这把锁，那偏向锁的概念是什么呢，这个线程来了之后呢，先不尝试对它进行加锁。

只是记录这个线程的id值，线程id记在这，那么我们就认为呢这个对象呢是这个线程独有，下次再来申请这把锁的时候，他就会认为就是那个那个倾向于还是这个这个县城，也就是说这个锁呢。

实际上是偏向于这个第一次拿到这把锁的这个现场了，所以他没有真正的加锁，他只是说你下次来的时候判断，你如果还是原来那个现场的，你就别加锁了，继续直接访问，不要考虑这个加锁的问题了。

因此呢效率上会稍微高一些，但是如果来到县城，新的这个县城呢，不是原来那个你发现新的线程id和原来这个县城i d呢，它不等在不懂的情况下怎么办呢，进行锁升级，进行所升级。

所升级呢首先会尝试进行自旋锁的升级，什么意思呢，从偏向所升级为自旋锁，自旋锁呢就是说呃如果说这个县城在这已经拿到这把锁了，那么另外一个县城来了之后，那个人转圈循环，well，哎我能不能拿微博锁。

能不能这么说，能不能这么说啊，跟着转圈转十圈，默认是这个知识是转十圈儿，如果拿不着，这时候干嘛升级重量级锁，这哥们儿就去wait了，大家知道重量级所的概念，就是说经过我们的os，然后进入等待队列啊。

进入等待队列里头，进入等待队列之后呢，他就不再占用cpu时间了，其他占用cpu时间占用十圈，十圈完了之后呢，就进入等待队列，什么时候用自旋锁，什么时候又中了，你所呢，你你你你还还记得吗。

如果说上局他没听，你好好考虑一下这个问题，根据自旋锁和重量级锁的特点，什么时候是自选，什么时候重量级锁，自旋锁，咱们说线程数少的时候，线程数偏少的时候，使用自旋还是用重量级比较合适，如果其他条件都一样。

这肯定是自选，没错，这大家都很这很很很很很简单，旋转数少，你选2000呢，消耗的时间也不多，但是如果线程数特别多，你跟这自旋还有意义吗，2000个县城，一个县城跟那厕所上蹲着2000个线程在旁边转圈。

你盯得住吗，这肯定不行，所以一个是这给大家写一下吧，自旋叫做积极的排队啊，他是占用cpu时间的，如果你是为了队列呢，诶他就不是不占你cpu时间，在那等着消不消耗cpu的，所以如果线程数少。

这个呢p应该是偏向于自旋，如果多的话呢，应该是偏向于重量计算，只有一个，那跑就行了，那我再问你呃，大家知道你拿到这把锁之后要执行操作，如果这个操作消耗时间长，来告诉我用自旋还是用重量级锁考虑一下。

系列 3：P25：【多线程与高并发】Volatile保证线程可见性 - 马士兵_马小雨 - BV1zh411H79h

demon就行了，形成有一个方法叫set demon，设成true，继续查thread类里面的一个方法，ok我们呃。

下面我们来看这个volatile的概念，volatile到底是什么意思，呃，volatile呢我我们直接来看程序，来看这个小程序啊，volt也是面试，现在现在像那种大的互联网企业的面试。

那么他有时候也不太问了，因为他认为呢你应该会，所以你会不会呢，他他也不问了，但是呢像那个中小企业呢，他也开始问这方面的问题啊，volt那volt到底是什么意思呢，来我们来看一下这个小程序你就知道了。

看这小程序小程序怎么写了，一个方法，先首先定一个变量布尔类型，ring等于true。

说现在这么在正，是不是正在跑的呀，是的。

然后呢，我们呃写了这么一个，这么一个一个一个方法啊，这方法呢是诶上来之后能输出m start，然后while running，while running的意思是说诶如果说正跑着，我就执行我的操作。

这里模拟的是什么呢，模拟的是一个服务器的服务器的操作，大家知道那个不管是什么样的服务器啊，游戏服务器也好，a t p服务器也好，这些服务器呢，一定是说在没有停止的情况下。

他就在那7x24小时不间断的运行，什么时让他停止，你可以点他一下，可以强制强制的杀死他，我们模拟了这么一个操作。

这个操作呢用一个布尔人型的变量来指示。

你要不要继续运行，如果这个值为true，那么你给我不停的尖端的运行，我什么时候把这只false，你就应该停止了，这里呢是一个非常理想的情况，我什么时候把这个值设成false，你就应该给我停止。

所以这时候你应该输出end，ok好，大家看这里啊，我的方法是怎么测的呢，我的我来对应对它进行测试，有了小t我就不说了，new thread起了一个线程，这线程调用了m方法，好，这个写法同学们没有问题吧。

有问题同学给老师扣一，后面林老师在初级里，我给大家讲了咱们的表达式，这是lamba表达式，lamba表达式相当于是我弄了一个thread，因为有同学有问题啊，这是lab的表达式的写法。

相当于呢呃是这么写的，new了一个thread，new了一个rnable，然后在这random里面呢，大家都知道他要重写run方法是吧，在run方法里边直接调用了m就是这个意思，ok，哦sorry。

这是我的问题啊，有问题扣一，你扣的是二哈哈，sorry，我的问题啊，我那我就不多说了啊，然后呢new了一个线程start，我把这个值设成false，那就是理想情况，你把这个值设成false之后。

理想情况这线程应该就停止了，这线程停止的话，他就应该输出m and我们来运行一下，看看是不是它会停止啊，看一眼，你看m42 的啊，你就数吧，两秒钟，三秒钟，四秒钟，你数多少秒，这哥们儿呢就是不停。

但是神奇的事呢，你只要把罗兰特打开，唉，如果这里呢我们修饰这个变量的时候，加了voltavola运行，m4 好，mn，ok大家能理解的意思是，你加了高了调，这这个他就能准确的停止，如果不接他就停不了。

ok这这就是voluntel它起的作用，那volatile到底起了什么作用呢，好volatile本身的含义呢叫做可变的，易变的，容易产生改变的，那意思就是说这个值是可变的，你得使劲儿的跟踪这个值。

什么时候它发生了变化，你要好好跟踪它好，你认真听，大家看这里外头要聊起来呢，它有两个作用，第一条作用呢叫做保证线程可见性，第二条作用叫做禁止指令重排序，大家给我记住了，由于面试常考。

你也啥话也啥也别废话，给我记住就行了，保证线程可见性，禁止指令重排序，不是实时监控，听我说，看这里保证线程可见性指的什么意思呢，指的是这个意思，我讲过很多次呢，这个现成的概念呢。

jvm我们是讲完这个并发之后才讲这位m，所以如果有同学没有听过的话，那我简单给你解释解释一下，大家知道的，java里面是有堆内存的，多内存呢是所有的线程共享里面的，这个内存，这是呢所有线程共享的内存。

除了所有线程共享内存之外呢，实际上呢每个线程都有自己的专属的区域，都有自己的工作内存，如果说在共享内存里面有一个值的话，比如说像刚才我们的running，它等于true啊，或者等于false啊等等。

当我们县城某一个县城，这是我们的主线程，这是我们的t一线程好，这两个线程都要去访问这个值的时候，他们会把这个值copy一份，copy到工作性，自己写成这个工作空间里头，然后对这个值的任何改变。

首先是在自己的空间里进行改变，比如在这里呢我把它变成了false，但是这个force什么时候写回到中，共享内存里头不好控制，我再说一遍，什么时候写回去不好控制，o，所以你刚才看到他什么时候喜欢看。

这玩意儿，真的不好控制，除此之外呢，还有一个呢，就是这个while使用flag的副本，这块的内容，那他什么时候他已经拿到这个副本了呢，他while不断的循环不断检查。

他什么时候再去检查这里面有没有新纸啊，也不好控制，那好如果你对这个变量不加高了调，就是这种情况，他什么时写回来，我不知道什么时候读这个新的，有没有改改过的，这个值我也不知道，那，对不起啊。

我感觉什么时候读是不知道的，什么时候写的话，应该是你改完之后会马上写回来，改完之后会马上写回来啊，这个sorry，这我要查一下啊，应该是改完之后马上写回来，但是什么时候读是不知道，但是不管怎么样。

在这个县城里头它会产生一个现象，就是在这个县城里头，对这个副本进行了更改，并没有及时地反映到另外一个县城里面，ok并没有及时的反映到另外一个县城里面，这个就叫做线程之间呢不可见，县城之间不可见好。

那既然县城之间不可见的话，你这个县城里头改变另外一个线程，就不知道，我刚才是在may线程里头把它设置成false，那么我在提这个县城里头，他什么时候看见这force，他不知道对这个变量值加了mod之后。

就能够保证一个线程之间的改变，另外一个县城马上就能看到，这是博let条，窝头它本身，如果我们说的再细致一点的话啊，听我说我不知道会不会考到这么细啊，其实现在这种这种，这种变态的考试越来越多了。

请大家去查这个词叫如果没记错的话，m e s i呃，这个是它它的本质上是使用了cpu的，一个叫做缓存一致性协议，cpu的缓存一致性协议，缓存一致性协议啊，我刚刚想起来呃，大家去分享，就是多个cpu之间。

它也需要去进行一些个缓存，由于你不同的线程是运行在不同的cpu上，所以这个cpu里面的这个副本，改了另外一个cpu，不一定马上就能看得到，本质上呢它这个它呃这个概念上是一样的。

但是呢你java里面这种线程之间的可见性，实际上要靠cpu的缓存一致性协议，你才能够保证你你你你你能得到这个值，不然你考虑一下它中间写回，读取的这个过程，如果在读取的这个过程之中，又有人改了又怎么办。

系列 3：P26：【多线程与高并发】Volatile禁止指令重排序 - 马士兵_马小雨 - BV1zh411H79h

那么volt还有一个很重要的，它的作用是什么呢，叫做禁止指令重排序，那么禁止指令重排序又是什么概念呢，听我说我们先说指令重排序是个什么概念，指令重排序呢如果往深里挖的话，也跟cpu有关系。

也是跟现代的cpu是有关系的，那么你去考虑一下啊，每次写都会被线程读到，对每次写都会被线程读到，这个指令能白剧呢，如果往细节上抠，它也是和cpu有关系的，cpu呢原来执行一条指令的时候啊。

他是那个就一步一步的顺序的执行，但是现在的cpu为了提高效率，它会把指令呢并发的来执行，这是第一个指令，指令的执行到一半的时候，那么第二个指令就可能已经开始执行了，第三个指令就可以开始执行了。

这叫做流水线式的执行，都是一线，那好在这种新的架构设计架构的这种这种基础之上呢，如果想充分地利用这一点，那么就要求你的编译器compiler要求你的编译器把你的源码编译完了，这个指令之后呢。

可能进行指令的一个重新排序，重新排顺序，原来是a等于三，b等于四，你代码里是这么写的，但是由于这两个如不如果说他们两个之间啊，后面又把b的值赋给五了啊，那么编译器呢可以对它进行一个一个重新的排序。

有可能把b等于三排，b等于四排前面啊，马上后面b等于五，跟上后面写a等于三，这件事情很正常，这是一个逻辑上的概念，那么细节上呢就是那个汇编语言上的它的一个重排序，这water还有一个作用呢。

就叫做禁止指令的重新排序，那么禁止指令重新排序，他会起什么样的作用呢，我通常给大家举例子举的是这个例子叫做double check lock，这个例子呢也是非常深入的一个内容啊。

好下面我来聊这个指令重排序的问题，指定龙排序其实经常举的就是这个例子，而且这个例子呢原来是一个面试题啊，甚至其实在这个业界里头也曾经出现过很长时间的争论，就是说我到底应不应该加volt。

那么这到底是什么意思呢，我来一步一步讲给大家听，好，我们来聊呢，到底什么是单利，单利的意思呢，就是这个意思，我保证你在jvm的内存里头永远只有某一个类的一个实例，其实这个也很容易理解。

在我们工程之中呢有一些类啊，他真的没有必要用好多个对象，你你比如说什么样的类型权限管理者，权限管理者，那哥们儿就是专门管权限的哪个操作呢，我都进行一个权限，我真的没有必要用好多个，一个就可以嗯。

守大门的对吧，一个就够了，这时候呢叫做单机上的这种单例模式，单列模式呢最简单的写法是这种写法，这种写法呢叫饿汉式，饿汉式的写法是说看这里我有这么一个类，定义了这个类的一个对象。

然后这个对象呢是在这个类内部的同时呢，我把这个类的构造方法设成什么，说成private的意思就是说你别说你没法new我，你不要去虐我，你不要去给我new manager 01，只有我自己能用。

所以我自己就new了一个扔在这儿，既然别人new不了，只有我自己能扭，我扭完了之后扔在这，那么理论上来说，我就只有这一个实例了，那什么怎么样才能访问我这个实力啊，通过一个方法叫get instance。

我就拿到这个实例给它返回，是返回去，所以无论你就要用多少次的get instance，本质上它只有这一个对象好，这是一个小程序，非常的简单，我解释的比较快，没问题，同学给老师扣一啊，有问题直接提。

但是这种写法呢非常的简洁，也很容易理解，而且呢由jvm来保证永远只有这一个实力，为什么这vm能保证这个很简单，一个class no到内存之后，这个static是由jvm来帮我们做初始化的。

由jvm来帮我们做初始观，那那个只有初始化完了之后，你才能使用，这个jvm就直接给你保证，肯定就只有这个实力了，那好，但是有的人呢他会吹毛求疵，他会说我还没开始用这个对象呢。

然后我没没用这个对象调这个方法是吧，你干嘛把它给初始化了，你能不能够说什么时候我开始用的时候，有时候get instance，什么时候调这方法的时候，你再给我做初始化。

所以呢这个是另外一种磁带和上一种一样的鞋，反正不说了啊好，所以呢就会产生这种懒汉式，懒汉式的意思是说我get instance，什么时候我一开始调用这个get instance的时候。

我才可以对它进行初始化，当然你这个初始化的话，你尽量不要初始化两次，你应该只能初始化一次才对，不然就成了俩对象了吗，所以上来之后，你先判断instance等于空的话，我才初始化，那你可以想象一下。

如果有人访问啊，发现他是空吗，我就初始化了，那么后面一个人再来的时候，发现他是空吗，已经不是空了，那就把这个instance给返回回去，不过更加吹毛求疵的事情就来了，说我不单单的要求你。

我用的时候才初始化，我还要求你线程安全，那这里就要就要问大家了，同学们这种写法是会使线程安全的吗，能不能支持线程的安全性，不会这个肯定不会吗，你第一个线程判断他是空，第二个线程同时也判断他是空。

第一个县城溜了一下，第二个线程又扭了一下。

这所以你多个线程开始访问的时候。

那他一定会出问题，这个我不运行了，只要他一定会出问题，你自己去实验，所以他会怎么做呢，我们要加一个synchronize来解决，这是肯定的对吧，我们加把锁嘛。

所以我加这个叫做pis that a synchronized to get incense，这句话一旦加上肯定没问题了，那所以这句话一旦加上肯定就没有问题了。

因为这里面从头到尾的就只有一个线程运行。

那第一个第一个线程发现他那个空给它扭了，第二个线程他无论怎么访问，这个值已经永远都不可能为空了，所以它只能是拿原来第一个线程初始化的这个部分，这是没问题的，但是有的人又开始持白求疵。

说你对simple一下，加在方法上。

你锁定这个代码，这个代码去啊，实在太长了，说不定里边还有其他业务逻辑。

咱们说对于枷锁这件事情来说，叫做代码，能能能锁得少的，就要尽量地锁得少，这个后面我还会提这个问题，所以呢有的人就开始进一步的吹毛求疵，它会变成新的写法，这个写法是什么呢，上来之后您先判断就先别加锁。

你先判断判断它为空。

这叫做锁，细化也是锁的一个优化的一部。

不过很不幸的是，这种写法是不对的，为什么这种写法不对，我们来分析一下，第一个线程判断它为空，然后还没有进行下面的执行的过程，第二个线程也来了，也判断它为空。

那那么第一个线程呢就开始synchronized sirng，上来之后对它进行初始化，初始化完了之后把锁释放了，但是这个时候第二个县城记住，第二个县城也已经执行完这句话了，他还仍然是为空的。

那会儿海第二天能拿拿到这把锁，又初始化了一遍，这种写法是有问题的，所以就会产生了好今天我们要讲的volatile这个问题，这个问题呢是是是是是这样来产生的啊，这样这样来问的，我们把这条给住着。

ok看这里，这叫做双重双重检查锁或者叫双重检查的单位是怎么写的，是这么写的，他说if ec等空，synchronized synchroni，完了之后再判断一遍，这叫做双重检查，它是不是等于空。

如果在这种情况下，刚才说的那种现成的问题就不会再有了，来分析一下，第一个线程来了，说ak你确实是空值，然后呢它进行下面的初始化过程，假设第一个线程把这个instance已经初始化了。

好第二个线程检查第一线程检查一等空的时候，第二个线程也检查它为空，所以第二第二个县城在这句话之后停住了，暂停暂停之后呢，第一个线程已经把它触发完了，释放锁，第二个线程继续往下运行，继续往下运行的时候。

他会尝试拿这把锁，他能拿到这把锁吗，可以第一线程已经释放了，对不对，他释放完之后，拿到这把锁之后，注意它还会进行一次检查，由于第一个线程已经把伊森初始化了，所以他这个线程已经通过了。

所以他不会再重新录一遍，因此这个双重检查这件事儿是能够保证线程安全的，讲到这里，有没有同学有疑问的，没问题，给老师扣一，我马上讲，wallet特，他说那外面的判断没必要啊，外面判断可以省很多很多的。

你不用加锁，外面这个判断不用枷锁，你理解吗，不加锁的话，上来不用加锁，你的效率就会高啊，刚才我们肯定不是哪位同学提的这个问题，我再说一遍，你想你县城，如果你如果你没有外面这个，你上来之后呢。

你直接就开始申请锁，这个效率当然就会低锁竞争吗，但是呢如果你上来之后先检查你是不用申请锁的，你先检查一下，多数的情况下，这个值已经不为空了，肯定有个现成本已经把他初始化了，如果他已经不为空了。

那你就直接拿就行了，跟跟锁就没有任何关系了，呃听懂这意思了吧，所以外面这个还是有必要的，好现在的问题是，你看啊，我用了双重检查之后，我起了100个线程。

这100个线程每一个都调用一个get instance，打印它的hash code，为了县城之间的互相之间会干扰。

所以我还中间让他睡了一个毫秒，跑一下，那么结果你会发现呢。

我告诉你，就这个程序无论你运行多少遍啊，你就算在高并发的情况下运行，拿100台机器同时访问这一台机器上的这个binance，然后那个每个机器上跑跑个1万个线程，使劲跑。

ok使劲儿使劲儿地跑，这个程序最后运行出来的结果一般也是正确的，我，周总说没有，外面一开始方法上不就一样了吗，不是这是两回事，我我经常省略了这其中的一些业务逻辑的处理，在这种地方很可能有一些业务逻辑。

能理解吧，我省略了这些了啊，所以还是不一样的，你家cnet加在方法上的话，没有这个必要吗，嗯，好那我跟我同学会说，那到底要不要加volatile，好，这是一道面试题，这道面试题他会直接这么问。

你听说过单例模式嘛，你肯定得说听说过，你要说没听说过单利，你还聊个肾，那那单立模式里头有一种叫双重检查的，你了不了解好，你这时候要说不了解，咱就咱就挂了，就别聊了，你说了解，ok那了解的话，问你一句。

这个单例要不要加volatile，通过我们的实验来看，你哪怕就是进行压力测试，压个111百万遍，它依然不会出问题，你拿到的依然是同一个对象，但是要不要加高了跳呢，答案呢是要价。

这个以前由于这个实验你很难做出来，就是让他出错的情况，所以以前很多人就不加这波罗跳，但是他也不会出问题，那么加了不加mod条，问题会出在哪呢，就会出现在指令重排序上，好认真听这个模型的特别的复杂。

你认真听我们说，第一个县城，第一个线程需要你了解这句话就是instance等于new manager，那么new manager经过了我们的，j vm虚拟机的编译编啊，所以这个编译器编译完之后呢。

它这个指令呢其实是分成三部，你有一个对象的时候分成三步，这个指令分成三步，第一步呢是给这个对象申请内存，第二步是给这个对象的成员变量初始化，第三步是把这块内存的内容赋值给这个instance。

所以它是123，好我再说一遍，申请内存，申请完内存之后呢，这个值啊是一个默认值，还是给大家在拼t上画一下。

先说new对象的这个过程就能给大家画一下，没有对象的这个过程，运动泵这个过程呢分成三步，第一步呢是申请这块内存，假如它里边有个值的话，呃i这个值它会给这个i它会a这个值吧。

a这个值他会给这个值呢-1个初始值默认值，这个默认值如果它是类型的，它是一个零，k是一个零，然后呢进行第二步，第二步呢是把这里面成员变量这个值呢设成真真正正的那个初始值，比如我们给a a负的初始值是八。

那么再把这个a变成八嗯，然后呢是第三步，第三步是什么呢，是把这个变量啊，这时候它的值已经是八了，是把这个变量呢啊真真正正的赋值给我们那个instance。

大家知道那个instance是在那个呃站内村里是吧，让他呢a指向这个变量的地址，理解这个过程啊，第一步申请内存，第二步改值，第三步呢把这个值赋值给他，但是如果说认真听，如果说这里面有指令重排序。

会发生什么呢，会发生a等于零之后还没有对d0 初始化之后好，我们就已经把这个instant的值赋值给他了，也就是说把第三步和第二步给换了个位置，这个a等于零的时候，我们这个instance里面就有值了。

就已经指向这个这个这块内存了，反正这块内存的地址是不会变的，我刚才讲的这个内容，有没有同学有问题的，你给老师提出来，没问题，给老师扣一，也就是说什么呢，这一个对象在半初始化初始化到一半的时候。

就已经赋值给这个变量了，那如果复制给这个变量之后，你仔细分析一下第一个线程synchronized的，虽然说它加了锁了，synchronized加了锁了，new了一半，a的值变成零，第二个县城来了。

第二县城，你刚才咱们刚才也读点代码了，第二个线程来了之后，他上来先判断这个instance是不是等于空，可是大家注意，由于它已经初始化一半，而且这个instance里面有值了，它已经不再是空值了。

同学们，所以它不再是空值了，就相当于第二个线程已经拿到这个对象可以直接使用，既然拿这个对象可以直接使用了，我很可能会使用里边这个值，这个很正常，但是呢我本来期望这个值应该是个八，可是很不幸的是呢。

这个值是个零，假如在一种超高超高并发的状态，这种情况是有可能产生的，超高超高并发的状态，阿里京东秒杀的时候是有可能产生的，如果你秒杀的时候，这里记得是一个库存的值，原来或者订单的值吧，订单的纸。

原来这个订单下到1万了，1万个订单了，你本来这个值再来一次的时候应该是10001，但是很不幸的是，中间你得到了一个零的状态，结果这个订单值变成一了，好不知道我说清楚这个问题没有。

所以在这种状态上你就会出问题，redemption，你说的这个你的这个疑问呢跟搬初始化没有任何鸟关系，没出隐患，会完全释放锁，这跟释放锁不释放锁没有任何关系，我说的是这个instance的值已经有了。

既然有这个值了，那么你在另外一个县城里头上来先去检查，你会发现这个纸已经有了，你根本就不会进入锁那部分的代码，听懂这意思了吧，那好那么java volatile会怎么样呢。

java volt指令重排序就不允许存在了，对这个对象上的指令重排序不允许存在，所以在这个时候一定是保证你初始化完了之后才会复制给你这个变量，这是莫罗特的含义，两个含义我就讲完了。

看看有没有同学对这块有疑问的，它有两个含义，第一保证线程可见性，底层的实现cpu的缓存一致性协议，第二个含义禁止指令重排序，单立的时候超高级情况你才可能会出现，但是平常我们写成绩是测不出来的。

我是没办法测出来的，如果你要是愿意的话，你可以测一下试试啊，其实是可以测啊，我跟你说，其实是可以测，只不过程序写起来比较麻烦，怎么测呢，大家知道那个a s m呢是直接。

就是a s m是可以直接操纵二进制码的，你只要在二进制码呃，这三条指令之间啊，就是说申请内存初始化赋值这三条指令之间，你你你插入一些代码睡觉就能测出来，到这个太费劲了，我就懒错了，我错嗯好的。

我们看看同学们还有什么有什么问题，当然有的同学可能很难理解，说那个中间居然是三条指令，你你怎么证明是三条指令啊，我给你看看，证明一下好吧，我随便写一个小程序，我比较简单的小程序啊，没有。

rest test，没办法，什么都不行，就直接写new object，选，order的o等于new object，嗯跑一下，跑掉之后，这是我后面讲虚拟机的时候，一个小工具。

这种容易被观察人类方法生成的那些个，二进制码它的扣的它的汇编指令是怎么生成的，你看这个汇编指令，这汇编指令呢它是没有这个对象的时候，有这么一条指令，第一个是new new就是申请内存，先把那钻石拧上。

dedication是复制的，就不说了，你完了之后的第二条指令duation，这个是下面就是指定要用的，你不用去不用去管它，第二这个一条指令内容念完了之后，申请完内存，申请完内存之后。

invoke special，invoke special，你看他掉的是什么呢，要的是object initial方法，调的是object的构造方法，所以他先用用完了之后调构造方法进行初始化。

初始化完了之后，a store才会真真正正的把这个值赋值给这个对象，所以你仔细如果看的话，这还不是一条指令的，这是四条指令。

系列 3：P27：【多线程与高并发】Volatile不能保证原子性 - 马士兵_马小雨 - BV1zh411H79h

ok好了，同学们继续上课啊，看这里，那么word跳呢刚才我们说了，它能够保证线程可见性，也能够保证也能够禁止指令重排序，呃，网上呢它并不能够保证原子性，lol是不能够替代synchronized的。

这个千万要注意，那么什么意思呢，我们来看这个小程序一下，因为比较好玩，model in account等于零，接下来有一个方法，m m呢循环了1万次，让cos加加，那么cot值就会变成9999啊。

好看这里又变成1万啊，6t呃，我做了一个线程，作为一个list list里面全是线程，然后起了十个线程，i等于零，i小于是i9 。

然后thread。at这个县城里面调用了m方法，十个线程，每个线程都m方法共加了10万次对吧，把所有的线程都启动，等所有线程结束，最后输出这个值嗯，同学们考虑一下，由于我加了窝了桥了。

每个线程在访问这个值的事呢，一定是能读到最新的值。

当来能不能告诉我最后这个值是多少，有没有什么问题。

会不会是10万，我要不加volt。

大家想肯定有问题吗，你先说不加volt。

不加菠萝头78000，好家乐珈乐我的特，加了没得挑，你想一下诶，这个时候是我的新的值，一旦改变啊，我的另外一个线程是马上能看见的。

另外线程马上能看见他就应该拿新的值啊，拿新的值来加了对吧，他正常应该是10万的，86000，再跑一遍，65000，再跑进93000，反正总而言之是到不了10万的，原因是什么呢，分析一下，原因其实很简单。

虽然说你看到加加这一块呢，你是保证这个cos值改了之后啊，能够被别的县城和看见，但是看光看点没用嗯，现在这个count值是零，第一个线程确实他是一，他加了一下变成一了，他把这一写回去了。

然后第二个线程也读到这个一了，第三个线程也读到这个一了，所以第二个线程拿到的还是以，第三个线程拿到的还是以能理解吧。

所以第二个性能加完是二，第三个性能加完也是二，两个血回来到最后还是二，不就少加了一次吗，所以归根结底是说，这count count这个值是保证可见性，但是count加加本身，它并不是原子性的一个操作。

那有同学会说老师count加加，这不是一句话吗。

他为什么不是原子性，刚才你看到了，你没有object还是一句话吗，在java的内部会分成好多条指令来执行count。

加加，也是这个我在后面讲虚拟机的时候，才会讲到这个指令的问题啊。

com加加呢本身它会分成好几条指令，至少三条，所以中间被打断的可能性也非常大。

保证线程的可见性，但是它并不能够是替代synchronized，保证不了原子性。

系列 3：P28：【多线程与高并发】synchronized优化 - 马士兵_马小雨 - BV1zh411H79h

我这就是就是线程这块内容就特别好玩，你如果按照逻辑来讲的话呢，它是这么一个顺序，1234567是吧，七七的内容，但是你如果按照优化来讲呢，它这些优化的内容呢，可能分布在不同的里面的。

不同的这个这个步骤之上，所以优化呢我我讲到某一个问题的时候，讲到优化我们就谈一次，讲到优化我们谈一次好吧，这优化呢所优化这个问题呢，其中有一个叫把锁力度加变细啊，还有一个叫做索力度变粗，且说到一回事。

什么意思呢，作为cle单子来说，你这个锁呢要，这种不是很很剧烈的前提之下，你这个锁能力度最好是要稍微小一些，好我这个小程序呢叫fine cofine是细化的，course，是粗糙的，这个意思啊。

fine cause look，什么意思，看这里呃。

如果说我们这个m方法啊，他假如说前面有一个有有一堆业务逻辑。

后面有一堆业务逻辑，这业务逻辑呢我用sleep来模拟了它。

然后中间是你需要解锁的代码，那么这个时候你不应该把这个锁，加在整个方法上，而应该加在哪呢，只加在count加加上，听懂我能理解的意思吧。

这非常简单，这叫做呢锁的细化，那有的时候会不会进行所得粗化呀，有有有有有没有明白，你们能想象一种情形，让你对进行所优化的时候不是细化，而是让它变大变粗，有这种可能性吗，能想象吗，考虑一下。

争议特别频繁的时候没错，假如你这个锁，由于你锁的力度能越编越细啊，特别特别越变越细诶，好别别运气好多好多小的系数啊，就跑跑到你这个上面，这个这个这个这个方法，某或者说某一段业务逻辑好好，特别细碎的锁。

那你还不如干脆给他弄成一张大锁，他的征用反而就没那么频繁了，嗯也会容易容易死锁，是你写程序的问题，你程序写得好也不会发生死锁，我说的优化呢是是说你程序没问题，但是你可以有进一步的更好的写法，这个叫优化。

这个时候呢你可以某些情况是可以进行锁，粗化的，把锁加大，这是没问题的，数据库的一张表，你在某一行所有的行程都加锁，大哥我跟你说，你的效率就会累死，随便的读写某一行上都加锁，那你不如把整张表都加不。

加拉锁得了，嗯这个所粗化所细化的问题呢，是一个概念上的东西，它并没有一定之规，理解这个概念就可以了，好关于这个小问题，我们过了没问题吧，有问题给老师扣一，sorry，有问题了，扣二没问题。

扣一我们以后没问题，永远扣一啊，那好下面又是一个小概念，很简单很直接就能理解，所以我速度会比较快，你认真听，锁定某个对象o如果o的属性发生改变，不影响所的使用，但是o变成一个对象，一定会产生产生问题。

什么意思，object o等于new object，如果我们把它当做synchronized o，但是你在某一种特定的不小心的条件下，你把o变成了别的对象了，大哥，这个时候现成的并发就会出问题。

这事太简单了，因为我们刚才说过，这个对锁呢是在对象上头上的两位，来代表的，你这个县城本来大家伙都去访问这两位了，结果突然之间，您老人家把这把锁根变成了一个别的对象，去访问别对象那两位了。

这俩之间还有活人，基本在现场没有任何鸟关系，因此你如果用对象做锁的时候怎么写，同学们来告诉我怎么写，不让他发生改变，所以你会看到别人的那些大牛的人，写的程序，它非常非常的规范和细化。

这个final他是少不了的啊，很简单啊，没问题吧，有问题没问题，扣一啊，继续string这个类型嗯，我我已经讲过了。

系列 3：P29：【多线程与高并发】day1课程简单回顾 - 马士兵_马小雨 - BV1zh411H79h

为止呢syra已经和volt。

那我就讲完了好吧，嗯稍微简单的再回顾一下啊，synchronize的线程同步走的是对象，不是代码，在呃所方法的时候说的是this锁，steady方法是锁的是class锁定方法，非锁定方法是对同时执行的。

这个也需要你了解那个大d c l double，check lock的时候的一个很重要的一点，所升级等偏向左到自旋锁到重量级，所我们讲volt它是能保证现实间的可见性，同时禁止指令重排序，线程可见性。

在cpu的级别呢，是用缓存一致性协议来保证的呃，自行车指令重排序呢，cpu的指令重排序是你是你是你cpu不级别的，指令重排序是你禁止不了的，你那个那是人家的内部的运行的过程，提高效率的呃。

但是在虚拟机级别加高了条之后呢，那么这个指令重排序语言上，语言级别来说就可以禁止，如果严格来讲，还还要去深究它的更细的内部的话呢，它是加了读屏障和写屏障，这个是cpu的一个原语叫lofence。

这是cpu的原语，cpu级别只是支持的，还有一个呢叫store fans，多变量写凭证，一个就是说前面一条指令，后面一条指令，那么lot of fans呢是你前面那个毒的指令。

必须得给我执行完才能执行后面的指令，这两条这两条指令之间是不能重排序的，写正好是写写方面的啊，读写屏障的问题啊，这个我不知道什么时候，整个的业界要求我们会深入到这一点，这也也也很简单不难啊。

load sense原理，由这两个来一块实现了stance原因之类，还有一个是什么来着，就是说也是一个fans，他是load和store两个都都包括的，是要lofans吗，带你们去上网查一下。

就是加读写，读写读写屏障一块儿的一条指令嗯，两个都有了。

系列 3：P3：【多线程】CAS在新的JUC包里有哪些运用？ - 马士兵_马小雨 - BV1zh411H79h

普通了，那么cs在新的j u c的包里头有哪些运用呢。

大家看这里，看代码，呃我觉得大多数人呢应该是了解过这个类的，这类叫什么，这类的叫atomic integer，atomic energy，它用来干什么的呢。

用来对一个int类型的这样的一个数字进行原子性的访问，比如说对这个数字进行访问的时候，是不需要加锁的，什么意思呢，比如说最简单的，我刚才说过这个问题啊，如果我们有一个值，这个只是一个普通的值，是一个零。

那么好多线程对这个零对这个数字进行加加的时候加加操作，那么这时候必须得加锁，如果我们用atomic engineer就不需要加速，怎么做呢，大家看这里。

etopic engineer等于new一个atomic energy，初始值是零，里边装了一个int类型，我如果多线程对他进行访问的时候，比如说我在这里有100个线程。

这100个线程对它进行访问的时候，每一个m的值，每一个都把这个m的值拿出来，给它增加了1万次，好增加1万次，平时我们怎么写啊，平时我们不这么写m加加吗，如果他是一个普通的int类型的值。

我们是不是写m加加，但是如果你那么写的话，你就需要加锁好这块能跟上同学给老师扣一，没问题吧，嗯如果平时用的时候，我们需要对它进行加锁，但是如果我们用atomic integer这样的一种方式的时候。

我们就不需要对它进行加速，你看我们我没有任何地方用了synchronized，也没有任何地方用log什么的，我只是调了一个方法，这个方法叫m。increment and get，ok那么你拿大腿想一下。

就这个方法一定是保证了它的原子形不用解锁，也能保证它的原子访问，那他是怎么做到的呢，就是用cs的方式，我们来跟进去看一眼，点increment and get increment。

增加get拿拿又拿新值，这个意思，increment增加，我们并没有拿新职过来用，所以我们要看它增加部分就可以点increment get点进去，点进去之后你会发现呢他进行了进一步的调用。

它调用的是unsafe这个类的，get and at in的方法好，我们再点进去跟进去，在get and an end里面，然后你会发现一操作这个操作是什么呢，do while一直不停的循环做cs吗。

然后里边调的是哪个方法呢，这个方法叫compare and swap in compare and swap in，compare and swap，大家看到了吗，cs出来了好，我们再跟进去。

compare and swap in，当我们跟到这里的时候，你会发现这哥们儿变成native了，好，那native是什么概念，native就是hobc和c加加代码实现的，你java代码到此为止。

那这时候我如果还想看它底层到底是咋实现的，怎么办呢，不好意思，你得去看c和c加加代码，那我就进去看看，没打开，我打开我的c和c加加代码。

呃这块呢如果大家会想编译代码的话，得需要在linux上啊，我懒得在linux上给你演示，我就直接打开对应的代码就好了好吧，那么刚才你看到了啊，呃其实，你我们呃在那个java里面调的是一个unsafe类。

那么这个类呢实际上对应的c加加代码呢是hot pot源码里面的，unsafe。cp，好那么我们刚才调用的是大家还记得吗，叫compare and swap int，有没有印象，那么在哪里实践呢。

实际上你在这儿啊，unsafe compare and swap int在这里实现，如果你要跟这个c代码跟进去的话。

你会发现它实际上调用的是atomic这类的compare and exchange方法，当然atomic这个类的compare and exchange方法啊。

就是atomic的cp里面的atomic compare and exchange，如果我们再跟进去的话，你会发现它掉的是本质上是另外一个compare exchange啊。

我就不给你演示中间一路跟踪的过程了，总而言之你跟到最后的话一定是跟到了这个文件里面，这个文件呢叫做嗯atomic linux x86 ，in linder，hp etom啊，原子类到底是怎么实现的是吧。

呃linux版本上的实现x86 这种架构的实现啊，in lit b b，那好在这个里面你会跟到the dominate啊，compare and exchange，跟到这个方法上，好。

这个方法上就等于说是不是是不是有点晕啊，晕了吗，晕了没关系啊晕了，我帮你做笔记了，你们知道吗，就这么贴心，unsafe啊，你要跟跟跟跟过来的话，实际上是调到了unsafe。c p。

然后这个点p p c p p，你跟过来的话，最后调用到了eatomic linux x86 的in line，好大家看这里，这里面调用了compare and exchange，调到了这个方法。

那在这个方法里面到底怎么实现，你会发现呢，他原来是用汇编实现的，是用汇编语言，汇编语言a s m a zler啊，这种语言来实现，那么在这个汇编语言里面呢，调用的是lock if mp，好。

这句话又是什么意思，反正最终呢就到了这里啊，我们说最终的视线好吧，总而言之，一顿两眼花缭乱的操作，穿出了我们八卦阵，走向了我们胜利的红场，在哪呢，就在这句话上，好这句话有一个红操作。

这个红的我就不一一的给你看，定义了，这个红其实非常简单，你看他的写法就就就很明白，lock if mp，那一定是有什么地方我要加lock，什么地方加呀，lock if mp吗，mp是什么意思。

mp的意思叫multi processor，呃多个处理器在多个处理器的情况下，我要加lo，在没有多个处理器的情况下呢，我就不用加lock，是这么回事，所以所谓的加lock到底是什么概念呢。

指的就是在这条指令的前面加上这条指令叫lock指令。

ok也就是到现在为止啊，不管你是听的能听得懂还是没跟得上。

都没有关系，我跟你说最后的结论，总而言之，cas的操作在底层到底是怎么实现的，好是这么来实现的，是这条指令来实现lock compare exchange，那现在这个事儿就就就就就好玩了啊。

这个到底是个什么东东呢，我知道有很多同学应该是没有接触过汇编的，这个很正常，有好多jav成员是培训过来，从别的专业转过来，没有接触过汇编，这个很正常，没有关系，汇编是直接对cpu进行操作的，机器语言。

最底层的语言啊，没有比他更底层了，那么也就是说实际上啊compared to change在底层是有支持的，在cpu的级别上，cpu源于这个级别上是有支持的，同学们，你们想过没有。

我们刚才所说的这个cs实际上有一个巨大的bug，没有讲，我把这个零拿出来之后，我把它改成一把这个一往回写的过程之中，需要进行比较，比较完了之后再把这个值新值写回去，那大家你们想过没有。

如果我这个值在比较往回写这个过程之中，注意他是两条啊，比较完了之后往回写这个过程中被其他的线程打断了，想过没有，是不会有这个问题来，能get到的，同学给老师扣个一，所以如果说啊同学们你们想一下啊。

如果说我们想真的完成cs操作，你最后这条比较和交换这条指令必须得是原子的，如果你不是原子的，那玩蛋还是依然能把别人打断，你还是不能保证数据一致性，那最后它是原子的吗，注意这条指令不是原子的。

这条指令中间也是有可能被其他cpu打断的，那为了保证整体的cs操作原子性，它在前面加了一条lock指令，这lock指令什么概念，lock指令的概念就是有任何一个cpu在访问这块内存的时候。

我在对它进行什么操作的时候呢，进行compare and exchange操作，也就是cs操作，在进行cs操作的过程之中，把总线上锁，或者把某个信号上锁，不许打断，我再说一遍，在最终的底层。

在cpu的级别，lock compare and exchange，这句话的指令的意思是在执行这条指令的过程之中，我这里对一个内存进行ci操作的这个过程之中上锁，不允许其他cpu刷完就看这个内存。

不允许其他co打断我，好当然硬件层面logo呢是锁定一个北条信号，这个就这个这个就算了吧，没必要了解到这个程度，雷克雅维克不是lock if吗，单cpu就不用加lo。

单cpu这两个指令之间本身就是序列化的，所以不用加lock，多cpu必须要加lock lock if的意思是如果是多cpu加lock，所以c a s的底层操作是用这条指令来实现的，情态的背过。

面试会问好吧，年薪50万以上的面试会问，好了，我刚刚讲完的这一小段来能够跟得上的get到同学，老师扣个一cs，我讲完了，今天我讲的synchronized cs呢只是个开胃菜。

我上周面30万的也问了谁这么有病，是不是听完老师课的天使官太过分了啊，这不还是枷锁了吗，那你觉得呢这个锁比我们在，比我们在操作系统级别，比我们在这vm级别的锁，是不是效率高多了呀，这不是还是加速了吗。

你说的很对，最终如果不加一点锁，你怎么把那种多线程的访问，对共享资源的访问变成序列化的。

系列 3：P30：【多线程与高并发】CAS(1) - 马士兵_马小雨 - BV1zh411H79h

嗯好了，我们继续，下面我们来聊这个cs，这也是我考面面试的重灾区，好吧，我们聊cs呢，这叫这号称是叫无所有化，自旋其实就是自旋啊，无所优化，它叫什么名字，无所谓理解他是干什么的，什么意思就行。

概念这个东西呢是人为了描述问题，解决问题而定义出来的，所以怎么定义嗯，这事不是很重要，重点在解决问题上哦，哦看这里，我们通过atomically atomic原子的，由于某一些特别常见的操作呀。

你老是来回的枷锁，总之需要加速，加速情况下特别多，所以干脆呢，java呢就提供了一些个，这些常见的操作的这么一个类，这个类的内部就自动带了锁，当然这个锁的实现并不是，synchronize的重量级锁。

而是cs，我无所号称无所c a s的操作来实现的好，什么意思呢，这些个类是什么类呢，我们举个举几个简单的例子啊，这个，被抄几个开头的呃，也是在这个这个这uc的这个包里啊。

concurrent atomic这个包，凡是atomic开头的，都是用cas这种操作来保证线程安全的，这样一些个类，最常见的这类呢就是他也成为一个image，it trainteger的意思。

里边包了一个int类型，这个int类型的自增count加加，我们刚才分析过它不是线程安全的，但是呢这个是线程安全的，还有呢拿职等等是线程安全的，由于我们在实际开发的工作之中呢，经常性的会有那种需求。

就是一个值所有的建筑共同访问他，他在往上递增，这种需求特别多，所以专门gdp里面提供了这样的一些个类，a terenger，我们先来看这个a term energy，它到底是怎么使用的，好吧。

看这里我们上一个小小程序啊，上一个小程序是count加加，我们加synchronized加锁，这次呢我们可以不用加锁，用什么来做呢，用it atomic energy原子的integer的操作。

itominteger count等于另一个atomic energy，初始值呢是设为零，m方法原来是要加synchrono，现在不需要加了，i等于零，a小于10000a加加count点。

increase increment and get increment and get increment自增，and get get的意思是拿到这个值，自增了一下，并且拿到这个值。

当然这个返回之后没有用，所以我没有定义这个返回值在哪里，ok这个叫做zincrement g，相当于ctrl加加，不过呢这个ctrl加加是线程安全的，不像原来那个看了佳佳是线程不安全的。

所以这次你起多少个县城来跑的时候，最后的职能已经是10万，送你10万啊，不考了，好多次都是好，关于atterm engineer的用法，有没有同学有疑问的，atomic energy就这么用，很简单。

没问题，我们学校给老师扣一啊，用会呢就这么用，来我们来分析分析，它内部的一个实验是什么实现啊，来聊原理，主要聊聊原理啊，有这个用法上的东西啊，你你你看看a i z都都能用是吧。

我们主要来聊原理好，这个原理是什么原理呢。

这个原理呢它叫做cs操作，看这里啊，it turan energy点进去，那么你也increment and get so incream，and get啊，调用了get and at it。

当然这个的话呢嗯也是一个compare and set，操作操作，内部掉掉掉就会跑到哪个哪个类去啊，当前的这个类呢叫unsafe这个类啊，unsafe不安全的，也就是说economic energy。

它内部是调用了unsafe，这个类里面的方法，好这个类里面的方法呢，你会看到这个方法叫compare and set，compare and set就是cs啊。

compare and set persuade，compare and set，来说一下字面的意思，compare比较并且设定比较，并且设定的意思是什么呢，我呢原来想改变某一个值，原来是零。

我想把它变成一，但是我其中呢我想做到线程安全，我怎么做呢，我只能加锁，加synchized，不然先生就不安全好，现在呢我可以用另外一个操作来替代，这把锁，用什么操作，能用c a s操作cs操作。

你可以想象它就是一个方法，这个方法有三个参数，第一个参数是要改的那个值，这就是那只原来是零，expected，希望当前的这个值会是几，要设定的新值好，当前这个线程想改这个值的时候。

我希望你这个值啊就是零，你不能是个一，你是个一的话，就说明我这只不对，然后想把你变成一，这句话说的是什么意思呢，你看看啊，原来这个值变成三了吧，比如我这现在想改一个值的时候。

我一定期望你这个值现在是三啊，你是三我才改，假如你在这个我改的这个过程中，你变成四了一个，那你这个跟我这个期望值就对不上了，你给我的期望值对不上了，说明什么，说明有另外一个线程改了这个值了。

那我这个cs哎干脆就重新再试一下，再试的时候，我希望你这个值是四，为什么，因为你现在值不就是四吗，我希望你这个人是四，假如我在改的这个过程之中呢，没有其他的线程改了个值，那么它就是4号。

这个时候我给你设成新纸变成五，所以这是cs操作，在本质上就是这么一个意思，如果说你这个值是我期望的那个值，这个v的这个值是我期望那个值，那我就不给你设成新值，不是我期望的值，说明在我这个执行的过程之中。

有别的县城访问了，并且更改了这个值了，好这个时候我就可以干嘛呢，哎再试一遍，或者干脆就失败了，我就不试了，这个是cs操作，那有同学可能马上就会说啊，我一我想你们一定能想到说，你当你判断这个值是不是。

你希望那个值的过程之中，在这个时候有另外一个线程给改了，怎么办，你这个线程来了，判断了一下，是不是我期望那只你发现我是期望的，是我期望那只还没有进行设新值，设定的时候，另外一个线程把这个值设成别的职了。

这怎么办，我不，好听，我说cs是cpu的原与支持，也就是说cs的操作是cpu指令级别上的支持，中间不能被打断，啊各位同学问的是那个期望值是什么意思，就是你当前这个县城，认为你原来应该有的那个值。

期望的值怎么来呃，举个最简单的例子，你比如说我某一个某一个什么吧，补一个链表吧，好链表的长度现在是三，我想往链表后面插一个新的新的节点，假如说这个是多线程，往往往后插我我我是不是往后插的时候。

我期望这个这个节点，或者说整个的这个size是三，如果是三，确实是三的时候才往后插，对不对吗，如果不是三的话，我一定不会不会往后插，所以期望的这个值呢，就是根据你实际当中的你的业务逻辑。

他的一个嗯你的你的有逻辑上的，这我来解释一下啊，这个直来啊，increment and get，我们拿a tomic integer来举例子吧，这个atomic engineer。

希望的这个值你是get一下，你首先呢拿int int int的类型来说，比如说它原来是一，你首先get一下，你拿你已经拿到这个值了，get一下，拿到这个值之后是一，然后是一，之后呢，你你怕的是什么呢。

怕的是在后面进行ca操作的时候，这个一会被别的给变成，所以在你cs时候，你期望这个值依然是一，我这么说，你是不是能理解了，期望值是对，是给定的，嗯我再说一遍啊，呃理解了是吧，好理解了。

我就我就我就我就不再多说了啊，就你原来这个值你拿到一个值了，这个值是几呢，这个值是一，你本来本来想把它变成二，但是在你变成二的过程之中好，你就把这个一这个期望值设给他，如果他目前还是以还是一。

就是说明什么，说明没有别的线程来吗，那这个时候呢你就把它变成二。

系列 3：P31：【多线程与高并发】CAS(2) - 马士兵_马小雨 - BV1zh411H79h

那么说明没有别的线程来吗，那这个时候呢就把它变成二，但这里面呢我们还要稍微说一下什么呢，我们还需要说一下的，就是这个a aba问题，这a b a问你呢，嗯一般面试呢也就简单问一下，就是问你了。

不了解这个a aba问题该怎么解决，这a b的问题是什么意思呢，这个问题a b a问题是这样的啊，假如说你有一个值是吧，我拿到一个值，这里面值是一，我拿到一之后想把它变成二，然后我拿到这个一之后。

我用cs操作把这个一期望值是一吗，变成准备变成二，cs操作，把这个对象object object这个对象好从一变成二，或者它里面的一个属性，从一变成2k在做这个操作的时候，注意在这个过程之中。

由于没有人，我们没有一个线程改过，我肯定是可以变成的，但是如果有一个线程做了什么更改呢，这个县城里先把这个一变成了二，后来又把这个二又又变回一，不然我说清楚没有，就这个县城里啊，先把这个一变成了二。

又把这个二变变回成一，同学们，你们想一下，这就会中间，实际上它经过了这个值得一个更改的过程，它会变成了1142，又变化了一个一，但是不影响我这个cs下面这个层，所以这个这个就是a b a的问题。

就是原来这个a变成了b，后来不好意思，他又变回a了，所以如果你使用cs操作的话，它实际上会有这个问题，就是aba问题，那么这个问题怎么解决，如果你非常关心这个问题，像这种int类型的无所谓嘛。

反正你期望值最后变成二就完了，这种的没有关系的，你就不用去管这个问题，如果你确实想管这个问题该怎么办，需要加版本号，就这个一啊，目前我做任何一个值的修改，修改完了之后，版本号加一，你后面在检查的时候。

简直连版本号一块检查，加version aba问题，第一个a版本是一点，那就叫一吧，第二个就是b就变成二点了，第三个a就变成三点了，所以你你后面做cs的时候，你需要再加一个版本号的比较就行了。

在cs的时候，我除了原来这个值之外呢，我还要检查这个version跟原来那个version相不相同，atomic类里面有，atomic类里面有带版本号的类啊，这个问的实在是少。

就没有专门给大家讲这个问题，atomic这个类里面是有版本号的，这个类的，大家搜一下他，atomic stamp rappers，感兴趣，你去自己找一下，目前还没有人嗯，起码面试的时候遇到过好吧。

用这个来解决啊，叫atomic stamped reference。

解决aba问题，step的意思就是加一个托嘛，加一时间戳类比有什么问题啊，我明白你意思了，就算产生了a b a会不会有什么问题，是这意思吧，在int类型上不会有问题，如果是个in的类型。

就是个一或者long类型，基础数据类型没问题，如果这里是一个object，指向的是个演员，是一个对象，那这个对象呢改完了之后，后来又指回到原来了，然后呃，它的中间这个对象，又会对这个对象有有有有链接。

这个解释一下啊，认真听咱们说a b a这个问题呢，如果是这个数据类型一变成了二维，变回了一只，剩要经过多少次改变，最后的结果无所谓，但是啊如果有这么一种情况，这是那个object，它指向一个对象。

指向了这个对象，这个蓝这个这个这个这个这个黄色的对象，然后这个黄色对象呢，又指向了这个蓝色的对象，好在中间的这个过程呢，有另外一个线程来了，他把这个o呢指向这个蓝色对象之后呢，又把里边的值做了一些改变。

然后这个哦又指回来到这个黄色对象，然后呢再回到下面这个问题的时候，你会发现这个黄色对象指向的别的对象，发生了改变，所以这个黄色的呢，你后面的逻辑还更会不会跟原来一样，这句话这个问题就不好说了啊。

不知道说清楚没有，如果是引用就会有问题，如果不是引用啊，一般问题不大啊啊，有点绕，哈哈哈，哎我说的我确实刚才讲的，是不是有点儿有点儿稍微绕了啊，来我再我再说一遍啊，这是那个原来的那个引用是吧。

然后他指向某个对象，指向这个对象，好指向这个对象之后呢，注意啊，我们本来是要把这个引用呢通过cs操作呀，变成别的一个引用，但是呢在中间呢来了个现场，这个线能做了一件什么事儿呢，这个线程呢是把这个o。

嗯做了一些个各种各样的操作，然后这里面的其中的某个其中的某一个，其中的某一个某一个引用，指向了别的地儿的值给改了，总而言之就是这这里边值也改了吧，然后改完之后呢，实际上这个这个这个这个o呢。

又又还是还是原来这个对象嗯，所以呢你在执行的这个过程之中，有可能你指向这个对象，里边发生了一些逻辑改变，那么在这种情况下是有可能会产生问题的，啊，呃我可能讲那段确实有点复杂了，这是我的问题，sorry。

呃呃，说最简单的就是里边这些在，在你在你在你一个引用，在被别的线程有可能改变里边的值，改完了之后呢，从，内存地址上，你这个o呢确实还是原来那个纸，但是呢其实从逻辑上，这个o指向这个对象。

已经是变成了另外一个对象了，已经是变成另外一个对象了，所以当你对这个对象进行一些判断，然后再做出其他改编的时候，就有可能会产生那种业务逻辑上的问题，唉当时这个例子举得比我好啊，哈哈哈哈。

毛石你这个例子举的举的比我好啊，你跟你的前女友复合之后是吧，他已经他实际上已经经历了别的n个男人，老师啊，你这个适合做老师很好，我这讲半天还不如你一句话，有生活啊，你这跟前女友复合几次了，哈哈，很好啊。

这个模式嗯思路也比较敏捷，来接下来，aba问题，好a b问题呢，如果基础类型无所谓好吧，那么如果是引用类型，你的女朋友跟你复合，有点尖锐了，别的女人o，就你你他不再是你原来那个女朋友了啊。

k老师看来这个生活经历经验很丰富啊，好这就是a b a问题，大概能理解了吧，ok呃所以啊这里面的这些个操作呢，由于原来需要加锁，现在不需要加锁了对吧，现在就不在学校加锁了，你从零往上加一。

你只要判断他原来还是不是零就行了，那如果是零的话。

你就直接往上加，这不需要加锁了，那么他是怎么做到的呢，其实它内部能使用的是这个unsafe，这个类，unsafe这个类呃，关于这个类呢大家要了解就行了，这个类里面的方法非常非常的多。

其他的你不能直接使用，这个类，不能直接使用的原因，还和class loader是有关系的，这个特别好玩，好我们简单了解这个类啊，就是所有的atomic操作肋骨下面都是compared。

compare and set这样的操作，那么compare and set是在哪个里面完成的，调用的好，就是unsafe这个类，compare and set，这里好像进行了修改，新的玩玩，fall。

match case words哦，我的天他又进行了修改了，现在叫wk compare set，可能是用了那个那个弱指针了啊，这个新版本的我还没有读过，这11点那个版本的，这不去管他了吧。

compare and set。

比较和设置，那么底层的那个是什么呢，是通过这波的原理知识来实现的，但是unsafe，这个类是比较好玩的一个类啊，这个类呢如果你能了解的话，那么面试的时候问到你肯定会加分，这是肯定的。

compare and set match case words，确实没有啊，他现在都改成weak comparisons and set，应该是这个很牛，看这里啊，这个这个unsafe这个类呢。

呃正好给我们讲的单例又可以配上，但你看啊这个unsafe这个类，首先它的构造方法看到了吗，各位朋友是什么，private unsafe，你能虐他吗，用不了，对不对，呃根本用不了他，那么拗不了他怎么办。

你想用这个on c时候怎么用啊，那你可以看到它里面有一个单例，静态的new unsafe，这不就是我们那个单例模式吗，private static final unsafe。

the unsafe等于new unsafe，所以什么时候你能用这个unsafe的话，只能调用它这个静态方法叫get on safe，它会返回一个int类型，它会返回这个unsafe类型的值。

这就是典型的单位能看懂我的意思吧，是挺实点，奇怪啊，这个新的版本和原来的确实不太一样了，啊我这ppt还是原来的版本的，这个我要更新了，sorry，这是1。7版本的时候啊，他这个是可以直接操作内存。

直接生成类的实力，直接操纵类的实力和变量，那么现在呢应该是，他不再用这个compared set了，跟我们实际compared set相关的是这些操作。

compare and and and and and set，compare and set，当然这个新版本叫w，通过点名字，你应该知道他应该是用的那个弱指针软弱，软弱虚用的是弱指针。

如果指针呢因这个它的好处啊，应该是在于垃圾回收的时候，回收的效率比较高，weak compare and set好了，你的那个版本没准是那什么的，put in改动很大啊，可对jdk 8里面还是对。

你查一下你们自己的jdk的版本，我这版本有点新啊，我的版本是11点呃，你的那个版本如果是1。8的话，那应该还是compare and swap，这个改动确实有点大，嗯这不去不去，我们不去详细探讨他了啊。

而且11点里头呢比较好玩的是，这个get on safe是你，你实际上是可以直接用的，不像原来你必须得能够通过反射，才能拿来用，1。8的版本，你们自己打开看这个刚才get on safe，你是拿不着的。

只能谁来用，只能那个jdk的作者，他们最根上的球类才能使用，而11点你是可以直接用的，unsafe你可以直接用，比较好玩儿，unsafe是干嘛的呢，其实其实unsafe呢。

就是直接操纵java虚拟机里面的那些内存，比如说你要分配一个新的对象，你是直接把这个对象的内存，看着看着扔在这儿了，而不是new啊，这跟new没有任何关系，那么如果你想操作某个对象里面的某个值。

某个对象里面某个属性，如果这个这个内存的开头是零的话，那么通过一个偏移量16，就直接咔嚓就定位到这个内存o，所以on on save，这个类，就是直接让我们具备了c加加写的程序的，这样的一种能力。

所有的atomic开头的类，内部都是通过unsafe类里面的，compare and swap，compare and set这一类的原子性操作，cs操作来实现的，当你读一下呢，它的写法呢也不难啊。

都非常简单的一个一个写法啊，有些没有了，居然啊嗯你看啊，你看这个比较好玩，你看这个就知道了，这个方法是什么字，allocate memory，呃，来同学们给我翻译一下英文，alex memory。

分配内存是吧，相当于c语言里面的什么c，这这这这不能在这敲c，c语言里面有一个方法叫什么，memory allocation是吧，对啊，这个词memory allocation。

我已经敲在咱们的讨论区了，这是alea allocate memory，相当于直接你在里面分配关内存，这块内存多长，所以你用unsafe是可以直接实现，原来c和c加加实现的这种能力，然后拿到它之后呢。

返回一个指针，这个指针呢一个long类型的指针，当然如果你有alex memory。

你你想想看你一定有什么呀，free嘛，free memory，如果你学过c和c加加，不知道有多少同学学过，所以unsafe这个类基本上就等同于c，c加加的指针，如果是c语言分配内存，用的是。

memory allocation，释放内存呢，free来有同学告诉我，c加加是什么样的，分配内存用什么。

系列 3：P32：【多线程与高并发】第二天课后总结 - 马士兵_马小雨 - BV1zh411H79h

回顾一下我们今天的内容啊，嗯，我们讲了synchronize结束了是吧，我们讲了volte，volt 22项线程可见性质量重排序禁止，然后呢我们讲了cs的原理，cs呢叫做无所优化或者叫乐观。

所有人把它叫乐观锁，其实是一样的，也是有人叫吴，所有人叫乐观锁，你说这事怎么聊，没法聊，所以知道是什么意思就行了，compare and set compare and swap，交换可能是一回事啊。

ok交换就是把原来这个值交换成新的值，c他有一个期望值，如果你跟期望值一样，我就给你换过来，我非常乐观的认为，在这个阶段是没有别的线程进来过的，好cs呢会产生a b a问题。

解决办法是加version或者加标签，张语言里面提供了一个叫做atomic，stamp reference，但是很少用，极少用，连问都很少问到，所以这个东西呢你认真的了解就行啊，知道就行了。

实在现在这个时间没有必要去实地了解他，那么所有的ci操作在java的内部的支持，用的是哪个类呢，on safe这个类，on safe这个类呢它变动比较大，这地方有点斑，一直到现在。

我我我为大家读的是11点的啊，他跟原来是不一样的，你们手头1。8，你们先看一看，然后再下11点。

系列 3：P33：【多线程与高并发】第三天课前复习 - 马士兵_马小雨 - BV1zh411H79h

我们稍微回顾一下，上节课呢我们讲到了这个atomic engineer。

the tra叫原子性的，原子性的，它里边做的任何的操作呢，都是用c a s来实现对吧，这个原来讲过这个问题了，就是讲过cs来实现cs呢其实就是三个值，哎你要改的那个值，然后你期望这个值。

以及你要改成的那个值啊，如果说我们稍微复习一下，因为我发现有小伙伴原来可能是没听过。

这个c这个概念呢，还是非常的重要，而且考的特别多，所以稍微给大家把这个cs复习一下啊，我目前的这个大小是多少啊，有屏幕分辨率比较高啊，就是先先这个大小吧，呃，我们稍微复习一下cs这个概念啊。

cs其实还是不难，就是乐观锁的概念，compare and set compare and swam，就是一个乐观锁的概念，它一般来说呢，一个cs的操作呢会有这么几个值，其实严格来讲呢就两个指。

因为cs的操作基本上就两个值，当然有的会写三个值啊，你要改的那个对象，这个就无所谓了，你肯定要改的有一个expected，就是你希望那个纸，还有呢你要改成的那个纸。

update update a bit value和expected value，expected叫期望值，小时全成中文，大家看得清楚，阿贝呢叫更新更新值或者叫新纸呃，你你可以这个叫旧址老职，旧的纸。

新的职也可以，我们用一个，m加加吧，那个m加加来举例子，比如说呢最开始的是m等于零，然后m加加呃，需要注意的是呢，如果说我们不同步的话，那么这个呢会产生多线程访问的时候呢，会产生问题，这一点呢比较简单。

不多说，那么我们可以采用无锁的操作，无锁的就是s操作，cs操作呢想把零给加个一的话，可以这样来多久，cs我希望你原来的值是零，然后呢我给它改成一，然后它里边的一个操作是怎么操作的呢，就是说。

类似于这样的一个操作，我这是伪代码啊，一个不停的死循环，就说如果，当前m值等于零等于你期望这个值，如果当前m里等于期望那个值，说明什么呢，说明很简单，说明没有人进来改过吗，没有线程进来改过这个值。

对不对，既然没有建成改革，那我现在呢就可以把这个值设成一，m等于一好，这是cs的概念，原来我讲cs的时候还说过，说这个cs呢，假如说你在m等零和判断m等于零，会把m变成e之间，如果有线程进来。

也会把m给改掉，可是呢现在的cpu呢是在原理层面上，是支持这种ci操作的，其实cpu呢就是这块内存的内容，它可以呢，前前后加个屏障，不让别人懂，唉直接原子性的更改这块内存的内容好吧。

所以这里呢就是cs的概念，其实就是乐观锁，跟乐观锁的概念是一模一样的，我就乐观的期望啊，就是在我改的这个过程之中，没有线程改过，所以我就直接改，那有人改过怎么办呢，我就跟着循环等着，等什么时候。

你比如说他下个值已经变成一了，那我这个cs就变成一二，如果需要就变成二了，就变成二三等等，这是cs一个操作叫无锁的操作，所谓的无所呢其实就是一个乐观锁啊，好那关于cs，尤其是咱们第一次过来听听课的同学。

有没有什么问题啊，有问题你提没有问题，你给老师扣一好吧，没问题，我就继续了啊，这个是期望值，怎么决定这个期望值呢，就是你读一下，上面先读一下rem，我读一下，这值这样来写，is expected。

等于m这个值，你从你m这个值里面读出了一个值，然后你在cs更改的时候呢，你只要把这个c a s这个期望值，扔到这个值，如果在你读出来和你的在你读出来啊，和这个呃你你cs中间如果有人改过的话。

那你就重新读，你在cs里面重新读。

系列 3：P34：【多线程与高并发】LongAdder - 马士兵_马小雨 - BV1zh411H79h

必须也得加锁对吧，你不加锁，你是完成不了这种原则性操作的，所以说你还是需要加水啊，我们讲的是呢，他讲的是他背后，你执行这条语句的背后的原理吗，这就是c a s的原理，它不需要加锁。

但其实呢它是需要靠cpu的原理来实现，好吧嗯a q s我们还没讲到啊，我们今天呢开始讲呃，继续讲一个atomic的问题，然后呢，我们开始讲除synchronized之外的别的锁，在前面的内容呢。

我们讲了synchronized，讲了volatile，讲了atomic和cs呃。

但是atomic呢我们只讲了一个开头，还没有讲完，今天呢我们继续。

好看这里啊，专门en就像原来的我们写m加加呀，就这一类的，你必须得都得加锁，如果在多线程访问的情况下，那现在呢我可以用aa omic energy了，它内部就已经也帮我们实现了原子操作。

原则操作是怎么做的呢。

直接写count their increment and get啊，这个就相当于cd加加，原来我们对抗加是需要加锁的。

不然的话呢会出问题，现在呢就不需要加锁了。

好。

就是m加加这块儿啊。

就再不需要加锁了，m加加这块不需要加锁的话呃，那么。

效率上呢应该来讲呢是要高一些啊，这个我再说一下啊，现在呢我模拟了，我们先读一下小程序啊，现在这个模拟了一个，像原来啊我们要记一个数，就是所有的线程都共同访问这个数，count count值呃。

大家知道当我们所有的线程都选，都要访问这个数的时候，如果每个线程给它加了个1万，往上加1万，你这时候是需要加锁的，如果你不加锁，它会出问题，上一节课呢已经演示过了。

但是如果你把它改成a term editor之后，那么你往上加呢，你就不需要再对这个cm加加，来进行加锁了啊，为什么呢，因为increment and get内部用了cs操作，直接无锁的操作往上递增。

那有同学可能会讲，老师他为什么要用无所操作，很简单。

无所操作的效率会更高，就这么简单来追求效率呢。

那怎么才能证明效率更高呢，来我们来看一下这个小程序啊。

我尝试着写了。

这叫抗的一可能会比较好，the factory name改成的名字，改成叫count嗯嗯。

扣个一啊。

ok，大家看这里啊，我呢，effect，我呢做了三个不同的操作，这是一个很粗糙的一个测试，但是这个测试呢，基本上也能说明一定的问题，好大家看这里，这里呢有几个比较好玩的，就是我现在模拟了很多个线程。

对一个数进行递增，好很多县城对一个数据进行递增，我们现在至少我们学的两种方法，第一种呢是我们这个long类型的数，然后对它递增的时候我们加锁，这是第一种，第二种呢是我们可以使用atomic long。

可以让它不断的往上递增，这是第二种，其实还有一种呢叫long added，由于呢很多县城对一个数进行递增。

这件事其实在实际我们工作之中，经常的可能会碰上。

所以在这种时候，你比如说秒杀秒杀的情形，我给你举个最简单，例如秒杀的情形，非常有可能会碰上，所以呢他写了好几个类来实现这种功能，那么其中一个呢叫做long adder，我们呢反正我是遇见这种东西的时候。

我会非常的好奇，我说到底是这种方式效率更高，还是说h m long效率更高，还说long adder效率更高，其实很多人的测试来看呢，这个atomic law呢很多时候也未必能比得上。

synchronized law，但是从我的测试来看，起码在现在的这种测试条件下，这tml它的效率还是要比呃synchronize要高，什么意思啊，我们来看程序。

我们count 1 count 2和count 3。

分别呢是三种不同的方式来实现的递增。

第一种呢是atomic long，第二种呢是直接synchronized的，第三种呢是用long adder。

long either的话，我们一会再聊好，大家看这里呃。

上来我起了1000个线程，线程数比较多，因为线程数太少的话呢，有好多时候你模拟不了那么高的并发，我来了1000个线程，这间的建成呢。

嗯现在呢我们第一步是试的是这个atomic，就是atomic la的方法啊，他是怎么做的呢。

一个线程的每个线程都列出来，列出来之后呢，每一个县城都做了10万次递增，每个县城都做了10万次好吧，这是第一种方式啊，然后我打印它开始了是吧，等它呃，打印骑士时间，等线程开始，等所有线程结束。

打印结束时间，算一下最后花了多少时间，这是因为最基础的测试，就是因为呢这个这种测试呢太粗糙，所以我才想说我们在这个包里呢。

我给大家讲一下，gmh那种测试呢相对更加的科学一些。

嗯后面讲到的时候，我们再来聊这个问题，就是更加专业的那种性能上的测试，那好这是第一种方式，那么第二种方式是什么呢。

第二种方式是我用ciront，用一个lock object log等于用object等于new random，依然是一样的，只不过这次呢在递增的时候。

我是写的是sront lock，所以这里是替代了atomic la。

上面是atomic law，下面是synchronized log，同样的计算时间，这就不说了。

好第三种，第三种是什么呢，第三种是同样的，也是1000个县城，每个县城10万次递增，那么第三种呢我用的是lan adder。

对这个long adder呢count 3啊，第三种呢是long adder。

loadder呢在里面呢直接就是cm 3点increment，同样的1000个线程10万次递增好了，来我们来跑一下，看到最后的结果是一个对比，像这种小程序，你们自己呢应该要动手写一写，你才知道呢。

到底在哪种情况下效率会更高一些啊，哪种情况下的效率不高，哪种情况下会怎么样，好来看一个对比啊，这是一个一组数据，其中是有可能的一组数据，用atomic的时候呢。

它的时间是两秒三，然后think呢是三秒五。

along adder是一秒一秒二，所以从这可以看得出来，这个long long either呢是最高的，就是效率最快的，居高再来一遍，再跑一遍，你来讲吧，所以所有的东西都写一个程序里。

其实不太科学啊，不过呢嗯那至少能看出个大概来呃。

你会看到long adder啊，效率非常的高，不过如果你自己做实验的时候，你要是把线程数变小了，long adder未必有优势，你要是把那个循环的数量变少了，long adder也未必有优势。

所以你呢实际当中用哪种，你要呢自己呢要考虑一下，将来你的这种病发的这个并发的线程，到底有多少，并发率呢，到底有多高，这个高并发高并发啊到底有多高，如果说没有特别高的情况之下，你要是实际当中模拟啊。

你你会发现呢，未必a toma就是最好的，或者未必long editor最好的，那刚才我们分析过，为什么我们来说为什么，关键是你们我问你们一个问题，为什么atomic要比sk快效率高，为什么。

刚才我们说了不加锁，对不对，sironize，是要加锁的，有可能他要去，操作系统去申请这种重量级锁，所以simple net的效率偏低，在这种情形下效率偏低啊，一定一定要说清楚。

那long adder为什么要比atomic要高呢，其实long adder的内部是做了一个这种分段锁。

类似于分段锁的概念，你认真听我来简，给大家简单解释一下这个long为什么要比，其他的两个都要快，long either，由于呢我们这涨就是加的这个值呢，特别特别的高，所以呢在它内部的时候呢。

它会把这个值，放到一个数组里，你比如说最开始的时候大家伙都是零是吧，然后呢县城数特别多，咱们不是1000个县城嘛，那么其中呢，速度成为四吧，最开始是零，然后1000个线程吗。

他会250个线程锁在这个位置，250个线程锁在这个位置，250个锁，这个位置250个锁这个位置，然后每一个都往上递增，最后算出来结果之后呢，把所有的数加在一起，最后一加加一个总的。

几个数一加算一个总数啊，算了，所以long either在并发性特别高的情况下，尤其是线程数量特别多的时候，long adder就有优势了，如果说线程数特别少，其实long adder没什么优势好。

所以我们现在来看来分析一下，为什么synchroni，为什么atomic比synchronized高啊，很简单，因为他用了无锁的操作cs操作啊，为什么long ther要比tony还要效率还要高呢。

因为它内部用了这种孙调走，资料走概念非常简单是吧，嗯好那呃关于刚才的这个知识点，如果没什么问题啊，你老是扣一有问题直接提好吧，分段所里是ci操作，是的是的是的，分段所也是c a i操作啊。

这个你想一想也肯定是嘛，他面试有可能会问，说那个这个这个问道可能性不大啊，但是有可能我认为您应该掌握，本身这个知识点也不难，long accumulator，只要long either呢。

是long accumulator的一种特殊形式，long accumulator呢用的就更少了，不少同学已经搞不太清了是吧，dollar ada的这个这个情形下。

系列 3：P35：【多线程与高并发】ReentrantLock - 马士兵_马小雨 - BV1zh411H79h

今天呢我们来讲这个经常用的基于c s操作的这种比较新的一些锁，新类型的锁，所谓新类型就是和呃怎么老的这么说，老老类型所的就是synchronized对吧，新闻台总经讲完了。

我们来讲基于c s操作的一些新类型的锁，我们先来讲这些所得用法，然后再来讲呢这些锁的原理好吧，嗯ok我们可以继续了，哎你给老师扣一好吧，测试很重要，对没错，这么跟你说，你实际写程序摸了条基本用不着。

摸了条就是用来干面试了，你在写程序的时候基本用不着va强听懂了吧，就是用来面试用的，在中国我们来看第一种算是比较新的东西，这个词呢叫做reaction rog，可重入选，其实有可重入锁本身的这个概念呢。

super nt的本身就是可重入锁的一种，哎，来看这里啊，什么叫可重入，可重入的意思是说我锁了一下之后呢，我还可以再锁对同样这边锁再锁一下，打开我的好评软件，右翻左右变成这个很好。

本身我们synchronize一个东西的时候，我们是锁定的这个对象，所谓锁定的对象就是在对象头里面呢，其实我用了两位来代表这个对象给我加锁了，那如果说我锁了一下之后呢，这个县城又毁了锁。

用神行这把锁发送呢这县城一申请的时候发现哦，当前持有这把锁的就是我自己这个先生，那好可以，你就继续执行你的代码就可以了，这叫可重入好可重入的呃，那必须是可重入的，不然的话你你你子类实现调用父类的。

你是没法实现的，来我们来看这个小程序啊，这个小程序是这样写的，siri的m一就是m一方法，然后m一方法里面睡了一个是唉，爱循环睡了睡了啊，做了一个循环是吧，领导时的一个循环。

second睡一秒十秒之后呢，打这个一呢可以想象一下那个0123456789，非常简单，接下来呢调这个m2 m2 呢是也是一个cnt的方法，那么来个主程序，主程序怎么写呢。

new thread me 1 start，就这么简单，两个线程就起来了，分析一下这个执行的过程，这个执行过程呢第一个线程在执行的时候，执行完，第二个线程就会起来，那假如说我们说这个锁要是不可重入的。

会是什么情况，会是第一个线程呢，我们申请这把锁锁的这个对象，然后，这里如果说我们是第二个线程来进行申请的话啊，这是因为这是别的县城能跑一下行了，那么你们想一下这个第二线程会start吗。

他start不了，必须得等什么呢，得等第一个线程结束了，因为这两个呢是不同的见证，所以你会看到呢，01234567891直m2 最后才能才能输出，但是你m2 得不到那把锁，所以没法执行。

所以在这种情况下，两个线程之间肯定是有征用的，但是如果说是在同一个线程啊，这个我是没有写出来是吧，就在这儿给大家做一个实验就行了，嗯如果是同一个线程的意思就能其实就是你在那个m一里面调m2 ，看啊。

a等于零，a小，于是i加加打印爱好艺术，呃如果等于0=2的时候，我们掉下来嘛，来同学们讲一下这个m2 能执行吗，m2 也要申请锁对吧，因为m2 也是synchronized，看到了吧，m一呢持有这把锁。

m2 也要申请这把锁，所以相当于在同一个县城里头都要进行son，那这样可以不可以呢，这样是没问题的啊，不起第二个线程，是，那你看到等于二的时候，m2 就被调用了。

说明snront方法是可以调schronize方法，也就是锁呢是可以重录的，好关于刚才的这个小概念，有没有同学有疑问的，有没有，所必须的可重入，尤其是secret如果不可重入的话，你自己想一下。

如果父类某一个方法是synchronized，那子类的话，调这个方法它没法掉了，没法重写了是吧，你重写的时候需要调父类的时候，你不也是新出台的调性空战机的吗，锁的是不同对象就不可重入了，那当然了。

你所不同对象当然就谈不上重录这个概念了，那不叫重录，那叫心路呀，大哥，slim free，同一把锁吗，如果是sample this，那就是同一把锁，这是simple net的方法吗。

不就是simple net this吗，同一个this当然是同一把锁，嗯，所以不能去小区，呃如果我们用这个logo呢，其实和原来的这个log reaction log啊，可重入锁，这是新型的一把锁。

他和synchronized的，它是可以替代synchronized，我再说一下，他是可以替synchronized的t型用来割，怎么t呢，原来写simnet的地方直接写lock点，look。

相当于加锁，解完锁之后，需要注意的是呢，一定要记得lock unlock解锁，我们siri是自动解锁的，只要这个siri的后面这个大括号执行完了好，这个锁呢就自动结束了，那么关于这个lock呢。

这不这不行，lock呢必须得手动解锁，手动解锁一定要写在try finally里面，要保证最后一定要解锁，不然的话你给上了锁之后。

你要是中间执行的过程中有问题了，死在那儿了，那别人永远也拿不到这把锁，所以一定是要写try lock finally，unlock。

同样的m2 的方法呢，我们也不需要写synchront door，我们怎么写，就lock。log log log就可以了，当然我们直列我再说一下，应该写try finally。

sorry，有时候讲理论的时候呢，把代码写的太复杂了，不容易讲清楚，倒不是别的概念，比不是别的意思，lock unlock啊，好当然这种情形呢其实和synchront是一样的。

它肯定是必须得等这把锁释放完了之后，然后呃thread呢就第二个threat才可以执行，这个说了比较简单，原来这个log呢，那有同学可能会说这个呃ranch logo既然和sonnet差不多的话。

那要它有什么用呢，reaction log有些功能还是要比sonnet强大的，强调在什么地方呢，你看这里第一个呢你可以使用trilog尝试锁定siri，如果说锁锁不了，上来之后进找那把锁。

如果锁搞不定的话，他肯定就阻塞了weight了，但是我们如果用reaction log，你自己可以决定你到底要不要weight好，可以用try log trilog，你可以尝试申请五秒钟之内。

我要求得到一把锁，如果说得不到的话，如果说得到了，就让他输出log，如果说得不到的话，我就我就我我就不干了，我说我啥事都不干了，就这意思，所以说你五秒钟你要是把你的程序执行完，那我可能就能得到这把锁。

如果得不到的话就不行，就这意思。

他们来演示下这小程序啊，现在呢由于我的第一个线程呢。

他跑了是十秒钟了是吧，所以你说你在第二个线程里头申请五秒五秒申请，你肯定是拿不着的，来实验一下，这是reaction log呢，比synchronized的好用一些的地方，你可以使用trl。

你可以自己尝试，你看m2 false m falls指的是什么，没拿着它锁了五秒，没拿着吗，没拿着，这是bollocked啊，lock等于try lock，如果说拿到了。

那么这个locked那一定是变成true了，他现在肯定是没有拿着，五秒钟没拿着，那怎么给他演示一下，能让他拿着呢，其实很简单，我让他循环三次就行了是吧，跑一下，三四这边完了，那m2 肯定就拿到了。

五秒钟之内，保证你拿着他不是说一定得等五秒，是五秒钟之内，保证你能你你拿着就拿，拿不了，就就就就你自己自己做出处理，所以simple来都是做不到这一点的。

所以这是reenterlock with simalized，牛的地方，当然不止这一个地方，我们继续看啊，siri除了这方面比较牛之外呢，还有一些其他方面啊，这个reentry log。

react to log呢，还可以用什么呢，用这种方式叫look interruptily logan，interrupted logan，interruply的意思是说我在logo的时候呢可以响应。

被别人打断了，你不要打断我的话，我是可以做出响应的，但你还记不记得sronized synchronize，一旦wait了之后，你必须得让别人notify，你才能够醒来，不然的话你是醒不过来的。

就是你可以被打断的枷锁，如果是这种方式来加锁的话呢，我们可以调用一个interrupt就可以打断这个线程二的等待啊，这个意思好。

线程一怎么做的，线程一是这样做的，线程一呢干了一件事上来之后加锁。

加锁了之后呢，他开始睡睡多长时间呢，integer max value，那就睡起来，没完了没完没了，没完没了，一定是睡，那建成二呢，县城二呢他这时候申请，如果说被县城一已经拿到这把锁的话。

那县城二想拿到这把锁基本不太可能了，他拿不到这把锁的情况下，他会怎么办呢，他就会在那等着，但是呢如果我们使用的是原来的这种look，你是打断不了他的线上是停不了的。

我们还可以用另外一种方式叫locking roduly，可以被打断的好，这时候你要想停止线程二，你就可以用interrupt，一旦他被interrupt之后，那么它就可以做出响应了，继续往下执行了。

就所以你会看出tr started tr and catch到exception之后呢。

interrupted跑一下试试，啊t1 that，你会看到那个。

这时候呢我们就catch到了。

interrupted exception，illegal monitor，data，lock unlock是说，没有锁定不住啊，这个得需要做一个更好的一个判断。

not interrupt the world，最后我们要解锁，这里稍微有点小问题啊，就一会儿再说啊，所以呢在那个lock里面，你还可以调用这种方式，locking roberly。

这也是他比siri好用一些的地方，维加索到了一场对我们一会再来聊这个判断的时候，他这个lock interrupt的返回值是一个void，所以在什么地方做判断是个小问题。

对我来说啊好这是reaction，not呢。

比sronized的，牛的一个地方继续看啊，留一个看，看完之后呢，先对h logo有一个了解。

那么如果这波还可以指定为一个公平锁，公屏锁的意思是当我们另一个reaction log，你可以传递参数为true处呢，而不是说谁后来了之后马上来执行这卫星所这么简单啊。

所以这是一个新的有可能会被考到的人，认真听你看啊，这是那把锁在这个县城等着就好多好多县城都在等这把锁，实际上这些线程呢是位于一个队列里，这是没问题的吧，唉1234等等，听我说。

当又有一个新的县城来的时候，它呢会不会检查队列里面有没有内容，是公平锁的关键，如果说这个锁不公平，这个线程上来就抢，他是有可能抢到的，如果说这个锁是一个公平锁。

好这个县城上来会先检查队列里有没有原来等着的，如果有的话，他就先进队列，等着等别人先运行，这是公平锁的概念，不知道说清楚没有，有没有同学有疑问的，你看他说出了他一定是，有一些嗯，默认是非重点。

是不是有一句logo啊，默认是非公平的死，当它为true的时候，rock。lock，lock on lock，总共100，这是输出的问题，这应该不是那个什么的问题，过流血thread current。

thread t1 t2 t2 t一就显示的图像是很公平的样子啊，嗯，那么如果说你是非公平的，它是有可能二话不说，直接一个线程全执行完了是吧，另外一个线程才能拿到，如果是公平锁的话，这实验确实不好做啊。

再说，如果是宫廷锁的话呢，你会看到它有一些交替的输出呃，一般来说呢他会中间有交替的情况，那有的同学可能会说，那老师他为什么不是挨着牌的交替，就是一完了之后马上按，完了之后马上三呢，其实呢是这样的啊。

注意这个公平锁呢它也并不是说就能保证的嗯，嗯没有线程执行完了，另外一个线程的必须必须得是另外一个线程执行，如果是那样的话，你必须得用那个线程之间的通信才可以，这个我们后面讲面试题的时候，再来讲这个问题。

给大家画一下这个图，非常有可能是什么情形呢，有一个线程拿到这把锁，然后呢你看啊他落后完了之后呢，打印完了之后呢，unlock对吧，好unlock完了之后呢，接下来另外其他的县城还没有进队列呢。

他自己又进了队列了，他下一个循环又进了队列了，所以下一个循环拿出来了，还是这个先生，所以一次他往外输出的时候还是还是t1 t1 ，完了还是t1 t完了还是t啊，但是至少呢它会有一些间接性的输出。

就提完了t2 t2 t1 ，如果我们用非公平的锁啊，你会看到大片的全是t1 t完了之后才是t2 ，听听雨落说，lock lock放for循环外面放for循环外面。

你t一不就马上执行完了吗，你想t一拿完锁之后，马上t一就结束了，那一定是t2 了，这个不用想。

所以你理解这个不清楚的概念就行，公平锁的概念我再说一下，并不是说那种完全的公平，说我执行完了之后就得是你不是公平锁的概念，是由于我们是在一个等待队列里，公平锁是后进来的。

这哥们需要检查一下队列里有没有人，队列里有您先来，队列里又没有，我就来了，非公平事，我才不管你呢，我抢了算我的，谁抢了算谁的。

听懂这意思了吧啊，reenter note和synchronized之间的一个对比，这个对比是什么呢，纹身work可以替代synchronized，这是没问题的，他也是可以重录，也是干嘛的。

也是没锁定的，这是肯定没问题的，本身的底层是cs，对srt的本身是一个所升级的概念，那么它呢可以指定，可以有travel自己来控制我锁不上怎么办，他还可以有，呃look interrupt。

好中间你还可以被打断，非公平的切换对吧，好归公平和非公平的一个切换，而sychronized就只有非公平锁，它没有公平和。

系列 3：P36：【多线程与高并发】CountDownLatch - 马士兵_马小雨 - BV1zh411H79h

我们来聊这个count down latch，count down，lash呢count down倒数lash是门栓的意思，而倒数的一个门栓啊，54321数到了，我的门窗就开了这么一个概念。

我们来看这个小程序，这个小程序呢叫using coundown，let是什么意思，看这里threads等于new一个thread，100个线程，接下来我来了一个100个数量的。

come down lash，诶什么意思，这是一个门栓，这个门栓上面积了个数，记了数是多少呢，是surprise，their lance，是100，每一个线程结束的时候。

我让let。come down。

然后缩写成start来点await。

ok最后and come on mage到底干什么使的呢。

先从这儿看，上面是所有的线程开始。

这是没问题的，let awaight的意思是说，门栓在这儿给我拴住，门给我插住，不要动，当执行到这句话的时候，这个门栓就在这里等着，并且上面接了个数是多少，是100。

每一个线程结束的时候都会往下come down，come down的意思是减一变成往往往下，原来都说的是基础上减一好，现在原来是100，一个线程结束了变成99，再一个线程结束了变成98。

再一个线程结束了变成97，咣咣咣咣咣，什么时候这个栓才会打开呢，很简单，变成零的时候就会被打开了，所以这就是门栓的概念叫countdown lash，倒数倒数奇数，那么它用来干什么呢。

你理解了这个东西之后，你说他用来干什么的呀，用来等着那些线程结束，等多少个线程结束之后，我们来干什么，干什么干什么，这就是一个门栓的概念啊，唯一用过的就是condolesh。

ok so and lesh，当然有同学可能会说我结束也可以用别的没错，可以用什么呢，可以用joy，这是没问题的，每一个县城都等着合并在当前现场上，ok让他让让他结束，这个也可以啊。

comblech叫嗯滚动发车，坐满就走，可以这么来理解，很简单，本身这个con lash比较简单啊，好关于condolesh，我就聊五分钟，用法上我们就聊五分钟，有问题吗，condolesh的用法。

有名同学就问你主要几个函数来配合，第一个呢是let。await，拴住了，什么时候这个打开栓继续往前走，111步一步不停的come down，等康康down到零的时候，这个栓就继续往前走啊。

性能上比折耳有很多嘛，性能我没错，这个我估计也不会比，照样有很多，而且你用common lash来聊性能，这事本身就不靠谱，康纳是干嘛的，await大哥。

await阻塞的阻塞里有什么这种这种这种阻塞的东西，你有什么性能可聊啊，就得等着所有的你的运营正在运行的线程结束了，你才能够继续往下移，那你运行线程运行多长时间，这才叫效率高，我靠好吧。

好这就是come on let的最常用的一个用法，因为门栓栓在那儿，什么时候，我想让他继续往前走的时候好，我可以来程序来进行控制，那如果你用joy能用joy，实际上不太好控制，你分析一下，用joy呢。

必须你这个线程结束了才能控制，但是如果是一个门栓的话，我在一个县城里可以不停的coundown，coundown，coundown calm down。

我在一个县城里就给他康down到从100直接给他数到零，我一个县城就可以控制这个门栓什么时候往前走，但是我如果用join的，用join的话，我只能说我当前线程结束了，你才能自动的往前走。

系列 3：P37：【多线程与高并发】CyclicBarrier - 马士兵_马小雨 - BV1zh411H79h

那我看这里啊，我们来讲，另外一个同步工具，这个同步工具呢叫cyclic barrier，cyclic barrier呃，cycle和bl的意思，栅栏这个炸弹呢就像什么呢，就像那个发令枪一样，嗯。

只有一个栅栏是吧，什么时候这边人满了，满了之后呢，就把这渣渣推倒，哗啦哗啦啦都出去了，都出去了之后呢，哎炸弹呢又重新起来，新来的人满了，把推倒推倒之后呢。

又继续就这样循环cyclic循环的cyberrier栅栏，循环栅栏好看，这里，clibarria等于六一个celebra，两个参数，当然第二个参数不传也是可以的，第二个参数不传的意思是他满人了之后呢。

你不做人了事，第二参数是一个什么呢，是一个rnable，它叫做berry action，两个30，第一个参数是20 20的，意思是满20个人发车，满20个人满了之后帮我调用第二个参数指定的动作。

我们这个这个动作呢就是一个render对象啊，所以我定了一个ro打印满人翻车呃，当然啊，同学们听我说，这三个加a呢有好几种内衣方式啊，sander berrier barrier的new，一个最简单的。

没有一个3d barrier，一个参数的20，其实这句话的意思就是说呃所有的程序一旦到20个县城。

到这儿之后，好这个栅栏才会被放倒，然后你才会继续看这里。

for a等于a小于100 100的线程。

new thread，每一个thread呢barrier weight，barrier weight的意思是beryl在这等着，你可以想一下第一个线程来了之后，在beryl前面等着，第二线出来的。

也等着什么时候这块都会被放倒，这块会被放倒呢，很简单，就是什么时候等到20个人了，就是你这里指定的是parties，参加者是20个，什么时候指定20个人了，我就发车，那就是满人发车。

你就想一下有一辆车扔在那儿是吧，什么时候人满了，什么时候翻，拿一簸箕，上面好多人什么时候坐满了，什么时候给你扔，扔到山底下去，周老师，你理解不对，好这是第一种方式啊，就是他圆满之后呢不做任何操作。

当然你这个av完了之后继续下面写任何操作也可以啊，人满发车也可以，不过呢跟我们家优雅的一个方式是这样来写的，就sexy berry啊，等于new bl，六完之后呢，人满之后，你让他执行一个rainbo。

类型的对象，其实说白了就是让他直接一个操作了。

我打印这个，我这个操作很简单，就是猛然发车，当然还有这种写法啊，我写出来看大家能不能理解beryl等于new cyberyl 20，the bactional，就我这样来写，就是拉姆达是，本人，啊。

这是这种写法啊，我只我只不过像这种写法呢是为了让大家看得更清楚。

那么上面这种写法呢就是用来b表达式的写法啊，o好看，这里来我们来执行一下，看看软，好买买买买买，15个满了人之后呢，说明人满了，程序可以继续往下执行了，所以这样的意思就是大家伙都在这等着。

什么时候人数够了够了，什么程度呢，什么叫够了呢，你指定你自己指定有多个线程跑到这儿了，如果说不够，大家伙都跟都跟我这等着，如果说够了好，你继续。

那么刚才呢真的是说这coronline的区别只能是循环一个正数，一个倒数，不不不，你千万千万别这么认为，这跟正数倒数没有任何鸟关系，好吧，你看他哪句话写了证书，哪句话写了倒数。

他如果看down是确实是个倒数，但是这个可没有证书的概念，这如果就是大家伙，县城在这堆满了，我们继续才能往前往前执行，而count down的意思是说我calm down了之后，什么时候归零。

什么时候当前线程继续往下运行，我可没有一定说就是100个县城或者多少个县城在那儿扛到，我可以一个县城一直扛到，老魏啊，周娜斯不知道说我说清楚没有给我点反馈啊，就是那个康down啊，他只是说拴在那儿。

他什么时候变成零，什么时候就继续往下执行了，但是你怎么让他看到呢，你不是不一定非得在每一个县城里coundown一下，你可以在一个线程cdn多下，什么时候归零啊，什么时候减下去就ok了。

20个县城是一直在这等着吧，19个县城，确切的说是19个县城，sing in the rain，同学为什么是16位啊，第二次第二次被建成来了就满了，满了大家伙就发车了吗，会询问这个栅栏的场景是啥。

这个栅栏的场景，栅栏的场景，我给你举一个限流的概念吧。

我想想啊，这个是不是很贴切啊，加栅栏的场景，最直观的场景就是面试，我告诉你嗯，然后呢，你就一个限限流的概念啊，clic barrier，塞雷贝尔这个限流。

嗯嗯你比如说我们前面来了很多很多的从前从从从从客户端那里啊，用来很多很多的一个访问，然后打到我们的web server上，我们web server呢由于可能秒杀也好，或者是突然之间的打流量冲过来也好。

大家知道呢，在后面的微服务要访问到我们某一些具体的服务的时候呢，唉我们要进行一些个限流，就你说这些这些流量太大了，我实在承受不了，如果任由他打到我后端数据库上的话，我数据库直接就崩了，我可能顶不住。

那这时候呢我们要进行一个限流，那限流怎么做呢，限流就是前面这个流量的入口啊，特别特别多，但是呢我后面的出口，我给他限制住后面的出口，我给他限制住，好这出口，我就给他限制住，我就给他说。

比方说你只有你两个请求能过来，或者是只有30个，40个，50个，60个，70个线程请求能过来，这时候我是不是就可以用clebarry了，胡云你想想他这个情景能想象得到吗。

当然我告诉你实际用的时候是用哪个的呃，一般来说有可能用的是那个，娃娃，java里面那叫rich limit，这是呃google对那个专门做了一个限流用的这样的flag啊，我可能会用这个，这得等够了。

20个一起处理，对没错啊，对或人说的很对啊，这个我举的这个例子呢稍微的有点问题，他来了19个应该就来了，前面少于20个就直接就过去了，所以限流这个概念就是大家伙儿等齐了这件事一块才能出发。

比如说我们某一个县城需要等到所有其他线程结果全都结束了，我另外一个线程才能执行，那么其他县城呢不能直接往前跑，在这种情况下，就需要就可以用cliberry了，对对对，这是令牌桶的限流。

这个和那个celebra这个例子举的举的不好啊，sorry，这个就不好，这是限流的概念，这个，赛里ban的就是有些县城啊，他必须得等其他的这些县城都完事了，你才能够继续往前执行嗯，举个例子的例子。

我们如果说做某一个操作的时候，我们需要干嘛呢，需要其中先去数据库取个取个数据，然后另外一个再去网络上了，取个数据，爬一个数据，还有一个去硬盘上读一个东西，假如说我们顺序执行这个例子。

应该会让你明白这件事啊，我重新举个例子啊，这实际上是限流的概念，不是sei berrier，呃vivi的概念没拼错，可能别人david的概念呢，你比如说一个复杂的操作，需要好，如果需要好的网络。

标准文件，假如有一种方式，你是顺序执行所有ipad的，全执行完顺序执行效率可能非常低，这是这是这是这是一种方式啊，但是还有一种可能性呢，我们就是病犯这种，就是我派某一个原来是123是吧，原来是123。

这么来执行并发执行的就是不同的线程，sheet，不同的线程去执行不同的操作，不同的院长出现不同的操作，有的线程的去数据库找，有的线程去网络访问，有的线程的去读文点好，等这些线程全都读结束了之后。

必须得三个线程全都到位了，我下面的操作操作才能进行好，这个时候就可以用sk barrier或云，不知道说清楚没有，拼错了是吧，这看着有点别扭啊，ok，很好啊，我们都看到单独。

系列 3：P38：【多线程与高并发】Phaser - 马士兵_马小雨 - BV1zh411H79h

那么面试官那肯定会对你高看一眼，是肯定的啊，咱们这个啊这个稍微复杂一些，这个叫什么呢，你这个叫fer face嗯，faze的意思是阶段不同的阶段，fer呢是按照不同的阶段来对现场进行，执行什么利益。

什么意思呢，就是它本身啊是维护着一个阶段，这样的一个成员变量，就当前我是执行到哪个阶段呢，是第零阶段呀，还是第一个阶段啊，第二个阶段啊，第三个阶段啊等等，那么每个阶段不同的时候呢。

这个线程呢都可以往前走，有的县城走到这儿的时候，他就停了，有的县城呢一直会走到结束，所以如果你在，各种，各种的你的程序之中，如果需要用，到时候分好几个阶段执行，而且呢有的人呢必须得同时。

几个人共同参与的，像这样的一种一种一种情形的情况下，你有可能会用到这个fer呃，我直接告诉大家，我是没有用过的，就是真正在我们自己写程序的时候，我只能是给大家写演示程序，但是有有一种情形可能会用到。

就是如果你写的是遗传算法，一传算法呢你上网自己查一下啊，这一传算法呢实际上是计算机的，来模拟达尔文的那种进化策略，所发明了一种算法叫遗传算法，当你去解决这类的问题的时候。

这个fader是有很多能用得上的，面试官没听过咋办，面试官没听过，你讲给他听了，哈哈哈，有点像先一步后同步大兵，你这个例子是，你这个理解也应该是没问题的，每个阶段就是先异步同步，其实这东西更像是什么呢。

更像是cyclic barrier，就是barrier这东西，栅栏这东西一个一个的栅栏，它原来是一个循环的栅栏循环使用诶，但是这个栅栏那是一个栅栏，一个栅栏，一个栅栏，一个栅栏，这么扔下去。

我们来看我给大家举一个小例子吧，好不好啊，自己造一个概念，忽悠面试官，可以，你只要能不用，面试官肯定是没问题啊，我，们我们直接看这个test fer 02就行了。

test肥皂二就可以了啊，fer 2呢比fer一又稍微改了一下，会更加齐全一些啊，我们要读这个小程序啊，小程又一点点多看这里啊，我们先不看这个fer的部分，我们先来看呢。

有一个现在我模拟了一个一个一个场景啊，这个场景呢是一个结婚的场景，听我说我模拟了一个场景，这个场景呢是一个结婚的场景，你认真听啊，这结婚呢是有好多人要参加的哦。

因此我写了一个class steady class，person implements rable，这个写的不是特别好，应该叫从thre集成就就行了，但是不管怎么样能理解就行。

就是我们是一个renderable，可以new出来扔给threat的执行的模拟，我们每个人要做一些操作，那这个人呢有自己这个名字，这个倒没问题，很简单，注意看它有几种方法呢，有这么几种方法。

第一个叫arrive，到达叫it是leave，离开hug，拥抱就这么几个，好听我说作为一个婚礼来说，它分成会分成好几个阶段，分成什么阶段呢，第一阶段是大家伙都得给我到齐了，第二个阶段呢大家伙开始吃饭。

第三个阶段呢大家伙离开，第四个阶段呢就是新郎新娘入洞房了，这两个可以hug，其他人是没法hug的，那好了，每个人都有这个方法，arrive it leave hard，看这里在方法的实践里头。

其实我就简单的睡了1000个毫米，这个你你就不要再纠结这个地方，我自己写了个方法，写了try catch了，要不然老老在写try catch，看着别扭啊，把开try catch扔到一个方法里了。

milliseconds，mini sleep，其实我就是把try catch扔到这方法里了，因为一堆摔开始看着太别扭了，那这就不解释了，每个方法我都让他随机的睡这么几秒钟，模拟我们的右逻辑。

然后我们打印谁谁到达现场，是哪个人到达现场了，arrive方法，意德呢是哪个人，吃完了live的那个人离开了，谢拉新娘啊，是进了洞房了，o好看，这里，下面这句话呢我们先不聊好吧。

叫fader arrive and weight advance，我们先不聊这几个方法。

大体的意思不知道大家看清楚没有，再看一下啊，一个类属性name方法就这么几个，arrive it leave her没了，先不看其他的逻辑好，到现在为止应该没问题吧，逻辑太简单了。

无非就是个非常普通的java，但是我们再来看它，实现了renov这部位得run方法，套在县城里去，这个县城里呢就是他就执行这四步，反正每个人参加婚礼吗，无非就这四部。

rive it leave和hard，没别的，还有这方法我就写完了，这个论文写完了有没有问题，刚才我讲完的这部分有没有问题，那没问题，那我们继续，然后呢我们来看主程序我是怎么写的。

主程序呢我们先不看上面，先看下面i等于零，i小于五，然后又多了一个小，咱们表达式的时候多难啊，然后represent，然后把它装到thread is start，所以p01 直到p4 p0 。

p1 p2 p3 p4 ，一共有五个人参加婚礼了。

接下来新郎参加婚礼，新娘参加婚礼好了，七个人，一共七个人参加婚礼，我们用线程来模拟它，它以start会调用我们的run方法，调用我们run方法，它会挨着盘的调用每一个阶段的方法。

那好大家记住在每一个阶段，我们是不是得控制人数啊，第一阶段是被所有人到齐了，我们才能开始啊，哎你们说新郎新娘还没到齐呢，就开始是吧，第二个阶段所有人都吃饭，第三个阶段所有人都离开。

但是到第四个阶段进入洞房的时候，你就不能所有人都干这事了，所以呢如果我们想模拟这个程序，我们呢会要把整个的过程要分好几个阶段，而且每个阶段必须得等，这些县城全都给我干完事了，你才能进入下一个阶段啊。

你不能说那个刚吃完就进洞房，这不行，不允许，ok看这里刚来，你就进病房是吧，连吃饭都不吃，对不起，那怎么来模拟的过程呢，我这样来写，我呢用了一个phaser，定义了一个pser哈。

我这pser呢是从fser这个类继承marriage，fer，extends fer重写，注意是重写的一个方法叫on advance，advance，英文是什么意思呀，前进，什么人会前进。

听我说到了这个栅栏满足条件之下，这个方法会被自动掉，on advance，县城抵达这个栅栏的时候，这个on advance会被自动调用，就是说，第一个是所有的线程都满足了，第一个战略的条件了。

这个on advance自动调用，目前我得有好几个阶段，这个阶段呢他是写死的，必须得是数字零，开始好几个阶段，switch phase，好advance的时候会传递两个参数。

后面这个呢是register parties，就目前这个阶段有几个人参加，顺子是第几个阶段，目前这个阶段由第几个人参加，是由谁来决定的，failure docker register。

往里头注册一个七个人，就是当前最开始的这个阶段，是有七个人参加，这个数字会被on advance接收到，我们重写，重写会被调用吗，这个会被调用，调用的时候，那个数字会被接收到，就到这里啊。

release please，当面是第几个阶段呢，如果是第零个阶段，第零个阶段的意思就是说，所有人都已经到了到了第一个炸弹，第一个炸弹被推倒了，结束的时候好，我打印所有人都到齐了，打印空行。

return false，到第二阶段，所有人都吃完了，return false，第三个阶段，所有人都离开了，第四阶段，婚礼结束啊，新郎新娘可以抱抱了，最后return true。

当我们return true的时候，所有的线程就结束了，整个的这个栅栏组，这个痱子的栅栏组就结束了，那好，那我怎么样才能让我的县城，在一个栅栏面前给停住呢，每个不同的阶段的栅栏给停住呢，就用这个方法。

fer arrive and waited varrive，到达weight advance，等待着继续往前走，我们再来执行一下，一会儿我们再来过一遍这代码啊，你会明显的看到呢它分成好几个阶段。

一个阶段新郎新娘到达到达现场是吧，p01 直到p1 p4 ，所有人都要齐了，目前呢当前接收的人数是七个。

这个阶段接收的线程是七个，七个线程，第二阶段全都吃完了七个县城。

第三个阶段呢全都吃完了七个县城好，最后一阶段新郎新娘洞房了，其他人没有了，只有两个现场，为什么只有两个线程呢，是因为我们在这写了，其实不是因为别的，而是说我们自己写的，在hug里面，我们写的是。

如果name是等于新郎或者新娘的时候，你可以动皇继续arrive and awaited vs，这是没问题的，其他的情况下叫arrive and diregister，就是你可以到这个阶段。

但是呢be regist，register是注册，d register是解注册是吧，不要在这注册了，这个阶段没我的事了，再往后的阶段没有我任何事了，就是到这个阶段啊，其他的人你都滚蛋。

只有新郎新娘继续可以往前走，生孩子干嘛的，随便，如果你再加一个新阶段啊，生孩子之类的，那么前面的这些个线程就都没了，好我我我画一个图，然后先来了解什么样的流程啊，这个具体的写法。

上一会儿你们下去再仔细看，先给大家画一个图，先了解这个流程，目前呢我们所谓的这个痱子呢，会成分成好几个阶段的栅栏，这第一个呢是零，第二个呢是一，第三个呢是二，第四个呢是三啊，我就这么这么几个阶段。

然后呢，这第一个呀大家伙得等大家伙来全了，五个人加两个人，一共七个人啊，五个客人，两个主角，这两个主角嗯把下面，好这是我们的两个主角啊，别总来拳了，然后这个这呢才会倒掉，倒掉之后呢会说所有人都来全了。

然后大家会去干嘛，进入下一个阶段，进入下一个阶段的意思是大家都都失败，o一完了进入下一个阶段，待会儿都离开，你开完了之后呢，进入下一个阶段，所有人都到了啊，但是在下一个阶段里头呢。

我们让这些个人啊都低于jor了，所以如果再有下一个阶段，这些人就不会再参与了，啊不知道我说清楚这个过程没有，这个是就是pser的意思啊，我们再来回顾一下这个写法，写法呢是这样的，你要用飞的时候。

需要呢从你要想处理每一个face的逻辑，你自己呢要写一个定义的自定义自定义类，从fser继承重写它的on advance方法，而这个方法呢是，当我们每一个站位被推倒的时候，它会被自动调用。

里面有两个你可以用的参数，第一个呢是当前是哪个阶段，哪个照样被推倒了，第二个呢是目前有多少人参与了这个阶段，就推倒之后还剩多少人可以这么来理解啊，ok 0123，所以剩下的过程呢。

就是你可以调用arrive and weight month，等着进入下一个阶段，或者是arrive and diredist，我就不进入下一个阶段，所以它不仅呢可以控制栅栏的个数。

还可以控制栅栏上等待线程的数量，这个呢就叫做废纸，还是那句话，是给大家拓宽知识面用的，假如说我面试好像都没人，都没人问到对，像cyclic不要读circle大哥，plic barrier的升级版。

1。8新的这点是哪个从哪个版。

哪个1。7，1。7cc，1。7。

系列 3：P39：【多线程与高并发】ReadWriteLock - 马士兵_马小雨 - BV1zh411H79h

ok这个是被问到过，而且是有可能会被使劲考的。

认真听，那么这个是什么呢，这个叫做reader read lock，读写锁好，读写锁的概念呢其实就是共享锁和排他锁，嗯，好就是共享锁和排他锁这两个音读锁和写锁，读锁就是共享锁，写锁就是排他锁啊。

这是什么意思，我们先要来理解这件事儿啊，读写呃有很多种情况，就是你那个数据库里的某条数据，比如说你放在我的内存，就可能读的时候特别多，其实改的时候呢可能并不多呃举个最简单的例子。

就是我们一个公司的组织结构，我们要想显示这个组织结构底下有哪些人在网页上访问它，所以这个组织结构呢经常会被访问到会读，但是他很少更改，除非是借人或者踢人是吧，雇佣人或者解雇人的时候，这个结构才会更改。

所以读的时候特别多，写的时候呢并不多，但是如果我们这个时候好多现场共同来访问这个结构的话，让大家想一下啊，好多线程共同来访问这个结构的时候，有的是读线程，有的是写线程，我们可以采用一种什么样的方式呢。

如果想不会要求他不不产生这种数据不一致的情况下啊，你不能说你这边写一半了，这边就读出来了哪些数据了啊，这边刚写一个张三，要要要入职，结果你刚写到张字啊，这边读出来了啊，有新进来一个有职员叫张啊。

这个还好是吧，要是写一个写一个什么别的不太不太好听的啊，这王八衰啊，前面俩字刚写进来，后面这读的县城开始读出来了，这个就不对了啊，所以这个时候呢你得最简单的情况就是枷锁，不管你是写的时候还是读的时候。

你都得给他上把锁，我读的时候只能我自己读，我写的时候只能我自己写，但那种情况下呢效率会非常的低，尤其是毒性程特别特别多的时候，毒性能特别特别多的时候，他效率就会非常的低，所以我们能不能做成这样的锁。

什么样的锁呢，就是当我读线程上来的时候，我加一把锁，这把锁呢是允许其他读线程可以继续读，就这把锁呢，如果是别的那个线程写线程来申请，我不给他，我正在读呢，你先别写，等我读完你再写。

但是别的独线程来的时候，我发现你是毒性程，好了好，这个时候我就允许你进来，大家伙一块儿读，因为你不改原来的内容，但是血线程上来二话不说就直接把整个的全锁定，你先别读呢啊，等我写完你再读。

这样的话效率就是比较高朗啊，s s问王八衰是什么鬼，很明显你没有看过倚天屠龙记啊，一天都有，你是吧，叫什么赵钱孙李周吴郑王了，赵敏所带的八个侍卫是赵赵赵一衰，前二拜孙三回，李四催。

这个这个赵一铺叫什么来着啊，最后一个叫王八衰嘛，你知道学名法老是，呃折叠器读的线程很多，会不会一直读，不是放锁血线程，一直读着，现在就等着呗，那你显现程一直等着呢，你在什么情况下。

你说写线程一直得不到这些，你告诉我一下，那除非cpu出问题了，cpu就挑那个毒的往里头扔，写的他不管，程序里的读写锁，数据库里的锁会不会冲突，两回事，数据库的锁，数据库的锁，程序锁，程序测锁两回事。

数据库的锁是你访问数据库的时候加在数据库上面，你读你从数据库读出来了之后，你会扔在那个程序里吗，那程序里的话是你扔在内存里的两回事啊，你别别混一块儿，我们读一个程序的时候。

不就是说先去数据库里把内容读出来，读出来了之后，你内存里才有，对不对啊，这时候已经读完了，都你至于说你读的时候需不需要给行上把锁，或者为整张表上把锁，那是你自己的事情。

你读完了之后是我们说的是这部分内容跟数据库没有任何鸟关系啊，我现在容易经常死锁，我去真的一会儿咱们好好聊一聊这件事啊，好我们先我们先讲先讲内容啊，我看这里啊。

嗯这个毒蝎手呢其实啊我后面给大家讲完这个reaction logo的condition之后，大家就会了解这个毒解锁呢其实就是和肯尼神的概念呢非常的类似，我们先不说，就说这件事啊，你先说这个读写锁怎么用。

读写锁呢，我们这么来用啊，嗯，啊。

咋看这里啊，看这里呃。

我们现在有两个方法，第一个方法呢是read读一个数据，第二个方法呢是写right。

写一个数据，read这个数据的时候呢，我需要你玩这个传传一把锁，这个你传那把锁你自己定，我们可以传自己定义的。

所有的全都是排查锁，也可以传自己定义的毒蝎锁里面的毒素和解锁。

这个随便你rap的时候也需要你传把锁，同时rap的时候需要你传一个新知。

你往这个纸里头传一个内容啊，也就是模拟这个操作，所以他就读的一个什么值呢。

读的是一个int类型的值，模拟一下，好，读的时候，我上来之后先上锁，读的时候也要上锁，写的时候也要上锁，刚才说过了，因为你读的时候万一被写，中间被写进去，你就读了脏数据了，所以不会是上锁。

read over表示我读完了。

做完了操作了，就这意思，最后unlock不说了，接下来解锁，解锁是上来之后unlock绕口完了之后呢，税表示写完了，把这个新值呢设给value，设完了之后呢。

unlocal非常的简单啊，我们的现在的问题就在于我们可以把这个往里传这个logo。

传这个logo的时候呢，有两种传法，第一种呢我就直接传这个logo，很清楚，等于new一个reaction log。

直接把这个logo传进去，但是你想一下，如果是这个logo传进去的话。

分析一下啊，啊，啊定义一个round对象啊，第一位round模对象呢是调用read方法，第二个呢是调用right方法，同时往里头扔一个随机的值，这个值是什么不重要，然后呢，我起了18个线程。

这18个是独线程啊，起了18个毒线程，起了两个血线虫好，你认真听同学们，这两个东西我要想执行完的话，现在我传的是什么锁呢。

我传的是一个reenterlock，看到了吧，这把锁大家知道他一旦上了手之后。

没有任何人，没有任何其他的线程，我能拿得到这把锁，同学们，你们告诉我一下这20个线程执行完需要多少秒，实验一下走。

你，你的血线程啊，你必须都得给我等着是吧，所以如果你起18的毒腺中用这种互斥锁。

互斥锁也叫排他所，我拿了这把锁，没有任何人能拿，如果用这种情况下。

你就得等20秒才能干完这件事，我们来换一下，这次我往里传的时候，虽然说还是read还是right。

但是我这往里传的时候呢，我换了锁了，这把锁是怎么做的呢，这把锁是这样子做的，看这里，read red log读写锁等于一个reentrant。

read red lock是read reload的一种实现，在这种实践里头呢，我分出两把锁来，第八锁呢叫relock，等于revlog的relock。

通过调用它的relax这种方法来拿到这relog对象，读索我就拿到了，通过断relog方法，我拿到他的reload对象，所以呢我把这把手分成两把，第一把呢叫relog。

第二把呢叫red log，好这两把锁在我读的时候。

我给扔进去，new road rer start。

这次往里读的时候呢是read read lock，传的是relog，而写的时候传的是red lock，刚才我们分析过啊，同学们，我说当一个这个对象上上了一把毒索的时候，其他的那种独线程也是可以继续读的。

所以理论上来说，看一下。

你自己看，回头把rap我没了，再来看一遍啊。

刚才那是一个一块多，但是现在我用reload呢，你看啊，real over rever，rever没了。

所以在这种情况下。

我现在这么聊这件事，大家能理解了吗，再看一遍，我们现在有一个值a sheet啊，好我们现在有一个值啊，这个值呢是一个int类型的数，然后我有18个独线程，使劲往里使劲儿从里往外读啊。

然后还有两个线程呢使劲往里写，我们加一个互斥锁或者叫排他锁，在这种情况下，一个线只能一个键能读，其他线上也不能读，也不能写，效率非常低，但是我们换用读写锁之后呢，在读线程里面加的是毒锁。

在写线程里面加的是写锁，写锁是排他的，我不能说我写的时候别人也可以写，我写的时候别人也可以读，这是开他的，这个没问题，由于血线程比较少，所以这个没有这个效率呢，呃也也不会降低太多，为什么呢。

因为我在一个线程读的时候，其他的也可以进来继续，好了哎，hello world，说的很问的很对，他说读的时候不加锁呢，读的时候如果不检索，那那就是说你读到一半，我这个假的中间的数据就可能写进去对吧。

这人叫王八衰，结果你读了前两个字儿啊。

系列 3：P4：【多线程】用户态与内核态 - 马士兵_马小雨 - BV1zh411H79h

好下面我们补第二个内容，文补用户态和内核态。

为什么要补这个这个事儿呢，这要补上，这要补就有点太多了，大致大致补一下，补用户带和内核带，什么意思，就是jdk的早期啊，我们我们今天的核心千万别忘了啊，今天我们核心是要讲synchronized的。

刚才只是拿cs开个way好，现在要讲清synchronized它的所升级过程，大家要了解用户态和内核态，这是什么意思，首先简单说作为操作系统来说，他能够做的一些操作是不允许普通程序做的，听懂了吗。

比如说我能够把硬盘给干掉好，我是不允许你普通程序干掉硬盘的，普通程序想干掉硬盘怎么办，必须通过操作系统申请，所以我们说为了保障操作系统的健壮性，现在的操作系统基本上都会把一些指令分成级别。

有些指令我可以直接访问，有些指令就是所有的指令我操作系统内核都可以直接访问，但是有些指令你作为用户空间的这样的一个进程，你是不能够去调用的，你要想调用，你得通过我来，你想访问网卡的内容。

想访问直接内存的内容，想访问显卡的内容，不好意思，你都得通过我操作系统来，那么这个呢就在逻辑上呢，把呃整个的这块内存的空间，或者叫内存的执行过程，或者叫程序的执行过程分成了两种状态，第一种呢叫内核态。

第二种叫用户态，内核态是执行在内核内核空间的这块呢，它能够访问所有的指令，而用户态的程序呢只能访问用户能够访问的指令呃，这种设计方式，操作系统在经过了一系列的升级采集的这种方式。

这种方式现在目前在硬件上是支持的，像英特尔的cpu，它本身就支持四种级别的分布，从ring 0级一直到ring 3级，linux内核工作在闰零级，它能够访问所有指令。

linux的用户空间的程序工作在ring 3级，某些直接的指令是不能访问的，这是大概的一个用户态和内核的概念啊。

来能够跟得上的，给老师扣个一，好我们继续，这个时候大家好好想一下，在jdk啊，最最开始的时候，synchronized也叫做重量级锁，重量级锁的概念是什么概念呢，重量级锁的概念就是注意对于操作系统来说。

这是我们操作系统，对操作系统内核来说，你jvm也仅仅是工作在我的用户台，好锁这个资源是要通过操作系统才能去申请到的，才能去申请到我这把锁这个lock。

ok所以原来的synchronized的叫做重量级锁，synchront一上锁上的什么锁呀，一上就是重量级jdk早期的时候1。1。01。1。2，他所谓的上中了。

你所的意思就是我jvm现在要对某一个资源加锁了，你要对这个资源加锁的时候，你得向操作系统申请一把锁，向操作系统申请，通过操作系统老大通过一个从用户态到内核态的一个调用系统，调用著名的0x80 。

阿里p9 问的问题，0x80 的执行过程，听懂了吗，好这个过程今天我来不及给你细讲再说，从这个m往os操申请的时候，是要经过一个中断的调用，那么也就是说我申请了这把锁之后，要把这锁返回去呢。

还需要从内核态返回到用户态，所以它叫重量级锁的原因就在于他申请这把锁的时候，都需要经过操作系统，老大都需要经过用户态到内核态的一个转换，现在synchront做了一些优化，这个优化呢就是在上锁的时候。

在某些状态之下，它是不需要向操作系统老大去申请，只需要在用户空间就可以解决问题，哈哈哈，今天我们要讲的就主要是这个升级过程，好了，刚刚讲完这小段能跟上的。

系列 3：P40：【多线程与高并发】Semaphore - 马士兵_马小雨 - BV1zh411H79h

好大家看这里啊，那个我们来聊这个sam这件事，sam呢叫信号量，sam for叫信号灯，灯塔是吧，信号灯这里面呢是有几盏sumer，你可以往里传一个数，这个数是promise，叫允许啊。

promise是要允许的数量，就是你可以想着有几有几盏信号灯啊，或者一个灯里面的闪着数字，到底允许几个来参考我这信号灯这个意思，那ser等于new ser，好看这里，太照顾每一个人啊，ok我们看这里啊。

这个simht是什么意思，有信号量，你远远的看着有个信号灯，那个灯亮着的时候，我就可以执行，不亮了，我就不能执行，大概就这么一个概念好，那怎么样才能执行，怎么样他不能执行呢，是这样来写，很简单。

sfs等于new sm for new thread，其其实我我我上次讲我记得的也得花了八个小时才把这个课给讲完，呃所以你说公开课一堂课顶三堂也不也也不太可能啊，哦看这里啊，而且真正理解透呢。

确实就得进行一些探讨，这个很正常啊，来s。acquire好，这个方法叫阻塞方法，阻塞方法意思就是说我如果快点不到的话，我就停在了，acquire的意思是什么呢，acquire意思叫得到取得。

英文取得的意思是，我认为这里写的一好，我取一下，快一下，它就会变成零，当变成零之后，别人是a qui不到的，对17年我也讲了八个小时呢，我们我们这次还讲了全加了很多内容。

所以不太可能能够说短时间内给大家讲完啊，大家理解好吧，奖金为主，后面你看视频的时候，你可以快快放两倍，三倍好看，这里啊s的快快的意思是你看啊，我们这个信号量上面写了个一好。

acquired的意思是我拿到这个一给它变成零，减个一变成零，这个呢是快。

ok然后呢继续执行执行执行执行执行直接完了之后。

注意看，当这个程序结束了之后，结束了之后呢，他就会县城结束，我在这里写，要写注意要release啊，s。release，我执行完该执行的，所以呢我把它release掉。

acquire的返回值，我看看是什么，是void，这里我写的稍微有点问题啊，应该是，finally啊，对不起，看到没啊，s。release release的意思是呢，诶他又从零又变回一了。

我从一元变回零了，表示我得到了，然后呢从零变回一了，表示你其他人可以继续得到了，大家看两个线程，现在我只有两个线程，第一个线程，第二个线程两个t1 t2 t一得到了，那么t2 就得不到p2 。

人物得到必须得等t一执行完了，这个就是acquire的含义，t20 t2 了，必须提一般的t一呢嗯弄完了t2 才能执行，所以这也是一种锁，这锁的意思呢就是看你在这里promise写了多少个，你要写两个。

这俩就可以同时执行，看这里这俩同时执行代表着就t running，中间可能会打印t2 running，我们来看一眼，你看啊t一软件t20 。

t一软件t2 杠0k所以samer的含义我想大家伙一看就明白了，sample含义是干什么吃的呀，这个自己能呃总结出来吗，sf行业干不干事了，限流哎这个是限流，这个才是限流是吧。

就最多的时候我最多允许你多少个线程同时在运行，就这么个概念，所以sam for你可以用哪种地方呢，哎可以用在，比如说我们卖票，我们最多开五个窗口，那你这三个号就写五，只有五个三个孔。

就是同时在买票的人只能有五个，好了，所以这是sm的一个概念，好我现在看大家的问题啊，我觉得待会儿提的问题挺好玩的，我都不知道你们是从哪想到的，这个是做限流啊，aqua从哪里获得，现场是有队列吗。

听我说aqua，那快乐的意思是获得这把锁，大哥，我可能我我我我不记得我说过从从哪获得县城大哥是这个县城，要想继续往下执行，这个县城到这儿了，要想继续往下执行，你必须得从sam for里面获得一个许可。

他一共有五个许可用到零了，这个时候你就得给我等着，你可千万别说获得某个县城acquire得到的嗯，明课不要说清楚，没有这个概念，千万别混了啊，那那你如果说那个比如说new fixed特别to。

一是感觉差不多，new fixed thread pool，好认真听，这个线程池里面永远就只有几个，你写new fixed threp，二呢就只有两个线程，但是summer呢说的是。

我有100个线程同时运行的，同时运行的只能有两个，听懂我意思了吗，雨落同学给点反馈啊，你fixed frap，你线程池线程只有一，你你固定的就只有那么几个，sam是来控制。

可以有好多个线程同时acquire，但是同时acquire到的就只有两个，也就是只有两个线程在同时运行，诶这个地儿这我为什么在这个地方很容易卡住啊，那个谁还没给我反馈呢，这这个这个这个刚才问的语录嗯。

啊线程数不一样，那跟那跟fix有什么关系啊，跟fix的说的作用是一样的，为什么总有这样，他线程池是往里现成线程池里面扔进几个县城去，要执行什么，要不要同步，那是另外的事情。

这个我们讲的是要现成同步的是这几个线程，你可以有一堆的线程池，然后这几个线程里头可以同时有多少个执行，你肯定是哪哪哪哪卡着呢啊这是完完全全没有半毛钱关系的事情啊，看这里，这是机动车道，八条车道。

但是很不幸的是，前面有一个收费站，只有两个，好八条车道，八个县城或者甚至更多的车都可以同时往这冲，不好意思，到这儿，谁acquire得到其中某一个谁执行限流。

但是你这八条车道里面的线程扔到线程池里没问题啊，没问题啊，理解意思吗，嗯，所以这里的限流呢非常类似于呃车道和收费站好吧，也不管车道和收费站啊，或者是买票什么的，都都是一个概念啊，嗯semer公平好。

我们来说这个公平的是跟表面上很像啊，跟表面也没有关系，肯定是拿卡着呢，语义上完全不一样，那就是个线程池，你往里头扔线程用的不涉及到同步的概念，那县城里边要不要同步是两回事，这个是要做同步。

是线程之间呢要进行互相之间的控制和访问，要进行同步是两回事啊，千万别混一起，你尤其是跟面试官聊的时候，你要这么聊的，聊的话，面试官直接那鄙视的小眼神就开始看你了啊，好关于sam for，看这里。

you new sf，注意看下面有第二个promise，可以12号bin，这里呢是有一个fire还是呃公平还是不公平的，默认是非公平，纯处公平，但是公平这事我说过了，还是那句话，是有一堆堆列在那等着。

是大家伙过来排队，如果我们用刚才这个例子来来举例子的话，我也想啊，刚才就是车车道和收费站这件事来给大家举例子啊，其实上呢是这样一种情况，就是现在假如说我们有四辆车都在等着进一个车道啊。

好后面又来一辆新的的时候，他不会抄到前面去，这叫公平，他也必须在屁股后面排着，这叫公平，听懂了吧，就这意思啊，哇居然可以什么什么什么可以s x，你在说什么，所以说内部是有队列的嘛，对内部是有队列的。

不仅内部是有队列的，这里面用到的所有东西，我今天讲的所有的从头到尾，retrock condolcelebra，fire，rylock summer，后面我要讲的exchanger都是用同一个队列。

就是同一个类来实现的，这个类呢叫a q s啊，啊我们后面讲原理的时候再来聊好不好，fire extends sink，sink，他从谁记仇，看到了吗。

就这个类abstract cute super iz，这个里面维护了一个队列，这个队列呢叫first in first out的先进先出的队列，它实际上叫c s c r h队列。

我们讲原理的时候再来聊好吧，我们先来看怎么用，你们先学会怎么用，再来聊原理，不会用的时候可不跟你聊原理啊，所以所有的东西啊你先学会怎么用，你就理解哦，里面是有一个队列没错。

当然各位同学现在已经感受到了有队列，但这个队列是怎么实现的呢，就就通过通过它来实现a q s。

系列 3：P41：【多线程与高并发】Exchanger - 马士兵_马小雨 - BV1zh411H79h

告诉你没法使用公屏，看到这里你自己好好想一下啊，这有什么疑问，能不能探讨这里呢，我定义了一个exchanger。

exchanger叫交换器是吧，就是俩人互相之间交换和数据用的，那怎么交换呢，看这里我第一个县城，第一个线程内部有一个成员变量叫s，它的名字，它的十个字符串类型叫t一好，接下来呢我把这s的值等于什么呢。

让exchange exchange s哇塞好好绕啊。

exchange exchange s好。

第二个呢也是它的名字叫t2 ，仍然呢把它这个值呢也是exchange exchange s。

大家知道啊，我这个t一的线程。

t一这个线程它里面的s名字叫t1 ，这个是没问题的。

对吧好，第二个线程，它里面这个s的名字叫t2 。

当我们经过了一系列的交换之后呢，然后我们最后在打印最后这个s的时候。

打印出来诶，你会发现呢这这俩哥们儿交换了一下。

嘿嘿t2 t1 t2 里面变成t一了。

t一变成t2 了。

线程间通信的方式非常多，这只是其中一种啊，就是线程之间交换数据用的，而且这交换数据呢是exchange exchange，它背后呢还有一点cyclic，barrier的概念啊，什么意思，我们怎么理解。

就这个最好这个啊，首先呢我们有一个exchanger。

你可以把它想象成是一个容器，这个容器呢。

可以有两个值，可以有有有有有有两个格，给大家的批评画吧，我们来聊这个exchanger的概念啊，x exchanger，好两个线程啊，这是第一个线程，在第二个线程需要注意的是。

我们两个线程的都调用了exchange exchange方法，注意这个exchange exchange方法是阻塞的，这是我们的exchange，在这里面呢有两个啊，一个，两个位置。

两个两个位置注意看好，第一个，第一个线程执行到exchanger exchange的时候，这是第一个线程执行到这句话的时候，阻塞我再说一下阻塞exchange exchange方法啊。

exchange的时候阻塞，但是需要注意的是，我这个方法呢是往里头扔了一个值，对不对，这个值会传哪去呢，你可以认为这里的我们的t扔到这儿了，从这注意它阻塞了，然后第二个线程开始执行，他也执行到这句话了。

exchange了，也执行到这句话的时候，ok他把自己的这个值t2 扔到这，接下来这俩哥们儿之间交换一下，里边儿，好俩哥们之间交换一下啊，他们两个之间互相交换一个值，这个t2 扔给t1 。

这个t一扔给t2 ，两个线程继续往前跑，好理解了吗，我们先说先不先不提后面的问题，先说我刚才讲的概念有没有什么问题的，没问题吧，这是exchanger的概念啊。

好听我说exchanger只能是两线程之间，所以你刚才提的三个线程，不知道三个线程怎么交换，不清楚三个线程你只能自己同步，如果只有t一执行exchange，t2 不执行，会怎么样，阻塞呀，刚才不说嘛。

阻塞等着吧，什么时候有一个线程过来在上面执行，执行了第二个exchange，他两个就交换了，就这么简单，而且我想问你的是，你三个线程交换是什么意思，怎么交换，是a给b还是a给c，还是c给a还是c给b。

你得规则的定义还是a给了b b再给csb，再给c，c给d，所以你不能张嘴就来啊，说这三个线程怎么交换，三个线程本身就没有交换这个概念，他们只能两两交换这东西啊，只能两两进行，没听说过三个在那交换的。

系列 3：P42：【多线程与高并发】第四天课前复习和课程规划 - 马士兵_马小雨 - BV1zh411H79h

好大家看这里啊，前面三节课呢我们是聊了这些内容了，就现成的基本的概念，这就不多说了，非常简单呃，我重点讲了synchronized，这个synchronized，你看啊，在这个面试题里头呢，他就已经。

问到了好几次可以这么说啊，你找找看这个synchronized呢。

问到好几个词，sunonized reaction。

lock的底层实现和重录的底层原理是吧。

synchronized的升级。

我看在哪里，啊又又问symphonized reaction lock的一同。

synchronized的升级用太多了，找不着了。

嗯锁的四种状态，他们有没有那个新生代合金子，锁的四种状态和升级过程，这个就是所升级的概念，所升级的概念呢在secret我已经给大家讲过了，他所谓的我讲的是三种状态，反正他是所谓四种状态呢。

其中有一种就叫无所，这个synchronized端上来之后，要锁定某个对象的时候，首先是一个无锁的状态，没有锁，ok然后呢接下来是偏向左，就是这个只有一个线程去占有这把锁的时，候，这把锁呢就是啊。

我说我在脑脑袋上有两位来记录啊，这是一把偏向锁，只给了一个线程，用接下来升级成为轻量级锁，所以它中间呢有一个所升级的过程，这个synchronnet所升级的过程，从今年看。

这些一线互联网的大厂已经开始猛问了，还有volatile，那我讲过这些问题了啊，然后volatile呢也问的特别多，关于a volatile呢，问得最深的呢其实是这道问题。

volatile的最深的问题是volatile的具体实现。

没想到他会问这样的问题。

voluntel的具体实现。

还有看这里这个问这是问的最顺利的问题，叫volt的，大家我跟大家聊过，这个可见性和指令重排序，这是窝窝头的作用，那么他问的是呢到底怎么实现的啊，这是美团问的，这比较这就比较讨厌了，呃。

因为这个问题呢我是在讲这个gmm的时候，才会给大家说这个问题啊，呃j m m ja memory model，就是咱们现在是上文断成高并发，我会讲到这个问题，所以现在呢你答不出来也正常。

这个是怎么实现的，一个是缓存一致性协议啊，msi对真真的说了，那么禁止指令重排序呢，主要是添加内存屏障，添加内存屏障，内存屏障呢一共有呃四各就各种组合，在你的写入和读存取之前添加内存屏障。

禁止它质量重排序，就干这个使的，这我们讲到gm的时候再来说这个问题，反正总而言之一句话，现在问的是越来越底层，越来越深入，所以大家呢做好心理准备，好好的努力啊，不过大家也不用担心呃。

课程讲到咱们这种深度的也不多，只要你使劲的把这个课程消化掉，我相信你还是能在面试之中的脱颖而出呃，atomic这我就讲了，讲了几个就a atomic integer，atomic long。

还有呢long adder，啊以及这个嗯at tell me alone啊，就加srt的各种各样的对比，然后呢我们聊了这个j u c的同步锁，lock，condolege，sally，barrier。

fer，right，right log，这部分我没有讲，但是我看到有的他在面试题里头，居然开始问这个了啊，stem log给大家留一作业，你回去查一下这个stem lock。

stem log是rrolog的一个升级态，比realloc能稍微的还要控制的更好一些，sam信号量用来限流的exchanger，两个线程用来交换数据的呃，我回去之后翻了一下，因为因为多线程和高并发呢。

我需要查好多好多资料，然后呢，把各种书上的内容给大家综合到一起，不小心落了一个lock support，一会儿，今天我们先把这个补上啊，log ort，那么我们回到这道面试题吧。

schnet和reaction lock到底有什么不同啊，synchronized和reaction log有什么不同，回想一下sychronized research log，人不懂的，自动解锁。

reach logo需要我们手动加锁，手动解锁，religion logo可以出现各种各样的condition，那这condition代表什么呢，condition代表的就是你不同的等待队列。

srt是做不到这一点的，ok底层的直线呢ranch logo呢是cs的实现，那么synchronized呢它默认进行了四种的锁，这个锁的状态的升级，这就不太一样好，我们今天讲什么内容。

我们今天呢第一个呢讲这个log sp，把遗留的这个lost ort讲给大家听，这个也比较简单，第二个呢我们由于我们学了这些个所的呃，基础的技巧之后呢，我们来看看，看两道面试题，我给大家讲两道面试题。

接下来我会给大家讲那些所这一集，这里面所有的锁基本retry，locon lecelebra，对我就不念了，总而言之，里面所有的锁除了logo之外，locbd相对底层，其他的这些锁都是基于谁来实现的呢。

都是基于aq s来实现，今天我教大家怎么样去阅读这里面的源码，重点呢教大家源码的阅读技巧，源码呢层出不穷，生生不息，掌握了源码的阅读技巧，大家培养起来对原阅读源码的兴趣，之后，好多代码呢你需要自己去抠。

抠出来啊，才可以才是你自己的啊。

系列 3：P43：【多线程与高并发】LockSupport - 马士兵_马小雨 - BV1zh411H79h

我们要讲的内容啊，嗯，第一个呢我们先讲这个lock po，咱们上演一些小程序的，后面我们加一个小程序，就是log support，呃这个lox support呢，其实非非常简单的一个用法来测试代码。

比如说我们来一个程序嗯，没有thread，cr给它一个定义，threat t等于new thread，在这个县城里面，写一个小小的循环，for i i等于零，i小于十吧，i加加，然后呢s out i。

这个非常简单啊，嗯unit第二second，不小心放大了，一个数字出来，我们定义了这样一个线程啊，然后呢呃我们来让这个线程启动，t0 start，那么大家可以想一下呢，老外打印啊，我们来看一眼，跑一下。

012341直打印到九啊，然后就不演示完了，这个小程序非常的简单呃，现在呢现在以前的时候吧，我们就是说很难控制说指定某一个线程，某一个具体的线程啊，让他阻塞和停止，但现在是可以了。

现在可以的原因是什么呢，是因为呢在jdk一点一点几之后啊，这个你自己去查logs，它添加了这样的一个api，这个app叫做log ort，看这里循环的时候这样来写打印i啊，if i如果说等于五的话。

等于五的时候，like support their park，park是什么意思，park是停车的意思，locked support所的支持，其实从这个角度上来讲呢，这个类呢是专门为了实现所支持的支持。

怎么去实现锁的这么一个类，但是我们可以直接拿来用，love support park，park的意思是停车，当前线程停止等于五的时候就直接停止了，看这里跑一下，01345好，打印完了。

你看到了整个县城就停止了，阻塞了，停在这儿了，那好那我们怎么让这个线程继续运行呢，继续运行，我们让线程继续运行的话呢，我在主线程里让它继续运行，专用机运行，啊这样来写啊，我在主线程。

second the sleep，我是让它睡八秒钟吧，在主线成八秒钟之后，我才给他解开，after eight seconds，那现在已经是八秒钟之后了，他才会打印出这句话来，打完这句话之后呢，t点。

unpark，unpark的意思，哎哥们儿，你别在那儿停着了，这个县城您别在那停着了，请你继续往前运行吧，来看一下这个小程序的执行结果，01345好五停，这时候主线程呢在那等着八秒钟了。

after 8秒钟，6789，立即续往下运行，所以log ort的给我们实现了什么功能呢，我们总结一下，log ort们实现的功能是当前线程阻塞，而且你回想一下，同学们。

在我们没讲loco locp之前，我们让当前线程阻塞，我们一般怎么做，还记得吗，回想一下，对你得加在某宝锁上，对风吹的同学说的非常对啊，他说用了weight或者await，不管用哪个都没有关系。

但是这个呢你是必须得有一把锁的，得加在某一把锁上，你比如说你想用weight的话，你是不是得用synchronized的给夹子，夹子夹在某宝锁上才可以锁定某个对象，才可以，log ort是不需要的。

log ort想停，想什么时候停，就什么时候停，而且如果说你呃原来像原来啊，我们要想叫醒一个县城的话，叫醒一个线程的话呢，我们得用notify，ok叫醒一个线程的时候呢，我们要用notify。

而且叫醒一个线程的时候，实际上这个线程呢，是往往是放在一个等待队列里的，你要叫醒某个指定的线程是非常费劲的，但是logs pop不一样，log ort有了之后，我们要叫醒某个指定的线程。

直接写t就可以叫醒这个线程啊，t这个线程还有一个，还有一个我们完全可以干嘛呢。

我给大家做个实验。

大家看这里，我在t。start之前啊，看这里，t。look support，点on park，唉这就比较好玩了，我先让他不停车，然后我再让它启动跑一下，看看效果，他本来正常到五这里啊。

他应该是停住的是吧，on park to the start，托尼由于还没有启动啊，ok你看到效果了啊，看到什么效果了呢，你会发现你看啊，分析一下我们这个小程序的执行过程啊，这小程序呢呃是这样的。

我们有一个呃t这个线程，t这个线程呢，他本来12345~5的时候，预期应该是停在这儿了，对不对，然后呢执行的时候是这样来执行的，这t线程已经开始执行了，与此同时啊，注意这句话。

实际上是和t线程同时开始执行的，我这么好，大家应该能理解吧，因为这是我们的主线程test data了之后，这句话已经看已经已经执行了，on park已经开始执行了。

也就是说on pk这件事是在这儿执行的，可是这时候替这个县城停车了吗，没停啊，他到五才停，对不对，你上来之后先不让他停，这说明一个什么问题呢，说明on park可以先与帕克调用，我再说一遍。

on park你可以在park之前调用，回想我们一下以前的，我们能在weight前面调notify吗，他还没有weight呢，你notify起作用吗，起不了，你必须得先wait了掉。

notify才起作用，但是park和on park不一样，on park呢是上来你可以先调，先调了，就代表什么，先调了，代表这个县城里面的某个状态改变了，说我已经给你放行了，即便是你后面要停车的时候。

你也停不住了，为什么，因为我on park里头告诉你了，你不用再停车了，你停车也没用，所以这两个呢，你可以认为on park给它变成了一，park给变成了零，我上来的时候先变成一了。

你帕克呢你发现变成一了，你也就别继续往前运行了，你直接变成零顺，直接直接往前走就行了，等于我这两个已经帮派，已经把你这次派克给你取消了，就这个意思，所以它的用法上要比synchronized要比。

系列 3：P44：【多线程与高并发】面试题一(1)_volatile - 马士兵_马小雨 - BV1zh411H79h

好我们聊了这个log ort之后呢，我们再来看一道面试题，就是我们刚才这道这道面试题啊，曾经的一道面试题呃，实际上一个容器提供两个方法，at和size写两个线程，线程一到十添加到元素之中啊。

线程二呢实现，元素的个数，当个数到五个的时候写成二，给出提示运结束嗯，这道题呢是还是两个线程之间互相通信的问题。

这是我在公开课上讲过几次，那个1a2 b3 c4 d的那个问题啊，没有听过也没有关系，我后面还会讲，实际上这两个呢是呃线程两个线程之间通信的问题，提供两个方法啊，at和si，然后两个线程之间通信。

第一个线程完成到某个位置的时候，要通知第二个线程好，呃时间关系我就不在现在的时间让大家去思考了啊，这样我直接来讲，我们先来看第一种写法，第一种写法呢我添加了两个这个这个这个两两个方法，两方非常简单。

然后写了一个t01 without volt，我用一个内部的list等于new一个array list，用这个来做我们的内部的这个容器，然后我写了一个a的方法添加，我直接调用了list的at方法。

非常简单，然后呃size方法到底加了多少个了，就直接调用了list的size方法。

一个a一个size没了啊，就这就这么两个，所以这两个方法就完成了。

在两个方法完成的基础之上，我们说写两个线程，第一个呢是从一到十往里头加元素，第二个监监控着啊，什么时候呢，他到第五个了，数到第五个的时候，你这个就马上爆出来说，哎哥们儿，你到第五个了，一边加一边监测。

一边加一边监测好看，这里大家呢你先读一下这个小程序，看看在这种方式下呢，他能不能够得到想要的结果，这种方式什么方式，你看这里，我首先扭了一下我这个容器，嗯，就不多说了，然后呢我起了一个新的线程。

这个第一个线程，第一个线程完成什么功能了吗，i等于零，a小于十，i加加，往里头加object加一个a wallet，打印ai加了第几个了。

启动了，第二线程我就在这监测的嘛，所谓的监测不就是说我跟那盯着吗，well to跟着不停地盯着，什么时候它的size等于五的时候，让他break，好同学们，你们分析一下第一这个能不能完成第二这个类呢。

呃就这种写法有没有什么问题，给大家30秒钟吧，a realist不是线程安全的吧，journe，你想一想看是不是健康安全的，哈哈哈，不是啊，我先告诉你结论，a realized不是线程安全的。

好看这里啊，我们来分析一下这个第一个能不能实现，能不能实现这件事，我们跑一下就知道跑一下，先，零一正常应该是加到五，诶你会发现是不行的，发现是不行的是吧，这是不可以的啊，而且程序停停住了不动了。

那么这是为什么，第一个它是不行的，我们看到了第一个这个小程序本身是有问题的，你们分析一下会有什么问题啊，同学们，从同步的角度去分析，这个小程序写上去的话，会不会有什么样的问题，来同学们直接给我敲。

你们仔细分析一下，我要求的是你当加加到第五个元素的时候，你这里判断的是c的size等于5k同学们，那我想问你他有没有可能cx等于4=6的时候啊，有很有可能就变成呃他就做做了一个错呃，错误的输出。

为什么你们想一想，因为a release本身啊，它这个size你加进去之后，你分析一下啊，呃一个object加到这个a release之后啊，加去之后它这个size呢是加完了之后size更新一下，加加。

这是肯定的，他这个肯定是这样实现的，那好如果当你的元素加进去之后，还没有size，还没有加加的时候，好，第二个线程来读了，这个时候他读到这个size的值就和你实际当中加入元素的值就不一致了。

好同学们能理解这个意思吧，所以这件事本身是不对的啊，所以这里头有两个毛病，这个程序第一个呢是你没有加同步，第二个为什么它会停止不了，停止不了的原因很简单，因为你在这while true的时候呢。

这个size等于我永远没有检测到，永远没有检测到的原因是什么，永远没有检测到的原因是你还记得吗，县城之间不可见的问题，是因为你的这个c的size里边的这个size的值线程之间呢，你第一个线程变了的话。

第二个线程之间，第二个线程并不会马上看见，那怎么解决这个问题呢，怎么解决这个问题啊，非常的奇怪这件事啊，你你认真看好，我讲到现在有没有同学理解不了的，能理解同学给老师扣一，有问题你直接提啊。

因为我后面要讲的问题呢比较怪异，然后我自己现在也没有答案，在这个基础之上，大家了解了之后啊，你认真听，那同学们可能会会想说，老师这件事还不简单吗，那正常的情况下，你给他加一个volatile。

县城之间就可见了嘛，对不对，我相信很多同学是是这样的想法好，所以我在第二个程序里头呢，其实和第一个程序完全一样，和第一个程序完全一样，只是呢把这个类似前面加了volati，其他都没有变，没有做任何变化。

我们再跑车线，ok t2 结束789嗯，结束了，ok没问题，这事儿呢就这么奇怪的解决了，当然我再说一遍，其实如果说你要想把同步这件事要做好的话，你得把i的方法加上什么呀，synchronized。

把size方法加上，synchronized，整个list得谁加上synchronized啊，呃这样这样这样说不对啊，sorry你得你得用用什么容器呢，用同步容器，后面我们讲到同步容器的时候再说。

就是你的这个size加对象和size的更新必须得是同步的，什么意思，听我说这个小程序还是有点小bug的，这个bug就是我刚才说的，当你添加一个对象过去的时候，你的size还没有更新的时候。

如果有第二个线程来读，会读到不一致的问题，你都加到五个了，但是你的size还没有更新到五，这里他读的时候呢就只能读到四，因为我们读的是size的值，所以你要想写的比较完善的话呢，应该是这样来写的啊。

重新写一下，嗯collections are synchronized the list，new link list，或者是另一个a realist，这个随意得是这样来写，我们先来看看我这写的没问题。

确认一下啊，这样就呃就真真正正的实现了呃，第一个呢你是保持可见，第二个呢你是那个保持啊，他们之间的同步同步不会出问题，ok当然这个是后面我要讲的同步容器，这里头是有必要用synchrise的啊。

咱们你你们好好分析一下好吧，有问题呢，一会再探讨好，咱们回到刚才这个问题，回到刚才这个问题啊，你看我写了这个volatile之后呢，他就莫名其妙的解决了，可是这件事本身是很奇怪的啊，我是想了半天的。

也没有想到他呃，这问题呢到底出在哪儿啊，这个java呢就实现啊，偶然偶然性对，不睡就不行是吧啊，睡了一嗯对，有可能是这样的问题啊，这首歌大家好，你记住了，这里是有问题的啊，认真听尤拉特呢，我前面讲过。

这个vt我们修饰的内容呢是要这块内容产生了变化之后，你what属于一个int类型的值啊，i等于五把这个值改改变了之后啊，另外一个现成的你才能够看得到这个值，但是我们这里moletely修饰的是什么。

实际上是修饰的是个引用，我们现在改的内容是什么，是在引用里面的这个值啊，引用里面这个纸是改了这部分内容，但是这个引用的值本身没有变，所以严格来讲你改的这个值你加了这个vlotl之后，应该也不起任何作用。

可是非常奇怪的点就在于这里，就是那个你在这加了blet tel之后啊，然后上一个程序里不加好，他就不行，现在加了blet跳他就行了，挺奇怪的，非常奇怪。

张扬说不奇怪，因为睡了一没错啊，你说的非常对啊。

把这睡了一去掉，可能就不会有这问题了，但是即便是睡了一两个程序完全不一样，加了voluntel嗯，他就睡了一之后，他只我们只能说就是睡了一的期间，他保证给你写回去了，只能是这么来解释啊。

来我们把这个睡衣给去掉了，只能是这么来解释，所以你有时候睡衣和不睡衣这件事是呃很很重要的，好吧，当然我们把这个不睡衣去掉之后，把睡衣去掉之后，你就会发现了，ok还是有问题，这里还是有问题啊。

所以你看这是这么写的，是还是实现不了的，c等于3=5 break，没办法啊，这是实现不了啊，那我们原本说我加这个行不行啊，这样写行不行，跑一下，你看到还是不行，绝对不行啊，反正总而言之呢。

关键是在于睡衣这个地方如果不睡衣的话就肯定不行，我要处大于等于五，你大于等于五，这件事就不对了，老夏同学，我们是在精确等于五的时候让他观察到，可是你大于等于五，你等于6=7。

等于八的时候再观察到就没有意义了，所以现在这么写不行，这个方法呢呃大家能理解了吧，对sx你问的很对啊，我这个事儿呢就只能解释为就是time unit。

睡觉的期间。

他就会去就这里的这里这里去读的时候。

他就能够去读一下里边的内容啊，我不说了嘛，就这件事我想了半天也没想太明白，他内部到底是是怎么实现这个机制啊。

我只能说hobt实现它应该是这样的，在另外一个县城睡觉的期间。

那么呃这个这个这个别的线程呢，另外一个线程睡觉的期间。

它会在这个期间把内容给写回去，这怎么解释，嗯不太好解释好吧，我跟大家说这个问题了啊，总而言之，总而言之啊得出的结论我网上也查了很多的资料，大家伙儿得出的最后的结论就是这样的。

volatile这件事如果你没有把握就不要用，这是第一，这是第一，除了面试的时候，在你真正开始写程序的volatile这件事没有把握就不要用，第一件呢volatile尽量的修饰简单的纸，越简单越好。

你不要去修饰引用值，引用值呢从前面我给大家讲的时候，就已经咱们那个程序我不知道大家还记不记得在程序里头啊。

就给大家讲了，你volatile呢只是关注的是什么内容呢，那个引用的内容引用指向那个对象里边的内容改变了。

它是观察不到的，好吧，val修饰的是一个引用对象，这个引用对象指向的是另外弄出来一个对象，如果这个对象里面的值，它的成员变量值改变了，你是观察不到的，记着一点结论啊。

所以这两种写法呢其实都是实现不了的。

那有同学说就没有办法了吗，当然可以啊，不可能没有办法，我们可以用wait note翻吗，你等于五的时候我就直接给你wait了，不让你不让你动了，不就完了嘛。

系列 3：P45：【多线程与高并发】面试题一(2)_wait,notify - 马士兵_马小雨 - BV1zh411H79h

看看这里啊，我们看第三种写法啊，就这种写法先读一下，先读还是先读，加了一个list，这加不加vd都无所谓了，大家看这里，这里呢我用了锁的方式，fal object lock等于new object。

第一个线程，synchronized lock，加锁，加锁之后启动，启动完了之后，如果size等于五的时候，你不是在这循环吗，如果说size等于五的时候，lock。weight，如果size不等于五啊。

sorry，这里先启动的是第二个线程，观察者那个县城啊，跟旁边观察着，如果size不等于五，我就wait这句话i意思是什么，你你你你你你，我们往里头往这个容器里头加内容啊，一个一个加。

刚开始呢这个第二个项链，就其中我在观察着，如果说你不等于五的时候，我就wait了，睡了在等待队列里睡着了，然后呢我是我保证先启动的是第二个线程。

保证先启动第二个线程，我启动第一个线程，第一个线程往里加，什么时候，size等于五的时候，我让lock。notify，哎，这件事情到底行不行，你分析一下，来先给大家30秒钟消化一下，刚才这个小程序啊。

给大家解释一下这个这个流程，就是我们还是这个容器，这个龙技能首先启动的是t2 观察者，现场在这儿观察着，上来之后一观察，这哥们还不等于五，不等于五，怎么办呢，我就wait了，等着了死，就是在这睡着了。

阻塞了，然后我启动第一个线程，第一个线程呢往里装，往里装，往里装，装到五的时候，如果再等于五的时候，我notify，我把你这根本给你叫醒，叫醒了你不就继续往下执行了吗，这件事总是可以的吧，好大家看这里。

wait完了之后把你叫醒，叫醒完了之后，你就应该继续往下执行打印这句话了，t2 结束，来分析一下啊，看看这件事行不行，我们先来跑一下，这样启动第二保证先启动了，t一启动0123456a还是不行。

一直等第一个线程加完了，第二个线程才结束，好分析一下为什么不行，县城还是不可见，真的是你你想你想多了，这个跟县城可见不可见就没有任何关系了，因为这里我们是用了synchronized的weight。

notify，啊对啊，不知道同学已经发现了，对你记住这一点啊，这个notify这东西，我们说这也是考经常考的一个重点，notify这东西是什么，不释放锁，好吧，不释放锁，不释放锁这件事就就比较恶心了。

你想想看，其实t2 ，这里呢我们想synchronized的执行的时候，你lock wait回来了之后，需要注意的是，你还这里头其实有一个隐藏的点，你wait完回来之后，必须要拿到这把锁，为了回来。

必须得拿到这把锁才能继续执行，可是很不幸的是，你虽然在这notify把人给叫醒了，叫醒没用，叫醒了，他也是在旁边等着，为啥呢，因为你本身这哥们儿你没释放锁，你只有打印完了，这把锁才释放释放了。

这哥们不是醒着呢吗，醒着呢一直在旁边等着这把锁呢，每次cpu调不到这个县城的时候，发现我要锁，我要锁，我要锁，结果要不着，他就只能在等着什么时候，等你第二线程执行完了，就是t一这个线程执行完了。

第二线能拿到这把锁才能继续执行，第二才能结束，这是weight notify的嗯，也是一种经典的用法，很多原来考，多线程的题啊，考的还是with notify，就必须要牢牢掌握。

好刚才这个小程序它的问题就出在这儿啊，我看不少同学开始提怎么解决了，没错解决是怎么解决啊，解决当然是这样来解决是吧，就是我第二个线都可以上来相位，他没有关系啊。

但需要注意的是呢，我的。

往里头啊加数据的这个线程啊，t一这个线程我让第二个等于五的时候，我让第二个线程notify，notify之后呢，我自己得去wait，我得让出这把锁来另外一个县城才能继续，好吧，来我们看看这个结果。

这就对了，天启动第一启动t一线程里头，如果再等于五的时候，它会wait叫醒t2 ，而且还会wait，所以t2 呢肯定是运行天已经结束之后，让出所t一继续运行，那我问大家一句，注意看。

其实我在t2 这个县城里，最后写了这句话，lock。notify，大家能不能理解，哈哈这句话不写会不会有什么问题，这优化不行，肯定是有问题的，t一就死在那了对吧，来问一下这个小程序的执行过程。

所以wait notify是必须你牢牢掌握的啊，with notif，这个执行的过程是这样的，首先上来还是那个容器，然后t2 上来呢，观察说这哥们儿不等于五吗，它不等于不等于u怎么办，它wait了。

他就在这停了，wait了，t一呢就往里装装装装装装装道路的时候，叫醒叫醒他，好叫醒他，完完了之后让自己去wait，一定自己得暂停停住，那么由于他自己wait了，所以他已经让出这把锁了，让出锁的情况下。

t2 继续运行，t2 t续运行会打印t2 结束，打印完t2 结束之后，注意你t一还在这里，wait，你起来继续运行，所以t一继续6789把后面的打印出来，然后t一结束，t2 结束，整个两个就全结束了。

好这是wait notify的写法，也是非常经典的写法，这就是为什么能体会成对出现就行，哈哈哈，不不不一定是不一定，在所有情况下都是需要成对出现的啊，好像一般都用notifall啊，jonas。

你好好用，好好想想，咱们这里为什么用notify，不用notifal or notifall，想想这道面试题，这是两个线程，只有两个线程，我一个县城在那跑着呢，notify的话也就通知另外一个县城。

不会有别的对吧，所以就就两个线程，当然你要是好多个线程，也就是我们后面这道面试题的时候，你就得用note all了，有没有和all是一样的，对没错，无非你你你就是那个杀鸡用牛刀呗。

本来你用单兵就可以解决的问题啊，你非得派一个团出去也可以，所以其实多线程的题麻烦就麻烦，在怎么写都可以，对你用notify就显得专业严谨一些，好了同学们，这是wait notify的写法。

以及它容易出现的问题，以及wait notify最核心的一点就是，notify它不会释放锁，而weight是可是会释放锁的，weight要回来继续执行的时候，还需要拿到锁才能继续执行。

系列 3：P46：【多线程与高并发】面试题一(3)_CountDownLatch - 马士兵_马小雨 - BV1zh411H79h

什么特别的废话，这次呢我们再用countdown lash，我们来试试，coundown lash，就学过了门栓吗，所以这件事也很简单，t2 上来之后先等着，如果不等于五，let await。

等着就行了，然后t一启动等于五的时候，let。come down搞定啊，就这么简单，当然这个lege的话是一从一降到零，就继续执行了，这句话可以吗，同学们分析一下来。

count down lash这个写法可以不可以告诉我一下，门栓这个，必须得先把前三节看完，所以你应该是有印象的，门栓是什么，就拴在这儿嘛，上面这里写了个一，什么时候这个一变成零了。

您这程序从这儿往下继续，好想想看这这个小程序，第一可以不可以，第二有没有什么问题，等一下我们先看，可以不可以，门窗会不会被击穿啊，你看它是可以的啊，这肯定是没问题的，嗯结束了，这个很正常是吧。

哎我加到这儿的时候，我把你打开门门栓，打开门栓之后，哥们儿你是不是就继续了吗对吧，你继续的话，你等于t2 结束了，这个很正常，没问题，同学们分析一下这个小程序会不会有问题，仔细看。

想想看会出会出现什么什么什么结果，跑一下，诶这个打印是打印在a m6 之后了，诶这是为什么呢，诶这是为什么，同学们分析一下啊，呵呵打印太快了，该加锁，对对你们说的非常对啊，其实都很简单。

就是t一这个线程呢，诶在这儿打到五的时候，确实把t2 这个门栓给他打开了，是打开了，可是t一马上蹭蹭蹭继续往下运行，可是呢现在呢t一是继续往下跑，很可能跑到六，跑到七，跑到八的时候。

t2 这个线程才打印出来对吧，所以严格来讲呢，这种门栓写的方式这么写是有问题的，那么大家分析一下，你们想想看，如果如果我非得用门栓的时候，然后还要求等于五的时候，必须让t2 先打印出来，你们该怎么做。

两只门栓啊，转的非常快，没错说的非常对，用两只门栓就对了，t一等于五的时候来个门栓给拴住await，然后t2 上来是先先先拴住的对吧，先把自己给拴住，然后提到有鼓的时候，背先把这个栓打开。

对这个栓什么时候打开呢，t2 完了之后把这个栓打开，所以come down lash，用两个就可以了啊，两只没栓没问题，这写法留都留的作业吧，不难你自己写好吧啊这个很这个很难吗，这个写法聊做作业好不好。

你们自己写，和两对notifine是一个道理，是的哎大家伙学了比较麻烦的方法，之后来我们来看看比较简单的方法好吧，来看比较简单方法啊，这个方法呢就贼简单贼简单了，一讲你就知道第二个线程上来，二话不说。

c size不等于五吗，把自己park阻塞主，然后，第一个线程什么时候再等于五了，on p解散，看懂这意思了吧，这样写可以不可以呢，走你lock support用起来是最简单的，但是到底行不行呢。

好睡一秒的时候没问题对吧，但是我们把这睡一秒给去掉，走你，对这个门栓是一样的，ok搞定不行了，到4t2 就结束了对吧，啊set size等于五pk嗯，诶这个是对的结果，诶这个好奇怪。

这个为什么永远运行都是对的啊，这次不对了，终于不对了，吓我一跳，我以为这个永远都是对的，t2 结束到最后，这其实和门栓刚才的问题是一样的，那么大家想一下。

如果我非得用lox support这件事该怎么做，分析一下，同学们两个唉又得两个了，没错，又得两个，为什么又得两个呢，你们呃呃分析一下啊，就是说我的第一个县城到等于五的时候，我得在这里写什么。

写locks support the park，把自己park住，必须等第二个线程，在第二个线程打印完之后，再让他on park，start，ok，我突然想了一下这个小问题，要写起来还是有点复杂的。

lock park，你必须得保证t2 线之行啊，这个这个事非常重要，就是说必须保证t2 先执行上来先park，然后在结束了之后呃，大家写一下这个问题吧，这个问题还是有必要给大家写一下啊。

我们我们我们写一下啊，我们重重新再起一个程序啊，ctrl c ctrl v，零七多线程的问题就是这么的麻烦，lox support without sleep，不睡啊，不睡的版本。

不睡的版本应该怎么写呢。

我我我讲起来比较简单，但突然间我想起来，这个写的话呢也没那么简单呃，第一个呢首先定义t2 ctrl c呃。

第二个呢sorry不是ctrl c and ctrl c。

这个，停车x第一个呢首先是第1t2 啊，第二个呢我们定义t1 thread，t一等于ctrl v new thread，然后这里面没有说名字叫t1 ，然后呢，下面这个睡眠就不要了。

tr start t一点start，如果写的比较完善的话，那得是这样来写的啊，这个t2 结束了之后呢，用luckport第二on park t1 ，先得定义提，t2 t1 ，现在把t一定在前面去啊。

lock support t1 on park t2 ，还得，嗯现在呢它是t201 在前面提到的，你必须得必须得提前定义啊，这些得先声明德瑞t1 ，必须得先声明啊，不然他不认识啊，等于空，等于空。

先声明啊，不然你在这个正在表达式里头，他不认识，可能lamba的should be final，这lamba表达式里面的，必须得是final和那个effective final的，小东西写起来。

好了不废话了，它定义到外就行了啊，lock support on park t一呃，log support on park t2 t2 结束，on park t13 等于五的时候。

lost supported the park，本质上和weight notifine是一样的，我们先跑一下，看看他能不能够运行正常，嗯t2 结束看上去是正常的，但是其实里面还是有小毛病小问题。

现在呢应该是问题不大，你就运行多少次呢，天启动t2 结束啊，就不管怎么样呢，运用多少次呢，应该它都是在这个四后面打印t2 的结果，这应该是没问题的，但是现在呢其实还是有一些小问题，问题出在哪儿呢。

我们一会儿来分析，因为我写的比较快，我担心有同学呢可能没跟上，我们先来读一下这个小程序啊，突然间想起来想给大家写一下这个小程序，看这里，就是说我们在t一添加元素的线程里头呢。

等于五的时候我on park t2 ，为什么，因为t2 的上来就pk了吗，把自己给park了，上来呢就把自己给pass了，所以我上来之后呢，把t2 给打开，让它继续运行。

接下来呢这个呃log sport的park让让自己停阻塞，然后在t2 里面上来之后，把自己先park呃，接下来呢在我打印完结束之后，再把t一给打开，所以t一呢不会说穿透，继续的循环的往下打印了。

所以这个最后的结果呢一定是对的，最后结果一定是对的啊，呃那么，现在的问题是啊，如果这么写的话，会不会有问题，我们来分析一下会不会有问题，你能遇到这儿的时候啊，这么写好应该是对的，这样就没问题了啊。

总之认真思考啊，好好好的好好好好，就得多线程程序，都得仔仔细细的去去判断啊，我刚才认为有问题的原因呢，是因为我觉得有可能提前运行，t2 没来得及park呢，t就先运行完了啊。

其实t2 呢会在这里park的park掉，所以不会不会有问题啊，sorry，这是我的问题啊，所以这个这么写啊，应该就没有什么问题了，结果是对的，那么刚才碎碎念呢他提了一个问题。

他说t2 的if判断是不需要的吧，第二个碎碎念的问题是，这个说if size不等于五，这句话实际上是不用写的，上来之后你只要先把自己pk就可以了，同学们，你们分析一下。

如果这个c的size不等于五不写的话，到底行不行，分析一下，同学们就上来之后，你二话不说把自己park，我认为是有问题的，应该是不行的，这个原因是在什么地方呢，其实原因你想一下啊，嗯上来先park啊。

我考虑一下，上来先park，如果上面等于五的时候，on park，然后把自己park，上来先帕克，怕自己诶，好像是可以的啊，这个碎碎念对碎碎念好像说对上来，二话不说，把自己先pk，应该是可以，呃是的啊。

没错没错啊，这三点说的对，sorry，这个log ort pk直接pk不用判断，应该是可以呃，主要的原因是因为t一呢无论如何，在c。3=5的时候，它自己会爬不掉，所以这件事这件事是最重要的。

这个事是最重要的，呃只要有这句话在的话，那么t2 来说呢，上来之后自己先pop就可以，二话不说，你先停住，什么时候等于五了，什么时候等于五的时候，才会让你继续往下运行，你才会打印t2 结束。

然后再安排个t1 ，没问题啊，说的非常对，谢谢你嗯，确实没有问题啊，这是我们多探讨啊，好多多线程的程序就得多探讨啊，october是t一不怕t，一不怕g就不行了，t一不pk是不可以的，就不行了。

因为你t一不帕克的话呢，嗯你很可能t2 都已经执行到六七的时候，就是t一已经输出到六七，六七个元素的时候。

系列 3：P47：【多线程与高并发】面试题一(4)_Semaphore,其他思路 - 马士兵_马小雨 - BV1zh411H79h

说的有道理啊，这个sx提供了提供了很好的思路来写一下我们new javloss t08 ，我使用三个法。

变成c，当然必须得保证t2 先t一先和快而道。

the volt add thread t，172，这个有道理啊，我觉得sam确实有可能实现，062321，这不出无所谓了，然后t1 ，t一启动，i小于五的时候，第，i s b a quire。

呃快完了之后呢。

我们，打印，2=2小于五加加at的in等于no 5呃，在这个时候呢，我们the release release完了之后。

release完了之后，t2 呢得取个快。

点快，最后the release，然后继续，s点快，但中间必须得您什么意思啊，也不是很完善，也不是很完善，这里release完了之后呢，你不能够保证是t2 的快速道。

而不是t一马上又要快到了s是吧。

所以还是有点有点小问题啊，那么那么呃ss的思路呢应该是以呃是一个思路啊，这是我们用semh sample里面promise是一的保证，就只有一个线程运行，这是肯定的。

然后呢呃t6 线程在跑的时候跑到第五个的时候，我上来先acquire，快到了之后跑到第五，第五个完了之后呢，我release掉，然后这个理想情况啊，现在是t2 本把他的快到了t2 ，快到了之后呢。

继续跑，跑完之后呢，诶t一呢继续在后面的五个数里头，从从六开始啊，后面的五五个数里头继续取个快，但是这是理想的情况，可是很不幸的是呢，呃当你释放的掉这个seer的时候，你不能给我下一次保证一块的时候。

是我的六继续还是第二集训，所以这个这个也也不好啊，你得你得你得呃先控制哪个线程先执行，那你要精确的控制好的话，或者是condole，所以还是不行啊，还是不行，legend啊。

legend也提了一个很好的想法啊，可以对嗯，大家伙还是很有想法啊，for对你们说的非常对啊，这个时候呢你看上面是小于等于五了对吧，这时候我应该是从五开始，从五开始小于十再继续输出，都快完了之后。

out，然后最后呢在sdr release对，贴点重哈对啊，这个legend和henry啊，这两位同学有点意思啊，t1 t一上t1 john可以，没错啊，这个可以啊，这个这个应该肯定是可以的啊，对不起。

不是让t转，而是让t2 转一啊，所以这是第一，拉克尔天结束嗯，这个理想呢，当然现在的小程序还是有问题啊，好看这里啊，这个，这个嗯还是稍微的有点小问题还是有问题好，我们先说这个就join的这个方法啊。

还是用这个permits summer为一，第一个线程打印到四的时候释放三个符，释放为零，然后另外t2 这个线程理想情况他会拿到，刚才我们说有可能我们这个t一积蓄，但是呢我们现在是在中间调用了join。

调用join会代表什么，会把t2 这个线程等着t2 线程结束完了之后才会继续往下运行，所以加的这个t2 john也是非常好的，理想的情况，没问题啊，现在是非常理想的情况，但是很不幸的是。

还有一个还有一个问题，我们说上来不是t1 ，并不是t一先拿到的，这个sam for，而是t2 先拿到了上来，他就acquire，acquire，完了之后直接就结束了，然后release了。

同学们是不是又不对了，哈哈哈嗯好，你们发挥自由发挥吧，好不好，你们自由发挥啊，多线程呢就是大家自己多写写，多探索，探索新的思路，好多题呢解起来，由于各种各样的，咱们现在各种各样的所学的比较多。

各种各样的写法层出不穷，可以说嗯你们自由发挥好吧，又提了个思路啊，说不用锁t2 ，在t一里边start，然后在t2 join t2 ，在t一里边start，哈哈有点意思啊，但思路越来越开阔了。

呃这个意思是他的意思是说呢，您这t2 啊，您也别控制了，我t一来控制你的t2 ，然后来join可以这可以啊，可以大家听懂了吗，就是您在这提二start啊，star的都tr join，这肯定没问题啊。

很好啊，你开脱了老师的思路，也我现在真没想过可以这么写，wait，这是，非常gbk convert，编码的问题啊，嗯嗯可以，当然这里如果换另外一道题就不可以了，这道题留给大家，你们也下去思考好不好。

这道题留给大家思考，这道题的要求呢是要求你两个县还是两个线程，依然是两个线程，但这两个线程呢我要求你顺序打印一个线程，是打印a一直到z，a一直到z，然后呢另外一个线程是打印一一直到26 两个线程。

但是我要求你交叉打印，什么意思呢，就a打印完了打一一，打印完了打b a1 b2 a n d4 ，听懂这意思吧，啊大家一起造了个火箭对，这也是两个线程，但是这个线程你用sam for就不太好写了。

就像刚才那样啊，你就不能用join了，因为你因为我们刚才所谓的用这个join，是因为我们t2 线程就干一件事，而且结束就不干了，但是你现在在这种情况下，用join是用不了的，所以大家发挥你们的想象力。

随便你们怎么写，看看能不能写完。

系列 3：P48：【多线程与高并发】面试题二(1)_synchronized - 马士兵_马小雨 - BV1zh411H79h

我们看第二道面试题。

第二道面试题呢是写一个固定容量的同容器，put get方法，get count方法，支持两个生产者线程，十个消费者线程的阻塞调用，这就是非常经典的呃，生产者消费者问题就是大家伙呢有一个固定的容器。

这里边可能就一个框了啊，最多装十个馒头，有两个生产馒头的人，包装包装就往里扔，什么时候满了，他们应该阻塞住停住，而另外有十个消费者线程，从里头往外吃馒头，什么时候吃空了，他们应该停住，就不要再往里。

不要再吃了，这个意思。

这道题link link list等于你一个link list呃。

我写了自己的一个container啊，这container是支持泛型的。

max等于十，最多十个元素同步容器吗，synchronized的put while list size等于max。

不是我是直接给了答案是吧。

对直接给了答案啊，这个没有办法了。

没有时间让大家伙自己思考了，所以就直接给答案呃，我们想一下往里头扔的时候，所以这个容器来说，往里扔的时候会怎么写，往里扔的时候呢，你必须得判断，如果说它等于最大值了，说明已经扔满了嘛。

扔满了你就得wait了，停住当前线程，停住diy o然后如果说没满，那你就往里加，加完了之后呢，加加count计算一下这个count的值啊，往往里头啊递增一通知消费者线程npo，让消费者线程进行消费啊。

这里头put的写法。

那get的写法呢依然是synchronized，如果说他size等于零了，说明什么，说明你已经取空了吗，取空了你就得wait，接下来remove first，取掉我们第一个，如果没，如果里边还有。

我们就拿掉，拿掉一个com减减好，通知生产者线程进行生产。

这个容器我们就写完了，其实这个写起来非常的简单，我建议大家呢把这种写法背过再说一遍，你2号别说把这种写法背过，直接略过就完了，当然你要有把握，现场能写出来也可以啊，其实也也不难，比较简单。

这是同步容器的写法，那么同步容器为什么叫同步容器，是因为它可以支持多线程往里装，多线程往外拿，为什么在这里面我们要思考几个，为什么第一个我为什么要加synchronized，同学们自己自己思考一下。

为什么，为什么要分析一下，同这个其实就是这句话的问题，加加count，因为我们往我们往里头扔了三个馒头，三个馒头扔到三个馒头，你还没来得及把这个count往上加的时候，这时候count还是二的时候。

如果你没有加synchronnet，另外一个线程独到的值很可能是二，它并不是三，所以最后结果就会出问题，所以这个理解起来非常简单啊，这里往里扔的时候是必须要加srt。

等到同理啊，往外拿的时候也必须要加sncnet，原因是什么呢，原因是我这数还没来得及剪呢，我这个东西已经拿走了，拿走的时候你remove first了吗，已经拿走了，拿走完之后。

我这count值还没来得及剪呢，如果这个时候又来了新的线程往里加还是会出问题，因为他上来之后会先判断这个count值等不等于max，如果这时候正好满了，全部都是满的。

我remove the first拿走了一个了，可是我还没有来得及把这count值减了，目前count还是max这个值，那我新的线程是不是就加不进来啊，本来你有一个空位了，我还是加不进来，不隐加不进来。

我看着加加看的还会出问题。

系列 3：P49：【多线程与高并发】面试题二(2)_CAS - 马士兵_马小雨 - BV1zh411H79h

s的写法，啊s说这个问题用处就和take是最方便的，你这不是废话吗，人家现在要你自己去实现阻塞队列的，put和take，你现在要用另外一个阻塞队列的put和take，那你这题解下来不就没有意义了。

要求你的，不就是自己实现阻塞的put和take吗，我现在是用的synchronized，是用的锁，但是呢我们想想看，实际上是可以用c a s的这个cs怎么用，你们你们能想到吗，同学们，cs怎么用啊。

在put之前上来先读出来这count，你分析一下啊，put之前先来先读这个count，比如说这count等于五，破完了之后呢，这个count要加加的，对不对。

count加加的时候是用c a s来加cs的，期望值是一个五，更新值是一个六，只要你这个现有的这个值是期望的，这个五说明我在中间往里装的过程之中，没有任何一个线程打打断过他。

所以呢你就把五变成六就可以了，我大概说了一下，这写法大家能理解吗，对当然这里面还涉及到aba问题，这就有点有点复杂了，你自己写的话会巨麻烦啊。

ok ok。

对嗯好了不多说了啊。

ok我们现在来看这个嗯。

222个生产者线程啊，两个生产者线程往里扔啊，这等于零，这小于25，不断的往里扔。

两个县城一共有50个是吧，然后消费者线程的i等零啊。

起了五个，并没有起十个，无所谓，都一样的不断的往外get，然后生产者线程的不断的往里push。

在线程里头呢，我们就不再需要加锁解锁了，为什么呢，因为我put和get方法，这两个都已经是同步的方法了，所以你应该会看到秩序井然的啊，往里装往外拿，往里装往外拿。

producer啊，p0 p1 p0 p一啊。

就往外拿的这个过程，ok，有点小瑕疵，好像嗯。

好这个生产者消费者的最简单的一种写法。

大家能够理解，同学啊，你给老师扣一，然后呢，你思考一个问题，为什么这里用while，为什么不能用if思考，思考一下，sx说有瑕疵是吧，嗯有瑕疵指出来哪里，好像这里为什么我们先来聊这个，为什么不能用呃。

if，你你如果用if的话，如果用if这句话是不行的，因为你this。weight了之后，当你list的size等于max，你已经wait了对吧，然后被你被叫醒了之后，你不会再判断它是不是还等于max。

你就会继续往下运行，如果你用if的话，所以假如你被叫醒了之后，另外一个县城又往里装了一个，他实际上还是已经满了，可是你二话不说就会往里装，然后还加加抗的，所以就会出问题，因此必须用while。

必须用while，你醒了之后也得再回来判断一遍。

哎哥们儿，你是不是还是满着的，当然同理啊，那部分呢你判断是不是还是说啊被空着的。

ok，当然这里头有一个小瑕疵是什么呢，我们先说刚才这小程序啊，这第一个小程序能够消化的同学，你给老师扣一啊，在这个基础之上，我们才能来讲第二个，这个没问题是吧，好我们来聊第二个问题。

第二个问题是我们用的是no tic all motif，or，这件事就会叫醒等待着的所有县城，那么大家都知道我这个synchronized的一家，就只有一个县城在这里跑，其他的县城你都得给我wait。

不管你有多少个县城，wait的时候，这里面是有量啊，生产者的线程和消费者的线程，所有的都在这个位置队列里，我一旦note for all空机全部叫起来，这些县城就开始争抢这把锁，抢到的仍然只有一个。

可是如果说我们比如说啊，我们是生产者的线程，生产满了，满了之后呢，我们叫醒消费者线程，可是很不幸的是，能他同样呢也会叫醒另外一个生产者先生，假如这个这个生产者上来，拿到了刚才的猎把锁。

刚才第一个生产者释放的猎把锁，拿到了之后呢，他又喂他一遍，对不对，mate完了之后呢才会又叫醒，那那其就是其他的舰长，你才去争抢这把锁，所以其实从这个意义上来讲呢，如果你是生产者的线程wait的。

你是没有必要去叫醒别的生产者的，我能不能够叫醒指定的，只是叫醒消费者。

而不叫醒生产者。

就是生产者线程只负责叫醒消费者，而消费者线程只负责叫醒生产者。

如果想达到这样一个程度的话。

用另外一种写法，这个写法呢叫做condition，condition，看下面这种写法，这个写法我就不再用sonnet。

我用的是reaction look，人for logo，我们说和super的最大区别，其实在这个面试题里就已经体现出来了，we rolook，它可以有两种condition条件。

producer等于new condition，consumer等于new condition，在我们put的时候，是我们的生产者，现场生产者，look，最后unlock不多说，一旦满了之后。

我是producer，await，就是我是producer，这种情况下我阻塞了，然后我叫醒的时候只叫醒consumer。

而另外这个消费者线程呢，消费者线程是我一旦空了，我是consumer await，然后我只叫醒的是producer啊，没叫醒别的，所以这个condition的含义，它能够精确地指定哪些先程被教训哪些。

而不是哪个。

好那是人听，那consumer和producer的本质是什么呢。

就是说lock condition的本质是什么呢，如果说啊只不过我们说producer啊，awaight什么consumer，await，你可能理解不了，其实认真听这个本质非常的简单。

依然是热巴松在synchronized the weight，notify的时候，它只有一个等待队列，如果我new condition了之后，它就变成了多个等待队列，听清楚我再说一遍，肯定是的。

本质就是等待队列个数，我们直达本质，这是那把锁，原来只有一个等待队列，现在我new了两个condition，一个叫producer，好，一个等待队列出来了，这个等待队列叫producer。

另外一个叫consumer，这个等待队列叫consumer，当我们调用producer weight的时候，指的是这个县城进入producer这个队列等待，指的是这个线程进入consumer的这个县城。

这个对这个队列里等待，那我要指定叫醒的时候，我就producer的时候，我就只叫醒consumer这个队列里的，而consumer呢只叫醒producer这个队列里的。

所以condition的本质就是不同的等待队列啊。

系列 3：P5：【多线程】对象的内存布局（大厂必问题） - 马士兵_马小雨 - BV1zh411H79h

到现在为止我们补了两个内容，那么下面呢是用汇编语言解释的，怎么样用对对对对，系统调用，通过通过用户态指向内核态的一个系统调用啊，这个今天呢我们就不单独的去专门讲它了，因为这里面牵扯到的内容呢又非常多了。

呃vip小伙伴通过老师讲的java成员应该掌握的底层知识啊，那里面讲专门讲了这部分内容啊，嗯听我说今天补了两个内容了，第一个呢是cs，第二是用户在内核态再补一个，必须再补完一个。

你才能够深入了解synchronize，真的没那么容易，再补一个啊，继续补，再补一个什么呢，补一个mark word，ok大家看这里，嗯现在很多大厂都会问这个问题，你了不了解一个对象的内存布局。

一个对象的内存布局，好什么叫做对象的内存布局，就是当我们new一个对象出来的时候，它在内存里头到底是怎么分布的，需要向大家交代的是什么呢，呃new出一个对象来之后，这个对象在内存中怎么分布这件事。

听我说这个东西是跟特定的j vm虚拟机实现有关系的，我们今天讲的主要是hobt实现啊，主要是hob时间，其他的别的虚拟机，人家有可能不是这种事情，这是很正常的，好吧，今天主要讲的hosp实验。

hosport在内存之中new出一个对象来，它是这么来布局的，认真听尿出这个对象来之后，比如说我们有一个类class t里边有一个小的成员变量叫m int类型，它等于几无所谓，当我们new一个t对象。

new出来之后，放到内存里，放到堆内存里，它是一种什么样的类型的布局呢，首先上面八个字节的mark word这个词你给我背过就行了，这个词直接背过好吧，这个词儿叫mark word。

如果你非得翻译成中文还不好听，叫标记字不好听，你直接背过，一共有八个字节，它是mark word，在默认的情况下，四个字节的class pointer，四个字节的类型指针类型。

指针的意思是这个指针通过它可以找到我们t。class这个类，也就是说我这个对象是属于哪个类的，通过哪儿去找，是哪个类的对象，通过哪儿去找呢，通过这个class pointer去找到它。

第二个class好，接下来是它的成员变量，instant data，成员变量，刚才我们说的是一个int类型，int类型占几个字，几个字节呀，四个字节，所以这里又有四个字节，好，我们继续还有吗，还有。

如果说一个对象啊，一个对象在hot ball里面实现，它要求这个对象八字节对齐，八字节对齐这些东西你要理解，八字节对齐的意思就是这个对象大小务必是八的整数倍，字节数啊，字节数不必是八的整数倍。

那看我们现在这个对象，我们现在的对象是8+4+4，一共等于16，是八的整数倍吗，是所以后面没有了，假如说我前面正好是个12，而不是16，那这时候怎么办呢，后面对齐四个字典。

四字姐给加上一共补到能够被八整，能够被八整除为止，所以我们稍微回顾一下我刚才讲的这个小知识点，这个小知识点说的是什么呢，说的是当一个对象new出来的时候，它由四部分构成。

第一个mark word一共是八字减，第二个class pointer，默认是开启压缩的，压缩之后是四字节，instant data，这个里面是多少，这事呢得看你的对象里面有多少成员变量。

那如果一个long类型，这里面呢又是一个八字节，8+8加就等于20 20，不能被八整除怎么办，后面再补四个字节，这四个字节是空的，好了刚才我讲的这小段知识能跟得上的，给老师扣个一。

方法你要问出这个话题来，说明你根本就不了解方法是个什么东东，好了，方法叫做放在虚方法表里，那个是另外一个视线啊，别问那么多，你先跟吧啊，今天晚上能消化掉就不错，ok那讲到现在为止。

我们用一个工具来证明它，这个工具呢叫java object layout，能证明这件事的工具特别多，java的agent h s d b那种工具，最最方便的就是这个这个是什么呢。

叫java object layout，这个工具是来源于open jdk，open jdk提供了这个工具，所以你在你的程序，你的程序里面加这个maven就可以了啊，把maven依赖加上就ok。

比较简单好看，这里。

我看我这个加没加加了。

改个名字啊，respectory name改成叫，零四hello j o l reflection，呃来我们看这个小程序啊，来我们看这小程序呃。

这个小程序呢给大家说明了一下这个j l l l这东西到底该怎么用，这东西用起来相当简单。

大家看这里，下面先把这个代码输掉呃，我们先来看这个代码，这两行代码就足以说明问题了，object o等于new object，然后我们把这个object进行一个分析，怎么分析的呢。

用的是gl工具里面的一个类，class lout，这个类有静态方法叫pass instance，把这个o进行一个分析，分析完之后呢，转换成为可以打印的字符串类型，然后我把它打印出来，就这么简单，跑一下。

跑一下看结果，看到结果你就理解了，我们用了一个非常普通的object，好大家看这里，这里拿到的就是object这个内存，它在它在内存里面的一个布局，显得显示不是很全诶。

往这边拖一拖。

还是不是很全啊，一会我给你拖拖拖过去看吧，我们来看这个内存的布局，看看是不是我们讲的那个四个内容，大家看这里这个内存打印出来之后是什么情况呢，从零字节开始往后数四个字节，又从四个字节开始。

又往后数四个字节，所以呢每一行都是四个字节，这里一共是八个字节，这里呢它称之为object header，object header有两部分，第一部分呢叫mark word。

所以这里是mark word，从第八个字节开始，右数四个字节，这四个字节是什么呢，这四个字节是class pointer，所以你看到的这个值它指向的那个通过它能够找到object，第二class。

因为我们用的是object，由于前面三个加起来是12，不能被八整除，所以后面又有一个对齐四个字节，lost due to the next object alignment对象的对齐。

所以整个对象呢它的大小是多少个呢，是16个字节，ok大体能看懂的同学来给老师扣个一，这块没问题是吧，好当我们理解了这件事之后。

下面呢我们来看看看什么呢，有同学说老师您是讲synchronized的大哥啊，class data去哪儿了，大哥这不叫class data，这叫instance d，你new了一个object了。

object里面有instant data吗，没有啊，所以他去哪了，他没有的东西，你问我去哪了，明镜本非静菩提议非台本来无一物，何处染尘埃，没有的东西，你问我去哪儿，我能知道吗，滑向了虚无。

每当我遥望广袤的宇宙，我的心总是滑向虚无，回来回来啊，搞反了好，大家看这里，但是不要忘了我们讲的是synchronized，synchronized什么，我们来比较一下，看看synchronized的。

如果是synchronized的，他到底是做了一件什么事，往这看，symphonized o表示锁定这个对象，锁定它，锁定他之后，我再对这个对象进行布局的输出，为了让大家看清楚啊，算了就这么走就行了。

好，看一下做个比较。

好好比较一下，看看上下两个对象有什么区别，比较一下，我看不知道哪国文字的小同学来说，为什么布局输出是四个字节一段显示的，人家喜欢，发现了吗，这一行和这一行是不一样的。

当然如果随着后面的srt越来越复杂的时候，跟你说是前面两行都是不一样的，前面两行是什么东东来着，还记得吗，前面两行叫做mark word，mark word这东西ok在这里你就会发现了。

原来我们所谓的上锁给对象上锁指的是一件什么事呢，在hobo里面的实现就是修改mark word。

所以所信息它被记录在了mark word里面，好讲到这里，我们得出一个结论，关于mark word这个东西，它里面记录了非常重要的信息，最重要的信息就是锁，synchronized。

ok能跟得上同学来给老师扣个一，当然如果我们说的更加详细一些呢，关于这个mark word里面还记录了什么呢，还记录了什么呢，还记录了hash code，这些个都有好吧。

如果大家伙想弄清楚一个mac word里面它到底详细的记录了什么，大家找到hot spot源码mark o o p。hp p文件我已经给他摘下来了，摘出来，好。

啊再来找出来mark op的hp在这个文件里面不需要看它的仔细的实现，去看它的注释就可以，注释呢分成两种形式，一种是32位，一种是64位的，64位的，直接看64位就可以，好吧嗯。

64位我们现在讲的都是64位啊，在64位里面一个mark word里面，你会发现他详细的记录了这么多信息，我勒个去太多了好。

那这些信息到底是什么呢。

老师已经帮你总结出来了，32位的往上一堆。

64位的网上还没有，目前只有老师这张图是最新的，所以是不是要抓下来啊，更新一下我的笔记。

讲vip的时候，那会儿呢讲的是32位的啊。

系列 3：P50：【多线程与高并发】读源码的方法 - 马士兵_马小雨 - BV1zh411H79h

多多讲一些内容，好这节课我们要讲的。

我继续往下讲的内容是什么呢，是要讲我带大家来了解这个retry lock啊。

到底它是怎么实现的，我们来看看它的源码层面是怎么实现的，同时我也教大家一下源码这个东西，你该怎么样去阅读好，大家已经了解过reaction lock了，其实比较简单了，就是reaction lock。

lock等于new一个reaction log，然后lock。lock，爱加加lock，点unlock搞定枷锁解锁，中间不给别人反应的机会，那现在的问题是，我想知道这个洛到底怎么实现的。

我想这个叫unlo到底怎么实现的，还有一个我想知道的是。

康down lash内部怎么实现，clic barrier内部怎么实现。

就是这些所有的这些新的所有里头，他到底内部都是怎么实现的呢，sama four内部又是怎么实现的，我勒个去太多了是吧，各种内部对，没办法啊，现在问问全部都问到源码级别。

那么怎么办呀，我们就去读嘛，读源码嘛，好，既然见识到读源码这个问题，原本这件事第一件，第一个事情呢是大家要承认一点，就是读原版很难很困难，好我们要承认一点的是，其实读别人的源码很困难。

困难的原因是什么呢，困难的原因其实是，你必须要理解别人的思路，大家知道你理解自己思路，或者理解跟你类似的人的思路，这件事是比较容易的，想想法都是一样的，我们俩都是住在农村，从小在小河边光屁股长大。

我们聊那个河边的那些柳树的问题，聊那些小虫子的问题，他一聊我就能理解，可是很不幸的是，那边是一白富美，天天住在天宫，每天都用各种的口红是吧，从来我们都没有用过的，所以他一聊这个色号的时候。

我就跟他聊不到一起去了，现在写程序的这些人就像住在天宫的人，而你就是那小小河边光屁股，那小孩儿你想理解他的思路，先让你的思维达到他那个高度，再说理解别人的思路，听我说读源码啊，不管你是读什么源码。

现在基本上，第一个要有一定的数据结构基础，你比如说那个priority q的问到的，别人11111句话就能说出来啊，这是一个最小堆啊，就堆排序嘛，堆排序里头就是小顶堆，一句话就搞定了。

可是你如果不了解这个数据结构，从来没有读过，你要去直接读那个priority源码，得你读半天，你也理解不了他到底什么意思，所以第一个呢要有一定的数据结构的基础，当然数学我刚才也看了。

我一直在给大家备这方面的课，如果你没这方面基础的话呢，也尝试着去读一下，简单的都没有都没关系，读源码，不要想着每一句话啊，他为什么在这里是爱家家是吧，哎为什么他不是那个就i加一是啊，为什么不是加减啊。

这这个取得例子稍微有问题啊，对不起，这为什么这个边界这里啊n的时候要减一，为什么要减一，为什么要加以边界，这里的处理你不要读这么细，没有意义，读源码最贵重的读懂思路就可以了，所以同学们，读源码的时候。

尝试去理解别人的思路，不要去追到那个特别特别细的，说每个地儿该怎么和什么要建，因为什么要减一，当然有一些结构性的东西，现在你看这个面试题的时候，你会发现他开始问啊，为什么要用这个因子来扩展。

为什么从八的时候变红黑数，从六又变又变回到列表，所以你要读的时候，还必须得大的这种层面上的东西，还得还得要进行思考，第二个呢要有设计模式的基础，大家要去读spring的源码。

do my best is源码，读nt源码，读这些个框架源码的时候，他可能没有这么多的数据结构，这种算法方面的东西，但是呢它有很多设计方面的东西，所以设计模式这块儿务必要理解你，比如说我今天带大家。

尝试带大家去读一下这个a q s，当然我所谓的尝试是要教大家怎么去读，a q s这种方法，它是用了什么什么模式呢，你们了解吗，template method模板方法。

call back function，回调函数，这两个数都一回事，所以如果说你了解设计模式，我一句话你就理解了，你如果不了解设计模式，我讲半天你也理解不了，所以同学们，我既然讲到这里了。

没有学过设计模式的同学翻回头去，坦克第一版，好吧，这里边我讲了所有的设计码是23种，怎么运用的，都加进去了，规矩不，你如果说时间关系啊行，高效率的学习，也没有必要从头到尾的这么全，看完我们今天说了。

q是什么temply method的吧，先去看这个设计模式是吧，当我们用到了别的，再去看别的好嗯，嗯能理解的同学啊，你给老师扣一好吧，就第一件事呢读读源码其实是比较困难，需要你有一定的基础的啊。

没有打好基础，同学要回去打基础，kb是观察者模板方法也可以呃，你学到最后的时候呢，就是说你可以做到那种呃心中无剑，手中有剑这个境界的时候，你就会发现呢这些东西都是互通的了，所以呢也不用去纠结了就好不好。

这这这个概念这东西是人类发明出来，帮助大家理解问题的，你如果要是死抠概念这件事就不对了，能理解就好啊，这次细一般认为quack是template method的，叫做模板方法，就是你手中心中无剑啊。

手工特别贱的时候，好你的你的你的经济就达到了，哈哈开个玩笑啊，好我们先来聊阅源码的阅读的原则，原版阅读原则是什么呢，以前有同学读源码这么来读，二话不说，我反正拿到那个源码之后，哇。

200多个文件全部一一字排开，打开开始读，得记着这个原则，就跑不起来，不读跑不起来的源码，一般你不要去看，他看也看不懂，很难看懂，叫事倍功半，跑不起来的原码，你不要去读，它读起来太费劲。

什么时候这个源码必须得能跑起来，跑起来有什么好处呢，跑起来的好处就是，你完全可以用debug 11条线的跟进去，举个例子，比方说这个look，我们如果说他没跑起来。

你只是静态的来读源码的话，怎么读呢，你就得这么来读。

and control lock好，你看到了啊，哦原来这个lock里调用了squire一好，那你就去读think到底是个什么东西，然后你发现think啊原来是一个自己的内部类。

好，这个sync在哪定义的呢，我在这儿定义的哦，它的父类是谁，absolute abstract cute synchroniza q s嗯。

你就读到了回去你继续读这个呃。

快一到底是什么概念，点进去你就会发现它跳到哪去了呢。

哦，amistra cute schronizer，这里面调用了trial choir，读起来非常的爽，点进去，你发现当你读到try acquire的时候，当你读到初二快二的时候，你读不下去了。

为什么呢，这哥们儿throw了一个exception出来，ok你还怎么读。

你没法读了是吧，但是如果这这个东西能跑起来就不一样，我刚才在讲的比较快，同学们能够能够理解吗，有没有什么有问题的地方，就是我刚才说的，就是如果说你他跑不起来的情况下，你读跑不起就行了，跑不起。

请问你读的话会读出什么问题来，就读着读着你读断了就断了，已经读不下去了，能理解的同学们，能理解的同学给老师扣一啊，ok那有同学说你你跑起来了，就不会读不下去吗，是的，当你能跑起来之后，我们在这里设断点。

点上去射好断点，这个断点射上去之后，我们用debug来跟踪，这得你们看不见我这菜单在这儿吧。

debug，debug跟踪的时候呢，好我们这个断点就设好了啊。

设好断点之后，我们跟进去跟到这个lock方法里边去。

first step into，跟进去之后你会发现哦。

原来它调用了acquire，没关系，我们再跟进去好，他调用了try也快了，没关系，我们再跟进去，当我们跟进到这个try acquire的时候，你会发现它不再去throw new。

那个什么exception吗，他在这里是已经有返回值了，return他是另外一个方法，为什么会这样，为什么会这样。

同学吗，为什么我没跑起来的时候，我读到穿了快乐的时候，我竟然读到了一个另外的一个方法，然后我跟起来的时候跟弄到了第二个方法，为什么，思考一下，在再回头看一眼啊，现在我读了trip的时候。

我现在跟踪到的是reaction lock。

里面的try快方法对吧。

但是如果我用静态的方法来读的话，look点进去，acquire，点进去，try require点进去得，我跟踪到的是abstracute，sychronizer的这一块方块，里边抛出的是异常。

我没法往下读了，没错是由于多态的存在，这里我们读到的是父类的一个实现，而真正运行的时候。

是跑的子类的一个具体的实现，try a quire analyze，analyze，这个和那个eclipse稍微有点不太一样诶。

有人the floor stries dependencies吗。

好pro这辆车。

啊不是，这是怎么找到他的。

那个他所有的子类的方法。

怎么找到它所有的子类的方法。

这里是吧，对你看到这个车二块呢，它实际上有一堆的这个子类的实现啊。

这个子类的实现里头呢它有好多，它到底运行的是哪个呢。

其实你根本，你要是通过这种静态的方法去读，累死你啊。

嗯ctrl t是吧，你点到类名上啊，不多说了，先不说这个，就说你得看他那些子类的视线，你看那些子类实现的时候，你不跑起来，你根本就不知道它运跑的是哪个，子类的视线。

所以这第一条原则我们就确定了，这是我给大家总结的第一条原则，就跑不起来，不读，好同学们能理解这个问题了吗，这第一条原则就跑不起来不读，能理解同学给老师扣一啊，一般的情况下跑不起来不读，但是特殊情况下呢。

读一下也没什么关系，尤其是读那个读那个新的，这种这种源码框架的时候，这个框架你要跑不起来，不要去读它没有意义，还有一种情况呢是你接受了一个，别人已经改过右手的代码，这事儿咱们同学不止一次的用到过。

我的学生不止一次的用这个遇到过，然后在这种情况下怎么办呢，跑不起来你就别去堵他了，如果代码跑不起来，你读起来没有任何意义，第一步先让他想想方设法让他跑起来再说，第二个问题在你实际问解决问题的时候。

就解决问题就好，你读源码呢，我们现在是为了面试啊，其实在原来很多时候是为了解决问题，什么意思呢，如果你接手了一个别人改过六手的代码，现在呢呃你的老板说，这个代码里面有些问题。

麻烦你往里头加一些功能或者修改一下bug，你解决问题就好了，你不要从头到尾再去读这个改六手代码，你读会读的累死你，目的性要强，我们解决问题就好，读的时候要一条线索到底不要用面来读，大家知道啊。

我们一个程序跑起来之后，可能这个程序非常大，一个main方法里边有没有各种put get呀，size呀，各种各样的其他的方法，每一种方法你读进去，这个方法很可能去调别的方法，这个方法很可能去调别的方法。

每个方法你读进去，你不要去怎么读呢，大面上所有的方法先读一遍，然后再去里边找什么，里边哪个没看懂等等，不要这么读，要一条线索到底一条线索到底什么，就读一个方法，这个方法你调了哪个方法。

这个方法你又掉了哪个方法，这么来读进去，无关细节略过，有一些那种边界性的，什么n n n到底是是边界呀，还是n减一啊，还是n加一呀，在你读第一遍的时候，没必要的时候先把它略过。

所以这四条原则大家看看能不能理解，第四条原则，第一个呢就跑不起来不读，第二个叫解决问题就好，第三个叫一条线索到底，第四个叫无关细节略过。

系列 3：P51：【多线程与高并发】ReentrantLock源码 - 马士兵_马小雨 - BV1zh411H79h

好当你理解了这个原则问题之后呢，我们来试试看啊，即便是这样，我我可以告诉你啊，你读源码也会废死老鼻子劲，这事儿很正常啊，但是呢你只要开始读了，慢慢的你就会越读越顺，越读水平越高，阅读你就从小河边儿唉。

找到了天宫，各种死亡芭比粉，各种色号，你就开始认识了，ok啊我们来看看它的到底是怎么实现的呢，lock lock这个很简单，软件之log里面调用了log方法，好，这个mod方法它调用了谁呢。

调用了sink的快方法，同学们听我说，你读源码的时候，自己分析源码的时候，我建议大家呢一定要尝试呢自己去画图。

自己去画图，画什么图呢，画这种图，这种的其实叫甬甬道图，又按照图的一种甬道，你如果说现在还不了解ui妙图怎么画，没有关系啊，我这个是装插件是可以画的。

看看啊，三，你有，你有你有你有新的，我这里能不能换，mary sources new啊，看着我这是装这个插件的，叫plul法，你可以尝试着呢，一边呃用就画这个sequence图，随便写一个啊，test。

ok，我这是可以画这种图的啊，你呢要是不熟或者说没装这个插件的话呢，你就装一下装一下，试着画好玩玩，这个呢就是相当于，这个玩法我在这改吗，这个这个插件啊，我回头我再看看啊，看看怎么用。

相当于呢就是这个类里面调用哪个方法，这个类里面调用哪个方法啊，如果说你ul用的还不熟。

没有关系啊，你不一定非得用u m l，你只要能画清楚，让自己看清楚就ok好听，我说你画的时候一定要画画出来。

然后你慢慢的呢这个流程就理解了，就是我现在教你的呢，如果说每个代码我都带你去读一遍，这代码量太大了，我现在教你一些方法，就是你看到啊，我们这reaction log调用它log方法的时候，它会调用谁呢。

它会调用reaction look里面的这个acquire，谁的acquire啊，是think的acquire。

对不对，是think的acquire方法，这很容易理解啊，回到，put on your ma，回头我再教大家这个吧，原来教大家呢都是那个呃russian rose。

但russian rose呢那个那那那那个还是挺好用的，不过后来这个软件呢已经没了用，也有好多好多可以画的啊，但我我我下了一个这个呃idea里面自带的它的一个插件啊，据反应应该是挺好用的，我稍微看一看。

然后再教大家怎么用啊，好大家看这里，我们还是回到a q s源码的阅读上，我刚才说了，你看一个呢，你就画一个，现在大家看到了我的人生lock的lock方法，它调用了think的acquire方法。

那think用的是谁呢，这个think啊，我们去看一眼，还是得让它跑起来看才可以，好继续让它跑起来，第八个，跟进去好，我们点开这个think，这think是谁啊，你仔细看一下啊。

它是relock的一个内部类，叫non fire sink，nonfire sink。

非公平的think，非公平的同步器。

所以这个图我相信大家应该能看懂了，这个图呢实际上是这样的，在我们的logo方法里，它调用了我们内部的一个类，这个类类呢叫no fair s，这long farethink。

它里面有个方法叫acquire，它调用了这个方法叫acquire，一。

当你读到这里的时候，为什么要开始分支，你要知道这个sink是一个什么样的类，大概扫一眼，我说我要按顺着线读进去吗，大概扫一眼，然后呢你再看这个acquire方法里面，它内部又是怎么调用的。

好看这里这个think是谁呢，它是一个nonfire think，我们找到这个nonfire think，找到呃，non fire sink，and substract class sin呃。

nonfire sink，在这里啊，这个nfire think的父类是think是吧。

所以你再画一张图，画什么图呢。

画这个图，就是这个no fair think，它的父类是think，因为你看到这个父类里面这个子类里面方法的时候，他有可能用到父类的方法，所以你要去分类里读才可以，所以你这个图也要画好。

就nfl think他爹是谁呢，是think好，既然not fair think，他爹是think，我们再回到think同步器啊，这个里面你看他爹又是谁啊，think他爹是谁，a q s好。

这是我告诉你，这是所有的锁的核心eq就是不管是condoleslie，barrier semhy，还有reaction log，内部都是用它实现的，aq，看sx同学遇到的这些面试题啊。

这个a q s到底有多少a q a q s也找不着，不会吧，就，我，看这里啊，是吧哈，ok为什么说a q s底层是cs加volde，弹一下a q s吧，好吧还有没有，这就不知道了，好了。

所以反正百度呢至少是问了四次是吧，a q s，其他人问了吗，我看看美团没有问顺风了，好像也没有问了，京东里面，京东里面没有问，百度问的比较多，问a a q s啊，问了好长时间是吧。

所以这个a q s呢是比较重要啊，就是呃这些全学嘛，当然了，为什么为什么不学，我们目标是奔向一线互联网大厂，就算你进不了，你至少也要比其他人要强很多啊，必须得削，要不然不会给你讲这么这么这么深。

这么细吧，嗯数据库还挺多，数据库主要集中在索引，我们来谈到这个a a q s了，这个a q是核心，所以最后呢我们会这个图。

你们自己应该是能画出来的，没问题吧，没问题，同学给老师扣一啊，就是说这个图你之上是能画出来的嗯，然后呢我们继续，我们现在呢这个lock呢是调用了acquire 1，这个方法是谁的。

aq r一呢是not fair sink的扣一，not fair sin又是谁，他是sink的子类，think又是谁，think是a q s的子类。

所以调用了aq r一多少块一的时候，我们再跟进去，跟进去，你看这个aqua一这里调用的是谁呢，调用了a stratute synchronizer，好，这里已经调用了a q s的acque了。

你看这个ag是一吗，所以这个块一又调用了aq s的快一，而在a q s里面。

它调用的是什么呢，要用的是try acquire，如果没有锁上try acquire获得，如果没有锁上某个值好该怎么办，下面是一堆算法，我们先不看他的，先看这个，如果说没有锁上，没有锁上有什么意思。

他又调动了谁呢，再跟进去，你会发现这次调用的是n fire sink里面的try也快啊。

哎这事儿就比较好玩了，刚才我们读的时候，你已经知道a q s里面有一个try a choir，但是它里面是throw了一个exception。

所以这很容易理解是因为not fair think里面重写了这个try a try啊，所以acquire一里面，调用了我们的nonfire sink的try块，我讲到这儿，有没有同学有疑问的，有问题吗。

有位老师扣一没问题，sorry，sorry，没问题的，给老师扣一啊，有问题，那你直接提，所以当我们acquire的时候呢，这里它调用的是它的一个子类的穿越宽二一的一个实现，然后他父类也有一个实现。

但这个实现基本没用，因为他上来就是throw new exception，你你要是不重写它，它肯定是抛exception，所以什么叫做模板方法，你们现在能理解了吗，模板方法是我在父类里面有个方法。

就是这个出二块一，它调用了我此类的一些方法，但这些子类的方法没有实现，我调用了我自己的方法是先写好是吧，但是呢由于这些方法就是用来给子类重写实现的，所以我就像一个模板一样，我要打造一辆汽车，我要造底盘。

造发动机，造车身，最后组装好造底盘这件事儿子类去实现哪个车厂实现，哪个是哪个车厂的事，奥迪是奥迪的事儿，奥拓是奥拓的事儿，车身也是发动机，也是最后反正这个流程是一样的，就像一个模板一样的，模板是固定的。

可是里边的方法是由具体的子类去实现，这个就叫模板方法，当我们执行到这里的时候，就会调用具体子类实现的函数，所以叫钩子函数，就像一个小钩子一样，勾着谁呢，勾着子类的实现了叫call back方式。

好同学们，在这里不知道大家理解这个什么叫模板方法了没有，redemption，说就是堕胎，这不废话吗，所有的设计模式，基本上90%的设计模式全是堕胎，吃这个try acquire啊。

它是就是要求让子类去重写啊，在这里呢not fair thing呢就是重写了try块一。

当然我们再来去读这个方法的话，你会发现啊，这个吹二快一又调动了谁呢，调用了nonfire tracquire，我们再跟进去，none fire tracquire，好，这事儿就比较好玩了。

当我们读到这里的时候，就必须得了解a q s。

系列 3：P52：【多线程与高并发】AQS源码 - 马士兵_马小雨 - BV1zh411H79h

moon fire tracquire，非公平的去获得好，我们先说这个非公平这件事儿啊，什么叫非公平，什么叫公平，这里面要你自己去搞的话，就会时间比较多了，所以我讲给你听，第一个事呢，什么叫公平。

什么叫非公平，好大家知道，当我们获得一把锁的时候，有一些等待队列，如果说新来了一个县城，要获得这把锁的时候，先去检查，等待队列里面有没有人，如果有，他就在后面排队，这个叫公平，上来先排队，公平。

上来二话不说，我才不管你的队列里有没有人在等着，我上来就抢抢着，就算我的插队非公平，诶我突然发现刚才有同学提了个很触及灵魂的问题啊，这个同步队列和等待队列是不同的队列吧，吃完饭再说，你能提出这个问题了。

你的脑洞也够大的，说明你的基础真的是差到一定程度了，我估计你这面试题里边应该有90%到百分之百的不会哈哈，你认真听啊，这个同步队列呢指的是队列，然后里面实现了同步，就多线程可以安全地访问等待队列。

等待队列是指等这把锁所附带的这么一个队列，至于这个具体的实现是同步的还是不同步的，这件事呢是具体实现的事，它是两两种概念啊，这个锁的内部的，它这个队列的实现呢，由于是虚拟机内部。

具体实现了它的同步不同步，这事呢不知道不好说，所以不去管它，这是两个概念，这就好比说呃这个这个这个这个老婆和老婆饼是不同的东西吧，对它是不同的东西，因为它是不同的角度来看待的，开个玩笑啊。

等我们你如果还是不理解的话，等我们后面讲的同一队列再说好不好，ok，呃我我我我我来看这个刚才讲了同步和非同步的问题啊，就是公平和非公平的问题啊，sorry，讲到这儿的时候呢。

你会发现呢他开始去去涉及到什么源码了呢，涉及到这个源码了，认真看诶，程序呢在这你看啊，他说final thread current等于thread current thread，好。

得到当前线程非线程有关系了，int c等于get state诶，what这里突然出现一方法叫get state啊，没有关系，我们看这方法到底他是给我的debug跑哪儿去了。

你看这方法呢到底是在哪儿的这个方法啊，程序被我停掉了吗，啊重新给气死我了，你在这设个断点吧，啊没停掉啊，很好没停掉啊，我以为被我停掉了，好在这儿啊，我们继续往下，刚才我们是直接跟进去跟进去。

我们往下执行一步，step over，把这部执行过去好，当我们到达这句话的时候，c。get data的，我们再来看这个get方法的在在哪里跟进去，你会发现这guest day的方法又去哪了。

又去了a q s里面，所以在他的这个实践里头，你可以直接调父类已经实现的方法，get it，那我们这个dress state这个state又是个什么东东呢，这里头是理解a q s的关键。

这个state到底是个什么东东，按住ctrl键点过去，你会发现这个state就是一个volunteer int类型的数o，这里就牵扯到a q s的捷报了，aq s队列也可以称之为c rh对点。

这个结构到底有什么结构，他是c h c h的一种变种啊，这个c o h c l h是三个人，三个人的首字母的缩写，你如果知道这名词跟面试官砍的时候，就会显得你知识非常的渊博，如果不知道。

你就别在这瞎说了，就说a k s就行了，好a q s最核心的结构是什么样子的，a q s的核心就是这个state，就是刚才我们读到的这个硬盘类型的数，给大家标注一下啊，这是一个int类型的数。

同时呢它是lolo的，所以我为什么要给大家标注这个东西呢，是因为，我看刚才这个ss给的面试题里头呢，他专门的说问了这么一个，百度多讨厌问这个东西，问了一个什么东西呢，问的是为什么。

你说a q s的底层是c a s加volt，所以你要了解这个state是waller的保证，线程之间可见，ok这是这里面最核心的一个数值，这个数值是什么呢，这个数值所代表的意思随你定，随子类来定。

就这个state到底是什么意思，你自己定，你看我们现在讲的是reentrant lock，好，这个值呢刚才值不是零吗，当你获得了之后，它就会变成一，就表示当前县城得到了这把锁，小声有什么。

什么时候你释放完了，ok从一又变回零，说明当前线程已经释放了这把锁，所以这个state 0和一就代表了枷锁和解锁，人称look，ok接下来如果我们讲的是countdown latch，这是我今天的作业。

你回去去读coundown lash的源码，这里面这个a代表什么呢，因为count down lash里面写的是五的话，好这个state就是代表我这个门栓得calm down多少次，你才能够解开这个数。

可能就是五，所以这个state这个东西，water tel啊，写错了都打错了啊，有瑕疵，这个你们自己改吧，理解什么意思就行了，写错了，volatile la。

ok这个呃这个值是根据你子类的不同的实现取不同的意义，我讲到这，有没有同学有疑问的，没问题，给老师扣一好，这个这个值目前来说从零变成一，就表示我们加了把锁从一变成二级，表示加了加了。

另外加了第二次锁就可重入锁吗，又重新重录了这个state值的基础之上，它的下面跟着一个队列啊，这个队列呢是a q s自己内部所维护的一个队列，这个队列里面每一个都是一个node，一个节点。

这个很容易理解了一个node吗，他在哪呢，在a q s这个类里面，lt 7，a q s这个队列，你看它的有一个内部类，也叫node final class，node这个mod里面有这么几项比较重要啊。

它的成员变量里面有这么几项比较重要，最重要的一个是这个在这个mod里面最重要的一项是，它里面保留了一个thread，一个线程，所以这个队列是个什么队列呢，是个线程队列。

而且你看这个node previous前前面那个节点，next，后面这个节点，所以这个队列是个什么队列呢，是这样一个队列，a q s里面比列是这样子的，一个一个的node。

这个node里面装的是现场装的是thread，ok然后这个node呢它可以指向后面的这个也可以指向前面这个，所以叫双向链表，我说这个讲到这儿，有没有同学有疑问的，所以eqs的它的核心是一个state。

以及监控这个state的一个双向链表，每个列表里面有个节点，这个节点里面装的是现成，好了，同学们，那么哪个县城得到了这把锁，哪个线程要等待，都要进入这个队列里面，所以这是一个双向链表，除此之外呢。

它还有一个head，有一个tail，好当我们其中某一个node的能得到这把锁，就是拿到了这个state给他改了，改成功之后，就说明这里面这个线程持有这把锁，所以当我们acquire快要来了之后。

上来看你这个stay值原来是零，那我就直接咔嚓，我拿到这把锁，就相当于我拿到了，如果说后面没有拿到的，现在是非公平，非公平就上来就抢，抢不着怎么办，抢不着进入队列里。

所以我们看这个代码的执行了大概的逻辑，回过头来，看到这儿呃，那能再看到这车也快了，如果说没有拿着，这不是非公平锁吗，上来就抢嘛，就是没抢着怎么办，没抢着，acquire cute。

acquire cute，什么意思，跑队列也给我挡着去，所以你进入队列继续等待，那如果抢到了，抢到就抢到了是吧，那怎么怎么是抢到的呢，这么来抢的等于scar s得到当前线程，拿到state，如果等于零。

用cs的方式compare and set state，cs的方式，期望值是零，然后尝试把它改成一，假如改成了set exclusive owner thread，设定当前的呃，excuse。

独占的当前的县城是谁呢，是current，就是当前现场把当前县城设为独占这把锁，这个state的这么一个现场，就说明我已经得到了这把锁，而且这把锁是互斥的，我得到之后，别人是得不到的。

因为别人再来的时候，这个c已经变成一了，那如果说我当前县城就已经是独占的这个县城了，get exclusive，get exclusive owner thread，当前的这种独占的县城是谁呢。

就是我当前县城怎么办呢，往后加加个一就表示可重录了，好了同学们，这个lock的大概的方法，我讲到这儿，现在大家能理解这个流程了吗，当然我需要你回过头去之后呢，好好地去阅读里面的源码，最重要最重要的。

我希望你能够掌握这个读源码的原则和过程，好吧，你听着可能不难，你听着不难的原因是，因为我直接把这个结构告诉你了，我如果不告诉你这个节奏，你呀读起来依然还是非常的费劲，所以你不要觉得独眼码这件事特别容易。

我们翻回头来看我们这个第三个小节讲了什么，讲了呢，我们讲了读阅读源码的原则，回想一下啊，第一个跑不起来不堵，记着这个原则，第二个呢解决问题就好了，有好多时候你接手，尤其是接触好几手的这种源码的时候。

解决问题就好，不要追求太高，一条线索到底，就像我刚才读的这样，咔嚓咔嚓一条线索读下去，而不要说大面上的阅读，大家说阅读什么情况下会用呢，你需要了解大致这个类是干什么的，比如说a q s这个类。

刚才那个no的节点是怎么回事，你肯定是要大概读一下无关的细节略过，我不会是这么读源码，我不会说上来a q s，我从头读到尾，所有的这些源码全读一遍，不要这么读，这个读起来是非常费劲的，也不是好的方法。

好这几条原则。

你们现在应该是有深刻认识了，应该有没有，如果有的同学给老师扣一好吧，好在你阅读的过程之中，我希望你画两种图，第一种方法之间的调用图，哪个方法调用哪个方法，你自己做笔记的时候还可以做得更详细一些。

哪个方法都干了些什么事儿。

那第二种类之间的类图，这个类之间的类图比较讨厌我，因为用的是idea的community版本，那么community版本它实际上是不支持通过源码直接给你生成类图的。

可是你如果要是用的是crack版本的话，这里面是有菜单的，这个菜单里面是有一个叫diagram，那个呢是可以直接的自动的帮你生成这个类图，那就更爽了，不过没有关系，我还是那句话，读源码，读源码。

重点在于你自己去阅读，所以你自己手动画一下，其实印象会更深刻，我说过那个黄石去面试的时候，最后是拿到p9 级别给他面试，他面试就是把这图都画清楚了，左手一张纸，右手一支笔是吧，把图画清楚。

那个a p s源码呢，我希望你们自己先读一下，因为由于这个结构我已经告诉你了，所以你读起来那就应该没有那么费劲了，其实所谓的ak原码呢最核心的是在哪呢，最核心的就在于后面我们讲那个对。

讲那个同步队列的时候，也会讲相应的内容，它最核心的问题在哪呢，就是它最核心的点在哪儿，最核心的点其实就是怎么入队，怎么出队的问题，原来入队出队你需要加加锁的，对不对，这里的入队出队用的都是cs。

用cs方法往尾巴上加，为什么什么意思呢，因为我们来分析一下啊，就是说这当有这样一个队列的时候，呃你呢两个县城啊或者多个县城都来抢这把锁了，但这把锁呢已经被别人调用了，被别人调用的时候怎么办呢。

你是不是得跑到这个队列里排队啊，那几个县城都往尾巴上加啊，都往上抢，谁先抢着，到底谁后抢不着啊，如果说你想让他不会出现这种一个尾巴带了好多好多新的尾巴的问题，你只能是一个来了之后先加上。

另外再来了之后只能加在第一个后面好，如果有这种情况下呢，你你最简单的想到的方法是应该加锁，对不对，是加速，哎但是呢现在的aq s的实现刀布里写的呢就直接不用加锁，是用c a的方法。

所以这里的重点就是cs啊，因此呢这也是为什么面试的时候就是谈一下cs啊，我觉得sx这个这小伙儿啊肯定是说啊a q s就是cs加播了，那他肯定要问你啊，为什么a q s底层就是c a s加播了。

tell啊，你把我刚才的这个图给大家画出来，然后记住了，state是波拉特修饰的，改这个里边内容是compare and sets data，你这个你如果c s x，你这样答的是不对的啊。

这里面的那个最重要的是维持了一个队列加速，就是往往往队列的尾巴上加东西的时候，这里用的是compare and set set state。

系列 3：P53：【Spring】互联网架构演变之路 - 马士兵_马小雨 - BV1zh411H79h

嘿嘿嘿嘿嘿嘿嘿嘿嘿，好了同学们，咱们开始准备上那个spring boot了，好吧，来能听到我声音的同学扣波一，呃今天啊咱们开始那个讲spring boat呃。

很多同学一直在问说那个spring bot讲什么程度呃，我希望讲一个完整性的课，就是说从基础，然后呢到后面的一个精通，包括到源码，我们这边都会讲的，所以有些基础东西啊，大家可能听得很烦。

因为之前你们在公司里面也用到了，但是我这还是希望把这些东西啊整体再做一个回顾，很重要一点信息，咱们怎么用复合课，大概我的计划是6~8节课，有可能时间会更长啊，这不一定，但最少也要上六次课，懂我意思吧。

从spring来讲，不会的，呃，spring啊是我们基础班的一个课，spring从基础班的一个实验一个课，基础班的时候也是一样的，我也会从基础的东西开始讲，然后讲到源码呃，还是一样。

我希望就是把这个整体的知识点啊，都做一个整体的完整的一个学习，这样的话对大家的一个好处更明显一点，如果你所有东西都提一半或者踢一个阶段可能不太好，ok大数据是不是连号上的呃，大数据讲了还有维持被子。

包括那个日志日志的那个小小小项目，然后后续的话可能会讲麒麟啊，基本上三门课我都讲了啊，呃大家还是根据自己的一个需要说我到底要学什么东西，基础班同学还没开始，刚刚讲到js啊，刚讲到js额。

js这块我们去讲，然后请了一个专业的老师来讲解的，后面的话都给大家补起来，这个大家放心啊，呃刚刚很多同学提到大叔这件大数据这件事情，呃我再说一下大数据的东西啊，怎么说呢，呃很多同学说老师我没时间看。

我没时间看或者怎么怎么样好吧，呃还是一样，大数据应该是一个必备技能，你们现在买个课，没时间看，没关系哦，没关没关系，后续的话啊，有时间了，一定要把大数学课补起来，因为你往后看3~5年。

大数据一定会像java一样来，那接它会成为一个必备技能，而且咱们这边大数据课啊，大数据课应该是比较专业的，光hdp周老师讲了14节课，懂我意思吧，应该有很多很多这方面的一个东西非常非常完整。

所以你需要哪一块儿听懂，听哪块可以了，不叫大家不要求大家说每天必须要跟某一门课，你根据自己的需求来决定就ok了，懂我意思吧，今天结课项目吧，看情况看能不能讲到这一块，但应该讲不到。

我们只是一个刚开始的一个基础课，好吧行了，废话不多说，我们开始讲解spring呃，加spring boat，然后再说一下啊，呃大家看到了，我上课的时候，首页打开了spring官网。

之前我在讲课的时候也是一样，非常喜欢啊，非常喜欢，或者带大家看一下我们spring的一些包括一些其他框架的一些官方网站，好官方网站，那为什么官网永远是我们第一手的一个学习资料。

所以我希望你们以后学知识也是一样的，所有东西从官网里面直接去看这些点很重要的信息好吧，寒江雪说腾讯课堂目录有点乱。

呃这个应该不会特别乱，因为之前给大家做了一个整理，那天有学生反馈之后，我在专门做了一个整理啊，大家可以看一下，其实啊只是加洛克里面稍微有点乱，因为加洛克里面我们加了很多的一些怎么说呢。

很多的一些小加加了很多餐，所以这块可能会稍微乱一点，然后这边大家做做好整理的网络的分布式，然后spring cloud多线程高并发，spring源码，net n l o，然后呢jvm一级流量的项目。

包括msl调优架构师的前置知识，这块都给他做做做了总结，明白意思吧，所以这一块几乎后面的东西啊也都会一直更新的，不用担心啊。

大数据的顺序有吗，大数据就按照课程顺序往里面写就行了，往里面学习就ok了，懂我意思吧，就按照我们课程的一个呃正正确目录顺序s来说，肺部留言说质检吗，呃没关系啊，你们能够找出来问题或者提出来bug。

这很正常，我们是人不是神，我们也会有自己认知错误的地方，如果有问题，希望大家能够及时反馈好，及时反馈，没问题啊，现在没有意义，根本跟不上，哈哈哈哈，慢慢就跟上了，总之一点你记住一定是要学的就可以了。

懂我意思吧，加工这里面有没有中台项目呃，这个怎么说呢，呃看情况吧，大家如果对中产有有兴趣的话，可以学一下呃，跟大家说一下中台项目，我们是请了一个现在已经投产的。

已经在呃产生一些商业商业价值的一个项目的公司cpu来进行讲解的，所以咱们的中台才是正儿八经的一个中台项目好，到时候你们期待就可以了，一定会有的啊，好了废话不多说，来先聊一下我们的spring boot。

好吧，很多同学在公司里面一直在用spring board吧，来在公司里面，现在没有接触过spring bot同学扣一没有接触过的，别说我接触过没有接触过扣一这么多吗，不可能吧，是我认知错误了吗。

人家给大家说一下呃，现现在还有很多传统项目，很多还是s sm呃，那我们就更要从刚开始来进行一个讲解了，刚开始进行讲解了，还是一样，先说一下我们的s m其实在s那么之前应该是什么叫s s h，对不对。

它是有一个整体的过渡阶段的，在s之前可能还有server rate和js p对吧，他们几乎都是一脉相承的一个东西，这块我希望从刚开始第一节课的时候，能够帮大家拔高我们整个架构的一个认知。

好架构的一个认知，大家想一下，在我们的项目或者我们的it行业发展起来之前，最开始的架构是打不到最开始的架构，没人知道好吧，叫单一架构好，单一架构这块给大家看一个东西。

看什么呀，我们看一下double的一个官网，大部官网里面有这样的一个描述，我不知道你们有没有看过，我们架构师根本不信这些话，胡哨的东西呃，要信好吧，这些东西设计还是非常有意义的啊，我们来找一个文档。

在他文章里面有一个背景，大家可以看一下这样的一个描述，我们今天不讲double好吧，不讲大宝没关系，然后这单这边我们要看一下互联网的发展趋势，说随着互联网的一个发展，网站应用的规模不断扩大。

常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，急需一个治理系统来确保架构有条不紊地进行演进，所以这里面几乎画了这样一个学习路线图，或者说一个架构的演变过程的一个图。

这个图我不知道你们能不能看懂好吧，但大部分应该是没问题的，往下看，上面放了framework什么框架吧，然后有我们的架构，后面有我们的cast表示我们的集群，好吧。

他就是这样的一条时间线的这个图我不知道你有没有见过没见过，没关系，我知道带你们看好吧，刚开始o o m m a c r p c s o a对不对，刚开始是什么呢，叫all in one。

就是我们说的单一应用架构，这也说了，当网站流量非常非常小的时候，只需一个应用，将所有的功能都部署在一起，以减少部署节点和成本，此时用于简化增删改查工作量的数据访问框架，om是关键。

这里面描述了一个什么信息啊，就好比你们在刚刚接触java的时候好吧，一般在学到server之后好很多人可能说老师我终于学到server了，ok我可以做一个前后端交互的一个项目了。

所以一般情况下都开发一个非常简单的项目，当你这个项目开发完成之后，一般都会部署一个外包，放到我们的一个top cat容器里面，好或者其他一些呃动态一个补充器里面，然后进行一个运行。

这个时候你看到你的浏览器可以进行访问，然后收入后面的有一些数据交互，这是最开始这样一个过程，但是你要注意一点啊，这是最最最开始的时候一个架构思想，然后呢随着技术的一个演变以及用户量的一个激增。

慢慢的说这种单一应用架构不太符合我们实际的一个情况了，那怎么办，有了叫垂直应用架构，大家其实可以看一下这个图，看这个图来做一个对比，什么图对比，刚开始叫all in one。

后面呢叫垂直的application应用架构，什么意思啊，这个图是不是没有任何变化好吧，刚开始一个蓝色块会变成三个蓝色块，然后下面急救规模由一到十台变成10~1000台，这表示都是我们的应用程序。

也就是说当用户的一个访问量逐渐增大的时候，单一应用增加机器带来的加速度是越来越小，为什么你想一件事啊，你想一件事，什么事情，你注意了，任何一个硬件它都是有自己的一个性能上限的。

你所有东西都不存在里面的话，就算你扩展或者增加你的硬件的一个效率，它其实对待大家速度影响也是非常非常小的，然后说了将其应用拆成互不相干的几个应用，以提升效率。

因为我现在需要把单一的一个应用拆分成123或者说n多个应用了，这样的话就变成一个什么呢，叫垂直应用架构，然后发演变之后说了，在垂直应用架构中，此时用于加速前端页面开发的web框架的mvc是关键。

什么叫用vc啊，model view control吧，包括你们现在写项目的时候一般都这么写，现在定义control用来接受我们用户的一些请求对吧，然后第一个model我们的实体类好吧。

然后还有我们的呃mv vo视图是我们的一些浏览器页面，是不是这样的方式，你们现在做的时候依然是一样的，只不过现在我们用spring也好，还是用spring boot也好。

它帮我们做了一个整体的整合好整洁整合这个大家注意了，好之后，我们再来说好之后我们再说这块，然后呢由垂直架构之后又做了一个演变，叫什么呢，叫分布式架构。

distributed的server好service是什么意思啊，一样的，也就是说当垂直应用架构越来越多，应用之间交互不可避免将核心业务抽离出来，作为独立的服务，逐渐形成稳定的服务中心。

这个时候你注意了，当你形成n多个服务中心之后，会存在什么问题啊，它们之间一定要产生数据的一个整体交互过程啊，整体交互过程这个交互的时候通过什么，是不是通过我们的r b c了，什么叫rpc。

是不是要远程过程调用这样的东西，好，远程过程调用这样的东西好吧，这后面这说的通过远程工过程调用来进行一个演变，然后用它之后还没完，又往下进行一个演变，怎么演变，说当服务越来越多的时候。

容量的评估小资源服务的浪费等问题逐渐没明显，此时需要增加一个调度中心，给予访问压力，实时管理集群容量，提高集群利用率，此时用于提高集星利润率，资源调度和治理中心就成为了关键。

就是我们的s a是不是大家看到了这段有一个基本的描述，这个描述里面就阐述了我们整个互联网架构的一个演变之路，当然很多同学可能年龄还比较小好吧，你可能没有接触过前面这些架构的一个演变过程，好吧。

你下来之后可能直接学spring boot搞定了，或者直接学名图，对不对，但是前面这些历史你要有一个感知，会有一个认知，它一定是要不断进行发展的好吧，而发展的最终的目的是为了什么，是不是。

其实我们第一开发效率提升，第二我们对应的一个应用程序，它执行的一个效率要做一个提升，所以人们怎么样呢，会发挥自己的想象力好吧，创造出来各种各样的一个东西好吧，来达到我们想要的一个效果，这块要注意了。

所以刚刚这个架构演变之路，能听明白，同学来扣个一就通通干过吧，永远不要想老师，你这个图你是怎么知道的，我还是那句话，你多去看官网，你不一定说我学什么技术，就一定要看什么官网啊，没必要。

但是你要知道一件事，当你开官网之后，他们其实可以交叉进行学习的，大包里面的东西是不是介绍这个将演变之路。

我们在spring boot这就可以进行一个使用了，而且现在在企业里面几乎没有spring，没有公司不用spring的好吧，spring它有一个全家桶理工里面提供了非常非常多的一个服务吧。

这块希望大家能够认知到好吧，大家看这是spring的一个官网。

我刚上来打开就是这个官网好吧，you soon boot spring out和spring codflow，他这三块表示什么意思呀，什么意思，第一个叫build anything，叫构建一切好吧。

第二个呢叫协调一切吧，第三个呢叫连接一切，这是spring他想做的一件事情，然后里面分了n多个组件来进行一个描述，第一个spring分母和五就是我们的spring框架。

这东西咱们教务课里面可能不会再讲了，后续的话基础课里面会讲，把基础课里面会讲，然后呢讲完之后我们会把那个课单独拿出来，成了一个小课，之前我也说过了，我们有自己的一个视频网站，这视频网站我还在开发好吧。

大概在1月1号的时候会重新给大家进行界面，把我们整个网站的一个设计，把整个网站的一个设计都会进行一个更新啊，其实现在也在做，我可以给大家提前看一个东西，看啥呀，呃大家找一下，就我后面一直在做升级。

很多同学可能有平常问问题的时候可能找不到，我，为什么一般都在开发这个开发这个项目给大家看一下，叫web这test，诶没了吗，大家看到了这个现在这样看起来这个图现在还没在做好吧。

之后的时候别老想着翻车好不好，之后的时候我们会把网站进行整体的一个升级啊。

这是我们后续的一个网站，这边的一个规划应该比我们现在官网要好好看很多吧好吧，大家今天等着以后啊，还是您这句话会提供越来越多越来越好的服务给大家。

你们从官网里面或者通过我们的视频网站都能看到很多信息。

但这开发只不过需要一段时间，所以希望大家能给我一段时间好吧，一人就是一支军队啊，不是啊，我们肯定要做这块东西的，懂我意思吧，用的技术你们就不用管了吧，不用的技术你就不用管了，前端也是一手包包干嘛。

呃基本上都在自己做好吧，基本上都在都在自己做啊，所以有时候可能回答问题不太不太及时，原因在这就在这一块，要是招人不可以去找我，可以投简历好吧，欢迎大家投简历，哈哈哈，反正你能想的东西我还是那句话。

你能想的东西我能做的都帮你做了，所以希望大家能够珍惜自己的时间，抓紧时间学习就够懂我意思吧，不知道七爷头像有没有没有了没有了，哈哈哈，没几天了，是没几天了，我们后续第二问都都都都在做啊。

不是不给你们看其他页面了，没有意义啊。

系列 3：P54：【Spring】什么是微服务架构？ - 马士兵_马小雨 - BV1zh411H79h

就行了好了呃。

禁止闲聊，我们接着往下看好吧，刚说完spring。

我们今天主要讲什么，讲spring boat这样的东西，我还是那句话，我希望你们去看官网啊。

逗号里面透露出来很多的一些相关信息，都是我们值得思考的，比如说很多人一直问我说，老师spring boot算不算是微服务，啊听到有问题啊，我说spring boot算不算被服务，就算同学扣一。

不算同学扣二，你觉得算吗，不算吧好吧，其实我照我的理解来说，我说一下可以说一下我个人的一个理解啊，在我看来，在我看来，微博是什么东西或者sm是什么东西，它其实就是一个启动器。

就是原来我可能要做各种各样的一些呃配置文件的一个编写的哦，包括说各个浮木块单独起一个，然后现在呢我把它整合到一起了，所以这块他给了一个非常官方的一个描述，你可以看一下叫什么叫spring boot。

是一个什么叫starting point for building of spring base application，这句话什么意思能翻译出来吧，没有六难单词看错了，sprbot是一个什么呢。

叫构建所有spring依托于spring的应用程序，然后呢告诉你说starting point是不是一个启动点，是不是有个启动点，好吧，再来看说sgo设计上来干嘛呢。

get you up and run，as quickly，as possible，什么意思啊，但他这种设计为了什么呢，让你能够尽快的把它搭建起来，并且尽快的把它给运行起来，这是最好的一个方式好吧。

叫within minimal，叫iphone的configuration of three，减少我们对应spring的一个配置，这句话是很明清楚的描述，你描述告诉我们spring bot是啥。

有提到任何跟微服务相关的点吗，有问题到不没有吧，所以你看到很多地方都在说spring spring board归服务呃，这么说其实也没啥毛病，但是可能不太严谨，你还一样看官方里面的一个基本描述。

这里面是最准确的，它里面有什么样的特点啊。

第一个叫干start in seconds，using spring english writer，什么意思，什么东西，这是啥，是不是说让你在进行配置的时候，通过在几秒钟之内就把它完成。

这有一个叫thresuler的一个启动器，我们直接听就可以了吧。

很多人在开发的时候，是不是有这样的东西叫starting spring i o，在里面我可以下载一个对应的一个扎包，建议运行，当然我们现在没人这么干啊，没人这么干，那怎么做，这样可以。

我们通过我们的idea是不是直接就给他进行一个集成，从idea里面直接做就可以了，好吧，s不要找事好吧。

你不来北京了吗，我等着给你打架的好吧，来北京找我好了，这是第一点，第二点是什么呢，叫building anything，什么意思，rest of a i吧，websocket。

web streaming task and more，是不是有很多很多这样的东西对吧，说构建任何事情再来看叫什么呢，叫更简单的一些secret吧，是不是安全。

然后呢叫rich sport for socsgo，搜索非常丰富的一个支持，对于我们的circle和我们的no circle，然后内嵌的运行支持有tomcat，有gt and you t对吧。

developer production toys是有很多开发者的一些高效率工具，比如说叫live reload，按照什么auto restart自动启动。

以及我们这个页面的一个自动加载好或者自自动重载对吧。

再往大家看这个翻译啊，我一直没解释解释对，我也不知道翻译干嘛的好，我也翻译不出来，谁知道各位可以给我说一下，懂我意思吧，再来看它什么呢，叫准备好的一些特点，例如跟踪对吧，杜龄和我们的一些健康检查。

然后说warner in your favorite，i de，可以在各种id里面进行运行，例如例如有什么spring to skills是一个工具的一个东西。

还有idea以及我们的that belt病啊，现在已经没人用了，我之前的时候还用，现在也没有用，所以大家想一下，我们现在开发的时候更专用，什么是我们的idea。

之后我们所有开发者都会在idea里面进行执行，好吧，其实在一级教授课的时候，因为老师已经讲过我们对应的一个spring boot了，好吧，讲过我们对应的一个应用这块大家应该都听过，为啥不说一个例子。

这块是它集成好spring的一个工具吧，也就是一个例子吧，但它集成oe spring是不是好吧，那现在你们在公司没用什么用，该第二吧，还用软件用的比较多，一点，所以我们上课的时候也会用我们的电。

不会用其他东西了，如果你觉得不习惯的话，你可以把它切换成一个例子啊，这就无所谓啊，反正就是个i d而已，看你自己的公司，lol的加加，你要能够派肩胛给我写好，你也是牛，你也是牛，我也佩服你，我也佩服你。

好吧行了，这是官网的一个基本介绍，这块儿就看这么多。

所以看完这些描述之后，你应该有个感知，ok我现在了解到spring boot到底是用来干嘛的，当然我现在还不会用，还不会用，不会用，没关系好吧。

一会我来教你如何进行一个使用，这边给大家画了一个什么呢，spring boot的一个思维导图呃。

我上课的时候习惯给大家画这些东西，好方便大家做一个整体的一个总结。

那我这儿来看一下吧，第一个叫回顾three，它需要某些spring的一些特点，比如说oware自动注入对，也就是说l o c和a op在我们的three bo面是有应用的。

很多同学可能还没写spring，没关系好吧，你不用管它，你不用管它好吧，这只是对spring的一个基本介绍好吧，基本介绍你再简单看看就行了，好基本简单看就可以了。

看完了说spring是为了解决企业级应用开发的复杂性而创建的，就是为了简化开发，然后spring降低开发复杂性的一个四个光线策略，第一个叫基于泡沫的一个轻量级和最小清属性的一个编程也写错了唉，侵入性。

我先说个字啊，编程第二个什么叫通过l o c，第三个呢叫a o p好吧，通过切面和模板减少样式的一个代码这块我们之后再说讲spring时候。

我会详细讲的，ok再来看spring boot有什么优点啊，说为所有spring开发者更提供更快的一个入门程序，然后他说第第二个叫开箱即用提供各种默认配置来简化项目配置，第三个叫内嵌式容器。

简化外部开发，第四个叫没有冗余代码生成和xm 2的一个配置要求之后，我们会学一种新的配置文件，你们之前可能用xml或者用pti之后呢，我会有一个东西叫什么叫email y m l。

这是我们spring boot里面官网里面给的一个推荐，好过网里面给一个推荐，到时候用钱就知道了，他写写了更简单一点好更简单一点。

然后后面我这也描述了一下我们对你的一个架构演变之路，这是从网上找的一张图片。

能放大吗，好大家看一下这个图片啊，第一个单体架构什么样子好吧，s o a架构以及我们的微服务架构，现在大家见到的更多是我们的微服务架构了，下面有对应的一些特点，这块儿下去之后自己来看好吧。

我们上课不做这样的一个演示，没意义，下课之后我会把这个图发给大家好。

欢迎大家，然后呢后面又对应的一个介绍好吧，什么叫单体架构啊，是不是叫all in one吧。

指的是将一个应用而中的所有服务都包含在一个应用程序里面，无论什么系统，都将数据库web能开个功能模块放到一个可执行文件里面，比如说一个外包或者一个炸包好吧，这样来进行一个执行，第二个叫soa架构。

面向服务的一个架构，它是一个什么叫组件模型，它将应用程序的不同功能单元简称为服务，通过这些服务之间定义良好的接口和契约联系起来，接口是采用中立的方式进行定义的，它应该独立于实现服务的什么呢，叫硬件平台。

操作系统和编程语言，这使得构建在各种各样系统中的服务，可以以一种统一的和通用的方式进行交互。

说完了，很多同学家不明白，好吧，你记住了什么叫rpc好，有这个东西知道就行了，rpc叫远程过程调用啊，很多地方都在用它，很多同学如果接触过大数据，应该知道大数据很多的一些呃框架都是以一种集群的方式。

集群的方式运行的，集群里面其余文字就是什么rp c吧，进行一些消息的通信啊，包括一些金刚检查了对吧，消息传输了很多点，都用它好，稍微听一下就可以了，如果你听到那个spring boat呃。

那个spark的话，应该知道周老师讲spark的时候，应该对这个点讲的比较清楚，什么叫r t c，因为在spark的源码里面有一个组件叫什么叫pc e n v吧，只有自己一个环境对吧。

包包里面用了我们的nt有什么point receive and the point，就有很多这样的信息，好吧，你看完之后你知道了，反正不管怎么样，你就是我学所有的技术啊，这些东西都是一样的啊。

都是一样的，ok所以我联系说我感觉sn和微服务区别就是有没有服务治理和福利，服务，数字和治理这一块，我希望还是一样，我希望你们能清楚地认知到什么到底叫微服务，微服务那篇论文你们看过吗。

是关于微服务介绍那篇论文有人看过吗，没有的话，一会儿我带你们看看，我一会带你们看看，一会我们带你看看，我看下大知道了，大家看一下这边的一个文字描述对吧，叫微服务架构，什么东西。

微服务架构是一种将单个应用程序作为一套小型服务开发的方法，每种应用程序都在自己的基层内运行，并与轻量级的机制通常是h p或者资源a p i进行通信，然后这些服务围绕业务功能构建，这个组件非常重要。

叫业务功能可以通过全自动部署机制独立部署，这些服务的集中管理，最少可以用不同的编程语言进行实现，并使用不同的数据存储技术，当然说完之后，很多人还是很懵，没关系，我们来看一个东西。

来看一下它呃，有错，等一下啊。

看这块叫michael service，是不是要微服务。

微博里面有一堆的一个介绍，是告诉你说什么到底叫微服。

刚才说了马天鹰路德好吧，有很多这样的一个介绍吧，下面有很多的一个描述，很多老师我看这个描述完我就疯了好吧。

我可能看不懂这些东西，没关系，这边中国人有个人做了一个翻译。

好翻译文章，我也找到了好看的船长好吧。

我们来看这样告诉你们说微服务到底是个啥宝贝，我到底是啥，大家看说微服务架构做做什么事情，这东西啊，注意了，这篇博客是给我们刚刚那个英文文档完整的一个翻译，如果你谁看英文看的有问题的话。

可以参考这个中文文档来进行看一下，我还是那句话，我建议你们把这套东西好好看，看好翻译插件，那个翻译插件并没有这个文章翻译的好好，我还是希望你们把这个文章能够看一下，懂我意思吧，地址。

可以吧啊这这个这是这个中文的地址啊，给他找一下这个英文地址，上面是中文地址，下面是英文地址，ok把两东西对比着，可以做一个查看啊。

能帮助你理解到底什么叫微服务，因为现在面试啊，你要说你不会spring cloud，或者你不会double面试都不敢出去，懂我意思吧，呃公司里面有些公司可能在用，有些公司可能没再用，就算没再用。

也一定是往这条线上进行呃靠拢的，懂我意思吧，这东西可能是以后的一个趋势，所以这块你必须要做一个学习。

为什么在spring boot这块讲一下微服务这个架构的一个体系，就是为了帮大家把spring boot和微服务给区分开来，不要把私人报考当成一个微服务，反正我是觉得不太合适的。

我不知道你是怎么认知的啊，好这东西每个人理解都不一样，那句话怎么说来着，1万人眼里有1万个哈姆雷特好吧，你这自己去做一个评估就可以了，我们这儿不看这些文字描述了，因为你看完这些文字描述。

你整个人就疯掉了啊，太多了，我们这儿直接来看这张图，你看这个图能不能感受到一些信息，好，能不能赶上一些信息，什么东西啊，这边有个单词啊，你可能是不认识的，你可能是不认识的，没关系，这是这是有解释。

是不是这个词，这是有个翻译叫整体应用架构吧，我就说我发现也无所谓了好吧，他说一个整体应用架构，put all is function into single process。

说他把他所有的一些功能组件方法都已经放到一个单一的process里面，是单一的进程里面，大家看到了这里面做了一个标识，什么标识，这样子的，这样子这样子这样子这样子的，是不是各种各样的一些组件。

你可以把每一个组件，每个组件都当成一个集中的服务或功能模块，好吧，他们统一的都放到一个进程里面，是不是，这是我们刚开始那个整体应用架构，或者说单应用架构是这样的方式，让妈妈他要做一个过渡，怎么过渡呢。

他做了我做的东西都放到一起可能不太合适，然后呢我要把它做一个拆分，怎么拆分呢，看后面这个演变之图，是把每一个小的功能模块或者说功能组件都做了一个独立的拆分，是拆分成我们看到这样子了，是这样子。

搭上了每一小块都是单独的，都是单独的对吧，他也说了，再发什么呢，把刚刚那个each elements of functionally，然后to啊，什么东西是不是拆分好的一个服务里面去，是这样的一个方式。

然后慢慢的又做了一个演变，怎么演变呢，从这张图上往下面一张图演变，大家看到了每一个功能里面是不是跟我们上面这块一样了之后呢，他在外面多套了一个。

就是相当于是多台的一个服务器，好吧，没服务器里面可以部署n多台的一个服务组件，是不是有1234，这样的话大家看到管理起来其实是比较混乱的或者比较杂乱的，然后又做一次过渡点，在后面这个地方这么多的。

就是说每一个服务里面好，每一个服务里面它会有不同的组件，不同的组件，我这块可以进行人为的一个选择，但是我规定好了一个里面是不是只能有四个服务。

这意味着你是不是在选择的时候，可以选择说我往不同的物理服务器里面进行部署，这时候他们是统一工作的，而这里面每一个地方你都可以称之为什么一个对应的微服务。

只不过从这个图上看起来的话，它可以是一个集群形式，所以从这个图里面你能感受到很多的点。

就是这个论文里面，你是不是看到这个点了，往上翻。

这个图啊就从官网里面直接拿过来了，就这个图是一模一样。

是不是一模一样，好吧，这也做了一个最官方的解释，所以你把这个图如果看懂了。

你就知道哦，原来是这么回事，大概是什么样的一个意思，后面对我们的微服务做了一系列的一个解释啊。

会有更多更多的解释下来之后自己看好我们这不太多解释了。

所以我希望你能认识到fboot不是为服务，不要把他再说错了。

这东西啊不是那么合适，懂我意思吧，ok我就这样给你们扭转一下这个观点。

仅此而已好了，这文章地址我已经发出来了，发完之后下载之后自己好好看看好吧。

下课之后就看，把这块好好做一个理解，或者做一个了解。

这很重要，懂我意思吧，放弃了，方便下一个图，这个图也是一个页面的一个图。

下周可以自己看好了，那这东西啊。

系列 3：P55：【Spring】第一个Springboot程序 - 马士兵_马小雨 - BV1zh411H79h

按时间了。

怎么学啊，好多同学又懵了，老师一涉及到知识点去就慌了，如果后面再出来一个spring port怎么办。

非常简单，官网我一直在强调这件事的重要性，my sql也是一样，我不是带你看过吗，你们要看好吧，叫spring boot，我们现在讲课用什么用，最新版本是2。2。2好，2。2。2。

有可能我们的使用boss还没讲完，这就更新了，smod更新啊，是比较快的好，但没关系，基本的核心点应该是不会变的，懂我意思吧，基本的核心点不会变，你可以从这儿进行一个查看啊，进行一个查看。

先点开之后挨个看就行了，大家看就行了，懂我意思吧，这块一定要看，那老师我不行，我看英文之后头疼头疼怎么办，一直老师翻译啊，没用好吧，翻译出来之后可能意思跟你想要的意思就不那么一样了，那怎么做也非常简单。

我这儿给大家分享一个也是别人写好的一个博客，好吧，叫gtbook啊，gtbox这里面有sp 2点x的一个中文文档，好大家看一下这个中文档里面有详细的一个介绍，好详细的一个介绍。

他说了6月时间基于spring bot 2。1。5的官方文档进行了翻译，注意了，这是2。1。5，我们现在用多少，二点点一吧，但我说过了这个小版本的一个更新的话，其实呃有些点可能会变化了。

所以这一块我还是希望你们能看一下中文的，看不懂英文，我们看中文总可以吧，一定要秉持下去，这是我我强调过这件事情，我觉得别别的老师也应该强调过，你不要说老师所有东西等着我喂给你没意义。

现在就你看官网其实能学到很多东西，这边导航栏你直接看就可以了，其实我说了，如果我不讲，我不讲，你也应该能学会啊，只不过说这东西怎么学的一个方式，所以这样我会带着你说，告诉你这块应该怎么学。

老师可以把这些app放到相关笔记里面，可以可以啊，一会儿我会把相应的一些笔记给大家都补充到里面去，下课路再补充吧，我们上课不浪费时间了，好一会我把这个图分享出去，你们从图里面直接看就行了，懂我意思吧。

一会儿做啊，这忘忘了往里面进行整理了好了，来往这看吧，上面的都是一堆废话，告诉你说我要怎么进行构建之类的东西啊，我们这儿不看了，这块它翻译还没翻译完好，我还没翻译完。

但是这些东西已经够我们进行一个使用了好吧，第一个先看入门，入门里面对spring boot做了一个基本的介绍，基于spring的一个应用，我们对spring平台和第三方内部有自己的考虑。

因此您可以从最基本的开始，大多数同人不同应用只需要很少的spring配置对吧，然后说你可以使用three boot来创建一个可以使用java杠站的命令来运行，它提供了一个什么呢。

叫运行spring这个呃sprts的一个命令行工具吧，有多种这样的一个方式，把后面告诉你说目标是啥，这块不用看了，你知道他运行完成后，或者你写完代码之后。

我可以通过java杠炸的一个命令来进行运行就够了，所以所以当你写完代码之后，你看到应该是什么，是不是应该是一个完整的炸文件对吧，这样大家只能所有人都知道啊，所以都知道这块不用多说了。

那下面有什么有系统的一个要求，现在一般情况下你们的电脑可能都满足了，但现在系统是什么意思，告诉你说我用什么样的一个web容器好吧，server的版本是多少，以及我们的jdk的版本是多少。

现在一定多少八了，所有人应该都用八了吧，没人再用六和七的吧，如果你公司里面还在用，就无所谓好吧，但是说了，虽然您可以在java 6 java 7上运行存不，但是我们强烈推荐你使用jaa 8，懂我意思吧。

一定要使用我们正二八这样一个版本，告诉你说如何进行一个安装啊，好吧，告诉你面有一堆的安装方式，这不再多说了啊，这里面有这样的一个机构的一个配置是啥，没了吧，你们对moon熟吗。

我来问一下现在听课的学生有没有不会问问的，有没有不会问问的，不会的扣一好吧，你还有一些基础班的学生啊，呃不过没关系，之后基础班的时候会讲maven这东西怎么算会呢，你知道可把我把我把我问住了。

基本的操作吧，基本的操作吧，这门课和架构一般的spring课是重复的吗，呃有一部分内容会重复，但是这边的话可能讲的更加那个就一期的时候教大家更多是一些使用，这边的话会使用加原理都讲，把石油家里也都讲了。

懂我意思吧，来看看这边告诉你maven gradle好吧，安装fbot c l r这块我们都不用好吧，所以对于你们没有东西不用管它往哪看，11叫开发第一个spring boot应用程序。

把cbot应用程序啥意思告诉你，我如何来进行一个最基本的创建过程，非常简单，第一步先在这里面安装maven，我这儿已经安装了，大家看到我电脑的c盘里面也有了一个maven，但是版本比较低啊。

b的低无所谓，这里面我希望大家改一个东西啊，改什么东西啊，改一个settings比较差，其实有两个非常重要的配置，那两个第一个是我们本地的一个仓库路径，你设置好好吧，第二个是你要参考的一个镜像地址。

大家看这我要用谁的，是不是阿里云的，是阿里云的，你这块可以自己做切换，无所谓，好无所谓，但是我建议你换啥里云的，因为有可能你访问国外的话，可能速度会比较慢一点，有可能我们现在班会比较多啊。

阿里云的话可能速度更快一点，所以这块做一个推荐，我作为推荐，当然你可以如果你比较熟的话，你看自己心情想要什么英雄就可以了，对于初学者，一会我会把这个配置文件发出来，发完之后你按照我的文件改就完事儿了。

懂我意思吧，不要在这个配置上面浪费太多的一个时间，懂我意思吧，就这块这是我之前配的啊，这是我之前配的，我不知地址改了没有，反正现在还能用，现在还能用，ok地址变了，不是应该是吧，就这个吧。

反正我现在还能用啊，我不知道他有没有改地址，因为基本上改完之后没动过它，没动过它好了，不再管他了，不再管他了，你现在之后自己配就行了，反正我我就一直用用用用用这个配置啊，不管它了。

来看第二个要创建pom文件，就是你把刚刚配置粘过来就完事儿了，好这样可以选对应的一个版本。

然后有个配置class的一个依赖，是不是分别分了n多个步骤，然后告诉你说如何进行一个编码操作。

然后使用rest controller和request mapping注解，然后把alt confit注解。

然后命方法只有预约的样例了啊，这块我们来运行一下，看一下应该怎么做好。

看一下应该怎么做，其实非常简单，我说了，这是第一种方式，你可以用我们的idea来做，除了之外，你可以用这样的一个工具来做，当然你在自己学的时候用它没问题好，因为他没问题。

但是如果在公司里面肯定没人这么干，太麻烦了啊，怎么做呢，这样可以选一个main project，然后选择一个编程语言叫java，第三个选一个版本，我们是不是2。2。2，就这个版本下面什么呢。

叫project mad，这可以选什么，选上你对应的一个group，这个group一般是你公司域名的一个告诫吧，怎么写，come点把视频对吧，这可以写一个叫spring boot，再见斯大林不讲究。

这有个option是详细的一些选择，比如package name python，我把它删掉到这儿，到com点把视频就够了，这第一个版本是八，这都可以做一个选择，除此之外好吧，除此之外。

这页面里面提供了我们各种加载的一个工具，好比如说上一个什么呢，叫dv twice，是不是进行热部署的，第二个box是不是进行那个那个实体类的那个sg方法进行一个填充，填充的是只需要加注就可以了。

现在有我们的timate是模板，比如后面我们要用simul对吧，security有spring security对吧，os二点是不是有各种各样的版本，然后circle我们用g d c好。

或者用spen dj d b c都行，把更多版本你可以选择自己需要的东西好吧，需要什么加什么就可以了，暂时我们是不是原生的，原生的话，我我就搞一个什么最基本的，比如说web项目吧，大家都选上勾。

选完之后拿去吧，这是告诉你说一个flat，然后把那个合起来好吧，别动不要了，点开它嗯，合不起来吗，我看这是不是可以写一个叫spring web，然后写完之后搞定了，别的东西不叫价，你不用不用管它了。

然后再选一个按这个按钮，它就会下载一个炸文件，对我把这文件拿出来，这很快啊，这很快啊。

c2 位拿过来，拿完之后直接解压，他就是一个项目，然后用我们的第二天打开，呃之前群里面有人问啊，说idea过期了怎么办，你过期了，你就从淘宝买一个，或者淘宝上搜一个。

我一会儿可以给你分享一个就是免就是到2099年的一个东西啊，一个注册码，你自己需要做一个配置，很麻烦，你要不想麻烦的话，你就你就搞一下啊。

这些东西很基础啊，这不再浪费时间了，你们应该都会了，呃这spring源码啊，我再带你们看源码东西呃，我现在给大家说一下，后续的话我们会讲组织源码，spot源码呃，很多学啊。

可能觉得那个老师sboot源码就是我看起来很麻烦，很麻烦，呃，这块给大家说一下，我会给大家写一写笔记，写写笔记啊，呃这我几乎整理了一些，大家没整理完，后续的话会给大家加东西的。

就是你在入口的时候去写东西，应该加什么样的组件，这块注释啊，我都会给大家写的啊，都会给大家写的懂我意思吧。

所以希望你们可能看源码看不懂，或者说看完之后就忘原因在哪。

你很少去做一些注释或做一些笔记，你把这段如果做完之后，你回头再看的时候都会感觉比较清晰，ok 2099年那个工具破解完之后就是2099年了啊，所以你们如果需要的话，我就给你们，你们需要吗，需要的话。

一会我分享一下，这没啥难的啊，这很简单的东西，需要就给你们无所谓，哼要啥你也要啥，你们什么你们都想要来cos project，这样可以选什么，选哪个，有import open吧是吧，交易版可以用。

打开我们的，desktop选他，ok，那这样这样会有一个妹妹的一个构建好妹妹的一个构件啊，等一下是构建好了，构建好了之后，这块可给大家说一下，你可以把几个，如果你看这个目录比较多的话，可以把这东西删掉。

这东西没用，这删了，反正我每次删掉他，我感觉没啥用，ok这就来一个s2 c，然后连上4s这种mean java里面有什么come，这个vision就是我们对应整个程序启动的一个入口了，听明白意思吧。

好吧，这块就有这东西了，所以这之后你就可以怎么样直接运行，当然我们现在运行之后没有任何效果，因为我现在是什么都没写，什么都没写了，这几个是啥啥是啥，开启源码入手啊，现在讲到源码，现在讲源码已经懵了。

但不知怎么样，现在这样直接运行了，运行完之后能开启，我们能运行我们对应的一个东西，删了几个字啊，一个是get的，一个是那个呃maven的一些相关配置的文件也无所谓，直接删就行了，你这个id留下。

把其他东西无所谓好现在我现在这种东西无所谓啊，然后看完它之后。

试验是不是弄好了，我们现在没法访问，因为你什么都没写，什么都没写没意义，那怎么做，非常简单，先看一个文件叫喷我文件，power文件跟我们刚刚那个spring boot是相呃。

跟我们那个maven是相互关联的，大家看一下里面有什么样的一个东西，好吧，往下找，刚开始上面写一个parent，是不是我们父母的一个东西，或者说一个副项目里面的东西。

还有个东西叫spring boot starter parent，这样可以点进去好吧，点击之后就看到有parent是不是各种各样依赖，the spot dependency，后面有各种各样的一个东西。

过过滤器了之类的相关相关属性配置，你这还可以往里面再接着点点，点完之后往下翻插这块儿是吧，这块属性我希望给你们看一下，因为我们之后再加载我们spring boot的一些相关的一些依赖的时候。

我们很少去写版本啊，为什么写了本，因为在他的父亲的父亲的这个配置文件里面，已经帮我们加了各种各样的一个版本了，这里面有一套配套的，所以一般版本这件事情我们就不会忘了，我们不会加了，不加也没啥意义，好吧。

这也帮我们定义了很多东西，好很多东西，这直接导入就行了，懂我意思吧，哇这里面这个配置啊下去之后可以详细看一下之后，像原版的时候我会带你们详细看啊，这是我们这个附体里面的东西。

再来看是对于我们当前这个项目的，那告诉你说这节课的版本是1。8，这有个dependency是我们的依赖，一个叫web，一个叫test，这块希望大家注意一件事，什么东西呢。

在我们的spring boot里面，它定义的这些依赖都是非常非常规范的，什么东西上面全部叫o r g three framework，点bot下面的都是three boat，gstar开头的。

后面是一个web，其实这个start就告诉你了，留情期之后意味着什么，如果我想加一些其他额外的组件的话，只需要加载对应的一个一带就行了，这东西怎么加啊，也非常简单。

来往下看，我们来找一下吧，还是要去官网找啊，知道在哪吗，官网我们看英文官网在哪找，你选这个叫user spring boot，停了之后，你往下看看这儿有个哪去了。

往上看在这块什么东西叫spring boat application star，只有一堆的启动器对吧，ret m q a m p p，然后呢a p然后呢有bg catch，是不是各种各样的组件好吧。

你后面需要用什么是dj b a d d b c dj p a好吧，l d a p mango对吧，你有for这个release是什么都有直接检查我们的pom看一下，在画布之后，这会有一个对应的依赖。

你把下面的一些dependence加进来就可以了，我加进来就可以了，直接粘非常方便的一个方式啊，所以官网里面都把我们定义好了，拿过来之后直接把手站搞定。

懂我意思吧，那么现在我们已经把当前项目给导进来了，导完之后再怎么做，主要测试一下，说跟当前项目能不能运行啊，首先因为我导入了一个外部模块，导了一个test模块，test不用说了，你可以直接进行一个运行。

这非常简单的一个方式啊，应该是一个context loader里面写就行了，主要是我们这个web，也就是说我可以把当前项目当成一个web项目进行运行，但是你看一下，我这有部署任何跟他们相关的东西吗。

能不说吧，因为刚刚看到一个东西叫什么叫内建的。

看官网首页，在高考里面是不是有一句话找一下，玩法什么东西叫内建的一个运行时的一个支持吧，例如tom cat gt m的the road undertale，是不是各种各样的一个组件。

这块它的本身里面就有了把内置的好内建的这样的东西。

所以我们这儿不需要做任何的一个事情了，这块所以我刚才为什么你读那块东西，因为读完之后你能获得很多启示，现在现在怎么做呀，非常简单了，现在运行的时候，这儿你有一个package等同学老师。

谢谢ctrl开电脑，很多人都这么干对吧，想看出了之后又一个吧，因为class叫hello，ok写完之后里面就能写东西啊，我说主要写一个方法叫帕贝克，就是说ring hello括号。

然后里面写一个return，哈喽，这样写完之后本身非常非常简单好吧，写这块的时候需要你具备一个基础知识，就是spring mvc，保存完vc，当然我说过了，有些同学可能没之前没有接触过，之前没接触过。

没关系，这样你按照我的写就可以了，那这块要加注解了吧，之前我们家是怎么加的，这是不是写一个东西叫at control，搞定了吧，是不是搞定了，然后呢这块是不是要写写什么。

是写一个at叫瑞quest mein main，写一个对应方程的，要发生一个请求叫杠，比如写一个hello，是不是检查检查之后按照我们之前说的，除此之外你还要写什么东西。

这是一个at response body，是不是写这东西，等我先这样写，先这样先这样写，一会儿再说rise control的事，是不是先这样写，这样写完之后，我们现在该写什么呢，这是一个命函数。

是有in方法对吧，一会儿我们直接把当前项目重启，等下重启啊，现在要重启啊，报错了吗，没有吧，开启端口多少是8080，这个端口端口开启了。

在这个时候我可以打开我浏览器进行访问，the local host 8080，然后加一个叫杠，hello，听到了吗，是直接返回，就是我们的，hello，这有点大，我来，我写一个logo，h e r o。

这不是请到了对吧，这是一种方式，除此之外，刚刚同学说了，老师可以用一下rest controler什么意思，在我们刚刚这个代码里面，一定是不是已经发送了一个对应的请求。

请完之后，我这是不是返回去一个合格的做出，你这样可以做一个修改叫word，然后重新启动。

修完之后一定能看到东西效果。

改了吗，改了吗，是就我们刚才写代码，其实这个题就没问题了，当然很多同学在使用的时候，他不太喜欢用这样的方式，他应该怎么写啊，老师我要这样写，把这东西删掉，不要了，然后上面这块我要改另外一个主语。

叫什么叫rest，可说了，等下了吧，打完之后我重新启动，让他再进行一个访问走能用吗。

穿线清缓存刷新没问题吧。

是不是也能访问到，所以两种方式你在写的时候都行好吧，你喜欢用哪种就用哪种，这无所谓啊，这个东西没有什么版本的一个限制，说我必须要怎么样好，这东西没有什么限制的，懂我意思吧是吧。

所以写的时候直接写就可以了，这是一个最基本的程序，大家看到了，我刚刚运行的时候有什么区别，vs ctrl就相当于是我们的ctrl加上我们的results bu，他返回的时候只能返回一个字符串。

返回字符串啊，这东西啊后面会讲到用，担心好吧，这个是不是一个这样一个ctrl，刚刚在我们的官网里面。

官网里面，他这是不是也给了一个建议，找一下找回叫格林start，哪去了，刚才是不是给了一个叫start，这个只要不说你第一个spring boot的一个项目，项目完了之后往下走。

这边告诉你说我要写什么东西，往那边去了，看这这写的什么东西，叫这是ctrl吧好吧，官网里面是不是推荐我们这样做的，所以你写的时候也可以这样做好，也可以这样做，直接把这个写成它就可以了。

刚学的时候还是那句话，在初学的时候，你就按照它的配置写就行了，他怎么写你怎么写。

你粘过来就搞定了，懂我意思吧，但这块我希望仅呃提醒一件事好吧，特别是对于我们对应的一个初学者，这点非常非常重要，非常非常关键，所以不太注意啊，这个启动器我能随便放位置吗，比如举个例子这块儿我在里面呃。

在这里面吧，再创建一个package，这写一个test，写完之后，我把刚刚那个移到我们test里面去，也去了吧，移完之后这块我是不是又可以运行我们的程序了，运行走，看到了，这是不是已经没问题。

启动好了吧，当你启动好这个东西之后啊。

那怎么办，我是不是又可以进行访问了，还是一样同样的请求地址是吧，告诉你说错误页面对吧，我们问过扫描不到好吧。

上面要加一个配置项吧，什么妹子叫叫auto哎，诶那去了干com s干嘛好吧，后面加一个组件加什么，不加上我们队的一个the com，第二把士兵，可是我加加加加上一个这样的组件和加加的组件。

加完之后我再重新启动。

然后呢我现在在刷新，听到了吗，听到了吧。

这是不是请到了大家发现了，原来我默认情况下，如果我没移动之前，它默认扫描是什么，但有些同学当然一般是没人去动它的，这肯定没问题，他不注意不注意之后，他把这个报告位置随便都是乱放。

之前我记得咱们班有一个学生，谁问我来着，就是这个问题，所以其实报错了，这个时候一般情况下最好不要动，为什么不要动，因为在我们的这个注释里面啊，注释里面它有一堆的一些自动的一注解吧，好吧。

这个注解也很重要好吧，注意这个注解也很重要，把这块讲就是相关的一些相关信息，其实注解一会儿我们再聊这事儿，但你要知道，如果你改变了，你要加上我们这个component，然后把对应的路径给加上。

加上这个路径之后，它就能进行扫描了，但一般我们没人干这事，所以你把它给移出来好，弄弄弄错了吧，老百姓，我会把它删掉，就是你发完错误之后，发生错误之后，你要知道在什么地方能做一个对应的修改。

好遇到什么问题怎么解决，它就搞定了，懂我意思吧，好吧，ok这是我们刚开始spring boot的一个基本讲解，大家看到了难吗，不难吧好吧，非常非常简单的一些东西，一些配置啊，很简单的一些东西。

后面这个resource里面有什么东西，一会儿我来我我我会来说好吧，我们通过源码且能看到很多的一个配置，懂我意思吧，注解我问一下呃，咱们同学有人自定义过注解吗，有人自定义过渡解吗，都不能用过是吧。

想要资金注解没在这块，我希望大家明确一件事，明确一件什么事情呢，注解其实是一个非常重要的东西，而且非常怎么说，虽然非常非常好玩一点，一会儿如果大家没接触过的话，一会我来讲一下自定义注解。

在我们的jdk里面，它默认提供了14个叫圆注解，叫元注解是吧，什么叫圆柱体啊，一会儿来解释，ok我们休息一下，十分钟之后，我们回来讲一下重点相关东西之后，你再看注解的时候，你就不懵了，懂我意思吧。

别看了注解之后，我看原版时一看这些注解是干嘛的，不知道好一会儿来讲这些东西，你知道了好吧，一会再聊，休息十分钟，十分钟回来之后，我们再接着讲好吧。

这人就不多说了啊。

系列 3：P56：【Spring】课间答疑 - 马士兵_马小雨 - BV1zh411H79h

我能看一下pom文件吗，能啊，破文件在这块儿想看啥啊，呃死人后要学到什么程度，其实不需要需要什么程度，但是很多同学说老师现在面试被问到源码了三分，之所以咱们就把源码讲一下，你记住啊，它就是一个工具。

反正我的理解存不就是工具，它就是应用层面的东西，懂我意思吧，工作会用就好对，确实这样的面试的时候可能会问一下你这个相应的一些原理，好相应的原理，这原理东西啊，咱开源码之后就知道了，别慌，能面试就行了。

就是自动装备，你把自动装备搞下来就行了啊，今天晚上这么多人没人过平安夜，身边都没有女朋友，哈哈哈哈哈，老师吃了几瓶啊，没吃呢，都在外面摆着呢，那班主任不给你们发了好多图片吗，嗯，你还有科比女朋友重要。

别吹好吧，别吹啊，初二陪天20炮，我说孤单，你陪我干嘛，我回去回不去，你回来加班，那中泰项目是不是要关联大数据的知识非常非常多呃，中台这东西啊是最近才提出一个概念好吧，然后我给大家看一篇博客啊。

你的中台比较感兴趣是吧，中台，这些东西，大家有时间可以看一下这个帖子，就有个中台四节是呃，后续的话给大家讲课的人啊，就是中台四节他们单独出了一出来之后成立的公司好，到时候你就知道什么叫中台了。

会有现成的产产品给大家做演示，你放心。

这个没问题的好吧，先让自己了解下就可以了，呃怎么说呢，这就是大数据里面东西确实关联很多，像他读博哈维这辈子可能都要用到，最好还是换的，最好还是会一点吧，会的可能更好一点。

看一下spring bot在使用上相比于之前的spring mvc更新的注解，然后还要取消了配置文件，这样呃，但如果单纯从应用层上来呃，层面上来说的话，确实是这样的，单独从应用上来说啊，就是这样的。

一期的spring源码呢还没看二期的特征描述，我们spring的源码应该不会讲啊，呃基础课的时候我会再讲一讲啊，基础课会再会再讲了，先看一七还是27，这东西看你自己的一个水平吧，看你自己一个水平吧。

这东西还是怎么说呢，二期的话会有像只不过很多同学最近在问那个私人bot，那个量化什么投资平台的项目还有吗，有但只讲一期，但只讲一期好，只讲一期，随后大家讲几课，6_8节，68节，明哥说。

穷人不会让你朋友玩，那个量化投资只会讲一次，之后就不会再讲了，那东西怎么说呢，怕你们着迷哈哈，本来打算3月山谷跑路一期，哪些东西要优先学，如果你是为面试做准备的话，刚刚给你看的vip里面的东西。

像上面几个点，你是都要学的，上面你都要学的，散人boss是为网约车项目做准备吧，是的是的，哪几个这块儿。

第一个强调粒子高，一发这块要看第二个吧，如果不会被服务的话，微服务要看多线程高并发要看，然后这个gm要看nike和ni o要看，然后就是下面这个蓝色的条要看好，把这些点看完就行了。

陈老师网约车视频根本看不了，为什么看不了，最后留言，为什么看不了。

学生boss要先学哪些课，s你要会吧，spring源码暂时不需要吧，呃你你可以你可以看，当然很多同学反馈说那个呃听不太懂啊，这所以这块也跟自己情况吧，我建议还是看的建议还是看的建议还是看的。

因为怎么说呢，呃很就是看一下面试的时候有的吹，就比如说ioc和op的一些底层原理，你要知道他的一些environment的环境，你要知道的这东西必须要知道，这次跟我讲项目。

你说纯的那个spring boot呀，你们需要我们做个增删改查，这没啥，你们需要我们做增删改查，这没这没啥，你就跟s一样，你们需要我就找一个前端模板，我们直接投模板，我们前端不得了，不要浪费时间啊。

就是我你们要说的话，就找一个前端模板，我讲下增增删改查，坐一下看一下就知道了，那个很简单的，没啥难度啊，我觉得这个东西没必要，反正你们之后马上接触网约车，网约车的时候，项目里面有代码。

到时候也可以用基础课，看什么时候开始讲点深的东西吧，肯定会讲的啊，肯定会讲的c2 是没必要，我先讲一些想先讲一些基本的应用，等我把这些基本的应用，因为咱们班有很多同学可能之前没用过。

所以这些基本用还是要讲一下的，讲完应用之后就可以开始讲源码了，所以大家如果这个基础应用都会的话，你可以暂时先不听，讲源码的时候，我会让那个班主任老师在群里给大家做出通知啊，这在群里大家都做通知。

到时候你来听也可以，可有同学提现的东西可能感觉比较简单啊，你如果觉得这个东西拿费时间就没必要听了呃，看下别的课也可以，这东西自由选择，无所谓啊，老师的课件在什么地方拿啊。

所有的相关资料都会在我们的get up上面进行展示啊，都会有get up展示，开始听声音做项目，谁听着声音做项目。

呃课件在这儿可能有很多新报名的学生啊，要说一下吧，咱们那个所有课的课在所有课的同学都在里边啊，这同学大家说一下吧，第一个是我们那个架构师课程里面，把之前讲的知识点都在里面，都给大家分好块啊，放好快啊。

这里面都有啊，这边都有，然后呢第二个第二个就是我们的大数据的大数据在这儿啊，这边不在这儿啊，这是那个后端工程师内容课的东西，好吧，就jo c里面的东西，都在这里面，你现在里面能看到很多东西，懂我意思吧。

咳咳，为啥我感觉ioc像多肽，我今天先看其他课了，等会再来，可以啊，讲原版的时候，我会在群里面都通知的，大家如果觉得这东西比较简单，你可以先不看，这没关系啊。

主keeper和release的文件夹里面是空的，可能吧，这有项目吗，这有这东西吗，有的，基础课基础应用课大概讲几节，这看大家把今天讲一下，今天讲一下，明天讲三节课吧，三四节课样子吧，三节课吧。

最多三四节课，最多，k8 s和docker在上传了吗，上传了上传了这这没有什么，看一下，没有的话，一会我更新一下，一会我更新一下，之前班主任忘了，之前班主任忘了，一会我更新一下，一会下课之后我更新一下。

等会扣我k8 s北京是不是很冷，是的，今天很冷，不加思成考怎么会，一期的时候是讲一些基本知识点，做了a项，后续的话我们把spring co详细讲的，周尔发个图，如果没有的话，找班主任要一下啊。

周尔发个图，要不把ioc和dotm关联写的是集大成吗，这个架构师这个歌单目录啊比较大，300多兆，所以有时候可能会比较多，你最好下某一个啊，一个一个下，樊东红，如果哪个资料没有，你去联系班主任。

然后班主任老师给你找好上课资料，我们都留着，主要有时候老师可能会帮我上传啊，这都有啊，最好听一下吧，二级会比一期更全面更完整好，会把一期课更全面更完整懂你说这块儿不用不用不用疑惑啊，嗯如果你面试集训。

你就听一下，面试基本不问你就行，不问就行，呃我还是那句话，你要知道我们这样设计这个课的原因是啥啊，都是已经在职的，都是已经在在职的，很少有小白的课，很少有小白，所以就说我们希望你在工作的时候。

或者你在工作过程中，应该知道哪些是需要，哪些是不需要的，那应该也非常的辨别能力好吧，游戏项目建议你们还是学一下，里面用到很多nike的东西，我觉得挺挺挺挺挺重要的，如果这个公司分到难题了。

你把这个视频看了之后，基本上都搞都挺好玩，在职的才是小白，那些在校时大佬，哈哈哈哈哈哈，咱们这个在校学生确实有些东西有些人是比较出色的，像斗罗的s对吧，心强这些人确实比较优秀，小怪兽。

系列 3：P57：【Spring】Springboot配置文件及区别 - 马士兵_马小雨 - BV1zh411H79h

好了多余废话，咱们不再多说了，再多说了，咱们就聊这么多吧，下面呢我们开始正式讲课程来，还在同学扣波一，呃大家记住一点，还是那句话，呃，因为咱们机构啊说实话成立时间并不是特别长。

所以可能有很多点可能给大家做的不是特别到位，所以如果你对哪个点有疑惑啊，或者说那个资料找不全这些东西你及时联系班主任，班主任老师会写到我们这边给大家补上的啊，这大家不用担心啊，该有的都会有的，ok。

呃我们后援会做的越来越好，但是希望大家如果有哪些地方找不到，不要着急好吧，就是联系班主任或联系老师都行。

来我们下面接着讲我们的three boot，刚刚呢我们是不是创建了一个项目，当然这个项目在进行创建的时候，然后解压之后运行的，在公司里面啊，在公司里面一般没人这么干，太low了，我也说过了。

在我们的idea里面，它本身自动集成了我们这样的东西，所以怎么做非常简单，我们把当前项目给cos掉，我们看一下在idea里面。

idea里面怎么进行一个创建，来干掉，创建一个新的项目，注意在这里面你直接选择这个spring in ler，好初始化一个东西，写完之后选择上这个默认的一个网址，点next上面写的时候也一样。

大家看到了，跟我们刚刚那个东西几乎一模一样，把萨利干掉掉啊，别东西就没有了，然后点next的，这样可以选择我们需要的组件，假如说你需要外表选外表，把第一个给选上，假如你需要先跳y者工具。

比如说one box，再比如说那个热部署，你根源上可以了啊，这直接勾，不需要进行任何的一个搜索好吧，那再来看next，然后这可以选择我们对应项目的一个目录吧，这个目录我给他改一下。

我给你们单独成立了一个目录啊，这有一个spring bo，六就完。

好判断了，十点钟我们准时下课，下课之后，你们该去宾馆去宾馆，该去旅店去旅店好吧，该干自己事干自己事儿好吧，不浪费大家时间啊，2123看到了，把这些gmv这些项目都给删掉，我没有网盘，我有时候看他难受。

我就把他删掉，你们不想删也没关系，不想删也没关系，ok好了，下面创建的时候呢跟我们刚刚是一模一样的，大家看到这个目录的结构，目录的结构跟我们刚刚看到一模一样，所以这块你直接拿来用就行了。

好非常简单的一个东西，非常简单的东西啊，好了，下面呢我们再接着往下讲。

对应的知识点讲什么呢，刚刚我们简单部署了一个web上面的一个项目，外上面的一个项目讲完之后再说了，有两种部署的一个方式，一个是three start spring io来试一下，第三个。

这有一个小玩具啊，什么叫动态生成我们队的一个banner，这东西是一个小工具。

我们这儿可以做一个基本的演示，就这块你看了之后，你每次启动的时候，这会输出一个什么呢，叫spring book这样一个东西，如果你想改变的话，也非常简单，官网里面告诉我们了，我们这应该怎么做。

二三是不是这样的东西，你看他难受没关系。

你可以做一个更改，这是在哪儿啊，很简单，我们找一下官网里面的东西，还是从官网里面找，返回返回找一个user spring bot，这个东西叫banner，我们找一下banner哪儿去了，没有啊。

找到了啊，这儿这儿这儿这儿有啊，我们找一下这个b，诶怎么没有了，他那不是有资金在哪，这是自己在哪，点开之后，这个出来告诉你说你要仔细变，说可以通过在plus里面加一个半导找txt的文件。

然后呢或者说把这个位置指向我们对应的一个文件。

你就可以进行一个更改了，非常简单的一个方式，我们来简单做一下啊，打开resource，这里面创建一个file叫banner。txt学民歌是吧，刚才说出学民歌这块该怎么做呢，非常简单，这儿给大家两个网站。

这样网站你都可以直接用来进行一个商场，sn book里面这个叫人报了班纳直接写，这可以写什么呢，这是不是有这个东西划开电源线下生成，是不是对应这样这样这样一个图标。

你把这个图标直接粘过来看c张张我们这个文件里面来。

装完之后，我们再重新启动，看到了吗，是不是能看到对应效果了，接下来之后你可以做自己定制化的一个慢点一个小玩具而已，如果不需要，就算一般啊，没人搞这东西，反正我觉得这东西如果是初学者的话，可能觉得挺好玩。

你可以试试啊，你可以试试这东西啊，没没没没多大价值。

这是一个网站而已，把这网站给大家，你从百度饼直接揍起来这个网站，然后除此之外，除了这个网站之外，还有另外一个网站，这东西这玩意里面也能进行一个搜索，比如说叫什么士兵，是不是有点东西啊。

你生成完之后拿过来之后直接改就行了啊，也是一样的，明白了吧，佛祖保佑永无bug可以改啊，你可以自己去改，我们这不浪费时间了，你知道有这样东西就行了是吧，能做一个对应的一个修改哇，非常简单一个小工具啊。

你把它用一下就行了，所以给大家简简单说一下，看完之后往下看看，这个东西叫私人bot配置文件好吧，终于到我们的配置文件了，配置文件这块其实非常简单，刚刚我们开启了一个外部项目，你可以直接进行一个运行。

进行一个额部署方面的东西。

我说了，打开我们的泡沫文件，破文件下面呢有一个东西是一in，你通过plin点开我们的maven project，在里面有一个lecircle，这有一个东西叫package，你这生判断之后。

大家看一下这个效果，比如最终你们如果写完spring boot程序之后，你可以放到我们对应的一个服务器运行，运行的时候用我们java的运行就可以了，这样可以把target是不是这样，pro是不是这个。

然后呢，seventy。

他直接扎a杠，扎，回车看看吧。

他可以直接运行的，这不能报错了，这种错说这个808是不是已经被占用了。

因为我这是已经启动掉了，这是已经启动好一个了啊，停掉，一样的，随时开启了一个8080端口，把运行之后能出来，我们对应效果就这个东西，所以呢你可以在我们的idea里面运行。

也可以放到我们对应的一个服务器运行，运行方式变得非常的简单了，还是我们对应的视频网站也好，下去之后知道怎么部署就行了，非常简单，一个小点，藏獒藏獒返看一下我们对应的一个配置文件。

之前啊，我们见过各种各样的一个配置文件。

在我们当前这个resource resources这个资源目录下面，你可以填写我们对应的一个配置文件，这个配置文件我要写成配置文件，其实也非常简单。

刚开始的时候这个东西叫什么叫obligation properties，这个properties你在写的时候，它有自己的一个固定格式吧，什么格式叫k等于value，是不是必须这么写。

这样写本身也没啥问题，但是在此人bot里面好吧，他给我们推荐另外一种比较好的一个方式，叫y m r或y m a r好吧，有两种这样的一个配置文件来简化我们配置。

很多同学说老师我在用那个压码文件进行配置的时候，发现他有很多坑啊，发现有很多坑这个坑啊，只不过说你对这个当前配置文件不太熟悉的原因，如果你对这个文件足够熟悉的话，这块是没有问题的好吧。

而且写起来是比较简单的，懂我意思吗。

那我现在怎么做这件事情，来看下这怎么写啊，还要说了，配置文件连他这有一个对应的文档吗，我把这个文档地址拿过来，我怕怕自己找不到，转过来，转过来再告诉你说优点y a m2 。

说使用我们这样的一个亚马尔的一个配的配置文件了，这告诉你们环境里面有第一位，有production，这个开发环境，有生产环境，你这都可以进行相关的一个配置，如果你不用这种方式的话会怎么办。

用我们的property这样的方式，properties的话就是我们的k等于y等，而在我们用样貌的时候，现在是不是冒号冒号冒号是不是k冒号为这样的方式啊，只不过前面如果你有很多重复的好吧。

如果你有很多重复的一些数据的话，这是不是不用重复写了，有这个东西用vironment再看看是不是写一遍，所以呢这块推荐大家使这东西好使用这样的方式，你就还用property，也没关系啊，也没关系的。

这块反正都一样啊，都一样啊，配置文件吧只是为了加载我们某些的一个属性，你只要把这些属性应用对了，这块是不会有什么问题的，懂我意思吧，这也说了两种方式，一个叫k等于v，一个叫k冒号，然后空格value好。

这块注意了，一定要加我们的空格，公章怎么写啊，来先写一个最基本的一个配置，写什么叫server，是一个炮塔，回车看看这是不是直接等于号，比如说8080，你这样在运行的时候把它关掉，谁影响你。

这是会指定端口号，这是我们的properties这样的一个文件来运行，是不是也是8080，如果不指定，默认是8080啊，你这可以改叫8081，再重新运行，你这样看到这个对应信息更改啊，8081吧。

好这是其中一种配置文件的方式，与此同时，我可以在这下面再建另外一个配置文件，fail叫什么application，这样y a m2 是不是这样方式，这应该怎么写，叫server依然有提示回车。

他看到了吧，8082看到了server冒号，然后加上我们的port冒号，加上8082，那就是大家想一下，如果我两个配置文件都在的话，我会用哪个可以的在吗，可以吧，来运行看看效果，多少看这个值8081吧。

好吧，那怎么办，把这个文件干掉删掉，别掉删，我随便删啊，这项目里面东西随便改无所谓啊，我看看多少8082了吧，主要这是不是改过来了，所以此时你在写的时候好吧，谢谢大家，反正我个人啊。

我个人喜欢用这个键帽，好像英文歌词又不喜欢那个pperties，这无所谓啊，这无所谓，你这样写的时候，你就用它好，特殊点，不管你用property自由啊，用我们的爱ml文件也好。

这块都有相关的一个提示吧，比如说three dimv c点是不是可以加很多相关的事情，表达方面是对应对应格式，这么说，data source，是不是可以配置我们对应一个sos源。

这就是内部password等等东西都有，把都有好吧，这一定要注意了，所以这块儿属性写的时候，它会有对应的一个提示，但这块要注意啊，你在写具体值的时候，如果把中间这个空格给删掉，把空位删掉。

这块是不能识别的，所以建议大家把这个空格一定要加，一定要加个空格，大家看到了，前面的字体是不是也你是不是也改变了啊，这是变成那个橙色的了，懂我意思吧，怎么配这两个数据源这个东西啊，咱们讲数据源。

然后咱们咱咱们再说好，再来设计不大好，再来设计设计不大，ok就这样一个方式加一个boss上睫毛在boss上干嘛，这只是一个简单的一个配置文件，好简单的一个配置文件，就大家知道这个东西怎么配就行了。

只不过在我们当前这个配置文件里面好吧。

它会有多种多样的一个属性吧，你根据我们的属性去加就行了，然后这边给你列出来了，说我在使用这样的方式的时候好吧，它有什么样的对应的一个区别，好两种配置文件的一个区别，这给大家写出来了。

好配置属性的一个数据，啥意思呢，这有个东西叫configuration properties，是不是提到我们的注解了这个东西叫at the value，是干嘛的啊，这干嘛呢，好是不是有功能。

有什么素材绑定s p e r，然后呢js 233复杂类型的一个村庄，是从网上抄的一个图，网上抄了一个图，这图里面标注说哪个配置文件支持哪些相关的一个信息啊，哪些配置文件支持哪相关信息，这块怎么验证啊。

其实也非常简单，我们这儿可以来写一下，写什么，刚刚的配置文件是我们直接加载的。

什么是我们spring boot里面默认的一个配置，与此同时好运，同时我这其实可以定义自己的一些配置，比如说这个person冒号，快写一个name，冒号张三好吧，这括号12，然后呢再写一个size。

冒号冒号再写一个南，ok再写一个，还有啥呀，多少次冒号再写一个，知道这些boss了还是类型，政策类型都都都都用到了，还有一个list的吧，比如说写一个叫那好，再写一个book，看到了。

如果你现在想想写一个例子怎么办，我写一个类似的，这怎么写啊，写的方式也非常简单好吧，回车后面加一个杠，加一个叫杠m m m o v i e杠，这写一个go可以吧，是不是这样的方式好吧。

你把这些东西定义好，当你定义好之后，我该怎么写了，定义一个，卡斯哎对了，配置这写一个叫nt，里面就有一个psl软件p嗯呢定义好之后，里面可以写到private string name。

然后呢private integer这样写一个让他private，然后再往写private li，nice，相对我们对应的一个c有属性，当你这块定义完之后，还有怎么写，一样的。

把他的一个4s的方法生成一下，ok同样的生成一下我们对应的一个构造方法，下面再生成一个，副词缀就搞定了，好吧，这对于这样一类，现在我想做一件事情，什么事情，我想把我当前这个类的属性都加载过来。

你告诉我怎么做，就说我现在这些属性是不是没有值，没有值的话，我想在这个类里面把这些属性值都给付过去，我怎么付，你们知道吗，怎么写at value，对不对，怎么写，再写一个小写at。

value l u e这样写吧，后面呢写上我们对应属性值是这样写吗，该写一个person，点name这样写吗，好这样写也太麻烦了，这样太麻烦了，你是不是每个属性都要加，如果有100个属性怎么办。

好刚刚同学说了，安于此生，上面加一个叫艾，reciproperties加它，然后后面加一个前缀叫perfect，好吧，后来等于什么，刚刚是不是写了一个6p，大家看一下，我知道是不是信号它了。

我这是信号它了，当我写完这个属性之后，我现在不要测一下了，我怎么测开了啊，怎么测，他现在就能把它注注注入进来了吗，就能把这些水就拿过来了吗，你知道做些测试，对不对。

这不是测试类测试里面我要定义一个东西叫person，person，上写一个艾特奥特曼了，这里面写一个属性写啥，写一个叫s o u t person，不错的，裤子上都歪了，不能到位了吗，没啊。

这少写东西上写啥艾特，p o i n t o o n component，写错了吗，c o m啊，这对吧，写完之后这有问题吗，没了吧，那这块的话我是不是可以加一个对应的一个测试了，好运行一下。

看看这边打印的一个属性值，往下翻，看见了吗，这写name等于张三，a等于10 12，sx等于男less等于book movie girls，是不是把对应的一些属性都加载进来了。

也就是说这样的一个属性配置文件好吧，我除了可以加载我们spring配置属性之外，我自己的属性是不是也可以往里面定义，是不是在这样的方式啊，这个文件是不是比较好，好，你是直接往里面加一个对应属性了。

这东西啊你们之前应该是接触过的，或者说应该是了解过的东西了，这东西啊比较简单，关键点在于什么呢，在于说我刚刚加了个啥呀，第一个把它变成一个组件，它能进坦白报了。

第二个呢叫configuration proper，第四之后我如果带你们看源码的话，大家注意了，我要看到n多个什么什么purple list的相关属性啊，如果这样可以做一个搜索诶，怎么出不来data。

source，我看怎么重重写了，看这是不是一个东西啊，data source proplease，对不对，你会看到一堆的properties这样的配置文件好吧。

这个配置文件就是用来加载我们对应的这个m2 里面的，一个配置属性的，通过这些属性我能够直接把相关的一些信息再进来，所以大家发现了，其实最关键点在哪，在于我们的注解吧，好那ok问题来了。

注解这块是不是讲一下啊，有多少同学了解一下我们这个注解啊，你们之前说了，海洋老师讲课的时候讲过那个自定义注解好吧，其实注意了，注解是对于我们的gg dk里面自带的，它里面有四个叫圆柱解好。

叫圆柱体的东西好，我不知道你们怎么去理解它，也就是说我们在定义注解的时候，如果你打开任意一个注解，答完之后看到了是一个public，然后叫at interface，写了一个东西好吧。

这四个属性分别表示不同的意思，大家看吧，找到我们最开始的一个主类swimt，你把它分有什么呢，41干嘛呢。

你是做一个分别的一个解释了，之前在基础班的时候，其实我讲过这些注解的相关属性，给大家找一下哦，原来没觉的东西特别难啊。

那可能会可能对这个东西不太了解，你看叫增音注解，真想好说什么叫注解说，annotation是3号五开始引入新特征啊，中文名叫注解就别说了吧，他说他提供了一种安全的类似于注释的一个机制。

用来将任何的信息和元数据与程序元素进行一个关联，为程序的元素加上更直观更明了的一个说明，这说明信息是与程序的业务逻辑无关的，并且供指令的工具和框架进行使用。

也就是说如果你之后自己公司里边可能要封装一些框架，当你自己在封装框架的时候，你一定要自己定义自己的一些注解吧，是这意思，刚才说了，ation是一种修饰符，各个方法。

方法呈现变量参数以及本地变量的一些声明语句中，加注解是附加在代码中的一些原信息，用一些工具在编译运行时进行解析和使用，起到说明和配置的一个作用，注解也不会也不能影响代码的一个实际逻辑吧。

今天体操是一个辅助作用，它有什么意义，好吧，最关键是什么呢，是下面这块我翻说注解的一个作用，第一生成文档，这是常用的好吧，比如说java里面最开始的一个注解，常用的有as fat retur。

你在定义好一个方法之后，你在生成注释的时候里面是不是直接属性，第一个参数，第二个返回值都见过吧，把开源码的时候应该都看过这些相关信息啊，看打开看这块是有return吧，有paren吗。

找你找一些有参数的方法就看到了。

好吧，有parts这些东西，这些东西都是我们刚开始说的，就出解说了跟踪代码的一个依赖性，实现替代配置文件的一个功能，在编译时会进行一些格式检查，如add override放在枪法之前。

如果你这个方法并不是覆盖了超越方法之后，则编译时就能检查出来是不是它对应的一些作用了，这些文字性说明啊，你稍微看就行了，你要注意注解最根本的最本质的原理是什么，是反射好反射这块有人知道吗，都会吧。

没有人不会反射吧，来不会反射，同学给我扣个一，有不会的吗，啊会的会的，扣一不会扣二有不会的吗，没有吧，两大反射这块我补一个额外的知识，补一个额外的知识呃，第一次你们在接触反射的时候在哪。

接触的是在我们的g d b c里面，接触的应该是j d b c，在d c环节的时候，第一步我们要做一件事情，叫什么叫class，然后呢点for name，后面写一个com。

点mysql java是这个时候用的好吧，这时候有一个问题就是为什么啊，为什么，因为你这样写出完这个这个呃，根据这个字符串找到这个对应类之后，你会发现它会生成一个大写c的ex文件。

但你下面用的时候用什么叫driver manager gan，我这边manager是怎么知道这个类的，这里面会延伸出来另外一个机制，不知道有没有听说过叫spi，有人知道吗，有没有听过这东西，spi。

有人听过是吧，ok啊还是有多少同学听过的，就你可以四打我用了，ok什么学的最大好吧，忘了基础课听过，对我基础课讲过，我记得会讲了，基础课讲过这东西了，你说你要讲我讲过这东西了啊，这块如果大家不了解的话。

你可以看一下我基础课里面的一个笔记，你从边上板直接下载啊，jase这有一个o的笔记吗，s spn呢，哎你在这讲了啊，在o口是讲的二胡o上面讲的s p i叫java spi。

这样机制叫service provider，interface provide，应该是face好吧，是jdk内置一种服务，发现服务器提供发现机制，s spi是一种动态替换发现的机制，比如有接口。

小学时动态的给它添加实现，你只需要添加一个实现，这个我们经常遇到就是什么呢，sql的专栏好吧，其他不同的厂商针对同接口不同不同的实现mysql producsol，不同的实现机制提供用户。

而java的spi机制可以为某个接口提供服务实现好吧，所以这块下之后可以看看，我这边带着摘那个jdk源码，大家看的，所以这个文档下载之后，你可以好好了解一下啊，就产生自己实验，确实是这样的。

就为什么你加载过来的看起来是一个msl或是一个oracle的一个driver，为什么drive mage的时候在用时能找到好，这边到里面，我觉得我这个注释写的比较详细了，这时候可以看看。

刚才看到了很多同学对这些都不了解，如果面试问脑子就是个坑啊，所以这块大家如果不了解，那个数据库里面我讲这东西了，我稍微提一下这个东西，这之后可以好好看看，流氓不流氓啊，不管流氓不流氓。

但这些东西是很重要好，因为很多地方其实都用到了s p i，这样的一个实现啊，希望大家能够了解他吧，这个文档大家发现了，可以一会我给你共享出来，这还一样，其实就是查了五次过程，如果这东西你没听到过。

那很明显你是不是要学一下了，懂我意思吧。

所以大家看到了那个基础课里面我讲东西还是比较多的，虽然说是个基础呢，其实呃不那么基础，不那么基础，没听过，图片总是找不到，还一样，你下载过源top图图片之后，你把对应那个仓库下过来。

这些所有的图片我都放到某一个指定目录里面了，你需要把那个路径做一个自己的修改，改成你自己本地路径就可以了，好没有设置统一的网上图片路径，因为有些同学网不太好，就加有网，网，网不是特别好啊。

所以有可能在比较慢，我骗人我骗你啥了，我没讲的东西吗，sp，讲了，您这都不基础哈哈我再讲一遍基础课就没意义了，再讲基础课没意义，所以里面很多深点会大家骂的比较深，所以大家如果有基础课全学同学。

我还是建议把那个课好好听听的好吧，帮我下拉姆表达式了，我都讲的比较多对吧，好听听，ok好了，非法达到此为止，观察看是内置注解，在我们的那个jk里面，它提供一些内置语，比如all right，好吧。

呃dispk，然后呢，super warning这东西你们都见过啊，之前一直在用，但关键是不知道在哪儿呢，在这儿在圆柱解说圆注解的注解作用是干嘛呢，说负责注视其他注释，让呃负责注解其他注解。

jav中定义了四个标准的一个注解，他们被用来提供对其他idotation类型的一个说明，好吧，第一个还是他给的tt表示的是用来描述注解的使用范围，比如说你可以看一下当前这个注解它用在哪个地方，是类上。

马上还是变量上啊，所以刚刚你看到一个相关信息，比如找一个，然后他点完这个往上看，这是一tan告诉你说element type等于type，你点tape里面有什么有type，you failed。

有method，有pm parameter，constructor，local variable，然后呢，annotation type，还有我们的package就告诉你说我可以用在不同的地方对吧。

tape什么意思叫class interface好，in code annotation type of annual decommission，是不是告诉你是这样的一些相关信息啊。

比如说我这儿可以定在类里面接口上面对吧，都可以定义，这是我们太类型，刚刚看到了这个属性，把这个这个注解是不是就放在我们的类上面了，这个随便拨打的c上面，对他也是一个资金注解了，这第一个点。

第二个叫什么叫return retention，这个属性很重要，它表示什么是不同的一个范围，大家说reaction表示需要在什么级别保存该注解信息，描述注解的一个生命周期，有source表示原文件。

有class表示我们的计划文件，还有一个叫wrong time，刚刚你看到了我们刚刚那个主语在哪儿，是叫run time，表示运行时环境还依然要有它，你点开刚刚这个类，你会到有source有class。

有状态有关，是不是三个属性值，所以你在定义自定义注解的时候，你可以自己做一个合理的选择，我应该把这个注解让它在什么时候，在什么阶段进行一个生效，全部由你自己来控制啊，一个是源码阶段，也是卡子文件阶段。

一个是我们的整个环境的一个运行周期，你自己做一个衡量就够了，懂我意思吧，好吧，这块的一个配置再回返，这不用说了吧，得分是什么意思啊，是否在加a d c中展示出来，就这意思好看。

第四个叫inherited，啥意思，是不是说说明此类可以继承父类中的一个该主解，父类子类能不能进行一个基层关系，所以刚刚你通过这个圆柱体的一说明之后，你这样能够发现什么信息，target是我们的看法。

可以在类上接口上面或者资金注解里面，然后呢这边的范围在运行时环境还有文档，是不是生成文档会会进行一个呃，d o c里加了d o c里面会不会有最后一个叫是否有继承，这边有啊，你点开任何一个注解之后。

这都有显示1234啊，这有三个，这这这这这个地方是不是不是不能被继承啊，对吧，再点开，你看这个地方是不是12344属性吧，几乎所有的属性都一样，明白了吗，所以以后如果你需要去自定义注解的时候。

你也可以用这样的一个方式好进行这样的一个编写，这个容易吧，来听同学给老师扣波一，就说你要知道这些属性是干嘛的啊，这人属于干嘛的，我们这儿其实可以做测试，把做什么测试来，我来写一个啊。

给大家做一个测试试试呃，在哪写啊，定一个吧，你们都不知道我们做一个测试啊，知道容易用起来不难，来来看看这里面我定义的时候，这注意写了，要改一下，叫at interface，interface写完了吗。

写完之后，上面写一个at，第一个叫什么来着，第一叫啥就四个吧，他给他吧，是告诉你他好吧，后面写个字之后，你注意你看下它的类型叫element，太好吧，先过来哎，哪去了，lisation 2 v。

然后呢点儿我要写一些东西，比如说写在field上面可以吧，第二个写完之后可以写一个at，啥叫re 21，真是好吧，这一样的，它也有对应的一个类型叫retention purpose。

第二run a run time对吧，第三个叫at dot，问题的是他不继承没关系，你下来之后可以怎么写的，比如说这定义好这个注解，我前面定一个类，class test，这几个parade。

我再加一个叫at，还有微信能加吗，能把再写一个public void，叫呵呵，括号at这是一个my annotation，什么效果，这是报错了，为什么报错，这怎么这怎么写啊。

逗号element type，他报错吗，不错了，这是视频field，是不是加一个master的，你加上mac pro，这还有有错误吗，是不是没错误，这种使用很简单，所以你定义好是什么。

你通过这四个圆重点能定义好我们对应的一些相关属性，用完之后拿完就直接用就行，就这意思，虽然用起来并没有很麻烦，关键是你敢不敢用它，你现在啊很多东西在公司里面可能用的都是别人，怎么说呢，就是现成的。

特别在一些大公司里面用的是别人现成的封装好的框架，拿这些出去之后拿到这些用，因为有一些文档有说明文档，如果你需要自己去开发一些项目的时候，这东西必须要有，我这不是写的简单案例，你说什么都可以不写对吧。

这个自己注意有啥用啊，我是检验是一个案例嘛，简单案例嘛，你看一下这里面写什么东西，你这边是可以定义我们队的一个属性值对吧，是不是可以定义我们对应的一个方法都有吧，好想定一下，你定义下行了。

再比如说你们在写的时候，一般写注解的时候，比如你自行注解后面那是有个括号，这是对应的括号，这个括号里面应该写什么呢，这写一个叫，v v v a l u e，再写一个，还有这个string name。

现在属性吧，这写完之后，大家发现了是报错了，我靠这是什么东西，说变量内容，might not have been in r，没有进行一个初始化操作吧，因为一般情况下我们这是默认值啊，这默认怎么解决。

等于一个，张三是不是写的，当你写出来之后，意味着我每次在使用注解的时候，我这里面有个属性叫name name的话，就可以把它复制叫张三，而一般我们在自定义注解写完之后，这不写一个at呃，叫什么啊。

不是标题，这and my own nation，这可以写个什么数据，比如说括号这写一个name等于，写一个合格，说一下这样一个属性值，有说老师这不对啊，他好像没有这样的一个方法名称。

下面你要提供一个与之对应的一个公共的方法，什么方法，你在不会写的时候怎么办，你看这里面的东西啊，我们找一个方法，这有没有方法看一下，看这，default，这样写一个值吧，张三，代表诶这都没有啊。

这几张4g，看效果吗，它默认情况下，默认情况下是不是我们的一个张三，这个值保障折完之后，我是不是可以改给他改属性，你们在使用注解的时候，是不是也是改里面的属性，这是不是可以直接进行定义了。

就这意思就这意思啊，就这样一个方方式应用，如果大家还有疑问的话，我们抄讲十分钟了就够了啊，如果大家对这块还有疑问的话，怎么办，也非常简单呃，我在基础班的时候讲过这样一段代码。

大家看一下啊，这应该有一个叫拉姆达，annotation，还有antation的一个注解，一个一个代码，在之后可以好好看看，好好看看好吧。

这里面讲的比较清楚，这东西不难啊，你下一周后自己搜下也能截掉，有很多同学不太喜欢写这些东西，写词而已，懂我意思吧，好了，这个字音注解能过吗，能过的同学扣一分，过同学扣二，这很简单啊。

你你下次自己自己自己练一下好吧，我不浪费时间说这些东西的基础班讲过了，如果这块有问题的话，我把那个基础班视频拿出来，还是不知道他写的，那我怎么办，我再给你讲个需求来写一下，没得必要啊，没必要。

我还是那句话，你自己封装封装框架的时候，可能需要用对自己说，不封窗的话就没必要用了，你关键是什么，你要能看懂这些注解是干嘛的，好，现在你能看懂这些注意就行了啊，你能看懂这些注意就行了，这是什么意思。

所以能坐在什么地方，还有别的用处吗，你想想你，你你这定义的注意有什么用，你是不是一spring application这个sprication。

它是不是在他的基础之上又定义了我们的spring boot configuration，你点开它点了之后，它是不是高品质，它是一个注解对方这些属性吗，那意味着我就可以用了，点开competition。

再点开再点开，到那之后是不是到头了，这里面定义什么东西了吗，没定义吧，是不是啥都没写，跟我刚写一样，是空的，懂我意思吧，上来就对你一个解释，告诉你说这周也是用来形成什么样的作用的，比如意义的一个实现。

就这意思啊，我不知道这个自行注意，还能还能还能怎么讲，还能怎么讲好，现在就自己看看，如果是有疑惑的话，我们再聊好吧，本来不在这浪费时间了，主要还是反射，肯定是反射，我刚才说了嘛，本质就是反射。

他们想看简解析器就要看里面的源码了啊，解析就要看演员了，那这东西讲完咱们讲不讲完啊，这样你有时间的话，我专门来专门录一个视频好不好，有时间我专门录一个视频，我们讲一下这个解析器啊，讲一下这个解析器。

我们不浪费时间了好吧，这个这个我没想到一个注解，你们会有这么多问题啊，这真的是。

这应该是他自己定义的注解吧，是不是发出来了，是不是有些属性值，你可以自己进行一些定义。

就这个东西行了，下去之后看几个一案例，看你用长就行了，ok好吧，删掉了啊，别打了行了，这是我们刚刚说的那个自定义注解，这个多写这个多写就好，对，就是多写，你写多了就知道什么意思了。

这个一点难真真真的一点难度都没有，没有啥意义，还是一样，在什么应用场景里面需要怎么用就可以了，好吧，这块你也没了解很深好吧，刚看到我们刚刚加一个什么。

就叫at configuration properties，点就来看一下吧，找到我们这一类啊，这加载这样一个属性，加属性之后，你发现了它定义一些注解，好吧，这里面读一些事情叫values叫什么东西。

然后呢告诉你说string perfect是啥，perfect是啥意思，profit是不是刚才第一列属性的时候，是不是加了一prov个前缀，如果你后面这不写名称的话，我再强调一点，如果你这不写名称。

不写名称，有可能你这边直接写个双引号，如果你直接双引号里面写值的话，它默认读取的是我们这个values，这个方法是这个values的一个方法，懂我意思吧，是value一个方法。

所以他会把这个value里面注入我们对应你需要写的一些属性值，现在也一样，定义的是不是四个对应普通方法有默认值，有数值，ok读完之后就搞定了，它有解析器。

当我读取到相应的一个confusion properties的时候，我要做什么样的一个处理，对应处理之后我要做什么事情，是把我们对应这个配置文件里面的一个相关属性值给加载进来。

加之后加载到我们当前这个属性的变量里面去，就这样的方式解一切，如果有兴趣的话，打下去之后可以自己看一下，好可以自己看一下，同学就发个啥。

这是写的战士也写，也是个应用案例，这都是大家之前应该写项目里面的东西啊。

写项目的东西啊，ok所以这儿注意这个配置就行了，如果这你没有加这样的一个属性配置的话，如果你用的是那个properties配置文件的话，你要怎么办，是不是必须要写一个东西叫at values。

写一下再写一下吧，爱的value写完as value之后，这是不是也是一个注解，我是不是可以点开这个注解，你看到里面有什么是一个value，那上写的时候该怎么写了，公告里面写了一个字符串。

什么类型叫person，点内容吧，咱再写画at，value，再写一个冒号叫person点，然后写一个age为大写，是不是前两个前两题我们来测一下吧，来运行一下，把这个注释注的注注了，周周我来打开。

我们刚刚看到这个测试文件，右击走，报错了吧，报错之后，你往上翻什么东西，他说，integer，string require，integer，写错了吗，没写错吧，这写的没，这没写上吗，找一下啊。

我们这写的是啥，就是12嘛，这不读直接读，读进来了吗，车为啥不行啊，他说不能解决我们的依赖，通过我们的fid的age，这写的是啥哦，这应该加东西啊，等会，这样行吗，忘怎么写了，来看一下。

开开属性值降价了吗，是不是张32都有了吧，这都有了，有了之后后面两只是空，没赋值吗，变成空了，所以大家想一下，如果你的属性比较多的话，你如果用avalue的方式的话，你是不是每个属性都要往这边写算了。

而如果你下面用完这个配置手机之后，你可以直接进行一个完全的一个加载，好，完全的一加载，就这意思啊，这并不是特别难啊，特别特别难，你注意有这样的一个属性值，你知道如何加载就够了。

这是我们这样的一个属性的配置，这样会这样列出来了，说两种配置属性有什么样的一个区别，第一个叫at a confusion properties，说批量注入配置文件中的一个属性。

at the value是一个至今指定，还有一个叫松散绑定，这个松散绑定是什么意思啊。

所以法令也非常好理解，这儿来举一个例子，比如说我在写这样的东西叫name，这写一个叫last详细内容，写他写他之后，我在定义名称的时候改不了，先把注起来，这定一个名称叫，last，老c，我来重新算一下。

把这个属性给放开，一九，怎么报错了，支持吗，那是内容现在结束了，改了吧，我哦没改，get last time sl，大写就通过标出来，要注意了啊，get大写走，那不行啊，last name，写错了。

成功破口吧，哈哈哈，这样改的比较麻烦是吧，这样把他干掉，干掉下面这个c的开发也可，写完之后这样重新生成一下，能抓的都要，下面也是一样的，加一个突刺追，现在没问题了，看着我这时候都进来了。

是不是能把这个值多进来对吧，这是松开绑定的意思，而如果你写一个as value的话，这边是不能够进行识别的。

是他们之间的一个区别来演示这样的情况，再来看看什么叫sp l是一个表达式的一个知识，现在不支持的，而jsr 33是一个数据校验，就是说我这加入之后建立规则，比如说邮箱的验证。

对邮箱是否也符合我们对应一个规则。

那这块你可以加这样的一个属性值，比如说写邮箱，我给他写邮箱之后，你上面可以加一个属性值，或者加一下试试，大家可以看看at有没有看这块了吧，我将按一秒之后，这个格式必须要符合你的一mail模式。

如果不符合的话，这就会报一个错误，来试一下吧，再验证一下属性不对应啊，你可以看下对面效果就行了，这回报有错，我没报错吗，啊少了一个东西，但是我再加一个a email之后，这些属性是没起作用，没起作用。

为什么起作用，为什么起作用啊，啊为什么起作用，对这儿少了一个对应的一个组件at，呃valley，这不行，所以大家看到了啊，这些组件啊几乎用的时候都是配对来进行一个使用的，是来进行使用的，不错吧，往下翻。

这应该有一个中文提示吧，哎你这种提示呢，看过了哈，看着他说这是不是一个合法的，变成一位地址吧，是不是告诉你该有提示吧，所以就说这里面可以用一个这个自己的交易规则，原来是我们在前端这块。

如果你js写的比较好的话，js是不是可以作为验证，只不过他把它截成到后端里面了，写了一个框架啊，写了一个那个注解，通过我们的注解来进行这样验证，就这样的方式啊，你知道就行了，你知道就行了，有这样的方式。

你知道就行了，这东西都是很小的一些细节点，对于一些初学者，这可能比较重要，所以你在工作中这些东西也也用的不多，因为一般教练的时候，我们都会放到前端，前端后端这块我们其实很少做验证。

但你要知道他提供这样一个规则方式做一个什么呢。

叫复杂类型的一个封装，一个是支持。

系列 3：P58：【Spring】配置文件位置的优先级 - 马士兵_马小雨 - BV1zh411H79h

改了就行了，ok再来看还有什么叫配置文件的一个优先级，也就是说当我们在写完我们的配置文件之后，配置文件之后，其实我n多个目录都可以放我们的配置文件，这个能听见不见，怎么放。

来往上看前后的录制作业一般没必要啊，一般没必要哇，前面只要做好，做好调研之后，后端一般没必要，一般你的规则都是一模一样的好吧，除非你的一些接口文档说明的不太清楚的话，可能都需要懂吗。

大家看我这写出来四个对应的一个配置文件目录，这四个配置文件的一个目录，不是我这随便写的，是官网里面给我们展出来的，官网里面有这样的一个展示目录，我这找一下。

嗯找一下公告里面给出了我们这样一个配置文件路径，就是说你在指定我们的压码文件的时候好吧，它可以有多个路径进行配置，但多文件路径配置的时候，你可以都都都写没关系，但它有一个优先级的概念。

也就是说你配的时候不能说我随便瞎配，这不合适哪儿去了，又没了算了不找了。

找一下不找了，大家看一下，我这已经给他写好了，我们从这些图上看吧。

就是说在这块还有四个配置文件的一个路径啊，前两天这样配置文件的路径，如果这里面有什么呢，叫fail冒号，然后呢叫点杠config g，还有一个file括号什么的，叫点杠，还有class class。

configure，class pass杠，大家看一下。

我刚刚写好的这个配置文件，它是在哪个对应的一个目录，刚才那放哪了，是放到我们这个result里面了，result下面是不是相当于是我们的class pass这样一个资源路径对，那我该怎么做。

大家往上看是做一个验证啊，呃把这些属性都给干掉，不要都删掉了是吧，删掉来做一下验证试一下吧。

在这块写的时候，第一个第一个是在哪来着，刚刚写的这是不是一个config。

下面fail指的是我们当前这个文件的一个路径，这样可以创建一个directory叫config，我这边我给你建一个配置文件叫application，第2y a m，现在我这可以写一个server。

冒号特8号，再写一个80808081吧。

8081，这第一个我们要定义一个配置文件路径，第二个是什么呢。

the fail杠，然后在这个当前目录下面，我们也可以建一个file文件叫ation，第2a t i o第二ym这边写一个server冒号，冒号要写一个80821样的。

在我们这个s2 c class path resce下面，在下面里面依然可以接一个config吧，这写一个右击进一个directory config，在config里面也可以写一个fail。

叫application，点怪a m2 server冒号托尔特，拨号8083，然后最下面是不是这里面这定一个叫8084，可以吧，当你这四个端口都定义好之后，我现在重启我们当前应用程序，把它关掉。

没有克罗索选择应用程序来右击走，你先看一下，现在可以越过去，我来看这个端口多少，8081吧，是8081，8081的话，大家看到哪个地方配的8081来着，是这里面写的是8081对。

那意味着我们的config这个的优先级是比较高的，优先级是比较高的，然后这个时候你把它给删掉，也就掉，上完之后，第二个是谁，是我们在外面也配了一个第二个cham呃，呃那个ation e y a m2 。

然后重新启动运行，多少8082了吧，探运气是不是也比较高，落地再把它删掉，走上完之后来再看，再次运行走，8083了吧，八三在哪儿，是不是在我们这个config里面，这是8083，把这个东西也删掉。

delete，那么在运行走，现在是不是应该变成8084了，对不对，大家看到了，我们刚刚通过这个端口号的演示，已经看到了它所对应的一个配置文件的优先级，所以你在指定的时候。

你要做一个查看，也就是说在这四个资源目录路径下面，你都可以配置我们的gm配置文件，问题是哪个优先级更高，哪个优先级更低，但一般情况下我们推荐好大家放到这里面啊，这边的话如果你的配置文件比较多。

你可以放到config里面去，它的优先级会变高，如果配置文件不太多的话，就直接扔到外面好吧，直接写到一个配置文件本区就够了，所以这是我们对应文件的优先级啊，这块有问题吗，来没问题，同学扣个一，很简单吧。

好像这些东西啊在我们的官方网站里面都是有对应的一个配置的，这东西啊并不是特别麻烦好并不是特别麻烦，ok这考完之后再来看中文属性，没有说了吧，表达式表达是什么意思啊。

啊这表达是什么意思，比如说我在写的时候，刚刚写的是什么，是具体的一个值吧，找一下这块儿在这儿写它我要怎么写，这样值一加唉，1+2能这样写吗，这个值能不能这样写，来我们试试就知道了。

你打开刚刚那个测试类走啊，拿错了，呃不是这不是这写这写错了，不不不不，这样不是这里面写好这个值啊，而在我们外层这写的时候，这可以怎么写啊，12找到我们的person这个类，person类里面。

我这可以怎么写啊，就说我这应该怎么使用我们对应的一个表达式这样一个注释方式，假如说你们用这样的方式，不要用，它，不是自动注入这块写的时候用它，这可以写一个1+2，我来再运行一下，哪去了，嗯还报错吗。

什么意思啊，哦，是把它给注掉了，好吧，这儿tur经住到了我inject，com就算一个六诶，不是这么写的吗，是这么写的吧，井号吗，写清楚了，大家试一下吧，好吧现在就好了。

就我们符号你这时候写成减号就可以了，在这里面也可以用我们对应的一个表达式这样的方式，但一般没人把它写表达式。

把他直播，是不是支持了这样一个简单用法，请此而已好吧，教练刚说过了，不多说了，最后一个叫多环境的一个配置，这个多环境配置什么意思啊，也就是说在我们的生产环境里面好吧，在我们的那个开发环境。

在我们的实际工作环境里面。

你可能会有开发环境对吧，可能会有测试环境，可能会有生长环境，是不是各种化环境，这个怎么办呢，啊这个怎么办也非常简单，在当前当前这个resource目录下面，你可以创建n多个我们对应的一个配置文件。

这块问题是你要怎么建，右击念一个file，再写一个objection，写什么叫杠，比如说d e v这样y a m2 ，这是一个server冒号，part再写一个8080是吧，然后呢再写一个。

test这y a n m，这是一个server port 801，是不是两个字环境了，在这里面我可以指定这样的一个属性，这不叫他叫什么，随便点，唉不对，这个诶叫什么来着，我忘了什么叫什么。

three profile t，对其他好吧，这可以指定我们对应属性，比如说叫d e a，第一位是多少，往上看是8080，现在我们重新启动一下，我们对应用程序走，看来测试啊，8080吧。

现在我把这些属性值给做一个更改，这样改成那是吧，这，test来再重新运行，多少了，8081吧，比如说你在生产环境里面，你可以配置多套我们不同的配置文件，然后呢在做切换的时候。

上线的时候换成我们第一杯好吧，自己练呃，测试的时候换成test是有多么不同，配置法师配置文件的作用，当然你也可以把它切换成pd 4都一样的，一模一样东西好，所以大家发现了这样码文件啊。

其实里面做的事情很多啊，推荐我推荐大家使用这样的方式，因为spring里面也是这么推荐的，当然你说老师我用用文件用的确实非常的麻烦，我就不想用它，那也没关系啊，你就用你的pd都一样的，这些属性值有直播。

这里面换成什么呢，冒号冒号这样的方式的，而其他地方用properties的话，换成是k等于value展示方式，所以合理选择就够了。

懂我意思吧，好在下去之后可以把我们spring官网里面关于我们的java文件的一个配置，这块好好详细看看，这样我们再不再详细详细说了啊，这个东西啊其实不那么重要，或者说这个东西不需要我来讲。

你看官网有能力把马上给学会，懂我意思吧好吧，这块儿来文文同学扣波一，问题啊，今天的东西算是比较基础的呃，我们基础课大概讲个三节课左右吧，啊三节课左右简单带你们过一下这个知识点就够了，好就够了。

下节课我们讲web相关的一个开发，然后之后我们就主要看底层的一些语法的讲解了，懂我意思吧，所以很多同学可能觉得这东西比较基础，比较简单哇，那你可以就是选择暂时不听好吧，后面的话我们会先暂时讲了。

懂我意思吧行了，大概就聊这么多呃，该过平安夜的，过平安夜，干过圣诞节的圣诞节好吧，希望你们今天晚上玩的开心，哈哈哈哈，还是周二周四周日是周二，周四周日，平安夜不平安，牧马人太太调皮了。

呃希望你们今天晚上玩的开心吧，ok那今天咱们就聊这么多，刚刚的话就是呃把刚才承诺给大家发资料，好吧好了，同学们多休息，拜拜拜拜拜，呃试讲，咱们中间插一下，这东西增删改来有必要写吗，等会再说吧好吧。

下节课我们再说。

系列 3：P59：【Spring】SpringBoot基础回顾 - 马士兵_马小雨 - BV1zh411H79h

此书页码还是我讲过了，如果你们觉得还是听着不太不是特别清楚的话，到时候在基础班的时候要不要重新讲一遍吧，重新讲一遍这东西啊，好了，今天呢我们接下来讲我们spring boot相关的一些知识点。

然后上节课讲完之后呢，我们讲的都是一些基础的配置和应用层面的东西，很多学生说老师那个我刚学这东西，然后呢可能学的不是特别清楚，你能不能帮我写一份笔记，所以这边呢给大家准备了一些笔记。

给大家放到这个地方了，好大看到有很多markdown文档，好吧，很多东西都已经写好了，所以一会儿下课之后，我会把这个笔记给大家分享出来，一看笔记就够了，ok我们先来对上节课的一个知识做一个回顾好吧。

我my sql基础家调小课啥时候出呃，正在剪，正在剪那个视频要剪辑啊，咱们那个视频网站大概在1月1号的时候会上线，把夜宴会上线，你会看到就是一个全新的一个视频网站啊，现在还没做好，现在还没做完。

还差两天时间，做完之后，你们从从那个视频网站上就能看对应小课了，好吧好了，我们先来回顾一下上节课大概讲点什么东西，其实讲东西啊也比较简单好吧，就是spring的一个spring bot的一个基本入门。

然后加上一些相关的一个配置配置文件这一块儿呃，很多同学啊可能之前没学过那个s s m和s s m，所以导致说老师这个spring配的配置啊，我不太清楚不太清楚也没关系，这边呢给大家整理了一个文档。

好给大家一个文档，文档里面讲的就是spring boot配置相关一些东西，就我们配置的时候，在之前的时候可能大家更青睐于用xml文档，好xm 2 xm文件在进行配置的时候。

每一个框架还有自己配置文件的格式，而现在到spring bot之后，你只需要配置到我们单独的spring boot的配置文件里就可以了，那个配置文件它支持第一个properties这样一个形式。

好properties这样一个文件格式就是k然后写一个等于v这样的格式，第二个可以，这是一个什么叫y a m2 好ym或者说ym都行好吧，这是这样的一个配置文件，然后这边给大家想写了一些比较详细的配置。

比如说如果我要用properties的话，我应该怎么做配置，ok然后呢创建实例对象应该怎么进行一个引入，引入的时候也是一样，可以通过我们的as the value来进行引入。

这比较基础了或者比较简单好吧，之前你们在学spring的时候，大家都是都是这么配的资源，mc的时候都是这么配的好吧，第二个这有一些测试类的一个测试，下面还说了，除此之外，在我们的purpose文件里面。

还可以引用相关的一些随机数的一些类这东西啊，上一节课我是没讲的好吧，这东西哪哪来的，也是从官网里面直接拿过来的，东西还是一样，不废话，我直接带你们看官方网站里面包含的东西，这是英文的，是中文的。

给他找个中文网站网站，你们从中文上直接看就行了啊，呃很多同学说老师我找不到这个中文网站，我给大家发一下，我给大家发一下，你们把这东西好好看看好吧，里面有一块是专门针对我们的压码，二个我找一下。

这太多了啊，看这块儿他说了石油压马号来代替我们这样的一个文件属性，里面告诉你说它是一个什么叫k，然后呢冒号v它是一个分格式的一个形式，写的下面有各种各样转换的一个形式。

比如说多profile亚马逊的一个文档，然后呢后面还包含我们对应一些缺点，然后按键属性的一个配置，以及后面说可以使用一些随机变量，找一下，刚写代码就从官网上面粘的啊，松三绑定，那怎么没有了随机数呢。

诶我的随机数呢没有了，嗯没有了吗，找不到了啊，你现在就自己找一下吧，反正就是在关关于我们这个随机数，这样有一个配置，这个配置哪去了，反正就是从官网里面粘出来的那个代码，就是从官网里面一模一样的代码。

然后呢我直播帮你在项目里面写了一下，然后把配置文件给追上了，大家看到了可以怎么写的，用dollar符号加一个大括号，写个random点，value rm点，int rm。l。

它分别会转换成对应的一个随机数的一个值，就是说之前我们写随机数的时候，必须要在java代码里面写一个random的一类，然后呢next什么东西，现在不需要了，这直接能帮我们进行生成，然后后面也一样。

可以通过and value这样的一个标签进行一个引入，引入，这代码我不带你们写了，非常基础的东西下去之后沾到你的ide工具里面直接运行就可以了，这个文档上写的比较全好吧，第三个就是多环境的一个配置。

这不用说了吧，比如说我们可以通过spring。profile their active，是通过这样的一个属性值，然后指向我们的dv或者text或者produ p r o d。

就是生产环境可以由多环境进行一个切换，这块东西啊也一样，下去之后自己去测，ok这上节课讲的东西，我们检测一个回顾，下面我说了，除了用properties之外。

还可以用一个东西叫ym l y a m l好吧，他什么东西啊，他说不是一种标记语言的一个外语缩写，但是为了强调这种语言以数据作为中心，而不是以标记语言作为中心，而用反谱词重新命名。

反正这东西啊很奇葩很奇怪，你知道它只是配置文件的一个形式就行了，现在回顾没关系，现在是回顾上节课都说过了好吧，然后后面告诉你说他是一个什么样的形式，比说了语法比time ml简单很多。

然后告诉你它有一些语法的规则，注意一下就行了，然后如何进行编写啊，这水写了，如果你要完成一个多环境的话，可以用spring，然后property，然后呢active加上它后面是用杠杠杠做一个分割。

这表示dv的环境，这表示test环境这块你可以选择你到底使用哪个环境的一个具体配置，也就是说我们现在之前上去给他演示的时候，我写了多个压码文档哦，y哦y a m2 文档。

现在呢你可以把它写到一个里面去了，但是要加三个杠，把它做一个基本的分割，好看这个舒服一点，这是第一点，第二点它也可以支持我们这些属性值的一个赋值，而且你在使用这个文档进行赋值之后。

它在其他属性之方也依然可以引用我们上面指定好的变量值，又写了一个bulps点，name major personage，是不是可以接引用了，然后在我们实体类里面想注入这些值的话，可以怎么注入。

叫configuration properties，前面必须要加一个前缀，因为这块它是一个是一个缩进方式来表示的，person表示说我可以引入里面对应的一个属性值了，然后引入的时候它就会自动进行装配。

就不用管它，但是而且呢它只是一种送餐绑定，就算你的名称写的不是那么一样，它也能绑定上来，但是不要区别太大，因为送餐绑定它有自己的一套语法标识是吧，刚刚在官网里面看吧，这个是不是它的一个缺点，比这儿啊。

松开绑定，好兄弟，你怎么回事，这给你演示出来了，好吧，告诉你说呃什么什么风格，然后建议在什么东西使用，然后建议什么投风标识，下划线表示法大写风格都有东西，这块从官网里面能看到很多的一个信息。

这块只给大家做了一个总结文档，然后再往下做了一个configuration properties和value的一个对比啊，他们两个有什么样一个特点，ok所以这个文档啊，我代码都给它粘出来了。

你下去之后拿这个文档好好配一下就行了，这东西没啥可说的，如果很多同学是刚接触的话，熟练一下，如果是接触的比较久了，在公司已经使用了这块，直接跳跳过去，不用怕了，好吧行了。

那关于我们spring book它的基本配置。

系列 3：P6：【多线程】锁升级过程 - 马士兵_马小雨 - BV1zh411H79h

好了，同学们，这张表呢你最好把它稍微的理解一下，这张表主要是在理解，不需要你背过，ok，好像到现在为止呢，我们终于可以开始讲我们的srt升级的过程了。

我的妈呀，铺垫的太多了，你们还能弄回来吗，来我们讲我们的sonnet这个升级的过程好，大家注意啊，嗯这个所谓的所升级呢，我刚才说过啊，最开始的时候呢，这个新款net全是重量级锁。

后来呢java对single net做了一系列的优化，这个优化的过程主要是在没有必要的时候，我没有完全没有必要向操作系统申请重量级锁，所以重量级锁是我最终的一个概念。

那么这个所升级的过程到底是什么样子的呢，是通过什么来标志的呢，大家听我说锁升级过程就是通过mark word上面后面这几位来标志的，仔细看这个锁目前有好几种状态，我们先来看锁的图。

好看这个图所升级的一个最主要的一个流程图就在这儿，当我们new出一个普通对象来的时候，它有可能是两种状态，两种状态的意思是new出来这种对象类型的对象，他的mark word是一种形式。

new出来这种类型的对象，他的mark word是一种形式，我们目前刚刚new出来的对象，new一个object，像这种对象就叫普通对象，还有一种情况我们直接扭会扭出来，匿名偏向对象。

这个我们一会儿再说，我们先来看一条主线，这条主线呢所升级的主线是这么来升级的，当我们首先new new一个普通对象出来，一旦我上，一旦我给这个对象加上synchronized这个关键字的时候。

它会升级为偏向锁，它会首先呢把这个锁呢做成偏向锁，做完偏向锁之后，如果竞争一旦激烈，它会变成轻量级锁，轻量级锁也是我们俗称的自旋锁，写一下吧，也是我们俗称的自旋锁，也有特别恶心的叫法叫吴所。

所以有的人会跟我抬杠，上次有一个学生问老师，无所到底是不是一把锁，对于你这种学回字到底有四种写法，六种写法，八种写法的孔乙级学生，我是没脾气的啊，随便你怎么认为你认为他是锁就是锁，不是锁，就不是锁好吗。

概念这东西是人类发明出来，互相之间交流沟通用的，理解什么意思就行了，不要学的这么死板啊，轻量级锁也叫自旋锁，也叫无所，这个词尽量别用好，在竞争再加剧，会变成重量级锁。

也就是我们最开始的向操作系统老大申请的那把锁，这个锁叫重量级锁，好，这是一条主线，我们先把这条主线讲通，new出来的普通对象，普通对象加锁加secret，关键字偏向锁，偏向锁，轻度竞争轻量级锁。

轻量级锁再竞争重量级所，这是一个最主要的升级过程，而且到现在为止还可以跟得上的，来给老师扣个一，好了，来我们继续。

我们来讲清楚这个过程好，首先来说怎么区分这个锁的状态，怎么区分锁的状态，这么来区分呢，在mark word里面优先看最低的两位，最低两位，最低两位是是你比如说最简单的最低两位，如果是零零。

那代表的是轻量级所最低两位，如果是一零，代表的是重量级所最低两位，如果是一一，说明这个对象正在被回收，gc回收的过程，最低两位如果是零一，它包含两种有可能的状态，第一种呢是无所谓。

也就是我们刚刚尿出来的，第二种是偏向锁，叫biased lock，那好那这两种状态又该怎么区分，所以在这种状态的前提之下，他必须得再加一位叫偏向，所谓来指明这是一把偏向锁还是无所无所派。

就是刚刚溜出来那个普通状态，如果是普通状态，001，如果是偏向锁状态，101不需要你背过，你大致理解这个过程就好了，那好可以继续了吗，继续的话，扣一，好了，下面我们来聊这个所升级的过程。

聊之前我们先来看看刚才列出来的普通对象，它到底是个什么状态啊，来大家看这里来同学们，你们看看你们看它是什么状态啊，刚开始的时候是new出来，001是什么，是什么，是什么意思来着，还有印象吗。

061是无所，就是普通的new出来的对象，对不对，无所派的一个对象啊，刚刚扭出来的，而下面这个零零呢诶零零代表的什么，零零代表的是看看轻量级锁，所以呢刚开始你看到一加速，他就直接给你加成轻量级了。

所以当我们看这个图的时候，跟你说。

当我看这个图的时候。

你会发现这个普通对象呢也是直接有可能啊，直接就上升到轻量级锁的，这是为什么呢，这是因为偏向锁没有启动，一会儿我们启动的时候再说好吧，启动的时候再说啊，先不管它来。

所以通过这你能看得出来这个锁信息呢就是记录在了我们mc的里面，好我们下面一点一点来讲，每一把锁到底是什么意思，每一种类型的锁到底是什么意思，我讲到这儿又要重复我一个以前经常重复的观点。

同学们学东西一定要先学脉络，不要先不要使劲的去抠细节，有同学说他现在就给我抠，我看到他刚才说了，说老师这块不是最低端的那边吗，为什么放在最前面，如果这个你不了解，去了解什么叫little ending。

就是小端和大端这个概念啊，这是计算机的最基础的概念，不过没关系，你知道这两位就行了啊，或者这三位，那么还有人说一些其他其他的细节，你先不要扣那些细节，最重要的是要了解什么呢，是要了解这张图。

这张图目前为止是最重要的。

什么叫脉络好，这个就叫脉络好吧，这就叫脉络啊，那，我们先来了解基本的概念好吧，我们先把这个大块的东西先了解清楚，然后再了解里面的细节，学东西要这么选啊，千万千万不要有一种有一种讲法，会有一种学习方法。

他是怎么他是怎么干的呢，讲义普通对象，然后呢好多好多好多好多好多好多好多好多细节，然后讲到你们学校好多好多好多好了，谢谢好，讲完了之后，突然间发现我已经忘了我现在在干什么，每次我都重复一遍。

不识庐山真面目，只缘你在庐山那棵松树底下研究蚂蚁窝，所以你永远也得不到一个全局的概念，永远也得不到一个系统化的知识，就在于这，所以先掌握脉络，什么叫脉络，ok我们先来了解到底什么叫偏向锁，什么叫轻量级。

什么叫重量级，好大家认真听，首先第一点先说第一点，这两把锁偏向锁，轻量级锁，这两把锁叫做用户空间锁，用户态的锁，这是什么意思，我不需要像操作系统跟不需要跟曹旭东老大打交道，少了一个打报告的过程。

好在这个时候你你你你稍微想想，我少一打报告的过程是不是就少很多呀，好很多呀，我就没那么重，所以这叫轻量级好吧，就这两个的都比较轻，这里面最轻的叫偏向锁啊，然后是轻量级锁，好这个里面呢我们一点点来讲。

就偏向左自旋锁都是用户空间来完成的，重量级锁是需要向内核申请，我们来聊到底什么叫偏向左。

我们现在聊什么叫偏向左设计，偏向左有一个最基本的它的一个前提，这个前提你好好听，认真听，千万别走神，我想问大家一个问题，大家知道在我们的，jdk的类里面有一个类叫string buffer。

我觉得大多数人应该都听说过这个类啊，string buffer，那关于这个string buffer，它里面的方法有没有同学知道他加不加synchronized，它是不是同步的，有没有。

stream buffer对，全都是假的，那我就想问你了，平时你们用这个string buffer的时候，你们真的会在多线程底下用吗，其实很多人写代码就直接拿来用了，也许大多数的你的代码运行的时间。

我跟你讲，其实就是一个线程在这用打多数时间就一个线程在用这个4g buff，但是呢里边又掉了synchronized的，那如果一个线程来访问srt方法，都要向操作系统申请一把锁的话。

这个效率是不是就很低啊，所以偏向锁是一个什么概念呢，偏向索的概念是这样的，在做了很多很多调查之后，发现代码在大多数的时间的情况下访问synchronize的时候，只有一个线程。

那干脆我为什么要让他进行锁的竞争，或者要向操作系统申请所没这个必要啊，哪个县城先来，我就偏向他就可以了，这是基本的理论上的逻辑，就是多数的synchronized的代码段在实际运行的时候只有一个线程。

多数时间，所以在这种情况下，我没有必要设计竞争机制，还不知道我说清楚没有，啊能跟上同学老师扣一，那既然这样的话，大哥我真的没有必要给你设计竞争机制，我干脆让你干一件事就可以了，好比如说啊。

比如说我们的谁来了大灰狼啊，有一个有一个小伙伴，我看大灰狼扣了个一大灰狼同学，他要进去噗噗噗干点事，但干这个事的过程，这就相当于我们的critical section。

也就是我们的那个sonnet的代码段，在这个过程中他要上锁的，他要给这把锁加ser来的，他怎么加呀，刚才我们说了，大多数情况下，其实只有他一个人，哥们儿，你有必要上锁吗，有必要像操作系统。

有必要向我们的厕所所长去申请一把巨大盖的锁来给他，给他给他锁上吗，没有这个必要，大灰狼就干一件事就行了，他在往这个，锁上面贴贴上他的名字，上书四个大字，大灰狼，ok ok这个就叫偏向所。

好偏向锁的意思就是我用非常非常轻量级的东西，我不需要通过锁竞争，我第一次第一个线程来的时候，我就直接把我自己的线程名字，当然专业名词叫线程i d，把我现成id啪贴到门上，所谓的贴到门上。

就是写到mark word里面，因此我们的偏向所来看这张图。

因此我们偏向左只是把当前线程的指针仍在自己的mark word里面就ok了，好了，这个叫偏向锁啊，不知道我说清楚没有，我们再来回再再复习一遍。

所谓的偏向左是没有必要设计锁竞争机制的，第一个访问这把锁的线程，直接把自己的线程id往上一贴就可以了，没必要继续好吧，嗯来可以继续，同学有点扣一，这叫偏向锁，是线程i d还要写成指针啊。

在java里面叫线程id，在c加加的时间里头就写成指针，无所谓，总而言总而言之就是当前现成的标志贴上去就行了啊，大灰狼的名字往上一贴，这个坑我的了，先把坑占一下啊，拉屎不拉屎，先把坑占了。

占着茅坑拉不拉再说，没有竞争对，正是因为上偏向所的时候没有竞争哎，所以呢这把偏向锁呢你可以随便上，而且他效率非常高，那偏向锁概念我们是不是就了解到这儿好吧，那好当我们了解了偏向所概念之后。

下面呢我们来看到底什么叫自旋锁啊，我看好多同学在那问还是cod去哪了，apple card到底什么意思啊，我跟你说了，别着急，先跟着老师的思路走，我先把脉络给你讲清楚，咱们再来谈细节好吗，好大家听我说。

作为下一步的锁，就是竞争一旦稍有加剧之后，他会把这把锁偏向锁给撤销，竞争来了，比方说上面写着大灰狼，大灰狼啊，上书四个大字，大灰狼，后来臭鱼来了，臭鱼说，哥们儿，你不能说把名往上一贴，这坑就变你的了。

我也想用，怎么办呢，好这时候你们两个竞争，这时候呢就是相当于有人来竞争所竞争所的话，那站在hosp角度，站在这个m角度，我就不能够说把你一个人的名贴在这了，这事我怎么做呢，我把你的名字扯下来。

这个叫偏向所撤销，先把偏向锁撤销，撤销掉之后，你们俩竞争，那你们俩怎么竞争啊，你们俩竞争的方式就是自旋的竞争，自旋所竞争好，下面我们说这个自旋锁竞争的过程，你们认真听认真听，刚才我说了，这是大灰狼县城。

大家知道每个县城都有自己的县城站，这是大灰狼县城站，这是臭鱼，这位同学的县城站，这俩哥们开始竞争这把锁怎么竞争，每个人在自己的县城站内部生成一个叫做l r的东西，目前面试最深也就问到这儿了。

所以你记住他的名字就行了，l r的意思叫lock record，叫索记录，lock record，好大灰狼生成大灰狼的lock record，臭鱼生成臭鱼的lock record。

然后这俩哥们儿就用争抢的方式，什么样的方式自旋，用自旋的方式想方设法把这个lock record的指针贴到门上，所以这里头呢最终有人竞争所竞争成功之后会有一个指针，一个poetry。

这个指针指向哪个县城的lock record就表示哪个县城持有这把锁，另外一个线程咋办呢，c a s继续竞争啥意思，什么叫cs继续竞争啊，在旁边转圈看看哥们儿，你释放锁了吗，你释放锁了吗，你释放锁了吗。

你释放锁了吗，他就在旁边转圈，他并不去操作系统，去申请内外重量级，所它就在用户空间转圈转圈转圈好，什么时候，你臭鱼用完了，我进去继续用，好这个过程不知道我说清楚没有，我知道你们会有疑问。

那不是很耗内存吗，他转多少圈才会不才会升级重量级锁呀，别急我不跟你说了吗，别急莫急，先学梗概，先学脉络啊，来稍微回顾一下什么叫做自旋锁，自旋锁的概念就是两个县城来竞争，这把锁，首先撤销原来的偏向锁。

或者你原来没有偏向锁，就像刚才那样普通对象，那我们两个直接抢就行了，抢的过程是这哥俩谁能够把自己的lock record的指针贴上去，谁贴成功了，谁赢好，你爹臭鱼贴成功了，说明臭鱼持有这把自旋锁。

那另外一个人怎么办，自选等待，所以这个就是自旋锁的由来，一个人在那儿拉屎，所有人在旁边转圈儿，本来这地儿我想给你做个动画的，后来一想算了，太恶心啊，不给你做了啊，ok好了，能get到同学老师扣一啊。

那好那到现在为止，我觉得你们应该听明白到底什么叫偏向锁，什么叫自旋锁了，那接下来我们来看这张图。

看，所谓的轻量级锁，自旋锁的无所，它是指向县城战之中的lock record的指针，好吧，所以一旦有人持有的话，62位里边就是一个指针，那好那下面我们继续聊什么叫重量级锁，重量级锁的概念。

这个时候就是这样的，看这里，看这里啊。

好什么叫重量级锁，重量级锁的概念呢就是我已经不再是呃用户空间了，我这把锁呢必须得向操作系统去申请，想当系统申请的时候，在macd里面记录什么东西呢，实际上记录的是一个叫object pointer啊。

叫object monitor，那么这个东西呢就是jvm空间写了一个c c加加对象，而这个c加加对象呢，它内部去访问的时候是需要通过操作系统这样的，经过操作系统之后拿到操作系统对应的那把锁啊。

到这种情况下你才能够呃相当于申请完这把锁之后，你才能继续持有，才能给他锁定，锁定完之后才能继续干活，好大体的一个过程我就说清楚了。

当然如果你要想理解的更透彻，恐怕你得去看pop ject monitor的源码，我一会简单给大家解释一下好吧。

简单解释一下hosport的这个层级的源码啊好吧。

所以大体的一个流程呢，就这个流程我不知道大家是不是大概的过程，我再说一遍，先学梗概，这个大概的过程是不清楚了，首先留一个对象出来，然后呢偏向锁一旦打开的时候，实际上给他上偏向左精度竞争。

两人过来开始抢轻量级锁，轻量级锁完成之后，如果竞争比较激烈，叫重量级锁，那么这个过程如果你想深入理解的话。

大家听我说，看housework源码的哪部分，hob源码里面的interpreter run time跟cp，最后你根根根一定会跟到这里，为什么会跟到这里，好，interpreter run time。

点a。c p p，这句话的意思是是是嗯，你你大家知道jvm是解释对java的class文件是解释执行，那么解释执行的过程之中，他到底是怎么做的，得通过它来读才能知道啊。

嗯我呢把这个代码呢已经给大家更到笔记里了，所以你如果想去仔细研究一下的话。

没有关系啊，你看老师的代码就都给你都给你更更更进来了啊，好interpreter run time要看哪个方法呢，叫monitor enter方法好，那么讲到现在为止。

在这儿呢我想给大家讲一点class文件的这种字解码。

这个呢非常简单，你认真听就行了啊，这个目前还没有人，没有任何人说理解不了了，注意看，在这儿呢我给它加了一个synchronized的o，然后我已经跑了一遍了。

我呢去观察一下它的字节码，这个字节码那叫view show by code，当然我用了一个插件，这个插件叫show by code with class library，就无所谓。

我们来看这个方法它生成的字节码code，你会如果你仔细去读，你会发现呢在这个生成字节码里面有一个字节码，这是jvm的汇编，有一个字节码，这个字节码是什么呢，它叫做monitor enter。

好大家听我说，那么也就是说当我们在源码层级，java的源码层级点java文件里，如果我们写了synchronized，它编译为class文件之后，它实际上是这个源码源码呢叫monitor enter。

什么时候会monitor enter，synchronized，大括号开始，monitor enter所开始了，什么时候所谓退出呢，monitor exit大概要结束。

还会有一个monitor exit的，这到底是为什么呢，产生任何异常的时候，monitor exit，所以对于single单来说，它叫做自动上锁，自动释放锁，什么时候自动释放成这段代码。

执行完自动就释放了，如果发生异常，自动释放，好这一段能跟上的，来给老师扣一，没问题吧，那所以你要想跟到我们。

这个跟我们hobo内部实现的时候，你要看的是monitor enter啊，那个那个代码monitor enter，如果你通过这个monitor enter的话，你能够大概读出它的梗概来。

同学们我们看一个大概就可以了啊，大家注意看啊，这个monitor angel它里面是怎么实现的呢，insert，大家看这里，if you biased locking，来翻译一下，如果使用了偏向锁。

也就是偏向锁，如果打开，我一会儿告诉你偏向锁怎么打开，怎么关闭，如果使用了偏向锁，我们调用的是哪个方法，叫fast enter，叫快速的进入所，就快速的竞争所啊，快速拿到这把锁。

else呢叫slow enter，你看他的名字，你就会知道偏向左比较快，其他方面呢要慢一些，slow intro，偏向索为什么快，刚才我解释过了，他不需要锁竞争的过程吗，当然快了。

所以fast enter slow enter呃，那这个如果你跟到fast enter里面啊。

我给你不给你一看了，因为我就给你摘出来了啊。

如果你跟到fast enter里面，你会发现啊，这个fast enter是怎么实现的呢，它会在一个safe point这个点，当然这点我要给你讲一讲，半天忽略好吧，在safe point的时候。

它进行一个revoke和revise撤销，并且定偏向所，如果偏向锁成功了，那就偏向所成功，如果不成功，他依然会进入到slow enter，所以它会有一个锁升级过程。

而这个slow enter又是怎么实现的呢，slow enter是首先进入进入自选，看到了吗，compare and pointer，进入自选，也就是升级为自旋锁，如果自旋锁不成。

下面这个过程叫inflate，叫锁膨胀好，这个膨胀过程就进入了我们的最终的重量级锁，如果大家伙想去读这个重量级锁代码在哪里。

synchronizer，synchronizer，在这个类里面啊，你自己去找就行了好吧，那么在这个类里面呢，他就开始调用linux内核一些实现方法了，这个时候就惊动了我们操心的内核了，然后就不大。

因为大多数人呢不是特别熟c加加啊，所以在这儿呢我就不一一的解释c加加代码了好吧。

系列 3：P60：【Spring】SpringBoot整合Servlet - 马士兵_马小雨 - BV1zh411H79h

下面要干嘛呢，我们聊一个东西叫web，也就是说现在我们用swim boot搭建我们项目的时候，他在开发一个web项目的时候是比较容易的，因为在官网首页里面告诉你了。

说spring boot里面内建了一个什么叫tom cat啊，真理这样的一些容器，对不对，然后直接运行了，运行时java杠炸就搞定了，但是在运行这些web项目的时候，我希望你能注意一些细节点。

为什么在官网里面对这块其实描述的也是比较详细的，你往下翻，这个东西叫开发web应用程序，说spring boot非常适用于开发web应用程序，你可以使用嵌入式tom tom cat，这题好吧。

大多数web应用程序使用spring boot starter的杠web，这是我们什么，也可以使用这个wiflows好吧，来搭建响应式的一个web应用程序，但不管怎么样，你要知道一点。

用它来搭建web的时候非常容易，因为我们在创建一个普通web项目的时候，只需要勾选一个模块就够了好吧，至于说为什么要勾选这些东西之后，我跟大家说还是一样，我们可以通过源码层面来说。

其实啊很多同学应该都知道，sn bot里面它底层最核心的和原版里面最核心的介绍是什么。

叫自动装配原理，对不对，好吧，叫auto configauto config，在to config往下走，这儿有一个spring factory，在这个factory里面，你往下翻看这块什么东西呢。

叫able auto configuration，里面有一堆以auto configuration结尾为这些文，这些类这些类干嘛的，最终就为了帮助我们完成一件事，就是自动装配啊。

就是自动装配这样一个原理，这个原理后续的时候我会告诉你它一步一步是怎么来的，但是你要有这样的一个意识，所以你需要哪个组件，直接把哪个组件直接以一个泡沫网页形式打进，加加进来就可以了。

我说老师这里面你看一下有这么多的一些auto configure，我每次启动程序的时候都需要进行加载吗，这都最近下载吗，不是的好，为什么，不是你可以往上翻点，随便点开一个，点开一个之后。

你会看到很多的一些标签，有两个非常显著的标签叫什么呢，叫conditional，什么东西，conditional什么东西是啥意思，什么叫condition，表示条件的意思，比如说它会进行一堆条件的判断。

如果你没有引路的话，大家看到这是不是爆爆一个红，那意味着此时他是不会进行自动一个装配的，也就是说你导入对应的配置文件之后，就是我们的pom依赖之后，它才会进行相应的一个导入哇，这块像有一个基本常识。

这是为什么告诉你们说每次在开启项目之前。

先把我们的炮母舰配置好，配置好之后导入对应的一个依赖，原因在这好吧，ok这块先聊这么多，再来看说spring web mvc框架对吧，告诉你说mvc是个什么东西，应该怎么做一个最基本配置这种东西啊。

其实之前我们已经讲过了，或者聊聊聊聊的已经比较多了，这块我希望提一件事，特别是年龄比较小的同学，有没有接触过server lake这样一个东西，有接触过这东西吗，什么叫s叫server apply吧。

是不是一个服务的一个小程序，把它本身是这样的一个意义，好吧，很多记住了mvc或者说一些外部的一些框架，几乎都是用于我们的，sorry，来来开发出来的啊，js的对的，这是比较老气的一个版本好吧。

其实它有一个过渡的过程啊，刚开始是jsp，然后呢加so late，后来呢切换成s s h，后来到s s m到现在又变成spring boot，是不是还有这样的一个历程好吧。

我不知道你们这块有同学接触过没有，然后最近打电话发现有好几个同学，他们公司里面还在用ssh stress to和harbor net，很多同学可能都没有经历过这块这块环节也没关系啊。

全经历了s刚学的时候最好都学一下，反正我认为最好学一下，因为学完之后你会感受到这些框架的升级，它带来的一个便利之处，把那天带来的便利之处，你会发现你的开发越来越简单了，很多框架就为什么要进行框架。

一个迭代原因也在这个地方，就在于说它让人或者开发人员变得越来越呃懒或者越来越简单，开发过程能够加快一点，懂我意思吧，那这块我们要学一个东西是什么呢，第一个点先学一个叫server lt相关的一个点。

刘老师为什么要学server rate啊啊为什么学server rate还是一样，因为我们的spring boot里面可以集成我们的so，可以集成我们的surface好吧，它里面有对应的一个相关配置。

给大家找一下，这叫内嵌siri的容器好吧，支持这些东西有什么用处啊，用处非常非常多，给大家说一下，就比如说我们后面啊，今天我应该会讲到数据源这个层面啊，就data source，大家注意啊。

你在公司里面可能在用的时候可直接获取，我用g d b c现在已经没人用了，更多可能要建立我们的数据库连接，然后再写一下我们的database，好吧行啊，data source不对啊。

要写下data source，在选择data source的时候，大家想一下现在用的最多的，好用的最多的一个是什么叫黑carry，是swimt里面自己自带的对吧，除此之外还有一个什么叫德鲁伊。

这是阿里巴巴开源出来一个框架，而且大家应该知道德鲁伊他是什么，叫专门为监控而生，还记得吗，是不是监控而生，也就是说你要想实现德鲁伊它对应的一个监控的一个性能的话，它需要你内嵌thy进去。

所以这块要作为我们第一个优先学的点是cbot，大部分开发人员只需要简单对应的starter来完成获取完整的配置实例，默认情况下监听8080上的http请求。

这块我们已经讲过了吧，来再写个代码试试啊，怎么做呢，非常简单，new一个project是啊，等一下come，这样把视频这样写一个spin，bot下划线加web 2宝拿走，刚next这要勾选了吗。

第一个勾选上我们的spring web这样一个框架啊，把它勾选上其他东西你可以自己去加好吧，自己加这里面透露出来另外一个东西好，另外一个东西叫spring boat dv toys，这是啥呀。

这是一个开发者工具，这些笔记我说一下啊，打断一下这些笔记，我最终都会上传的。

上传什么地方啊，咱们有这样一个地址，可能喜欢能先来啊，再说一遍，在bo马士兵这里面有一个internet t tt，在这里面这里面我建了一个单独的目录，叫spring boot。

好第一天第二天讲什么东西，我这都会往里面写好吧，所以拿过来之后，你直接从这儿下载就行了好吧，直接下载就可以了，ok这不都说了，刚刚看到一个东西叫dev toys。

叫热部署用的，很可能都知道，除此之外还有什么东西叫jio好吧，这样东西我不知道你们在公司里面好吧，哪个地方用的更多一点好吧，这块儿我们一会儿都说一下，都用过是吧，如果你要用dv twice的话，怎么办。

你直接加载一个maven依赖就可以了，而如果你要用我们的jbl的话，这块你可能需要进行额外的一些配置，我也感觉是宝好用一点好。

这边好像一点好吧，怎么做也很简单，告诉你官网里面哪个地方有，非常简单，你往上翻往上翻，这儿有一个开发者工具，在开发者工具里面他说了，你可以使你的开发体验更快，syn bot第1v twice。

以提供额外的开发时的一些功能，需要知识的话，把一模块加进去好吧，加完之后告诉你说应该怎么用，下面有一堆配置文章，解释下之后自己看就行了，但是我知道啊，这个dv twice我们这儿我介绍了。

不是不想介绍了，没啥用好吧，我们现在重点来说一下我们的jb jb也非常非常简单，我这给大家写了一个madam文档，好马大的一个文档，这文章里面我写的比较清楚了好吧，第一步安装在我们在idea里面。

fail setting plugin brother rise，卡在里面写入我们的jer宝，说了之后，找到jerball for int install子，弄好之后，然后重启就行了。

但是它需要进行一个激活，而这个激活的时候好吧，大家注意了，这儿有一个激活的步骤，你按照这个激活步骤去进行操作好吧，最好你自己能做一个反向代理的一个服务器，自己搭建的话，不用担心失效，可能需要失效。

之前明哥应该也说过这东西啊，之前明明说的时候应该是在那个一个例子里面讲过的，我这是idea里面的，所以这块都有了，下去之后按照这个文档来做操作就行了。

这不演示了，我这这个id里面已经集成好了，那看这个这个图标了吧，只有只有宝里面的一个图标，非常简单，如果谁在安装过程中遇到问题了，私聊我好，很简单一个东西了，这不说了啊好了。

刚刚我们是不是选择好一个web的一个窗口了，选完之后点next，这样改一下啊，spring boot spring boot web，我们改，我们改一下这个目录，我直接给你们上传上去。

给他reports internet嗯，这怎么没有，老王还没同步啊，没同步，我换一个吧，这样写到斯不是bot放这里边，杠啊分析师，ok，直接打开就行了，打开之后如果你想配置一个web项目的话。

就变得非常非常简单，怎么做呀，直接在我们把这些东西先删掉，这东西想删删不删无所谓啊，我看着难受就删掉了，s r c选择me，在这里面可以建一个ctrl n t r o，待会r ctrl完之后。

在里面可以随便写一些东西，知道吧，叫my control，创建好之后，前面加一个at叫regress controller，只要解说rise control吧，它什么意思。

然后pp这string hello，这是我们之前写的东西啊，还是一样，retur，spring报他来返回上面呢，加一个at request map，加一个，hello，看见了吧，写完之后直接运行。

我们当前这个应用程序启动一下，行动号召。

这是默认在8080端口进行一个启动，所以此时我们可以直接进行一个访问，叫local host 8080，然后杠flow走，是不是告诉你返回hello，spring boot，大家想一下。

这是不是就是一个web项目了，这是我们之前说的搭建，非常非常简单好吧，最简单的一种方式，除此之外我说了它可以集成我们对应的一个so late，后续的时候我们会对它进行一个使用，就这块我希望大家能够了解。

然后在这块集成的时候注意了，他说了一遍啊，你把它翻这块儿说什么东西，然后呢在使用so late的时候，你可以配什么，第一个pso late，第二个pay filter。

第三个pay listener好吧，此外就不用说了，就是我们实际处理的一个业务逻辑类，然后呢fire是什么东西，是过滤器吧，然后listener呢是不是我们对着一个监听器这块。

你都可以做一个最实际的一个操作，他说了使用它的时候可以使用b或扫描方式来注入sr好吧，然后呢说将这些东西要干嘛，要注册到内嵌的容器中，如果你想使用这里面值的话，这样可能会更方便一点。

后面告诉你说我应该怎么加入这些过滤器，是不是写了一堆参数代码，写这些案例吧，这块我们直接来演示我们的案例，代码还是一样啊，我这儿给大家写了一个非常重要的一个文档，web开发。

来看一下第一个cbot web开发，说第一个叫整合我们的servlet好吧，折都进行整合，第一个你要先写一个s好吧，先写一个s这块是不是我们原生代码，我这把拿过来了。

正好不浪费时间了，没啥没啥意思啊，来直接打开我们的代码，开始sorry的二位扎完之后，这是用的是sorry 2333点吧，是不是直接用我们的注解就可以了，注解配的时候写什么东西。

第一个叫web so late，第二个写一个名称，第二第三个写一个叫you are pattern好，这两个东西是什么意思啊，你们都卡吗，我这儿没卡，所以应该是不卡的啊，如果卡的话。

可能是你自己网络的问题，不是我这的问题是吧，自己重新调一下网络，ok来我来看，当我们导进来我们对应的一个server之后，他首先需要继承一个叫http ser，这不叫继承好介绍完了之后。

上面写一个东西叫web solid，表示说这是一个si的实体类，如果原来你没有用注解的话，你怎么办，你想一下你在之前搭建项目的时候，是不是都有个东西叫web点插毛对吧。

server name等于什么东西，survey class等于什么东西，还有东西，you are pattern，python里面是不是写了一些呃nt in设置的东西，好，很麻烦很麻烦好吧。

所以这块儿他做了一个简化，然后这第一个是我们的名称，你要写一个名称，第二个写上你对应请求匹配的类，好把它写上就行了，听起来，麻烦啊，其注意了，这块我们其实并没有写全，为什么。

因为这里面除了一个do get之外，还能有另外一个叫do post哦，叫do post这块其实都有用到，比如这个你可以写一下，多看到了吗，这是一个do post的好。

一般写的时候就说你匹配到你对应的一个get和post post这样一个请求方式，仅此而已，我们这儿进入我们的get请求就不用管它了，这里面我的处理逻辑啊非常简单，没处理就直接写了一个一只能打印就够了。

河南老师这个c位的整合用的不多吧不多，但是我说了我们后面会有一个应用场景，然后有一个应用场景，什么场景，就是我们在配置德鲁伊监控的时候，我们需要自己来写一个srt，那时候也需要自己写好吧。

其实英文思维的东西都是一模一样的，你这块先稍看一看，先要理解其中的一个最基本的一个原理，这个说看就行了好吧。

说完它之后没完还要干嘛呢，说在启动类上添加如下的一个配置，这个配置才是最核心的一个点，就是说你这只是定义了一个srt，我怎么知道或者siming boot，怎么知道你当前这个so late应该生效。

或者说什么时候生效呢，这就意味着你要在你的启动类里面好吧。

加一个东西，第一个找到我们启动类这块儿加什么东西叫at server le component sky，一个注解吧，好把它给装载进去，它会有一个自动扫描这样的过程，大概加上加完之后里面没完。

你需要把你对应的那个service注册为我们当前sbot容器里面的一个ban好。

这块怎么注册，他写了一堆代码。

我们把这个b直接拿过来，大家看一下这个病，其实非常简单，做事情也不是特别麻烦，你注意了啊，你在写代码的时候，你没必要说老师我每个代码都是手写吗，没必要来看看这个逻辑吧。

这边有什么东西叫get server register，registration b什么意思啊，获取server注册的一个并对象吧，然后这首先创建一个东西叫serate registration。

并然后后面告诉你说你有一个这样变，把我们当前这个si的对象给放进去，放完之后，这儿有个东西叫bsload on starup，很多同学如果你配置过web点叉ma的话，应该有这样的一个呃记忆，这是干嘛的。

这设置我们当前sl它装载了一个呃，什么时候进行启动，什么时候配置，我们当前这个类好，这个加属性，我们这配置成e了，然后配置完之后把这个并返回去，此时就意味着我当前这个病已经加载进去了，好加进去。

那这怎么办啊，直接进行一个重新启动，之前我们中学怎么起的，是不是用我们这个直接键启动的不太好啊，我们这换成我们的追日报，启动之后的话，我们这儿就不用管它了，好吧，等一下吧，开大几刀啊，嗯。

没报错吧，此时我们可以发送我们队内一个请求了，暂时用什么东西叫杠杠s r v吧，回车诶，怎么有东西啊。

看着看这个信息打印出来了吗，答案出来了吧好吧，这个大家不是已经看到了，我刚刚写msl里面是不是打印了一个111这个这个请求，这是不是这已经打印出来我们对应的一个结果了，懂我意思吧，所以这个配置非常简单。

只需要说我自定义实现一个surface一类，实现完了之后，然后直接把当前类的类注入到我们的spring boot里面就搞定了啊，这配置难吗，不难吧，当然刚刚那个风声也说了。

老师这个sy单独用的话是用的很少，事实确实是这样的，几乎没人用啊，但是但是你要知道一件事，什么事情呢，我在进行这样的一个呃page的时候，我怎么把我们对应server lt给注入到我们当前这个容器里面。

也就是说在我们当前这个启动类里面，这行代码或者这几行代码非常重要的好，这写下这个注释吧，添加到，我知道了，除此之外注意了，这后面还可以写东西，叫什么叫u r r making，好，什么意思。

这可以加一个叫杠，这写一个s2 吧，随便写东西啊，杠s2 好，随便写的东西，写完之后，这块你必须要重启，我们这再来发一个请求。

叫s2 回车。

是不是这页面没效果吧，因为我们这没有返回任何东西了，看这这返回对应结果了吗，是不是返回了，然后我们对应结果了吧，好这回大家一定要注意了，好吧，把我们当前这个结果你返回来，意味这也能调用成功。

就这意思好吧，容器是指定容器吗，是的，l o c容器就是我们自动装配这个对象是lo c，是这样的。

好这把听明白了吧，他呀并不难好，它并不难，要让文档里面直接写就行了，好吧，我要说的不是这个东西，要说的是什么，是我们s2 生效了。

s r v还有一还有生效吗，你就按生效吗，我把它干掉。

来配一下，二位高。

看一下后台效果，答应吗，打印吧，为什么一次请求有两个打印这块来给大家说一下这块在请求的时候，为什么会有两次打印的一个结果，他在请求我们对应的method late的时候。

这时候按道理说是不是只打印一次就够了，是不是按c够了，你想一下它是怎么样的一个轮转过程，如果你的do get就是这四位里面的东西啊，如果你的请求没有请示，没有请求到的话。

它还有一个action的一个请请求，艾肯的一个请求再看一下啊。

很多人可能已经已经已经很少很少有人看这东西了，我给大家看一下，大家知道了，找一下我们对应的一个更多工具开发者工具诶，你看一下我们的network这块，我们来刷一下页面，大家看一下，这仅有几次。

这什么玩意儿，什么状况请求啊，date image，拼这bass诶，这啥玩意儿怎么出来，是这样的，那思维这家产帽车s2 ，注意啊，这块有点问题啊，我们这怎么做的过滤啊，我想想就你这块。

你看你的xx r在哪呢，下面一块是吧，这两个东西吗，咱这块我给大家说一下原因，我给大家说一下原因是啥啊，在这块是吧，先刷一下，这没有啊，这行不，这s2 的，他没发到任何请求啊。

搞抽几下。

好吧，清掉清完之后我们再重新刷新刷，刷完之后大家看到这怎么没打赢啊，好了，现在我们来请求一个东西叫s2 回车，这边依然是我们的error配置对吧。

解完了之后，你往这儿看后台是不是打印了诶，变成一色的吗，教学事故，这不大家试过之前给大家说一下吧，呃之前的时候如果你写过servlet的话，大家应该知道当我们在发请求的时候，因为我现在过滤器什么都没写。

所以他除了会发现我们当前这个请求之外，还有一个action的一个请求，那个请求如果你不过滤的话，如果你不过滤的话，它依然会发一次请求，请到我们这个地方，所以此时的话会打印两个一，现在看到了。

我这还有两个一吗，没有了吧，没有原因是啥，你现在再发送我们这个s r v lv 6请求的话走。

你往后看。

大家求到了吗，已经请不到了，因为什么，因为刚刚我在这块是不是已经配过杠s杠s2 了，当你配置好之后好吧，后面前面的之前的那个配置就不生效了，这可以写一下，高配置是u22 magic之后。

serve it，自己的配置，就不会生效好吧，所以这块你只能请什么请求我们的s2 ，这样我们再试一下吧，刷新一下是吧。

看后台有打印吗，没有吧，我现在换一个请求挂着我们的s2 走。

然后这时候来再往下看，是不是请求了，这个请求是不正常了，懂我意思吧好吧，这块大家一定要注意了，ok折腾记说老师不用加到容器里面也能响一把server le server component scan。

但这块我相当于什么，我把它注册到我们对应一个病里面了，好吧，这就是这个意思啊，这边有个属性来着，叫base package吧，是不是有这个tage，你后面可以加上一个随便的一个路径，com点马士兵点。

然后加一个sle，它是不是也可以自动扫描，但是你这如果要进行一个自动扫描的话，那意味着你在你对应的mesol里面，这不是因为他了，拜拜，sorry，it，这也可以生效，但是啊最好你把它注入进来好。

这样子的方式比较好的。

为什么这么说，这官网里面给我们推荐一方式，给大家找一下，可以看一下我们这个server我转了一类，你看这块就知道了，这里面有这样一个东西嗯，看这他说了，默认情况下，意识到杠多个sb的时候。

变的name运作前缀，所以过滤到更新，如果基于约定配置的映射不够灵活，您可以使用什么呢，叫super late registration，being filter registration。

并和他的东西类来进行一个完全控制，在这里告诉你说你可以使用这样的方式来进行配置，所以我在演示的时候就直接演示这样一个配置方式，懂我意思吧，周子健，那多个three不是得多个ban吗，是这样的。

一般我说了，刚刚那个风声也说了，srt其实用的很少，关键是什么东西，关键是我们要看一下，下面要讲这个过滤器和过滤器和监听器，过滤器电器比较多，像这块用的比较少，这种配置可以写路径还一样。

就跟什么一样，就跟你在swebot里面，你可以加一个at component scan，这是不是也可以写一个属性，比如说写一个，叫base package default。

这写一个com点马士兵之前我们是不是也这样写过，好吧，但是但是你注意了，我们现在为什么不写它，原因非常简单，它会因为你声明了three boot application这样一个，但是声明好之后。

它会自动加载当前类所在目录下面的所有文件，这是为什么，你刚刚开始在讲死神boss之前，我给你讲一个要求，说最好你启动好这类之后，主程序不要随便改变目录，如果你改变目录了。

就意味着你要改变你当前加载路径了，是不是意思之前是收获的东西，好吧，要用重要，要是用注解有顺序吗，什么什么顺序，说说说的是哪块顺序，你说这个上下顺序啊，这无所谓啊，这个是无所谓的。

这个无所谓这个无所谓啊，这个无所谓的，好吧好了，这是我们srt里面最基本的一个点。

好吧，这块用的不多，下面我们来看另外一个东西好吧，看什么呢，看下我们的过滤器，大家想一下过滤器有用吗，有用吗，你想想如果你要做一个网站，你做一个网站，做完网站之后，我们是要过滤掉某些请求。

比如说如果这个用户没登录，我让他进行登录，不能不登录的话，这块是没法进行使用的，是不是要写一个过滤对应的一个过滤器的过滤器的时候也非常简单，大家可以看一下这块一个代码是跟thy里面写的一模一样。

没有任何变化，还是一个web filter加filter name，加一个请求，加一个请求，有个need，有个ditry，还有一个do filter，这啥意思啊，告诉你说我什么时候要启动。

或者说初始化我们的过滤器什么时候执行，我们的过滤器，什么时候销毁我们的过滤器，这一块在做的时候，我希望你注意一件事，因为什么事呢，在我们的filter这个里面有一个东西叫filter chain。

它是一个什么，它是一个链链条，好吧，什么意思啊，它会延长一个顺序，接着每一个过滤器都挨着往下进行一个执行，所以在写的时候必须要加什么叫tm。do filter，当你做到最里面之后，如果没有输入了怎么办。

它就相当于这个意思，这样的意思啊，比如刚开始这是filter 1 f1 ，然后这里面可以是f2 ，后面是f3 ，然后里面才是我们对应的一个s，当你的设备处理完之后，再回来f3 f2 。

然后f一是这样一个执行顺序，好这块大家知道就行了，你们看过设计模式是吧，就责任练练模式这块稍微注意下就行了，所以这块一样，我们把它直接给拿进来，小c拿完之后一样的吧。

在我们当时代码里面建一个目录，看看这叫fault，有他，麻烦你先写好就好了，好了，这就是我们对应这个filter好吧，有数字化，有我们的呃，执行由我们对应的一个d4 串，当你把它配置好之后要干嘛。

这是不是也要顾虑我们对应的请求，所以一会儿我请求filter的时候，请filter的时候，你会看到这个打印这个filter一个对象，此时虽然你不用重启，但是我这建议你重启一下，为什么。

因为重启的时候你能看到对应的一个效果，往上看看什么效果，往上看看这个东西，看个东西，这有啥，in it吧，是不是意味着当我在重新启动我们当前这个服务器的时候，它已经完成了我们整体这样的一个初始化工作。

是完成初始化工作了，然后现在他没有执行的fter吧。

为什么没执行，我这可以发一个请求叫gfilter。

当你加载完gfilter之后往下翻，有filter了吗，有fter吧，是不是有filter了，是不意味着我已经执行好了好吧，它会一直往里面进行执行。

但因为我们没有对应于filter好匹配的server的，所以这不有会有任何的一个显示，会有任何一个显示，那现在你可以干嘛把它给关掉，发的多了，我这是直接关的，所以它不会打印diy。

如果你是一个正常结束的话，会把这个diy也给你打印出来啊，就这样一个顺序，所以以后你可以在我们这个filter里面添加任何的一个数据代码，比如说加什么东西，if我不可以做一个匹配，叫做quest啊。

不对，叫什么，request get，contest，sorry，contest，第二get，比如session，没有吗，request get，那怎么写来着，get contest，第二get 3。

成都，get session，那这块儿注意了，你可以设置到我们获取到我们对应的一个强转是吧，哦这是一个啊，这是一个server contest，这样强转一下，旋转完之后。

你可以获取到我们的c获取到我们三人对象，是不是可以把它跳转到我们的这个首页登录里面，是不是可以过滤到我们的武器对应的一个请求，这是我们的过滤器，它最常用的应用场景，除此之外还要干嘛，比如说你的js请求。

再比如说你对应的c3 次请求，将这些请求就不要发送我们对应请求，直接把我们计算资源返回就可以了，是不是也可以这样过滤，特别是在进行登录页面设置的时候，这块几乎是必须要做的。

所以这个过滤器你知道怎么做就行了啊，知道怎么做就可以了，可以了，过滤器牛头是这样的，ok这这块的一个相关配置配置完了之后，除了之外还有啥来着。

刚刚说的吧，刚刚我们在官网里面看到这样一个属性叫啥，叫filter registration beans了，你是不是也可以通过它来往里面注册成一个being，这是不是也可以，但之前啊我没有写啊。

这是不是写它了，ok那所有页面都要写一个filter吗，还是一样的，filter里面在写的时候，你注意一件事。

这是不是有东西叫ur python，他会设置说我发送什么请求的时候才会进行一个匹配，如果你的请求不匹配的话，这就不会进来啊。

这不会进来的，比如说你这写一个我随便发言请求啊，刚刚那不是写了一个很乐，还记得吗。

把这个请求给删掉，然后我们的状重新启动下。

走了把删掉，我这发一个hello。

h e l o走翻译合作之后，大家看一下这块会打印pter吗，不会吧，不会不会吧，你可以进行这你可以进行这样一个设置，一般我们设置怎么设置，你要如果是首页登录的话，写一个杠星对吧，你写完钢琴之后。

意味着你所有的请求都会进行一个过路走，这怎么没没没没起作用，发送请教。

你写作业了吗，抗抗鞋吗，要不要更新啊，这不对吧，不能直接写杠杠新了，应该是，怎么不管用啊，我们配的支配是纸质宝，这应该可以啊，说实话是不好了，来刷一下刷新是不是filter了，重启一下就好了吧。

这重启一下就好了，然后现在然后现在的话我们怎么做，所以现在再发送另外一个，比如说发送一个a b c d随便写，你之前请不到，这边是有filter，是不是有filter这块，大家注意就行了。

ok如果一个页面一二要是match多个filter呢，都怪无所谓啊，我说过了，你的filter它是一个什么，以一个链式的消防车往前走了之后会跳到我们下一个filter。

一直往filter里面进行一个跳转，进行一个跳转，所以还在往里面跳的，这你不用担心，好的老师，那这个filter的顺序我应该怎么定义了，如果你现在如果你现在写filter的时候，热的时候。

你如果直接像我们这样写，直接写一个类别的东西不配的，那此时的话有什么顺序吗，就是加载到哪一类，第三方哪一类，而如果你用了，我们刚刚在官网里面看到那个方法叫filter register。

你是不是可以设置我们对应注册的一个类怎么做。

是不是跟我们刚刚那service一样，你挨个房里面有对象就行了吧，也是一样的吧，ok这小点可以设置不拦截蘑菇请求吗，这应该不可以啊，这我还没写过，这应该不可以啊，一般情况下。

如果你要想设置拦截和不拦截的话，有什么有include和include，我不知道里面有这样的属性，不知道有这样一个属性啊，反正有include和include哇，应该有这样一个配置，但是里面怎么配。

我忘了怎么配的啊，你稍微注意下就行了好吧，差数是这东西是吧，这上面可以加一个order的一个属性，order这个值可以指定啊，比如-1可以指定一，他越值值越高，值越高意味着什么，值越小是越越越优先执行。

是不是这意思啊，这个order是顺序啊，这个顺序要求越小越优先嘛，输输出越小越先执行，这是顺序，但不然就得请求我看一下，这没有啊，我们可以看一下里面的属性啊，给个注解，找一下里面的东西。

display name for your name，icon，sername ur pc，这好像没有啊，这边好像没有对应的属性啊，这应该是没法控制的，这没法控制啊，反正请求里面是不是没法做的啊。

如果你直接在这里面加参数的话，是没法做的，in the sector叫什么叫拦截器，不叫过滤器，过滤器和拦截器还是有区别的，过滤器和拦截器还是有区别的，好吧，加逻辑自己放回去啊，这可以这可以做合作。

搞混好了。

这是我们对应的一个过滤器吧，过期完了之后要放最后一个r什么的角，接连起男同学还一直搞不懂说老师这个监听器是干嘛的，非常简单，说监听器也是src规范定义的一个特殊类，用于监听，不用于监听。

什么叫thread contest与tp session，thread request等于对象的创建和消费，事件监听与对象的属性发生修改的一些事件，用于在事件发生前发生后做一些必要处理。

一般可以用于哪些方面，第一个叫统计人数啊，第二个加载初始化信息，第三个网站访问量，第四个用户路径访问，访问路径都可以做，我让你写的好吧，来把它拿过来，当然方式都比较简单的代码都比较简单，我直接给他粘了。

当我们的坑写哪，我我直接选filter啊，这些这些里面去了计算器之后，大家看到了，这是不是有一个继承了一个htp session listener，继承完之后，这定了一个正弦变量叫online等于零。

你说每次三神创建的时候，这会创建一个三人对象，打印一句话，同时online加一，销毁的时候是告诉你说销毁这个session这块我们不用做那么严格啊，不用做那么严格，怎么做，注意了。

这必须要创建好我们对应的一个3d对象，所以此时这里面没有加任何的一个注解的配置。

那此时怎么办，你这样是不是又要写这样一个属性啊，是不是还要把它注入进来。

2c加到我们的这个配置里面去，找所谓，叫server listener regestion beans吧，是不是往里面创建好我们对应的一个对象，把对象放到我们这个listener里面去。

翻完之后就搞定了，这东西并不是特别难，那怎么做一样，我们重新启动一下嗯，接着不先启动，看看效果，你看效果知道了，ok类似的是不是启动好了，启动好之后，我这是不是可以进行一些配置的。

这配置的时候大家注意一件事，在我们的listen呢里面，这时候有个session。

这不是打印一句话，同时这还是没站稳，还有东西啊，这样还要加一个什么，加一个控制层的一个代码，就告诉你我的ctrl我要加什么样的一个信息。

拿过来找到我们来看中了这块儿不要他了，不要乱四，从这边，ok，哎不加保底了，这跟我刚才写的不一样，还加了次ctrl，写完之后，这是不是有这样一个值，把纸打进来，告诉你说再见入多少人。

是不是请求online就可以了，那现在我们把它干掉。

现在来请求一下小奥出来走，大家看到了，我现在在线人数多少，是不是零人对吧，走走走走，刘老师，这为什么总是零个人啊，这不太对啊，为什么。

原因非常简单，你注意你刚刚写的这个监听器，你到底是怎么写的，你写的时候是什么，是创建三成对象之后，是不是才会给他加加，你想一下刚刚我发那个请求的时候，有任何三人对象的一个请求吗，没有吧。

那怎么做也非常简单，在里面是有一个hello，在lo里面的时候，我这加一个信息，加一个什么叫a t t p session session，这里写一个什么叫session，第二三台这边加一个东西吧。

a a等会a a假如我加这样一个属性，这可以吧，是不是可往上面加一个随便一个值，这个值无所谓，我们反正也不用，我们反正也不用，然后现在干嘛呢，还是一样的程序清空清空完了之后哎，这怎么又有页面。

页面打开完之后刷新。

现在是不是还是零人，然后现在做一件事情叫logo host冒号走，说不行，又回来了，此时你再刷新变成一个了吧，然后现在我再换另外一个浏览器，你再试一下，你打不开打开这还是一样local host的。

然后呢这写一个hello，走，是不是挺有意思，这个时候你再来刷新一下，变成二了吧，我现在在请求再刷一诶，这里面有有有有有有有那个三项三项是不是同一个，那现在怎么办，只能换浏览器了吧。

是不是只能换浏览器了，是不是已经看到这个直已经在变化了。

也就是说你监听器里面你监听的是什么数据啊，今天是什么数据，这块就会进行一个增长，这是有三针的，有三针，this ro有很多这样的一个属性值配置。

下载之后，我刚才说了，在文档里游戏比较清楚，我说了，你可以监听我们的session，也可以见证我们的service contest，也可以进行service service request等与对象。

你都可以做一个对应监控，只要里面的值发生更改了，拿过来之后直接用就行了，你如果实在说老师我还想看一下到底有哪些电器怎么办。

很简单，打开它，打那之后你看一下当前结构里面是有session create，是有session提出来，是不是有两个方法好，周三你再往下翻，这个没有了，就这个接口啊，还有其他一些接口啊。

比如说htp session，找一下ttp server late contest listening，a s那，就这个了，在哪儿吗。

这块儿啊，你看一下这块怎么办，也非常简单，之前我讲过这东西，很早了，我来找一下，之前我在讲那个，的时候之前录过一次这类的视频啊，找一下，找好了，人哪去了，找不到了，之前我录过一次那个java一个视频。

在那个java视频里面讲了各种各样的一个监听器，好，server request dion，对，就这样监听器每个监听器里面它有自己实现的一个方法。

所以你把这些方法拿过来之后，直接继承过来实现一下就行了，好像不同这样一个分类，但有兴趣的话看可以回过头来看一下siri，好看一下three这块我们看了没啥意思，没啥意思啊。

你知道监听器过滤器这个东西应该如何配置就够了。

相当于回顾一下我们之前相关的一个知识，你下来之后自己也可以做一个演示，好，自己可以做一个演示，明白了吧，这块大家还有问题吗，没问题，能学扣个一，就非常简单了，这不用多说了啊，非常简单一些东西啊。

下来之后拿着这个笔记好好看一下，我笔记写的是比较详细的，一般该写的都写了好了，这是第一点，第二点该看看什么了，看一下我们对应的一个静态资源的一个配置，是集成了我们的surate。

大家发现了surface其实写起来并不方便。

而在我们刚刚你出现好我们队的一个数据目录之后和项目录之后，你发现了在我们的com下面有一个resource，这个resource下面有一个esthetic，有一个timate。

这里面是可以放置我们对应的一个静态资源的，sa里面放什么，他们里面放什么，我怎么去读取里面的一个数据文件啊，应该怎么做，是涉及到静态文件的一个资源加载过程了。

这要说了下，spring boot会在class pass或者server contest根目录下名为esthetic，然后呢这有个public resource。

然后呢resources目录的目录中开始读取我们的精彩内容，使用了sprmc叫resource，http request handler，因此你可以添加什么东西来编写这样的一个行为是啥意思啊。

告诉你我们写页面的时候可能写了很多html对吧，可能写了很多js文件，可能写了很多cs文件，可能写了很多emage这样的一个图片，对于这样的一些请求，我是要把它放到哪个地方。

原来是你是有个web bot，web in fin fin里面，是不是可随便往里面扔，但现在没有这东西了，没有这东西了，那我怎么做，我只能把它带到我们某一个静态资源的一个目录里面。

所有人都不知道说老师我应该往resource连放，谁能告诉我为什么要往resource面放好吧，或者说result里面还可以建什么东西，你在公司里面如果是不是自己开发项目，如果是拿别人项目的话。

你看到有些人可能接到这样的，我就发个对不对，还有些人可能在这里面又建了一个dt教授source，有人见过这样目录吗，public resources，有人见过吗，你刚建好目录的时候。

是不是有static对吧，那为什么public和results它要创建好，他怎么把这些文件给读进来的啊，有人想过这东西吗，先这东西还是一样，我们要看看看到我们对应的一个呃源码自动装备配置的吧，是这样的。

你告诉我哪找啊，下去之后我们可以给他看这样一个类，什么类呢，叫web还在单元码了啊，叫外web mvc auto，a u t o com configuration，这个了点这类啊。

各种auto configure是这样的，在里面你要找一下我们对应的一个资源目录，你看一下他在哪指定了那些静态文件的配置目录，我怎么去里面查看，ok下去之后，我们切个十分钟，十分钟时间内。

你看一下这个源码，自己打开idea，自己看看看能不能找到，这里面肯定有你认识的东西行吧，ok那行，那我们就先休息十分钟。

你们找一下这个目录。

系列 3：P61：【Spring】课间答疑 - 马士兵_马小雨 - BV1zh411H79h

ok propd 4吧是你怎么找到那个pd 4的，折子戏出了一个非常关键的点叫properties，也就是说呃休息时间是吧，我说一下啊，你要想知道这个spring boot一个自己的一个呃配置的话。

这里面有两个文件，一个叫什么呢，往下看你往上翻，你往上翻，这里面包含了两个properties，一个我刚看到哪去了没了，有有个deer在这看两个文件，一个叫web mvc properties。

一个叫resource properties，好吧，就这块东西这里面就做了一个基本标识，它也是一样的，两个类嘛，好吧，通过这两类也能看到，但是你要知道从哪找进来的，这很重要。

有很多同学说老师我不会看原码，为什么不会看，你不知道从哪入手，你找到对应的配置之后，你知道从哪从哪进去了，好吧，你先自己找一会儿来带你找好吧，晚上还有这个有的，今天时间啊，我尽量把那个基础东西讲完。

然后从下节课开始，从不从下周的课开始，我们就直接干源码了，好带你们看里面的源码，你要知道这些东西好吧，一般的配置都是resource，找到了终于等人，哈真找到了，没有spring源码就能把源码都不难。

别人写好，你看别人写的代码而已，有什么难的，就那个顺序，朋友圈他写的项目比较大，但是比较多，我们找起来比较麻烦了，没有什么玩意啊，炸包里面配置包包的意思吗，一会儿我来讲这个过程啊，一会我来讲这个过程。

就是他为什么找这个类，它是怎么找进来的，做什么事情，一会来看这东西啊，看源码的时候看到都是各种注释，然后只需要添加不同的注解注释就可以神奇的工作了，不知道看什么时候解析这些注释的，你注意点啊。

你在看框架的时候，千万不要就是一行代码，一行代码去抠，因为你现在不是说我要写一个spring boot出来，这不是这不是意义，关键是说你要告诉别人说他到底是怎么完成这样一个装配工作的，只要这样就行了。

自己想出来比较难跟思路才能显示的，所以你要捋出来大概大致的一个思路，其实我跟你们说，你们其实不会看，不会看官网，如果看官网的话，你们都能找到对应的东西，我刚刚让你们看那个静静静态的东西。

你往那边找啊，我们可以找一个叫静态页面，这话说了，我刚刚那句话是从官网里面粘出来的啊，从官网里面粘出来的，粘完之后他说了，往里面找个东西，找一个东西看这。

他说你可以使用mvc叫resource a tp，resource request h，因此你可以通过添加自己的叫web mvc configuration adaptor。

并重写add resource hand，所以你看到官网也是给你解释了，从哪找，我刚刚是不是已经打开我们的web mvc这东西了。

当你打开这configuration之后，你可以打开我们整体的一个目录结构，找一个叫外版vc adapter哪去了，这样你点开之后找一个东西叫add resource handler。

是找这块了，这块里面是不是就对应了一个提示，对我为什么给你们强调说，你们一定要去看官网，看官网，因为官网里面真的有很多对应的一个东西，高管都给你指指出来了，只不过很多同学选择性忽略这东西啊，一七老师。

我们现在刚要用spring boot前后端分离怎么弄好，sbot打成炸前台不方便放，不方便开发，什么叫不方便开发呀，现在如果你要做前后端分离的话，最好的架构应该是spring boot加mae哦。

加v e，你加我v o e之后，相当于你前一秒都已经写好了，直接打包之后直接能运行了呀，就你的页面可以放到你的tempt里面，template里面，你返回之后，只要请求道具对应的正能数据就可以了，连条。

你后端后端这块你提供好对应的一个接口，提供好对应的一个接口，留好接口之后，前端只需要调用我们后台接口的一个服务，返回对那个真实数据就可以了，而且你如果用，而且你one spot之后。

它有一个sim leaf的一个模板模板引擎，一会儿我们会讲用到模板引擎的时候，可以用模板引擎直接进行加载的，这些东西很方便啊，并不难，这东西啊你不要自己瞎琢磨啊，你上完一搜。

随便bot前后端分离一堆的案例，告诉你怎么做，学会学习就够了，事实证明面上百度边上是最快捷的，理论来说没问题，但是你要知道现在的帖子啊都是抄过来抄过去有很多的坑，像我给你们整理的笔记。

里面都是之前我自己都演示过的，或者自己都调过错的，2%没问题的东西，我再发给你们，你要具备一个最基本的排错能力啊，这能力要有，2017年写的代码，你还能找到，对你这个不就是看他写的这个东西。

他自己不就继承了这样一个类集成这样类之后，他是不是可以映射我们对应的一个目录，就可以映射我们对应目录了。

现在上班吗，为什么17年那会还在还留着，这么快找到了，印象深刻。

系列 3：P62：【Spring】SpringBoot资源配置源码分析 - 马士兵_马小雨 - BV1zh411H79h

好嘞还在同学扣波一来了勾一我们来玩讲源码了，带你们看一下源码，很多老觉得这东西简单，我们可以聊点不简单的东西啊，刚刚我说了，我们都知道我们在写页面的时候要加载很多css，js等这样的一些近代文件。

在官网里面告诉你了，说我们写静态文件的时候可以把干嘛呢，把cass pass下面的这些目录的东西给导进去啊，为什么可以倒，这告诉你了，说你可以添加web m v c configuration det。

并重写里面的add results conter来修改此行为。

那么刚刚通过查找之后，你应该已经发现了，怎么找来着，先打开外版vc configuration，你点开这confiation之后。

找到里面的一个东西叫外版m v c auto configuration at，在里面有一个方法叫爱resource h，在这里面他告诉你了，我应该如何进行一个相关配置，怎么配啊，说if什么东西。

然后呢这有个if什么东西，if什么东西，是不是做了三个最基本的逻辑判断，这块我们挨个来看，他说了，this the resource properties，there is a advp。

就是说它会判断你是否修改了自己对应的一个资源目录，如果你自己这儿已经做了一个添加，那不好意思好吧，这块就不会做一个任何，就你原来配这东西就可能不会生效了，只有这个resource properties。

这是不是有这样一类点，这类你看一下哪个哪个目录叫spring。resources，然后呢往里面翻，里面是有很多一些属性，像这些属性值，你就可以直接在我们的配置文件里面进行一个直接的编写啊。

直接进行一个编写，就这块东西好，但你要知道这个前缀是啥，你们之前写代码的时候，很多人写的都直接写，比如说spring第二个冒号，然后呢mvc，然后冒号后面可以加各种各样的属性，为什么要加这样的前缀。

在哪标识的就在于我们刚刚这个properties里边有个perfect，在这profit里面告诉你说这块是哪个东西，懂我意思吧，这都会有b一个对应的标识，回过来我们刚刚看的地方，刚刚看完之后。

你发现了它有一个东西叫i的result handler，第一个是判断它是否等于空，这样的信息判断完之后，第二个叫什么呢，叫多些什么东西，不用看，往下看，这个东西叫什么，叫web js，正常玩意儿。

我不知道你们在公司里面是否有人用脑袋被炸死了，比如说我们在写前端页面的时候，可能需要导入很多的一些web框架，比如说jquery等等相关信息。

而web js就指的是我们对应的一个jquery里面的一个相关信息，这怎么找啊，非常简单，不止可以折合人啊，你说直影这块是有这个问题的。

可以干嘛，在百度里面你直接做一个搜索，搜啥搜web j a r s，他把这些静态文件，静态文件也打成了我们对应的一个home文件的方式，比如第一个这是jk ry。

是不是npm boss rap swagger对吧，第三点，js是不是有很多js的一些文件拿过来之后好吧，你可以把里面比如说我们选择这块是吧，选择我们的妹妹把这块东西拿过来。

把他c拿完之后可以加载到我们当前这个项目路径里面。

找到我们的pom文件，把一代先进去，二位ok讲完之后，打开我们的依赖包，我来找一下这是不是多了一个jquery，在这块里面，你往下翻，因为刚刚在岩板做了一个标识，哪个目录啊。

往下翻是不是在web炸死星星，它可以读取这个资源目录，同时有class pass m e t a app，然后呢resource，然后web炸死，所以我们在看的时候，点开它，点开里面的resource。

点开里面的web js，在点开里面的jquery，点开里面的版本号，点开里面的j query的js，这意味着什么事啊。

因为什么事意味着当前这个项目我其实可以进行一个直接访问了，怎么访问，选择它，第一个叫web，这时候反问过，直接访问过了吧，回车，来吧炸死走。

请求不到，重新重新重启一下，周琦等下，前端框架都放了，被炸死吗，不一定看你自己的需要啊。

拿完之后来写一下发，请发送一下，看这请求到了吗，说不行了，大家这个文件了，这边是谁，是不是就相当于是我们问问包里面某一个的一个依赖。

就是说我这可以自动设置为它读取我们web js里面的一些相关配置信息，是不是这这这这里面的衣服，也就是说你到底是否参与这个配置，占完了之后，第三个什么东西呢，叫static past present。

这啥玩意儿啊，是不是叫静态路径的一个匹配，或者说静态资源的一个匹配，那句话怎么找这个东西讲this的m v c properties，get static papa，点进去，点完之后你发现它有个地方。

this past pata，点进去叫杠星星啊，这杠星星指向什么地方，这其实已经跳过了，跳到哪了，看这叫web mvc properties了，是不是跳这个文件里面了，在这个文件里面，你往上翻翻。

翻哪去了，这儿有一个resource来着，找一个resource，这没有啊，我搜一下叫resource properties，在这个文件里面，大家看到有什么东西叫class pass。

source locations，是不是指定几个目录，第一个叫resource，第二个呢叫resource，ctras spa下面的resource，第二呢叫卡斯帕下面的static。

第三呢叫卡斯帕下面的public，这意味着里面有很多的一个目录结构，这是the static locations等于class resource locations，是不是就指向了我们刚刚那个目录。

所以我每次在进行资源查找的时候，为什么在你的resource这个资源目录下面，有人写public，有人写resource，有人写esthetic，有人写te，他这写的是模板。

主要是上面三个public resource和static里面，其实按道理来说都可以放我们对应的一个静态资源这块，其实我们都可以进行一个请求，怎么请求来右击又一个费，再写一个一点js，写一个呵呵。

有什么东西thetic吧，然后这再放一个东西，你有一个fail，这依然叫一点js里面写一个叫resource，他们这个面也一样，我也可以放一个fil，再写一个一点js，大家看到了诶，要js。

这写一个public，大家看到了这三个文件名称是不是一模一样，几乎没有什么变化吧，名称虽然一样，但是我在发送请求的时候，它都会从我们当前这个资源路径里面，是不是查找我们对那个一个目录啊。

刚看到了在哪来着，叫m web mvc，好多configation在里面找一个东西叫resource properties，是不是三个目录，1233个目录，那你告诉我。

我现在如果发送一个请求叫一点js的话。

它会先请求哪个显示哪个哪个哪个东西，或者显示哪个目录下面的东西，你觉得刚是不是在三个目录里面都创建了public resource sdk。

先请用谁，后请用谁自带，这个是吧，来我们验证一下对应的一个情况。

就是现在谁，选谁results吧，好吧，然后呢，现在我在做一件事情，什么事情呢，把resource里面的东西给干掉。

dele掉k d6 。

完了之后，我现在在同样发请求刷哎呀，这个这个到哪了，是不是到thetic了，是到thetic了，thetic完了之后。

我可以再把我们的thetic也给进行一个删除delete。

然后现在我再发送一个请求，在哪儿pk吧，所以大家看到了，这里面是有对应的一个顺序，就是说我可以包含n多个同名的一个数据文件。

但是它有一个加载顺序，而那个加载的顺序是不是刚刚好跟我们这块写的一模一样，第一个叫resources，第二个叫static，第三个叫public，这里面是标志好了，我将来数学，所以以后你在写资源的时候。

我家里人进来进来资源文件的时候，不要随便乱放好吧，谁的运气更大，你往前放面积更小，往后放，这样的话他不会进行随便乱覆盖，使得一个样式就乱了，懂我意思吧，当然一般情况下也没人写那种同名的啊。

一般也没人写同名的，如果写同名的，你要知道它对应的一个加载顺序是啥啊，加载顺序是啥，第四个是44吗，等第四个这个吗，tm里面放的是我们对应的ap mk面的模板啊，这模板引擎里面有东西跟你们无关。

跟你目录无关，跟这没关系，就上面三个目录，把上面三个目录如果不放这的话，你往哪放，是不是m e t a杠in for，然后resource刚想要刚刚那个web炸死，你放哪了。

是不是放在我们的m e t a info，然后里面是不是有resource resour，下面是不是有web js jquery 3。4。1，什么东西是从哪进价来的啊。

刚刚我们写近代文件不算是这样的一个配置目录，所以此时的话只有这三个，所以你要知道他们对应的一个单项数据，第一次找的时候，先去找我们这个m e t a inform。

让resource里面第二个找resources，第三个找static，第四个找public啊，这块我们那里面都给大家写了啊。

web web 2怎么做，现在在资源的时候，它路径是杠新星会去我们的resource properties，这个类里面看到对应一个资源目录就是四个。

然后下面固定上说可以看到资源目录一共有如下几个resources，static public，它们的顺序就是这样一个顺序，所以你直接拿过来看就行了，听到了吗，知道我们加载了吗，这是我们今年资源。

所以放的时候不要随便乱放好吧，但是一般情况下，其实你们在做的时候可能就有一个static public和resource，你们可能没有自己自己没有创建过，没创建过，你不用管它了，所有的cs文件。

js文件都直接把我们sd里面中就完事，但是你最好把它给分好目录，明白了吧，ok这个静态资源的加载，听完同学来扣个一，还是这样，你通过源码里面是不是能验证到很多东西啊，这个源码里面信息好吧。

说实话第二个什么呢，叫加载下面一个叫首页资源的一个配置，这个首页配置在哪啊，一样的，在官网里面有帮我们做了一个东西叫呃欢迎页面是不是有展示是吧，spring boot支持静态和外漫画，欢迎欢迎面。

你首先在配置静态内容是找到index html，如果找不到就找index的模板好吧，如果找到其中任何一个，它将自动用用作什么的应用程序的欢迎页面是啥意思啊，也非常简单，每次写的时候都写index。

为什么呀啊，或者说凭什么写就是index啊，凭什么index就是我们对应的一个欢迎页面，原因也非常简单。

还是一样，找哪儿是找源码，从哪开始找啊，别忘了我刚刚说的东西好吧，还是在我们的web mvc all configuration里面。

在web m c of convation里面找到我们的adaptor，在data里面拍下去，这边我们来找另外一个东西，找啥呀，找一个东西啊，这有什么信息诶，别走别跑，往上看什么呢。

叫welcome配置hler mein，不要看这个gain dex啊，是不是看这块了对吧，这里面怎么做的呀，你往里面翻，他说啊，这都参数啊，说new一个welcome page on remain。

然后用完之后呢，里面做了一件事情，说用了一个template provider，什么东西，然后从里面获取的时候怎么获取的，叫get welcome page。

这里面是不是调了我们的get welcome page，你点进去是不是下面的方法里面，这告诉你了，说get resources，然后这次resource什么的叫gas study location。

是依然从我们今天目里面找好吧，整完之后，这里面有一个方法叫什么呢，叫this冒号，get index html，这种写法大家见过吗，见过吧，这些话大家见过吧，什么时候见过拉姆达表达式对。

所以如果浪漫表达式不会的话，看一下，我之前在基础班讲拉达表达式那个地方讲的比较细，比较比较清楚好吧，放完以后这东西讲的比较多，好慢慢冒，这样的方式讲完之后，我往下看这个方法是哪儿啊。

是不是调到我们的get一代47m2 ，到这之后往上看，说什么呢，叫location，加上一个东西叫index。htm，二是不是告诉你说我默认在进行调动的时候就会找我们的index html。

所以这个地方是标志出来我的欢迎页面，就是我们的index tm是不是要标注出来了，所以思维这块你是不是可以自己进行一个自我定制了，懂我意思吧，所以你把这个原版看完之后。

你会发现很多相关的信息你能找到说ok他是从哪来的，从哪来的，你要给别人能把这个东西给说清楚，说明白白的说明白就够了，听明白意思吧，把这东西难吗，不难吧，来这块听明白，同学扣个一。

是不是你能看到很多关键的信息啊，这为什么让你看源码，源码里面都有，大家看一下这个源码难不难不难吧，我个人感觉spring boot源码相对而言还是比较简单的，但现在啊怎么说呢。

就是你们现在还没还没梳理出框架，等咱下周开始吧，下周开始我给你讲源码的时候，我先帮你梳理出来一个整体的脉络图，根据那个脉络的图，我们在一步一步进去找找对应的实现类，你就知道哦，原来是这么回事。

明白了吧啊这这块有相关信息，所以配首页配置怎么做，你应该知道了，我们那里面我这里都写了。

通过哪一类找过来，找过来之后找那个方法它都有展示行吧。

系列 3：P63：【Spring】Springboot启动源码解析一 - 马士兵_马小雨 - BV1zh411H79h

你要听话，我只说这一次错过就找不到我这样的天使，我就是喜欢你，想要跟你在一起。

从此以后我要握紧你的心，爱你真的很犀利，第一眼看到你立刻拿下了，我的心，眼里都是你，就算再多风景照片永远都是你无懈可击的魅力，轻易就让人入迷，什么道理都没关系，不妨碍我爱你，我想要牵着你去看繁星点点。

在浪漫的夜空下撩拨你心弦，伴着你到永远，让愿望都实现，能随时随地躺你怀里相偎相依。

people sit on that can fi，and i love it，when we rise side by side，cause you know。

we got that can fight，people save up that can fi，and i love it，how we don't even try，because we know。

we can't take it fi，the things i do couldn't do without you，place everywhere，when you need me there。

when you need me there，one piece could do whenever，i love with you。

cause we know we got that can fight，yeah，we know we got it，don't bring no，we are making e。

and i love it，how we don't get to try，cause，we know we got that good bye，yeah，we know we got。

this people say，we got that goodbye，i was singing，cause i can't stay inside。

cause we know we got that goodbye，things i'll do what do without you，oh thanks，everywhere。

when you need me there，when you need me there，one come into whenever，i went with you。

cause we know we got to get back，yeah，we know we got，because we know we got taken by。

and i love it that，we don't give them，a try as，we know we got it，b，yeah，we know we got that。

one piece clointo，whenever，i'm a review，cause，we know，we got that kf，can i love you。

how we don't even try cause we do，we take it by，yeah，we know we got it。

when you hold the line when every one of them escaping，i'm giving in tell me in this house of mine。

and now i never come out of runconcos，tell me where this style line will have a sting，well。

i save one more thing will put the sound of mine，stands strong，that's the price，you pay leave。

behind your heart，cast away，just another product of today，rather be the hunter than the prey。

and the finding on the air race of cause，you're rumentor a beating hear。

so you could be so cold to make it in wye girl，let you road lip in your life。

go go you gotta be so cold，yeah，you're left to roll，will somebody。

let me see the living in the doctor，i'm living through the glass，find the wrong within the past。

that's the price you pay，maybe i'm your heart gets away，just in that brother today。

rather be the hunter than the pre，and you're standing on the outfits of。

cause you are mentila beating on the rot be so cold to make it into，deep in your life，gogo gotta be。

so cold，yeah，you're left your roll，i'll tell you a story before it feels itself the lei on my reasons。

and say that i need help we all got expectations，but no one listen to me，so i played in this song。

they tell me think with my head，not that thing in my chest，they got their hands。

and my neck this time，but you're the one that，i want if this real is around then。

they don't know what this feeling is like，and i say，yeah，yeah，yeah，yeah，yeah，yeah，yeah，yeah。

then sit in my hands，i'll tell you all my secrets，and you tell what with your friends。

hold on to your opinion，and stand for what you say in the end，it's my decision，so with my foreina。

they tell me think with my head，not that thing in my chest，they got their hands，and my name is time。

but you're the one that，i want if this，real is around then，they don't know what this feeling is like。

yeah，yeah，yeah，yeah，yeah，yeah，yeah，yeah，yeah，yeah，yeah，yeah，yeah，好了同学们，咱们开始准备上课了好吧，能听到我声音的同学来扣个一。

这节课咱们开始讲那个bot源码的，讲bot源码人有点少啊，咋回事，你把我赶这周赶到哪个房间了，哈哈哈，这要是有自己单独的房间好吧，雅间ok好了，今天呢我们开始讲对应的一个源码课程，呃，讲源码的时候啊。

我刚刚说过了，内容容易引起极度不适，很多同学啊不管自己看也好，还是听源码课也好，听，都非常头疼，好听的非常头疼呃原因非常简单，大家可能很多基础知识呃不具备好不具备，所以可能呢呃看的时候非常非常难受。

非常难受o没事啊，该去听大数据听听听听大数据，你选择你感兴趣就可以了，这无所谓好，只要你听课就好了行吧，呃咱们现在开始讲一下spring boot的一个源码课程，呃之前啊你们应该听过很多源码课了。

问一个问题，大家觉得我应该以什么样的一个方式来看源码啊，这样的话效率更效率更好啊，高级感到底应该怎么做，官网官网上看源码就就就看不到啥了，好吧，先流程ok好奇来给大家说一下，其实如果你作为一个初学者。

或者说你作为一个只是应用一个应用者的话，好吧，你其实对swibox这块东西可能不太了解，但我们知道它是什么，是不是另一边定义了一堆启动器，所以第一件事先入手的时候，你应该知道了一些基本的配置，先想一下。

每次当我们想运行一个three bot程序的时候，都是通过这样一个幂函数来启动的，保持作战方式来进行启动的，这个启动方式大家看到了非常非常之简单，是感觉跟什么都什么都没写一样，那我们怎么做还是一样。

在后续看的时候，跟着源码进去进行一个debug，你要看一下每句话的一个代码好吧，这到底传到什么样一个参数进去，一定要顶bug，不敌bug之后，到后面就懵了，我看我也懵懂，我意思吧，大家看到了。

我们刚开始都是一个spring application，点wrong的一个方法，所以你先点到这方法里面，这打一个断点，我这边打了，你这直接打个断点。

然后我们一步往里边跟老师让我们写一个spring boot吗，不带你们写没意义啊，没意义啊，第八启动呃，太太说第一次上课，老师自我介绍一下呗，我姓连，大连大连有啥自我介绍的官网都有好吧。

游戏循环去官网看一下好了，我们刚刚已经打了一个最基本断点了，现在来右击debug开始进行启动，大家看到了这块会卡住，返回卡住，同时从第一行已经跳到我们这里面的一个run方法了，加上方法之后。

里面又是一个run的方法，还是一样，一次一次往里面点，点到里面去之后，这大家发现了有什么东西叫new spring application，好吧，他这是不是创建了一个对象，刚刚我们在主函数里面写的时候。

我并没有创建对象嘛，是不是直接以这样一个参数来进行写的，是不是调用它静态方法，但此时你注意了，除了这样写之外，其实很多地方你可以这样来写，它叫three boat啊，不对。

spring vacation sa等于另外一个spring application，它是可以创建我们对象的，创建对象之后sa第二叫set binder model。

你通过这个参数对象也可以进行一个直接调用，好听说这里面你可以设置自己的一个参数，那这块我们在后面源码的时候，你能看到具体的一个环节和具体的一个过程过程，只是稍微有点心，稍微了解一下就可以了。

进去之后跳到我们的three application这个源码里面去往上翻，我强烈大家建议大家一件事干什么事儿，每次在看源码的时候，先把它的一个最基本的注释给看了啊，最基本一个注释看了他说了。

这个class干嘛呢，叫can be used to brua，引导好吧，并且启动一个spring的应用程序，对于一个java主函数，是不是通过一个单指玩数，我能启动一个程序了，对人家说了。

bad bot class will perform the following step to bottoshop，your application是啥意思，说，他可能会经过下面的几个步骤来引导你。

启动当前你自己的一个应用程序，下面分了三个步骤，第一个叫什么叫创建一个什么东西叫instance吧，是不是一个实例对象对吧，哪个谁对象叫application contest。

又看到当前这个上下文对象了吧，你不要跟我说，老师这上下文怎么解释，你们从学sl的开始就已经开始接触我们的上下文对象了啊，它就表示你可以把它理解为一个容器吧，可以把理解为声器。

都会有一个上下文会放到里面去，这是第一点，第二点什么呢，叫register a说他要注册一个什么叫common online property，source，是命令行的一个属性参数吧对吧。

然后呢做一个school command line arguments at spring property，就是你可以启动的时候指定一个命令行参数，比如说我们写的叫杠杠server port。

是不是指定端口号，是这样的方式，第三种方式叫，重新刷新我们对应的一个context上下文环境吧，loading all single，beans，single变身啥意思啊。

是不是加载所有的单例的beans，这不用说了吧，然后再往下看，叫trigger定病死，是不是触发所有的病死好，所以注意这里面告诉你了，我大概就通过这几个步骤，然后现在告诉你说有几种启动方式。

第一种应该怎么做，是不是写了一个主要程序，第二种后面告诉你说了，你可以这样自己一个设置，先创建对象，再进行设置，两种方式都是可以的，然后下面有一堆的解释，前一周看一下就行了，我们这儿不再挨个读了算了。

我就我就给一个建议，每次在写的时候一定要去看这个注释，这注释里面虽然比较少，虽然比较少，但是呃描述事情描述的还是比较清楚的，一定要去看好吧，看完之后我们再重新看吧，看到刚刚那个run方法。

这刚刚那个上面那个解释看懂了吧，应该稍微看懂点吧，ok来往下看绕方法，然后放完之后先看他new了一个对象，new对象的时候一定要做一件事情干嘛，是不是点进去再点进去，是不是有一个主函数了，那一样的。

我们刚刚因为已经选择debug这样的一个方式了，所以你可以一步一步往后点诶，到哪去了，到这儿了，等会儿啊，我把这些断点给干掉，来干掉，重启一下，好了到这一行，然后呢往里边点点f7 对吧。

再进到f7 里面再进去加到这儿之后，看到了他就到它的一个主函数里面了，在当前这个构造方法里面，各个方案里面做什么事，第一个叫this resource loader干嘛的，不知道第二个是不是一个断言。

第三个prime source，然后viation type type，然后set什么叫初始化的一个方法，然后set什么叫listener，最后有一个mean obs，大家发现了里面一共做了这几件事。

这几件事很重要，你必须要提前把它进行一个出装好，同时在当前类的上面还定义了很多的一些参数值吧，这30当你在创建对象的时候，一定会进行一个创建吧，比如说上面有什么用哈，希set这是不是一定会执行的对吧。

要不要执行，怎么判断也是一样的，你挨个往上动啊，走f8 是到这行了，开始创建走走走，是不是把这些前面的一些成员变量值都给你附上值对吧，复完之后跳到这一行，第一步叫这操作，load等于空空就空着，不管它。

第二步是个断言，也不管第三步，这一步很关键的是干嘛的，叫primary source了，这东西怎么翻译啊啊主要资源吧，是不是主要资源后面给了一个值。

说arise at least primary source，是谁，是我们刚刚传递过来的，就是我们刚刚写好的那个主类，明白了吗，主类你刚刚在外面写个啥，是不是three bot dation。

所以当前这个主类就是这里面的东西直接拿过来，你给他看一下零是不是有一个name叫spring boat，诶，那叫spring boot data vacation，是不是刚刚好的那个启动类。

等着看这个吧，看完之后，这第一步骤先把它赋给一个集合对象，第二步干嘛呢，叫web app application type，第二deduce from class class，这个是干嘛的，注意了。

在方法里面这东西很关键。

你先听我说，你不用在意，说也不错的笔记，我这儿给大家写好一个文档，大家看一下这个文档里面怎么做的，能写注释的地方，我几乎都把它写注释了，懂我意思吧，所以你现在先跟着我的思路去走，他是怎么做的。

做什么事情，ok所以这个文档一会儿下课之后，我会发现大家你现在说自己看啊，这个东西我们不不管它了，我们还是一样，这个文档写的比较多，内容大家看这进度条很多的啊，能帮你们占的地方我都帮你们占了。

所以现在跟着我的思路去走。

不要去做笔记，没有意义好吧，这干嘛了，刚刚同学说了，叫解析web类型是m v z还是web flux，就是说我们用的是最基本的点进去看一下吧，一个是third啊。

或者是我们的显式布局或者srt或者是none，它这有三个对应的参数，你可以往里边点，同时也可以怎么做返回直接跳到我们当前这个方法里面去，进去就完之后，这是不是该判断了这一个pet啥意思好。

后面还有什么inspire preparent is present，什么意思，这要做一个解析，这前面都是我们对应的一个常量值，其实这里面你注意了有个东西叫什么叫dispatch。

hl是有这样一个常量值，其实它表示是某一个类的完全性的名，从报名到类名吧，是整体这样的过程，然后这里面也是做一个判断，判断了之后，如果符合里面对应条件的时候，把它设置为什么叫ra reactive。

是不是响应式的东西，如果它不符合的话，是不是跳到下面这个地方，这回是nt一个类型，如果这两个都不满足的话，最终会返回一个东西啊，sir这块就一个e什么意义来设置我们当前这个应用程序它是什么类型。

有三个默认的值，第一个是srt，第二个是响应式的，第三个就是我们的好，我们这走完之后，你可以往下看，跳哪跳哪去了，是不是该一个便利了这参数值啊，下一次一看我们这边都不做判断了啊。

接下来之后是不是直接返回最后一个，所以这返回的值就是我们对应的一个service，听白我意思吗，所以这块大家记住了，永远记住这个web app是tt等于so late，因为之后我们在环境在上下文的时候。

会有很多地方都用到这样的一个参数值，好这是第一个步骤啊，这关键这个点比较重要，这是第一块，这块做完之后该看第二块了，到这目前为止能听懂同学来扣个一，能听懂吗，你知道的东西在在在在在干嘛了。

就是参数设置好吧，我现在没跟你说，那个架子没有意义，你现在说架子也不了解，你就想下，如果你是初学者看源码的时候，我应该怎么一步往那边跟，上面其实就是一些参数值的判断。

因为我现在要创建一个spring application的一个对象了，这样一个对象，所以此时我要调查构造方法，在构造方法里面我做了一些参数值的赋值，然后这样做了一个当前应用程序类型的一个判断。

做完之后下面有个什么东西叫set sunder，然后呢这个东西叫get spring factory instance，很多同学在公司里面用spring，你对这个方法是不是应该很熟悉了。

这什么东西干嘛呢，叫获取spring的工厂实力对吧，这个获取工厂实力是干嘛的呀，啊是干嘛的，后面再传了一个类叫application application，然后呢。

contents later是不是相当于是我们当前上下文的一个初始化的一个类，这个类注意不要小瞧它，它的作用非常非常之大，我们可以干嘛呢，先跳到这里面点mc进去，进到里面去之后往下看。

叫get three factory instance，是不是料理方法里面再往里面走，昨天我第一步先获取一个类加载器卡，sog，这没问题吧，现在完之后，第二步往下走，是不是创建一个集合，这个集合干嘛的。

不知道，但后面一句注释叫usernames and insure unique to protect against the dk，是不是去除的一个操作，所以这里面又是什么，是一个set，然后往后看啊。

或者说这一段都是做资源加载的前置校验，可以这样理解吗，呃不太准确，它更多是为了加载资源，没有校验的东西，就是加加加加载资源，往下看啊，这里面传一个参数叫spring factory loader。

这load fighter names这块也一样，往里面点，这个太不用我说了吧，是不是刚刚都是传过来的一个参数，什么参数叫application context的need relier吧，这就传过来了。

就刚刚写好，那卡斯对象刚写完那个那个那个类对象，点完之后，你往里边依次往里边走，走到这儿之后，这儿有一个名称，这个名称也很简单，看到了吧，看这吧，翻译能不能什么a contest，你是letter吧。

这其实你看不出来啥，它为什么要定义这样一个类啊，我知道很多同学之前写的，其实你自己可能看过一些帖子，那个帖子里面说了，每次当你在进行加载资源的时候，哪个文件呢叫spring。

然后第二factory factories，有人见过这东西吗，应该都见过吧，是不是这样的东西，它是个啥，它可以理解为类似于是一个propertise，一个配置文件，在当前这个配置文件里面。

定义了很多外部或者内部的一些资源来供我们进行下载，那这东西我应该如何进行查看啊，也非常简单，第一行点到这块儿，再往里边点点聊，到这儿有个什么东西，是不是叫spring factory。

你看一下里面定义的啥，叫o r g spring framework，bot e n v property soft road里面是不是定义两个类的一个完全性的名。

然后有个spring application run，listen listener是监听器，再往下看，exception report叫异常报告器，再往下看，这东西熟不熟，说了吧。

是不是跟我们刚刚你所看到的那个application contest，你说letter是一样的东西啊，是不一样的东西，那里面一样吧，所以它会去读取当前我们这个文件，把文件里面相当于前面是k。

而后面这几行是我们的value值，他会把这些value值给你取出来，这东西也不是我瞎说的，老师李同学老师，你怎么知道他会去里面找这东西啊，这个spring factor，这个文件只在两个账号里面有。

第一个就是spring bot好吧，第二个在哪呢，在auto configure，它有一个同名文件，其他里面是没有的，好其他也没有的，你这便点开一个第三个有吗，你再点有吗，没有了吧，是不是没有。

所以这里面我需要把这两个文件里面的东西给你加载进来，好大家看到了里面都是什么，就是一些类好吧，你看到这个东西之后，有没有一个条件反射，它要干嘛，我要去读取当前配置文件，读完之后。

我根据我们的k值是能取出来一个value的，而我的value取完之后一定是一个字符串，对不对，那我根据这个字符串，我要生成类的话，ok同学说了，反射，其实这里面后面我们会看到有很多反射应用地方。

他把这些对象都进行一个实例化，怎么是这话是有东西叫class pass，对不对，那个class叫for name，for name，完了之后是不是有东西叫instance，这些实例化就搞定了好。

但你要知道它是哪，从哪儿来的，应该怎么进行一个最基本的读取，这块也不是我瞎说的，我们可以来进行一个验证，我关掉了啊，两个文件没啥用，关完之后往这边走看，第一个方法，往这边点，点击之后再走。

是不是在哪儿下载，这完了之后上面告诉你了，说这是一个什么东西，是个map结构，把你自己调大一点吧，看不清楚吗，调大一点放着，现在好了吗，现在好点了吧，没关系啊，大爷我们大点无所谓啊。

来往里边看做什么事情，我刚刚说了，这里得到了一个名称是什么，叫application spring application contest吧，建完之后通过调这个方法，这个方法之后往下看。

这儿先创建一个map结构，创建完当前map结构之后，把放大创建完3000map结构之后干嘛了，先判断一下这个结果是否不等于空，如果不等于空话，直接返回等于空话不做了，第二步干嘛呢，叫n有这个东西是啥。

一个枚举类，是不是一个枚举类，这东西大家应该都认识，然后中国叫class loader的，get resource，从哪get resource resource啊，点进去看到参数了吗。

是不是m e t a杠i n f spring patteries，他会去我们当前的class pass这个路径下面，查找当前具备相关文件的一个名称，找到这个文件名称之后，会把里面的东西给你取出来。

好给你获取出来干嘛，下面也是一样，get system resource，是不是通过两个资源路径把这东西给读下来，读完之后没完，然后呢，这个我告诉你说了，要你另外的一个map结构是我们的result了。

念完之后开始挨个进行便利，因为我们当前依赖的环境里面有两个spring的文件好吧，spring factor文件吧，所以这时候它是一个集合，要进行一个迭代，迭代完了之后，挨个把里面的值都取出来好吧。

注意啊，根据什么取，是把里面所有的k等于v这样的方式的值全部都拿回来。

刚我给他站出来了，这天粘出来点往下看。

我把那两个文件的东西全部都站出来了，好吧，上面这块就是我们的k值。

后面就是value，把这些k和value的值全部都获取出来，好这块就是获取的一个操作，获取完了之后没完，他要干嘛呢，叫catch。put什么什么东西啥意思，因为你后续的时候啊需要不停的去加载那些。

比如说间冰器类，比如说初始化类，我每次我都去文件里面进行读取的话，这个效率可能会比较低，所以在这一步的时候，我做一件事情，我提前把所有的配置文件都读取进来，然后放到我们的缓存里面，但我需要哪个类的时候。

我直接去缓存里面读就行了，而不需要从文件里面再进行读取了，懂我意思吧，所以这就是这个步骤的一个操作，最终会把我们的rett给反应回去，然后呢就是一个map结构，听明白了吧，这个过程应该能听明白。

完了之后大家看到了，是到这步了，这不是完成了，完成之后，第二步叫get a default，获取或者是呃获取或者是那个什么一个默认值吧，叫factory type name，借着这个名字叫什么。

叫application context的，然后已经是leather吧，把这名字给记住，这是不是有这是不是有好，所以我们可以往里面走一下，f7 进到这里面，然后往下走，一直走走走，这不是一循环结构。

我也这么打的，打到你啊，直接跳，直接跳过去啊，走它会进行n次循环，大家看到了里面有多少个。

是不是有13个，我们对应的一个结构极了，是13个吗，是不是13个很好判断。

怎么判断，你打开刚刚我们站出来这个spring文件，你搜一下里面有多少个k，你送完之后你会发现里面应该我没记错的话，应该是15个k，因为什么，因为里面是连接两个文件，这两个文件里面某些k的值是重复的。

比如说我举个例子，第一个叫obligation contest，usual lander啊，你往下翻，这是不是还有一个，再比如说pication listener，往上翻。

这边还有一个它有一些重复的k的值。

重复k值会把所有的几个value值都放到一起，就这样你看到只有13个，懂意思了吧，然后往下走，回来回来之后该从里面获取了吧，实际上在此处获取我们参数配置的时候，它从哪读的，是从缓存里面读的。

记住了缓存里面读的，我们这进去之后可以看一下吧，这f7 进去呃，退出不是这样，再点进去看，那是不是它是开始从里面叫v等于get什么东西，然后呢ctrl k什么东西。

然后把我们对应的一个值直接返回回就可以了，当你这返回回去之后，因为你刚刚匹配过来是啥，是哪个东西，叫application context nether吧。

所以这时候我们可以做一件事，什么事，你数一下当前的配置里面几个是几个类啊，123455个吧，你往下翻121共几个。

是不是七个，是不是应该七个，那意味着我当前这个集合类里面，它返回粒子集合就应该是七个，这没毛病吧，所以下面我们这边走，走到那之后往下走一步，再往上看，看这size多少是七吗。

你把这个弹出框调大一点，是不是七个对应类，你可以给我们刚刚这边做一个验证，做一个匹配，放哪儿，放这儿吧，看后缀就行了，看后两个，第一个叫sharing metadata，什么东西。

然后呢肯定是到什么东西，后两个一样吗，一样吧，那意味着我是不是从当前配置文件里面把这个值给取出来了。

而且刚刚好跟我们的数据是一样的，所以刚刚完成什么操作，玩什么操作，是不是就完成了，我们整体从里面获取我们数据文件的一个操作，但其实刚刚把刚刚这块注意了，只是把那个东西给取出来了。

取出来例子集合现在有进行任何实例化操作吗，听我的问题啊，有进行任何实例化操作吗，怎么怎么没说话，没有吧，你没看到吗，是不是没看到，没看到，你往下撸，这是什么东西。

叫create spring factory instance，这儿告诉你说我要开始创建目前对象的一个实例了，它是不是也返回一个集合，集合是一个实例的一个集合，等到上面集合不一样的，上面只有name。

下面是跟我们的集合了，所以你依然往里面点进之后get到这一步，这是要做什么事情啊，你看一下这里面是不是我说的反射啊，第一步先把我们这个内部放到里面去，先创建一个空的集合t t类型。

因为类型嘛你的类型都不一样，所以他写了一个t占位符，然后开始循环遍历，我们当前内学完之后，第一步叫class you too，什么点for name吧，你点进去看一下，往下走，找一下哪儿去了。

看看是不是全部都是for name，是不是告诉你说这name start with什么东西啊，这有for name，我之前用过的东西吧，class for内容直接进行一个反射的一个操作。

获取完之后只是什么，找到我们当前这个大写函数对象，然后呢获取它什么该构造器了吧，就是告诉你说明它的一个构造器是啥，有了构造器之后，我再进行什么，是不是实例化类好吧，所以当你这实力完之后。

这已经变成一个instance了，此时把instance再放到我们刚刚定义好那个例子集合里面，请大家想一下，当我这个步骤如果我已经完成了，我做什么事就相当于我实例化的，实例化好，七个已经存在的对象。

是这意思吧，你得把它走一下啊，我们变下试试吧，第一个先取出来一个值，class等于什么东西，是不是取出第一个取完之后再下下下下下来看这instance有一个知道吗，是不是已经有一个结果了。

因为你现在完成一次了吗，下面也一样七次，所以要循环七次循环，我们这不看了，我一样的把它直接跳过去了。

走调这这这一行等下有点慢啊，你咋这么慢吗，怎么这么慢，所以这块大家注意了，当你看完之后，你会发现他完成了七个类的一个实例化，断点无效，不是吧，好了停了停了重来没事，重来也行，来往下走看。

这是不是到这个实例化了，这赛季多少，是不是七个，是不是七个，这已经知道我们对应七个的一个值了，所以此时我可以把我这个值直接返回去，当前返回去之后，你这已经发现了，是不是已经有了七个对应的值。

你往下拉一下，这样instance他变成现在都是我们什么实际的对象了吧，这是不是都是我们对象了，所以这已经得到这个实体化对象了。

当然这些对象是干嘛的，你现在还不知道，我也不知道，你看一下这电影什么东西。

就是一堆初始化的一些值吧，往下翻往上翻，看上面这个地方什么叫configuration，warning，application compass，you leter配置警告的一个初始化，一个初始化的东西。

现在呢the contest id是什么东西，我想看下面还有什么叫dedication，i will是什么东西，而socket是什么东西，然后server port是什么东西。

是有很多这方面的一些值啊，我知道很多同学对这些值很懵，我不知道这个类是干嘛的，没关系没关系，我刚刚我说了，我在这个文件里面给你们写了一些麻烦啊，赵醒来后来看，刚刚说了，这里面是什么。

是一些contest的一些初始化设置，第一个叫报告，spring容器的一些常见错误配置是第一个它的作用，第二个叫使用啊，配置那个three上下文的一些id的一个值，然后指定初始化器进行初始化的一些规则。

设置到什么的环境里面去写东西，我都给大家写好了，所以你现在先不要管这几个类是干嘛的。

因为运行的时候我不知道懂我意思吧，来到目前为止，能听懂的同学扣个一，你懂吗，好没问题，扎完了之后来再接着往下跟，跟什么东西，到这儿之后再做一个操作，叫annotation wolder compare。

不知道干嘛的，没关系，这有shot shot，什么意思，排序吗，我只要进行一个排序操作，排出去，排完序之后把当前这个结果直接返回去，你不要管老师排序干嘛的，我也不知道好，我也没看下这个排序干嘛的。

但是最反正最终得到一个结果，不过我现在已经把它拍回去了，并且能把我当前这个实例对象都返回回去了，这样做完之后注意了，只是里面东西，一会我们来画图，一会我们来画图好，先看这里面做做做，做什么东西。

一会儿来画图啊，别慌啊，会会给你画图啊，别慌，这做完之后再往上看，是不是刚刚只是掉里面的方法，加完之后该叫外面了吧，是不是该设置到我们当前这个初始化器里面去了，所以往里边依次进行一个点，哎哟快求你了。

写错了，来往下看这边做什么事是吧，你刚刚处理好那些类的对象，直接放到一个集合里面去搞定了，这里面其实没做啥啊，其实没做啥，非常简单，就直接放到我们这边去啊，这是刚刚写好那个那个步骤来再来看。

回过来做这些事情，你放下面这个代码的时候，你看到了跟上面是不是一样，也是get spring factory instance，然后呢，obligation listener，这两个是一模一样。

你看到listener之后是不是一样的，去我们配置文件里面要找我们的listener了几个。

12345678 90 十个吧，你再往下找，这不是有一个一共是11个我们数码器啊，所以你往下走也是一样的，点进去就这就到这了，往回翻多少个是11个吗，是不是一个意味着我把这个监听器也给创建好了。

然后再定到我们的listener里面，直接创造一个集合好吧，这是我们这个操作做完之后，上面的东西都做完了，就完成一些参数设置，做完之后再到这叫this mean application class。

是干嘛的，是不是找一下我们当前应用程序的一个主类啊，或者一个主函数，对不对，主函数它用这个方法叫什么，deduce medication conclass，这干嘛的一个方法，你可以点到方法里面去。

这里面打印的什么呢，叫new wrong time exception，然后呢点get stack trace，你看到这个方法熟不熟说吧，你之前写代码的时候，当你看到异常信息的时候。

都是通过叫一点price tag dress获取到跟踪信息，所以此时在这里面，我们也能获取到我们整体这一类的一个异常对战信息，好就说你这个代码是一步一步怎么走的，因为我要找到你的主函数吗。

取得一个集合之后，你也发现了这有什么叫if me，点什么东西，是不是找到我们的幂函数，未来之后叫class there for name，又开始跟踪我们当前这一类来进行当前类的一个初始化操作。

当前列的一个什么反射操作，获取一个大写c的一个对象，好来点击试一下吧，过完之后你把它看互相有什么是不mean obligation，contest a obligation class吧。

做完之后往后翻是啥，是我们自己写好的com吗，是不是点three boat dvk是吗是吧，是不是看到这个步骤了，所以这块你应该能看到很多的一个相关信息，相关信息，那这个东西来我们画一下图。

来看一下刚刚那个步骤讲了这个代码。

我们做点什么事情啊，说三三，先报，请检流程图，来往这看吧，他进去之后，第一步骤我干嘛呢，是当前这咋回事，叫启动当前应用程序怎么启动呢，是不是找到我们对应的一个幂函数，想让你帮我啥。

是叫spring data application，第二啊，不对啊，叫spring，好厉害，第二run方法吧，这叫弱方法，调查方法之后，最终你会看到一件事，往后走，这里面做的什么东西。

是不是new了一个spring application，有对象吗，是不是先救它，是先救它，你要对象之后，你要知道在当前对象里面，我一共做了几件事情了，做这件事情，想想做这件事情，我们这写一下。

第一步叫一，配置什么叫resource loder，当然这个值啊，刚开始时候是空的，刚开始时候是空的，这没关系，你就先写，这是第一步，第二步叫判断什么呢，当前应用程序的类型，这个类型有三种。

分别是server lt，reactive，然后呢还有now，证明问题吗，这是第二个步骤，第三个步骤在干嘛，哎三在干嘛，是不是初始化，或者说获取初始化器的实力对象，第四步获取监听器的实例对象。

第五步找到当前累的呃，当前应用程序的主类开始执行，想一想，这是我们刚刚那个构造函数里面做的这几件事吗。

这没法用啊，所以能看懂吗，我刚刚就带你们看这点东西啊，这东西还没开始看的，我说一下再说一下，第一个是他吧，第二个第三个，第四个就是一共这么多步骤，你把它记住就行了啊，这没必要记啊，你把它理解到就行了。

当你做完这件事之后，这块到目前为止能听懂，同学来扣个一，能听懂吗，你先按照这个流程去做，先按流程去做，这样这样他当你检查之后，到第二步了，该干嘛了，我对象创建好之后，这个步骤会执行一个run方法。

这种方法，这种方法表示什么意思，启动，怎么老乱了启动，因为大家想一下，每次当你在运行，为啥从long time的异常堆栈信息里面找到主类啊。

来这里看一下，知道吧，是不是这方法里面我要打断点试试啊，我找一下走，漏的走走走七个，进到里面去往下走，这是一个什么叫new装time excel什么，这儿有一个叫get stries。

你往下看这个rise干嘛的，你看一下01234567，对不对，你看一下后面它都跟那什么，跟你当前类里面所在的那个代码里面多多少行了，在多行279行，你找一下270 95，这一行你往上翻就274。

270在哪，你往上找是不是刚刚你调过来的方法，你调过来之后，你往上翻253，你往上找是不是刚刚是从这行调过来的，你往下翻一步一步找到就找到最后一行，是不是有东西随便背的，第11行，11号找一下。

是我们当前一类主函数吗，是不是找他了，这个直直直接找到了，就找到主函数时候，意味着我们现在可以开始执行了，就这样步骤好，所以你刚刚看的程序里面，它会一步一步往里面接着往下走吧，挨个匹配。

如果是mean的话，如果是的话，他就可以直接返回去看，那他知道这三天类了，然后把当前类进行一个实例化操作，因为我们并没有创建这个几个对象啊，所以这直接进行一个class，然后返回去就行了，就这样步骤啊。

搜查很难理解吗，好吧，异常战斗，这样就是这样的啊，这有啥可看的对吧好了，这做完之后来往下看，是不是这个对象创建好了，传建好之后，我这样是不是会掉一个装方法，当然后面要传一个参数。

你们在写设计程序的时候有写过这个参数吧，这都写什么，比如说叫杠杠，然后加一个叫server。port等于8081，是不是可以指定端口号以及其他的一些参数配置，是不是都可以用杠杠的方式进行写。

到现在我们这程序里面什么参数没写没写没写没关系，点f7 进到我们当前这个run函数里面去。

这里面这才是我们整个应用程序启动的一个过程，这个过程给大家说一下，是非常非常之麻烦的，好里面涉及到很多的一些点，这些点我要挨个来说，你好好听，这才是我们的核心，第一个参数，这是空，不用管它了。

以后我们都直接忽略，我们30要做事，第一步干嘛呢，叫start stop，watch是什么东西啊，我很难不知道他干嘛的，但是你想一下，你作为一个应用不应用程序，你每次启动完之后，你看的都是什么。

先打印一个banner，打印了我们对应的一个binder之后，然后呢我要打印一些异常信息，我会正常的信息，打开日信息之后会给你一个时间吗时间，所以这个stop watch就是用来计算我们当前时间的。

你点进去你会发现非常简单，这个this往里边点，这是他出现好对象了，好就给了一个this，这是个什么空格字符串，地址是空字符串，完了之后，这个东西叫翻译下走，这东西start吧。

点击start这边点进去，你看都是什么，叫this countess name，不等于空，它的空字符串，空字符串并不是空，和大家不一样的，如果空的话，不是空的话，计算一下，告诉你说当前任务的名称是啥。

你说开始的时间是什么时间，这叫system dna动态统计好我们当前应用程序的一个时间也搞定了，是不是这样一个值，这条计算什么，计算你当前整个应用程序，你在启动的时候，它所浪费的一个时间啊。

浪费的时间或者说所耗费的时间，这样大家注意一下就行了，好注意一下就行了，就是一个时间的东西，别的到没啥啊，它为什么计算时间不用我说了吧，看一下你启动不用花多长时间嘛对吧，记完之后往下看。

这这两步骤很简单啊，不多说了，再往下看，第三个是干嘛的，configuration，application，contest，contest等于啥干嘛的。

就设置的是我们当前这个three ring程序的一个什么沙环境，当然是现在的沙文环境，依然是等于空的空，什么都没有做设置，把任何事都没有做准备，不用管它。

然后我们来看第二个什么叫大家都叫exception reporter，是个异常报告信息啊，所有人都知道你在启动你的spring程序的时候，有可能会成功，有可能会失败，而失败的时候要把这些信息给汇总回来。

启动过程中你报的一个错误会放到里面去，说建一个创建一个集合，当然现在只是new了一个race，你不用管它，如果你起了不报错的话，这对象没有用了啊，没有用了，意思就是这部再来看第三步。

什么叫configure headless properties，这东西也很没用啊，几乎一点用都没有，他干嘛的，它的作用也非常非常简单，你往这边点一下试试啊，走做点什么事儿叫system。

set properties，然后呢这给了一个参数值，叫java。a w t。headless，然后呢做完之后再来看第三个叫system的get properties，也是这样的一个值。

我现在要设置这样的一个参数值，把当前这样的参数值设置，为什么设置为tru windows环境里面是不需要的，因为大家知道环境的时候，你有对应的键盘吗，有对应的屏幕吗，有这些东西吗。

是没有这样的一些外部设备，是不是有这样的外部设备也老师有啊，我自己可以连啊，你连是通过远程进行访问的，懂吗，你在你服务器上装过显示器吗，涛同学，你不去装我显示器啊，没有吧。

所以这里面只是说我在会因为他用的什么用的是awt，应该很熟了，现在可能没人学了，但这个大家应该很熟，java里面用做那个图形化一些东西，所以这块做这样一个参数的一个设置，物理就告诉你说你服务器里面啊。

如果没有那种呃鼠标了，屏幕的这样一些外部设备的时候，我可以进行一些图像的绘制。

就这意思好，所以这块我给大家做解释了，大家给他看一下吧，我找一下啊，23找一下，看这设置系统属性上就占二点awp，还有类似的值，默认为tru可以运行iis服务器时进行简单的图像处理啊。

都用于什么叫缺少显示器，然后呢键盘和鼠标时的一个系统配置，很多监控器如j抗so需要的话，把这个值设置为true就完事儿了，他对我们当前这个应用程序其实没有多大影响。

它就是只设了一个系统参数而已，稍微记一下就行了，好过一下可以可以了，ok这过招不用说了吧，不用说了吧，到这儿为止来能听懂同学扣个一，是不是现在就是一个前置准备环节，我们再来画一下图吧。

想要做一件什么事，装技能之后这样把它做一下，第一步叫设置或者是记录，一，我这个键盘咋回事，设置启动时的启动时的时间值，时间，指定用不着，做完它之后，第二个想一下刚刚第二做什么，做什么事。

是设置一下我们当前这个contest对象，我说创建，这怎么射啊，好麻烦，这个突然是这样的，设置叫contest，应用。

下文啊这都比较简单，这是第二个步骤，好这是第二个步骤，然后第三个步骤干嘛的。

是设置一下我们的异常报告器，啧啧啧哎我操，这是一场报告，七，第四个步骤。

这刚刚是上面这第四步，是不是要再往下看。

完了是设置一个第四，把封掉了，设置，java第a w t点他的例子系统参数化为true m可以切换，没有啊，好不管它了，这是我们前面这四步要做的事情，对不对，这四步做的事情都比较简单。

都是从这儿挨个练下来的，然后画一下第二步，ok这是四部，前四步做起来还是比较简单的好吧。

或者说他几乎没设置啥，是从下面这步骤开始就比较麻烦了好吧，这步骤相当相当麻烦，我们看一下之后也非常容易看到说什么呢，叫spring application run listener。

listener等于get wrong listener，看完之后感觉没什么感受，干嘛呢，是获取我们的wrong listener这样东西类似的是什么是什么，是什么玩意儿啊，这东西该怎么判断啊。

怎么判断怎么做这个东西吧，先想一下它有什么样的一个意义啊，其实你非常简单，我们可以做一些什么事情，你可以看一下，刚刚你看到前面这个类，它是干嘛的，点进去叫a collections of。

什么叫three application wrong listener，这就是一个运行时的一个监听器，点到这个监听器里面告诉你一个解释，说listener什么呢，for the method。

是不是告诉你说我要监听我们当前这个spring vacation这样一定程序对吧，然后说了这个spring application run listener是一个什么呢，叫加载。

什么叫three factory road来进行加载，并且应该被声明为一个什么呢，叫公共的构造方法，允许接收一个什么呢，实力，并且有一些什么词缀类型的一个参数，你说它就是用来干嘛的进行监听的。

只不过前面加了个s之后，它变成一个对应的集合了，是变成一个集合了，一个集合里面放了什么，放就是单一的一个视频对象好，所以这块很很很很明确，而且这个类里面也明确告诉你了，干嘛呢。

他说这类必须声明介绍一个什么叫sprint的一个实例，有一个string的一个构造参数，把这块稍微记一下啊，稍微听一下，就刚刚点开这里面这个方法我们找一下，可以来看一下哪儿去了啊啊他是个接口是吧。

这样没有是吧，这个接口就往回返往回返后面这几个方法叫什么，叫get listener，run listener吧，点进去，这就告诉你说返回这样的一个集合，这个集合啊其实也比较简单啊，其实比较简单。

但是上面这不简单了，那传参数第一个叫spring application that class，第二个叫spring declass，是我们刚刚说的吧，他接受一个spring vacation的一个类。

一个class对象，同时介绍一个string参数，是前面说的东西，往下看，开始new了，这个new这非常非常麻烦啊，非常非常麻烦，好为什么说它非常非常麻烦，原因非常简单。

有一个new spring education run listener这样一个对象，同时叫get spring factory instance，你是不是又看到这东西了，你看这东西你觉得你熟不熟啊。

这能熟吗，在刚刚我们所看的源码里面，你有没有见过类似这样的东西，你见过吗，有印象没，没有见过吧，哪见过我们在创建当前这个spring implication对象的时候。

你在往里面注入我们的初始化器和我们刚刚那个listener的时候，是不是看过这个东西，它是不是都是同一个方法，所以你告诉我这个步骤是来干嘛的，他干嘛的，对，7+11，就这数字7+11。

七表示我们的初始化器，11个表示我们的监听器对象什么东西，那这又用到它了，那很明显，我又要从我们刚刚那个spring fire文件里面是不是加载某一个类进来了。

怎么加载spring application run listener。

找他了一样，你去我们刚刚配置文件里面，你找一下有这个run什么东西吗，看是不是叫spring obligation，wrong listener，这里面它是我们的k吗，它返回的value值等于什么。

等于叫event publishing，然后呢wrong listener，什么叫事件发布的一个运行时监听器。

但很明显我们这儿拿过来之后，我所得到的一个对象有对象，是不是刚刚说好了，对象叫什么叫event。

就是值publishing，wrong listener是得到它。

得到它之后，这又干嘛了，是不是该new我们当前这样一个对象了，所以此时你点进去画面做成这，首先把log敷一个blog，第二个是把我们的listener给放过来，这看完之后又懵了。

我listener是啥是啥类似是不是你刚刚传递一个对象，直接给它传进来，传完之后它又构建了一个什么叫three obligation，wrong listener的一个对象，他来做这件事情的。

大家想一下刚刚这个方法里面我到底做了一件什么样的事，情，什么样的事情想一下，就告诉你说我创建了一个spring application，装类似的一个对象，那个对象叫什么叫ev，然后呢叫啥来着。

啥啥啥技术啊。

找一下是叫pation wrong listener，是不是在当前这个这个对这个这个这个监听器了，这个监听器它有什么样的一个用处啊，那同样用处啊，注意了，这个电电器的用处其实非常非常重要。

好非常非常重要。

为什么这么说，我们可以依次来往这边走一走一下试试啊，第八到哪了。

这哪儿啊，这还在哪儿呢，是到这一步了，到这了吧，刚刚是不是获取到这个对象，这个时候它获取完之后，它有且仅有我们这样一个值，然后再点点我们的这块这边走完之后往下翻看，它返回的值是多少。

只找一下我的listener listeners，连续一个值是一个结果值，叫event power，是装listener，是这个步骤里面要做就做这样的事，我就说我把刚刚那个监视器已经放到里面去了。

这样放完之后没完，因为你放进去没啥意义，它就是一个对象，问题是我要把当前这个对象进行一个starting了，starting，朋友们就知道老师我很明确它就是用来干嘛的，用来进行一个启动的吧。

是不是你启动的，那他要如果进行一个启动的话，我应该怎么找他呀，点一下我们的starting往这边走啊。

f7 大家知道大家看到了，这是个什么操作，这个叫for for循环吧，这样循环我们刚刚写好那个类似listener吧，这个listener是谁啊，你看上面这上面这个类是哪一类。

叫three application wrong listeners说了，这里面有两个对象，一个叫three application run listener，还有个listener s是不是加了个s。

这是一个集合，public是wrong listener，所以这今天开始进行一个循环操作，往上走一循环，取消第一个值，event publish，wrong list，是不是取取完之后，这又有啥东西。

又开始进行一个整体的启动过程了，是不是要启动了，这启动怎么启动一样，点进去把二了到这一步之后，和那个懵了，老师这是个啥，我压根儿完全看不懂这样一套东西，这儿如果看不懂的话，我来问一个问题。

在我们的spring里面，不是fbo，在spring不死，在spring里面有没有一个事件监听机制，有人知道吗，没听过这东西，对事件发布机也行，事件发布机制在spring里面有听过吗，对吧。

他是什么样一个套路，或者说它底层到底用了什么样的一个方式，什么东西是不是就用了一个最基本的设计模式，教程设计模式叫观察者模式吧，有人知道的东西吗，观察者模式有人听过吗，你们应该听过这东西啊，来知道扣一。

不知道扣二，前置通知这些东西吗，同学啊，你如果之前了解过spring或看过spring的一些源码的话，应该是知道这个东西的里面就可以过上这个模式，大家对观察者模式不太熟的话，回调对，就是回调就回调。

大家如果对这块不太熟的话，下去之后把马老师之前讲那个设计模式这个东西好好看一下，这个还不太舒服的话怎么办。

我要给大家推荐一本书啊，之前我在做基础班的时候，就给给大家发一本书，叫设计模式，这本书啊叫设计模式之禅，但是比呃外面书要好很多，为什么每一个设计模式里面都给你举了一个例子，然后里面有代码。

有类图这样的方式来进，给你进行解释的，告诉你那块东西干嘛的，反正我觉得这本书啊还挺好玩的，为什么，因为里面举的例子特别好，他这个观察模式是干嘛的，说了一个韩非，然后还说了一个韩非子，说了一个李四。

是说几个人通过这样方式怎么一步步进行迭代，迭代完之后达到什么效果，有代码的一个最基本实现，看到了吧，下来之后呃，我一会儿把这个书共享出来，你们可以给大家好好看看，好好好看一下这个东西啊。

呃设计模式其实说白了我们平常写代码的时候可能用的比较少一，但是你在看源码的时候，你会发现很多源码里面都用到了无视力模式，你如果汇率设计模式的话，你的理解会非常怎么说，非常轻松，我意思吧。

如果你不是这模式，可能看起来稍微有点难受，headfirst怎么样，那本书挺好的，那一系列书都挺好的，那个书就是里面有配图了，有什么东西我觉得还还差不多，单方设计模式没必要，你就看我这本书啊。

给这个这个书也不也不多，363页里面就有一些设计模式，主要代码占了很多的一个，每个里面都是一个小小故事，策略模式，刘备要娶回家，能回娶老婆了，走之前给赵云三个锦囊妙计，说是什么东西上的。

告诉你三个问题是啥，代理模式是什么东西，代理模式，举一个说西门庆找潘金莲，潘金莲不好意思拿出来咋办，找王婆做代理，然后呢，首先程序上是这样的，一个是我没跟艾滋文字man happy韦斯曼。

这里面都是一个小故事，就通过这个小故事能非常轻松，非常简单的告诉你说这设计模式有什么意义，单例模式，多例模式每个地方都一样的，再比如说工厂模式告诉你说女娲补天，你懂历史干嘛，谁让你懂历史的。

你去看看里面人物就举举这个例子啊，怎么做的，是创建实际对象，女娲造人怎么造人，第一次考，你这字熟了吗，第一针丢一半的是没烤熟，第二次过头了，变成黑人，第三次，然后呢，正正好黄主任是不是这样一个案例。

所以下一句话把这个东西好好看一下，然后我觉得这这时候还挺好的啊，基本上每个地方都是一些案例，每个小案例，然后直接拿出去看一下，好晚上躲被窝偷偷看可以，你要有这个兴趣，你就偷偷看吧，行吧。

呃一会儿我把这个书给大家共享出来，一，下周把这个设计模式好看看，呃如果有时间的话，最好还是把马老师那个视频再翻翻好，再翻一翻吧，好了。

我们刚刚讲这块了啊，刚讲哪了，是不是讲到这块了，我上传到我们get up，上传get up，所以你要把世界模式的东西好好看一下，一定要看，不管你现在工作多少年，如果你想看源码的话，这块一定要一定要看。

我都忘了，原因就在于你这些案例基记不牢，如果你把潘金莲这东西看了之后，你一定不会忘的行吧，我们刚刚看完这块是不是要进行一个监听器的一个启动了，这块我们稍微休息一下好吧，生成回来之后。

我们再接着讲整体这个启动过程啊，整体启动过程嗯，再睡一下啊，嗯，看到现在感觉怎么样蒙吗，首先由于涉黄被封，先丢群里瞅瞅行事情。

你们瞅一下吧，我再一步一步带你看啊，但现在就是带你看的时候就会有一种感受，什么感受呢，我每一个步骤好像能看懂，但是我整体串不起来啊，我是故意这么讲的，我是住故意这么讲的呃原因非常简单。

大家可以看到我在这个pos 2上其实给大家之前画了一张图，整体这个流程图其实我是有画的，每个里面做什么事情，我是有画这张图的，为什么没给你们先看这样一个东西，为什么先看，因为这东西只有你看了原版之后。

你才能把它给画出来啊，你才能把它给画出来，觉得作为一个初学者，你在刚开始学的时候，你一定没有这样的能力，没有这样强烈，所以你先捋源码，等我把这套流程捋完之后，我们再回过头来画这个图的时候。

你就感觉哦原来这么回事，然后你再去看一遍源码，你就知道这东西是这么搞的，你就清晰了，懂了吗，你上来的时候，我在看野马的时候，我刚才啥都不知道，这不可能，所以我在给你讲什么，讲我在看原版的时候是怎么看的。

我是什么样一个方式，我希望你们把这个方式给学会了这个东西，或者比如你要看其他页码的时候，也是这样的套路，懂我意思吧，唉，你室内不是不允许抽烟吗，我们办公室允许啊，不允许抽烟的话，我跟周老师就别活了。

这日子没法过了，就，我跟香叶，你选哪个，那肯定选老婆呀，你疯了，现在娶个媳妇多难啊，对不对，那就别抽了，媳妇不管我抽烟，我媳妇不管我的，周老师头发长出来了，你开玩笑吧，还是少抽少抽点吧。

你们开始欠我这个绳儿了是吗，哈哈，媳妇怀孕之前戒了半年烟，后来就就又又又又又又抽了，这权限管理数据，权限管理系统数据库怎么设计好啊，现在是这样的，如果你要做权限管理的话，最low的一种方式。

r b c3 张表角色什么之类的，好复杂一点的话，可以上three siri，或者用一下sho，你这个现在不是什么难点啊，大学生的话，你要想在学校做项目时候，用那个权限管理的话。

就设一个东西r b a c，有东西r b a c你可以搜一下，现在生产环境里面没人那么用好吧，我的毕业设计企业课题，之前那个在一架构仪器的时候，明哥做那个五指化曝光系统的时候，里面就有r b a c啊。

你看一下那个视频之前讲过的，三个一般适合做权限这块东西，框架是不是也是这样设计数据库表，这不一定啊，这不一定啊，这要根据你公司业务来决定了，框架我知道，但是自己设计数据库不会就这样创建。

首先你有一张用户表，然后建一张第三张表，里面存两个字段，一个是用户id，一个是角色id，只要操作这个关联表就行了，其他表情设计是最low的一种方式，叫r b a c。

这东西你要想要杀手或者用spring city的话，就可能稍微复杂一点，就像token这样东西，这你有问题的话，下回我们再聊吧，三个叹号好吧。

看同学扣波一，我们接着往下讲啊，高铁还是比较多的啊，要让人家比较多啊，刚刚我们看到这部了，这不是干嘛呢，是不是要进行一个监听器的一个启动，哪个监听器大家还记得吗，监听器是不是是不是有一个东西。

有个东西叫什么叫event，叫publish relish，然后呢叫run在哪儿吧，我们刚刚传过来，是不是这样一个东西好传这样一个参数啊，你记住就行了，先把这个参数记住，当你传过来这样一个参数之后。

然后呢看这个东西叫什么，叫this点你手什么东西，然后点什么东西，我都看过，我是干嘛的，但是你发现你可以往里面进行一个点击，这里面创建一个什么对象啊。

叫new application starting event，又看到第二个东西叫stan event，是不是老师说开启事件或者开始事件之前干嘛的，我还不知道，我还不知道之前干嘛的，但是我先记住了。

他先创建好了这样的一个对象，你可以把这个对象点进去看一下，他这是最基本的一个构造方法，一次性把八点是不是就设置一个参数标挑去都没有了，所以其实没有什么核心的一个含量，就告诉你说我创建好这样一个对象了。

创建对象关键是什么，在这个方法里面，你可以调这个方法点进去看一下，这里面又开始指往里面掉，处理一个什么叫result type，好处理的一个类型啊，或者处理类型，这不管它啊，这波并不重要。

点进去你可以往这边走，不到下面的方法里面去了，到下面方案里面去之后，这儿有一个tab类型是我刚刚通过这个参数来进行一个最基本设置的，设置完之后，这儿有个东西叫tap tap。

下面之后这是不是有参数告诉你类型是什么类型，第一个叫application starting，问的是你刚刚创建好的对象吧，好对象。

然后event告诉你了哪些event叫obligation staring event，后面告诉你说source是谁，是不是还是我们的一个spring application对吧，先告诉你。

其实现在要记两个对象了啊，第一个同学们说了，你问他party形状类似哪，第二个叫application starting event，就是有监听器，还要有坚定我们的监听器的事件。

这已经有个事件叫obliation starting，疑问说完之后，你往下走好吧，这样就是什么叫cut，是不是执行器，执行器，我们现在好像没做任何事情，你可以往这边看一下，有东西吗，等于空。

所以它现在返回来之后，这个值就等于空了，等于空之后没没事，往这看叫get a lication listener，这种你见过吗，有没有见过这个get不ation listen a，有没有见过这样的东西。

没，那老师我没见过呀，没见过吗，你想一下，刚刚在我们那个spring，这不是那个ation这里面的时候，你有没有见过类似这样的东西，记住行，134好吧，这134行你可以往上翻一下，我找一下他写了一个页。

看到这个类似的叫get wrong listener吧，是不是有listeners，刚刚134行，是不是也获取到我们刚刚在类类似于这样的一件间隙的东西，没想死了，哪去了，好在这134号诶，哪去了。

找不到了，看到说这块是不是也这个get什么呢，listener吧，只不过这就换成什么了，换成get application listener吧，是不是在这里面，这个时候问题来了。

他回的时候一定是一个什么是一个listener的一个集合，要不然的话，要不然的话它不会因为我们对应一个循环的那问题来了，这个集合获取完之后，它应该是个啥玩意儿啊，一这是个什么东西。

这块儿我又应该怎么做一个最基本的判断啊，能够判断能够放大吗，这么也非常非常简单啊，非常简单，关键就是说你要看一下当前这样的一个方法里面做什么事，往里面做什么事，可以外边点一下试试，f7 点进去之。

你发现了这是什么东西，叫event。get s是获取到我们的一些s资源，source是谁，往后看是啥，是不是还是application starting event，还是当年的event，这没有关系。

没关系，往下走点击看一下吧，点击看一下吧，是不是告诉你就是piction，这没啥变化啊，来往下走，告诉你说有当前这样一个对象了，对象完了之后叫source，太好啊，它代表是不是还是我们那个类型。

这都没变化，这种东西来了叫listener catch key，catch k等于什么呢，你有一个listener，catch key是不是一个缓存的一个监听器的一个k的一个值，这个值是用来干嘛的呀。

他干嘛的，我们刚刚其实在很多地方已经建成见到我们的listen listener吧，刚刚有一个11个listener，然后呢除了11个之外，我在里面我又放了一些其他东西，比如说第一个叫event。

刚才看到了里面有个事件叫coration starting event，是这是我们就像这样一个一条路线吧，来在application，在three application这个对象里面有11个监听器。

同时我在进行运行的时候，我又创建了一个什么叫你问他publish，然后run lisa对吧，在这里面又建立了一个事件叫spring，那不叫application starting event，这是事件。

那是鉴定器，所以现在我现在一共多少个监听器了，一共有12个11，加上刚外面的一个，一共有12个监听器，同时有一个事件叫spring啊，starting问他把这个名称先给我记住好先给我记住，一定要记住啊。

因为不记的话，你后面跟着跟着可能就更乱了啊，肯定更乱了，懂我意思吧，那干嘛之后我们下面再要做什么事情啊，其实就是下面这段要处理的一个核心代码，什么黑心代码。

这样创建了一个listener catch k集合，扭出来一个集合，这个集合啊不是不是不叫集合，又出来一个对象啊，当然这个对象有了之后，我现在干嘛了，叫this点什么什么东西点get该get了。

你要想get一定要干嘛，是从某一个地方开始取这个东西是啥呀，就是叫做cho catch什么，你有carry的阿信麦好，是一哈希麦好吧，我看了它是一个集合，那意味着它是不是相当于是一个缓存。

我要从我们当前这个集合里面来获取到我们高的数据，但是这个集合里面数据是从什么时候来进行创建的呀，或者说我什么时候往里面放我们具体值的，这怎么看，很好看啊，你点个debug，找我们刚刚这个对象。

this叫retrieve cash，看里面现在东西吗，这什么东西没有吗，因为我们在执行过程中，你从来没有执行到任何一个步骤，给他负这个值嘛，刚开一定空吧，既然是空，我可以挨个往下走，好挨个往下走走。

大家之后能取到这个值吗，肯定所以等于空，等于空之后这样判断了，如果不等于空，我是不是直接给吞回去了，那我等于空，我还能理他吗，不懂了吧，所以下面要做一些判断什么呢，this。

b class loader等于空，然后呢catch thief什么东西，然后呢什么source type，什么什么意思，csf什么东西，是就是一个逻辑判断好，我们这上面等于空。

下面这块做判断的时候一定要能进去吧，是这是一定要等于处的，等于出完之后是一个single net的东西，干嘛的，不知道，但我知道有什么东西啊，这什么什么东西，这是一个什么互斥锁吧，因为互是一个锁。

这个单词应该见过啊，应该见过，为什么这样加锁，我们先不管好，先管他为什么加锁，往下走，走到这儿了，这个叫this the retrieve catch，点get key，我还是那句话，这里面有东西吗。

往下走，这时候你看到了这个reserve，这个值多少啊，翻啊，是不是还有孔子值，那意味着我现在还没取出来，没取出来没关系，再往下挨个走，走了之后，你有一个listener什么东西。

是不是开始就用这样一个集合了，当我用我这样啊，你有这样的对象啊，当我new了这样一个对象之后，没完，你只是说我把当前这个对象给我创建出来了，但是当前对象里面我到底要放啥呀，还不知道啊，你不知道放啥。

没关系，这个参数你看看在哪用了，是下这张用了，像用怎么用的，叫做trip application listener，什么东西，是不是看从里面开始加载我们队的一个数据了，所以你往这边走。

走了之后点fc进去，进去了，往下走，listener等于什么东西好吧，创建一个集合，集合完之后有listener，listener，这不就是snt的，往下看，listener等于什么。

等于new link的哈，希set没有病吗，没问题，这就是新的集合，这个集合完了之后，你往后看叫this。default retriever，这是谁，你妈找一下this default里面有东西吗。

第二application listeners，往你们看这东西熟不熟，啊你看这些东西是啥，123456711345678 90 11，11等于收不收手吧，11是在哪呢。

是我们在刚刚那个lication pp，这里面我是往里面注过11个这样的一个一个监听器，是我刚开创建对象的时候，第一步手下来的，所以此时是不是意味着，我把我这11对象放到我们当前这个类型里面去了。

类似的病死呢，是不是就是把这些病对象也放到里面去了，这没问题吧，是不是这点问题完之后，我开始接着往下进行一个查找，走走走好，走完之后你往下翻，这是不是开始进行便利了，list等于谁。

是相当于是我们的11个监听器对象，然后便利的时候，这又做了一个最基本的判断逻辑，什么逻辑说if叫event，就说我是否支持这样的东西，一个第一个已经取出来了，叫cod foundary。

什么v c a p什么东西是1000题，我不知道嘛的，没关系，往下走，这开始进行一个支持的吧，你可以点到这个sport里面看一下这边干嘛干嘛的，它是不是要进行判断了是吧。

listener一次是of等于它，然后类似等于返回它要返回它，所以此时我们最先或者说最应该要看的是一个什么东西啊，要不要看一下当前这个类里面的一个最基本的继承关系，我能看一下吗，能看吗，好吧。

这基层关系我该怎么看，你告诉我你找谁，我们刚刚我定义好那个类，刚我定义好，是不是这东西是不是这一类啊，对然后呢，这个时候你右击这有一个受，看到这往上继承什么叫order的。

然后有个叫ation run listener，这不是他一个继承关系，能看明白吧，这种传过的一个事件嘛对吧，传过这个事件之后，你再往回返来到这儿，到这儿之后。

每次是要把我们当前这个listener对象给你传出来，是不是传成型之后，我就要做一个最基本判断，所以第一个传唤是啥，叫cloud fd，我们找一下c l o u d这样一个这样一个这个诶。

等一下我看这边有个东西，foundary什么东西，processor对吧，你可以点到我们当前这个类里面，在这儿这块完了之后，你又可以看一下我们当前这个类的一个集成关系关系，有了吗，有了吗。

往上看这个类它继承于谁，首先继承一个order，是个排序的东西，不用管，然后继承谁叫post processor，这不用管，往这儿看，这儿有啥，叫application listener了。

是不是你终于看到一个listener这样一个东西了，它是不是也是继承于它上面定义一个接口嘛，所以此时当我来回跳的时候，我会做一个最基本的判断，也就是说这里面要支持一下点穴这个东西。

看判断一下我刚刚传过这个listener，它是否是归属于这样一个对象了，如果你是的话，怎么样直接把这三个返回，如果你不是的话，我是不是要创建一个新的这样的对象，然后把它给放进去，这是要做一个判断。

判断完了之后把我们当前这个值给返回去吧，所以这块值做了一个最近逻逻逻辑判断，这看出了特别的啊低头啊，这个怎么怎么就决定是否是给定的监视器，然后呢支持给定的事件，比如说我要判断一下那11个监听器里面。

因为我那个什么事件还记得吗，叫啊，starting，然后呢疑问吧，还记得事件不，这个事件还记得吗，来借同学扣一还记得吗，啊对吧，那我现在干嘛，我是不是验证了一下，我现在这个是这这11个监听器。

里面有哪些监听器是符合这样的一个规则的，或者说能监听这样一个事件吧，所以此时就是做这样一个最最基本的判断对吧，你还三三，咱这块儿人家走第一个运行，这是什么，不知往回翻走。

第二个进来之后去判断支持什么也不支持，第二次，第三次不支持，第四次，看这支持呢，这进来个什么东西叫logging application listener，是当前这个listener。

那看一下这个listener，obligation为什么，我们这儿可以看一下，这儿有一个判断叫event instant，application starting，event。

是不会看一下我当前这个事件它到底归属于什么样的一个类型，如果你是这类型，我是支持的，大家看application event，pre eva，vitation，prepare event。

然后还有什么叫contents close event，大家看到了，这里面是有很多事件的一个类型，我来说最判断了，所以刚刚你通过你的验证之后，你能发现那时第一个监视器里面，在我们当前这个步骤的时候。

它不一定都满足我们所有的需要，所以相当我要把我的11个监听器在这儿做一次过滤吧，我过滤掉能监听event starting，不能application starting问的这样事件的过滤器。

这么把它留下来，这句话能听明白吗，这句话能听吗，同学来给老师扣个一，还是去要登录搜索，你现在如果不跟着我搜索，一会儿自己看的时候更懵，比一下思路，刚刚我们开始时有11个监听器。

这十个监听器因为我开启了一个事件啊，因为你要监听你的事件嘛，对不对，那个事件并不是说我所有监控器里面都能满足的，所以此时我要把这些监听器做一次过滤验证了一下。

说说你到底是否符合我对应的一个这个事件事件鉴定嘛，所以就在这做一个判断，如果它不等于空之后，是不是叫pk listener往里面加东西了，是刚才加了，然后往下走，我们就到哪都加进来了吧。

加完之后把奥利加a是不是加进来，这是第一个往下走，这完了之后能进来吗，进不来，首先两个了，不要走三个吧，哈哈大家看到了，我刚刚当我执行完刚刚上面的步骤之后，我一共走了几步。

也就是说只有四个能对我们这个starting疑问的事件做一个监听，其他监听器是不符合规则的，我是不是相当于这个地方我提前做了一次过滤的一个操作，明白了吗，啊啊就是这个步骤你要做的一个事情。

当你做完之后往上翻到哪去了，是，跑哪儿啊，天呐刚才这个判断的是刚才这个地方破循环，循环完了之后，这要判断一下说当前类似的pin是不是不等于不等于空的，这个没执行，直接跳过去了，跳完之后往下走到这步了吧。

这帮我判断一下，你担心这个对象是否是等于空的，然后呢判断一下它的pk变色是否等于空的，所以这样做完之后，你可以看一下我们当前这个对象还啊，那没没有变啊，找一下我们的哪去了，他，是经过我们的验证。

我发现了里面剩几个是不是有，而且仅剩了四个，我们对应的一个监听器，把它测监听器是不是要留下来，11个过滤完之后，但是这11取的时候，我是不是都是从我们的缓存里面取的，因为我说过了你的那些计算器啊。

你不一定什么时候用好，不一定什么时候用，但是呢我要把这些事件的东西给你判断下来，或者留下来，所以这留了四个对应东西，没问题吧，他往这往这儿走走，清空掉，然后把它所有东西加加进来。

把这个or listeners给它返回去，返回去之后一共是不是只有四个，所以当你完成这个步骤之后，你发现了你的listener只有几个，找一下listeners，看他也累啊，有listeners吗。

走了有钱人过来吗，对象listener，不管他了，大家看到了，这里面listener是不是有只有四个在40返回来的，然后完了之后往下走就travel catch等于点put。

想一下这东西是我们刚刚上面创建好的一个空的一个集合，是不是对象往上走哪去了，那怎么没有了，把这东西放进去了，放哪儿了，是不是shower里面去了，不放我们的开支k里面去了吧。

是不是我们开着k把它给我们的直接放进去，放完之后把这个listeners直接给他返回去，所以当你返回完了之后，你想一下这个集合在便利的时候变了几次，是不是只需要遍历四次就可以了，是变成四次。

变成四次之后，关键是下面干嘛的，因为刚刚sq的执行器是等于空的，下面监听器完了之后，我已经可以监听我们的世界了，所以此时我看一下他应该怎么进行执行吧，你不能说我定义好电器之后，定义好时间之后。

我还放着没用，不可能，既然是我一定要发生我们对应的一个作用的，所以此时开始进行一个便利操作，取出其中的四条，然后走第一个等于空，所以第一个不走不走的话走。

第二个叫invoke listener emote，干嘛呢，是不是进行一个执行操作，所以点f7 进去，error handler，不管它是等于空的，然后呢不能一空的话往下走。

叫do invoke listener，往下走，是不是这块在这之后再进去，接着这个listener on application event，知道这一步了，到这步之后，每一个监听器里面它都有方法的。

它都有什么呢，一个对应方法的实现，所以我们可以干嘛呢，再往里边进行一个点击f7 进去，写完之后，第一个哪个类叫logging application，listeners，listeners，接上去之后。

是不是第一个叫什么applications that event吧，是不是支持他差之后往下走，进到延续这点，login system等于login system加get，然后呢。

this log system。before in life，你告诉我这样不是干嘛的，他看不懂，但你猜一下这两句话，他们干嘛干嘛的，你告诉我，完善我们当前的一个日志系统，明白了吗。

你想每次我在操作的时候，我正常情况下启动一个spring boot项目的时候，刚开始先打印我们的班长班，打印完之后，我一定会输出一些正常的日志信息，但整个步骤里面那是不是一定要进行一个日志系统初始化。

而这个系统的一个初始化是不是就在这个步骤里面完成的，由我们当前这个监听器来完成我们对应的操作，就说我刚开始我要打印哪些正常日志信息，把认证信息给我打出来，大家看这个event。

get spring application是获得对象，然后再get soder或者专业类对象，那不用管它，点完之后，这时候有个get方法，点到get方法里面去。

这get这个system promise，就loin system congress，点get name，就是告诉你说我要获取到当前这样的一个类了，好这样的一个参数好吧，往后点我点开看看吧。

f7 这是获取到刚才那个preciation，get source，就是我们的spring，就是我们那个spring vacation啊，你可以看一下啊，get vacation啊。

就就就就这样一个只能看到我这，我找一下是不是spring vacation，有了这个spring vacation之后，是该卡拉搜索获取我们的类加载器，不用管它，那在哪走，走点过去了啊，不好意思啊。

这点过去，然后就说我不管它了，反正你知道这混到一个什么，混到一个日志系统吧，日志系统吧，注意了，这儿有一句话说detect什么的，and return the log system。

we use support love band java logging，啥意思啊啊啥意思啊，是不是他可以支持我们logo back。

同时也支持我们java的一个log的方式来判断这有个这有个操作好吧，所以说这应该支持什么样的一个方式，它默认情况下支持是什么。

是logo back这样的一个方式就是以logo back来记录我们当前的一个日志，感觉跳过去我们看了好，你记住就行了，就是我们初始化我们的日志系统触发完成之后。

这样进行一个叫before in nether吧，是执行这个方法，点击之后拆开获取我们康泰的内容，然后呢就进行支持支持，然后呢设置一些过滤器的参数值，这些东西你别管它了，所以当看到了。

当我初始化一个间隙之后，我是不是要做这样一件事吧，走吧，是不是第一步做完了，做完之后往回返往回返到哪了啊，嗯没有啊，到哪步了，我看一下转回来转回来，刚刚是不是执行完第一个，直完第一个之后。

我刚刚取的什么叫logging，什么东西好吧，该第二个第二个往下走，第二个第二个什么叫back ground，什么东西，是不是又是一个这样这样一个东西，点完之后也是一样的，我们可以看一下我们单元参数。

点进去是不是就到这儿了，他之后点f7 进来之后，你往下走，走到这一步，然后呢电去叫哪点啊，lication疑问他，然后再往里边进行一个点击走，是不是这样吧，这件事情了。

大家看到了同样的方法名称都叫什么on application event，但是它完成的事件是不一样的，这都什么事，看下参数叫spring background，什么什么一个闹啊，什么这什么东西不管它。

然后再判断这样做一个验证了，先判断它是否是这样一个true或者false的一个类型，然后呢，然后问他distance是否等于这样一个值，如果是的话，下面是该做下面的事情了，走走走到这儿吧。

到这完之后往下走，这是不是开启了一个所有的线程，看下我的装潢吧，a start，是，我看不到了，我直接直接自己自己点了，这看没关系啊，我们找一下这个方法走，点完之后，这是不是叫叫run safely。

叫conversion service in internether，vation，nemessage，converter in sulator，jackson，insula chaser。

你告诉我这四个东西干嘛的，懂了吗，三发生什么事儿，对各种的初始化，比如说第一个叫转化服务的一个初始化，验证我的初始化消息转化了一个初始化json格式的一个初始化，以及我们字符集的初始化是不是到。

所以说你所有这些事件其实都是在我们间隙里完成的，只不过说你什么时候去启动你的间隙，什么时候开始进行执行的，是不是就这样一个操作，你是不是已经看到两个监视器，它大概做什么样的事，是不是搞明白了。

已经两个了吧，对不对，第一个叫什么叫logging obligation listener，他告诉你说我默认使用什么的日志系统，它的东西叫什么叫log background，然后呢，这是干嘛的。

是完成一些初始化的一些东西，并进行弱化状况好吧，里面是不是有什么转化器了，验验验证器了，jason啊，似乎极了，是不是各种转换方式在这块儿，你通过这个代码你能看到的好，完成对这些基本功能啊，lg系统对。

到这了，到这了，往下往下走啊，我不看这了，是不是到这了，是不是该循环了，系统可以做很多事情，是的，刚刚我们说过的这四个，所以你只需要判断这四个要干什么事就行了，往下走到第三个了。

叫deviation是什么东西，往下走就到这儿吧，进去往下走走，别进去叫这是什么东西，然后点进去得了吧，说event instance是这个事件吗，不是吧，不是做不了。

到这儿看一下它那个值是不是等于空啊，等于这空调，这不管了，返回去大家发现了刚刚那个监听器，他做什么事了吗，是不是什么事情都没做，什么事情可以做好，没事没关系，往下走，第四个叫lip base。

什么service，是什么东西，往家走到这儿点进去走走点进去，这样吧，走走能跳进去吗，是不是加不进去，那意味着当前类型也不匹配，所以此时你就过去了，大家刚刚我们验证完之后，你发现了，虽然我们只有四个啊。

今天但这四个编辑器里面其实只有两个做事的，其他两个什么时候没做，第一个做事是logo就完成系统，第二个叫by ground，是完成我们的某些转化器了对吧，验证生气了，然后我们字符集的一些测试器了。

他做一些事情，这更完之后是不是搞定了，懂我意思吧啊也就是说你刚刚初始化的时候，很多老师那11个监器干嘛的，我不知道，但是我已经用了其中四个了，并且这四个监视器里面某些东西已经完成了一些初始化功能。

这总体的因为我们当年这个培训所提供的一些服务所提供支持的啊，方老师数字化许多service的一些服务支持系统就这样了，往这儿大家注意了好吧，做完之后往回反走，是不是这地方执行完了，早往回返。

大家看一下刚刚那个步骤做完了吗，做完了是不是做完了，刚刚那个步骤就已经做完了，所以一共就完成这么多事情，这样大家要注意了，好来捋一下这儿做什么事情啊，这做了什么事情，想一下做什么事。

很多人可能已经更懵了，来现在还清楚的同学扣一，不清楚同学扣二，二哈这么多二是吧，那么大块才starting，所以我说这个里面做事，后面还有很多呢，后面写多少呢。

我现在总结一下后面那块大概做了什么样一个事情好，做什么样的事情来往下看，这个建议是一个对象，这是怎么调一下这个语言首选项，嗯，已经有了，这这，啊好了，刚刚啊，再初始化是一个对象啊，是一个对象，好了好了。

来看屏幕，当我们在第一步的时候，我知道出谁的对象好吧，刚刚上面那投稿不说了，都非常简单，然后这一步的时候。

第五个步骤，第一个步骤，你还一样回到我们站这儿，你想要做什么事，我说的东西，get wrong listeners，点进去填写之后，这创建了一个什么叫lication run listener。

其实就是说我创建了这样一个对象。

有的说法创建监听器对象是不是这样，一直好这样值它指向或者说从文件中读取到。

转过来又到谁了，是不是叫一问呢，pc谁知在哪。

这样一个对象好吧，拿过来当前这个对象之后，是不是意味着我已经完成当前对这样一个构造方法了，然后点了一个什么呢，叫return返回去，返回去之后你再回想，这是不是意味着我当时已经混到这样对象了。

然后开始干嘛呢，进行一个启动，当我在启动的时候，这儿我要说一件事，其实刚刚我们忽略了一个步骤，你们也没人提问啊，正常情况下，如果你跟着我走的话，你会有一个疑问，老师我刚刚在那个啊没到那儿了。

没到哪没到哪了，好，没到那个发布pl event的，没到那个地方，当我刚刚在做这件事情的时候，我是从11个里面获取了四个，对不对，你告诉我我这11个是归属于谁的。

归属于我们的spring application的，没问题吧，但是你刚刚在进行实际操作的时候，你什么时候看到他往里面赋值了呀，你点starting，点完之后点这个starting，点三点之后点它点它之。

大家看啊，这是这样的对象，然后从里面进行一个实际操作，搜完之后点进去，点到这儿之后，这是进行一个循环便利的一个过程，而是进行循环面对过程，但此时在这个方法里面，我就开始取对应值了。

你看一下当前这个类是我们的spring application吗，是spring吗，不是啊，是不是，那不是意味着什么，意味着一定在某一个环节里面，我做了这样一件事。

或者说把我们这里面原来对象给他复制过来的，是不是大家过来这个set的，对，确实是这样东西，什么叫set，你想一下什么set的，其实过程非常非常简单啊，非常简单，我这需要大家注意一件事，刚刚有一个步骤。

我们是直接跳过去的，哪个步骤跳过去了，往回返，吕吕吕吕系了好吧，点这点之后，我刚刚是通过什么叫get spring factor instance，我说这一步骤大都见过了啊。

见过之后我们知道了就完成一个实例化操作啊，完了哪个东西实际化操作呀，你点进去，点完之后，这个der是不是获取到我们刚刚那个叫什么，就问他publishing了是吧，但是你别忘了一个操作怎么操作。

这除了获取到我们当前这个名字之外，如果我刚刚读过来的话啊，你会发现从这取的话，只能取出一个参数，取完一个参数之后，我是要把当成一个参数进行实例化，你点这个的时候。

这里面有个什么不叫instance class，而且有个东西叫什么叫get declare constructor是要设置，那意味着是不是要完成整体的一个创建对象操作，但是我们刚刚看的时候。

我带你看这个步骤了吗，没有吧，所以首先你应该看什么东西叫疑问他，然后publishing，然后呢，run listener，public run类型呢是不是类点进来之后你要找什么。

找一下我们当前这个方法的构造方法，找到方法，在这个方法里面第一个叫this。application等于application是吧，lication给到它了，这第一步骤吧，你想想啊，刚怎么做的。

然后反啊说操作是不是这个步骤来操作操作的，是不是进行一个实际化，不好吧，实际画完了之后，我们知道我们刚刚那一类问他哪去了，到了之后我们找一下它当前这个方法的构造方法。

到了之后把ation给到他是第一步骤，之后第二步叫什么，叫对不对，第三步往这儿看，这儿做一件事情很关键，叫this点你手什么东西，然后呢你一个什么东西，这时候发现你用了一个基本操作。

这个你基本操作什么时候干，干一件什么事情啊，是不是给他一个新对象，你刚刚掉的时候是不是都是通过this点什么东西才掉的，刚掉的时候，所以大家想一下里面是不是也是指向的对象，所以这里面我会干嘛。

看一下这个里面它所支持的哪些对应的一个对象，你看到了有东西吗，没有吧，不管它好就掉二个创建对象，然后往里边走走，什么叫listener，application，get listeners，applic。

点get listeners，这个东西你熟不熟，apeaction，谁是不是就是我们的spring vacation 11个，然后从里面是不是获取到我们当前这个listeners把里面加过来。

再把之后一个循环循环的时候，往我们当前这个对象里面是不是加东西了，点它点它，这是一个锁东西，做完之后看这个操作叫this。default retriever，而不是listen。

那第二是不是先remove人，mo完之后，这是不是有个a的，这是所以大家想一下在哪做的，是不是在我们创建当前对象的时候，我已经把我application那里面的11个构造器。

是不是给到了我们的default retriever，这里面选加入雷神里面去，所以刚刚你在查找的时候，从11个里面找的时候，你是不是才能从里面取出四个来，如果你没有这个操作。

你告诉我这11个平时能给到他连上了吗，听到同学扣一太复杂了，不要这样想这件事情嗯，你在看源码的时候，你知道最忌讳的是啥吗，语文也就是可能会在判断的时候，就是我咋说呢，就看这东西的时候，我是怎么看的。

其实我刚开始点的时候，我第一次看到这点点东西的时候，我也没往里面点，没往里面点，当我点到最后的时候，就从11个里面开始获取那四个东西的时候，我懵了，我说他们哪来11个多少这个减震器啊，从哪开始抓进来的。

哪给他赋值的，这时候往后我发现哦，你要进行实例化进行进行实这句话，那我现在是不是要看一下这个实例化里面这个各个方案里面，你做什么事儿，我一看到我妈在做的事情哦。

原来在构造方法里面把application里面的11个11个监视器给他了，然后我从这11个里面是取出了四个出来，明白了，所以你要想这个流程明白吗，你到底想这件事情，如果你不想的话，你就跟着源码。

像我一样跟着源码啪过一遍，一点用都没有，好做这些事情，懂我意思吧，好发现了，这是不是完成了我们刚刚那个复制操作，所以这里面其实很重要啊，其实很重要啊，一定要记住了，来我们来写一下吧。

转起来写一下，这是干嘛呢，咋写没法写了，这叫创建啊，那对象并且好吧，创建，创建出记得吗。

刚刚那一类是创建出这样一个对象。

啊然后呢当我创建完成这个类之后，的11个，你给到是当前对象，好啧啧，方便我们从中，出啥东西，这符合监听事件，一个监听器，理清楚了一定要记住了啊，这样的一个步骤就选出，选出了四个，就那么一点啊。

我再说一件事儿，这块儿可能跟大家那个基本的一个知识是就是说呃还是spring这块吧，大家可能稍微有点有点问题，好像算是有点问题啊，我来给大家说一下，这有什么问题啊，就是我在新画一坨啊，一堆监听器。

随便画了一天监听器，你们应该知道是干嘛的好吧，你想一下这块，如果你不知道吗，你应该想一件事什么事，我们当时在讲那个server lt的时候。

server还记得cc里面是不是可以配一个东西叫过滤器来过滤我们的请求，同时是不是可以配置我们的监听器对吧，之前我在讲three项目的时候，我还专门给你们讲一个什么是一个server，一个监听器啊。

讲那个案例还记得吗，你估计都忘了找一下哪去了，看着文档啊，在这块的时候，我给你们讲的东西叫监听器去了，这我们来统计什么的，统计当前这个网站在线人数还记得吧，是不是监听器统计，listener有了之后。

它可以干嘛，是不是可以监听我们的，而cp 3 service request是有这样的一些对象的一些监控，或者我们这些与对象一个监控这块的的时候，那意味着你要想实现这样的监控功能。

必须要实现里面的方法了，而这些方法是意味着都是某一个具体的监听事件，听到了吗，这里有点写下，这是监听器放上来吧，的监听器，运行的过程中，监听某些事件和各种，到监听器的事件是不一样的，能看懂来这句话。

看懂同学来扣个一啊，这句话能看懂的话，你想一下刚刚我们那个类里面，我是不是就完成了一件事，我是不是完成了11个监听器放到我们的，就完成它的一个实例化操作，但这实际经济一定是满足我们所有的需求吗。

或者说这个事件是满足我所有需求吗，不是吧，他是不是是满足我所有需求的。

所以此时你想一下我这做了一件什么事情，来往回搞啊，刚那句话你先记住了，刚那句话你先记记住了啊，记住完之后反反反不对不，这里面还是还是从从从这开始看啊，第二点它点它之后。

你会发现这里面首先我创建这样一个呃这这这东西吧，这没问题吧，好没问题吧，之后往里面找找一个东西叫扭这个对象，诶，不在这儿，别在这儿啊，别别别别别晃了，加个listener点它，这里面传闻是什么东西啊。

比如说刚刚我在含氧含这个图里面。

所有这些都运行过程中建立某些事件的，好吧，呃在不太舒服啊，小点吧，我靠这个这个输入法真的是，对象创建的时候，让他创建第一个监听器吧，但是这样，监听器，是不同的，换句话说，监听的事件，是不同的啊，刚开始。

气的时候，火车开始启动监听器的时候，要，判断，人类或者当前先是否能监听，如果可以正常启动，如果不可以，抛弃，帮我写这段文字放大点儿啊，文字文字文字描述缩减，在运行过程中都建议每个事件这个问题了好吧。

每个电机事件不一样的，然后最后我刚开始是不是创建十个电击器，但是十个监视器完成任务肯定不一样好吧，但是我们刚刚在进行starting的时候。

也就是说我在刚刚完成启动事情的时候，你发现了这里面我new了一个新的事件叫application starting，疑问他是骗事件，那此时你想要我要第一件，这些中学都要做什么事儿。

我要看一下我那11个监听器里面有几个可以监听当前事件，如果能监听，把你留下来，如果我监听不了，我就把你抛弃抛弃，是不是这意思，所以下面你在做这个方法的时候，调到一个方法的时候慢慢走，我要做一个过滤。

什么过滤网上看叫get a re吧，这边怎么过滤的，点进去，这不是应该做一个判断了，我刚刚给你给你们判那个判断条件了吧，哪去了，找一下啊，没有了，照相retriever cat k没在这。

single net get rever rever，呃找一下我们event吧，看问咋用啊，问他这块就这样会有一个这条件的一个判断，好条件判断，然后从里面要进行一个整体的筛选。

筛选的时候是通过这个地方来进行筛选的，这里面是不是有条件判断呃，这块儿吧是不是都叫sport，这是个sport点那个sport这里面是不是我要判断一下，说我当前这个经济是否是属于我们当前类。

如果属于的话，我可以把你留下来，如果不属于的话，把你移走，这是不是一整体的条件条件判断，是不是这意思啊，好吧，刚这个点同学总结来说。

就是从11个监听器里面把可以监听application that event事件监听监听器拿出来，拿来之后并启动，就这意思啊，就这意思，所以刚刚大家应该已经发现了好吧，我们刚刚创建的时候。

剩下完这其中四个之后，然后我把这四要分别进行一个整体的启动过程，而启动的时候虽然有四个在启动的时候，大家发现了，是不是只有两个有用。

一个是我们的loga log有用好第二个第二个是我们的白白开广告的应用，而其他两个里面什么事情都没有做，是不是就过去了啊，所以大家想一下，就相当于我现在毕竟还是run了一个初始阶段。

初始阶段现在什么事还没做呢，只是说我要把前提之后需要用某些服务提前给你准备，好好准备好，只有准备好这些服务之后，我后面用的时候我才能够顺利调用，就这样过程听懂了吧，一个步骤啊，呃如果没听懂没关系。

下去之后你再好好自己再捋一下啊，自己捋一下，刚刚我们刚看的是不是刚刚看到我们的listen starting，是不是在刚看这地方啊，看懂了吧，好这个条注意哦，一定要注意了，来这块儿现在没问题的。

同学会稍微清晰一点，同学给我扣个六好，扣个一也行，扣一吧，行不行啊，这句话你下去之后一定要自己去点一下debug，自己去跟一下，一定要去跟，一定让你跟，因为你不跟的话，你光听我说，我觉得怎么说呢。

我会的，看你会不会这还两说着啊，这就是很多同学为什么看源码的时候，他他他接不上，你知道吗，我不知道你们看源码有这种感受啊，我前面看了一节，后面看一节，我突然发现两个月合不起来，但是你突刚刚的讲解之后。

你有没有感觉我前期做的一些准备工作都是有用的，并且某个新节点虽然发现突然发现就像什么呢，有一段桥中间有一段缺失，我在往回找的时候，我能把缺失的东西给你找回来，有这种感觉吗，啊这样很重要啊，这很重要。

一定要做这件事情啊，还给你干干什么，还是看源码的方法，这原版方法学的时候啊，一定就是很很很很很关键，因为我现在批判我给你讲明白了，你要看spring ca的源码的时候怎么看，在等老师给你讲，你也会讲。

但是最主要还是什么，你要有这样的一个自学能力，懂我意思吧，啊这一定要注意注意了啊，喊得我嗓子疼了，这练多少年，不用练多少年，你不要把它想的太难，不要把想想想想太难啊，就是那个整理的速。

就你在看原版的时候，你要知道你在干嘛，这很重要这很重要，懂我意思吧，啊我一上来之后，我并没有给你看这样一个图。

为什么没看见，为什么不重要，因为你在刚开始第一次看源码的时候，第一次看源码的时候，你根本没有这样一个感觉，就是我能看到这个图去看吗，不可能，你一定是从刚开这处理方法开始，我一步一步的往下走。

走哪步的时候做什么事情我要知道了，知道完了之后你才能判断出来懂我意思吧，所以我现在你们直接看那个图，原因在这原因在这ok一啊，别懵别懵，慢慢捋呃，我相信你听完我讲这个源码课之后。

你应该会给你一种我我我我所希望的吧，我希望是给你一种启发，什么启发就看源码的一个启发啊，我也没有跟你说来，那么今天就讲自动装配的源码没意义，你刚才找的时候找自动装配原码，你根本找不到啊，我资料一定共享。

你放心，资料肯定共享，这这这这这没问题，但是你重要什么，这才是最重要的，行吧好了废话不多说了，这个点啊就过去了。

同时看原版的勇气一定要去看，你不看真帮得了你，真的我给你灌输东西没有意义，好吧，这就过了啊，我们到哪儿了，是不是到前期这块儿了，来这一块啊，我们总结一下，总结一下这块做什么事儿，到这一步完成之后。

我从11个监视器里面，我取出来四个监视器，完成了我们日志系统的一个功能，并且完成了一些转化器好吧，正气以及我们的呃那个字符集，它的一些基本基本设施服务，知道这就完事儿了啊，这块呢注意了啊。

就到这块儿完事儿了，完事儿完了之后，我们下面来再接着往下看，做什么事，到第二部叫application arguments，application arguments词的是什么东西，是干嘛的。

你一还是很懵啊，不是叫应用程序的一个参数吧，是不是意味着我要开始解决我们的参数了，但一般我们写代码的时候，其实很少去看我们对应参数，但有没有有没有写的，有吧，就比如说不是环境变量啊，环境变量。

就比如说你们之前写代码的时候，我不知道没有这样启动过java，杠杠一个，就比如说hello，像这种，我们这写一个杠杠死人bot程序啊，杠杠service，杠杠server，点port，等于8081。

比如这样写过吧，是不是写过这东西，是不是意味着我在运行的时候，命令行里面带着我们对应参数了，的话那就意味着啊，那就意味着此时这个2x就不能等于空了啊，这时候把ax封装到某一个对象里面去了。

我对象里面去了，点一下看叫assert no，no，是不是就断言对吧，第一个this的source等于new source，这个new source干嘛的，不知道，点进去看一下一个最基本的一个静态类吧。

是不是new source好吧，往里面传递我们这样一个参数，并且把我们的ux给再加进去，加完之后点数类是不是有一个叫simple command line。

arguments pressure depressure，看这代码了吗，好，我刚才不是说了，在命令行启动的时候，你是可以加我们对应参数的，这怎么做判断的。

就告诉你说我要你一个简单的命令行的一个参数解析器对吧，你去看一下吧，做什么事儿有多方吗，看一下有没有多少方法，没有吧，没有什么，他自身本身自带一个无参的，能创建我们班对象，当你创建完当前对象之后。

第二步干嘛了，是不是该pressure，返回是不是这个por 8字传进去吧，点它点它之后怎么传的，叫common的，等于什么，new一个对象用完之后开始遍历我们这样一个数组电脑就说了，叫x点单的位置。

杠杠你传是不是以杠杠的方式来传递的，为什么，这是不是原版里面告诉你了，是不是就是传递的，传完之后没完，你看里面的参数解析啊，叫option text，等于x加substring，是不是开始结串了。

结什么串，从第二个字符开始截，然后后面东西留下来，是不是这样方式对吧，之后取一个名称，取一个值，然后呢用本号做一个分割，内部就是前面的value，就是后面的，对不对，你把这些参数都解析完成了，解完成了。

干嘛是要把它放到我们某一个对象里面去，哪个对象叫common the line arguments，是不是里面你通过这儿，你是不是看到这个具体解决过程了，server点炮的点里面吗，是的。

所有的命令行参数都会在这里面进行解析，他如果不在里面解析的话，你怎么你怎么传递过去啊，懂了这是验证出来了，就好比你们写为什么是杠杠，你就没人有疑问吧，为什么写一个杠不行，为什么要写两个杠。

当然这是指定指定好的，大家想一下，你如果你写的一个普通的java java代码，hello word，就写hello word，你传参数的时候是空格分割，你没有指定刚刚但建议的时候都指定成杠或者杠杠。

k等于v的方式，你想一下你在写my sql的时候，mysql更优，root，然后呢呃123456是不是这样写，它一定有一个解析过程的，而这个解析过程你是能看到的，懂我意思吧，你要设计一个应用程序。

让别人用，你不指定这个参数方式，你怎么做啊，详细在哪儿啊，不带你们看了，不带你们看了好吧，你下载之后自己来看一下，杠d是一个比较特殊的一个参数，指定方式好，杠低是比较特殊的，啊这块大家就是说一下啊。

呃一个application就是simple的应用程序之后，你在运行的时候，你是不是可以选择杠杠service啊，不是server port这样一个方式，他会做一个匹配，把把这个k和y6 拿出来。

拿完之后还没完，拿完之后还没完，为什么我要说一件事，你这几十分之后，这只是得到这样一个对象，这个对象里面放啥，你看那看着放上什么东西换啥map。

而不是2x类似的none of和x是不是有我们这样两个集合，那意味着你解决完之后，其实对象里面也是一个对应的一个集合对象，通过集合对象之后，你把它给拿过来，往回返往回返往回返。

反之是不是得到这样一个类型，是得到这样一类，在这个当前类里面点选，这类里面是不是有很多印象一些这样的一个参数参数值了，有了这样的一个参数值之后，后面是干嘛的啊。

后面是一定要对我们当前这个参数值做一个引用的，什么时候引用，往后面看看下面一行代码干嘛啦，叫application arguments，到这了吧，这哪来刚写设置好的一个参数对吧。

然后干嘛呢叫prepare，environment，又蒙了，完了这干嘛呢，叫prepare，为什么呢，叫准备我们的环境，这个环境指的是啥啊，什么叫啊，这个怎么解释，你想一下，其实你猜能猜到，你知道吗。

为什么说能猜猜到，你想一下所谓的环境应该需要的某一些参数和某些依赖一个支持啊，而本身这里面又传来一个arguments的一个对象，你想一下arguments里面不就指定我们参数格式吗，是不是这意思好吧。

application的外貌对，就是这样的东西，所以此时你要判断了这里面我到底做了什么样的一个事情，怎么办呢，往下走，这这不在里面看了，直接跨过去了啊，点进去，然后到f7 到里面之后，你就懵了。

我的天哪里面这么多东西啊，东西别慌，东西多别慌，你一步往里面看什么东西，create and confect，the environment叫创建或者配置，我们的环境，环境是啥，不知道好。

但这些有什么什么什么操作叫get a create，有关是一个方法，你可以点到当前的方法里面去点进去，点完之后做，等一下我往里边点f7 走进这判断了吧，说this vironment不等于空。

之前做top的时候，你有做过任何跟环境相关东西吗，从来没有，那没有的话，只能肯定等于空了，不能一空，直接返回，等于空的话，往下走到这儿了吧，到了之后你看这个参数值，你熟不熟，叫z。

web application type，熟不熟，我在讲那个创建sprm的一流对象的时候，里面是不是有这样的参数，我说了，是不是三个，第一个，要不然只是弄，要不然只是red reactable。

要不然那只是so late吧，我说这东西很重要啊，后面很多地方都会对它进行一个引用，是不是就关联上前面是不是关联上了，我们那个制度是不是so late，这样的话。

我这做一个case switch case嘛，然后走到这能进来吧，返回一个什么东西，叫返回一个starting serenvironment，告诉你了，我要创建好一个最基本的叫标准环境这种东西吧。

什么叫标准环境啊啊这怎么解释，解释很懵，很多人不是老师，我不知道干嘛的，不知道没关系啊，不知道没关系，然后这个时候我们可以往里边进行一个最基本的查看，好最基本查看怎么看啊，点一下当前对象是不是有对象了。

用的时候你发现了它没有指向我们这的构造方法，没指向构造方法意味着什么，它是我算完了之后，你右击看一下这个目录的一个最基本结构，最下面是我们的标准server的一个环境，上面它的父类是谁。

负类是一个stand environment的一个值，叫标准环境吗，再往下看还有什么呢，有抽象环境好吧，再往看看这关键点来了，看这些值，看这些值，你看这些值，你再往上面看这些值有没有，这干嘛呢。

这些东西看名字啊，这名字起得非常好啊，你看名字这干嘛的，解析你看到这个configuration保留东西了吗，这东西不是随便乱加的好吧，不是说我想加就加了不对，这不严谨好吧，写的时候一定是有具体含义的。

但是有些单词我们不认识没关系，但我通过这我判断出来了哦，原来这是一个配置的一个东西，既然配置的话，他最开始的负累谁，这叫spenvironment，是stment好吧，既然四大版本之后。

那ok我们也可以做这件事，往上翻，是不是有个abstract好吧，在里面，这时候我们可以来做一个最基本的事实啊，最基本查看啊，来返回返怎么看返回来诶，是这点开之后是不是该点它点它，点它之后再点它。

到这一步之后，它是一个抽象的类，对不对，是不是抽象类，抽象类也没关系，抽象类也没关系，在里面你想一下你每次是不是要new了，是不是new了，你在new的时候，或者在进行一个实例化的时候，它会怎么做。

你们找一下当前类里面有我们对应的构造方法吗，有吧，父类里面是不是规划方法叫abstract environment，但它本身是一个抽象类，是不是要那大家想一下，你再点到这方法里面去点，有东西吗。

有东西吗，没有是空的话，意味着我的子类里面必须要对它进行一个实现，对不对，是不是此类实现，所以那时候你点一下子类，我们叫什么来着，哪个叫词，and server lenvironment。

这样的东西是不是他给他给他给他之后，你往这儿看，这儿好东西来了，宝贵的东西来看什么东西了，第一步骤叫property source是啥，点进去是不是就是一个这个参数值好，我还不知道干嘛的。

点一下看看这类吧，可能有有有解释说the default movement of the interface，然后呢，allow什么东西，source吧，是我们的属性的一些资源，是不是写属性资源好。

不管了，先不看他了，不会反到最后还要加加什么东西，第一个叫at last，at last new，一个什么东西，你一个什么东西，这两个是干嘛的呀，不知道什么，你看这些参数点。

它叫三config init parts，第一个参数值先记着，第二个参数值，test一个sconfig，如果你还对thy的有印象的话，这样东西很重要吧，是不是servlet里面那个时候两个最宝贵的对象。

你应该还记得是不是这东西好之后来再往回，反正是不是g n d i的这个电源有没有，如果有的话，也把它给加进去是吧，然后把它调调出super的一个方式，一个一个一个参数的值啊，好质量高。

加我们对应的一个参数值就搞定了，你知道了，我指定了两个最基本的一个参数，这没问题吧好吧，但是你看一下这是不是还有个具体对象了啊，这个具体对象你可以点一下，把name和source给它给复制回去。

这块其实没啥可看的，没啥可看的，你这样稍微注意下就行了，其实啊你可以看一个东西好看些什么东西，你看一下当前这个类的一个具体继承关系，我们来看一下吧，so是不是他呃好像它实现了一个子类收音这么多吗。

之类啊，那不对啊，你想看什么，看它这里面的一个最基本的寄生关系，好这些关系不继承关系啊，看不了不看了，他继承了，看这像一个resource，一个值，它是一个什么抽象类吧。

超类里面意味着它里面必然有很多子接口，再看一下它的digm，算了不看了，找不到找到算找到不带你看了，就在里面要求我们各种各样的一些呃系统的一个值啊，系统一个值，这边你是能够进行一个最近查的。

就是说来解析我们对应的一个配置文件，好解决我们对应配置文件好了，这刚刚下一步往回返返返返返回来，虽然刚刚只是new了最基本的一个环境，但其实在new这个最基本环境的时候。

我是不是意味着我可以读取一些系统的一些参数了啊，那个参数是什么来着，in a server context，initial parrain。

a server config initial parable，把两个值你先给我记住啊，先给我记住，ok当你你记完他之后，记完他之后，我会现在往回返啊，走啊走，是不是到第一步了。

这是不是意味着我当前环境是不是已经有了，好吧，有环境之后，我们看一下当前的环境里面的东西，看到没，default 03，刚好看到什么写，第一个叫sconfig，so context insupms。

除了这俩，刚才我就找这个，还有一个system properties，还有一个叫system environment，就这些参数值你应该是都能找到了哦，刚才我没点出来，好没点出来。

但你要知道这里面是有对应对应东西的，有对的东西之后，你我可以读取这里面的某些配置参数了啊，这第一步你要记住了啊，先把它给我记住，设计完之后来我们现在再往下挖，挨个看该干嘛了。

第二步叫config environment是干嘛的，来刚刚第一步创建环境，批判同学来找我扣波一，读取我们sd里面的一些配置参数，以及我们的系统里面一些配置参数了啊，这第一步第二步，第一步判断来判之后。

第二步是不它配置我们的环境了，什么配置点进去点，这里面又做了很多事儿，做事做什么事儿，完了看第一个叫我爱的conversion service，这个东西什么时候见过见过吗，有没有什么时候见过。

我刚刚在看一个东西的时候，诶，哪去了，看一下啊，看一下什么东西叫b，在里面点这里面的一个方法的时候，看这块是不是同学叫commercial service，commercial service。

看到了吗，还记得刚刚是不是大家看过这东西了啊，你要借他，你要借他，你看我你别忘了好吧，看到你别忘了留他之后看一下当前这个值到底是否是true还是false，这不是告诉你这个值当前值是true好吧。

既然true的话，我点一下，点一下这个数值走，点完之后到底走进去，进去之后说converter service等于application converter service。

点get share instance，往下走一set是把我们这个服务给设置到当前这个环境里面去，是不是这个设置操作，这个操作非常非常简单了，就完成一个最基本的设置操作，这块你也想点击一下。

你看一下该si d把里面的东西给获取出来啊，这也带上，没啥可看的，没啥可看的，他说了return啊，什么叫shared，然后呢。

default application instance是返回一做共享的the polication的一个实例，是不是这意思说lazy building it one need。

它被使用的时候是蓝加奶的高价东西，也就是说所有的我们当前应用应用程序里面，它设参数的用的都是同一个vation啊，这块被蒙了，懂我意思吧，面试还没问呢，直接被现实淘汰了，你把这些东西记住你。

你你好歹留个印象，对不对，你好歹留个印象，留印象之后你就可以聊很多事了，懂我意思吧，当然了，还是要熟悉还是要熟悉啊，来再来看他做完之后是不是获取到我们当前这个对象，往回看，不要看他做完之后。

刚刚那个service给它设置到我们的环境里面去，给他们去试试吧，走是不是叫property，点set conversation service吧，这时候你来看一下this，啊这里面有什么东西。

你点一下看看啊，是不是只有四个参数，刚刚我们读到的一个叫sweet，然后呢config呃，usual parts，scan，contest，usual pm system。

然后呢system environment是这个参数值，当你执行完刚刚这个代码之后，大家看到了是刚才你说property resource。set。

是不是又加了一个叫conversion service这样一个服务，大家给我们建议去了吧，往那看对象里面是有值的，对象里面就是加上这样一个参数值，你可以看一下，我们可以看一下。

点开这个converters来看看操作了吗，什么东西扎完了number转什么东西，然后呢叫string number，string number，什么一堆东西是有一堆这个集合，这边都是啥。

是不是都是我们对应全部的一个转化器，这样的速度是不是conquer，还有这是哪来的，就刚刚上面这个步骤里面，我把它给加进来了，就不能服务嘛，服务完了之后把它给这下再加起来价值。

让我把它设置给我们的环境变量，就这意思好吧，就是完成了，就刚刚你指创建好我们对应一个实例初始化了，但是你的应用程序想要执行的话，它是需要一个环境依赖的，而我们这个环境依赖。

环境依赖就在于在这儿给大家是吃进去了，但这波我大给他说一下呃，我在用的版本，但是2。2。2是比较新的版本，如果在老版本的时候，他不是在那完成的，老板也是没有，这句话不是在完成的。

所以每个版本的这个源码变还是有一些变化的，所以你要看一下具体的东西，懂我意思了吧，嗯好了对，往下看再往下看啊，第三步干嘛呢，叫config property source，这不是干嘛的。

很明显是我们的properties一些资源，对不对啊，那这块我应该怎么进行一个最基本查看，environment。get property resource，这样在进行get的时候。

你想一下我怎么get的，是不是从vironment那边拿东西，我这里面有东西吗，有吧是不是已经有四个对应的默认配置文件了，有外面的是不是有四个，刚是不是已经说过了，好，先把它给拿过来。

拿完之后这样做一个基本的判断，拿走是吧，default default，谁点进去有值吗，没准是空，它不等于空，就发现操作是不是等于空等于空，不管它往下走到第二这点。

at command line properties and x点，认识大于零是干嘛的，想一下是不是行，对应的一个参数，你是如何玩家的加载的，此时我们有参数吗，没参数吧，那没参数的话，我怎么办啊。

是不是跳我就想回去了，所以此时想下这干嘛的，是不是就用来设置我们具体的一个参数就搞定了啊，这具体的一个步骤啊，把它再加进去就行了，返回这个步骤，完了把这步骤完了，这步骤这步骤能听。

是不是就配置我们的property那个property source对吧，什么叫confile profile，是不是该我们的有这样的一个文件了，那一样的，你也可以把它给点进去。

点进之后边有个set profile，等于你一个hit slink的hit s今天可能发现了临时表示什么呢，我要创建当前的一个集合类的，把它当成一个集合类，当我创建完当前这个集合类之后，哇。

我还干嘛啊啊还干嘛，这怎么做，是不是有值吗，是就是空的集合空集合吧，你不用管它往下走，走到这步，profiles。at all，然后呢叫environment。get active profit。

这个属性收不收什么，这个属于熟吗，熟吧，是不是叫spring profile，点active是不是有dv环境，这个环境是不是读取配置文件，大家看一下是不是就转一个这样点进去。

是不是t我判断一下这个属性值，点进去是这个属性值吗，是不是，这是不是可以做一个最基本判断，判断一下你用的是哪个环境里面的一个配置参数吧，是把它转过来了对吧。

整完之后来再进来看还有什么东西叫外面的set it profile，你刚刚已经属性值给你加进来了，加完之后你是要设置成这样一个属性值，把这prof然后进行一个转换。

转换完之后把它设到我们当前这个环境里面去，环境里面去，最后一个就ok了啊，一个就ok了，往上走一下，这这不看有头判断走，这说完上完之后返回返回大家看一下。

刚刚第一个配置一个property source，第二个看到一个配置profile吧，所以这就是我们这个配置这个步骤要做的一个事情，要做一个事情，明白了吗，好到这儿为止来还能听懂，同学给我扣波一。

注意一件事，现在这个地方只是为了读取我们的property source和我们对应的一个呃，profile文件，你你们刚刚提那个亚马尔和泡泡里的文件，我们现在看到了吗，看到了吗，还没呢，还没呢。

就说他什么时候加载我们的app，什么加载我们的profile文件，还没开始呢，还没到那个步骤呢，啊，你要接着大家看才能看到具体的一个相关信息和具体相关信息，还往下看吗，听见了吗，对下面才几个文件还看吗。

别呀你你干嘛呢，休息休息，这样什么来，我现在带你们快速的溜一遍，快速溜一遍，录完之后，我们下节课上完之后，我们再接着讲，我们再接着讲好，重新再过一遍，我现在在想什么，你们先看一下，就是你们想看什么呢。

那个fm application that properties，那个文件到底是在什么时候进行加载的，你要看到那东西，你心里就舒服了，懂我意思吧，来来看啊，到哪一步，这个东西。

convation properties，resource，点attach，是不是加attach了，t干嘛的，贴上去的意思好吧，这样点进去，这里面就做了一些except。

是不是configuration，这里面就加另外的一个参数值，叫convation properties，好，你要不用管它，这步骤不重要，拿走点完之后你可以看我们的environment。

看到刚刚你看到的时候，这是不是还是四个，现在变成五个了，多了什么东西就多了一个configuration properties好，加上一个自己的一个配置文件，加这东西加完之后。

这这个步骤不重要不重要好吧，大家看这个步骤，这步骤就好玩了，是不是又看到什么东西了，又看到四分二四了吧，好鉴定器又是我们所熟悉的东西，非常喜欢这玩意儿，对不对，喜欢的话慢i一样往里边点，它点进去走走。

点下去之后说spring application wrong，listener，listener等于什么叫this。listener，你告诉我这个this。listener是谁，哎给点回应好不好试一下。

是不是叫event publishrun listener，是不是还是他错了，整个这整个过程里面的还是它，那它就往里边走，取出来它吧，是不是把它取出来，然后点进去走到那之后，你看到这个方法了吗。

是不是z点什么东西，点什么东西，此时你这个监听事件换了没，刚刚叫什么，刚刚叫application，然后呢，starting event，现在呢叫application environment。

prepared event，看到吗，事件是不是换了，那你告诉我事件换了之后，我下一步骤该干嘛了，一下有哪些对应的一个监听器吧，是不是南京天气啊，这个监听器才是非常非常关非常非常重要。

非常非常关关键一件事啊，来点看吧，点一下走到这了吧，这样一个对象，然后往下走走，不管他走到那之后，是不是就该执行这个方法了，点进去到这步点进去，然后呢，这是不是这个方法过去，点进去就到这儿了吧。

到这儿之后往下走，往下走，得到这步了吗，是不是开始说干还要pk，是listener，是不是又开始在里面找了，找到了点进去往下走走走，说跟刚刚那个重复的过程是一模一样的，是不是一模一样啊，走走走走。

这块到这了，到这之后来再点进去，是不是又到这块儿进行一个便利了，里面都是初始11个值啊，开始值是不是11个，从11个里面又要开始取值了吧，来我们暑假起多少个进去一个吧，叫什么of slication。

问第一个进去了，记住了吧，第三个，第四个，第五个，第六个，七个，七个吧，进不来，新改完了之后，是不是把它给加进去，再返回回来，所以此时这里面一共有几这个东西是不是拥有七个集合，有七个集合的话。

大家想一下，我是不是又该从这七个里面进行挨个的一个便利，看一下这些便利的时候在干什么事儿，是在干什么事儿对吧，来看一下干什么事儿好吧，挨个取走，第一个叫config fail。

然后呢application listener，你一看这东西你应该很熟，或者说很欣慰，为什么结尾，这个单词吧，哪个单词叫config fi，配置文件，对不对，这明确是不是已经告诉你了。

我这就是一个配置文件，既然是配置文件的话，那ok我们该往这边走了吧，点进去走到这儿了吧，emoke点进去往下走走，点进去是不是就类似now complication event。

又开始往里边进行一个点击了吧，点进去呃，点进去看这叫application，然后呢，environment prepared，让他往里面走，点进去到这了吧，listener poa叫post。

post processor，等于load processor了，是不是该到这里面去了，对不对，这之后怎么办，一样的，我可以是不是看一下这个当前这个方法，来看一下这个方法。

连续叫spring factloader，叫log factory，叫environment popost processor，看他了吧，干嘛呢，不知道不知道，来找我们参数叫event哪去了。

啥名来着，event pol，pol，pol or。

找一下，一二是不是有对应的四个对应的一个对象，是不是把这四个对象给取出来，结果就搞定了，好吧，那这样不看了啊，往这边过往回返这at的是不是把它给加进来，是不是有四个，四个完之后往下走。

是不是该循环我们这四个循环之后往这边走点进去，然后这次不管它不啊，再点也不是，这方法点叫source name，等于stard event，第二种东西给他，大家知道这是疑问，它e r v吧。

是我们刚刚设置好一个参数，测试完了之后，event叫get post，get，是从里面把那些参数值都给取出来，修改之后这进行一个整体的替换替换，听完之后啊，返回返回返回，这是不是有情怀，一共有四个嘛。

挨个进行一个循环好吧，你把它循环完之后，你就能看到对应的值啊，这块我们往里面看了，我这说一下大家关心的东西，关心什么，老师我想看到我们的ym这个文件我应该从哪开始进行查看。

查看的时候也非常非常简单非常简单，你只需要找具体的一个属性值就行了啊，哪个属性值啊啊内存值，看一个对应的一个呃一个类图，一个类图，刚看是哪个，第一个就environment processor。

那哪去了，我去找一下是不是他是不是就有这样一对吧，点这类之后来点进去，点完之后我们可以看一下当前这个类的一个类图，它上面是谁，叫functional in the face吧。

呃不是不是想这类图怎么今天都找不到了，找不到今天这类图，再看一下，在这个processor里面，我来找一个东西，加州这儿有一个，这属性值叫system envpa，property，source。

environment，post processor，这类啊，非常非常长长啊，非常长长，没关系，往常没关系，然后呢往里边进行一个点击查看这儿有值不值这个值啊，不是这只啊，呃想找东西没在这儿，没在这。

刚刚那个是不是找另外一个东西，找他找这东西找东西啊，叫哪类人的，看一下，fail啊，config file应该读这个类啊，config file confile，fail之后，我可以点到这个当前类里边。

得到这类之后，我们可以往里边看当前这个方法i的这个什么东西，random value property source，这个random value property source熟不熟熟，你想一下。

你想一下，你在进行处理的时候，你的java文件里面我找一下我们的压码，这里面你之前他写的时候，你是不是可写很多东西，写什么给他写一个啊，冒号这写个东西写什么呢，哎错了，8号那第二嗯嗯怎么没有啊，啊。

我记错了没有吧，大家想一下，我们刚才写的时候，这里面是不是可以生成一个随机数的一个直按技能吗，是不是写成一个随机数就random是什么东西，你是不可以直接取了，你取出来啊，等一下我再试一下，可以起来的。

我应该不我应该不会记错啊，叫aaa冒号，后面写一个dol，是run，那么点浪，这么点valley，那点int，为什么这可以用这边的对象是原因在哪，就在刚刚我们看到这个属性值。

它是通过这个属性往里边加我们对应的一个方法的，看那int long，然后int long u u i d，通过这些前缀匹配，我能够去识别识别我们对这个random这个函数了。

懂我意思吧啊这是我要说的东西啊，就这样加一个让他们累，这是第一个，这样加完之后没完又new了个什么东西，new了一个东西叫loader ler，是什么意思，太累了，好没关系，点它点logo，点了之后。

你往下看，又看到一些非常熟悉的东西。

打开environment，envionment，不用管它好吧，property sp hold solar，不用管它，往下看，找一个东西叫漏的factory，熟不熟。

loader在load theories什么，好像有几分熟悉，对不对，如果他比较熟的话，你想一下又有东西叫properties source lower，又看他了吧，之后找我们这个文件里面找一下。

往上翻，这个东西叫property source logo，看见了吗，你看完这个类之后，你应该知道它读取过的这两个文件，一个叫properties，propertisource，一个叫压门。

然后properties sler是他俩，这这这两类你看完两类之后。

是不是又可以进行一个加载了，点一下啊，点点点里面去啊，再开始取我们的ftp选的tag之后，往里边开始找，是不是叫loading fname，从里面取一个值吧，选完之后再返回是一个例子值。

这个例子只取的时候一定是取两个对应的文件。

那两个文件第一个叫properties，把拿过来没走。

是不是真的假，看到是不是叫点properties，是不是cha，这里面是不是对应参数啊，是不是看到这个点后缀的名字了，好这第一个第二个还有啥，把那个名字再站出来啊，看呗走，后缀名是谁。

是不是y m2 和y a m2 ，是不是看这个东西了，是不是，这是因为这样，所以你才能把配置文件给读过，来人说老师那个application在什么地方，是另外一个名称，他这只是补的后缀，把只补到后缀。

懂我意思吧啊所以这块就找到文件吧，就是说你把这个文件给读进来之后，我才能够解析我们对应的一个配置参数，如果读到这个文件参数解题不到了，懂我意思吧，好这大家注意了，ok好了，目前为止来还能听到同学扣个一。

都听懵了吧，呵呵，这块我下节课我会接着讲，下节课我会接着讲的，不用担心啊，不用担心他们问老师，ba是什么时候加载的banner，它加载过程再往回找找一下，什么东西啊啊班长这个特特特别特殊的东西往外倒。

找到了找到我们这儿搜一下吧，走，这个还没在这，这是我们班的读取的地方，而在你的环境准备好之后，你的配置参数读取好之后，你这样才会执行，这样才会执行，我直接可以做一个验证好吧，我给大家验证一下，我找一下。

我把这单线圈直接打，直接直接打过来了，到这里不找，啊这都意味着我喊你准备好了，然后呢你往下走看故事台，现在控制台还是空的，对不对，当你执行完下载步骤之后走，看到了吗。

这才会打印我们这个spring这个banner这个文件啊，这步骤才能完成我们具体的一个操作的地方，这东西啊我们下节课再说，现在说这个不说了啊，这些不说了啊，来这个。

读出来的环境配置信息还和配置文件内容结合用吗，是的，因为注意啊，读出来那些文件，你想要读出来的都是啥，他这里面大家大家注意啊，你读的话啥，然后contest，然后加一个confi。

这样呢就所谓的configure pintro pm，还有什么东西叫system，然后呢呃还有一个什么叫sm e n v，那些属性跟我们配置文件并不冲突啊，并不冲突，这没有什么冲突的地方，懂我意思吧。

有种东西叫configuration properties，拥有五个，拥有五个，你说那五个正在一个配置文件，没没没没还没还没关联少，等你把环境准备好之后，你开始读取数据了之后，才会把里面的参数给读过来。

现在还没开始读呢，还没开始读呢，懂我意思吧，现在没开始读呢，我们讲了这样复杂的一个过程，相信恒坤已经听懵了是吧，呃课啊，我觉得就是不管谁讲都会蒙，什么时候讲，refresh，refresh预言真好。

refresh不太讲，refresh算是我们的spring boot里面的东西，它更多的应该换算谁算是我们spring里面的东西，spring的东西，因为你往里面看reflash点进去，点完之后点进去。

这是谁，obligation context里面的reflash啊，这spring里面他做了n多个步骤，我要把这些步骤给你说完了，我的天呐，我就又得用了好几个小时，又得好几个小时。

等一下这这东西谁说我不太懂的话，里面可以好好回去看一下，好好看一下，懂我意思吧好吧，这里面参数相差五件，java杠炸叉叉叉叉叉叉叉叉是啥东西，你再说了，你说配置参数吗，有个command line。

command line对象可以读取的参数吗，是这意思吗，那里面有东西啊，来来来，你你账号到站的时候也是找到我们的面函数，找到我们面函数之后，也是按照我的顺序一行一行往里面走。

只不过它会解析后面的一个杠杠杠叉，杠杠o杠杠o的这个欧叉叉的东西，当你解决完之后，它有个命令行的东西可以直接解析，看都都都梦了，回头我把代码点一点好吧，自己去点一点，自己去捋一捋，你就知道了，没意思吧。

来我们总结一下，今天今天晚上这节约八课，我讲点啥，这个注解的作用呢，我现在会不聊，为什么，我给大家说一件事儿，你聊到注解的时候，你可以点它，是不是点它加了之后，其实这里面你最主要要看是什么。

第一个东西叫spring bo configuration，第二叫enable auto configuration，第三个叫confion。

这里面最重要是谁是enable auto configuration，这是在自动装配里面讲的，我们还没到自动装配内部还没到这个步骤，现在只是完成了一个初始化的一个基本功能，还没到那步骤，所以别慌。

纯真年代别慌，后面的时候我会单独把这个做装备再给大家重新讲一下啊，我我写好了，就这个一定会讲。

他，我笔记笔记笔记都写了啊，应该怎么做，比如说怎么怎么找过来了，我都说书都写好了，好后面一定会讲的。

别慌，还没到那一步，你先把整体这个启动换的过程，先把启动过程先搞明白了，这才是比较重要的，先把它搞明白再说别的好吧，来想一下今天晚上我们讲点啥，其实其实讲的东西不是特别难好。

不是特别难好吧，讲中下来我们写一下第一步，我告诉你先要调一个装方法，对不对，然后在里面我们会创建一个sprplication的一个对象，对吧，spring spring。

我不在这儿写了。

这会儿吧想想刚刚我们调一个b函数，调并函数之后，这个落后啊，然后创建一个对象叫对象之后，我们会有一个状方向的一个启动，在启动的时候我们设置启动时间，记录启动时间，然后设置应用上下模式空的。

然后设置一下报告计也是一个集合空的，先给大家做，我们设置这样一个headlist的一个参数没啥用好吧，然后呢读取我们对应的一个是创建好我们对应一个监听对象了对吧，在电梯对象这个地方好吧。

但这样的话一共有11个，我会挨个进行一个整体的过滤过程好吧，过滤完之后，我们要获取到一些对应的一个参数值，是这些步骤，这样做完之后，你想一下还做啥了，等下我们找一下东西啊。

方法对不对，是不是比较简单好吧，这步骤是干嘛的，完成一些初始化功能上，做完之后该干嘛了，该设置我们的命令行参数，然后准备我们的环境，就是给大家写一下，我这儿画到这边吧，第六个叫装配，嗯，ok传送完之后。

第七步，我的新应用程序，环境，我们做了很多的一些事情，这环境这块我下一节课来了之后，我会重新说了，所以你们要做的事情非常简单，把从这儿开始，然后按照不知道第六个步骤之前东西你要看懂。

好在之后你就挨个点一下试试，看一下能不能把这块东西给点明白，懂了吗，好，你回去之后好好点一下，自己点点试，你看一下这些参数到底干嘛的，你多看几遍，你就知道什么意思了，懂了吗，好了。

这就是咱们那个第一节的一个源码课，呃，源码课确实是比较麻烦，确实比较累的，这东西谁都有共识，像你们自己看的时候可能更懵更懵，但是啊我觉得怎么说呢，呃这东西我再给你们讲这些事情，下去之后一定要自己去点好。

一定要自己去看，呃你把其实这个东西啊，就是我怎么说呢，我刚刚给你带你们看那个步骤，就是我当时第一次看的时候，我的步骤，我的过程一点瑕疵都没有，我刚看就是你发现了中间漏很多东西，我都回过头来再接着找我。

带你们也是一样的，回过头来接着找，你不可能一口来看，看全了，一会就看全了，其实编码这一块其实没有什么小白不小白啊，你找个讲的一个东西的原码给看完了啊，你就有自己的思路了，你就知道哦，原来是这么回事哦。

原来是这么回事，懂意思吗，记住什么情况，今天看了两眼，看了几页之后，感觉卧槽看上去就疯了，没什么成就感，不看了啊，看见不看了，你永远坚持不下去，你就咬着牙啊，咬着牙把一个东西看完啊。

你看完你再看源码的时候，看其他方向码的时候，你就不慌了，你就不慌了，如果你不看你，你没办法，好吧对，就是你想一下啊，你现在我现在带着你讲，你都听得很懵，如果让你自己去看的话，你会怎么样懂我意思吧。

呃源码啃只能啃，然后就是什么呃，自己自己在画的时候，自己在点源码的时候可以就看一下迪吧里面的内容好吧，同时呢做一下相应的一些小笔记，比如说你之前掉哪一类，不用很认真的话，拿篇废纸写上去就行了，好不会乱。

保证你的顺序不会乱，这就够了，就那个热量会掉的时候，你可能看的很懵懂，我意思吧，怎么说呢，就跟你在上班一样，你你接受别人的一个项目，你问他有什么捷径，有捷径吗，没有的，你只能硬看啊，直接真难带啊。

没有啊，就是呃之前没跟大家讲过源码课啊，你想一下之前黄师傅讲过源码课，然后周老师讲过源码课，我还没讲，源码课是第一次给大家讲呃，就是你反应不过来，或者说你你理解不了，我觉得这是很正常的事情。

所以你发现刚跟你讲的就很多东西我会重复很多遍，呃，不要怕不怕有疑问，也不怕大家不会，你慢慢听，等你把这个东西坚持下来之后，你就会感觉哦原来这么回事，懂我意思吧哈你下去之后补一个东西，补一个什么东西。

就是spring里面的事件发布机制，你把这个东西下了，你现在在看的时候就会很容易很多，就会容易很多，我尽量真的是呃，因为我能达到一个最最最最牛的一个一个方式来给你们讲的东西。

或者最简单的一种方式给你们讲了啊，所以如果还听不懂，你就多听两遍，多跟着多看看好吧，如果是咱们私下里跟人交再交流行吗，就不多说了，不说了啊，呃今天咱们就聊这么多，然后周周日的时候咱们再接着聊，呃。

准备不准啊，我这边呃该写的笔记，该写的东西我都给你准备好了，一会我们共享出来，刚刚写东西比较全，你下去之后把这块东西好好自己再捋一下，自己再看看啊，有些注释啊，可能写的呃不太不太不太不太详细。

但是我觉得你自己可以进行补充好吧，周六看懂吗，不上周日，咱们周日两节，周日两节，周日下午和周日晚上，因为周日周二的时候还没上课嘛，啊咱们周末的时候这个黑板补起来，给他补补上来行吗，同学们。

晚上回去好好捋一下啊，对这么两周末两节，啊这话不是没上课吗，所以要给他补吧，不补的话，这这笔记放在上面，你们一会儿直接从根往上，你是来劝退的，我这还叫劝退啊，我的天啊，行下次休息了，妹妹，我忘不了。

好吧。

系列 3：P64：【Spring】Springboot启动源码解析二 - 马士兵_马小雨 - BV1zh411H79h

世界有很多爱你的人呐，放手吧，别想她是否值得你这样牵挂就放手吧，别想她过就好，何必要苦苦挣扎，放手吧，别想她把所有一切都当作是一个笑话，你害怕的吗，是不是海里的头发，无聊的午后，特别爱讲爱情的童话。

你害怕大雨，我还记得在分手那天风很大，等再想不起那些后悔的话，若不是你的人常去我生活，我怎会把死守的寂寞放任了，爱我的话，你都说爱我的事你不做，我却。

可惜我们终于来到一个句号，窗外不愿飞的蜂鸟也在哀悼，城市再也不会停靠，我们争吵，你会不会少了一点烦恼，回到12年前，回忆就在眼前，你戴着帽子，而我样子带着腼腆，不过第一次的见面。

你说你有先见我的先天被训难过，我能有偏见，我当时天真寡见，鲜闻不像成年人有能力，别人不是为了赚了有钱分，我为我的前程，希望我写的歌里面有更好的和弦声，谢谢你，你的恋爱情，霜雪心里话，be a怀念。

第一次发唱片就一马当先，从此在大场面，我不在家旁边，我是真的感谢佩服你的眼界，想到和你是带着刺痛的完结，你看着一朵花慢慢萌芽，我想看着你气慢慢风发，欲望，价值慢慢分岔到的失望，让我对你的信任慢慢崩塌。

可惜我们终于来到一个句号，窗外不愿飞的蜂鸟也在哀悼城市，再也不会听到我们讲讲你会不会少一点烦恼，小声滴滴答，你还记，说句心里话，你还怀念吗，你说我是个商品，没有你们就不可以。

这些扭曲的真理差点毁掉我的自信，如今的我已觉醒，如今我不再哭泣，再不怕坚持自己做你没做对的决定，你知道吗，再唱一辈子，除了我的爸爸，你曾是我最信任的男人吧，但空白的娃娃总会慢慢长大。

抱歉我没法永远当你听话的傻瓜，不是吧，终于来到一个知道，we are the right now，就是爱不会停留在快乐的挣扎，我们终于来到一个区，多少年里多少遍，你没去过多少座城，没多少解密。

但过去了就不再介意，反正感到快乐，幸福里把痛的伤的全都忘记，下次我往前转的全部回忆，这可爱的很难，全都是你，我想希望你偶尔也会想起，就让我真心真意把这场梦囚禁在这里啊，你还记，说句心里话，你还会变得。

似奔走之友，爱你，每个结痂伤口酿成的陈年烈酒入喉尚算可口，要你是看心中缺口，裂缝中留存温柔，爱的人正在路上，我知他风雨兼程，途经日暮不赏，穿越人海，只为与你相拥从容才可以皓月当空，爱的人手捧星光。

我知他乘风破浪去了黑暗一趟，感同身受，给你救赎了我，知道你不能还要你感受，让星光加了一点彩虹，让樱花偷偷吻你额头，让世间美好与你环环相扣，爱的人正在路上，我知他风雨兼程，途经日暮不赏，穿越人海。

只为与你相拥，我此刻已皓月当空，爱的人手捧星光，我知他乘风破浪去了黑暗一趟，感同身受，给你救赎热望，爱的人正在路上，我知他风雨兼程，途经日暮，不赏穿越人海，只为与你相拥，我此刻已皓月当空。

爱的人手捧星光，我知他乘风破浪去了黑暗一趟，感同身受，给你救赎热望，知道你不能还要你感受，让星光加了一点彩虹，当樱花开的纷纷扬扬，当世间美好与你环环相。

沿着路灯一个人走回家。

和老朋友打电话。

你那里天气好吗，有什么新闻可以当作笑话，回忆与我都不爱说话，偶尔我会想起的，心里有一些牵挂，有些爱却不得不各安天涯，在夜深人静的时候，想起她送的那些话，还说过一些撕心裂肺的情话，赌一把幸福的筹码。

在人来人往的街头想起他，他现在好吗，可我没有能给你想要的回答，可是你一定要幸福啊，好同学们能听到声音吗，能听到话来扣个一，我准备上课了，呃今天讲什么，讲swibot源码，发下spot源码。

大家想听源码课吗，哈哈哈哈哈，这个野马克啊听起来确实是比较无聊的，是不太行呃，研网课天天确实比较无聊，然后上次我讲课的时候，很多同学可能已经听懵了啊，可能已经听懵了呃。

然后呢就是不知道你下课之后自己有没有啊，虽然痛，但是爽呃这个过程啊，你必须要经历，当你完完整整的把一个项目的源码，如果呃听完了，听完了之后，然后的话你再看新的源码的时候，你会有一种非常舒服的感觉。

最主要是找那种感觉，反正源码啊之后怎么着都是要听的啊，或者怎么着都是要自己看的，你不看的话，面试问到怎么办，很麻烦好吧，呃前两天的课约马课没听，今天能听懂吗，呃估计有点够呛啊，估计有点够呛啊。

但你可以先过一遍，先听一听，先听一听呃，什么时候讲网约车，等咱们所谓boot源码讲完之后呃，来讲这网页车项目，好像网易车项目呃，不用担心微服务熔断，没听完困难不，这块没关系啊。

这个跟b服务这种断那块没有关系，我们就看一下它里面的一些实现机制，其实像swim源码在问的时候可能自动装配，问的比较多，所以我现在在考虑说这个源码大概讲到哪哪一个层次呃，这还没想好。

但最起码我们这个启动过程是要讲完的，讲完启动过程之后，第二个就是讲一下我们对应自动装配的一个原理啊，第三个我准备讲一下我们那个starter它那个整体的启动过程。

因为我们知道每次你在搭建spring sgo项目的时候，有些外不了这些东西所在的讲一下呃，其他的一些系列，比如说spark bot的一些环境方面的东西对吧，呃再比如说像后面的一些自定义的东西。

我们这儿就不讲了，或者第一期暂时先不讲了，我怕讲完之后很多同学就懵了，所以我们这儿呢先讲讲一些简单的或者说面试中经常被问到的，好吧，别的废话，我们这就不多说了，周末的时候人比较少啊。

什么时候讲完四五节课就讲完了，好吧，大概还有四节课左右吧，如果跟不上的话，可以先不跟好吧，先看那些基础的东西，ok好了，来看我这个项目，我们还是一样，先回顾一下上节课我们大概讲点什么东西啊，我知道了。

每次我们的spring boot项目在启动的时候，必须要执行我们这个装方法，然后你往里边依次进行点击的时候，你会发现了他创建了一个spring application的一个对象。

在这个对象里面大家还记得做什么事吗，应该还有印象吧，首先它创建了一些资源的一些管理器，但这个值是空的，第二指定了我们这个程序启动的主力是谁，叫primary source。

第三个指定我们当前应用程序它是什么样的一个类型，第四个往里边设置了一堆的什么，是不是初始化器和我们这样的一些监听器，这些监听器和初始化器。

这些文件是不是在一个叫spring their factories的文件里面，大家应该有只有有印象吧，说在账号里面，当时我跟你们说了，其他账号是没有的，那两个你再看一下呃。

找一下我们的spring boat，第一个在stboot里面有一堆的配置吧，这是第一个文件，第二个有个out to wear，out，out to confia。

在这里面也有一个spring factory，这两个文件就会进行自动一个加加载，而且它加载完之后，因为后续的源码里面会不停的从这个文件里面取对应的一个类啊，取定一个类文件，所以这样希望大家注意一件事。

注意什么事呢，它首先加载过来之后，会把文件里面的全部顺序，把全部顺序，然后直接读取到我们的全部内容堆，都堆到我们的缓存里面以后，再取的时候就会直接从我们的缓存里面进行一个获取，懂我意思吧好吧。

所以这块大家注意了，我们这说的是什么，是swing bot里面的东西啊，spring源码你们之前已经讲过了，我知道不太重复了，懂我意思吧，the board里面只有两个，里面有spring bot。

肯定要依赖我们的spring吗，懂我意思吧，ok这块稍微注意下就行了，就这些东西，然后呢，最后一个找到我们当前这个应用程序它所执行的一个主函数，我找到我就是主函数，它是有一个对对战的一个路径吧。

依次往上找，能找到我们对应的一个主函数，就是当前这个类在创建对象的时候，他所做的一些事情，好想做一些事情，大家进行完成之后还要干嘛，是不是该进行整体的一个启动环节了。

我们上节课也大概就讲到这个启动环节了，大家想一下这个启动环节前期他做了哪些准备工作，第一个设置了一个stop watch的一个对象，这个对象里面非常简单，就给了一个名称，给了一个时间。

记录一下我当前程序启动了多长时间啊，这是第一个，第二个又进了一个上下文的一个对象，当然此时对象还是空的啊，此时对线还是空的，之后才会给他进行一个创建，第三步，我们定义了一个异常的报告器。

它是一个release，第四个配置一个什么叫java wt headless这样的一个属性，把在我们的系统属性里面去了六个，是不是加载了一些监听器的内容，表示一些监听器监听，我跟你们说过了。

首先我们会从11个监听器里面来进行一个数据的获取，取完之后并不是说所有东西都能进行适配的，他要干嘛，根据我们的事件来进行匹配，刚开始你第一次刚进去的时候，这儿有个什么东西找一下。

是把我们这个装类似呢都给获取到，当你获取到之后，第二步开始进行一个starting，一点starting里面会出现一个对应的事件吧。

你点一下看个什么东西叫application starting event，第一次的时候会像这里面，也就是说我会从那些过滤器里面进行一个匹配，能匹配到当前事件处理的进行监听器，留下来。

不能匹配的直接过滤掉，然后呢把那些监听器分别进行一个整体的处理环节，这是第一个我们讲的一个事件，后面的时候啊还有很多，然后这块我跟大家说了，我们在取的时候是不是有这样一个这样一个属于是这样一个对象值。

这样对象值是在当前这个类进行呃，初始化的时候，或者处上对象的时候，这里面进行了一些复制操作，这东西啊之前已经带你们看过了是吧，我是反过头来带你们直接看的，所以这块要留一个印象。

然后当这些监听器都启动好之后，下一步骤该干嘛了，是不是解析我们对应的一个参数值，而当前的参数值是从哪来的，是从我们的命令行来的吧，你还记得解析了我们命令行的一个参数，然后带你们看了是以杠杠开头。

k等于v这样的一个方式来指定的，他后面会有一系列的一个匹配过程，匹配到之后直接把它带到我们的呃，那个这个配置而配置参数里面来好参数里面来，这是我们上节课讲的东西，然后这节课我们讲什么。

主要讲一下我们当前这个环境好吧，也就是说我们spring boot程序在运行的时候，它是需要依托于环境的，叫conferable environment吧，是不是叫配置环境，因为我们都知道啊。

你虽然可以从我们的application properties或者说application emar里面读取我们的配置参数，除此之外好处之外，在很多的类的上面，其实你定义的一些注解吧，好吧。

这块一定要总结到我们对应的一个什么环境里面去，所以这主要是准备环境，还记得吧，那我从这儿开始进行一个讲解了，这个方法上节课大概带你们看了一下呃，可能因为下课的原因吧，也可能时间比较长的原因。

很多同学听到那之后就已经听懵了，好我们今天把这个东西再重新重新重复讲一下，来到这个环节为止，上面的东西还有点印象，可能记个大概的同学，老师扣波一，好了，那没问题啊，没问题的话，我们来开始执行程序。

记住我说过了，第八个来进行执行，嗯错了，稍微进行一个跳转啊，往下走走走走走，说到这一步骤了好吧，到了之后f7 进到我们当前这个环境里面来进到里面去之后，你能看到很多相关的一个呃语句啊，看下语句干嘛呢。

你通过名字你能做一个判断，第一个叫get or create environment，先创建一个环境对象，是第一步骤，第二步骤是进行一个合理的配置吧，第三个叫attach，很多同学看到太太之后懵了。

我这个touch什么意思，你把它理解为什么贴上，就是说它会往这个环境里面再加载一些对应的属性值，第四个是进行一些计算器的一些启动准备工作吧。

第五个把我们当前这个环境绑定到我们的application里面去，第六个做一个类型的一个判断，环境变量对环境对象是否是符合我们的类型的，如果不符合再进行一个转换，第七步也是往里边加一些其他属性。

仅此而已，明白了吧，我们挨个来看一下，第一个叫创建，或者说获取一个环境，大家想一下，到目前为止，我们在之前的操作里面有做过任何跟环境相关的事情吗，没有吧，所以此时你在进去之后一定是什么。

是不是一定是我们要进行一个创建工作，而不是一个获取工作，四连续看一下，刚开始environment是不等于空，等于空的话不走，这然后这个会进行什么，根据我们当前应用程序的一个类型来做一个判断，再说了。

什么类型叫throat吧，是不是throat，因为之前说过了，有三种类型，一个是n exerate，一个是reactive，三种式的东西之前它会根据一些参数进行一个判断，好进行一个判断。

为什么要贪吃两次，你看一会我要回来再说啊，回来再说，一会儿再讲讲这东西啊，回来再说，来来看，这是一个survey的东西，所以在往下走的时候往下走走，是不是匹配到这儿了。

叫stard server envim吧，这个方法我希望大家能够注意一下，非常关键，为什么他这实际上是创建了一个对象，而在我们当前这个对象里面，对象里面你们可以看一下它的一个类的一个结构图啊。

收大家过来看这个层次依赖关系了吗。

它的上面是谁叫stand you warn warm，上面是谁叫abstract you warr，为什么要带大家看这样的一个依赖关系图，上面这个接口不用看了，接口不用看好，先放一边。

我们主要看它对应类的一个继承关系，因为当你创建完成当前对象之后，他默认情况下需要做一些准备工作的准备工作，来回来我们看一下，如果按我们刚刚的说法的话，点赞点它，点它之后是不是找他的构造方法。

你看一下当前这方法里面有构造方法吗，有没有做过吗，没有吧，没有说老师，那我就单单创建这个对象就行了嘛，很简单嘛，不对好，你这样看原版的时候，很容易漏掉一些关键的属性值，为什么我说了他有一个继承关系。

在此类创建我们对象的时候，父类对象是不是也要进行一个创建，所以此时你要往上翻，明白我意思吧，一定要往上翻，你看一下分类里面大概做了什么样的一个事情，大家做什么样一个事情，往上走点，负累负累的时候。

你看一下当前这个分类里面有对应的构造方法吗，是不是也没有，没有的话，再往分类里面找它是一个什么类，叫抽象类吧，虽然是抽象类，但是当前抽象类里面它有一个什么，是不是也有一个对应的各个方法。

各个方面它掉了一个什么，是不是这样的一个方法值，所以你发现了当你的子类对象在创建的时候，他依然是不是也会掉的方法，而这个方法里面做了很多的事情，做很多事情，我们这儿可以点一下看看点它点完之后。

这是个空时线，空实现的话一定要找什么，是不是找具体子类的一个实现了，刚刚我们看叫什么叫standard server，然后呢environment点它这是两个选哪个，下面这个吧，点下面这个点完之后。

这告诉你一个道理，或者说这告诉你一个信息，property source，点at last at last，这个property source是什么东西啊，你猜一下应该知道吧。

这不就是一个放置我们属性资源的一个对象，或者是一个集合点，看一下是不是传过来一个这样一个呃不可变的一个集合对象，有了它之后往里边叫at last，往里面最后进行添加嘛。

加上了new了一个什么叫s t o b property source，这个psource，这是一个对象都无所谓，关键是看后面的参数值，哪个地方叫server configure promise好。

inal pm pm啥意思是surface it里面配置的一些初始化参数值是第一个，第二个再点一下这什么叫server lake context，interfms，一个是confe。

一个是context，如果你对你的server的印象还比较深的话，这是server里面两个非常非常重要的对象吧，或者会之前的时候如果是sv的话，会从我们的外表上班里面读取一些参数，配置好。

这样的话是不是把这个参数值也帮你给加载过来，是不是完成这样一个基本工作，所以前面做了这样一件事，这要记住了啊，这样记住了，一定要去记住它，这样做完之后没完好没完，还有什么事。

下面这还有一个叫gndi这家店的东西啊，你们一般用不到，所以不用管它好，往上看，这有一个super点什么东西，一键看到super了，一定是掉负类的，你点一下负类上面有什么东西。

是不是跟刚刚的代码一模一样，直播现在变成什么了，变成叫properties，点什么东西，system in environment，点什么东西，你点开这两个常量值，你看到了谁。

是不是表示我们的系统属性是不是系统属性对吧，你再点下面那个叫什么，是不是也是我们的系统环境，看明白这意思吗，所以大家能看到刚刚我们完成那个操作之后。

实际上它是往我们的property source里面加载了四个默认的一个配置资源，好吧，你想一下啊，你要想运行你的应用程序，当时我们在那个jdk刚刚讲java的时候，老让你配环境变量。

环境max里面是不是指定了很多的一个路径，像那些路径是不是都属于我们当前的一个系统环境了，所以那些系统环境的参数值它都会被加载进来，一会儿我们可以看一下，明白意思吧。

所以一定要看一下当前类这里面的一个继承关系，你比方说老师，我就new一个对象就完事了，那样看的话是不完整的，我说了你会丢掉很多关键的一些属性值，所以这块是不是直接创建了往下走了，那个东西不带你们看了。

不带你们看了，说到这了，这次老师已经得到一个最基本的环境对象了对吧，来看一下这个环境吧，我拉一下environment，找到我们的property source是不是有四个。

分别是server config in need a paparamel，server contest in it，persi system properties，然后呢。

system environment能看到四个属性值了吗，现在是不是应该知道说哦，原来四个属性值是通过这样的方式给加载进来的，来这个点，听完同学扣个一能看懂吧，就是我们之后啊，这不管在配置文件里面也好。

还是在那些系统变量里面也好，配置的这些值都会降到里面去，这个时候你可以看一个东西啊，叫environment，sm environment，点开我们的source，你往下看这些属性值能看见东西吗。

他有没有把这些东西加加加载过来，是不是指定好一些路径，再比如说你点开上面这个叫system properties，点开你看这东西了吗，java vm version等于谁好吧。

java javm是什么东西，然后一堆参数看看出了吗，能看到吧，是不是能看到具体一些相关信息，所以这些信息都已经被我们给加进来了，如果之后的程序里面我需要用的话，是不是拿过来之后直接用就行了。

懂我意思了吧，所以这块也能看到很多相关的一些参数值的，它不是说我白加来的，一定是存在具体的一个意义的，那上面这块da source有东西吗，没有吧，因为现在你还没往里边处理任何东西。

所以现在还没有任何的艺术性，但之后我们会往里面加载很多的一些其他属性值，是第一步骤，先创建当前的一个环境，环境完之后，第二步该往当前这个环境里面进行相关参数的一个具体值的配置了。

这个配置其实也非常简单也非常简单，你可以点一下这个参数值走交方案里面去，是不是在这儿在这儿的时候，这儿需要大家注意一件事儿，我们都知道在写spring boat这些程序的时候。

比如说string转成int对吧，再比如说date日期做转成字符串，字符串转成date日期，是不是及到很多相关的一些转化工作，而那些转化工作最终会在这个步骤里面完成，当然啊呃这个东西啊。

是根据你不同的那个总部的版本不一样而决定的啊，在老区的里面，版本里面是没有这个东西的，这是新加的，因为我讲的是2。2。2，最新的版本，明白意思吧，这地方该做什么事，第一个是属性值是处，所以肯定能进去。

进去之后我们这里做一个判断，往下走啊，注意判断他说了叫application conversion service，点get share instance，这get share instance干嘛的。

不知道吧，好吧，你们有没有印象，之前好像似曾相识过这样的东西叫share什么东西，没有的话，我们接着往里边进行点击，点完之后，这里面告诉你了，说是一个share instance的一个值吧。

这是不是有定义这样一个属性，你往下走，刚开始这个属性值有值吗，没有吧，是不是空的，空了之后它往里边一直往里面走走，现在还是空的啊，一直往里边空，到这块的时候，你看一下这做点什么事。

是不是又开始创建我们当前这个对象了，来点进去走，在这里面做了什么事，看这块了吗，我们挨着往下看吧，这个值等于空吗，等一会啊，是跳下面一块，这有个config，你点到这个configure方法里面去。

第一个叫default conversion service，点at default converters，converters，熟不熟，什么叫converter啊，见过吧。

之前是不是也自定义过一些对应的一些转化器，你自定义过实现过吗，哎还记得这东西吗，double check clock，不要管这个锁的事好吧，你先理大概的一个思路行吗，限制外连锁的是你先理一个大概思路。

你先把这个流程给捋清楚了，是不是叫转化器，这个时候你可以往里面进行一个点击走，看里面做什么事，第一个叫a什么什么东西，computers点进去看他做什么。

叫number two number converters，然后呢string to number object to string，string to chara，character。

object to string，然后number to a character一堆一堆，看到了吗，这是不是我们之前看到的一些相应的一些转换器的东西了，能看到了吗，是不是相当于在我们配置环境的时候。

他已经把这些对象直接把我们给注册进去了，这样能看懂吧，把能看到我直接把他跳了一行行走，这里面就是一些对象，这没啥好吧，这些对象的一些处理过程，这个很简单，没啥没啥可看的啊，往哪走走走走走，东西很多啊。

点进去第二就第二个什么叫at cassions converters，是集合的一些转换器了，你点进去一样的，array to collections，collections to array。

array to a ray，然后呢collection collection map to map，是不是一堆转换器也是一样的啊，一样的都搞完，搞完之后，下面还有别的什么呢，叫bad buffer。

computer，string to tytwo，他们呃，他们id to time zone，什么什么一堆东西，是不是还是一堆转换器，就这里面定义了n多个的一个实体类对象，这没问题吧。

这是第一步要做的事情，第二步叫什么呢，叫at default format formula，什么，啥玩意格式化题吧，是不是格式化器，然后点进去依然看一下。

这不是可以加一个number for me and education for factory，什么东西对吧，我这不往里边点了，不往里边点了，你还跟往下走，这做一个判断，判断完了之后。

这儿有一个叫data time for me register对吧，后面还有一堆的一些逻辑判断，比如date formal register，是不是有很多这样的一个格式化器了，要转换完就完事儿了。

再来看第三个叫at application for it，把刚刚那个转换器是不是加进来，点进去叫char array format，night address for it。

s upset format，是不是这个值再往外边走，string to多多tion to string number two，多tion，什么cba一堆东西，所以这波大家看到了，我们这儿不用管。

但我知道了，整体上来说这块儿一共完成了一件事儿，什么事，把我们很多的一些转换器和格式化器对象都已经提前创建好，创建好之后加载到我们当前这个commercial service里面吧。

而这个converse service最终是不是还要给到我们的environment里面，所以它有一个层次递进的一个关系来往下走，创建好对象了，这个值是不是已经有值了instance了。

然后把这个值返回回去，返回去之后叫environment set conversion service，把它加载到我们当前这个environment里面去，加完之后你可以看一下debug里面的一些值。

来找一下我们的另外ment，找完之后找一下刚看到的小叶是谁来着，格挡environment in哪去了，看这converse service吧，点完之后，这儿有个converters，点进去。

converters点进去多少个多少个，一共134个吧，意味着把我们所有这些转换器，这些工作是不是都已经加到里面去了，那这块之后在做的时候还用我们操心吗，不用吧，你在写代码的时候。

它是不是有些情况下自动也会帮我们进行转化，如果是他转化那种格式不太符合我们需求的话，我自己是不是也可以进行自定义的时候，他也会进行整体的一个装载工作，加载工作也能够进行一个生效这块东西。

所以这样都比较简单，来到为止能听明白，同学扣个一，你最起码要知道说他这一步做什么事，做什么事，你平常用的时候看起来好像很舒服的样子，好像不知道什么是做的，但其实在初始化的时候。

或者在创建这个应用程序的时候，他已经把这些基本工作都帮我们做好了之后往下看，下面两个东西就非常非常关键了，第一个叫配置property source，第二呢叫配置profiles。

这profiles到底指的是啥呀，promise s不用我说了吧，就是我们参数的一些属性值，对不对，这个profit是啥呀，有人知道吗，对spring profile。

你想一下你在配置的时候是不是指定过多个环境，比如说有生产环境，有测试环境，有各种各样的环境属性，叫spring。profit，点active，你可以指定说我可以在多环境里面进行直接的一个切换。

是多个多个配置了，就是这样一个意思，来挨个往里面看，挨个往里面看好吧，先看第一个叫config promise，这里面做的事情也比较简单，刚刚我们看到了，在我们当前这个environment里面。

它所谓的properties一共有四个值，对不对，这个一共有四个大四个参数值给我记住，service configure sweet呃，contest system，properties。

system environment，把它40只给记住，因为这现在它要往里边加东西了，删东西了，来点一下往下走，这时候告诉你这是一个source，这没有吗，有吧，看看看第八个里面参数值吧。

点下去一个source是不是四个，还是刚刚那四个这个没有变化，那这样会做一个判断时候干嘛，它会往里边重新创建一个叫default properties的东西，就默认的一些参数值的配置。

默认参数直接配置不完了，加这样的属性，忘了吗，不换了吧，所以这第一个不是什么叫不等于空，并且什么不等于mt的时候会进去，连续能进去吗，进不去吧，进不去没关系，往下走，这个this。

at command line properties and ex大于零，我们这儿有参数吗，没参数没参数会跨过去啊，没参数会跨过去走，所以大家看到了这个里面好像没做什么事对吧，我做完这个步骤之后。

他依然还是我们四个参数属性值，但你要知道后续的时候，因为刚刚在这个方法里面，它指定了一个default properties的东西，虽然现在没有之后，是不是也一定会往里边进行一个具体的添加工作。

只不过在这部里面没有进行一个完成工作，那后面肯定会完成吗，现在这样一个悬念，看一下他什么时候做这件事情的好，第五步干嘛叫convex profile吧，是不是家里profile了。

这里面你能看到很多你认识的东西来往上看，第一个叫new一个现在集合吧，叫additional profile，这个值现在是空的好现在是空的，这就是一个high集合，进行一个驱动操作，这么啥说的。

第二步往下走，叫environment的get action profiles，你想一下我们现在我们现在有指定任何配置文件吗，没有吧，大家看一下我这个配置文件啊，几乎都没写。

找一下我们的这里面有些东西吗，没有吧，是不是没有好没有，没关系，我们往这边走一下，点进去叫get do get actor fi，再往里面点多了之后，你看下这个属性值啊，不是不是是这个东西。

看这个名字你熟不熟，叫spring profiles，点active，看这名字了吗，这名字熟吧，原来是读取我们当前这样的一个参数值，你在生产环境里面肯定会用的，一定是多环境的配置，测试环境了。

开发环境了对吧，这一定是有的，回来之后，这里面就干嘛做这样一个参数值的一个判断，看完之后，因为我们这里都没有吗，没有之后直接返回就行了，我们没配，所以直接返回，但你要知道他完成了这样的一个基本工作。

如果他有的话，加回来没有的话，那这个值还是空号空的，什么都没有，再来看干嘛，把我们刚刚设置好的这个活页或t profile文件，加载到我们当前这个environment里面来，是不是加进来了。

当然这个id profit是什么空的吗，我说了，我没指定任何值，所以这时候是空的，空就空吧，无所谓啊无所谓啊，大家看一下，刚刚那个步骤是完成了，所以这里面你看到了他除了这里面其实做两件事。

第一加一个什么，或者判断一下有没有default，让他和那个properties这样一个参数值，第二个加一下叫spring profile，然后呢active就加两个东西，别的东西不加了。

这个大家注意一下就行了，注意一下行了，第三个叫configuration proof property source，点attach很多，刚刚问了说老师这儿有一个attach。

下面是不是还有一个attach，你看完这块的一个逻辑之后，其实非常简单，都是把什么把我的有外面的时候加进去，只会进入这样的环节，做一个转换器，他把你转换过程中里面丢失了，所以后面重新加了一次。

仅此而已啊，来试一下吧，点击看一下做什么事，第一个是断言，不管它是第二个往下走，是不是获取到我们当前这个泡泡的source，这里面还有几个四个吧，看一下source是不是还有四个没任何变化，没任何变化。

然后呢往这边点这个source，点get，看那儿看到了吗，是不是叫configuration properties，我们现在这里面有这个configuration properties吗。

所以向下做一个判断了，如果它不等于空方法怎么做，如果等于空的话怎么做，是不是我们要看一下什么，看一下这个等于空的时候，他做什么事，对不对，在当前这个等于空的时候，可能跳到里面去，往臊子里面加东西。

这里面加东西就非常非常关键了啊，非常非常关键了，为什么这么说，为什么这么说，一会儿往里面看一下，你知道大概是什么样的一个意思了，好往上走一下，来看一下，点一下这个f7 走，第一个创建一个呃。

是不是一个构造方法，这构造方法非常简单啊，不管它了，走走走，然后第二个看这个参数值是不是还是那composition properties。

第二个叫new spring composition property source，点这些对象，点完之后点super，点完super之后呃，这也是他是吧，看到一个属性值是吧。

这点i force在这往下来看，这是不是值了，刚刚取过来一个属性值，configuration properties parties。

完了之后会把它把它加到我们这个property source list集合里面去，所以这样可以完成这样的一个基本工作，往下走，你走完之后你再看一下当前这个值几个了，12345了吧。

是不是相当于我加了一个值，叫configuration properties，现在你看到几个了，12345个吧，这五个参数是什么时候加载的，你必须要知道刚才的过程我已经带你看过了。

你必须要知道它到底什么时候加载的，听懂我意思吧，啊做完之后来回来，是不是，这不是做完了，做完了吗，知道这个函函是干嘛的吧，就是把这个判断一下，我有没有confirefpx，如果有的话加进去啊。

没有的话就加进去，有的话就不管它了，懂我意思吧，这这块儿的一个基本工作好，来到这块，到房前为止，能听见同学扣个一，谁让你记他了，你记他干啥，这个源码不是让你去记的啊，你要说老师我把原号背下来。

我也背不住，但是里面关键的某些步骤，你把它能说清楚就行了啊，这比较重要，这比较重要啊，好了这块判断完之后，下面又到这个环境叫this，然后呢第二environment prepared。

一看到这个方法好像有点似曾相识的感觉，有种感觉吗，有种感觉，这之前是不是也见过一个listeners加什么东西，这不之前叫什么叫listeners destarting吗，现在换了吧。

换了这一warm perfect prepared，就说我们环境准备刚刚是应用程序的启动，现在是环境准备往这边点，自己回头写一个，没意义好吧，点进去，点完之后看这个环境了吗。

是不是又该进行listener了，你告诉我还记得这个listener是谁吗，这个真的是谁，还有印象吗，我现在不带你看那个值，有没有同学记得上节课讲的叫event publishing。

然后呢run listeners吧，是不是这个东西来往里面看一下，是不是这只一event polication，run listener，是不是还是卡，整个我们这个程序启动的环节里面，唯一的只有这一。

这只有这个对象，m是什么，我们之前说的那11个监听器吧，然后再往里边进行点击走，连进去之后就到这了吧，这个时候看到一个新的对象了，原来叫application starting。

现在呢叫application environment prepared ev，相当于我多了这样一个对象值，看到了吧，所以这块出逻辑啊，调到同一方法基本上是一样，没有变化点，这是创建我们那些对象。

你往这边看一下，也没啥，往下走，是不是就记住一个时间，这个没啥值好吧，没啥值，不用管他，就创建这样一个对象，对象出完之后往里面走，走到这行是不是就看了点走，走到这方法里面去，到那之后可能又熟了吧。

干嘛呢，往下走，走到这，这这这是空的空，怎么办，这有个方法叫get obligation listeners，还是一样，我要通过干嘛，从那11个对应的一个参数里面值把它取出来，符合我们规则的吧。

什么规则叫application environment，什么application environment，然后呢prepare吧，还记得那个疑问的事件吧，把那个事件给我记住了。

往来看看这是不是有个疑问，看那the vironment prepared问，把这参数值给我记住，然后进来之后往前走走走，这儿有一个哪去了，这把是不是检检索我们对应的信息值往上走，这有个判断。

这是从缓存里面直接把这个值给读取，来，把读取出来，读完之后，这一个叫sports疑问词吧，都知道刚刚那个so这个listen有多少个，看listen us多少个类似点的形式有吗，多少个11个吧。

是不是还是11个，所以我还是一样，同时11个里面做一个筛选了吧，来走第一个不不不符合吧，好吧，来走走，第二个是不是进来了，进来之后往里面进行一个添加工作。

叫abstract obligation event，什么东西还是一样，最终要往里边进行一个整体添加工作，是这样，我希望能带你们好好看一下，因为他那把这个鉴定事件加进去之后，并不是我加就完事了。

不是这样的，还是要做一些最基本的一些工作的啊，最基本的一些工作的，大家看一下吧，这先过滤吧，先过滤好吧，一个啊，刚刚看到了，这是第一个，第二个吧，往里面挨个走走走走走，你不用数了。

一会儿看我直接看结果就行了，这就是个循环工作，循环完了吧，循环之后来看底下的一些参数，是不是有七个，这记住记住这个参数值好吧，记住特征值，同时还有一个什么叫点retrials applications。

点at leen是吧，他还往这里面也加了一份加值多少，是不是还是七个确实是一模一样的，还是这七个更没有什么变化，你把这个值给我记住了好吧，知道这里面放了这样一个对象，放完之后还是一样。

挨个往下走吧，这里面干嘛的，获取并对象，然后获取不了，往下走走走，把它加进来，加完之后返回我们这个值一共有七个，走，回七个访问七个之后，这儿开始具体的一个执行工作了，这个步骤我们需要重新看的。

因为之前想一下，第一次我们看那个事件的时候，是不是一共有四个，我你们还记得没有，当然是实现出来四个事件，那四个是不是有四个类似的，那四个类似的里面是不是只做两件事，第一个叫log system。

是不是和日志系统的一个初始配置，还记得吗，第二个是什么，是配置了很多转换器，格式化器等等很多操作参数，还有另外两个是什么作用没起，这块在执行的时候依然是一模一样的。

我们还是要挨个进行一个最基本判断走第一个叫什么叫configure，fail application listeners，你一看这个名字就知道这两个东西一定是有用的啊，一定是有的。

为什么说一定是有用的呀，告诉我这个有用吗，有用啊，这块可能会往里边跟的比较深，跟的比较深，因为p2 是配置文件，我们最主要处理其实就是配置文件可能会跟的比较深，我希望这块你能够好好听，好好听这块东西啊。

来往这边走，这个选项pm对，就他listeners而走，点进去开始执行吧，点进去走走，do invoke listeners，点进去，这有一个listener on application event。

再点进去，这是不是作为判断了，判断一下当前这个事件是不是ation viv，是他吗是吧，是的话，就往这边走了，再点进去，整体的一个处理环节，在这个处理环节的时候，这东西叫什么。

叫漏的post processors，这个是干嘛的，是干嘛的，叫post processor吧，是不是我们在主里面你们见过这个东西吗，在我们注入并对象的时候，它相当于是一个构造函数里面这样的东西。

就这块大家也知道啊，在词语里面经常见到这样这样这样单词，你把它理解为一个处理类就行了，扩展处理类就行了，也没什么特别难的，然后点点到下面了吧，这有个东西叫spring factory loader。

点load a哎点点点点错了，不管没关系，大家看点点方法不对了吧，在这个方法叫spring factory，load load factory，这东西少不少，是不是还告诉你说。

我要从我们刚开始那个spring factories，这个文件里面开始加载一些具体类名了，这名称告诉你叫event post processor，来点开我们那个配置文件，我说了啊。

我都提前给大家给粘出来了啊。

晚上再往上翻找一下，叫event，找一下，看这是不是叫environment post processor，你点那个地方，第一个叫color什么啊，found foundry什么东西。

第二呢three application什么东西，第三个system e n v property，source environment pose，第四个叫debug agent。

environment processor，之前几个值一共有几个，所以我这加载回来之后。

是不是四个一定是吧，来往下走啊。

这这这这已经过去了，过去告我们看一下这个值吧，刚刚点快了过去了，怎么五个呀，下面还有吗，看下面还有没有了，别问我们的pos processor，没有了没事，应该四个怎么五个呀，看这个这是啥啊。

第一个这有第二个，第三个，第四个，看这儿这家里什么东西，那这加个什么东西叫at processor，at this吧，是把自己本身也加进去了，所以是不是一共五个，对的没说错啊，是不是有五个有过之后。

这tation where all compare to shot，是不是把它进行一个排序操作，你排完序之后，这儿你要注意了，注意什么事，在这里面开始进行一个for循环操作。

而这个for循环操作里面叫post processor，问vironment是开始往里面加这些东西了，好吧，挨个来辨认一下试试啊，走第先取出来叫什么，叫system environment。

properti先读取回来是这样一个属性值，这里面他做了个什么事儿啊，可以往里面点一下，第一个get environment告诉你了，是slender serenvironment。

不管他第二个参数是get through application，这就是我们当前那个主动的一个application程序，大家走，你看这个b不成程序啊，找一下找一下来问他，是这个疑问，到这儿没有啊。

没看到啊，点开大家看一下吧，even get spring，是不是我们之前说的spring date，simple the application好，还是我们当前这个类啊，这类是不变的那个主类主体动类。

然后再往里边进行点击，叫post process in 2文字，这里面就很关键了，点一下这个参数什么值叫system environment吧。

还记得我们之前那个source properties里面是不是有将来这样的东西，所以现在我先把它给获取到完了之后，第二步叫you want get process，这get通过这个名字把它拿过来。

拿完之后不等于空，这做了整体的一个替换工作，叫replace property source，给你看一下，干嘛呢啊，值取出来，取完之后放到一个mac结构里面，放完之后。

他把刚刚那个配置参数值是不是什么叫origin or system environment property source，在这样一个对话对象转换恰多少都没做。

我到现在我也没猜测到说他为什么要把这个对象给转化成这样啊，不知道啊，我只知道说他里面做这件事，但是我没猜到他为什么要这样干，懂我意思吧，反正不管你记住一件事，他这个操作非常简单。

就是把我们刚刚那个呃系统参数的一个值，system arm的是不是做了一个对象转换之后，转换之外其他东西都没做，懂我意思吧，啊这是第一个，我们要做一个事儿，来这块评判同学扣个一，你听我说啥吧。

所以我们在读取参数的时候，有一个system environment这样一个对象，但这个对象拿过来之后，他在里面做一件事儿，把那个对象转成另外一个类型，但现在我也没猜到他为什么要把它转成这个类型。

还不知道，如果谁有那个研究过的话，可能跟我说一下，我没猜到为什么要这么干，你懂我意思吧，没关系，来再接着往下看，其他的完了循环循环，第二个叫什么叫spring application。

jason什么东西，看到spring jason的话是干嘛的，肯定是要处理我们对应一些战斗数据了吧，点一下走，这都不用管它，点进去到这块了吧，这里面你看到这样一个操作点，这个旁白色等于谁。

看一下是configuration provisource里面是不是传了这样一些参数值啊，这值啊很多了，我们点开看一下吧，叫property，是不是一共有对应的五个值，这个值就是五个值。

这个值拿过来之后，它变成了一个什么，是一个集合对象，有机电之后点stream这个1。8之后，它保留出来一个流式处理，或者说函数式编程对吧，map jason get什么filter过滤。

然后放first找到第一个，然后pet呢判断一下这个值，然后press jackson能处理我们对应的一个json的一个对象了，是这意思吧，好它能处理整体的一个这样对象，你往这里面做一下。

你点完之后你发现了用了一个什么，这块是用了一个东西叫jason property source啊，你点进去是不是就加了这样一个值，叫obligation，叫jason吗，这三个不熟吗，之前有人见过吗。

来见过同学扣个一有没有见过，就是看说诶这东西见过吗，没见过，这个参数值你们都没试过是吧啊，就是说允许我们对应的一个参数值，它以jason的格式啊进行一个呃数据传入啊，就这个意思，没别的东西啊。

就是jjason，如果没见过没关系，但你要知道说他这里面做了这样一个基本操作，基本操作操作给记住了吧，记完之后往回返，我不看它了，那我就不看它了，这接着玩家处理吧，玩家处理走走走走。

是不是第二个过滤不做完了，做完之后就相当于说我这只是说允许了一个战神的基本操作，别的东西没有了，来看大家看该第三个了吧，往下走，第三是谁叫cloud foundry，什么东西。

你看到cloud肯定是云上面的一些东西，我们这里面有涉及到云上面的东西吗，没有吧，所以起码这个点之后，你会发现它里面好像什么事都没做一样，点进去，这衣服放哪走，有做任何事吗，没做没做就不管他啊。

这是第三个事件了，来咱们来看第四个事件叫configure fail application，你看到这个值，很多同学应该知道了哦，原来这看看了吧，做事情就比较多了，这种事就比如说很多老师。

老师在读取配置文件的时候，可以是application properties，也可以是什么叫yy的properties吧，那东西我怎么看的，怎么知道它有这样一个东西的。

从这儿你就能看到你们看到我们来看一下吧，好不好，再点下试试吧，第一个获取当前环境，不管它，第二个还是apeaction，不管它也是三个。

再点这块叫application get resource loader，它是不是就获取了一个resource loader的一个值，点一下试试吧，看一下这个返回一个值是空的。

不管它第四个叫and property source，该加载我们property s资源的吧，然后往里边点，第一个叫random value，property source。

点add to environment，这干嘛的，value随机值吧，你想一下之前你在你的配置参数里面有没有见过随机值这样的东西，应该见过吧，见过吗，就这样就这样这样写吧，我们也没写过，我来写。

随便写一个，就这个就这块东西是不是dollar符号加一个random点，是是不是印t对吧，是不是还有浪，是不是这样类型值上这个见过了对吧，ok这块就注意了，就它里面加了这样一个属性值，仅此而已。

所以这块也没有管它，这边加完之后，我们可以往回看能做什么什么处理啊，连续对之后，这有一个environment吧，原版完之后，这有一个呃啊after，然后这儿有一个参数的一个系统值。

是不是叫system environment，当前系统的一个环境，第三个叫new value property source rdom。

source name是random告诉你说你可以random进行一开头，下面告诉你了，这是一个前缀是random点，在这里面提供了很多的一个哪去了啊。

别在这儿是不是get next int什么range，这一只反正都是返回我们这样乱乱乱乱那么一个值啊，慢慢走一下试试点一下，这是获取到我们的psource赶走，那再往下走。

add up是往里边进行一个调用，super往里面点类似，都是往里边一直往上加加东西就行了，正好不用看了，不重要，回回回对，让他往那边走，叫add after吧，是不是开始往里面加我们这东西了。

叫at at index是一，然后property source是不是把我们这个值给它给加进去，是不是加进去，相信最后意味着你当前环境里面已经允许，允许我们出现random两个东西了。

这东西怎么看也非常简单，点开我们debug debug，debug之后往里边找，找外文，找property source，看他有没有多一个东西，多了吗，做啥是多了一个random这样的东西。

最后一个random刚刚第一行执行完之后，是不是rm之前是没见过这东西，之前一直说是五个吗，现在是六个了啊，所以这块儿你能看到具体的一个职业情况没完，这东西还是比较简单的，知道什么。

我可能在工作中可能压根不用它，因为我没有那么多的一个随机值的情况，代码就非常非常重要的，叫new logo。ler，你有六点六点是干嘛的呀，就是用来读取我们之前说的那些配置文件的东西，来点一下试试。

牛的往这边走啊。

这里面开始开始开始操作了啊，比较关心了，就哎这是对对象创建完第一个environment，environment还是我们的标准service的一个环境，不管它第二个叫new person啊。

然后呢source of his holder resource，这rett不用管它走，走到这块之后，这儿有个东西叫load factories，应该比较熟吧，是不是又看到这句话了，之前已经不止一次。

是不是见到过这句话了，配置匹配什么匹配我们spring factory里面的文件，这类名叫什么叫property source，点ler是不是他往上翻。

最上面是不是叫property source la，看懂了吗，取完之后是不是应该取回来，是两个具体的一个类，一个叫什么叫power property。

然后sloader第二个呢叫em 2 property，sload是把这两个文件给你加载过来。

当然这是两个具体的类，这两个具体的一个类，具体类完了之后还要干嘛，我们看看这logo fet他都忘了走，不管他就是卡索格表，他你往下翻找一个东西啊，来走一下吧。

第一个是获取到我们这样的一个factory实现的一个名称吧，我们可以看一下这个名称是啥，找一下这两个看两个类是两类吗，对吧，有点累之后没完没完还要干什么事，叫呃在哪找找找找，这东西是干嘛的。

instance是什么东西吧，一看到instance，很明显他就是为了进行一个具体的实例化操作吧，再找一下试试吧，来走一下，那我们走一下第一个加载过来是什么。

叫o r g three free work bot，因为properties，property，property sorder吧，是不是下载第一个这样的类加载完之后把它点燃槽。

是不是进行一个实际化操作，实际化的时候就是我们反射角度，flash reflection，you tos。accessible，什么ctrl，后续的话当前这个构造器吧。

ult完之后点at的是把当前的类加载过来，你要想完成这个类的一个注册的话，你必须要干嘛，是不是看一下当前类的构造方法，pr t i e s power source，就找他。

是不是当前情况下我们这类看一下这个类啊，load点下a ler诶，p r o p a r t i e s，p a r t y source load，点的是这类，这里面告诉你啥了，有个东西叫点xml。

同时告诉你叫get fail extensions，叫applications啊，不是properties dexml吧，不是两个，一个是properties，一个是插m2 。

是不是两种配置文件方式都可以进行一个整体下载这样一个方式啊，ok这是第一个，第二个还有什么来着，叫ym 2吧，哎出不来了，怎么诶诶叫啥来着，看看值啊，把这拿过来，有大的类没记不住啊，来走他这边告诉你了。

后面是啥，是不是ym和ym 2，那此时当你完成之后，我应该就完成了具体两个类的一个实例化工作，对不对啊，计划工作完成之后返回把这个结果返回去，就这里面一定是两个啊，里面是不是这两个对象。

一个叫ymar property source ler，再加回去，这样就这样直接返回，发完了之后，这就有了，有后面别忘了还有什么方法叫low的方法吧，是漏方法，你可以点一下我们当前这个漏的方法里面。

他做的事情其实也比较简单，也比较简单，什么environment，什么default什么东西，然后呢往里面进行一个直接资源的一个加载，叫at property source吧。

这里面做的时候完了几bug不太好debug，因为它是什么，是不是我们对应的一个浪漫表达式里面用到一些东西，如果你表示不太熟的话，这块你可能看不清楚，我看不明白，但你要知道一件事。

这里面就办完成一件什么事，我们当以前的一个配置文件里面的一些相关属性值。

给你完成一个整体的加载工作，所以到你这儿完成之后，拿走拿走拿走，是不是完成了。

完成了之后，你往上翻看我们的这个话，找一下我们的vironment，点一下我们的source source，点它多一个没，是不是多了个什么东西叫application。

第二差我压ma你这配的是properties的话，你这就变成properties了，如果你这样配的是ym 2的话，就变成ym了，能够把我们当前这个文件是不是都取过来。

所以又看到了你当前这些属性值加载的时候，一共是从这七个地方进行加载的，就是开始你整体这个加载的过程看了吗，来到这儿能听完同学扣个一，能不能听懂，他是不是已经懵了，你会看到这个环境一个环境好吧。

这里面的东西都会把你给读过来，这一启动要把那两个文件中的所有人都实例化吗，需要用的实例化，不需要用的不实例化，需要用实例化，不需要用呃，不需用就不实例化了，这啥意思，就是刚刚给大家看那东西啊。

这里面是不是有很多类，它是以kv的形式存在的，而每次在取k v的时候就get什么，get ft是这样的方式来读取的，你读取过来之后，读取过来之后，我会进行一个有实例化，就实例化，没实例化我就不实例化了。

代码怎么写，那你需要哪个用哪个，到目前为止我们看看哪些。

第一个他是加载过了，第二个他是加载过了好吧，第三个这块会一会就看到它加载了，第四个初始化载过了吧，listen是载过了好加载过了，还有这个暂时没用了，一会会用到它。

再来看还有什么东西也会用到in internet，用过了，用过了，listener，这个还没用到，一会一会用到了，一会用到它了好吧，再来看这个也没用到，这这是那个自动导入是会用的，下面都是自动导入。

会用的，会用到的东西，也就是说你需要的时候会停下来，基本上所有对象都会给你加进来是吧，基本上都是这样的，会有多个配置文健康，你如果配置文件也没关系，我说了。

卡拉斯帕斯路径下面的所有spring final文件都读过来，那这个地方其实就是两个配置文件里面的东西，就是两这价格不是不是一个，我只不过把两个合到一块儿，合合合到一起了，我们这儿可以看一下吧。

给你看一下啊，第一个spring boot里面的一个东西，你点开之后，你发现最后用的到哪，到failure the letter reporter吧，点一下the reporter reporter。

去了这就结束了，从下面的开始都属于第二个配置文件的啊，都属于配第二配置文件的，不管你有多少配件，它都会进行加载的啊，在刚开始的时候就进加载，而且会把它放到我们的缓存里面，你把上节课那个视频听一下。

就知道我上节课讲过的东西啊，都是聊过这东西了，好吧，这关了啊，不管他了，不看他了。

大家看到了，刚刚我已经把我们对应的一个配置都加进来了，加加之后这个循环还没完还没完，还要往下走，让他走一下走，这个是不是又看一个post processor了。

这叫啥叫debug agent environment，什么东西，是这玩意儿，这玩意儿干嘛的呀，我想走试一下吧，这debug里面要用到用到一个东西啊，走一下，走开他就跳，判断是不是什么都没做。

就什么都没做，直接跳过去了，拿走走还有吗，这是我们一共找了五个对应的一个pose processor，但这五个里面其实最重要的是谁。

是configure fail obligation listener啊，是这里面的一些呃processor，一些相关相关相关相关的一些处理，其他东西几乎都没用对吧，这做完之后往回返好，往后翻。

翻到这儿之后，说到这哪去了，往下走走走，走，走到这了吧，是不是又该电离我们的listener了，还记得刚刚提了吧，不是有七个，是不是七个来着走，再拿走，第二个叫什么叫a n s。

i output application，是什么东西，这东西啊，我不管你不管这边看了没啥用，就设置a n s i的一个输出，知道什么叫in si吗，知道吧，你应该知道吧。

什么时候知道，还给我举个例子，不知道啊，来我来看你点开它a t s文件，你选文件另存为，在上面你选一个东西叫n s，看到了吗，就是编码格式，就编码格式而已，看这块了吗，没是不是选ut。

ut的ut和八是不是可以是ns格式。

这块不用管它好吧，呃对我们的影响也不是特别大啊，就这样一个东西好了，那这块不往里面看了，再往上走，第三个叫login application是什么东西，这个logation这个东西见过吗。

之前我是完成了一个初始化日志系统的功能，这块也是一样的啊，也是一样的，走了上哪走，第三个叫卡拉斯pass log，什么东西，点一下吧，有点儿不舒服啊，点一下走，能有做什么事了吗，没做吧，这什么都没做。

来没做完过，烦烦烦烦，放这儿再下走，第五个叫bground，什么什么东西，这个bground什么做什么事了吗，走点进去，走走看，那是不是全部全部都没有对吧，是什么什么事都没做没做，我再往下走。

叫pk是什么东西，这边也一样，往下走玩，别人试试吧好吧，反正几乎大部分东西啊，这时候做了一个获取到一个类似的一个对象，获取完之后做一个return，这不直接return了，如果这等于空接着能回去。

所以相当于跟什么事也没做，一样都一样好吧，咱俩走，第四个叫fencoding，这不用说了吧，这也是一样，指定我们对应的一个什么文件编码格式吧，这不看了啊，下面走还有吗，没了，刚刚大家想一下。

我是不是把完成的七个具体的一个呃listen的一个操作做完了，做完之后，王一凡王一凡，王一凡，王一凡，王一凡，这波是刚看到这波下面是不是还有呢，是不是还有，但这波你要知道了，上面其实干嘛。

就是创建了一个最基本的环境，然后呢往环境里面多加了一些配置参数，仅此而已，这东西就没有了好吧，所以大家想一想，我们花一小时时间就讲这么点东西多吗，不多吧，我只能听明白，同学扣个一，1。5，多也要看。

多也要看，你不用想了，我现在带着你看，我不带你看，你往那边走的时候走多少，走多深都很麻烦，都很麻烦，看懂了，你现在能听多少，能听多少，能进记多少记多少，自己下课之后多迪拜了，东方里面点点试试，多看看。

你知道哦，原来这么回事哦，原来这么简单，你会有这种感受的，现在没这样感受，原因是啥，是因为你们之前没自己看过自主思维，或者说我应该看到哪个层次就结束了，也没有这样的感知，像我之前第一次看的时候也一样。

我我我我怎么看，有先把整体的东西能看懂的，就先看过去，看不懂方法不管了，不往里边，不往里面深究，因为你的方法如果一层一层一直往里边点的话，点完之后就封了，完之后就分了，好吧，看到这里了。

下午就听得听得懂点好，能听懂就好啊，不知道在干嘛，这环境啊，准备我们的环境啊，想一下你现在如果想赢取你的jdk，想赢取你的jdk，jdk的话，需不需要一个环境。

那同样的你要想运行你的spring bot的一个应用程序，它不需要一个环境吗，就是在这个环境里面，我需要做哪些对应的一个准备工作，仅此而已，ok，把刚刚讲的东西啊先换一下，我们休息十分钟。

十分钟回来之后，我们再接着讲好吧，放三脑子，抽根烟，上个厕所，喝杯咖啡好吧，放松一下，ok，雷声大，想一件事让开他是好事，你看懂了，别人没看懂，你面试是不是沾光了，随便的人都能看懂的话。

你面试的时候没有什么优势啊，对不对，构图呃，这东西啊跟我们的spark不太一样吧，不太一样，像spark的时候，我们之前画过很多的一些图，给大家画点东西，因为它里面有一些，比如说组建statement。

excel这些对象里面干什么事都是一层一层嵌套的，我在这儿debug。

看的时候，我往里面找的时候，我自己都找不到，有时候都找不到他，因为他这个对象的一个嵌套过程太太太复杂，太麻烦了，等我们把整个启动过程完了之后，给你们画图画画整体图行吧，我这个这个笔记你们看了吗。

这个东西你们看了吗，有有人看这东西吗，没人看啊，我在这个笔记写的时候，我把我能写的东西我基本都给你们写进去了，只不过有些方法，有些方法之后没有点那么深，都往里面粘的话太麻烦了，然后我其实刚开始的时候。

我设想的是我要自己编一个呃，2021个源码给大家看一下。

其实我也编辑好了，但是不能用就很麻烦，看一下，我之前真的想在那个原画里面自己来做这件事情的，你看一下吧，笔记跟那个注释啊都是分离的，我原来是想往这里面写的，原来写的时候我其实写了一部分。

但写完之后发现跳不过去给大家看一下。

这里面我写一些东西，我写东西写完之后，我发现我点的时候，呃不对，不是找找一个东西啊，找一个还是这个类啊，跳一个类啊啊这玩儿吧，看这个地方一点，但之后这里面他跳的还是maven里面的东西。

还是没法在面直接直接直接改，而且这里面还有还有一些错误的东西，反正就我上网搜些帖子，他们都说这个2。2里面有一些bug，他跑不起来还能跑起来，但高本跑不起来，所以我就没往里面写写写写注释，其实跑不起来。

2。2确实跑不起来，地板本身能跑起来，2。2确实跑不起来，我试了好久，真跑不起来，没办法，我只能帮你们写笔记，帮你写笔记嗯。

我觉得那我的笔记写的还是足够全的，足够多了，下来之后自己看啊，慢慢看，我看得多了，自然而然就知道啥意思，就知道啥啥问题应该怎么看了啊，面试的时候怎么都源码都问哪些东西，一般的就是启动过程。

如果再问的话，就是我们的starter下面的相关的东西了，所以我这次原来我本来打算讲讲讲比较深，后来想算了吧，我们讲一下这个启动过程，讲一下那个自动装备的一些原理。

然后再讲一下呃什么还有还有那个dk就完事了啊，不跟你们讲太深了，后面如果还需要的话，我们把二期里面加，二期往里面加以后，课程里面往里面加东西，更新东西不讲太深了，我感觉你们听着也好难受，是吧。

不难受就好，讲一步流程，你把每一个环节能把它给捋清楚，就行了好吧，把一些关键步骤就行了，没让你都记啊，都记得干嘛没意义啊，还是一句话，你看完这个源码之后，你自己捋一个流程线出来，每一步做什么事儿啊。

面试的时候如果问到这些点了，你能把它给说出来就够了就够了，千万千万不要像我跟周老师这样开眼玩，跟周像我跟周老师这样开源码的话，看完之后你就疯了啊，讲完这个启动过程之后，我会画，我会画的，我会说的。

我会说的，拿拿杯水，拿杯水回来，我们接着讲啊，好在同学扣波一，我们见马奖，你看源码的时候千万注意一件事，不要想着把所有东西都搞明白，结果刚你说的那个一样，然后转化下类型，我到现在都没想明白。

但是在不影响我们整体大局上面的一个查看，懂我意思吧，这是一样的啊，再往下走吧，往下看呃，刚刚我们看到这个准备环境，这个监听器里面做哪些事情，这个很明显翻译过来干嘛呢。

往我们的spring application里面绑定我们对应的一个engram的这样一个对象吧，是不是意思，这个时候在外面看的时候，你会发现一件就是比较神奇的事情，看看点类似，这里面有一个东西。

荧光粉是不是等于空对吧，当他执行完这个代码之后，你可以往外面看一下，我看完之后我也没搞明，特别想干啥，来了走走一点都不难，做完之后你发现了它虽然名字叫这样的名字，但是它实际上这个值还是空的吧，我又懵了。

我当时也不知道他为什么要做这样一件事儿，我到现在我也没想明白，对对吧，所以这块想不明白，我们先放一放，先不管它，反正不会影响我们后面的一个整体思路的这块可以先往后整理边。

所以你也别指望说老师把源码全部都看明白，不太不太可能，反正我是做不到，那那那一点你毕竟不是作者，你不知道怎么想的，你只能说根据他写的代码，你去大概去猜，但有些东西能验证出来，有些都验证不出来。

不知道干嘛的，懂我意思对吧，好这样大家要注意了好了，我们接着来看吧，刚刚那个绑定的过程，因为绑定逻辑也非常简单，但是我发现的绑定成功，不知道为什么把原版根据看了，看完之后也没得到一个结论。

这不管它了好吧，再来看第三个是什么东西，做一个基本判断，说its customer environment做了一个基本判断，这个值默认值是false false，你可以点击看一下这个这是force吧。

刚开始就是false false，完了之后这样做一个判断，感叹号是不是取反，就是true了，进去之后再做一个执行，执行之后这个过程也非常简单，干什么事儿叫new一个warm的converter。

是不是做了一个类型，一个转换器，转换完了，这里面有一个方法，这个方法也比较重要，什么叫deduce environment class，也没有见过，后面有没有一种似曾相识的感觉，有吗，来给你看一下啊。

不管他走给这get的，不用管他走，converter，也不管他到哪去了，是不是该第六次就放完了，在这方法里面好也非常一样，是判断一下我们当前这个应用程序的一个类型perate吧，它返回了具体的一个值。

跟我们之前一样，还是service environment，所以判断判断完之后就是这样一个对象创建，是给大家做一个转换，如果必要的话，把它进行一个转换，转换完成之后就行了，好这是我们的对象啊。

这里面做事情就一样，就是说他会判断一下你当前这个环境是什么环境，如果不符合规则的话，会再做一下这个这个事情啊，转成我们的stard is sweb的这样一个环境，做完之后，这是该该到这了，这干嘛的。

是不是还是还是刚刚上放，上面的话一模一样，它里面执行的具体逻辑也是一模一样的，没有任何的一个变化，所以这块你挨个看一下就行了，只是说在转换环境的时候，top里面再做一次验证。

如果里面没有我们对应那个composition properties的话，会往里面再加一次，如果有的话，就不做这个事情了，这事情了，然后最终会把我们这个environment进行一个返回操作。

所以相当于我们这个环境已经准备好了，你准备好了，就这个环境准备其他发现环境里面我们噼里啪啦说了这么多东西，其实最最最最核心的还是啥，我们的配置文件要做一些事情，如何读取配置文件。

如果将来我们的配置文件这些东西啊，记住就行了好吧，制作环境这块环境完了之后再往下看，下面一行叫config，一个not being inform啊，这行代码这样代码也非常非常简单好吧，它其实一点都不难。

其实你如果名字也能够把它给猜出来，它到底完成了一具体的验什么样的一个事情啊，什么样的事情，其实说白了干嘛的啊，干嘛呢，就是说这里面设置了一个系统的一个属性值，用来忽略我们某些的一些病啊，你点进去。

你能发现这样一个值啊，点一下嗯，然后点fc到了之后看到这个什么属性叫spring。being for，点一nore，就是我忽略哪些对应的一个属性值，这会做一个最基本的判断，如果等于空的话，往下走。

是不是这样，后续的这样一个布尔类型值，把这个布尔类型值放哪儿，是不是system。set properties里面，所以这块看完之后，当他把把整体的逻辑执行完了，你在我们当前这个属性里面。

你能看到这样一个值，environment，笑死，找到我们的system enarment system哪去了，找一个source，找一下我们刚刚设置的那个值啊，叫什么，叫spring点也没在这里面。

spring一个闹什么东西，有啊在这是不是叫spring。being for you know，就把当前这个属性给加进来啊，别的东西没做了，所以说只是说我可以读取这样的一个属性值。

来后面做这个并判断的时候做一个这样一个判断啊，是否可以忽略某些病，就这块东西，所以这行代码其实无所谓，其实无所谓，好吧，就是一个系统属性的一个判断值，再来看下面该干嘛了。

叫banner print banner等于print banner什么东西，这是干嘛的，很明显的，大家知道就是用来读取我们对应在哪儿，当我的代码执行到现在之后，你会发现控制台现在几乎什么都没打印。

什么都没打一会儿我们是可以打印一下我们那个spring那个样那个图标了，那个样式的就在这里面进行完成的，所以这里面我们也可以想起来查看一下啊，其实这块儿看不看问题不大，看看问题不大，就好好看看吧。

我们带你带你去过一下，这里面东西比较简单了，点进去你要说prince banner，然后在print banner里面好，你可以做一个判断，说banner model等于啥。

banner model是我们之前进行一个设置的，就是说你创建完spring这个对象之后，我说你们还没有印象，我们这来试试吧，之前我给你们写过这样的东西，就不要创建对象之后。

比如说你一个spring app，set da model，这边有个model，然后model，啧是不是有of有console log，有一种一一堆的值，这是做一个进行判断，所以刚刚第一步骤的时候。

就是用来把这个参数值做了一个小的判断而已，好也没啥啊，你没事的话，默认是什么，默认是不是我们csol的这里面等于他们不等于好，不等于，所以直接就可以划过去了。

那第二步叫做resource loader是什么东西，是不是还是用来加载我们当前这个resource的一个资源，但这只是空的vl。

看这现在是不是有了new了一个什么叫default resource loader吧，还是一样创建这样一个默认资源的加载器里面就是一个对象啊，什么没有，什么都没有，不管它了。

战斗完之后一样的到dj一波了，这波有意思，什么呢，叫spring application banner print，是不是也是构造了这样一个对象，对象里面非常简单，叫gf jpg png这一首首。

我们之前在放我们对应图片的时候，可不是不可以，是我们这样的一个格式好，先往下走，刷完之后再判断下这个模式是啥啊，往下走到这步了，叫banner print，是不是刚创建好对象对象。

什么叫print prince environment in class是什么东西，然后set out进行一个输出，这给你看一下，叫bba等于get banner，是不是还是获取到我们当前这样一个值。

注意了，现在在我们的控台里面依然什么输出都没有，只是为了获取我们班长这样的对象，点进去是一个banner，用完之后判断一下这个get in mage banner是否能读取到我们当前这个图片。

走这个属性是这个图片吗，是不是叫spring banner的，emage叫location，你是不是给这个属性直接属性之后，可以把我们对应的一个图片移动到不同的一个位置，但现在留给人的是什么空的空的。

完了之后往下走，这么判断了吧，再来看这一步干嘛的，叫spring e s t，叫以mage extension是干嘛的啊，是不是还是我们的扩后缀名吧，有gbgm，jpg和png这三种文件格式，慢慢走。

让我来获取这一类词的，没有一类是没有，应该是没有，这边的话是不是都反应反空，也说我们现在并没有自定义我们对应的一个半点图片，来来走，叫test版的，是不是获取一下我们图片没有了，那ok文本就可以了吧。

点进去也一样的，但是是不是这个值叫spring banner，点location一样的一模一样东西，再点它叫default blocation，是不是叫banner。t s t想替换ban的话。

呃之前讲过的东西吧，是放到我们的results作业目录下面就可以了，它会进行直接的一个读取，那读完之后这是什么，是不是也应该是我们具体的一个btc文件，读完之后。

然后呢resource等于get resource是把这个文件给你读进来看一下吧，走走location start with，然后呢往下走，这是微信告诉你他在哪儿好吧，然后读取我们当前这样的一个文件。

把它给读起来，好读起来，做一个ist mel，是不是还是因为现在也没指定了，所以直接返回空了，翻完之后往下走走，都是逻辑盘的，都返回不了，所以还是我们的默认单点，默认搬完之后，到这儿的时候。

开始进行整体的一个打印工作，打印工作怎么打印，注意啊，你看起来是一个图像，但是我希望你注意，实际上它本身看起来就是一个字符串，明白了吗，来看效果，点进去，点完之后是不是有个在哪儿点进去，你看这东西了吗。

啥，字符串吧，字符串啊，是不是后面是不是也都是字符串，是不是全部串，你现在看起来好像是乱的，但是你把它的格式排列好之后，它就是一个正常的一个半点一个图片，所以此时干嘛了。

该循环我们当前这样一个在哪好循环一下，再往外面走走，第一行空了吧，第二行看第一行吧，再循环是不是出来这一部分了，再循环再循环再循环，看这发信息了吗，我是不是经过n次的一个循环之后。

我就把这个图片给打印出来了，是不是打印出来了，说了啊，他本身就是字符串嘛，你看见之后就打印出来了，其实并不难，也没啥难，就打印这样的东西，打印完之后反应回来。

这样获取一个姊妹book的一个version，告诉你这version多少点，release version等于它如果不等于空的话，做一个转换，为什么东西做一个格式格式化转换，转换完成之后。

又一让他往里面进行循环，添加这个空格加空格，最好看那是冒号three bot冒号，然后后面加一个这样的空格，空完之后是括号v2。2。2的意思，翻盘输出吧，输完之后回车快走，是不是返回了。

此时这个反应的是他打印出来了是吧，定义的肯定可以啊，自定义的你可以放一个图片嘛，对不对，是不是也可以放一个天启文档，之前我在第一节课的时候讲自boss的时候，是不是就放了一个半点t s d。

作者为什么给一个班长设置都设置这么多逻辑扩展性，扩展性，你发现了，刚刚里面虽然看起来好像很复杂的样子，但其实都在干嘛读，有没有图片的配置好不好，有没有你自定化的一个配置对吧，如果都没有的话。

我只能用默认配置了，默认配置就是字符串，没别的了，扩展性好一点，就是你自己可以定制自己画自己的一些东西，仅此而已，没啥难的啊，听一下墙也不是特别关键，行吧啊，这个不是bt男同学来扣个一，比较简单吧。

彩蛋没啥彩蛋啊，就非常low的一种实验方式而已，好一点就是他考虑到各种各样的情况，你可以往里面放图片，也可以往里面放一个传统文档啊，放什么都行，所以这东西你往这边点点试试，你会发现它并不难。

得看野马都不露脸，都很好，你看完之后，你觉得实现没没没没没没没多大那个那个意义好吧，搞个小电影儿想多了吧，这样搞完之后，这样搞完之后感悟说放什么图片都可以吗。

放图片必须是什么jb j j f p n g吧，他一那你知道这是干啥啊，干啥没意义好吧对，跟面试官想搬，那将来能干啥，没人用，没啥用，没啥用处啊，对了，我往下看，这块下面东西比重要了好吧。

这个东西是我们今天要讲的一个最核心的一个点，最核心的一个点就是我们的application contest，刚刚准备的是什么叫environment，对不对，是环境，环境完了之后还要干嘛。

还是它应该有一个上下文的一个对象，之前我们上面其实见过了，有个叫convictable application contest，是不是这样一个类，但这类是空的这个值。

而现在相当于干嘛给这个空的值附上我们具体的一个对象，给他一个给给给他一个对象，对对象怎么做的，叫可以的，obcompass，手往后站，这步骤很关键，很核心很核心，然后来看过干了一件什么事情。

这里面它也有各种各样不同的类型，所以点的时候给你看一下这是干嘛的，你看这东西之后是不是有点似曾相识的感觉，我在讲那个spring application这个构造方法的时候，我说了。

永远不要小看这个应用程序的类型，因为后面在很多地方是不是都用到我们的应用程序类型，第一个我们的对象创建的时候是不是判根据类型来判断的，第二个你的contest也是根据文应用程序类型来判断的。

就这个值一定要注意了，好吧，聊聊第一个会制造值应该是空的，因为我们没做过赋值嘛，空的话没关系，这有一个switch的一个判断判断了，如果是的话，匹配到第一个，第一个值好像是某一个类。

哪个类叫annotation confide呃，config server类的web server，application contest名字非常长，所长，为什么零之一嘛是吧，名字写的非常长。

大家知道它读取的是这样一个类，然后他通过什么，通过我们对应的一个class for name干嘛的，是不是把它变一个大写的a class的对象，但对象完了之后，最后面还有一个是什么步骤来走一下，大家好。

是不是叫b有tos。iso什么class吧，是进行一个初始化的一个呃，不是进行实例化的一个工作，刚刚只是一个卡组对象，现在要完成一个对象创建了，把整理下这过程，所以你往这边点的话，这个不点了。

点完之后就是一个实例化工作，这有一个什么来着，找下一个注解的一些东西，看着return一个昵称class class，加什么东西会叫做造器，然后往里边点的话，一定有一个什么叫拉啊，拿去吧。

呃就反正就是通过反射来进行一个正常的，接下来自己看吧，找不到了，反正就是通过反射来，你看到了是吧，有有有意思吗，啊啊，这是不是这个一次分子是不是这就进行一个是对象创建了啊，就这样过啊，所以这块都不难。

也没必要往里面看看，很深的东西，知道就行了，那直接完之后往回返回，此时看了吗，对象有了，但是你打开当前这个对象之后，你会发现打开我们的这个当前contest里面哪去了，这里面空了吧，是不是做空的。

有些对象有些对象好吧，那大部分值是不是都是空的，是做空的一些值之后，是不是该往我们这个context上下文对象里面放一堆东西了，是放一堆东西，所以放东西这就会成为我们的一个重点，当然除此之外。

这中间夹了一个步骤，叫什么叫exception reporter，这个reporter还记得吗，原来是因为这块不难。

就创建对象了，就有个对象不能看这个地方，我们之前不也穿过这对象了，干嘛的，是在启动过程中如果报异常了，这会有一个异常的一个缩进器，同样的你看完代码之后。

就get spring fetory instance，一看到这个方法很明显干嘛的，是不是还是我们的spring fast文件里面来进行数据的读取。

这类spring boat exception reporter往上翻，spring boeing reporter吧，好吧，说这个东西后面还有吗，是不是意味着我就读到了当前这样的一个类。

并且把它进行实例化，哪一类叫failure and letter，就这样对象啊这样的一个对象。

所以你读完之后，我们可以看一下这个集合里面的一个值，不往里面看了，打开我们的reorder，failure la，这个对象是不是就有他给他，这就够了啊，之后其中一条报错的时候，这里面都会给它放进去。

都会放进去啊，别忘啥了呀，暂时这块还没用到，还没用到这些东西不往后面看吧，这是抛一场六，这会这才会有不抛异常的话，这没用，这没用啊，来再往下看该干嘛了，我说了。

刚刚只是创建到我们的创test这样一个对象，但对象里面很多属性值还没付呢，所以这段时间最主要的就是往里面进行一些最基本的赋值操作啊，复制操作。

这副装作可能看起来稍微有一点点麻烦，有点麻烦啊，但是呃怎么说呢。

看多了就知道咋回事了，这东西啊也不是特别难，但是在讲这个操作之前，我希望大家先看一些东西，什么东西呢，就是这些类它们之间的关系，我们都知道，你如果就是之前详细聊，结果spring源码的话。

其实你看spring boot会比较容易一点，如果你这目前是什么源码，一点都没看过的话，你看这个课程确实比较麻烦，它里面其实很多地方都用到了我们spring一些东西啊，这是肯定的懂我意思吧好吧。

所以这样大家一定要一定一定要注意了，一定要注意了，然后呢往上看contest吧，好吧，点进去这类里面还记得刚刚16号，16号那个类是哪个哪个类。

啊就是我给大家点一下看看annotation config，我们先把它打开吧，财神诶没有吗，tt不可能没有吧，是不是这一类好吧，你一定记住我们当时剩下的环境就是这样一类，它里面是有多方法好多个方法啊。

各方这块儿我们先你先停到这儿，先停到这块儿，先停到这块，这块看完之后，这块看完之后，这里面两对象很重要，一个是render，一个是scout，之后我们都会用两个对象，好象就是说你现在要往里面放东西了。

放对象的时候，首先要创建好战略对象，对不对，这东西大家应该没有疑问的，但没疑问之后，我希望大家你可以打开当前这个类，看一下这个类的一个类图啊，或者它这个继承关系的一个图，这个图很重要。

我为什么上课的时候带你们看这个东西，因为你发现你后面在找某些属性值的时候。

你找不到，其实是在是在父类里面，它帮你完成了整体的一个赋值，或者说初始化的一个工作，初始化工作，所以这玩意看起来可能会稍微有那么一丢丢的一个难受，难受也要接着看，你要接着看，大家看这里面类比较多。

你要把每一个类都看完之后，你就疯了，但有一些类你们应该知道的，比如说这东西叫冰山水，知道吧，对不对，是最中间一类，但你看什么，看绿色这个是看蓝色这个线，看蓝色这个线好，开始我们看是什么。

最底下的东西上面有什么呢，叫server web，server application contest，还有个叫，然后呢，web application contest。

那真的是obliation contest，abstract obligation test，它是不是有这样默认的一层继承关系了，我希望大家注意一件事儿，什么事儿呢。

呃spring时候你们是不是看过这个东西，你看过的东西吗，看过来扣一，没看过来扣二，哼看过就好了啊，看一定要去看啊，没改，你看一定要去看，那这块我就简单来说一下，简单说一下做什么事情，做什么事情。

你看到蓝色这条线了，蓝色这条线表示它整体的一个继承路线的关系，这些对你不要觉得无所谓，你看起来好像我只出了这样一个对象就完事了，不对，你也父子之间的一个继承关系，因为在这些继承关系里面。

它依然有很多非常重要的属性会帮你进行加载，比如第一个叫resource loader，这里面干嘛呢干嘛呢，是不是为了获取我们默认的一个类加载的一个器对吧，获取一下上下文类加载器。

这第一个方法要怎么上这个事情，第二个叫什么呢，叫abstract object contest，名称范，这叫什么，叫抽象的一个应用上下文，这是我们翻一个东西吧，但其实但其实你注意了，这里面用很多东西。

或或者说有很多东西，比如说有个叫resource，pattern reserver，有人知道吗，给大家敲一下呃，resource，然后呢reserver，这东西有人知道吗。

模式一个解析器是资源模式解析器啊，没听过算了，没听过就先留个印象好吧，就这里面它会完成很多事情，还有很多事情就说为什么你在配置加载一些配置文件的时候，是通过什么呢，叫class pass。

通过阿斯pass这个路径写完之后，冒号后面可以直接跟我们的文件名称，他也能读取到，原先在这个地方它会完成很多这方面的一些工作，把这连完成的好吧，而且在这个通用的上下文对象里面，把这个类里面除此之外。

什么东西我们可以来看一下这个呃，咋说呢，看看这一类吧，这么多，详细看一下。

我们找一下这个继承关系啊，s，这里面有一个非常非常重要的一个对象，好吧，叫being f，叫default，并单这东西，default lizable ban factory之后。

我们在很多地方都会看到这样的一个属性值，这样属性值大家看到了，这是创建的对象，是不是在我们父类的构造方法里面定义好吧，不是啊，是在缝里面做好的，所以你点开这个对象，你看一下当前对象。

这个类图也一样的，看例图流程里面也依然表明了一个继承的一个关系，这继承关系啊，这其实在你们应该会接触到的第一个default是最底层的。

上面有什么叫abstract auto where comparable being factory，abstract being factory，factory being reject，然后呢。

default singleton being registry，然后rest register，是不是看到很多这样的人类的关系，它里面有一个集中关系。

你在new的时候依然会一层一层一层一层往里面进行创建，其实这些类的名称我们大概能做一个最基本的一个猜测，是不是第一叫simple alex，什么东西是啥简单别名儿吧。

你想想你做错弊的时候有没有写写别名儿，可以吧，这边注册边边边注射器对吧，那大家看这是什么东西，叫singleton being reject reject，什么叫单例bean的一个注册器吧，是不是意思。

下面来看还有什么叫factory being register，your support是工厂并注册了一个什么是注册一个的方法，提供这样的一个支持，对不对。

再来看abstract being factory，抽象工厂类就不用说了吧，为什么呢，呃abstract auto wear comparable being factory。

是不是抽象的有自动装配功能的一个兵工厂，是不是自动装配的一个功能了，是不是这块东西，再往下最后一个才是我们这个默认的一个最基本的实现对吧，所以刚刚就是为什么很多同学在看源码的时候看不懂。

其实更多的还是因为这个点就是你在new一个对象的时候，你看到源码里面也有很多对象，但是很少有人去说我一层一层往上看一下它里面到底办成什么事儿啊，把这些事情的脉络如果都捋的非常非常清楚了。

你再看这块的时候，其实就觉得哦原来这么回事啊，原来并没有那么难，如果你前新的一个基础建设没有的话，你后面看的时候肯定会越来越难，越来越麻烦啊，这点我希望大家能认能认认同把这块要注意，一定要注意了。

曲线实现蓝色线是什么意思，这类图里面表示去具体的一个继承关系了，大家看一下这个来自什么，是我们具体的一个class之间继承关系，好吧，这儿应该有一个徒弟来找我，我找一下啊，这没有是吧，就去图例啊。

就这块呢其实表示就是一个继承和实现的一个呃，就就就你看到啊，这是不是有c有i i表示是我们的接口啊，i表示我们接口，然后呢c表示我们的类类跟类之间的寄生关系，用蓝色来表示的。

把接口之间的实践大家看看是不是用绿色线表示的，就这样的关系哇，这这这没啥，这没啥，就啥好看的吗啊就是实现实现是类虚线，虚线是接口，接口都是虚线，就这东西啊，没看过这东西是吗，没下一周一定要详细看一下。

这块一定要看呃，所以啊大家发现了呃，如果你要看一些比较sploud这样源码的时候，最常看的时候，其实他们都是依托于spring的，还能把spring源码好好听一下，好好看一下，真的很重要。

这东西难或听不懂，我就不听了呃硬着头皮咬着牙一定要去看，因为你看完这东西之后，你再回来听的时候感觉容易一点，或者说最起码有那么点感觉，能印象有点印象，如果都没有的话，你就看起来很麻烦，实现是啥。

一个是表示继承，一个是表示是我们的一个实现接口的，要继承接口，接口是不能实现接口，能不能继承接口也可以吧，就这样的是继承的关系，它表示是实践的关系，就接口之间的一个继承，你接是不是可以用extends。

是不是也可以用那个imp，好了好了，这没关系啊，不知道说这个这个没必要看嗯，呃看一遍之后你知道你记住就行了，这没啥好吧，这个没啥可学的，懂我意思吧，下来思考的话什么的，spring啊，最好就看一下。

最好去看一下，一定要看啊，看完之后你你的感受是不一样的，整体的一个架构都是不一样的，懂我意思吧，好吧不看了再也不看了。

不看了不看了就有种过，再回反反啊啊看看这个这个类类类类出了是吧。

看到这块之后，看到这块之后，下面是什么呢，叫generate web application，然后呢那个application是不是到这块了，这块也是一样的，这是通用的，什么叫通用的应用程序。

上下文叫通用的web应用程序，上下文也是一样，提供了一个外方面的一个支持，贷方面的一个支持，仅此而已是吧，下面还有什么叫呃server web，server application contest吧。

这里面是啥叫server web应用程序的一个上下文啊，server程序上文仅此而已，那下面最下面是什么，是我们具体子类是annotation里面的一个东西啊。

tation里面的东西按类是我们自己是不是上下行的市场分对象啊，你知道这样提升关系，因为之后你会看到很多being reje并finantory这样的东西，你如果这块东西不了解的话，你听起来很懵。

这东西我也没他给你做一个就非常简短的一个解释，说我一句话把它说明白，说明白听吧，下去之后好好看一下，最好好好看一下是吧，呃看完之后你会有一个整体的感知的，很重要，行吧好了，别的东西废话我就不多说了。

不多说了，来回来再看看什么东西，还是看到我们刚刚的安装tation这个类啊，这类还是要看的。

来看这类这个类，刚刚我们是在完成一个是那个实例化，当实例化我是直接跳过去了，但其实你会发现在整个实例化的一个环节，它又两个对象，一个叫this。reader，一个叫this。scanner。

这块东西不懂没关系，你往下看，他说创建了一个新的这个东西，然后需要干嘛呢，叫popular through cause，and then呃，什么reflesh，这干嘛要被进行调用吊起。

并且呢需要被进行reflesh，是不是进行一个刷新操作，那这个this reader是干嘛的，好吧，上面看有没有解释啊，找一下没解释啊，为什么是不是读取scar，是不是进行一个扫描对吧，用于干嘛呢。

用于完成我们对于一些病的一些注册功能，病的一些注册功能，比如说我们之前在那个还是说你们经常用一些，比如说像卡罗德斯干啊，像component，然后呢像service对吧，还有那个呃respon一个东西。

你在进行并实例的时候，其实都是通过我们当前这个read对象来完成的啊，都通过对象来完成的，scanner其实它也比较简单好吧，它就是定义的一个扫描器，用来扫描我们这个地方。

它符合我们对应规则的一些并对象，因为你只有扫我们通过之后，才能把我们b注册到我们对应的一个上下文环境里面，此时在后面用的时候，你才能够完成对应的一个调取的功能，如果没有这样操作，你是掉不了的。

懂我意思吧，好吧就这样，大家要注意了o那我们再接着往下看呃，在对象里面创建的时候也非常简单，就是一个早点去一个操作吧，在操作里面我还是希望大家注意一个注意一个东西稍微注意一下啊，你稍微留个印象也行啊。

哪怕留个印象有这样的东西，他也没有留意过这干嘛的啊，这个东西吗，叫condition v6 条是干嘛的，这这这这东西干啥的，什么叫肯定是，条件我们后面再进行自动装配的时候。

自动装配的时候你会看到有很多的一个限制条件，比如说举一个例子，我们来看，别累啊，看了你就知道了点，我这没有是吧，应该有条件来着，叫小web，at肯定是看那有什么叫conditional。

然后呢呃十on web plication，conditional on class，然后呢conditional on missing becditional order，哦。

上面这四个是不是conneon on web pication，on class on miss bean，是不是这东西看错了啊啊好吧，然后呢on class on miss me。

这都是我们这些条件的一个判断，好你不明白没关系，不过没关系，到后面的时候会在呃那个自动装配的时候会讲，这个东西其实就是一个条件的一个判断啊，看错了也有点晕，刚翻过来。

里面会注册这样一个条件的一个判断一个器啊，这回大家写了。

给大家找一下装配的运行原理吧，很多笔记啊，为了方便你们所理解，还没在这儿，他大概有这么多扩展一些属性，就是说我必须要满足什么样一个条件才能进行一个生效，就这块东西啊，这块的东西明白了吧。

这东西啊咱们后面聊，到时候再再讲，先不管他，你现在有这样一个印象，就是这里面会加一些条件判断的一个计算器啊。

有些东西呃我们能做很多的一些条件上的判断了，这时候是比较舒服的，你懂我意思了吧，啊这款稍微注意下就行了，稍微注意下就行了好了，这是我们就这样一个render，一个对象，又有render对象，回来回来。

除了这个润到这还有个什么，还有一个scanner吧，点下scanner，点进去点进去，你这个就是非常简单吧，做什么事儿叫呃呃先注册这个注册器。

做新完了之后叫reject before the filter，是获取我们默认的一些过滤器，来获取我们的环境，获取我们对你一个资源型的加载器，我说了，他完成一个什么，再说了吧。

是不是component repository service controler是不会检测这方面的一些注解，有了这些注解之后，我会把你扫描进来，如果没有这些注解的话，我就不给你扫描了啊，整体上来说。

这个上下文环境是非常非常重要的一个对象，好吧，这块儿先留一个印象，因为后面的时候我们大概会用到它，你先留印象，有了印象之后，我们后面会讲的时候，我们再详细说这东西行吧，好这东西啊。

我们这儿就不再浪费时间了，再浪费时间了啊，重点来我们再见吧，再再再再往下看，再看什么东西啊，刚刚只是我们当前这个上下文环境的一个准备，除了这个上下的话天之外，还有什么东西来着。

是不是还要往里边添加一些对应的一个参数了，那么会反到哪了，ok到这，好吧，还知道还知道我我在我我在说啥吧，map爆红跟这个有关吗，啊没关系，那爆红是因为你没有引入map的一个依赖。

有没有引入map的一个注解，引了注解之后就不会爆红了，刚才上面写了只有四个注解或者散文，那四个注解里面它是否会做一个并对象，把它给呃自动呃，那个什么角度外进来，凹凸外进来啊，好了。

这是我们这样一个contest的一个对象的一个解释，好好看看很重要，这步骤完成之后讲到这儿了，叫prepare contest是吧，这步骤这步骤很关键啊，很关键啊，这才是我们整体完成的一个核心。

来我们看一下完成到底它里面到底做了一件什么样的一个事情啊，什么事情呃，其实事情怎么说呢，难道并不难难并不难，关键是你要知道好吧，来走一下吧，第一个叫contest s vironment，干嘛的是吧。

那contest里面设置我们对应一个当当前对象，一个环境给您看一下，走突破点，set environment，是把环境对象给设进来，这是第一个，第二个叫z。render。set environment。

第二叫点scanner，scenvironment，是不是除了给我们当前这个对象做一个最基本的设置之外，还要往哪把我们reader属性里面设一个，把我们的skt属性里面再设一个，是不是要设很多东西对吧。

私信问问的，一定要把它给设计来，把这块很重要，因为后面会用到我们那个环境里面的一些属性值，一些自己具体操作，所以这往下走就行了，都往这边看了，a一啊，就是一个设设置一个属性看一下吧。

是不是就往里边外面的时候加进来就行了，用了几个新的对象就出来一个操作，不管他了之后，第三位叫什么呢，叫post post process obligation contest，就看这东西了吧。

这东西难吗，并不难好吧，一起来看一下往里边到底做了什么样的一个事情，走这儿先做一个叫big name generator的一个判断，是什么东西，名称的一个生成器，对不对，这个值刚开始是什么，因为你没。

所以刚开始的话一定是等于空的吧，第二个呢叫瑞等于空吗，等于空，往下走到第三步，this is的conversion service，这熟不熟，熟之前已经见过他了，是不是见过他了。

还是一样来用来添加我们很多这方面的转化了，它所对应的一些服务，这不往里面看了，之前我们带你们带带你们看过了，那走走走，做完之后完成了，关键是你要看一下这个这个方法好吧。

叫apply in the nether，这干嘛呢，叫用我们的初始化的一些呃初始化器，对不对，你想一下刚开始我们在创建对象的时候，我有没有往里面读取我们一些触发器，有吧，还记得有多少个吗，记不记得。

啊这个in factory里面对七个好吧，那记得很清楚啊，对就是七个，进行税务工作了，这个处理工作记录了非常非常关键，而且非常非常重要啊，同学同学一直在聊老师后面那个自动装备怎么聊，面试官同学怎么答。

其实就用到了这里面的某些点，某些点来看一下吧，我这点啊点进去连线之后，这是不是一共有七个拿走，我们看一下这个这个集合，能看集合吗，啊看不懂没关系啊，这get的英雄来点哦，我点点一下这方法试试啊。

走点进去，这这这这没有是吧，热点你是来的，看这是不是有七个七个，就我们从那个类文件里面直接带过来的这些呃，初始化器已经输入进来了，这边一共有七个，第一个叫什么叫培根认刚才的一生来着，之前做什么事。

不知道啊，不知道没关系，你可以接着往下看，中间一个class对象，然后呢也是一个application context letter class，这边往下走到这一步，这一步是最核心的啊。

最核心的看的是完成我们这样的一个初始化功能，走完了点一下试试啊，看一下第一个叫get environment，是涉及我们当前这个环境变量，往边走走，不等于空，看这儿大家懂是不是进不来进不来。

这里面不是相当于什么事都没做，只是获取了让我们当前一个对象，所以这个方法什么都没做来做，第二个叫shared meat date reader。

然后呢叫factory contest issulator，这个方法很重要很重要，这里面其他东西什么叫mac data，就是我们的原数据，这里面往里面放一个metadata。

catch metadata的一个post processor，一个类往下面看一下吧，还有一样你就在这里面点进去，就说到这吧，叫at bean factory post processor。

你有了一个什么就想叫catching，my data reer，factory post processor，很重要，好吧，你记住了，他是不是完全放这个类似于一个对象点样，可能构造方法什么没有。

还是一样，在父类里面，我们这不往里面看了，然后点完之后往下走走，诶，慢慢走，叫this being factory propost processor，加at是把刚才的方法给加进来，加完之后也一样。

这是一个对象添加集合，加完之后你可以看一下，找一下我们对这东西啊，我不是给你contest，很重要呃，找一下叫bin factory，叫post processor，找一下。

post processor，你成功，你怎么看到你，嗯，这是看到了，我先生，是这样吗，病人post processor，没有呢，我没看错吧，in fe，泡泡or这个没有了，应该应该有一个对象啊，拿走吧。

不管他了，contest，这有了吧，看这是不是经进来了，看错地方了，看错地方了，看错地方了，大家看这里面加了什么呢，是不是叫catch metadata，reer，factory。

post processor，之后要用它，我这强调一下，把这家店的对象别东西没做拿走，第三个叫contest，idea of lication，什么东西依然往里面走。

编译之后get contest的id啊，这个contest的id是什么东西，还记得吗，那个contest慢慢走，或者一个地址地址就是谁叫compass的id，然后呢in出来的是我们刚才进行那个初始化。

那个初始化器往输查器拿走，也是往里面进行设置，设置完了之后注册一个单例的一个对象啊，注册单对象做完之后就搞定了啊，这个东西不用管它，再来看第三个叫confi warning是什么东西，这一类也很重要。

往下走，走到这儿点进去，是不是又加了个对象，叫configuration warning，post post processor，是不是相当于另外东西也是往里面加另外一个对象。

将完之后返回再来看第三个叫r socket port，什么东西拿走，是加上一个新的listener啊，这是我们往里面需要添加的东西，大家注意了，他是往我们那个呃pos加吗，不是啊。

这是往哪儿往我们的application listener里面加啊，加对象不一样的啊，加地址不一样的，那走走，第四个叫server port infer，什么东西好吧，咱们走向下走，啥东西判断不等于空。

and listener是把这listener给加进来好吧，把这listen listener站起来，加完之后就搞定了，叫the report in for。

然后呢a contest in the letter，再站起来，加完之后再往上翻翻吧，还有吧叫是呢，是不是也是条件的一个最基本判断，一次也是一样，每次都掉一个初始化方法，然后完了之后。

我们对应的一些初始化功能，是不是也是往这里面注册一个类似的东西之后啊，我们都是要用的啊，都是要用的啊，好那么走没了吧，是不是这七个初始化器在这个地方几乎都经完成了，完成好之后往这看看，先进行。

属于这里面有两个类啊。

有两个具体类，这两类后面会用到，除此之外还有什么呢，还有个东西叫listeners，找一下，那我们小雷智能有are 什么东西，server port inf定是拿什么东西。

反正对象记住后面我们要用的时候，你要知道啊，原来在这儿进行了一个最基本的赋值操作，在这完成了好，玩完之后，我来往返再看一下高那个初始化就完成了吧，所以那些初始化器在这些步骤里面。

要不然我注册成一个类似的了，要不然我注册成一个什么叫post processor还是pos pos也行，他就说白了最终都是为了给我们后面的一些操作做准备工作的，现在你还不知道什么，没关系，我再给你强调。

到了强化之后，你先把它留下来，等我后面看的时候，你要知道是干嘛用的就行了好吧，看完之后听懂同学来扣，我一听蒙了吧，好，问题之后没再往下看，看到这行代码，你看到这行之后是不是又会变得非常非常熟悉啊。

是不是是叫类似呢，点contest prepared，就看这句话了吧，那一样啊，要完成我们相应的一些具体功能了吧，外面走连续连续，这时候又该循环类似的listen呢，注意了，永远只有一个，往下走。

点进去，点进去之后是不是叫new一个叫application contest，new sualize environment，来到目前为告诉我，你现在见到几个疑问了，几个问，第一个叫什么。

obligation，starting event，第二，prepared什么event吧，是不是三个，这是第三个叫obligation contest，usual letter event，咋想起。

不管是多少个疑问的，最终它所对应的一个处理的一个环节，或者说处理的一个流程一样不一样一样的，是不是一模一样，他几乎注意了没有完，几乎没有一些任何多余的一个操作，任何多余的操作。

所以这样大家一定要注意了啊，一定要注意了好了，这个题之后，我们下面来接着往下看，看这块来干嘛的呢，慢慢走吧，点一下试试吧，走创建这样对象，不管他走那边去点点进去呃，大家知道又该进行处理了吧。

还是一样判断一下它是否格式是一样的，是不是判断判断一下它是否呃哪些监听器符合我们的规则，感觉看一下吧，点下去知道来走走走走走走，大家看一下这个代码处理逻辑啊，都是一模一样，没有任何变化。

同一套代码把同样代码把y哥进行遍历，哪个复合条件不符合条件，就这样吧，结束了吧，所以这第一个叫什么叫background，然后呢点进去往下走走走，执行执行判断判断是不是什么什么都没做一样，什么都没做完。

再来看第二个走叫digation，什么什么东西来走，点进去，第二个也是依然什么都没做啊，你还是一样进行a x的一个循环就可以了啊，压制完之后往下走，大家发现了，一共有两个监听器留下。

那这样监听器几乎好像什么都没做，是什么都没做，什么没做什么，这么做，不管它好，不管它，然后接着往下进行便利走啊，早结束了吧，把接收完之后，这准备工作就算是完成了，所以大家看到了。

当我完成这个最基本的准备工作之后，相当于什么是不是跟什么都没做一样啊，其实它对应的就是一个最基本的空时线啊，虽然里面留下两个监听器，带两个电器依然手都没做啊，你不用管它了。

懂我意思吧啊这这一块的一个基本操作照，做完之后来再往下看，get到这块儿了，叫什么呢，叫this点，log start up in for，它是什么，它是一个最基本的属性值，叫什么。

触网是不是处的值出来之后，这一定是能进来的，一定进来，当你这进来之后叫log start in for什么东西，log that profile inf什么东西，你看方法也没有点熟悉的感觉。

你之前在启动我们当前这个spring程序的时候，到这一步没拿，是不是里面还要打印多余的几行的一个日志，而那些日志信息的一个打印就是在这完成的啊，对同位置就这东西，所以我们可以怎么样呢，往里面看一下。

第一个叫lost stin for，看里面做什么事儿啊，走这配上他不管他点去啊，他说判断是不是root是吧，然后点进去，这是不是你有一个叫set up in flog这样的对象。

然后log点击对象创建对象，不管好了，是这个对象创建啊，再往下走，叫harder走走走，get application log吧，走走再点看那obligation。log。

in for message是什么呢，叫this。get starting message吧，怎么get ssage，往上看，spring builder message等于什么东西。

然后呢message append starting说application message name等于啥，然后呢append version等于什么东西，append on。

append pad什么东西，append contact是什么东西，return一个message message，是不是，所以当你把这个代码执行完成之后，看着输出了吗。

是不是叫starting什么spring boot，spring bot dation on root with p i d等于谁这个目录在哪，然后start by root，然后in哪个目录。

是不是刚刚我们这些相关信息啊，这是不是直接进行输出了啊，这就是我们启动日志完了之后，第二个叫application。log，点debug loc of o什么get running message。

点进去是不是叫running start a spring boot，那加上一个mac class，一个类名称，加上一个碰到一个spring，然后面加一个mec也一样，直接把它返回吧，我们这直接运行了。

走看啊，没输出吧，为什么没输出啊，没说原因是这是什么级别，第八呃，是不是第八个级别，不是我们log级别啊，这不是我们一份级别，所以这没这没有进行输出吧，唉这应该输出吧，没输出啊。

of new一个什么的设置，默认info是吧，不管他了，没说没输入法不行，必向大局啊，这第一个是不是你说我启动一些信息，告诉我什么时候启动的对吧，这块信息打印再看第二个什么呢。

叫log start up profit for，是告诉你说我是哪个profile的一个文件，连续大家都走，这是我们的logo对象，别管他往哪走，spring acid profile，contest。

get environment，get in profile，这个地方我没有指定吗，没有吧，没有的话，这有一个是不是一个空的一个值，大家走，is empty吧，做什么事，然后log in for。

大家走走看，那什么东西叫no active profile，set for a back to default，profile default是不是使用就是我们默认的一个日，这是打印，是不是情况了。

往下走走，这不就完了，就是一个启动日志信息的一个打印工作，所以这块大家应该能看懂不难吧，所以你看到了它每一步骤每一步骤都分解开的话，它并不难，没步骤完成，这事情就是我们眼界所能看到的东西，明白了吧。

好来段目前为止能看懂同学对吧，扣个一还能看懂吗，如果没问题之后下面的东西就比较复杂了，我们五分钟讲完了好吧，大家说一下，你其实大家可以看一下，叫艾伯特specific single和bs，干完了。

你看他内行的一个注释，你来告诉我他完成了一件什么样的一个事情是吧，叫a boat specific singleton beans，是不是天boss里面指定的那些单利的b是不是意思，这边都是非常简单啊。

首先获取我们的b factory，然后呢注册一下我们当前这个sletter吧，谁是我们的spring application arguments，是不是我们当前在初始化的时候设置的那个参数的一个对象。

把那个参数对象给你加进来啊，这就注册了这样一个面对象，懂我意思吧，就是这样的这样这样这样的东西做完之后打印我们的fbanner，对不对，然后告诉你说变对象属于哪个面对象，然后呢允许怎样进行一个设置。

是否是懒加载的对吧，后面再来进行一些相关设置，然后类似的什么东西，然后呢old lol什么东西，这东西啊，我们晚上就会再讲好，现在不讲了，那讲不完了啊，记住到哪了，答对不知道吧，我们晚上再接着往下看。

打打个点好吧，你想刚刚我们所看到完成的一个具体的一个过程，我们今天要讲讲讲讲啥啊，想接下来再加上什么东西啊，来找一下找放方法，找绕绕方法，在当前这个弱方案里面，弱方案里面。

首先我们讲一下这个环境的一个基本配置对吧，是不是讲一下这个环境配置是吧，这个环境做哪些事情，做哪些准备工作，然后呢忽略哪些，然后我们ban怎么打印的，创建了我们的contest这样一个对象。

对象里面我们又往里面做什么事，说就这步完成的，其实这些东西啊，呃说难吧，也不是特别难，也不是特别难，但关键在哪儿，其实看方法里面你留个e，今天晚上我们重点会看里面的一个变的东西啊。

不是这这个漏的这个东西，就记住了个banner哈哈，但是大家比较简单是吧，啊唉呀那个整体的流程给记住了，这个漏的方法，我希望大家下去之后能自己先看一下漏的方法，非常非常重要的方法。

非常重要好非常非常重要，因为我们之后用到一些核心操作，其实都是在这个漏洞方案里面完成的，都放里完成的，这东西我们晚上再聊，其实啊呃源代码看到现在我不知道有种感觉，很多类可能不知道是干嘛的是吧。

但是大致的流程我是能梳理出来的，我能说出来的同时你会发现了里面重复的代码多不多，很多吧，比如说从spring spring property的那个spring f文件里面读取文件对吧。

再比如说像刚刚那个监听器那一块东西一模一样吧，只不过说我的世界换了一下而已，其他东西都一模一样，所以我只能在那里面定义不同的方法，但我不同的事件就搞定了，就这意思。

所以啊你们也不要把原本想说老师这东西是不是特别复杂或怎么样，没必要是吧，他们都指着火慢慢往下看，哪个地方看不懂，先跳过去，只要不影响你整体的一个布局就完事了啊，这块大家能够注意到啊，呃今天晚上吧。

我今天晚上尽量把这个早市写出来了，别吹牛逼好吧，别吹牛，别吹牛逼啊，这个早10年你写写不出来啊，你要我想你要想实现出来，这个太太麻烦了，所以我说我不讲好吧，呃你们现在玩一会儿之后。

把今天刚讲东西好好消化一下，然后晚上的时候我们再接着讲，我尽量在今天晚上的时间，我们把这个呃这个这个启动这个过程说完，启动过程说完，人家说完的话其实很麻烦，因为我后面要讲的东西还是比较多的。

我还想讲一下自动装配，还想讲一下start，对你有帮助吗，感觉有帮助，同学扣个一，呃不是慢慢讲的事儿，嗯啊还是一样，我在讲课的时候，我就想带你们一步步去看，呃按照顺序去看，原因非常简单，懂我意思吧。

呃这东西啊迟早慢慢看，还等等，你怎么看呢，我真想讲他们看的，我看到你们这这个这个这个这个这个东西，我觉得讲他们看你们不一定能看到，他们看不能容一点，能容一点，加课加课，你不加了啊，呃还是一样。

我把我计划东西讲完，这个没讲的东西，到后期的话呃，我们再更新，我们在更新讲讲太多，我们也讲两节课，今天晚上三节课，如果再讲三节课，我就懵了，你们就疯了，所以咱慢慢讲，我希望你能把整个流程给捋清楚了好吧。

大家可能要等到等到年后了，年前就就没有了，研发完了是什么，原版玩的是网约车，网约车项目，我啊计划不算，今天的课还有2~3节，就我说的东西，第一把启动过程讲完，第二把自动装配讲完。

第三再讲一下这个start，就是你你看那个starter的东西，就是我们配的时候，你们都都都打吧，这个三怎么用的，如何自定义的ar这个原理应该怎么写，这原理底层源码怎么走的，讲了三个点。

这三个点讲完之后，就就别的东西不聊了，当然除了这点，这边还有什么，比如说像呃环境东西好吧，自定义的一些东西其实很很麻烦是吧好吧，我还一样能面，最主要是什么，能在面试中帮到你们，课过年讲不讲课。

听老马看老马的安排，不知道老马在网上讲行吧，好了废话不多说呃，利用这里三个小时间尽快消化一下，然后呢，我们晚上八点准时再见，好。

系列 3：P65：【Spring】Springboot启动源码解析三 - 马士兵_马小雨 - BV1zh411H79h

我也见过空心一点点，是真的自己把空心的歌，那曾经有短暂停留，后来飘走的云，黑夜我丢了，我丢风和日丽，春暖花季，但却万里无云，就当我把我的人写感情都给你搬走了，夜里我不解风情，并记住你的给你。

开始让我变得狰狞，也开始变得曾经变成风吹风吹风景呀，要喜洋洋决定把爱变死不休，你能不能慢点走，家乡最难的没得多余的钟离，没法的因素倒影，你带着我的感觉是亲爱的巴黎输赢。

我风雨满天都是来回到曾经碎裂的大地，记录这场爱失败的正义，那我想上学，我多嫌弃你的人会下到哪里，那段听到没，暴雨还是控制不住自己想逃离，嘿嘿，我想找到那曾经又团暂停留，后来飘走的云，黑夜。

我有那么一风和日丽，春暖花季，但却万里，嘿，我想要到达，那曾经都很真情，留后来飘走的黑夜，我丢了，我自风和日丽。

春暖花季满却万里无，还，那曾经有短暂停留，后来。

我爱你，无畏人海的拥挤，用尽余生的勇气，只为能靠近你，哪怕1cm，爱上你，是我落下的险棋，不惧岁月的更替，往后的朝夕，无论风雨，是你就足矣，看了太多情人分分合合，爱情是很脆弱，像温室里的话多，你这么说。

我其实很忐忑，若我没有许过承诺，你还爱我吗，听夜空的流星陨落的声音，只愿望让你听，我爱你，无畏人海的拥挤，用尽余生的勇气，只为能靠近你，哪怕1cm，爱上你，是我落下的险棋，不惧岁月的更替，往后的朝夕。

不论风雨，是你就足矣，等你，你这么说，我其实很忐忑，若我没有许雨过承诺，你还爱我吗，听夜空的流星，听我的声音，这愿望让你听，我爱你，无畏人海的拥挤，用尽余生的勇气，只为能靠近你，哪怕1cm，爱上你。

是我落下的险棋，不惧岁月的更替，往后的朝夕，无论风雨是你就足，我爱你，无畏人海的拥挤，用尽余生的勇气，只为能靠近你，哪怕1cm，爱上你，是我落下的险棋，不惧岁月的更替，无论风雨是你就足矣。

it's a degrees like villing down once the brother，we just wanna be free，it，don't feel like the star。

i've been to the radio with that scaas，the moonlight close，no，we don't give a fu，we got a chance。

dragon，i could we gonna do it，because we want to taste pass spine now，we playing by your one，chasi。

see what a cusing iswake you，da new pocket don to the most school with the kings are the same all the lights are pretty with bad boys like d。

we in the club，detta，we just have the blessed the future，so bright we looking at the past。

and we just stin the moment，because it's all of degrees，libili was the bra。

we're just said to be free it，don't feel like this s。

slap into the radio with that so calling the moonlight，close no，we don't give a。

so we gotta change a thing on the mo，hey yall，you look，so good when the songs up。

but i love father should we do when the sun down playing around are you here。

is that sounds turning up the music，when we got a little too，loud turn around a smile。

when she got a pretty，wait，so she writers saw me，dry，i need me some peter light，we gonna take it。

so headed，why she on the phone said，she wants some more keep it on the low low。

i get my feet up on a dead，deep gling，we just have a blast and future，so bright。

we looking at the past here，we just stall in the mind，好了，同学们，咱们开始讲课了啊，呃今天是第三节源码课哇，这节课是第三节，这是第三节呃。

之前如果没听的话，听起来的话可能会稍微有点难受，因为这源码这东西都是连起来讲的，稍微有点难受啊，你可以尝试着去听一下这个东西啊，呃刚刚跟那边那个陈老师沟通了一下，然后源码课呢咱们就看你们的反馈啊。

都不是特别好，大家可能需要很多个消化时间，所以这边计划是下周二，下周四咱们再上两节，保证了五节课的一个源码，基本上面试的时候应该够用了，后面像确认一下源码课，后面会拉补起来啊，大家放心好吧。

呃你们还是一样，把我这几天讲这原版课能够呃掌握了啊，就已经面试，反正几句我觉得应该没问题了，之前听过也难受难受，什么阿联圆满对工作有用吗，给大家说一下源码这东西啊，说实话对工作有用吗。

稍微有一点就是说你在用一些框架的时候，当然是小公司，大公司里面可能有自己封装的框架呃，有时候可能会遇到一些bug，你解决不了，解决不了，然后呢你最好还是有可能需要看一些源码。

有可能需要看一下源码这方面的东西呃，但是常规来说影响不是特别大，但是现在在面试的时候，他为了考验你对应的一个技术深度，往往在面试的时候问源码好，这是很尴尬的一个点是没办法，所以源码这东西还是要学的。

而且源码学完之后，不是说我工作用不到就可以不学了，不是这样的，我不是为了应付面试，我需要源码，就是思想层面的竞技的提高会有很大的一个帮助作用，所以这块我还是希望大家能够把源码能够系统的学一下。

如果你把spring my dis，spring vc，my bt，那个spring boot，这些原本都看完了，你之后其实完全有能力说我自己开发一个开源框架出来，这玩意有可能有有可能的。

关键是你想不想这样做，小连连外部快开始了，什么叫外部快开始了，所以啊源码课我还是希望那个能多看一下，都看完了，感觉成仙了，那不至于好吧，看过原版的人很多啊，不至于都成仙了，呃没没大家想的那么难。

ok只不过源码一直被大家被大家当成一个非常难的东西，所以很少有人去完完全全看一下，他其实看完之后感觉也就那么回事，没有特别难行了，多余的，废话不多说，我们下面来接着讲我们的源码课程呃，下午的时候呢。

然后我们大概讲到哪个地方了，还记得吗，我们是不是开始准备我们对一个呃application contest，是不是这意思啊，我们这现在主要是干嘛的，叫prepare contest。

往我们的上下文环境里面，下文环境里面注入一些属性值，或者做一些参数值，主要这样的一个工作，我们看到这个地方，就是说他已经开始打印我们对应的一个启动日志了，好吧，之前我也给你们看对应的一个控制台了。

这东西我没关，打印了两行对应的一个日志信息，人事情怎么打印的，从哪打印的，输出什么信息，人家信息从哪从哪从哪看出来的，我都带你们看下面看了最下面我们接着往下走，其实下面这一块才是我们整体的一个核心点啊。

和金典上面东西不是说不重要也重要，但是在面试的时候，其实一旦聊到spring bo的spring bot，问更多的人是什么，是自动装配的原理，好这块可问的比较多。

而自动装配就是在我们后面某一个地方实现的，讲到那我再说好吧，我们接下来往下看吧，这块我上下午转向这块啊，这是什么东西，说at a boat specific singleton beans。

添加一个单一的实例对象，或者单一的一个是并并对象，仅此而已，他拿过来一个东西叫get in factory，这是我们的呃，并的工厂类，拿过来之后呢，我们可以往下走。

第二个叫bba regular simon，是不是注册一个单例对象了，注册谁啊，叫spring application arguments，大家还记得这个参数吗，记得吧，这个参数在哪见到过。

在我们之前那个run方法里面，大家是不是见过这个东西，让我们先找一下，找一下我的run方法，在这块儿我是不是弄了一个东西哪儿去了，叫application arguments吧。

是不是指的是我们命令行里面输入进去的一些参数值，是不是在这儿好吧，所以你看完之后，你会发现这终于把它给输进去了，嗯哪嗯哪去了，就这是不是把它给注册进去了，spaction arguments。

就把这个对象放进去，完事了，别东西不用管它，而再往下看，三玩家是什么，if print banner不等于空，我们现在等于空吗，下午是不是已经打印出来我们对应ban的一个对象了，所以这直接往下走。

不等于空，所以马上走，告诉说我把这个banner的一个打印对象也放到我们当前这个bin factor里面，大家还记得这东西吗，我下午带你们开箱的时候，大概看了一下那样的一个目录结构。

我不知道大家还记得没往后翻看哪个对象哪去了，呃，找一下啊，看不到看不到，我们一起来看一下吧，之前下午的时候我带你们见过这个对象，我们之前看了一个类叫什么，annotation。

i know tension confithweb，thority contest吧，是不是给大家看这样一类，在当前这个类里面，我带你们看一下它整体的一个类图，也就是说它整体的一个继承关系。

应该还记得吧，放大一点儿来，我们来看吧，这块是不是看了最下面那个类，然后我带你们依次看了整体的一个继承关系，到这块的时候，这块的时候我是说这里面帮我们完成了很多特殊的工作。

在这个abstract contest里面，我们可以再搜一下呃，找一下那个类啊，找寄生关系，走点它，点开它，点我们的strat，在这个里面我们可以找对应的一个构造方法，找一下，是这样吗。

不是这不是这样的话，就是在哪儿啊，我找一下在这里面吗，看这这是不是new了一个对象，叫this been factory，等于什么呢，等于你一个default libban factory。

看到对象了吗，这是不是已经帮我完成整体的一个创建工作了，所以刚刚我们在我们的spring application这个类里面，你是不是能看到对应的一个代码的实现了，这东西哪来的，是不是这个bfy。

所以你要判断一下当前pfc是否归属于这样的一个工厂类，如果归属于的话，是不是该接着往下走了，把走吧，然后大家走之后，往往后然后往里面写。

这个我们学校set allow being definition override，是告诉你说我是否允许一个纯写，这里面就是一个参数值，默认是什么false吧，这是一个false值。

就这直接把它给注进来，就是不允许你进行一个重新工作，直接步骤完成一个事情能看得懂吧，所以我说了，你在看什么动源码的时候，如果你对spring源码有一个清楚认知的话，你看起来可能会舒服一点。

如果spring源码之前没怎么看过，现在看起来可能有点难受，有点难受，但没关系，你先把这些关键的类给记住了之后，再看的时候也会轻松很多，这边我说下午有课有啊，呃大家注意啊，那个群你们不要去屏蔽他。

当然有些同学可能会在里面，我们吹一下水，或者说扯一下别的这些东西，最好把群打开，因为经常会发一些群公告，呃，上周二的时候，因为我们做活动做活动，所以呢那个夏洛克没拿上，所以今天下午我们补了一下课。

基本上啊咱们所有课程保证每周三节，你们最起码有的听，我最起码有c现在上课前几分钟才通知婴儿之前通知的吧，很早之前就发过群公告，你可以翻一下，每周我看看公告，对看一下公告啊，每周三节基本上是这样的啊。

保证你们最起码这一周有的学也没事干，多不好啊，是不是这意思啊，所以之前就算有，如果我们个人有一些特殊情况，可能会比如有什么想法，上不上课了之后，也会再抽时间给大家补补回来，是不会的，大家放心啊。

这个是大家发现啊，ok啊这块我就不再解释了，我们先往下看啊，接着往下看啊，多留意一下这个群，周五的时候可以问下班主老师，这周末会补什么课，行吧，好了不多聊了，来再往下看，但判断完之后再往下做一件事。

你要this。lazy slide吧，是不是否会进行一个烂加载，这块没做任何设置的话，会直接跳过去啊，这个不用管它了，再来看叫source。get or sources。

这个get sources是干嘛的，是获取一下我当前所有存在的一些资源值，对我们可以点到这个方法里面看一下再完成什么事，首先创建一个哈希set不用说了吧，另一个哈希set完成判断是否对值等于空。

然后呢往里边添加一下，再判断一下这个source值是不等于空，往里面添加，最后把它变成一个集合，所以当这个操作完成之后，你会发现了里面是不是只有一个source的一个对象，对象是谁啊，一样点开看一下。

找一下我们的source谁是我们之前定义好那个primary source的，在进行spring application这个类实例化的时候，我们是做了这样一件事，把当前这一类给它给加载进来。

就这样判断一下这个值，这个值如果等于空的话，那后面就没法加载，没有加载这个必要了，在这儿要把这个值对象拿过来，拿过来之后再往下走，是什么呢，是我们漏的这个方法，这个方法我希望所有人能够重点关注一下。

为什么，因为在这个方法的里面，其实就在我们漏方法里面讲了，来看一下这个方法吧，你把这个点你能做一件事情，不要他点进去，看这儿做了一个什么样的一个判断，你看能不能认识第一个logo的意思。

debug enable是否允许debug，不管他好吧，第二个说创建一个bean definition loader，是不是相当于一个类的一个加那个注册器或者加载器，这东西好，这块其实你不用管它。

你直接跳过就行，想看的话，把里面看一下，里面的一个代码实现是不是就了一个bin，在分析上loader一个对象，别的东西没闪了，别的东西没啥了，看完之后，这已经漏的都像有了，再往下接着走。

找这是不是最后挨个的一个判断，判断完之后，这还有一个load。load的方法，你点开这个load方法，这是一个循环，因为我们的主类有且仅有一个就是我们的spring data application。

所以这里面也只有一个值，再点我们的load跳到下面了吧，跳下来之后，你看这段代码你能不能做一个亲子认知，这块是干嘛的，他说了，如果你当前的source资源是一个类的话，我会加载类的漏的。

如果我是一个resource配置文件的话，会加载配置文件的一个l的方法，如果你是一个字符串的话，会使用字符串方法，这是不是帮我们做了一个判断，你想一下你每次启动的时候。

是不是需要在spring boot的主程序里面添加一个叫什么，还记得吗，只要看一下这里是什么spring boot vacation吗，是不是有这样的一个注解值对吧，这个值会直接加进来。

我们这儿很明显看到它属于什么class吧，是属于某一个类对吧，再往下走，属于类吗，属于吧，然后点到我们这个logo方案里面去，在这个漏方案里面，它提供了几种加载文件的方式，第一种叫gala。

我不知道读对不对啊，反正你知道这种方式行了，这个方式你们之前有没有见过，会有印象吗，有没有见过这东西，在spring boss原版里面，我带你们看的时候，有没有见过这个东西，没有很多同学一点印象都没有。

我给大家说一下啊，之前讲的每一句话不能说都有用，但大部分是有用的，我不会白带你看一些乱七八糟东西，好吧，我会带你看一些有用的东西，什么东西，你点开一个类叫spring publication。

我们看一下当前这个类，在这个类的最上面往上翻，往上翻，乱七八糟是吧，呵呵呵，他错了，这个类是用来干嘛的好吧，是引导我们当前这个程序来进行一个启动，在启动的时候告诉你说你要进行如下几个步骤。

我找一下哪去了，没有了吗，没有啊，但是你们看过这东西，我记得看不懂啊，使劲跟了，再找一下他这个ps，看看以下这些步骤吧，他说创建一个这样的实力，register，他register slebean。

这儿怎么没有了，没有了吧，不可能这ho o没看到了吗，就说我们在我们在读取对应配置的时候再告诉你了，你会有几种方式，第一种是什么方式是不加这样一个antreader的东西。

第二个时候你可以使用一个插板文件好吧，或者使用一个什么呢，叫grava的一个脚本，是动态一个脚本对吧，但所以我说过了，你看源码的时候，不要只看这些东西，最好有注释的地方，把注释也稍微看一下。

这里面其实都有一个提示，通过这其实我们也可以验证回来要发生什么事，我们现在有吗，没有吧，没有的话，那这个东西按道理说是应该跳过去的，对不对，就跳过去来往下跳跳，跳在一块吧，这事没执行，你没配吗。

所以脚本压根不会执行，是不是跟我刚开始定义那段或者他写的注释比配上了吧，就这块一定要做一个前后前后关联，你发现了啊，我在讲个代码的时候，我一提到前面的东西听过吗，没听过，一找肯定能找到，把肯定要找到。

所以这块大家注意了呃，讲spring boot启动的时候，先把spring ioc讲一遍，我不讲这些东西，因为之前那个spring源码已经讲过了，所以就没讲啊，所以就没讲嗯。

这个你们回去翻spring源码好吧，来往来看，现在这一步之后，这有一个非常非常关键的方法，叫is component，is component不认识，但component认识了之前。

我们想要把某一个类变成一个呃，spring contest里面的一个对象的话，是不是要加一个标签叫component对吧，你可以看一下当前里面这个方法他做了一件什么事情。

你可以看一下叫merge annotations，点from type，然后这有一个四是storage，什么type，什么东西不认识不认识后的is part叫onent class。

这个come on的class是个什么玩意儿是啥，是不是我们定义好的那个注解，所以它会扫描当前你的注解，这个组件到底是否存在，存在的话才能把当前对象注入进来，如果不存在的话，你是不是入不进来。

就这数我传过来tab是谁，是不是告诉你是spring boot data ti这类，你找他之后没满没完，是不是验证一下，知道了，spring obligation，c tm刀就跳出来了。

跳了跳出来我们没关系，二三你看这一类这一类的上面啊，不是这类啊，是我们自己的类啊，不是这类，你看这类这类上面有这个组件吗，没有没关系，你往里边点，点击之后，你发现上面也没有cm的组件，你再往里边点。

这是不是也没有好吧，你再往里边点，你点到这个configuration的时候，你往这儿看这儿有没有一个component的东西，有了吗，有了吧，它里面是不是存在着一个继承关系，这都看明白了。

这样如果看明白了，你再回过头来看一下，刚刚我们指定好这个参数叫测试什么搜索的一个策略吧，这个策略里面它是一个枚举类，好在大家媒体里面有什么有direct直接的，他们的第二个叫什么东西。

他说found or directory decare，the notation，as well，as any叫super class annotation，所以它会有一个竞争关系。

所以当前这个注解它也会被扫描到，所以此时你告诉我，刚刚我们定义好这个主程序类能不能进行一个配对象，一个注入，懂了吗，懂了吧，那这个值判的国家之一是处的吧，你往下走是不是也能触。

触完了之后直接把那些方法返回return tru了之后，这是干嘛了，只是告诉你说当前启动类我能够用了，但对象并没有进行一个注册功能，所以到下面这之后我才开始整体的一个register的一个注册，往哪走。

就在b然后reacer往那边走，走完之后下面有一堆的逻辑判断，这里面更麻烦啊，这样更麻烦那个东西我们看我，我想带你们看一下，简单看一下啊，我们不详细看了，这块儿，你看一下上面的名称干嘛的。

叫注册一个b从给定的一class里面好吧，devt emt data from class，从他指定好的，你们类里面的一个注解里面把它的一些原数据给分解出来，这个方法你就不用往下看，我们往下走走走走。

就是这些数据处理啊，不用管它走道往下走走走走，这块儿这儿有个非常关键话，叫什么叫ban definition reer，you too，点register什么是不是叫being definition。

是不是还是我们这hola holder，你往这边走的话，你能看到一个东西是叫get definition的一个get be name，获取个名称吧，来看名称是谁。

是不是spring boot data application，有有名称吗，还有对应的一个类对象，这有了名称之后，我把这个名称和当前对应，这个类都加进去，我才能把它给注册成功，这才是完成注册成功。

这个功能除此之外，除了这点之外，还有什么东西叫definition holder，点get allax，你是不是也可以给我们当前这个病对象来设置一些别名，这个别名同样也会完成整体的一个注册功能。

所以刚刚那个步骤到底完成了一件什么事，你告诉我往往一反往下翻，往下翻往下翻，没有了高低落的完成后完成干嘛了，注册变吧，你说清楚注册是谁，注册的是谁。

注意是我们当前这个spring bolication里面那个主要的那个启动应用程序，启动类要把这个程序启动好，是不是也在我们的contest里面完成的，听完了吧好吧。

这个时候你整个的逻辑线有没有理清楚一点，来听明白的同学扣个一，所以啊你把它一层一层往里面找，你会找到你自己认识的东西，当你找到自己认识的东西，告诉我哦，原来是这么回事，心里很舒服了吧，是不是这意思。

往这儿一定要注意了，ok这个操作完成了之后，当然我这个东西先讲这么多之后啊，还有很多其他的一些组件，我们到时候再聊啊，一会再收他，一会再说，他这样完成之后又到哪了，叫listeners。

第二contest loader，又看到这个方法了，每次看到listen的测试走，应该有一个条件反射，我之前见过n多次这东西了，之前最起码见过三次，是不是还是用来注册我们对应的一个监听器，触发某些事件。

只不过每次的事件是不是都不一样对吧，来往这边点一下，看这是不是又开始循环了，这个类似，那是谁，只有一个吧，叫event publish run listener。

整个我说过整个启动环节里面有且仅有的一个对应监听器的一类，填完之后把这边走，然后呢叫contest loader，点进去，点完之后，这时候又开始叫get listeners了。

application listeners开始获取我们当前这个监听器往哪走，判断一下它是否是这样一个类型，如果是的话，做做做下面那个判断，如果不是的话，就不做下面判断吧，往这边走这个循环，把循环走完。

两打断点吧，这其实就是过程里面就是一个筛选的过程啊，就是一个筛选的过程，这块你可以不用管它，就判断一个类型是不是这个obligation where的这个application confist river。

有人见过吗，在spring时候见过没见过同学回去看spring源码，老师之前也讲过这个东西，它是一个扩展接口吧，是不是一个非常重要的可扩展接口，你看到这些偶尔的时候都是扩展接口，好回头自己看。

回头自己看，我们只说了最终答案之后，是不是又进到这个方案里面去了，此时他这个疑问的事件变成啥了，叫application prepared的疑问啊，之前是不是见过三个event了，还记得吗。

该交哪些事件，不记得，没关系，回去看原版的时候，把这个事件给我记下来，给我记下来，这样记下来之后，我知道了当前是第四个事件，有了第四个事件之后，我要干什么事儿，是不是还是要过滤我们计算器哪些东西匹配。

我们对这些规则来往这走，哎呀好吧，直接跳过去了，找兄弟打打的呀，兄弟打兄弟打兄弟麻烦，有多少行，94行，然后删掉删掉重新启动啊，什么启动啊，刚刚直接跳过去了，不好意思，好到这儿了。

这是一个news 16的对象，你不管它不管它，再点知道了吧，再点，然后呢，这样往里边走点，它是不是又到这张方程的方法里面去了，怎么做的，往里面挨个进行处理，先获取到我们所有的这个listeners。

往这边走，这边是不是依次就是一个基本的判断，二哥走了走了走走走，这块是不是要进行返回了，点进去往下走走走走，走到这块是不是要进行一个判断了，叫sport event。

判断一下我当前到底是否支持我们当前这个environment这东西吧，来开始循环走走加进去判断是多少级判断，大家看看是不是有n个条件的一个逻辑判断，当你把当前这个逻辑判断弄完之后，是一共有11个。

最终会剩下几个符合我们对应需求的，来看看这个吧，一共几个五个吧，怎么做条件判断呢，这个具体规则你下来之后自己看自己看，我之前在给大家看过很多次了，我们这我不带大家看了，你知道还剩下五个吧。

有了五个之后往回翻转回来，知道吧，是不是从这五个里面挨个取出来，第一个the cloud funny是什么东西，一看到是一个云平台，我们这儿没有支持往这边走，invoke走走走。

点进去是不是只带一个日志变动，没有吗，没有吧，没有不用管它了啊，这相当于这个事件是什么都没做好，没做完之后再老板第二个叫config file application是什么东西。

你看到这个config fail之后，你是不是有点熟悉了，他干嘛的，是不是还是一样加载我们队的一个配置文件的，是配置文件的，所以你往里边走一下试试啊，往下走点进去点进去点进去再说。

一般一次次of o这个东西匹配吗，不匹配吧，好再往下走，这时匹配匹马再往那边点点进去，这是干嘛呢，叫this love to switch to，告诉你说这个log东西。

你看log先不管是不是就是日志的一个输出，这个输出再来看at post processor，这里面是不是开始往里面添加我们的post processor，对吧，加什么东西点进去，这返回一个具体的一个值。

connect，不管它填进去，知道吧，叫contest点，at being factory post process。

你有一个什么对象叫property source ordering post processor，此时你看到当前对象之后，我应该知道这件事了，知道什么事。

我把我当前的这个contest里面注册了一个什么叫并factory post processor，而这些并不是说不在干嘛，会对我们之后所有要存储的这些资源进行一个什么操作，叫orderly吗。

是不是oor排序吗，好完成一个基本的排序功能，所以这块就它一个基本功能完成之后，往回返往回返往回返往回返，烦烦是不是，当然了，再按下一个是什么叫logan application干嘛的。

这时候我们要看一下这个logo啊，我们之前用过很多次了，完成初始化系统，初始化认知系统，战时又用到了点，点进去点进去连续，这要判断了吧，判断哪个走走，这是不是能进来连续走，这边也说了，当前配对象。

叫spring boot login system，是不是有这样的一个认知系统走，是不是进来了，我进来之后往里面注册一个什么，就是把它注册到我们的bin fire里面，也是一个实例对象的。

这个都是一样的，只是完成初始化，完成了复制操作，但是你并没有构建整个对象出来，而此时是不是开始构建对象了，我们的不是，并且是不是把我们的contest里面是不是该进入进入了都有拿走走走啊。

这是一个logo，是日志组的东西，不管它了好吧，也是往里面注册对象，知道就行了好了，这做完了，做完之后往回返没有了吧，这是日志这东西要做的操作，再往下看叫bat ground的什么东西。

之前我们看到的所有bound几乎都没做什么事，什么都没做吧，那这是不是也一样呢，点进去点进去点进去走走，看这两个是不是都跳过去了，不太满足条件吗，跳过去不管它是再往回翻，在这最后一个叫dk什么东西好吧。

这个东西之前是不是也没做，是不是也没啥用处，没用处也是一样的，点进去看一下走走走，我判断判断都不符合规则吧，往回返好了，做完了，做完之后里面还有吗，没了吧，我说过了，一共只有五个，所以这个做完之后。

这工作就算是完成了，还是我们监听我们对应的一个事件吧，这里面就是监听是什么事件，第一个给我们的property source进行一个排序的功能。

第二个来把我们的日志系统的一个b对象注册到我们的content里面去，下坡多都没做了，对就完成最基本这样一个功能往回返吧，反反这还有吗，没了吧，就一个对象吧，走当然是完成了，到达完成之后。

我们整个prepare compass这个操作就算是结束了，好来回顾一下在这里面我们到底做了哪些最基本的一个工作呀，啊做哪些基本工作，想一下能想到吗，这个paper contest里面回顾一下。

第一我刚刚是不是只是创建好了一个实例化的一个contest对象，但是里面并没有进行参数值的一个复制，参数值一个创建，所以现在我要往里面复制某些具体的参数，复制这些具体参数值的时候。

你注意一定要看它对应的一个父子之间的一个依赖关系，因为它是根据我们的依赖关系里面添加了很多其他的一些属性，如果你不看的话，你会感觉到很懵，我就感到很懵，然后做完之后也是一样的，这里面还做什么事了。

再想到有什么事了，这就是设置一下对应的一个环境值好吧，设置一个post processor啊，做一些post processor的创建工作，这工作把这做完之后，别的东西有没有别的东西没有了。

所以这个环节准备也不是特别难，也特别难，这块一样的下去之后自己跟一下源码，看一看里面到底做了什么样的一个事情，但你要知道它最基本功能是干嘛的，是不是准备我们的上下文环境好，这块认识到就行了。

人造完之后来再接着往下走，这块来能听懂的同学能跟上，同学扣个一能跟上吗，记住我说那句话，你在旅的时候自己别乱了，之前看到过的东西跟现在看的东西，你要放一块做对比，放下做对比，这对比什么意思。

别之前看过啥都忘了，一点印象都没有，这不对，这样的话你看看他什么时候你都一脸懵，发展完了之后get到这个东西叫reflash contest，这步骤，这个步骤是一个非常非常麻烦的一个基本操作。

看里面都什么事儿吧，你往这边点，点完之后叫free flash contest对吧，再往里边点往下走，点点完之后是不是super好，再往下点，像这块了吧，这是完成了一个最基本的一个初始化工作。

他在哪个类里面，abstract application，然后呢contest吧，还记得这个类吗，记得吧，当时我为什么要带你看这样的一个关系图，那个annotation呢就没了。

bo pei t a t i n。

这类里面我带你们看了一个整体的类图，在类图集中关系里面是不是有个东西叫abstract obligation contest，是不是在这儿，你刚看到这个类，这一样吗。

是不是一模一样，看的就是这一类，在这个类里面有一个reflash的一个操作啊，reflash作，而reflash其实这块东西属于谁，属于spring里面的东西，而不属于我们的spring boot。

spring是要进行reflash的操作，还记得吗，这个spring里面reflash操作，知道同学来扣个一，知道同学扣二，知道吧，这也不知道啊，当时当时讲原版的话，应该跟你说这东西这么多，不知道的。

这这这没法带大家看啊，这个没法大家看看的话太多了，王师傅说过是吧，自己没看过是吧，你其实没关系，没看我们我们粗略的看一下，粗略的看一下，粗略看一下好吧，看见没完成什么功能，然后来看第一个叫cper。

this contest foreflesh，啥意思，你看注释，你讲过什么源，什么源码吗，没有没讲过没讲过没讲过啊，讲spring bot源码没加过sp源码，外面看进来之后再做一件事情。

prepare reflash是准备我们进行上下文环境的一个刷新工作，来往里面看，我们看一下他做了什么事，我们这边点一下，点一下看，知道了好吧，点进去。

然后他告诉你说this scanner叫clear tch，这个scanner还记得是干嘛的吗，有没有同学记得这个词，刚那是啥，我们当时在创建这个annotation config server。

web server，application tnt的时候，是不是定一个实例化对象，小老师，反正初始化工作是不是扫描一下上下这个东西，我之前讲过这个东西了，好吧，你要骂的话怎么办，还是一样。

看这个类里面找一下构造方法，这边有个sca sa里面是不是指定好了，干嘛的，叫ca new呃，不是这这找一个方法，看这个方法他是干嘛的，他说了，定义了一个ban好吧，能够sky scanner。

我们当前那个什么，我们这个路径里面的所有的一些组件进行一个扫描工作，就这个就这个这个类来完成的，这第一步是完成这样的操作，往回返啊，把它这个缓存给清空掉。

清掉之后一样也是掉到负类里面的prepareflash，做什么事，第一个switch多unity记录一下当前的一个时间，把close给关掉，把xt 5给设置成开启，让它定型认知的一个输出吧。

这块不用管它好吧，再来看叫it property source是干嘛的，init初始化吧，pissource professor s熟吗，是不是看过很多psse的东西了。

就完成了我们这些provisource的一个初始化功能也是一样的，判断一下当前的环境是啥，然后呢如果是他的话，进行一个初始化工作里面是不是依次往里面点，还记得吗，还记得同学扣个一几个。

还有没有一点印象啊，没印象啊，是不是一共有具体的四个，刚开始是四个吧，刚开始不是四个，四个了之后我是不是加了一个东西叫什么叫configuration呃，叫什么礼貌的configuration。

还记得吧对吧，后面加一个什么，加一个runner吧，对不对，后来又加了一个什么，是不是加了一个，然后点一记得吗，看一下property source 17个吗，看这convation propose。

然后呢server的两个，server system的两个，然后加上我们的random，加上我们的obligation，改羊毛这几个对吧，记住记住记住一定要记得一定要记得，别忘了你还没讲完就忘了他叫。

所以我说了啊，你们你们为什么看源码的时候看不下来，原因在这儿，很多同学看完我前面讲的源码了，我看完自己之前看的东西了，看完就忘这东西，我感觉跟新东西一样不对，一定要产生一个前后关联。

前后关联连续初始化工作，你遇到什么东西，get a proper s干嘛的，就是一个初始化啊，就是一个初始化这块我不往这边看了，再看就没头了，不往这边看了，你知道它完成一个什么事儿就行了啊。

这完成什么事就是一个初始化工作吧，发完之后，这是什么东西，叫get environment where when it required properties，这是干嘛的，你怎么做到，看了不忘。

看多了就看的不忘了，哈哈哈哈哈，怎么做到的，你要有点印象啊，有点印象，具体类别我也记不住，但大概大致东西我会记得好吧，我来看看这个函数干嘛的，叫获取环境，并且进行一个验证必备的一些属性值吧。

是不是就是验证操作，你把这个点它有一个具体时间内看哪个看吧，往里面进行一个验证就行了，我们这不往里面看了，就是干嘛，这边就是一个环境验证验证的一个东西，好吧，就是验证东西啊。

验证完了之后来再往下看在干嘛，是不是，this radification listeners等于空等级，功率值没负过值吗，等级空进来之后，把刚刚那个p里面类似的是不是给他复过去，创建一个集合。

上下集合之后往下走，找this early等于什么，new一个list是不是把它给放进去就行了，创建一个新的对象，仅此而已啊，别动西没有了，然后返回啊，然后返回就是刚刚那个初始化的工作。

是不是准备了一些基本的环境，就是配置文件，你去操作啊。

这只注意就行了，这块如果你实在不知道的话，没关系，我说我之前给你写过笔记啊，我进来了，reflash，这看完了，刷新上下文环境，初始化上下文环境好吧，对系统的环境变量后，系统属性进行准备和校验。

现在这句话看明白了吗，你看完原片之后，你再看这句话是不是会好很多，大家知道哦，里面比方说这样一些功能，这样一些功能，这样先先记着先记着先记记完之后来往下看。

这个操作叫tsub subclass to reflect，the internal being factory是干嘛的，什么叫internal bin factory，也因他的病，我告诉大家。

你如果去实际的那里面找的话，你压根找不到这些东西，但是在我们debug这个环境里面，它确实存在着一些这样的值，找一下我给你找一下，找一下你就知道了，being factory in it。

being fpx，在这吧，看这这是一些值，叫o r g spring contest，什么internal confire，什么东西，internet什么东西，什么东西，是不是很多这样的值。

虽然不知道这个是干嘛的，没关系，我们搜一下，看能把这只给搜到，叫internet i n，t e r t e r，然后呢叫n a l config，哎g u r a还用搜吗，没有吧，注意了。

这些类值你是不存在的，是不存在的，刚才干嘛，他只是指定了具体的一个路径，路径之后，或者一个完全性的名，根据完全性的名，它其实起的是一个名称，这个名称我们能找到具体的一个实例类，相当于把那个类换了个名字。

而名字起的这样一个名称，仅此而已，这东西啊我后面呃讲自动装配的时候，我会带你们看一个，看那些东西的时候，你就知道怎么回事了啊，先留个印象，然后点进去看一下吧，做什么事。

注意flash bin factory往这边点咋判断，for这是false是吧，进不去，然后呢叫set serii d是创建一个虚拟化的一个id值，往这边走，返回一个id，不须先搞定这东西就没有了。

然后呢return一个get in factory返回当前并factory对象叫default liable decenter是吧，还是当前这个值，这是没变化的，当时下午讲课的时候。

为什么给你强调这个类别，在这后面你在很多地方都能看到这东西，能看这个东西，就这个对象再往下走，叫奎特定范，不是告诉你说我获取到了一个并派人，现在呢是不是要进行一些准备工作了，好吧，来往里面看这个类是谁。

是不是还是default lizable，being factory啊，还是当成是对象，好吧，你玩个点进去就完成了一些出场动作。

set being class logo that being expression reserver，是不是表达式的一些操作操作，再来看at poverty editor，register，往下走。

at being什么东西，ignore什么什么东西，是不是忽略，告诉你说我忽略这些依赖的一些接口忽略，然后再往下走，就是往里面注册一些处理的一些器，处理器，一些依赖关系，慢慢走。

正常走是不是稍微判断一下，大概那个类似是哪个类型，走走都是一些判断，所以说大家看到了，我就是把我们当前这个bean fighter里面好，be fter里面给它做一些参数的设置。

是不是这意思，我注意下行了，刚刚我这边也写了，对been factory各种功能进行填充，not wear specific，这个这个s p e l表达式是编辑支出注册器添加带着五二的pos pos点。

这样一个处理器等东西属性值啊，没必要挨个看你大概理解什么意思就行了。

大概什么意思，再来看叫post processor，being factory，就是一个跟ftory allow post processing of the big fatory in contact supply supper plus。

还是为此类添加一些具体的功能，写了吧。

提供子类覆盖的结构外处理及此类处理自定义的the factory personal processor，就这个功能啊。

再往下看，这东西叫invoke，being factory post processor，invoke是什么意思，表示执行处理的一个环节吧，好而我们注意了，我们后面再看的时候，很多字装备的类。

它在完成这个初始化这个对象工作的时候，其实就在这个步骤里面完成的这块，我希望大家把这个方法给我记住，现在我不带你们看，有时候讲自动装配的时候，我会带你们详细把这个流程再看一下，你就知道原来是这么回事啊。

其实就是一个解析配置的环节啊，解析配置的环节，再来看这干嘛的，叫register，然后呢being processor that interrupt，being creation。

这句话翻译过怎么翻译，看不懂没关系，我这写了刚刚写叫注册拦截并创建的并处理器，好吧，及注册b post processor，再往下初始商家文环境的资源文件，如国际化的一个处理。

再来看初始化上下文环境广播事件，再来看为了子类扩展，初始化其他的一些病，那就要为所有在所有的病中查找listener b，然后呢注册的广播器中，最后完成是初始化剩余的非懒惰性的一些病。

及初始化非延时下载的并对象，最后一个完成刷新过程过程，这个步骤啊里面东西很很很复杂。

在你们挨个往里边看，但你要知道这个方法里面起了一个至关重要的作用，而我们之后再看的时候，这些auto comparable。

那个叫auto configuration的一些病对象都是通过这个方法注册进来的，什么时候注册的，一会这个方法我会带你们进去好好看看，进去好好看看，这其他方法我就跳过就不看了啊，谁如果不清楚的话。

你上网搜一下，一搜spring contest，一搜搜出spring contest，然后加一个reflash，一堆解释啊，里面有很多页码来解释，下一周自己看行吧，哇这块不担心牌子看了，这太浪费时间了。

咱毕竟不是讲spring东西啊，你看了这些过程可能要花一点时间，他不是说立马就往下走了，是不是需要到执行时间啊，所以这块比较关键，这个步骤往下走，走走走走走，回来走。

走完之后叫register shudha，shutdown hook吧，这干嘛的，一个关闭结束的一个钩子吧，这钩子非常简单，判断一下这个值是否等于空，现在是不是执行完了，执行完之后读close。

执行close方法，好东西啊，很简单，好往回翻吧，这执行完之后，这就完成了，一会我们再详细一会再详细看看东西，boss还没学全，我是不是可以撤了呃现在撤的话之后也一样，看不懂这个东西啊。

不在于说你spring boot会不会用，跟你会不会用半毛钱关系都没有，关键是你要对整个体系结构有一个认知，这时候你再看就好，就舒服很多了，明白意思吧，硬着头皮去听，这是一个很好的方式。

因为你现在听起来可能不知道我在说什么，是当你把某些基础知识的一个储备，如果具备上来了，你再回过头来看我说这句话的时候，你知道哦，原来老师想表达这个意思，听明白了吗，它是需要一些基础知识知识的。

特别是原版里面的东西，我相信啊，咱们班现在听的人有80多个吧，你告诉我有几个人能完完全全跟下来，其实比较难，其实比较难，所以希望大家能够认真去跟一下，认真去跟一下我，我觉得很少有人能把它跟下来啊。

多听两遍，然后多搜一些基础知识，你慢慢就知道了，一说实话我不可能说我在讲一个存储源码，我把前面很多系统知识再从头给你讲一遍，可能你那个力量没听过，ok记下来，下课之后搜资料，搜完资料之后回过头再看。

懂我意思吧，慢慢去补充，慢慢去扩充，这样的话你就理解是什么意思了，如果你现在，如果你现在一次都没听过，你第一次听的时候，你依然还是会有一种感受是吗，我这种又是全新的懂我意思吧，多听几遍。

你会发现还是不懂，哈哈哈，不可能好吧，多听几遍不可能不懂的，不懂不懂啊，27真可怜，可怜啥呀，跟大家说一下sn bot原码本来是没打算讲的，是因为在那个9年前就12月份的时候。

很多学生他说老师我在面试的时候问到spp的源码了，你来给我说一下这东西吧，我来讲一下吧，我们先把这个规划的课程里面懂我意思吧，来只讲所谓木头源码，有画十个图吗，一会我就画一个整体框架图，我之前尝试画过。

但是这里面比较恶心，比较恶心，为什么叫恶心，比如说spring application这个类，你往下翻一下就有上千行，这是来回进行调转的一个过程，所以你画完视图之后。

这线勾的真的是真的是那个什么就是乱七八糟的，你看到视图，你画你画你画不清楚，你懂我意思吧，你看看我之前画过，真的是给你画过，我想过各种方式把东西给你画出来，但是真的是透不透，你知道吗，好吧。

你先你先你你先听你先听好吧，你先听完感一类的对，就是这个类来回调，调过来之后又回过来了，调完之后又回过来了，你会发现这个东西很乱，太乱了，没法画，这没法画啊，还是要搞清楚类图对，这是为什么。

我在讲原版的时候，带你们看了很多类似原因，它有一个继承关系，啊没事没事呃，我也没指望你们一定能听懂啊，一边听懂，我感觉就是也不太现实，就慢慢听就行了。

ok刚刚是完成了我们这个contest的一个刷新功能，刷新功能刷新完了之后，下面还有什么问题叫after reflash，是啥意思啊，什么意思，什么叫after reflash，就说你刷新完了之后。

他又完成一件事，但是你往里边走的时候，你会发现这里面什么都没做好啊，这个功能是干嘛的，是为了我们不是在发现啊，是为了完成我们具体的一些扩展功能的好，他说了。

called after the contest has been refreshed，当你刷新完成之后，我会做一些后期处理，它里面什么都没写，如果你需要填充一些基本功能的时候。

你可以把这个代码里面补充东西，这东西听白了吧，好吧嗯，我再往下看，这执行完成之后，其实我们基本的核心环节已经都做完了，同学们做完了，做完之后好吧，该干完了。

最后的一个具体的一个过程或者最后一个步骤叫stop，watch加stop，我说了吧，刚开始还记得吗，我们是不是记录了一个启动时间，对写作时间完了之后，这一定要去关掉好吧，点进去点点。

是不是会记住一个拖动，拖动一个值，写完之后把它记录下来啊，把这个值返回回去，返回去之后，这是一个this log star和for，这个值讲完之后，new一个具体的对象，这个对象里面是干嘛的。

你说过了吧，返回返回返回走logo，get什么，对这个对象，然后再往里走，obligation in for什么get message叫start in什么东西，看这边m running for。

是不是刚才这个时间把它给加进来，然后把这个数据给反应过去，就让你看一下我们的控制台吧，答案走走哪去了，是完成了，告诉你了吧，说start spring position in这个东西用多长时间。

1393秒，因为我刚重启了，如果没重启的话，这个时间可能会更长，可能会更长，就是记录一下你大家启动用多长时间，因为我们debug了一步不是看的，所以这个时间会稍微长一点，启动完了。

保持这个logo start off，这个这个工作战斗完之后来再接着往下看，叫listeners，点start就到这了，又熟悉了，这干嘛的，是还是我们对应监控器它所要做的一些基本工作了啊，完了点一下吧。

看下这东西走，这也是一个吧，叫event publishing，然后呢run listeners慢慢走，点进去事件叫application started in event吧。

是不是刚现在要开始运行我们的application了，开始运行了，等下试试走走，不管他点进去，点进去往那边走，还有一个事件啊，他之后往这边走，是不是到一到又遇到这里面了，也是挨个进行一个执行。

是返回一个对象，不管它再点，在这之后也是获取到我们这listeners一共有多少个点，一下我直接往那边跳了啊，直接往直接往后跳，直接跳往下跳，大哥一下吧，等一下看是，是reliance。

这个retx等于几啊，看一下有值吗，太快了，没看到，我想算了，没关系，来个慢慢点一下走，第一个叫background，想一下之前做什么事了吧，没做吧，那现在你想一下。

是不是按道理来说也应该是什么都不做好，走走判断的不合适吧，所以这些东西过滤掉了，第二个之后也是一样的，delegation，它是不是也是一般情况下什么都不做，管他了，管他了，再来看第三个a去了。

跳哪去了，找不着了，诶，怎么没有了，点错了啊，咱这里面是完成了一些最基本的一些呃处理的功能操作，我再往回点一下试试，我们村运行一下啊，点太快了，把它给干掉，这300多号下载来存运行一下，咱们看一下。

带你们看一下进去，然后呢进去，延续延续，这方法里面去了，这儿可以获取到我们这个listeners，往里边点走走走，这里面会有一个整体的验证过程啊，走走走走走是完了，在这个方法里面。

方法里面是不是有这个应用的东西，叫support验证这个规则是否合适，是不是直接进行一个跳转返回就行了对吧，挨个往里边进行判断，直接完，返回啊，太麻烦了，ok等一下等一下，这不是这还没到啊，太麻烦了。

哪去了，这我跟孟老师到哪了，这啊到这儿那三条等于几个，是不是因为有两个好，你会看到这个listeners一共就两个，所以到时候我们在循环的时候只循环两个就行，一个白给的一个delegation。

两个里面你也会神奇地发现一件事儿啊，这是循环了循环之后，第一个白光的之前什么都没做好，这也是一模一样的，你把它点一下试试走走走，两个衣服是不是干完了，干完之后来再往下走，是不是带给你这些东西再往哪走。

emoke emoke e连续判断都不合格吧，他执行完之后，大家想一下，是相当于最后一个电器，我几乎跟什么事都没做一样，这意思啊，所以他直接就进行一个最基本的反应工作了，大家注意了。

这个东西是新版本里面，他好像什么都没干，如果你看的是比较老的版本的话，好吧，他的版本这个过去的值是不一样的，个数是不一样的，这做完之后在干嘛，叫靠runners是干嘛的，看到runners。

你应该是比较舒服的，rn是不是正儿八经正式开始进行运行了，是怎么运行，点进去看一下，这创建一下这个release，然后往里边开始添加我们这样的一个值，走rnice，有东西吗，没有吧，这个值没有吗。

不存在，所以只要进进进不去，第二个呢可online是不是也没有进行排序，没啥可排的吧，基本上就是个空的一个值，那这个时候开始判断我们这装死，当前rn是一个空对象，这里面会进来吗，所以直接跳过去了。

把直接跳过去了，再往下看，当你跳过去之后，跳过去之后是到下面这个地方了，叫listen listeners drunning，我们开启了很多个的一个监听器，然后呢让这些监听器是不是开始运行起来。

运行时也一样的，点进去挨个去运行，running连续是不是又是一个叫application ready event，是问他对吧，这时候告诉你说我已经准备好了，这是第几个，第五个了吧，第五个疑问的事件了。

走走走，这不是开始循环，正好不看了啊，这该类似哪几个呀，进有几个，这样看不到是吧，我看下全都能看到吧，看看没关系，我们看一下第一个是什么呢。

叫spring application adm x being register，这是第一个东西，它会进行一些具体的实际操作，然后把yc里面执行，然后点进去是判断一下这类类型是吧。

read完之后这样点进去，然后呢往里面进行一个判断，说是否等于这个值，如果是的话，状态告诉你说是可以的，不等于处了，你等于出了之后，是不是这个值可以进行一个返回工作了，告诉你说我已经准备好了。

准备好之后，王一凡，这还有吗，那个白光的不用看它了吧，什么都不做，对不对，不看他了，走第三大家给点也是一样的，不管他还吗，没了吧，所以这步是干嘛的，告诉你说我现在已经准备好可以进行一个启动工作了。

好这个ready，这个这样这样这样一个操作，一个操作，点完走回来是不是直接把我们这个contest给进行一个返回，意味着contest已经准备好了，准备好之后往下走。

你说你一个spring run就行了吧，走回看回到第一行了吧，祝我们刚开始看完这个代码，这完了之后就ok了，是不是一个意思了，这事儿你能看到一个完整的一个环境，就告诉你说我已经都启动完成了。

中间你会发现一个神奇的事情，我们好像少看很多东西，什么东西，第一个这句话我们见过，第二个，i t for我们，i t u feel我们见过，但是像这个tom cat的东西对吧。

答应他们以及我们看这些服务好吧，这东西你有见过吗，是不是没见过，我好像都没有怎么见过啊，然后到最后一句话的时候，我才见过，中间是不是省略了很多的工作，这个工作什么时候做的，我跳过了。

他们看这块儿我没带你们看下边的时候，它会注册很多对应的一个冰对象，在里面会完成，我们很多自动装配的一个功能是在里面完成的，所以刚刚那个环节就完成了，我们整体这样一个启动步骤，把启动步骤。

所以这块希望大家能了解到，来到目前为止，我们差不多花了五个小时的时间，把这个runner运行的时候就搞定了，就就就就完成这个基本的一个操作了是吧，大家想一下这个wrong。

你看起来好像说老师我一启动一个程序，然后右击运行很舒服啊，跟什么设置都没做一样，其实里面涉及到n多个步骤，一共花了一秒多的时间，但你大家看的时候，里面完成了n多个对象，n多参数等各种值的一些装配工作。

很多准备工作肯定是很麻烦的，老师这块你要注意一下啊，其实这里面还涉及到另外一个东西，另外东西什么呢，就自动装备的一些核心啊，自动装配的一个核心，但没关系，一会儿我再带大家看啊，刚刚那个启动过程啊。

稍微有点感觉，同学来扣个一，我大概知道他做什么事，同学来扣个一，看懂了，看的话来下面的时间我们休息十分钟，十分钟回来之后啊，十分钟回来之后，我来带你们画一下整个启动过程，我到底做了什么样的一个事儿啊。

它里面完成什么样的功能，我们一起来画一下，这个图是整体的一个部署的一个图，好之后，我们再接着聊，ok要录几遍，肯定要看的，不看不行，就等这个了，嗯，最后一节不是不是不是不是第三节。

我计划周二周四周二周四再讲两节，计划之后再再再讲两节，从下周就开始，你们开始讲网约车，讲网约车好吧，就记住各种listener，contest，property source。

来回prepare reflesh，其实就是这样的过程，准备好，然后添加属性之类的东西好吧，完成课程怎么试的，二期比一期讲的要多，二期的计划是12节课，12节课，听不懂不至于吧，不用不用不用不用。

第二期就好了，二期在一期阶段基础上做了一个扩展，做了一个扩展，他这也没有啊，没有白皮书，白皮书可以给大家看一下，打宝宝不要呃，不需要停，都是十分的，不用打我，不是往外撤吗，不讲了吧，让我歇会儿吧。

讲完这个课，我大概要去那个基础班讲4s m了，讲s m9 ，再等我一下，我给你找一下那个那个白皮书，大家可以看一下。

考了一份啊。

嗯，大家可以看一下吧，这个网约车二期中还要讲解的一些知识点好吧，架构的一个设计，后面有课程大概讲什么东西。

考过一期的，考错了，考一期的那二级也一样，在一期的基础之上做了一些扩充扩充，所以大家如果想先找工作的话，这个这个这个项目，这个项目是可以用到你的简历里面去的啊，要简历延续的。

大家下课之后可以找那个班长老师，回一会我给大家分享一下我们这个课程的白皮书啊，下课就来分享啊，比较匆忙，所以搞错了，ok反正你知道你下一步要学啥就行了好吧，你为啥不能骂，可以可以啊。

可是这个源码你看了几遍，不知道谁家数遍数，看懂为止吧，常老师讲，只是一个入门级的东西啊，markdown软件的名字，t y p o r a，对就这个刚听到打火机的声音，重根烟放松一下好吧，抽烟了。

声音很大吗，这你都听不着，下楼买烟了没有，我们办公室一般都存着好几条，我的天呐，我就疯了啊，哎不抽烟啥感觉，不抽烟感觉要死了，太大好吧，感觉这个世界都不好了，这些代码特情调，不至于啊。

回家之后一般都是去楼道抽烟，快完了吧，好像是快完了，vo应该就没了吧，家里有孩子不能成，是这样的，一节课，二级网约车进化12节课有可能会更多，有可能会更多，多出很多阵容来啊，办公室抽烟怕是要卷铺盖了。

马老师比较好，允许我们在办公室抽烟，哈哈哈哈，支付吗，这个细节玩不了，一会儿我把那个白皮书分享出去，你们可以看一下，可以看一下，好吧，下课之后吧，做一个分享没发出去，来还在同学扣个一。

我们开始要画这个图了啊，聊啥，会更新的那个会更新的，肯定肯定肯定会的，肯定会啊，就放心啊，抽烟六六和七老师不说嘛，我跟周老师有自己的一个单独办公室，所以在办公室抽烟没事，外面闻不到，讲个tivity吗。

就讲了一个工作流，也没啥讲过吧，很简单的东西了，我就提一下这个工作流，我们没啥不会还用开发吗，现在网上一搜一堆，你去讲的是哪个课程，后端工程师这门课，后端工程师这门课就基础班，基础班的课程，啧。

这是二套。

啊打这个浏览器打开错了。

来我先来画一下整体这个图啊，开了，就是这个课就是这个你讲项目讲的那个，到时候那个什么叫啥，何家园服务平台，我讲回家音服务平台，以为我讲讲算法心态，别捣乱，算法讲不了四法，往后推吧，云服务平台啊。

到时候会讲的这样画一个图，我们现在带大家从头画，大家从头画好吧，我们不在之前的基础上做啊。

我们从头画，那个有啥问题，一会儿一会儿我们再聊一会，我们再聊好吧，先把流程梳理清楚，有啥问题，我们讲完图之后，大家再聊这事，下面呢我们来画一下整体这个boss在启动的时候还做了哪些事情啊，首先第一点啊。

首先第一点你要知道了，我们刚开始在启动运行的时候，这边会陷入一个什么呢，叫spring application，所以的类是不是这个在这个类里面进行一个启动过程的，这类非常非常关键啊。

之后我们看到了几乎所有代码里面都在这里面去，是不是都在这儿，大家看，那之后，首先第一步骤，我们虽然在这个主方法里面，我们自己没有创建对象。

但你要知道这里面其实涉及到一个什么叫new spring obligation，过程吧，这个过程就是完成了一个这个对象，一个基本创建这个东西其实并不是特别麻烦啊，比如说麻烦。

但你要知道在整体这个初始化里面，他做了什么样的一个事情，要写一下，不这样写，这样写一下初始化，是分出来n多块，是分成n多块吧，啊哪些块啊，大家想一下，第一步骤最关键的啊。

是不是有东西叫resource logo，我想跟我去回忆好不好，跟我回东西啊，叫resuler东西，其实刚开始是不是一个空的一个值，所以这东西写不写无所谓，然后写不写无所谓啊，就这一点，第二点做什么事。

是不是判断当前应用程序的是不是有这样一个类型的值，第一个叫n，第二个叫server lt，好吧，第三个叫active，就是reactive t i v e，这块稍微注意一下好，这是第一点。

然后呢这是第一步你要做的一个最基本的事情，这样做完之后，还有第二个工作要完成什么事儿，是不是加载，所有的初始化，初始化啊，八从而加载的是从我们的spring。factor里面进行一个直接加加加载啊。

保持第二步你要做的事情，然后第三步该干嘛了啊，是不是该加载所有，自然听起，有中文翻译过来，不太准确好吧，大家凑合听到这块，这做完之后还有第四步操作干嘛呢，是不是找到程序，然后运行的，主类执行的好。

有一个程序的一个主类main函数，它通过一个对战的方式依次进行向上的一个插槽工作，是这块东西，这这个步骤你要完成的事情还记得吧，这东西应该是留有一个最基本印象的啊，最基本印象啊，这块，ok这是第一步。

当你把这个对象初始化完成好了之后，下面第二步是不是该执行一个最基本的弱方法了，这写下开始执行rock啊啊说实话这些过程其实比较简单，但你要知道在里面其实做了n多个最基本的一个布置操作吧。

这里面大家想一下我做了什么样的一个事情，什么样的事情还是一样挨个优化吧，第一步开启一个什么，开启17吧，这个计时器啊，我给大家写一下，记得吗，来我们看看源码吧。

还要看一下源码，不看的话，大家可能跟不上，看一下，第一个是stop watch，开启这样的计时器，我把每一行代码给大家粘过来。

这个步骤你要做一个最基本的工作，保持第一步骤。

第一步做完之后，第二步还有什么事儿，除了这东西对吧，下面是不是定义一个对象对象，接不管第三个是配置一个headless的一个属性文件，这是第二步嗯。

配置系统属性，java。awt点开的例子，展开属性值，这是第二步骤，我这样写一下step或者一，拿不过来了算了，这样写一下小二这第一步骤啊，这这样步骤他俩合到一块了，怎么拿不出来呀，这可以吧。

这是一至二好两个步骤就搞明白了，这是前两个步骤，它做了一个比较简单的一个事情，然后他做完之后，第三步骤该干嘛了，注册我们对你一些类似的东西的，这个大家应该还记得吧，我要画一下第三步骤，注册。

l i s t0 listen是不是注册了很多对应一个listener。

就在这块儿，是不是啊，当然这个listener里面肯定还涉及到一个什么。

是不是启动的一个过程，我都拿过来，然后做完它之后，方法是点点挨个的一个匹配工作进行一个启动，是不是这个步骤，当这个步骤也做完了之后，也做完了之后，在干嘛在干嘛，想一下是不是该起，这是写一下三，第三步骤。

振动完之后再往下看。

是不是该启动，它刚写了42点，启动了，该准备什么了，是准备我们对应的一个命令行的一个基本参数了，好第四步骤。

这边放这边好，第四步加载，命令行的参数值完成，大家看，同时我是不是构建出来一个新的对象，相当于是新的对象把它过来啊，这四个步骤这个事情，但这个事情完成之后，注意了，这其实做的事情也算是比较多吧，好吧。

你要想看的话，点到这个方法里面。

你可以看一下创建对象，然后往里边进行挨个进行一个添加的一个操作，这个东西new new resource，然后读取到他对着一个值应该不是点过了。

用了一个什么叫simple command line arguments processor，然后进行一个直接的一个解析，剪完之后是不是杠杠开头了，这东西啊，之前我都带你们给他看过了。

所以这块我们不再详细说了，大天说了，但是你要知道他做了些什么事啊，这里面必须要知道他做完之后，第五个步骤。

啊，干嘛是不是准备，应用程序的啊，呃环境是不是要准备我们当前应用程序的一个基本环境了。

这是该这个环境啊，这个环境里面其实也非常简单，你来做些什么事情，是不是就往里边加了一些配置，是创建一个对象，然后再加一些基本的配置，启动我们对应监听器对吧，把对象给返回去对吧，那行啊，准备把代码粘一下。

这个值。

代码，除非我当前环境，这是第五个，步骤五，当你当前这个环境准备好了之后，你告诉我下面你要做啥。

配好之后，我在这边设置另外一个属性，就忽略某些病，不让他加入到我们的当前环境里面去吧。

第六步，那，就麻烦设置系统属性，然后呢保证某些，不会添加到环境，要准备的保安静，对，啧，这个步骤做一下，第六个步骤要做一个事情，这都能看懂吧。

知道这个整体步骤应该记得第六步骤，然后这做完之后，第七步干嘛。

是不是准备我们的一个打印图案，打印版的图案，下饭吗，只要直接换了bba的打印，这是我第七个步骤，哎，放弃了好吧，你知道这个步骤就行了好吧，这是第七个步骤，进入这个之后，我们再往下看他要干嘛。

是不是开始给我们准备上下文的一个最基本环境了，是准备下文最基本的环境，准备，交替这些啊，上下对打击的环境对象，好吧，这块你应该记住了，记住那个最多的那个类名称，非常非常长的一个类啊，这块记住ok。

第八步骤，这做完之后再拿走干嘛了，他还原准备好之后，我是不是该收收集我们对应这些异常报告器了，拿过来，这写一个，是一查报告七对象，我把代码都补全啊，刚才有张有没沾有把代码补全，这两参数值一样的。

把它拿过来。

这图这图完之后一样的在干嘛，是不是准备我们当前这个环境。

当前上下的，拿过来让大家看干嘛呢，是不是要重新刷新我们这个环境，上下和缓解，标注一下叫关键操作，这关键步骤你这一定要把它给注意住了，不一定要把记记住了啊，这是我们关键的一个操作，就比较大。

背完之后还有什么，是不是开始最后的一个刷新，来凑合着看，哎上下文对象准备好，之后，好好做默认，都不错啊，方便，好把那个匕首步骤记住了啊，还有很多东西没没没往里面加，一会我往里面添添添添加东西好吧。

还没加东西呢，这只是把这个大致轮廓先给大家梳理一下，大家理一下这样的一个环境。

这牌子怎么来，之后是不是计时结束好吧。

计时结束，结束并打印呃，启动去把运行的时长啊，这个步骤，我们这样一个基本的步骤图，下面就有个listener start。

这面我说了什么都没做，前面toonist也是什么都没做，这样东西跟没做都一模一样好怎么样，最后还有个什么呢，叫listen那点rning，让这些启动器是不是都启动起来。

监听器，找一下监听器，所有的监听去对象，所以你把这些基本的步骤都记住好吧，这是2+2 d8 不，说过了吧，把这块，绝了啊，这个东西给小光，然后大家看这个地方，第十步，哎呀我，拖把没事就拖吧好吧。

快被整疯了，没事快快完了t我记得我自己的想笑啊，小龙好了，签完下东西，一会儿我给你们分享完之后，我把这东西给你们补全好，在这先先写这么多，写这么多这块之后，就是我们整体这块的一个基本步骤。

看起来好像是已经比较清晰了啊，已经比较清晰了，但是但是我说了，我要往里边加东西，加什么东西呢，首先最基本的东西你要知道是吧，这就什么东西，你想一下我们本身。

我们本身从spring the property of spring fighter文件里面，是不是加载了很多对象的一个值，是加在属性值，这些属性值你拿过来之后，其实它是通过一个什么统一的一个方法。

是不是读取过来的，所以在后面这块我希望大家做这样一件事，页面我把它放大一点啊，啊我往右边加点东西啊，加点料加什么料，也就是说你之前在进行数据读取的时候，你到底是怎么读的啊，到底怎么读的。

想一下最开始读都是从哪读，是不是通过这东西，我要从模拟rfs文件里面是加加加加加这个内容了，就这块拖移过来，这写一下叫根据叫传入的类型类名，或者就是我们的k，呃得到，的工厂集合的实力啊。

先把这个实例名或读过来，当你把它读过来之后，把读过之后，第二步骤在干嘛，下载叫spring，点factory a e s文件文件中的内容，是不是这个文件里面内容了，我们之前所有的那些类别。

几乎都是直接从这个类别里面给加载过来的，加载过来的，战斗完之后，第二步骤在干嘛，文件名是不是给人取到啊，起到之后来获取，装工厂啊累的什么全路径，根据反射，具体是。

对实体对象是不是拿过来拿谁对象之后再往下看，的生成，的对象之后，再返回给调用者注意了，对不对，但注意了，其实它并不是独，里面都加加颜色，加这条吧，你想一下像这块的基本操作，哪个地方用到了。

第一个这块用到看吗，第二个这块能看了吗，是的都是通过什么，还记得方法名称吗，这写一下叫get spring federate，唉es，然后呢，cs是通过当前这样的一个方法把这个值给出去。

到了这最起码两个地方都是一模一样的啊，都是一模一样的，这块大家注意了啊，这东西都一模一样的，除此之外想一下还有哪个地方用到了我们当前这个值，我在进行这个类的一个初始化器的时候，他听到了吗，是好了。

还有意思，是等于方法了，来再来看还有什么东西，我们之前在写那个异常报告气的时候呢，这画，来换一下方向，大方向要把那个图片上画，拿过来，啊，找上挪一下，然后呢想一下刚刚那一张报告器里面。

我在获取具体类的属性值的时候，是不是也是调的是这样的一个方法啊，啊所以这块你要知道啊，所有东西都在里面存储，这块是比较清晰了，来这听他同学来扣个一笔记，会非常跟他玩，会不会这些东西啊全部上传的啊。

全部会上传的缩小一点，肯定会啊，我不上传，那我费劲画个图干嘛，转化完之后，别的东西还有吗，想一下别的还有啥，不要就是为我们具体的一个细节了是吧，涉及到细节里面的内容了，细节这块我们再接着往下画。

每一个步骤里面其实都有具体的一个细节操作对吧，这这里面完成了哪些事情，我应该做哪些东西，我们这儿来补充一下，光画这东西没意义，好吧，又要说了，你这东西你自己也能画，按照代码就是前后往下去往下捋就行了。

关键是你要知道几个最核心的一个步骤，装填步骤之后，你要知道我如何进行一些实际操作，这才是最核心的，懂我意思吧，一会下课之后，我会把这个图再美化一下了，这个图画太丑，和我这个是审美观啊。

有对象他提bug了，大家看这画完之后，我们再做什么事，你还是一样想一下刚刚我们那个群体步骤里面我可以做什么事，第一个开启计时器，其实开启计时器的东西并不是特别麻烦，好并不明白这里面你就是一个东西。

我想一下怎么链接过去，怎么练怎么怎怎么练，呃，这儿写啥，我想想，这样没法这样没办法往里面画了画了，我这写吧，角设置，当前任务的id和的时间，然后呢方便后续的时候某些，进行某些什么呃，进行叫计时。

真的注意了，我一会儿把这东西再美化一下，太丑了，这个，在哪点，这是我们整体的第一个步骤吧，它完成了什么样的一个事情，这块注意就行了，这逻辑来好吧，这是第一块，它是比较简单的好吧，其实里面没有什么核心。

没有什么核心代码啊，非常简单，基本操作，ok这做完之后来第二步干嘛了，是不是加载我们对应命令诶，哪去了，这是第一步，第二步呢，这第二波，啊，它发生什么事，是不是就设置了一个系统的一个属性值对吧。

这个属性值意义不大，这个忽略，反而没人去问他，好吧，你大概知道是什么样的一个意思就搞定了，别东西不用在乎好，然后再往下看第三块步骤来告诉我第三步骤干嘛，注册了一个类似的一个对象对吧。

说起来很容易的东西并不是特别难，但是跑这儿了，来来看这里面我声明了一个对应的一个listener对象，但是这个listen呢你要知道它是怎么来的，什么东西叫event，然后呢publish。

roll listener，那这个东西这写一下会贯穿，不来写不来写不来写不小一块儿，获取一个叫event publish，listen now，对对象好吧，此对象，整个，应用程序启动的过程，每次在进行。

操作的时候都会从中获取具体的监听器，啊啊啊，这是我们要做的一个事情，我要做的一个事情好吧，你先装出了事件发生器，对事件发生器这块就行了啊，调一下，这个解释就行了，就是解释。

然后最终的时候这样会有一个starting，是不是starting，这个这也比较关键，因为每次在进行starting这个操作的时候，其实它整体的一个处理机制是不是也是一模一样的，是一模一样的。

你告诉我这个三他做什么事情。

我们让黑老师点一下看看啊，12点，找一下就在这块把这儿有第一个这对象。

找一个方法，找这个方法，再画一下，想到这怎么画对每次都重复这东西，我画了个外边了，监听器在实际发生，呃做操作的时候都会，叫lisi体验124点星，把每次啊都会执行这点新的方法。

这点星可以是starting，也可以是running，也可以是各种各样的一些触发事件吧，是这样的东西再进行进行技术啊，它会调用这样的东西，当你调用当前这个方法之后，它最终会出到哪，触发这个地方嗯。

当你有了当前代码之后，有当前代码之后会干嘛，比如说会发布不同类型的一个事件，会匹配，啧啧啧，类型的事件，从干嘛呢，从哪儿，从所有的监听器中把和条件的监听器给过滤掉。

啊这这个方法里面它要做的一个最基本的工作。

做完它之后来往这边看走，点我我点一下试试，点一下试试，点完之后中间有一个核心处理逻辑。

条件的监听器，一次投入会循环具体的自己的处理，通过什么来处理呢，就刚刚后面我发了个代码，这个invoke后面东西有点不太不给你们画了，这个emo，剩下核心点你们下去之后自己画。

你知道有这样一套处理机制就可以了，是不是比如说安装一些日志化，一些初始功能对吧等等等等，相关一些操作这块稍微注意一下，行了好了，就这样东西现在看到了，这是我们整体这个监听器，你在做的时候。

我要做的一些事情啊，是ok就这块数据环节，这记住就行了，来这边讲一点，能听明白，同学扣个一，这时候没问题，之后你发现了这个starting，是不是也会掉到我们这个地方算开掉吧，执行叫starting。

这个步骤好了，一会儿我们都往这练啊，这个线可能会比较乱一点，但是你凑合着看，我改一下乱，我们这儿可以打成这样的需求，好吧，就这样好了，看完了之后，我们来再接着往下看。

这启动的时候是不是在做一些最基本的初始化工作了对吧，初始化工作14，都是能把我搞疯了，我的天哪算了，不管他了，不管他了啊，来再来看这个第三步，我们完成了，完成完了之后，我们来看第四步干嘛的。

第四步做事情也非常非常之简单，他其实就做了一件事儿，是不是就是说我要初始化我们对应命令行的一个参数，你最终再往里边点的过程中，你会看到一个具体的实例对象，叫simple common the line。

是一个解析一个东西，这样会完成我们整个参数的一个解析工作，把这个颜色上上，换个色就这样，会掉到哪儿呢。

找一下烦烦烦，往回翻一，熟练好吧，走他走他走他。

七在命令行中，什么叫杠杠，然后呢k等于value，输入的属性是，嗯。

哪个对象还记得吗，保卫反。

别瞎说啊，把这块儿我该到了啊，他表示什么意思，一定要知道，ok这块三个全打第四步吧，这么难吗，不打完了之后来往下看，第五步骤来改编之第四步，啧，我做什么事情。

是不是就要创建我们当前这个应用程序满足的一个呃，准备好一个对应的一个环境了，在环境这你也要知道一件事，什么事呢，往后延伸诶，摸上去了，我想到这儿啊，这里面什么叫准备环境的一个初始化工作吧。

在这个环境初始化工作里面。

其实分了最基本的几个步骤，我把这个步骤来写一下，第一个叫获取或创建一个环境。

跌不着，或者创建，环境好，当然我们都知道，当你换创建这个环境的时候，他需要依托于谁，想想等一下我一边改大一点，变化吗，有变化，这些东西都往外挪一下啊，整体上第一个步骤，这注意了，你是根据什么，根据。

只要根据当前应用程序的类型来做判断的，想一下这个步骤啊，这个步骤可以跟我们哪块东西给关联起来，还记得吗，我在完成当前这个程序初始化的时候，这是个初始化，在说话，是不是有有有一个类型的判断。

所以这块其实可以勾一条线过来到这个地方啊，这能看懂吗，啧好吧，根据我们这样一个参数类型来进行一个整体的判断，因为这会返回说你具体是什么样的一个类型，我看这没问题，这现在看明白了。

这第一个你先进行一个创建步骤，创建完成之后，第二步是干嘛。

进行一个相关参数的一个配置吧。

当前环境进行，就这个属性，当然配置什么东西，我这不说了，你下来之后自己可以进行一个查看这这个细节啊，这块不懂啊啊这就不够，地盘不够啊，先放上面。

第三步骤在干嘛，这个太不用管它了吧，是不是就是配一个什么叫default properties的一个东西好，或就是旁边你自己的东西，ok这是又到这儿了。

listen了，listener这一块了，这个listener这一块它创建一个什么东西，叫environment prepared，是相当于是一个全新的一个整体事件，这个全新事件最终会用到谁。

是不是还是看到我们下面这个地方来我这画一下，把图拿过来啊，我说了啊，这个有可能会有一些交叉下来，看的时候自己免免啊，凑合去看一下，我把这个线给大家打过来，画一条线，把这个环节。

这些东西啊都是有整体的一个关联的，不是说我想怎么做就怎么做，不是不是这样的，明白了吧，这样一个环节来这块能看懂吧，好了是这样的东西好了。

这个完成，棒哥给我说，这东西没啥用啊，我们这就像目前看起来还没啥用。

然后最终把我们就要返回去，这个处理的一个环节来这样的制度，同学扣个一，还在线吗，这些关键步骤可以做一个详细的做一做呃，大概罗列一下啊，好了，这个完成之后来再来看第六步骤，第六部哪去了，就这样吧。

第六步做什么事，是不是设置我们对应的一些系统使属性，这就是系统属性，所以这块其实没啥看的，是a系统属性，你们平常用的时候可能也几乎没怎么用过，这句话你注意就行了，再说哪个系统属性啊。

把系统属性给大家说一下哪个系统属性啊，我找一下劣质。

来来好吧，这是我们的第六步骤，让大家看，这是我们的第七步骤，嗯，是干嘛的，是不是准备我们banner的一个打印了，这个banner打印ban打印其实也非常非常简单，就是说它是按照几种方式进行打印的呀。

是不是两种方式的一个选择，那我先把这个干嘛给他粘过来啊，不到打印没关系。

怎么打印的，画一下，先判断，有图片吧，只支持，支持什么叫jpg，然后呢gf，然后呢png图片，这是第二步骤，第一步骤，这如果没有的话，如果没有的话，第二步在干嘛，叫banner。txt文件，内容对吧。

如果这也没有的话，第三步，打印的循环打印输出，是啊logo吧，默认的banner，就经历了这三个选项，那我来第一个，第三个，就是买东西，ok这样看懂吧，说了对对对，就这些东西啊，很多东西啊。

能但是我思路往里面写东西，说明你还记得当时咱们讲课讲了点啥，还有点印象好吧，这是我们的第七步，第八步就到这了吧，第八步做什么事啊，是不是说了叫准备上下文的一个基本对象，别别别，当然基本环境都讲了。

上下文，没有，啊这这个步骤要做的一个事情是第八步骤。

第八周回来之后也一样。

二位，在创建的时候它也是一样吧，根据什么来创建的。

还记得吗，是不是还是根据我们对应一个一obligation，它的一个类型来进行创建的哦。

这里要注意了，这里写一下，不过，当前应用程序的类型来判断创建，格式的上下文对象啊，这块呢大家注意就行了，这块我还要再给大家写一个最呃写一个小提示吧，30写小提示，在看到上下呃，再看到。

上下文的对象之后一定要，地图啧啧啧，好在父子关系的内容，对很多初始化的操作啊，容易忽略，说是啥吧，大家想一下，如果你是一个application这样类型的一个参考值的话，最终会创建一个啥来着。

还记得吗，搜一下叫ano，是不是东西创建它吧，当你创建它的时候，它最终哪去了。

它的一个最基本的构造方法是创建了一个reader和scout，一个对象，有它之后，你看一下它的类图，我当时就在你们看了，我看不是他，这图链图里面有一次有很多层次的一个继承关系，比如说它复类是他父类。

是它这些基层关系里面，每个里面是不是都完成很多的事情，这东西啊在你们看那个呃死轮研发，这时候应该有有有有机会看到啊，跟spring里面差不多，所以这块你不忽略了，不要忽略了之后在哪呢。

在这个generate写下这个类，啊这儿有个非常关键的类啊。

我们再找一下来，想给你们看一下好，里面它是不是也有一个对应的构造方法，还记得吗，什么叫defaullable factory吧，把它拿过来，我们找一下刚刚那个类。

有这类之后。

第二个，注意这类。

因为高我们再看原版的大a应该已经发现了，像刚刚说的那个类，在后面的时候有很多地方其实都用到了，好一定把两个给我记住了，它的层次关系是怎么找的，一层一层，你是怎么发现它的，一定要知道一个核心，来有印象。

同学扣个一，有没有印象，都有都有这块东西啊，一定要记着他好吧好，帮你们做做做做这个细化了，这里面东西太多了啊，这块完之后我们还要做一个最基本的关联点关联啊。

根据我们当前这个应用程序的一个类型值来做一个基本判断的，好，这块大家注意了啊，两个地方都用到了我们这样一个类型判断，来三把阿凡，他什么东西该第六期，1956819波是设置什么异常报告对象吧。

这对象没啥可看的，就是报告我们对应程序启动过程中，它所涉及到一些异常情况，这块还是比较简单的，还是比较简单的，大家看第十步是这样吧，我准备当前上下文的一个环境对象，这块东西可能稍微麻烦一点啊。

稍微麻烦一点，我们依然一样往里边画对应的一个细节，想想在准备我们这个上下文环境的时候。

你需要考虑什么事儿，contact的是它给它写完之后，里面做了n多的一个事情嘛，对吧，你想想这里面事情是干嘛用的，我们只说几个比较关键的东西，这个表关键特点，第一个是不是设置我们环境，这不用说了吧。

这没啥可重要的好吧，第三个叫post processor呃，叫application这块儿他做点什么事情还记得吗，判断一下你当前类到底归属于什么类型，然后呢往里边加载一下，注册一个实例对象吧，这也没啥。

这也没啥好吧，大家看第三个这东西。

看着啊，剩下的东西你下一周自己自己往前往里边补充啊，初始化器进行执行啊，进行执行，而在这个执行的环节里面点进去。

在里面是不是到了什么叫letter，诶不对，这里面是不是也是一循环过程，每次进来之后是不是都有一个循环，循环完之后，一个初始化器都做一个相应的执行，大于执行完之后能获取到对应的一个初始化的一个操作。

说的好吧。

这也一样，把这个细节步骤注注注意就行了，这里面还要强调一件事，我说了后面可能会呃，可能会用到它什么东西呢，执行，然后呢像，in factory，注入了三个叫post，co 2的对象啊。

后续再自动装配的时候会用到味道，啊有有没有点印象了，这块东西什么叫mate，叫catch，mate date，什么东西哦，还有一个config file，什么东西，应该还记得吧。

我当时都都都都讲过这些东西啊，在干嘛，是不是又到我们的listener了，这是不是又匹配上了，这个同学要指向什么地方，让他打一个虚线，他是不是也要调用这样整体的过程，这一模一样的，这一模一样的。

那再往下看看下面还有啥认知的输出，不管它注册单体，并不管它对，还有这东西，嗯，哎呃加载很多资源配置是自动装配，然后呢再死环节，是不是这意思啊，好吧，就这样的一个步骤，这块，下面还有最后一句话。

是不是又是listeners的什么东西拿过来，对应监听器它完成了一个基本操作了，那这块的话也一样，也要指向这个环节啊，啧是不是这个东西啊，这块儿大家还记得吗，来到目前为止，还能听懂同学扣个一，我来带你。

我来帮你梳理一块东西啊，后来把它点个点个四，走，然后上下之间对，是这样的东西啊，破坏了还要自己点一下，肯定要自己点的，你不点的话肯定肯定不行啊，准备上下文对象，这不来再往回返看一下我们的第11步骤。

这干嘛呢，刷新吧，这刷新这个东西我说了是一个关键性的一个操作，好吧，呃重点spring的时候好会讲到之前看没没没看的同学，下来之后自己来搜一下，我们这儿不再浪费时间给你们画这个细节，细细节东西来大家看。

第12步骤，很多就多了台，啊这是不是可以了啊，这块好多了好了，这样写完之后，第12步干嘛了，就方便做一些扩展交易，就是刷新之后要做的一个基本事情对吧，这个东西没啥可默认就是空的嘛。

你之后如果要做扩展的话，可以把这块内容做一个整体的补充，然后第13步骤是不是进程结束，我要往里面打印一些很多新的东西了对吧，最后还有最后一步是运行所有的一个监视器的一个对象啊，然后呢啧啧，大启动执行。

这块儿喝完之后打。

还有别的玩，我拿过来，coroners虽然少了一个步骤，叫listener star，但是我们做备的listen star。

诶这里的步骤，三步骤了这吧，我要被这个东西，我要被这个搞死了，啧啧啧，耦合到一块儿了啊，12步骤是after reflash。

然stole watch上面有这个这个这个东西啊，我start把它拿过来。

给少写一个步骤，啧啧，再点下线，有种，来，来来14过来吧，从这儿可以吧，哇这这个步骤，那下面我们再多加一个。

是不是最后一个这东西吧。

我带你们看这里面的一个核心代码，其实里面几乎什么事都没做一样啊，跟什么事情没做一样，把它来装方法，哎，15步，就搞定了吧是吧，就是我们的一个整体的running这样的一个环节是running的话。

点进去看一下是不是也listener running，我们这儿再点一条线吧。

把这个线再点过来，ok这一样的这条线是一条虚线，所以你看过来之后，最左边那个13步，如果这个顺序有问题啊，现在就自己做一个调整的好吧，画乱了啊，来我们刚刚图画这么多，是他能写的一些核心的环节。

我都帮你们写好了，看完这个图之后，有没有感觉稍微清晰那么一丢丢啊，有吗，这句话大家我把那个pos文件也发，大家也发现大家，所以上去之后按照这样的一个顺序去依次点一下啊，依次点一下啊。

看一下整体的一个处理环节到底做什么事儿，每个东西还可以往里边细点，往里面补充什么东西，所以最好啊，呃你画一个比较深的一个像思维导图也行，画这个图也行啊，这块可以做这个图，我给大家说一下，其实之前我说了。

我画过，但画的东西不是这样的东西呃，之前画过一个类似的，大家看就这样的图，这句话写的就比较简略了，我写就比较简略了，懂我意思吧，要简略啊，里面都是一些核心应用呃，写的比较简略啊，不是特别细节。

刚刚给他画的东西是比较详细的，来再写一下boss 2。2。2，过程分析题的过程流程，我会把那个pos文件和那个图片文件都翻，大家在之后一定要自己点那关于的一个启动类这块东西，我们就不再浪费时间了。

下周一定要点分，现在开始我们开始讲一下自动装配相关的东西，先讲自动装配的时候说过了，最终啊最终啊还是要回到我们这个启动过程里面，因为在启动过程的时候，其实它已经帮我们完成了自动装配这样一个过程了啊。

只不过大家可能没看到之后，我们会点到细节的源码里面，看一下它到底是怎么做的，之前你们应该看过一些自动装配东西是吧，我来我说一下你们之前怎么看的，很多人是这样告诉大家的。

你在看这个自动装配的时候，找到当前主类，然后呢在当前主页里面等一下点，然后这有个东西叫enable auto confia，auto confi。

点进去这个东西叫out of confusion part letter，所以你可以点一下这个类，在搬运类里面完成了很多对应初始化的一些工作，做完之后就搞定了，这不对好吧，你应该知道什么东西。

你应该知道当前这个类是什么时候，将来的，为什么能加在当前这个注释类，它是什么时候找到它的这个类，你要所以之后我你看的时候还会深入到原版里面，我们找这个类到底什么时候完成了，并对象一个注册。

以及它如何进行加载的，听懂我意思吧，保持这个环，我们到时候还要再走一次，还要再走一次呃，有一部分要走一次，大部分就不重不重走了，听白意思吗，你从网上看那些自动转换原理，我不是说的不对啊。

呃他讲的东西比较怎么说呢，没到那个没没没没到那个点到那个点才对，你要告诉他这个整体的一个处理流程行吧，好了多，那咱们就不多说了啊，我们画这几个过程给大家捋了一下，大家捋了一下。

然后后续我们再讲一下自动装配什么的这些东西呃，尽量给大家讲的最最清楚一点，当然我说了，按照我的计划，其实什么源码我看可能还有还有好几节课，是这一次我们讲自动装配，讲一下这个自定义的，咱们就结束了啊。

别东西就在大家说了啊，不太大说了呃，才能有兴趣的同学，我们之后再详细聊后续课程时回答补好吧，那还有啥问题吗，没问题的话，下课了下课了啊，我也休息了，今天上了四个小时，挺累的，大家休息了啊。