WeakHashMap

WeakHashMapWeakHashMap,此种Map的特点是,当除了自身有对key的引用外,此key没有其他引用那么此map会自动丢弃此值,见实例:此例子中声明了两个Map对象,一个是HashMap,一个是WeakHashMap,同时向两个map中放入a、b两个对象,当HashMap remove掉a并且将a、b都指向nu…

大家好,又见面了,我是你们的朋友全栈君。

WeakHashMap,此种Map的特点是,当除了自身有对key的引用外,此key没有其他引用那么此map会自动丢弃此值,

见实例:此例子中声明了两个Map对象,一个是HashMap,一个是WeakHashMap,同时向两个map中放入a、b两个对象,当HashMap  remove掉a 并且将a、b都指向null时,WeakHashMap中的a将自动被回收掉。出现这个状况的原因是,对于a对象而言,当HashMap  remove掉并且将a指向null后,除了WeakHashMap中还保存a外已经没有指向a的指针了,所以WeakHashMap会自动舍弃掉a,而对于b对象虽然指向了null,但HashMap中还有指向b的指针,所以

WeakHashMap将会保留

Java代码  
收藏代码

  1. package test;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Iterator;  
  5. import java.util.Map;  
  6. import java.util.WeakHashMap;  
  7.   
  8. public class Test {  
  9.     public static void main(String[] args) throws Exception {  
  10.         String a = new String(“a”);  
  11.         String b = new String(“b”);  
  12.         Map weakmap = new WeakHashMap();  
  13.         Map map = new HashMap();  
  14.         map.put(a, ”aaa”);  
  15.         map.put(b, ”bbb”);  
  16.   
  17.           
  18.         weakmap.put(a, ”aaa”);  
  19.         weakmap.put(b, ”bbb”);  
  20.           
  21.         map.remove(a);  
  22.           
  23.         a=null;  
  24.         b=null;  
  25.           
  26.         System.gc();  
  27.         Iterator i = map.entrySet().iterator();  
  28.         while (i.hasNext()) {  
  29.             Map.Entry en = (Map.Entry)i.next();  
  30.             System.out.println(”map:”+en.getKey()+“:”+en.getValue());  
  31.         }  
  32.   
  33.         Iterator j = weakmap.entrySet().iterator();  
  34.         while (j.hasNext()) {  
  35.             Map.Entry en = (Map.Entry)j.next();  
  36.             System.out.println(”weakmap:”+en.getKey()+“:”+en.getValue());  
  37.               
  38.         }  
  39.     }  
  40.   
  41.       
  42. }  

 

来自:

http://mzlly999.iteye.com/blog/1126049

==================================================

先把问题说清楚:

WeakHashMap是主要通过expungeStaleEntries这个函数的来实现移除其内部不用的条目从而达到的自动释放内存的目的的.基本上只要对WeakHashMap的内容进行访问就会调用这个函数,从而达到清除其内部不在为外部引用的条目。但是如果预先生成了WeakHashMap,而在GC以前又不曾访问该WeakHashMap,那不是就不能释放内存了吗?

对应的两个测试案例:

WeakHashMapTest1:

public class WeakHashMapTest1 {
   
   
public static void main(String[] args) throws Exception {
List<WeakHashMap<byte[][], byte[][]>> maps = new ArrayList<WeakHashMap<byte[][], byte[][]>>();
for (int i = 0; i < 1000; i++) {
WeakHashMap<byte[][], byte[][]> d = new WeakHashMap<byte[][], byte[][]>();
d.put(new byte[1000][1000], new byte[1000][1000]);
maps.add(d);
System.gc();
System.err.println(i);
}
}
}

由于Java默认内存是64M,所以再不改变内存参数的情况下,该测试跑不了几步循环就内存溢出了。果不其然,WeakHashMap这个时候并没有自动帮我们释放不用的内存。

WeakHashMapTest2:

