cl /I "C:\Program Files\Microsoft SDK\include" 
/I C:\WINDDK\3663\inc\crt source.c 
/link /LIBPATH:C:\WINDDK\3663\lib\wxp\i386 

					  　
BOOL CloseHandle( 
HANDLE hObject　　// オブジェクトのハンドル
);

					  　
#include 
#include 

DWORD WINAPI ThreadFunc( LPVOID lpParam ) 
{ 
	char szMsg[80]; 

	wsprintf( szMsg, "Parameter = %d.", *(DWORD*)lpParam ); 
	MessageBox( NULL, szMsg, "ThreadFunc", MB_OK ); 

	return 0; 
}

VOID main( VOID ) 
{ 
	DWORD dwThreadId, dwThrdParam = 1; 
	HANDLE hThread; 
	char szMsg[80]; 

	hThread = CreateThread( 
		NULL, 			// default security attributes
		0, 			// use default stack size 
		ThreadFunc, 		// thread function
		&dwThrdParam, 		// argument to thread function
		0, 			// use default creation flags
		&dwThreadId); 		// returns the thread identifier

// Check the return value for success. 

  if (hThread == NULL) 
  { 
	wsprintf( szMsg, "CreateThread failed." ); 
	MessageBox( NULL, szMsg, "main", MB_OK ); 
  }
  else 
  { 
	_getch(); 
	CloseHandle( hThread ); 
  } 
}  

					  　
HANDLE CreateThread( 
  LPSECURITY_ATTRIBUTES lpThreadAttributes,	// セキュリティ記述子
  DWORD dwStackSize,			// 初期のスタックサイズ
  LPTHREAD_START_ROUTINE lpStartAddress,	// スレッドの機能
  LPVOID lpParameter,			// スレッドの引数
  DWORD dwCreationFlags,			 // 作成オプション
  LPDWORD lpThreadId 			// スレッド識別子
); 

					  　
HANDLE GetCurrentProcess(VOID);

					  　
HANDLE GetCurrentThread(VOID);

					  　
DWORD GetCurrentThreadId(VOID);

					  　
BOOL SetPriorityClass(
  HANDLE hProcess, 	// プロセスのハンドル
  DWORD dwPriorityClass 	// 優先順位クラス
);

					  　
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS)

					  　
BOOL SetThreadPriority(
  HANDLE hThread,	// スレッドのハンドル
  int nPriority 	// スレッドの相対優先順位値
);

					  　
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);

					  　
DWORD GetPriorityClass(
  HANDLE hProcess	// プロセスのハンドル
);

					  　
int GetThreadPriority(
  HANDLE hThread	// スレッドのハンドル
);

					  　
HANDLE hEvents[2];
DWORD i, dwEvent;

// Create two event objects.

for (i = 0; i < 2; i++)
{
	hEvents[i] = CreateEvent(
	NULL,	// no security attributes
	FALSE,	// auto-reset event object
	FALSE,	// initial state is nonsignaled
	NULL);	// unnamed object

   if (hEvents[i] == NULL)
   {

	printf("CreateEvent error: %d\n", GetLastError() );
	ExitProcess(0);
   }
}

// The creating thread waits for other threads or processes
// to signal the event objects.

dwEvent = WaitForMultipleObjects(
	2,		// number of objects in array
	hEvents,		// array of objects
	FALSE,		// wait for any
	INFINITE);	// indefinite wait

// Return value indicates which event is signaled.

switch (dwEvent)
{

	// hEvent[0] was signaled.
	case WAIT_OBJECT_0 + 0:
		// Perform tasks required by this event.
		break;
	// hEvent[1] was signaled.
	case WAIT_OBJECT_0 + 1:
		// Perform tasks required by this event.
		break;
	// Return value is invalid.
	default:
		printf("Wait error: %d\n", GetLastError());
		ExitProcess(0);
}

					  　
DWORD WaitForSingleObject(
  HANDLE hHandle,	// オブジェクトのハンドル
  DWORD dwMilliseconds	// タイムアウト時間
);

					  　
DWORD WaitForMultipleObjects(
  DWORD nCount,			// 配列内のハンドルの数
  CONST HANDLE *lpHandles,	// オブジェクトハンドルからなる配列
  BOOL fWaitAll,		// 待機オプション
  DWORD dwMilliseconds		// タイムアウト時間
);

					  　
#define NUMTHREADS 4

HANDLE hGlobalWriteEvent;

