深入理解ThreadLocal实现原理

最新推荐文章于 2023-02-09 20:08:44 发布
最新推荐文章于 2023-02-09 20:08:44 发布
阅读量241 收藏 1
点赞数 1
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40429540/article/details/105408195
版权

目录

锁优化的思想

  1. 减少锁持有时间
    • 像比如在调用某个方法时其中只有一小部分是需要同步的，那么大可不必将整个方法上锁，而是对需要同步的这一小块代码加上同步锁，以此来降低锁持有的时间，该优化还会提高自旋锁的成功率。
  2. 减小锁的颗粒度
    • 将一个大对象拆成小对象，增加并行度降低锁的竞争，比如jdk。1.7的concurrentHashMap中就是采用分段锁的方式将一个大对象分成若干个segment，每个线程只会对segment进行加锁访问，每个segment之间互不干扰。并且减小锁的颗粒度时还会让偏向锁，轻量级锁的成功率提高。
  3. 锁分离
    • 将锁以功能来进行区分，就像之前提到的ReadWriteLock,它就将读写进行了分离，使读读不互斥以此增加并行度提高整体的性能。
  4. 锁粗化
    • 在此之前我们提出了对锁的优化可以减少锁持有时间，但是如果对同一个锁不停的请求、同步和释放的话反而会降低系统的性能，所以可以将两个同步代码进行合并，但前提是中间代码不会占用太多的时间，否则也是不妥的。
  5. 锁消除
    • 在即时编译器时，如果发现不可能被共享的对象，则可以消除这些对象的锁操作，（这些锁可能不是你自己加的锁对象，而是在一些不必要使用的场景使用了一些jdk提供的线程安全类）。
    • 但是锁消除需要编译器在server模式下运行并开启逃逸分析和锁消除：
      在这里插入图片描述

ThreadLocal及其源码分析

  1. ThreadLocal出现的原因，因为我们知道关于并发的出现是因为多个线程需要访问同一个临界区，而如果说线程都访问自己的变量，线程之间就不会存在竞争也不用在进行加锁来防止程序错误，所以就引出了ThreadLocal。
  2. ThreadLocal的应用：
    public class ThreadLocalVariableHolder implements  Runnable{

    private static ThreadLocal<Integer> value=new ThreadLocal<Integer>(){

      private Random rand=new Random(2);
      //对ThreadLocal的值进行初始化
      protected synchronized Integer initialValue(){

          return rand.nextInt(10000);

      }

    };
    //对ThreadLocal的值做自增操作。
    public  void increment(){

        value.set(value.get()+1);

    }

    @Override
    public void run() {
        //判断线程是否中断
        while (!Thread.currentThread().isInterrupted()){

            increment();

            System.out.println(Thread.currentThread().getName()+":"+value.get());

        }

    }

    public static void main(String[] args) {

        ExecutorService exec= Executors.newCachedThreadPool();

        for (int i = 0; i < 3; i++) {

            exec.execute(new ThreadLocalVariableHolder());

        }
        try {

            TimeUnit.MICROSECONDS.sleep(1);

        } catch (InterruptedException e) {

            e.printStackTrace();
        }

        exec.shutdownNow();

    }

}

    部分打印结果：
