blocks|key|4677250|text|Servlet的生命周期与应用程序的生命周期相同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4677251|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A Servlet lives as long as the application does.

blocks|key|4677299|text|servlet不绑定到会话，它是一个服务对象，在需要时由容器实例化，并且通常在webapp的整个生命周期中保持活动状态。它通常响应来自多个客户端(和会话)的请求，甚至是并发请求。这就是为什么servlet代码必须是线程安全的，并且决不能在servlet字段中存储一些与请求或会话相关的数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4677300|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A servlet is not bound to a session, it is a service object that is instantiated by the container when needed, and typically is kept alive for the full life of the webapp. It typically responds to requests from several clients (and sessions), even concurrent requests.
That's precisely why your servlet code must be thread safe, and you never store in a servlet field some data associated to a request or a session.

blocks|key|1895530|text|如果我没记错的话，Servlet在Servlet容器(例如Tomcat)中是作为Singletons存在的。我不确定第一个实例化是否是惰性的，这意味着只有在需要时才会构造Servlet，但我猜可以在相应的Servlet容器的Classloader源代码中检查这一点。Servlet的生命周期结束，它的destroy()方法在Servlet容器关闭时被调用。您可以通过设置断点或在适当的init()和destroy()方法和构造函数中记录日志来轻松地检查这一点，然后只需在调试器/日志文件中检查代码何时执行即可。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1895531|希望这能帮上忙。|1895532|参考资料：Tomcat's+Classloader+howto|1895533|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Singleton_pattern|1|http://tomcat.apache.org/tomcat-6.0-doc/class-loader-howto.html^0|46|9|5C|6|5J|9|14|A|0|0|0|5|Q|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|14|8|@]|D|@$9|15|A|16|1|17]]|E|$]]|$1|J|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

when i remember correctly servlets live as <a href="http://en.wikipedia.org/wiki/Singleton_pattern" rel="nofollow">Singletons</a> in the Servlet Container (e.g. Tomcat). Im not sure if the first instantiation is lazy, meaning that the Servlet gets constructed only if needed, but im guessing one could check this in the corresponding Servlet Container's Classloader sources.
 The Servlet's lifecycle ends and it's <code>destroy()</code> method gets called when the Servlet Container is shut down.
 You can check this easily by setting up breakpoints or logging in the appropriate <code>init()</code> and <code>destroy()</code> methods and Constructor then just check when the code gets executed in your debugger/logfile.

hope that helped.

References:
 <a href="http://tomcat.apache.org/tomcat-6.0-doc/class-loader-howto.html" rel="nofollow">Tomcat's Classloader howto</a>

blocks|key|1150335|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1150336|+servlet是在应用程序启动(部署在servlet容器上)或首次访问(取决于load-on-startup设置)时创建的。|unordered-list-item|offset|length|style|CODE|1150337|实例化servlet时，servlet的init()方法被调用|1150338|，然后servlet+(它的唯一实例)处理所有请求(它的service()方法由多个线程调用)。这就是为什么不建议在其中进行任何同步，并且您应该避免servlet+|1150339|的实例变量。当应用程序被取消部署(servlet容器停止)时，将调用destroy()方法。|1150340|1150341|entityMap^0|0|14|F|0|K|6|0|S|9|0|Y|9|0|0^^$0|@$1|2|3|-4|4|5|6|Q|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|R|7|@$D|S|E|T|F|G]]|8|@]|9|$]]|$1|H|3|I|4|C|6|U|7|@$D|V|E|W|F|G]]|8|@]|9|$]]|$1|J|3|K|4|C|6|X|7|@$D|Y|E|Z|F|G]]|8|@]|9|$]]|$1|L|3|M|4|C|6|10|7|@$D|11|E|12|F|G]]|8|@]|9|$]]|$1|N|3|-4|4|5|6|13|7|@]|8|@]|9|$]]|$1|O|3|-4|4|5|6|14|7|@]|8|@]|9|$]]]|P|$]]

<ul>
<li>a servlet is created when the application starts (it is deployed on the servlet container) or when it is first accessed (depending on the <code>load-on-startup</code> setting)</li>
<li>when the servlet is instantiated, the <code>init()</code> method of the servlet is called</li>
<li>then the servlet (its one and only instance) handles all requests (its <code>service()</code> method being called by multiple threads). That's why it is not advisable to have any synchronization in it, and you should avoid instance variables of the servlet</li>
<li>when the application is undeployed (the servlet container stops), the <code>destroy()</code> method is called.</li>
</ul>

