当前位置：文档库 › 面试知识点

面试知识点

负责后台会员管理、商品管理、订单管理、购物车管理等，前台商品展示等相关页面静态化，季度报表。

登录模块,权限设置，用户管理。

主要负责注册、登陆、投标、发标等模块。（p2p）

单点登录页sso：

用户登录---跳转登录页面--登录页面---action接受用户名、密码---验证是否正确---正确（生成token请求的唯一字符串（用户名还不知道是谁），因为没有session，token相当于session的ID，ID也就是当前session会话）---根据ID把用户信息保存redis并设置有效期保存（key是token，value是用户信息）----保存---返回登录成功---把token写入cookie中（为了保证其他系统知道你是谁就需要把token写入cookie中、正常session也是暴露给用户的session的ID也写在cookie中）------返回首页

--------
第二个流程（查询订单）----从cookie中取token（找到）---调用sso服务根据token查询用户信息（根据token查询当前用户的登录状态）---sso接受token---根据token查询redis---根据key（token）取值（值是有有效期的有可能过期）---判断token是否存在---存在调整生存期为最长---返回用用户已登录---显示订单信息（如果不存在跳转登录页面重新登录生成token写入redis--把token写入cookie中---判断是否有回调的url（没有返回首页、有并跳转要访问的URL）

redis：

weblogic：
Bootstrap：
Linux：
webservice：
Rose

struts1:
struts1的工作原理
客户端发送请求（Http Request），被struts1的核心控件器ActionServlet接收，ActionServlet根据struts-config.xml里的映射关系找到对就的Action，若找不到就返回500错误到JSP页面。若有就Action里的 excute()方法里执行相应的逻辑操作，比如调用Model层的方法，然后通过ActionForward，跳转到对应的输出页面。

1.初始化：struts框架的总控制器ActionServlet是一个Servlet，它在web.xml中配置成自动启动的
Servlet，在启动时总控制器会读取配置文件(struts-config.xml)的配置信息，为struts
中不同的模块初始化相应的对象。(面向对象思想)

2.发送请求：用户提交表单或通过URL向WEB服务器提交请求，请求的数据用HTTP协议传给web服务器。
3.form填充：struts的总控制器ActionServlet在用户提交请求时将数据放到对应的form对象中的成员
变量中。
4.派发请求：控制器根据配置信息对象ActionConfig将请求派发到具体的Action对应的formBean一并
传给这个Action中的excute()方法。
5.处理业务：Action一般只包含一个excute()方法,执行相应的业务逻辑模块
完毕后返回一个ActionForward对象进行转发工作。
6.返回响应：Action将业务处理的不同结果返回

一个目标响应对象给总控制器。
7.查找响应：总控制器根据Action处理业务返回的目标响应对象，找到对应的资源对象，一般情况下
为jsp页面。
8.响应用户：目标响应对象将结果传递给资源对象，将结果展现给用户。

Struts2:
（1）客户端（Client）向Action发用一个请求（Request）
（2） Container通过web.xml映射请求，并获得控制器（Controller）的名字
（3）容器（Container）调用控制器（StrutsPrepareAndExecuteFilter或FilterDispatcher）。在Struts2.1以前调用FilterDispatcher，Struts2.1以后调用StrutsPrepareAndExecuteFilter
（4）控制器（Controller）通过ActionMapper获得Action的信息
（5）控制器（Controller）调用ActionProxy
（6） ActionProxy读取struts.xml文件获取action和interceptor stack的信息。
（7） ActionProxy把request请求传递给ActionInvocation
（8） ActionInvocation依次调用action和interceptor
（9）根据action的配置信息，产生result
（10） Result信息返回给ActionInvocation
（11）产生一个HttpServletResponse响应
（12）产生的响应行为发送给客服端。

Spring:

内部最核心的就是IOC了，
动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射
反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置
文件来动态的创建对象，和调用对象里的方法的。
Spring还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象进行监督和控制（也就是
在调用这类对象的具体方法的前后去调用你指定的模块）从而达到对一个模块扩充的功能。这些都是通过
配置类达到的。
Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明
管理的（Spring根据这些配置内部通过反射去动态的组装对象）
要记住：Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能。
Spring里用的最经典的一个设计模式就是：模板方法模式。（这里我都不介绍了，是一个很常用的设计模式）
Spring里的配置是很多的，很难都记住，但是Spring里的精华也无非就是以上的两点，把以上两点跟理解了也就基本上掌握了Spring.

