From af3502d049ecdf4dbaa54db91794e5fa8e55abbd Mon Sep 17 00:00:00 2001 From: bryce Date: Tue, 28 Mar 2000 02:22:24 +0000 Subject: * 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. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@32773 138bc75d-0d04-0410-961f-82ee72b054a4 --- libjava/java/lang/Thread.java | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) (limited to 'libjava/java/lang/Thread.java') diff --git a/libjava/java/lang/Thread.java b/libjava/java/lang/Thread.java index 3b867a59846..a731b0ab252 100644 --- a/libjava/java/lang/Thread.java +++ b/libjava/java/lang/Thread.java @@ -79,12 +79,11 @@ public class Thread implements Runnable 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 @@ public class Thread implements Runnable 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 @@ public class Thread implements Runnable data = null; interrupt_flag = false; alive_flag = false; + startable_flag = true; + if (current != null) { daemon_flag = current.isDaemon(); @@ -267,7 +275,8 @@ public class Thread implements Runnable 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 @@ public class Thread implements Runnable private boolean daemon_flag; private boolean interrupt_flag; private boolean alive_flag; + private boolean startable_flag; // Our native data. private RawData data; -- cgit v1.2.1