zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/{IceUtil → Ice}/Thread.cpp

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
 //
 // **********************************************************************
 
-#ifdef __sun 
+#ifdef __sun
 //
 // Solaris 10 bug: it's supposed to be defined in pthread.h
 //
@@ -19,10 +19,11 @@
 #include <IceUtil/Thread.h>
 #include <IceUtil/Time.h>
 #include <IceUtil/ThreadException.h>
+#include <Ice/ConsoleUtil.h>
 #include <climits>
 #include <exception>
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 #   include <thread>
 #endif
 
@@ -32,8 +33,9 @@
 #endif
 
 using namespace std;
+using namespace IceInternal;
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 
 IceUtil::ThreadControl::ThreadControl() :
     _id(this_thread::get_id())
@@ -83,7 +85,7 @@ IceUtil::ThreadControl::detach()
     {
         throw BadThreadControlException(__FILE__, __LINE__);
     }
-    
+
     try
     {
         _thread->detach();
@@ -169,13 +171,13 @@ WINAPI startHook(void* arg)
     {
         if(!thread->name().empty())
         {
-            cerr << thread->name() << " terminating" << endl;
+            consoleErr << thread->name() << " terminating" << endl;
         }
         std::terminate();
     }
 
     thread->_done();
-   
+
     return 0;
 }
 
@@ -216,7 +218,7 @@ IceUtil::Thread::start(size_t, int)
 
     _started = true;
     _running = true;
-    
+
     return ThreadControl(_thread);
 }
 
@@ -237,12 +239,6 @@ IceUtil::Thread::operator==(const Thread& rhs) const
     return this == &rhs;
 }
 
-bool
-IceUtil::Thread::operator!=(const Thread& rhs) const
-{
-    return this != &rhs;
-}
-
 bool
 IceUtil::Thread::operator<(const Thread& rhs) const
 {
@@ -308,7 +304,7 @@ IceUtil::ThreadControl::join()
     {
         throw ThreadSyscallException(__FILE__, __LINE__, GetLastError());
     }
-    
+
     detach();
 }
 
@@ -319,7 +315,7 @@ IceUtil::ThreadControl::detach()
     {
         throw BadThreadControlException(__FILE__, __LINE__);
     }
-    
+
     if(CloseHandle(_handle) == 0)
     {
         throw ThreadSyscallException(__FILE__, __LINE__, GetLastError());
@@ -410,13 +406,13 @@ WINAPI startHook(void* arg)
     {
         if(!thread->name().empty())
         {
-            cerr << thread->name() << " terminating" << endl;
+            consoleErr << thread->name() << " terminating" << endl;
         }
         std::terminate();
     }
 
     thread->_done();
-   
+
     return 0;
 }
 
@@ -453,14 +449,14 @@ IceUtil::Thread::start(size_t stackSize, int priority)
     // __decRef().
     //
     __incRef();
-    
+
     unsigned int id;
-    _handle = 
+    _handle =
         reinterpret_cast<HANDLE>(
-            _beginthreadex(0, 
-                            static_cast<unsigned int>(stackSize), 
-                            startHook, this, 
-                            CREATE_SUSPENDED, 
+            _beginthreadex(0,
+                            static_cast<unsigned int>(stackSize),
+                            startHook, this,
+                            CREATE_SUSPENDED,
                             &id));
     _id = id;
     assert(_handle != (HANDLE)-1L);
@@ -481,7 +477,7 @@ IceUtil::Thread::start(size_t stackSize, int priority)
 
     _started = true;
     _running = true;
-    
+
     return ThreadControl(_handle, _id);
 }
 
@@ -502,12 +498,6 @@ IceUtil::Thread::operator==(const Thread& rhs) const
     return this == &rhs;
 }
 
-bool
-IceUtil::Thread::operator!=(const Thread& rhs) const
-{
-    return this != &rhs;
-}
-
 bool
 IceUtil::Thread::operator<(const Thread& rhs) const
 {
@@ -635,7 +625,7 @@ IceUtil::Thread::~Thread()
 {
 }
 
-extern "C" 
+extern "C"
 {
 static void*
 startHook(void* arg)
@@ -662,18 +652,17 @@ startHook(void* arg)
     {
         if(!thread->name().empty())
         {
-            cerr << thread->name() << " terminating" << endl;
+            consoleErr << thread->name() << " terminating" << endl;
         }
         std::terminate();
     }
 
     thread->_done();
-    
+
     return 0;
 }
 }
 