blocks|key|1900194|text|生命周期是定义良好的，并通过在Servlet的init、服务和销毁方法中公开的生命周期方法公开。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1900195|而且，不管这里还说了些什么，这就是你能从规范中得到的所有东西。基本上，您可以获得这三个方法，并保证Servlets不是线程安全的。单个servlet可以由一个或多个请求同时访问。|1900196|规范中没有将servlet限制到容器的一个实例，如果容器决定，它可以获得一个请求，创建一个servlet，调用它的init，然后是服务，然后销毁方法，并将其释放以进行垃圾收集。|1900197|每个容器都可能有不同的实现。|1900198|大多数容器都会创建单个实例。但是规范不能保证这一点，所以你不应该依赖它。|1900199|另外，考虑一下像Google+App+Engine这样的东西。GAE非常具有侵略性，它不断地过期并关闭整个web应用程序，这些应用程序没有收到任何流量。如果您有一个访问较少的站点，您可以很好地预期整个应用程序将启动，初始化其所有服务，初始化任何启动时加载的servlet，执行请求，然后关闭所有内容。因此，在GAE上，为了保持表面上的性能，您必须拥有一个非常快速的应用程序启动。|1900200|所以，简单地说，您可以依靠的是规范所说的内容。各个容器可能会提供不同的运行时体验。|1900201|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

The lifecycle is well defined, and exposed through lifecycle methods exposed in init, service, and destroy methods of the Servlet.

And, despite what else is being said here, this is all you can count on from the specification. Basically, you get those three methods and a guarantee that Servlets are not thread safe. That a single servlet MAY be simultaneously accessed by one or more requests.

There is nothing in the specification that limits a servlet to one instance the container, if a container decides to, it can get a request, create a servlet, call it's init, then service, then destroy methods, and set it free for garbage collection.

Individual containers have potentially different implementations.

Most containers do create a single instance. But the specification does not guarantee that, so you shouldn't rely on it.

Also, consider something like Google App Engine. GAE is VERY aggressive is continually expiring and shutting down entire web apps that receive no traffic. If you have a lightly traveled site, you can very well expect the entire app to start up, init all of its services, init any load-on-startup servlets, execute the request, and then shut everything down. So, on GAE it's imperative that you have a very fast application startup in order to maintain any semblance of performance.

So, simply, what you can count on is what the specification says. Individual containers may offer different run time experiences.

blocks|key|1150376|text|servlet+(它的一个也是唯一的实例)将以每个客户端的单独单线程的方式处理n个请求，其中克服了CGI限制。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1150377|servlet对象驻留在服务器端机器的堆中，只要应用程序未部署或servletConatiner关闭，servlet对象就不会消亡。|1150378|技术上:+servletcontainer保存servletobject，servletobject保存servletConfig对象|1150379|Servletcontainer只能调用其生命周期的3个方法1)init()+2)service()+3)destroy()|1150380|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The servlet (its one and only instance) will handle n number of request in the fashion of separate single thread for every client ie where CGI limitation is overcomed

A servlet object lives in heap of serverside machine as long as application is undeployed or servletConatiner is shutdown the servlet object will not die.

Technically : servletcontainer holds servletobject and servletobject holds servletConfig object 

Servletcontainer can only call the 3 methods of its life cycle 1)init() 2)service() 3)destroy()

blocks|key|1895627|text|servlet生命周期可以定义为从创建到销毁的整个过程。以下是servlet遵循的路径|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1895628|1895629|+servlet通过调用init+()方法进行初始化。|unordered-list-item|1895630|通过调用|1895631|()方法来处理客户端的请求。|1895632|+servlet通过调用destroy()终止servlet被JVM的垃圾收集器垃圾回收。|1895633|1895634|更多信息在这里..|1895635|http://www.dzone.com/links/r/java_ee_servlets_life_cycle.html|offset|length|1895636|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|0|0|0|0|1P|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|11|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|12|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|13|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|14|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|17|8|@]|9|@$Q|18|R|19|1|1A]]|A|$]]|$1|S|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|P]]]]

A servlet life cycle can be defined as the entire process from its creation till the destruction. The following are the paths followed by a servlet

<ul>
<li>The servlet is initialized by calling the init () method.</li>
<li>The servlet calls service() method to process a client's request.</li>
<li>The servlet is terminated by calling the destroy() method.</li>
<li>Finally, servlet is garbage collected by the garbage collector of the
JVM.</li>
</ul>

More here ..

