प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

• सार्वजनिक विडियो->सार्वजनिकपाठ्यक्रमं प्रति कूर्दितुं लिङ्क् नुदन्तु
• ब्लॉग मुखपृष्ठ->ब्लॉग् मुखपृष्ठं प्रति कूर्दितुं लिङ्क् नुदन्तु

सामग्रीसूची

जातिस्थितिः

आलोचनात्मकखण्डः

म्यूटेक्स

आलोचनात्मकखण्ड एवं म्यूटेक्स

सेमाफोर

घटना

---

जातिस्थितिः

• बहुसूत्रयुक्ते वातावरणे यदा बहुविधाः सूत्राः एकस्मिन् समये समानदत्तांशं अभिगच्छन्ति वा परिवर्तयन्ति वा तदा अन्तिमपरिणामः सूत्रनिष्पादनसमयः भवति ।

• यदि समन्वयनतन्त्रं नास्ति तर्हि जातिस्थितयः भविष्यन्ति, येन अशुद्धदत्तांशः अथवा कार्यक्रमअपवादः भवितुम् अर्हति ।

#include <iostream>
#include <windows.h>
 
DWORD g_Num = 0;
 
DWORD WINAPI WorkThread(LPVOID lp)
{
    for (size_t i = 0; i < 10000000; i++)
    {
        //g_Num++;
        __asm LOCK INC [g_Num] 
    }
    return 0;
}
 
int main()
{
    HANDLE hThread[2] = { 0 };
    hThread[0] = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
    hThread[1] = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
    WaitForMultipleObjects(2, hThread, TRUE, -1);
    std::cout << g_Num << std::endl;
 
    return 0;
}

आलोचनात्मकखण्डः

#include <iostream>
#include <windows.h>
 
DWORD g_Num = 0;
CRITICAL_SECTION cs = { 0 };
 
DWORD WINAPI WorkThread(LPVOID lp)
{
	for (size_t i = 0; i < 1000000; i++)
	{
		// 进入临界区
		EnterCriticalSection(&cs);
 
		// TODO
		g_Num++;
 
		// 退出临界区
		LeaveCriticalSection(&cs);
	}
	return 0;
}
 
int main()
{
 
	HANDLE hThread[2] = { 0 };
	// 初始临界区
	InitializeCriticalSection(&cs);
 
	hThread[0] = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
	hThread[1] = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
 
	WaitForMultipleObjects(2, hThread, TRUE, -1);
 
	std::cout << g_Num << std::endl;
 
	// 清理临界区
	DeleteCriticalSection(&cs);
 
	return 0;
}

म्यूटेक्स

• Mutex (Mutex) इत्यस्य उपयोगः बहुविधधागानां एकस्मिन् समये साझासंसाधनानाम् अभिगमनं परिवर्तनं वा निवारयितुं भवति ।

• केवलं एकः सूत्रः एव म्यूटेक्सस्य स्वामित्वं कर्तुं शक्नोति यदि एकः सूत्रः म्यूटेक्सस्य स्वामित्वं गृह्णाति तर्हि म्यूटेक्स् इत्यस्य अनुरोधं कुर्वन्तः अन्ये सूत्राः यावत् म्यूटेक्स् अनुमतिः न मुक्ताः न भवति तावत् अवरुद्धाः भविष्यन्ति ।

• एकं म्यूटेक्सं रचयन्तु - CreateMutex

• म्यूटेक्स इत्यस्य अनुरोधः - WaitForSingleObject

• म्यूटेक्सं मुक्तं कुर्वन्तु - ReleaseMutex

#include <iostream>
#include <windows.h>
 
HANDLE hMutex = 0;
DWORD g_Num = 0;
 
DWORD WINAPI WorkThread(LPVOID lp)
{
	for (size_t i = 0; i < 100000; i++)
	{
		WaitForSingleObject(hMutex, INFINITE);
		g_Num++;
		ReleaseMutex(hMutex);
	}
 
	return 0;
}
 
int main()
{
	hMutex = CreateMutex(NULL, FALSE, NULL); 
 
	HANDLE hThread1 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
	HANDLE hThread2 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
 
	WaitForSingleObject(hThread1, INFINITE);
	WaitForSingleObject(hThread2, INFINITE);
 
	CloseHandle(hThread1);
	CloseHandle(hThread2);
	CloseHandle(hMutex);
	
	std::cout << g_Num << std::endl;
 
	return 0;
}

