C:/rwlock/thread_w32.cpp

Go to the documentation of this file.

/* ****************************************************************************
 * Author:      Evgeniy Makeev
 * ****************************************************************************
 */
#include <process.h>

#include "thread.hh"

    struct W32ThreadData
    {
            unsigned long       handle; 
        unsigned                id;
            long                        defaultPriority;
            long                        currentPriority;
    };

    const unsigned long Thread::kThreadShutDownTimeout = 60;

    static unsigned __stdcall W32ThreadFunc( void *currThread )
    {
            ((Thread *)currThread)->internalRun();
            return(0);
    }


    Thread::Thread(bool susp) : self_destruct(false), implData((void*)new W32ThreadData)
    {
            currentPriority = 0;
//          *((W32ThreadData **)&implData) = new W32ThreadData;
            assert(implData);
            cs = System::createCriticalSection();
            assert(cs);     
            cs->enter();

            status = kThreadCreated;
            suspended = susp;

            W32ThreadData &d = *((W32ThreadData *)implData);
            status = kThreadCreated;
    //  d.handle = CreateThread( NULL, 0, W32ThreadFunc, (LPVOID)this,
    //                                                   suspended ? CREATE_SUSPENDED : 0, &d.id );
            d.handle = _beginthreadex( NULL, 0, W32ThreadFunc, (LPVOID)this,
                                                             suspended ? CREATE_SUSPENDED : 0, &d.id );
        if((!d.handle) || suspended) cs->leave(); // don't leave CS before initaialized call

            assert(d.handle);
    }
                    
    Thread::~Thread()
    {
            stop( kThreadShutDownTimeout );
            if( !stopped() )
            {
                    destroy();
            }
            CloseHandle( (HANDLE)((W32ThreadData *)implData)->handle );
            delete (W32ThreadData *)implData;
            delete cs;
    }
            
    long        Thread::stop( unsigned long timeoutSeconds )
    {
            cs->enter();
            if( status == kThreadRunning )
            {
                    status = kThreadStopping;
            }
            else
            {
                    cs->leave();
                    return( kThreadIsNotRunning );
            }
            cs->leave();

            return(join( timeoutSeconds ));
    }

    long        Thread::suspend()
    {
            cs->enter();
            suspended = true;
            cs->leave();

            if( SuspendThread( (HANDLE)((W32ThreadData *)implData)->handle ) != 0xFFFFFFFF )
            {
                    cs->enter();
                    suspended = false;
                    cs->leave();
                    return(GetLastError());
            }
            else
            {
                    return(0);
            }
    }

    long        Thread::resume()
    {
            DWORD res;
            cs->enter();
            suspended = false;
            cs->leave();
            do
            {
                    res = ResumeThread( (HANDLE)((W32ThreadData *)implData)->handle );
                    if( res == 0xFFFFFFFF )
                    {
                            res = GetLastError();
                            cs->enter();
                            suspended = true;
                            cs->leave();
                            return(res);
                    }
            }
            while( res > 1 );
            return(0);
    }

    long        Thread::join( unsigned long timeoutSeconds )
    {
        DWORD timeout = timeoutSeconds * 1000;

//        System::debugPrint("Thread::join - waiting.");
            while( (status == kThreadRunning) || (status == kThreadStopping) )
            {
                    DWORD res = WaitForSingleObject( 
                                                    (HANDLE)((W32ThreadData *)implData)->handle,
                                                     50 );
                    if( res != WAIT_TIMEOUT )
            {
                if( res == WAIT_FAILED ) return kThreadTimeout;
                else return 0;
            }
            if( timeout < 50 ) return kThreadTimeout;
            timeout -= 50;
            }

            return(0);
    }

    void        Thread::sleep( unsigned long sleepTimeMillisec )
    {
            Sleep( sleepTimeMillisec );
    }

    void        Thread::yield()
    {
            Sleep(0);
    }

    long        Thread::destroy()
    {
            long res;
            if( TerminateThread( (HANDLE)((W32ThreadData *)implData)->handle, 3 ) )
            {
                    res = 0;
            }
            else
            {
                    res = GetLastError();
            }

            return(res); 
    }

    struct ThreadPriorityStr
    {
            static      ThreadPriorityStr       priorities[];
            static      long    normalPriority;
            static      long    len;

            static      int             getNativePriority( long cpPr )
            {
                    int res = cpPr + normalPriority;
                    if( res < 0 ) res = 0;
                    if( res >= len ) res = len - 1;
                    return( priorities[res].w32Priority );
            }

            int                         w32Priority;
    };


    ThreadPriorityStr   ThreadPriorityStr::priorities[7] =
    {
            THREAD_PRIORITY_TIME_CRITICAL, 
            THREAD_PRIORITY_HIGHEST, 
            THREAD_PRIORITY_ABOVE_NORMAL,

            THREAD_PRIORITY_NORMAL, 

            THREAD_PRIORITY_BELOW_NORMAL,
            THREAD_PRIORITY_LOWEST,
            THREAD_PRIORITY_IDLE
    };

    long        ThreadPriorityStr::len = 7;
    long        ThreadPriorityStr::normalPriority = 3;

    //
    // 0 - default(normal) priority, -xx - lower priorities,
    // yy - higher priorities
    //
    long        Thread::setPriority( long newPriority )
    {
            if( newPriority > getMaxPriority() || newPriority < getMinPriority() )
            {
                    return( kThreadInvalidParameter );
            }
            if( SetThreadPriority( (HANDLE)((W32ThreadData *)implData)->handle,
                            ThreadPriorityStr::getNativePriority(newPriority) ) )
            {
                    currentPriority = newPriority;
                    return(0);
            }
            else
            {
                    return( GetLastError() );
            }
    }

    long        Thread::getPriority()
    {
            return( currentPriority );
    }

    long        Thread::getMaxPriority()
    {
            return( ThreadPriorityStr::len - (ThreadPriorityStr::normalPriority + 1) );
    }

    long        Thread::getMinPriority()
    {
            return( -(ThreadPriorityStr::normalPriority) );
    }

---