Création de threads

Sur la plateforme Windows, l'API Windows prend en charge le multithreading. Précédemment, dans les concepts de processus et de threads, nous avons mentionné qu'un programme possède au moins un thread, appelé thread principal. Si nous ne créons pas explicitement de threads, le programme que nous produisons est un programme monothread avec uniquement le thread principal.

Ci-dessous, examinons les opérations et méthodes liées aux threads dans Windows :

CreateThread et CloseHandle

CreateThread est utilisé pour créer un thread. Son prototype de fonction est le suivant :

HANDLE WINAPI CreateThread(
    LPSECURITY_ATTRIBUTES   lpThreadAttributes, //线程安全相关的属性,常置为NULL
    SIZE_T                  dwStackSize,        //新线程的初始化栈在大小,可设置为0
    LPTHREAD_START_ROUTINE  lpStartAddress,     //被线程执行的回调函数,也称为线程函数
    LPVOID                  lpParameter,        //传入线程函数的参数,不需传递参数时为NULL
    DWORD                   dwCreationFlags,    //控制线程创建的标志
    LPDWORD                 lpThreadId          //传出参数,用于获得线程ID,如果为NULL则不返回线程ID
);

Description:

  • lpThreadAttributes : Un pointeur vers une structure SECURITY_ATTRIBUTES qui détermine si le handle retourné peut être hérité par les processus enfants. S'il est NULL, le handle retourné ne peut pas être hérité par les processus enfants.

  • dwStackSize : La taille initiale de la pile du thread, en octets. Le système alloue cette valeur...
  • lpStartAddress : Un pointeur vers un pointeur de fonction ; cette fonction sera appelée et exécutée par le thread. Par conséquent, cette fonction est également appelée fonction de thread (ThreadProc), qui est l'adresse de départ de l'exécution du thread. La fonction de thread est une fonction de rappel appelée par le système d'exploitation dans le thread. Le prototype de la fonction de thread est le suivant :

    DWORD WINAPI ThreadProc(LPVOID lpParameter);    //lpParameter是传入的参数,是一个空指针
  • lpParameter : Le paramètre transmis à la fonction de thread (ThreadProc) ; utilisez NULL lorsqu'aucun paramètre n'a besoin d'être transmis.

  • dwCreationFlags : Indicateurs contrôlant la création de threads. Il existe trois types : 0 : le thread s'exécute immédiatement après sa création ; CREATE_SUSPENDED : le thread entre dans l'état prêt après sa création et n'est pas invoqué jusqu'à ce que le thread soit repris ; STACK_SIZE_PARAM_IS_A_RESERVATION : le paramètre dwStackSize spécifie la taille initiale de la pile du thread. Si l'indicateur STACK_SIZE_PARAM_IS_A_RESERVATION n'est pas spécifié, dwStackSize sera défini sur une valeur réservée par le système.

  • Valeur de retour : Si le thread est créé avec succès, le handle du nouveau thread est retourné ; sinon, NULL est retourné. Si la création du thread échoue, les informations d'erreur peuvent être obtenues via la fonction GetLastError.

    BOOL WINAPI CloseHandle(HANDLE hObject);        //关闭一个被打开的对象句柄
    
    Cette fonction peut être utilisée pour fermer le handle du thread créé. Si la fonction s'exécute avec succès, elle retourne true (non-zéro) ; si elle échoue, elle retourne false (0). Si l'exécution échoue, vous pouvez appeler la fonction GetLastError pour obtenir les informations d'erreur.

[Demo1] : Créer le thread le plus simple

Exemple

#include "stdafx.h" #include <windows.h> #include <iostream> using namespace std; //fonction de thread DWORD WINAPI ThreadProc(LPVOID lpParameter) { for (int i = 0; i < 5; ++ i) { cout << "thread enfant : i =" << i << endl; Sleep(100); } return 0L; } int main() { //créer un thread HANDLE thread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL); //fermer le thread CloseHandle(thread); //chemin d'exécution du thread principal for (int i = 0; i < 5; ++ i) { cout << "thread principal : i =" << i << endl; Sleep(100); } return 0; }

Le résultat est le suivant :

主线程:i = 0 
子线程:i = 0 
主线程:i = 1 
子线程:i = 1 
子线程:i = 2 
主线程:i = 2 
子线程:i = 3 
主线程:i = 3 
子线程:i = 4 
主线程:i = 4

[Demo2] : Passage de paramètres à la fonction de thread

Exemple

