Java引用

最新推荐文章于 2024-03-21 13:40:28 发布

Alex_________

最新推荐文章于 2024-03-21 13:40:28 发布

阅读量283

点赞数

分类专栏： Java后端

Java后端专栏收录该内容

10 篇文章 0 订阅

订阅专栏

http://blog.csdn.net/xiaofengcanyuexj

Java中没有指针的概念，而引用就是一个弱化的指针，保证开发不能任意操作内存。最近整理了一下之前不明白的各种级别引用：强引用、软引用、弱引用、虚引用，它们的特点和应用场景汇总如下：

1、强引用
如果一个对象具有强引用，GC绝不会回收它；当内存空间不足，JVM宁愿抛出OutOfMemoryError错误。一般new出来的对象都是强引用，如下

[java]view plain copy 
   
 //强引用  
 User strangeReference=new User();  

2、软引用
如果一个对象具有软引用，当内存空间不足，GC会回收这些对象的内存，使用软引用构建敏感数据的缓存。

在JVM中，软引用是如下定义的，可以通过一个时间戳来回收，下面引自JVM：

[java]view plain copy 
   
 public class SoftReference<T> extends Reference<T> {  
   
     /** 
      * Timestamp clock, updated by the garbage collector 
      */  
     static private long clock;  
   
     /** 
      * Timestamp updated by each invocation of the get method.  The VM may use 
      * this field when selecting soft references to be cleared, but it is not 
      * required to do so. 
      */  
     private long timestamp;  
   
     /** 
      * Creates a new soft reference that refers to the given object.  The new 
      * reference is not registered with any queue. 
      * 
      * @param referent object the new soft reference will refer to 
      */  
     public SoftReference(T referent) {  
         super(referent);  
         this.timestamp = clock;  
     }  
   
     /** 
      * Creates a new soft reference that refers to the given object and is 
      * registered with the given queue. 
      * 
      * @param referent object the new soft reference will refer to 
      * @param q the queue with which the reference is to be registered, 
      *          or <tt>null</tt> if registration is not required 
      * 
      */  
     public SoftReference(T referent, ReferenceQueue<? super T> q) {  
         super(referent, q);  
         this.timestamp = clock;  
     }  
   
     /** 
      * Returns this reference object's referent.  If this reference object has 
      * been cleared, either by the program or by the garbage collector, then 
      * this method returns <code>null</code>. 
      * 
      * @return   The object to which this reference refers, or 
      *           <code>null</code> if this reference object has been cleared 
      */  
     public T get() {  
         T o = super.get();  
         if (o != null && this.timestamp != clock)  
             this.timestamp = clock;  
         return o;  
     }  
   
 }  

软引用的声明的借助强引用或者匿名对象，使用泛型SoftReference<T>；可以通过get方法获得强引用。具体如下：

[java]view plain copy 
   
 //软引用  
 SoftReference<User>softReference=new SoftReference<User>(new User());  
 strangeReference=softReference.get();//通过get方法获得强引用  

3、弱引用
如果一个对象具有弱引用，在GC线程扫描内存区域的过程中，不管当前内存空间足够与否，都会回收内存，利用jdk中的ThreadLocal就是弱引用的，具体间下面的详细说明。

在JVM中，弱引用是如下定义的，下面引自JVM：

[java]view plain copy 
   
 public class WeakReference<T> extends Reference<T> {  
   
     /** 
      * Creates a new weak reference that refers to the given object.  The new 
      * reference is not registered with any queue. 
      * 
      * @param referent object the new weak reference will refer to 
      */  
     public WeakReference(T referent) {  
         super(referent);  
     }  
   
     /** 
      * Creates a new weak reference that refers to the given object and is 
      * registered with the given queue. 
      * 
      * @param referent object the new weak reference will refer to 
      * @param q the queue with which the reference is to be registered, 
      *          or <tt>null</tt> if registration is not required 
      */  
     public WeakReference(T referent, ReferenceQueue<? super T> q) {  
         super(referent, q);  
     }  
   
 }  

弱引用的声明的借助强引用或者匿名对象，使用泛型WeakReference<T>，具体如下：

[java]view plain copy 
   
 //弱引用  
 WeakReference<User>weakReference=new WeakReference<User>(new User());  

