文章目录
引子：SimpleDateFormat类
为什么SimpleDateFormat 是线程不安全的？
- 这主要是因为，它内部使用了一个全局的 Calendar 变量，来存储 date 信息
解决方式：
- 在sdf.parse()前后加锁，这也是我们一般的处理思路。
- 手动改造代码，给每个线程都new一个SimpleDateFormat
- 使用JDK的ThreadLocal类（和2的思想相似）
2代码如下
public class ThreadSafeSDFUsingMap {
private Map<Long, SimpleDateFormat> sdfMap = new ConcurrentHashMap();
//key 是线程 ID，value 是 SimpleDateFormat
public String formatIt(Date date) {
Thread currentThread = Thread.currentThread();
long threadId = currentThread.getId();
SimpleDateFormat sdf = sdfMap.get(threadId);
if (null == sdf) {
sdf = new SimpleDateFormat("yyyyMMdd HHmm");
sdfMap.put(threadId, sdf);
}
return sdf.format(date);
}
}
3代码如下
static ThreadLocal<SimpleDateFormat> tl = new ThreadLocal<SimpleDateFormat>();
public static class ParseDate implements Runnable {
int i = 0;
public ParseDate(int i) {
this.i = i;
}
public void run() {
try {
if (tl.get() == null) {
tl.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
}
Date t = tl.get().parse("2015-03-29 19:29:" + i % 60);
System.out.println(i + ":" + t);
} catch (ParseException e) {
e.printStackTrace();
}
}
}
从这里也可以看到，为每一个线程人手分配一个对象的工作并不是由ThreadLocal来完成的，而是需要在应用层面保证的。如果在应用上为每一个线程分配了相同的对象实例，那么ThreadLocal也不能保证线程安全。这点也需要大家注意。
ThreadLocal是什么
- 用于创建线程的本地变量。可以使用get()\set()方法去获取他们的默认值或者在线程内部改变他们的值
- 简单说ThreadLocal就是一种以空间换时间的做法，在每个Thread里面维护了一个以开地址法实现的ThreadLocal.ThreadLocalMap，把数据进行隔离，数据不共享，自然就没有线程安全方面的问题了
ThreadLocal 的另一个用途
- ThreadLocal 还有另一个用途，那就是保存线程上下文信息。这一点在很多框架乃至JDK类加载中都有用到。
- 比如Spring的事务管理，方法A里头调用了方法B，方法B如果失败了，需要执行connection.rollback()来回滚事务。那么方法B怎么知道connection是哪个？最简单的就是方法A在调用方法B时，把connection对象传进去
- 显然，这样很挫，需要修改方法的定义
- 不过你现在知道ThreadLocal了，只需把connection塞入threadLocal，methodB和methodA在一个线程中执行，那么自然，methodB可以获取到和methodA相同的connection。
- Spring 采用 Threadlocal 的方式，来保证单个线程中的数据库操作使用的是同一个数据库连接，具体可以参考Spring的TransactionSynchronizationManager类
总结ThreadLocal的两大用途
- 实现线程安全；
- 保存线程上下文信息；
当然ThreadLocal肯定还有更多的用途，只要我们弄懂了它的原理，就知道如何灵活使用。
ThreadLocal 的源代码
设置到ThreadLocal中的数据，写入了threadLocals这个Map。其中，key为ThreadLocal当前对象，value就是我们需要的值。而threadLocals本身就保存了当前自己所在线程的所有“局部变量”，也就是一个ThreadLocal变量的集合
在set时，首先获得当前线程对象，然后通过getMap()拿到线程的ThreadLocalMap，并将值设入ThreadLocalMap中
get()方法先取得当前线程的ThreadLocalMap对象。然后，通过将自己作为key取得内部的实际数据
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
ThreadLocalMap
- ThreadLocalMap 是 ThreadLocal 的内部类，没有实现 Map 接口，用独立的方式实现了 Map 的功能，其内部的 Entry 也独立实现。
- 在 ThreadLocalMap 中，也是用 Entry 来保存 K-V 结构数据的。但是 Entry 中 key 只能是 ThreadLocal 对象 ，这点被 Entry 的构造方法已经限定死了。
- 和 HashMap 的最大的不同在于，ThreadLocalMap 结构非常简单，没有 next 引用，也就是说 ThreadLocalMap 中解决 Hash 冲突的方式并非链表的方式，而是采用线性探测的方式：根据初始 key 的 hashcode 值确定元素在数组中的位置，如果发现这个位置上已经有其他 key 值的元素被占用，则利用固定的算法寻找一定步长的下个位置，依次判断，直至找到能够存放的位置。
- 显然 ThreadLocalMap 采用线性探测的方式解决 Hash 冲突的效率很低，如果有大量不同的 ThreadLocal 对象放入 map 中时发生冲突，或者发生二次冲突，则效率很低。
- 所以这里引出的良好建议是：每个线程只存一个变量，这样的话所有的线程存放到 map 中的 Key 都是相同的 ThreadLocal，如果一个线程要保存多个变量，就需要创建多个 ThreadLocal，多个 ThreadLocal 放入 Map 中时会极大的增加 Hash 冲突的可能。
ThreadLocalMap 的问题
- 由于 ThreadLocalMap 的 key 是弱引用，而 Value 是强引用。
- 这就导致了一个问题，ThreadLocal 在没有外部对象强引用时，发生 GC 时弱引用 Key 会被回收，而 Value 不会回收，如果创建 ThreadLocal 的线程一直持续运行，那么这个 Entry 对象中的 value 就有可能一直得不到回收，发生内存泄露。
如何避免泄漏
- 既然 Value 是强引用，那么我们要做的事，就是在调用 ThreadLocal 的 get()、set() 方法时完成后再调用 remove 方法，将 Entry 节点和 Map 的引用关系移除，这样整个 Entry 对象在 GC Roots 分析后就变成不可达了，下次 GC 的时候就可以被回收。
- 如果使用 ThreadLocal 的 set 方法之后，没有显示的调用 remove 方法，就有可能发生内存泄露，所以养成良好的编程习惯十分重要，使用完 ThreadLocal 之后，记得调用 remove 方法
ThreadLocal的key为什么设置成弱引用？value为什么不是弱引用？
假如key对ThreadLocal对象的弱引用，改为强引用。
即使ThreadLocal变量生命周期完了，设置成null了，但由于Entry中的key对ThreadLocal还是强引用。
就会存在这样的强引用链：Thread变量 -> Thread对象 -> ThreadLocalMap -> Entry -> key -> ThreadLocal对象。
假设该线程一直存在，那么，ThreadLocal对象和ThreadLocalMap都将不会被GC回收，于是产生了内存泄露问题。
但如果是弱引用，当ThreadLocal变量=null之后（强引用没了），只剩下key的弱引用，gc就会自动回收ThreadLocal对象
所以这里要理解的是：如果强引用和弱引用同时引用一个对象，那么这个对象不会被GC回收
Entry的value一般只被Entry引用，有可能没被业务系统中的其他地方引用。如果将value改成了弱引用，被GC贸然回收了（数据突然没了），可能会导致业务系统出现异常。
Thread、ThreadLocal、ThreadLocalMap 的关系
ThreadLocal带来的性能提升
多线程下产生随机数的性能对比（多线程共用同一个Random类、使用ThreadLocal实现每个线程各自持有一个Random类）
注意Random类是线程安全的
package com.space.java.juc.threadlocal;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class RandomDemo {
public static final int GEN_COUNT = 10000000;//生成随机数的数量
public static final int THREAD_COUNT = 4;//线程数量
static ExecutorService exe = Executors.newFixedThreadPool(THREAD_COUNT);
public static Random rnd = new Random(123);
public static ThreadLocal<Random> tRnd = new ThreadLocal<Random>() {
// 当ThreadLocal get为null时，会调用此方法初始化
@Override
protected Random initialValue() {
return new Random(123);
}
};
public static class RndTask implements Callable<Long> {
private int mode = 0;
public RndTask(int mode) {
this.mode = mode;
}
public Random getRandom() {
if (mode == 0) {
return rnd;
} else if (mode == 1) {
return tRnd.get();
} else {
return null;
}
}
@Override
public Long call() {
long b = System.currentTimeMillis();
for (long i = 0; i < GEN_COUNT; i++) {
getRandom().nextInt();
}
long e = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName() + " spend " + (e - b) + "ms");
return e - b;
}
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
Future<Long>[] futs = new Future[THREAD_COUNT];
for (int i = 0; i < THREAD_COUNT; i++) {
futs[i] = exe.submit(new RndTask(0));
}
long totaltime = 0;
for (int i = 0; i < THREAD_COUNT; i++) {
totaltime += futs[i].get();
}
System.out.println("多线程访问同一个Random实例:" + totaltime + "ms");
// ThreadLocal的情况
for (int i = 0; i < THREAD_COUNT; i++) {
futs[i] = exe.submit(new RndTask(1));
}
totaltime = 0;
for (int i = 0; i < THREAD_COUNT; i++) {
totaltime += futs[i].get();
}
System.out.println("使用ThreadLocal包装Random实例:" + totaltime + "ms");
exe.shutdown();
}
}
ThreadLocalRandom类
Random是线程安全的，但由于内部使用cas机制，导致它不是高并发的
而ThreadLocalRandom是一个性能强悍的高并发随机数生成器，ThreadLocalRandom继承自Random
和ThreadLocal的原理类似，Thread类内部有一些变量专门用于让随机数生成器只访问本地线程数据，从而避免竞争
基本使用方法：
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Player().start();
}
}
private static class Player extends Thread {
@Override
public void run() {
System.out.println(getName() + ": " + ThreadLocalRandom.current().nextInt(100));
}
}
用于生成随机订单编号
private static final SimpleDateFormat dateFormatOne=new SimpleDateFormat("yyyyMMddHHmmssSS");
private static final ThreadLocalRandom random=ThreadLocalRandom.current();
/**
* 生成订单编号-方式一
* @return
*/
public static String generateOrderCode(){
//时间戳+N为随机数流水号
return dateFormatOne.format(DateTime.now().toDate()) + generateNumber(4);
}
//N为随机数流水号
public static String generateNumber(final int num){
StringBuffer sb=new StringBuffer();
for (int i=1;i<=num;i++){
sb.append(random.nextInt(9));
}
return sb.toString();
}
931
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
