Результаты поиска

Я работаю над многопоточным приложением C++, которое разрушает кучу. Обычные инструменты для обнаружения этого повреждения кажутся неприменимыми. Старые сборки (18 месяцев) исходного кода демонстрируют такое же поведение, как и самый последний релиз, поэтому это было сделано в течение длительного времени и просто не было замечено; с другой стороны, исходные дельты не могут быть использованы для определения того, когда была введена ошибка - в репозитории есть много изменений кода.

Подсказка для аварийного поведения заключается в том, чтобы генерировать пропускную способность в этом системном сокете передачи данных, которые загружаются во внутреннее представление. У меня есть набор тестовых данных, которые периодически вызывают исключение приложения (различные места, различные причины-в том числе сбой выделения кучи, таким образом: повреждение кучи).

Такое поведение, по-видимому, связано с мощностью CPU или пропускной способностью памяти; чем больше у каждой машины есть, тем легче она падает. Отключение ядра hyper-threading core или двухъядерного ядра снижает скорость (но не устраняет) повреждения. Это наводит на мысль о проблеме, связанной со сроками.

А теперь вот в чем загвоздка:
Когда он выполняется в облегченной среде отладки (скажем, Visual Studio 98 / AKA MSVC6), повреждение кучи достаточно легко воспроизводится - проходит десять или пятнадцать минут, прежде чем что-то ужасно выходит из строя и возникают исключения, например alloc; при работе в сложной среде отладки (Rational Purify, VS2008/MSVC9 или даже Microsoft Application Verifier) . система становится привязанной к скорости памяти и не падает (привязка к памяти: CPU не становится выше 50% , индикатор диска не горит, программа работает так быстро, как может, коробка потребляет 1.3G из 2G RAM). Итак, у меня есть выбор между возможностью воспроизвести проблему (но не идентифицировать причину) или возможностью идентифицировать причину или проблему, которую я не могу воспроизвести.

Мои текущие лучшие догадки о том, куда идти дальше:

1. Получите безумно грубый ящик (чтобы заменить текущий ящик dev: 2Gb RAM в E6550 Core2 Duo ); это позволит повторить сбой, вызывающий неправильное поведение при работе в мощной среде отладки; или
2. Перепишите операторы new и delete , чтобы использовать VirtualAlloc и VirtualProtect для обозначения памяти как доступной только для чтения, как только это будет сделано. Бегите под MSVC6 и пусть OS поймает плохого парня, который пишет в освобожденную память. Да, это признак отчаяния: кто, черт возьми, переписывает new и delete ?! Интересно, будет ли это так же медленно, как в случае с Purify и др.

И нет: доставка с встроенным прибором Purify-это не вариант.

Коллега только что прошел мимо и спросил "Stack Overflow? Are we getting stack overflows now?!?"

А теперь вопрос: как мне найти корруптор кучи?

Обновление: балансировка new[] и delete[] , похоже, прошла долгий путь к решению этой проблемы. Вместо 15 минут приложение теперь работает примерно за два часа до сбоя. Но пока еще нет. Есть еще какие-нибудь предложения? Повреждение кучи сохраняется.

Обновление: сборка выпуска под Visual Studio 2008 кажется значительно лучше; текущие подозрения основываются на реализации STL , которая поставляется с VS98 .

3. Воспроизвести проблему. Dr Watson создаст дамп, который может быть полезен в дальнейшем анализе.

Я приму это к сведению, но меня беспокоит, что доктор Уотсон будет спотыкаться только после того, как это произойдет, а не тогда, когда куча будет растоптана.

Другой попыткой может быть использование WinDebug в качестве инструмента отладки, который является довольно мощным и в то же время легким.

В данный момент это опять же происходит: не очень-то помогает, пока что-то не пойдет не так. Я хочу поймать вандала с поличным.

Возможно, эти инструменты позволят вам хотя бы сузить проблему до определенного компонента.

Я не питаю больших надежд, но отчаянные времена требуют этого...

И вы уверены , что все компоненты проекта имеют правильные настройки библиотеки времени выполнения ( C/C++ tab, категория генерации кода в настройках проекта VS 6.0)?

Нет, я не буду, и завтра я проведу пару часов, просматривая рабочее пространство (58 проектов в нем) и проверяя, что все они компилируются и связываются с соответствующими флагами.

