1.Java常用框架组合(java框架)
2.Netty基础篇2-Netty核心模块组件
3.HashMap为什么不安全？

Java常用框架组合(java框架)

       java常用的链表链表框架有哪些?

       web层框架：SpringMVC、Struts2、反转反转Struts1、源码GoogleWebToolkit（GWT）、算法扰皮简JQWEB

       服务层框握迹架缓裤：Spring、链表链表EJB

       持久层框架：Hibernate、反转反转赞助我们页面源码MyBatis、源码JPA、算法TopLink

       Java中最常用的链表链表集合类框架？

       一、HashMap的反转反转概述

       HashMap可以说是Java中最常用的集合类框架之一,是Java语言中非常典型的数据结构。

       HashMap是源码基于哈希表的Map接口实现的,此实现提供所有可选的映射操作。天通苑电脑培训发现存储的算法是对的映射，允许多个null值和一个null键。链表链表但此类不保证映射的反转反转顺序，特别是源码它不保证该顺序恒久不变。

       除了HashMap是非同步以及允许使用null外，HashMap类与Hashtable大致相同。

       此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get和put）提供稳定的性能。迭代collection视图所需的时间与HashMap实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。

       HashMap的实冲行培例有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行rehash操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

       通常，默认加载因子(0.)在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数HashMap类的操作中，包括get和put操作，都反映了这一点）。swt.jar源码在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少rehash操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生rehash操作。

       注意，此实现不是同步的。如果多个线程同时访问一个HashMap实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。这通常是通过同步那些用来封装列表的对象来实现的。但如果没有这样的对象存在，则应该使用{ @linkCollections#synchronizedMapCollections.synchronizedMap}来进行“包装”，该方法最好是在创建时完成，为了避免对映射进行意外的非同步操作。

       Mapm=Collections.synchronizedMap(newHashMap(...));

       二、构造函数

       HashMap提供了三个构造函数：

       HashMap()：带念构造一个具有默认初始容量()和默认加载因子(0.)的空HashMap。

       HashMap(intinitialCapacity)：构造一个带指定初始容量和默认加载因子(0.)的空HashMap。

       HashMap(intinitialCapacity,floatloadFactor)：构造一个带指定初始容量和加载因子的空HashMap。

       这里提到了两个散唯参数：初始容量，加载因子。这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.，eclipse 下载源码失败一般情况下我们是无需修改的。

       HashMap是一种支持快速存取的数据结构，要了解它的性能必须要了解它的数据结构。

Java的三大框架是什么？

       java三大框架是：

       1、Struts

       为了解决这些问题，出现了Struts框架，它是一个完美的MVC实现，它有一个中央控制类（一个Servlet），针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输团肢出显示，还有一个Form类负责传递Action和JSP中间的数据。JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。从此JSP页面中不需要出现一行包围的Java代码了。

       可是所有的运算逻辑都放在Struts的Action里将使得Action类复用度低和逻辑混乱，所以通常人们会把整个Web应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写。

       使用JDBC连接来读写数据库，我们最常见的就是打开数据库连接、使用复杂的SQL语句进行读写、关闭连接，获得的数据又需要转换或封装后往外传，这是一个非常烦琐的过程。

       2、Hibernate

       这时出现了Hibernate框架，它需要你创建一系列的持久化类，每个类的属性都可以简单的看做和一张数据库表的属性一一对应，当然也可以实现关系数据库的各种表件关联的对应。当我们需要相关操作是，不用再关注数据库表。我们不用再去一行行的openwrt app源码下载查询数据库，只需要持久化类就可以完成增删改查的功能。使我们的软件开发真正面向对象，而不是面向混乱的代码。我的感受是，使用Hibernate比JDBC方式减少了％的编程量。

       现在我们有三个层了，可是每层之间的调用是怎样的呢？比如显示层的Struts需要调用一个业务类，就需要new一个业塌空世务类出来，然后使用；业务层需要调用持久层的类，也需要new一个持久层类出来用。通过这种new的方式互相调用就是软件开发中最糟糕设计的体现。简单的说，就是调用者依赖被调用者，它们之间形成了强耦合，如果我想在其他地方复用某个类，则这个类依赖的其他类也需要包含。程序就变得亏悔很混乱，每个类互相依赖互相调用，复用度极低。如果一个类做了修改，则依赖它的很多类都会受到牵连。为此，出现Spring框架。

       3、Spring

       Spring的作用就是完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。所以Spring框架最核心的就是所谓的依赖注射和控制反转。

       现在的结构是，Struts负责显示层，maven 编译源码命令Hibernate负责持久层，Spring负责中间的业务层，这个结构是目前国内最流行的JavaWeb应用程序架构了。另外，由于Spring使用的依赖注射以及AOP（面向方面编程），所以它的这种内部模式非常优秀，以至于Spring自己也实现了一个使用依赖注射的MVC框架，叫做SpringMVC，同时为了很好的处理事物，Spring集成了Hibernate，使事物管理从Hibernate的持久层提升到了业务层，使用更加方便和强大。

       Struts框架是年就开始起步了，技术相当成熟，目前全球Java开发中Struts框架是显示层技术中当之无愧的王者。它拥有大量的用户群和很好的开发团队。这也是国内大部分Java软件公司对新进员工的基本要求。

java的框架有哪些？

       Java框架可以简化开发难度，更便于我们开发程序。所以学好Java框架还是比较重要的。

       Java的框架主要有：SpringMVC、Spring、Mybatis、Dubbo、Maven、RabbitMQ、Log4j、Ehcache、Redis、Shiro。

       不过这十个我们不需要都学会，只要学会其中四五个比较常用的就腊饥逗可以。

       第一个，SpringMVC。SpringMVC是一种基于Java地实现了WebMVC设计模肢哗式的请求驱动类型的轻量级Web框架，主要是帮助我们简化日常的Web开发;

       第二个，Mybatis。MyBatis是支持普通SQL查询，存储过程和高级映射的优秀持久层框架;

       第三个，Spring。Spring深得企业的青睐;

       第四个，Maven。越来越多的开发人员开始使用maven。

       掌握轮卖以上四种框架，你在找工作的时候就会比较吃香。

java有什么常用开源的框架？

       java常用开源框架如下：\x0d\1.SpringFrameworkJava开源JEE框架\x0d\\x0d\Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。Spring的架构基础是基于使用JavaBean属性的InversionofControl容器。然而，这仅仅是完整图景中的一部分：Spring在使用IoC容器作为构建完关注所有架构层的完整解决方案方面是独一无二的。\x0d\\x0d\2.WebWorkJava开源Web开发框架\x0d\\x0d\WebWork是由OpenSymphony组织开发的，致力于组件化和代码重用的拉出式MVC模式J2EEWeb框架。\x0d\\x0d\3.StrutsJava开源Web开发框架\x0d\\x0d\Struts是一个基于SunJ2EE平台的MVC框架，主要是采用Servlet和JSP技术谨祥罩来实现的。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，在过去的一年中颇受关注。Struts把Servlet、JSP、自定义标签和信息资源(messageresources)整合到一个统一的框架中\x0d\\x0d\4.HibernateJava开源持久层框架\x0d\\x0d\Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合\x0d\\x0d\5.QuartzJava开源调度框架\x0d\\x0d\Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的日程序表。\x0d\\x0d\6.VelocityJava开源模板引擎\x0d\\x0d\Velocity是一个基于java的模板引擎（templateengine）。它允许任何人仅仅简单的使用模板语言（templatelanguage）来引用由java代码定义的对象。当Velocity应用于web开发时，界面设计人员可以和java程序开发人员同步开发一个遵循MVC架构的web站点，也就是说，页面设计人员可以只关注页面的显示效果，而由java程序开发人员关注业务逻辑编码。Velocity将java代码从web页面中分离出来，这样为web站点的长期维护祥闹提供了便利，同时也为我们在JSP和PHP之外又提供了一种可选的方案。\x0d\\x0d\7.IBATISJava开源持久层框架\x0d\\x0d\使用ibatis提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象，这一层与通过Hibernate实现ORM而言基本一致，而对于具体的数据操作，Hibernate会自动生成SQL语句，而ibatis则要求开发者宴或编写具体的SQL语句。相对Hibernate等“全自动”ORM机制而言，ibatis以SQL开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。作为“全自动”ORM实现的一种有益补充，ibatis的出现显得别具意义。

Netty基础篇2-Netty核心模块组件

       欢迎大家关注?github.com/hsfxuebao?，希望对大家有所帮助，要是觉得可以的话麻烦给点一下Star哈

1. Bootstrap 和 ServerBootstrap

       Bootstrap 意思是引导，一个 Netty 应用通常由一个 Bootstrap 开始，主要作用是配置整个 Netty 程序，串联各个组件，Netty 中 Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类

       常见的方法有:

public?ServerBootstrap?group(EventLoopGroup?parentGroup,?EventLoopGroup?childGroup)，该方法用于服务器端，用来设置两个?EventLooppublic?B?group(EventLoopGroup?group)?，该方法用于客户端，用来设置一个?EventLooppublic?B?channel(Class<?extends?C>?channelClass)，该方法用来设置一个服务器端的通道实现public?<T>?B?option(ChannelOption<T>?option,?T?value)，用来给?ServerChannel?添加配置public?<T>?ServerBootstrap?childOption(ChannelOption<T>?childOption,?T?value)，用来给接收到的通道添加配置public?ServerBootstrap?childHandler(ChannelHandler?childHandler)，该方法用来设置业务处理类（自定义的?handler）public?ChannelFuture?bind(int?inetPort)?，该方法用于服务器端，用来设置占用的端口号public?ChannelFuture?connect(String?inetHost,?int?inetPort)?，该方法用于客户端，用来连接服务器端2. Future 和 ChannelFutures

       Netty 中所有的 IO 操作都是异步的，不能立刻得知消息是否被正确处理。但是可以过一会等它执行完成或者直接注册一个监听，具体的实现就是通过 Future 和 ChannelFutures，他们可以注册一个监听，当操作执行成功或失败时监听会自动触发注册的监听事件

       常见的方法有:

Channel?channel()，返回当前正在进行?IO?操作的通道ChannelFuture?sync()，等待异步操作执行完毕3. Channel

       Netty 网络通信的组件，能够用于执行网络 I/O 操作。

       通过Channel 可获得当前网络连接的通道的状态

       通过Channel 可获得 网络连接的配置参数 （例如接收缓冲区大小）

       Channel 提供异步的网络 I/O 操作(如建立连接，读写，绑定端口)，异步调用意味着任何 I/O 调用都将立即返回，并且不保证在调用结束时所请求的 I/O 操作已完成

       调用立即返回一个 ChannelFuture 实例，通过注册监听器到 ChannelFuture 上，可以 I/O 操作成功、失败或取消时回调通知调用方

       支持关联 I/O 操作与对应的处理程序

       不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应，常用的 Channel 类型:

       NioSocketChannel，异步的客户端 TCP Socket 连接。

       NioServerSocketChannel，异步的服务器端 TCP Socket 连接。

       NioDatagramChannel，异步的 UDP 连接。

       NioSctpChannel，异步的客户端 Sctp 连接。

       NioSctpServerChannel，异步的 Sctp 服务器端连接，这些通道涵盖了 UDP 和 TCP 网络 IO 以及文件 IO。

4. Selector

       Netty 基于 Selector 对象实现 I/O 多路复用，通过 Selector 一个线程可以监听多个连接的 Channel 事件。

       当向一个 Selector 中注册 Channel 后，Selector 内部的机制就可以自动不断地查询(Select) 这些注册的 Channel 是否有已就绪的 I/O 事件（例如可读，可写，网络连接完成等），这样程序就可以很简单地使用一个线程高效地管理多个 Channel

5. ChannelHandler 及其实现类

       ChannelHandler 是一个接口，处理 I/O 事件或拦截 I/O 操作，并将其转发到其 ChannelPipeline(业务处理链)中的下一个处理程序。

       ChannelHandler 本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类。ChannelHandler 及其实现类一览图(后)

       ChannelInboundHandler 用于处理入站 I/O 事件。

       ChannelOutboundHandler 用于处理出站 I/O 操作。

       //适配器

       ChannelInboundHandlerAdapter 用于处理入站 I/O 事件。

       ChannelOutboundHandlerAdapter 用于处理出站 I/O 操作。

       ChannelDuplexHandler 用于处理入站和出站事件。

       我们经常需要自定义一个 Handler 类去继承 ChannelInboundHandlerAdapter，然后通过重写相应方法实现业务逻辑，我们接下来看看一般都需要重写哪些方法

public?class?ChannelInboundHandlerAdapter?extends?ChannelHandlerAdapter?implements?ChannelInboundHandler?{ ?@Skip?@Override?public?void?channelRegistered(ChannelHandlerContext?ctx)?throws?Exception?{ ?ctx.fireChannelRegistered();?}?@Skip?@Override?public?void?channelUnregistered(ChannelHandlerContext?ctx)?throws?Exception?{ ?ctx.fireChannelUnregistered();?}?//?通道就绪事件?@Skip?@Override?public?void?channelActive(ChannelHandlerContext?ctx)?throws?Exception?{ ?ctx.fireChannelActive();?}?@Skip?@Override?public?void?channelInactive(ChannelHandlerContext?ctx)?throws?Exception?{ ?ctx.fireChannelInactive();?}?@Skip?@Override?//?通道读取数据事件?public?void?channelRead(ChannelHandlerContext?ctx,?Object?msg)?throws?Exception?{ ?ctx.fireChannelRead(msg);?}?@Skip?@Override?//?数据读取完毕事件?public?void?channelReadComplete(ChannelHandlerContext?ctx)?throws?Exception?{ ?ctx.fireChannelReadComplete();?}?@Skip?@Override?public?void?userEventTriggered(ChannelHandlerContext?ctx,?Object?evt)?throws?Exception?{ ?ctx.fireUserEventTriggered(evt);?}?@Skip?@Override?public?void?channelWritabilityChanged(ChannelHandlerContext?ctx)?throws?Exception?{ ?ctx.fireChannelWritabilityChanged();?}?@Skip?@Override?@SuppressWarnings("deprecation")?//?通道发生异常事件?public?void?exceptionCaught(ChannelHandlerContext?ctx,?Throwable?cause)?throws?Exception?{ ?ctx.fireExceptionCaught(cause);?}}6. Pipeline 和ChannelPipeline

       ChannelPipeline 是一个重点：

       ChannelPipeline 是一个 Handler 的集合，它负责处理和拦截 inbound 或者 outbound 的事件和操作，相当于一个贯穿 Netty 的链。(也可以这样理解：ChannelPipeline 是 保存 ChannelHandler 的 List，用于处理或拦截 Channel 的入站事件和出站操作)

       ChannelPipeline 实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及 Channel 中各个的 ChannelHandler 如何相互交互

       在 Netty 中每个 Channel 都有且仅有一个 ChannelPipeline 与之对应，它们的组成关系如下

       一个 Channel 包含了一个 ChannelPipeline，而 ChannelPipeline 中又维护了一个由 ChannelHandlerContext 组成的双向链表，并且每个 ChannelHandlerContext 中又关联着一个 ChannelHandler

       入站事件和出站事件在一个双向链表中，入站事件会从链表 head 往后传递到最后一个入站的 handler，出站事件会从链表 tail 往前传递到最前一个出站的 handler，两种类型的 handler 互不干扰

       常用方法

?ChannelPipeline?addFirst(ChannelHandler...?handlers)，把一个业务处理类（handler）添加到链中的第一个位置?ChannelPipeline?addLast(ChannelHandler...?handlers)，把一个业务处理类（handler）添加到链中的最后一个位置7. ChannelHandlerContext

       保存 Channel 相关的所有上下文信息，同时关联一个 ChannelHandler 对象,即ChannelHandlerContext 中 包 含 一 个 具 体 的 事 件 处 理 器 ChannelHandler ， 同 时ChannelHandlerContext 中也绑定了对应的 pipeline 和 Channel 的信息，方便对 ChannelHandler进行调用.

       常用方法:

ChannelFuture?close()，关闭通道ChannelOutboundInvoker?flush()，刷新ChannelFuture?writeAndFlush(Object?msg)?，?将?数?据?写?到?ChannelPipeline?中?当?前ChannelHandler?的下一个?ChannelHandler?开始处理（出站）8. ChannelOption

       Netty 在创建 Channel 实例后,一般都需要设置 ChannelOption 参数。 ChannelOption 参数如下:

       ChannelOption.SO_BACKLOG: 对应 TCP/IP 协议 listen 函数中的 backlog 参数，用来初始化服务器可连接队列大小。服务端处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接。多个客户端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog 参数指定了队列的大小。

       ChannelOption.SO_KEEPALIVE : 一直保持连接活动状态

9. EventLoopGroup 和实现类NioEventLoopGroup

       EventLoopGroup 是一组 EventLoop 的抽象，Netty 为了更好的利用多核 CPU 资源，一般会有多个 EventLoop 同时工作，每个 EventLoop 维护着一个 Selector 实例。

       EventLoopGroup 提供 next 接口，可以从组里面按照一定规则获取其中一个 EventLoop来处理任务。在 Netty 服务器端编程中，我们一般都需要提供两个 EventLoopGroup，例如：BossEventLoopGroup 和 WorkerEventLoopGroup。

       通常一个服务端口即一个 ServerSocketChannel对应一个Selector 和一个EventLoop线程。BossEventLoop 负责接收客户端的连接并将 SocketChannel 交给 WorkerEventLoopGroup 来进行 IO 处理，如下图所示:

       BossEventLoopGroup 通常是一个单线程的 EventLoop，EventLoop 维护着一个注册了ServerSocketChannel 的 Selector 实例BossEventLoop 不断轮询 Selector 将连接事件分离出来

       通常是 OP_ACCEPT 事件，然后将接收到的 SocketChannel 交给 WorkerEventLoopGroup

       WorkerEventLoopGroup 会由 next 选择其中一个 EventLoop来将这个 SocketChannel 注册到其维护的 Selector 并对其后续的 IO 事件进行处理

       常用方法

?public?NioEventLoopGroup()，构造方法?public?Future<?>?shutdownGracefully()，断开连接，关闭线程. Unpooled类

       Netty 提供一个专门用来操作缓冲区(即Netty的数据容器)的工具类

       常用方法如下所示

?//通过给定的数据和字符编码返回一个?ByteBuf?对象（类似于?NIO?中的?ByteBuffer?但有区别）?public?static?ByteBuf?copiedBuffer(CharSequence?string,?Charset?charset)

       举例说明Unpooled 获取 Netty的数据容器ByteBuf 的基本使用 案例演示

       案例1：

public?class?NettyByteBuf?{ ?public?static?void?main(String[]?args)?{ ?//创建一个ByteBuf?//说明?//1.?创建?对象，该对象包含一个数组arr?,?是一个byte[]?//2.?在netty?的buffer中，不需要使用flip?进行反转?//底层维护了?readerindex?和?writerIndex?//3.?通过?readerindex?和?writerIndex?和?capacity，?将buffer分成三个区域?//?0---readerindex?已经读取的区域?//?readerindex---writerIndex?，?可读的区域?//?writerIndex?--?capacity,?可写的区域?ByteBuf?buffer?=?Unpooled.buffer(5);?for?(int?i?=?0;?i?<?5;?i++)?{ ?buffer.writeByte(i);?}?System.out.println("capacity="?+?buffer.capacity());?//?//输出//for?(int?i?=?0;?i?<?buffer.capacity();?i++)?{ //System.out.println(buffer.getByte(i));//}?for?(int?i?=?0;?i?<?buffer.capacity();?i++)?{ ?System.out.println(buffer.readByte());?}?System.out.println("执行完毕");?}}

       执行结果为：

capacity=执行完毕

       案例2：

public?class?NettyByteBuf?{ ?public?static?void?main(String[]?args)?{ ?//创建ByteBuf?ByteBuf?byteBuf?=?Unpooled.copiedBuffer("hello,world!",?Charset.forName("utf-8"));?//使用相关的方法?if?(byteBuf.hasArray())?{ ?//?true?byte[]?content?=?byteBuf.array();?//将?content?转成字符串?System.out.println(new?String(content,?Charset.forName("utf-8")));?System.out.println("byteBuf="?+?byteBuf);?System.out.println(byteBuf.arrayOffset());?//?0?System.out.println(byteBuf.readerIndex());?//?0?System.out.println(byteBuf.writerIndex());?//??System.out.println(byteBuf.capacity());?//??//System.out.println(byteBuf.readByte());?//?System.out.println(byteBuf.getByte(0));?//??int?len?=?byteBuf.readableBytes();?//可读的字节数??System.out.println("len="?+?len);?//使用for取出各个字节?for?(int?i?=?0;?i?<?len;?i++)?{ ?System.out.println((char)?byteBuf.getByte(i));?}?//按照某个范围读取?System.out.println(byteBuf.getCharSequence(0,?4,?Charset.forName("utf-8")));?System.out.println(byteBuf.getCharSequence(4,?6,?Charset.forName("utf-8")));?}?}}

       执行结果为：

Channel?channel()，返回当前正在进行?IO?操作的通道ChannelFuture?sync()，等待异步操作执行完毕0参考文档

       Netty学习和源码分析github地址Netty从入门到精通视频教程(B站) Netty权威指南 第二版

       原文：/post/

HashMap为什么不安全？

       æˆ‘们都知道HashMap是线程不安全的，在多线程环境中不建议使用，但是其线程不安全主要体现在什么地方呢，本文将对该问题进行解密。

       1.jdk1.7中的HashMap

       åœ¨jdk1.8中对HashMap做了很多优化，这里先分析在jdk1.7中的问题，相信大家都知道在jdk1.7多线程环境下HashMap容易出现死循环，这里我们先用代码来模拟出现死循环的情况：

       public class HashMapTest {     public static void main(String[] args) {         HashMapThread thread0 = new HashMapThread();        HashMapThread thread1 = new HashMapThread();        HashMapThread thread2 = new HashMapThread();        HashMapThread thread3 = new HashMapThread();        HashMapThread thread4 = new HashMapThread();        thread0.start();        thread1.start();        thread2.start();        thread3.start();        thread4.start();    }}class HashMapThread extends Thread {     private static AtomicInteger ai = new AtomicInteger();    private static Map map = new HashMap<>();    @Override    public void run() {         while (ai.get() < ) {             map.put(ai.get(), ai.get());            ai.incrementAndGet();        }    }}

       ä¸Šè¿°ä»£ç æ¯”较简单，就是开多个线程不断进行put操作，并且HashMap与AtomicInteger都是全局共享的。

       åœ¨å¤šè¿è¡Œå‡ æ¬¡è¯¥ä»£ç åŽï¼Œå‡ºçŽ°å¦‚下死循环情形：

       å…¶ä¸­æœ‰å‡ æ¬¡è¿˜ä¼šå‡ºçŽ°æ•°ç»„越界的情况：

       è¿™é‡Œæˆ‘们着重分析为什么会出现死循环的情况，通过jps和jstack命名查看死循环情况，结果如下：

       ä»Žå †æ ˆä¿¡æ¯ä¸­å¯ä»¥çœ‹åˆ°å‡ºçŽ°æ­»å¾ªçŽ¯çš„位置，通过该信息可明确知道死循环发生在HashMap的扩容函数中，根源在transfer函数中，jdk1.7中HashMap的transfer函数如下：

       void transfer(Entry[] newTable, boolean rehash) {         int newCapacity = newTable.length;        for (Entry e : table) {             while(null != e) {                 Entry next = e.next;                if (rehash) {                     e.hash = null == e.key ? 0 : hash(e.key);                }                int i = indexFor(e.hash, newCapacity);                e.next = newTable[i];                newTable[i] = e;                e = next;            }        }    }

       æ€»ç»“下该函数的主要作用：

       åœ¨å¯¹table进行扩容到newTable后，需要将原来数据转移到newTable中，注意-行代码，这里可以看出在转移元素的过程中，使用的是头插法，也就是链表的顺序会翻转，这里也是形成死循环的关键点。

       ä¸‹é¢è¿›è¡Œè¯¦ç»†åˆ†æžã€‚

       1.1 扩容造成死循环分析过程

       å‰ææ¡ä»¶ï¼Œè¿™é‡Œå‡è®¾ï¼š

       hash算法为简单的用key mod链表的大小。

       æœ€å¼€å§‹hash表size=2，key=3,7,5，则都在table[1]中。

       ç„¶åŽè¿›è¡Œresize，使size变成4。

       æœªresize前的数据结构如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       å¦‚果在单线程环境下，最后的结果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       è¿™é‡Œçš„转移过程，不再进行详述，只要理解transfer函数在做什么，其转移过程以及如何对链表进行反转应该不难。

       ç„¶åŽåœ¨å¤šçº¿ç¨‹çŽ¯å¢ƒä¸‹ï¼Œå‡è®¾æœ‰ä¸¤ä¸ªçº¿ç¨‹A和B都在进行put操作。线程A在执行到transfer函数中第行代码处挂起，因为该函数在这里分析的地位非常重要，因此再次贴出来。

       è¯·ç‚¹å‡»è¾“入图片描述

       æ­¤æ—¶çº¿ç¨‹A中运行结果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       çº¿ç¨‹A挂起后，此时线程B正常执行，并完成resize操作，结果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       è¿™é‡Œéœ€è¦ç‰¹åˆ«æ³¨æ„çš„点：由于线程B已经执行完毕，根据Java内存模型，现在newTable和table中的Entry都是主存中最新值：7.next=3，3.next=null。

       æ­¤æ—¶åˆ‡æ¢åˆ°çº¿ç¨‹A上，在线程A挂起时内存中值如下：e=3，next=7，newTable[3]=null，代码执行过程如下：

newTable[3]=e ----> newTable[3]=3e=next ----> e=7

       æ­¤æ—¶ç»“果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       ç»§ç»­å¾ªçŽ¯ï¼š

e=7next=e.next ----> next=3【从主存中取值】e.next=newTable[3] ----> e.next=3【从主存中取值】newTable[3]=e ----> newTable[3]=7e=next ----> e=3

       ç»“果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       å†æ¬¡è¿›è¡Œå¾ªçŽ¯ï¼š

e=3next=e.next ----> next=nulle.next=newTable[3] ----> e.next=7 å³ï¼š3.next=7newTable[3]=e ----> newTable[3]=3e=next ----> e=null

       æ³¨æ„æ­¤æ¬¡å¾ªçŽ¯ï¼še.next=7，而在上次循环中7.next=3，出现环形链表，并且此时e=null循环结束。

       ç»“果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       åœ¨åŽç»­æ“ä½œä¸­åªè¦æ¶‰åŠè½®è¯¢hashmap的数据结构，就会在这里发生死循环，造成悲剧。

       1.2 扩容造成数据丢失分析过程

       éµç…§ä¸Šè¿°åˆ†æžè¿‡ç¨‹ï¼Œåˆå§‹æ—¶ï¼š

       è¯·ç‚¹å‡»è¾“入图片描述

       çº¿ç¨‹A和线程B进行put操作，同样线程A挂起：

       è¯·ç‚¹å‡»è¾“入图片描述

       æ­¤æ—¶çº¿ç¨‹A的运行结果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       æ­¤æ—¶çº¿ç¨‹B已获得CPU时间片，并完成resize操作：

       è¯·ç‚¹å‡»è¾“入图片描述

       åŒæ ·æ³¨æ„ç”±äºŽçº¿ç¨‹B执行完成，newTable和table都为最新值：5.next=null。

       æ­¤æ—¶åˆ‡æ¢åˆ°çº¿ç¨‹A，在线程A挂起时：e=7，next=5，newTable[3]=null。

       æ‰§è¡Œnewtable[i]=e，就将7放在了table[3]的位置，此时next=5。接着进行下一次循环：

e=5next=e.next ----> next=null，从主存中取值e.next=newTable[1] ----> e.next=5，从主存中取值newTable[1]=e ----> newTable[1]=5e=next ----> e=null

       å°†5放置在table[1]位置，此时e=null循环结束，3元素丢失，并形成环形链表。并在后续操作hashmap时造成死循环。

       è¯·ç‚¹å‡»è¾“入图片描述

       2.jdk1.8中HashMap

       åœ¨jdk1.8中对HashMap进行了优化，在发生hash碰撞，不再采用头插法方式，而是直接插入链表尾部，因此不会出现环形链表的情况，但是在多线程的情况下仍然不安全，这里我们看jdk1.8中HashMap的put操作源码：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {         Node[] tab; Node p; int n, i;        if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;        if ((p = tab[i = (n - 1) & hash]) == null) // å¦‚果没有hash碰撞则直接插入元素            tab[i] = newNode(hash, key, value, null);        else {             Node e; K k;            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k))))                e = p;            else if (p instanceof TreeNode)                e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);            else {                 for (int binCount = 0; ; ++binCount) {                     if ((e = p.next) == null) {                         p.next = newNode(hash, key, value, null);                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            treeifyBin(tab, hash);                        break;                    }                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                        break;                    p = e;                }            }            if (e != null) {  // existing mapping for key                V oldValue = e.value;                if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e);                return oldValue;            }        }        ++modCount;        if (++size > threshold)            resize();        afterNodeInsertion(evict);        return null;    }

       è¿™æ˜¯jdk1.8中HashMap中put操作的主函数， 注意第6行代码，如果没有hash碰撞则会直接插入元素。

       å¦‚果线程A和线程B同时进行put操作，刚好这两条不同的数据hash值一样，并且该位置数据为null，所以这线程A、B都会进入第6行代码中。

       å‡è®¾ä¸€ç§æƒ…况，线程A进入后还未进行数据插入时挂起，而线程B正常执行，从而正常插入数据，然后线程A获取CPU时间片，此时线程A不用再进行hash判断了，问题出现：线程A会把线程B插入的数据给覆盖，发生线程不安全。

       æ€»ç»“

       é¦–å…ˆHashMap是线程不安全的，其主要体现：

       åœ¨jdk1.7中，在多线程环境下，扩容时会造成环形链或数据丢失。

       åœ¨jdk1.8中，在多线程环境下，会发生数据覆盖的情况。