pool-1-thread-1:6109
pool-1-thread-3:4041
pool-1-thread-3:4042
pool-1-thread-3:4043
pool-1-thread-2:1373
pool-1-thread-3:4044
pool-1-thread-1:6110
pool-1-thread-3:4045
pool-1-thread-2:1374
pool-1-thread-3:4046
    可以看到每个线程的变量值都不同。
  3. 源码解析：

    • 静态内部类ThreadLocalMap

      • 我们这里讲到ThreadLocal，其底层操作都是基于ThreadLocalMap来加以实现，该ThreadLocalMap的对象是线程的一个本地变量，该ThreadLocalMap是专门用于处理线程本地变量进行构建的。
        在这里插入图片描述
      • 首先我们先查看ThreadLocalMap的一个成员变量
        • INITIAL_CAPACITY：map的默认初始化大小为16
        • size：记录当前数组的大小
        • table：为当前Map对象的基础，也就是该Map对象是一个数组+Entry的一个结构
        • threshold：下一次扩容的阈值
      • 我们在看到table成员变量其实是ThreadLocalMap的一个结构，那我们再看一看Entry内部的结构
        在这里插入图片描述
        我们看到Entry是继承了个弱引用，并将key标注为一个弱引用的对象，也就是在下一次GC的时候就会被回收掉，那如果这样虽然key被回收了但是Value不会被回收难道不会出现问题？那为什么会继承弱引用呢，因为如果一个线程一直没有销毁，那就一直没有办法回收，会严重的占用内存空间。（比如线程池，线程在使用的使用完本地线程变量后，线程不会关闭这样会造成无谓的损耗。）
      • 初始化：
        回到ThreadLocalMap类，知道了其具体结构后我们先去看到关于map中存值是怎么样进行的，进入到构造函数中进行查看
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
	//对table变量进行初始化，并设定数据大小为INITIAL_CAPACITY，也就是16
    table = new Entry[INITIAL_CAPACITY];
    //这里计算索引的方式就跟jdk1.8中hashmap在扩容时计算索引位置是一样的
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //然后进行赋值
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    //设置下一次扩容的阈值
    setThreshold(INITIAL_CAPACITY);
}	       
/**
 * 初始化完毕后我们看到还调用了setThreshold方法，
 * 它其实就是计算下一次扩容的阈值，我们根据setThreshold
 * 方法内部可以看出，其负载因子为0.75。
 */
private void setThreshold(int len) {
    threshold = len * 2 / 3;
}
      • 存值：
        /**
 * 将当前ThreadLocal对象作为键，将键值存入到ThreadLocalMap中
 */
private void set(ThreadLocal<?> key, Object value) {
      //拿到当前的数组对象
      Entry[] tab = table;
      int len = tab.length;
      //计算当前entry的索引位置
      int i = key.threadLocalHashCode & (len-1);
      //从当前索引位置开始遍历如果获取的entry对象直到获取到的entry为null停止
      for (Entry e = tab[i]; e != null;e = tab[i= nextIndex(i, len)]) {
   		//这个是从entry对象中获取键值
          ThreadLocal<?> k = e.get();
   		//如果获取到的键与当前的键是相等的则将值进行替换就可以了
          if (k == key) {
              e.value = value;
              return;
          }
   	    /**
   		 * 这里是如果获取的key为null，为什么为null？
   		 * 还记得之前提到的Entry继承了一个弱引用吗？
   		 * 如果发生了GC就会将key变为null，但是其value
   		 * 不会为null，元素也不会为null，这样ThreadLocalMap
   		 * 就可以针对此类entry对象进行清理
   		 */
          if (k == null) {
              replaceStaleEntry(key, value, i);
              return;
          }
      }
     //如果获取数组元素为null则将当前数组索赋值。
      tab[i] = new Entry(key, value);
      //将当前map大小加1
      int sz = ++size;
      /**
      * 从当前元素位置的下一位置开始清理无效元素，如果没有发生无效元素的清理说明对数清理方式没有找到无效元素 且在当前数组实际长度大于阈值的情况下需要对数组进行全面清理，如果
      */
      if (!cleanSomeSlots(i, sz) && sz >= threshold)
          rehash();
}

/**
 * 判断当前的索引加1是否大于数组长度，如果大于则返回数组第一位元素下标值否则返回索引加1
 */
private static int nextIndex(int i, int len) {

       return ((i + 1 < len) ? i + 1 : 0);
       
}
/**
 * 判断当前的索引减1是否大于等于0，如果成立返回当前索引减1，否则返回数组的最后一位元素下标值。
 */