#include "stdafx.h" #include <windows.h> #include <iostream> using namespace std; #define NAME_LINE 40 //définir la structure pour les paramètres de la fonction de thread typedef struct __THREAD_DATA { int nMaxNum; char strThreadName[NAME_LINE]; __THREAD_DATA() : nMaxNum(0) { memset(strThreadName, 0, NAME_LINE * sizeof(char)); } }THREAD_DATA; //fonction de thread DWORD WINAPI ThreadProc(LPVOID lpParameter) { THREAD_DATA* pThreadData = (THREAD_DATA*)lpParameter; for (int i = 0; i < pThreadData->nMaxNum; ++ i) { cout << pThreadData->strThreadName << " --- " << i << endl; Sleep(100); } return 0L; } int main() { //initialiser les données du thread THREAD_DATA threadData1, threadData2; threadData1.nMaxNum = 5; strcpy(threadData1.strThreadName, "thread 1"); threadData2.nMaxNum = 10; strcpy(threadData2.strThreadName, "thread 2"); //créer le premier thread enfant HANDLE hThread1 = CreateThread(NULL, 0, ThreadProc, &threadData1, 0, NULL); //créer le deuxième thread enfant HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc, &threadData2, 0, NULL); //fermer les threads CloseHandle(hThread1); CloseHandle(hThread2); //chemin d'exécution du thread principal for (int i = 0; i < 5; ++ i) { cout << "main thread ===" << i << endl; Sleep(100); } system("pause"); return 0; }

Résultat :

主线程 === 线程1 — 0 
0 
线程2 — 0 
线程1 — 1 
主线程 === 1 
线程2 — 1 
主线程 === 2 
线程1 — 2 
线程2 — 2 
主线程 === 3 
线程2 — 3 
线程1 — 3 
主线程 === 4 
线程2 — 4 
线程1 — 4 
线程2 — 5 
请按任意键继续… 线程2 — 6 
线程2 — 7 
线程2 — 8 
线程2 — 9

CreateMutex, WaitForSingleObject, ReleaseMutex

D'après [Demo2], nous pouvons voir que bien que les threads enfants créés se soient tous exécutés normalement, le résultat de sortie ne correspondait pas à ce que nous attendions. Nous attendions qu'à chaque instruction de sortie suive un retour à la ligne, mais les résultats n'étaient pas tous ainsi. Cela est dû au fait qu'aucune synchronisation n'a été effectuée pendant l'exécution des threads. Par exemple, dans la première ligne de sortie, après que le thread principal a affiché « main thread === », son quantum de temps est épuisé ; puis c'est au tour du thread enfant 1 de s'afficher. Après que le thread enfant 1 a affiché « thread 1 — », son quantum de temps est également épuisé ; puis c'est au tour du thread principal d'afficher « 0 », puis le thread enfant 1 affiche « 0 ». Ainsi apparaît le résultat « main thread === thread 1 — 0 0 ».

Thread principal : cout << "main thread === " << i << endl;
Thread enfant : cout << pThreadData->strThreadName << " — " << i << endl;

Pour éviter cette situation, nous effectuons une synchronisation simple sur les threads. Ici, nous utilisons un mutex.

Un mutex est similaire à un sémaphore binaire, où une ressource ne peut être accédée que par un seul thread. Contrairement à un sémaphore binaire — où un sémaphore peut être acquis et libéré par n'importe quel thread de tout le système, c'est-à-dire que le même sémaphore peut être acquis par un thread et libéré par un autre — un mutex exige que le thread qui a acquis le verrou du mutex soit celui qui le libère. Il est invalide que d'autres threads libèrent le mutex à sa place.

Lors de l'utilisation de mutex pour la synchronisation des threads, les fonctions suivantes sont utilisées :

HANDLE WINAPI CreateMutex(
    LPSECURITY_ATTRIBUTES lpMutexAttributes,        //线程安全相关的属性,常置为NULL
    BOOL                  bInitialOwner,            //创建Mutex时的当前线程是否拥有Mutex的所有权
    LPCTSTR               lpName                    //Mutex的名称
);

Description :lpMutexAttributes est aussi une structure de sécurité, avec la même fonction que lpThreadAttributes dans CreateThread, indiquant si le handle retourné peut être hérité par les processus enfants. Si NULL, le handle retourné ne peut pas être hérité par les processus enfants. bInitialOwner indique si le thread actuel possède le Mutex lors de sa création. Si TRUE, le thread créateur actuel est désigné comme propriétaire de l'objet Mutex, et les autres threads doivent appeler ReleaseMutex avant d'y accéder. lpName est le nom du Mutex.

