C# Singleton seguro para subprocesos

Question

tengo una clase Singleton similar a este

public class Singleton 
{ 
    private static Singleton m_instance; 
    private Timer m_timer; 
    private static List<CustomObject> m_cacheObjects; 

    private Singleton() 
    {  
     m_cacheObjects = new List<CustomObject>(); 
     m_timer= new Timer(MyTimerCallBack, 
          null, 
          TimeSpan.FromSeconds(60), 
          TimeSpan.FromSeconds(60));   
    } 

    public static Singleton Instance 
    { 
     get 
     { 
      if (m_instance == null) 
      { 
       m_instance = new Singleton(); 
      } 
      return m_instance; 
     } 
    } 

    private void MyTimerCallBack(object state) 
    { 
     //******** Update the list by interval here ****************** 

     m_cacheObjects = UpdateTheList(); 
    } 

    public void CallMe() 
    { 
     foreach (CustomObject obj in m_cacheObjects) 
     { 
      // do something here based on obj 

      // The question is, does the m_cacheObjects is thread safe?? 
      // what happen if the m_cacheObjects is changed 
      // during the loop interation? 
     } 
    } 
} 

El método CallMe

será llamado por servicio web:

[WebMethod] 
    public void CallMeWebService() 
    { 
     Singleton.Instance.CallMe(); 
    } 

Las preguntas: 1) es el m_cacheObjects es hilo ¿seguro? ¿Qué ocurre si se cambia m_cacheObjects (debido al temporizador) durante la interacción del bucle (en CallMe())?

2) ¿Se creará un nuevo subproceso cuando se llame al servicio web CallMeWebService()?

Answer 1

Este es un muy buen recurso sobre cómo implementar el patrón singleton de una manera segura hilo: http://msdn.microsoft.com/en-us/library/ff650316.aspx

public sealed class Singleton 
{ 
    private static volatile Singleton instance; 
    private static object syncRoot = new Object(); 

    private Singleton() {} 

    public static Singleton Instance 
    { 
     get 
     { 
    if (instance == null) 
    { 
     lock (syncRoot) 
     { 
      if (instance == null) 
      instance = new Singleton(); 
     } 
    } 

    return instance; 
     } 
    } 
} 

Esto simplemente se asegura de que nunca habrá más de una instancia. También necesita aplicar el bloqueo para su método personalizado.

public void CallMe() 
{ 
    lock (syncRoot) 
    { 
     foreach (CustomObject obj in m_cacheObjects) 
     { 
      // do something here based on obj 
     } 
    } 
} 

Answer 2

1: No, una lista estática no es automáticamente segura para subprocesos; debe proteger m_cacheObjects manualmente

2: Es un detalle de implementación; a primera vista, parece que se expone a sí mismo como un método de sincronización, pero cómo lo hace por completo

En realidad, su inicialización estática tampoco es segura para subprocesos; Podría usar fuerza bruta en un escenario donde se usaron dos instancias diferentes de Singleton. Tomaría repetición producirlo, pero sucedería.

Francamente, a menos que tenga una muy buena razón para no hacerlo, el patrón Singleton más simple pero más seguro es simplemente:

private static readonly Singleton m_instance = new Singleton(); 

Answer 3

No es seguro para subprocesos.

creo que usaría una cerraduratanto en 'MyTimerCallBack' y los métodos 'CallMe'

Answer 4

me gustaría sugerir que tiene aread sobre el artículo de Jon Skeets sobre cómo crear conjuntos unitarios de seguridad de rosca encima en http://csharpindepth.com/Articles/General/Singleton.aspx

Answer 5

1) No, m_cacheObjects no es seguro para subprocesos.

2) Sí, se creará un nuevo subproceso (bueno, puede que no sea un subproceso nuevo, sino un subproceso tomado del grupo de subprocesos).

Deberá proteger m_cacheObjects con la declaración lock.Además, en el método CallMe Me gustaría recomendar para crear una copia local de m_cacheObjects: Método

// create new field syncRoot 
private static readonly object syncRoot = new object(); 

Nueva CallMe:

List<CustomObject> localCopy; 
lock (syncRoot) 
{ 
    localCopy = new List<CustomObject>(m_cacheObjects); 
} 

foreach (var nextObject in localCopy) 
{ 
// Do some work 
} 

y actualizada MyTimerCallBack método:

lock (syncRoot) 
{ 
    m_cacheObjects = UpdateTheList(); 
} 

Y por favor también implemente Singleton seguro para subprocesos (lea otras respuestas para más detalles).

Answer 6

//using System.Runtime.CompilerServices; 

private static volatile Singelton _instance; 

public static Singelton Instance 
{ 
    [MethodImpl(MethodImplOptions.Synchronized)] 
    get 
    { 
     if (_instance == null) 
     { 
      _instance = new Singelton(); 
     } 
     return _instance; 
    } 
} 

Explicar:

[MethodImpl (MethodImplOptions.Synchronized)] Esto le dirá al compilador que el acceso a la "Instancia" está "sincronizado" por lo que el sistema se encargue de las llamadas a este parámetro.

Esto es Thread-Safe.

EDIT: (También, el "bloqueo()" ejemplos no son seguros Coz, u puede desactivar la seguridad hilo con "Monitor.Exit (Singleton);"!)