Κοινή χρήση τεχνολογίας

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

• Δημόσιο βίντεο->Κάντε κλικ στον σύνδεσμο για να μεταβείτε στο δημόσιο μάθημα
• Αρχική σελίδα ιστολογίου->Κάντε κλικ στον σύνδεσμο για να μεταβείτε στην αρχική σελίδα του ιστολογίου

Πίνακας περιεχομένων

κατάσταση του αγώνα

Κρίσιμο Τμήμα

Mutex

CriticalSection & Mutex

Σηματοφόρος

Εκδήλωση

---

κατάσταση του αγώνα

• Σε ένα περιβάλλον πολλαπλών νημάτων, όταν πολλά νήματα έχουν πρόσβαση ή τροποποιούν τα ίδια δεδομένα ταυτόχρονα, το τελικό αποτέλεσμα είναι ο χρόνος εκτέλεσης του νήματος.

• Εάν δεν υπάρχει μηχανισμός συγχρονισμού, θα προκύψουν συνθήκες αγώνα, κάτι που μπορεί να οδηγήσει σε ανακριβή δεδομένα ή εξαιρέσεις προγραμμάτων.

#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 (Mutex) χρησιμοποιείται για την αποτροπή πολλαπλών νημάτων από την πρόσβαση ή την τροποποίηση κοινόχρηστων πόρων ταυτόχρονα.

• Μόνο ένα νήμα μπορεί να είναι κάτοχος του mutex ταυτόχρονα.

• Δημιουργία mutex - CreateMutex

• Αίτημα mutex - WaitForSingleObject

• Αφήστε το mutex - 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;
}

CriticalSection & Mutex

• κρίσιμο τμήμα

  • Μηχανισμός συγχρονισμού νημάτων για κοινόχρηστους πόρους, κρίσιμες ενότητες παρέχουν αμοιβαία αποκλειστική πρόσβαση μεταξύ νημάτων της ίδιας διαδικασίας.

  • Κάθε νήμα πρέπει να μπορεί να εισέλθει στην κρίσιμη ενότητα πριν αποκτήσει πρόσβαση σε κοινόχρηστους πόρους και να αποχωρήσει από την κρίσιμη ενότητα μετά την ολοκλήρωση της πρόσβασης για να ολοκληρωθεί ο συγχρονισμός νημάτων.

• mutex

  • Ο μηχανισμός συγχρονισμού νημάτων χρησιμοποιείται για τον περιορισμό της ταυτόχρονης πρόσβασης πολλαπλών νημάτων σε κοινόχρηστους πόρους.

  • Τα Mutexe μπορούν να συγχρονίσουν διεργασίες ή νήματα και μπορούν να συγχρονιστούν μεταξύ των διεργασιών.

  • #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;
    }
    

• εκτέλεση

  • Τα κρίσιμα τμήματα είναι ταχύτερα από τα mutexe μέσα σε νήματα της ίδιας διαδικασίας.

• Λειτουργία

  • Τα Mutexes μπορούν να συγχρονιστούν σε όλες τις διεργασίες, αλλά τα κρίσιμα τμήματα μπορούν να συγχρονιστούν μόνο μεταξύ νημάτων στην ίδια διεργασία.

• ιδιοκτησία

  • Τα Mutexes έχουν αυστηρές απαιτήσεις ιδιοκτησίας και μόνο τα νήματα με δικαιώματα mutex μπορούν να τα απελευθερώσουν.

• αδιέξοδο
  • Όταν ένα νήμα πεθαίνει απροσδόκητα κρατώντας μια κλειδαριά (εξαίρεση)
  • Εάν ένα νήμα τερματιστεί απροσδόκητα ενώ κρατάτε ένα κλείδωμα κρίσιμου τμήματος, το κλείδωμα δεν θα απελευθερωθεί, με αποτέλεσμα άλλα νήματα που περιμένουν το κρίσιμο τμήμα να μην μπορούν να εκτελεστούν κανονικά, με αποτέλεσμα αδιέξοδο.

  • #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;
    }
    

  • Εάν ένα νήμα τερματιστεί απροσδόκητα ενώ κρατάτε ένα κλείδωμα mutex, τα Windows απελευθερώνουν αυτόματα την ιδιοκτησία του, έτσι ώστε τα άλλα νήματα να μπορούν να συνεχίσουν να εκτελούνται κανονικά.

  • #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.

  • απελευθερώθηκε : Αυξήστε την αξία του σηματοφόρου. Εάν υπάρχουν μπλοκαρισμένα άλλα νήματα που περιμένουν αυτόν τον σηματοφόρο, ένα από αυτά θα αφυπνιστεί.

• Δημιουργία σηματοφόρου

  • Σε συστήματα Windows, χρησιμοποιήστε CreateSemaphore ήCreateSemaphoreEx Η συνάρτηση δημιουργεί έναν σηματοφόρο.

• Περιμένετε (Περιμένετε) και απελευθερώστε το σηματοφόρο (Απελευθέρωση).

  • Η αναμονή σε έναν σηματοφόρο συνήθως γίνεται χρησιμοποιώντας 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;
}

Εκδήλωση

• Στον προγραμματισμό των Windows, τα συμβάντα είναι ένας μηχανισμός συγχρονισμού που χρησιμοποιείται για την αποστολή σημάτων μεταξύ πολλαπλών νημάτων.Το αντικείμενο συμβάντος μπορεί να είναιμη αυτόματη επαναφοράήαυτόματη επαναφορά。

  • Συμβάν χειροκίνητης επαναφοράς: Όταν ένα συμβάν έχει οριστεί (σηματοδοτηθεί), θα παραμείνει σε αυτήν την κατάσταση έως ότου γίνει ρητή επαναφορά. Αυτό σημαίνει ότι πολλά νήματα που περιμένουν το συμβάν μπορούν να αφυπνιστούν πριν από την επαναφορά του συμβάντος.

  • Αυτόματη επαναφορά συμβάντος: Όταν ένα συμβάν λαμβάνεται (σήμαινε) από ένα νήμα αναμονής, το σύστημα επαναφέρει αυτόματα την κατάσταση συμβάντος σε μη σηματοδοτημένο (μη σηματοδοτημένο). Αυτό σημαίνει ότι επιτρέπεται να αφυπνίζεται μόνο ένα νήμα τη φορά.

• Δημιουργία εκδήλωσης

  • Χρήση λειτουργιών API των WindowsCreateEventΜπορεί να δημιουργηθεί ένα αντικείμενο συμβάντος

  • 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;
}