This is the mail archive of the
java-patches@sourceware.cygnus.com
mailing list for the Java project.
Patch: posix-threads code update
- To: java-patches at sourceware dot cygnus dot com
- Subject: Patch: posix-threads code update
- From: Bryce McKinlay <bryce at albatross dot co dot nz>
- Date: Fri, 24 Mar 2000 01:57:07 +1200
This patch improves the posix-threads code. It should fix a lot of bugs,
improve portability, and reduce code complexity.
The major changes are:
1. We no longer (ever) use the platform-native implementation of
recursive mutexes. These are a non-standard extension to the
posix-threads spec, are buggy on some platforms when they do exist, and
do not interact well with pthread_cond_wait(). Instead, we now implement
recursion ourselves in the _Jv_MutexLock()/_Jv_MutexUnlock() calls.
2. We now use our own interruptable condition variables to implement
wait()/sleep()/join(). Each thread has its own associated 'native'
condition variable and mutex that is used to implement waiting. For each
libgcj condition variable, a linked list of threads waiting on that
variable is maintained. When a condition variable is notified, it picks
one waiting thread, signals it, and removes it from the linked list of
waiters (wait set). When a thread is interrupted (or if a wait timeout
occurs), the thread removes itself from the wait set for the condition
variable it is waiting on. This implementation is based on a suggestion
from Tom Tromey (thanks, Tom).
The patch also fixes a few other threads bugs, which should be
self-explanitory.
I'm awaiting review of this code. Enjoy!
regards
[ bryce ]
2000-03-23 Bryce McKinlay <bryce@albatross.co.nz>
* Makefile.in: New #defines and friends for Thread.h.
* posix-threads.cc: (struct starter): Remove `object'.
(_Jv_CondWait): Use interruptable condition variables and new
recursive mutexes.
(_Jv_CondNotify): Ditto.
(_Jv_CondNotifyAll): Ditto.
(_Jv_ThreadInterrupt): Set thread interrupt flag directly. Interrupt
the target thread by signaling its wait condition.
(_Jv_ThreadInitData): Set `thread_obj' in the thread data struct,
not the starter struct. Initialize wait_mutex and wait_cond.
(_Jv_MutexLock): New recursive mutex implementation. Moved from
posix-threads.h.
(_Jv_MutexUnlock): Ditto.
(really_start): Set info->data->thread from pthread_self() to work
around a race condition.
* java/lang/Thread.java: (isInterrupted_): Renamed to overloaded
`isInterrupted(boolean)'. Clear interrupted flag if clear_flag is
set.
startable_flag: New private field.
(Thread): Initialize `startable_flag'.
(toString): Check for null thread group.
* java/lang/natThread.cc: (struct natThread): New fields
`join_mutex', `join_cond'. Removed fields `joiner', `next'.
(class locker): Removed.
(initialize_native): Initialize `join_cond' and `join_mutex'.
(interrupt): Now just calls _Jv_ThreadInterrupt().
(join): Simplified. Just wait on the target thread's join condition.
(finish_): Remove join list code. Unset thread group. Signal
potential joiners by notifying the dying threads join_cond.
(start): Check for illegal restarts.
* java/lang/natObject.cc: Check for return value of _Jv_CondWait and
act appropriatly.
* include/posix-threads.h: Remove all HAVE_RECURSIVE_MUTEX related
#defines and #ifdefs.
(struct _Jv_Thread_t): New fields `thread_obj', `wait_cond',
`wait_mutex', `next'.
(struct _Jv_ConditionVariable_t): Declare as a struct.
(struct _Jv_Mutex_t): New recursive implementation.
(_Jv_PthreadCheckMonitor): Reimplemented. Simple `owner' check.
_Jv_HaveCondDestroy: Never define this for posix-threads.
(_Jv_CondNotify): Remove inline implementation(s), prototype instead.
(_Jv_CondNotifyAll): Ditto.
(_Jv_MutexLock): Ditto.
(_Jv_MutexUnlock): Ditto.
(_Jv_MutexInit): Changed to reflect new mutex implementation.
(_Jv_MutexDestroy): Ditto.
(_Jv_CondDestroy): Removed.
Index: Makefile.in
===================================================================
RCS file: /cvs/java/libgcj/libjava/Makefile.in,v
retrieving revision 1.57
diff -u -r1.57 Makefile.in
--- Makefile.in 2000/03/17 00:45:06 1.57
+++ Makefile.in 2000/03/23 13:50:34
@@ -1635,9 +1635,14 @@
$(GCJH) -classpath $(top_builddir) \
-prepend 'class _Jv_JNIEnv;' \
-prepend 'extern "Java" { namespace gnu { namespace gcj { namespace jni { class NativeThread; } } } };' \
+ -prepend '#define _JV_NOT_OWNER 1' \
+ -prepend '#define _JV_INTERRUPTED 2' \
-friend '_Jv_JNIEnv * _Jv_GetCurrentJNIEnv ();' \
-friend 'void _Jv_SetCurrentJNIEnv (_Jv_JNIEnv *env);' \
-friend 'class gnu::gcj::jni::NativeThread;' \
+ -friend 'int _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint nanos);' \
+ -friend 'int _Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu);' \
+ -friend 'void _Jv_ThreadInterrupt (_Jv_Thread_t *data);' \
$(basename $<)
java/lang/String.h: java/lang/String.class libgcj.zip
Index: posix-threads.cc
===================================================================
RCS file: /cvs/java/libgcj/libjava/posix-threads.cc,v
retrieving revision 1.17
diff -u -r1.17 posix-threads.cc
--- posix-threads.cc 2000/03/07 19:55:24 1.17
+++ posix-threads.cc 2000/03/23 13:50:42
@@ -40,7 +40,6 @@
struct starter
{
_Jv_ThreadStartFunc *method;
- java::lang::Thread *object;
_Jv_Thread_t *data;
};
@@ -78,30 +77,23 @@
+// Wait for the condition variable "CV" to be notified.
+// Return values:
+// 0: the condition was notified, or the timeout expired.
+// _JV_NOT_OWNER: the thread does not own the mutex "MU".
+// _JV_INTERRUPTED: the thread was interrupted. Its interrupted flag is set.
int
_Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
jlong millis, jint nanos)
{
- if (_Jv_PthreadCheckMonitor (mu))
- return 1;
+ pthread_t self = pthread_self();
+ if (mu->owner != self)
+ return _JV_NOT_OWNER;
- int r;
- pthread_mutex_t *pmu = _Jv_PthreadGetMutex (mu);
struct timespec ts;
- jlong m, m2, startTime;
- bool done_sleeping = false;
+ jlong m, startTime;
- if (millis == 0 && nanos == 0)
- {
-#ifdef LINUX_THREADS
- // pthread_cond_timedwait can be interrupted by a signal on linux, while
- // pthread_cond_wait can not. So pthread_cond_timedwait() forever.
- m = java::lang::Long::MAX_VALUE;
- ts.tv_sec = LONG_MAX;
- ts.tv_nsec = 0;
-#endif
- }
- else
+ if (millis > 0 || nanos > 0)
{
startTime = java::lang::System::currentTimeMillis();
m = millis + startTime;
@@ -109,173 +101,179 @@
ts.tv_nsec = ((m % 1000) * 1000000) + nanos;
}
- java::lang::Thread *current = _Jv_ThreadCurrent();
+ _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
+ java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
+
+ // Add this thread to the cv's wait set.
+ current->next = NULL;
+
+ if (cv->first == NULL)
+ cv->first = current;
+ else
+ for (_Jv_Thread_t *t = cv->first;; t = t->next)
+ {
+ if (t->next == NULL)
+ {
+ t->next = current;
+ break;
+ }
+ }
+
+ pthread_mutex_lock (¤t->wait_mutex);
+
+ // Now that we hold the wait mutex, check if this thread has been
+ // interrupted already.
+ if (current_obj->interrupt_flag)
+ {
+ pthread_mutex_unlock (¤t->wait_mutex);
+ return _JV_INTERRUPTED;
+ }
+
+ // Record the current lock depth, so it can be restored when we reaquire it.
+ int count = mu->count;
+
+ // Release the monitor mutex.
+ mu->count = 0;
+ mu->owner = 0;
+ pthread_mutex_unlock (&mu->mutex);
+
+ int r = 0;
+ bool done_sleeping = false;
+
+ while (! done_sleeping)
+ {
+ if (millis == 0 && nanos == 0)
+ r = pthread_cond_wait (¤t->wait_cond, ¤t->wait_mutex);
+ else
+ r = pthread_cond_timedwait (¤t->wait_cond, ¤t->wait_mutex,
+ &ts);
+
+ // In older glibc's (prior to 2.1.3), the cond_wait functions may
+ // spuriously wake up on a signal. Catch that here.
+ if (r != EINTR)
+ done_sleeping = true;
+ }
+
+ // Check for an interrupt *before* unlocking the wait mutex.
+ jboolean interrupted = current_obj->interrupt_flag;
+
+ pthread_mutex_unlock (¤t->wait_mutex);
- do
+ // Reaquire the monitor mutex, and restore the lock count.
+ pthread_mutex_lock (&mu->mutex);
+ mu->owner = self;
+ mu->count = count;
+
+ // If we were interrupted, or if a timeout occured, remove ourself from
+ // the cv wait list now. (If we were notified normally, notify() will have
+ // already taken care of this)
+ if (r == ETIMEDOUT || interrupted)
{
- r = EINTR;
- // Check to ensure the thread hasn't already been interrupted.
- if (!(current->isInterrupted ()))
+ _Jv_Thread_t *prev = NULL;
+ for (_Jv_Thread_t *t = cv->first; t != NULL; t = t->next)
{
-#ifdef LINUX_THREADS
- // FIXME: in theory, interrupt() could be called on this thread
- // between the test above and the wait below, resulting in the
- // interupt() call failing. I don't see a way to fix this
- // without significant changes to the implementation.
- r = pthread_cond_timedwait (cv, pmu, &ts);
-#else
- if (millis == 0 && nanos == 0)
- r = pthread_cond_wait (cv, pmu);
- else
- r = pthread_cond_timedwait (cv, pmu, &ts);
-#endif
- }
-
- if (r == EINTR)
- {
- /* We were interrupted by a signal. Either this is
- because we were interrupted intentionally (i.e. by
- Thread.interrupt()) or by the GC if it is
- signal-based. */
- if (current->isInterrupted ())
+ if (t == current)
{
- r = 0;
- done_sleeping = true;
- }
- else
- {
- /* We were woken up by the GC or another signal. */
- m2 = java::lang::System::currentTimeMillis ();
- if (m2 >= m)
- {
- r = 0;
- done_sleeping = true;
- }
+ if (prev != NULL)
+ prev->next = t->next;
+ else
+ cv->first = t->next;
+ t->next = NULL;
+ break;
}
+ prev = t;
}
- else if (r == ETIMEDOUT)
- {
- /* A timeout is a normal result. */
- r = 0;
- done_sleeping = true;
- }
- else
- done_sleeping = true;
+ if (interrupted)
+ return _JV_INTERRUPTED;
}
- while (! done_sleeping);
-
- return r != 0;
+
+ return 0;
}
-#ifndef RECURSIVE_MUTEX_IS_DEFAULT
-
-void
-_Jv_MutexInit (_Jv_Mutex_t *mu)
+int
+_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
{
-#ifdef HAVE_RECURSIVE_MUTEX
- pthread_mutexattr_t *val = NULL;
-
-#if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE)
- pthread_mutexattr_t attr;
-
- // If this is slow, then allocate it statically and only initialize
- // it once.
- pthread_mutexattr_init (&attr);
- pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
- val = &attr;
-#elif defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP)
- pthread_mutexattr_t attr;
- pthread_mutexattr_init (&attr);
- pthread_mutexattr_setkind_np (&attr, PTHREAD_MUTEX_RECURSIVE_NP);
- val = &attr;
-#endif
-
- pthread_mutex_init (_Jv_PthreadGetMutex (mu), val);
-#ifdef PTHREAD_MUTEX_IS_STRUCT
- mu->count = 0;
-#endif
+ if (_Jv_PthreadCheckMonitor (mu))
+ return 1;
-#if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE) || defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP)
- pthread_mutexattr_destroy (&attr);
-#endif
-
-#else /* HAVE_RECURSIVE_MUTEX */
-
- // No recursive mutex, so simulate one.
- pthread_mutex_init (&mu->mutex, NULL);
- pthread_mutex_init (&mu->mutex2, NULL);
- pthread_cond_init (&mu->cond, 0);
- mu->count = 0;
+ _Jv_Thread_t *target;
+ _Jv_Thread_t *prev = NULL;
-#endif /* HAVE_RECURSIVE_MUTEX */
-}
-
-#endif /* not RECURSIVE_MUTEX_IS_DEFAULT */
+ for (target = cv->first; target != NULL; target = target->next)
+ {
+ pthread_mutex_lock (&target->wait_mutex);
-#if ! defined (LINUX_THREADS) && ! defined (HAVE_RECURSIVE_MUTEX)
+ if (target->thread_obj->interrupt_flag)
+ {
+ // Don't notify a thread that has already been interrupted.
+ pthread_mutex_unlock (&target->wait_mutex);
+ prev = target;
+ continue;
+ }
-void
-_Jv_MutexDestroy (_Jv_Mutex_t *mu)
-{
- pthread_mutex_destroy (&mu->mutex);
- pthread_mutex_destroy (&mu->mutex2);
- pthread_cond_destroy (&mu->cond);
-}
+ pthread_cond_signal (&target->wait_cond);
+ pthread_mutex_unlock (&target->wait_mutex);
-int
-_Jv_MutexLock (_Jv_Mutex_t *mu)
-{
- if (pthread_mutex_lock (&mu->mutex))
- return -1;
- while (1)
- {
- if (mu->count == 0)
- {
- // Grab the lock.
- mu->thread = pthread_self ();
- mu->count = 1;
- pthread_mutex_lock (&mu->mutex2);
- break;
- }
- else if (pthread_self () == mu->thread)
- {
- // Already have the lock.
- mu->count += 1;
- break;
- }
+ // Two successive notify() calls should not be delivered to the same
+ // thread, so we remove the target thread from the cv wait list now.
+ if (prev == NULL)
+ cv->first = target->next;
else
- {
- // Try to acquire the lock.
- pthread_cond_wait (&mu->cond, &mu->mutex);
- }
+ prev->next = target->next;
+
+ target->next = NULL;
+
+ break;
}
- pthread_mutex_unlock (&mu->mutex);
+
return 0;
}
int
-_Jv_MutexUnlock (_Jv_Mutex_t *mu)
+_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
{
- if (pthread_mutex_lock (&mu->mutex))
- return -1;
- int r = 0;
- if (mu->count == 0 || pthread_self () != mu->thread)
- r = -1;
- else
+ if (_Jv_PthreadCheckMonitor (mu))
+ return 1;
+
+ _Jv_Thread_t *target;
+ _Jv_Thread_t *prev = NULL;
+
+ for (target = cv->first; target != NULL; target = target->next)
{
- mu->count -= 1;
- if (! mu->count)
- {
- pthread_mutex_unlock (&mu->mutex2);
- pthread_cond_signal (&mu->cond);
- }
+ pthread_mutex_lock (&target->wait_mutex);
+ pthread_cond_signal (&target->wait_cond);
+ pthread_mutex_unlock (&target->wait_mutex);
+
+ if (prev != NULL)
+ prev->next = NULL;
+ prev = target;
}
- pthread_mutex_unlock (&mu->mutex);
- return r;
+ if (prev != NULL)
+ prev->next = NULL;
+
+ cv->first = NULL;
+
+ return 0;
}
-#endif /* not LINUX_THREADS and not HAVE_RECURSIVE_MUTEX */
+void
+_Jv_ThreadInterrupt (_Jv_Thread_t *data)
+{
+ pthread_mutex_lock (&data->wait_mutex);
+ // Set the thread's interrupted flag *after* aquiring its wait_mutex. This
+ // ensures that there are no races with the interrupt flag being set after
+ // the waiting thread checks it and before pthread_cond_wait is entered.
+ data->thread_obj->interrupt_flag = true;
+
+ // Interrupt blocking system calls using a signal.
+// pthread_kill (data->thread, INTR);
+
+ pthread_cond_signal (&data->wait_cond);
+
+ pthread_mutex_unlock (&data->wait_mutex);
+}
+
static void
handle_intr (int)
{
@@ -300,10 +298,14 @@
}
void
-_Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *)
+_Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *obj)
{
_Jv_Thread_t *info = new _Jv_Thread_t;
info->flags = 0;
+ info->thread_obj = obj;
+
+ pthread_mutex_init (&info->wait_mutex, NULL);
+ pthread_cond_init (&info->wait_cond, NULL);
// FIXME register a finalizer for INFO here.
// FIXME also must mark INFO somehow.
@@ -331,10 +333,16 @@
{
struct starter *info = (struct starter *) x;
- pthread_setspecific (_Jv_ThreadKey, info->object);
+ pthread_setspecific (_Jv_ThreadKey, info->data->thread_obj);
pthread_setspecific (_Jv_ThreadDataKey, info->data);
- info->method (info->object);
+ // glibc 2.1.3 doesn't set the value of `thread' until after start_routine
+ // is called. Since it may need to be accessed from the new thread, work
+ // around the potential race here by explicitly setting it again.
+ info->data->thread = pthread_self ();
+
+ info->method (info->data->thread_obj);
+
if (! (info->data->flags & FLAG_DAEMON))
{
pthread_mutex_lock (&daemon_mutex);
@@ -367,7 +375,6 @@
// FIXME: handle marking the info object for GC.
info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
info->method = meth;
- info->object = thread;
info->data = data;
if (! thread->isDaemon())
@@ -389,6 +396,38 @@
}
}
+int
+_Jv_MutexLock (_Jv_Mutex_t *mu)
+{
+ pthread_t self = pthread_self ();
+ if (mu->owner == self)
+ {
+ mu->count++;
+ }
+ else
+ {
+ pthread_mutex_lock (&mu->mutex);
+ mu->count = 1;
+ mu->owner = self;
+ }
+ return 0;
+}
+
+int
+_Jv_MutexUnlock (_Jv_Mutex_t *mu)
+{
+ _Jv_PthreadCheckMonitor (mu);
+
+ mu->count--;
+
+ if (mu->count == 0)
+ {
+ mu->owner = 0;
+ pthread_mutex_unlock (&mu->mutex);
+ }
+ return 0;
+}
+
void
_Jv_ThreadWait (void)
{
@@ -396,10 +435,4 @@
if (non_daemon_count)
pthread_cond_wait (&daemon_cond, &daemon_mutex);
pthread_mutex_unlock (&daemon_mutex);
-}
-
-void
-_Jv_ThreadInterrupt (_Jv_Thread_t *data)
-{
- pthread_kill (data->thread, INTR);
}
Index: java/lang/Thread.java
===================================================================
RCS file: /cvs/java/libgcj/libjava/java/lang/Thread.java,v
retrieving revision 1.8
diff -u -r1.8 Thread.java
--- Thread.java 2000/03/07 19:55:26 1.8
+++ Thread.java 2000/03/23 13:50:42
@@ -79,12 +79,11 @@
public static boolean interrupted ()
{
- return currentThread().isInterrupted_();
+ return currentThread().isInterrupted (true);
}
- // FIXME: it seems to me that this should be synchronized.
// Check the threads interrupted status. Note that this does not clear the
- // threads interrupted status (per JDK 1.2 online API documentation).
+ // thread's interrupted status (per JDK 1.2 online API documentation).
public boolean isInterrupted ()
{
return interrupt_flag;
@@ -119,11 +118,18 @@
private static final native void run_ (Object obj);
private final native void finish_ ();
- // Convenience method to check and clear the thread's interrupted status.
- private boolean isInterrupted_ ()
+ // Check the thread's interrupted status. If clear_flag is true, the
+ // thread's interrupted status is also cleared.
+ private boolean isInterrupted (boolean clear_flag)
{
boolean r = interrupt_flag;
- interrupt_flag = false;
+ if (clear_flag && r)
+ {
+ // Only clear the flag if we saw it as set. Otherwise this could
+ // potentially cause us to miss an interrupt in a race condition,
+ // because this method is not synchronized.
+ interrupt_flag = false;
+ }
return r;
}
@@ -221,6 +227,8 @@
data = null;
interrupt_flag = false;
alive_flag = false;
+ startable_flag = true;
+
if (current != null)
{
daemon_flag = current.isDaemon();
@@ -267,7 +275,8 @@
public String toString ()
{
- return "Thread[" + name + "," + priority + "," + group.getName() + "]";
+ return "Thread[" + name + "," + priority + "," +
+ (group == null ? "" : group.getName()) + "]";
}
public static native void yield ();
@@ -280,6 +289,7 @@
private boolean daemon_flag;
private boolean interrupt_flag;
private boolean alive_flag;
+ private boolean startable_flag;
// Our native data.
private RawData data;
Index: java/lang/natThread.cc
===================================================================
RCS file: /cvs/java/libgcj/libjava/java/lang/natThread.cc,v
retrieving revision 1.15
diff -u -r1.15 natThread.cc
--- natThread.cc 2000/03/07 19:55:26 1.15
+++ natThread.cc 2000/03/23 13:50:42
@@ -35,47 +35,16 @@
struct natThread
{
// These are used to interrupt sleep and join calls. We can share a
- // condition variable here since this thread can either be sleeping
- // or waiting for a thread exit, but not both.
- _Jv_Mutex_t interrupt_mutex;
- _Jv_ConditionVariable_t interrupt_cond;
+ // condition variable here since it only ever gets notified when the thread
+ // exits.
+ _Jv_Mutex_t join_mutex;
+ _Jv_ConditionVariable_t join_cond;
// This is private data for the thread system layer.
_Jv_Thread_t *thread;
// Each thread has its own JNI object.
JNIEnv *jni_env;
-
- // All threads waiting to join this thread are linked together and
- // waiting on their respective `interrupt' condition variables.
- // When this thread exits, it notifies each such thread by
- // signalling the condition. In this case the `interrupt_flag' is
- // not set; this is how the waiting thread knows whether the join
- // has failed or whether it should throw an exception.
- struct natThread *joiner;
-
- // Chain for waiters.
- struct natThread *next;
-};
-
-// We use this for its side effects: it lets us lock a mutex directly
-// and not lose if an exception is thrown.
-class locker
-{
-private:
- _Jv_Mutex_t *mutex;
-
-public:
- locker (_Jv_Mutex_t *m)
- : mutex (m)
- {
- _Jv_MutexLock (mutex);
- }
-
- ~locker ()
- {
- _Jv_MutexUnlock (mutex);
- }
};
// This is called from the constructor to initialize the native side
@@ -90,14 +59,12 @@
// any "interesting" point.
natThread *nt = (natThread *) _Jv_AllocBytes (sizeof (natThread));
data = reinterpret_cast<gnu::gcj::RawData *> (nt);
- _Jv_MutexInit (&nt->interrupt_mutex);
- _Jv_CondInit (&nt->interrupt_cond);
+ _Jv_MutexInit (&nt->join_mutex);
+ _Jv_CondInit (&nt->join_cond);
_Jv_ThreadInitData (&nt->thread, this);
// FIXME: if JNI_ENV is set we will want to free it. It is
// malloc()d.
nt->jni_env = NULL;
- nt->joiner = 0;
- nt->next = 0;
}
jint
@@ -125,90 +92,33 @@
void
java::lang::Thread::interrupt (void)
{
- interrupt_flag = true;
-
- // Wake up this thread, whether it is sleeping or waiting for
- // another thread to exit.
natThread *nt = (natThread *) data;
- _Jv_MutexLock (&nt->interrupt_mutex);
- // Notify the interrupt condition to interrupt sleep() and join() calls.
- _Jv_CondNotify (&nt->interrupt_cond, &nt->interrupt_mutex);
- // Send a signal to the target thread to interrupt system calls. On Linux,
- // this will also interrupt the target thread from *any* _Jv_CondWait call,
- // ie wait(). This behaviour is not portable, however.
_Jv_ThreadInterrupt (nt->thread);
- _Jv_MutexUnlock (&nt->interrupt_mutex);
}
void
java::lang::Thread::join (jlong millis, jint nanos)
{
- // FIXME: what if we are trying to join ourselves with no timeout?
-
if (millis < 0 || nanos < 0 || nanos > 999999)
_Jv_Throw (new IllegalArgumentException);
Thread *current = currentThread ();
- if (current->isInterrupted_ ())
- _Jv_Throw (new InterruptedException);
- // Update the list of all threads waiting for this thread to exit.
- // We grab a mutex when doing this in order to ensure that the
- // required state changes are atomic.
- _Jv_MonitorEnter (this);
- if (! isAlive ())
- {
- _Jv_MonitorExit (this);
- return;
- }
-
- // Here `CURR_NT' is the native structure for the currently
- // executing thread, while `NT' is the native structure for the
- // thread we are trying to join.
- natThread *curr_nt = (natThread *) current->data;
+ // Here `NT' is the native structure for the thread we are trying to join.
natThread *nt = (natThread *) data;
- JvAssert (curr_nt->next == NULL);
- // Put thread CURR_NT onto NT's list. When NT exits, it will
- // traverse its list and notify all joiners.
- curr_nt->next = nt->joiner;
- nt->joiner = curr_nt;
- _Jv_MonitorExit (this);
-
-
// Now wait for: (1) an interrupt, (2) the thread to exit, or (3)
- // the timeout to occur. Use a `locker' object because _Jv_CondWait
- // can throw an exception.
- {
- locker l (&curr_nt->interrupt_mutex);
- _Jv_CondWait (&curr_nt->interrupt_cond,
- &curr_nt->interrupt_mutex,
- millis, nanos);
- }
-
- // Now the join has completed, one way or another. Update the
- // joiners list to account for this.
- _Jv_MonitorEnter (this);
- JvAssert (nt->joiner != NULL);
- natThread *prev = 0;
- natThread *t;
- for (t = nt->joiner; t != NULL; t = t->next)
+ // the timeout to occur.
+ _Jv_MutexLock (&nt->join_mutex);
+ if (! isAlive ())
{
- if (t == curr_nt)
- {
- if (prev)
- prev->next = t->next;
- else
- nt->joiner = t->next;
- t->next = 0;
- break;
- }
- prev = t;
+ _Jv_MutexUnlock (&nt->join_mutex);
+ return;
}
- JvAssert (t != NULL);
- _Jv_MonitorExit (this);
+ _Jv_CondWait (&nt->join_cond, &nt->join_mutex, millis, nanos);
+ _Jv_MutexUnlock (&nt->join_mutex);
- if (current->isInterrupted_ ())
+ if (current->isInterrupted (true))
_Jv_Throw (new InterruptedException);
}
@@ -245,43 +155,31 @@
++nanos;
Thread *current = currentThread ();
- if (current->isInterrupted_ ())
- _Jv_Throw (new InterruptedException);
// We use a condition variable to implement sleeping so that an
- // interrupt can wake us up.
+ // interrupt can wake us up.
natThread *nt = (natThread *) current->data;
- {
- // Use a locker because _Jv_CondWait can throw an exception.
- locker l (&nt->interrupt_mutex);
- _Jv_CondWait (&nt->interrupt_cond, &nt->interrupt_mutex,
- millis, nanos);
- }
+ _Jv_MutexLock (&nt->join_mutex);
+ _Jv_CondWait (&nt->join_cond, &nt->join_mutex, millis, nanos);
+ _Jv_MutexUnlock (&nt->join_mutex);
- if (current->isInterrupted_ ())
+ if (current->isInterrupted (true))
_Jv_Throw (new InterruptedException);
}
void
java::lang::Thread::finish_ ()
{
- // Notify all threads waiting to join this this.
- _Jv_MonitorEnter (this);
- alive_flag = false;
-
- // Note that we don't bother cleaning up the joiner list here. That
- // is taken care of when each thread wakes up again.
natThread *nt = (natThread *) data;
- for (natThread *t = nt->joiner; t != NULL; t = t->next)
- {
- _Jv_MutexLock (&t->interrupt_mutex);
- _Jv_CondNotify (&t->interrupt_cond, &t->interrupt_mutex);
- _Jv_MutexUnlock (&t->interrupt_mutex);
- }
-
+
group->remove (this);
-
- _Jv_MonitorExit (this);
+ group = NULL;
+
+ // Signal any threads that are waiting to join() us.
+ _Jv_MutexLock (&nt->join_mutex);
+ alive_flag = false;
+ _Jv_CondNotifyAll (&nt->join_cond, &nt->join_mutex);
+ _Jv_MutexUnlock (&nt->join_mutex);
}
void
@@ -314,10 +212,12 @@
{
JvSynchronize sync (this);
- if (alive_flag)
+ // Its illegal to re-start() a thread, even if its dead.
+ if (!startable_flag)
_Jv_Throw (new IllegalThreadStateException);
alive_flag = true;
+ startable_flag = false;
natThread *nt = (natThread *) data;
_Jv_ThreadStart (this, nt->thread, (_Jv_ThreadStartFunc *) &run_);
}
Index: java/lang/natObject.cc
===================================================================
RCS file: /cvs/java/libgcj/libjava/java/lang/natObject.cc,v
retrieving revision 1.8
diff -u -r1.8 natObject.cc
--- natObject.cc 2000/03/07 19:55:26 1.8
+++ natObject.cc 2000/03/23 13:50:42
@@ -198,11 +198,15 @@
if (timeout < 0 || nanos < 0 || nanos > 999999)
JvThrow (new IllegalArgumentException);
_Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info;
- if (_Jv_CondWait (&si->condition, &si->mutex, timeout, nanos))
- JvThrow (new IllegalMonitorStateException(JvNewStringLatin1
- ("current thread not owner")));
- if (Thread::interrupted())
- JvThrow (new InterruptedException);
+ switch (_Jv_CondWait (&si->condition, &si->mutex, timeout, nanos))
+ {
+ case _JV_NOT_OWNER:
+ JvThrow (new IllegalMonitorStateException (JvNewStringLatin1
+ ("current thread not owner")));
+ case _JV_INTERRUPTED:
+ if (Thread::interrupted ())
+ JvThrow (new InterruptedException);
+ }
}
//
Index: include/posix-threads.h
===================================================================
RCS file: /cvs/java/libgcj/libjava/include/posix-threads.h,v
retrieving revision 1.12
diff -u -r1.12 posix-threads.h
--- posix-threads.h 2000/03/07 19:55:25 1.12
+++ posix-threads.h 2000/03/23 13:50:42
@@ -20,82 +20,65 @@
#include <pthread.h>
#include <sched.h>
-#if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE) || defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP)
-# define HAVE_RECURSIVE_MUTEX 1
-#endif
-
-
//
// Typedefs.
//
-
-typedef pthread_cond_t _Jv_ConditionVariable_t;
-#if defined (PTHREAD_MUTEX_HAVE_M_COUNT) || defined (PTHREAD_MUTEX_HAVE___M_COUNT)
+typedef struct _Jv_Thread_t
+{
+ // Flag values are defined in implementation.
+ int flags;
-// On Linux we use implementation details of mutexes in order to get
-// faster results.
-typedef pthread_mutex_t _Jv_Mutex_t;
+ // Actual thread id.
+ pthread_t thread;
+
+ // Java Thread object.
+ java::lang::Thread *thread_obj;
+
+ // Condition variable and corresponding mutex, used to implement the
+ // interruptable wait/notify mechanism.
+ pthread_cond_t wait_cond;
+ pthread_mutex_t wait_mutex;
+
+ // Next thread for Condition Variable wait-list chain.
+ _Jv_Thread_t *next;
+
+} _Jv_Thread_t;
-#else /* LINUX_THREADS */
+typedef void _Jv_ThreadStartFunc (java::lang::Thread *);
-#define PTHREAD_MUTEX_IS_STRUCT
+// Condition Variables used to implement wait/notify/sleep/interrupt.
typedef struct
{
- // Mutex used when locking this structure transiently.
- pthread_mutex_t mutex;
-#ifndef HAVE_RECURSIVE_MUTEX
- // Some systems do not have recursive mutexes, so we must simulate
- // them. Solaris is one such system.
-
- // Mutex the thread holds the entire time this mutex is held. This
- // is used to make condition variables work properly.
- pthread_mutex_t mutex2;
- // Condition variable used when waiting for this lock.
- pthread_cond_t cond;
- // Thread holding this mutex. If COUNT is 0, no thread is holding.
- pthread_t thread;
-#endif /* HAVE_RECURSIVE_MUTEX */
+ // Linked list of Threads that are waiting to be notified.
+ _Jv_Thread_t *first;
- // Number of times mutex is held. If 0, the lock is not held. We
- // do this even if we have a native recursive mutex so that we can
- // keep track of whether the lock is held; this lets us do error
- // checking. FIXME it would be nice to optimize this; on some
- // systems we could do so by relying on implementation details of
- // recursive mutexes.
- int count;
-} _Jv_Mutex_t;
+} _Jv_ConditionVariable_t;
-#endif
-
typedef struct
{
- // Flag values are defined in implementation.
- int flags;
+ // For compatibility, simplicity, and correctness, we do not use the native
+ // pthreads recursive mutex implementation, but simulate them instead.
- // Actual thread id.
- pthread_t thread;
-} _Jv_Thread_t;
-typedef void _Jv_ThreadStartFunc (java::lang::Thread *);
+ // Mutex the thread holds the entire time this mutex is held.
+ pthread_mutex_t mutex;
+ // Thread holding this mutex.
+ pthread_t owner;
+ // Number of times mutex is held (lock depth). If 0, the lock is not held.
+ int count;
+} _Jv_Mutex_t;
+
// This convenience function is used to return the POSIX mutex
// corresponding to our mutex.
inline pthread_mutex_t *
_Jv_PthreadGetMutex (_Jv_Mutex_t *mu)
{
-#if ! defined (PTHREAD_MUTEX_IS_STRUCT)
- return mu;
-#elif defined (HAVE_RECURSIVE_MUTEX)
return &mu->mutex;
-#else
- return &mu->mutex2;
-#endif
}
-#include <stdio.h>
-
// This is a convenience function used only by the pthreads thread
// implementation. This is slow, but that's too bad -- we need to do
// the checks for correctness. It might be nice to be able to compile
@@ -104,95 +87,44 @@
inline int
_Jv_PthreadCheckMonitor (_Jv_Mutex_t *mu)
{
- pthread_mutex_t *pmu;
-#ifdef HAVE_RECURSIVE_MUTEX
- pmu = _Jv_PthreadGetMutex (mu);
- // See if the mutex is locked by this thread.
- if (pthread_mutex_trylock (pmu))
- return 1;
-
-#if defined (PTHREAD_MUTEX_HAVE_M_COUNT)
- // On Linux we exploit knowledge of the implementation.
- int r = pmu->m_count == 1;
-#elif defined (PTHREAD_MUTEX_HAVE___M_COUNT)
- // In glibc 2.1, the first time the mutex is grabbed __m_count is
- // set to 0 and __m_owner is set to pthread_self().
- int r = ! pmu->__m_count;
-#else
- int r = mu->count == 0;
-#endif
-
-#else /* HAVE_RECURSIVE_MUTEX */
- // In this case we must lock our structure and then see if this
- // thread owns the mutex.
- pmu = &mu->mutex;
- if (pthread_mutex_lock (pmu))
- return 1;
-
- int r = mu->thread != pthread_self () || mu->count == 0;
-#endif /* HAVE_RECURSIVE_MUTEX */
-
- pthread_mutex_unlock (pmu);
- return r;
+ pthread_t self = pthread_self();
+ if (mu->owner == self)
+ return 0;
+ else return 1;
}
//
// Condition variables.
//
-inline void
-_Jv_CondInit (_Jv_ConditionVariable_t *cv)
-{
- pthread_cond_init (cv, 0);
-}
-
-#ifndef LINUX_THREADS
-
-// pthread_cond_destroy does nothing on Linux and it is a win to avoid
-// defining this macro.
-
-#define _Jv_HaveCondDestroy
-
-inline void
-_Jv_CondDestroy (_Jv_ConditionVariable_t *cv)
-{
- pthread_cond_destroy (cv);
-}
-
-#endif /* LINUX_THREADS */
-
int _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
jlong millis, jint nanos);
+
+int _Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu);
-inline int
-_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
-{
- return _Jv_PthreadCheckMonitor (mu) || pthread_cond_signal (cv);
-}
+int _Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu);
-inline int
-_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
+inline void
+_Jv_CondInit (_Jv_ConditionVariable_t *cv)
{
- return _Jv_PthreadCheckMonitor (mu) || pthread_cond_broadcast (cv);
+ cv->first = NULL;
}
-
//
// Mutexes.
//
-#ifdef RECURSIVE_MUTEX_IS_DEFAULT
inline void
_Jv_MutexInit (_Jv_Mutex_t *mu)
{
- pthread_mutex_init (_Jv_PthreadGetMutex (mu), NULL);
-#ifdef PTHREAD_MUTEX_IS_STRUCT
+ pthread_mutex_init (&mu->mutex, NULL);
+
mu->count = 0;
-#endif
+ mu->owner = 0;
}
-#else
-void _Jv_MutexInit (_Jv_Mutex_t *mu);
-#endif
+
+int _Jv_MutexLock (_Jv_Mutex_t *mu);
+int _Jv_MutexUnlock (_Jv_Mutex_t *mu);
#ifndef LINUX_THREADS
@@ -201,52 +133,13 @@
#define _Jv_HaveMutexDestroy
-#ifdef HAVE_RECURSIVE_MUTEX
-
-inline void
+inline void
_Jv_MutexDestroy (_Jv_Mutex_t *mu)
{
- pthread_mutex_destroy (_Jv_PthreadGetMutex (mu));
+ pthread_mutex_destroy (&mu->mutex);
}
-#else /* HAVE_RECURSIVE_MUTEX */
-
-extern void _Jv_MutexDestroy (_Jv_Mutex_t *mu);
-
-#endif /* HAVE_RECURSIVE_MUTEX */
#endif /* LINUX_THREADS */
-
-#ifdef HAVE_RECURSIVE_MUTEX
-
-inline int
-_Jv_MutexLock (_Jv_Mutex_t *mu)
-{
- int r = pthread_mutex_lock (_Jv_PthreadGetMutex (mu));
-#ifdef PTHREAD_MUTEX_IS_STRUCT
- if (! r)
- ++mu->count;
-#endif
- return r;
-}
-
-inline int
-_Jv_MutexUnlock (_Jv_Mutex_t *mu)
-{
- int r = pthread_mutex_unlock (_Jv_PthreadGetMutex (mu));
-#ifdef PTHREAD_MUTEX_IS_STRUCT
- if (! r)
- --mu->count;
-#endif
- return r;
-}
-
-#else /* HAVE_RECURSIVE_MUTEX */
-
-extern int _Jv_MutexLock (_Jv_Mutex_t *mu);
-extern int _Jv_MutexUnlock (_Jv_Mutex_t *mu);
-
-#endif /* HAVE_RECURSIVE_MUTEX */
-
//
// Thread creation and manipulation.