Makefile.am: Added `java/lang/ThreadLocal.java'.

libjava:

2001-07-10  Alexandre Petit-Bianco  <apbianco@redhat.com>

        * Makefile.am: Added `java/lang/ThreadLocal.java'.
        * Makefile.in: Regenerate.
        * java/lang/ThreadLocal.java: Initial import.

libjava/testsuite:

2001-07-10  Alexandre Petit-Bianco  <apbianco@readhat.com>

        * libjava.lang/TLtest.java: New file.
        * libjava.lang/TLtest.out: New file.

(http://gcc.gnu.org/ml/java-patches/2001-q3/msg00042.html )

From-SVN: r43915

libjava/ChangeLog

@@ -1,3 +1,9 @@
+2001-07-10  Alexandre Petit-Bianco  <apbianco@redhat.com>
+
+	* Makefile.am: Added `java/lang/ThreadLocal.java'.
+	* Makefile.in: Regenerate.
+	* java/lang/ThreadLocal.java: Initial import.
+
 2001-07-07  Jeff Sturm  <jsturm@one-point.com
 	
 	* Makefile.am (libgcj.jar): Don't recursively make

libjava/Makefile.am

@@ -840,6 +840,7 @@ java/lang/System.java \
 java/lang/Thread.java \
 java/lang/ThreadDeath.java \
 java/lang/ThreadGroup.java \
+java/lang/ThreadLocal.java \
 java/lang/Throwable.java \
 java/lang/UnknownError.java \
 java/lang/UnsatisfiedLinkError.java \

libjava/java/lang/ThreadLocal.java

@@ -0,0 +1,165 @@
+/* java.lang.ThreadLocal
+   Copyright (C) 2000 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+package java.lang;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/**
+ * ThreadLocal objects have a different state associated with every
+ * Thread that accesses them. Every access to the ThreadLocal object
+ * (through the <code>get()</code> and <code>set()</code> methods)
+ * only affects the state of the object as seen by the currently
+ * executing Thread.
+ * <p>
+ * The first time a ThreadLocal object is accessed on a particular
+ * Thread (and no state is associated with that Thread yet)
+ * the state for that Thread is set by executing the method
+ * <code>initialValue()</code>.
+ * <p>
+ * An example how you can use this:
+ * <pre>
+ * class Connection {
+ *     private static ThreadLocal owner = new ThreadLocal() {
+ *        public Object initialValue() {
+ *            return("nobody");
+ *        }
+ *     };
+ * ...
+ * }
+ * </pre>
+ * Now all instances of connection can see who the owner of the currently
+ * executing Thread is by calling <code>owner.get()</code>. By default any
+ * Thread would be associated with 'nobody'. But the Connection object could
+ * offer a method that changes the owner associated with the Thread on
+ * which the method was called by calling <code>owner.put("somebody")</code>.
+ * (Such an owner changing method should then be guarded by security checks.)
+ * <p>
+ * When a Thread is garbage collected all references to values of
+ * the ThreadLocal objects associated with that Thread are removed.
+ *
+ * @since 1.2
+ * @author Mark Wielaard (mark@klomp.org)
+ */
+public class ThreadLocal {
+	
+	/**
+	 * Trivial container to wrap the stored values.
+	 * Needed to see if the value is null or not yet set.
+	 * If it is not yet set we must call intialValue() once.
+	 * Package local so InheritableThreadLocal can see it.
+	 */
+	final static class Value {
+		final Object value;
+		
+		Value(Object value) {
+			this.value = value;
+		}
+		
+		Object getValue() {
+			return value;
+		}
+	}
+	
+	/**
+	 * Maps Threads to Values. Uses a WeakHashMap so if a Thread is garbage
+	 * collected the reference to the Value will disappear. Only the
+	 * <code>set(Thread, Value)</code> and <code>get(Thread)</code> methods
+	 * access it. Since this can happen from multiple Threads simultaniously
+	 * those methods are synchronized.
+	 */
+	private final Map valueMap = new WeakHashMap();
+	
+	/**
+	 * Creates a ThreadLocal object without associating any value to it
+	 * yet.
+	 */
+	public ThreadLocal() {
+	}
+	
+	/**
+	 * Gets the value associated with the ThreadLocal object for the
+	 * currently executing Thread. If there is no value is associated
+	 * with this Thread yet then the valued returned by the
+	 * <code>initialValue()</code> method is assosiated with this Thread
+	 * and returned.
+	 */
+	public Object get() {
+		Thread currentThread = Thread.currentThread();
+		Value v = get(currentThread);
+		if (v == null) {
+			v = new Value(initialValue());
+			set(currentThread, v);
+		}
+		return v.getValue();
+	}
+	
+	/**
+	 * Gets the Value of this ThreadLocal for a particular Thread.
+	 * It is synchronized so the <code>set(Thread, Value)</code> method cannot
+	 * simultaniously modify the </code>valueMap</code> from another thread.
+	 * Package local so InheritableThreadLocal can access it when a new child
+	 * Thread inherits values from its parent Thread.
+	 */
+	synchronized final Value get(Thread thread) {
+		return (Value)valueMap.get(thread);
+	}
+	
+	/**
+	 * Sets the value associated with the ThreadLocal object for the
+	 * currently executing Thread. This overrides any existing value
+	 * associated with the current Thread and does not call the
+	 * <code>initialValue()</code> method, even if this is the first
+	 * time this Thread accesses this ThreadLocal.
+	 */
+	public void set(Object value) {
+		Thread currentThread = Thread.currentThread();
+		Value v = new Value(value);
+		set(currentThread, v);
+	}
+	
+	/**
+	 * Sets the Value for this ThreadLocal for a particular Thread.
+	 * It is synchronized so the <code>get(Thread)</code> method cannot
+	 * simultaniously read the </code>valueMap</code> from another thread.
+	 * Package local so InheritableThreadLocal can access it when a new child
+	 * Thread inherits values from its parent Thread.
+	 */
+	synchronized final void set(Thread thread, Value value) {
+		valueMap.put(thread, value);
+	}
+	
+	/**
+	 * Called when <code>get()</code> is called and no state is associated
+	 * with the currently executing Thread yet.
+	 * <p>
+	 * The default implementation returns <code>null</code>.
+	 */
+	protected Object initialValue() {
+		return null;
+	}
+}

libjava/testsuite/ChangeLog

@@ -1,3 +1,8 @@
+2001-07-10  Alexandre Petit-Bianco  <apbianco@readhat.com>
+
+	* libjava.lang/TLtest.java: New file.
+	* libjava.lang/TLtest.out: New file.
+
 2001-07-06  Andrew Haley  <aph@cambridge.redhat.com>
 
 	* libjava.lang/Divide_1.java: Add many more test cases.

libjava/testsuite/libjava.lang/TLtest.java

@@ -0,0 +1,60 @@
+class TLtest extends Thread {
+
+    public static void main (String [] args) {
+	Data d = new Data ();
+	new ThreadTest (d, "A").start ();
+	new ThreadTest (d, "B").start ();
+    }
+}
+
+class Data {
+
+    private static ThreadLocal owner = new ThreadLocal () {
+	    public Object initialValue () { return ("0"); }
+	};
+    /* A thread will call `set' to set a value it wants an instance
+       of Data to associate with it and only it. */
+    synchronized public void set (String v){owner.set (v);}
+    /* A thread will call `get' to get a value it wants an instance
+       of Data to associate with it and only it. */
+    synchronized public String get (){return (String)owner.get();}
+}
+
+class ThreadTest extends Thread {
+
+    public Data d;
+
+    ThreadTest (Data d, String name) {
+	super (name);
+	this.d = d;
+    }
+
+    public void run () {
+
+	int value = 0;
+	int ref = 0;
+
+	for (int i = 0; i < 20; i++) {
+
+	    int rand = (int)(Math.random ()*20);
+
+	    /* Read `value', ref is kept for comparison */
+	    value = Integer.parseInt (d.get());
+	    
+	    /* change `value' and ref by a random number, store `value'. */
+	    value += rand; ref += rand;
+	    d.set (Integer.toString (value));
+
+	    try {
+		sleep((int)(Math.random() * 500));
+	    } catch (InterruptedException e) {}
+	}
+
+	/* If a thread didn't have private value to attach to the
+	   instance of Data, results wouldn't be the same */
+	if (ref == value)
+	    System.out.println ("test OK.");
+	else
+	    System.out.println ("test failed.");
+    }
+}

libjava/testsuite/libjava.lang/TLtest.out

@@ -0,0 +1,2 @@
+test OK.
+test OK.