आलोचनात्मकखण्ड एवं म्यूटेक्स

• आलोचनात्मकः खण्डः

  • साझासंसाधनानाम् कृते सूत्रसमन्वयनतन्त्रम्, महत्त्वपूर्णखण्डाः समानप्रक्रियायाः सूत्राणां मध्ये परस्परं अनन्यप्रवेशं प्रदास्यन्ति ।

  • प्रत्येकं सूत्रं साझासंसाधनानाम् अभिगमनात् पूर्वं महत्त्वपूर्णविभागे प्रवेशं कर्तुं समर्थः भवितुमर्हति, तथा च सूत्रसमन्वयनं पूर्णं कर्तुं अभिगमनस्य समाप्तेः अनन्तरं महत्त्वपूर्णखण्डं त्यक्त्वा गन्तुं शक्नोति

• mutex इति

  • एकस्मिन् समये साझासंसाधनानाम् अभिगमनं बहुविधं थ्रेड् प्रतिबन्धयितुं थ्रेड् समन्वयनतन्त्रस्य उपयोगः भवति ।

  • म्यूटेक्स् प्रक्रियां वा थ्रेड् वा समन्वययितुं शक्नुवन्ति, प्रक्रियासु समन्वयं कर्तुं च शक्नुवन्ति ।

  • #include <iostream>
    #include <Windows.h>
     
    int main()
    {
    	HANDLE hMutex = CreateMutex(NULL, FALSE, L"0xCC_Mutex");
    	if (hMutex == NULL) return 0;
    	if (GetLastError() == ERROR_ALREADY_EXISTS)
    	{
    		MessageBox(NULL, L"禁止多开", L"错误", MB_OKCANCEL);
    		return 0;
    	}
    	std::cout << "Game Start..." << std::endl;
    	system("pause");
    	CloseHandle(hMutex);
    	return 0;
    }
    

• प्रदर्शनम्‌

  • समानप्रक्रियायाः सूत्राणाम् अन्तः म्यूटेक्स् इत्यस्मात् समीक्षात्मकाः विभागाः द्रुततराः भवन्ति ।

• नियोग

  • म्यूटेक्स्स् प्रक्रियासु समन्वयितुं शक्यन्ते, परन्तु महत्त्वपूर्णखण्डाः केवलं एकस्मिन् प्रक्रियायां थ्रेड् मध्ये समन्वयितुं शक्यन्ते ।

• स्वामित्वम्

  • म्यूटेक्स् इत्यस्य स्वामित्वस्य कठोरता आवश्यकी भवति, केवलं म्यूटेक्स् अनुमतियुक्ताः सूत्राः एव तत् मुक्तुं शक्नुवन्ति ।

• गतिरोध
  • यदा सूत्रं तालं धारयन् अप्रत्याशितरूपेण म्रियते (अपवादः) ।
  • यदि कश्चन सूत्रः गम्भीरखण्डस्य तालं धारयन् अप्रत्याशितरूपेण समाप्तः भवति तर्हि ताला न मुक्तः भविष्यति, येन गम्भीरखण्डस्य प्रतीक्षमाणाः अन्ये सूत्राः सामान्यतया निष्पादयितुं असमर्थाः भवन्ति, यस्य परिणामेण गतिरोधः भवति

  • #include <iostream>
    #include <Windows.h>
     
    CRITICAL_SECTION CriticalSection = { 0 };
     
    DWORD WINAPI WorkThread(LPVOID lp)
    {
    	EnterCriticalSection(&CriticalSection);
    	
    	printf("TID -> %d rn", GetCurrentThreadId());
    	Sleep(5000);
     
    	LeaveCriticalSection(&CriticalSection);
     
    	return 0;
    }
     
    int main()
    {
    	InitializeCriticalSection(&CriticalSection);
     
    	HANDLE hThread1 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
    	Sleep(1000);
    	TerminateThread(hThread1, 1);
     
    	HANDLE hThread2 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
    	WaitForSingleObject(hThread2, INFINITE);
     
    	DeleteCriticalSection(&CriticalSection);
     
    	return 0;
    }
    

  • यदि म्यूटेक्स-लॉक् धारयन् कश्चन सूत्रः अप्रत्याशितरूपेण समाप्तः भवति तर्हि विण्डोज स्वयमेव स्वस्य स्वामित्वं मुक्तं करोति येन अन्ये थ्रेड् सामान्यतया निष्पादनं निरन्तरं कर्तुं शक्नुवन्ति ।

  • #include <iostream>
    #include <Windows.h>
     
    HANDLE hMutex = NULL;
     
    DWORD WINAPI WorkThread1(LPVOID lp)
    {
    	WaitForSingleObject(hMutex, INFINITE);
    	printf("TID -> %d rn", GetCurrentThreadId());
    	Sleep(5000);
    	TerminateThread(GetCurrentThread(), -1);
     
    	//todo
    	return 0;
    }
     
    DWORD WINAPI WorkThread2(LPVOID lp)
    {
    	printf("Wait For Thread1 Leavern");
    	WaitForSingleObject(hMutex, INFINITE);
    	printf("TID -> %d rn", GetCurrentThreadId());
    	ReleaseMutex(hMutex);
    	return 0;
    }
     
     
    int main()
    {
    	hMutex = CreateMutex(NULL, FALSE, NULL);
     
    	HANDLE hThread1 = CreateThread(NULL, 0, WorkThread1, NULL, 0, NULL);
    	Sleep(1000);
     
    	HANDLE hThread2 = CreateThread(NULL, 0, WorkThread2, NULL, 0, NULL);
    	WaitForSingleObject(hThread2, INFINITE);
     
    	CloseHandle(hMutex);
    	CloseHandle(hThread1);
    	CloseHandle(hThread2);
     
    	return 0;
    }
    

