Re: Synchronize the read/write operation between threads
mmlab_js wrote:
In main thread, I capture video stream from webcam with VFW. When the video
frame is captured by the driver, the OnCaptureStream is invoked. In this
callback function, I copy the frame into a global frame buffer and return.
The code is following:
==================================================
LRESULT CALLBACK OnCaptureStream(HWND mwnd,LPVIDEOHDR lphdr)
{
CCaptureDlg *pCapDlg = (CCaptureDlg *)capGetUserData(mwnd);
if(pCapDlg != NULL) {
EnterCriticalSection(&g_CriticalSection);
memcpy(g_FrameBuffer, lphdr->lpData, lphdr->dwBytesUsed);
LeaveCriticalSection(&g_CriticalSection);
}
return TRUE;
}
==================================================
In worker thread, if the global frame buffer is already written, the worker
thread will copy the frame into its buffer and process it.
But how can I let the woker thread know the new frames is already written
into global frame buffer?
And can I read the buffer from threads at the same time?
In the worker thread, in order to avoid the data be written by the main
thread during copy from global buffer into woker's thread, I use the critical
senction object:
=============================
EnterCriticalSection(&g_CriticalSection);
memcpy(workerbuffer, g_FrameBuffer, len);
LeaveCriticalSection(&g_CriticalSection);
=============================
But there are many the same worker threads, is there any problem for this
design?
The design seems safe but inefficient. All the writer and reader
threads must use the critical section, which suspends them to avoid
simultaneous access, so they are sometimes slowed down. And also for
some reason you are copying the frame buffer twice. With this design,
the way to let the worker thread know when the new frame is written is
to use WaitForSingleObject in the worker thread, and SetEvent in the
main thread. WaitForSingleObject will suspend the worker thread until
SetEvent is called.
A more efficient design would use message-driven threads, the so-called
UI thread created by AfxBeginThread(RUNTIME_CLASS(CMyThread).... The
main thread would tell a work thread when to process by calling
pThread->PostThreadMessage. A parameter in PostThreadMessage would pass
a pointer to the buffer to be processed. The buffer could be allocated
with new in the main thread, deleted in the work thread. Or for better
performance you would manage a circular queue of buffers so no real-time
allocation or copying is needed. This can give you a design with no
copying, no critical section delays, and built-in read/write
synchronization.
--
Scott McPhillips [VC++ MVP]