4、虚引用
如果一个对象仅持有虚引用，在任何时候都可能被垃圾回收，虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列联合使用，虚引用主要用来跟踪对象被垃圾回收的活动。

在JVM中，虚引用是如下定义的，下面引自JVM：

[java]view plain copy 
   
 public class PhantomReference<T> extends Reference<T> {  
   
     /** 
      * Returns this reference object's referent.  Because the referent of a 
      * phantom reference is always inaccessible, this method always returns 
      * <code>null</code>. 
      * 
      * @return  <code>null</code> 
      */  
     public T get() {  
         return null;  
     }  
   
     /** 
      * Creates a new phantom reference that refers to the given object and 
      * is registered with the given queue. 
      * 
      * <p> It is possible to create a phantom reference with a <tt>null</tt> 
      * queue, but such a reference is completely useless: Its <tt>get</tt> 
      * method will always return null and, since it does not have a queue, it 
      * will never be enqueued. 
      * 
      * @param referent the object the new phantom reference will refer to 
      * @param q the queue with which the reference is to be registered, 
      *          or <tt>null</tt> if registration is not required 
      */  
     public PhantomReference(T referent, ReferenceQueue<? super T> q) {  
         super(referent, q);  
     }  
   
 }  

虚引用PhantomReference<T>的声明的借助强引用或者匿名对象,结合泛型ReferenceQueue<T>初始化，具体如下：

[java]view plain copy 
   
 //虚引用  
 PhantomReference<User> phantomReference=new PhantomReference<User>(new User(),new ReferenceQueue<User>());  

5、总结

下面是一段关于强引用、软引用、弱引用、虚引用的程序：

[java]view plain copy 
   
 import java.lang.ref.*;  
 import java.util.HashSet;  
 import java.util.Set;  
   
 class User {  
   
     private String name;  
   
     public User()  
     {}  
   
     public User(String name)  
     {  
         this.name=name;  
     }  
   
     @Override  
     public String toString() {  
         return name;  
     }  
   
     public void finalize(){  
         System.out.println("Finalizing ... "+name);  
     }  
 }  
   
 /** 
  * Created by jinxu on 15-4-25. 
  */  
 public class ReferenceDemo {  
   
     private static ReferenceQueue<User> referenceQueue = new ReferenceQueue<User>();  
     private static final int size = 10;  
   
     public static void checkQueue(){  
        /* Reference<? extends User> reference = null; 
         while((reference = referenceQueue.poll())!=null){ 
             System.out.println("In queue : "+reference.get()); 
         }*/  
         Reference<? extends User> reference = referenceQueue.poll();  
         if(reference!=null){  
             System.out.println("In queue : "+reference.get());  
         }  
     }  
   
     public static void testSoftReference()  
     {  
         Set<SoftReference<User>> softReferenceSet = new HashSet<SoftReference<User>>();  
         for (int i = 0; i < size; i++) {  
             SoftReference<User> ref = new SoftReference<User>(new User("Soft " + i), referenceQueue);  
             System.out.println("Just created: " + ref.get());  
             softReferenceSet.add(ref);  
         }  
         System.gc();  
         checkQueue();  
     }  
   
     public static void testWeaKReference()  
     {  
         Set<WeakReference<User>> weakReferenceSet = new HashSet<WeakReference<User>>();  
         for (int i = 0; i < size; i++) {  
             WeakReference<User> ref = new WeakReference<User>(new User("Weak " + i), referenceQueue);  
             System.out.println("Just created: " + ref.get());  
             weakReferenceSet.add(ref);  
         }  
         System.gc();  
         checkQueue();  
     }  
   
     public static void testPhantomReference()  
     {  
         Set<PhantomReference<User>> phantomReferenceSet = new HashSet<PhantomReference<User>>();  
         for (int i = 0; i < size; i++) {  
             PhantomReference<User> ref =  
                     new PhantomReference<User>(new User("Phantom " + i), referenceQueue);  
             System.out.println("Just created: " + ref.get());  
             phantomReferenceSet.add(ref);  
         }  
         System.gc();  
         checkQueue();  
     }  
   
     public static void main(String[] args) {  
         testSoftReference();  
         testWeaKReference();  
         testPhantomReference();  
     }  
 }  