С появлением multicore CPUs на рабочем столе навыки многопоточности станут ценным активом для программистов. Можете ли вы порекомендовать какие-то хорошие ресурсы (книги, учебные пособия, веб-сайты и т. д.) для программиста, который хочет узнать о потоковом программировании?

С появлением multicore CPUs на рабочем столе навыки многопоточности станут ценным активом для программистов. Можете ли вы порекомендовать какие-то хорошие ресурсы (книги, учебные пособия, веб-сайты и т. д.) для программиста, который хочет узнать о потоковом программировании?

Я работаю над приложением, которое захватывает и устанавливает кучу обновлений с внешнего сервера,и мне нужна помощь с потоковой обработкой. Пользователь выполняет этот процесс:

• Нажимает кнопку
• Метод проверяет наличие обновлений, возвращается счетчик.
• Если больше 0, то спросите пользователя, если они хотят установить с помощью MessageBox.Show().
• Если да, то он проходит через цикл и вызывает BeginInvoke() в методе run() каждого обновления, чтобы запустить его в фоновом режиме.
• В моем классе обновления есть некоторые события, которые используются для обновления индикатора выполнения и т. д.

Обновления индикатора выполнения в порядке, но MessageBox не полностью очищается от экрана, потому что цикл обновления начинается сразу после нажатия пользователем кнопки да (см. снимок экрана ниже).

• Что я должен сделать, чтобы сделать messagebox исчезнуть мгновенно до начала цикла обновления?
• Должен ли я использовать потоки вместо BeginInvoke()?
• Должен ли я выполнять начальную проверку обновления в отдельном потоке и вызывать MessageBox.Show() из этого потока?

Код

// Button clicked event handler code...
DialogResult dlgRes = MessageBox.Show(
    string.Format("There are {0} updates available.\n\nInstall these now?", 
    um2.Updates.Count), "Updates Available", 
    MessageBoxButtons.YesNo, 
    MessageBoxIcon.Question, 
    MessageBoxDefaultButton.Button2
);

if (dlgRes == DialogResult.Yes)
{
    ProcessAllUpdates(um2); 
}

// Processes a bunch of items in a loop
private void ProcessAllUpdates(UpdateManager2 um2)
{
    for (int i = 0; i < um2.Updates.Count; i++)
    {
        Update2 update = um2.Updates[i];

        ProcessSingleUpdate(update);

        int percentComplete = Utilities.CalculatePercentCompleted(i, um2.Updates.Count);

        UpdateOverallProgress(percentComplete);
    }
}

// Process a single update with IAsyncResult
private void ProcessSingleUpdate(Update2 update)
{
    update.Action.OnStart += Action_OnStart;
    update.Action.OnProgress += Action_OnProgress;
    update.Action.OnCompletion += Action_OnCompletion;

    //synchronous
    //update.Action.Run();

    // async
    IAsyncResult ar = this.BeginInvoke((MethodInvoker)delegate() { update.Action.Run(); });
}

Скриншот

Рассмотрим эту проблему: у меня есть программа, которая должна получить (скажем) 100 записей из базы данных, а затем для каждой из них она должна получить обновленную информацию из веб-службы. Есть два способа ввести параллелизм в этом сценарии:

1. Я запускаю каждый запрос к веб-службе в новом потоке. Количество одновременных потоков контролируется каким-то внешним параметром (или динамически настраивается каким-то образом).

2. Я создаю меньшие партии (скажем, по 10 записей в каждой) и запускаю каждую партию в отдельном потоке (так что возьмем наш пример, 10 потоков).

Какой подход лучше, и почему вы так думаете?

Когда я не должен использовать ThreadPool в .Net?

Похоже, что лучшим вариантом является использование ThreadPool, и в этом случае, почему это не единственный вариант?

Что вы испытываете по этому поводу?

Я уверен, что для этого есть хорошая (или, по крайней мере, приличная) причина. Что это?

Наша команда создает новую систему документооборота по подбору персонала взамен старой. Мне было поручено перенести старые данные в новую схему. Я решил сделать это, создав небольшой проект Windows Forms, поскольку схема радикально отличается, а прямые скрипты TSQL не являются адекватным решением.

Основной запечатанный класс 'ImportController', выполняющий эту работу, объявляет следующее событие делегата:

public delegate void ImportProgressEventHandler(object sender, ImportProgressEventArgs e);
public static event ImportProgressEventHandler importProgressEvent;

