OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

natThread.cc (class locker): New class.

Browse Source 
* java/lang/natThread.cc (class locker): New class.
	(join): Use a locker around _Jv_CondWait.
	(sleep): Likewise.

From-SVN: r28770
This commit is contained in:
Tom Tromey 1999-08-19 22:58:27 +00:00 committed by Tom Tromey
parent 8f985ec4c7
commit bd30fa53ca
2 changed files with 37 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libjava/ChangeLog
View File

@ -1,3 +1,9 @@
1999-08-19 Tom Tromey <tromey@cygnus.com>
* java/lang/natThread.cc (class locker): New class.
(join): Use a locker around _Jv_CondWait.
(sleep): Likewise.
1999-08-18 Tom Tromey <tromey@cygnus.com>
* java/lang/ThreadGroup.java: Fixed now-erroneous comment.

38
libjava/java/lang/natThread.cc
View File

@ -49,6 +49,26 @@ struct natThread
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
// of the Thread.
void
@ -153,12 +173,14 @@ java::lang::Thread::join (jlong millis, jint nanos)
// Now wait for: (1) an interrupt, (2) the thread to exit, or (3)
// the timeout to occur.
_Jv_MutexLock (&curr_nt->interrupt_mutex);
_Jv_CondWait (&curr_nt->interrupt_cond,
// 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);
_Jv_MutexUnlock (&curr_nt->interrupt_mutex);
}
// Now the join has completed, one way or another. Update the
// joiners list to account for this.
@ -224,10 +246,12 @@ java::lang::Thread::sleep (jlong millis, jint nanos)
// We use a condition variable to implement sleeping so that an
// interrupt can wake us up.
natThread *nt = (natThread *) current->data;
_Jv_MutexLock (&nt->interrupt_mutex);
_Jv_CondWait (&nt->interrupt_cond, &nt->interrupt_mutex,
{
// 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_MutexUnlock (&nt->interrupt_mutex);
}
if (current->isInterrupted ())
_Jv_Throw (new InterruptedException);