DWORD WINAPI WaitForSingleObject(
    HANDLE hHandle,                             //要获取的锁的句柄
    DWORD  dwMilliseconds                           //超时间隔
);

Description :WaitForSingleObject attend un objet spécifié (tel qu'un objet Mutex) jusqu'à ce que l'objet soit dans un état non occupé (par exemple, que l'objet Mutex soit libéré) ou que l'intervalle de temps défini se soit écoulé. De plus, il existe une fonction similaire, WaitForMultipleObjects, qui attend un ou tous les objets spécifiés jusqu'à ce que tous les objets soient dans un état non occupé, ou jusqu'à ce que l'intervalle de temps défini se soit écoulé.

hHandleLe handle de l'objet spécifié à attendre. dwMilliseconds : L'intervalle de délai d'attente, en millisecondes ; si dwMilliseconds est non nul, il attend jusqu'à ce que l'intervalle dwMilliseconds se soit écoulé ou que l'objet devienne non occupé. Si dwMilliseconds est INFINITE, cela signifie attendre indéfiniment jusqu'à ce que l'objet attendu soit dans un état non occupé.

BOOL WINAPI ReleaseMutex(HANDLE hMutex);

Description :Libère l'objet de verrou mutex détenu. hMutex est le handle du mutex à libérer.

[Demo3] : Synchronisation des threads

Exemple

#include "stdafx.h" #include <windows.h> #include <iostream> #define NAME_LINE 40 //définir la structure pour les paramètres de la fonction de thread typedef struct __THREAD_DATA { int nMaxNum; char strThreadName[NAME_LINE]; __THREAD_DATA() : nMaxNum(0) { memset(strThreadName, 0, NAME_LINE * sizeof(char)); } }THREAD_DATA; HANDLE g_hMutex = NULL; //mutex //fonction de thread DWORD WINAPI ThreadProc(LPVOID lpParameter) { THREAD_DATA* pThreadData = (THREAD_DATA*)lpParameter; for (int i = 0; i < pThreadData->nMaxNum; ++ i) { //demande d'acquisition d'un verrou mutex WaitForSingleObject(g_hMutex, INFINITE); cout << pThreadData->strThreadName << " --- " << i << endl; Sleep(100); //libérer le verrou mutex ReleaseMutex(g_hMutex); } return 0L; } int main() { //créer un mutex g_hMutex = CreateMutex(NULL, FALSE, NULL); //initialiser les données de thread THREAD_DATA threadData1, threadData2; threadData1.nMaxNum = 5; strcpy(threadData1.strThreadName, "thread 1"); threadData2.nMaxNum = 10; strcpy(threadData2.strThreadName, "thread 2"); //créer le premier thread enfant HANDLE hThread1 = CreateThread(NULL, 0, ThreadProc, &threadData1, 0, NULL); //créer le deuxième thread enfant HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc, &threadData2, 0, NULL); //fermer les threads CloseHandle(hThread1); CloseHandle(hThread2); //chemin d'exécution du thread principal for (int i = 0; i < 5; ++ i) { //demande d'acquisition d'un verrou mutex WaitForSingleObject(g_hMutex, INFINITE); cout << "main thread ===" << i << endl; Sleep(100); //libérer le verrou mutex ReleaseMutex(g_hMutex); } system("pause"); return 0; }

Résultat :

主线程 === 0 
线程1 — 0 
线程2 — 0 
主线程 === 1 
线程1 — 1 
线程2 — 1 
主线程 === 2 
线程1 — 2 
线程2 — 2 
主线程 === 3 
线程1 — 3 
线程2 — 3 
主线程 === 4 
线程1 — 4 
请按任意键继续… 线程2 — 4 
线程2 — 5 
线程2 — 6 
线程2 — 7 
线程2 — 8 
线程2 — 9

Pour mieux comprendre l'importance de la synchronisation des threads et de l'utilisation des mutex, examinons un autre exemple.

L'achat de billets de train est ce qui préoccupe le plus tout le monde lors du retour à la maison pour la Fête du Printemps. Simulons simplement un système de vente de billets de train (pour garder le programme simple, nous extrayons le modèle le plus simple pour la simulation) : il y a 500 billets de train de Pékin à Ganzhou, vendus simultanément à 8 guichets, assurant la stabilité du système et l'atomicité des données.

[Demo4] : Simulation d'un système de billetterie de train

SaleTickets.h

