diff -r c1e76ee31360 -r 8ed05565a481 rt/emul/compact/src/main/java/java/lang/ThreadLocal.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/rt/emul/compact/src/main/java/java/lang/ThreadLocal.java Thu Sep 12 12:26:23 2013 +0200 @@ -0,0 +1,157 @@ +/* + * Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +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 Josh Bloch and Doug Lea
+ * @since 1.2
+ */
+public class ThreadLocal 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.
+ *
+ * @return the initial value for this thread-local
+ */
+ protected T initialValue() {
+ return null;
+ }
+
+ /**
+ * Creates a thread local variable.
+ */
+ 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() {
+ if (value == NONE) {
+ return setInitialValue();
+ } else {
+ return (T)value;
+ }
+ }
+
+ /**
+ * 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 v = initialValue();
+ this.value = v;
+ return v;
+ }
+
+ /**
+ * 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) {
+ this.value = 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
+ * initialValue method in the current thread.
+ *
+ * @since 1.5
+ */
+ public void remove() {
+ this.value = NONE;
+ }
+}