vos/source/thread.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: thread.cxx,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <osl/time.h>
  32 #include <vos/diagnose.hxx>
  33 #include <vos/object.hxx>
  34 #include <vos/thread.hxx>
  35
  36 using namespace vos;
  37
  38 void vos::threadWorkerFunction_impl(void * pthis)
  39 {
  40     NAMESPACE_VOS(OThread)* pThis= (NAMESPACE_VOS(OThread)*)pthis;
  41
  42     // call Handler-Function of OThread-derived class
  43     pThis->run();
  44
  45     // if not already terminating, by a kill do normal shutdown
  46     if (! pThis->m_bTerminating)
  47     {
  48         pThis->m_bTerminating = sal_True;
  49
  50         pThis->onTerminated();          // could e.g. delete this
  51     }
  52 }
  53
  54 /////////////////////////////////////////////////////////////////////////////
  55 //
  56 // Thread class
  57 //
  58
  59 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OThread, vos),
  60                         VOS_NAMESPACE(OThread, vos),
  61                         VOS_NAMESPACE(OObject, vos), 0);
  62
  63 OThread::OThread()
  64 {
  65     m_hThread      = 0;
  66     m_bTerminating = sal_False;
  67     m_aCondition   = osl_createCondition();
  68 }
  69
  70 OThread::~OThread()
  71 {
  72     if (m_hThread != 0)
  73     {
  74         osl_destroyThread(m_hThread);
  75     }
  76
  77     osl_destroyCondition( m_aCondition );
  78 }
  79
  80 sal_Bool OThread::create()
  81 {
  82     VOS_ASSERT(m_hThread == 0); // only one running thread per instance
  83
  84     m_hThread = osl_createSuspendedThread(
  85         threadWorkerFunction_impl, (void*)this);
  86     if (m_hThread)
  87         osl_resumeThread(m_hThread);
  88
  89     return m_hThread != 0;
  90 }
  91
  92 sal_Bool OThread::createSuspended()
  93 {
  94     VOS_ASSERT(m_hThread == 0); // only one running thread per instance
  95
  96     m_hThread= osl_createSuspendedThread(threadWorkerFunction_impl, (void*)this);
  97     return m_hThread != 0;
  98 }
  99
 100 void OThread::suspend()
 101 {
 102     VOS_ASSERT(m_hThread != 0); // use only on running thread
 103
 104     osl_suspendThread(m_hThread);
 105 }
 106
 107 void OThread::resume()
 108 {
 109     VOS_ASSERT(m_hThread != 0); // use only on running thread
 110
 111     osl_resumeThread(m_hThread);
 112 }
 113
 114 sal_Bool OThread::isRunning()
 115 {
 116     return m_hThread != 0 && osl_isThreadRunning(m_hThread);
 117 }
 118
 119 OThread::TThreadIdentifier OThread::getIdentifier() const
 120 {
 121     return (TThreadIdentifier)osl_getThreadIdentifier(m_hThread);
 122 }
 123
 124 OThread::TThreadIdentifier OThread::getCurrentIdentifier()
 125 {
 126     return (TThreadIdentifier)osl_getThreadIdentifier(0);
 127 }
 128
 129 void OThread::join()
 130 {
 131     if (m_hThread) {
 132         VOS_ASSERT(getCurrentIdentifier() != getIdentifier());
 133         osl_joinWithThread(m_hThread);
 134     }
 135 }
 136
 137 OThread::TThreadSleep OThread::sleep(const TimeValue& Delay)
 138 {
 139     TThreadSleep eRet;
 140
 141     switch( osl_waitCondition( m_aCondition, &Delay ) )
 142     {
 143     case osl_cond_result_ok:
 144         eRet = TSleep_Normal;
 145         break;
 146
 147     case osl_cond_result_timeout:
 148         eRet = TSleep_Cancel;
 149         break;
 150
 151     default:
 152         eRet = TSleep_Error;
 153         break;
 154     }
 155
 156     return eRet;
 157 }
 158
 159 void OThread::wait(const TimeValue& Delay) {
 160     osl_waitThread(&Delay);
 161 }
 162
 163 sal_Bool OThread::awake()
 164 {
 165     osl_setCondition( m_aCondition );
 166     return osl_resetCondition( m_aCondition );
 167 }
 168
 169 void OThread::terminate()
 170 {
 171     osl_terminateThread(m_hThread);
 172 }
 173
 174 sal_Bool OThread::schedule() {
 175     return osl_scheduleThread(m_hThread);
 176 }
 177
 178 void OThread::kill()
 179 {
 180     if (osl_isThreadRunning(m_hThread))
 181     {
 182         // flag we are shutting down
 183         m_bTerminating = sal_True;
 184
 185         terminate();
 186         join();
 187     }
 188 }
 189
 190 void OThread::setPriority(OThread::TThreadPriority Priority)
 191 {
 192     osl_setThreadPriority(m_hThread, (oslThreadPriority)Priority);
 193 }
 194
 195 OThread::TThreadPriority OThread::getPriority()
 196 {
 197     return      (TThreadPriority)osl_getThreadPriority(m_hThread);
 198 }
 199
 200
 201 void OThread::yield()
 202 {
 203     osl_yieldThread();
 204 }
 205
 206 void OThread::onTerminated()
 207 {
 208 }
 209
 210 /////////////////////////////////////////////////////////////////////////////
 211 //
 212 // ThreadData class
 213 //
 214
 215 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OThreadData, vos),
 216                         VOS_NAMESPACE(OThreadData, vos),
 217                         VOS_NAMESPACE(OObject, vos), 0);
 218
 219 OThreadData::OThreadData( oslThreadKeyCallbackFunction pCallback )
 220 {
 221     m_hKey = osl_createThreadKey( pCallback );
 222     VOS_VERIFY(m_hKey);
 223 }
 224
 225 OThreadData::~OThreadData()
 226 {
 227     osl_destroyThreadKey(m_hKey);
 228 }
 229
 230 sal_Bool OThreadData::setData(void *pData)
 231 {
 232     VOS_ASSERT(m_hKey != 0);
 233
 234     return (osl_setThreadKeyData(m_hKey, pData));
 235 }
 236
 237 void *OThreadData::getData()
 238 {
 239     VOS_ASSERT(m_hKey != 0);
 240
 241     return (osl_getThreadKeyData(m_hKey));
 242 }
 243