一、Servlet

　　Servlet 是sun公司提供一套规范（接口），用来处理客户端请求、响应给浏览器的动态资源。通过java的API 动态的向客户端输出内容。

　　Servlet是Java Web的三大组件（Servlet,Filter,Listener）之一，属于动态资源 ,运行在 Web 服务器或应用服务器上的程序作用为处理请求，服务器会把接收的请求交给Servlet来处理，在Servlet中通常需要：

　　　　* 接受请求数据；　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　* 处理请求；　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　* 完成响应。　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　Servlet是为了解决实现动态页面而衍生的东西。理解这个的前提是了解一些http协议的东西，并且知道B/S模式(浏览器/服务器)。

　　　　#服务器如何保存并返回一个网页？

　　　　　　##静态网页：无论谁看，其内容都一样

　　　　　　　　百科、新闻

　　　　　　　　--服务器直接存HTML，直接返回HTML即可。

　　　　　　##动态网页：不同人看到的内容有差异

　　　　　　　　淘宝、微博

　　　　　　　　--服务器保存一个组件，动态给每个用户拼一个网页。 >> 组件：满足规范的对象。Java中这个组件就是Servlet。

　　　　servlet规范（sun公司自己制定了一种用于扩展web服务器功能的组件规范）：包含三个技术点（三大组件）　　　

　　　　　　* servlet技术
　　　　　　* filter技术---过滤器
　　　　　　* listener技术---监听器

　　　　　　1）扩展web服务器功能

　　　　　　　　web服务器(tomcat、Weblogic、iis、apache)没有处理动态资源请求的能力(即该请求需要计算),

　　　　　　只能处理静态资源的请求(如果浏览器请求某个html页面，
　　　　　　　　web服务器查看请求的html页面是否存在，存在则返回。)如果要让web服务器处理动态资源的请求，

　　　　　　则需要使用cgi程序、组件加容器的方式。

　　　　　　2）组件（可以单独部署的软件模块，组件必须要符合相应的规范。）

　　　　　　　　优点是可以加快软件开发的速度，提高软件的可维护性。容器：为组件提供运行环境，并且管理组件的生命周期。

　　　　　　组件并不完全依赖特定的容器，只要符合相应的规范就可以。　　　

　　　　Servlet和普通java类的区别：
　　　　　　客户不能直接创建Servlet对象和调用Servlet的方法，只能通过向Web服务器发出HTTP请求，间接调用Servlet的方法。

# Servlet特点

　　## 是服务器端的组件

　　## 可以动态拼资源（HTML/IMG等），属于，处理HTTP协议。

　　## 满足sun规范

# 定义：Sun推出的用于在服务端处理HTTP协议的组件。

# 开发步骤

　　1. 创建web项目

　　2. 导入jar包

　　　　-- 使用maven：搜索javaee

　　　　-- 使用tomcat自带的包

　　　　　　- 选择项目，右键properties

　　　　　　- 弹窗左侧选targeted runtimes

　　　　　　- 右侧勾选Apache Tomcat

　　　　　　- Apply

　　3.开发Servlet

　　　　clip_image002

　　　　-- 编写Servlet

　　　　　　- 创建package、类；

　　　　　　- 继承HttpServlet，从而间接实现Servlet接口。

　　　　　　　　>> 实现Servlet的方式（通常会去继承HttpServlet类来完成Servlet）

　　　　　　　　　 实现javax.servlet.Servlet接口
　　　　　　　　　 继承javax.servlet.GenericServlet类
　　　　　　　　　 继承javax.servlet.http.HttpServlet类

　　　　　　- 重写父类的service()方法。

　　　　-- 配置Servlet

　　　　　　- 在web.xml文件中，先声明类，并取别名

　　　　　　- 通过别名引用此类，给它取一个访问路径

　　　　--4.部署

#原理：

　　clip_image002[5]

#HTTP协议

　　##抄文本传输协议。定义浏览器和web服务器之间如何通信和通信的数据格式。

