Question

Consider the following code:

public class Foo
{
    private static object _lock = new object();

    public void NameDoesNotMatter()
    {
        if( SomeDataDoesNotExist() )
        {
            lock(_lock)
            {
                if( SomeDataDoesNotExist() )
                {
                    CreateSomeData();
                }
                else
                {
                    // someone else also noticed the lack of data.  We
                    // both contended for the lock.  The other guy won
                    // and created the data, so we no longer need to.
                    // But once he got out of the lock, we got in.
                    // There's nothing left to do.
                }
            }
        }
    }

    private bool SomeDataDoesNotExist()
    {
        // Note - this method must be thread-safe.
        throw new NotImplementedException();
    }

    private bool CreateSomeData()
    {
        // Note - This shouldn't need to be thread-safe
        throw new NotImplementedException();
    }
}

First, there are some assumptions I need to state:

1. There is a good reason I couldn’t just do this once an app startup. Maybe the data wasn’t available yet, etc.

2. Foo may be instantiated and used concurrently from two or more threads. I want one of them to end up creating some data (but not both of them) then I’ll allow both to access that same data (ignore thread safety of accessing the data)

3. The cost to SomeDataDoesNotExist() is not huge.

Now, this doesn’t necessarily have to be confined to some data creation situation, but this was an example I could think of.

The part that I’m especially interested in identifying as a pattern is the check -> lock -> check. I’ve had to explain this pattern to developers on a few occasions who didn’t get the algorithm at first glance but could then appreciate it.

Anyway, other people must do similarly. Is this a standardized pattern? What’s it called?

Answer 1

Lazy initialization with double-checked locking?