1.画带你彻底弄懂三级缓存和循环依赖的画图问题
2.JDK成长记7：3张图搞懂HashMap底层原理！
3.手把手超详细！解源教你用turtle画一个象棋棋盘附源码

画带你彻底弄懂三级缓存和循环依赖的码画问题

       大家好。我们都知道，图解Spring可以通过三级缓存解决循环依赖的源码问题，这也是画图扫描源码后门面试中很常见的一个面试题，本文就来着重讨论一下有关循环依赖和三级缓存的解源问题。

一、码画什么是图解循环依赖

       大家平时在写业务的时候应该写过这样的代码。

       其实这种类型就是源码循环依赖，就是画图AService 和BService两个类相互引用。

二、解源三级缓存可以解决的码画循环依赖场景

       如上面所说，大家平时在写这种代码的图解时候，项目其实是源码可以起来的，也就是说其实三级缓存是可以解决这种循环依赖的。

       当然除了这种字段注入，set注入也是可以解决的，代码如下。

       接下来就来探究三级缓存是如何解决这种循环依赖的？

三、Spring的Bean是如何创建出来的

       本文所说的Bean和对象可以理解为同一个意思。

       先说如何解决循环依赖之前，先来了解一下一个Bean创建的大致流程。为什么要说Bean的创建过程，因为循环依赖主要是发生在Bean创建的过程中，知道Bean是如何创建的，才能更好的理解三级缓存的作用。

       其实Spring Bean的生命周期源码剖析我也在微信公众号 三友的java日记 中发过，并且有简单的提到三级缓存，有兴趣的同学可以在关注公众号之后回复 Bean 即可获取文章链接，里面有Bean创建过程更详细的说明。这里我简单画一张图来说一下。

       其实图里的每个阶段还可以分为一些小的阶段，我这里就没画出来了。

       来说一下每个阶段干了什么事。

       BeanDefinition的读取阶段：我们在往Spring容器注入Bean的时候，一般会通过比如xml方式，@Bean注解的方式，@Component注解的方式，其实不论哪一种，容器启动的时候都会去解析这些配置，然后为每个Bean生成一个对应的BeanDefinition，这个BeanDefinition包含了这个Bean的创建的信息，Spring就是根据BeanDefinition去决定如何创建一个符合你要求的Bean

       Bean的实例化阶段：这个阶段主要是将你配置的Bean根据Class的类型创建一个对象出来

       Bean的属性赋值阶段：这个阶段主要是用来处理属性的赋值，比如@Autowired注解的生效就是在这个阶段的

       Bean的初始化阶段：这个阶段主要是回调一些方法，比如你的类实现了InitializingBean接口，那么就会回调afterPropertiesSet方法，同时动态代理其实也是在这个阶段完成的。

       其实从这可以看出，一个Spring Bean的生成要分为很多的阶段，只有这些事都处理完了，这个Bean才是完完全全创建好的Bean，也就是我们可以使用的Bean。

四、CTF思维考题找到源码三级缓存指的是哪三级缓存

       这里直接上源码

       第一级缓存：singletonObjects

       存放已经完完全全创建好的Bean，什么叫完完全全创建好的？就是上面说的是，所有的步骤都处理完了，就是创建好的Bean。一个Bean在产的过程中是需要经历很多的步骤，在这些步骤中可能要处理@Autowired注解，又或是处理@Transcational注解，当需要处理的都处理完之后的Bean，就是完完全全创建好的Bean，这个Bean是可以用来使用的，我们平时在用的Bean其实就是创建好的。

       第二级缓存：earlySingletonObjects

       早期暴露出去的Bean，其实也就是解决循环依赖的Bean。早期的意思就是没有完完全全创建好，但是由于有循环依赖，就需要把这种Bean提前暴露出去。其实 早期暴露出去的Bean 跟 完完全全创建好的Bean 他们是同一个对象，只不过早期Bean里面的注解可能还没处理，完完全全的Bean已经处理了完了，但是他们指的还是同一个对象，只不过它们是在Bean创建过程中处于的不同状态，如果早期暴露出去的Bean跟完完全全创建好的Bean不是同一个对象是会报错的，项目也就起不来，这个不一样导致报错问题，这里我会结合一个案例再来写一篇文章，这里不用太care，就认为是一样的。

       第三级缓存：singletonFactories

       存的是每个Bean对应的ObjectFactory对象，通过调用这个对象的getObject方法，就可以获取到早期暴露出去的Bean。

       注意：这里有个很重要的细节就是三级缓存只会对单例的Bean生效，像多例的是无法利用到三级缓存的，通过三级缓存所在的类名DefaultSingletonBeanRegistry就可以看出，仅仅是对SingletonBean也就是单例Bean有效果。

