少年阿宾

//web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 id="WebApp_ID" version="3.0">
 <display-name>universal</display-name>
 <!-- spring -->
 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath*:com/abin/lee/ssh/spring-service.xml</param-value>
 </context-param>
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>

 <!-- spring MVC -->
 <servlet>
  <servlet-name>spring-mvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>classpath*:com/abin/lee/ssh/spring-mvc.xml</param-value>
  </init-param>
  <load-on-startup>2</load-on-startup>
 </servlet>
 <servlet-mapping>
  <servlet-name>spring-mvc</servlet-name>
  <url-pattern>/mvc/*</url-pattern>
 </servlet-mapping>
 <!-- spring encoding -->
 <filter>
  <filter-name>utf8-encoding</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
   <param-name>encoding</param-name>
   <param-value>utf-8</param-value>
  </init-param>
  <init-param>
   <param-name>forceEncoding</param-name>
   <param-value>true</param-value>
  </init-param>
 </filter>
 <filter-mapping>
  <filter-name>utf8-encoding</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>

 

 <welcome-file-list>
  <welcome-file>index.html</welcome-file>
  <welcome-file>index.htm</welcome-file>
  <welcome-file>index.jsp</welcome-file>
  <welcome-file>default.html</welcome-file>
  <welcome-file>default.htm</welcome-file>
  <welcome-file>default.jsp</welcome-file>
 </welcome-file-list>
</web-app>

//spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:cache="http://www.springframework.org/schema/cache"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:oxm="http://www.springframework.org/schema/oxm"
 xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd 
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd">
 <!-- 指定系统寻找controller路径 -->
 <mvc:annotation-driven>
  <!-- json 数据格式转换-->
  <mvc:message-converters>
   <bean class="com.abin.lee.ssh.function.FastJsonAbstractHttpMessageConverter">
    <property name="supportedMediaTypes" value="application/json" />
    <property name="serializerFeature">
     <list>
      <value>WriteMapNullValue</value>
      <value>QuoteFieldNames</value>
     </list>
    </property>
   </bean>
  </mvc:message-converters>

 </mvc:annotation-driven>
 <!-- 搜索的包路径 -->
 <context:component-scan base-package="com.abin.lee.ssh"
  use-default-filters="false">
  <context:include-filter type="annotation"
   expression="org.springframework.stereotype.Controller" />
 </context:component-scan>

</beans>

//spring-service.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:cache="http://www.springframework.org/schema/cache"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
 xmlns:jms="http://www.springframework.org/schema/jms" xmlns:lang="http://www.springframework.org/schema/lang"
 xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:oxm="http://www.springframework.org/schema/oxm"
 xmlns:p="http://www.springframework.org/schema/p" xmlns:task="http://www.springframework.org/schema/task"
 xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
    http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd 
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd 
    http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd 
    http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.1.xsd 
    http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-3.1.xsd 
   http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-3.1.xsd 
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd 
   http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm-3.1.xsd 
  http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.1.xsd 
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd 
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd">
 
 <context:annotation-config />
 <context:component-scan base-package="com.abin.lee.ssh"></context:component-scan>
 
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"       
        destroy-method="close">      
    <property name="driverClass" value="oracle.jdbc.driver.OracleDriver"/>      
    <property name="jdbcUrl" value="jdbc:oracle:thin:@localhost:1521:xe"/>      
    <property name="user" value="abin"/>      
    <property name="password" value="abin"/>      
 </bean>
 
 <bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
  <property name="dataSource">
   <ref bean="dataSource" />
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">
     org.hibernate.dialect.OracleDialect
    </prop>
    <prop key="hibernate.show_sql">
     true
    </prop>
    <prop key="hibernate.show_sql">true</prop>
    <prop key="hibernate.format_sql">true</prop>
    <prop key="hibernate.hbm2ddl.auto">update</prop>
   </props>
  </property>
  <!--主键Bean类
  <property name="annotatedClasses">
   <list>
    <value>com.abin.lee.ssh.entity.ModeBean</value>
   </list>
  </property>
   -->
  <!-- 自动扫描-->
   <property name="packagesToScan" value="com.abin.lee.ssh.entity" />
 </bean>
 
 <!-- 配置事务管理器 -->
 <bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory">
   <ref bean="sessionFactory" />
  </property>
 </bean>
 
 <!-- 配置注解实现管理事务（cglib：proxy-target-class="true"） -->
 <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />
 <!-- 指定使用cglib -->
 <!--   -->
 <aop:aspectj-autoproxy proxy-target-class="true" />
 
 <!-- 配置事务的传播特性 -->
 <tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
   <tx:method name="save*" propagation="REQUIRED" />
   <tx:method name="insert*" propagation="REQUIRED" />
   <tx:method name="update*" propagation="REQUIRED" />
   <tx:method name="delete*" propagation="REQUIRED" />
   <tx:method name="*" read-only="false" />
  </tx:attributes>
 </tx:advice>
 
 <!-- 那些类的哪些方法参与事务-->
 <aop:config>
  <aop:pointcut id="allServiceMethod" expression="execution(* com.abin.lee.ssh.spring.*.*(..))" />
  <aop:advisor pointcut-ref="allServiceMethod" advice-ref="txAdvice" />
 </aop:config>
 
</beans>



//FastJsonAbstractHttpMessageConverter.java

package com.abin.lee.ssh.function;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URLDecoder;
import java.nio.charset.Charset;

import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.util.FileCopyUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

//来对requestbody 或responsebody中的数据进行解析
public class FastJsonAbstractHttpMessageConverter extends AbstractHttpMessageConverter<Object>{
  public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
 // fastjson特性参数 
    private SerializerFeature[] serializerFeature; 
 
    public SerializerFeature[] getSerializerFeature() { 
        return serializerFeature; 
    } 
 
    public void setSerializerFeature(SerializerFeature[] serializerFeature) { 
        this.serializerFeature = serializerFeature; 
    } 
 
 //限定页面文本传送类型 只有数据是改类型 的 才会进行拦截
 //application/json
 public FastJsonAbstractHttpMessageConverter(){
//  super(new MediaType("text","plain"));
  super(new MediaType("application","json"));
 }
 @Override
 protected Object readInternal(Class<? extends Object> clazz, HttpInputMessage inputmessage) throws IOException,
   HttpMessageNotReadableException {
  Charset charset;
  MediaType mediaType=inputmessage.getHeaders().getContentType();
  if(mediaType!=null&&mediaType.getCharSet()!=null){
   charset=mediaType.getCharSet();
  }else{
   charset=Charset.forName("UTF-8");
  }
  
  String input=FileCopyUtils.copyToString(new InputStreamReader(inputmessage.getBody(),charset));
  String result=URLDecoder.decode(input, "UTF-8");
  System.out.println(result);
  /*OrgnizationPO po=new OrgnizationPO();
  po.setId(1);
  po.setName("11");
  po.setOrgdesc("1");*/
  
  /*ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
        int i; 
        while ((i = inputmessage.getBody().read()) != -1) { 
            baos.write(i); 
        }  */
        return JSON.parseObject(result, clazz);
