Re: why UI gets hangs

From:

Dan Bloomquist <public21@lakeweb.com>

Newsgroups:

microsoft.public.vc.mfc

Date:

Mon, 24 Mar 2008 18:47:59 GMT

Message-ID:

<zHSFj.466$NU2.309@news01.roc.ny>

Joseph M. Newcomer wrote:

See below...
On Mon, 24 Mar 2008 17:04:10 GMT, Dan Bloomquist <public21@lakeweb.com> wrote:

Joseph M. Newcomer wrote:

On Mon, 24 Mar 2008 06:31:44 GMT, Dan Bloomquist <public21@lakeweb.com> wrote:

UINT Thread( LPVOID pParam )
{
    TS& strct= *static_cast<TS*>( pParam );

    for( long i= 0; ; ++i )
    {
        //if( strct.bTReady )
        {
            strct.strT.Format( _T("Test This %d"), i );
            ::PostMessage( *strct.pDlg, ID_CHECK_THREAD, 0, 0 );

****
This is truly weird, because you are using a shared variable and bizarre simulated
locking, and there is no need to do ANY of this, because you can pass a pointer in the
message itself! This means that you aren't going to lose anything, and you don't need to
do ugly polling loops!

Hi Joe,
I think you have misunderstood my objective.

UINT Thread( LPVOID pParam )
{
...
    for( long i= 0; ; ++i )
    //This is the worker loop, it is doing real work.
    {
        ...
        //Now it has progress data for the GUI thread
        //if that thread is ready for another message
        //it will post it.
        if( strct.bTReady )
        {
            strct.strT.Format( _T("Test This %d"), i );
            ::PostMessage( *strct.pDlg, ID_CHECK_THREAD, 0, 0 );
            strct.bTReady= false;
        }
    }
}

I wouldn't trust this code to work correctly in a multiprocessor.

Does this still apply?

sending thread:
WaitForSingleObject(strct.semaphore, INFINITE);
That's what semaphores are for. The code you show cannot be trusted to be correct in all
situations, and by using polling, you are wasting significant amounts of energy.

My objective was an example of 'not' blocking the thread and keeping the
GUI updated. In that light, do you see a problem with the way I use the
semaphore strct.bTReady?

****
It isn't a semaphore; it is a bool variable.

The wiki author calls it a 'binary semaphore', better known as a mutex.
http://en.wikipedia.org/wiki/Semaphore_(programming)

I would think any object that is used as a signal between threads would
qualify as a semaphore.

In rereading it, I see that the Sleep() is
not part of the test loop, but now you have a situation in which it will not update unless
the other thread has processed the data, which means that you will lose information by not
sending it at all. If your system is redundant enough that you can afford to lose
information, then it works, but if you need reliable communication by which everything you
want to send is received, it doesn't work.

Sorry for the confusion. I thought what I was doing was clear in the
original post. It was an experiment to purposefully break it. One, by
swamping the GUI thread and second, by letting the GUI thread at the
data while it was changing.

And yes, of course it would have to be more elaborate to ensure data is
not lost.

Best, Dan.