#944 – Lazy Instantiation, Solution #2

The previous post showed one way to achieve lazy instantiation–waiting to initialize a data object until just before it’s needed.  The problem with this example, however, was that it wasn’t thread-safe.  Two threads could simultaneously check to see if the object is initialized and both determine that it is not.  Both threads would then try to initialize the object.

The code below updates the earlier example, making it thread-safe.

        private static List listOfAllFamousDogs = null;
        private static readonly object initLock = new object();

        private static List GenerateBigListOfFamousDogs()
        {
            Console.WriteLine("Loading big list of famous dogs!");
            List bigList = new List();
            bigList.Add(new Dog("Lassie"));
            bigList.Add(new Dog("Rin Tin Tin"));
            // load 1,000 more dogs here

            return bigList;
        }

        public bool IsFamous
        {
            get
            {
                lock (initLock)
                {
                    if (listOfAllFamousDogs == null)
                        listOfAllFamousDogs = GenerateBigListOfFamousDogs();
                }

                return listOfAllFamousDogs.Contains(this);
            }
        }

Next time, we’ll see an easier way to do this in .NET 4.0 or later.

#943 – Lazy Instantiation, Solution #1

There are cases when we have a large amount of data to allocate in a class, either in an instance of the class or as static data.  We want to allocate and initialize the data as late as possible, i.e. just before we need to use the data.  This is know as lazy instantiation.

One method for lazy instantiation is to check to see if the data is instantiated, wherever we try to use it.

        private static List<Dog> listOfAllFamousDogs = null;

        private static List<Dog> GenerateBigListOfFamousDogs()
        {
            Console.WriteLine("Loading big list of famous dogs!");
            List<Dog> bigList = new List<Dog>();
            bigList.Add(new Dog("Lassie"));
            bigList.Add(new Dog("Rin Tin Tin"));
            // load 1,000 more dogs here

            return bigList;
        }

        public bool IsFamous
        {
            get
            {
                if (listOfAllFamousDogs == null)
                    listOfAllFamousDogs = GenerateBigListOfFamousDogs();

                return listOfAllFamousDogs.Contains(this);
            }
        }

We get lazy instantiation here–the list isn’t initialized until we use the IsFamous property.  This solution, however, is not thread-safe.

#942 – The Case for Lazy Instantiation

Assume that we create some large data item in an object, e.g. the listofAllFamousDogs object in the sample below:

    public class Dog
    {
        public string Name { get; set; }

        public Dog(string name)
        {
            Name = name;
        }

        public void Bark()
        {
            Console.WriteLine("Woof!");
        }

        private static List<Dog> listOfAllFamousDogs = GenerateBigListOfFamousDogs();

        private static List<Dog> GenerateBigListOfFamousDogs()
        {
            Console.WriteLine("Loading big list of famous dogs!");
            List<Dog> bigList = new List<Dog>();
            bigList.Add(new Dog("Lassie"));
            bigList.Add(new Dog("Rin Tin Tin"));
            // load 1,000 more dogs here

            return bigList;
        }

        public bool IsFamous
        {
            get { return listOfAllFamousDogs.Contains(this); }
        }
    }

The problem with this is that we end up creating the big list when we first use the class–whether or not we’ll later use the IsFamous property.

            Dog bob = new Dog("Bob");
            bob.Bark();

What we need is to lazily instantiate this list.  That is–wait to create the list until we actually need it.