<a href="http://www.dzone.com/links/r/java_ee_servlets_life_cycle.html" rel="nofollow">http://www.dzone.com/links/r/java_ee_servlets_life_cycle.html</a>

blocks|key|1900264|text|在Tomcat上运行的典型servlet的生命周期可能如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1900265|1.+1.Tomcat通过它的一个连接器接收来自客户端的请求。|1900266|2.+2.Tomcat将此请求映射到适当的引擎进行处理。这些引擎包含在其他元素中，例如主机和服务器，这限制了Tomcat搜索正确引擎的范围。|1900267|3.一旦请求被映射到适当的servlet，Tomcat就会检查该servlet类是否已经加载。如果没有，Tomcat将把servlet编译成Java字节码，并创建servlet的一个实例。|1900268|4.+4.Tomcat通过调用其init方法初始化servlet。servlet包括能够读取Tomcat配置文件并相应地执行操作的代码，以及声明它可能需要的任何资源的代码，以便Tomcat能够以有序、托管的方式创建它们。|1900269|5.一旦初始化了servlet，Tomcat就可以调用servlet的服务方法来处理请求，请求将作为响应返回。|1900270|6.在servlet的生命周期中，Tomcat和servlet可以通过使用侦听器类进行通信，侦听器类监视servlet的各种状态变化。Tomcat可以以各种方式检索和存储这些状态更改，并允许其他servlet访问它们，从而允许给定上下文的各个组件跨单个或多个用户会话维护和访问状态。此功能的一个实际应用示例是电子商务应用程序，该应用程序记住用户添加到购物车中的内容，并能够将此数据传递给结帐流程。|1900271|7.+7.Tomcat调用servlet的destroy方法来平滑地删除servlet。此操作要么由正在侦听的状态更改触发，要么由传递给Tomcat的外部命令触发，以取消部署servlet的上下文或关闭服务器。|1900272|参考资料：|1900273|https://www.mulesoft.com/tcat/tomcat-servlet|offset|length|1900274|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|0|0|0|0|0|18|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|19|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1A|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1B|8|@]|9|@$T|1C|U|1D|1|1E]]|A|$]]|$1|V|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|S]]]]

The lifecycle of a typical servlet running on Tomcat might look something like this: 

1.Tomcat receives a request from a client through one of its connectors. 

2.Tomcat maps this request to the appropriate Engine for processing. These Engines are contained within other elements, such as Hosts and Servers, which limit the scope of Tomcat's search for the correct Engine.

3.Once the request has been mapped to the appropriate servlet, Tomcat checks to see if that servlet class has been loaded. If it has not, Tomcat compiles the servlet into Java bytecode, which is executable by the JVM, and creates an instance of the servlet. 

4.Tomcat initializes the servlet by calling its init method. The servlet includes code that is able to read Tomcat configuration files and act accordingly, as well as declare any resources it might need, so that Tomcat can create them in an orderly, managed fashion.

5.Once the servlet has been initialized, Tomcat can call the servlet's service method to process the request, which will be returned as a response.

6.During the servlet's lifecycle, Tomcat and the servlet can communicate through the use of listener classes, which monitor the servlet for a variety of state changes. Tomcat can retrieve and store these state changes in a variety of ways, and allow other servlets access to them, allowing state to be maintained and accessed by various components of a given context across the span of a single or multiple user sessions. An example of this functionality in action is an e-commerce application that remembers what the user has added to their cart and is able to pass this data to a checkout process.

7.Tomcat calls the servlet's destroy method to smoothly remove the servlet. This action is triggered either by a state change that is being listened for, or by an external command delivered to Tomcat to undeploy the servlet's Context or shut down the server.

Reference:

<a href="https://www.mulesoft.com/tcat/tomcat-servlet" rel="nofollow">https://www.mulesoft.com/tcat/tomcat-servlet</a>

blocks|key|1152947|text|life+cycle+of+servlet+>
1)+load+the+class.
2)+instantiate+the+servlet.
3)+servlet+container+construct+the+servlet+config+interface.
4)+container+call+the+init()+and+pass+the+servlet+config+object.
5)+httpRequest+and+httpResponse+object+created.
6)+container+call+the+service()+and+pass+the+httpRequest+and+httpResponse+object+as+argument.
7)+process+the+service+method.and+if+have+any+other+request+then+follow+the+step+4+again.
8)+other+wise+container+call+the+distroy().|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1152948|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>life cycle of servlet &gt;
1) load the class.
2) instantiate the servlet.
3) servlet container construct the servlet config interface.
4) container call the init() and pass the servlet config object.
5) httpRequest and httpResponse object created.
6) container call the service() and pass the httpRequest and httpResponse object as argument.
7) process the service method.and if have any other request then follow the step 4 again.
8) other wise container call the distroy().
</code></pre>

