求问关于wince中的线程 以及 事件

011fmh

求问关于wince中的线程 以及 事件 [复制链接]

创建事件： createEvent是函数 创建的开始是睡眠状态

m_hCommandCompleted = CreateEvent( NULL, FALSE, FALSE, NULL );

等待函数：WaitForSingleObject（） 如果这里用
WaitForSingleObject( m_hCommandCompleted, INFINITE );

设置有信号 SetEvent(hCommandCompleted);

线程：
m_hThread = CreateThread( NULL, 0, CGraphManager::ThreadProc, this, 0, &m_dwThreadId );

我如何等 在有信号的时候 就让m_hThread 唤醒 执行呢？

SetEvent函数应该放在WaitForSingleObject 之前还是之后啊？

谢谢

xyyyxmh

这个原理在windows平台下的都是一样的。

在m_hThread中
WaitForSingleObject( m_hCommandCompleted, INFINITE );

在线程外想唤醒线程时就
SetEvent(hCommandCompleted);

mondayfriday

至少也要两个线程吧，一个调用等待函数进入等待状态；另一个线程设置事件，使用前一个等待的线程被唤醒。

laopo163

to lenux：

那设置信号之后，开始唤醒线程  那什么时候让这个线程重新睡眠呢？

谢谢

wzyllgx

线程：

while(1)
{
WaitForSingleObject( m_hCommandCompleted, INFINITE );
.......
}
上面是举个例子。

处理完了，回到一个循环重新wait

aleksoft

to lenux：

比如在wm5.0下面的一个sample中有：


HRESULT
CGraphManager::Init()
{
    HRESULT hr = S_OK;

    // Create the event that will signal the thread for commands
    m_handle[0] = CreateEvent( NULL, FALSE, FALSE, NULL );
    if( m_handle[0] == NULL )
    {
        ERR( HRESULT_FROM_WIN32( GetLastError() ));
    }
    m_handle[1] = 0;

    // Create the event to sync on to wait for the command to be executed
    m_hCommandCompleted = CreateEvent( NULL, FALSE, FALSE, NULL );  //建立事件
    if( m_hCommandCompleted == NULL )
    {
        ERR( HRESULT_FROM_WIN32( GetLastError() ));
    }

    // CCreate the thread that will run the filtergraph.
    // The filtergraph is runing on a background thread to prevent any window message
    // reentrancy issue.
    m_hThread = CreateThread( NULL, 0, CGraphManager::ThreadProc, this, 0, &m_dwThreadId );//建立线程
    if( m_hThread == NULL )
    {
        ERR( HRESULT_FROM_WIN32( GetLastError() ));
    }


Cleanup:
    return hr;
}



//HandleCommand() 是CAppWindow 的处理WM_COMMAND命令的函数
//
HRESULT
CAppWindow::HandleCommand( WPARAM wParam )
{
        HRESULT hr = S_OK;

        if( m_pGraphManager == NULL )
        {
                ERR( E_FAIL );
        }

        switch( wParam )
        {
                case CMD_START_RECORD_VIDEO:
                        EnableWindow( m_startButtonHwnd, FALSE );
                        EnableWindow( m_stopButtonHwnd, TRUE );
                        EnableWindow( m_stillButtonHwnd, FALSE );
                        m_pGraphManager->StartRecordVideo();
                        break;

                case CMD_STOP_RECORD_VIDEO:
                        EnableWindow( m_stopButtonHwnd, FALSE );
                        m_pGraphManager->StopRecordVideo();
                        break;

                case CMD_STILL_IMAGE:
                        EnableWindow( m_startButtonHwnd, FALSE );
                        EnableWindow( m_stopButtonHwnd, FALSE );
                        EnableWindow( m_stillButtonHwnd, FALSE );
                        m_pGraphManager->CaptureStillImage();
                        break;

                default:
                        break;
    }

Cleanup:
        return hr;
}


HRESULT
CGraphManager::StartRecordVideo()
{
        RETAILMSG(1,(L"CGraphManager::StartRecordVideo() \n"));
    m_currentCommand = COMMAND_STARTCAPTURE;
    SetEvent( m_handle[0] );
    WaitForSingleObject( m_hCommandCompleted, INFINITE );

    return S_OK;
}


