聊聊ThreadLocal那些事儿

threadlocal是什么

threadlocal能干什么

阿里巴巴手册

线程池的场景下为啥要调用remove()

import javax.sound.midi.Soundbank;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/***
 * 5个销售买房  统计总共买的数量
 * 5个销售买买完随机数房子，各自独立销售额度，自己拿业绩提成
 */
class MyData{

    ThreadLocal<Integer> threadField = ThreadLocal.withInitial(()->0);

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

public class ThreadLocalDemo02 {

    public static void main(String[] args) throws InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(3);
        MyData myData = new MyData();
        try{
        for (int i = 0; i < 10; i++) {

            executorService.submit(() -> {
                Integer beforeInt = myData.threadField.get();
                myData.add();
                Integer afterInt = myData.threadField.get();
                System.out.println("before:"+beforeInt+",after:"+afterInt);
               // myData.threadField.remove();
            });
        }
            }finally {
                executorService.shutdown();
            }

        }
    }

 上处逻辑输入

before:0,after:1
before:0,after:1
before:0,after:1
before:1,after:2
before:2,after:3
before:3,after:4
before:4,after:5
before:5,after:6
before:6,after:7
before:1,after:2

如果不调用remove方法  在线程池中使用的话 after会慢慢变大，导致内存紧张；

使用场景举例

import java.util.Random;

/***
 * 5个销售买房  统计总共买的数量
 * 5个销售买买完随机数房子，各自独立销售额度，自己拿业绩提成
 */
class House{
    int saleCount = 0;
    public synchronized void saleHouse(){
        ++saleCount;
    }
    ThreadLocal<Integer> saleVolume = ThreadLocal.withInitial(()->0);

    public void saleVolumeByThreadLocal(){
        saleVolume.set(saleVolume.get()+1);
    }
}

public class ThreadLocalDemo {

    public static void main(String[] args) throws InterruptedException {
        House house = new House();
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                int size =  new Random().nextInt(5)+1;
                try {
                    for (int j = 1; j <=size; j++) {
                        house.saleHouse();
                        house.saleVolumeByThreadLocal();
                    }
                    System.out.println(Thread.currentThread().getName()+"号销售卖出"+house.saleVolume.get());
                }finally {
                    house.saleVolume.remove();
                }

            },String.valueOf(i)).start();

        }
        Thread.sleep(300);
        System.out.println("共计卖出了"+house.saleCount+"套");
    }
}

 上述两次代码总结

因为每个Thread内有自己的实例副本且该副本只由当前线程自己使用

既然其他Thread不可访问，那就不存在多线程间共享的问题

统一设置初始值，但是每个线程对这个值的修改都是各自线程互相独立的

Thread、ThreadLocal、ThreadLocalMap关系

 

 

ThreadLocal内存泄露问题 

什么是内存泄露

不再被使用的对象或者变量占用内存不能被回收，就是内存泄露。

谁惹的祸

 jvm中的引用 强 软 弱 虚

强引用

软引用

弱引用

软引用使用场景

 虚引用

内部关系

为什么要用弱引用，不用会怎样 

 举例代码

 

 ThreadLocalMap使用ThreadLocal的弱引用来作为key,如果一个ThreadLocal没有外部强引用引用它，那么gc的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的entry, 就没有办法访问这些key为null的entry的value，如果当前线程再迟迟不结束的话（比如使用线程池），这些key为null的entry对象的value就会一直存在一条强引用连。