结果为

[java]view plain copy 
   
 Just created: Soft 0  
 Just created: Soft 1  
 Just created: Soft 2  
 Just created: Soft 3  
 Just created: Soft 4  
 Just created: Soft 5  
 Just created: Soft 6  
 Just created: Soft 7  
 Just created: Soft 8  
 Just created: Soft 9  
 Just created: Weak 0  
 Just created: Weak 1  
 Just created: Weak 2  
 Just created: Weak 3  
 Just created: Weak 4  
 Just created: Weak 5  
 Just created: Weak 6  
 Just created: Weak 7  
 Just created: Weak 8  
 Just created: Weak 9  
 Finalizing ... Weak 7  
 Finalizing ... Weak 8  
 Finalizing ... Weak 9  
 Finalizing ... Weak 4  
 Finalizing ... Weak 5  
 Finalizing ... Weak 6  
 Finalizing ... Weak 0  
 Finalizing ... Weak 1  
 Finalizing ... Weak 2  
 Finalizing ... Weak 3  
 Finalizing ... Soft 9  
 Finalizing ... Soft 8  
 Finalizing ... Soft 7  
 Finalizing ... Soft 6  
 Finalizing ... Soft 5  
 Finalizing ... Soft 4  
 Finalizing ... Soft 3  
 Finalizing ... Soft 2  
 Finalizing ... Soft 1  
 Finalizing ... Soft 0  
 In queue : null  
 Just created: null  
 Just created: null  
 Just created: null  
 Just created: null  
 Just created: null  
 Just created: null  
 Just created: null  
 Just created: null  
 Just created: null  
 Just created: null  
 In queue : null  
 Finalizing ... Phantom 9  
 Finalizing ... Phantom 7  
 Finalizing ... Phantom 8  
 Finalizing ... Phantom 4  
 Finalizing ... Phantom 5  
 Finalizing ... Phantom 6  
 Finalizing ... Phantom 0  
 Finalizing ... Phantom 1  
 Finalizing ... Phantom 2  
 Finalizing ... Phantom 3  

六、ThreadLocal

ThreadLocal是java多线程中牺牲空间获取线程隔离的方法，避免上锁，即每个线上保持对ThreadLocal<T>对象T的副本。线程在访问变量时，操作的是该线程独有的变量副本，彻底封闭在每个访问的线程中，并发问题也完全消除了。

上面原图摘自博客园：原图，在此表示感谢。

每个thread中都存在一个map，map的类型是ThreadLocal.ThreadLocalMap。Map中的key为一个threadlocal实例。这个Map的确使用了弱引用，不过弱引用只是针对key。每个key都弱引用指向threadlocal。当把threadlocal实例置为null以后，没有任何强引用指向threadlocal实例，所以threadlocal将会被gc回收。但是，我们的value却不能回收，因为存在一条从current thread连接过来的强引用。只有当前thread结束以后，current thread就不会存在栈中，强引用断开，Current Thread， Map，value将全部被GC回收。