五、三级缓存在Bean生成的过程中是如何解决循环依赖的

       这里我假设项目启动时先创建了AService的Bean，那么就会根据Spring Bean创建的过程来创建。

       在Bean的实例化阶段，就会创建出AService的对象，此时里面的@Autowired注解是没有处理的，创建出AService的对象之后就会构建AService对应的一个ObjectFactory对象放到三级缓存中，通过这个ObjectFactory对象可以获取到AService的早期Bean。

       然后AService继续往下走，到了某一个阶段，开始处理@Autowired注解，要注入BService对象，如图

       要注入BService对象，肯定要去找BService对象，那么他就会从三级缓存中的第一级缓存开始依次查找有没有BService对应的Bean，肯定都没有啊，因为BService还没创建呢。没有该怎么办呢？其实很好办，没有就去创建一个么，共享充电宝源码java这样不就有了么。于是AService的注入BService的过程就算暂停了，因为现在得去创建BService，创建之后才能注入给AService。

       于是乎，BService就开始创建了，当然他也是Spring的Bean，所以也按照Bean的创建方式来创建，先实例化一个BService对象，然后缓存对应的一个ObjectFactory到第三级缓存中，然后就到了需要处理@Autowired注解的时候了，如图。

       @Autowired注解需要注入AService对象。注入AService对象，就需要先去拿到AService对象，此时也会一次从三级缓存查有没有AService。

       先从第一级查，有没有创建好的AService，肯定没有，因为AService此时正在在创建（因为AService在创建的过程中需要注入BService才去创建BService的，虽然此刻代码正在创建BService，但是AService也是在创建的过程中，只不过暂停了，只要BService创建完，AService会继续往下创建）；第一级缓存没有，那么就去第二级看看，也没有，没有早期的AService；然后去第三级缓存看看有没有AService对应的ObjectFactory对象，惊天的发现，竟然有(上面提到过，创建出AService的对象之后，会构建AService对应的一个ObjectFactory对象放到三级缓存中)，那么此时就会调用AService对应的ObjectFactory对象的getObject方法，拿到早期的AService对象，然后将早期的AService对象放到二级缓存，为什么需要放到二级缓存，主要是怕还有其他的循环依赖，如果还有的话，直接从二级缓存中就能拿到早期的AService对象。

       虽然是早期的AService对象，但是我前面说过，仅仅只是早期的AService对象可能有些Bean创建的步骤还没完成，跟最后完完全全创建好的AService Bean是同一个对象。

       于是接下来就把早期的AService对象注入给BService。

       此时BService的@Autowired注解注入AService对象就完成了，之后再经过其他阶段的处理之后，BService对象就完完全全的创建完了。

       BService对象创建完之后，就会将BService放入第一级缓存，然后清空BService对应的第三级缓存，当然也会去清空第二级缓存，只是没有而已，至于为什么清空，轰炸机源码2.1很简单，因为BService已经完全创建好了，如果需要BService那就在第一级缓存中就能查找到，不需要在从第二级或者第三级缓存中找到早期的BService对象。

       BService对象就完完全全的创建完之后，那么接下来该干什么呢？此时当然继续创建AService对象了，你不要忘了为什么需要创建BService对象，因为AService对象需要注入一个BService对象，所以才去创建BService的，那么此时既然BService已经创建完了，那么是不是就应该注入给AService对象了？所以就会将BService注入给AService对象，这下就明白了，BService在构建的时候，已经注入了AService，虽然是早期的AService，但的确是AService对象，现在又把BService注入给了AService，那么是不是已经解决了循环依赖的问题了，AService和BService都各自注入了对方，如图。

       然后AService就会跟BService一样，继续处理其它阶段的，完全创建好之后，也会清空二三级缓存，放入第一级缓存。

       到这里，AService和BService就都创建好了，循环依赖也就解决了。

       这下你应该明白了三级缓存的作用，主要是第二级和第三级用来存早期的对象，这样在有循环依赖的对象，就可以注入另一个对象的早期状态，从而达到解决循环依赖的问题，而早期状态的对象，在构建完成之后，也就会成为完完全全可用的对象。

