java JUC并发编程 第八章 ThreadLocal

系列文章目录

第一章 java JUC并发编程 Future: link
第二章 java JUC并发编程 多线程锁: link
第三章 java JUC并发编程 中断机制: link
第四章 java JUC并发编程 java内存模型JMM: link
第五章 java JUC并发编程 volatile与JMM: link
第六章 java JUC并发编程 CAS: link
第七章 java JUC并发编程 原子操作类增强: link
第八章 java JUC并发编程 ThreadLocal: link
第九章 java JUC并发编程 对象内存布局与对象头: link
第十章 java JUC并发编程 Synchronized与锁升级: link
第十一章 java JUC并发编程 AbstractQueuedSynchronizer之AQS: link

---

---

1 概述

ThreadLocal 该类提供线程局部变量

1.1 是什么

1.2 能干嘛

1.3 helloworld

方法说明

使用规范

Code

package com.atguigu.springcloud.util.interrup;

import java.util.Random;
import java.util.concurrent.TimeUnit;

class House{
    int saleCount=0;
    //满足需求1
    public synchronized void saleHouse(){
        ++saleCount;
    }
    //满足需求2 匿名内部类实现
    /*ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue(){
            return 0;
        }
    };*/
    //满足需求2 使用withInitial实现
    ThreadLocal<Integer> saleVolume =ThreadLocal.withInitial(()->0);
    public void saleVolumeByThreadLocal(){
        saleVolume.set(1+saleVolume.get());
    }
}

/**
 * 需求1:5个销售买房子，集团高层只关心销售总量的精确统计数
 * 需求2： 5个销售卖完随机数房子，各自独立销售额度。
 */
