自学教程：C++ ENTERCRITICALSECTION函数代码示例

objrtn	Association_initialize(void){	static  CRITICALSECTION  cs;	static  int volatile once = 0;	ENTERCRITICALSECTION(_CI_CS_);	if (!once) {		INITIALIZECRITICALSECTION(cs);		once = 1;	}	LEAVECRITICALSECTION(_CI_CS_);	ENTERCRITICALSECTION(cs);	if (Association_c) {		LEAVECRITICALSECTION(cs);		return Association_c;	}	INHIBIT_THREADER;	Association_c = gNewClass(Class, "Association", 0, 0, END);	ENABLE_THREADER;	LEAVECRITICALSECTION(cs);	return Association_c;}

objrtn	ArgumentList_initialize(void){	static  CRITICALSECTION  cs;	static  int volatile once = 0;	ENTERCRITICALSECTION(_CI_CS_);	if (!once) {		INITIALIZECRITICALSECTION(cs);		once = 1;	}	LEAVECRITICALSECTION(_CI_CS_);	ENTERCRITICALSECTION(cs);	if (ArgumentList_c) {		LEAVECRITICALSECTION(cs);		return ArgumentList_c;	}	INHIBIT_THREADER;	LinkObject_initialize();	if (ArgumentList_c)  {		ENABLE_THREADER;		LEAVECRITICALSECTION(cs);		return ArgumentList_c;	}	ArgumentList_c = gNewClass(Class, "ArgumentList", 0, 0, LinkObject, END);	cMethodFor(ArgumentList, gNew, ArgumentList_cm_gNew);	cMethodFor(ArgumentList, gNewArglist, ArgumentList_cm_gNewArglist);	ENABLE_THREADER;	LEAVECRITICALSECTION(cs);	return ArgumentList_c;}

objrtn	InputStream_initialize(void){	static  CRITICALSECTION  cs;	static  int volatile once = 0;	ENTERCRITICALSECTION(_CI_CS_);	if (!once) {		INITIALIZECRITICALSECTION(cs);		once = 1;	}	LEAVECRITICALSECTION(_CI_CS_);	ENTERCRITICALSECTION(cs);	if (InputStream_c) {		LEAVECRITICALSECTION(cs);		return InputStream_c;	}	INHIBIT_THREADER;	InputStream_c = gNewClass(Class, "InputStream", sizeof(InputStream_iv_t), 0, END);	cMethodFor(InputStream, gNewWithStr, InputStream_cm_gNewWithStr);	cMethodFor(InputStream, gNew, InputStream_cm_gNew);	iMethodFor(InputStream, gDispose, InputStream_im_gDispose);	iMethodFor(InputStream, gGCDispose, InputStream_im_gGCDispose);	iMethodFor(InputStream, gLineHasColon, InputStream_im_gLineHasColon);	iMethodFor(InputStream, gNextToken, InputStream_im_gNextToken);	iMethodFor(InputStream, gDeepDispose, InputStream_im_gDispose);	ENABLE_THREADER;	LEAVECRITICALSECTION(cs);	return InputStream_c;}

objrtn	SeriousCondition_initialize(void){	static  CRITICALSECTION  cs;	static  int volatile once = 0;	ENTERCRITICALSECTION(_CI_CS_);	if (!once) {		INITIALIZECRITICALSECTION(cs);		once = 1;	}	LEAVECRITICALSECTION(_CI_CS_);	ENTERCRITICALSECTION(cs);	if (SeriousCondition_c) {		LEAVECRITICALSECTION(cs);		return SeriousCondition_c;	}	INHIBIT_THREADER;	Condition_initialize();	if (SeriousCondition_c)  {		ENABLE_THREADER;		LEAVECRITICALSECTION(cs);		return SeriousCondition_c;	}	SeriousCondition_c = gNewClass(Class, "SeriousCondition", 0, 0, Condition, END);	iMethodFor(SeriousCondition, gDefaultRestart, SeriousCondition_im_gDefaultRestart);	ENABLE_THREADER;	LEAVECRITICALSECTION(cs);	return SeriousCondition_c;}