सेमाफोर

• सेमाफोर् इति समन्वयनवस्तु यस्य उपयोगः बहुभिः सूत्रैः साझासंसाधनानाम् अभिगमनं नियन्त्रयितुं भवति । उपलब्धानां संसाधनानाम् परिमाणं प्रतिनिधियति इति गणकः अस्ति । यदा सेमाफोरस्य मूल्यं 0 इत्यस्मात् अधिकं भवति तदा एतत् सूचयति यत् यदा मूल्यं 0 भवति तदा संसाधनं उपलब्धं नास्ति इति सूचयति;

  • प्रतीक्षतु : सेमाफोरस्य मूल्यं न्यूनीकर्तुं प्रयतते। यदि सेमाफोरस्य मूल्यं 0 इत्यस्मात् अधिकं भवति तर्हि 1 इत्यनेन न्यूनीकृत्य निष्पादनं निरन्तरं कुर्वन्तु । यदि सेमाफोरस्य मूल्यं 0 भवति तर्हि यावत् सेमाफोरस्य मूल्यं 0 इत्यस्मात् अधिकं न भवति तावत् सूत्रं अवरुद्धं करोति ।

  • मुक्तः : सेमाफोरस्य मूल्यं वर्धयन्तु। यदि अन्ये सूत्राः अवरुद्धाः सन्ति ये अस्य सेमाफोरस्य प्रतीक्षां कुर्वन्ति तर्हि तेषु एकः जागरितः भविष्यति ।

• सेमाफोर रचयन्तु

  • विण्डोज-प्रणालीषु, उपयोगं कुर्वन्तु CreateSemaphore वाCreateSemaphoreEx फंक्शन् सेमाफोर् निर्माति ।

• प्रतीक्ष्यताम् (Wait) तथा (Release) सेमाफोरं मुक्तं कुर्वन्तु

  • सेमाफोर् इत्यत्र प्रतीक्षा प्रायः उपयोगेन क्रियते WaitForSingleObject वाWaitForMultipleObjects नियोग।

  • सेमाफोरप्रयोगं विमोचयन्तु ReleaseSemaphore नियोग।

#include <iostream>
#include <Windows.h>
 
#define MAX_COUNT_SEMAPHORE 3
 
 
HANDLE g_SemapHore = NULL;
HANDLE g_hThreadArr[10] = { 0 };
 
DWORD WINAPI WorkThread(LPVOID lp)
{
	WaitForSingleObject(g_SemapHore, INFINITE);
 
	for (size_t i = 0; i < 10; i++)
	{
		std::cout << "COUNT -> " << (int)lp << std::endl;
		Sleep(500);
	}
 
	ReleaseSemaphore(g_SemapHore, 1, NULL);
 
	return 0;
}
 