#include "stdafx.h" #include <windows.h> #include <iostream> #include <strstream> #include <string> using namespace std; #define NAME_LINE 40 //définir la structure pour les paramètres de la fonction de thread typedef struct __TICKET { int nCount; char strTicketName[NAME_LINE]; __TICKET() : nCount(0) { memset(strTicketName, 0, NAME_LINE * sizeof(char)); } }TICKET; typedef struct __THD_DATA { TICKET* pTicket; char strThreadName[NAME_LINE]; __THD_DATA() : pTicket(NULL) { memset(strThreadName, 0, NAME_LINE * sizeof(char)); } }THD_DATA; //convertir des données de type de base en chaîne template<class T> string convertToString(const T val) { string s; std::strstream ss; ss << val; ss >> s; return s; } //programme de vente de tickets DWORD WINAPI SaleTicket(LPVOID lpParameter);

SaleTickets.cpp

#include "stdafx.h" #include <windows.h> #include <iostream> #include "SaleTickets.h" using namespace std; extern HANDLE g_hMutex; //programme de vente de tickets DWORD WINAPI SaleTicket(LPVOID lpParameter) { THD_DATA* pThreadData = (THD_DATA*)lpParameter; TICKET* pSaleData = pThreadData->pTicket; while(pSaleData->nCount > 0) { //demande d'acquisition d'un verrou mutex WaitForSingleObject(g_hMutex, INFINITE); if (pSaleData->nCount > 0) { cout << pThreadData->strThreadName << "Vente de" << pSaleData->nCount -- << "-ème billet,"; if (pSaleData->nCount >= 0) { cout << "Ticket vendu avec succès ! Il reste" << pSaleData->nCount << "tickets." << endl; } else { cout << "Échec de la vente du ticket ! Le ticket est épuisé." << endl; } } Sleep(10); //libérer le verrou mutex ReleaseMutex(g_hMutex); } return 0L; }

Programme de test :

//售票系统
void Test2()
{
    //创建一个互斥量
    g_hMutex = CreateMutex(NULL, FALSE, NULL);

    //初始化火车票
    TICKET ticket;
    ticket.nCount = 100;
    strcpy(ticket.strTicketName, "北京-->赣州");

    const int THREAD_NUMM = 8;
    THD_DATA threadSale[THREAD_NUMM];
    HANDLE hThread[THREAD_NUMM];
    for(int i = 0; i < THREAD_NUMM; ++ i)
    {
        threadSale[i].pTicket = &ticket;
        string strThreadName = convertToString(i);

        strThreadName = "窗口" + strThreadName;

        strcpy(threadSale[i].strThreadName, strThreadName.c_str());

        //创建线程
        hThread[i] = CreateThread(NULL, NULL, SaleTicket, &threadSale[i], 0, NULL);

        //请求获得一个互斥量锁
        WaitForSingleObject(g_hMutex, INFINITE);
        cout << threadSale[i].strThreadName << "开始出售 " << threadSale[i].pTicket->strTicketName << " 的票..." << endl;
        //释放互斥量锁
        ReleaseMutex(g_hMutex);

        //关闭线程
        CloseHandle(hThread[i]);
    }

    system("pause");
}

Résultat :

窗口0开始出售 北京–>赣州 的票… 
窗口0出售第100的票,出票成功!剩余99张票. 
窗口1开始出售 北京–>赣州 的票… 
窗口1出售第99的票,出票成功!剩余98张票. 
窗口0出售第98的票,出票成功!剩余97张票. 
窗口2开始出售 北京–>赣州 的票… 
窗口2出售第97的票,出票成功!剩余96张票. 
窗口1出售第96的票,出票成功!剩余95张票. 
窗口0出售第95的票,出票成功!剩余94张票. 
窗口3开始出售 北京–>赣州 的票… 
窗口3出售第94的票,出票成功!剩余93张票. 
窗口2出售第93的票,出票成功!剩余92张票. 
窗口1出售第92的票,出票成功!剩余91张票. 
窗口0出售第91的票,出票成功!剩余90张票. 
窗口4开始出售 北京–>赣州 的票… 
窗口4出售第90的票,出票成功!剩余89张票. 
窗口3出售第89的票,出票成功!剩余88张票. 
窗口2出售第88的票,出票成功!剩余87张票. 
窗口1出售第87的票,出票成功!剩余86张票. 
窗口0出售第86的票,出票成功!剩余85张票. 
窗口5开始出售 北京–>赣州 的票… 
窗口5出售第85的票,出票成功!剩余84张票. 
窗口4出售第84的票,出票成功!剩余83张票. 
窗口3出售第83的票,出票成功!剩余82张票. 
窗口2出售第82的票,出票成功!剩余81张票.

Source : http://blog.csdn.net/luoweifu/article/details/46835437