线程范围内共享变量的概念与作用(六)

多个模块在同一个线程中运行时要共享同一份数据，实现线程范围内的数据共享可以用上一节中所用的方法。

       JDK1.5提供了ThreadLocal类来方便实现线程范围内的数据共享，它的作用就相当于上一节中的Map。

       每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map集合中增加一条记录，key就是各自的线程，value就是各自的set方法传进去的值。

       在线程结束时可以调用ThreadLocal.clear()方法用来更快释放内存，也可以不调用，因为线程结束后也可以自动释放相关的ThreadLocal变量。

       一个ThreadLocal对象只能记录一个线程内部的一个共享变量，需要记录多个共享数据，可以创建多个ThreadLocal对象，或者将这些数据进行封装，将封装后的数据对象存入ThreadLocal对象中。

       将数据对象封装成单例，同时提供线程范围内的共享数据的设置和获取方法，提供已经封装好了的线程范围内的对象实例，使用时只需获取实例对象即可实现数据的线程范围内的共享，因为该对象已经是当前线程范围内的对象了。下边给出张老师的优雅代码：

package cn.itheima;

import java.util.Random;

public classThreadLocalShareDataDemo

{   /**06.ThreadLocal类及应用技巧

     * 将线程范围内共享数据进行封装，封装到一个单独的数据类中，提供设置获取方法

     * 将该类单例化，提供获取实例对象的方法，获取到的实例对象是已经封装好的当前线程范围内的对象

     */

    public static voidmain(String[] args)

    {

        for (inti=0; i<2; i++)

        {

            newThread(

                    newRunnable()

                    {                      

                        public voidrun()

                        {

                            intdata = new Random().nextInt(889);

    System.out.println(Thread.currentThread().getName()+"产生数据："+data);

                            MyDatamyData = MyData.getInstance();

                            myData.setAge(data);

                            myData.setName("Name:"+data);

                            newA().get();

                            newB().get();

                        }

                    }).start();

        }

    }

   

    static class A

    {   //可以直接使用获取到的线程范围内的对象实例调用相应方法

        Stringname = MyData.getInstance().getName();

        int age =MyData.getInstance().getAge();

        public voidget()

        {

            System.out.println(Thread.currentThread().getName()+"--AA name:"+name+"...age:"+age);

        }

    }  

   

    static class B

    {

        //可以直接使用获取到的线程范围内的对象实例调用相应方法

        Stringname = MyData.getInstance().getName();

        int age =MyData.getInstance().getAge();

        public voidget()

        {

            System.out.println(Thread.currentThread().getName()+"--BB name:"+name+"...age:"+age);

        }

    }  

   

    static classMyData

    {

        privateString name;

        private int age;

        publicString getName()

        {

            return name;

        }

        public voidsetName(String name)

        {

            this.name =name;

        }

        public intgetAge()

        {

            return age;

        }

        public voidsetAge(int age)

        {

            this.age =age;

        }

        //单例

        privateMyData() {};

        //提供获取实例方法

        public staticMyData getInstance()

        {

            //从当前线程范围内数据集中获取实例对象

            MyDatainstance = threadLocal.get();

            if(instance==null)

            {

                instance= new MyData();

                threadLocal.set(instance);

            }

            returninstance;

        }

        //将实例对象存入当前线程范围内数据集中

        staticThreadLocal<MyData> threadLocal = newThreadLocal<MyData>();

    }

}

*线程范围内共享变量的概念与作用
 *这里面需要考虑的的是如果这个线程加入到集合的时候，这个线程结束那么这个value什么时候被释放也，
 *这个方法里面的一个clear就是清除map里面的数据
 *1、有没有可能出现这种情况，map里面存了很多,可以查看javase文档，
 *第一个线程都有一个隐含的引用，只要这个线程是活的，并且这个threadlocal是可以访问的，然后一个线程走了，它的拷贝线程实例就会被垃圾回收
 *除非有其他引用线程内的变量，如果没有被其他引用就可以释放，
 */
public class ThreadLocalTest {


    private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
    private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();
    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();
                    System.out.println(Thread.currentThread().getName() 
                            + " has put data :" + data);
                    x.set(data);
/*                  MyThreadScopeData myData = new MyThreadScopeData();
                    myData.setName("name" + data);
                    myData.setAge(data);
                    myThreadScopeData.set(myData);*/
                    MyThreadScopeData.getThreadInstance().setName("name" + data);
                    MyThreadScopeData.getThreadInstance().setAge(data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }
    
    static class A{
        public void get(){
            int data = x.get();
            System.out.println("A from " + Thread.currentThread().getName() 
                    + " get data :" + data);
/*          MyThreadScopeData myData = myThreadScopeData.get();;
            System.out.println("A from " + Thread.currentThread().getName() 
                    + " getMyData: " + myData.getName() + "," +
                    myData.getAge());*/
            MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
            System.out.println("A from " + Thread.currentThread().getName() 
                    + " getMyData: " + myData.getName() + "," +
                    myData.getAge());
        }
    }
    
    static class B{
        public void get(){
            int data = x.get();         
            System.out.println("B from " + Thread.currentThread().getName() 
                    + " get data :" + data);
            MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
            System.out.println("B from " + Thread.currentThread().getName() 
                    + " getMyData: " + myData.getName() + "," +
                    myData.getAge());           
        }       
    }
}


class MyThreadScopeData{
    private MyThreadScopeData(){}
    // 这里面为什么使用ThreadLocal不加synchronize，因为线程a拿到为null,与线程b不是同一个所以不需要加synchronized
    // b线程来拿跟a线程没有关系，所以不需要加
    public static /*synchronized*/ MyThreadScopeData getThreadInstance(){
        MyThreadScopeData instance = map.get();
        if(instance == null){
            instance = new MyThreadScopeData();
            map.set(instance);
        }
        return instance;
    }
    //private static MyThreadScopeData instance = null;//new MyThreadScopeData();
    private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();
    
    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;
    }
}