问题描述
我们在使用threadLocal的时，使用ThreadLocal.withInitial去初始化而不是使用new ThradLocal去初始化，这是为什么呢？
问题例子
比如说，假设我们想要在每个线程中维护一个独立的计数器
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadLocalExample {
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadLocalExample {
private static final ThreadLocal<AtomicInteger> counterThreadLocal = new ThreadLocal<>();
public static void main(String[] args) {
// 创建多个线程
for (int i = 0; i < 5; i++) {
new Thread(() -> {
// 获取 ThreadLocal 变量并递增计数器
int count = counterThreadLocal.get().getAndIncrement();
System.out.println("线程" + Thread.currentThread().getId() + " 计数: " + count);
}).start();
}
}
}
这个程序实际会报错
首先要说明一下，这个代码并不是实现多线程的累加
import java.util.concurrent.atomic.AtomicInteger;
public class MultiThreadedIncrement {
private static final AtomicInteger counter = new AtomicInteger(0);
public static void main(String[] args) {
// 创建多个线程进行累加
for (int i = 0; i < 5; i++) {
new Thread(() -> {
// 在多线程环境下使用AtomicInteger进行累加
for (int j = 0; j < 10000; j++) {
counter.incrementAndGet();
}
}).start();
}
// 等待所有线程执行完毕
try {
Thread.sleep(1000); // 这里仅为示例，实际使用中可能需要更精确的等待方式
} catch (InterruptedException e) {
e.printStackTrace();
}
// 输出最终累加结果
System.out.println("累加结果: " + counter.get());
}
}
多线程的累加是这样的，一定要注意。而本案例是想实现每个线程独立维护一个计数器，互不干涉。
或者我们这样来写大家可以看的更清楚
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadLocalIncrement {
private static final ThreadLocal<AtomicInteger> threadLocalCounter = ThreadLocal.withInitial(AtomicInteger::new);
public static void main(String[] args) {
// 创建多个线程进行递增
for (int i = 0; i < 5; i++) {
new Thread(() -> {
// 获取当前线程的计数器
AtomicInteger counter = threadLocalCounter.get();
// 在每个线程中递增计数器
for (int j = 0; j < 10000; j++) {
counter.incrementAndGet();
System.out.println("线程" + Thread.currentThread().getId() + " 计数: " + counter.get());
}
}).start();
}
}
}
我们知道thread底层是基于treadmap实现的
ThreadLocal 使用了一个名为 ThreadLocalMap 的内部类，它是 Thread 类的一个字段。
每个线程都有自己的 ThreadLocalMap 实例，它是一个自定义的散列表结构。在 ThreadLocalMap 中，ThreadLocal 实例作为键，与之关联的值则存储在相应的槽位中。每个 ThreadLocal 实例在自己所属线程的 ThreadLocalMap 中有一个条目。
当你调用 ThreadLocal 的 get 方法时，实际上是在当前线程的 ThreadLocalMap 中查找与该 ThreadLocal 实例关联的值。而调用 set 方法则是在当前线程的 ThreadLocalMap 中设置对应的关联值。
这种设计的好处在于，每个线程都有自己独立的存储空间，不需要锁定或同步，从而提高了并发性能。
总体来说，虽然底层并不直接使用标准的 Map 实现，但可以将 ThreadLocalMap 看作是一个简化版的散列表
解决
我们可以简单理解为这就是一个map，key就是每个线程的threadLacle实例，value就是要存的值
实际上，每个线程在开始执行时，实例化threadLocal并没有初始化值，而是一开始threalLocal的值就是null,所以在执行get方法的时候实际上取得是一个null值。所以null.getAndIncrement()自然会报错
我们可以这样修改
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadLocalExample {
private static final ThreadLocal<AtomicInteger> counterThreadLocal = new ThreadLocal<>();
public static void main(String[] args) {
// 创建多个线程
for (int i = 0; i < 5; i++) {
new Thread(() -> {
// 检查 ThreadLocal 变量是否为 null，如果为 null，则设置初始值
if (counterThreadLocal.get() == null) {
counterThreadLocal.set(new AtomicInteger());
}
// 获取 ThreadLocal 变量并递增计数器
int count = counterThreadLocal.get().getAndIncrement();
System.out.println("线程 " + Thread.currentThread().getId() + " 计数: " + count);
}).start();
}
}
}
或者我们也可以使用ThreadLocal.withInitial来避免这个问题
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadLocalExample {
private static final ThreadLocal<AtomicInteger> counterThreadLocal = ThreadLocal.withInitial(AtomicInteger::new);
public static void main(String[] args) {
// 创建多个线程
for (int i = 0; i < 5; i++) {
new Thread(() -> {
// 获取 ThreadLocal 变量并递增计数器
int count = counterThreadLocal.get().getAndIncrement();
System.out.println("线程 " + Thread.currentThread().getId() + " 计数: " + count);
}).start();
}
}
}
总结
在上述例子中，counterThreadLocal 是一个 ThreadLocal 变量，初始值是一个 AtomicInteger 计数器。每个线程第一次访问 counterThreadLocal 时，都会调用 AtomicInteger::new 获取一个新的 AtomicInteger 实例作为初始值。每个线程都有自己独立的计数器，互不干扰。
如果我们使用 new ThreadLocal<>(); 创建 ThreadLocal 实例，它的初始值将为 null。这样，每个线程第一次访问 ThreadLocal 变量时都会得到 null。这可能需要额外的逻辑来处理初始值，增加了出错的可能性。所以，使用 ThreadLocal.withInitial 提供了一种更清晰和线程安全的方式来初始化 ThreadLocal 变量。
