C semaphore - Historique des versions

Magsss : /* Initialisation */

2018-11-01T18:05:04Z

Initialisation

← Version précédente		Version du 1 novembre 2018 à 20:05
Ligne 22 :		Ligne 22 :
	</source>		</source>
	*semaphore → pointeur vers le sémaphore à initialiser ;		*semaphore → pointeur vers le sémaphore à initialiser ;
	*pshared → ~~drapeaux~~ qui précise si le sémaphore est utilisé par des threads (valeur ''0'') ;		*pshared → drapeau qui précise si le sémaphore est utilisé par des threads (valeur ''0'') ;
	*valeur → valeur de départ du sémaphore.		*valeur → valeur de départ du sémaphore.
	* le code retour varie entre:		* le code retour varie entre:
	** '0' si tout s'est bien passé		** '0' si tout s'est bien passé
	** '1' si une erreur survient et errno est positionné		** '1' si une erreur survient et errno est positionné

	== Blocage ==		== Blocage ==
	Une fois le sémaphore initialisé, on peut demander son blocage avec		Une fois le sémaphore initialisé, on peut demander son blocage avec

Magsss : /* Introduction */

2018-11-01T18:04:21Z

Introduction

← Version précédente		Version du 1 novembre 2018 à 20:04
Ligne 4 :		Ligne 4 :
	On peut se demander quelle est la différence avec un [[C_pthread#Exclusion_mutuelle \| mutex]] ?		On peut se demander quelle est la différence avec un [[C_pthread#Exclusion_mutuelle \| mutex]] ?

	Un [[C_pthread#Exclusion_mutuelle \| mutex]] est un mécanisme de verrouillage utilisé pour synchroniser l'accès à une ressource alors qu'un sémaphore est un mécanisme de signalisation utilisé pour sérialiser l'exécution dans une portion de code. Un peu comme si les processus se ~~passer~~ le mot: "J'ai fini, tu peux y aller".		Un [[C_pthread#Exclusion_mutuelle \| mutex]] est un mécanisme de verrouillage utilisé pour synchroniser l'accès à une ressource alors qu'un sémaphore est un mécanisme de signalisation utilisé pour sérialiser l'exécution dans une portion de code. Un peu comme si les processus se passaient le mot: "J'ai fini, tu peux y aller".

	= Utilisation=		= Utilisation=

Jc.forton : /* Blocage */

2018-10-25T07:34:37Z

Blocage

← Version précédente		Version du 25 octobre 2018 à 09:34
Ligne 73 :		Ligne 73 :
	[[Fichier:Warning-icon.png\|40px]]		[[Fichier:Warning-icon.png\|40px]]
	\|valign="top"\|		\|valign="top"\|
	Cette fonction est ~~non~~ bloquante le temps spécifié !		Cette fonction est bloquante le temps spécifié !
	\|}		\|}
	Voici le détail de la structure ''timespec'':		Voici le détail de la structure ''timespec'':

Jc.forton : /* Blocage */

2018-10-25T07:34:07Z

Blocage

← Version précédente		Version du 25 octobre 2018 à 09:34
Ligne 61 :		Ligne 61 :
	<source lang="c">		<source lang="c">
	#include <semaphore.h>		#include <semaphore.h>
			#include <time.h>

	int sem_timedwait(sem_t semaphore, const struct timespec abs_timeout);		int sem_timedwait(sem_t semaphore, const struct timespec abs_timeout);
Ligne 81 :		Ligne 82 :
	};		};
	</source>		</source>

	== Relâchement d'un sémaphore ==		== Relâchement d'un sémaphore ==
	Une fois la section critique passée, on peut relâcher le sémaphore:		Une fois la section critique passée, on peut relâcher le sémaphore:

Jc.forton : Page créée avec « = Introduction = Les sémaphores permettent de gérer ce que l'on appelle les sections critiques. Il y a des parties de code où l'on souhaite que toutes les instructions... »

2018-10-22T18:36:04Z

Page créée avec « = Introduction = Les sémaphores permettent de gérer ce que l'on appelle les sections critiques. Il y a des parties de code où l'on souhaite que toutes les instructions... »

Nouvelle page