Spring AOP与IOC
一、 IoC(Inversion of control): 控制反转
1、IoC：
概念：控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系
核心：bean工厂；在Spring中，bean工厂创建的各个实例称作bean
二、AOP(Aspect-Oriented Programming): 面向方面编程
1、代理的两种方式：
静态代理：
? 针对每个具体类分别编写代

理类；
? 针对一个接口编写一个代理类；
动态代理：
针对一个方面编写一个InvocationHandler，然后借用JDK反射包中的Proxy类为各种接口动态生成相应的代理类

JAVA Hibernate工作原理及为什么要用

hibernate 简介：
hibernate是一个开源框架，它是对象关联关系映射的框架，它对JDBC做了轻量级的封装，而我们java程序员可以使用面向对象的思想来操纵数据库。
hibernate核心接口
session：负责被持久化对象CRUD操作
sessionFactory:负责初始化hibernate，创建session对象
configuration:负责配置并启动hibernate，创建SessionFactory
Transaction:负责事物相关的操作
Query和Criteria接口：负责执行各种数据库查询

hibernate工作原理：
1.通过Configuration config = new Configuration().configure();//读取并解析hibernate.cfg.xml配置文件
2.由hibernate.cfg.xml中的读取并解析映射信息
3.通过SessionFactory sf = config.buildSessionFactory();//创建SessionFactory
4.Session session = sf.openSession();//打开Sesssion
5.Transaction tx = session.beginTransaction();//创建并启动事务Transation
6.persistent operate操作数据，持久化操作
https://www.wendangku.net/doc/4b1553001.html,mit();//提交事务
8.关闭Session
9.关闭SesstionFactory

为什么要用hibernate：
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

Hibernate是如何延迟加载?get与load的区别

1. 对于Hibernate get方法，Hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查询数据库，数据库中没有就返回null。这个相对比较简单，也没有太大的争议。主要要说明的一点就是在这个版本(bibernate3.2以上)中get方法也会查找二级缓存！

2. Hibernate load方法加载实体对象的时候，根据映射文件上类级别的lazy属性的配置(默认为true)，分情况讨论：

(1)若为true,则首先在Session缓存中查找，看看该id对应的对象是否存在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为实体类的子类，由CGLIB动态生成)。等到具体使用该对象(除获取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一个ObjectNotFoundException。

(2)若为false,就跟Hibernateget方法查找顺序一样，只是最终若没发现符合条件的记录，则

会抛出一个ObjectNotFoundException。

这里get和load有两个重要区别:

如果未能发现符合条件的记录，Hibernate get方法返回null，而load方法会抛出一个ObjectNotFoundException。

load方法可返回没有加载实体数据的代理类实例，而get方法永远返回有实体数据的对象。

(对于load和get方法返回类型：好多书中都说：“get方法永远只返回实体类”，实际上并不正确，get方法如果在session缓存中找到了该id对应的对象，如果刚好该对象前面是被代理过的，如被load方法使用过，或者被其他关联对象延迟加载过，那么返回的还是原先的代理对象，而不是实体类对象，如果该代理对象还没有加载实体数据（就是id以外的其他属性数据），那么它会查询二级缓存或者数据库来加载数据，但是返回的还是代理对象，只不过已经加载了实体数据。)

总之对于get和load的根本区别，一句话，hibernate对于 load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于get方法，hibernate一定要获取到真实的数据，否则返回null。

Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

说下Hibernate的缓存机制：

Hibernate缓存的作用：
Hibernate是一个持久层框架，经常访问物理数据库，为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据
Hibernate缓存分类：
Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存
Hibernate一级缓存又称为“Session的缓存”，它是内置的，意思就是说，只要你使用hibernate就必须使用session缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。在第一级缓存中，持久化类的每个实例都具有唯一的OID。
Hibernate二级缓存又称为“SessionFactory的缓存”，由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的，是一个可配置的插件，在默认情况下，SessionFactory不会启用这个插件。

什

么样的数据适合存放到第二级缓存中？
1 很少被修改的数据
2 不是很重要的数据，允许出现偶尔并发的数据
3 不会被并发访问的数据
4 常量数据
不适合存放到第二级缓存的数据？
1经常被修改的数据
2 .绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发
3 与其他应用共享的数据。

Hibernate查找对象如何应用缓存？
当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；如果都查不到，再查询数据库，把结果按照ID放入到缓存
删除、更新、增加数据的时候，同时更新缓存

Hibernate管理缓存实例
无论何时，我们在管理Hibernate缓存（Managing the caches）时，当你给save()、update()或saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。
当随后flush()方法被调用时，对象的状态会和数据库取得同步。如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。

Hibernate的查询方式
Sql、Criteria,object comptosition
Hql：
1、属性查询
2、参数查询、命名参数查询
3、关联查询
4、分页查询
5、统计函数

如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态

7. 表字段要少，表关联不要怕多，有二级缓存撑腰

hibernate的开发步骤：

开发步骤
1)搭建好环境
引入hibernate最小的jar包
准备Hibernate.cfg.xml启动配置文件
2)写实体类(pojo)
3)为实体类写映射文件"User.hbm.xml"
在hibernate.cfg.xml添加映射的实体
4)创建库表
5)写测试类
获得Configuration
创建SessionFactory
打开Session
开启事务
使用session操作数据
提交事务
关闭资源