Главное окно запускает статический метод в этом классе, используя новый поток:

Thread dataProcessingThread = new Thread(new ParameterizedThreadStart(ImportController.ImportData));
dataProcessingThread.Name = "Data Importer: Data Processing Thread";
dataProcessingThread.Start(settings);

ImportProgressEvent args содержит строковое сообщение, максимальное значение int для индикатора выполнения и текущее значение progress int. В Windows форма зарегистрировавшегося на мероприятие:

ImportController.importProgressEvent += new ImportController.ImportProgressEventHandler(ImportController_importProgressEvent);

И реагирует на событие таким образом, используя свой собственный делегат:

    private delegate void TaskCompletedUIDelegate(string completedTask, int currentProgress, int progressMax);

private void ImportController_importProgressEvent(object sender, ImportProgressEventArgs e)
            {
                this.Invoke(new TaskCompletedUIDelegate(this.DisplayCompletedTask), e.CompletedTask, e.CurrentProgress, e.ProgressMax);
            }

Наконец, индикатор выполнения и listbox обновляются:

private void DisplayCompletedTask(string completedTask, int currentProgress, int progressMax)
        {
            string[] items = completedTask.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

            foreach (string item in items)
            {
                this.lstTasks.Items.Add(item);
            }

            if (currentProgress >= 0 && progressMax > 0 && currentProgress <= progressMax)
            {
                this.ImportProgressBar.Maximum = progressMax;
                this.ImportProgressBar.Value = currentProgress;
            }
        }

Дело в том, что ListBox, похоже, обновляется очень быстро ,но индикатор выполнения никогда не перемещается, пока пакет не будет почти завершен??? а что дает ?

До сих пор я избегал кошмара, который испытывает многопоточный код, поскольку он просто кажется слишком большим минным полем. Я хотел бы спросить, как люди начали тестировать код, который полагается на потоки для успешного выполнения, или просто как люди начали тестировать те виды проблем, которые появляются только тогда, когда два потока взаимодействуют определенным образом?

Это кажется действительно ключевой проблемой для программистов сегодня, было бы полезно объединить наши знания по этому имхо.

само собой разумеющийся вопрос.

Почему эта штука пузырится в моей попытке поймать даже тогда, когда ничего не случилось?

Почему он появляется в моем журнале сотни раз?

Я знаю, что это новый вопрос, но если этот сайт собирается получить рейтинг поиска и привлечь новых пользователей, мы должны спросить их

Время от времени я получаю System.Threading.ThreadStateException при попытке перезапустить поток. Рассматриваемый код выглядит следующим образом:

// Make sure the thread is done stopping
while (this.mThread.ThreadState == ThreadState.Running)
{ 
    Thread.Sleep(0);
}
// Respawn a thread if the current one is stopped or doesn't exist
if (this.mThread == null || this.mThread.ThreadState == ThreadState.Stopped)
{ 
    this.mThread = new Thread(new ParameterizedThreadStart(Monitor)); }
// Start the thread
if (check)
{ 
    this.mThread.Start(60000); 
}
else
{   
    this.mThread.Start(0); 
}

Итак, два вопроса - Является ли это правильным способом делать вещи, и есть ли способ предотвратить возникновение ошибки?

Время от времени я получаю System.Threading.ThreadStateException при попытке перезапустить поток. Рассматриваемый код выглядит следующим образом:

// Make sure the thread is done stopping
while (this.mThread.ThreadState == ThreadState.Running)
{ 
    Thread.Sleep(0);
}
// Respawn a thread if the current one is stopped or doesn't exist
if (this.mThread == null || this.mThread.ThreadState == ThreadState.Stopped)
{ 
    this.mThread = new Thread(new ParameterizedThreadStart(Monitor)); }
// Start the thread
if (check)
{ 
    this.mThread.Start(60000); 
}
else
{   
    this.mThread.Start(0); 
}

Итак, два вопроса - Является ли это правильным способом делать вещи, и есть ли способ предотвратить возникновение ошибки?

Есть ли эквивалент для Interlocked.Exchange для логических?

Например, атомарный обмен значениями, который возвращает Предыдущее значение и не требует блокировки?

Какие библиотеки существуют для других языков программирования, чтобы обеспечить модель параллелизма в стиле Erlang (процессы, почтовые ящики, сопоставление шаблонов) и т. д.)?

