Java代碼

1. private static final ThreadLocal threadSession = new ThreadLocal();   
2.   
3. public static Session getSession() throws InfrastructureException {   
4.     Session s = (Session) threadSession.get();   
5.     try {   
6.         if (s == null) {   
7.             s = getSessionFactory().openSession();   
8.             threadSession.set(s);   
9.         }   
10.     } catch (HibernateException ex) {   
11.         throw new InfrastructureException(ex);   
12.     }   
13.     return s;   
14. }  

    private static final ThreadLocal threadSession = new ThreadLocal();
public static Session getSession() throws InfrastructureException {
Session s = (Session) threadSession.get();
try {
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
}

Java代碼

1. public class ThreadLocal<T> {   
2.     /**  
3.      * ThreadLocals rely on per-thread hash maps attached to each thread  
4.      * (Thread.threadLocals and inheritableThreadLocals).  The ThreadLocal  
5.      * objects act as keys, searched via threadLocalHashCode.  This is a  
6.      * custom hash code (useful only within ThreadLocalMaps) that eliminates  
7.      * collisions in the common case where consecutively constructed  
8.      * ThreadLocals are used by the same threads, while remaining well-behaved  
9.      * in less common cases.  
10.      */  
11.     private final int threadLocalHashCode = nextHashCode();   
12.   
13.     /**  
14.      * The next hash code to be given out. Accessed only by like-named method.  
15.      */  
16.     private static int nextHashCode = 0;   
17.   
18.     /**  
19.      * The difference between successively generated hash codes - turns  
20.      * implicit sequential thread-local IDs into near-optimally spread  
21.      * multiplicative hash values for power-of-two-sized tables.  
22.      */  
23.     private static final int HASH_INCREMENT = 0x61c88647;   
24.   
25.     /**  
26.      * Compute the next hash code. The static synchronization used here  
27.      * should not be a performance bottleneck. When ThreadLocals are  
28.      * generated in different threads at a fast enough rate to regularly  
29.      * contend on this lock, memory contention is by far a more serious  
30.      * problem than lock contention.  
31.      */  
32.     private static synchronized int nextHashCode() {   
33.         int h = nextHashCode;   
34.         nextHashCode = h + HASH_INCREMENT;   
35.         return h;   
36.     }   
37.   
38.     /**  
39.      * Creates a thread local variable.  
40.      */  
41.     public ThreadLocal() {   
42.     }   
43.   
44.     /**  
45.      * Returns the value in the current thread's copy of this thread-local  
46.      * variable.  Creates and initializes the copy if this is the first time  
47.      * the thread has called this method.  
48.      *  
49.      * @return the current thread's value of this thread-local  
50.      */  
51.     public T get() {   
52.         Thread t = Thread.currentThread();   
53.         ThreadLocalMap map = getMap(t);   
54.         if (map != null)   
55.             return (T)map.get(this);   
56.   
57.         // Maps are constructed lazily.  if the map for this thread   
58.         // doesn't exist, create it, with this ThreadLocal and its   
59.         // initial value as its only entry.   
60.         T value = initialValue();   
61.         createMap(t, value);   
62.         return value;   
63.     }   
64.   
65.     /**  
66.      * Sets the current thread's copy of this thread-local variable  
67.      * to the specified value.  Many applications will have no need for  
68.      * this functionality, relying solely on the {@link #initialValue}  
69.      * method to set the values of thread-locals.  
70.      *  
71.      * @param value the value to be stored in the current threads' copy of  
72.      *        this thread-local.  
73.      */  
74.     public void set(T value) {   
75.         Thread t = Thread.currentThread();   
76.         ThreadLocalMap map = getMap(t);   
77.         if (map != null)   
78.             map.set(this, value);   
79.         else  
80.             createMap(t, value);   
81.     }   
82.   
83.     /**  
84.      * Get the map associated with a ThreadLocal. Overridden in  
85.      * InheritableThreadLocal.  
86.      *  
87.      * @param  t the current thread  
88.      * @return the map  
89.      */  
90.     ThreadLocalMap getMap(Thread t) {   
91.         return t.threadLocals;   
92.     }   
93.   
94.     /**  
95.      * Create the map associated with a ThreadLocal. Overridden in  
96.      * InheritableThreadLocal.  
97.      *  
98.      * @param t the current thread  
99.      * @param firstValue value for the initial entry of the map  
100.      * @param map the map to store.  
101.      */  
102.     void createMap(Thread t, T firstValue) {   
103.         t.threadLocals = new ThreadLocalMap(this, firstValue);   
104.     }   
105.   
106.     .......   
107.   
108.     /**  
109.      * ThreadLocalMap is a customized hash map suitable only for  
110.      * maintaining thread local values. No operations are exported  
111.      * outside of the ThreadLocal class. The class is package private to  
112.      * allow declaration of fields in class Thread.  To help deal with  
113.      * very large and long-lived usages, the hash table entries use  
114.      * WeakReferences for keys. However, since reference queues are not  
115.      * used, stale entries are guaranteed to be removed only when  
116.      * the table starts running out of space.  
117.      */  
118.     static class ThreadLocalMap {   
119.   
120.     ........   
121.   
122.     }   
123.   
124. }  

public class ThreadLocal<T> {
/**
* ThreadLocals rely on per-thread 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. Accessed only by like-named method.
*/
private static int nextHashCode = 0;
/**
* 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;
/**
* Compute the next hash code. The static synchronization used here
* should not be a performance bottleneck. When ThreadLocals are
* generated in different threads at a fast enough rate to regularly
* contend on this lock, memory contention is by far a more serious
* problem than lock contention.
*/
private static synchronized int nextHashCode() {
int h = nextHashCode;
nextHashCode = h + HASH_INCREMENT;
return h;
}
/**
* Creates a thread local variable.
*/
public ThreadLocal() {
}
/**
* Returns the value in the current thread's copy of this thread-local
* variable.  Creates and initializes the copy if this is the first time
* the thread has called this 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)
return (T)map.get(this);
// Maps are constructed lazily.  if the map for this thread
// doesn't exist, create it, with this ThreadLocal and its
// initial value as its only entry.
T value = initialValue();
createMap(t, value);
return value;
}
/**
* Sets the current thread's copy of this thread-local variable
* to the specified value.  Many applications will have no need for
* this functionality, relying solely on the {@link #initialValue}
* method to set the values of thread-locals.
*
* @param value the value to be stored in the current threads' 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);
}
/**
* 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
* @param map the map to store.
*/
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
.......
/**
* 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 {
........
}
}

Java代碼

1. private final int threadLocalHashCode = nextHashCode();   
2. private static int nextHashCode = 0;   
3. private static final int HASH_INCREMENT = 0x61c88647;  

    private final int threadLocalHashCode = nextHashCode();
private static int nextHashCode = 0;
private static final int HASH_INCREMENT = 0x61c88647;

Java代碼

1. private final int threadLocalHashCode = nextHashCode();  

    private final int threadLocalHashCode = nextHashCode();

Java代碼

1. private static synchronized int nextHashCode() {   
2.     int h = nextHashCode;   
3.     nextHashCode = h + HASH_INCREMENT;   
4.     return h;   
5. }  

    private static synchronized int nextHashCode() {
int h = nextHashCode;
nextHashCode = h + HASH_INCREMENT;
return h;
}

Java代碼

1. ThreadLocalMap map = Thread.currentThread().threadLocals;  

        ThreadLocalMap map = Thread.currentThread().threadLocals;

Java代碼

1. public class Thread implements Runnable {   
2.     ......   
3.   
4.     /* ThreadLocal values pertaining to this thread. This map is maintained  
5.      * by the ThreadLocal class. */  
6.     ThreadLocal.ThreadLocalMap threadLocals = null;     
7.     ......   
8. }  

public class Thread implements Runnable {
......
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
......
}

Java代碼

1. if (map != null)   
2.     map.set(this, value);  

        if (map != null)
map.set(this, value);