Menu
We implemented a lazy loaded singleton using double locking on get to make sure the instance is only initialized once (and not twice due to thread race conditions).
I was wondering if simply using Lazy<T> is a good solution for this problem?
I.E.
private static Lazy<MyClass> _instance = new Lazy<MyClass>(() => return new MyClass()); public static MyClass Instance { get { return _instance.Value; } } 
634
By default, Lazy<T> objects are thread-safe. That is, if the constructor does not specify the kind of thread safety, the Lazy<T> objects it creates are thread-safe.
Is singleton thread safe? A singleton class itself is not thread safe. Multiple threads can access the singleton same time and create multiple objects, violating the singleton concept. The singleton may also return a reference to a partially initialized object.
From MSDN: IMPORTANT: Lazy initialization is thread-safe, but it doesn't protect the object after creation. You must lock the object before accessing it, unless the type is thread safe.
The Lazy<T> object ensures that all threads use the same instance of the lazily initialized object and discards the instances that are not used.
I suggest you to read referencede articles from comments:
In all cases the Lazy<T> class is thread-safe, but you need to remember that the Value of this type can be thread-unsafe, and can be corrupted in multithreading environment:
private static Lazy<MyClass> _instance = new Lazy<MyClass>(() => return new MyClass()); public static MyClass Instance { get { return _instance.Value; } } public void MyConsumerMethod() { lock (Instance) { // this is safe usage Instance.SomeMethod(); } // this can be unsafe operation Instance.SomeMethod(); } Also you can use any constructor you like depending on the environment of your application.
178
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