六、三级缓存无法解决的循环依赖场景1）构造器注入无法解决循环依赖

       上面的例子是通过@Autowired注解直接注入依赖的对象，但是如果通过构造器注入循环依赖的对象，是无法解决的，如代码下

       构造器注入就是指创建AService对象的时候，就传入BService对象，而不是用@Autowired注解注入BService对象。

       运行结果

       启动时就会报错，所以通过构造器注入对象就能避免产生循环依赖的问题，因为如果有循环依赖的话，那么就会报错。

       至于三级缓存为什么不能解决构造器注入的问题呢？其实很好理解，因为上面说三级缓存解决循环依赖的时候主要讲到，在AService实例化之后，会创建对应的ObjectFactory放到第三级缓存，发生循环依赖的时候，可以通过ObjectFactory拿到早期的淘宝客源码搭建流程AService对象；而构造器注入，是发生在实例化的时候，此时还没有AService对象正在创建，还没完成，压根就还没执行到往第三级添加对应的ObjectFactory的步骤，那么BService在创建的时候，就无法通过三级缓存拿到早期的AService对象，拿不到怎么办，那就去创建AService对象，但是AService不是正在创建么，于是会报错。

2）注入多例的对象无法解决循环依赖**

       启动引导类

       要获取AService对象，因为多例的Bean在容器启动的时候是不会去创建的，所以得去获取，这样就会创建了。

       运行结果

       为什么不能解决，上面在说三级缓存的时候已经说过了，三级缓存只能对单例Bean生效，那么多例是不会起作用的，并且在创建Bean的时候有这么一个判断，那就是如果出现循环依赖并且是依赖的是多例的Bean，那么直接抛异常，源码如下

       注释其实说的很明白，推测出现了循环依赖，抛异常。

       所以上面提到的两种循环依赖的场景，之所以无法通过三级缓存来解决，是因为压根这两种场景就无法使用三级缓存，所以三级缓存肯定解决不掉。\

七、不用三级缓存，用二级缓存能不能解决循环依赖

       遇到这种面试题，你就跟面试官说，如果行的话，Spring的作者为什么不这么写呢？

       哈哈，开个玩笑，接下来说说到底为什么不行。

       这里我先说一下前面没提到的细节，那就是通过ObjectFactory获取的Bean可能是两种类型，第一种就是实例化阶段创建出来的对象，还是一种就是实例化阶段创建出来的对象的代理对象。至于是不是代理对象，取决于你的配置，如果添加了事务注解又或是自定义aop切面，那就需要代理。这里你不用担心，如果这里获取的是代理对象，那么最后完全创建好的对象也是代理对象，ObjectFactory获取的对象和最终完全创建好的还是同一个，不是同一个肯定会报错，所以上面的理论依然符合，这里只是更加的细节化。

       有了这个知识点之后，我们就来谈一下为什么要三级缓存。

       第一级缓存，也就是缓存完全创建好的Bean的缓存，这个缓存肯定是需要的，因为单例的Bean只能创建一次，那么肯定需要第一级缓存存储这些对象，如果有需要，直接从第一级缓存返回。那么如果只能有二级缓存的话，就只能舍弃第二级或者第三级缓存。

       假设舍弃第三级缓存

       舍弃第三级缓存，也就是没有ObjectFactory，那么就需要往第二缓存放入早期的Bean，那么是放没有代理的Bean还是被代理的Bean呢？

       1）如果直接往二级缓存添加没有被代理的Bean，那么可能注入给其它对象的Bean跟最后最后完全生成的Bean是不一样的，因为最后生成的是代理对象，这肯定是不允许的；

       2）那么如果直接往二级缓存添加一个代理Bean呢？

       假设没有循环依赖，提前暴露了代理对象，那么如果跟最后创建好的不一样，那么项目启动就会报错，

       假设没有循环依赖，使用了ObjectFactory，那么就不会提前暴露了代理对象，到最后生成的对象是什么就是什么，就不会报错，

       如果有循环依赖，不论怎样都会提前暴露代理对象，那么如果跟最后创建好的不一样，那么项目启动就会报错

       通过上面分析，如果没有循环依赖，使用ObjectFactory，就减少了提前暴露代理对象的可能性，从而减少报错的可能。

       假设舍弃第二级缓存

       假设舍弃第二级缓存，也就是没有存放早期的Bean的缓存，其实肯定也不行。上面说过，ObjectFactory其实获取的对象可能是代理的对象，那么如果每次都通过ObjectFactory获取代理对象，那么每次都重新创建一个代理对象，这肯定也是不允许的。

       从上面分析，知道为什么不能使用二级缓存了吧，第三级缓存就是为了避免过早地创建代理对象，从而避免没有循环依赖过早暴露代理对象产生的问题，而第二级缓存就是防止多次创建代理对象，导致对象不同。

       本文完。

       如果觉得这篇文章对你有所帮助，还请帮忙点赞、在看、转发给更多的人，码字不易，非常感谢！

