//int maxNoOfThreads = 10;
        public CustomMultithreads GetCustomMultithreadsInstance(Func<object, string> myMethodName, int maxNoOfThreads)
        {
            CustomMultithreads cms = new CustomMultithreads(myMethodName, maxNoOfThreads, maxNoOfThreadsInPool);
            //lstCustomMultiThreads.Add(cms);
            return cms;

        }
        public void CallMultithreadedMethod(CustomMultithreads cmt, object item)
        {
            try
            {
                lock (lockr_PoolThreads)
                {
                    if (counterWorkerThreadsInPool >= maxNoOfThreadsInPool)
                    {
                        lock (lockr_PoolThreads)
                        {
                            Monitor.Wait(lockr_PoolThreads);

                            if (counterWorkerThreadsInPool >= maxNoOfThreadsInPool)
                            {
                                Monitor.Wait(lockr_PoolThreads);
                            }
                        }
                    }
                }
                cmt.StartSingleMultithreadedMethod(item);
                Thread.Sleep(500);
            }
            catch (Exception ex)
            {
            }
        }
        public void CallMultithreadedMethod(CustomMultithreads cmt, object item)
        {
            try
            {
                //cmt.threadStartedEvent.processCompletedEvent += new EventHandler(threadStartedEvent_processCompletedEvent);
                //cmt.threadCompletedEvent.processCompletedEvent += new EventHandler(threadCompletedEvent_processCompletedEvent);
                lock (lockr_PoolThreads)
                {
                    if (counterWorkerThreadsInPool >= maxNoOfThreadsInPool)
                    {
                        lock (lockr_PoolThreads)
                        {
                            Monitor.Wait(lockr_PoolThreads);

                            if (counterWorkerThreadsInPool >= maxNoOfThreadsInPool)
                            {
                                Monitor.Wait(lockr_PoolThreads);
                            }
                        }
                    }
                }
                cmt.StartSingleMultithreadedMethod(item);

               
            }
            catch (Exception ex)
            {
                GlobusLogHelper.log.Error(" Error : " + ex.StackTrace);

            }


        }
        public void CallMultithreadedMethod(CustomMultithreads cmt, object item)
        {
            try
            {
                //cmt.threadStartedEvent.processCompletedEvent += new EventHandler(threadStartedEvent_processCompletedEvent);
                //cmt.threadCompletedEvent.processCompletedEvent += new EventHandler(threadCompletedEvent_processCompletedEvent);
                lock (lockr_PoolThreads)
                {
                    if (counterWorkerThreadsInPool >= maxNoOfThreadsInPool)
                    {
                        lock (lockr_PoolThreads)
                        {
                            Monitor.Wait(lockr_PoolThreads);

                            if (counterWorkerThreadsInPool >= maxNoOfThreadsInPool)
                            {
                                Monitor.Wait(lockr_PoolThreads);
                            }
                        }
                    }
                }
                cmt.StartSingleMultithreadedMethod(item);
            }
            catch (Exception ex)
            {
                GlobusLogHelper.log.Error(" Error : " + ex.StackTrace);
            }
        }
        //int maxNoOfThreads = 10;
        public CustomMultithreads GetCustomMultithreadsInstance(Func <object, string> myMethodName, int maxNoOfThreads)
        {
            CustomMultithreads cms = new CustomMultithreads(myMethodName, maxNoOfThreads, maxNoOfThreadsInPool);

            //lstCustomMultiThreads.Add(cms);
            return(cms);
        }
        public void CallMultithreadedMethod(CustomMultithreads cmt, object item)
        {
            try
            {
               
                lock (lockr_PoolThreads)
                {
                    if (counterWorkerThreadsInPool >= maxNoOfThreadsInPool)
                    {
                        lock (lockr_PoolThreads)
                        {
                            Monitor.Wait(lockr_PoolThreads);

                            if (counterWorkerThreadsInPool >= maxNoOfThreadsInPool)
                            {
                                Monitor.Wait(lockr_PoolThreads);
                            }
                        }
                    }
                }
                cmt.StartSingleMultithreadedMethod(item);
                Thread.Sleep(500);

               
            }
            catch (Exception ex)
            {
              

            }


        }
        public FacebookFanPageData()
        {

            GetProcessManagerFromDictionary();

            mt_AllParsersReader = processThreadManagerAllParsersREader.GetCustomMultithreadsInstance(GetFbPost, 2, 20, "DirectUrlParser");
            //mt_AllParsersReader.processCompletedEvent.processCompletedEvent += new EventHandler(processCompletedEvent_processCompletedEventReader);

        }
 public CustomMultithreads GetCustomMultithreadsInstance(Func<object, string> myMethodName, int maxNoOfThreads, int maxNoOfThreadsInPool, string poolName)
 {
     this.maxNoOfThreadsInPool = maxNoOfThreadsInPool;
     CustomMultithreads cmt = new CustomMultithreads(myMethodName, maxNoOfThreads, maxNoOfThreadsInPool, poolName);
     lstCustomMultiThreads.Add(cmt);
    
     cmt.threadStartedEvent.SubscribeProcessCompletedHandler(new EventHandler(threadStartedEvent_processCompletedEvent));
     cmt.threadCompletedEvent.SubscribeProcessCompletedHandler(new EventHandler(threadCompletedEvent_processCompletedEvent));
     return cmt;
 }
        public CustomMultithreads GetCustomMultithreadsInstance(Func <object, string> myMethodName, int maxNoOfThreads, int maxNoOfThreadsInPool, string poolName)
        {
            this.maxNoOfThreadsInPool = maxNoOfThreadsInPool;
            CustomMultithreads cmt = new CustomMultithreads(myMethodName, maxNoOfThreads, maxNoOfThreadsInPool, poolName);

            lstCustomMultiThreads.Add(cmt);

            cmt.threadStartedEvent.SubscribeProcessCompletedHandler(new EventHandler(threadStartedEvent_processCompletedEvent));
            cmt.threadCompletedEvent.SubscribeProcessCompletedHandler(new EventHandler(threadCompletedEvent_processCompletedEvent));
            return(cmt);
        }