FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Makefile.in: New #defines and friends for Thread.h.

Browse source 
* 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
This commit is contained in:
Bryce McKinlay 2000-03-28 02:22:24 +00:00 • committed by Bryce McKinlay
parent 73780b74b3
commit b834f1fa06
8 changed files with 394 additions and 494 deletions
Download patch file Download diff file Expand all files Collapse all files

24
libjava/java/lang/Thread.java
View file

@ -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;

14
libjava/java/lang/natObject.cc
View file

@ -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);
}
}
//

162
libjava/java/lang/natThread.cc
View file

@ -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);
}
_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 @@ 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_);
}