Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Hidden Features of Java
After reading Hidden Features of C# I wondered, What are some of the hidden features of Java?
2. When and how should I use a ThreadLocal variable?
When should I use a ThreadLocal variable? How is it used?
3. What is a good way to pass useful state information to an exception in Java?
I noticed some confusion initially with my question. I'm not asking about how to configure a logger nor how to use a logger properly, but rather how to capture all of the information that would have been logged at a lower logging level than what the current logging level is in the exception message. I have been noticing two patterns in Java for logging information that may be useful to a devel...
4. What are the advantages of instance-level thread-local storage?
This question led me to wonder about thread-local storage in high-level development frameworks like Java and .NET. Java has a ThreadLocal<T> class (and perhaps other constructs), while .NET has data slots, and soon a ThreadLocal<T> class of its own. (It also has the ThreadStaticAttribute, but I'm particularly interested in thread-local storage for member data.) Most other modern de...
5. Hibernate + Swing
What's the best practice? A single session for the whole app A session per window A session per thread, and detaching everything at random Something else? I've googled around, and there's no consensus. Everyone says something, and then takes it back. I find lugging a session around stupid... So, what's the deal?
6. Uses of ThreadLocal
What is the typical use of ThreadLocal in java. When does one use it? I couldn't application details from this java docs article.
7. JSF initialize application-scope bean when context initialized
I'm building a JSF+Facelets web app, one piece of which is a method that scans a directory every so often and indexes any changes. This method is part of a bean which is in application scope. I have built a subclass of TimerTask to call the method every X milliseconds. My problem is getting the bean initialized. I can reference the bean on a page, and when I go to the page, the bean is init...
8. How does UserTransaction propagate?
I have a stateless bean with bean-managed transaction and a method like this: @Stateless @TransactionManagement(TransactionManagementType.BEAN) public class ... { @Resource private UserTransaction ut; @EJB private OtherStatelessBeanLocal other; public void invokeSomeMethods() ut.begin(); ... // invoke other bean's methods here. other.me...
9. Most interesting/useful Java classes?
I've been using Java for a year or so now, and I constantly find myself discovering new things in the language. Most of this cool stuff, interestingly enough, doesn't come from 3rd-party APIs or libraries, but rather from the classes that ship in the JDK. So I'm wondering, partly out of curiosity and partly for the education of others and myself, what classes that come in the JDK are the most ...
10. Is it possible to use Seam in a JBoss timed service?
I've started to write some new JBoss timed service that was meant to use some existing seam components. But it seems that I can't access these components because of non-existing contexts. Is it possible to use them other than in the typical situation with JSF? A little snippet to demonstrate what I want to do... @Service public class MyService extends DefaultTimedService implements TimedObjec...
11. Purpose of ThreadLocal?
Possible duplicate: When and how should I use a Threadlocal variable The purpose of ThreadLocal as given here states that the variable is local to any Thread accessing an object containing the ThreadLocal variable. What difference does it make, in having a ThreadLocal variable as a member of a class and then making it local to a Thread, rather than having a local variable to the Thread itself?
12. Get unique identifier of a Thread in Java 1.4
In Java 1.4, is there any better way of getting a Thread's ID than using Thread.getName()? I mean, getName() in unit tests returns something like "Thread-1", but in WebLogic 10 I get "[ACTIVE] ExecuteThread: '1' for queue: 'weblogic.kernel.Default (self-tuning)'.xml".
13. Why should Java ThreadLocal variables be static
I was reading that JavaDoc for Threadlocal here http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ThreadLocal.html and it says "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). " But my question is why did they choose to make it static (typically) - it makes it a bit confusing to have "per thr...
14. ThreadLocal Resource Leak and WeakReference
My limited understanding of ThreadLocal is that it has resource leak issues. I gather this problem can be remedied through proper use of WeakReferences with ThreadLocal (although I may have misunderstood this point.) I would simply like a pattern or example for correctly using ThreadLocal with WeakReference, if one exists. For instance, in this code snippet where would the WeakReference be int...
15. Synchronizing on SimpleDateFormat vs. clone
We know that the dateformat classes are not thread safe. I have a multi-threaded scenario where dateformats needs to be used. I can't really create a new instance in new thread as SimpledateFormat creation seems to be expensive(the constructor ends up calling "compile" which is costly). After some tests the only two options left for me are: External Synchronization - I really dont want to do...
16. Splitting log4j Output with Quartz Worker Threads
I'm working on an application that consists of an overall Quartz-based scheduler and "CycledJob" run using CronTriggers. The purpose of the application is to process inputs from different email inboxes based on the source country. Based on the country that it comes in from (i.e. US, UK, FR, etc.) the application triggers one job thread to run each country's processing cycle, so there would be...
17. Logging activities in multithreaded applications
I have a layered application in Java which has a multi thread data access layer which is invoked from different points. A single call to this layer is likely to spawn several threads to parallelize requests to the DB. What I'm looking for is a logging tool that would allow me to define "activities" that are composed by various threads. Therefore, the same method in the data access layer shoul...
18. NoSuchMethodError with JSON-Lib and JDK 1.4
I've downloaded the supposedly latest JDK 1.3 compatible binary named json-lib-2.4-jdk13.jar and am getting the following error. Exception in thread "main" java.lang.NoSuchMethodError: java.lang.ThreadLocal: method remove()V not found at net.sf.json.AbstractJSON.removeInstance(AbstractJSON.java:221) I checked the JDK 1.4 API and noticed that remove method on a ThreadLocal is indeed unsup...
19. In Java, it's possible Singleton per thread?
Using threads, I have a principal class (SlaveCrawler) that instantiates three classes(Downloader, ContentAnalyzer, URLAnalyzer) that are dependent on each other. SlaveCrawler uses Downloader and URLAnalyzer Downloader uses ContentAnalyzer and URLAnalyzer ContentAnalyzer uses URLAnalyzer I want only one instance of each class. If I use Singleton, I can get this, but working with threads, I ...
20. Does a static variable takes only one memory location for all running threads?
Given that a static variable of a class takes only one memory location, is it shared by all threads of process? Or is one memory location for such a variable created for each of the running threads? Also, if all threads share the same memory location, how can we ensure mutual exclusion?
21. Get the HttpServletRequest (request) object from Java code
Hey guys, this is probably a very beginner level question. But I need to get hold of the request object in Java code. I can't pass this object down to my code for certain reasons. Is there any way I can say something like: getCurrentHTTPServletRequest? It is safe for me to assume that I am in a Servlet Context. 
1
  /*
2
   * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package java.lang;
This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable. 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).

For example, the class below generates unique identifiers local to each thread. A thread's id is assigned the first time it invokes ThreadId.get() and remains unchanged on subsequent calls. 

 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();
     }
 }

Each thread holds an implicit reference to its copy of a thread-local variable as long as the thread is alive and the 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(s):
Josh Bloch and Doug Lea
Since:
1.2
71
 
72
 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. 
82
 
83
     private final int threadLocalHashCode = nextHashCode();

    
The next hash code to be given out. Updated atomically. Starts at zero. 
88
 
89
     private static AtomicInteger nextHashCode =
90
         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. 
96
 
97
     private static final int HASH_INCREMENT = 0x61c88647;

    
Returns the next hash code. 
102
    private static int nextHashCode() {
103
        return .getAndAdd();
104
    }

    
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 get() method, unless the thread previously invoked the set(java.lang.Object) method, in which case the 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 remove() followed by get().

This implementation simply returns null; if the programmer desires thread-local variables to have an initial value other than null, ThreadLocal must be subclassed, and this method overridden. Typically, an anonymous inner class will be used.

Returns:
the initial value for this thread-local
124
    protected T initialValue() {
125
        return null;
126
    }

    
Creates a thread local variable. 
131
    public ThreadLocal() {
132
    }

    
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 initialValue() method.

Returns:
the current thread's value of this thread-local
142
    public T get() {
143
        Thread t = Thread.currentThread();
144
        ThreadLocalMap map = getMap(t);
145
        if (map != null) {
146
            ThreadLocalMap.Entry e = map.getEntry(this);
147
            if (e != null)
148
                return (T)e.value;
149
        }
150
        return setInitialValue();
151
    }

    
Variant of set() to establish initialValue. Used instead of set() in case user has overridden the set() method.

Returns:
the initial value
159
    private T setInitialValue() {
160
        T value = initialValue();
161
        Thread t = Thread.currentThread();
162
        ThreadLocalMap map = getMap(t);
163
        if (map != null)
164
            map.set(this, value);
165
        else
166
            createMap(t, value);
167
        return value;
168
    }

    
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 initialValue() method to set the values of thread-locals.

Parameters:
value the value to be stored in the current thread's copy of this thread-local.
179
    public void set(T value) {
180
        Thread t = Thread.currentThread();
181
        ThreadLocalMap map = getMap(t);
182
        if (map != null)
183
            map.set(this, value);
184
        else
185
            createMap(t, value);
186
    }

    
Removes the current thread's value for this thread-local variable. If this thread-local variable is subsequently read by the current thread, its value will be reinitialized by invoking its initialValue() method, unless its value is set by the current thread in the interim. This may result in multiple invocations of the initialValue method in the current thread.

Since:
1.5
199
     public void remove() {
200
         ThreadLocalMap m = getMap(Thread.currentThread());
201
         if (m != null)
202
             m.remove(this);
203
     }

    
Get the map associated with a ThreadLocal. Overridden in InheritableThreadLocal.

Parameters:
t the current thread
Returns:
the map
213
        return t.threadLocals;
214
    }

    
Create the map associated with a ThreadLocal. Overridden in InheritableThreadLocal.

Parameters:
t the current thread
firstValue value for the initial entry of the map
map the map to store.
224
    void createMap(Thread t, T firstValue) {
225
        t.threadLocals = new ThreadLocalMap(this, firstValue);
226
    }

    
Factory method to create map of inherited thread locals. Designed to be called only from Thread constructor.

Parameters:
parentMap the map associated with parent thread
Returns:
a map containing the parent's inheritable bindings
235
    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
236
        return new ThreadLocalMap(parentMap);
237
    }

    
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. 
247
    T childValue(T parentValue) {
248
        throw new UnsupportedOperationException();
249
    }

    
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. 
261
    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. 
271
        static class Entry extends WeakReference<ThreadLocal> {
            
The value associated with this ThreadLocal.
273
            Object value;
275
            Entry(ThreadLocal k, Object v) {
276
                super(k);
277
                 = v;
278
            }
279
        }

        
The initial capacity -- MUST be a power of two. 
284
        private static final int INITIAL_CAPACITY = 16;

        
The table, resized as necessary. table.length MUST always be a power of two. 
290
        private Entry[] table;

        
The number of entries in the table. 
295
        private int size = 0;

        
The next size value at which to resize. 
300
        private int threshold; // Default to 0
301

        
Set the resize threshold to maintain at worst a 2/3 load factor. 
305
        private void setThreshold(int len) {
306
             = len * 2 / 3;
307
        }

        
Increment i modulo len. 
312
        private static int nextIndex(int i, int len) {
313
            return ((i + 1 < len) ? i + 1 : 0);
314
        }

        
Decrement i modulo len. 
319
        private static int prevIndex(int i, int len) {
320
            return ((i - 1 >= 0) ? i - 1 : len - 1);
321
        }

        
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. 
328
        ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
329
             = new Entry[];
330
            int i = firstKey.threadLocalHashCode & ( - 1);
331
            [i] = new Entry(firstKey, firstValue);
332
             = 1;
333
            setThreshold();
334
        }

        
Construct a new map including all Inheritable ThreadLocals from given parent map. Called only by createInheritedMap.

Parameters:
parentMap the map associated with parent thread.
342
        private ThreadLocalMap(ThreadLocalMap parentMap) {
343
            Entry[] parentTable = parentMap.table;
344
            int len = parentTable.length;
345
            setThreshold(len);
346
             = new Entry[len];
348
            for (int j = 0; j < len; j++) {
349
                Entry e = parentTable[j];
350
                if (e != null) {
351
                    ThreadLocal key = e.get();
352
                    if (key != null) {
353
                        Object value = key.childValue(e.value);
354
                        Entry c = new Entry(key, value);
355
                        int h = key.threadLocalHashCode & (len - 1);
356
                        while ([h] != null)
357
                            h = nextIndex(h, len);
358
                        [h] = c;
359
                        ++;
360
                    }
361
                }
362
            }
363
        }

        
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.

Parameters:
key the thread local object
Returns:
the entry associated with key, or null if no such
375
        private Entry getEntry(ThreadLocal key) {
376
            int i = key.threadLocalHashCode & (. - 1);
377
            Entry e = [i];
378
            if (e != null && e.get() == key)
379
                return e;
380
            else
381
                return getEntryAfterMiss(key, i, e);
382
        }

        
Version of getEntry method for use when key is not found in its direct hash slot.

Parameters:
key the thread local object
i the table index for key's hash code
e the entry at table[i]
Returns:
the entry associated with key, or null if no such
393
        private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
394
            Entry[] tab = ;
395
            int len = tab.length;
397
            while (e != null) {
398
                ThreadLocal k = e.get();
399
                if (k == key)
400
                    return e;
401
                if (k == null)
402
                    expungeStaleEntry(i);
403
                else
404
                    i = nextIndex(i, len);
405
                e = tab[i];
406
            }
407
            return null;
408
        }

        
Set the value associated with key.

Parameters:
key the thread local object
value the value to be set
416
        private void set(ThreadLocal key, Object value) {
418
            // We don't use a fast path as with get() because it is at
419
            // least as common to use set() to create new entries as
420
            // it is to replace existing ones, in which case, a fast
421
            // path would fail more often than not.
423
            Entry[] tab = ;
424
            int len = tab.length;
425
            int i = key.threadLocalHashCode & (len-1);
427
            for (Entry e = tab[i];
428
                 e != null;
429
                 e = tab[i = nextIndex(i, len)]) {
430
                ThreadLocal k = e.get();
432
                if (k == key) {
433
                    e.value = value;
434
                    return;
435
                }
437
                if (k == null) {
438
                    replaceStaleEntry(key, value, i);
439
                    return;
440
                }
441
            }
443
            tab[i] = new Entry(key, value);
444
            int sz = ++;
445
            if (!cleanSomeSlots(i, sz) && sz >= )
446
                rehash();
447
        }

        
Remove the entry for key. 
452
        private void remove(ThreadLocal key) {
453
            Entry[] tab = ;
454
            int len = tab.length;
455
            int i = key.threadLocalHashCode & (len-1);
456
            for (Entry e = tab[i];
457
                 e != null;
458
                 e = tab[i = nextIndex(i, len)]) {
459
                if (e.get() == key) {
460
                    e.clear();
461
                    expungeStaleEntry(i);
462
                    return;
463
                }
464
            }
465
        }

        
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.)

Parameters:
key the key
value the value to be associated with key
staleSlot index of the first stale entry encountered while searching for key.
482
        private void replaceStaleEntry(ThreadLocal key, Object value,
483
                                       int staleSlot) {
484
            Entry[] tab = ;
485
            int len = tab.length;
486
            Entry e;
488
            // Back up to check for prior stale entry in current run.
489
            // We clean out whole runs at a time to avoid continual
490
            // incremental rehashing due to garbage collector freeing
491
            // up refs in bunches (i.e., whenever the collector runs).
492
            int slotToExpunge = staleSlot;
493
            for (int i = prevIndex(staleSlot, len);
494
                 (e = tab[i]) != null;
495
                 i = prevIndex(i, len))
496
                if (e.get() == null)
497
                    slotToExpunge = i;
499
            // Find either the key or trailing null slot of run, whichever
500
            // occurs first
501
            for (int i = nextIndex(staleSlot, len);
502
                 (e = tab[i]) != null;
503
                 i = nextIndex(i, len)) {
504
                ThreadLocal k = e.get();
506
                // If we find key, then we need to swap it
507
                // with the stale entry to maintain hash table order.
508
                // The newly stale slot, or any other stale slot
509
                // encountered above it, can then be sent to expungeStaleEntry
510
                // to remove or rehash all of the other entries in run.
511
                if (k == key) {
512
                    e.value = value;
514
                    tab[i] = tab[staleSlot];
515
                    tab[staleSlot] = e;
517
                    // Start expunge at preceding stale entry if it exists
518
                    if (slotToExpunge == staleSlot)
519
                        slotToExpunge = i;
520
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
521
                    return;
522
                }
524
                // If we didn't find stale entry on backward scan, the
525
                // first stale entry seen while scanning for key is the
526
                // first still present in the run.
527
                if (k == null && slotToExpunge == staleSlot)
528
                    slotToExpunge = i;
529
            }
531
            // If key not found, put new entry in stale slot
532
            tab[staleSlot]. = null;
533
            tab[staleSlot] = new Entry(key, value);
535
            // If there are any other stale entries in run, expunge them
536
            if (slotToExpunge != staleSlot)
537
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
538
        }

        
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

Parameters:
staleSlot index of slot known to have null key
Returns:
the index of the next null slot after staleSlot (all between staleSlot and this slot will have been checked for expunging).
551
        private int expungeStaleEntry(int staleSlot) {
552
            Entry[] tab = ;
553
            int len = tab.length;
555
            // expunge entry at staleSlot
556
            tab[staleSlot]. = null;
557
            tab[staleSlot] = null;
558
            --;
560
            // Rehash until we encounter null
561
            Entry e;
562
            int i;
563
            for (i = nextIndex(staleSlot, len);
564
                 (e = tab[i]) != null;
565
                 i = nextIndex(i, len)) {
566
                ThreadLocal k = e.get();
567
                if (k == null) {
568
                    e.value = null;
569
                    tab[i] = null;
570
                    --;
571
                } else {
572
                    int h = k.threadLocalHashCode & (len - 1);
573
                    if (h != i) {
574
                        tab[i] = null;
576
                        // Unlike Knuth 6.4 Algorithm R, we must scan until
577
                        // null because multiple entries could have been stale.
578
                        while (tab[h] != null)
579
                            h = nextIndex(h, len);
580
                        tab[h] = e;
581
                    }
582
                }
583
            }
584
            return i;
585
        }

        
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.

Parameters:
i a position known NOT to hold a stale entry. The scan starts at the element after i.
n scan control: log2(n) cells are scanned, unless a stale entry is found, in which case 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.)
Returns:
true if any stale entries have been removed.
611
        private boolean cleanSomeSlots(int i, int n) {
612
            boolean removed = false;
613
            Entry[] tab = ;
614
            int len = tab.length;
615
            do {
616
                i = nextIndex(i, len);
617
                Entry e = tab[i];
618
                if (e != null && e.get() == null) {
619
                    n = len;
620
                    removed = true;
621
                    i = expungeStaleEntry(i);
622
                }
623
            } while ( (n >>>= 1) != 0);
624
            return removed;
625
        }

        
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. 
632
        private void rehash() {
633
            expungeStaleEntries();
635
            // Use lower threshold for doubling to avoid hysteresis
636
            if ( >=  -  / 4)
637
                resize();
638
        }

        
Double the capacity of the table. 
643
        private void resize() {
644
            Entry[] oldTab = ;
645
            int oldLen = oldTab.length;
646
            int newLen = oldLen * 2;
647
            Entry[] newTab = new Entry[newLen];
648
            int count = 0;
650
            for (int j = 0; j < oldLen; ++j) {
651
                Entry e = oldTab[j];
652
                if (e != null) {
653
                    ThreadLocal k = e.get();
654
                    if (k == null) {
655
                        e.value = null; // Help the GC
656
                    } else {
657
                        int h = k.threadLocalHashCode & (newLen - 1);
658
                        while (newTab[h] != null)
659
                            h = nextIndex(h, newLen);
660
                        newTab[h] = e;
661
                        count++;
662
                    }
663
                }
664
            }
666
            setThreshold(newLen);
667
             = count;
668
             = newTab;
669
        }

        
Expunge all stale entries in the table. 
674
        private void expungeStaleEntries() {
675
            Entry[] tab = ;
676
            int len = tab.length;
677
            for (int j = 0; j < len; j++) {
678
                Entry e = tab[j];
679
                if (e != null && e.get() == null)
680
                    expungeStaleEntry(j);
681
            }
682
        }
683
    }
New to GrepCode? Check out our FAQ X