public class ThreadLocalDemo {
    //需求1
/*    public static void main(String[] args) {
        House house = new House();
        for (int i = 1; i <=5 ; i++) {
            new Thread(()->{
                int size = new Random().nextInt(5)+1;
                System.out.println(size);
                for (int j = 1; j <=size ; j++) {
                    house.saleHouse();
                }
            },String.valueOf(i)).start();

        }
        try {TimeUnit.MILLISECONDS.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println(Thread.currentThread().getName()+"\t"+"共卖出套："+house.saleCount);
    }*/
    //需求2
    public static void main(String[] args) {
        House house = new House();
        for (int i = 1; i <=5 ; i++) {
            new Thread(()->{
                try {
                    int size = new Random().nextInt(5)+1;
                    for (int j = 1; j <=size ; j++) {
                        house.saleHouse();
                        house.saleVolumeByThreadLocal();
                    }
                    System.out.println(Thread.currentThread().getName()+"\t"+"号销售卖出:"+house.saleVolume.get());
                } finally {
                    //使用完毕要remove 新new的Thread的问题还不大，如果是线程池就有问题，所以使用完毕后一定要清空
                    house.saleVolume.remove();
                }
            },String.valueOf(i)).start();

        }
        try {TimeUnit.MILLISECONDS.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println(Thread.currentThread().getName()+"\t"+"共卖出套："+house.saleCount);
    }
}

尽量回收，因为每个Thread内有自己的实体副本且改副本只由当前线程自己使用
既然其他Thread不可访问，那就不存在多线程间共享的问题。
统一设置初始值，但是每个线程对这个值得修改都是各自线程互相独立的

package com.atguigu.springcloud.util.interrup;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyData{
    ThreadLocal<Integer> threadLocalField = ThreadLocal.withInitial(()->0);
    public void add(){
        threadLocalField.set(1+threadLocalField.get());
    }
}
/**
 * 必须回收自定义的ThreadLocal变量，尤其是在线程池场景下，线程经常会被复用，如果不清理自定义的ThreadLocal变量，
 * 可能会影响后续业务逻辑和造成内存泄漏等问题。尽量在代理中使用try-finally块进行回收
 */
public class ThreadLocalDemo2 {
    public static void main(String[] args) {
        MyData myData = new MyData();
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        try {
            for (int i = 0; i <10 ; i++) {
                threadPool.submit(()->{
                    try {
                        Integer beforeInt = myData.threadLocalField.get();
                        myData.add();
                        Integer afterInt = myData.threadLocalField.get();
                        System.out.println(Thread.currentThread().getName()+"\t"+"beforeInt:"+beforeInt+"\t"+"afterInt:"+afterInt);
                    } finally {
                        myData.threadLocalField.remove();
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }

    }
}

2 ThreadLocal源码分析

2.1 Thread和THreadLocal

每个Thread都有自己的ThreadLocal

2.2 ThreadLocal和ThreadLocalMap

里面有个静态内部类ThreadLocalMap

2.3 三者概括

当我们为threadLocal变量赋值，实际上是以当前threadLocal实例为key,值为value的Entry往这个threadLocalMap中存放
近似的可以理解为：
ThreadLocalMap从字面上可以看出是一个保存ThreadLocal对象的map(其实是以ThreadLocal为key),不过是经过了两层包装的ThreadLocal对象：

JVM内部维护了一个线程版的Map<ThreadLocal,Value>(通过THreadLocal对象的set方法，结果把ThreadLocal对象自己做key,放进了ThreadLocalMap中)，每个线程要用到这个T的时候，用当前的线程去Map里面获取，通过这样让每个线程拥有了自己独立的变量，人手一份，竞争条件被彻底消除，在并发模式下绝对安全的策略

3 ThreadLocal内存泄漏问题

为什么ThreadLocalMap里面有个WeakReference(弱引用)

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

3.1 强引用、软引用、弱引用、虚引用

3.1.1 整体架构

3.1.2 强 ：StrongReference：默认支持模式

package com.atguigu.springcloud.util.interrup;

class MyObject{
    //这个方法一般不用重写，只是为了演示
    @Override
    protected void finalize() throws Throwable{
        //finalize的通常目的是在对象被不可撤销的丢弃之前执行清理操作
        System.out.println("------------invoke finalize method");
    }
}
public class ReferenceDemo {
    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        System.out.println("ge before+"+myObject);
        myObject=null;
        System.gc();//人工开启Gc一般不用
        System.out.println("ge after+"+myObject);

    }
}

3.1.3 软：SoftReference

为了看效果提前配置jvm内存：
1.点击Run

2.点击Edit Configurations…

3.点击Modify options,再点击add VM options

4.配置参数-Xms10m -Xmx10m

package com.atguigu.springcloud.util.interrup;

import java.lang.ref.SoftReference;
import java.util.concurrent.TimeUnit;

class MyObject{
    //这个方法一般不用重写，只是为了演示
    @Override
    protected void finalize() throws Throwable{
        //finalize的通常目的是在对象被不可撤销的丢弃之前执行清理操作
        System.out.println("------------invoke finalize method");
    }
}
public class ReferenceDemo {
    public static void main(String[] args) {
        SoftReference<MyObject> softReference = new SoftReference<>(new MyObject());
        System.out.println("----softReference:"+softReference);
        System.gc();
        try {TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}
        //内存够用不会被回收
        System.out.println("----gc after内存够用不会回收："+softReference.get());
        try {
            byte[] bytes = new byte[20*1024*1024];//20MB对象
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("----gc after内存不够会回收："+softReference.get());
        }
    }

    private static void StrongReference() {
        MyObject myObject = new MyObject();
        System.out.println("ge before+"+myObject);
        myObject=null;
        System.gc();//人工开启Gc一般不用
        System.out.println("ge after+"+myObject);
    }
}

3.1.4 弱：WeakReference

弱引用需要java.lang.ref.WeakReference类来实现，它比软引用的生存期更短。
对于只有弱引用的对象来说，只要垃圾回收机制已运行，不管JVM的内存空间是否足够，都会回收改对象占用的内存。
运行前恢复到之前的JVM配置

package com.atguigu.springcloud.util.interrup;

import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.concurrent.TimeUnit;

class MyObject{
    //这个方法一般不用重写，只是为了演示
    @Override
    protected void finalize() throws Throwable{
        //finalize的通常目的是在对象被不可撤销的丢弃之前执行清理操作
        System.out.println("------------invoke finalize method");
    }
}
public class ReferenceDemo {
    public static void main(String[] args) {
        WeakReference<MyObject> weakReference = new WeakReference<>(new MyObject());
        System.out.println("----gc before 内存够用"+weakReference.get());
        System.gc();
        try {TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("----gc after 内存够用"+weakReference.get());
    }

    private static void softReference() {
        SoftReference<MyObject> softReference = new SoftReference<>(new MyObject());
        System.out.println("----softReference:"+softReference);
        System.gc();
        try {TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}
        //内存够用不会被回收
        System.out.println("----gc after内存够用不会回收："+softReference.get());
        try {
            byte[] bytes = new byte[20*1024*1024];//20MB对象
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("----gc after内存不够会回收："+softReference.get());
        }
    }

    private static void StrongReference() {
        MyObject myObject = new MyObject();
        System.out.println("ge before+"+myObject);
        myObject=null;
        System.gc();//人工开启Gc一般不用
        System.out.println("ge after+"+myObject);
    }
}

结果被回收掉了

软引用和弱引用适用的场景

3.1.5 虚：PhantomReference

设置JVM参数

不一定一遍成功

package com.atguigu.springcloud.util.interrup;

import java.lang.ref.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

class MyObject{
    //这个方法一般不用重写，只是为了演示
    @Override
    protected void finalize() throws Throwable{
        //finalize的通常目的是在对象被不可撤销的丢弃之前执行清理操作
        System.out.println("------------invoke finalize method");
    }
}
public class ReferenceDemo {
    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        ReferenceQueue<MyObject> referenceQueue = new ReferenceQueue<>();
        PhantomReference<MyObject> phantomReference = new PhantomReference<>(myObject,referenceQueue);
//        System.out.println(phantomReference.get());//只会返回null
        List<byte[]> list = new ArrayList<>();
        new Thread(()->{
            while (true){
                list.add(new byte[1*1024*1024]);
                try {TimeUnit.MILLISECONDS.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}
                System.out.println(phantomReference.get()+"\t"+"list add ok");

            }
        },"t1").start();

        new Thread(()->{
            while (true){
                Reference<? extends MyObject> reference = referenceQueue.poll();
                if(reference != null){
                    System.out.println("----有虚对象回收加入了队列");
                    break;
                }
            }
        },"t2").start();
    }

    private static void weakReference() {
        WeakReference<MyObject> weakReference = new WeakReference<>(new MyObject());
        System.out.println("----gc before 内存够用"+weakReference.get());
        System.gc();
        try {TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("----gc after 内存够用"+weakReference.get());
    }

    private static void softReference() {
        SoftReference<MyObject> softReference = new SoftReference<>(new MyObject());
        System.out.println("----softReference:"+softReference);
        System.gc();
        try {TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}
        //内存够用不会被回收
        System.out.println("----gc after内存够用不会回收："+softReference.get());
        try {
            byte[] bytes = new byte[20*1024*1024];//20MB对象
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("----gc after内存不够会回收："+softReference.get());
        }
    }

    private static void StrongReference() {
        MyObject myObject = new MyObject();
        System.out.println("ge before+"+myObject);
        myObject=null;
        System.gc();//人工开启Gc一般不用
        System.out.println("ge after+"+myObject);
    }
}

结果

3.1.6 总结

强引用：即便发生oom也不会回收
软引用：内存紧张回收
弱引用：只要有gc马上被回收
虚引用：必定被回收

4 ThreadLocal为什么要用弱引用？不用如何？

4.1 为什么使用弱引用

4.2 key为null的entry

4.3 set、get方法会去检查所有键为null的entry对象

都会调用expungeStaleEntry方法

4.3.1 set()

4.3.2 get()

4.3.3 remove()

三个方法都寻找脏Entry,即key =null的Entry,然后进行删除。

4.4 结论

5 实践

1.ThreadLocal.withInitial(()->尽量初始化)
2.建议把ThreadLocal修饰为static

3.用完手动remove

6 总结

1.ThreadLocal并不解决线程间共享数据的问题
2.ThreadLocal适用于变量在线程间隔离且在方法间共享的场景
3.ThreadLocal通过隐式的在不通线程内创建独立实例副本避免了实例线程安全的问题
4.每个线程持有一个只属于自己的专属Map并维护了ThreadLocal对象与具体实例的映射，该Map由于只被持有它的线程访问，故不存在线程安全以及锁的问题
5.ThreadLocalMap的Entry对THreadLocal的引用为弱引用，避免了ThreadLocal对象无法被回收的问题
6.都会通过expungeStaleEntry,cleanSomeSlots,replaceStaleEntry这三个方法回收键为null的Entry对象的值（即为具体实例）以及Entry对象从而防止内存泄漏，属于安全加固的方法