当前位置：首页 > 资讯 > 技术文档

深入解析Java中ThreadLocal线程类的作用和用法

时间：2021-01-23 14:32 编辑：来源：阅读：
扫一扫，手机访问

摘要：深入解析Java中ThreadLocal线程类的作用和用法

ThreadLocal与线程成员变量还有区别，ThreadLocal该类提供了线程局部变量。这个局部变量与一般的成员变量不一样，ThreadLocal的变量在被多个线程使用时候，每个线程只能拿到该变量的一个副本，这是Java API中的描述，通过阅读API源码，发现并非副本，副本什么概念？克隆品? 或者是别的样子，太模糊。准确的说，应该是ThreadLocal类型的变量内部的注册表（Map<Thread,T>）发生了变化，但ThreadLocal类型的变量本身的确是一个，这才是本质！下面就做个例子： [b]一、标准例子 [/b] 定义了MyThreadLocal类，创建它的一个对象tlt，分别给四个线程使用，结果四个线程tlt变量并没有出现共用现象，二是各用各的，这说明，四个线程使用的是tlt的副本（克隆品）。

 
/** 
* 使用了ThreadLocal的类 
*/ 
public class MyThreadLocal { 
    //定义了一个ThreadLocal变量，用来保存int或Integer数据 
    private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() { 
        @Override 
        protected Integer initialValue() { 
            return 0; 
        } 
    }; 

    public Integer getNextNum() { 
        //将tl的值获取后加1，并更新设置t1的值 
        tl.set(tl.get() + 1); 
        return tl.get(); 
    } 
}

/** 
* 测试线程 
*/ 
public class TestThread extends Thread { 
    private MyThreadLocal tlt = new MyThreadLocal(); 

    public TestThread(MyThreadLocal tlt) { 
        this.tlt = tlt; 
    } 

    @Override 
    public void run() { 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName() + "t" + tlt.getNextNum()); 
        } 
    } 
}

/** 
* ThreadLocal测试 
*/ 
public class Test { 
    public static void main(String[] args) { 
        MyThreadLocal tlt = new MyThreadLocal(); 
        Thread t1 = new TestThread(tlt); 
        Thread t2 = new TestThread(tlt); 
        Thread t3 = new TestThread(tlt); 
        Thread t4 = new TestThread(tlt); 
        t1.start(); 
        t2.start(); 
        t3.start(); 
        t4.start(); 

    } 
}

可以看出，三个线程各自独立编号，互不影响：

Thread-0 1 
Thread-1 1 
Thread-0 2 
Thread-1 2 
Thread-0 3 
Thread-1 3 
Thread-2 1 
Thread-3 1 
Thread-2 2 
Thread-3 2 
Thread-2 3 
Thread-3 3 


Process finished with exit code 0

tlt对象是一个，废话tl对象也是一个，因为组合关系是一对一的。但是tl对象内部的Map随着线程的增多，会创建很多Integer对象。只是Integer和int已经通用了。所以感觉不到Integer的对象属性。 [b]二、不用ThreadLocal [/b] 假如不用ThreadLocal，只需要将MyThreadLocal类重新定义为：

/** 
* 使用了ThreadLocal的类 
*/ 
public class MyThreadLocal { 
    private Integer t1 = 0; 
    public Integer getNextNum(){ 
        return t1=t1+1; 
    } 



//    定义了一个ThreadLocal变量，用来保存int或Integer数据 
//    private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() { 
//        @Override 
//        protected Integer initialValue() { 
//            return 0; 
//        } 
//    }; 
// 
//    public Integer getNextNum() { 
//        //将tl的值获取后加1，并更新设置t1的值 
//        tl.set(tl.get() + 1); 
//        return tl.get(); 
//    } 
}

然后运行测试：

Thread-2 1 
Thread-2 2 
Thread-1 4 
Thread-1 6 
Thread-3 3 
Thread-3 9 
Thread-3 10 
Thread-1 8 
Thread-0 7 
Thread-0 11 
Thread-0 12 
Thread-2 5 

