Microsoft KB Archive/141533

= FIX: CSyncObject::Lock Always Returns TRUE for Finite Waits =

Article ID: 141533

Article Last Modified on 8/18/2005

-

APPLIES TO


 * Microsoft Foundation Class Library 4.2

-



This article was previously published under Q141533



SYMPTOMS
The CSyncObject::Lock function always returns TRUE for finite values of timeout intervals. This happens even if the synchronization object is in a non-signaled state.



CAUSE
CSyncObject::Lock is supposed to return FALSE only when the synchronization object is in a non-signaled state. The current implementation of this function makes a call to ::WaitForSingleObject and returns FALSE only when ::WaitForSingleObject returns WAIT_FAILED. This is incorrect.


 * WaitForSingleObject returns WAIT_FAILED only when the call itself fails. When it succeeds, it can return a variety of values, with only WAIT_OBJECT_0 indicating that the synchronization object is in a signaled state.

CSyncObject::Lock is a virtual function that is overridden only in the case of CCriticalSection. Hence the problem arises if you work with a CEvent, CMutex, or a CSemaphore object. The problem also comes up if you work with the CSingleLock class and call CSingleLock::Lock. This is because CSingleLock::Lock calls CSyncObject::Lock through its synchronization object.

In the case of finite timeout intervals, if the object is non-signaled, ::WaitForSingleObject returns WAIT_TIMEOUT. The CSyncObject::Lock should return FALSE but its current implementation returns TRUE. The return value from the Lock function is also TRUE when ::WaitForSingleObject returns WAIT_ABANDONED indicating that the thread that owned this synchronization object (a CMutex) terminated before releasing it.



RESOLUTION
The easiest way to fix the problem is to derive a new class from the synchronization object class that is being used (CEvent, CMutex, or CSemaphore). The only function that needs to be overridden is the CSyncObject::Lock function. Because this function is virtual, if you work with an object of your derived class, your derived class' implementation of Lock will be called. The Lock function in the new class (assuming it is called CMyEvent) should be implemented as: BOOL CMyEvent::Lock(DWORD dwTimeout) { if (::WaitForSingleObject(m_hObject, dwTimeout) == WAIT_OBJECT_0) return TRUE; else return FALSE; } Please see the "Sample Code" section of this article for an illustration showing how to work around the problem. The sample code gives the definition of a class derived from the CEvent class and its implementation.

In the case of CMutex and CSemaphore, you need to proceed in the same manner. You need to derive new classes and override the Lock function in an identical fashion.

The correct CSyncObject::Lock : BOOL CSyncObject::Lock(DWORD dwTimeout) { if (::WaitForSingleObject(m_hObject, dwTimeout) ==  WAIT_OBJECT_0) return TRUE; else return FALSE; }



STATUS
Microsoft has confirmed this to be a bug in the Microsoft products listed at the beginning of this article. This bug was corrected in Visual C++ 4.1.



Sample Code
/* Compile options needed: Default Options

// The Myevent.h File


 * 1) ifndef _MY_EVENT_
 * 2) define _MY_EVENT_

class CMyEvent : public CEvent {     DECLARE_DYNAMIC(CMyEvent)

// Constructor public: CMyEvent(BOOL bInitiallyOwn = FALSE, BOOL bManualReset = FALSE,              LPCTSTR lpszName = NULL,               LPSECURITY_ATTRIBUTES lpsaAttribute = NULL) : CEvent(bInitiallyOwn, bManualReset, lpszName,                     lpsaAttribute) { }

// Operations public: BOOL virtual Lock (DWORD dwTimeout = INFINITE); };


 * 1) endif

// The Myevent.cpp File


 * 1) include "stdafx.h"
 * 2) include 
 * 3) include "myevent.h"

IMPLEMENT_DYNAMIC (CMyEvent, CEvent)

BOOL CMyEvent::Lock(DWORD dwTimeout) { if (::WaitForSingleObject(m_hObject, dwTimeout) ==  WAIT_OBJECT_0) return TRUE; else return FALSE; }

Additional query words: kbVC400bug CSyncObject 4.00 Lock WAIT_TIMEOUT Windows 95 4.10

Keywords: kbbug kbfix kbthread kbnoupdate kbvc410fix KB141533

-

[mailto:TECHNET@MICROSOFT.COM Send feedback to Microsoft]

© Microsoft Corporation. All rights reserved.