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


文章目录

  • 系列文章目录
  • 1 概述
    • 1.1 是什么
    • 1.2 能干嘛
    • 1.3 helloworld
  • 2 ThreadLocal源码分析
    • 2.1 Thread和THreadLocal
    • 2.2 ThreadLocal和ThreadLocalMap
    • 2.3 三者概括
  • 3 ThreadLocal内存泄漏问题
    • 3.1 强引用、软引用、弱引用、虚引用
      • 3.1.1 整体架构
      • 3.1.2 强 :StrongReference:默认支持模式
      • 3.1.3 软:SoftReference
      • 3.1.4 弱:WeakReference
      • 3.1.5 虚:PhantomReference
      • 3.1.6 总结
  • 4 ThreadLocal为什么要用弱引用?不用如何?
    • 4.1 为什么使用弱引用
    • 4.2 key为null的entry
    • 4.3 set、get方法会去检查所有键为null的entry对象
      • 4.3.1 set()
      • 4.3.2 get()
      • 4.3.3 remove()
    • 4.4 结论
  • 5 实践
  • 6 总结


1 概述

ThreadLocal 该类提供线程局部变量

1.1 是什么

java JUC并发编程 第八章 ThreadLocal_第1张图片
在这里插入图片描述

1.2 能干嘛

在这里插入图片描述
java JUC并发编程 第八章 ThreadLocal_第2张图片

1.3 helloworld

方法说明
java JUC并发编程 第八章 ThreadLocal_第3张图片
使用规范

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 threadLocal = new ThreadLocal(){
        @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
java JUC并发编程 第八章 ThreadLocal_第4张图片

2.2 ThreadLocal和ThreadLocalMap

里面有个静态内部类ThreadLocalMap
java JUC并发编程 第八章 ThreadLocal_第5张图片

2.3 三者概括

java JUC并发编程 第八章 ThreadLocal_第6张图片
当我们为threadLocal变量赋值,实际上是以当前threadLocal实例为key,值为value的Entry往这个threadLocalMap中存放
近似的可以理解为:
ThreadLocalMap从字面上可以看出是一个保存ThreadLocal对象的map(其实是以ThreadLocal为key),不过是经过了两层包装的ThreadLocal对象:
java JUC并发编程 第八章 ThreadLocal_第7张图片
JVM内部维护了一个线程版的Map(通过THreadLocal对象的set方法,结果把ThreadLocal对象自己做key,放进了ThreadLocalMap中),每个线程要用到这个T的时候,用当前的线程去Map里面获取,通过这样让每个线程拥有了自己独立的变量,人手一份,竞争条件被彻底消除,在并发模式下绝对安全的策略

3 ThreadLocal内存泄漏问题

为什么ThreadLocalMap里面有个WeakReference(弱引用)
java JUC并发编程 第八章 ThreadLocal_第8张图片
内存泄漏:不再会被使用的对象或者变量占用的内存不能被回收,就是内存泄漏

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

3.1.1 整体架构

java JUC并发编程 第八章 ThreadLocal_第9张图片

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
java JUC并发编程 第八章 ThreadLocal_第10张图片
2.点击Edit Configurations…
java JUC并发编程 第八章 ThreadLocal_第11张图片
3.点击Modify options,再点击add VM options
java JUC并发编程 第八章 ThreadLocal_第12张图片
4.配置参数-Xms10m -Xmx10m
java JUC并发编程 第八章 ThreadLocal_第13张图片

java JUC并发编程 第八章 ThreadLocal_第14张图片

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

结果
java JUC并发编程 第八章 ThreadLocal_第15张图片

3.1.6 总结

java JUC并发编程 第八章 ThreadLocal_第16张图片
强引用:即便发生oom也不会回收
软引用:内存紧张回收
弱引用:只要有gc马上被回收
虚引用:必定被回收
java JUC并发编程 第八章 ThreadLocal_第17张图片
在这里插入图片描述

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

4.1 为什么使用弱引用

java JUC并发编程 第八章 ThreadLocal_第18张图片

在这里插入图片描述

4.2 key为null的entry

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

都会调用expungeStaleEntry方法

4.3.1 set()

java JUC并发编程 第八章 ThreadLocal_第19张图片
java JUC并发编程 第八章 ThreadLocal_第20张图片

4.3.2 get()

java JUC并发编程 第八章 ThreadLocal_第21张图片
java JUC并发编程 第八章 ThreadLocal_第22张图片
java JUC并发编程 第八章 ThreadLocal_第23张图片

4.3.3 remove()

java JUC并发编程 第八章 ThreadLocal_第24张图片
三个方法都寻找脏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对象从而防止内存泄漏,属于安全加固的方法

你可能感兴趣的:(java)