MyBatis:

MyBatis的前身就是iBatis,iBatis本是apache的一个开源项目，2010年这个项目由apahce sofeware foundation 迁移到了google code，并且改名为MyBatis。

iBATIS 一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO），同时还提供一个利用这个框架开发的 JPetStore实例。(来源于百度)

总体来说 MyBatis 主要完成两件事情

根据 JDBC 规范建立与数据库的连接；
通过Annotaion/XML+JAVA反射技术，实现 Java 对象与关系数据库之间相互转化。
一、原理介绍
Mybatis的应用是围绕着一个SqlSessionFactory实例展开的。SqlSessionFactoryBuilder根据XML映射文件创建SqlSessionFactory。

SqlSessionFactory由名字可以联想到，可以通过它获取一个SqlSession。SqlSession包含了执行sql所需要的所有方法，可以通过SqlSession实例直接运行映射的sql语句：
Java代码收藏代码
SqlSession session = sqlSessionFactory.openSession();
try {
Blog blog = session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
} finally {
session.close();
}
上面的方法是基于Mybatis的旧版本，在最新的版本中有更清晰的方法，通过一个java接口作为参数(e.g. BlogMapper.class)返回一个给定的sql映射。
Java代码收藏代码
SqlSession session = sqlSessionFactory.openSession();
try {
BlogMapper mapper = session.getMapper(BlogMapper.class);
Blog blog = mapper.selectBlog(101);
} finally {
session.close();
}
看到这里，您可能会对什么才是SqlSession和Mapper类真正执行的sql语句非常好奇。下面我们看一下例子.
Xml代码收藏代码

PUBLIC "-//https://www.wendangku.net/doc/4b1553001.html,//DTD Mapper 3.0//EN"
"https://www.wendangku.net/doc/4b1553001.html,/dtd/mybatis-3-mapper.dtd">

这个例子非常简单，是轻量级的。您可以定义众多类似这样的sql语句。这个文件在命名空间"org.mybatis.example.BlogMapper"中，定义了一个叫做"selectBlog"的sql语句。这样就可以使用一个绝对唯一路径“org.mybatis.example.BlogMapper.selectBlog”定位到这个sql语句上。如下所示：
Java代码收藏代码
Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
请注意这是一个绝对唯一的 Java类调用方法如何类似的。这个名字可以直接映射到命名空间的映射类，以及具有相匹配的名称、参数和返回类型映射 select语句的方法。这使得您可以很简单地调用映射接口的方法，这里是例子：
Java代码收藏代码
BlogMapper mapper = session.getMapper(BlogMapper.class);
Blog blog = mapper.selectBlog(101);
如您所见，第二种方法更简洁，不需要返回值的cast。

到目前为止，我们已经了解Mybatis如何将xml映射文件与Java类映射去执行sql语句的，具体xml映射文件的含义请查询mybatis官方网站的资料，再此不在介绍。
二、spring的集成
在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilde

r 来创建。而在 MyBatis-Spring 中,则使用 SqlSessionFactoryBean 来替代。

要创建工厂 bean,放置下面的代码在 Spring 的 XML 配置文件中:
Xml代码收藏代码

要注意 SqlSessionFactoryBean 实现了 Spring 的 FactoryBean 接口(请参考Spring文档的3.8 章节)这就说明了由Spring最终创建的bean不是SqlSessionFactoryBean本身。而是工厂类的getObject()返回的方法的结果。这种情况下,Spring将会在应用启动时为你创建SqlSessionFactory对象,然后将它以SqlSessionFactory为名来存储。在 Java中, 相同的代码是:
Java代码收藏代码
SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
SqlSessionFactory sessionFactory = factoryBean.getObject();
在一般的MyBatis-Spring 用法中, 你不需要直接使用 SqlSessionFactoryBean或和其对应的SqlSessionFactory。相反,session工厂将会被注入到MapperFactoryBean或其它扩展了SqlSessionDaoSupport 的DAO(Data Access Object,数据访问对象,译者注)中。

