Java多线程之ThreadLocal原理

最新推荐文章于 2024-10-10 19:49:41 发布
最新推荐文章于 2024-10-10 19:49:41 发布
阅读量179 收藏
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/foreverwsx/article/details/102568748
版权

       首先看下面这个demo，如果多个线程共享一个实例对象，并修改和访问对象内部数据，看看执行会有什么结果。

public class ThreadLocalTest {
    static class AddClass {
        private Integer value = 0;

        void add() {
            value++;
        }

        Integer getValue() {
            return value;
        }
    }

    private static void sleep() {
        try {
            Thread.sleep((int) (Math.random() * 100 + 1));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        final AddClass addClass = new AddClass();
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 4; j++) {
                    addClass.add();
                    System.out.println(Thread.currentThread().getName() + ":" + addClass.getValue());
                    sleep();
                }
            }).start();
        }
    }
}

  sleep方法主要是为了模拟真实多线程环境，让效果更佳明显。

执行后结果为

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

可以看到addClass对象的value在交错执行的线程中递增，可以说此时AddClass是线程不安全的。

如果利用线程同步机制，对addClass对象加锁呢？

    public static void main(String[] args) {
        final AddClass addClass = new AddClass();
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                synchronized (addClass) {
                    for (int j = 0; j < 4; j++) {
                        addClass.add();
                        System.out.println(Thread.currentThread().getName() + ":" + addClass.getValue());
                        sleep();
                    }
                }
            }).start();
        }
    }

执行后结果是

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

各个线程按先后顺序完成了对addClass对象的操作，没有发生交替。

但是，此时我们有了新的需求，我们要求各个线程对addClass对象的访问结果彼此不受影响，也就是每个线程都想对有初始值的addClass对象进行操作，该怎么做呢？

每个线程new一个AddClass操作？抱歉，只给你一个AddClass实例。

在实际开发中，像Session对象，数据库连接对象等都用到了ThreadLocal，达到了多线程访问互不干扰的目的。

这时，主角ThreadLocal登场了！

public class ThreadLocalTest {
    static class AddClass {
        private ThreadLocal<Integer> value = new ThreadLocal<Integer>() {
            public Integer initialValue() {
                return 0;
            }
        };

        void add() {
            value.set(value.get() + 1);
        }

        Integer getValue() {
            return value.get();
        }
    }

    private static void sleep() {
        try {
            Thread.sleep((int) (Math.random() * 100 + 1));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        final AddClass addClass = new AddClass();
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 4; j++) {
                    addClass.add();
                    System.out.println(Thread.currentThread().getName() + ":" + addClass.getValue());
                    sleep();
                }
            }).start();
        }
    }
}

执行结果如下

Thread-1:1
Thread-0:1
Thread-2:1
Thread-2:2
Thread-2:3
Thread-1:2
Thread-2:4
Thread-0:2
Thread-1:3
Thread-0:3
Thread-1:4
Thread-0:4

此处实例化ThreadLocal对象时，覆盖了ThreadLocal的initialValue方法，这个方法是一个延时方法，不会立即执行，会在第一次调用get方法时执行一次。

就好像每个线程都有一个单独的addClass对象一样，彼此间完全没有关联影响。

与同步机制相比，同步机制采用了“以时间换空间”的方式：访问串行化，对象共享化。而ThreadLocal采用了“以空间换时间”的方式：访问并行化，对象独享化。

ThreadLocal使用了什么魔法办到的呢？如果让你去实现ThreadLocal，你会怎么做呢？大多数人肯定想到了Map，是的，ThreadLocal内部定义了一个Map，先看一下ThreadLocal内部几个重要的方法。

    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;
    }

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

我们刚刚提到的那个map在ThreadLocal中就是ThreadLocalMap。

在第一次调用ThreadLocal的get或set方法时，会创建ThreadLocalMap。

我们发现ThreadLocal把ThreadLocalMap对象交给了Thread的threadLocals变量，这个变量又是个什么东东？查看一下Thread的源码，如下

    class Thread implements Runnable {
        //省略...
        ThreadLocal.ThreadLocalMap threadLocals = null;
        //省略...
    }

原来ThreadLocal里面仅仅是定义了ThreadLocalMap，通过createMap方法在每个线程第一次调用ThreadLocal的get或set方法时，创建ThreadLocalMap对象，并把ThreadLocalMap对象交给了对应访问线程Thread保管。ThreadLocal中的get、set方法中访问ThreadLocalMap对象时，调用getMap方法，传入当前操作的线程Thread，获取到对应线程保管的ThreadLocalMap，从而访问到对应线程保管的独享数据。我们谈到ThreadLocal经常讲到每个线程复制一份数据，就是这里所讲的使用createMap，为每个线程创建了一个ThreadLocalMap对象，并交由Thread自身保管，ThreadLocalMap中包含了这份数据。

