Better fix for ThreadPool/ORequestThread life cycle

This is a follow up to d015384e1d98fe77fd59339044f58efb1ab9fb25 "Fixed
ThreadPool (and dependent ORequestThread) life cycle" that still had some
problems:

* First, if Bridge::terminate was first entered from the reader or writer
thread, it would not join on that thread, so that thread could still be running
during exit.

That has been addressed by giving Bridge::dispose new semantics:  It waits until
both Bridge::terminate has completed (even if that was called from a different
thread) and all spawned threads (reader, writer, ORequestThread workers) have
been joined.  (This implies that Bridge::dispose must not be called from such a
thread, to avoid deadlock.)

* Second, if Bridge::terminate was first entered from an ORequestThread, the
call to uno_threadpool_dispose(0) to join on all such worker threads could
deadlock.

That has been addressed by making the last call to uno_threadpool_destroy wait
to join on all worker threads, and by calling uno_threadpool_destroy only from
the final Bridge::terminate (from Bridge::dispose), to avoid deadlock.  (The
special semantics of uno_threadpool_dispose(0) are no longer needed and have
been removed, as they conflicted with the fix for the third problem below.)

* Third, once uno_threadpool_destroy had called uno_threadpool_dispose(0), the
ThreadAdmin singleton had been disposed, so no new remote bridges could
successfully be created afterwards.

That has been addressed by making ThreadAdmin a member of ThreadPool, and making
(only) those uno_ThreadPool handles with overlapping life spans share one
ThreadPool instance (which thus is no longer a singleton, either).
Additionally, ORequestThread has been made more robust (in the style of
salhelper::Thread) to avoid races.

(cherry picked from commit 2fa2660b55a34a5780f9ea8dbbbe92d05dc9a818)

Conflicts:

	binaryurp/source/bridge.cxx
	cppu/Library_cppu.mk
	cppu/source/threadpool/threadpool.cxx

Change-Id: I2cbd1b3f9aecc1bf4649e482d2c22b33b471788f

Signed-off-by: Caolán McNamara <caolanm@redhat.com>

13 files changed, 372 insertions, 283 deletions