下面给出一个完成的Mybatis-spring集成的例子：
Xml代码收藏代码

destroy-method="close">

如有疑问，请查看Mybatis-spring集成的官方文档。
三、代码生成工具
经过前面的两章，我们已经掌握了Mybatis的映射原理，并且可以集成进入到spring中使用了。但是童鞋们肯定会感觉Mybatis

的配置文件和映射类的工作也十分的巨大，并且繁琐，简直就是望而生畏。
不过我们有强大的代码生成工具帮我们自动生成xml映射文件和java映射类，它大大减轻了我们使用Mybatis的工作负担！

首先，建议在eclipse上安装Mybatis代码生成工具的插件。插件地址请点击我。
安装完毕，就可以在eclipse上自动生成Mybatis的文件了，程序员可以把自己的精力专注在业务逻辑上的开发，而不是Mybatis配置文件和映射类上面。
Mybatis代码生成工具的原理是使用xml配置文件驱动的代码生成工具。配置文件解决了如下问题：
如何连接数据库
生成哪些对象如何生成
哪些表要用来生成对象
详细内容请查看官网的文档。

自动生成如下文件包括下面四个类型的组件：
Module类数据库的对象POJO(没有实现Serializable接口，如使用缓存需要添加 )
Example 用于拼动态sql的帮助类
XXXMapper.xml 映射文件(包括自动生成的动态sql部分)
XXXMapper.java 与映射文件对应的DAO接口
四、缓存
缓存技术是一种“以空间换时间”的设计理念，利用内存空间资源来提高数据检索速度的有效手段之一。
MyBatis默认情况下是没有开启缓存的，除了局部的 session 缓存。要开启二级缓存，你需要在你的 SQL映射文件中添加一行：
Xml代码收藏代码

这样配置会开启二级缓存，并且加载缺省的缓存配置。下面的例子说明了如何更改缓存策略和配置：
Xml代码收藏代码
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
这个配置创建了一个 FIFO 缓存，并每隔 60 秒刷新，存取512 个结果对象或列表的引用，而且返回的对象为只读，因此在不同线程中的调用者之间修改它们会导致冲突。
注意：二级缓存是支持事物的，这意味着只有在SqlSession结束和提交的时候，或者当回滚结束并且插入、删除、更新操作没有配置flushCache=true，才会更新缓存内容。
除了Mybatis自己提供的缓存，也可以使用第三方的分布式缓存。要使用第三方的缓存需要实现Mybatis的缓存接口：

Java代码收藏代码
public interface Cache {
String getId();
int getSize();
void putObject(Object key, Object value);
Object getObject(Object key);
boolean hasKey(Object key);
Object removeObject(Object key);
void clear();
ReadWriteLock getReadWriteLock();
}
然后只要在xml映射文件中，缓存配置的部分使用自己的实现类。

Xml代码收藏代码

更详细的内容请直接查看

官方网站的说明文档。
幸运的是，针对很多著名的第三方分布式缓存，已经有了开源的插件，已经不需要我们自己开发缓存接口的实现了。下面拿我们公司DAL使用的Memcached为例，已经有了开源的实现。如果使用maven管理项目，可以添加如下项目到maven的配置文件中引入Mybatis-Memcached框架：

Xml代码收藏代码

org.mybatis.caches
mybatis-memcached
1.0.0-beta1

然后在xml映射文件指定定制的Memcached缓存实现类：
Xml代码收藏代码

...

具体的使用方法还请阅读Mybatis-Memcached项目文档。
五、分库
现在大型网站都有自己的分布式DAL(Data access layer)层。如何在Mybatis上构建DAL，实现分库表的配置，路由规则定制都有现实的实际应用价值。下面简介一个Mybatis的分库插件。

shardbatis是一个由国人贡献的，Mybatis分库分表插件。Shardbatis的名称由shard(ing)+mybatis组合得到。诣在为ibatis实现数据水平切分的功能。

Shardbatis0.9是在mybatis 2.3.5代码的基础上进行一些扩展实现数据水平切分功能。数据的水平切分包括多数据库的切分和多表的数据切分。目前shardbatis已经实现了单数据库的数据多表水平切分。

