ThreadLocal全面解析(一)

今天无意中看到了一篇关于ThreadLocal的文章,然后就去学习了一下,但是那篇文章看完之后,小六六又觉得有点不完善的地方,所以就继续找资料学习,终于把ThreadLocal大部分的知识有了点基本的认知吧,故写文章记录一下。

ThreadLocal基础之Java的引用

在 JDK1.2 之前,Java中的定义很传统:如果 reference 类型的数据中存储的数值代表的是另外一块内存的起始地址,就称为这块内存代表着一个引用。
Java 中的垃圾回收机制在判断是否回收某个对象的时候,都需要依据“引用”这个概念。
在不同垃圾回收算法中,对引用的判断方式有所不同:

  • 引用计数法:为每个对象添加一个引用计数器,每当有一个引用指向它时,计数器就加1,当引用失效时,计数器就减1,当计数器为0时,则认为该对象可以被回收(目前在Java中已经弃用这种方式了)。
  • 可达性分析算法:从一个被称为 GC Roots 的对象开始向下搜索,如果一个对象到GC Roots没有任何引用链相连时,则说明此对象不可用。
  • JDK1.2 之前,一个对象只有“已被引用”和"未被引用"两种状态,这将无法描述某些特殊情况下的对象,比如,当内存充足时需要保留,而内存紧张时才需要被抛弃的一类对象。

四种引用类型

所以在 JDK.1.2 之后,Java 对引用的概念进行了扩充,将引用分为了:强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Weak Reference)、虚引用(Phantom Reference)4 种,这 4 种引用的强度依次减弱。

强引用

Java中默认声明的就是强引用,比如:

Object obj = new Object(); //只要obj还指向Object对象,Object对象就不会被回收
obj = null;  //手动置null
复制代码

只要强引用存在,垃圾回收器将永远不会回收被引用的对象,哪怕内存不足时,JVM也会直接抛出OutOfMemoryError,不会去回收。如果想中断强引用与对象之间的联系,可以显示的将强引用赋值为null,这样一来,JVM就可以适时的回收对象了

软引用

软引用是一种比强引用生命周期稍弱的一种引用类型。在JVM内存充足的情况下,软引用并不会被垃圾回收器回收,只有在JVM内存不足的情况下,才会被垃圾回收器回收。所以软引用的这种特性,一般用来实现一些内存敏感的缓存,只要内存空间足够,对象就会保持不被回收掉,比如网页缓存图片缓存等。

SoftReference<String> softReference = new SoftReference<String>(new String("小六六"));
System.out.println(softReference.get());
复制代码

弱引用

弱引用的引用强度比软引用要更弱一些,无论内存是否足够,只要 JVM 开始进行垃圾回收,那些被弱引用关联的对象都会被回收。在 JDK1.2 之后,用 java.lang.ref.WeakReference 来表示弱引用。这个对ThreadLocal有用,大家先记住

WeakReference<String> weakReference = new WeakReference<String>(new String("小六六"));
System.gc();
if(weakReference.get() == null) {
    System.out.println("weakReference已经被GC回收");
}
复制代码

输出结果:

weakReference已经被GC回收
复制代码

虚引用(PhantomReference)

虚引用是最弱的一种引用关系,如果一个对象仅持有虚引用,那么它就和没有任何引用一样,它随时可能会被回收,在 JDK1.2 之后,用 PhantomReference 类来表示,通过查看这个类的源码,发现它只有一个构造函数和一个 get() 方法,而且它的 get() 方法仅仅是返回一个null,也就是说将永远无法通过虚引用来获取对象,虚引用必须要和 ReferenceQueue 引用队列一起使用。

PhantomReference<String> phantomReference = new PhantomReference<String>(new String("小六六"), new ReferenceQueue<String>());
System.out.println(phantomReference.get());
复制代码

运行后,发现结果总是null,引用跟没有持有差不多。

简单总结

  • 强引用 一直存活,除非GC Roots不可达 所有程序的场景,基本对象,自定义对象等。
  • 软引用 内存不足时会被回收 – 一般用在对内存非常敏感的资源上,用作缓存的场景比较多,例如:网页缓存、图片缓存
  • 弱引用 只能存活到下一次GC前 生命周期很短的对象,例如ThreadLocal中的Key。
  • 虚引用 随时会被回收, 创建了可能很快就会被回收 业界暂无使用场景, – 可能被JVM团队内部用来跟踪JVM的垃圾回收活动

ThreadLocal基础之Java中的值传递和地址传递

首先我们来看看代码

public class Test {
	 public static void main(String[] args) {
	        String str = "123";
	        System.out.println(str);
	        change(str);
	        System.out.println(str);
	    }
    public static void change(String str){
    		str = "小六六";
    }
}

复制代码

那么你觉得会输出多少呢?至少我曾经觉得是:

123
小六六
复制代码

但是,正确答案是:

123
123
复制代码

这是为什么呢?我相信答错的同学大都是受到了一些”java教材“的影响–java的参数传递有两种:

  • 值传递,传递值,在函数中形参发生的变化不影响实参。
  • 引用传递,传递对象引用,在函数中形参发生的变化影响实参。

然而,实际上java参数传递只有一种情况,那就是值传递。所不同的是,一般说的"引用传递",在实际中传递的不过是引用对象的地址值 值传递传递的是真实内容的一个副本,对副本的操作不影响原内容,也就是形参怎么变化,不会影响实参对应的内容。

在解释上述代码前,先要在补充一点知识:

String a = new String("小六六");
String b;
b= new String("小六六");

复制代码

两种形式的代码所形成的的结果是完全一致的,后面一种更容易理解java中的引用与对象的具体含义。先声明一个String对象的引用,再new一个“小六六”对象,最后将这个对象赋值(等号=)给该引用。

  • b:对象的引用
  • “小六六”:实际对象