下面摘取了一部分ThreadLocalMap的源码。

    static class ThreadLocalMap {
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /**
             * The value associated with this ThreadLocal.
             */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

        private static final int INITIAL_CAPACITY = 16;

        private Entry[] table;

        private int threshold;

        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

        private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

        private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal<?> k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

        private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }
    }

ThreadLocalMap中包含了一个初始大小为16的Entry数组table。threshold被设置成现有容量的2/3，它表示保存数据数量超过现有容量的2/3时，需要扩容。

在ThreadLocal的get方法里面可以看到，使用了 ThreadLocalMap.Entry e = map.getEntry(this)来获取要操作的数据，this就是ThreadLocal对象。查看getEntry方法会发现table数组索引计算方式为：int i = key.threadLocalHashCode & (table.length - 1);

可以看出ThreadLocalMap与我们常说的HashMap不同，它自己实现了存取数据的操作方式。当有多个ThreadLocal对象时，以ThreadLocal对象参与索引计算得出索引，找到对应ThreadLocal保存的数据。

public class ThreadLocalTest {
    static class AddClass {
        private ThreadLocal<Integer> value = new ThreadLocal<Integer>() {
            public Integer initialValue() {
                return 0;
            }
        };

        private ThreadLocal<Integer> value2 = new ThreadLocal<Integer>() {
            public Integer initialValue() {
                return 100;
            }
        };

        void add() {
            value.set(value.get() + 1);
            value2.set(value2.get() + 1);
        }

        Integer getValue() {
            return value.get();
        }

        Integer getValue2() {
            return value2.get();
        }
    }

    private static void sleep() {
        try {
            Thread.sleep((int) (Math.random() * 100 + 1));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        final AddClass addClass = new AddClass();
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 4; j++) {
                    addClass.add();
                    System.out.println(Thread.currentThread().getName() + ":value=" + addClass.getValue() + "&value2=" + addClass.getValue2());
                    sleep();
                }
            }).start();
        }
    }
}

输出为：

Thread-0:value=1&value2=101
Thread-1:value=1&value2=101
Thread-2:value=1&value2=101
Thread-1:value=2&value2=102
Thread-1:value=3&value2=103
Thread-2:value=2&value2=102
Thread-0:value=2&value2=102
Thread-1:value=4&value2=104
Thread-2:value=3&value2=103
Thread-0:value=3&value2=103
Thread-2:value=4&value2=104
Thread-0:value=4&value2=104