private static int prevIndex(int i, int len) {

       return ((i - 1 >= 0) ? i - 1 : len - 1);
       
}

/**
 *  将无效元素进行清理并将键值存入到Map中
 */
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
       Entry[] tab = table;
       int len = tab.length;
       Entry e;

   	   //拿到当前无效元素的索引
       int slotToExpunge = staleSlot;
 	   //往前遍历，查找最前面的一个无效元素
       for (int i = prevIndex(staleSlot, len);(e = tab[i]) != null;i = prevIndex(i, len))
           if (e.get() == null)
               slotToExpunge = i;
               
   	   //从当前无效元素往后遍历
       for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
       	
           ThreadLocal<?> k = e.get();
   		   //找到了key相等的元素，将其与无效元素进行交换，并把无效元素的值更新有需要存入的值
           if (k == key) {
               e.value = value;
               tab[i] = tab[staleSlot];
               tab[staleSlot] = e;

   			   //如果之前的往前扫描中没有找到无效元素，则从
   			   //当前交换后的元素位置开始作为开始清理的位置
               if (slotToExpunge == staleSlot)  slotToExpunge = i;
               // 从slotToExpunge开始做一次连续段的清理，再做一次启发式清理
               cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
               return;
           }
   		   //如果当前遍历到节点也是无效元素，且向前扫描时没有其他无效元素，
   		   //则更新slotToExpunge为当前元素位置
           if (k == null && slotToExpunge == staleSlot)
               slotToExpunge = i;
       }
       //走到这里说明数组中不存在该key的元素，则将当前无效元素更新为新的元素。
       tab[staleSlot].value = null;
       tab[staleSlot] = new Entry(key, value);
   	   //再当前无效元素之前存在有无效元素，则从slotToExpunge开始清理。
       if (slotToExpunge != staleSlot)
           cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

/**
 *  清理当前索引位置的无效元素，并且找到下一个元素如果无效也做清理，否则重新排位。
 */
private int expungeStaleEntry(int staleSlot) {
      Entry[] tab = table;
      int len = tab.length;
   	  //清理当前无效元素，并将数组实际长度减一
      tab[staleSlot].value = null;
      tab[staleSlot] = null;
      size--;
   
      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 {
          	 /**
          	  * 否则获取当前元素本来索引位置，如果本来位置与当前位置不相等
          	  * 则先将当前元素置空，在从本来索引位置开始往下寻找一直到元素为null，
          	  * 则将该元素赋值为当前的entry。这样的操作相当于rehash操作
          	  */
              int h = k.threadLocalHashCode & (len - 1);
              if (h != i) {
                  tab[i] = null;
                  while (tab[h] != null)
                      h = nextIndex(h, len);
                  tab[h] = e;
              }
          }
      }
      return i;
}

/**
 * 从当前索引位置的下一元素开始对无效元素进行清理，循环在n/2次数后结束
 * 其采用对数数量扫描的方式，因为相对每次的全数组扫描的话太过于消耗资源，
 * 而如果不进行清理的话又会导致资源的浪费，所以采用这种适中的方式对数组中的无效元素进行清理
 */
private boolean cleanSomeSlots(int i, int n) {

        boolean removed = false;
        Entry[] tab = table;
        int len = tab.length;
        //从当前索引位置的下一元素开始检查，如果是无效元素则直接做清理
        do {
            i = nextIndex(i, len);
            Entry e = tab[i];
            if (e != null && e.get() == null) {
                n = len;
                removed = true;
                i = expungeStaleEntry(i);
            }
        } while ( (n >>>= 1) != 0);
        
        return removed;
    
}

/**
 * 对ThreadLocalMap 中的无效元素进行清理，之后用最低的阈值
 * 预防因为磁滞现象的扩容失败，如果等式成立则进行扩容
 */
