DOCUMENTATION EN LIGNE
DE WINDEVWEBDEV ET WINDEV MOBILE

Aide / WLangage / Fonctions WLangage / Fonctions standard / Fonctions de gestion des traitements / Threads, sémaphores, signaux et mutex
  • Présentation
  • Qu'est-ce qu'une section critique
  • La variable SectionCritique
  • La section critique associée à une variable
  • Cas particulier
  • Exemple
  • Remarques
  • La section critique nommée
  • Le principe
  • Programmation en WLangage
  • Les fonctions de gestion des sections critiques
WINDEV
WindowsLinuxUniversal Windows 10 AppJavaEtats et RequêtesCode Utilisateur (MCU)
WEBDEV
WindowsLinuxPHPWEBDEV - Code Navigateur
WINDEV Mobile
AndroidWidget AndroidiPhone/iPadWidget IOSApple WatchMac CatalystUniversal Windows 10 App
Autres
Procédures stockées
Présentation
Les sémaphores permettent de limiter l'exécution simultanée d'un code (procédure, ligne de code, ...) à un ou plusieurs threads à un instant donné. Un sémaphore peut être partagé par plusieurs applications.
D'autres systèmes permettent également de protéger une partie de code :
  • Les mutex permettent de limiter l'exécution simultanée d'un code (procédure, ligne de code, ...) à un thread à un instant donné. Un mutex peut être partagé par plusieurs applications. Pour plus de détails, consultez Gérer les mutex dans les threads.
  • Les sections critiques : Une section critique est un sémaphore limité à un seul thread sur une seule portion de code (traitement, procédure, ...).
Qu'est-ce qu'une section critique
Une section critique est un sémaphore limité à un seul thread sur une seule portion de code (traitement, procédure, ...).
Au contraire des sémaphores, une section critique ne peut être utilisée qu'une seule fois.
Par exemple, il est possible d'utiliser une section critique pour protéger une procédure de mise à jour des champs d'une fenêtre.
Remarque : Les sections critiques sont uniques pour l'application qui les a créés. Elles ne peuvent pas être partagées entre plusieurs applications.
WINDEV, WEBDEV et WINDEV Mobile proposent plusieurs méthodes pour mettre en place les sections critiques.
La variable SectionCritique
Le type de variable SectionCritique permet de mettre en place simplement une section critique grâce à la syntaxe UTILISER .. DANS.
Exemple :
s est un SectionCritique
using s DANS
	// code protégé par la section critique
	// un seul thread pourra exécuter ce code à un moment donné

FIN
Remarques :
  • Le type SectionCritique permet de simplifier la déclaration des sections critiques.
  • Les variables de type SectionCritique respectent les règles de portée de variables.
La section critique associée à une variable
Lors de la déclaration d'une variable, il est possible d'associer cette variable à une section critique en utilisant l'attribut section critique.
La syntaxe est la suivante :
NomVariable est un TypeVariable <section critique>

ou

NomVariable est un TypeVariable, section critique
Les portions de code qui manipulent ces variables doivent ensuite être encadrées par les fonctions SectionCritiqueDébut et SectionCritiqueFin.

Cas particulier

Une section critique est automatiquement associée aux variables sur lesquelles des opérations simples sont effectuées, telles que :
  • affectation d'une valeur.
  • récupération d'une valeur.
  • incrémentation, décrémentation (opérateurs +, -, ++, --, +=, -=).

Exemple

// Déclarations globales de la fenêtre FEN_STAT
gmoSomme est un monétaire, section critique
gmoMax est un monétaire, section critique
...
// Code exécuté par plusieurs threads
moMontantCommande est un monétaire 
...
// opération atomique, la section critique est gérée automatiquement par le WLangage
gmoSomme += moMontantCommande

// opération multiple, il est nécessaire de mettre en place la section critique explicitement
using SectionCritique(gmoMax) DANS
	SI moMontantCommande > gmoMax ALORS
		gmoMax = moMontantCommande
	FIN
FIN

Remarques

  • L'attribut section critique est autorisé sur :
    • les variables globales de projet, collection de procédures, fenêtre, page et état.
    • les variables locales.
    • les membres de classes.
    • les tableaux : dans ce cas, l'attribut est associé au tableau et pas aux éléments du tableau.
  • Les files et les piles sont nativement protégées : l'attribut section critique n'est pas nécessaire.
La section critique nommée

Le principe

La section critique est définie par la fonction SectionCritiqueDébut et terminée par la fonction SectionCritiqueFin.
Le nom de la sectionCritique est passé en paramètre à ces fonctions à l'aide d'une chaîne de caractères.
Exemple :
// Utilisation d'une section critique nommée
SectionCritiqueDébut("MaSection")
// Deux threads ne pourront pas exécuter ce code en même temps
...
SectionCritiqueFin("MaSection")
Ce mode d'utilisation des sections critiques comporte plusieurs inconvénients :
  • risque de collisions entre plusieurs sections critiques de même nom.
  • sections critiques jamais libérées.
Programmation en WLangage

Les fonctions de gestion des sections critiques

Les fonctions du WLangage spécifiques à la gestion des sections critiques sont les suivantes :
SectionCritiqueActive une section critique nommée ou sur une variable dans une instruction de type UTILISER ... DANS.
SectionCritiqueDébutSignale le début d'une section critique : aucun autre thread ne pourra exécuter le code tant que le thread courant ne sera pas sorti de la section critique.
SectionCritiqueFinSignale la fin d'une section critique : un autre thread pourra exécuter le code.
Pour manipuler les sections critiques, il est également possible d'utiliser le type suivant :
SectionCritiqueLes variables de type SectionCritique permettent de définir des sections critiques afin de limiter l'exécution simultanée d'un code (procédure, ligne de code, ...) à un thread à un instant donné dans une seule application.
Liste des exemples associés :
WD ThreadUI Exemples didactiques (WINDEV) : WD ThreadUI
[ + ] L'utilisation de threads ou de tâches parallèles est très souvent obligatoire afin de répondre au besoin de rapidité des utilisateurs.
Avec le WLangage de WINDEV, le lancement de traitements en tâche de fond est simplifié à l'extrême avec :
- les fonctions de gestion des threads,
- le type Thread,
- les tâches parallèles.
Mais attention, s'il est facile de lancer un traitement en arrière plan, il faut néanmoins être précautionneux sur l'UI de l'application : seuls les traitements exécutés dans le thread principal sont autorisés à mettre à jour l'interface (affecter un champ, remplir une liste, combo, table, zone répétée...).
Cet exemple vous montre 4 façons de mettre à jour l'UI de vos applications avec des données provenant de threads secondaires.
Version minimum requise
  • Version 9
Documentation également disponible pour…
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire

Dernière modification : 07/05/2024

Signaler une erreur ou faire une suggestion | Aide en ligne locale