C / C++ / MFC

class CMyDialog : public CDialog //or another suitable CWnd derived base class
{
    .....
protected:
    static UINT MyThreadFn( LPVOID pThis ) { return ((CMyDialog*)pThis)->MyThreadFn(); }
    UINT MyThreadFn(); // The thread controlling function
    volatile BOOL m_bStopMyThread;
    CWinThread* m_pMyThread;
    ....
};

#define UWM_MY_MESSAGE (WM_APP + 1)
class CMyClass : public CDialog
{
    ....
    afx_msg LRESULT OnMyMessage( WPARAM wParam, LPARAM lParam );
    ....
};

....
BEGIN_MESSAGE_MAP(CMyClass, CDialog)
    ....
    ON_MESSAGE( UWM_MY_MESSAGE, OnMyMessage )
    ....
END_MESSAGE_MAP()
....
....
LRESULT CMyClass::OnMyMessage( WPARAM wParam, LPARAM lParam )
{
    // Do whatever you need to do here
    return 0;
}

UINT CMyClass::MyThreadFn()
{
    WORD wLength; // The length of the received data
    BYTE* pData;  // Pointer to the received data
    ....
    while( !m_bStopMyThread )
    {
        ....
        pData = new BYTE[wLength];
        // Here should be some code that copies the data to pData e.g. memcpy( pByte, ...., wLength )
        PostMessage( UWM_MY_MESSAGE, (WPARAM)wLength, (LPARAM)pByte );
        ....
    }
    ....
}

LRESULT CMyClass::OnMyMessage( WPARAM wParam, LPARAM lParam )
{
    WORD wLength = (WORD)wParam;
    BYTE* pData = (BYTE*)lParam;
    // Do whatever you need to do with your data, update controls and so on
    ....
    delete pData;
    return 0;
}

#define UWM_GOT_DATA (WM_APP + 1)

m_pMyThread = AfxBeginThread( MyThreadFn, this )

m_pMyThread = AfxBeginThread( MyThreadFn, this, 0, 0, CREATE_SUSPENDED, NULL );
if( m_pMyThread )
{
    m_pMyThread->m_bAutoDelete = FALSE;
    m_pMyThread->ResumeThread();
}

DWORD dwWaitResult;
BOOL bQuit = FALSE;
while( !bQuit )
{
    dwWaitResult = ::MsgWaitForMultipleObjects( 1, &m_pMyThread->m_hThread, FALSE, INFINITE, QS_ALLINPUT );
    switch( dwWaitResult )
    {
        case WAIT_OBJECT_0:
            bQuit = TRUE;
            break;
            
        case WAIT_OBJECT_0 + 1:
        {
            MSG msg;
            while( ::PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
            {
                ::DispatchMessage( &msg );
            }
        }
        break;
            
        case WAIT_FAILED:
        {
            CString msg;
            msg.Format( "Wait failed. Error code 0x%x.\n", GetLastError() );
            ::OutputDebugString( msg );
            bQuit = TRUE;
        }
        break;
        
        default:
        {
            CString msg;
            msg.Format( "Unexpected wait result: 0x%x.\n", dwWaitResult );
            ::OutputDebugString( msg );
            bQuit = TRUE;
        }
        break;
    }
}
delete m_pMyThread;
m_pMyThread = NULL;

enum
{
    SuccessIndex,
    ErrorIndex,
    WinMsgIndex //Index returned by MsgWaitFor... in case of a message, this is also the number of events in the array
};
HANDLE m_hThreadStartEvents[WinMsgIndex];

m_hThreadStartEvents[SuccessIndex] = ::CreateEvent( NULL, TRUE, FALSE, NULL );
m_hThreadStartEvents[ErrorIndex] = ::CreateEvent( NULL, TRUE, FALSE, NULL );

::CloseHandle( m_hThreadStartEvents[SuccessIndex] );
::CloseHandle( m_hThreadStartEvents[ErrorIndex] );

dwWaitResult = ::MsgWaitForMultipleObjects( WinMsgIndex, m_hThreadStartEvents, FALSE, INFINITE, QS_ALLINPUT );

case SuccessIndex:
    // Do whatever needs to be done if the thread started successfully
    break;
    
case ErrorIndex:
    // Do whatever needs to be done if the thread failed somehow
    break;
    
case WinMsgIndex:
    // We now have messages in the threads message queue to process
    // How this is done is shown above
    break;

while( !m_bStopThread )
{
    ....
    ....
}

with probably too much time to spare