　　　　clip_image004

　　　　一次请求一次连接，降低服务器压力。

　　##数据格式

　　　　1. 请求数据

　　　　　　-请求行：请求的基本信息

　　　　　　-消息头：请求数据的描述

　　　　　　-实体内容：具体的业务数据

　　　　　　clip_image006

　　　　2. 响应数据

　　　　　　-状态行：响应的基本信息

　　　　　　-消息头：响应数据的描述

　　　　　　-实体内容：具体的返回数据

　　　　　　clip_image008

　　##Servlet运行原理

　　clip_image010

　　　　###Servlet执行过程

　　　　在浏览器的地址栏输入：http://ip:port/appNames/servlet

　　　　　　1）通过浏览器和ip:port和这个服务器建立连接。
　　　　　　2） 浏览器会生成一个请求数据包（路径appNames/servlet）向服务器发送请求。
　　　　　　3） 服务器收到请求数据包，分析请求资源路径做精准定位，通过请求的appName查找webapps文件下面的appName

　　　　　　做匹配，匹配上了需要获取web.xml中的servlet(mapping)。　

　　　　　　4） 服务器创建两个对象：
　　　　　　　　第一个对象：请求对象，该对象实现了HttpServletRequest接口，服务器会将请求数据包中的数据解析出来,

　　　　　　　　　　　　　　存储在该对象里。这样做的好处是没有必要理解http协议，只需要读取request。

　　　　　　　　第二个对象：响应对象，实现了HttpServletResponse接口，作用是servlet处理完成后的结果可以存放到该对象上，

　　　　　　　　　　　　　　然后服务器依据该对象的数据生成响应数据包。
　　　　　　5） servlet在执行service()方法时，可以通过request获取请求数据，也可以将处理结果存放到response上。

　　　　　　然后服务器与响应对象直接形成一个默契，生成一个响应数据包给浏览器。

　　　　　　6）浏览器解析服务器返回的响应数据包，生成响应的结果。

　　　　　　

　　　　Servlet访问的过程：

　　　　Http请求 --->web.xml --->  url-pattern --->servlet-name --->servlet-class --->QuickStratServlet(对应的Class文件)

　　##浏览器向服务器发送数据的方式　　#请求方式

　　　　--需要掌握的有两种：GET+POST

　　　　　　-GET（默认）

　　　　--采用请求路径传参

　　　　--参数可见，隐私性差

　　　　--路径可容纳数据有限，只能传少量数据

　　　　　　-POST

　　　　--采用实体内容传参

　　　　--参数传递过程不可见，隐私性好

　　　　--没有大小限制

#代码例子

ServletDemo1:

package web;

import java.io.IOException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TimeServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        //告诉浏览器给它发送的是网页
        //request获取请求数据
        //1.请求行
        System.out.println("请求方式："+req.getMethod());

        System.out.println("访问路径："+req.getServletPath());
        System.out.println("协议类型："+req.getProtocol());
        //2.消息头（键值对）
        Enumeration<String> headerNames = req.getHeaderNames();
        while(headerNames.hasMoreElements()) {
            String key = headerNames.nextElement();
            String value = req.getHeader(key);
            System.out.println(key+":"+value);
        }
        //3.实体内容：此处未传内容
        
        //response发送响应数据
        //1.状态行：服务器自动填充
        //2.消息头：大部分由服务器填充，但返回内容的格式需要程序指定。
        res.setContentType("text/html");
        //3.实体内容：
        PrintWriter out = res.getWriter();
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        String now = sdf.format(date);
        //输出的网页就是实体内容
        out.println("<p>" + now + "</p>");
        out.close();
    }
}

