ThreadLocal和线程局部变量有什么区别，我们先看一段代码，如下：
public class ThreadLocalLearn {
static ThreadLocal<IntHolder> tl = new ThreadLocal<IntHolder>(){
protected IntHolder initialValue() {
return new IntHolder();
}
};
public static void main(String args[]) {
for(int i=0; i<5; i++) {
Thread th = new Thread(new ThreadTest(tl, i));
th.start();
}
}
}
class ThreadTest implements Runnable{
ThreadLocal<IntHolder> tl ; //threadlocal变量
int i;
int a = 3; //线程局部变量
public ThreadTest(ThreadLocal<IntHolder> tl, int i) {
super();
this.tl = tl;
this.i = i;
}
@Override
public void run() {
tl.get().increAndGet();
a++;
System.out.println(tl.get().getA() + " ");
System.out.println("a : " + a);
}
}
class IntHolder{
int a = 1;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public int increAndGet() {
return ++a;
}
}
代码的运行结果如下：
2
a : 4
2
a : 4
2
a : 4
2
a : 4
2
a : 4
可以看到，局部变量和ThreadLocal起到的作用是一样的，保证了并发环境下数据的安全性。那就是说，完全可以用局部变量来代替ThreadLocal咯，这样想法对么？我们看一看官方对于ThreadLocal的描述：
This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its {@code get} or {@code set} method) has its own, independently initialized copy of the variable. {@code ThreadLocal} instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).
翻译起来就是
ThreadLocal提供的是一种线程局部变量。这些变量不同于其它变量的点在于每个线程在获取变量的时候，都拥有它自己相对独立的变量初始化拷贝。ThreadL:ocal的实例一般是私有静态的，可以做到与一个线程绑定某一种状态。PS：有更好的翻译请指教。
所以就这段话而言，我们知道ThreadLocal不是为了满足多线程安全而开发出来的，因为局部变量已经足够安全。ThreadLocal是为了方便线程处理自己的某种状态。
可以看到ThreadLocal实例化所处的位置，是一个线程共有区域。好比一个银行和个人，我们可以把钱存在银行，也可以把钱存在家。存在家里的钱是局部变量，仅供个人使用；存在银行里的钱也不是说可以让别人随便使用，只有我们以个人身份去获取才能得到。所以说ThreadLocal封装的变量我们是在外面某个区域保存了处于我们个人的一个状态，只允许我们自己去访问和修改的状态。
ThreadLocal同时提供了初始化的机制，在实例化时重写initialValue()方法，便可实现变量的初始化工作
//method 1
static ThreadLocal<IntHolder> tl = new ThreadLocal<IntHolder>(){
protected IntHolder initialValue() {
return new IntHolder();
}
};
//method 2
IntHolder intHolder = new IntHolder()；
static ThreadLocal<IntHolder> tl = new ThreadLocal<IntHolder>(){
protected IntHolder initialValue() {
return intHolder;
}
};
方法一和方法二都可以实现初始化工作，但是方法二不能保证线程变量的安全性，因为引用拷贝指向的是同一个实例，对引用拷贝的修改，等同于对实例的修改。
当然，也可以在判断ThreadlLocal获取数据为空时，在线程内部为ThreadLocal实例化一个数据。如下：
if(null == tl.get()) {
tl.set(new IntHolder());
}
为什么我们需要ThreadLocal来实现在自身内部外创建一个有关自己的状态呢？其实可以完全使用参数传递内部参数，就像我在自己随便放钱一样！这里要注意的是，我们定义一个方法的时候，并不是参数越多越好，有些共有参数，我们应该尽量设为全局，便于系统的可维护性与可扩展性。另一个角度考虑，银行也有其存在的价值，ThreadLocal会简化我们的编程，毕竟它是安全的。
根据ThreadLocal原理，我们自己实现一个：
import java.util.concurrent.ConcurrentHashMap;
public class ThreadLocalVar<T> {
public T initVaribale() {
return null;
}
volatile ConcurrentHashMap<Thread, T> map = new ConcurrentHashMap<Thread, T>();
public void put(T t) {
map.put(Thread.currentThread(), t);
}
public T get() {
T value = map.get(Thread.currentThread());
if(null == value) {
T t = initVaribale();
if(null == t) {
return null;
}
map.put(Thread.currentThread(), t);
return t;
} else {
return value;
}
}
}
有兴趣也可以去阅读jdk中ThreadLocal的源码~
===================
后记：20190622
`
局部变量可以保证的是方法内的线程私有，threadlocal可以保证对象级别的线程私有特性。因此局部变量在某些情况下不能保证并发安全性