1. <span style="font-size: medium;">public class ThreadSafeTestServlet extends HttpServlet  {
2. // 定义一个实例变量，并非一个线程安全的变量
3. private int counter = 0;
4. public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
5. doPost(req, resp);
6. }
7. public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
8. // 输出当前Servlet的信息以及当前线程的信息
9. System.out.println(this + ":" + Thread.currentThread());
10. // 循环，并增加实例变量counter的值
11. for (int i = 0; i < 5; i++) {
12. System.out.println("Counter = " + counter);
13. try {
14. Thread.sleep((long) Math.random() * 1000);
15. counter++;
16. } catch (InterruptedException exc) {
17. }
18. }
19. }
20. }
21. </span>

1. <span style="font-size: medium;">sample.SimpleServlet@11e1bbf:Thread[http-8081-Processor23,5,main]
2. Counter = 60
3. Counter = 61
4. Counter = 62
5. Counter = 65
6. Counter = 68
7. Counter = 71
8. Counter = 74
9. Counter = 77
10. Counter = 80
11. Counter = 83
12. sample.SimpleServlet@11e1bbf:Thread[http-8081-Processor22,5,main]
13. Counter = 61
14. Counter = 63
15. Counter = 66
16. Counter = 69
17. Counter = 72
18. Counter = 75
19. Counter = 78
20. Counter = 81
21. Counter = 84
22. Counter = 87
23. sample.SimpleServlet@11e1bbf:Thread[http-8081-Processor24,5,main]
24. Counter = 61
25. Counter = 64
26. Counter = 67
27. Counter = 70
28. Counter = 73
29. Counter = 76
30. Counter = 79
31. Counter = 82
32. Counter = 85
33. Counter = 88
34. </span>

1. <span style="font-size: medium;">public class Thread implements Runnable {
2. // 这里省略了许多其他的代码
3. ThreadLocal.ThreadLocalMap threadLocals = null;
4. }</span>

1. <span style="font-size: medium;">public class ThreadLocal<T> {
2. // 这里省略了许多其他代码
3. // 将value的值保存于当前线程的本地变量中
4. public void set(T value) {
5. // 获取当前线程
6. Thread t = Thread.currentThread();
7. // 调用getMap方法获得当前线程中的本地变量ThreadLocalMap
8. ThreadLocalMap map = getMap(t);
9. // 如果ThreadLocalMap已存在，直接使用
10. if (map != null)
11. // 以当前的ThreadLocal的实例作为key，存储于当前线程的
12. // ThreadLocalMap中，如果当前线程中被定义了多个不同的ThreadLocal
13. // 的实例，则它们会作为不同key进行存储而不会互相干扰
14. map.set(this, value);
15. else
16. // ThreadLocalMap不存在，则为当前线程创建一个新的
17. createMap(t, value);
18. }
19. // 获取当前线程中以当前ThreadLocal实例为key的变量值
20. public T get() {
21. // 获取当前线程
22. Thread t = Thread.currentThread();
23. // 获取当前线程中的ThreadLocalMap
24. ThreadLocalMap map = getMap(t);
25. if (map != null) {
26. // 获取当前线程中以当前ThreadLocal实例为key的变量值
27. ThreadLocalMap.Entry e = map.getEntry(this);
28. if (e != null)
29. return (T)e.value;
30. }
31. // 当map不存在时，设置初始值
32. return setInitialValue();
33. }
34. // 从当前线程中获取与之对应的ThreadLocalMap
35. ThreadLocalMap getMap(Thread t) {
36. return t.threadLocals;
37. }
38. // 创建当前线程中的ThreadLocalMap
39. void createMap(Thread t, T firstValue) {
40. // 调用构造函数生成当前线程中的ThreadLocalMap
41. t.threadLocals = new ThreadLocalMap(this, firstValue);
42. }
43. // ThreadLoaclMap的定义
44. static class ThreadLocalMap {
45. // 这里省略了许多代码
46. }
47. }
48. </span>

1. <span style="font-size: medium;">public class Counter {
2. // 新建一个静态的ThreadLocal变量，并通过get方法将其变为一个可访问的对象
3. private static ThreadLocal<Integer> counterContext = new ThreadLocal<Integer>() {
4. protected synchronized Integer initialValue() {
5. return 10;
6. }
7. };
8. // 通过静态的get方法访问ThreadLocal中存储的值
9. public static Integer get() {
10. return counterContext.get();
11. }
12. // 通过静态的set方法将变量值设置到ThreadLocal中
13. public static void set(Integer value) {
14. counterContext.set(value);
15. }
16. // 封装业务逻辑，操作存储于ThreadLocal中的变量
17. public static Integer getNextCounter() {
18. counterContext.set(counterContext.get() + 1);
19. return counterContext.get();
20. }
21. }</span>

