double contrôle de verrouillage en motif singleton

il peut être question de base

avoir un singleton en environnement multithread, nous pouvons utiliser un verrou. Veuillez consulter l'extrait de code. Mais pourquoi avons-nous besoin d'un double contrôle de verrouillage dans le pattern singleton? Et de plus ce n'est vérifié blocage des moyens?

class singleton
{
    private static singleton instance = null;
    private static singleton() { }

    private static object objectlock = new object();

    public static singleton Instance
    {
        get
        {

            lock (objectlock) //single - check lock
            {
                if (instance == null)
                {
                    instance = new singleton();
                }

                return instance;
            }
        }

    }
}

source d'informationauteur Raghav55 | 2011-05-10

  1. 24

    Jon Skeet explique cela en détail.

    Serrures sont chers.

    Si l'objet existe déjà, il n'y a aucun intérêt à prendre un verrou.

    Ainsi, vous avez une première vérification à l'extérieur de la serrure.

    Cependant, même si l'objet n'existait pas avant de vous a pris le look, un autre thread peut avoir créé entre les if de la condition et de la lock déclaration.

    Par conséquent, vous devez vérifier à nouveau l'intérieur de la serrure.

    Cependant, la meilleure façon de rédiger un singleton est d'utiliser un static constructeur:

    public sealed class Singleton
{
    private Singleton()
    {
    }

    public static Singleton Instance { get { return Nested.instance; } }

    private class Nested
    {
        //Explicit static constructor to tell C# compiler
        //not to mark type as beforefieldinit
        static Nested()
        {
        }

        internal static readonly Singleton instance = new Singleton();
    }
}
  2. 3

    Et avec .Net 4.x et versions plus récentes, vous devriez reporter à la paresse de classe lorsque c'est possible que ce modèle est utilisé à l'Initialisation Et à la Publication de l'option. (remarque: l'inverse est également disponible où la création n'est pas thread-safe, mais la publication de l'instance est par l'intermédiaire de l'option de Publication)

  3. 2

    Multithread Singleton : La meilleure approche à utiliser la double vérification de verrouillage

    public sealed class Singleton
{
   private static volatile Singleton _instance;
   private static readonly object InstanceLoker= new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (_instance == null) 
         {
            lock (InstanceLoker) 
            {
               if (_instance == null) 
                  _instance = new Singleton();
            }
         }

         return _instance;
      }
   }
}
  4. 2

    La "meilleure" façon je sais, c'est

    public class MySingleton {
    //object for synchronization
    private static readonly object syncRoot = new object();
    //the singleton instance
    private static MySingleton @default;

    public static MySingleton Default {
        get {
            //geting singleton instance without locking
            var result = @default;
            //if result is NOT null, no additional action is required
            if ( object.ReferenceEquals(result, null) ){
                //lock the synchronization object
                lock(syncRoot) {
                    //geting singleton instanc in lock - because
                    //the value of @default field could be changed
                    result = @default;

                    //checking for NULL
                    if ( object.ReferenceEquals(result, null) ) {
                        //if result is NULL, create new singleton instance
                        result = new MySingleton();
                        //set the default instance
                        @default = result;
                    }
                }
            }

            //return singleton instance
            return result;
        }
    }
}
  5. 1

    Si vous créez l'objet dans le champ initialiser, vous n'avez pas besoin de la serrure:

    class singleton
{
    private static singleton instance = new singleton();
    private static singleton() { }

    public static singleton Instance
    {
        get { return instance; }
    }
}

    Aussi garder à l'esprit que la serrure est seulement le contrôle de la création de l'objet, l'objet, encore faudrait-il être thread-safe si vous l'utilisez dans plusieurs threads.

  6. 1

    Lorsque nous essayons d'exécuter la méthode de la classe singleton à l'aide de bibliothèques en Parallèle. Il ne reconnaît pas le singleton de comportement à cause de multi threading est en cours d'exécution dans le TPL qui provoque l'échec du concept de Pattern Singleton . Pour surmonter ce problème, il existe le concept de verrouillage de l'objet de sorte qu'à un moment, un seul thread peut accéder.
    Mais ce n'est pas efficace, car l'implication de verrouillage de la vérification de créer des montres à l'objet. Pour éviter cela, nous utilisons le “Double verrouillage de la vérification de la”

    double contrôle de verrouillage en motif singleton