DWORD WINAPI
CGraphManager::ThreadProc( LPVOID lpParameter )
{
    HRESULT       hr = S_OK;
    DWORD         dwReturnValue;
    CGraphManager *pThis = (CGraphManager*) lpParameter;
    GRAPHCOMMANDS command = COMMAND_NOCOMMAND;
        RETAILMSG(1,(L"CGraphManager::ThreadProc() started\n"));
    if( pThis == NULL )
    {
        return 0;
    }

    while(( command != COMMAND_SHUTDOWN ) && ( hr != S_FALSE ))
    {
        dwReturnValue = WaitForMultipleObjects( 2, pThis->m_handle, FALSE, INFINITE );
        switch( dwReturnValue )
        {
            case WAIT_OBJECT_0:
                command = pThis->m_currentCommand;
                pThis->ProcessCommand();
                break;

            case WAIT_OBJECT_0 + 1:
                pThis->ProcessDShowEvent();
                break;

            default:
                break;
        }
    };
        RETAILMSG(1,(L"CGraphManager::ThreadProc() is  finished\n"));
    return 0;
}

HRESULT
CGraphManager::ProcessCommand()
{
    HRESULT hr = S_OK;
    switch( m_currentCommand )
    {
        case COMMAND_BUILDGRAPH:
            hr = CreateCaptureGraphInternal();
            SetEvent( m_hCommandCompleted );
            break;

        case COMMAND_RUNGRAPH:
            hr = RunCaptureGraphInternal();
            SetEvent( m_hCommandCompleted );
            break;

        case COMMAND_STARTCAPTURE:
           hr = StartCaptureVideoInternal();
            SetEvent( m_hCommandCompleted );
            break;

        case COMMAND_STOPCAPTURE:
                       
            hr = StopCaptureVideoInternal();
            SetEvent( m_hCommandCompleted );
            break;
        
                case COMMAND_STILLIMAGE:
        hr = CaptureStillImageInternal();
            SetEvent( m_hCommandCompleted );
            break;

        case COMMAND_SHUTDOWN:

            hr = S_FALSE;
            break;

        default:
            break;
    }

    return hr;
}
可以用按Start做个例子么？
按下Start后 窗口相应CMD_START_RECORD_VIDEO ，调用StartRecordVideo（）函数，其中有语句WaitForSingleObject( m_hCommandCompleted, INFINITE )；

我通过串口打印的信息 在这之后才调用ProcessCommand（） 函数，而
m_hCommandCompleted的信号是在ProcessCommand（）函数中被设置。
这里我就很不懂，在这里设置之后难道还要反向到StartRecordVideo（）中等待嘛？但是执行顺序是先WaitForSingleObject 后才SetEvent()，这个到底是怎么一回事呢？

还有 为什么启动的线程就是    m_hThread？？？
谢谢

521022

我还有一点很不明白  在运行的时候是先开始运行到 CGraphManager::BuildCaptureGraph() 这个函数
但是这个函数
HRESULT
CGraphManager::BuildCaptureGraph()
{
        RETAILMSG(1,(L"CGraphManager::BuildCaptureGraph() \n"));
    // The Graph is built on a separate thread to
    // prevent reentrancy issues.
    m_currentCommand = COMMAND_BUILDGRAPH;
    SetEvent( m_handle[0] );
    WaitForSingleObject( m_hCommandCompleted, INFINITE ); //请看这句话

    return S_OK;
}

很是奇怪 在这个函数被调用之前m_hCommandCompleted 一直是没有信号的
为什么不会停在这个地方 而事实是要继续执行的

谢谢

zhgb1981

多线程不是C下面的单线程顺序逻辑。

StartRecordVideo()中执行到WaitForSingleObject( m_hCommandCompleted, INFINITE );之后就挂起（睡眠）了。在等待m_hCommandCompleted这个event被设置(set)。

ProcessCommand()中SetEvent(m_hCommandCompleted)，然后StartRecordVideo()这个线程就被唤醒了，从刚才挂起（睡眠）的地方，也就是WaitForSingleObject( m_hCommandCompleted, INFINITE );之后一条语句开始继续执行。

多找些线程的资料，然后自己写几个多线程的程序跑一跑，更能理解的清楚些。

asdfgh123

霏霏说得很对。

多线程是指几个线程在你看来是同时都在运行的。你的单步只是使当前断点所在线程停下来，其他线程还在继续运行。

所以
WaitForSingleObject( m_hCommandCompleted, INFINITE );
后，很快m_hCommandCompleted就被set了