Process finished with exit code 0

从这里可以看出，四个线程共享了tlt变量，结果每个线程都直接修改tlt的属性。 [b]三、自己实现个ThreadLocal [/b]

package com.lavasoft.test2; 

import java.util.Collections; 
import java.util.HashMap; 
import java.util.Map; 

/** 
* 使用了ThreadLocal的类 
*/ 
public class MyThreadLocal { 

    //定义了一个ThreadLocal变量，用来保存int或Integer数据 
    private com.lavasoft.test2.ThreadLocal<Integer> tl = new com.lavasoft.test2.ThreadLocal<Integer>() { 
        @Override 
        protected Integer initialValue() { 
            return 0; 
        } 
    }; 

    public Integer getNextNum() { 
        //将tl的值获取后加1，并更新设置t1的值 
        tl.set(tl.get() + 1); 
        return tl.get(); 
    } 
} 

class ThreadLocal<T> { 
    private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>()); 

    public ThreadLocal() { 
    } 

    protected T initialValue() { 
        return null; 
    } 

    public T get() { 
        Thread t = Thread.currentThread(); 
        T obj = map.get(t); 
        if (obj == null && !map.containsKey(t)) { 
            obj = initialValue(); 
            map.put(t, obj); 
        } 
        return obj; 
    } 

    public void set(T value) { 
        map.put(Thread.currentThread(), value); 
    } 

    public void remove() { 
        map.remove(Thread.currentThread()); 
    } 
}

运行测试：

Thread-0 1 
Thread-0 2 
Thread-0 3 
Thread-2 1 
Thread-2 2 
Thread-3 1 
Thread-2 3 
Thread-3 2 
Thread-1 1 
Thread-3 3 
Thread-1 2 
Thread-1 3 

Process finished with exit code 0

很意外，这个山寨版的ThreadLocal也同样运行很好，实现了JavaAPI中ThreadLocal的功能。 [b] 四、透过现象看本质 [/b] 其实从程序角度看，tlt变量的确是一个，毫无疑问的。但是为什么打印出来的数字就互不影响呢？是因为使用了Integer吗？-----不是。原因是：protected T initialValue()和get()，因为每个线程在调用get()时候，发现Map中不存在就创建。调用它的时候，就创建了一个新变量，类型为T。每次都新建，当然各用个的互不影响了。为了看清本质，将Integer换掉，重写部分类：

package com.lavasoft.test2; 

import java.util.Collections; 
import java.util.HashMap; 
import java.util.Map; 

/** 
* 使用了ThreadLocal的类 
*/ 
public class MyThreadLocal { 

    //定义了一个ThreadLocal变量，用来保存int或Integer数据 
    //    private ThreadLocal<Bean> tl = new ThreadLocal<Bean>() { 
    private com.lavasoft.test2.ThreadLocal<Bean> tl = new com.lavasoft.test2.ThreadLocal<Bean>() { 
        @Override 
        protected Bean initialValue() { 
            return new Bean(); 
        } 
    }; 

    @Override 
    public String toString() { 
        return "MyThreadLocal{" + 
                "tl=" + tl + 
                '}'; 
    } 

    public Bean getBean() { 
        return tl.get(); 
    } 

} 

class ThreadLocal<T> { 
    private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>()); 

    public ThreadLocal() { 
    } 

    protected T initialValue() { 
        return null; 
    } 

    public T get() { 
        Thread t = Thread.currentThread(); 
        T obj = map.get(t); 
        if (obj == null && !map.containsKey(t)) { 
            obj = initialValue(); 
            map.put(t, obj); 
        } 
        return obj; 
    } 

    public void set(T value) { 
        map.put(Thread.currentThread(), value); 
    } 

    public void remove() { 
        map.remove(Thread.currentThread()); 
    } 
}

package com.lavasoft.test2; 

/** 
* 测试Bean 
*/ 
public class Bean { 
    private String id = "0"; 
    private String name = "none"; 

    public Bean() { 
    } 

