cppu/source/threadpool/threadpool.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: threadpool.hxx,v $
  10  * $Revision: 1.6 $
  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 #include <hash_map>
  31
  32 #include <osl/conditn.h>
  33
  34 #include <rtl/byteseq.hxx>
  35
  36 #include "jobqueue.hxx"
  37
  38
  39 using namespace ::rtl;
  40 namespace cppu_threadpool {
  41     class ORequestThread;
  42
  43     struct EqualThreadId
  44     {
  45         sal_Int32 operator () ( const ::rtl::ByteSequence &a , const ::rtl::ByteSequence &b ) const
  46             {
  47                 return a == b;
  48             }
  49     };
  50
  51     struct HashThreadId
  52     {
  53         sal_Int32 operator () ( const ::rtl::ByteSequence &a  )  const
  54             {
  55                 if( a.getLength() >= 4 )
  56                 {
  57                     return *(sal_Int32 *)a.getConstArray();
  58                 }
  59                 return 0;
  60             }
  61     };
  62
  63     typedef     ::std::hash_map
  64     <
  65         ByteSequence, // ThreadID
  66         ::std::pair < JobQueue * , JobQueue * >,
  67         HashThreadId,
  68         EqualThreadId
  69     > ThreadIdHashMap;
  70
  71     typedef     ::std::list     < sal_Int64 > DisposedCallerList;
  72
  73
  74     struct WaitingThread
  75     {
  76         oslCondition condition;
  77         ORequestThread *thread;
  78     };
  79
  80     typedef     ::std::list     < struct ::cppu_threadpool::WaitingThread * > WaitingThreadList;
  81
  82     class DisposedCallerAdmin
  83     {
  84     public:
  85         ~DisposedCallerAdmin();
  86
  87         static DisposedCallerAdmin *getInstance();
  88
  89         void dispose( sal_Int64 nDisposeId );
  90         void stopDisposing( sal_Int64 nDisposeId );
  91         sal_Bool isDisposed( sal_Int64 nDisposeId );
  92
  93     private:
  94         ::osl::Mutex m_mutex;
  95         DisposedCallerList m_lst;
  96     };
  97
  98     class ThreadPool
  99     {
 100     public:
 101         ~ThreadPool();
 102         static ThreadPool *getInstance();
 103
 104         void dispose( sal_Int64 nDisposeId );
 105         void stopDisposing( sal_Int64 nDisposeId );
 106
 107         void addJob( const ByteSequence &aThreadId,
 108                      sal_Bool bAsynchron,
 109                      void *pThreadSpecificData,
 110                      RequestFun * doRequest );
 111
 112         void prepare( const ByteSequence &aThreadId );
 113         void * enter( const ByteSequence &aThreadId, sal_Int64 nDisposeId );
 114
 115         /********
 116          * @return true, if queue could be succesfully revoked.
 117          ********/
 118         sal_Bool revokeQueue( const ByteSequence & aThreadId , sal_Bool bAsynchron );
 119
 120         void waitInPool( ORequestThread *pThread );
 121     private:
 122         void createThread( JobQueue *pQueue, const ByteSequence &aThreadId,     sal_Bool bAsynchron);
 123
 124
 125         ThreadIdHashMap m_mapQueue;
 126         ::osl::Mutex m_mutex;
 127
 128         ::osl::Mutex m_mutexWaitingThreadList;
 129         WaitingThreadList m_lstThreads;
 130     };
 131
 132 } // end namespace cppu_threadpool