- 浏览: 149452 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
EclipseEye:
fair_jm 写道不错 蛮详细的 谢谢分享
SWT/JFace专题 --- SWT中Display和多线程 -
fair_jm:
不错 蛮详细的 谢谢分享
SWT/JFace专题 --- SWT中Display和多线程
Map
------
1.HashMap
2.LinkedHashMap
3.IdentityHashMap
4.WeakHashMap
5.TreeMap
6.EnumMap
7.ConcurrentHashMap
8.ConcurrentSkipListMap
--------------------------------------------
4.WeakHashMap及java.lang.ref类库 持有引用
在分析WeakHashMap 之前先来看看java.lang.ref 类库 的持有引用相关的知识。
java.lang.ref类库包含了一组类,这些类为垃圾回收提供了更大的灵活性。当存在可能消耗掉内存的大对象时,这些类显的特别重要。
有3个继承自Reference的类:SoftReference、WeakReference和PhantomReference。当垃圾回收器正在考察的对象只能通过某个Reference对象才“可获得”时,上述这些不同的派生类为垃圾回收器提供了不同级别的间接指示。
对象是“可获得的”(reachable)指该对象在程序中某处 直接或间接的引用了。如果一个对象是“可获得的”,垃圾回收器就不能释放它,因为它仍在程序中使用。如果一个对象不是“可获得的”,表示程序中已经不存在对该对象的引用,这时将其回收是安全的。
对象经过Reference包装后就能实现上述功能,不过该对象一定不能存在有普通对象(未经Reference包装的对象)引用之。
SoftReference、WeakReference和PhantomReference由强到弱对于不同级别的“可获得性”:SoftReference用于实现内存敏感的高速缓存;WeakReference用于实现“规范映射”而设计的,“规范映射”中对象的实例可以在程序的多处使用以节省空间;PhantomReference用以调度回收前的清理工作,比java终止机制更为灵活。
使用SoftReference和WeakReference时,可以选择是否要将它们放入ReferenceQueue(用作“回收前清理工作”的工具)。而PhantomReference只能依赖于ReferenceQueue。
----------------------
JVM的垃圾回收机制,和Java中存在的4种类型的引用有关:强引用,软引用,弱引用以及幻象引用。
其中,HashMap采用的是类似强引用的强键来管理的,也就是说即使作为key的对象已经没有被任何对象引用了,它仍然会保存 在 HashMap中,在某些情况(如内存缓存)下,这些过期的对象会造成内存泄露。
WeakHashMap采取的策略是,只要作为key的对象已经超出了生命周期,就不会阻止垃圾回收器对该对象的处理,即使在内存并不紧张的情况下。不过由于GC是一个优先级很低的线程,所以不能保证弱引用的对象超出生命周期后会立刻被清除。
弱引用特别适用场景:占有大量内存,但通过垃圾回收功能回收以后很容易重新创建。
软引用是只在内存紧张时才收集软可及对象。所以软引用比WeakHashMap采用的弱引用策略更适合于实现缓存机制。
-----------
WeakHashMap被用来保存WeakReference。它使得规范映射更易于使用。在这中映射中,每个值只保存一份实例以节省存储空间。当程序中需要那个值的时候,便在映射中查询现有的对象,然后使用它(而不是重新new一个新对象)。映射可以将值作为其初始化的一部分,不过通常是在需要的时候才生成“值”。
这是一种节约存储空间的技术,因为WeakHashMap允许垃圾回收器自动清理键和值,所以显得十分便利。对于想WeakHashMap添加键和值的操作,则没有什么特殊的要求。映射会自动使用WeakReference包装它们。
----------
WeakHashMap源码分析:
-------------------------------------
下面看一下:WeakReference和Reference的实现
WeakReference是Reference的子类,实现较为简单,就两个构造方法用于生成对象的引用
------
1.HashMap
2.LinkedHashMap
3.IdentityHashMap
4.WeakHashMap
5.TreeMap
6.EnumMap
7.ConcurrentHashMap
8.ConcurrentSkipListMap
--------------------------------------------
4.WeakHashMap及java.lang.ref类库 持有引用
在分析WeakHashMap 之前先来看看java.lang.ref 类库 的持有引用相关的知识。
java.lang.ref类库包含了一组类,这些类为垃圾回收提供了更大的灵活性。当存在可能消耗掉内存的大对象时,这些类显的特别重要。
有3个继承自Reference的类:SoftReference、WeakReference和PhantomReference。当垃圾回收器正在考察的对象只能通过某个Reference对象才“可获得”时,上述这些不同的派生类为垃圾回收器提供了不同级别的间接指示。
对象是“可获得的”(reachable)指该对象在程序中某处 直接或间接的引用了。如果一个对象是“可获得的”,垃圾回收器就不能释放它,因为它仍在程序中使用。如果一个对象不是“可获得的”,表示程序中已经不存在对该对象的引用,这时将其回收是安全的。
对象经过Reference包装后就能实现上述功能,不过该对象一定不能存在有普通对象(未经Reference包装的对象)引用之。
SoftReference、WeakReference和PhantomReference由强到弱对于不同级别的“可获得性”:SoftReference用于实现内存敏感的高速缓存;WeakReference用于实现“规范映射”而设计的,“规范映射”中对象的实例可以在程序的多处使用以节省空间;PhantomReference用以调度回收前的清理工作,比java终止机制更为灵活。
使用SoftReference和WeakReference时,可以选择是否要将它们放入ReferenceQueue(用作“回收前清理工作”的工具)。而PhantomReference只能依赖于ReferenceQueue。
----------------------
JVM的垃圾回收机制,和Java中存在的4种类型的引用有关:强引用,软引用,弱引用以及幻象引用。
其中,HashMap采用的是类似强引用的强键来管理的,也就是说即使作为key的对象已经没有被任何对象引用了,它仍然会保存 在 HashMap中,在某些情况(如内存缓存)下,这些过期的对象会造成内存泄露。
WeakHashMap采取的策略是,只要作为key的对象已经超出了生命周期,就不会阻止垃圾回收器对该对象的处理,即使在内存并不紧张的情况下。不过由于GC是一个优先级很低的线程,所以不能保证弱引用的对象超出生命周期后会立刻被清除。
弱引用特别适用场景:占有大量内存,但通过垃圾回收功能回收以后很容易重新创建。
软引用是只在内存紧张时才收集软可及对象。所以软引用比WeakHashMap采用的弱引用策略更适合于实现缓存机制。
//有机会可以研究一下 ReferenceQueue queue =new ReferenceQueue(); queue.poll();
-----------
WeakHashMap被用来保存WeakReference。它使得规范映射更易于使用。在这中映射中,每个值只保存一份实例以节省存储空间。当程序中需要那个值的时候,便在映射中查询现有的对象,然后使用它(而不是重新new一个新对象)。映射可以将值作为其初始化的一部分,不过通常是在需要的时候才生成“值”。
这是一种节约存储空间的技术,因为WeakHashMap允许垃圾回收器自动清理键和值,所以显得十分便利。对于想WeakHashMap添加键和值的操作,则没有什么特殊的要求。映射会自动使用WeakReference包装它们。
----------
WeakHashMap源码分析:
public class WeakHashMap<K, V> extends AbstractMap<K, V> implements Map<K, V> { //....有多个成员变量,包括初始容量,负载因子等都和HashMap中的相似,这里不多说了 /** *这是WeakHashMap中维持的一个引用队列,用于保存待要被垃圾回收器回收的WeakEntries(弱引用) */ private final ReferenceQueue<K> queue = new ReferenceQueue<K>(); //..... /** *清除掉queue 中包含的引用,在getTable(),resize()和size()方法中有调用 */ private void expungeStaleEntries() { Entry<K,V> e; while ( (e = (Entry<K,V>) queue.poll()) != null) {//遍历整个queue int h = e.hash; int i = indexFor(h, table.length);//得到改元素在table中的位置 Entry<K,V> prev = table[i]; Entry<K,V> p = prev; while (p != null) {//遍历table i位置处的链表(和HashMap一样采用的next维持的链式结构) Entry<K,V> next = p.next; if (p == e) {//如果找到了queue中对应的e元素在链表中的引用 if (prev == e)//如果该元素在table 的i位置处(其实table中只存放最前面的那个元素),就把该处设置为next位置的元素 table[i] = next; else// 否则,把perv的next定位到next上意思就是把queue中的e元素删除掉 prev.next = next; e.next = null; // Help GC 这里设null是为了更明显的体系GC,可以回收了 e.value = null; // " " size--; break; } prev = p; p = next; } } } //去掉弱引用对象后的新Table private Entry[] getTable() { expungeStaleEntries(); return table; } public V get(Object key) { Object k = maskNull(key);//key == null ? new Object(): key int h = HashMap.hash(k.hashCode());//调用HashMap的hash方法得到哈希值 Entry[] tab = getTable();//这是去掉弱引用对象后的新Table int index = indexFor(h, tab.length); Entry<K,V> e = tab[index]; while (e != null) { if (e.hash == h && eq(k, e.get())) return e.value; e = e.next; } return null; } public V put(K key, V value) { K k = (K) maskNull(key); int h = HashMap.hash(k.hashCode()); Entry[] tab = getTable(); int i = indexFor(h, tab.length); for (Entry<K,V> e = tab[i]; e != null; e = e.next) { if (h == e.hash && eq(k, e.get())) { V oldValue = e.value; if (value != oldValue) e.value = value; return oldValue; } } modCount++; Entry<K,V> e = tab[i]; tab[i] = new Entry<K,V>(k, value, queue, h, e);//这里加入了 应用队列的包装 if (++size >= threshold) resize(tab.length * 2); return null; } /** * 除了在创建Entry时添加了ReferenceQueue封装及extend WeakReference,其他的和HashMap.Entry的实现相似 */ private static classEntry<K,V> extends WeakReference<K> implements Map.Entry<K,V> { private V value; private final int hash; private Entry<K,V> next; /** * Creates new entry. */ 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; } public K getKey() { return WeakHashMap.<K>unmaskNull(get()); //通过引用得到key对象 } public V getValue() { return value; } public V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry e = (Map.Entry)o; Object k1 = getKey(); Object k2 = e.getKey(); if (k1 == k2 || (k1 != null && k1.equals(k2))) { Object v1 = getValue(); Object v2 = e.getValue(); if (v1 == v2 || (v1 != null && v1.equals(v2))) return true; } return false; } public int hashCode() { Object k = getKey(); Object v = getValue(); return ((k==null ? 0 : k.hashCode()) ^ (v==null ? 0 : v.hashCode())); } public String toString() { return getKey() + "=" + getValue(); } } //....... }
-------------------------------------
下面看一下:WeakReference和Reference的实现
WeakReference是Reference的子类,实现较为简单,就两个构造方法用于生成对象的引用
public class WeakReference<T> extends Reference<T> { /** * 创建一个引用,没有在引用队列中注册 */ public WeakReference(T referent) { super(referent); } /** * 创建一个引用,并且在指定的引用队列中注册 */ public WeakReference(T referent, ReferenceQueue<? super T> q) { super(referent, q); } }-----
public abstract class Reference<T> { private T referent; /* Treated specially by GC */ ReferenceQueue<? super T> queue; Reference next; transient private Reference<T> discovered; /* used by VM */ static private class Lock { }; private static Lock lock = new Lock(); /** *pending维护着一个等待入队的引用列表(通过next实现),垃圾收集器会把挂起的等待入列的引用添加到该列表中, *上面定义的lock就是为了维护这个列表而设置的 */ private static Reference pending = null; /** * 用高优先级线程把挂起的引用加入队列中 */ private static class ReferenceHandler extends Thread { ReferenceHandler(ThreadGroup g, String name) { super(g, name); } public void run() { for (;;) { Reference r; synchronized (lock) { if (pending != null) { r = pending; Reference rn = r.next; pending = (rn == r) ? null : rn; r.next = r; } else { try { lock.wait(); } catch (InterruptedException x) { } continue; } } // Fast path for cleaners if (r instanceof Cleaner) { ((Cleaner)r).clean(); continue; } ReferenceQueue q = r.queue; if (q != ReferenceQueue.NULL) q.enqueue(r); } }//run() }//ReferenceHandler static {//静态代码块,得到当前线程组的最顶层父类线程,并把优先级设置为最高 ThreadGroup tg = Thread.currentThread().getThreadGroup(); for (ThreadGroup tgn = tg; tgn != null;tg = tgn, tgn = tg.getParent()); Thread handler = new ReferenceHandler(tg, "Reference Handler"); handler.setPriority(Thread.MAX_PRIORITY); handler.setDaemon(true); handler.start(); } /* -- 引用对象的获得和清除 -- */ public T get() { return this.referent; } public void clear() { this.referent = null; } /** * 由程序或垃圾回收器通知是否已将此引用对象加入队列。 */ public boolean isEnqueued() { synchronized (this) { return (this.queue != ReferenceQueue.NULL) && (this.next != null); } } /** * 将此引用对象添加到引用对象已向其注册的队列(如果有)。 */ public boolean enqueue() { return this.queue.enqueue(this); } /* -- 两个构造函数 -- */ Reference(T referent) { this(referent, null); } Reference(T referent, ReferenceQueue<? super T> queue) { this.referent = referent; this.queue = (queue == null) ? ReferenceQueue.NULL : queue; } }
发表评论
-
Nio Socket
2013-05-16 05:53 0asfda -
结合jdk源码解读,Error Exception
2013-05-10 04:00 0/* * @(#)Error.java 1.17 05/11 ... -
从不同的角度,重新审视class和interface
2013-05-07 03:40 0java开发中,对应class和interface的基本区别都 ... -
java.lang.Object
2013-05-07 03:35 0/* * @(#)Object.java 1.73 06/0 ... -
反射机制+类加载机制
2013-02-18 01:30 0反射机制+类加载机制 -
并发专题----使用开源软件Amino构建并发应用程序/多线程运行时分析工具MTRAT
2013-02-14 00:50 1371使用开源软件构建并发 ... -
并发专题 ---- 线程安全
2013-02-14 00:50 746线程安全 ================== ... -
并发专题 --- 锁
2013-02-14 00:50 802相比于synchronized,ReentrantLock 提 ... -
并发专题 ----(JMM)java内存模型
2013-02-14 00:50 534Java 内存模型 ------------ ... -
并发专题 ---java.util.concurrent 包
2013-02-13 02:26 1832java.util.concurrent 包 原 ... -
集合框架 Queue篇(8)---PriorityBlockingQueue、SynchronousQueue
2013-02-07 12:40 1307Queue ------------ 1.ArrayDeq ... -
集合框架 Queue篇(7)---LinkedBlockingDeque
2013-02-07 12:40 850Queue ------------ 1.ArrayDeq ... -
集合框架 Queue篇(6)---LinkedBlockingQueue
2013-02-07 12:39 827Queue ------------ 1.ArrayDeq ... -
集合框架 Queue篇(5)---ArrayBlockingQueue
2013-02-06 10:39 701Queue ------------ 1.ArrayDeq ... -
集合框架 Queue篇(4)---阻塞队列和生产者-消费者模式、DelayQueue
2013-02-06 10:39 994Queue ------------ 1.ArrayDeq ... -
集合框架 Queue篇(3)---ConcurrentLinkedQueue
2013-02-06 10:38 1043Queue ------------ 1.ArrayDequ ... -
集合框架 Queue篇(2)---PriorityQueue
2013-02-06 10:38 829Queue ------------ 1.ArrayDeq ... -
集合框架 Queue篇(1)---ArrayDeque
2013-02-06 10:38 927Queue ------------ 1.ArrayDeq ... -
集合框架 Set篇---HashSet、LinkedHashSet、TreeSet、CopyOnWriteArraySet、ConcurrentSkipList
2013-02-05 08:43 1479Set --------- 1.HashSet 2.Link ... -
集合框架 List篇(2)---CopyOnWriteArrayList
2013-02-05 08:43 840List ----------- 1.ArrayList(jd ...
相关推荐
12. WeakHashMap:键使用弱引用的Map,当键不再被引用时,条目会自动从Map中移除。 13. Timer和TimerTask:定时任务调度,可以安排一次或周期性的任务执行。 14. Bitset:位集,用于高效存储和操作位标志。 15. ...
java集合框架 3.6. LinkedHashSet类 4. Map接口 4.1. Map.Entry接口 4.2. SortedMap接口 4.3. AbstractMap抽象类 4.4. HashMap类和TreeMap类 4.4.1. HashMap类 4.4.2. TreeMap类 4.5. LinkedHashMap类 4.6. ...
Java集合框架是Java编程语言中用于存储和管理对象的核心组件,它为开发者提供了灵活且高效的数据结构选择。这个框架的设计目标是确保高性能、高度互操作性以及易于扩展。以下是对标题和描述中涉及的知识点的详细说明...
数据结构和Java集合框架是Java编程中至关重要的概念,它们是高效编程和算法设计的基础。在Java中,数据结构指的是组织、存储和管理数据的方式,而集合框架则是一组接口和类,为处理各种数据结构提供了统一的API。 ...
本篇文章将详细探讨Java集合框架中的一些核心概念和技术细节。 #### 1. Collection与Collections的区别 - **Collection**:这是一个接口,位于`java.util`包中,它定义了一系列方法来操作一个对象的集合。它是所有...
Java 6中的集合框架是编程中的核心部分,它在`java.util`包下,包括List、Set、Map等接口以及它们的实现类。ArrayList和LinkedList实现了List接口,分别提供基于数组和链表的数据存储方式。HashSet和TreeSet实现了...
Java集合框架是Java编程语言中不可或缺的一部分,它提供了一组接口和类,用于高效地存储、管理和操作数据。这个“一个讲解很清晰的Java集合框架PPT”显然是一个对外公开的教育资源,旨在帮助学习者深入理解Java集合...
WeakHashMap是Java中的一种特殊的哈希表实现,它使用弱引用(Weak Reference)来保存键对象。当键对象没有被其他强引用引用时,在垃圾回收时会自动从WeakHashMap中移除对应的键值对。
集合框架的核心是`java.util`包下的`Collection`接口和`Map`接口,它们定义了处理对象集合的一系列通用操作。 `Collection`接口是最基础的集合接口,代表了一组Object的集合,可以通过迭代器`Iterator`遍历其元素。...
List 是 Java 集合框架中的一个接口,它允许元素重复,并且每个元素都有一个特定的顺序位置。这意味着可以通过索引来访问 List 中的元素。List 提供了多种实现类,包括 `LinkedList`、`ArrayList`、`Vector` 和 `...
Java 2集合框架是Java语言中用于存储和管理对象的核心组件,它提供了一套标准的接口和类,使得程序员能够高效地操作数据集合。这个框架的设计目标是提高代码的复用性和灵活性,允许开发者根据需求选择不同的数据结构...
什么是 Java2 Java 的特点Java 开发环境 JDK JRE Java 开发环境配置 Java 基本语法 数据类型基础语法运算符 Java 执行控制流程条件语句 if 条件语句 if...else 条件语句if...else if 多分支语句switch 多分支语句 ...
Java 提供了丰富的集合框架,包括列表、集合和映射等。 - **List**:有序的元素集合。 - **ArrayList**:动态数组实现的列表。 - **LinkedList**:双向链表实现的列表。 - **Vector**:线程安全的列表。 - **Set...
### 超全Java集合框架讲解 #### 集合框架总览 Java集合框架是Java编程语言中处理数据结构的基础。它为开发者提供了一系列高度优化的数据存储与操作方法,使得开发者可以更加专注于业务逻辑而无需担心底层实现细节...
Map接口是Java集合框架中的重要组成部分,它提供了一种存储键值对数据结构的方式,使得我们可以通过键(Key)快速查找对应的值(Value)。在Java中,有许多实现了Map接口的类,如HashMap、TreeMap、LinkedHashMap等...
Java集合框架是Java编程语言中不可或缺的一部分,它提供了一种高效、灵活的方式来存储和操作数据。面试中,Java集合框架的题目通常会测试应聘者对数据结构、算法以及API的理解。以下是对Java集合框架的一些核心知识...