-
 IceUtil::ThreadControl
 IceUtil::Thread::start(size_t stackSize)
 {
@@ -789,12 +778,6 @@ IceUtil::Thread::operator==(const Thread& rhs) const
     return this == &rhs;
 }
 
-bool
-IceUtil::Thread::operator!=(const Thread& rhs) const
-{
-    return this != &rhs;
-}
-
 bool
 IceUtil::Thread::operator<(const Thread& rhs) const
 {

data/ext/ice/cpp/src/Ice/ThreadPool.cpp

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -18,8 +18,8 @@
 #include <Ice/Properties.h>
 #include <Ice/TraceLevels.h>
 
-#if defined(ICE_OS_WINRT)
-#   include <IceUtil/StringConverter.h>
+#if defined(ICE_OS_UWP)
+#   include <Ice/StringConverter.h>
 #endif
 
 using namespace std;
@@ -70,6 +70,14 @@ public:
     execute(ThreadPoolCurrent& current)
     {
         _handler->finished(current, _close);
+
+        //
+        // Break cyclic reference count.
+        //
+        if(_handler->getNativeInfo())
+        {
+            _handler->getNativeInfo()->setReadyCallback(0);
+        }
     }
 
 private:
@@ -99,29 +107,6 @@ private:
     IceUtil::ThreadPtr _thread;
 };
 
-class InterruptWorkItem : public ThreadPoolWorkItem
-{
-public:
-
-    virtual void
-    execute(ThreadPoolCurrent& current)
-    {
-        // Nothing to do, this is just used to interrupt the thread pool selector.
-    }
-};
-ThreadPoolWorkItemPtr interruptWorkItem;
-
-class InterruptWorkItemInit
-{
-public:
-
-    InterruptWorkItemInit()
-    {
-        interruptWorkItem = new InterruptWorkItem;
-    }
-};
-InterruptWorkItemInit init;
-
 //
 // Exception raised by the thread pool work queue when the thread pool
 // is destroyed.
@@ -132,6 +117,16 @@ class ThreadPoolDestroyedException
 
 }
 
+Ice::DispatcherCall::~DispatcherCall()
+{
+    // Out of line to avoid weak vtable
+}
+
+Ice::Dispatcher::~Dispatcher()
+{
+    // Out of line to avoid weak vtable
+}
+
 IceInternal::DispatchWorkItem::DispatchWorkItem()
 {
 }
@@ -147,81 +142,42 @@ IceInternal::DispatchWorkItem::execute(ThreadPoolCurrent& current)
     current.dispatchFromThisThread(this);
 }
 
-IceInternal::ThreadPoolWorkQueue::ThreadPoolWorkQueue(const InstancePtr& instance, Selector& selector) :
-    _instance(instance),
-    _selector(selector),
+IceInternal::ThreadPoolWorkQueue::ThreadPoolWorkQueue(ThreadPool& threadPool) :
+    _threadPool(threadPool),
     _destroyed(false)