ServletDemo2:

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <!-- 
        1.完整路径
        http://localhost:8080/ServletDemo2/reg
        2.绝对路径
         格式：/项目名/网名
         /ServletDemo2/reg
        3.相对路径（*）
        只需写出目标和当前页面的相对位置
        当前/ServletDemo2/register.html
        目标：/ServletDemo2/reg
        相对路径不能以/开头
     -->
    <form action="reg" method = "post">
        <p>
            账号：<input type = "text" name = "userName" />
        </p>
        <p>
            密码：<input type = "password" name = "password" />
        </p>
        <p>
            性别：
            <input type = "radio" name = "sex" value = "M">男</input>
            <input type = "radio" name = "sex" value = "F">女</input>
        </p>
        <p>
            兴趣：
            <input type = "checkbox" name = "inserest" value = "sport">运动</input>
            <input type = "checkbox" name = "inserest" value = "music">音乐</input>
            <input type = "checkbox" name = "inserest" value = "movie">电影</input>
        </p>
        <p>
            <input type = "submit" value = "注册" />
        </p>
    </form>
</body>
</html>
package web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class RegServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//        req.setCharacterEncoding("utf-8");//只对post有效
        //处理请求的一般步骤：
        //1.接收参数
        String userName = req.getParameter("userName");
        String pwd = req.getParameter("password");
        String sex = req.getParameter("sex");
        String[] interests = req.getParameterValues("interest");
        //2.处理业务
        System.out.println(userName);
        System.out.println(pwd);
        System.out.println(sex);
        if(interests != null) {
            for(String interest:interests) {
                System.out.print(interest+"\t");
            }
        }
        //3.发送响应
        res.setContentType("text/html;charset=utf-8");//方法一
//        res.setCharacterEncoding("UTF-8");//方法二，二选一
        PrintWriter out = res.getWriter();
        out.println("<p>注册成功</p>");
        out.close();
    }

}

#如何配置Servlet访问路径

　　##精确匹配

　　　　-此servlet只能处理一个请求：/abc

　　　　-适合规模小的项目

　　##通配符：例：/*

　　　　-所有的路径都能访问此servlet

　　　　-此servlet能处理所有请求

　　　　-适合一个项目只写一个servlet

　　##后缀：例：*.hi （不允许以/开头）

　　　　-所有以hi为后缀的请求都能访问此servlet

　　　　-此servlet能处理多个请求

　　　　-适合一个项目写少量的几个servlet

#servlet生命周期

clip_image002[1]

　　　  clip_image004[1]

　　##生命周期方法与特性

　　　　1、void init(ServletConfig servletConfig)：Servlet对象创建之后马上执行的初始化方法，只执行一次；
　　　　2、void service(ServletRequest servletRequest, ServletResponse servletResponse)：

　　　　每次处理请求都是在调用这个方法，它会被调用多次；
　　　　3、void destroy()：在Servlet被销毁之前调用，负责释放Servlet对象占用的资源的方法；

#ServletConfig和ServletContext

　　-作用

　　　　clip_image006[1]

　　-区别

　　　　1.config

　　　　　　-和servlet是一对一关系

　　　　　　-tomcat在初始化每个servlet前会给他创建一个config

　　　　　　-调用HiServlet. init()前给它创建一个config

　　　　　　-调用HelloServlet.init()前给它创建一个config

　　　　　　　　--如果想给某个Servlet预置数据，使用config

　　　　2.context

　　　　　　-和Servlet是一对多的关系

　　　　　　-tomcat在启动时就创建唯一的一个context

　　　　　　-所有的servlet都可以共享这个对象中的数据

　　　　　　　　--如果想给多个servlet预置数据，使用context

　　-应用

　　##特性：　　

　　　　-单例，一个类只有一个对象，当然可能存在多个Servlet类
　　　　-线程不安全的，所以它的效率高。

　　　　-Servlet类由自己编写，但对象由服务器来创建，并由服务器来调用相应的方法　

　　ServletDemo3