1. <span style="font-size: medium;">public class ThreadLocalTest extends Thread {
2. public void run() {
3. for(int i = 0; i < 3; i++){
4. System.out.println("Thread[" + Thread.currentThread().getName() + "],counter=" + Counter.getNextCounter());
5. }
6. }
7. }
8. </span>

1. <span style="font-size: medium;">public class Test {
2. public static void main(String[] args) throws Exception {
3. ThreadLocalTest testThread1 = new ThreadLocalTest();
4. ThreadLocalTest testThread2 = new ThreadLocalTest();
5. ThreadLocalTest testThread3 = new ThreadLocalTest();
6. testThread1.start();
7. testThread2.start();
8. testThread3.start();
9. }
10. }
11. </span>

1. <span style="font-size: medium;">Thread[Thread-2],counter=11
2. Thread[Thread-2],counter=12
3. Thread[Thread-2],counter=13
4. Thread[Thread-0],counter=11
5. Thread[Thread-0],counter=12
6. Thread[Thread-0],counter=13
7. Thread[Thread-1],counter=11
8. Thread[Thread-1],counter=12
9. Thread[Thread-1],counter=13
10. </span>

Struts2 控制流程
1) 请求到来 
2) 创建 ValueStack（ Action 放栈顶），迕行初始化 
3) 调用拦截器 Interceptor，在拦截器中是可以访问 ValueStack 的 
4) 调用 Action，执行 execute()方法 
5) 调用 Result， Result 负责把数据显示给用户 
6) 最后到页面，通过标记库（Taglib）取出数据

当一个请求到达Servlet容器(Tomcat)后，将被传递给一个标准的过滤器链，在这个过滤器链中包括了可选的ActionContextCleanUp过滤器.当在Struts2 Web应用程序中集成SiteMesh时，才会用到此链。接下来，必须的FilterDispatcher被调用，它轮询ActonMapper(org.apache.struts2.dispatcher.mapper.ActionMapper)，以便确认这个请求是否应该调用一个action。如果ActionMapper确定了一个请求应该被调用，那么FilterDispatcher就把控制权委派给ActionProxy(com.opensymphony.xwork2.ActionProxy),ActionProxy询问框架的配置文件管理器(它从struts.xml文件中读取配置信息)，接下来，ActionProxy创建一个实现了命令模式的ActionInvocation，ActionInvocation在调用action之前会一次调用所有配置的连接器。一旦action执行返回，ActionInvocation就要struts.xml里面配置)，然后执行这个result,通常情况下result会调用JSP或者freeMarker模板呈现页面(但不总是这样，result也可以是一个action链).

这里介绍一下Struts2框架的组成部分:

1.ActionMapper和ActionMapping：

org.apache.struts2.dispatcher.mapper.ActionMapper接口在HTTP请求和action调用请求之间提供了一个映射，当给定一个HTTP请求时，ActionMapper根据请求的URL来查找是否有对应的action调用。如果有则返回一个描述了action调用的

ActionMapping，如果没有找到匹配的action调用请求，则返回null;

Struts2框架对该接口提供的默认实现是org.apacher.struts2.disspatcher.mapper.

DefaultActionMapper.

ActionMapping本质上是一个数据传输对象，它将Action类和要执行的方法的详细资料收集在一起，ActionMapping由org.apache.struts2.dispatcher.Dispatcher和各种用户接口组合使用。

ActionMapping的完整类名是

org.apacher.struts2.dispatcher.mapper.ActionMapping.

2.ActionProxy&ActionInvocation

Action的一个代理，由ActionProxyFactory创建，它本身不包括Action实例，默认实现DefaultActionProxy是由ActionInvocation持有Action实例。ActionProxy作用是如何取得Action，无论是本地还是远程。而ActionInvocation的作用是如何执行Action，拦截器的功能就是在ActionInvocation中实现的。

ConfigurationProvider&Configuration

ConfigurationProvider就是Struts2中配置文件的解析器，Struts2中的配置文件主要是尤其实现类XmlConfigurationProvider及其子类

StrutsXmlConfigurationProvider来解析。

3.ActionContext

是action执行的上下文，每一个上下文都相当于一个action执行所需要的一组对象的容器，例如session,application,parameters,locale等.