Примечание: меня особенно интересуют вещи, которые должны быть похожи на Erlang, а не просто любая библиотека потоков или очередей.

Я работаю над приложением SharePoint, которое поддерживает импорт нескольких документов в одной операции. У меня также есть обработчик событий ItemAdded, который выполняет некоторое базовое обслуживание метаданных элемента. Это событие срабатывает как для импортированных документов, так и для созданных вручную. Последняя часть головоломки-это функция пакетной операции, которую я реализовал, чтобы запустить рабочий процесс и обновить другое поле метаданных.

Я могу вызвать COMException 0x81020037, извлекая данные файла SPListItem. Этот файл - всего лишь документ формы InfoPath/XML. Я могу изменить XML и успешно подтолкнуть его обратно в SPListItem. Когда я запускаю пользовательскую функцию сразу после этого и изменяю метаданные, это иногда вызывает ошибку COM.

Сообщение об ошибке в основном указывает,что файл был изменен другим потоком. Казалось бы, событие ItemAdded все еще записывает файл обратно в базу данных, в то время как пользовательская функция изменяет метаданные. Я попытался ввести задержки и циклы перехвата ошибок, чтобы попытаться обнаружить, что SPListItem безопасно изменять с небольшим успехом.

Есть ли способ узнать, имеет ли другой поток блокировку на документе?

Я нахожу, что модель событий .NET такова, что я часто вызываю событие в одном потоке и слушаю его в другом потоке. Мне было интересно, какой самый чистый способ маршалировать событие из фонового потока в мой поток UI.

Основываясь на предложениях сообщества, я использовал это:

// earlier in the code
mCoolObject.CoolEvent+= 
           new CoolObjectEventHandler(mCoolObject_CoolEvent);
// then
private void mCoolObject_CoolEvent(object sender, CoolObjectEventArgs args)
{
    if (InvokeRequired)
    {
        CoolObjectEventHandler cb =
            new CoolObjectEventHandler(
                mCoolObject_CoolEvent);
        Invoke(cb, new object[] { sender, args });
        return;
    }
    // do the dirty work of my method here
}

есть ли способ прервать потоки, созданные с помощью QueueUserWorkItem?

Или, может быть, мне это и не нужно? Что произойдет, если основное приложение завершит работу? Все ли потоки, созданные из него, автоматически прерываются?

Хорошо, вот сценарий. У меня есть утилита, которая обрабатывает тонны записей и вводит информацию в базу данных соответственно.

Он работает на этих записях в многопоточных пакетах. Каждый такой пакет записывается в один и тот же файл журнала для создания рабочего процесса trace для каждой записи. Потенциально, мы могли бы сделать около миллиона записей журнала в день.

Должен ли этот журнал быть внесен в базу данных, находящуюся на другом сервере? Рассмотрения:

1. Очевидным недостатком записи нескольких потоков в один и тот же файл журнала является то, что сообщения журнала перемешиваются между собой. В базе данных они могут быть сгруппированы по коду пакета.
2. Производительность-что бы замедлить пакетную обработку больше? запись в локальный файл или отправка данных журнала в базу данных на другом сервере в той же сети. Теоретически, файл журнала быстрее, но есть ли здесь gotcha?

Существуют ли какие-либо оптимизации, которые могут быть сделаны на любом подходе?

Спасибо.

У нас есть служба Windows, написанная в C#. служба порождает поток, который делает это:

private void ThreadWorkerFunction()
{
  while(false == _stop) // stop flag set by other thread
  {
    try
    {
      openConnection();

      doStuff();

      closeConnection();
    }
    catch (Exception ex)
    {
      log.Error("Something went wrong.", ex);

      Thread.Sleep(TimeSpan.FromMinutes(10));
    }
  }
}

Мы поместили Thread.Sleep через пару раз, когда база данных ушла, и мы вернулись к файлам журналов 3GB, полным ошибок подключения к базе данных.

Это работает нормально в течение нескольких месяцев, но недавно мы видели несколько случаев, когда оператор log.Error() регистрирует исключение "System.InvalidOperationException: This SqlTransaction has completed; it is no longer usable", а затем никогда не возвращается. Служба может быть оставлена работать в течение нескольких дней, но больше ничего не будет зарегистрировано.

Сделав некоторое чтение, я знаю, что Thread.Sleep не идеален,но почему он просто никогда не вернется?