Aucun titre de diapositive

1
LES THREADS EN C SOUS NT
1) Rappels sur les threads 2) Comment créer une
thread 3) Attributs et variables des threads 4)
Concurrences des threads (mutex, sémaphore)
Cyril TATTEVIN Jeudi 12 Octobre 2000 IR5
2
I) RAPPELS SUR LES THREADS
A quoi ça sert
SYSTEME
PROCESS
PROCESS
3
I) RAPPELS SUR LES THREADS
Intérêt

• Si méthode B plus courte -gt pas besoin
  d attendre A
• Accès aux entrées sorties accélérés
• Plusieurs processeurs se partagent les threads
• Profiter du temps CPU pour faire travailler
  plusieurs threads

4
II) COMMENT CRÉER UNE THREAD
Modélisation en C

• 1 thread est une fonction C qui s exécute
  en parallèle du programme qui l appelle.

Void main (void) int i creationthread(fonctionT
hread) for (i0ilt10i) printf(main i
d\n ,i)
int fonctionThread(void) int i for
(i0ilt10i) printf(thread i d\n ,i)
5
II) COMMENT CRÉER UNE THREAD
main i 0 main i 1 main i 2 thread i
0 thread i 1 main i 3 main i 4 thread i
2 thread i 3 main i 5 main i 6 thread i
4 thread i 5 thread i 6 main i 7 main i
8 thread i 7 thread i 8 thread i 9 main i
9

• Le système alterne entre les threads du main
• On ne peut pas savoir dans quel ordre seront
  exécutés les threads
• Si on relance immédiatement le programme, le
  résultat ne sera sûrement pas exactement le
  même

Résultat
6
II) COMMENT CRÉER UNE THREAD
Exemple
include ltstdio.hgt include
ltwindows.hgt DWORD WINAPI ThreadFunc(LPVOID
lpParam) int i for (i0ilt10i)
printf("Thread i d\n", i) return 0
// valeur retournée au système int
main ( void ) DWORD dwThreadId, dwThrdParam
1 HANDLE hThread //
descripteur du thread int i // création du
thread hThread CreateThread( NULL, 0,
ThreadFunc,
dwThrdParam, 0, dwThreadId )
if (hThread NULL) // test
valeur de retour return 1 for (i0ilt10i)
printf("Main i d\n",i) CloseHandle( hThread
) // fermeture du descripteur return 0
DWORD unsigned long
Paramètres de la fonction CreateThread() NULL
no security attributes 0 use default stack
size ThreadFunc fonction à exécuter
dwThrdParam argument de la fonction 0
flags de création par défaut / suspend dwThreadI
d retourne le thread id
7
III) ATTRIBUTS ET VARIABLES DES THREADS
Paramètres de la fonction CreateThread()
NULL 0 ThreadFunc param 0 id

• CreateThread() retourne un HANDLE (descripteur)
  si création réussie sinon NULL (GetLastError())

• CloseHandle() ferme le descripteur mais ne ferme
  pas le thread (ExitThread)

8
III) ATTRIBUTS ET VARIABLES DES THREADS
Priorité des threads
main i 0 main i 1 thread i 0 thread i
1 thread i 2 thread i 3 thread i 4 thread i
5 thread i 6 thread i 7 thread i 8 thread
i 9 main i 2 main i 3 main i 4 main i
5 main i 6 main i 7 main i 8 main i 9

• La priorité est seulement un des paramètres de
  l ordonnancement des tâches par le processeur.

• Priorité par défaut 0
• Fonction pour connaître priorité d un thread
• int GetThreadPriority(HANDLE hThread)
• Fonction pour définir la priorité d un thread
  
• BOOL SetThreadPriority(HANDLE hThread, int
  nPriority)
• Si priorité positionné à THREAD_PRIORITY_HIGHEST
• alors priorité priorité 2

9
IV) CONCURRENCE DES THREADS
Problèmes de programmes multi-thread

• Problème si plusieurs threads accèdent à la même
• ressource (ex si un thread lit et l autre
  écrit on ne sait pas ce qui sera lu,
  l ancienne valeur, la nouvelle ou un mélange
  des deux).

• cas de deadlocks deux threads sont bloqués
  car en attente chacun l un
• de l autre
• cas de race conditions un thread t1 doit
  recevoir des infos d un autre thread t2 mais
  t2 se termine avant t1

10
IV) CONCURRENCE DES THREADS
Synchronisation des threads
Event Active thread si événement est apparu
Mutex Peut être possédé par un seul thread à
la fois. Permet aux threads l accès exclusif
à une ressource partagée. Sémaphore Limite le
nombre de thread qui accède simultanément à
une ressource partagée entre un minimum et un
maximum. Waitable timer Précise aux threads
quun temps spécifié a été atteint, quil faut
rendre la main.
11
IV) CONCURRENCE DES THREADS
Mutex
Etat Possédé (par un seul thread à la fois)
ou libre. Permet aux threads l accès exclusif
à une ressource partagée
Exemple Pour synchroniser l écriture de
plusieurs threads dans un fichier log, on
n autorise que le thread qui a le mutex à
écrire. Les autres attendent (temps limité ou
infini) que le mutex soit libéré. Lorsque le
thread qui écrit dans le fichier log a
terminé, il libère le mutex et le premier thread
qui peut le prendre pourra à son tour écrire
dans le fichier log.
Création en C HANDLE hMutex // descripteur du
mutex hMutex CreateMutex( NULL, // no
security attributes FALSE, // initially not
owned "MutexToProtectDatabase  // nom du
mutex ) if (hMutex NULL) // Check for
error.
12
IV) CONCURRENCE DES THREADS
Mutex attente du mutex pour écrire dans une DB
BOOL FunctionToWriteToDatabase(HANDLE hMutex)
DWORD dwWaitResult // Request ownership of
mutex. dwWaitResult WaitForSingleObject(
hMutex, INFINITE) // bloque indéfiniment switch
(dwWaitResult) case WAIT_OBJECT_0 // Le
thread est possédé try // Ecriture dans DB
finally // Libération du mutex une fois
écriture terminée if (! ReleaseMutex(hMutex))
//problème libération break case
WAIT_TIMEOUT // time out atteint return
FALSE case WAIT_ABANDONED // Objet abandoné
return FALSE return TRUE
13
IV) CONCURRENCE DES THREADS
Sémaphore
Objectif Limiter le nombre de thread qui
accède simultanément à une ressource partagée
entre un minimum et un maximum.
Exemple Cela permet par exemple de limiter le
nombre de fenêtres graphiques ouvertes
simultanément.
Création en C HANDLE hSemaphore LONG cMax
10, cPreviousCount // Créer un sémaphore avec
initial and max. 10. hSemaphore
CreateSemaphore( NULL, // no security
attributes cMax, // initial count cMax, //
maximum count NULL) // unnamed semaphore if
(hSemaphore NULL) // Check for error.
14
IV) CONCURRENCE DES THREADS
Sémaphore gestion du nombre de fenêtre ouverte
HANDLE hSemaphore DWORD dwWaitResult //
Résultat si sémaphore disponible ou
non dwWaitResult WaitForSingleObject( // Test
pour avoir le sémaphore hSemaphore, //
descripteur du sémaphore 0L) // pas de
délai d attente switch (dwWaitResult) case
WAIT_OBJECT_0 // sémaphore disponible //
Création de la fenêtre break case
WAIT_TIMEOUT // sémaphore indisponible //
Impossible de créer la fenetre break