15.3.1 建立多线程环境

[pythread.h]
typedef void *PyThread_type_lock;
[ceval.c]
static PyThread_type_lock interpreter_
lock = 0; /* This is the GIL */
static long main_thread = 0;
void PyEval_InitThreads(void)
{
if (interpreter_lock)
return;
interpreter_lock = PyThread_allocate_lock();
PyThread_acquire_lock(interpreter_lock, 1);
main_thread = PyThread_get_thread_ident();
}

[thread_nt.h]
PyThread_type_lock PyThread_allocate_lock(void)
{
PNRMUTEX aLock;
if (!initialized)
PyThread_init_thread();
aLock = AllocNonRecursiveMutex() ;
return (PyThread_type_lock) aLock;
}

[thread.c]
void PyThread_init_thread(void)
{
if (initialized)
return;
initialized = 1;
PyThread__init_thread();
}
[thread_nt.h]
static void PyThread__init_thread(void) { }

 [thread_nt.h]
typedef struct NRMUTEX {
LONG owned ;
DWORD thread_id ;
HANDLE hevent ;
} NRMUTEX, *PNRMUTEX ;

[thread_nt.h]
PNRMUTEX AllocNonRecursiveMutex(void)
{
PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
if(mutex && !InitializeNonRecursiveMutex(mutex)) {
free(mutex);
Mutex = NULL;
}
return mutex ;
}
BOOL InitializeNonRecursiveMutex(PNRMUTEX mutex)
{
……
mutex->owned = -1 ; /* No threads have 
entered NonRecursiveMutex */
mutex->thread_id = 0 ;
mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
return mutex->hevent != NULL ; /* TRUE 
if the mutex is created */
}

 [thread_nt.h]
int PyThread_acquire_lock(PyThread_
type_lock aLock, int waitflag)
{
int success ;
success = aLock && EnterNonRecursiveMutex
((PNRMUTEX) aLock, (waitflag
== 1 ? INFINITE : 0)) == WAIT_OBJECT_0 ;
return success;
}
DWORD EnterNonRecursiveMutex(PNRMUTEX mutex, BOOL wait)
{
/* Assume that the thread waits successfully */
DWORD ret;
/* InterlockedIncrement(&mutex->owned) == 
0 means that no thread
currently owns the mutex */
if (!wait)
{
if (InterlockedCompareExchange((PVOID *)
&mutex->owned, (PVOID)0,
(PVOID)-1) != (PVOID)-1)
return WAIT_TIMEOUT ;
ret = WAIT_OBJECT_0 ;
}
else
ret = InterlockedIncrement(&mutex->owned) ?
/* Some thread owns the mutex, let's wait... */
WaitForSingleObject(mutex->hevent, 
INFINITE) : WAIT_OBJECT_0 ;
mutex->thread_id = GetCurrentThreadId() 
; /* We own it */
return ret ;
}

 原形：InterlockedCompareExchange
(PLONG dest, long exchange, long compared)
功能：如果*dest == compared,那么*dest = exchange

[thread_nt.h]
void PyThread_release_lock(PyThread_type_lock aLock)
{
LeaveNonRecursiveMutex((PNRMUTEX) aLock)；
}
BOOL LeaveNonRecursiveMutex(PNRMUTEX mutex)
{
/* We don't own the mutex */
mutex->thread_id = 0 ;
return
InterlockedDecrement(&mutex->owned) < 0 ||
SetEvent(mutex->hevent) ; /* Other 
threads are waiting, wake one on
them up */
}

[thread_nt.h]
void PyThread_release_lock(PyThread_type_lock aLock)
{
LeaveNonRecursiveMutex((PNRMUTEX) aLock)；
}
BOOL LeaveNonRecursiveMutex(PNRMUTEX mutex)
{
/* We don't own the mutex */
mutex->thread_id = 0 ;
return
InterlockedDecrement(&mutex->owned) < 0 ||
SetEvent(mutex->hevent) ; /* Other 
threads are waiting, wake one on
them up */
}