public class WeakHashMapTest2 {
   
   
public static void main(String[] args) throws Exception {
List<WeakHashMap<byte[][], byte[][]>> maps = new ArrayList<WeakHashMap<byte[][], byte[][]>>();
for (int i = 0; i < 1000; i++) {
WeakHashMap<byte[][], byte[][]> d = new WeakHashMap<byte[][], byte[][]>();
d.put(new byte[1000][1000], new byte[1000][1000]);
maps.add(d);
System.gc();
System.err.println(i);
for (int j = 0; j < i; j++) {
System.err.println(j + " size" + maps.get(j).size());
}
}
}
}

这次测试输出正常,不在出现内存溢出问题.

总结来说:WeakHashMap并不是你啥也干他就能自动释放内部不用的对象的,而是在你访问它的内容的时候释放内部不用的对象

问题讲清楚了,现在我们来梳理一下.了解清楚其中的奥秘.

WeakHashMap实现弱引用,是因为它的Entry<K,V>是继承自WeakReference<K>的

在WeakHashMap$Entry<K,V>的类定义及构造函数里面是这样写的:

private static class Entry<K,V> 
extends WeakReference<K>
implements Map.Entry<K,V> Entry(K key, V value, ReferenceQueue<K> queue,int hash, Entry<K,V> next) {
super(key, queue);
this.value = value;
this.hash = hash;
this.next = next;
}

请注意它构造父类的语句:“super(key, queue);”,传入的是key,因此key才是进行弱引用的,value是直接强引用关联在this.value之中.System.gc()时,key中的byte数组进行了回收,value依然保持(value被强关联到entry,entry又关联在map,map关联在arrayList.).

如何证明key中的byte被回收了呢?可以通过内存溢出时导出的内存镜像进行分析,也可以通过如下的小测试得出结论:

把上面的value用小对象代替,

for (int i = 0; i < 10000; i++) { 
WeakHashMap<byte[][], Object> d = new WeakHashMap<byte[][], Object>();
d.put(new byte[1000][1000], new Object());
maps.add(d); System.gc();
System.err.println(i);
}

上面的代码,即使执行10000次也没有问题,证明key中的byte数组确实被回收了。

for循环中每次都new一个新的WeakHashMap,在put操作后,虽然GC将WeakReference的key中的byte数组回收了,并将事件通知到了ReferenceQueue,但后续却没有相应的动作去触发 WeakHashMap 去处理 ReferenceQueue

所以 WeakReference 包装的key依然存在在WeakHashMap中,其对应的value也当然存在。

 value是何时被清除的呢?

对两个例子进行分析可知,例子二中的maps.get(j).size()触发了value的回收,那又如何触发的呢.查看WeakHashMap源码可知,size方法调用了expungeStaleEntries方法,该方法对vm要回收的的entry(quene)进行遍历,并将entryvalue置空,回收了内存.

所以效果是keyGC的时候被清除,valuekey清除后访问WeakHashMap被清除.

疑问:keyquenemapquene是同一个quene,poll操作会减少一个reference,那问题是key如果先被清除,expungeStaleEntries遍历quene时那个被回收的key对应的entry还能取出来么???

关于执行System.GC,key中的byte数据如何被回收了,请见WeakReference referenceQuene

来这里:http://www.cnblogs.com/redcreen/archive/2011/02/15/1955289.html

