Question

Classes:

public class Tree
{
    public Node RootNode { get; set; }
}

public class Node
{
    public int Key { get; set; }
    public object Value { get; set; }
    public Node ParentNode { get; set; }
    public List<Node> Nodes { get; set; }
}

Methods:

This method generates a tree.

private static int totalNodes = 0;
       static Tree GenerateTree()
       {
           Tree t = new Tree();
           t.RootNode = new Node();
           t.RootNode.Key = 0;
           t.RootNode.Nodes = new List<Node>();
           Console.WriteLine(t.RootNode.Key);
           List<Node> rootNodes = new List<Node>();
           rootNodes.Add(t.RootNode);
           while (totalNodes <= 100000)
           {
               List<Node> newRootNodes = new List<Node>();
               foreach (var rootNode in rootNodes)
               {

                   for (int j = 0; j < 3; j++)
                   {
                       totalNodes++;
                       Console.Write(string.Format(" {0}({1}) ", totalNodes, rootNode.Key));
                       Node childNode = new Node() {Key = totalNodes, Nodes = new List<Node>(), ParentNode = t.RootNode};
                       rootNode.Nodes.Add(childNode);
                       newRootNodes.Add(childNode);
                   }
                   Console.Write("     ");
               }
               Console.WriteLine();
               rootNodes = newRootNodes;
           }

           return t;
       }

This method is supposed to print a tree, but node is null in some case:

 static void PrintTreeParallel(Node rootNode)
       {
           List<Node> rootNodes = new List<Node>();
           List<Node> newRootNodes = new List<Node>();

           rootNodes.Add(rootNode);
           Console.WriteLine(rootNode.Key);

           while (rootNodes.Count > 0)
           {
               newRootNodes = new List<Node>();
               Parallel.ForEach(rootNodes, node =>
                                               {
                                                   if (node != null)
                                                   {

                                                       Console.Write(string.Format(" {0} ", node.Key));
                                                       if (node.Nodes != null)
                                                           Parallel.ForEach(node.Nodes,
                                                                            newRoot => { newRootNodes.Add(newRoot); });

                                                   }
                                                   else
                                                   {
                                                       //HOW CAN WE GET HERE?????
                                                       Debugger.Break();
                                                       Console.WriteLine(rootNodes.Count);
                                                   }
                                               });

               Console.WriteLine();
               rootNodes = newRootNodes;
           }
       }

Execute:

 static void Main(string[] args)
        {

            var t = GenerateTree();
            Console.WriteLine("Tree generated");



            PrintTreeParallel(t.RootNode);
            Console.WriteLine("Tree printed paral");


            Console.ReadLine();
        }

Question:

What’s wrong here?
Why node is null in some case?
And it happens only when there are a lot of generated nodes. For ex if there would be only 10 nodes everything is OK.

Answer 1

The problem is that you have this code:

Parallel.ForEach(node.Nodes, newRoot => { newRootNodes.Add(newRoot); });

Which allows multiple threads to add items to the newRootNodes list concurrently. As a commenter pointed out, List<T> is not thread-safe. What’s probably happening is that one thread’s Add is being interrupted by another thread’s call to Add, which causes an internal index in the list to be incremented. That leaves a null value in one of the list’s items.

Then, later in the loop you have:

rootNodes = newRootNodes; 

Which puts the corrupted list as the list that’s going to be iterated by the while.