void CreateEventsAndThreads(void)
{
	HANDLE hReadEvents[NUMTHREADS], hThread;
	DWORD i, IDThread;

	// Create a manual-reset event object. The master thread sets
	// this to nonsignaled when it writes to the shared buffer.

	hGlobalWriteEvent = CreateEvent(
	   NULL,	// no security attributes
	   TRUE,	// manual-reset event
	   TRUE,	// initial state is signaled
	   "WriteEvent"	// object name
	   );

	if (hGlobalWriteEvent == NULL)
	{
	// error exit
	}

	// Create multiple threads and an auto-reset event object
	// for each thread. Each thread sets its event object to
	// signaled when it is not reading from the shared buffer.

   for(i = 1; i <= NUMTHREADS; i++)
   {
	// Create the auto-reset event.
	hReadEvents[i] = CreateEvent(
	   NULL,	// no security attributes
	   FALSE,	// auto-reset event
	   TRUE,	// initial state is signaled
	   NULL);	// object not named

	if (hReadEvents[i] == NULL)
	{
	   // Error exit.
	}

	hThread = CreateThread(NULL, 0,
		(LPTHREAD_START_ROUTINE) ThreadFunction,
		&hReadEvents[i],	// pass event handle
		0, &IDThread);

	if (hThread == NULL)
	{
		// Error exit.
	}
   }
}

					  　
VOID WriteToBuffer(VOID)
{
	DWORD dwWaitResult, i;

	// Reset hGlobalWriteEvent to nonsignaled, to block readers.

	if (! ResetEvent(hGlobalWriteEvent) )
	{
		// Error exit.
	}

	// Wait for all reading threads to finish reading.

	dwWaitResult = WaitForMultipleObjects(
		NUMTHREADS,	// number of handles in array
		hReadEvents,	// array of read-event handles
		TRUE,		// wait until all are signaled
		INFINITE);	// indefinite wait

	switch (dwWaitResult)
	{
		// All read-event objects were signaled.
		case WAIT_OBJECT_0:

			// Write to the shared buffer.
			break;

		// An error occurred.
		default:
			printf("Wait error: %d\n", GetLastError());
			ExitProcess(0);
	}
	
	// Set hGlobalWriteEvent to signaled.

	if (! SetEvent(hGlobalWriteEvent) )
	{
		// Error exit.
	}

	// Set all read events to signaled.
	for(i = 1; i <= NUMTHREADS; i++)
		if (! SetEvent(hReadEvents[i]) )
		{
			// Error exit.
		}
}

					  　
VOID ThreadFunction(LPVOID lpParam)
{
   DWORD dwWaitResult;
   HANDLE hEvents[2];

   hEvents[0] = *(HANDLE*)lpParam;	// thread's read event
   hEvents[1] = hGlobalWriteEvent;

   dwWaitResult = WaitForMultipleObjects(

	2,		// number of handles in array
	hEvents,	// array of event handles
	TRUE,		// wait till all are signaled
	INFINITE);	// indefinite wait

   switch (dwWaitResult)
   {
	// Both event objects were signaled.
	case WAIT_OBJECT_0:
		// Read from the shared buffer.
		break;

	// An error occurred.
	default:
		printf("Wait error: %d\n", GetLastError());
		ExitThread(0);
   }

   // Set the read event to signaled.

   if (! SetEvent(hEvents[0]) )
   {
	// Error exit.
   }
}

					  　
HANDLE CreateEvent(
   LPSECURITY_ATTRIBUTES lpEventAttributes,	// セキュリティ記述子
   BOOL bManualReset,				// リセットのタイプ
   BOOL bInitialState,				// 初期状態
   LPCTSTR lpName				// イベントオブジェクトの名前
);

					  　
BOOL SetEvent(
   HANDLE hEvent	// イベントオブジェクトのハンドル
);

					  　
BOOL ResetEvent(
   HANDLE hEvent	// イベントオブジェクトのハンドル
);

					  　
BOOL PulseEvent(
   HANDLE hEvent	// イベントオブジェクトのハンドル
);

					  　
CRITICAL_SECTION CriticalSection;