ActionContext包含了大量执行期间有用的环境信息，这些信息由org.apacher.

struts2.dispatcher.Dispatcher类在创建ActionProxy前设置，

并封装到一个Map对象extraContext中，

Map<String, Object> extraContext = createContextMap(request,

response, mapping, context);

该对象随后被作为参数传递给ActionProxyFactory的createActionProxy()方法.

ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(

namespace, name, method, extraContext, true, false);

ActionContext是线程本地的，这就意味着在ActionContext中存储的值对于每个线程都是唯一的，所以对于某个Action,如果要从ActionContext中获取数据，不需要担心线程安全问题。

ActionContext是被存放在当前线程中的，获取ActionContext也是从ThreadLocal中获取的。所以在执行拦截器、 action和result的过程中，由于他们都是在一个线程中按照顺序执行的，所以可以可以在任意时候在ThreadLocal中获取 ActionContext。ActionContext包括了很多信息，比如Session、Application、Request、Locale、ValueStack等，其中 ValueStack可以解析ognl表达式，来动态后去一些值，同时可以给表达式提供对象。

ActionContext(com.opensymphony.xwork.ActionContext)是Action执行时的上下文,上下文可以看作是一个容器 (其实我们这里的容器就是一个Map而已),它存放的是Action在执行时需要用到的对象. 一般情况, 我们的ActionContext都是通过: ActionContext context = (ActionContext) actionContext.get(); 来获取的.我们再来看看这里的actionContext对象的创建:

static ThreadLocal actionContext = new ActionContextThreadLocal();

ActionContextThreadLocal是实现ThreadLocal的一个内部类.ThreadLocal可以命名为"线程局部变量",它为每一个使用该变量的线程都提供一个变量值的副本,使每一个线程都可以独立地改变自己的副本,而不会和其它线程的副本冲突.这样,我们 ActionContext里的属性只会在对应的当前请求线程中可见,从而保证它是线程安全的.通过ActionContext取得

HttpSession: Map session = ActionContext.getContext().getSession();

(通过Map模拟HttpServlet的对象,操作更方便)

ActionConext的完整类名是:org.opensymphony.xwork2.ActionContext.

4．result

com.opensymphony.xwork2.Result接口代表action执行后的结果。每一个action 执行都需要返回一个String类型的结果码，用于配置result元素列表中选择对应的result。result在struts.xml文件中进行配置。

Result接口的不同实现代表了不同类型的结果输出，Struts2框架提供的Result 实现包括了Servlet转发，Servlet重定向，Velocity模板输出，FreeMarker模板输出，JasperReports(可生成PDF，CVS，XML等)和ActionChainResult(可用于从当前action 到其他action的链式处理)等.

Struts2框架的调用流程：

1>当Servlet容器接收到一个请求之后，将请求交给了在web.xml文件中配置的过滤器  FilterDispatcher,调用它的doFilter()方法。

2>FilterDispatcher询问ActionMapper,以便确认这个请求是否有对应的action调用.

3>ActionMapper返回一个描述了action调用的ActionMapping对象

4>FilterDispatcher调用Dispatcher类的serviceAction()方法。

5>FilterDispatcher调用ActionProxy的execute()方法。

6>ActionProxy设置ActionInvocation对象的执行上下文，然后调用其invoke()方法。

7>ActionInvocation的invoke()方法从拦截器映射中查找尚未执行的拦截器，调用它的intercepet(invocation)方法，并将自身对象的引用作为参数传递个拦截器。

8>拦截器完成某些预处理工作后,反过来调用ActionInvocation的invoke()方法，

ActionInvocation维护着自己的状态，所以它知道哪些拦截器已经被执行，如果还没有执行的拦截器，就继续执行它的intercept(invocation)方法。

9>如果所有的拦截器都已经执行过了，就调用action实例的execute()方法（如果在struts.xml文件中没有被设置成其它方法的话）.

10>ActionInvocation根据action执行返回的结果码，查找对应的Result，调用result的execute(invocation)，将结果页面呈现给用户.

11>ActionInvocation的invoke()方法将控制权返回给拦截器映射中的最后一个拦截器，该拦截器完成所有必须的后期处理工作，然后从intercepter(invocation)返回，允许前一个拦截器执行它自己的后处理工作。如此反复，直到所有的拦截器都成功返回。

12>ActionInvocation的invoke0方法执行完毕后，向ActionProxy返回一个String类型的结果码，最后ActionProxy清理状态并返回.