private void rehash() {
    // 清理掉数组中所有的无效元素
     expungeStaleEntries();
     
      // 就是避免因为size数值的滞后所以用最低一个阈值来做判断是否应该扩容。
      if (size >= threshold - threshold / 4)
          resize();
}

/**
 * 清除所有的无效元素
 */
private void expungeStaleEntries() {
       Entry[] tab = table;
       int len = tab.length;
       //直接从头开始清理数组中的无效元素
       for (int j = 0; j < len; j++) {
           Entry e = tab[j];
           if (e != null && e.get() == null)
               expungeStaleEntry(j);
       }
}
/**
 *  数组扩容
 */
private void resize() {
   	//可以看出其扩容后是原来的两倍
       Entry[] oldTab = table;
       int oldLen = oldTab.length;
       int newLen = oldLen * 2;
       Entry[] newTab = new Entry[newLen];
       int count = 0;
   	   //这里其实就跟hashMap有些相似了通过公式hashcode&(2^n^-1)
   	   //来获取其在新数组中的索引在将其直接进行复制就完成了
       for (int j = 0; j < oldLen; ++j) {
           Entry e = oldTab[j];
           if (e != null) {
               ThreadLocal<?> k = e.get();
               if (k == null) {
                   e.value = null; 
               } else {
                   int h = k.threadLocalHashCode & (newLen - 1);
                   while (newTab[h] != null)
                       h = nextIndex(h, newLen);
                   newTab[h] = e;
                   count++;
               }
           }
       }
   	//最后重新设置阈值、数组实际大小、以及新数组引用
       setThreshold(newLen);
       size = count;
       table = newTab;
}
      • 取值
         /**
  *  根据对应的键获取其Entry对象
  */