int main()
{
	g_SemapHore = CreateSemaphore(
		NULL,						//安全属性
		MAX_COUNT_SEMAPHORE,		//初始计数
		MAX_COUNT_SEMAPHORE,		//最大计数
		NULL						//信号名称
	);
	
	if (g_SemapHore == NULL)
	{
		std::cout << GetLastError() << std::endl;
		return 1;
	}
 
	for (size_t i = 0; i < 10; i++)
	{
		g_hThreadArr[i] = CreateThread(
			NULL,
			0,
			WorkThread,
			(LPVOID)i,
			0,
			NULL
		);
	}
	
	WaitForMultipleObjects(10, g_hThreadArr, TRUE, INFINITE);
	
	//closehandle
 
	return 0;
}

घटना

• विण्डोज प्रोग्रामिंग् इत्यस्मिन् इवेण्ट् इति समन्वयनतन्त्रं बहुसूत्राणां मध्ये संकेतं प्रेषयितुं प्रयुक्तम् ।इवेण्ट् ऑब्जेक्ट् भवितुम् अर्हतिमैनुअल रीसेटवास्वचालितं पुनः सेट् करणीयम्。

  • मैनुअल् रीसेट् इवेण्ट्: यदा कश्चन इवेण्ट् सेट् (संकेतः) भवति तदा सः स्पष्टतया रीसेट् यावत् अस्मिन् अवस्थायां एव तिष्ठति । अस्य अर्थः अस्ति यत् घटनायाः प्रतीक्षमाणाः बहुविधाः सूत्राः घटनायाः पुनःस्थापनात् पूर्वं जागृतुं शक्यन्ते ।

  • Auto Reset Event: यदा प्रतीक्षमाणेन थ्रेड् द्वारा कश्चन इवेण्ट् प्राप्तः (संकेतः) भवति तदा प्रणाली स्वयमेव घटनास्थितिं गैर-संकेतयुक्तं (असंकेतं) इति रीसेट् करोति । एकस्मिन् समये एकमेव सूत्रं जागरितव्यमिति भावः ।

• घटना रचयन्तु

  • विण्डोज एपिआइ कार्याणां उपयोगःCreateEventइवेण्ट् ऑब्जेक्ट् निर्मातुं शक्यते

  • lpEventAttributes: सुरक्षाविशेषणस्य सूचकः, यदि सेट् भवतिNULL, पूर्वनिर्धारितसुरक्षा उपयुज्यते ।

  • bManualReset: यदिTRUE, ततः मैनुअल् रीसेट् इवेण्ट् निर्मीयते, अन्यथा स्वयमेव रीसेट् इवेण्ट् निर्मीयते ।

  • bInitialState: यदिTRUE, तर्हि प्रारम्भिकावस्था संकेतावस्था यदि;FALSE, असंकेतावस्था अस्ति ।

  • lpName: आयोजनस्य नाम।

• इवेण्ट् सेट् कर्तुं (इवेण्ट् स्टेट् इत्येतत् सिग्नल् स्टेट् इत्यत्र सेट् कर्तुं) उपयोगं कुर्वन्तुSetEventनियोग

• घटनां पुनः सेट् कर्तुं (घटनास्थितिं अ-संकेतस्थितौ सेट् कर्तुं) उपयोगं कुर्वन्तुResetEventनियोग

• इवेण्ट् इत्यस्य प्रतीक्षां कुर्वन्तु यत् इवेण्ट् ऑब्जेक्ट् इत्यस्य सिग्नल् स्टेट् भवितुं प्रतीक्षां कुर्वन्तु ।WaitForSingleObjectनियोग

#include <iostream>
#include <Windows.h>
 
DWORD WINAPI WorkThread(LPVOID lp)
{
	HANDLE hEvent = *(HANDLE*)lp;
	std::cout << "Thread - " << GetCurrentThreadId() << " Waiting For Event" << std::endl;
	WaitForSingleObject(hEvent, INFINITE);
	std::cout << "Thread - " << GetCurrentThreadId() << " actived" << std::endl;
	return 0;
}
 
int main()
{
	HANDLE hThreads[3] = { 0 };
	HANDLE hEvent = NULL;
 
	hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	if (hEvent == NULL) return 0;
 
	for (size_t i = 0; i < 3; i++)
	{
		hThreads[i] = CreateThread(NULL, 0, WorkThread, &hEvent, 0, NULL);
	}
 
	Sleep(2000);
	SetEvent(hEvent);
	
	WaitForMultipleObjects(3, hThreads, TRUE, INFINITE);
 
	CloseHandle(hEvent);
 
	return 0;
}