= Introduction =
Les sémaphores permettent de gérer ce que l'on appelle les sections critiques. Il y a des parties de code où l'on souhaite que toutes les instructions soient exécutées en évitant les interblocages un peu comme avec un [[C_pthread#Exclusion_mutuelle | mutex]].

On peut se demander quelle est la différence avec un [[C_pthread#Exclusion_mutuelle | mutex]] ?

Un [[C_pthread#Exclusion_mutuelle | mutex]] est un mécanisme de verrouillage utilisé pour synchroniser l'accès à une ressource alors qu'un sémaphore est un mécanisme de signalisation utilisé pour sérialiser l'exécution dans une portion de code. Un peu comme si les processus se passer le mot: "J'ai fini, tu peux y aller".

= Utilisation=
== Création ==
Tout d'abord, il faut créer un objet de type sémaphore:
<source lang="c">
#include <semaphore.h>

sem_t semaphore;
</source>
== Initialisation ==
Une fois l'objet créé, on peut l'initialiser:
<source lang="c">
#include <semaphore.h>

int sem_init(sem_t *semaphore, int pshared, unsigned int valeur);
</source>
*semaphore → pointeur vers le sémaphore à initialiser ;
*pshared → drapeaux qui précise si le sémaphore est utilisé par des threads (valeur ''0'') ;
*valeur → valeur de départ du sémaphore.
* le code retour varie entre:
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné
== Blocage ==
Une fois le sémaphore initialisé, on peut demander son blocage avec
<source lang="c">
#include <semaphore.h>

int sem_wait(sem_t *semaphore);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
{|style="width:350px" align="center"
|
[[Fichier:Warning-icon.png|40px]]
|valign="top"|
Cette fonction est bloquante !
|}
<source lang="c">
#include <semaphore.h>

int sem_trywait(sem_t *semaphore);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
{|style="width:380px" align="center"
|
[[Fichier:Warning-icon.png|40px]]
|valign="top"|
Cette fonction est non bloquante !
|}
<source lang="c">
#include <semaphore.h>

int sem_timedwait(sem_t *semaphore, const struct timespec *abs_timeout);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
{|style="width:380px" align="center"
|
[[Fichier:Warning-icon.png|40px]]
|valign="top"|
Cette fonction est non bloquante le temps spécifié !
|}
Voici le détail de la structure ''timespec'':
<source lang="c">
struct timespec {
time_t tv_sec; /* Seconds */
long tv_nsec; /* Nanoseconds [0 .. 999999999] */
};
</source>
== Relâchement d'un sémaphore ==
Une fois la section critique passée, on peut relâcher le sémaphore:
<source lang="c">
#include <semaphore.h>

int sem_post(sem_t *semaphore);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
=Exemple=
Ci-dessous un exemple d'utilisation d'un sémaphore:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <errno.h>
#include <semaphore.h>

#define NB_THREAD 4
#define LIMIT 2

// Création du sémaphore;
sem_t semaphore;

void * job(void * args) {
// Récupération de l'identifiant du thread
int tid = pthread_self();
int i = 0;
while (i < LIMIT) {
// On attend la disponibilité du sémaphore
sem_wait(&semaphore);
// Section critique
printf("Je suis le thread [%i] et je vais dormir 1 seconde\n", tid);
sleep(1);
printf("Je suis le thread [%i] et j'ai fini ma sieste\n", tid);
// On relache le sémaphore
sem_post(&semaphore);
i++;
}
pthread_exit(EXIT_SUCCESS);
}

int main() {
// Création d'un tableau de thread
pthread_t threads[NB_THREAD];
// Initialisation du sémaphore
sem_init(&semaphore, PTHREAD_PROCESS_SHARED, 1);
for (int i = 0; i < NB_THREAD; i++) {
int err;
if ((err = pthread_create(&threads[i], NULL, job, NULL)) != 0) {
printf("Echec de la création du thread: [%s]", strerror(err));
return EXIT_FAILURE;;
}
printf("Création du thread numéro %i\n", i);
}
for (int i = 0; i < NB_THREAD; i++) {
pthread_join(threads[i], NULL);
}
sem_destroy(&semaphore);
return EXIT_SUCCESS;
}
</source>
Ce programme donne, par exemple, la sortie suivante:
<pre>
Création du thread numéro 0
Création du thread numéro 1
Création du thread numéro 2
Création du thread numéro 3
Je suis le thread [-1171347712] et je vais dormir 1 seconde
Je suis le thread [-1171347712] et j'ai fini ma sieste
Je suis le thread [-1171347712] et je vais dormir 1 seconde
Je suis le thread [-1171347712] et j'ai fini ma sieste
Je suis le thread [-1192327424] et je vais dormir 1 seconde
Je suis le thread [-1192327424] et j'ai fini ma sieste
Je suis le thread [-1192327424] et je vais dormir 1 seconde
Je suis le thread [-1192327424] et j'ai fini ma sieste
Je suis le thread [-1181837568] et je vais dormir 1 seconde
Je suis le thread [-1181837568] et j'ai fini ma sieste
Je suis le thread [-1181837568] et je vais dormir 1 seconde
Je suis le thread [-1181837568] et j'ai fini ma sieste
Je suis le thread [-1160857856] et je vais dormir 1 seconde
Je suis le thread [-1160857856] et j'ai fini ma sieste
Je suis le thread [-1160857856] et je vais dormir 1 seconde
Je suis le thread [-1160857856] et j'ai fini ma sieste
</pre>
On voit bien les threads exécuter la section critique les uns après les autres !

C semaphore - Historique des versions

Magsss : /* Initialisation */

Magsss : /* Introduction */

Jc.forton : /* Blocage */

Jc.forton : /* Blocage */

Jc.forton : Page créée avec « = Introduction = Les sémaphores permettent de gérer ce que l'on appelle les sections critiques. Il y a des parties de code où l'on souhaite que toutes les instructions... »

Magsss : /* Initialisation */

Magsss : /* Introduction */

Jc.forton : /* Blocage */

Jc.forton : /* Blocage */

Jc.forton : Page créée avec « = Introduction = Les sémaphores permettent de gérer ce que l'on appelle les sections critiques. Il y a des parties de code où l'on souhaite que toutes les instructions... »