    public Bean(String id, String name) { 
        this.id = id; 
        this.name = name; 
    } 

    public String getId() { 
        return id; 
    } 

    public void setId(String id) { 
        this.id = id; 
    } 

    public String getName() { 
        return name; 
    } 

    public void setName(String name) { 
        this.name = name; 
    } 

    public String showinfo() { 
        return "Bean{" + 
                "id='" + id + ''' + 
                ", name='" + name + ''' + 
                '}'; 
    } 
}

package com.lavasoft.test2; 

/** 
* 测试线程 
*/ 
public class TestThread extends Thread { 
    private MyThreadLocal tlt = new MyThreadLocal(); 

    public TestThread(MyThreadLocal tlt) { 
        this.tlt = tlt; 
    } 

    @Override 
    public void run() { 
        System.out.println(">>>>>:" + tlt); 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName() + "t" +tlt.getBean()+"t"+tlt.getBean().showinfo()); 
        } 
    } 
}

然后运行测试：

>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d} 
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d} 
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d} 
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d} 
Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} 
Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'} 
Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'} 
Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'} 
Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'} 
Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} 
Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'} 
Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'} 
Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} 
Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} 
Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} 
Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} 


Process finished with exit code 0

从打印结果很清楚的看到，MyThreadLocal的tlt对象的确是一个，tlt对象里的ThreadLocal的tl对象也是一个，但是，将t1t给每个线程用的时候，线程会重新创建Bean对象加入到ThreadLocal的Map中去使用。 [b]关于ThreadLocal的几个误区： [/b][b]一、ThreadLocal是java线程的一个实现[/b] ThreadLocal的确是和java线程有关，不过它并不是java线程的一个实现，它只是用来维护本地变量。针对每个线程，提供自己的变量版本，主要是为了避免线程冲突，每个线程维护自己的版本。彼此独立，修改不会影响到对方。 [b]二、ThreadLocal是相对于每个session的[/b] ThreadLocal顾名思义，是针对线程。在java web编程上，每个用户从开始到会话结束，都有自己的一个session标识。但是ThreadLocal并不是在会话层上。其实，Threadlocal是独立于用户session的。它是一种服务器端行为，当服务器每生成一个新的线程时，就会维护自己的ThreadLocal。对于这个误解，个人认为应该是开发人员在本地基于一些应用服务器测试的结果。众所周知，一般的应用服务器都会维护一套线程池，也就是说，对于每次访问，并不一定就新生成一个线程。而是自己有一个线程缓存池。对于访问，先从缓存池里面找到已有的线程，如果已经用光，才去新生成新的线程。所以，由于开发人员自己在测试时，一般只有他自己在测，这样服务器的负担很小，这样导致每次访问可能是共用同样一个线程，导致会有这样的误解：每个session有一个ThreadLocal [b]三、ThreadLocal是相对于每个线程的，用户每次访问会有新的ThreadLocal[/b] 理论上来说，ThreadLocal是的确是相对于每个线程，每个线程会有自己的ThreadLocal。但是上面已经讲到，一般的应用服务器都会维护一套线程池。因此，不同用户访问，可能会接受到同样的线程。因此，在做基于TheadLocal时，需要谨慎，避免出现ThreadLocal变量的缓存，导致其他线程访问到本线程变量 [b]四、对每个用户访问，ThreadLocal可以多用[/b] 可以说，ThreadLocal是一把双刃剑，用得来的话可以起到非常好的效果。但是，ThreadLocal如果用得不好，就会跟全局变量一样。代码不能重用，不能独立测试。因为，一些本来可以重用的类，现在依赖于ThreadLocal变量。如果在其他没有ThreadLocal场合，这些类就变得不可用了。个人觉得ThreadLocal用得很好的几个应用场合，值得参考 1、存放当前session用户：quake want的jert 2、存放一些context变量，比如webwork的ActionContext 3、存放session，比如Spring hibernate orm的session

全部评论(0)

上一篇：微信公众号点击菜单即可打开并登录微站的实现方法
下一篇：java基础学习笔记之反射

资讯排行榜
更多>>