Le constructeur statique de C# est-il suffisant pour l'implémentation de Singleton Thread-Safe ?

Sécurité des threads du constructeur statique C# en mode singleton

Le modèle singleton est un modèle de conception courant dans le développement de logiciels, garantissant qu'une classe n'a qu'une seule instance dans le domaine d'application. En C#, un constructeur statique est chargé d'initialiser les membres statiques d'une classe, y compris les instances dans une implémentation singleton.

Question :

L'implémentation singleton C# suivante est-elle thread-safe ?

<code class="language-C#">public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

    static Singleton()
    {
        instance = new Singleton();
    }

    public static Singleton Instance
    {
        get { return instance; }
    }
}</code>

Réponse :

Oui, le constructeur statique de cette implémentation garantit la sécurité des threads lors de la construction initiale de l'instance singleton. Selon la documentation Microsoft, les constructeurs statiques en C# sont garantis de s'exécuter une seule fois dans chaque domaine d'application avant la création d'une instance de la classe ou l'accès aux membres statiques.

Cependant, il est important de noter que cette sécurité des threads ne s'applique qu'à la construction initiale de l'instance. Cela ne garantit pas que l’utilisation ultérieure de l’instance sera synchronisée. Pour garantir une sécurité totale des threads, des mécanismes de synchronisation supplémentaires sont requis.

Une façon d'obtenir la synchronisation des threads consiste à introduire un mutex statique pour contrôler l'accès à l'instance singleton :

<code class="language-C#">public class Singleton
{
    private static Singleton instance;
    private static System.Threading.Mutex mutex;

    private Singleton() { }

    static Singleton()
    {
        instance = new Singleton();
        mutex = new System.Threading.Mutex();
    }

    public static Singleton Acquire()
    {
        mutex.WaitOne();
        return instance;
    }

    public static void Release()
    {
        mutex.ReleaseMutex();
    }
}</code>

Cette implémentation nécessite que chaque appel à Acquire() soit associé à un appel à Release(), garantissant qu'un seul thread peut accéder à l'instance singleton à la fois. En adoptant cette approche, la sécurité des threads est obtenue non seulement lors de la construction initiale, mais également lors de l'utilisation ultérieure de l'instance.

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!