//        return JSON.parseArray(baos.toString(), clazz);
//  return po;
 }

 @Override
 protected boolean supports(Class<?> clazz) {
  return true;
  //throw new UnsupportedOperationException();
 }

 @Override
 protected void writeInternal(Object o, HttpOutputMessage outputMessage) throws IOException,
   HttpMessageNotWritableException {
  String jsonString = JSON.toJSONString(o, serializerFeature); 
//  System.out.println(jsonString);
        OutputStream out = outputMessage.getBody(); 
        out.write(jsonString.getBytes(DEFAULT_CHARSET)); 
        out.flush(); 
 }

}

package com.abin.lee.ssh.hibernate;

import com.abin.lee.ssh.entity.ModeBean;

public interface ModeDao {
 public boolean insert(ModeBean mode);
}

package com.abin.lee.ssh.hibernate.impl;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

import com.abin.lee.ssh.entity.ModeBean;
import com.abin.lee.ssh.hibernate.ModeDao;
@Repository
public class ModeDaoImpl extends HibernateDaoSupport implements ModeDao{
 
 @Resource(name = "sessionFactory")
 public void setSuperSessionFactory(SessionFactory sessionFactory) {
  super.setSessionFactory(sessionFactory);
 }
 
 public boolean insert(ModeBean mode) {
  boolean flag=false;
  try {
   this.getHibernateTemplate().saveOrUpdate(mode);
   flag=true;
  } catch (Exception e) {
   e.printStackTrace();
  }
  return flag;
 }
 
 
}