-#ifdef ICE_USE_IOCP
-    , _info(SocketOperationRead)
-#endif
 {
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
-    SOCKET fds[2];
-    createPipe(fds);
-    _fdIntrRead = fds[0];
-    _fdIntrWrite = fds[1];
-
-    _selector.initialize(this);
-    _selector.update(this, SocketOperationNone, SocketOperationRead);
-#endif
-}
-
-IceInternal::ThreadPoolWorkQueue::~ThreadPoolWorkQueue()
-{
-    assert(_destroyed);
-
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
-    try
-    {
-        closeSocket(_fdIntrRead);
-    }
-    catch(const LocalException& ex)
-    {
-        Error out(_instance->initializationData().logger);
-        out << "exception in selector while calling closeSocket():\n" << ex;
-    }
-
-    try
-    {
-        closeSocket(_fdIntrWrite);
-    }
-    catch(const LocalException& ex)
-    {
-        Error out(_instance->initializationData().logger);
-        out << "exception in selector while calling closeSocket():\n" << ex;
-    }
-#endif
+    _registered = SocketOperationRead;
 }
 
 void
 IceInternal::ThreadPoolWorkQueue::destroy()
 {
-    Lock sync(*this);
+    //Lock sync(*this); Called with the thread pool locked
     assert(!_destroyed);
     _destroyed = true;
-    postMessage();
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
+    _threadPool._selector.completed(this, SocketOperationRead);
+#else
+    _threadPool._selector.ready(this, SocketOperationRead, true);
+#endif
 }
 
 void
 IceInternal::ThreadPoolWorkQueue::queue(const ThreadPoolWorkItemPtr& item)
 {
-    Lock sync(*this);
-    if(_destroyed)
-    {
-        throw CommunicatorDestroyedException(__FILE__, __LINE__);
-    }
+    //Lock sync(*this); Called with the thread pool locked
     _workItems.push_back(item);
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
+    _threadPool._selector.completed(this, SocketOperationRead);
+#else
     if(_workItems.size() == 1)
     {
-        postMessage();
+        _threadPool._selector.ready(this, SocketOperationRead, true);
     }
-#else
-    postMessage();
 #endif
 }
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
 bool
 IceInternal::ThreadPoolWorkQueue::startAsync(SocketOperation)
 {
@@ -242,47 +198,24 @@ IceInternal::ThreadPoolWorkQueue::message(ThreadPoolCurrent& current)
 {
     ThreadPoolWorkItemPtr workItem;
     {
-        Lock sync(*this);
+        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_threadPool);
         if(!_workItems.empty())
         {
             workItem = _workItems.front();
             _workItems.pop_front();
-
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
-            if(_workItems.empty())
-            {
-                char c;
-                while(true)
-                {
-                    ssize_t ret;
-#   ifdef _WIN32
-                    ret = ::recv(_fdIntrRead, &c, 1, 0);
-#   else
-                    ret = ::read(_fdIntrRead, &c, 1);
-#   endif
-                    if(ret == SOCKET_ERROR)
-                    {
-                        if(interrupted())
-                        {
-                            continue;
-                        }
-
-                        SocketException ex(__FILE__, __LINE__);
-                        ex.error = getSocketErrno();
-                        throw ex;
-                    }
-                    break;
-                }
-            }
-#endif
         }
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
         else
         {
             assert(_destroyed);
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
-            postMessage();
-#endif
+            _threadPool._selector.completed(this, SocketOperationRead);
         }
+#else
+        if(_workItems.empty() && !_destroyed)
+        {
+            _threadPool._selector.ready(this, SocketOperationRead, false);
+        }
+#endif
     }
 
     if(workItem)
@@ -291,6 +224,7 @@ IceInternal::ThreadPoolWorkQueue::message(ThreadPoolCurrent& current)
     }
     else
     {
+        assert(_destroyed);
         current.ioCompleted();
         throw ThreadPoolDestroyedException();
     }
@@ -311,47 +245,7 @@ IceInternal::ThreadPoolWorkQueue::toString() const
 NativeInfoPtr
 IceInternal::ThreadPoolWorkQueue::getNativeInfo()
 {
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
-    return new NativeInfo(_fdIntrRead);
-#else
     return 0;
-#endif
-}
-
-void
-IceInternal::ThreadPoolWorkQueue::postMessage()
-{
-#if defined(ICE_USE_IOCP)
-    if(!PostQueuedCompletionStatus(_selector.getIOCPHandle(), 0, reinterpret_cast<ULONG_PTR>(this), &_info))
-    {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = GetLastError();
-        throw ex;
-    }
-#elif defined(ICE_OS_WINRT)
-    _selector.completed(this, SocketOperationRead);
-#else
-    char c = 0;
-    while(true)
-    {
-#   ifdef _WIN32
-        if(::send(_fdIntrWrite, &c, 1, 0) == SOCKET_ERROR)
-#   else
-        if(::write(_fdIntrWrite, &c, 1) == SOCKET_ERROR)
-#   endif
-        {
-            if(interrupted())
-            {
-                continue;
-            }
-
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
-        }
-        break;
-    }
-#endif
 }
 
 IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& prefix, int timeout) :