Shardbatis2.0可以以插件的方式和mybatis3.x进行整合，对mybatis的代码无侵入，不改变用户对mybatis的使用习惯。Shardbatis2.0支持的功能和Shardbatis0.9基本相同。

shardbatis的使用与原生的mybatis3没有区别，使用者只需要将shardbatis以Mybatis插件的方式引入进来，实现路由策略接口，实现自己的路由策略即可，此外还需要一个shard_config.xm配置文件，定义哪些sql映射操作需要使用路由策略。

更详细的内容可以参考shardbatis官方文档。以及iteye资料

六、其它基于Mybatis的项目和资料

1.CobarClient主要针对现有网站应用中使用iBatis做数据访问层这一情况而设计开发,如果你的应用程序最初使用了Spring提供的SqlMapClientTemplate的话, 那迁移到CobarClient实际上仅仅是稍微改一下应用程序的配置而已.
项目地址:https://www.wendangku.net/doc/4b1553001.html,/wiki/display/CobarClient/Home
2.https://www.wendangku.net/doc/4b1553001.html,/
3.https://www.wendangku.net/doc/4b1553001.html,/p/mybatis/

Mybatis从出生到现在已经有10岁了，最新的Mybatis项目是Mybatis for scala，相信在并行计算大行其道的今天，Mybatis一定会跟上时代的潮流，与时俱进，继续保持在ORM框架里面的霸主地位。

什么是线程安全和线程不安全
首先要明白线程的工作原理，jvm有一个main memory，而每个线程有自己的working memo

ry，一个线程对一个variable进行操作时，都要在自己的working memory里面建立一个copy，操作完之后再写入main memory。多个线程同时操作同一个variable，就可能会出现不可预知的结果。根据上面的解释，很容易想出相应的scenario。
而用synchronized的关键是建立一个monitor，这个monitor可以是要修改的variable也可以其他你认为合适的object比如method，然后通过给这个monitor加锁来实现线程安全，每个线程在获得这个锁之后，要执行完 load到workingmemory －> use&assign －> store到mainmemory 的过程，才会释放它得到的锁。这样就实现了所谓的线程安全。

------------------------------------------------------

什么是线程安全?线程安全是怎么完成的(原理)?
线程安全就是说多线程访问同一代码，不会产生不确定的结果。编写线程安全的代码是低依靠线程同步。

------------------------------------------------------

在接口方式中，线程有一个共享的数据成员，即： private int count =10;
而在继承方式中，线程之间没有共享的成员，而是各线程各自有一个私有成员，即： private int count =10;
楼主的代码刚好是一个好例子，说明了何时需要考虑线程同步，并在一定程序上说明了怎样才能编写出线程安全的代码。
在多线程环境中，当各线程不共享数据的时候，那么一定是线程安全的。问题是这种情况并不多见，在多数情况下需要共享数据，这时就需要进行适当的同步控制了。

--------------------------------------------------------

线程安全一般都涉及到synchronized 就是一段代码同时只能有一个线程来操作不然中间过程可能会产生不可预制的结果

---------------------------------------------------------

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

举例比如一个 ArrayList 类，在添加一个元素的时候，它可能会有两步来完成：1. 在 Items[Size] 的位置存放此元素；2. 增大 Size 的值。

在单线程运行的情况下，如果 Size = 0，添加一个元素后，此元素在位置 0，而且 Size=1；而如果是在多线程情况下，比如有两个线程，线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B也向此 ArrayList 添加元素，因为此时 Size 仍然等于 0 （注意哦，我们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加 Size 的值。那好，现在我们来

看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而 Size 却等于 2。这就是“线程不安全”了。

java多线程 —— 两种实际应用场景模拟 - 薛定谔的猫_
时间 2014-08-21 10:56:00 博客园-原创精华区
原文 https://www.wendangku.net/doc/4b1553001.html,/juepei/p/3926673.html
主题 Java 多线程
最近做的偏向并发了，因为以后消息会众多，所以，jms等多个线程操作数据的时候，对共享变量，这些要很注意，以防止发生线程不安全的情况。

（一）

先说说第一个，模拟对信息的发送和接收。场景是这样的：

就像笔者之前做的消息的发送，一个是服务器，一个是客户端。发送的话，要保证信息100%的发送给客户端，那么发给客户端之后，客户端返回一个消息告诉服务器，已经收到。当服务器一直没有收到客户端返回的消息，那么服务器会一直发送这个信息，直到客户端发送回确认信息，这时候再删除重复发送的这个信息。

