Повреждение кучи С++ в функции pthread realloc(): недопустимый следующий размер

Я не знаю, решит ли это вашу проблему, но у вас есть несколько проблем с вашей функцией peek:

Проблема 1. Преждевременное выделение памяти.

Первые две строки функции делают это безоговорочно:

   char* myBuffer  = new char[512];
   len = 0;

Но позже ваша функция могла обнаружить этот len == -1, поэтому вообще не нужно было выделять память. Выделения не должно происходить, пока вы не уверены, что есть причина для выделения памяти.

Проблема 2. Выделение памяти вне мьютекса.

Что касается проблемы 1 выше, вы выделяете память до того, как мьютекс будет установлен. Если два или более потока попытаются вызвать peek, оба потока могут выделить память, что вызовет состояние гонки.

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

pthread_mutex_lock(&mLock);
// now memory can be allocated

Проблема 3. Возврат выделенной памяти при ошибке.

Поскольку функция peek возвращает указатель на выделенную память, а позже вызывающая программа вызывает delete [] для этого указателя, вполне допустимо возвращать nullptr и не выделять никакой памяти.

В вашей текущей функции peek вы возвращаете выделенную память даже при ошибке. Вот предлагаемая переработка этого кода:

if(front==NULL) 
{
   len = -1;
   pthread_mutex_unlock(&mLock);
   return nullptr;
}
char* myBuffer = new char[len];
//...

Обратите внимание, что нет необходимости в выделении памяти до тех пор, пока не будет уверена, что для выделения памяти есть причина.

Проблема 4. Предполагается, что нужно выделить 512 байт.

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

Проблема 5: не используется RAII для управления мьютексом.

Что, если в середине peek возникнет исключение (что может произойти, если используется new[])? Вы бы оставили мьютекс заблокированным, и теперь у вас есть остановленный поток, если этот поток ожидает разблокировки мьютекса.

Используйте RAII для управления блокировками, где в основном используется небольшая структура, где деструктор автоматически вызывает функцию unlock мьютекса. Таким образом, независимо от причины возврата peek, мьютекс автоматически разблокируется.

В C++ 11 у вас есть std::lock_guard, который выполняет это с помощью C++ 11. резьбовая модель. Если по какой-то причине вам приходится использовать pthreads, вы можете создать свою собственную оболочку RAII:

struct pthread_lock_guard 
{
   pthread_mutex_lock* plock; 
   pthread_lock_guard(pthread_mutex_lock* p) : plock(p) {}
   ~pthread_lock_guard() { pthread_mutex_unlock(plock); }
};

Тогда вы будете использовать его следующим образом:

char* MsgQueue::peek(int &len) 
{
   pthread_mutex_lock(&mLock);
   pthread_lock_guard lg(&mlock);
   char* myBuffer  = new char[512];
   len = 0;
   
   pthread_mutex_lock(&mLock);
   if(front==NULL) {
      len = -1;
      return myBuffer;
     }
     
     len = front->len;
   strncpy(myBuffer,front->chars,len);
   return myBuffer;
}

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

Итак, учитывая все эти проблемы, вот окончательная переработка функции peek:

struct pthread_lock_guard 
{
   pthread_mutex_lock* plock; 
   pthread_lock_guard(pthread_mutex_lock* p) : plock(p) {}
   ~pthread_lock_guard() { pthread_mutex_unlock(plock); }
};

char* MsgQueue::peek(int &len) 
{
   pthread_mutex_lock(&mLock);
   pthread_lock_guard lg(&mLock);
   if(front==NULL) 
   {
      len = -1;
      return nullptr;
   }
   len = front->len;
   char* myBuffer  = new char[len];
   strncpy(myBuffer,front->chars,len);
   return myBuffer;
}

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

И последнее замечание: вы действительно должны стремиться использовать классы-контейнеры как можно чаще, такие как std::vector<char> или std::string, чтобы не использовать слишком много необработанной обработки динамической памяти.

Я подозреваю, что это из-за утечки памяти.

Рассмотрим приведенный ниже цикл while.

  //empty outgoing queue
  tempBuf = pAppServer->OUtgoingMsgQueue.peek(tempMsgLen);
  while(tempMsgLen>0) {
     broadcast(pAppServer->Con,mg_mk_str(tempBuf));
     pAppServer->OUtgoingMsgQueue.dequeue();             
     delete [] tempBuf;          
     
     tempBuf = pAppServer->OUtgoingMsgQueue.peek(tempMsgLen);                        
  }

Всегда есть утечка 512 байт, так как вы не освобождаете память, когда tempMsgLen<=0. то есть всякий раз, когда цикл прерывается ИЛИ даже когда ваш поток не входит в цикл, возникает утечка.

В качестве быстрого исправления вы можете просто добавить delete [] tempBuf; после этого цикла while и попробовать.

Или измените цикл while на цикл while. Убедитесь, что количество вызовов peek() равно количеству удалений.