多线程（三）实现线程范围内模块之间共享数据及线程间数据独立（ThreadLocal）-蒲公英云

ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。JDK 1.2的版本中就提供java.lang.ThreadLocal，使用这个工具类可以很简洁地编写出优美的多线程程序，ThreadLocal并不是一个Thread，而是Thread的局部变量。

1.下图和辅助代码解释ThreadLocal的作用和目的：用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。

2.每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map中增加一条记录，key分别是各自的线程，value是各自的set方法传进去的值。在线程结束时可以调用ThreadLocal.clear()方法，这样会更快释放内存，不调用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。

3.ThreadLocal的应用场景：
(1)订单处理包含一系列操作：减少库存量、增加一条流水台账、修改总账，这几个操作要在同一个事务中完成，通常也即同一个线程中进行处理，如果累加公司应收款的操作失败了，则应该把前面的操作回滚，否则，提交所有操作，这要求这些操作使用相同的数据库连接对象，而这些操作的代码分别位于不同的模块类中。
(2)银行转账包含一系列操作：把转出帐户的余额减少，把转入帐户的余额增加，这两个操作要在同一个事务中完成，它们必须使用相同的数据库连接对象，转入和转出操作的代码分别是两个不同的帐户对象的方法。
(3)例如Strut2的ActionContext，同一段代码被不同的线程调用运行时，该代码操作的数据是每个线程各自的状态和数据，对于不同的线程来说，getContext方法拿到的对象都不相同，对同一个线程来说，不管调用getContext方法多少次和在哪个模块中getContext方法，拿到的都是同一个。
4.实验案例：定义一个全局共享的ThreadLocal变量，然后启动多个线程向该ThreadLocal变量中存储一个随机值，接着各个线程调用另外其他多个类的方法，这多个类的方法中读取这个ThreadLocal变量的值，就可以看到多个类在同一个线程中共享同一份数据。
5.实现对ThreadLocal变量的封装，让外界不要直接操作ThreadLocal变量。
(1)对基本类型的数据的封装，这种应用相对很少见。
(2)对对象类型的数据的封装，比较常见，即让某个类针对不同线程分别创建一个独立的实例对象。

Center

例子程序:

第一种实现方式:（但是这种实现方式不如第二种实现方式好）

package cn.itcast.lishehe;
import java.util.Random;
/**
 * 李社河-2015年6月11日 * 题目要求：构造两线程，要求： * (1)两线程并发操作 （这就要求不能使用syschronized关键字） * (2)要求两线程分别访问各自的数据MyData对象，互不干扰 * （这里就可以使用ThreadLocal对象，通过set()和get()即可获得与本线程相关的MyData对象，但注意，其只能关联一个数据， * 所以对于多个数据则应该封装到一个类中，其实际上也是通过Map实现的） * (3)线程内有A、B两个模块，模块之间共享数据MyData数据 * * 本程序实现方式不如ThreadLocalDataIndependent2.java好。
 **/
public class ThreadLocalDataIndependent1 {
    static ThreadLocal<MyData> threadLocal = new ThreadLocal<MyData>();
    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int data = new Random().nextInt();
                    //这里的data必须定义为局部变量，否则线程间不能实现数据独立 
                    MyData myData = new MyData();
                    myData.setName("name" + data);
                    myData.setAge(data);
                    threadLocal.set(myData);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }
    static class A {
        public void get() {
            MyData myData = threadLocal.get();
            System.out.println("A from " + Thread.currentThread().getName() + " get MyData :" + myData.getName() + "," + myData.getAge());
        }
    }
    static class B {
        public void get() {
            MyData myData = threadLocal.get();
            System.out.println("B from " + Thread.currentThread().getName() + " get MyData :" + myData.getName() + "," + myData.getAge());
        }
    }
}
class MyData {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

运行结果

Center 1

第二种实现方式:（struts2中对于用户的每次请求创建一个action实例，其也是这样实现的）

 package cn.itcast.lishehe;
import java.util.Random;
/**
 * 李社河-2015年6月11日 * 题目要求：构造两线程，要求： * (1)两线程并发操作 （这就要求不能使用syschronized关键字） * (2)要求两线程分别访问各自的数据MyData对象，互不干扰 * （这里就可以使用ThreadLocal对象，通过set()和get()即可获得与本线程相关的MyData对象，但注意，其只能关联一个数据， * 所以对于多个数据则应该封装到一个类中，其实际上也是通过Map实现的） * (3)线程内有A、B两个模块，模块之间共享数据MyData数据 * * 本程序实现方式比ThreadLocalDataIndependent1.java要好。 * 其中Struts2对于用户的每次请求，都将创建一个action实例进行处理，每个线程都有其独立的数据，其实现方式就是这种。
 **/
public class ThreadLocalDataIndependent2 {
    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int data = new Random().nextInt();
                    //这里的data必须定义为局部变量，否则线程间不能实现数据独立 
                    MyData2.getInstance().setName("name" + data);
                    MyData2.getInstance().setAge(data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }
    static class A {
        public void get() {
            MyData2 myData = MyData2.getInstance();
            System.out.println("A from " + Thread.currentThread().getName() + " get MyData :" + myData.getName() + "," + myData.getAge());
        }
    }
    static class B {
        public void get() {
            MyData2 myData = MyData2.getInstance();
            System.out.println("B from " + Thread.currentThread().getName() + " get MyData :" + myData.getName() + "," + myData.getAge());
        }
    }
}
class MyData2 {
    private static ThreadLocal<MyData2> threadMap = new ThreadLocal<MyData2>();
    private MyData2() {
    }
    //这里无需使用syschronized关键字 
    public static MyData2 getInstance() {
        MyData2 myData = threadMap.get();
        if (myData == null) {
            myData = new MyData2();
            threadMap.set(myData);
        }
        return myData;
    }
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}