blocks|key|4677726|text|实际上，Servlet可以在任何时候被销毁和重新创建！因此，其他答案有点描述了整个生命周期，但忽略了这个重要的细节。来自servlet规范：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4677727|servlet容器不需要在任何特定时间段内保持加载的servlet。servlet实例可以在servlet容器中保持活动一段毫秒，在servlet容器的生命周期内(可以是几天、几个月或几年)，或在两者之间的任何时间量。|4677728|..。|4677729|一旦在servlet实例上调用了destroy方法，容器就不能将其他请求路由到该servlet实例。如果容器需要再次启用servlet，则必须使用servlet类的新实例来启用。|4677730|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Actually the Servlet may be destroyed and recreated at any time ! So the other answers kinda describe the whole lifecycle but miss this important detail. From the servlet specification:

The servlet container is not required to keep a servlet loaded for any particular
period of time. A servlet instance may be kept active in a servlet container for a
period of milliseconds, for the lifetime of the servlet container (which could be a
number of days, months, or years), or any amount of time in between.

[...]

Once the destroy method is called on a servlet instance, the container may not route
other requests to that instance of the servlet. If the container needs to enable the
servlet again, it must do so with a new instance of the servlet’s class.

blocks|key|4677775|text|servlet的容器连接到web服务器，该服务器侦听某个端口号上的HTTP或HTTPS请求(端口8080通常在开发过程中使用，在生产中使用端口80+)。当客户端(使用web浏览器的用户)发送HTTP请求时，servlet容器会(为每个新请求)创建新的HttpServletRequest和HttpServletResponse对象，并将它们传递给任何定义的筛选器链，并最终传递给Servlet实例。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4677776|对于筛选器，将调用doFilter()方法。当servlet的代码调用chain.doFilter(request,+response)时，请求和响应继续到下一个筛选器，如果没有剩余的筛选器，则命中servlet。|4677777|对于servlets，service()方法被调用(由多个线程针对不同的请求)。默认情况下，此方法确定基于request.getMethod()调用哪个doXxx()方法。如果所确定的方法不在servlet中，则在响应中返回HTTP405错误。|4677778|request对象提供对有关HTTP请求的所有信息的访问，例如其标头和正文。response对象提供了以您想要的方式控制和发送HTTP响应的能力，例如，允许您设置头部和正文(通常使用从JSP文件生成的HTML内容)。当HTTP响应被提交并完成时，请求和响应对象都将被回收并用于重用。|4677779|entityMap^0|3H|I|40|J|0|9|A|Z|X|0|B|9|1H|J|24|7|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|14|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|M|$]]

The servlet's container is attached to a web server that listens for HTTP or HTTPS requests on a certain port number (port 8080 is usually used during development and port 80 in production). When a client (user with a web browser) sends an HTTP request, the servlet container creates new <code>HttpServletRequest</code> and <code>HttpServletResponse</code> objects (for every new request) and passes them through any defined Filter chain and, eventually, the Servlet instance.

In the case of filters, the <code>doFilter()</code> method is invoked. When its code calls <code>chain.doFilter(request, response)</code>, the request and response continue on to the next filter, or hit the servlet if there are no remaining filters.

In the case of servlets, the <code>service()</code> method is invoked(by multiple threads for different request). By default, this method determines which one of the <code>doXxx()</code> methods to invoke based off of <code>request.getMethod()</code>. If the determined method is absent from the servlet, then an HTTP 405 error is returned in the response.

The request object provides access to all of the information about the HTTP request, such as its headers and body. The response object provides the ability to control and send the HTTP response the way you want by, for instance, allowing you to set the headers and the body (usually with generated HTML content from a JSP file). When the HTTP response is committed and finished, both the request and response objects are recycled and made for reuse.

Basically, how long is an instance of a servlet around for? I am kind of guessing it is session scope. However, I suppose it could have some sort of timeout or garbage collection to remove old instances.

What is the lifecycle of a HttpServlet?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

基本上，servlet的一个实例存在多长时间？我猜是会话作用域。但是，我认为它可能会有某种超时或垃圾回收来删除旧实例。

问HttpServlet的生命周期是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问HttpServlet的生命周期是什么？EN