sw/source/core/inc/threadmanager.hxx

   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: threadmanager.hxx,v $
  10  * $Revision: 1.3 $
  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 #ifndef _THREADMANAGER_HXX
  31 #define _THREADMANAGER_HXX
  32
  33 #include <ithreadlistenerowner.hxx>
  34 #include <vcl/timer.hxx>
  35 #include <osl/mutex.hxx>
  36 #include <osl/interlck.h>
  37 #include <rtl/ref.hxx>
  38
  39 #include <deque>
  40 #include <list>
  41 #include <cppuhelper/weak.hxx>
  42 #include "com/sun/star/util/XJobManager.hpp"
  43 #include <observablethread.hxx>
  44 #include <cancellablejob.hxx>
  45 #include <threadlistener.hxx>
  46
  47 #include <boost/shared_ptr.hpp>
  48 #include <boost/weak_ptr.hpp>
  49
  50 /** class to manage threads
  51
  52     OD 2007-01-29 #i73788#
  53     An instance of this class takes care of the starting of threads.
  54     It assures that not more than <mnStartedSize> threads
  55     are started.
  56
  57     @author OD
  58 */
  59 class ThreadManager : public IThreadListenerOwner
  60 {
  61     public:
  62
  63         explicit ThreadManager( ::com::sun::star::uno::Reference< ::com::sun::star::util::XJobManager >& rThreadJoiner );
  64         ~ThreadManager();
  65
  66         // --> IThreadListenerOwner
  67         virtual boost::weak_ptr< IFinishedThreadListener > GetThreadListenerWeakRef();
  68         virtual void NotifyAboutFinishedThread( const oslInterlockedCount nThreadID );
  69         // <--
  70
  71         /** initialization
  72
  73             IMPORTANT NOTE: Needs to be called directly after construction
  74
  75             @author OD
  76         */
  77         void Init();
  78
  79         /** add thread to the thread manager and taking ownership for the thread
  80
  81             @author OD
  82
  83             @return unique ID for added thread
  84         */
  85         oslInterlockedCount AddThread(
  86                             const ::rtl::Reference< ObservableThread >& rThread );
  87
  88         void RemoveThread( const oslInterlockedCount nThreadID,
  89                            const bool bThreadFinished = false );
  90
  91         DECL_LINK( TryToStartNewThread, Timer* );
  92
  93         /** suspend the starting of threads
  94
  95             Suspending the starting of further threads is sensible during the
  96             destruction of a Writer document.
  97
  98             @author OD
  99         */
 100         inline void SuspendStartingOfThreads()
 101         {
 102             osl::MutexGuard aGuard(maMutex);
 103
 104             mbStartingOfThreadsSuspended = true;
 105         }
 106
 107         /** continues the starting of threads after it has been suspended
 108
 109             @author OD
 110         */
 111         void ResumeStartingOfThreads();
 112
 113         inline bool StartingOfThreadsSuspended()
 114         {
 115             osl::MutexGuard aGuard(maMutex);
 116
 117             return mbStartingOfThreadsSuspended;
 118         }
 119
 120         struct tThreadData
 121         {
 122             oslInterlockedCount nThreadID;
 123             ::rtl::Reference< ObservableThread > pThread;
 124             com::sun::star::uno::Reference< com::sun::star::util::XCancellable > aJob;
 125
 126             tThreadData()
 127                 : nThreadID( 0 ),
 128                   pThread( 0 ),
 129                   aJob()
 130             {}
 131         };
 132
 133     private:
 134
 135         static const std::deque< tThreadData >::size_type mnStartedSize;
 136
 137         osl::Mutex maMutex;
 138
 139         ::com::sun::star::uno::WeakReference< ::com::sun::star::util::XJobManager > mrThreadJoiner;
 140
 141         boost::shared_ptr< ThreadListener > mpThreadListener;
 142
 143         oslInterlockedCount mnThreadIDCounter;
 144
 145         std::deque< tThreadData > maWaitingForStartThreads;
 146         std::deque< tThreadData > maStartedThreads;
 147
 148         Timer maStartNewThreadTimer;
 149
 150         bool mbStartingOfThreadsSuspended;
 151
 152         struct ThreadPred
 153         {
 154             oslInterlockedCount mnThreadID;
 155             explicit ThreadPred( oslInterlockedCount nThreadID )
 156                 : mnThreadID( nThreadID )
 157             {}
 158
 159             bool operator() ( const tThreadData& rThreadData ) const
 160             {
 161                 return rThreadData.nThreadID == mnThreadID;
 162             }
 163         };
 164
 165
 166         inline oslInterlockedCount RetrieveNewThreadID()
 167         {
 168             return osl_incrementInterlockedCount( &mnThreadIDCounter );
 169         }
 170
 171         bool StartWaitingThread();
 172
 173         bool StartThread( const tThreadData& aThreadData );
 174 };
 175 #endif