aboutsummaryrefslogtreecommitdiff
path: root/libjava/java
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/java')
-rw-r--r--libjava/java/lang/Thread.java24
-rw-r--r--libjava/java/lang/natObject.cc14
-rw-r--r--libjava/java/lang/natThread.cc164
3 files changed, 58 insertions, 144 deletions
diff --git a/libjava/java/lang/Thread.java b/libjava/java/lang/Thread.java
index 3b867a5..a731b0a 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;
diff --git a/libjava/java/lang/natObject.cc b/libjava/java/lang/natObject.cc
index 47b88a8..25b2966 100644
--- a/libjava/java/lang/natObject.cc
+++ b/libjava/java/lang/natObject.cc
@@ -198,11 +198,15 @@ java::lang::Object::wait (jlong timeout, jint nanos)
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);
+ }
}
//
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<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 @@ 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_);
}
generated by cgit v1.1 at 2025-05-31 20:33:48 +0000