private void CollectLinksToObjects(Object o)
        {
            //const int dublicateCountObjsToRecheck = 20;
            //string[] dublicateLastAddedLinks = new string[dublicateCountObjsToRecheck];
            //int dublicateLoopCounter = 0;
            //bool[] dublicateMatrix = new bool[dublicateCountObjsToRecheck];
            Instruction instruction = null;
            NetFetcher net = new NetFetcher();
            bool stopLoop = false;
            Template template = o as Template;
            if (template == null)
                return;
            HtmlParser parser = new HtmlParser();
            int countLinksObtained = -1;

            int countInstructions = 0;

            SortedList<int, bool> existingKeys = new SortedList<int, bool>();//список добавленных ключей 

            do
            {

                if (countLinksObtained == 0)//если не нашли ниодной ссылки- сбрасываем текущие  инструкции
                    instruction = null;

                //if (dublicateLoopCounter >= dublicateCountObjsToRecheck - 1)
                //{
                //    instruction = null;
                //    dublicateLoopCounter = 0;
                //}

                if (instruction == null || string.IsNullOrEmpty(instruction.link.Trim()))
                {
                    //instruction = null;
                    lock (instructionLocker)
                    {
                        if (instructions.Count() == 0)
                        {
                            Console.WriteLine("All instructions were processed, CollectLinksToObjects thread going to terminate");
                            eventLog.AddEventToLog("CollectLinksToObjects Инструкции закончились,  завершаем работу");
                            break;
                        }
                        else
                        {
                            instruction = instructions.Dequeue();//берем инструкцию с очереди
                            countInstructions = instructions.Count();
                            countLinksObtained = -1;
                        }
                    }
                }

                eventLog.AddEventToLog("CollectLinksToObjects количество инструкций в очереди: " + countInstructions.ToString());

                string content = string.Empty;
                if (!stopLoop && instruction != null)
                {
                    content = net.DownloadWebPage(instruction.link, Encoding.UTF8);//скачиваем страницу по линку из инструкций

                    countLinksObtained = 0;//сбрасываем счетчик полученных линков
                    foreach (var item in parser.GetLinks(content, instruction.host, template.links[0]))//получаем линки на объявления
                    {
                        if (string.IsNullOrEmpty(item)) continue;

                        bool canAddToQueue = true;
                        int currentKey = SearchIdFromURL(item.ToLower(), "ad_id");
                        if (existingKeys.ContainsKey(currentKey))
                        {
                            canAddToQueue = false;
                            eventLog.AddEventToLog("Найден дубликат в ключах url для " + currentKey.ToString());
                        }
                        else
                            existingKeys.Add(currentKey, true);
                        //if(existingKeys.ContainsKey(
                        //for (int i = 0; i < dublicateCountObjsToRecheck; i++)
                        //    if (dublicateLastAddedLinks[i] == item)
                        //    {
                        //        dublicateMatrix[i] = true;//dublicate found
                        //        canAddToQueue = false;//can't add current link to global queue
                        //        dublicateLoopCounter++;//считаем количество дубликатов
                        //        break;
                        //    }

                        if (canAddToQueue)//in case no dublication for last elements
                        {
                            //if (dublicateLoopCounter >= dublicateCountObjsToRecheck - 1)
                            //    dublicateLoopCounter = 0;

                            //dublicateLastAddedLinks[dublicateLoopCounter++] = item;


                            int countLinksToObject = -1;

                            Instruction linkToObj = new Instruction()
                            {
                                city = instruction.city,
                                district = instruction.district,
                                host = instruction.host,
                                link = item,
                                propertyAction = instruction.propertyAction,
                                propertyType = instruction.propertyType
                            };
                            lock (linksToObjectLocker)
                            {
                                linksToObjects.Enqueue(linkToObj);//adding url to object in global queue                           
                                countLinksToObject = linksToObjects.Count;
                            }
                            Console.WriteLine("item: " + item);
                            countLinksObtained++;

                            linkToObj = null;


                            lock (collectEntityLock)//разлочиваем сборку объектов
                            {
                                Monitor.PulseAll(collectEntityLock);
                            }

                            if (countLinksToObject >= LimitList)//если превышен лимит ссылок на объеты -лочимся
                            {
                                //lock (collectEntityLock)//разлочиваем сборку объектов
                                //{
                                //    Monitor.PulseAll(collectEntityLock);
                                //}

                                lock (linksToObjectLimitLocker)
                                {
                                    Monitor.Wait(linksToObjectLimitLocker);
                                }
                            }


                        }
                    }

                    string currentLink = instruction.link;

                    if (template.pages[0].Count() > 1)
                    {
                        string tmpData = string.Empty;
                        for (int i = 0; i < template.pages.Count - 1; i++)
                        {
                            if (string.IsNullOrEmpty(tmpData))
                                tmpData = parser.GetSingleContent(content, template.pages[i]);
                            else
                                tmpData = parser.GetSingleContent(tmpData, template.pages[i]);

                        }


                        foreach (var item in parser.GetLinks(tmpData, instruction.host, template.pages[template.pages.Count() - 1]))
                        {
                            instruction.link = item;
                            break;
                        }


                    }
                    else
                    {
                        foreach (var item in parser.GetLinks(content, instruction.host, template.pages[0]))
                        {
                            instruction.link = item;
                            break;
                        }
                    }



                    if (currentLink == instruction.link && countInstructions == 0)//если предыдущая ссылка и новая  совпадают- достигли конца
                        stopLoop = true;

                    if (countLinksObtained == 0 && countInstructions == 0)//если предыдущая ссылка и новая  совпадают- достигли конца
                        stopLoop = true;

                }

                //if (string.IsNullOrEmpty(instruction.link) || stopLoop)
                //{
                //    stopLoop = false;
                //    lock (instructionLocker)
                //    {
                //        if (instructions.Count > 0)
                //            instruction = instructions.Dequeue();
                //        else stopLoop = true;
                //    }
                //}

            } while (!stopLoop);


            lock (collectEntityLock)//разлочиваем ожидающий поток на прощание
            {
                Monitor.PulseAll(collectEntityLock);
            }


            Console.WriteLine("CollectLinksToObjects terminated");
            return;

        }