WeakHashMap
public class WeakHashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>
以弱键实现的基于哈希表的 Map。在 WeakHashMap 中,当某个键不再正常使用时,将自动移除其条目。
更精确地说,对于一个给定的键,其映射的存在并不阻止垃圾回收器对该键的丢弃,这就使该键成为可终止的,被终止,然后被回收。
丢弃某个键时,其条目从映射中有效地移除,因此,该类的行为与其他的 Map 实现有所不同。
null 值和 null 键都被支持。该类具有与 HashMap 类相似的性能特征,并具有相同的效能参数初始容量 和加载因子。
像大多数集合类一样,该类是不同步的。可以使用 Collections.synchronizedMap 方法来构造同步的 WeakHashMap。
该类主要与这样的键对象一起使用,其 equals 方法使用 == 运算符来测试对象标识。
一旦这种键被丢弃,就永远无法再创建了,所以,过段时间后在 WeakHashMap 中查找此键是不可能的,不必对其项已移除而感到惊讶。
该类十分适合与 equals 方法不是基于对象标识的键对象一起使用,比如,String 实例。
然而,对于这种可重新创建的键对象,键若丢弃,就自动移除 WeakHashMap 条目,这种表现令人疑惑。
WeakHashMap 类的行为部分取决于垃圾回收器的动作,所以,几个常见的(虽然不是必需的)Map 常量不支持此类。
因为垃圾回收器在任何时候都可能丢弃键,WeakHashMap 就像是一个被悄悄移除条目的未知线程。
特别地,即使对 WeakHashMap 实例进行同步,并且没有调用任何赋值方法,在一段时间后 ,size 方法也可能返回较小的值,
对于 isEmpty 方法,可能返回 false,然后返回 true,对于给定的键,containsKey 方法可能返回 true 然后返回 false,对于给定的键,
get 方法可能返回一个值,但接着返回 null,对于以前出现在映射中的键,put 方法返回 null,而 remove 方法返回 false,
对于键集、值集、项集进行的检查,生成的元素数量越来越少。
WeakHashMap 中的每个键对象间接地存储为一个弱引用的指示对象。因此,不管是在映射内还是在映射之外,
只有在垃圾回收器清除某个键的弱引用之后,该键才会自动移除。
实现注意事项:WeakHashMap 中的值对象由普通的强引用保持。因此应该小心谨慎,确保值对象不会直接或间接地强引用其自身的键,
因为这会阻止键的丢弃。注意,值对象可以通过 WeakHashMap 本身间接引用其对应的键;
这就是说,某个值对象可能强引用某个其他的键对象,而与该键对象相关联的值对象转而强引用第一个值对象的键。
处理此问题的一种方法是,在插入前将值自身包装在 WeakReferences 中,如:m.put(key, new WeakReference(value)),
然后,分别用 get 进行解包。
该类所有“collection 视图方法”返回的迭代器均是快速失败的:在迭代器创建之后,
如果从结构上对映射进行修改,除非通过迭代器自身的 remove 或 add 方法,其他任何时间任何方式的修改,
迭代器都将抛出 ConcurrentModificationException。因此,面对并发的修改,迭代器很快就完全失败,
而不是冒着在将来不确定的时间任意发生不确定行为的风险。
注意,迭代器的快速失败行为不能得到保证,一般来说,存在不同步的并发修改时,不可能作出任何坚决的保证。
快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此,编写依赖于此异常程序的方式是错误的,
正确做法是:迭代器的快速失败行为应该仅用于检测 bug。 
注意1:null 值和 null 键都被支持。
注意2:不是线程安全的。
注意3:迭代器的快速失败行为不能得到保证。
注意4:WeakHashMap是无序的。
注意5:确保值对象不会直接或间接地强引用其自身的键,
因为这会阻止键的丢弃。但是,值对象可以通过 WeakHashMap 本身间接引用其对应的键;
这就是说,某个值对象可能强引用某个其他的键对象,而与该键对象相关联的值对象转而强引用第一个值对象的键,这时就形成了环路。
处理此问题的一种方法是,在插入前将值自身包装在WeakReferences中,如:m.put(key, new WeakReference(value)),
然后,分别用 get 进行解包。如实例1.
实例1:
import java.lang.ref.WeakReference;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Random;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
public class Test {

 /**
  * @param args
  */
 public static void main(String[] args) {

  WeakHashMap<Integer,WeakReference<People>> map=new WeakHashMap<Integer,WeakReference<People>>();
  People p1=new People(“robin”,1,28);
  People p2=new People(“robin”,2,29);
  People p3=new People(“harry”,3,30);
  map.put(new Integer(100), new WeakReference<People>(p1));
  map.put(new Integer(101), new WeakReference<People>(p2));
  map.put(new Integer(1), new WeakReference<People>(p3));
  
  for(WeakReference<People> rp:map.values())
  {

   People p= rp.get();
   System.out.println(“people:”+p);
  }
 }
}
class People{