好了,来个例子具体解释一下值传递和地址值引用吧。

先定义一个对象:

public class Person {
         private String name;
         private int age;
 
         public String getName() {
             return name;
         }
         public void setName(String name) {
             this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
}
复制代码

我们写个函数测试一下:

public static void PersonCrossTest(Person person){
         System.out.println("传入的person的name:"+person.getName());
         person.setName("我是张小龙");
         System.out.println("方法内重新赋值后的name:"+person.getName());
     }
 //测试
 public static void main(String[] args) {
         Person p=new Person();
         p.setName("我是马化腾");
        p.setAge(45);
        PersonCrossTest(p);
        System.out.println("方法执行后的name:"+p.getName());
}
复制代码

结果

1传入的person的name:我是马化腾
2方法内重新赋值后的name:我是张小龙
3方法执行后的name:我是张小龙
复制代码

可以看出,person经过personCrossTest()方法的执行之后,内容发生了改变,这印证了上面所说的“引用传递”,对形参的操作,改变了实际对象的内容。

那么,到这里就结题了吗?
不是的,没那么简单,
能看得到想要的效果
是因为刚好选对了例子而已!!!

下面我们对上面的例子稍作修改,加上一行代码,

public static void PersonCrossTest(Person person){
        System.out.println("传入的person的name:"+person.getName());
        person=new Person();//加多此行代码
        person.setName("我是张小龙");
        System.out.println("方法内重新赋值后的name:"+person.getName());
    }
复制代码
传入的person的name:我是马化腾
方法内重新赋值后的name:我是张小龙
方法执行后的name:我是马化腾
复制代码

为什么这次的输出和上次的不一样了呢?
看出什么问题了吗?

按照JVM内存模型可以知道,对象和数组是存储在Java堆区的,而且堆区是共享的,因此程序执行到main()方法中的下列代码时

Person p=new Person();
        p.setName("我是马化腾");
        p.setAge(45);
        PersonCrossTest(p);
复制代码

JVM会在堆内开辟一块内存,用来存储p对象的所有内容,同时在main()方法所在线程的栈区中创建一个引用p存储堆区中p对象的真实地址,

当执行到PersonCrossTest()方法时,因为方法内有这么一行代码:

person=new Person();
复制代码

JVM需要在堆内另外开辟一块内存来存储new Person(),假如地址为“xo3333”,那此时形参person指向了这个地址,假如真的是引用传递,那么由上面讲到:引用传递中形参实参指向同一个对象,形参的操作会改变实参对象的改变。

可以推出:实参也应该指向了新创建的person对象的地址,所以在执行PersonCrossTest()结束之后,最终输出的应该是后面创建的对象内容。

然而实际上,最终的输出结果却跟我们推测的不一样,最终输出的仍然是一开始创建的对象的内容。

由此可见:引用传递,在Java中并不存在。

但是有人会疑问:为什么第一个例子中,在方法内修改了形参的内容,会导致原始对象的内容发生改变呢?
这是因为:无论是基本类型和是引用类型,在实参传入形参时,都是值传递,也就是说传递的都是一个副本,而不是内容本身。
可以看出,方法内的形参person和实参p并无实质关联,它只是由p处copy了一份指向对象的地址,此时:
p和person都是指向同一个对象。
因此在第一个例子中,对形参p的操作,会影响到实参对应的对象内容。而在第二个例子中,当执行到new Person()之后,JVM在堆内开辟一块空间存储新对象,并且把person改成指向新对象的地址,此时:
p依旧是指向旧的对象,person指向新对象的地址。
所以此时对person的操作,实际上是对新对象的操作,于实参p中对应的对象毫无关系。

同样总结一下

  • 在Java中所有的参数传递,不管基本类型还是引用类型,都是值传递,或者说是副本传递。
    只是在传递过程中:
  • 如果是对基本数据类型的数据进行操作,由于原始内容和副本都是存储实际值,并且是在不同的栈区,因此形参的操作,不影响原始内容。
  • 如果是对引用类型的数据进行操作,分两种情况,一种是形参和实参保持指向同一个对象地址,则形参的操作,会影响实参指向的对象的内容。一种是形参被改动指向新的对象地址(如重新赋值引用),则形参的操作,不会影响实参指向的对象的内容。

ThreadLocal基础之this关键字

this关键字的作用

Person

String name;//定义当前Person名字

//参数name是目标名字
//成员变量name是自己名字
public  void sayHello(String name) {
	System.out.println(name+",你好。我是"+name);
}

复制代码

Demo01Person

public static void main(String[] args) {
	Person person = new Person();
	//设置当前person名字
	person.name = "王健林";
	//调用sayHello方法
	person.sayHello("王思聪");
}

复制代码

运行结果:王思聪,你好。我是王健林
总结:当我们使用this.成员变量名时,就可以访问本类当中的成员变量。
由此我们可以总结出:使用this关键字可以准确的进行属性的标记

this关键字的原理

String name;//定义当前Person名字

//参数name是目标名字
//成员变量name是自己名字
public  void sayHello(String name) {
	System.out.println(this);
}

复制代码
public static void main(String[] args) {
	Person person = new Person();
	//设置当前person名字
	person.name = "王健林";
	//调用sayHello方法
	person.sayHello("王思聪");
	System.out.println(person);
}

复制代码

打印结果:demo01.Person@7852e922 demo01.Person@7852e922
从结果我们可以看出,person和方法中this的地址是一样的。
由此我们可以总结出:通过谁调用的方法,谁就是this

原文 

https://juejin.im/post/5f058d8ae51d4534695c2237

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » ThreadLocal全面解析(一)

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址