欢迎关注公众号 三友的java日记，更多技术干货及时获得。原文：/post/

JDK成长记7：3张图搞懂HashMap底层原理！

       一句话讲， HashMap底层数据结构，JDK1.7数组+单向链表、JDK1.8数组+单向链表+红黑树。

       在看过了ArrayList、LinkedList的底层源码后，相信你对阅读JDK源码已经轻车熟路了。除了List很多时候你使用最多的还有Map和Set。接下来我将用三张图和你一起来探索下HashMap的底层核心原理到底有哪些？

       首先你应该知道HashMap的核心方法之一就是put。我们带着如下几个问题来看下图：

       如上图所示，put方法调用了putVal方法，之后主要脉络是：

       如何计算hash值？

       计算hash值的算法就在第一步，对key值进行hashCode()后，对hashCode的值进行无符号右移位和hashCode值进行了异或操作。为什么这么做呢？其实涉及了很多数学知识，简单的说就是尽可能让高和低位参与运算，可以减少hash值的冲突。

       默认容量和扩容阈值是多少？

       如上图所示，很明显第二步回调用resize方法，获取到默认容量为，这个在源码里是1<<4得到的，1左移4位得到的。之后由于默认扩容因子是0.，所以两者相乘就是扩容大小阈值*0.=。之后就分配了一个大小为的Node[]数组，作为Key-Value对存放的数据结构。

       最后一问题是，如何进行hash寻址的？

       hash寻址其实就在数组中找一个位置的意思。用的算法其实也很简单，就是用数组大小和hash值进行n-1&hash运算，这个操作和对hash取模很类似，只不过这样效率更高而已。hash寻址后，就得到了一个位置，可以把key-value的Node元素放入到之前创建好的Node[]数组中了。

       当你了解了上面的三个原理后，你还需要掌握如下几个问题:

       还是老规矩，看如下图：

       当hash值计算一致，比如当hash值都是时，Key-Value对的Node节点还有一个next指针，会以单链表的形式，将冲突的节点挂在数组同样位置。这就是数据结构中所提到解决hash 的冲突方法之一：单链法。当然还有探测法+rehash法有兴趣的人可以回顾《数据结构和算法》相关书籍。

       但是当hash冲突严重的时候，单链法会造成原理链接过长，导致HashMap性能下降，因为链表需要逐个遍历性能很差。所以JDK1.8对hash冲突的算法进行了优化。当链表节点数达到8个的时候，会自动转换为红黑树，自平衡的一种二叉树，有很多特点，比如区分红和黑节点等，具体大家可以看小灰算法图解。红黑树的遍历效率是O(logn)肯定比单链表的O(n)要好很多。

       总结一句话就是，hash冲突使用单链表法+红黑树来解决的。

       上面的图，核心脉络是四步，源码具体的就不粘出来了。当put一个之后，map的size达到扩容阈值，就会触发rehash。你可以看到如下具体思路：

       情况1:如果数组位置只有一个值：使用新的容量进行rehash，即e.hash & (newCap - 1)

       情况2:如果数组位置有链表，根据 e.hash & oldCap == 0进行判断，结果为0的使用原位置，否则使用index + oldCap位置,放入元素形成新链表，这里不会和情况1新的容量进行rehash与运算了，index + oldCap这样更省性能。

       情况3：如果数组位置有红黑树，根据split方法，同样根据 e.hash & oldCap == 0进行树节点个数统计，如果个数小于6，将树的结果恢复为普通Node，否则使用index + oldCap，调整红黑树位置，这里不会和新的容量进行rehash与运算了，index + oldCap这样更省性能。

       你有兴趣的话，可以分别画一下这三种情况的图。这里给大家一个图，假设都出发了以上三种情况结果如下所示：

       上面源码核心脉络，3个if主要是校验了一堆，没做什么事情，之后赋值了扩容因子，不传递使用默认值0.，扩容阈值threshold通过tableSizeFor(initialCapacity);进行计算。注意这里只是计算了扩容阈值，没有初始化数组。代码如下：

       竟然不是大小*扩容因子？

       n |= n >>> 1这句话，是在干什么？n |= n >>> 1等价于n = n | n >>>1; 而|表示位运算中的或，n>>>1表示无符号右移1位。遇到这种情况，之前你应该学到了，如果碰见复杂逻辑和算法方法就是画图或者举例子。这里你就可以举个例子：假设现在指定的容量大小是,n=cap-1=，那么计算过程应该如下：

       n是int类型，java中一般是4个字节，位。所以的二进制： 。

       最后n+1=，方法返回，赋值给threshold=。再次注意这里只是计算了扩容阈值，没有初始化数组。

       为什么这么做呢？一句话，为了提高hash寻址和扩容计算的的效率。

       因为无论扩容计算还是寻址计算，都是二进制的位运算，效率很快。另外之前你还记得取余(%)操作中如果除数是2的幂次方则等同于与其除数减一的与(&)操作。即 hash%size = hash & (size-1)。这个前提条件是除数是2的幂次方。

       你可以再回顾下resize代码，看看指定了map容量，第一次put会发生什么。会将扩容阈值threshold，这样在第一次put的时候就会调用newCap = oldThr;使得创建一个容量为threshold的数组，之后从而会计算新的扩容阈值newThr为newCap*0.=*0.=。也就是说map到了个元素就会进行扩容。

       除了今天知识，技能的成长，给大家带来一个金句甜点，结束我今天的分享：坚持的三个秘诀之一目标化。

       坚持的秘诀除了上一节提到的视觉化，第二个秘诀就是目标化。顾名思义，就是需要给自己定立一个目标。这里要提到的是你的目标不要定的太高了。就比如你想要增加肌肉，给自己定了一个目标，每天5组，每次个俯卧撑，你看到自己胖的身形或者海报，很有刺激，结果开始前两天非常厉害，干劲十足，特别奥利给。但是第三天，你想到要个俯卧撑，你就不想起床，就算起来，可能也会把自己撅死过去......其实你的目标不要一下子定的太大，要从微习惯开始，比如我媳妇从来没有做过俯卧撑，就让她每天从1个开始,不能多，我就怕她收不住，做多了。一开始其实从习惯开始，先变成习惯，再开始慢慢加量。量太大养不成习惯，量小才能养成习惯。很容易做到才能养成，你想想是不是这个道理？

       所以，坚持的第二个秘诀就是定一个目标，可以通过小量目标，养成微习惯。比如每天你可以读五分钟书或者5分钟成长记，不要多，我想超过你也会睡着了的.....

       最后，大家可以在阅读完源码后，在茶余饭后的时候问问同事或同学，你也可以分享下，讲给他听听。

手把手超详细！教你用turtle画一个象棋棋盘附源码

       本文教你使用turtle库画出中国象棋棋盘并提供源代码，助你掌握画图技能。

       一、简介

       通过turtle绘制象棋棋盘示意图。

       二、确定尺寸

       设定棋盘尺寸，确保绘图比例合适。

       三、初始化

       初始化棋盘尺寸数据，为绘制做准备。

       四、定义自定义函数

       创建一个函数简化坐标操作，方便后续绘制。

       五、画两个外边框

       使用turtle库绘制棋盘的外部边界。

       六、画棋盘主体

       设计思路，逐步绘制棋盘内部。

       七、画将帅老窝斜线

       根据路径绘制棋盘上的特殊斜线。

       八、绘制楚河汉界

       添加棋盘分割线，增加细节。

       九、完整源代码

       提供Python代码，详细注释，助你快速上手。

       此过程充满挑战，耗时较长，但通过实践可显著提升Python与turtle技能。

       若有关于棋盘绘制的疑问，请直接留言。如有帮助，不妨点赞与转发。感谢你的参与！

       关注Python入门速学，一同深入学习Python。