Est-ce que « const » en C 11 garantit la sécurité des threads ?

« const » implique-t-il la sécurité des threads en C 11 ?

Introduction

Il est largement admis que l'emploi de « const » en C 11 garantit le thread sécurité. Cependant, cette notion nécessite des éclaircissements supplémentaires.

Clarifier l'affirmation

Bien que « const » à lui seul ne garantisse pas la sécurité des threads, il répond aux attentes de la bibliothèque standard selon laquelle les opérations sur les objets « const » sont des threads. sûr. Plus précisément :

• Les opérations marquées « const » doivent entièrement consister en des lectures (pas d'écritures) ou synchroniser en interne des écritures.
• La bibliothèque standard suppose que toutes les opérations sur les objets « const » en elle-même être non-racing (tant que ses arguments non-const gèrent la concurrence).
• Si les opérations d'un type sur son Les objets 'const' violent cette attente, l'utilisation de ce type avec la bibliothèque standard pourrait entraîner des courses de données et un comportement indéfini.

Const n'est pas égal à la synchronisation de Java

Contrairement à la synchronisation de Java, ' 'const' ne fournit pas intrinsèquement de synchronisation. Prenons l'exemple suivant :

class rect {
    int width = 0, height = 0;

public:
    void set_size(int new_width, int new_height) {
        width = new_width;
        height = new_height;
    }
    int area() const {
        return width * height;
    }
};

• La fonction 'area()' est thread-safe car elle lit uniquement, pas n'écrit.
• Cependant, 'rect' lui-même n'est pas thread-safe car il ne synchronise pas les opérations d'écriture effectuées par 'set_size()'.

Sécurité conditionnelle des threads avec 'const'

Pour utiliser correctement 'const' pour la sécurité des threads avec les écritures, l'état mutable (comme une valeur de zone mise en cache) doit être protégé par des primitives de synchronisation, comme démontré ci-dessous :

class rect {
    int width = 0, height = 0;

    mutable std::mutex cache_mutex;
    mutable int cached_area = 0;
    mutable bool cached_area_valid = true;

public:
    void set_size(int new_width, int new_height) {
        if (new_width != width || new_height != height) {
            std::lock_guard guard(cache_mutex);
            cached_area_valid = false;
        }
        width = new_width;
        height = new_height;
    }
    int area() const {
        std::lock_guard guard(cache_mutex);
        if (!cached_area_valid) {
            cached_area = width * height;
            cached_area_valid = true;
        }
        return cached_area;
    }
};

Bien que 'area()' soit thread-safe, 'rect' reste toujours non-thread-safe en raison d'écritures non protégées dans 'set_size()'.

Pénurie de mots-clés

L'affirmation selon laquelle les développeurs C manquent de mots-clés est vraie, car le langage a un nombre limité de mots réservés depuis sa création.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!