package web;public class HiServlet extends HttpServlet {
    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        String maxOnline = config.getInitParameter("maxOnline");
        System.out.println(maxOnline);
    }
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //此config就是init()传入的那个
        ServletConfig cfg = getServletConfig();
        String maxOnline = cfg.getInitParameter("maxOnline");
        System.out.println(maxOnline);
        System.out.println("登录中……");
    }
    @Override
    public void destroy() {
        super.destroy();
    }
}
package web;
public class FindDeptServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        //tomcat启动时就会创建唯一的context，并且会调用它的方法加载web.xml中的公用参数，
        //context是全局的，任何servlet都可以使用。
        ServletContext context = getServletContext();
        String size = context.getInitParameter("size");
        System.out.println(size);
        System.out.println("分页查询");
        //统计流量
        Integer count = (Integer) context.getAttribute("count");
        context.setAttribute("count", ++count);
        System.out.println(count);
    }
    @Override
    public void destroy() {
        super.destroy();
    }
}
package web;
public class InitServlet extends HttpServlet {
    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        //tomcat启动时会优先创建context，然后再创建servlet
        ServletContext ctx = getServletContext();
        //流量默认为0
        ctx.setAttribute("count", 0);
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="" xmlns=" xsi:schemaLocation="" version="2.5">
  <display-name>ServletDemo3</display-name>
  <servlet>
      <servlet-name>login</servlet-name>
      <servlet-class>web.HiServlet</servlet-class>
      <!-- 给此servlet预置参数 -->
      <init-param>
          <param-name>maxOnline</param-name>
          <param-value>3000</param-value>
      </init-param>
  </servlet>
  <servlet-mapping>
      <servlet-name>login</servlet-name>
      <url-pattern>*.hi</url-pattern>
  </servlet-mapping>
  <servlet>
      <servlet-name>findDept</servlet-name>
      <servlet-class>web.FindDeptServlet</servlet-class>
      <!-- 给此servlet预置参数 -->
      <init-param>
          <param-name>maxOnline</param-name>
          <param-value>3000</param-value>
      </init-param>
  </servlet>
  <servlet-mapping>
      <servlet-name>findDept</servlet-name>
      <url-pattern>*.find</url-pattern>
  </servlet-mapping>
  <!-- 在标签外配置的参数是给所有servlet公用的参数，他们都可以通过context读取参数 -->
  <context-param>
      <param-name>size</param-name>
      <param-value>20</param-value>
  </context-param>
  <servlet>
      <servlet-name>init</servlet-name>
      <servlet-class>web.InitServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
  </servlet>
</web-app>

#Servlet与线程安全问题

　　一个类型的Servlet只有一个实例对象，那么就有可能会出现一个Servlet同时处理多个请求，线程不安全，但Servlet工作效率高。

　　解决方案：

　　　　1、不要在Servlet中创建成员，创建局部变量即可！
　　　　2、可以创建无状态成员！
　　　　3、可以创建有状态的成员，但状态必须位为只读的！　

public class Servlet extends HttpServlet {
    //无状态成员
    /*public class User {
        public void hello() {
            System.out.println("Hello");
        }
    }*/
    //创建有状态的成员，但状态必须位为只读的
    /*public class User {
        private String name = "zhangsan";
        public String getName() {
            return name;
        }
    }*/
    private User user = new User();
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("doPost()...");
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("doGet()...");
    }
}

 #tomcat和Servlet的联系

　　Tomcat 是Web应用服务器,是一个Servlet/JSP容器。Tomcat 作为Servlet容器，负责处理客户请求,把请求传送给Servlet，并将Servlet的响应传送回给客户。而Servlet是一种运行在支持Java语言的服务器上的组件.。

　　Servlet最常见的用途是扩展Java Web服务器功能，提供非常安全的,可移植的,易于使用的CGI替代品。

　　从http协议中的请求和响应可以得知，浏览器发出的请求是一个请求文本，而浏览器接收到的也应该是一个响应文本。

　　但是在上面这个图中，并不知道是如何转变的，只知道浏览器发送过来的请求也就是request，我们响应回去的就用response。忽略了其中的细节，现在就来探究一下。

　　

　　1）Tomcat将http请求文本接收并解析，然后封装成HttpServletRequest类型的request对象，所有的HTTP头数据读可以通过request对象调用对应的方法查询到。

