Java自动拆装箱(Autoboxing and unboxing)学习
在学习并发的过程中,用“boolean bool = true”的自动装箱方式初始化了两个对象锁去锁两块代码,结果运行的时候出现了竞争等待,调试了一下发现两个锁变量指向的是同一个对象,由此可见我对自动拆装箱的机制想的太简单了,查了一下,发现这个机制还挺细节,那就记录一下:
本文主要有以下几个方面:
- 什么是自动拆装箱
- 拆装箱的实现
- 拆装箱发生的场景
- 关于string
- 回首望月
尝试的第一篇博客,不当之处,求轻喷!
一. 什么是自动拆箱与装箱
我们都知道,java定义了8种基本类型和与之对应的8中包装器,其中6种数据类型,1种字符类型以及1种布尔类型:
在java5之前,定义生成一个integer包装器类型的对象,只能通过以下方式:
1 integer i = new integer(0);
java5支持了基本类型和对应的包装类型之前的自动转换机制,即自动拆箱(包装器类型转换成基本类型)与装箱(基本类型封装成包装器类型)。于是,就有了以下两行代码:
1 integer i = 0; //自动装箱 2 int j = i; //自动拆箱
二. 自动拆装箱的实现(int-integer为例)
我们将下面自动拆装箱的代码反编译一下,拆装箱的动作就一目了然。
1 public class maintest { 2 public static void main(string[] args) { 3 integer i = 0; 4 int j = i; 5 } 6 }
编译后:
通过反编译的结果看,在"integer i = 0"自动装箱的过程中,调用了integer.valueof(int i)方法;在"int j = i;"的自动装箱的过程中,调用了integer.intvalue()方法。
其中,拆箱方法integer.intvalue()方法很简单:
1 /** 2 * returns the value of this {@code integer} as an 3 * {@code int}. 4 */ 5 public int intvalue() { 6 return value; 7 }
只是返回了当前对象的value值,没什么好说的。
但是装箱方法integer.valueof(int i)就有细节了,一起看下:
1 /** 2 * returns an {@code integer} instance representing the specified 3 * {@code int} value. if a new {@code integer} instance is not 4 * required, this method should generally be used in preference to 5 * the constructor {@link #integer(int)}, as this method is likely 6 * to yield significantly better space and time performance by 7 * caching frequently requested values. 8 * 9 * this method will always cache values in the range -128 to 127, 10 * inclusive, and may cache other values outside of this range. 11 * 12 * @param i an {@code int} value. 13 * @return an {@code integer} instance representing {@code i}. 14 * @since 1.5 15 */ 16 public static integer valueof(int i) { 17 if (i >= integercache.low && i <= integercache.high) 18 return integercache.cache[i + (-integercache.low)]; 19 return new integer(i); 20 }
这边的源码比预想的多了一个细节操作,值落在[integercache.low, integercache.high]区间上时,是直接从一个integer类型的缓存数组integercache.cache中取一个对象返回出去,值不在这个区间时才new一个新对象返回。
看一下integercache的实现,它是integer类的一个私有静态内部类:
1 /** 2 * cache to support the object identity semantics of autoboxing for values between 3 * -128 and 127 (inclusive) as required by jls. 4 * 5 * the cache is initialized on first usage. the size of the cache 6 * may be controlled by the {@code -xx:autoboxcachemax=<size>} option. 7 * during vm initialization, java.lang.integer.integercache.high property 8 * may be set and saved in the private system properties in the 9 * sun.misc.vm class. 10 */ 11 12 private static class integercache { 13 static final int low = -128; 14 static final int high; 15 static final integer cache[]; 16 17 static { 18 // high value may be configured by property 19 int h = 127; 20 string integercachehighpropvalue = 21 sun.misc.vm.getsavedproperty("java.lang.integer.integercache.high"); 22 if (integercachehighpropvalue != null) { 23 try { 24 int i = parseint(integercachehighpropvalue); 25 i = math.max(i, 127); 26 // maximum array size is integer.max_value 27 h = math.min(i, integer.max_value - (-low) -1); 28 } catch( numberformatexception nfe) { 29 // if the property cannot be parsed into an int, ignore it. 30 } 31 } 32 high = h; 33 34 cache = new integer[(high - low) + 1]; 35 int j = low; 36 for(int k = 0; k < cache.length; k++) 37 cache[k] = new integer(j++); 38 39 // range [-128, 127] must be interned (jls7 5.1.7) 40 assert integercache.high >= 127; 41 } 42 43 private integercache() {} 44 }
integercache中有3个final类型的变量:
low:-128(一个字节能够表示的最小值);
high:127(一个字节能够表示的最大值),jvm中设置的属性值(通过-xx:autoboxcachemax=设置)二者取大值,再和integer.max_value取小值;
cache:在静态块中初始化为由区间[low, high]上的所有整数组成的升序数组。
综上,java在虚拟机堆内存中维持了一个缓存池,在装箱的过程中,如果发现目标包装器对象在缓存池中已经存在,就直接取缓存池中的,否则就新建一个对象。
测试一下:
1 public static void main(string[] args) { 2 integer i = 127; 3 integer j = 127; 4 system.out.println(system.identityhashcode(i)); //本地输出i的地址:1173230247 5 system.out.println(system.identityhashcode(j)); //本地输出j的地址:1173230247 6 7 integer m = 128; 8 integer n = 128; 9 system.out.println(system.identityhashcode(m)); //本地输出m的地址:856419764 10 system.out.println(system.identityhashcode(n)); //本地输出n的地址:621009875 11 }
由测试结果来看,值为127时,两次装箱返回的是同一个对象,值为128时,两次装箱返回的是不同的对象。
因为小数的区间取值无限,所以float->float,double->double两种类型装箱机制没有缓存机制,其他5中基本类型的封装机制也是类似int->integer的装箱套路,不过缓存的边界不可改变:
基本类型 | 包装器类型 | 缓存区间 | 缓存是否可变 |
---|---|---|---|
byte | byte | [-128, 127] | 不可变 |
short | short | [-128, 127] | 不可变 |
int | integer | [-128, 127] | 上限可设置 |
long | long | [-128, 127] | 不可变 |
float | float | -- | -- |
double | double | -- | -- |
char | character | [0, 127] | 不可变 |
boolean | boolean | {true, false} | 不可变 |
因为基本类型对应的包装器都是不可变类,多以他们的缓存区间一旦初始化,里面的值就无法再改变,所以在jvm运行过程中,所有的基本类型包装器的缓存池都是不变的。
三. 拆装箱发生的场景
1.定义变量和方法参数传递:
这里的拆装箱是指开发者通过编写代码控制的拆装箱,比较明显:
1 public static void main(string[] args) { 2 integer i = 0; //装箱 3 int j = i; //拆箱 4 aa(i); //拆箱,传值时发生了:int fi = i; 5 bb(j); //装箱,传值时发生了:integer fi = j; 6 } 7 private static void aa(int fi){ 8 } 9 private static void bb(integer fi){ 10 }
2.运算时拆箱
我们都知道,当一个变量的定义类型不是基本类型,其实变量的值是对象的在虚拟机中的地址,当用初始化后的包装器类型变量进行运算时,会发生什么呢?
1.“+,-,*,/ ...”等运算时拆箱
当用包装器类型的数据进行运算时,java会先执行拆箱操作,然后进行运算。
1 public class maintest { 2 public static void main(string[] args) { 3 integer i = 127; 4 integer j = 127; 5 i = i + j; 6 } 7 }
将上面一段代码反编译:
发现,除了在分别源码的3,4行进行了装箱操作后,在执行add操作之前,有两次拆箱操作,add之后,又把结果装箱赋值给变量i。
2.“==”判等运算
“==”运算比较特殊:
a == b
- 当a,b都是基本类型时,直接进行比较两个变量的值是否相等
- 当a,b都是包装器类型时,比较两个变量指向的对象所在的地址是否相等
- 当a,b中有一个是基本类型时,会将另一个包装器类型拆箱成基本类型,然后再进行基本类型的判等比较
测试如下:
1 public static void main(string[] args) { 2 int m = 128; 3 int n = 128; 4 integer i = 128; 5 integer j = 128; 6 system.out.println(m == n); //输出:true 7 system.out.println(m == i); //输出:true 8 system.out.println(i == j); //输出:false 9 }
前文已经说了,jvm没有设置integer类型的缓存上限的时候,128不在缓存池内,所以两次封装后的对象是不同的对象。在此基础上:
- 第6行输出true:如果比较的是装箱后的对象地址,结果肯定是false,实际结果是true,说明比较的是基本类型的值,没有发生自动拆装箱动作
- 第7行输出true:如果比较的是装箱后的对象地址,结果肯定是false,实际结果是true,说明比较的是基本类型的值,那么包装器类型的变量肯定进行了自动拆箱动作
- 第8行输出false:如果比较的是拆箱后的基本类型的值,结果肯定是true,实际结果是false,说明比较的是对象的地址,没有发生自动拆装箱动作
看一下反编译的结果:
对应源码中除了第4、5行出现了自动装箱动作,就只有在第7行发生了自动拆箱动作。
四. 关于string类型
string类型没有对应的基本类型,所以没有自动拆装箱的机制,之所以在这里提一下,是因为string的初始化过程和自动装箱的过程很像。
1 public static void main(string[] args) { 2 string s1 = "hello"; 3 string s2 = "hello"; 4 string s3 = new string("hello"); 5 string s4 = new string("hello"); 6 system.out.println(system.identityhashcode(s1)); //输出s1地址:1173230247 7 system.out.println(system.identityhashcode(s2)); //输出s2地址:1173230247 8 system.out.println(system.identityhashcode(s3)); //输出s3地址:856419764 9 system.out.println(system.identityhashcode(s4)); //输出s5地址:621009875 10 }
从上面的输出结果可以看出,两个直接用字符串赋值的变量s1,s2指向的是同一个对象,而new string()生成对象赋值的变量s3,s4则是不同的对象。
其实,jvm中存在一个字符串缓存池,当直接使用字符串初始化变量的时候,java会先到字符串缓存池中查看有没有相同值的string对象,如果有,直接返回缓存池中的对象;如果没有,就new出一个新的对象存入缓存池,再返回这个对象。而string的不可变性质则能保证在对象共享的过程中不会出现线程安全问题。
与基本类型的缓存池相比,string类型的缓存池在运行时是动态变化的。
五. 回首望月
回到最开始我碰到的问题,当我用“boolean bool = true”的自动装箱方式定义变量的时候,这两个变量其实指向的都是boolean类型的缓存池中的那个值为true的对象,所以用他们当做同步锁,其实是用的同一把锁,自然会出现竞争等待。
经验:当我们使用自动装箱机制初始化变量的时候,就相当于告诉java这里需要一个对象,而不是告诉java这里需要一个新的对象。当我们需要一个新的对象的时候,为了保险起见,自己new一个出来,比如锁。
推荐阅读
-
java自动装箱拆箱深入剖析
-
java包装类的自动装箱拆箱中对象的变化
-
Java自动拆装箱(Autoboxing and unboxing)学习
-
Java13-day04【Integer、int和String的相转、自动装箱和拆箱、Date、SimpleDateFormat、Calendar、异常、try...catch、throws】
-
详解Java 自动装箱与自动拆箱
-
JAVA自动装箱拆箱
-
java基础1.5版后新特性 自动装箱拆箱 Date SimpleDateFormat Calendar.getInstance()获得一个日历对象 抽象不要生
-
Java 自动装箱与拆箱
-
Java集合框架 List集合、Set集合、Map集合 学习泛型与包装类的装箱拆箱
-
java包装类的自动装箱拆箱中对象的变化