Using ThreadPool creates a 100% cpu usage

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Threading.Tasks;

namespace InParallel
{
    class Run
    {

        public static void Main(string[] args)
        {
            try
            {
                while (true) // Loop indefinitely
	            {
	                Console.WriteLine("Enter input:"); // Prompt
	                string line = Console.ReadLine(); // Get string from user
	                if (line == "exit") // Check string
	                {
		            break;
	                }
	                int value;
	                if (int.TryParse(line, out value)) // Try to parse the string as an integer
	                {
	                    switch(value)
                        {
                            case 1:
                                Seqential();
                                break;
                            case 2:
                               UsingThreadPool();
                                break;
                            case 3:
                                UsingParaller();
                                break;
                            case 4:
                                UsingThreadPool2();
                                break;
                        }
	                }
	            }



                GC.Collect();
                Console.ReadLine();
               
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        private static void Seqential()
        {
            Console.WriteLine("*************************Started Seqential *********************************");
            Stopwatch watch = Stopwatch.StartNew();

            for (int i = 2; i < 20; i++)
            {
                var result = SumRootN(i);
                // Console.WriteLine("root {0} : {1} ", i, result);
            }

            //WalkTree(myTree);
            // WalkTreeUsingThreadPool(myTree);
            watch.Stop();
            Console.WriteLine("********************End Seqential***************************************");

            Console.WriteLine("Total Time Taken Sequential " + watch.ElapsedMilliseconds.ToString());
        }
        private static void UsingThreadPool()
        {
             ThreadPool.SetMaxThreads(50,50);
             Console.WriteLine("************************Started UsingThreadPool***************************************");
            Stopwatch watch = Stopwatch.StartNew();
           
            for (int i = 2; i < 20; i++)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc),i);
                Console.WriteLine("donefor" + i);
            }

            //WalkTree(myTree);
            // WalkTreeUsingThreadPool(myTree);
            watch.Stop();
            Console.WriteLine("****************************End UsingThreadPool*****************");

            Console.WriteLine("Total Time Taken UsingThreadPool " + watch.ElapsedMilliseconds.ToString());
        }
        private static void UsingParaller()
        {
            Console.WriteLine("*********************Started UsingParaller********************************");
            Stopwatch watch = Stopwatch.StartNew();

            Parallel.For(2, 20, (i) =>
                {
                    var result = SumRootN(i);
                   // Console.WriteLine("root {0} : {1} ", i, result);
                });
            watch.Stop();
            Console.WriteLine("****************************End UsingParaller******************");

            Console.WriteLine("Total Time Taken UsingParaller " + watch.ElapsedMilliseconds.ToString());
        }
        private static void UsingThreadPool2()
        {
            ThreadPool.SetMaxThreads(50, 50);
            Console.WriteLine("************************Started UsingThreadPool***************************************");
            Stopwatch watch = Stopwatch.StartNew();

            //for (int i = 2; i < 20; i++)
            //{
            //    ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc), i);
            //    Console.WriteLine("donefor" + i);
            //}

            ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc2), 0);
            ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc2), 1);



            //WalkTree(myTree);
            // WalkTreeUsingThreadPool(myTree);
            watch.Stop();
            Console.WriteLine("****************************End UsingThreadPool*****************");

            Console.WriteLine("Total Time Taken UsingThreadPool " + watch.ElapsedMilliseconds.ToString());
        }
       
        static void ThreadProc(Object stateInfo)
        {
            SumRootN((int)stateInfo);
            // No state object was passed to QueueUserWorkItem, so  
            // stateInfo is null.
           Console.WriteLine("Hello from the thread pool."+Thread.CurrentThread.GetHashCode());
        }

        static void ThreadProc2(Object stateInfo)
        {
            int startcount = (int)stateInfo;
            if (startcount == 0)
            {
                for (int i = 0; i < 10; i++)
                {
                    SumRootN(i);
                }
            }
            else 
            {
                for (int i = 10; i < 20; i++)
                {
                    SumRootN(i);
                }
            }
            
            // No state object was passed to QueueUserWorkItem, so  
            // stateInfo is null.
            Console.WriteLine("Hello from the thread pool." + Thread.CurrentThread.GetHashCode());
        }

        
        public static double SumRootN(int root)
        {
            double result = 0;
            for (int i = 1; i < 10000000; i++)
            {
                result += Math.Exp(Math.Log(i) / root);
            }
            Console.WriteLine("root=" + root+"result="+result);
            return result;
        }

    }

   

   

    
}