[PATCH] Import java/lang/ThreadLocal.java from classpath, test.

[Alexandre Petit-Bianco <apbianco at cygnus dot com>]

I need ThreadLocal for a package I'd like to build. I imported
ThreadLocal and wrote a test to make sure it functions minimally.

Test on x86/linux. OK to commit?

./A

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.

Index: ChangeLog
===================================================================
RCS file: /cvs/gcc/gcc/libjava/ChangeLog,v
retrieving revision 1.820
diff -u -p -r1.820 ChangeLog
--- ChangeLog	2001/07/05 15:57:09	1.820
+++ ChangeLog	2001/07/10 23:12:16
@@ -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-05  Tom Tromey  <tromey@redhat.com>
 
 	For PR java/3562:
Index: Makefile.am
===================================================================
RCS file: /cvs/gcc/gcc/libjava/Makefile.am,v
retrieving revision 1.153
diff -u -p -r1.153 Makefile.am
--- Makefile.am	2001/06/08 19:09:04	1.153
+++ Makefile.am	2001/07/10 23:12:21
@@ -859,6 +859,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 \
Index: java/lang/ThreadLocal.java
===================================================================
RCS file: ThreadLocal.java
diff -N ThreadLocal.java
--- /dev/null	Tue May  5 13:32:27 1998
+++ ThreadLocal.java	Tue Jul 10 16:12:32 2001
@@ -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:

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

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

Index: testsuite/libjava.lang/TLtest.java
===================================================================
RCS file: TLtest.java
diff -N TLtest.java
--- /dev/null	Tue May  5 13:32:27 1998
+++ TLtest.java	Tue Jul 10 16:12:39 2001
@@ -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.");
+    }
+}
Index: testsuite/libjava.lang/TLtest.out
===================================================================
RCS file: TLtest.out
diff -N TLtest.out
--- /dev/null	Tue May  5 13:32:27 1998
+++ TLtest.out	Tue Jul 10 16:12:39 2001
@@ -0,0 +1,2 @@
+test OK.
+test OK.