objrtn	UnsignedShortInteger_initialize(void){	static  CRITICALSECTION  cs;	static  int volatile once = 0;	ENTERCRITICALSECTION(_CI_CS_);	if (!once) {		INITIALIZECRITICALSECTION(cs);		once = 1;	}	LEAVECRITICALSECTION(_CI_CS_);	ENTERCRITICALSECTION(cs);	if (UnsignedShortInteger_c) {		LEAVECRITICALSECTION(cs);		return UnsignedShortInteger_c;	}	INHIBIT_THREADER;	Number_initialize();	if (UnsignedShortInteger_c)  {		ENABLE_THREADER;		LEAVECRITICALSECTION(cs);		return UnsignedShortInteger_c;	}	UnsignedShortInteger_c = gNewClass(Class, "UnsignedShortInteger", sizeof(UnsignedShortInteger_iv_t), 0, Number, END);	cMethodFor(UnsignedShortInteger, gNewWithUnsigned, UnsignedShortInteger_cm_gNewWithUnsigned);	iMethodFor(UnsignedShortInteger, gUnsignedShortValue, UnsignedShortInteger_im_gUnsignedShortValue);	iMethodFor(UnsignedShortInteger, gChangeDoubleValue, UnsignedShortInteger_im_gChangeDoubleValue);	iMethodFor(UnsignedShortInteger, gDoubleValue, UnsignedShortInteger_im_gDoubleValue);	iMethodFor(UnsignedShortInteger, gCompare, UnsignedShortInteger_im_gCompare);	iMethodFor(UnsignedShortInteger, gChangeLongValue, UnsignedShortInteger_im_gChangeLongValue);	iMethodFor(UnsignedShortInteger, gChangeShortValue, UnsignedShortInteger_im_gChangeShortValue);	iMethodFor(UnsignedShortInteger, gShortValue, UnsignedShortInteger_im_gShortValue);	iMethodFor(UnsignedShortInteger, gPointerValue, UnsignedShortInteger_im_gPointerValue);	iMethodFor(UnsignedShortInteger, gCharValue, UnsignedShortInteger_im_gCharValue);	iMethodFor(UnsignedShortInteger, gStringRepValue, UnsignedShortInteger_im_gStringRepValue);	iMethodFor(UnsignedShortInteger, gChangeUShortValue, UnsignedShortInteger_im_gChangeUShortValue);	iMethodFor(UnsignedShortInteger, gHash, UnsignedShortInteger_im_gHash);	iMethodFor(UnsignedShortInteger, gChangeValue, UnsignedShortInteger_im_gChangeValue);	iMethodFor(UnsignedShortInteger, gLongValue, UnsignedShortInteger_im_gLongValue);	iMethodFor(UnsignedShortInteger, gChangeCharValue, UnsignedShortInteger_im_gChangeCharValue);	ENABLE_THREADER;	LEAVECRITICALSECTION(cs);	return UnsignedShortInteger_c;}

void MA_compact(void) { 	MemBlk *mb; 	Header *fh, *mfh = NULL; 	int i; 	ENTERCRITICALSECTION(CS); 	for (mb=MMBP ; mb ; mb = mb->next) { 		fh = compact(mb); 		if (fh) { 			fh->next = mfh; 			mfh = fh; 		} 	} 	for (i=0 ; Map[i].userBytes ; ++i) 		Map[i].h = NULL; 	while (fh = mfh) { 		mfh = fh->next; 		fh->status = 'U'; 		fh->next = NULL; 		MA_free(fh+1); 	} 	LEAVECRITICALSECTION(CS); } 