package com.abin.lee.ssh.spring;

import com.abin.lee.ssh.entity.ModeBean;

public interface ModeService {
 public boolean insert(ModeBean mode);

}

package com.abin.lee.ssh.spring.impl;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.abin.lee.ssh.entity.ModeBean;
import com.abin.lee.ssh.hibernate.ModeDao;
import com.abin.lee.ssh.spring.ModeService;

@Service
@Transactional(readOnly = true, timeout = 2, propagation = Propagation.SUPPORTS, isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
public class ModeServiceImpl implements ModeService {
 @Resource
 private ModeDao modeDao;

 @Transactional(readOnly = false, propagation = Propagation.REQUIRED)
 public boolean insert(ModeBean mode) {
  boolean flag = false;
  try {
   flag = this.modeDao.insert(mode);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return flag;
 }

}

package com.abin.lee.ssh.springmvc;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.abin.lee.ssh.dto.request.ModeRequest;
import com.abin.lee.ssh.dto.response.ModeResponse;
import com.abin.lee.ssh.entity.ModeBean;
import com.abin.lee.ssh.spring.ModeService;

@Controller
@RequestMapping("/stevenjohn/")
public class ModeController {
 @Resource
 private ModeService modeService;

 @RequestMapping(value = "getMode", method = RequestMethod.POST)
 public @ResponseBody
 ModeResponse getMode(
   @ModelAttribute ModeRequest modeRequest) {
  ModeResponse response = new ModeResponse();
  String id=modeRequest.getId();
  String username=modeRequest.getUsername();
  String password=modeRequest.getPassword();
  int age=modeRequest.getAge();
  String address=modeRequest.getAddress();
  String email=modeRequest.getEmail();
  ModeBean mode=new ModeBean(id, username, password, age, address, email);
  boolean flag=modeService.insert(mode);
  System.out.println("flag="+flag);
  if(flag==true){
   response.setStatus("success");
  }else{
   response.setStatus("failure");
  }
  
  return response;
 }
}

package com.abin.lee.ssh.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="MODEBEAN")
public class ModeBean implements Serializable{
 @Id
 @Column(name="ID")
 private String id;
 @Column(name="USERNAME",length=100,nullable=true)
 private String username;
 @Column(name="PASSWORD",length=100,nullable=true)
 private String password;
 @Column(name="AGE",length=10,nullable=true)
 private int age;
 @Column(name="ADDRESS",length=100,nullable=true)
 private String address;
 @Column(name="EMAIL",length=100,nullable=true)
 private String email;
 public ModeBean() {
 }
 public ModeBean(String id, String username, String password, int age,
   String address, String email) {
  super();
  this.id = id;
  this.username = username;
  this.password = password;
  this.age = age;
  this.address = address;
  this.email = email;
 }
 
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getUsername() {
  return username;
 }
 public void setUsername(String username) {
  this.username = username;
 }
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getAddress() {
  return address;
 }
 public void setAddress(String address) {
  this.address = address;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 
 
}

//SpringMVC请求参数

package com.abin.lee.ssh.dto.request;

import java.io.Serializable;

public class ModeRequest implements Serializable{
 /**
  *
  */
 private static final long serialVersionUID = 1886596479119297989L;
 private String id;
 private String username;
 private String password;
 private int age;
 private String address;
 private String email;
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getUsername() {
  return username;
 }
 public void setUsername(String username) {
  this.username = username;
 }
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getAddress() {
  return address;
 }
 public void setAddress(String address) {
  this.address = address;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 
}

//SpringMVC响应参数

package com.abin.lee.ssh.dto.response;

import java.io.Serializable;

public class ModeResponse implements Serializable{
 /**
  *
  */
 private static final long serialVersionUID = 7725619232731203410L;
 private String status;
 private String message;
 public ModeResponse() {
 }
 public ModeResponse(String status, String message) {
  super();
  this.status = status;
  this.message = message;
 }
 public String getStatus() {
  return status;
 }
 public void setStatus(String status) {
  this.status = status;
 }
 public String getMessage() {
  return message;
 }
 public void setMessage(String message) {
  this.message = message;
 }
 
}

//log4j.properties

log4j.rootCategory=info,log,console

log4j.logger.org.apache.axis2.enterprise=FATAL
log4j.logger.de.hunsicker.jalopy.io=FATAL
log4j.logger.httpclient.wire.header=FATAL
log4j.logger.org.apache.commons.httpclient=FATAL

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d [%t] %-5p %c %x - %m%n
 
log4j.appender.log=org.apache.log4j.DailyRollingFileAppender
log4j.appender.log.File=../logs/mms.log
log4j.appender.log.layout=org.apache.log4j.PatternLayout
log4j.appender.log.layout.ConversionPattern=%d [%t] %-5p %c %x - %m%n

//测试springMVC的Junit4+httpClient类：

package com.abin.lee.ssm;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import junit.framework.TestCase;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.junit.Test;

public class HttpsClient extends TestCase {
 private String httpUrl = "http://localhost:7000/universal/mvc/stevenjohn/getMode";

 @Test
 public void testHttpsClient() {
  try {
   HttpClient httpClient = new DefaultHttpClient();
   HttpPost httpPost = new HttpPost(httpUrl);
   List<NameValuePair> nvps = new ArrayList<NameValuePair>();
   nvps.add(new BasicNameValuePair("id", UUID.randomUUID().toString()));
   nvps.add(new BasicNameValuePair("username", "abin"));
   nvps.add(new BasicNameValuePair("password", "abing"));
   nvps.add(new BasicNameValuePair("age", "28"));
   nvps.add(new BasicNameValuePair("address", "beijing of china"));
   nvps.add(new BasicNameValuePair("email", "varyall@tom.com"));
   httpPost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
   HttpResponse httpResponse = httpClient.execute(httpPost);
   BufferedReader buffer = new BufferedReader(new InputStreamReader(
     httpResponse.getEntity().getContent()));
   StringBuffer stb=new StringBuffer();
   String line=null;
   while((line=buffer.readLine())!=null){
    stb.append(line);
   }
   buffer.close();
   String result=stb.toString();
   System.out.println("result="+result);
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

}

在java线程并发处理中，有一个关键字volatile的使用目前存在很大的混淆，以为使用这个关键字，在进行多线程并发处理的时候就可以万事大吉。

Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了 同步块 和 volatile 关键字机制。

 

synchronized 

同步块大家都比较熟悉，通过 synchronized 关键字来实现，所有加上synchronized 和 块语句，在多线程访问的时候，同一时刻只能有一个线程能够用

synchronized 修饰的方法 或者 代码块。

 

volatile

用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。

 

下面看一个例子，我们实现一个计数器，每次线程启动的时候，会调用计数器inc方法，对计数器进行加一

 

执行环境——jdk版本：jdk1.6.0_31 ，内存 ：3G   cpu：x86 2.4G

运行结果:Counter.count=992

运行结果还是没有我们期望的1000，下面我们分析一下原因

 

在 java 垃圾回收整理一文中，描述了jvm运行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，

线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存

变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，

在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。下面一幅图

描述这写交互

 

 

 

read and load 从主存复制变量到当前工作内存
use and assign  执行代码，改变共享变量值
store and write 用工作内存数据刷新主存相关内容

其中use and assign 可以多次出现

但是这一些操作并不是原子性，也就是 在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样

对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的

例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值

在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6

线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6

导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

爱公司的程序员
博客园blog地址:http://www.cnblogs.com/aigongsi/
本人版权归作者和博客园所有，欢迎转载，转载请注明出处。