0
点赞
收藏
分享

微信扫一扫

hadoop零碎知识点总结

cnlinkchina 2023-05-26 阅读 87

一、ThreadLocal 定义

  官方JDK的定义:此类提供线程局部变量。这些变量与其正常对应变量的不同之处在于,每个访问一个(通过其get或set方法)的线程都有自己的、独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态字段,这些字段希望将状态与线程(例如,用户ID或事务ID)相关联。
例如,下面的类生成每个线程本地的唯一标识符。线程的id在第一次调用ThreadId.get()时被分配,并且在随后的调用中保持不变。

ThreadLocal是用来存放线程相关数据的一个容器,这个容器叫做ThreadLocalMap,它是ThreadLocal的一个静态内部类,同时作为Thread类的一个成员变量。ThreadLocal在使用时,先拿到当前线程的成员变量ThreadLocalMap,以当前的ThreadLocal对象作为key,变量作为value存入ThreadLocalMapThreadLocal相当于给每个线程都开辟了一个独立的存储空间,各个线程的ThreadLocal关联的实例互不干扰。然后每个线程取变量都是从线程各自的ThreadLocalMap中取值,自然是线程安全的了。因为变量只在自己线程的生命周期内起作用,所以说ThreadLocal提供线程局部变量,或者叫线程本地变量。

ThreadLocal实例通常总是以静态字段初始化如下:

static ThreadLocal<User> threadLocalUser = new ThreadLocal<>();

 二、ThreadLocal的使用

ThreadLocal 的常用方法:

  1. public ThreadLocal():通过构造器创建对象。一般是静态的。
  2. static <S> ThreadLocal<S>withInitial(Supplier<? extends S> supplier):初始化一个 ThreadLcoal。
  3. void set(T value):设置当前线程绑定的局部变量。
  4. T get():返回此线程局部变量的当前线程副本中的值。
  5. void remove():删除当前线程绑定的局部变量。

对于多任务,Java标准库提供的线程池可以方便地执行这些任务,同时复用线程。Web应用程序就是典型的多任务应用,每个用户请求页面时,我们都会创建一个任务,类似:

public void process(User user) {
    checkPermission();
    doWork();
    saveStatus();
    sendResponse();
}

process()方法需要传递的状态就是User实例。

这种在一个线程中,横跨若干方法调用,需要传递的对象,我们通常称之为上下文(Context),它是一种状态,可以是用户身份、任务信息等。

给每个方法增加一个context参数非常麻烦,而且有些时候,如果调用链有无法修改源码的第三方库,User对象就传不进去了。

Java标准库提供了一个特殊的ThreadLocal,它可以在一个线程中传递同一个对象。

ThreadLocal实例通常总是以静态字段初始化如下:

static ThreadLocal<User> threadLocalUser = new ThreadLocal<>();

它的典型使用方式如下:

void processUser(user) {
    try {
        threadLocalUser.set(user);
        step1();
        step2();
    } finally {
        threadLocalUser.remove();
    }
}

通过设置一个User实例关联到ThreadLocal中,在移除之前,所有方法都可以随时获取到该User实例:

void step1() {
    User u = threadLocalUser.get();
    log();
    printUser();
}

void log() {
    User u = threadLocalUser.get();
    println(u.name);
}

void step2() {
    User u = threadLocalUser.get();
    checkUser(u.id);
}

注意到普通的方法调用一定是同一个线程执行的,所以,step1()step2()以及log()方法内,threadLocalUser.get()获取的User对象是同一个实例。

实际上,可以把ThreadLocal看成一个全局Map<Thread, Object>:每个线程获取ThreadLocal变量时,总是使用Thread自身作为key:

Object threadLocalValue = threadLocalMap.get(Thread.currentThread());

因此,ThreadLocal相当于给每个线程都开辟了一个独立的存储空间,各个线程的ThreadLocal关联的实例互不干扰。

最后,特别注意ThreadLocal一定要在finally中清除:

try {
    threadLocalUser.set(user);
    ...
} finally {
    threadLocalUser.remove();
}

这是因为当前线程执行完相关代码后,很可能会被重新放入线程池中,如果ThreadLocal没有被清除,该线程执行其他代码时,会把上一次的状态带进去。