　　2）Tomcat同时会将要响应的信息封装为HttpServletResponse类型的response对象，通过设置response属性就可以控制要输出到浏览器的内容，然后将response交给tomcat，tomcat就会将其变成响应文本的格式发送给浏览器。

　　Java Servlet API 是Servlet容器(tomcat)和servlet之间的接口，它定义了serlvet的各种方法，还定义了Servlet容器传送给Servlet的对象类，其中最重要的就是ServletRequest和ServletResponse。

　　所以说我们在编写servlet时，需要实现Servlet接口，按照其规范进行操作。

#创建的servlet是继承自httpServlet，而不是直接实现Servlet接口的原理

　　servlet的生命周期中，可以看出，执行的是service方法，为什么我们就只需要写doGet和doPost方法呢？
　　查看源码，httpServlet的继承结构。
　　httpServlet继承GenericServlet。懂的人立马就应该知道，GenericServlet(通用Servlet)的作用是什么？大概的就是将实现Servlet接口的方法，简化编写servlet的步骤。具体下面详解
　　　　　　

　　GenericServlet的继承结构，实现了Servlet接口和ServletConfig接口

　　　　　　

　　Servlet接口内容

　　　　　　

　　从这里可以看到，Servlet生命周期的三个关键方法，init、service、destroy。还有另外两个方法，一个getServletConfig()方法来获取ServletConfig对象，

　　ServletConfig对象可以获取到Servlet的一些信息，ServletName、ServletContext、InitParameter、InitParameterNames、通过查看ServletConfig这个接口就可以知道：

　　ServletConfig接口内容

　　　　　　

　　其中ServletContext对象是servlet上下文对象，功能有很多，获得了ServletContext对象，就能获取大部分我们需要的信息，比如获取servlet的路径，等方法。

　　到此，就知道了Servlet接口中的内容和作用，总结起来就是，三个生命周期运行的方法，获取ServletConfig，而通过ServletConfig又可以获取到ServletContext。而GenericServlet实现了Servlet接口后，

　　也就说明我们可以直接继承GenericServlet，就可以使用上面我们所介绍Servlet接口中的那几个方法了，能拿到ServletConfig，也可以拿到ServletContext，不过那样太麻烦，不能直接获取ServletContext，

　　所以GenericServlet除了实现Servlet接口外，还实现了ServletConfig接口，那样，就可以直接获取ServletContext了。

　　GenericServlet类的内容详解

　　　　　　

　　看上图，用红色框框起来的就是实现Servlet和ServletConfig接口所实现的方法，有9个，这很正常，但是我们可以发现，init方法有两个，一个是带有参数ServletConfig的，一个有无参的方法，为什么这样设计？

　　这里需要知道其中做了什么事情，来看看这两个方法分别做了什么事？

　　　　init(ServletConfig config)

　　　　　　

　　　　init()

　　　　　　

　　　　一个成员变量config

　　　　　　

　　　　getServletConfig()

　　　　　　

　　通过这几个方法一起来讲解，首先看init(ServletConfig config)方法，因为只有init(ServletConfig config)中带有ServletConfig对象，为了方便能够在其他地方也能直接使用ServletConfig对象，而不仅仅局限在init(ServletConfig config)方法中，

　　所以创建一个私有的成员变量config，在init(ServletConfig config)方法中就将其赋值给config，然后通过getServletConfig()方法就能够获取ServletConfig对象了，这个可以理解，但是在init(ServletConfig config)中，158行，还调用了一个init()方法，

　　并且这个init()方法是空的，什么读没有，这是为什么呢？这个原因是为了防止一件事情，当我们需要在init方法中做一点别的事情，我们想到的方法就是继承GenericServlet并且重写了init(ServletConfig config)方法，这样依赖，

　　就破坏了原本在GenericServlet类中init(ServletConfig config)写的代码了，也就是在GenericServlet类中的成员变量config会一直是null，无法得到赋值，因为被重写了，就不会在执行GenericServlet中init(ServletConfig config)方法中的代码。