@@ -372,14 +266,14 @@ IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& p
     _threadIdleTime(0),
     _stackSize(0),
     _inUse(0),
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
     _inUseIO(0),
     _nextHandler(_handlers.end()),
 #endif
     _promote(true)
 {
     PropertiesPtr properties = _instance->initializationData().properties;
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 #   ifdef _WIN32
     SYSTEM_INFO sysInfo;
     GetSystemInfo(&sysInfo);
@@ -403,7 +297,7 @@ IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& p
     }
 
     int sizeMax = properties->getPropertyAsIntWithDefault(_prefix + ".SizeMax", size);
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     if(sizeMax == -1)
     {
         sizeMax = nProcessors;
@@ -441,7 +335,7 @@ IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& p
     const_cast<int&>(_size) = size;
     const_cast<int&>(_sizeMax) = sizeMax;
     const_cast<int&>(_sizeWarn) = sizeWarn;
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     const_cast<int&>(_sizeIO) = min(sizeMax, nProcessors);
 #else
     const_cast<int&>(_sizeIO) = sizeMax;
@@ -452,7 +346,16 @@ IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& p
     _selector.setup(_sizeIO);
 #endif
 
-    int stackSize = properties->getPropertyAsInt(_prefix + ".StackSize");
+#if defined(__APPLE__)
+    //
+    // We use a default stack size of 1MB on macOS and the new C++11 mapping to allow transmitting
+    // class graphs with a depth of 100 (maximum default), 512KB is not enough otherwise.
+    //
+    int defaultStackSize = 1024 * 1024; // 1MB
+#else
+    int defaultStackSize = 0;
+#endif
+    int stackSize = properties->getPropertyAsIntWithDefault(_prefix + ".StackSize", defaultStackSize);
     if(stackSize < 0)
     {
         Warning out(_instance->initializationData().logger);
@@ -469,7 +372,8 @@ IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& p
         const_cast<int&>(_priority) = properties->getPropertyAsInt("Ice.ThreadPriority");
     }
 
-    _workQueue = new ThreadPoolWorkQueue(_instance, _selector);
+    _workQueue = ICE_MAKE_SHARED(ThreadPoolWorkQueue, *this);
+    _selector.initialize(_workQueue.get());
 
     if(_instance->traceLevels()->threadPool >= 1)
     {
@@ -528,7 +432,6 @@ IceInternal::ThreadPool::destroy()
     {
         return;
     }
-
     _destroyed = true;
     _workQueue->destroy();
 }
@@ -549,6 +452,28 @@ IceInternal::ThreadPool::initialize(const EventHandlerPtr& handler)
     Lock sync(*this);
     assert(!_destroyed);
     _selector.initialize(handler.get());
+
+    class ReadyCallbackI : public ReadyCallback
+    {
+    public:
+
+        ReadyCallbackI(const ThreadPoolPtr& threadPool, const EventHandlerPtr& handler) :
+            _threadPool(threadPool), _handler(handler)
+        {
+        }
+
+        virtual void
+        ready(SocketOperation op, bool value)
+        {
+            _threadPool->ready(_handler, op, value);
+        }
+
+    private:
+
+        const ThreadPoolPtr _threadPool;
+        const EventHandlerPtr _handler;
+    };
+    handler->getNativeInfo()->setReadyCallback(new ReadyCallbackI(this, handler));
 }
 
 void
@@ -569,20 +494,6 @@ IceInternal::ThreadPool::update(const EventHandlerPtr& handler, SocketOperation
     }
 
     _selector.update(handler.get(), remove, add);
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
-    if(add & SocketOperationRead && handler->_hasMoreData && !(handler->_disabled & SocketOperationRead))
-    {
-        if(_pendingHandlers.empty())
-        {
-            _workQueue->queue(interruptWorkItem); // Interrupt select()
-        }
-       _pendingHandlers.insert(handler.get());
-    }
-    else if(remove & SocketOperationRead)
-    {
-        _pendingHandlers.erase(handler.get());
-    }
-#endif
 }
 
 bool
@@ -590,9 +501,8 @@ IceInternal::ThreadPool::finish(const EventHandlerPtr& handler, bool closeNow)
 {
     Lock sync(*this);
     assert(!_destroyed);
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
     closeNow = _selector.finish(handler.get(), closeNow); // This must be called before!
-    _pendingHandlers.erase(handler.get());
     _workQueue->queue(new FinishedWorkItem(handler, !closeNow));
     return closeNow;
 #else
@@ -610,6 +520,17 @@ IceInternal::ThreadPool::finish(const EventHandlerPtr& handler, bool closeNow)
 #endif
 }
 
