C Language
Atomique

algorithm Android C# Language C++ iOS Java Language GNU/Linux Objective-C Language opencv Python Language
Recherche…


Syntaxe

  • #ifdef __STDC_NO_ATOMICS__
  • # error this implementation needs atomics
  • #endif
  • #include <stdatomic.h>
  • _Atomic counter non signé = ATOMIC_VAR_INIT (0);

Remarques

Atomics dans le cadre du langage C est une fonctionnalité optionnelle disponible depuis C11.

Leur objectif est de garantir un accès sans race aux variables partagées entre différents threads. Sans qualification atomique, l'état d'une variable partagée serait indéfini si deux threads y accèdent simultanément. Par exemple, une opération d'incrémentation ( ++ ) peut être divisée en plusieurs instructions d'assembleur, une lecture, l'addition elle-même et une instruction de stockage. Si un autre thread effectuait la même opération, ses deux séquences d'instructions pourraient être entrelacées et entraîner un résultat incohérent.

  • Types: Tous les types d'objets à l'exception des types de tableaux peuvent être qualifiés avec _Atomic .

  • Opérateurs: Tous les opérateurs de lecture-modification-écriture (par exemple ++ ou *= ) sur ceux-ci sont garantis atomiques.

  • Opérations: Il existe d'autres opérations spécifiées en tant que fonctions génériques de type, par exemple atomic_compare_exchange .

  • Threads: il est garanti que l'accès à ces threads ne produira pas de race de données lorsqu'ils sont accessibles par différents threads.

  • Gestionnaires de signaux: Les types atomiques sont appelés sans verrouillage si toutes les opérations sur eux sont sans état. Dans ce cas, ils peuvent également être utilisés pour traiter les changements d'état entre un flux de contrôle normal et un gestionnaire de signal.

  • Un seul type de données est garanti sans verrou: atomic_flag . C'est un type minimal dont les opérations sont destinées à être mappées sur des instructions matérielles efficaces de test et de configuration.

D'autres moyens d'éviter les conditions de mtx_t sont disponibles dans l'interface de thread de C11, en particulier un type de mutex mtx_t pour exclure mutuellement les threads d'accès aux données critiques ou les sections critiques du code. Si les atomes ne sont pas disponibles, ils doivent être utilisés pour empêcher les courses.

atomiques et opérateurs

Les variables atomiques sont accessibles simultanément entre différents threads sans créer de conditions de course. 

/* a global static variable that is visible by all threads */
static unsigned _Atomic active = ATOMIC_VAR_INIT(0);


int myThread(void* a) {
  ++active;         // increment active race free
  // do something
  --active;         // decrement active race free
  return 0;
}

Toutes les opérations lvalue (opérations qui modifient l'objet) autorisées pour le type de base sont autorisées et ne conduisent pas à des conditions de concurrence entre les différents threads qui y accèdent.

  • Les opérations sur des objets atomiques sont généralement des ordres de grandeur plus lents que les opérations arithmétiques normales. Cela inclut également les opérations simples de chargement ou de stockage. Vous ne devez donc les utiliser que pour des tâches critiques.
  • Opérations arithmétiques habituelles et affectation telles que a = a+1; sont en fait trois opérations sur a : tout d' abord une charge, puis addition et enfin un magasin. Ce n'est pas gratuit. Seule l'opération a += 1; et a++; sont.


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow