mirror of
git://gcc.gnu.org/git/gcc.git
synced 2024-12-23 02:09:08 +08:00
b834f1fa06
* 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
141 lines
2.7 KiB
C++
141 lines
2.7 KiB
C++
// -*- c++ -*-
|
|
// win32-threads.h - Defines for using Win32 threads.
|
|
|
|
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
|
|
|
|
This file is part of libgcj.
|
|
|
|
This software is copyrighted work licensed under the terms of the
|
|
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
|
details. */
|
|
|
|
#ifndef __JV_WIN32_THREADS__
|
|
#define __JV_WIN32_THREADS__
|
|
|
|
#include <windows.h>
|
|
|
|
//
|
|
// Typedefs.
|
|
//
|
|
|
|
typedef HANDLE _Jv_ConditionVariable_t;
|
|
typedef HANDLE _Jv_Mutex_t;
|
|
|
|
typedef struct
|
|
{
|
|
int flags; // Flags are defined in implementation.
|
|
HANDLE handle; // Actual handle to the thread
|
|
} _Jv_Thread_t;
|
|
|
|
typedef void _Jv_ThreadStartFunc (java::lang::Thread *);
|
|
|
|
//
|
|
// Condition variables.
|
|
//
|
|
|
|
inline void
|
|
_Jv_CondInit (_Jv_ConditionVariable_t *cv)
|
|
{
|
|
*cv = CreateEvent (NULL, 0, 0, NULL);
|
|
}
|
|
|
|
#define _Jv_HaveCondDestroy
|
|
|
|
inline void
|
|
_Jv_CondDestroy (_Jv_ConditionVariable_t *cv)
|
|
{
|
|
CloseHandle (*cv);
|
|
cv = NULL;
|
|
}
|
|
|
|
int _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
|
|
jlong millis, jint nanos);
|
|
|
|
inline int
|
|
_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *)
|
|
{
|
|
// FIXME: check for mutex ownership?
|
|
return PulseEvent (*cv) ? 0 : _JV_NOT_OWNER; // FIXME?
|
|
}
|
|
|
|
inline int
|
|
_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *)
|
|
{
|
|
// FIXME: check for mutex ownership?
|
|
return PulseEvent (*cv) ? 0 : _JV_NOT_OWNER; // FIXME?
|
|
}
|
|
|
|
//
|
|
// Mutexes.
|
|
//
|
|
|
|
inline void
|
|
_Jv_MutexInit (_Jv_Mutex_t *mu)
|
|
{
|
|
*mu = CreateMutex (NULL, 0, NULL);
|
|
}
|
|
|
|
#define _Jv_HaveMutexDestroy
|
|
|
|
inline void
|
|
_Jv_MutexDestroy (_Jv_Mutex_t *mu)
|
|
{
|
|
CloseHandle (*mu);
|
|
mu = NULL;
|
|
}
|
|
|
|
int _Jv_MutexLock (_Jv_Mutex_t *mu);
|
|
|
|
inline int
|
|
_Jv_MutexUnlock (_Jv_Mutex_t *mu)
|
|
{
|
|
return ReleaseMutex(*mu) ? 0 : GetLastError(); // FIXME: Map error code?
|
|
}
|
|
|
|
//
|
|
// Thread creation and manipulation.
|
|
//
|
|
|
|
void _Jv_InitThreads (void);
|
|
void _Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *thread);
|
|
|
|
inline java::lang::Thread *
|
|
_Jv_ThreadCurrent (void)
|
|
{
|
|
extern DWORD _Jv_ThreadKey;
|
|
return (java::lang::Thread *) TlsGetValue(_Jv_ThreadKey);
|
|
}
|
|
|
|
inline _Jv_Thread_t *
|
|
_Jv_ThreadCurrentData (void)
|
|
{
|
|
extern DWORD _Jv_ThreadDataKey;
|
|
return (_Jv_Thread_t *) TlsGetValue(_Jv_ThreadDataKey);
|
|
}
|
|
|
|
inline void
|
|
_Jv_ThreadYield (void)
|
|
{
|
|
Sleep (0);
|
|
}
|
|
|
|
void _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio);
|
|
void _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
|
|
_Jv_ThreadStartFunc *meth);
|
|
void _Jv_ThreadWait (void);
|
|
void _Jv_ThreadInterrupt (_Jv_Thread_t *data);
|
|
|
|
// Remove defines from <windows.h> that conflict with various things in libgcj code
|
|
|
|
#undef TRUE
|
|
#undef FALSE
|
|
#undef MAX_PRIORITY
|
|
#undef MIN_PRIORITY
|
|
#undef min
|
|
#undef max
|
|
#undef interface
|
|
#undef STRICT
|
|
#undef VOID
|
|
|
|
#endif /* __JV_WIN32_THREADS__ */
|