void asCThreadManager::Unprepare(){	asASSERT(threadManager);	if( threadManager == 0 )		return;	// It's necessary to protect this section so no	// other thread attempts to call AddRef or Release	// while clean up is in progress.	ENTERCRITICALSECTION(threadManager->criticalSection);	if( --threadManager->refCount == 0 )	{		// Make sure the local data is destroyed, at least for the current thread		CleanupLocalData();		// As the critical section will be destroyed together		// with the thread manager we must first clear the global		// variable in case a new thread manager needs to be created;		asCThreadManager *mgr = threadManager;		threadManager = 0;		// Leave the critical section before it is destroyed		LEAVECRITICALSECTION(mgr->criticalSection);		asDELETE(mgr,asCThreadManager);	}	else		LEAVECRITICALSECTION(threadManager->criticalSection);}

asCThreadLocalData *asCThreadManager::GetLocalData(){	if( threadManager == 0 )		return 0;#ifndef AS_NO_THREADS#if defined AS_POSIX_THREADS	asPWORD id = (asPWORD)pthread_self();#elif defined AS_WINDOWS_THREADS	asPWORD id = (asPWORD)GetCurrentThreadId();#endif	ENTERCRITICALSECTION(threadManager->criticalSection);	asCThreadLocalData *tld = threadManager->GetLocalData(id);	if( tld == 0 )	{		// Create a new tld		tld = asNEW(asCThreadLocalData)();		if( tld )			threadManager->SetLocalData(id, tld);	}	LEAVECRITICALSECTION(threadManager->criticalSection);	return tld;#else	if( threadManager->tld == 0 )		threadManager->tld = asNEW(asCThreadLocalData)();	return threadManager->tld;#endif}

int asCGarbageCollector::GetObjectInGC(asUINT idx, asUINT *seqNbr, void **obj, asIObjectType **type){	if( seqNbr ) *seqNbr = 0;	if( obj )    *obj    = 0;	if( type )   *type   = 0;	ENTERCRITICALSECTION(gcCritical);	asSObjTypePair *o = 0;	asUINT newObjs = gcNewObjects.GetLength();	if( idx < newObjs )		o = &gcNewObjects[idx];	else if( idx < gcOldObjects.GetLength() + newObjs )		o = &gcOldObjects[idx-newObjs];	else	{		LEAVECRITICALSECTION(gcCritical);		return asINVALID_ARG;	}	if( seqNbr ) *seqNbr = o->seqNbr;	if( obj )    *obj    = o->obj;	if( type )   *type   = o->type;	LEAVECRITICALSECTION(gcCritical);	return asSUCCESS;}

void asCGarbageCollector::IncreaseCounterForNewObject(int idx){	// We need to protect this update with a critical section as	// another thread might be appending an object at the same time	ENTERCRITICALSECTION(gcCritical);	gcNewObjects[idx].count++;	LEAVECRITICALSECTION(gcCritical);}

asDWORD asCAtomic::atomicDec(){	asDWORD v;	ENTERCRITICALSECTION(cs);	v = --value;	LEAVECRITICALSECTION(cs);	return v;}

int asCGarbageCollector::AddScriptObjectToGC(void *obj, asCObjectType *objType){	if( obj == 0 || objType == 0 )	{		engine->WriteMessage("", 0, 0, asMSGTYPE_ERROR, TXT_GC_RECEIVED_NULL_PTR);		return asINVALID_ARG;	}	engine->CallObjectMethod(obj, objType->beh.addref);	asSObjTypePair ot = {obj, objType, 0};	// Invoke the garbage collector to destroy a little garbage as new comes in	// This will maintain the number of objects in the GC at a maintainable level without	// halting the application, and without burdening the application with manually invoking the 	// garbage collector.	if( engine->ep.autoGarbageCollect && gcNewObjects.GetLength() )	{		// If the GC is already processing in another thread, then don't try this again		if( TRYENTERCRITICALSECTION(gcCollecting) )		{			// Skip this if the GC is already running in this thread			if( !isProcessing )			{				isProcessing = true;				// TODO: The number of iterations should be dynamic, and increase 				//       if the number of objects in the garbage collector grows high				// Run one step of DetectGarbage				if( gcOldObjects.GetLength() )				{					IdentifyGarbageWithCyclicRefs();					DestroyOldGarbage();				}				// Run a few steps of DestroyGarbage				int iter = (int)gcNewObjects.GetLength();				if( iter > 10 ) iter = 10;				while( iter-- > 0 )					DestroyNewGarbage();				isProcessing = false;			}			LEAVECRITICALSECTION(gcCollecting);		}	}	// Add the data to the gcObjects array in a critical section as	// another thread might be calling this method at the same time	ENTERCRITICALSECTION(gcCritical);	ot.seqNbr = numAdded++;	gcNewObjects.PushLast(ot);	LEAVECRITICALSECTION(gcCritical);	return ot.seqNbr;}

void asCGarbageCollector::MoveAllObjectsToOldList(){	// We need to protect this update with a critical section as	// another thread might be appending an object at the same time	ENTERCRITICALSECTION(gcCritical);	if( gcOldObjects.Concatenate(gcNewObjects) )		gcNewObjects.SetLength(0);	LEAVECRITICALSECTION(gcCritical);}

objrtn	BufferedTempFile_initialize(void){	static  CRITICALSECTION  cs;	static  int volatile once = 0;	ENTERCRITICALSECTION(_CI_CS_);	if (!once) {		INITIALIZECRITICALSECTION(cs);		once = 1;	}	LEAVECRITICALSECTION(_CI_CS_);	ENTERCRITICALSECTION(cs);	if (BufferedTempFile_c) {		LEAVECRITICALSECTION(cs);		return BufferedTempFile_c;	}	INHIBIT_THREADER;	BufferedTempFile_c = gNewClass(Class, "BufferedTempFile", sizeof(BufferedTempFile_iv_t), 0, END);	cMethodFor(BufferedTempFile, gOpenTempFile, BufferedTempFile_cm_gOpenTempFile);	iMethodFor(BufferedTempFile, gFlush, BufferedTempFile_im_gFlush);	iMethodFor(BufferedTempFile, gRetreat, BufferedTempFile_im_gRetreat);	iMethodFor(BufferedTempFile, gPosition, BufferedTempFile_im_gPosition);	iMethodFor(BufferedTempFile, gLength, BufferedTempFile_im_gLength);	iMethodFor(BufferedTempFile, gWrite, BufferedTempFile_im_gWrite);	iMethodFor(BufferedTempFile, gEndOfStream, BufferedTempFile_im_gEndOfStream);	iMethodFor(BufferedTempFile, gSeek, BufferedTempFile_im_gSeek);	iMethodFor(BufferedTempFile, gPointerValue, BufferedTempFile_im_gPointerValue);	iMethodFor(BufferedTempFile, gAdvance, BufferedTempFile_im_gAdvance);	iMethodFor(BufferedTempFile, gDispose, BufferedTempFile_im_gDispose);	iMethodFor(BufferedTempFile, gName, BufferedTempFile_im_gName);	iMethodFor(BufferedTempFile, gGets, BufferedTempFile_im_gGets);	iMethodFor(BufferedTempFile, gGCDispose, BufferedTempFile_im_gGCDispose);	iMethodFor(BufferedTempFile, gDeepDispose, BufferedTempFile_im_gDispose);	iMethodFor(BufferedTempFile, gRead, BufferedTempFile_im_gRead);	ENABLE_THREADER;	LEAVECRITICALSECTION(cs);	return BufferedTempFile_c;}

objrtn	ObjectPool_initialize(void){	static  CRITICALSECTION  cs;	static  int volatile once = 0;	ENTERCRITICALSECTION(_CI_CS_);	if (!once) {		INITIALIZECRITICALSECTION(cs);		once = 1;	}	LEAVECRITICALSECTION(_CI_CS_);	ENTERCRITICALSECTION(cs);	if (ObjectPool_c) {		LEAVECRITICALSECTION(cs);		return ObjectPool_c;	}	INHIBIT_THREADER;	ObjectPool_c = gNewClass(Class, "ObjectPool", sizeof(ObjectPool_iv_t), sizeof(ObjectPool_cv_t), END);	cMethodFor(ObjectPool, gNewGlobalPoolWithSize, ObjectPool_cm_gNewGlobalPoolWithSize);	cMethodFor(ObjectPool, gDisposeGlobalPool, ObjectPool_cm_gDisposeGlobalPool);	cMethodFor(ObjectPool, gRemoveFromPool, ObjectPool_cm_gRemoveFromPool);	cMethodFor(ObjectPool, gNewWithInt, ObjectPool_cm_gNewWithInt);	cMethodFor(ObjectPool, gAddToPool, ObjectPool_cm_gAddToPool);	cMethodFor(ObjectPool, gNew, ObjectPool_cm_gNew);	cMethodFor(ObjectPool, gNewGlobalPool, ObjectPool_cm_gNewGlobalPool);	cMethodFor(ObjectPool, gDisposeObject, ObjectPool_cm_gDisposeObject);	iMethodFor(ObjectPool, gRemoveFromPool, ObjectPool_im_gRemoveFromPool);	iMethodFor(ObjectPool, gAddToPool, ObjectPool_im_gAddToPool);	iMethodFor(ObjectPool, gDispose, ObjectPool_im_gDispose);	iMethodFor(ObjectPool, gDeepDispose, ObjectPool_im_gDispose);	iMethodFor(ObjectPool, gDisposeObject, ObjectPool_im_gDisposeObject);	ObjectPool_cv = GetCVs(ObjectPool);	ENABLE_THREADER;	LEAVECRITICALSECTION(cs);	return ObjectPool_c;}

void asCGarbageCollector::AddScriptObjectToGC(void *obj, asCObjectType *objType){	engine->CallObjectMethod(obj, objType->beh.addref);	asSObjTypePair ot = {obj, objType};	// Add the data to the gcObjects array in a critical section as	// another thread might be calling this method at the same time	ENTERCRITICALSECTION(gcCritical);	gcObjects.PushLast(ot);	LEAVECRITICALSECTION(gcCritical);}

void asCMemoryMgr::FreeScriptNode(void *ptr){	ENTERCRITICALSECTION(cs);	// Pre allocate memory for the array to avoid slow growth	if( scriptNodePool.GetLength() == 0 )		scriptNodePool.Allocate(100, 0);	scriptNodePool.PushLast(ptr);	LEAVECRITICALSECTION(cs);}

objrtn	PointerArray_initialize(void){	static  CRITICALSECTION  cs;	static  int volatile once = 0;	ENTERCRITICALSECTION(_CI_CS_);	if (!once) {		INITIALIZECRITICALSECTION(cs);		once = 1;	}	LEAVECRITICALSECTION(_CI_CS_);	ENTERCRITICALSECTION(cs);	if (PointerArray_c) {		LEAVECRITICALSECTION(cs);		return PointerArray_c;	}	INHIBIT_THREADER;	Array_initialize();	if (PointerArray_c)  {		ENABLE_THREADER;		LEAVECRITICALSECTION(cs);		return PointerArray_c;	}	PointerArray_c = gNewClass(Class, "PointerArray", 0, 0, Array, END);	cvMethodFor(PointerArray, vNew, PointerArray_cvm_vNew, PointerArray_cfm_vNew);	ivMethodFor(PointerArray, vChangeValue, PointerArray_ivm_vChangeValue, PointerArray_ifm_vChangeValue);	ivMethodFor(PointerArray, vPointerValue, PointerArray_ivm_vPointerValue, PointerArray_ifm_vPointerValue);	init_class();	ENABLE_THREADER;	LEAVECRITICALSECTION(cs);	return PointerArray_c;}

void asCThreadManager::Prepare(){	// The critical section cannot be declared globally, as there is no	// guarantee for the order in which global variables are initialized	// or uninitialized.	// For this reason it's not possible to prevent two threads from calling 	// AddRef at the same time, so there is a chance for a race condition here.	// To avoid the race condition when the thread manager is first created, 	// the application must make sure to call the global asPrepareForMultiThread()	// in the main thread before any other thread creates a script engine. 	if( threadManager == 0 )		threadManager = asNEW(asCThreadManager);	else	{		ENTERCRITICALSECTION(threadManager->criticalSection);		threadManager->refCount++;		LEAVECRITICALSECTION(threadManager->criticalSection);	}}

void *MA_realloc(void *arg, unsigned n) { 	char *m; 	Header *h = (Header *) arg; 	ENTERCRITICALSECTION(CS); 	if (!h || (--h)->status != 'U') { 		LEAVECRITICALSECTION(CS); 		return NULL; 	} 	if (h->size >= n) { 		h->rsize = n; 		LEAVECRITICALSECTION(CS); 		return h+1; 	} 	m = (char *) MA_malloc(n, h->next); 	memcpy(m, h+1, h->rsize); 	h->next = NULL; 	MA_free(h+1); 	LEAVECRITICALSECTION(CS); 	return m; } 

void MA_free(void *arg) { 	int i; 	Header *h = (Header *) arg; 	ENTERCRITICALSECTION(CS); 	if (!h || (--h)->status != 'U') { 		LEAVECRITICALSECTION(CS); 		return; 	} 	for (i=1 ; Map[i].userBytes && Map[i].userBytes <= h->size ; ++i); 	i--; 	h->status = 'F'; 	if (h->next) 		*((char **) h->next) = NULL; 	h->next = Map[i].h; 	Map[i].h = h; 	LEAVECRITICALSECTION(CS); }