为了模拟这个场景，这里写两个线程，一个是发送，一个是接收，把发送的信息，要保存到线程安全的对象里面，防止发生线程安全问题，这里采用concurrenthashmap。

发送代码：

package com.TestThread;
/*
*
* @author 薛定饿的猫
*
* */
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;

public class PushThread extends Thread {

@Override
public void run() {
// TODO Auto-generated method stub
try {
sleep(6000);
while(MainThread.pushmessage.size()>0){
//重发消息
for(Entry hashMap:MainThread.pushmessage.entrySet()){
System.out.println("消息id:"+hashMap.getKey()+"未发送成功，在此重发:"+hashMap.getValue());
}
sleep(1000);
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
发送代码，是不断遍历内存对象councurrenthashmap，从中取出信息，不断的重发。其中MainThread.pushmessage是内存对象，在最后一段代码中有定义。

当确认接收到信息后，另外一个线程来删除内存对象。

删除的代码：

package com.TestThread;

/*
*
* @author 薛定饿的猫
*
* */
import java.util.Map.Entry;

public class RemoveThread extends Thread {

@Override
public void run() {
// TODO Auto-generated method stub
try {
for (int i = 0; i < 10000; i++) {
sleep(2000);
for(Entry map:MainThread.pushmessage.entrySet()){
if (map.getKey()==i) {
System.out.println("成功收到id为："+map.getKey()+"返回的信息，删除该元素");
MainThread.pushmessage.remove(map.getKey());
}
}
System.out.println("内存对象中的元素数量为："+Mai

nThread.pushmessage.size());
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
这里是来删除已收到的信息，然后从内存中删除，不再发送。

然后写一个主类入口：

package com.TestThread;
/*
*
* @author 薛定饿的猫
*
* */
import java.util.concurrent.ConcurrentHashMap;

public class MainThread {
public static ConcurrentHashMap pushmessage=new ConcurrentHashMap();
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
pushmessage.put(i, "该消息是id为"+i+"的消息");
}
Thread pushThread=new PushThread();
Thread remove=new RemoveThread();
pushThread.start();
remove.start();
for (int i = 10; i < 20; i++) {
pushmessage.put(i, "又一波到来，消息是id为"+i+"的消息");
}
}
}
这样两个线程可以轮流的进行各自的事情，并且不会造成数据安全的问题。用这种方式，再结合Androidpn的推送机制，会更加符合实际生产中的应用。

（二）多线程同步计数器

多线程同步计数器，按道理也是可以按照上面的方式来进行处理，定义一个像concurrenthashmap的变量。在java中，确实也有另外一种变量，原子变量 Atomic，有 AtomicLong， AtomicInteger， AtomicReference这些。

如果在多线程环境下要给一些值赋唯一id的话，这个时候，就要考虑这个id的安全性问题，也就是一致性的问题，不能重复。这里有两个实现的代码：

package com.test;

public class ThreadCount {
public static void main(String[] args) {

Thread[] threads=new Thread[10000];
for (int i = 0; i < 10000; i++) {
threads[i]=new AThread();
threads[i].start();
}
}
}

class AThread extends Thread{

@Override
public void run() {
// TODO Auto-generated method stub
@SuppressWarnings("unused")
Counter counter=new Counter();
System.out.println(Counter.calNum());
}

}

class Counter{
private static long num;
public Counter(){
synchronized (Counter.class) {
num++;
}
}
public static synchronized long calNum(){
return num;
}
}
这里创建了10000个线程，每个线程都来访问这个计数器，在构造方法中来进行值的递增。

在计数器中，有两次用到同步，很多人都说用同步，经常会对性能造成影响。于是，用第二种的原子变量，这个性能应该会更好。

代码：

package com.test;

import java.util.concurrent.atomic.AtomicLong;

public class ThreadCount {
public static void main(String[] args) {

Thread[] threads=new Thread[10000];
for (int i = 0; i < 10000; i++) {
threads[i]=new AThread();
threads[i].start();
}
}
}

class AThread extends Thread{

@Override

public void run() {
System.out.println(MyCounter.calNum());
}

}

class Counter{
private static long num;
public Counter(){
synchronized (Counter.class) {
num++;
}
}
public static synchronized long calNum(){
return num;
}
}

class MyCounter{
private static AtomicLong num=new AtomicLong();

public static long calNum(){
num.incrementAndGet();
return num.get();
}
}
这样写的话，在调用这个计数器的时候，直接不需要再new一个MyCounter对象，也不需要加同步的关键字了，这样可以作为工具类，直接调用MyCounter的calNum方法。