void main()
{

	...

	// Initialize the critical section one time only.
	if (!InitializeCriticalSection(&CriticalSection)

		return;
	...

	// Release resources used by the critical section object.
	DeleteCriticalSection(&CriticalSection)
}

DWORD WINAPI ThreadProc( LPVOID lpParameter )
{

	...

	// Request ownership of the critical section.
	EnterCriticalSection(&CriticalSection);

	// Access the shared resource.
	// Release ownership of the critical section.
	LeaveCriticalSection(&CriticalSection);

	...
}

					  　
VOID InitializeCriticalSection(
   LPCRITICAL_SECTION lpCriticalSection	// クリティカルセクション
);

					  　
VOID EnterCriticalSection(
   LPCRITICAL_SECTION lpCriticalSection	// クリティカルセクション
);

					  　
VOID LeaveCriticalSection(
   LPCRITICAL_SECTION lpCriticalSection	// クリティカルセクション
);

					  　
VOID DeleteCriticalSection(
   LPCRITICAL_SECTION lpCriticalSection	// クリティカルセクション
);

					  　
HANDLE hMutex;

// Create a mutex with no initial owner.

hMutex = CreateMutex(
	NULL,	// no security attributes
	FALSE,	// initially not owned
	"MutexToProtectDatabase");	// name of mutex

if (hMutex == NULL)
{
	// Check for error.
}

					  　
BOOL FunctionToWriteToDatabase(HANDLE hMutex)
{
	DWORD dwWaitResult;

	// Request ownership of mutex.

	dwWaitResult = WaitForSingleObject(
		hMutex,	// handle to mutex
		5000L);	// five-second time-out interval

	switch (dwWaitResult)
	{
		// The thread got mutex ownership.
		case WAIT_OBJECT_0:
			__try {
			    // Write to the database.
			}

			__finally {
			    // Release ownership of the mutex object.
			    if (! ReleaseMutex(hMutex))
			    {
				// Deal with error.
			    }

			    break;
			}

		// Cannot get mutex ownership due to time-out.
		case WAIT_TIMEOUT:
			return FALSE;

		// Got ownership of the abandoned mutex object.
		case WAIT_ABANDONED:
			return FALSE;
	}

	return TRUE;
}

					  　
HANDLE CreateMutex(
   LPSECURITY_ATTRIBUTES lpMutexAttributes,	// セキュリティ記述子
   BOOL bInitialOwner,	// 最初の所有者
   LPCTSTR lpName	// オブジェクトの名前
);

					  　
BOOL ReleaseMutex(
   HANDLE hMutex	// ミューテックスオブジェクトのハンドル
);

					  　
HANDLE hSemaphore;
LONG cMax = 10;
LONG cPreviousCount;

// Create a semaphore with initial and max. counts of 10.

hSemaphore = CreateSemaphore(
	NULL,	// no security attributes
	cMax,	// initial count
	cMax,	// maximum count
	NULL);	// unnamed semaphore

if (hSemaphore == NULL)
{
	// Check for error.
}

					  　
DWORD dwWaitResult;

// Try to enter the semaphore gate.

dwWaitResult = WaitForSingleObject(
	hSemaphore,	// handle to semaphore
	0L);	// zero-second time-out interval
switch (dwWaitResult)
{
	// The semaphore object was signaled.
	case WAIT_OBJECT_0:
		// OK to open another window.
		break;

	// Semaphore was nonsignaled, so a time-out occurred.
	case WAIT_TIMEOUT:
		// Cannot open another window.
		break;
}

					  　
// Increment the count of the semaphore.

if (!ReleaseSemaphore(
	hSemaphore,	// handle to semaphore
	1,		// increase count by one
	NULL) )		// not interested in previous count
{
	// Deal with the error.
}

					  　
HANDLE CreateSemaphore(
   LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,	// セキュリティ記述子
   LONG lInitialCount,				// 初期のカウント
   LONG lMaximumCount,				// 最大カウント
   LPCTSTR lpName				// オブジェクトの名前
);

					  　
BOOL ReleaseSemaphore(
   HANDLE hSemaphore,		// セマフォのハンドル
   LONG lReleaseCount,		// カウントを増やすべき数
   LPLONG lpPreviousCount	// それまでのカウント
);

					  　
LONG InterlockedIncrement(
   LPLONG lpAddend	// インクリメントするべき変数
);

					  　
LONG InterlockedDecrement(
   LPLONG lpAddend	// 変数へのポインタ
);

					  　
LONG InterlockedExchange(
   LPLONG Target,	// 交換に使われる変数
   LONG Value		// 新しい値
);

					  　
LONG InterlockedExchangeAdd (
   PLONG Addend,	// 加数へのポインタ
   LONG Increment	// 増分値
);

					  　
BOOL QueryPerformanceFrequency(
   LARGE_INTEGER *lpFrequency	// 現在の周波数
);

					  　
#include 
#include 

double
TokGetTime(
	VOID
	)
{
	LARGE_INTEGER curCount, frequency;
	double period, retval;

	if (TRUE == QueryPerformanceFrequency(&frequency))
	{

		// Figure out how many seconds elapse / count
		period = 1.0 / frequency.QuadPart;
		QueryPerformanceCounter(&curCount);
		retval = curCount.QuadPart * period;
	} else
	{
		// All the systems we are dealing with should support
		// querying the performance counter.
		assert(FALSE);
	}
	return (retval);
}

					  　
LPVOID pFiber[2];
LPVOID pMainFiber;
VOID WINAPI DoFiber(DWORD fiberCount)
{
	if (fiberCount == 0) {
		SwitchToFiber(pFiber[1]);
	} else {
		SwitchToFiber(pMainFiber);
	}
}

DWORD WINAPI DoMainFiber( LPVOID lpParam )
{
	pMainFiber = ConvertThreadToFiber(NULL);

	SwitchToFiber(pFiber[0]);

	return 0;
}

VOID main( VOID )
{
	HANDLE hThread;
	int i;

	for(i = 0; i < 2; i++) {
		pFiber[i] = CreateFiber(
			0,
			(LPFIBER_START_ROUTINE)DoFiber,
			(LPVOID)i);
	}

	hThread = CreateThread(
		NULL,
		0,
		(LPTHREAD_START_ROUTINE)DoMainFiber,
		NULL,
		0,
		NULL);

	// wait until the thread exits

	WaitForSingleObject(hThread, INFINITE);

	CloseHandle(hThread);
}

					  　
LPVOID CreateFiber(
   DWORD dwStackSize,	// スレッドの初期のスタックサイズ(バイト数)
   LPFIBER_START_ROUTINE lpStartAddress,
			// ファイバ関数へのポインタ
   LPVOID lpParameter	// 新しいファイバの引数
);

					  　
LPVOID ConvertThreadToFiber(
   LPVOID lpParameter	// 新しいファイバのファイバデータ
);

					  　
VOID SwitchToFiber(
   LPVOID lpFiber	// 切り替え先ファイバへのポインタ
);

					  　
SwitchToFiber(GetCurrentFiber());

					  　
VOID DeleteFiber(
   LPVOID lpFiber	// 削除対象のファイバへのポインタ
);

					  　
#include 
#include 

// Structure to be used for a list item. Typically, the first member
// is of type SLIST_ENTRY. Additional members are used for data.
// Here, the data is simply a signature for testing purposes.

typedef struct _PROGRAM_ITEM {
	SLIST_ENTRY ItemEntry;
	ULONG Signature;
} PROGRAM_ITEM, *PPROGRAM_ITEM;

void main( )
{
	ULONG Count;
	PSLIST_ENTRY FirstEntry, ListEntry;
	SLIST_HEADER ListHead;
	PPROGRAM_ITEM ProgramItem;

	// Initialize the list header.

	InitializeSListHead(&ListHead);

	// Insert 10 items into the list.
	for( Count = 1; Count <= 10; Count += 1 )
	{
		ProgramItem = (PPROGRAM_ITEM)malloc(sizeof(*ProgramItem));
		ProgramItem->Signature = Count;
		FirstEntry = InterlockedPushEntrySList(&ListHead,
			&ProgramItem->ItemEntry);
	}

	// Remove 10 items from the list.
	for( Count = 10; Count >= 1; Count -= 1 )
	//

	{
		ListEntry = InterlockedPopEntrySList(&ListHead);
		free(ListEntry);
	} Flush the list and verify that the items are gone.
	ListEntry = InterlockedFlushSList(&ListHead);
	FirstEntry = InterlockedPopEntrySList(&ListHead);
	if (FirstEntry != NULL)
	{
		printf("Error: List is not empty.");
	}
}

					  　
void InitializeSListHead(
   PSLIST_HEADER ListHead
);

					  　
PSLIST_ENTRY InterlockedPushEntrySList(
   PSLIST_HEADER ListHead,
   PSLIST_ENTRY ListEntry
);

					  　
PSLIST_ENTRY InterlockedPopEntrySList(
   PSLIST_HEADER ListHead
);