diff --git a/binaryurp/source/bridge.cxx b/binaryurp/source/bridge.cxx
index f591fe0e9e43..13987fe3bd51 100644
--- a/binaryurp/source/bridge.cxx
+++ b/binaryurp/source/bridge.cxx
@@ -102,17 +102,15 @@ rtl::OUString toString(css::uno::TypeDescription const & type) {
 extern "C" void SAL_CALL freeProxyCallback(uno_ExtEnvironment *, void * pProxy)
 {
     assert(pProxy != 0);
     static_cast< Proxy * >(pProxy)->do_free();
 }
 
-void joinThread(osl::Thread * thread) {
+bool isThread(osl::Thread * thread) {
     assert(thread != 0);
-    if (thread->getIdentifier() != osl::Thread::getCurrentIdentifier()) {
-        thread->join();
-    }
+    return osl::Thread::getCurrentIdentifier() == thread->getIdentifier();
 }
 
 class AttachThread: private boost::noncopyable {
 public:
     explicit AttachThread(uno_ThreadPool threadPool);
 
@@ -210,14 +208,14 @@ Bridge::Bridge(
             RTL_CONSTASCII_USTRINGPARAM(
                 "com.sun.star.bridge.XProtocolProperties::requestChange"))),
     protPropCommit_(
         rtl::OUString(
             RTL_CONSTASCII_USTRINGPARAM(
                 "com.sun.star.bridge.XProtocolProperties::commitChange"))),
-    threadPool_(0), currentContextMode_(false), proxies_(0), calls_(0),
-    normalCall_(false), activeCalls_(0), terminated_(false),
+    state_(STATE_INITIAL), threadPool_(0), currentContextMode_(false),
+    proxies_(0), calls_(0), normalCall_(false), activeCalls_(0),
     mode_(MODE_REQUESTED)
 {
     assert(factory.is() && connection.is());
     if (!binaryUno_.is()) {
         throw css::uno::RuntimeException(
             rtl::OUString(
@@ -235,82 +233,142 @@ Bridge::Bridge(
 
 void Bridge::start() {
     rtl::Reference< Reader > r(new Reader(this));
     rtl::Reference< Writer > w(new Writer(this));
     {
         osl::MutexGuard g(mutex_);
-        assert(threadPool_ == 0 && !writer_.is() && !reader_.is());
+        assert(
+            state_ == STATE_INITIAL && threadPool_ == 0 && !writer_.is() &&
+            !reader_.is());
         threadPool_ = uno_threadpool_create();
         assert(threadPool_ != 0);
         reader_ = r;
         writer_ = w;
+        state_ = STATE_STARTED;
     }
     // It is important to call reader_->create() last here; both
     // Writer::execute and Reader::execute can call Bridge::terminate, but
     // Writer::execute is initially blocked in unblocked_.wait() until
     // Reader::execute has called bridge_->sendRequestChangeRequest(), so
     // effectively only reader_->create() can lead to an early call to
     // Bridge::terminate
     w->create();
     r->create();
 }
 
-void Bridge::terminate() {
+void Bridge::terminate(bool final) {
     uno_ThreadPool tp;
-    rtl::Reference< Reader > r;
-    rtl::Reference< Writer > w;
-    Listeners ls;
+    // Make sure function-local variables (Stubs s, etc.) are destroyed before
+    // the final uno_threadpool_destroy/threadPool_ = 0:
     {
-        osl::MutexGuard g(mutex_);
-        if (terminated_) {
-            return;
+        rtl::Reference< Reader > r;
+        rtl::Reference< Writer > w;
+        bool joinW;
+        Listeners ls;
+        {
+            osl::ClearableMutexGuard g(mutex_);
+            switch (state_) {
+            case STATE_INITIAL: // via ~Bridge -> dispose -> terminate
+            case STATE_FINAL:
+                return;
+            case STATE_STARTED:
+                break;
+            case STATE_TERMINATED:
+                if (final) {
+                    g.clear();
+                    terminated_.wait();
+                    {
+                        osl::MutexGuard g2(mutex_);
+                        tp = threadPool_;
+                        threadPool_ = 0;
+                        assert(!(reader_.is() && isThread(reader_.get())));
+                        std::swap(reader_, r);
+                        assert(!(writer_.is() && isThread(writer_.get())));
+                        std::swap(writer_, w);
+                        state_ = STATE_FINAL;
+                    }
+                    assert(!(r.is() && w.is()));
+                    if (r.is()) {
+                        r->join();
+                    } else if (w.is()) {
+                        w->join();
+                    }
+                    if (tp != 0) {
+                        uno_threadpool_destroy(tp);
+                    }
+                }
+                return;
+            }
+            tp = threadPool_;
+            assert(!(final && isThread(reader_.get())));
+            if (!isThread(reader_.get())) {
+                std::swap(reader_, r);
+            }
+            w = writer_;
+            joinW = !isThread(writer_.get());
+            assert(!final || joinW);
+            if (joinW) {
+                writer_.clear();
+            }
+            ls.swap(listeners_);
+            state_ = final ? STATE_FINAL : STATE_TERMINATED;
+        }
+        try {
+            connection_->close();
+        } catch (const css::io::IOException & e) {
+            SAL_INFO("binaryurp", "caught IO exception '" << e.Message << '\'');
+        }
+        assert(w.is());
+        w->stop();
+        if (r.is()) {
+            r->join();
+        }
+        if (joinW) {
+            w->join();
+        }
+        assert(tp != 0);
+        uno_threadpool_dispose(tp);
+        Stubs s;
+        {
+            osl::MutexGuard g(mutex_);
+            s.swap(stubs_);
+        }
+        for (Stubs::iterator i(s.begin()); i != s.end(); ++i) {
+            for (Stub::iterator j(i->second.begin()); j != i->second.end(); ++j)
+            {
+                SAL_INFO(
+                    "binaryurp",
+                    "stub '" << i->first << "', '" << toString(j->first)
+                        << "' still mapped at Bridge::terminate");
+                binaryUno_.get()->pExtEnv->revokeInterface(
+                    binaryUno_.get()->pExtEnv, j->second.object.get());
+            }
+        }
+        factory_->removeBridge(this);
+        for (Listeners::iterator i(ls.begin()); i != ls.end(); ++i) {
+            try {
+                (*i)->disposing(
+                    css::lang::EventObject(
+                        static_cast< cppu::OWeakObject * >(this)));
+            } catch (const css::uno::RuntimeException & e) {
+                SAL_WARN(
+                    "binaryurp",
+                    "caught runtime exception '" << e.Message << '\'');
+            }
         }
-        tp = threadPool_;
-        std::swap(reader_, r);
-        std::swap(writer_, w);
-        ls.swap(listeners_);
-        terminated_ = true;
     }
-    try {
-        connection_->close();
-    } catch (const css::io::IOException & e) {
-        SAL_INFO("binaryurp", "caught IO exception '" << e.Message << '\'');
-    }
-    assert(w.is());
-    w->stop();
-    joinThread(r.get());
-    joinThread(w.get());
-    assert(tp != 0);
-    uno_threadpool_dispose(tp);
-    Stubs s;
+    if (final) {
+        uno_threadpool_destroy(tp);
+    }
     {
         osl::MutexGuard g(mutex_);
-        s.swap(stubs_);
-    }
-    for (Stubs::iterator i(s.begin()); i != s.end(); ++i) {
-        for (Stub::iterator j(i->second.begin()); j != i->second.end(); ++j) {
-            SAL_INFO(
-                "binaryurp",
-                "stub '" << i->first << "', '" << toString(j->first)
-                    << "' still mapped at Bridge::terminate");
-            binaryUno_.get()->pExtEnv->revokeInterface(
-                binaryUno_.get()->pExtEnv, j->second.object.get());
+        if (final) {
+            threadPool_ = 0;
         }
     }
-    factory_->removeBridge(this);
-    for (Listeners::iterator i(ls.begin()); i != ls.end(); ++i) {
-        try {
-            (*i)->disposing(
-                css::lang::EventObject(
-                    static_cast< cppu::OWeakObject * >(this)));
-        } catch (const css::uno::RuntimeException & e) {
-            SAL_WARN(
-                "binaryurp", "caught runtime exception '" << e.Message << '\'');
-        }
-    }
-    uno_threadpool_destroy(tp);
+    terminated_.set();
 }
 
 css::uno::Reference< css::connection::XConnection > Bridge::getConnection()
     const
 {
     return connection_;
@@ -336,25 +394,20 @@ BinaryAny Bridge::mapCppToBinaryAny(css::uno::Any const & cppAny) {
         cppToBinaryMapping_.get());
     return out;
 }
 
 uno_ThreadPool Bridge::getThreadPool() {
     osl::MutexGuard g(mutex_);
+    checkDisposed();
     assert(threadPool_ != 0);
     return threadPool_;
 }
 
 rtl::Reference< Writer > Bridge::getWriter() {
     osl::MutexGuard g(mutex_);
-    if (terminated_) {
-        throw css::lang::DisposedException(
-            rtl::OUString(
-                RTL_CONSTASCII_USTRINGPARAM(
-                    "Binary URP bridge already disposed")),
-            static_cast< cppu::OWeakObject * >(this));
-    }
+    checkDisposed();
     assert(writer_.is());
     return writer_;
 }
 
 css::uno::UnoInterfaceReference Bridge::registerIncomingInterface(
     rtl::OUString const & oid, css::uno::TypeDescription const & type)
@@ -819,15 +872,21 @@ void Bridge::setCurrentContextMode() {
 bool Bridge::isCurrentContextMode() {
     osl::MutexGuard g(mutex_);
     return currentContextMode_;
 }
 
 Bridge::~Bridge() {
-    if (getThreadPool() != 0) {
-        terminate();
+#if OSL_DEBUG_LEVEL > 0
+    {
+        osl::MutexGuard g(mutex_);
+        SAL_WARN_IF(
+            state_ == STATE_STARTED || state_ == STATE_TERMINATED, "binaryurp",
+            "undisposed bridge, potential deadlock ahead");
     }
+#endif
+    dispose();
 }
 
 css::uno::Reference< css::uno::XInterface > Bridge::getInstance(
     rtl::OUString const & sInstanceName) throw (css::uno::RuntimeException)
 {
     if (sInstanceName.getLength() == 0) {
@@ -882,13 +941,17 @@ rtl::OUString Bridge::getDescription() throw (css::uno::RuntimeException) {
     b.append(sal_Unicode(':'));
     b.append(connection_->getDescription());
     return b.makeStringAndClear();
 }
 
 void Bridge::dispose() throw (css::uno::RuntimeException) {
-    terminate();
+    // For terminate(true) not to deadlock, an external protocol must ensure
+    // that dispose is not called from a thread pool worker thread (that dispose
+    // is never called from the reader or writer thread is already ensured
+    // internally):
+    terminate(true);
     // OOo expects dispose to not return while there are still remote calls in
     // progress; an external protocol must ensure that dispose is not called
     // from within an incoming or outgoing remote call, as passive_.wait() would
     // otherwise deadlock:
     passive_.wait();
 }
@@ -897,13 +960,14 @@ void Bridge::addEventListener(
     css::uno::Reference< css::lang::XEventListener > const & xListener)
     throw (css::uno::RuntimeException)
 {
     assert(xListener.is());
     {
         osl::MutexGuard g(mutex_);
-        if (!terminated_) {
+        assert(state_ != STATE_INITIAL);
+        if (state_ == STATE_STARTED) {
             listeners_.push_back(xListener);
             return;
         }
     }
     xListener->disposing(
         css::lang::EventObject(static_cast< cppu::OWeakObject * >(this)));
@@ -992,13 +1056,24 @@ bool Bridge::becameUnused() const {
 
 void Bridge::terminateWhenUnused(bool unused) {
     if (unused) {
         // That the current thread considers the bridge unused implies that it
         // is not within an incoming or outgoing remote call (so calling
         // terminate cannot lead to deadlock):
-        terminate();
+        terminate(false);
+    }
+}
+
+void Bridge::checkDisposed() {
+    assert(state_ != STATE_INITIAL);
+    if (state_ != STATE_STARTED) {
+        throw css::lang::DisposedException(
+            rtl::OUString(
+                RTL_CONSTASCII_USTRINGPARAM(
+                    "Binary URP bridge already disposed")),
+            static_cast< cppu::OWeakObject * >(this));
     }
 }
 
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/binaryurp/source/bridge.hxx b/binaryurp/source/bridge.hxx
index 8d667897d253..3ffbfbaeb43b 100644
--- a/binaryurp/source/bridge.hxx
+++ b/binaryurp/source/bridge.hxx
@@ -90,14 +90,17 @@ public:
         com::sun::star::uno::Reference<
             com::sun::star::bridge::XInstanceProvider > const & provider);
 
     void start();
 
     // Internally waits for all incoming and outgoing remote calls to terminate,
-    // so must not be called from within such a call:
-    void terminate();
+    // so must not be called from within such a call; when final is true, also
+    // joins all remaining threads (reader, writer, and worker threads from the
+    // thread pool), so must not be called with final set to true from such a
+    // thread:
+    void terminate(bool final);
 
     com::sun::star::uno::Reference< com::sun::star::connection::XConnection >
     getConnection() const;
 
     com::sun::star::uno::Reference< com::sun::star::bridge::XInstanceProvider >
     getProvider() const;
@@ -225,24 +228,29 @@ private:
     com::sun::star::uno::Any mapBinaryToCppAny(BinaryAny const & binaryAny);
 
     bool becameUnused() const;
 
     void terminateWhenUnused(bool unused);
 
+    // Must only be called with mutex_ locked:
+    void checkDisposed();
+
     typedef
         std::list<
             com::sun::star::uno::Reference<
                 com::sun::star::lang::XEventListener > >
         Listeners;
 
     struct SubStub;
 
     typedef std::map< com::sun::star::uno::TypeDescription, SubStub > Stub;
 
     typedef std::map< rtl::OUString, Stub > Stubs;
 
+    enum State { STATE_INITIAL, STATE_STARTED, STATE_TERMINATED, STATE_FINAL };
+
     enum Mode {
         MODE_REQUESTED, MODE_REPLY_MINUS1, MODE_REPLY_0, MODE_REPLY_1,
         MODE_WAIT, MODE_NORMAL, MODE_NORMAL_WAIT };
 
     rtl::Reference< BridgeFactory > factory_;
     rtl::OUString name_;
@@ -256,30 +264,31 @@ private:
     rtl::ByteSequence protPropTid_;
     rtl::OUString protPropOid_;
     com::sun::star::uno::TypeDescription protPropType_;
     com::sun::star::uno::TypeDescription protPropRequest_;
     com::sun::star::uno::TypeDescription protPropCommit_;
     OutgoingRequests outgoingRequests_;
+    osl::Condition passive_;
+        // to guarantee that passive_ is eventually set (to avoid deadlock, see
+        // dispose), activeCalls_ only counts those calls for which it can be
+        // guaranteed that incrementActiveCalls is indeed followed by
+        // decrementActiveCalls, without an intervening exception
+    osl::Condition terminated_;
 
     osl::Mutex mutex_;
+    State state_;
     Listeners listeners_;
     uno_ThreadPool threadPool_;
     rtl::Reference< Writer > writer_;
     rtl::Reference< Reader > reader_;
     bool currentContextMode_;
     Stubs stubs_;
     std::size_t proxies_;
     std::size_t calls_;
     bool normalCall_;
     std::size_t activeCalls_;
-    osl::Condition passive_;
-        // to guarantee that passive_ is eventually set (to avoid deadlock, see
-        // dispose), activeCalls_ only counts those calls for which it can be
-        // guaranteed that incrementActiveCalls is indeed followed by
-        // decrementActiveCalls, without an intervening exception
-    bool terminated_;
 
     // Only accessed from reader_ thread:
     Mode mode_;
     sal_Int32 random_;
 };
 
diff --git a/binaryurp/source/bridgefactory.cxx b/binaryurp/source/bridgefactory.cxx
index 5c9105585916..8f4caa64e17d 100644
--- a/binaryurp/source/bridgefactory.cxx
+++ b/binaryurp/source/bridgefactory.cxx
@@ -209,13 +209,13 @@ BridgeFactory::getExistingBridges() throw (css::uno::RuntimeException) {
 namespace {
 
 static cppu::ImplementationEntry const services[] = {
     { &binaryurp::BridgeFactory::static_create,
       &binaryurp::BridgeFactory::static_getImplementationName,
       &binaryurp::BridgeFactory::static_getSupportedServiceNames,
-      &cppu::createSingleComponentFactory, 0, 0 },
+      &cppu::createOneInstanceComponentFactory, 0, 0 },
     { 0, 0, 0, 0, 0, 0 }
 };
 
 }
 
 extern "C" SAL_DLLPUBLIC_EXPORT void * SAL_CALL component_getFactory(
diff --git a/binaryurp/source/incomingrequest.cxx b/binaryurp/source/incomingrequest.cxx
index 431c88505ad1..83b0030623e7 100644
--- a/binaryurp/source/incomingrequest.cxx
+++ b/binaryurp/source/incomingrequest.cxx
@@ -120,13 +120,13 @@ void IncomingRequest::execute() const {
                 OSL_LOG_PREFIX "caught UNO runtime exception '%s'",
                 (rtl::OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).
                  getStr()));
         } catch (const std::exception & e) {
             OSL_TRACE(OSL_LOG_PREFIX "caught C++ exception '%s'", e.what());
         }
-        bridge_->terminate();
+        bridge_->terminate(false);
     } else {
         if (isExc) {
             OSL_TRACE(OSL_LOG_PREFIX "oneway method raised exception");
         }
         bridge_->decrementCalls();
     }
diff --git a/binaryurp/source/reader.cxx b/binaryurp/source/reader.cxx
index c052fadc5629..47bdfbf065fc 100644
--- a/binaryurp/source/reader.cxx
+++ b/binaryurp/source/reader.cxx
@@ -147,13 +147,13 @@ void Reader::run() {
         }
     } catch (const css::uno::Exception & e) {
         SAL_WARN("binaryurp", "caught UNO exception '" << e.Message << '\'');
     } catch (const std::exception & e) {
         SAL_WARN("binaryurp", "caught C++ exception '" << e.what() << '\'');
     }
-    bridge_->terminate();
+    bridge_->terminate(false);
 }
 
 void Reader::onTerminated() {
     release();
 }
 
diff --git a/binaryurp/source/writer.cxx b/binaryurp/source/writer.cxx
index 5aca57b108eb..69825e13bc37 100644
--- a/binaryurp/source/writer.cxx
+++ b/binaryurp/source/writer.cxx
@@ -193,13 +193,13 @@ void Writer::run() {
         OSL_TRACE(
             OSL_LOG_PREFIX "caught UNO exception '%s'",
             rtl::OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).getStr());
     } catch (const std::exception & e) {
         OSL_TRACE(OSL_LOG_PREFIX "caught C++ exception '%s'", e.what());
     }
-    bridge_->terminate();
+    bridge_->terminate(false);
 }
 
 void Writer::onTerminated() {
     release();
 }
 
diff --git a/cppu/inc/uno/threadpool.h b/cppu/inc/uno/threadpool.h
index 0c647442e377..77bb712e53b4 100644
--- a/cppu/inc/uno/threadpool.h
+++ b/cppu/inc/uno/threadpool.h
@@ -163,26 +163,26 @@ uno_threadpool_putJob(
   The threads waiting with uno_threadpool_enter() will return with *ppJob == 0
 
   Later calls to uno_threadpool_enter() using the hPool handle will also
   return immeadiatly with *ppJob == 0.
 
   @param hPool The handle to be disposed.
-  In case, hPool is 0, this function joins on all threads created
-  by the threadpool administration. This may e.g. used to ensure, that
-  no threads are inside the cppu library anymore, in case it needs to get
-  unloaded.
 
   This function is called i.e. by a bridge, that is forced to dispose itself.
  */
 void SAL_CALL
 uno_threadpool_dispose( uno_ThreadPool hPool ) SAL_THROW_EXTERN_C();
 
 
 /** Releases the previously with uno_threadpool_create() created handle.
     The handle thus becomes invalid. It is an error to use the handle after
     uno_threadpool_destroy().
+
+    A call to uno_threadpool_destroy can synchronously join on spawned worker
+    threads, so this function must never be called from such a worker thread.
+
     @see uno_threadpool_create()
  */
 void SAL_CALL
 uno_threadpool_destroy( uno_ThreadPool hPool ) SAL_THROW_EXTERN_C();
 
 #ifdef __cplusplus
diff --git a/cppu/source/threadpool/thread.cxx b/cppu/source/threadpool/thread.cxx
index cc22a453c79d..12ea09a131ee 100644
--- a/cppu/source/threadpool/thread.cxx
+++ b/cppu/source/threadpool/thread.cxx
@@ -30,13 +30,12 @@
 #include <osl/diagnose.h>
 #include <uno/threadpool.h>
 
 #include <com/sun/star/lang/DisposedException.hpp>
 #include <com/sun/star/uno/Reference.hxx>
 #include <com/sun/star/uno/XInterface.hpp>
-#include <rtl/instance.hxx>
 #include <rtl/ustring.h>
 #include <rtl/ustring.hxx>
 
 #include "thread.hxx"
 #include "jobqueue.hxx"
 #include "threadpool.hxx"
@@ -45,23 +44,12 @@ namespace {
 
 namespace css = com::sun::star;
 
 }
 
 using namespace osl;
-extern "C" {
-
-void SAL_CALL cppu_requestThreadWorker( void *pVoid )
-{
-    ::cppu_threadpool::ORequestThread *pThread = ( ::cppu_threadpool::ORequestThread * ) pVoid;
-
-    pThread->run();
-    pThread->onTerminated();
-}
-
-}
 
 namespace cppu_threadpool {
 
 // ----------------------------------------------------------------------------------
     ThreadAdmin::ThreadAdmin(): m_disposed(false) {}
 
@@ -72,13 +60,13 @@ namespace cppu_threadpool {
         {
             fprintf( stderr, "%lu Threads left\n" , static_cast<unsigned long>(m_lst.size()) );
         }
 #endif
     }
 
-    void ThreadAdmin::add( ORequestThread *p )
+    void ThreadAdmin::add( rtl::Reference< ORequestThread > const & p )
     {
         MutexGuard aGuard( m_mutex );
         if( m_disposed )
         {
             throw css::lang::DisposedException(
                 rtl::OUString(
@@ -87,159 +75,145 @@ namespace cppu_threadpool {
                         " cppu_threadpool::ThreadAdmin has been disposed")),
                 css::uno::Reference< css::uno::XInterface >());
         }
         m_lst.push_back( p );
     }
 
-    void ThreadAdmin::remove( ORequestThread * p )
+    void ThreadAdmin::remove_locked( rtl::Reference< ORequestThread > const & p )
+    {
+        ::std::list< rtl::Reference< ORequestThread > >::iterator ii = ::std::find( m_lst.begin(), m_lst.end(), p );
+        if( ii != m_lst.end() )
+        {
+            m_lst.erase( ii );
+        }
+    }
+
+    void ThreadAdmin::remove( rtl::Reference< ORequestThread > const & p )
     {
         MutexGuard aGuard( m_mutex );
-        ::std::list< ORequestThread * >::iterator ii = ::std::find( m_lst.begin(), m_lst.end(), p );
-        OSL_ASSERT( ii != m_lst.end() );
-        m_lst.erase( ii );
+        remove_locked( p );
     }
 
     void ThreadAdmin::join()
     {
         {
             MutexGuard aGuard( m_mutex );
             m_disposed = true;
         }
-        ORequestThread *pCurrent;
-        do
+        for (;;)
         {
-            pCurrent = 0;
+            rtl::Reference< ORequestThread > pCurrent;
             {
                 MutexGuard aGuard( m_mutex );
-                if( ! m_lst.empty() )
+                if( m_lst.empty() )
                 {
-                    pCurrent = m_lst.front();
-                    pCurrent->setDeleteSelf( sal_False );
+                    break;
                 }
+                pCurrent = m_lst.front();
+                m_lst.pop_front();
             }
-            if ( pCurrent )
-            {
-                pCurrent->join();
-                delete pCurrent;
-            }
-        } while( pCurrent );
-    }
-
-    struct theThreadAdmin : public rtl::StaticWithInit< ThreadAdminHolder, theThreadAdmin >
-    {
-        ThreadAdminHolder operator () () {
-            ThreadAdminHolder aRet(new ThreadAdmin());
-            return aRet;
+            pCurrent->join();
         }
-    };
-
-    ThreadAdminHolder& ThreadAdmin::getInstance()
-    {
-        return theThreadAdmin::get();
     }
 
 // ----------------------------------------------------------------------------------
-    ORequestThread::ORequestThread( JobQueue *pQueue,
+    ORequestThread::ORequestThread( ThreadPoolHolder const &aThreadPool,
+                                    JobQueue *pQueue,
                                     const ByteSequence &aThreadId,
                                     sal_Bool bAsynchron )
-        : m_thread( 0 )
-        , m_aThreadAdmin( ThreadAdmin::getInstance() )
+        : m_aThreadPool( aThreadPool )
         , m_pQueue( pQueue )
         , m_aThreadId( aThreadId )
         , m_bAsynchron( bAsynchron )
-        , m_bDeleteSelf( sal_True )
-    {
-        m_aThreadAdmin->add( this );
-    }
-
-
-    ORequestThread::~ORequestThread()
-    {
-        if (m_thread != 0)
-        {
-            osl_destroyThread(m_thread);
-        }
-    }
+    {}
 
+    ORequestThread::~ORequestThread() {}
 
     void ORequestThread::setTask( JobQueue *pQueue,
                                   const ByteSequence &aThreadId,
                                   sal_Bool bAsynchron )
     {
         m_pQueue = pQueue;
         m_aThreadId = aThreadId;
         m_bAsynchron = bAsynchron;
     }
 
-    sal_Bool ORequestThread::create()
+    void ORequestThread::launch()
     {
-        OSL_ASSERT(m_thread == 0);  // only one running thread per instance
-
-        m_thread = osl_createSuspendedThread( cppu_requestThreadWorker, (void*)this);
-        if ( m_thread )
-        {
-            osl_resumeThread( m_thread );
+        // Assumption is that osl::Thread::create returns normally with a true
+        // return value iff it causes osl::Thread::run to start executing:
+        acquire();
+        ThreadAdmin & rThreadAdmin = m_aThreadPool->getThreadAdmin();
+        osl::ClearableMutexGuard g(rThreadAdmin.m_mutex);
+        rThreadAdmin.add( this );
+        try {
+            if (!create()) {
+                throw std::runtime_error("osl::Thread::create failed");
+            }
+        } catch (...) {
+            rThreadAdmin.remove_locked( this );
+            g.clear();
+            release();
+            throw;
         }
-
-        return m_thread != 0;
-    }
-
-    void ORequestThread::join()
-    {
-        osl_joinWithThread( m_thread );
     }
 
     void ORequestThread::onTerminated()
     {
-        m_aThreadAdmin->remove( this );
-        if( m_bDeleteSelf )
-        {
-            delete this;
-        }
+        m_aThreadPool->getThreadAdmin().remove( this );
+        release();
     }
 
     void ORequestThread::run()
     {
-        ThreadPoolHolder theThreadPool = cppu_threadpool::ThreadPool::getInstance();
-
-        while ( m_pQueue )
+        try
         {
-            if( ! m_bAsynchron )
+            while ( m_pQueue )
             {
-                if ( !uno_bindIdToCurrentThread( m_aThreadId.getHandle() ) )
+                if( ! m_bAsynchron )
                 {
-                    OSL_ASSERT( false );
+                    if ( !uno_bindIdToCurrentThread( m_aThreadId.getHandle() ) )
+                    {
+                        OSL_ASSERT( false );
+                    }
                 }
-            }
 
-            while( ! m_pQueue->isEmpty() )
-            {
-                // Note : Oneways should not get a disposable disposeid,
-                //        It does not make sense to dispose a call in this state.
-                //        That's way we put it an disposeid, that can't be used otherwise.
-                m_pQueue->enter(
-                    sal::static_int_cast< sal_Int64 >(
-                        reinterpret_cast< sal_IntPtr >(this)),
-                    sal_True );
-
-                if( m_pQueue->isEmpty() )
+                while( ! m_pQueue->isEmpty() )
                 {
-                    theThreadPool->revokeQueue( m_aThreadId , m_bAsynchron );
-                    // Note : revokeQueue might have failed because m_pQueue.isEmpty()
-                    //        may be false (race).
+                    // Note : Oneways should not get a disposable disposeid,
+                    //        It does not make sense to dispose a call in this state.
+                    //        That's way we put it an disposeid, that can't be used otherwise.
+                    m_pQueue->enter(
+                        sal::static_int_cast< sal_Int64 >(
+                            reinterpret_cast< sal_IntPtr >(this)),
+                        sal_True );
+
+                    if( m_pQueue->isEmpty() )
+                    {
+                        m_aThreadPool->revokeQueue( m_aThreadId , m_bAsynchron );
+                        // Note : revokeQueue might have failed because m_pQueue.isEmpty()
+                        //        may be false (race).
+                    }
                 }
-            }
 
-            delete m_pQueue;
-            m_pQueue = 0;
+                delete m_pQueue;
+                m_pQueue = 0;
 
-            if( ! m_bAsynchron )
-            {
-                uno_releaseIdFromCurrentThread();
-            }
+                if( ! m_bAsynchron )
+                {
+                    uno_releaseIdFromCurrentThread();
+                }
 
-            theThreadPool->waitInPool( this );
+                m_aThreadPool->waitInPool( this );
+            }
+        }
+        catch (...)
+        {
+            // Work around the problem that onTerminated is not called if run
+            // throws an exception:
+            onTerminated();
+            throw;
         }
     }
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/threadpool/thread.hxx b/cppu/source/threadpool/thread.hxx
index a3ea45aadaed..88f3d91f8722 100644
--- a/cppu/source/threadpool/thread.hxx
+++ b/cppu/source/threadpool/thread.hxx
@@ -25,69 +25,55 @@
  * for a copy of the LGPLv3 License.
  *
  ************************************************************************/
 #ifndef _CPPU_THREADPOOL_THREAD_HXX
 #define _CPPU_THREADPOOL_THREAD_HXX
 
-#include <list>
+#include <osl/thread.hxx>
 #include <sal/types.h>
-
-#include <osl/thread.h>
+#include <salhelper/simplereferenceobject.hxx>
 
 #include "jobqueue.hxx"
+#include "threadpool.hxx"
 
 namespace cppu_threadpool {
 
     class JobQueue;
-    class ThreadAdmin;
-    typedef boost::shared_ptr<ThreadAdmin> ThreadAdminHolder;
 
     //-----------------------------------------
     // private thread class for the threadpool
     // independent from vos
     //-----------------------------------------
-    class ORequestThread
+    class ORequestThread:
+        public salhelper::SimpleReferenceObject, public osl::Thread
     {
     public:
-        ORequestThread( JobQueue * ,
+        ORequestThread( ThreadPoolHolder const &aThreadPool,
+                        JobQueue * ,
                         const ::rtl::ByteSequence &aThreadId,
                         sal_Bool bAsynchron );
-        ~ORequestThread();
+        virtual ~ORequestThread();
 
         void setTask( JobQueue * , const ::rtl::ByteSequence & aThreadId , sal_Bool bAsynchron );
 
-        sal_Bool create();
-        void join();
-        void onTerminated();
-        void run();
-        inline void setDeleteSelf( sal_Bool b )
-            { m_bDeleteSelf = b; }
+        void launch();
+
+        static inline void * operator new(std::size_t size)
+        { return SimpleReferenceObject::operator new(size); }
+
+        static inline void operator delete(void * pointer)
+        { SimpleReferenceObject::operator delete(pointer); }
 
     private:
-        oslThread m_thread;
-        ThreadAdminHolder m_aThreadAdmin;
+        virtual void SAL_CALL run();
+        virtual void SAL_CALL onTerminated();
+
+        ThreadPoolHolder m_aThreadPool;
         JobQueue *m_pQueue;
         ::rtl::ByteSequence m_aThreadId;
         sal_Bool m_bAsynchron;
-        sal_Bool m_bDeleteSelf;
-    };
-
-    class ThreadAdmin
-    {
-    public:
-        ThreadAdmin();
-        ~ThreadAdmin ();
-        static ThreadAdminHolder &getInstance();
-        void add( ORequestThread * );
-        void remove( ORequestThread * );
-        void join();
-
-    private:
-        ::osl::Mutex m_mutex;
-        ::std::list< ORequestThread * > m_lst;
-        bool m_disposed;
     };
 
 } // end cppu_threadpool
 
 
 #endif
diff --git a/cppu/source/threadpool/threadpool.cxx b/cppu/source/threadpool/threadpool.cxx
index f9f0be6c7d03..9099b7e1981e 100644
--- a/cppu/source/threadpool/threadpool.cxx
+++ b/cppu/source/threadpool/threadpool.cxx
@@ -106,21 +106,12 @@ namespace cppu_threadpool
         return sal_False;
     }
 
 
     //-------------------------------------------------------------------------------
 
-    struct theThreadPool :
-        public rtl::StaticWithInit< ThreadPoolHolder, theThreadPool >
-    {
-        ThreadPoolHolder operator () () {
-            ThreadPoolHolder aRet(new ThreadPool());
-            return aRet;
-        }
-    };
-
     ThreadPool::ThreadPool()
     {
         m_DisposedCallerAdmin = DisposedCallerAdmin::getInstance();
     }
 
     ThreadPool::~ThreadPool()
@@ -129,52 +120,30 @@ namespace cppu_threadpool
         if( m_mapQueue.size() )
         {
             printf( "ThreadIdHashMap : %lu left\n" , static_cast<unsigned long>(m_mapQueue.size()) );
         }
 #endif
     }
-    ThreadPoolHolder ThreadPool::getInstance()
-    {
-        return theThreadPool::get();
-    }
-
 
     void ThreadPool::dispose( sal_Int64 nDisposeId )
     {
-        if( nDisposeId )
-        {
-            m_DisposedCallerAdmin->dispose( nDisposeId );
+        m_DisposedCallerAdmin->dispose( nDisposeId );
 
-            MutexGuard guard( m_mutex );
-            for( ThreadIdHashMap::iterator ii = m_mapQueue.begin() ;
-                 ii != m_mapQueue.end();
-                 ++ii)
+        MutexGuard guard( m_mutex );
+        for( ThreadIdHashMap::iterator ii = m_mapQueue.begin() ;
+             ii != m_mapQueue.end();
+             ++ii)
+        {
+            if( (*ii).second.first )
             {
-                if( (*ii).second.first )
-                {
-                    (*ii).second.first->dispose( nDisposeId );
-                }
-                if( (*ii).second.second )
-                {
-                    (*ii).second.second->dispose( nDisposeId );
-                }
+                (*ii).second.first->dispose( nDisposeId );
             }
-        }
-        else
-        {
+            if( (*ii).second.second )
             {
-                MutexGuard guard( m_mutexWaitingThreadList );
-                for( WaitingThreadList::iterator ii = m_lstThreads.begin() ;
-                     ii != m_lstThreads.end() ;
-                     ++ ii )
-                {
-                    // wake the threads up
-                    osl_setCondition( (*ii)->condition );
-                }
+                (*ii).second.second->dispose( nDisposeId );
             }
-            ThreadAdmin::getInstance()->join();
         }
     }
 
     void ThreadPool::destroy( sal_Int64 nDisposeId )
     {
         m_DisposedCallerAdmin->destroy( nDisposeId );
@@ -182,13 +151,13 @@ namespace cppu_threadpool
 
     /******************
      * This methods lets the thread wait a certain amount of time. If within this timespan
      * a new request comes in, this thread is reused. This is done only to improve performance,
      * it is not required for threadpool functionality.
      ******************/
-    void ThreadPool::waitInPool( ORequestThread * pThread )
+    void ThreadPool::waitInPool( rtl::Reference< ORequestThread > const & pThread )
     {
         struct WaitingThread waitingThread;
         waitingThread.condition = osl_createCondition();
         waitingThread.thread = pThread;
         {
             MutexGuard guard( m_mutexWaitingThreadList );
@@ -198,25 +167,40 @@ namespace cppu_threadpool
         // let the thread wait 2 seconds
         TimeValue time = { 2 , 0 };
         osl_waitCondition( waitingThread.condition , &time );
 
         {
             MutexGuard guard ( m_mutexWaitingThreadList );
-            if( waitingThread.thread )
+            if( waitingThread.thread.is() )
             {
                 // thread wasn't reused, remove it from the list
                 WaitingThreadList::iterator ii = find(
                     m_lstThreads.begin(), m_lstThreads.end(), &waitingThread );
                 OSL_ASSERT( ii != m_lstThreads.end() );
                 m_lstThreads.erase( ii );
             }
         }
 
         osl_destroyCondition( waitingThread.condition );
     }
 
+    void ThreadPool::joinWorkers()
+    {
+        {
+            MutexGuard guard( m_mutexWaitingThreadList );
+            for( WaitingThreadList::iterator ii = m_lstThreads.begin() ;
+                 ii != m_lstThreads.end() ;
+                 ++ ii )
+            {
+                // wake the threads up
+                osl_setCondition( (*ii)->condition );
+            }
+        }
+        m_aThreadAdmin.join();
+    }
+
     void ThreadPool::createThread( JobQueue *pQueue ,
                                    const ByteSequence &aThreadId,
                                    sal_Bool bAsynchron )
     {
         sal_Bool bCreate = sal_True;
         {
@@ -237,16 +221,15 @@ namespace cppu_threadpool
                 bCreate = sal_False;
             }
         }
 
         if( bCreate )
         {
-            ORequestThread *pThread =
-                new ORequestThread( pQueue , aThreadId, bAsynchron);
-            // deletes itself !
-            pThread->create();
+            rtl::Reference< ORequestThread > pThread(
+                new ORequestThread( this, pQueue , aThreadId, bAsynchron) );
+            pThread->launch();
         }
     }
 
     sal_Bool ThreadPool::revokeQueue( const ByteSequence &aThreadId, sal_Bool bAsynchron )
     {
         MutexGuard guard( m_mutex );
@@ -382,12 +365,18 @@ namespace cppu_threadpool
             }
         }
         return pReturn;
     }
 }
 
+// All uno_ThreadPool handles in g_pThreadpoolHashSet with overlapping life
+// spans share one ThreadPool instance.  When g_pThreadpoolHashSet becomes empty
+// (within the last uno_threadpool_destroy) all worker threads spawned by that
+// ThreadPool instance are joined (which implies that uno_threadpool_destroy
+// must never be called from a worker thread); afterwards, the next call to
+// uno_threadpool_create (if any) will lead to a new ThreadPool instance.
 
 using namespace cppu_threadpool;
 
 struct uno_ThreadPool_Equal
 {
     sal_Bool operator () ( const uno_ThreadPool &a , const uno_ThreadPool &b ) const
@@ -412,45 +401,65 @@ static ThreadpoolHashSet *g_pThreadpoolHashSet;
 
 struct _uno_ThreadPool
 {
     sal_Int32 dummy;
 };
 
+namespace {
+
+ThreadPoolHolder getThreadPool( uno_ThreadPool hPool )
+{
+    MutexGuard guard( Mutex::getGlobalMutex() );
+    assert( g_pThreadpoolHashSet != 0 );
+    ThreadpoolHashSet::iterator i( g_pThreadpoolHashSet->find(hPool) );
+    assert( i != g_pThreadpoolHashSet->end() );
+    return i->second;
+}
+
+}
+
 extern "C" uno_ThreadPool SAL_CALL
 uno_threadpool_create() SAL_THROW_EXTERN_C()
 {
     MutexGuard guard( Mutex::getGlobalMutex() );
+    ThreadPoolHolder p;
     if( ! g_pThreadpoolHashSet )
     {
         g_pThreadpoolHashSet = new ThreadpoolHashSet();
+        p = new ThreadPool;
+    }
+    else
+    {
+        assert( !g_pThreadpoolHashSet->empty() );
+        p = g_pThreadpoolHashSet->begin()->second;
     }
 
     // Just ensure that the handle is unique in the process (via heap)
     uno_ThreadPool h = new struct _uno_ThreadPool;
-    g_pThreadpoolHashSet->insert( ThreadpoolHashSet::value_type(h, ThreadPool::getInstance()) );
+    g_pThreadpoolHashSet->insert( ThreadpoolHashSet::value_type(h, p) );
     return h;
 }
 
 extern "C" void SAL_CALL
-uno_threadpool_attach( uno_ThreadPool ) SAL_THROW_EXTERN_C()
+uno_threadpool_attach( uno_ThreadPool hPool ) SAL_THROW_EXTERN_C()
 {
     sal_Sequence *pThreadId = 0;
     uno_getIdOfCurrentThread( &pThreadId );
-    ThreadPool::getInstance()->prepare( pThreadId );
+    getThreadPool( hPool )->prepare( pThreadId );
     rtl_byte_sequence_release( pThreadId );
     uno_releaseIdFromCurrentThread();
 }
 
 extern "C" void SAL_CALL
 uno_threadpool_enter( uno_ThreadPool hPool , void **ppJob )
     SAL_THROW_EXTERN_C()
 {
     sal_Sequence *pThreadId = 0;
     uno_getIdOfCurrentThread( &pThreadId );
     *ppJob =
-        ThreadPool::getInstance()->enter(
+        getThreadPool( hPool )->enter(
             pThreadId,
             sal::static_int_cast< sal_Int64 >(
                 reinterpret_cast< sal_IntPtr >(hPool)) );
     rtl_byte_sequence_release( pThreadId );
     uno_releaseIdFromCurrentThread();
 }
@@ -460,35 +469,34 @@ uno_threadpool_detach( uno_ThreadPool ) SAL_THROW_EXTERN_C()
 {
     // we might do here some tiding up in case a thread called attach but never detach
 }
 
 extern "C" void SAL_CALL
 uno_threadpool_putJob(
-    uno_ThreadPool,
+    uno_ThreadPool hPool,
     sal_Sequence *pThreadId,
     void *pJob,
     void ( SAL_CALL * doRequest ) ( void *pThreadSpecificData ),
     sal_Bool bIsOneway ) SAL_THROW_EXTERN_C()
 {
-    ThreadPool::getInstance()->addJob( pThreadId, bIsOneway, pJob ,doRequest );
+    getThreadPool(hPool)->addJob( pThreadId, bIsOneway, pJob ,doRequest );
 }
 
 extern "C" void SAL_CALL
 uno_threadpool_dispose( uno_ThreadPool hPool ) SAL_THROW_EXTERN_C()
 {
-    ThreadPool::getInstance()->dispose(
+    getThreadPool(hPool)->dispose(
         sal::static_int_cast< sal_Int64 >(
             reinterpret_cast< sal_IntPtr >(hPool)) );
 }
 
 extern "C" void SAL_CALL
 uno_threadpool_destroy( uno_ThreadPool hPool ) SAL_THROW_EXTERN_C()
 {
-    assert(hPool != 0);
-
-    ThreadPool::getInstance()->destroy(
+    ThreadPoolHolder p( getThreadPool(hPool) );
+    p->destroy(
         sal::static_int_cast< sal_Int64 >(
             reinterpret_cast< sal_IntPtr >(hPool)) );
 
     bool empty;
     {
         OSL_ASSERT( g_pThreadpoolHashSet );
@@ -507,11 +515,11 @@ uno_threadpool_destroy( uno_ThreadPool hPool ) SAL_THROW_EXTERN_C()
             g_pThreadpoolHashSet = 0;
         }
     }
 
     if( empty )
     {
-        uno_threadpool_dispose( 0 );
+        p->joinWorkers();
     }
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/threadpool/threadpool.hxx b/cppu/source/threadpool/threadpool.hxx
index 18bb47a1ff20..3ff52b362af1 100644
--- a/cppu/source/threadpool/threadpool.hxx
+++ b/cppu/source/threadpool/threadpool.hxx
@@ -22,17 +22,25 @@
  * You should have received a copy of the GNU Lesser General Public License
  * version 3 along with OpenOffice.org.  If not, see
  * <http://www.openoffice.org/license.html>
  * for a copy of the LGPLv3 License.
  *
  ************************************************************************/
+
+#ifndef INCLUDED_CPPU_SOURCE_THREADPOOL_THREADPOOL_HXX
+#define INCLUDED_CPPU_SOURCE_THREADPOOL_THREADPOOL_HXX
+
+#include <list>
+
 #include <boost/unordered_map.hpp>
 
 #include <osl/conditn.h>
 
 #include <rtl/byteseq.hxx>
+#include <rtl/ref.hxx>
+#include <salhelper/simplereferenceobject.hxx>
 
 #include <boost/shared_ptr.hpp>
 
 #include "jobqueue.hxx"
 
 
@@ -71,13 +79,13 @@ namespace cppu_threadpool {
     typedef ::std::list < sal_Int64 > DisposedCallerList;
 
 
     struct WaitingThread
     {
         oslCondition condition;
-        ORequestThread *thread;
+        rtl::Reference< ORequestThread > thread;
     };
 
     typedef ::std::list < struct ::cppu_threadpool::WaitingThread * > WaitingThreadList;
 
     class DisposedCallerAdmin;
     typedef boost::shared_ptr<DisposedCallerAdmin> DisposedCallerAdminHolder;
@@ -95,21 +103,38 @@ namespace cppu_threadpool {
 
     private:
         ::osl::Mutex m_mutex;
         DisposedCallerList m_lst;
     };
 
+    class ThreadAdmin
+    {
+    public:
+        ThreadAdmin();
+        ~ThreadAdmin ();
+
+        void add( rtl::Reference< ORequestThread > const & );
+        void remove( rtl::Reference< ORequestThread > const & );
+        void join();
+
+        void remove_locked( rtl::Reference< ORequestThread > const & );
+        ::osl::Mutex m_mutex;
+
+    private:
+        ::std::list< rtl::Reference< ORequestThread > > m_lst;
+        bool m_disposed;
+    };
+
     class ThreadPool;
-    typedef boost::shared_ptr<ThreadPool> ThreadPoolHolder;
+    typedef rtl::Reference<ThreadPool> ThreadPoolHolder;
 
-    class ThreadPool
+    class ThreadPool: public salhelper::SimpleReferenceObject
     {
     public:
         ThreadPool();
         ~ThreadPool();
-        static ThreadPoolHolder getInstance();
 
         void dispose( sal_Int64 nDisposeId );
         void destroy( sal_Int64 nDisposeId );
 
         void addJob( const ByteSequence &aThreadId,
                      sal_Bool bAsynchron,
@@ -121,23 +146,31 @@ namespace cppu_threadpool {
 
         /********
          * @return true, if queue could be succesfully revoked.
          ********/
         sal_Bool revokeQueue( const ByteSequence & aThreadId , sal_Bool bAsynchron );
 
-        void waitInPool( ORequestThread *pThread );
+        void waitInPool( rtl::Reference< ORequestThread > const & pThread );
+
+        void joinWorkers();
+
+        ThreadAdmin & getThreadAdmin() { return m_aThreadAdmin; }
+
     private:
         void createThread( JobQueue *pQueue, const ByteSequence &aThreadId, sal_Bool bAsynchron);
 
 
         ThreadIdHashMap m_mapQueue;
         ::osl::Mutex m_mutex;
 
         ::osl::Mutex m_mutexWaitingThreadList;
         WaitingThreadList m_lstThreads;
 
         DisposedCallerAdminHolder m_DisposedCallerAdmin;
+        ThreadAdmin m_aThreadAdmin;
     };
 
 } // end namespace cppu_threadpool
 
+#endif
+
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/util/makefile.mk b/cppu/util/makefile.mk
index ea0c09488c85..cf8e1bd5133a 100644
--- a/cppu/util/makefile.mk
+++ b/cppu/util/makefile.mk
@@ -53,13 +53,13 @@ SHL1LIBS= \
 .IF "$(COM)" == "MSC"
 SHL1TARGET=$(TARGET)$(UDK_MAJOR)
 .ELSE
 SHL1TARGET= uno_$(TARGET)
 .ENDIF
 
-SHL1STDLIBS = $(SALLIB)
+SHL1STDLIBS = $(SALLIB) $(SALHELPERLIB)
 
 SHL1DEPN=
 .IF "$(COM)" == "MSC"
 SHL1IMPLIB=i$(TARGET)
 .ELSE
 SHL1IMPLIB=uno_$(TARGET)
diff --git a/cpputools/source/unoexe/unoexe.cxx b/cpputools/source/unoexe/unoexe.cxx
index 684bc39934e1..46fcbf8b310a 100644
--- a/cpputools/source/unoexe/unoexe.cxx
+++ b/cpputools/source/unoexe/unoexe.cxx
@@ -844,12 +844,16 @@ SAL_IMPLEMENT_MAIN_WITH_ARGS(argc,)
                 if (bSingleAccept)
                 {
                     Reference< XComponent > xComp( xBridge, UNO_QUERY );
                     if (! xComp.is())
                         throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM("bridge factory does not export interface \"com.sun.star.lang.XComponent\"!" ) ), Reference< XInterface >() );
                     ODisposingListener::waitFor( xComp );
+                    xComp->dispose();
+                        // explicitly dispose the remote bridge so that it joins
+                        // on all spawned threads before process exit (see
+                        // binaryurp/source/bridge.cxx for details)
                     break;
                 }
             }
         }
         else // no uno url
         {