+void
+IceInternal::ThreadPool::ready(const EventHandlerPtr& handler, SocketOperation op, bool value)
+{
+    Lock sync(*this);
+    if(_destroyed)
+    {
+        return;
+    }
+    _selector.ready(handler.get(), op, value);
+}
+
 void
 IceInternal::ThreadPool::dispatchFromThisThread(const DispatchWorkItemPtr& workItem)
 {
@@ -617,7 +538,15 @@ IceInternal::ThreadPool::dispatchFromThisThread(const DispatchWorkItemPtr& workI
     {
         try
         {
+#ifdef ICE_CPP11_MAPPING
+            _dispatcher([workItem]()
+                        {
+                            workItem->run();
+                        },
+                        workItem->getConnection());
+#else
             _dispatcher->dispatch(workItem, workItem->getConnection());
+#endif
         }
         catch(const std::exception& ex)
         {
@@ -645,6 +574,11 @@ IceInternal::ThreadPool::dispatchFromThisThread(const DispatchWorkItemPtr& workI
 void
 IceInternal::ThreadPool::dispatch(const DispatchWorkItemPtr& workItem)
 {
+    Lock sync(*this);
+    if(_destroyed)
+    {
+        throw CommunicatorDestroyedException(__FILE__, __LINE__);
+    }
     _workQueue->queue(workItem);
 }
 
@@ -663,10 +597,6 @@ IceInternal::ThreadPool::joinWithAllThreads()
     {
         (*p)->getThreadControl().join();
     }
-
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
-    _selector.finish(_workQueue.get(), true);
-#endif
     _selector.destroy();
 }
 
@@ -679,10 +609,9 @@ IceInternal::ThreadPool::prefix() const
 void
 IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
 {
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
     ThreadPoolCurrent current(_instance, this, thread);
     bool select = false;
-    vector<pair<EventHandler*, SocketOperation> > handlers;
     while(true)
     {
         if(current._handler)
@@ -711,7 +640,7 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
         {
             try
             {
-                _selector.select(handlers, _serverIdleTime);
+                _selector.select(_serverIdleTime);
             }
             catch(const SelectorTimeoutException&)
             {
@@ -730,22 +659,8 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
             {
                 if(select)
                 {
-                    _handlers.swap(handlers);
-                    if(!_pendingHandlers.empty())
-                    {
-                        for(_nextHandler = _handlers.begin(); _nextHandler != _handlers.end(); ++_nextHandler)
-                        {
-                            _pendingHandlers.erase(_nextHandler->first);
-                        }
-                        set<EventHandler*>::const_iterator p;
-                        for(p = _pendingHandlers.begin(); p != _pendingHandlers.end(); ++p)
-                        {
-                            _handlers.push_back(make_pair(*p, SocketOperationRead));
-                        }
-                        _pendingHandlers.clear();
-                    }
+                    _selector.finishSelect(_handlers);
                     _nextHandler = _handlers.begin();
-                    _selector.finishSelect();
                     select = false;
                 }
                 else if(!current._leader && followerWait(current))
@@ -762,14 +677,6 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
                     // the IO thread count now.
                     //
                     --_inUseIO;
-                    if(current._handler->_hasMoreData && current._handler->_registered & SocketOperationRead)
-                    {
-                        if(_pendingHandlers.empty())
-                        {
-                            _workQueue->queue(interruptWorkItem); // Interrupt select()
-                        }
-                        _pendingHandlers.insert(current._handler.get());
-                    }
                 }
                 else
                 {
@@ -780,14 +687,6 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
                     if(_serialize && current._handler.get() != _workQueue.get())
                     {
                         _selector.enable(current._handler.get(), current.operation);
-                        if(current._handler->_hasMoreData && current._handler->_registered & SocketOperationRead)
-                        {
-                            if(_pendingHandlers.empty())
-                            {
-                                _workQueue->queue(interruptWorkItem); // Interrupt select()
-                            }
-                            _pendingHandlers.insert(current._handler.get());
-                        }
                     }
                     assert(_inUse > 0);
                     --_inUse;
@@ -798,29 +697,22 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
                     return; // Wait timed-out.
                 }
             }
-            else if(current._handler->_hasMoreData && current._handler->_registered & SocketOperationRead)
-            {
-                if(_pendingHandlers.empty())
-                {
-                    _workQueue->queue(interruptWorkItem); // Interrupt select()
-                }
-                _pendingHandlers.insert(current._handler.get());
-            }
 
             //
             // Get the next ready handler.
             //
-            while(_nextHandler != _handlers.end() && !(_nextHandler->second & _nextHandler->first->_registered))
+            while(_nextHandler != _handlers.end() &&
+                  !(_nextHandler->second & ~_nextHandler->first->_disabled & _nextHandler->first->_registered))
             {
                 ++_nextHandler;
             }
             if(_nextHandler != _handlers.end())
             {
                 current._ioCompleted = false;
-                current._handler = _nextHandler->first;
+                current._handler = ICE_GET_SHARED_FROM_THIS(_nextHandler->first);
                 current.operation = _nextHandler->second;
                 ++_nextHandler;
-                thread->setState(ThreadStateInUseForIO);
+                thread->setState(ICE_ENUM(ThreadState, ThreadStateInUseForIO));
             }
             else
             {
@@ -844,7 +736,7 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
                     _handlers.clear();
                     _selector.startSelect();
                     select = true;
-                    thread->setState(ThreadStateIdle);
+                    thread->setState(ICE_ENUM(ThreadState, ThreadStateIdle));
                 }
             }
             else if(_sizeMax > 1)
@@ -868,11 +760,11 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
         try
         {
             current._ioCompleted = false;
-#ifdef ICE_OS_WINRT
-            current._handler = _selector.getNextHandler(current.operation, _threadIdleTime);
+#ifdef ICE_OS_UWP
+            current._handler = ICE_GET_SHARED_FROM_THIS(_selector.getNextHandler(current.operation, _threadIdleTime));
 #else
-            current._handler = _selector.getNextHandler(current.operation, current._count, current._error,
-                                                        _threadIdleTime);
+            current._handler = ICE_GET_SHARED_FROM_THIS(_selector.getNextHandler(current.operation, current._count, current._error,
+                                                                                 _threadIdleTime));
 #endif
         }
         catch(const SelectorTimeoutException&)
@@ -887,7 +779,7 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
                 }
                 else if(_inUse < static_cast<int>(_threads.size() - 1)) // If not the last idle thread, we can exit.
                 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
                     BOOL hasIO = false;
                     GetThreadIOPendingFlag(GetCurrentThread(), &hasIO);
                     if(hasIO)
@@ -918,11 +810,12 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
 
             try
             {
-#ifdef ICE_OS_WINRT
-                current._handler = _selector.getNextHandler(current.operation, _serverIdleTime);
+#ifdef ICE_OS_UWP
+                current._handler = ICE_GET_SHARED_FROM_THIS(_selector.getNextHandler(current.operation, _serverIdleTime));
 #else
-                current._handler = _selector.getNextHandler(current.operation, current._count, current._error,
-                                                            _serverIdleTime);
+
+                current._handler = ICE_GET_SHARED_FROM_THIS(_selector.getNextHandler(current.operation, current._count,
+                    current._error, _serverIdleTime));
 #endif
             }
             catch(const SelectorTimeoutException&)
@@ -938,7 +831,7 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
 
         {
             IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-            thread->setState(ThreadStateInUseForIO);
+            thread->setState(ICE_ENUM(ThreadState, ThreadStateInUseForIO));
         }
 
         try
@@ -955,7 +848,7 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
             Error out(_instance->initializationData().logger);
             out << "exception in `" << _prefix << "':\n" << ex << "\nevent handler: " << current._handler->toString();
         }
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
         catch(Platform::Exception^ ex)
         {
             //
@@ -964,7 +857,7 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
             //
             Error out(_instance->initializationData().logger);
             out << "exception in `" << _prefix << "':\n"
-                << IceUtil::wstringToString(ex->Message->Data(), _instance->getStringConverter())
+                << wstringToString(ex->Message->Data(), _instance->getStringConverter())
                 << "\nevent handler: " << current._handler->toString();
         }
 #endif
@@ -981,7 +874,7 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
                 assert(_inUse > 0);
                 --_inUse;
             }
-            thread->setState(ThreadStateIdle);
+            thread->setState(ICE_ENUM(ThreadState, ThreadStateIdle));
         }
     }
 #endif
@@ -994,12 +887,12 @@ IceInternal::ThreadPool::ioCompleted(ThreadPoolCurrent& current)
 
     current._ioCompleted = true; // Set the IO completed flag to specifiy that ioCompleted() has been called.
 
-    current._thread->setState(ThreadStateInUseForUser);
+    current._thread->setState(ICE_ENUM(ThreadState, ThreadStateInUseForUser));
 
     if(_sizeMax > 1)
     {
 
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
         --_inUseIO;
 
         if(!_destroyed)
@@ -1007,19 +900,6 @@ IceInternal::ThreadPool::ioCompleted(ThreadPoolCurrent& current)
             if(_serialize && current._handler.get() != _workQueue.get())
             {
                 _selector.disable(current._handler.get(), current.operation);
-
-                // Make sure the handler isn't in the set of pending handlers (this can
-                // for example occur if the handler is has more data and its added by
-                // ThreadPool::update while we were processing IO).
-                _pendingHandlers.erase(current._handler.get());
-            }
-            else if(current._handler->_hasMoreData && current._handler->_registered & SocketOperationRead)
-            {
-                if(_pendingHandlers.empty())
-                {
-                    _workQueue->queue(interruptWorkItem); // Interrupt select()
-                }
-                _pendingHandlers.insert(current._handler.get());
             }
         }
 
@@ -1082,7 +962,7 @@ IceInternal::ThreadPool::ioCompleted(ThreadPoolCurrent& current)
     return _serialize && current._handler.get() != _workQueue.get();
 }
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
 bool
 IceInternal::ThreadPool::startMessage(ThreadPoolCurrent& current)
 {
@@ -1090,11 +970,11 @@ IceInternal::ThreadPool::startMessage(ThreadPoolCurrent& current)
 
     if(current._handler->_started & current.operation)
     {
-        assert(!(current._handler->_ready & current.operation));
-        current._handler->_ready = static_cast<SocketOperation>(current._handler->_ready | current.operation);
+        assert(!(current._handler->_completed & current.operation));
+        current._handler->_completed = static_cast<SocketOperation>(current._handler->_completed | current.operation);
         current._handler->_started = static_cast<SocketOperation>(current._handler->_started & ~current.operation);
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
         AsyncInfo* info = current._handler->getNativeInfo()->getAsyncInfo(current.operation);
         info->count = current._count;
         info->error = current._error;
@@ -1105,20 +985,26 @@ IceInternal::ThreadPool::startMessage(ThreadPoolCurrent& current)
             current._handler->_pending = static_cast<SocketOperation>(current._handler->_pending & ~current.operation);
             if(!(current._handler->_pending & SocketOperationWaitForClose) && current._handler->_finish)
             {
+                Lock sync(*this);
                 _workQueue->queue(new FinishedWorkItem(current._handler, false));
                 _selector.finish(current._handler.get());
             }
             return false;
         }
     }