foreveryuya
关注
【Java多线程】ThreadLocal 原理分析与使用场景
墩墩分墩
06-05 698
面试官：听说你看过ThreadLocal源码？我来瞅瞅？ Java并发之ThreadLocal 一文搞懂 ThreadLocal 原理 Java中ThreadLocal 原理分析与使用场景 ThreadLocal就是这么简单 再也不学ThreadLocal了，看这一篇就忘不掉了！（万字总结） 线程安全性？如何安全地使用 ThreadLocal ThreadLocal 和神奇的数字 0x61c88647 面试再问ThreadLocal，别说你不会 ThreadLocal可以解决并发问题吗 面试官再问你 Thr
Java多线程：带你了解神秘的线程变量 ThreadLocal
m0_74931226的博客
11-28 518
由于ThreadLocal变量引用 指向 ThreadLocalMap对象，即获取ThreadLocalMap对象的值 = 该线程设置的存储在ThreadLocal变量的值。* ThreadLocal变量引用 指向 ThreadLocalMap对象，即设置ThreadLocalMap的值 = 该线程设置的存储在ThreadLocal变量的值。// 设置值 = 线程名。// 设置值 = 线程名。// b. ThreadLocalMap的值 = 该线程设置的存储在ThreadLocal变量的值。
ThreadLocal 原理
m0_61601521的博客
02-20 988
ThreadLocal 本地线程
ThreadLocal原理探究
技术原始积累
12-26 199
2.1.11 ThreadLocal多线程访问同一个共享变量特别容易出现并发问题，特别是多个线程需要对一个共享变量进行写入时候，为了保证线程安全，一般需要使用者在访问共享...
ThreadLocal原理详解
最新发布
2301_76632762的博客
10-10 652
ThreadLocal，也称线程变量，每个ThreadLocal对象存储的变量仅仅属于当前线程，对于其他线程而言，无法获取到该变量,是一种线程隔离的变量，适用于一些在每个线程的上下文中，需要频繁地获取该变量，但处于需求或隐私考虑，需要独属于该线程的情况。
threadlocal原理
modouwu的博客
12-16 400
底层原理 实际上是每个Thread线程维护着一个ThreadLocalMap，ThreadLocalMap底层是一个带有key，value的Entry数组，而Entry的键即是一个ThreadLocal对象，value是我们通过ThreadLocal.set()方法传进去的参数 ThreadLocal.java: 一个ThreadLocal对象只能存储一个value Thread.java: threadlocal.ThreadlocalMap.java: threadlocal.Threadloc
threadLocal原理
sam19911的博客
06-04 5254
一.ThreadLocal的作用   ThreadLocal提供的实际上就是一种线程隔离，不同的线程的变量归属不同的线程，线程之间不能想问访问各自的变量，当线程生命周期结束的时候，线程会被销毁。 二.ThreadLocal的原理 Thread类中有一个成员变量threadLocals： 这个ThreadLocalMap 是ThreadLocal类中一个静态内部类； ThreadLocal类中最主要的就是set 方法get方法； set方法 这个getMap(t); 传入一个Thr.
Java并发编程:ThreadLocal
toBeMN的博客
02-12 251
正经学徒，佛系记录，不搞事情 原文链接：https://www.jianshu.com/p/98b68c97df9b ThreadLocal是什么 ThreadLocal是一个本地线程副本变量工具类。主要用于将私有线程和该线程存放的副本对象做一个映射，各个线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用，特别适用于各个线程依赖不通的变量值完成操作的场景。 从数据结构入手 ...
多线程之ThreadLocal原理分析
练习时长1个月
02-28 155
ThreadLocal使用场景源码分析setgetThreadLocalMap3种引用强引用内存泄漏 使用场景 ThreadLocal提供了线程独有的局部变量，可以在整个线程存活的过程中随时取用，极大地方便了一些逻辑的实现。常见的ThreadLocal用法有： 1.存储单个线程上下文信息。一次request中可以将一些用户信息存到ThreadLocal中，在业务处理是可以随时获取。 2.使变量线程安全。变量既然成为了每个线程内部的局部变量，自然就不会存在并发问题了； 3.减少参数传递。比如做一个trace工
Java多线程编程中ThreadLocal类的用法及深入
09-02
在Java多线程编程中，ThreadLocal类是一个非常重要的工具，它主要用于解决线程安全问题。ThreadLocal提供了一个线程局部变量，也就是说，每个线程都有自己的独立副本，互不影响。这种机制使得线程间的数据隔离得以...
java多线程 ThreadLocal理论总结
许诗宇的博客
05-09 2226
目录 什么是ThreadLocal变量 使用样例 threadlocal的内部属性-哈希 ThreadLocalMap ThreadLocal 内存泄漏，remove方法 ThreadLocal 的 set 方法 ThreadLocal 的 get 方法 ThreadLocalMap 的 resize 方法 ThreadLocal 应用场景 注意：本文参考了https://baijiahao.baidu.com/s?id=1663127810801876375 什么是ThreadLoc
ThreadLocal原理
这有一片海的博客
03-27 775
● ThreadLocal更像是对其他类型变量的一层包装，通过ThreadLocal的包装使得该变量可以在线程之间隔离和当前线程全局共享。 ● 在Thread中有一个threadLocals变量，类型为ThreadLocal.ThreadLocalMap，ThreadLocalMap中key是ThreadLocal,value是存入的变量值。 ● Thread中threadLocals由ThreadLocal维护。 ● 每个线程的本地变量不是存储在ThreadLocal示例里边的，而是存放在调用线程的thr
ThreadLocal的原理
David的博客
05-29 707
参考： https://blog.csdn.net/v123411739/article/details/78698834 https://blog.csdn.net/u010687392/article/details/50549236 https://www.jianshu.com/p/56f64e3c1b6c https://www.jianshu.com/p/377bb840802f ...
ThreadLocal原理(简单易懂)
热门推荐
学习即修行
10-14 6万+
最近公司开展了一个新项目，使用token达到API的无状态，其中有一个功能，是在timeline上展示不同的action是由哪个user操作的。这个时候我们需要在service中获得token信息，但是使用参数传值会十分冗余，此时ThreadLocal就发挥了很好的作用。
ThreadLocal原理及详解
TechnologyShare的博客
11-15 180
ThreadLocal原理 首先多线程访问同一个共享变量特别容易出现数据出错，为了保证线程安全，需要做一些同步的措施，同步的措施一般是加锁，有没有一种方式当访问这个变量时，会变成线程内部自己的变量，ThreadLocal就可以做这件事。 其实ThreadLocal可以理解为一个工具，线程真正调用ThreadLocal存数据其实数据是存储在ThreadLocal类中:threadLocals和inheritableThreadLocals中的。这两个变量时一个map类型的，其中key存的是当前调用这个Thre
ThreadLocal实现原理
ZH的博客
05-10 2662
ThreadLocal和其他并发工具一样，也是用于解决多线程并发訪问。ThreadLocal通过为每个线程都提供了变量的副本，使得每个线程在同一时间访问的并非同一个数据，从而隔离了多个线程对数据的数据共享。 ThreadLocal的使用 ThreadLocal 类接口只提供了4个方法： public void set(Object value)，设置当前线程的线程局部变量的值。 public Object get()，该方法返回当前线程...
Java多线程技术详解：原理、实现与优势
"Java多线程技术涵盖了多线程的基本概念、创建方式、生命周期、控制、调度、互斥与同步以及线程组。通过多线程，程序可以在同一时间执行多个任务，提升效率和响应性。Java语言为多线程编程提供了良好的支持，通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值