private Entry getEntry(ThreadLocal<?> key) {
		//首先通过key值获取元素在数组中的大概索引位置。
        int i = key.threadLocalHashCode & (table.length - 1);
        Entry e = table[i];
        //如果当前索引取的元素，键不为null且其key值与需要获取key相等则直接返回这个元素
        if (e != null && e.get() == key)
            return e;
        else
            return getEntryAfterMiss(key, i, e);
}
 /**
  *  从当前索引位置开始往下遍历，如果key相等则直接返回，
  * key为null则对该无效元素清理，一直到获取出对应的元素或者遍历到为null的元素为止
  */
 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;
            //key值为null直接对元素进行清理   
            if (k == null)
                expungeStaleEntry(i);
            //否则获取下一元素
            else
                i = nextIndex(i, len);
            e = tab[i];
        }
        return null;
}

    • set方法：

      public void set(T value) {
  			//获取当前线程
  	       Thread t = Thread.currentThread();
  	       //获取一个ThreadLocalMap对象
  	       ThreadLocalMap map = getMap(t);
  	       /**
  	       * 如果这个map不为null则以当前ThreadLocal对象为键和值放入到这个map中，
  	       * 否则就创建一个ThreadLocalMap对象
  	       */
  	       if (map != null)
  	           map.set(this, value);
  	       else
  	           createMap(t, value);
 }

      进入到getMap方法中

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

      在这里插入图片描述

      我们看到获取的map其实是线程的一个变量，所以就说明ThreadLocal本身就可以说是一个线程的一个变量。
      而createMap方法当然就是创建一个ThreadLoclMap对象并将该对象赋值给当前线程的threadLocals变量。
      在这里插入图片描述
      拿到这个map对象之后就会将键-值存入到ThreadLocalMap 中了

    • get方法

      public T get() {
		//获取当前线程
	    Thread t = Thread.currentThread();
	    //从线程本地变量中获取ThreadLocalMap对象
	    ThreadLocalMap map = getMap(t);
	    if (map != null) {
	    	//调用ThreadLocalMap的getEntry方法获取到对应的Entry对象
	        ThreadLocalMap.Entry e = map.getEntry(this);
	        //如果不为null返回value
	        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对象
        ThreadLocalMap map = getMap(t);
        //如果不为null，则将为当前线程本地变量赋上初值
        if (map != null)
            map.set(this, value);
        else
        //否则创建map
            createMap(t, value);
        //最后返回初值
        return value;
}
Home Well Go
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解ThreadLocal工作原理及使用示例
08-28
深入理解ThreadLocal工作原理及使用示例 ThreadLocal是Java提供的一种解决多线程程序并发问题的工具类，自JDK1.2版本以来提供了java.lang.ThreadLocal类。ThreadLocal的主要作用是为每个使用该变量的线程提供独立的...
人手一支笔:ThreadLocal（怎么优化多线程中的锁？）
热门推荐
02-17 5万+
除了控制资源的访问外，我们还可以通过增加资源来保证所有对象的线程安全。比如，让100个人填写个人信息表，如果只有一支笔，那么大家就得挨个填写，对于管理人员来说，必须保证大家不会去哄抢这仅存的一支笔，否则，谁也填不完。从另外一个角度出发，我们可以准备100支笔，人手一支，那么所有人很快就能完成表格的填写工作。
并发线程、锁、ThreadLocal
最新发布
WoWBOOM的博客
02-09 2324
java并发编程进阶知识，JUC中常用的类，ThreadLocal
浅谈ThreadLocal
qq_36609994的博客
11-05 4028
1. ThreadLocal简介 ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。 ThreadLoal 变量，线程局部变量，同一个 ThreadLocal 所包含的对象，在不同的 Thread 中有不同的副本。这里有几点需要注意： 因为每个 Thread 内有自己的实例副本，且该副本只能由当前 Thr
ThreadLocal和同步锁机制的对比分析
chens616的专栏
10-10 666
       概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。       同步机制利用所实现资源的同步访问，确保某一个时刻只有一个线程在访问资源；而ThreadLoca则规避了同步，让每一个线程有自己的一份副...
ThreadLocal：不同于“锁”的优化
大力海棠的博客
04-29 746
现在都是多核CPU了，多线程方式可以提高系统的性能，充分利用各个CPU，但是，多线程也增加了很多额外的开销，例如线程之间的切换，线程调度，还有最重要的多线程同步的问题，通常我们都会使用锁来控制线程同步，临界资源的访问通常我们都只加上一把锁，这样做的问题是，一个线程占用了这把锁，其他想要访问临界资源的线程就只能停下来等待，等待锁的释放，如果一个线程拿住了锁后，久久不放，那么越来越多的其他线程被阻塞，...
深入理解 Java 之 ThreadLocal 工作原理1
08-03
ThreadLocal是Java中用于线程局部变量的一个工具类，它的工作原理主要体现在如何在不同的线程之间隔离变量的副本，确保每个线程拥有自己的独立...理解和掌握ThreadLocal的工作原理对于编写高效并发的Java程序至关重要。
ThreadLocal原理及内存泄漏原因
08-25
让我们深入理解ThreadLocal的工作原理以及可能导致内存泄漏的原因。 首先，ThreadLocal是如何实现每个线程都有独立变量副本的呢？这主要得益于内部类`ThreadLocalMap`。当一个ThreadLocal对象被创建后，它并没有...
Android 中ThreadLocal的深入理解
01-20
在深入理解ThreadLocal之前，我们需要明确其基本用法。ThreadLocal有一个`set`方法用于存储数据，一个`get`方法用于获取数据。这两个方法的操作都是针对当前线程进行的。下面我们将详细解析这两个方法的实现过程。 ...
正确理解ThreadLocal
04-23
**标题：“正确理解ThreadLocal”** ThreadLocal是Java并发编程中的一个重要工具类，它提供了一种线程局部变量的机制。这些变量在每个线程中都有独立的副本，互不干扰，可以用来解决多线程环境下的数据隔离问题。...
ThreadLocal锁
weixin_30856965的博客
10-10 284
要了解ThreadLocal，首先搞清楚ThreadLocal 是什么？是用来解决什么问题的？ ThreadLocal 是线程的局部变量， 是每一个线程所单独持有的，其他线程不能对其进行访问， 通常是类中的 private static 字段，是对该字段初始值的一个拷贝，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联 我们知道有时候一个对象的变量会被多个线程所访问，这时就会...
ThreadLocal的两种实现方式
P19777的博客
12-01 314
ThreadLocal的两种实现方式 1.一个ThreadLocal对象内部有一个map，然后在每一个线程中获取值的时候，根据当前线程作为key到map中去获取对应的值 因为ThreadLocal中的值在每个线程中有一个副本，所以这种方式也非常的合适 但是缺点在于，多个线程会一起竞争同一个ThreadLocal对象的map，就会出现竞争，要想避免竞争，就要进行加锁 还有一个需要注意的点就是，如果我...
【java基础 14】锁的粒度：ThreadLocal、volatile、Atomic和Synchronized
该怎么解释？我懒得解释
01-07 2338
导读：题目中提到的几个关键字，分别是解决并发问题中，加锁所使用到的几个关键字，每个关键字代表的锁的粒度 不同，本篇博客，主要是从概念定义上，区分这几个关键字的应用场景。（PS：睡梦中，依稀记得有回面试的时候，问了我一个问题：你们在加锁的时候，加多大的锁？ 哇塞，当时愣了一下，压根儿就没有这个大小的概念，我真的以为都是一样的） 话说，就像加锁日记本的锁是个很小的艺术锁，保险箱一般是密码锁（
ThreadLocal的实际作用及实现原理
jl19960421的博客
04-12 171
在多线程的情况下，我们有时需要访问同一个共享变量，并且对共享变量做某种操作。但是由于多线程的存在，不同线程间对同一个共享变量的操作可能会互相影响。可是在实际业务中，我们可能都需要对共享变量做初始操作，又不想互相影响，这个时候就需要一个机制，将多线程之间相互隔离。从而使得其他线程对该共享变量进行操作时，不会影响其他线程。 例如以下代码，我们希望各个线程都对初始变量count做加10操作。如果使用多线程，代码如下： public class ThreadLocalWork extends Thread {
java 乐观锁和悲观锁，Threadlocal
菜鸟心声：学的不仅是技术，更是梦想！
01-20 585
7.乐观锁和悲观锁 悲观锁（Pessimistic Lock）顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会 block 直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。 乐观锁（Optimistic Lock）顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。 悲观锁
认识ThreadLocal，死锁，ConcurrentHashMap
weixin_44731875的博客
08-08 1023
认识ThreadLocal ThreadLocal 用于提供线程局部变量，在多线程环境可以保证各个线程里的变量独立于其它线程里的变量。也就是说 ThreadLocal 可以为每个线程创建⼀一个【单独的变量副本】，相当于线程的 private static 类型变量。 ThreadLocal 的作用和同步机制有些相反：同步机制是为了保证多线程环境下数据的一致性；而ThreadLocal 是保证了多线程环境下数据的独立性。 ThreadLocal的简单使⽤ public class Test { pri
ThreadLocal类与Synchonized对象锁的区别
Brook
10-07 1431
package com.brook.demo.threalocal;import java.util.Random;public class ThreadLocalDemo { public static void main(String[] args) { School school = new School(); Thread thread = new Th
ThreadLocal源码解读
weixin_30326741的博客
05-20 451
1. 背景 ThreadLocal源码解读，网上面早已经泛滥了，大多比较浅，甚至有的连基本原理都说的很有问题,包括百度搜索出来的第一篇高访问量博文，说ThreadLocal内部有个map，键为线程对象，太误导人了。 ThreadLocal非常适合对Java多线程编程感兴趣的程序员作为入门类阅读，原因两方面： 加上注释源码也不过七八百行。 结构清晰，代码简洁。 本文重点导读ThreadLocal...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值