Are C# static methods synchronized and locked?

Question

I have a static class that gets me a client..

public static ClientFactory {

    private static Lazy<IClient> _MyClient;

    public static IClient GetClient(ICache cache) {

        if (_MyClient == null) {
            _MyClient = new Lazy<IClient>(() => CreateClient(cache));
        }

        return _MyClient.Value;
    }

    private static IClient CreateClient(ICache cache) {
        // code that takes 1-2 seconds to complete
        return new Client(cache);
    }
}

Is there any chance that I can have 2 or more clients created by writing code like this? Where the second client would overwrite the first one?

How should I update my code in a way, such that the constructor is called only once per application?

Thanks.

Does this answer your question? Are static methods thread safe and How to make static method thread safe? and What does MethodImplOptions.Synchronized do? and C# : What if a static method is called from multiple threads? — user12031933
– user12031933, Commented Jun 19, 2021 at 7:35
Is there any chance that I can have 2 or more clients created by writing code like this? Yes. — mjwills
– mjwills, Commented Jun 19, 2021 at 7:41
Also, be aware that the default Lazy caches exceptions, which is very unlikely to be the behaviour you want. So if CreateClient has any possibility of throwing an exception you should consider using stackoverflow.com/a/42567351/34092 . — mjwills
– mjwills, Commented Jun 19, 2021 at 7:42

Moho · Accepted Answer · 2021-06-19 07:52:19Z

2

Yes, your code can result in multiple Client objects created. Use a static constructor to create the Lazy<IClient> instance:

public static ClientFactory
{
    ...

    static ClientFactory()
    {
        _myClient = new Lazy<IClient>(() => CreateClient());
    }

    public IClient GetClient() => _myClient.Value;
}

Example execution from your code:

thread A evaluates _myClient == null as true, enters block
thread B evaluates _myClient == null as true, enters block
thread A creates Lazy<IClient> object and sets _myClient field
thread A exits if block
before thread B sets _myClient field with a new Lazy<IClient> object, thread A accesses _myCilent.Value property, resulting in the creation of your Client object
thread B sets the _myClient field to its new Lazy<IClient> object
thread B accesses the _myClient.Value property, creating a second Client object
all subsequent calls to GetClient will return this second instance of Client

edited Jun 19, 2021 at 7:52

answered Jun 19, 2021 at 7:38

Moho

16.8k1 gold badge36 silver badges35 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

mjwills Over a year ago

Why use a static constructor? Why not just assign on the same line as the declaration? private static Lazy<object> _MyClient = new Lazy<object>(() => CreateClient());

Zhen Liu Over a year ago

so, in this case, if many calls are made to do _MyClient.Value am I guaranteed to have created only 1 instance?

Moho Over a year ago

yes as the static constructor is guaranteed to execute only once per application domain and will execute before any other method in the class can be externally called

Moho Over a year ago

@mjwills yes, inline initialization would produce the same results in this case

Zhen Liu Over a year ago

So, what should I do my GetClient call needs to have some objects passed in? How do I do that with a single static constructor?

|

Ofiris · Accepted Answer · 2021-06-19 07:47:21Z

Yes, there is a chance, consider this example, based on your input, a run of this simple program may result in initialization of one or two clients (run multiple times to see):

void Main()
{
    System.Threading.Tasks.Parallel.Invoke(
        () => ClientFactory.GetClient(1),
        () => ClientFactory.GetClient(2));  
}

// You can define other methods, fields, classes and namespaces here
public static class ClientFactory {

    private static Lazy<IClient> _MyClient;

    public static IClient GetClient(int init) {
        Console.WriteLine(_MyClient == null);
        if (_MyClient == null) {
            Console.WriteLine(init);
            _MyClient = new Lazy<IClient>(() => CreateClient());
        }       
        return _MyClient.Value;
    }

    private static IClient CreateClient() {
        // code that takes 1-2 seconds to complete
        return new Client();
    }
}

public interface IClient {

}

public class Client : IClient {
    public Client() {
        Console.WriteLine("Client constucrtor");
    }
}

Two threads may be within the if (_MyClient == null) clause in the same time, creating multiple objects, only one assigned.

Collectives™ on Stack Overflow

Are C# static methods synchronized and locked?

2 Answers 2

6 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

6 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related