Kommunikation zwischen Threads

Sense

Hoi!

In meiner Anwendung habe ich 2 Threads, die eine größere Anzahl Messages austauschen müssen. Die Messages selbst sollen eine variable Größe haben (sprich unterschiedlichen Typs sein, z.B. MsgQuit, MsgChatSendText, ...).

Mein erster Ansatz war folgender:
Der Sender erstellt eine Message mit new und schreibt den Pointer in einen MessageQueue des Empfängerthreads (natürlich per z.B. mutex gelockt). Der Empfänger liest jeden Loop (also regelmäßig) seinen MessageQueue aus und bekommt so die Nachrichten..

Problem bzw. meine Frage: Wie soll die Message wieder deleted werden?

Ist es ein Problem, wenn ein Thread Speicher eines anderen Threads löscht?

Der Quellcode vom operator delete schaut im Debug Build so aus:

void operator delete(
        void *pUserData
        )
{
        _CrtMemBlockHeader * pHead;

        RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));

        if (pUserData == NULL)
            return;

        _mlock(_HEAP_LOCK);  /* block other threads */
        __TRY

            /* get a pointer to memory block header */
            pHead = pHdr(pUserData);

             /* verify block type */
            _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));

            _free_dbg( pUserData, pHead->nBlockUse );

        __FINALLY
            _munlock(_HEAP_LOCK);  /* release other threads */
        __END_TRY_FINALLY

        return;
}

Durch den Lock also vermutlich thread safe.

Im Release Build aber entfällt der Lock:

void operator delete( void * p )
{
    RTCCALLBACK(_RTC_Free_hook, (p, 0));

    free( p );
}

Wenn ja, was gibt es für Alternativen beliebig lange Messages zwischen Threads auszutauschen (abgesehen von Sockets)?