-    else if(!(current._handler->_ready & current.operation) && (current._handler->_registered & current.operation))
+    else if(!(current._handler->_completed & current.operation) && (current._handler->_registered & current.operation))
     {
         assert(!(current._handler->_started & current.operation));
-        if(!current._handler->startAsync(current.operation))
+        if(current._handler->_ready & current.operation)
+        {
+            return true;
+        }
+        else if(!current._handler->startAsync(current.operation))
         {
             current._handler->_pending = static_cast<SocketOperation>(current._handler->_pending & ~current.operation);
             if(!(current._handler->_pending & SocketOperationWaitForClose) && current._handler->_finish)
             {
+                Lock sync(*this);
                 _workQueue->queue(new FinishedWorkItem(current._handler, false));
                 _selector.finish(current._handler.get());
             }
@@ -1133,8 +1019,8 @@ IceInternal::ThreadPool::startMessage(ThreadPoolCurrent& current)
 
     if(current._handler->_registered & current.operation)
     {
-        assert(current._handler->_ready & current.operation);
-        current._handler->_ready = static_cast<SocketOperation>(current._handler->_ready & ~current.operation);
+        assert(current._handler->_completed & current.operation);
+        current._handler->_completed = static_cast<SocketOperation>(current._handler->_completed & ~current.operation);
         return true;
     }
     else
@@ -1142,6 +1028,7 @@ IceInternal::ThreadPool::startMessage(ThreadPoolCurrent& current)
         current._handler->_pending = static_cast<SocketOperation>(current._handler->_pending & ~current.operation);
         if(!(current._handler->_pending & SocketOperationWaitForClose) && current._handler->_finish)
         {
+            Lock sync(*this);
             _workQueue->queue(new FinishedWorkItem(current._handler, false));
             _selector.finish(current._handler.get());
         }
@@ -1152,10 +1039,14 @@ IceInternal::ThreadPool::startMessage(ThreadPoolCurrent& current)
 void
 IceInternal::ThreadPool::finishMessage(ThreadPoolCurrent& current)
 {
-    if(current._handler->_registered & current.operation)
+    if(current._handler->_registered & current.operation && !current._handler->_finish)
     {
-        assert(!(current._handler->_ready & current.operation));
-        if(!current._handler->startAsync(current.operation))
+        assert(!(current._handler->_completed & current.operation));
+        if(current._handler->_ready & current.operation)
+        {
+            _selector.completed(current._handler.get(), current.operation);
+        }
+        else if(!current._handler->startAsync(current.operation))
         {
             current._handler->_pending = static_cast<SocketOperation>(current._handler->_pending & ~current.operation);
         }
@@ -1173,6 +1064,7 @@ IceInternal::ThreadPool::finishMessage(ThreadPoolCurrent& current)
     if(!(current._handler->_pending & SocketOperationWaitForClose) && current._handler->_finish)
     {
         // There are no more pending async operations, it's time to call finish.
+        Lock sync(*this);
         _workQueue->queue(new FinishedWorkItem(current._handler, false));
         _selector.finish(current._handler.get());
     }
@@ -1195,7 +1087,7 @@ IceInternal::ThreadPool::followerWait(ThreadPoolCurrent& current)
 {
     assert(!current._leader);
 
-    current._thread->setState(ThreadStateIdle);
+    current._thread->setState(ICE_ENUM(ThreadState, ThreadStateIdle));
 
     //
     // It's important to clear the handler before waiting to make sure that
@@ -1252,7 +1144,7 @@ IceInternal::ThreadPool::nextThreadId()
 IceInternal::ThreadPool::EventHandlerThread::EventHandlerThread(const ThreadPoolPtr& pool, const string& name) :
     IceUtil::Thread(name),
     _pool(pool),
-    _state(Ice::Instrumentation::ThreadStateIdle)
+    _state(ICE_ENUM(ThreadState, ThreadStateIdle))
 {
     updateObserver();
 }
@@ -1285,11 +1177,19 @@ IceInternal::ThreadPool::EventHandlerThread::setState(Ice::Instrumentation::Thre
 void
 IceInternal::ThreadPool::EventHandlerThread::run()
 {
+#ifdef ICE_CPP11_MAPPING
+    if(_pool->_instance->initializationData().threadStart)
+#else
     if(_pool->_instance->initializationData().threadHook)
+#endif
     {
         try
         {
+#ifdef ICE_CPP11_MAPPING
+            _pool->_instance->initializationData().threadStart();
+#else
             _pool->_instance->initializationData().threadHook->start();
+#endif
         }
         catch(const exception& ex)
         {
@@ -1320,11 +1220,19 @@ IceInternal::ThreadPool::EventHandlerThread::run()
 
     _observer.detach();
 
+#ifdef ICE_CPP11_MAPPING
+    if(_pool->_instance->initializationData().threadStop)
+#else
     if(_pool->_instance->initializationData().threadHook)
+#endif
     {
         try
         {
+#ifdef ICE_CPP11_MAPPING
+            _pool->_instance->initializationData().threadStop();
+#else
             _pool->_instance->initializationData().threadHook->stop();
+#endif
         }
         catch(const exception& ex)
         {
@@ -1349,7 +1257,7 @@ ThreadPoolCurrent::ThreadPoolCurrent(const InstancePtr& instance,
     _threadPool(threadPool.get()),
     _thread(thread),
     _ioCompleted(false)
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
     , _leader(false)
 #endif
 {