　　要想赋值，就必须在重写的init(ServletConfig config)方法中调用父类的init(ServletConfig config)方法，也就是super.init(ServletConfig config)，这样一来，就很不方便，怕有时候会忘了写这句代码，所以在GenericServlet类中增加一个init()方法，

　　以后需要在init方法中需要初始化别的数据，只需要重写init()这个方法，而不需要去覆盖init(ServletConfig config)这个方法，这样设计，就好很多，不用在管init(ServletConfig config)这个其中的内容了。也不用出现其他的问题。

　　service(ServletRequest req, ServletResponse res)

　　

　　一个抽象方法，说明在GenericServlet类中并没有实现该内容，那么我们想到的是，在它上面肯定还有一层，也就是还有一个子类继承它，实现该方法，要是让我们自己写的Servlet继承GenericServlet，

　　需要自己写service方法，那岂不是累死，并且我们可以看到，service方法中的参数还是ServletRequest，ServletResponse。并没有跟http相关对象挂钩，所以我们接着往下面看。

　　HttpServlet类详解

　　　　继承了GenericServlet类，通过我们上面的推测，这个类主要的功能肯定是实现service方法的各种细节和设计。并且通过类名可以知道，该类就跟http挂钩了。

　　　　

　　　　关注service(HttpServletRequest req, HttpServletResponse resp)方法和service(ServletRequest req, ServletResponse res)方法。

　　　　service(ServletRequest req, ServletResponse res)方法

　　　　

　　　　该方法中就做一件事情，就是将ServletRequest和ServletResponse这两个对象强转为HttpServletRequest和HttpServletResponse对象。为什么能这样转？

　　　　首先要知道req、res是什么类型，通过打印System.out.println(req)，可以知道，req实际上的类型是org.apache.catalina.connector.RequestFacade

　　　　Tomcat中的源码：

　　　　　　　

　　　　通过图可以得知，req的继承结构：RequestFacade、httpServletRequest、ServletRequest，我们知道本身req是ServletRequest，那么从继承结构上看，它也可以看成HttpServletRequest，也可以看成ServletRequest，

　　　　所以强转为HttpServletRequest是可以的，如果不明白，我举个例子，ArrayList、List、Object 这个，Object obj = new ArrayList();  List list = new ArrayList();  一个ArrayList对象可以看成List对象， 也可以看成一个Object对象，

　　　　现在obj是不是可以堪称List对象呢？答案是可以的，因为obj就是ArrayList对象，既然是ArrayList对象，那么就可以看成是List对象。一样的道理，RequestFacade 对应 ArrayList、httpServleRequest对应 List、 ServletRequest 对应 Object。

　　　　转换为httpServletRequest和HttpServletResponse对象之后，在调用service(HttpServletRequest req, HttpServletResponse resp)方法。

　　　　service(HttpServletRequest req, HttpServletResponse resp)

　　　　这个方法就是判断浏览器过来的请求方式是哪种，每种的处理方式不一样，我们常用的就是get，post，并且，我们处理的方式可能有很多的内容，所以，在该方法内会将get，post等其他5种请求方式提取出来，

　　　　变成单个的方法，然后我们需要编写servlet时，就可以直接重写doGet或者doPost方法就行了，而不是重写service方法，更加有针对性。所以这里就回到了我们上面编写servlet时的情况，继承httpServlet，

　　　　而只要重写两个方法，一个doGet，一个doPost，其实就是service方法会调用这两个方法中的一个(看请求方式)。

附件：

什么是JavaBean？

满足如下规范的类：

-有包

-有默认构造器

-实现序列化接口

-有get/set方法

clip_image002[3]

#Servlet线程安全问题

##1.同时修改局部变量

##2.同时修改成员变量

    -成员变量存于堆内

    -所有线程共享这样的数据

    >存在线程安全问题

##解决方案

    -加锁synchronized

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/menbozg/p/10435826.html