 String name;
 int id;
 int age;
 public People(String name,int id)
 {

  this(name,id,0);
 }
 public People(String name,int id,int age)
 {

  this.name=name;
  this.id=id;
  this.age=age;
 }
 public String toString()
 {

  return id+name+age;
 }
 public boolean equals(Object o)
 {

  if(o==null)
   return false;
  if(!(o instanceof People))
   return false;
  People p=(People)o;
  boolean res=name.equals(p.name);
  if(res)
   System.out.println(“name ”+name+” is double”);
  else
   System.out.println(name+” vS ”+p.name);
  return res;
 }
 public int hashCode()
 {

  return name.hashCode();
 }
}

来这里http://hubingforever.blog.163.com/blog/static/1710405792010794452203/

$(“.MathJax”).remove();

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/138137.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • 如何利用Python画图

    如何利用Python画图一、问题描述对于刚刚学习编程的同学来说对编程是非常陌生的,对很多的代码也是非常陌生,高中忙于学习的我们甚至可以说是对编程是一无所知,进入大学进入到这个专业才开始接触很多电脑相关的东西才开始接触编程,下面我就教大家如何利用编程语言画图,以Python语言为例,我们这次利用Python画一个爱心。二、问题分析刚开始进入大学学习的我们,对于高中和大学教学方式的巨大转变一时间可能会有点适应不了导致我…

  • 概要设计和详细设计说明书的区别

    概要设计和详细设计说明书的区别1.需求分析–产生软件功能规格说明书,需要确定用户对软件的需求,要作到明确、无歧义。不涉及具体实现方法。用户能看得明白,开发人员也可据此进行下面的工作(概要设计)。     2.概要设计–产生软件概要设计说明书,说明系统模块划分、选择的技术路线等,整体说明软件的实现思路。并且需要指出关键技术难点等。       3.详细设计–产生软件详细设计说明书,对概要设计的进一步细化,一般由各部

  • 表白代码vbs不同意无法关闭(vbs表白代码不同意按键会跑)

    代码网上很多,我找了两个,再加上一些套路,效果更好。代码1:msgbox”做我女朋友好吗”,vbQuestion,”在吗”msgbox(“房产写你名字”)msgbox(“保大”)msgbox(“我妈会游泳”)dimjdowhilej<1SelectCasemsgbox(“做我女朋友好吗”,68,”请郑重的回答我”)Case6j=1Case7msgbox(“再给你一次机会”)endSelectloopmsgbox(“我就知道你会同意的,哈哈哈哈

  • 系统安装失败如何恢复原系统_安装失败显示其他原因

    系统安装失败如何恢复原系统_安装失败显示其他原因按照博客上的方法安装了npm,但是安装cnpm出现了“cnpm不是内部命令”那么我就详细的来说下解决方法;1,node.js的安装在node.js官网下载,根据你电脑的选择版本,我的安装路径是D盘,D:\ProgramFiles\nodejs输入npm-v检测是否安装成功。2.安装cnpmnpminstall-gcnpm–registry=https://registry.npm.taobao.org(注意要对环境变量配置)在系统变量path下添加该路径D:\Prog

    2022年10月15日
  • javascript飞机大战游戏_javascript游戏开发

    javascript飞机大战游戏_javascript游戏开发系列目录1.JavaScript贪吃蛇游戏2.JavaScript俄罗斯方块3.JavaScript扫雷小游戏4.JavaScript网红太空人表盘引言:之前我有用Java写过一个飞机大战,感觉挺受欢迎的,有的小伙伴想用Javasript写,我这次就按我的思路写了一个版本。实现思路分2张画布来实现,画布1仅仅用来绘制背景图,画布2用来绘制游戏相关的动态内容。创建我方飞机定时创建敌机开启主线程,用来刷新画布2.代码实现编写页面<!DOCTYPEhtml&

  • Java程序设计(高级及专题)- JDBC「建议收藏」

    Java程序设计(高级及专题)- JDBC「建议收藏」Java程序设计(高级及专题)- JDBC

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号