为了保证能释放ThreadLocal关联的实例,我们可以通过AutoCloseable接口配合try (resource) {...}结构,让编译器自动为我们关闭。例如,一个保存了当前用户名的ThreadLocal可以封装为一个UserContext对象:

public class UserContext implements AutoCloseable {

    static final ThreadLocal<String> ctx = new ThreadLocal<>();

    public UserContext(String user) {
        ctx.set(user);
    }

    public static String currentUser() {
        return ctx.get();
    }

    @Override
    public void close() {
        ctx.remove();
    }
}

 二、ThreadLocal原理解析

ThreadLocal 的原理要从它的set(T value)get()、remove()方法的源码入手:

1、set()方法

public void set(T value) {
        //获取当前线程
    Thread t = Thread.currentThread();
    //获取维护当前线程变量的ThreadLocalMap数据,一种类似于HashMap的数据结构
    ThreadLocalMap map = getMap(t);
    //如果当前线程已经存在了Map,直接调用map.set
    if (map != null)
        map.set(this, value);
    //不存在Map,则先进行新增map,再进行set
    else
        createMap(t, value);
}

set方法中出现了一个ThreadLocalMap这个数据结构,点进去看一下

static class ThreadLocalMap {

    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;

        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
        
        //代码太多不一一贴出来了
}

其中维护了一个entry结构用来用来维护节点的数据,细心地同学应该已经发现了Entry这个结构继承了WeakReference,从构造方法可以看出,ThreadLocalMap的Key是软引用维护的。这个地方很重要,至于为什么重要,后面再细说。

再继续点击一下发现ThreadLocal成员变量里面定义了这么一句话

ThreadLocal.ThreadLocalMap threadLocals = null;

这句话的出现表明了,针对于每一个线程,都是独立维护一个ThreadLocalMap,一个线程也可以拥有多个ThreadLocal变量。

2、get()方法

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}
private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}
protected T initialValue() {
    return null;
}

get()方法整体上比较简单,贴上了关键逻辑逻辑代码,调用get()时,如果存在值,则将值返回,不存在值调用setInitialValue()获取值,其中初始化的值为null,也就是说如果ThreadLocal变量未被赋值,或者赋值后被remove掉了,直接调用get()方法不会报错,将会返回null值。

3、remove()方法

//ThreadLocal
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}
//ThreadLocalMap
private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode &amp; (len-1);
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {
            e.clear();
            expungeStaleEntry(i);
            return;
        }
    }
}

remove方法调用时会判断当前线程中ThreadLocalMap是否存在,如果存在则调用ThreadLocalMap.remove(key);遍历链表结构移除entry节点

4、ThreadLocal 如何存多个变量

ThreadLocal 使用set方法存数据时,key 用的this对象,就是当前正在使用的 ThreadLocal 对象,说明一个 ThreadLocal 对象,在一个线程中,只能存一个线程本地变量。多个线程虽然都是用的是一个 key,但是不同的线程用的是不同的ThreadLocalMap

具体做法有两种:

1、 生成ThreadLocal 对象,每个 ThreadLocal 对象对应一个业务变量

2、给 ThreadLocal 初始化一个HashMap,这是最常规的做法。比如下面:

public class ThreadLocalTest {
    private static final ThreadLocal<Map<String, Object>> context =
            ThreadLocal.withInitial(HashMap::new);

    private String getUserId() {
        return String.valueOf(context.get().get("userId"));
    }

    private void setUserId(String userId) {
        context.get().put("userId", userId);
    }

    public void setUserName(String userName) {
        context.get().put("userName", userName);
    }

    public String getUserName() {
        return String.valueOf(context.get().get("userName"));
    }

    public static void main(String[] args) {
        ThreadLocalTest test = new ThreadLocalTest();
        for (int i = 1; i < 5; i++) {
            Thread thread = new Thread(() -> {
                String threadName = Thread.currentThread().getName();
                test.setUserId(threadName + "的userId");
                test.setUserName(threadName + "的userName");
                System.out.println("===执行业务代码===");
                System.out.println(threadName + "-->" + test.getUserId() + "," + test.getUserName());
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}
举报

相关推荐

0 条评论