[java]view plain copy 
   
 /* 
  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. 
  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  * 
  */  
   
 package java.lang;  
 import java.lang.ref.*;  
 import java.util.Objects;  
 import java.util.concurrent.atomic.AtomicInteger;  
 import java.util.function.Supplier;  
   
 /** 
  * This class provides thread-local variables.  These variables differ from 
  * their normal counterparts in that each thread that accesses one (via its 
  * {@code get} or {@code set} method) has its own, independently initialized 
  * copy of the variable.  {@code ThreadLocal} instances are typically private 
  * static fields in classes that wish to associate state with a thread (e.g., 
  * a user ID or Transaction ID). 
  * 
  * <p>For example, the class below generates unique identifiers local to each 
  * thread. 
  * A thread's id is assigned the first time it invokes {@code ThreadId.get()} 
  * and remains unchanged on subsequent calls. 
  * <pre> 
  * import java.util.concurrent.atomic.AtomicInteger; 
  * 
  * public class ThreadId { 
  *     // Atomic integer containing the next thread ID to be assigned 
  *     private static final AtomicInteger nextId = new AtomicInteger(0); 
  * 
  *     // Thread local variable containing each thread's ID 
  *     private static final ThreadLocal<Integer> threadId = 
  *         new ThreadLocal<Integer>() { 
  *             @Override protected Integer initialValue() { 
  *                 return nextId.getAndIncrement(); 
  *         } 
  *     }; 
  * 
  *     // Returns the current thread's unique ID, assigning it if necessary 
  *     public static int get() { 
  *         return threadId.get(); 
  *     } 
  * } 
  * </pre> 
  * <p>Each thread holds an implicit reference to its copy of a thread-local 
  * variable as long as the thread is alive and the {@code ThreadLocal} 
  * instance is accessible; after a thread goes away, all of its copies of 
  * thread-local instances are subject to garbage collection (unless other 
  * references to these copies exist). 
  * 
  * @author  Josh Bloch and Doug Lea 
  * @since   1.2 
  */  
 public class ThreadLocal<T> {  
     /** 
      * ThreadLocals rely on per-thread linear-probe hash maps attached 
      * to each thread (Thread.threadLocals and 
      * inheritableThreadLocals).  The ThreadLocal objects act as keys, 
      * searched via threadLocalHashCode.  This is a custom hash code 
      * (useful only within ThreadLocalMaps) that eliminates collisions 
      * in the common case where consecutively constructed ThreadLocals 
      * are used by the same threads, while remaining well-behaved in 
      * less common cases. 
      */  
     private final int threadLocalHashCode = nextHashCode();  
   
     /** 
      * The next hash code to be given out. Updated atomically. Starts at 
      * zero. 
      */  
     private static AtomicInteger nextHashCode =  
         new AtomicInteger();  
   
     /** 
      * The difference between successively generated hash codes - turns 
      * implicit sequential thread-local IDs into near-optimally spread 
      * multiplicative hash values for power-of-two-sized tables. 
      */  
     private static final int HASH_INCREMENT = 0x61c88647;  
   
     /** 
      * Returns the next hash code. 
      */  
     private static int nextHashCode() {  
         return nextHashCode.getAndAdd(HASH_INCREMENT);  
     }  
   
     /** 
      * Returns the current thread's "initial value" for this 
      * thread-local variable.  This method will be invoked the first 
      * time a thread accesses the variable with the {@link #get} 
      * method, unless the thread previously invoked the {@link #set} 
      * method, in which case the {@code initialValue} method will not 
      * be invoked for the thread.  Normally, this method is invoked at 
      * most once per thread, but it may be invoked again in case of 
      * subsequent invocations of {@link #remove} followed by {@link #get}. 
      * 
      * <p>This implementation simply returns {@code null}; if the 
      * programmer desires thread-local variables to have an initial 
      * value other than {@code null}, {@code ThreadLocal} must be 
      * subclassed, and this method overridden.  Typically, an 
      * anonymous inner class will be used. 
      * 
      * @return the initial value for this thread-local 
      */  
     protected T initialValue() {  
         return null;  
     }  
   
     /** 
      * Creates a thread local variable. The initial value of the variable is 
      * determined by invoking the {@code get} method on the {@code Supplier}. 
      * 
      * @param <S> the type of the thread local's value 
      * @param supplier the supplier to be used to determine the initial value 
      * @return a new thread local variable 
      * @throws NullPointerException if the specified supplier is null 
      * @since 1.8 
      */  
     public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {  
         return new SuppliedThreadLocal<>(supplier);  
     }  
   
     /** 
      * Creates a thread local variable. 
      * @see #withInitial(java.util.function.Supplier) 
      */  
     public ThreadLocal() {  
     }  
   
     /** 
      * Returns the value in the current thread's copy of this 
      * thread-local variable.  If the variable has no value for the 
      * current thread, it is first initialized to the value returned 
      * by an invocation of the {@link #initialValue} method. 
      * 
      * @return the current thread's value of this thread-local 
      */  
     public T get() {  
         Thread t = Thread.currentThread();  
         ThreadLocalMap map = getMap(t);  
         if (map != null) {  
             ThreadLocalMap.Entry e = map.getEntry(this);  
             if (e != null) {  
                 @SuppressWarnings("unchecked")  
                 T result = (T)e.value;  
                 return result;  
             }  
         }  
         return setInitialValue();  
     }  
   
     /** 
      * Variant of set() to establish initialValue. Used instead 
      * of set() in case user has overridden the set() method. 
      * 
      * @return the initial value 
      */  
     private T setInitialValue() {  
         T value = initialValue();  
         Thread t = Thread.currentThread();  
         ThreadLocalMap map = getMap(t);  
         if (map != null)  
             map.set(this, value);  
         else  
             createMap(t, value);  
         return value;  
     }  
   
     /** 
      * Sets the current thread's copy of this thread-local variable 
      * to the specified value.  Most subclasses will have no need to 
      * override this method, relying solely on the {@link #initialValue} 
      * method to set the values of thread-locals. 
      * 
      * @param value the value to be stored in the current thread's copy of 
      *        this thread-local. 
      */  
     public void set(T value) {  
         Thread t = Thread.currentThread();  
         ThreadLocalMap map = getMap(t);  
         if (map != null)  
             map.set(this, value);  
         else  
             createMap(t, value);  
     }  
   
     /** 
      * Removes the current thread's value for this thread-local 
      * variable.  If this thread-local variable is subsequently 
      * {@linkplain #get read} by the current thread, its value will be 
      * reinitialized by invoking its {@link #initialValue} method, 
      * unless its value is {@linkplain #set set} by the current thread 
      * in the interim.  This may result in multiple invocations of the 
      * {@code initialValue} method in the current thread. 
      * 
      * @since 1.5 
      */  
      public void remove() {  
          ThreadLocalMap m = getMap(Thread.currentThread());  
          if (m != null)  
              m.remove(this);  
      }  
   
     /** 
      * Get the map associated with a ThreadLocal. Overridden in 
      * InheritableThreadLocal. 
      * 
      * @param  t the current thread 
      * @return the map 
      */  
     ThreadLocalMap getMap(Thread t) {  
         return t.threadLocals;  
     }  
   
     /** 
      * Create the map associated with a ThreadLocal. Overridden in 
      * InheritableThreadLocal. 
      * 
      * @param t the current thread 
      * @param firstValue value for the initial entry of the map 
      */  
     void createMap(Thread t, T firstValue) {  
         t.threadLocals = new ThreadLocalMap(this, firstValue);  
     }  
   
     /** 
      * Factory method to create map of inherited thread locals. 
      * Designed to be called only from Thread constructor. 
      * 
      * @param  parentMap the map associated with parent thread 
      * @return a map containing the parent's inheritable bindings 
      */  
     static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {  
         return new ThreadLocalMap(parentMap);  
     }  
   
     /** 
      * Method childValue is visibly defined in subclass 
      * InheritableThreadLocal, but is internally defined here for the 
      * sake of providing createInheritedMap factory method without 
      * needing to subclass the map class in InheritableThreadLocal. 
      * This technique is preferable to the alternative of embedding 
      * instanceof tests in methods. 
      */  
     T childValue(T parentValue) {  
         throw new UnsupportedOperationException();  
     }  
   
     /** 
      * An extension of ThreadLocal that obtains its initial value from 
      * the specified {@code Supplier}. 
      */  
     static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {  
   
         private final Supplier<? extends T> supplier;  
   
         SuppliedThreadLocal(Supplier<? extends T> supplier) {  
             this.supplier = Objects.requireNonNull(supplier);  
         }  
   
         @Override  
         protected T initialValue() {  
             return supplier.get();  
         }  
     }  
   
     /** 
      * ThreadLocalMap is a customized hash map suitable only for 
      * maintaining thread local values. No operations are exported 
      * outside of the ThreadLocal class. The class is package private to 
      * allow declaration of fields in class Thread.  To help deal with 
      * very large and long-lived usages, the hash table entries use 
      * WeakReferences for keys. However, since reference queues are not 
      * used, stale entries are guaranteed to be removed only when 
      * the table starts running out of space. 
      */  
     static class ThreadLocalMap {  
   
         /** 
          * The entries in this hash map extend WeakReference, using 
          * its main ref field as the key (which is always a 
          * ThreadLocal object).  Note that null keys (i.e. entry.get() 
          * == null) mean that the key is no longer referenced, so the 
          * entry can be expunged from table.  Such entries are referred to 
          * as "stale entries" in the code that follows. 
          */  
         static class Entry extends WeakReference<ThreadLocal<?>> {  
             /** The value associated with this ThreadLocal. */  
             Object value;  
   
             Entry(ThreadLocal<?> k, Object v) {  
                 super(k);  
                 value = v;  
             }  
         }  
   
         /** 
          * The initial capacity -- MUST be a power of two. 
          */  
         private static final int INITIAL_CAPACITY = 16;  
   
         /** 
          * The table, resized as necessary. 
          * table.length MUST always be a power of two. 
          */  
         private Entry[] table;  
   
         /** 
          * The number of entries in the table. 
          */  
         private int size = 0;  
   
         /** 
          * The next size value at which to resize. 
          */  
         private int threshold; // Default to 0  
   
         /** 
          * Set the resize threshold to maintain at worst a 2/3 load factor. 
          */  
         private void setThreshold(int len) {  
             threshold = len * 2 / 3;  
         }  
   
         /** 
          * Increment i modulo len. 
          */  
         private static int nextIndex(int i, int len) {  
             return ((i + 1 < len) ? i + 1 : 0);  
         }  
   
         /** 
          * Decrement i modulo len. 
          */  
         private static int prevIndex(int i, int len) {  
             return ((i - 1 >= 0) ? i - 1 : len - 1);  
         }  
   
         /** 
          * Construct a new map initially containing (firstKey, firstValue). 
          * ThreadLocalMaps are constructed lazily, so we only create 
          * one when we have at least one entry to put in it. 
          */  
         ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {  
             table = new Entry[INITIAL_CAPACITY];  
             int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);  
             table[i] = new Entry(firstKey, firstValue);  
             size = 1;  
             setThreshold(INITIAL_CAPACITY);  
         }  
   
         /** 
          * Construct a new map including all Inheritable ThreadLocals 
          * from given parent map. Called only by createInheritedMap. 
          * 
          * @param parentMap the map associated with parent thread. 
          */  
         private ThreadLocalMap(ThreadLocalMap parentMap) {  
             Entry[] parentTable = parentMap.table;  
             int len = parentTable.length;  
             setThreshold(len);  
             table = new Entry[len];  
   
             for (int j = 0; j < len; j++) {  
                 Entry e = parentTable[j];  
                 if (e != null) {  
                     @SuppressWarnings("unchecked")  
                     ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();  
                     if (key != null) {  
                         Object value = key.childValue(e.value);  
                         Entry c = new Entry(key, value);  
                         int h = key.threadLocalHashCode & (len - 1);  
                         while (table[h] != null)  
                             h = nextIndex(h, len);  
                         table[h] = c;  
                         size++;  
                     }  
                 }  
             }  
         }  
   
         /** 
          * Get the entry associated with key.  This method 
          * itself handles only the fast path: a direct hit of existing 
          * key. It otherwise relays to getEntryAfterMiss.  This is 
          * designed to maximize performance for direct hits, in part 
          * by making this method readily inlinable. 
          * 
          * @param  key the thread local object 
          * @return the entry associated with key, or null if no such 
          */  
         private Entry getEntry(ThreadLocal<?> key) {  
             int i = key.threadLocalHashCode & (table.length - 1);  
             Entry e = table[i];  
             if (e != null && e.get() == key)  
                 return e;  
             else  
                 return getEntryAfterMiss(key, i, e);  
         }  
   
         /** 
          * Version of getEntry method for use when key is not found in 
          * its direct hash slot. 
          * 
          * @param  key the thread local object 
          * @param  i the table index for key's hash code 
          * @param  e the entry at table[i] 
          * @return the entry associated with key, or null if no such 
          */  
         private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {  
             Entry[] tab = table;  
             int len = tab.length;  
   
             while (e != null) {  
                 ThreadLocal<?> k = e.get();  
                 if (k == key)  
                     return e;  
                 if (k == null)  
                     expungeStaleEntry(i);  
                 else  
                     i = nextIndex(i, len);  
                 e = tab[i];  
             }  
             return null;  
         }  
   
         /** 
          * Set the value associated with key. 
          * 
          * @param key the thread local object 
          * @param value the value to be set 
          */  
         private void set(ThreadLocal<?> key, Object value) {  
   
             // We don't use a fast path as with get() because it is at  
             // least as common to use set() to create new entries as  
             // it is to replace existing ones, in which case, a fast  
             // path would fail more often than not.  
   
             Entry[] tab = table;  
             int len = tab.length;  
             int i = key.threadLocalHashCode & (len-1);  
   
             for (Entry e = tab[i];  
                  e != null;  
                  e = tab[i = nextIndex(i, len)]) {  
                 ThreadLocal<?> k = e.get();  
   
                 if (k == key) {  
                     e.value = value;  
                     return;  
                 }  
   
                 if (k == null) {  
                     replaceStaleEntry(key, value, i);  
                     return;  
                 }  
             }  
   
             tab[i] = new Entry(key, value);  
             int sz = ++size;  
             if (!cleanSomeSlots(i, sz) && sz >= threshold)  
                 rehash();  
         }  
   
         /** 
          * Remove the entry for key. 
          */  
         private void remove(ThreadLocal<?> key) {  
             Entry[] tab = table;  
             int len = tab.length;  
             int i = key.threadLocalHashCode & (len-1);  
             for (Entry e = tab[i];  
                  e != null;  
                  e = tab[i = nextIndex(i, len)]) {  
                 if (e.get() == key) {  
                     e.clear();  
                     expungeStaleEntry(i);  
                     return;  
                 }  
             }  
         }  
   
         /** 
          * Replace a stale entry encountered during a set operation 
          * with an entry for the specified key.  The value passed in 
          * the value parameter is stored in the entry, whether or not 
          * an entry already exists for the specified key. 
          * 
          * As a side effect, this method expunges all stale entries in the 
          * "run" containing the stale entry.  (A run is a sequence of entries 
          * between two null slots.) 
          * 
          * @param  key the key 
          * @param  value the value to be associated with key 
          * @param  staleSlot index of the first stale entry encountered while 
          *         searching for key. 
          */  
         private void replaceStaleEntry(ThreadLocal<?> key, Object value,  
                                        int staleSlot) {  
             Entry[] tab = table;  
             int len = tab.length;  
             Entry e;  
   
             // Back up to check for prior stale entry in current run.  
             // We clean out whole runs at a time to avoid continual  
             // incremental rehashing due to garbage collector freeing  
             // up refs in bunches (i.e., whenever the collector runs).  
             int slotToExpunge = staleSlot;  
             for (int i = prevIndex(staleSlot, len);  
                  (e = tab[i]) != null;  
                  i = prevIndex(i, len))  
                 if (e.get() == null)  
                     slotToExpunge = i;  
   
             // Find either the key or trailing null slot of run, whichever  
             // occurs first  
             for (int i = nextIndex(staleSlot, len);  
                  (e = tab[i]) != null;  
                  i = nextIndex(i, len)) {  
                 ThreadLocal<?> k = e.get();  
   
                 // If we find key, then we need to swap it  
                 // with the stale entry to maintain hash table order.  
                 // The newly stale slot, or any other stale slot  
                 // encountered above it, can then be sent to expungeStaleEntry  
                 // to remove or rehash all of the other entries in run.  
                 if (k == key) {  
                     e.value = value;  
   
                     tab[i] = tab[staleSlot];  
                     tab[staleSlot] = e;  
   
                     // Start expunge at preceding stale entry if it exists  
                     if (slotToExpunge == staleSlot)  
                         slotToExpunge = i;  
                     cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);  
                     return;  
                 }  
   
                 // If we didn't find stale entry on backward scan, the  
                 // first stale entry seen while scanning for key is the  
                 // first still present in the run.  
                 if (k == null && slotToExpunge == staleSlot)  
                     slotToExpunge = i;  
             }  
   
             // If key not found, put new entry in stale slot  
             tab[staleSlot].value = null;  
             tab[staleSlot] = new Entry(key, value);  
   
             // If there are any other stale entries in run, expunge them  
             if (slotToExpunge != staleSlot)  
                 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);  
         }  
   
         /** 
          * Expunge a stale entry by rehashing any possibly colliding entries 
          * lying between staleSlot and the next null slot.  This also expunges 
          * any other stale entries encountered before the trailing null.  See 
          * Knuth, Section 6.4 
          * 
          * @param staleSlot index of slot known to have null key 
          * @return the index of the next null slot after staleSlot 
          * (all between staleSlot and this slot will have been checked 
          * for expunging). 
          */  
         private int expungeStaleEntry(int staleSlot) {  
             Entry[] tab = table;  
             int len = tab.length;  
   
             // expunge entry at staleSlot  
             tab[staleSlot].value = null;  
             tab[staleSlot] = null;  
             size--;  
   
             // Rehash until we encounter null  
             Entry e;  
             int i;  
             for (i = nextIndex(staleSlot, len);  
                  (e = tab[i]) != null;  
                  i = nextIndex(i, len)) {  
                 ThreadLocal<?> k = e.get();  
                 if (k == null) {  
                     e.value = null;  
                     tab[i] = null;  
                     size--;  
                 } else {  
                     int h = k.threadLocalHashCode & (len - 1);  
                     if (h != i) {  
                         tab[i] = null;  
   
                         // Unlike Knuth 6.4 Algorithm R, we must scan until  
                         // null because multiple entries could have been stale.  
                         while (tab[h] != null)  
                             h = nextIndex(h, len);  
                         tab[h] = e;  
                     }  
                 }  
             }  
             return i;  
         }  
   
         /** 
          * Heuristically scan some cells looking for stale entries. 
          * This is invoked when either a new element is added, or 
          * another stale one has been expunged. It performs a 
          * logarithmic number of scans, as a balance between no 
          * scanning (fast but retains garbage) and a number of scans 
          * proportional to number of elements, that would find all 
          * garbage but would cause some insertions to take O(n) time. 
          * 
          * @param i a position known NOT to hold a stale entry. The 
          * scan starts at the element after i. 
          * 
          * @param n scan control: {@code log2(n)} cells are scanned, 
          * unless a stale entry is found, in which case 
          * {@code log2(table.length)-1} additional cells are scanned. 
          * When called from insertions, this parameter is the number 
          * of elements, but when from replaceStaleEntry, it is the 
          * table length. (Note: all this could be changed to be either 
          * more or less aggressive by weighting n instead of just 
          * using straight log n. But this version is simple, fast, and 
          * seems to work well.) 
          * 
          * @return true if any stale entries have been removed. 
          */  
         private boolean cleanSomeSlots(int i, int n) {  
             boolean removed = false;  
             Entry[] tab = table;  
             int len = tab.length;  
             do {  
                 i = nextIndex(i, len);  
                 Entry e = tab[i];  
                 if (e != null && e.get() == null) {  
                     n = len;  
                     removed = true;  
                     i = expungeStaleEntry(i);  
                 }  
             } while ( (n >>>= 1) != 0);  
             return removed;  
         }  
   
         /** 
          * Re-pack and/or re-size the table. First scan the entire 
          * table removing stale entries. If this doesn't sufficiently 
          * shrink the size of the table, double the table size. 
          */  
         private void rehash() {  
             expungeStaleEntries();  
   
             // Use lower threshold for doubling to avoid hysteresis  
             if (size >= threshold - threshold / 4)  
                 resize();  
         }  
   
         /** 
          * Double the capacity of the table. 
          */  
         private void resize() {  
             Entry[] oldTab = table;  
             int oldLen = oldTab.length;  
             int newLen = oldLen * 2;  
             Entry[] newTab = new Entry[newLen];  
             int count = 0;  
   
             for (int j = 0; j < oldLen; ++j) {  
                 Entry e = oldTab[j];  
                 if (e != null) {  
                     ThreadLocal<?> k = e.get();  
                     if (k == null) {  
                         e.value = null; // Help the GC  
                     } else {  
                         int h = k.threadLocalHashCode & (newLen - 1);  
                         while (newTab[h] != null)  
                             h = nextIndex(h, newLen);  
                         newTab[h] = e;  
                         count++;  
                     }  
                 }  
             }  
   
             setThreshold(newLen);  
             size = count;  
             table = newTab;  
         }  
   
         /** 
          * Expunge all stale entries in the table. 
          */  
         private void expungeStaleEntries() {  
             Entry[] tab = table;  
             int len = tab.length;  
             for (int j = 0; j < len; j++) {  
                 Entry e = tab[j];  
                 if (e != null && e.get() == null)  
                     expungeStaleEntry(j);  
             }  
         }  
     }  
 }  