From b834f1fa0659d66d4c2d033cdb3d0f2a1f1ce390 Mon Sep 17 00:00:00 2001 From: Bryce McKinlay Date: Tue, 28 Mar 2000 02:22:24 +0000 Subject: Makefile.in: New #defines and friends for Thread.h. * 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. New return codes on interrupt or non-ownership of mutex. (_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. Destroy wait_mutex and wait_cond when run() returns. * 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): Define as a struct instead of directly mapping to pthread_cond_t. (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. (_Jv_PthreadGetMutex): Removed. * include/win32-threads.h: (_Jv_CondNotify): Guess _JV_NOT_OWNER on an error. Add a FIXME about this. (_Jv_CondNotifyAll): Ditto. * win32-threads.cc: (_Jv_CondWait): Return 0 on a timeout. Guess _JV_NOT_OWNER on other errors. Add FIXME. From-SVN: r32773 --- libjava/java/lang/natThread.cc | 164 ++++++++--------------------------------- 1 file changed, 32 insertions(+), 132 deletions(-) (limited to 'libjava/java/lang/natThread.cc') diff --git a/libjava/java/lang/natThread.cc b/libjava/java/lang/natThread.cc index 6ff548c..9fc30b9 100644 --- a/libjava/java/lang/natThread.cc +++ b/libjava/java/lang/natThread.cc @@ -35,47 +35,16 @@ details. */ 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 @@ java::lang::Thread::initialize_native (void) // any "interesting" point. natThread *nt = (natThread *) _Jv_AllocBytes (sizeof (natThread)); data = reinterpret_cast (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 @@ java::lang::Thread::destroy (void) 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 @@ java::lang::Thread::sleep (jlong millis, jint nanos) ++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); - } - - if (current->isInterrupted_ ()) + _Jv_MutexLock (&nt->join_mutex); + _Jv_CondWait (&nt->join_cond, &nt->join_mutex, millis, nanos); + _Jv_MutexUnlock (&nt->join_mutex); + + 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 @@ java::lang::Thread::start (void) { 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_); } -- cgit v1.1