zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/Selector.cpp

@@ -1,93 +1,70 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/Selector.h>
-#include <Ice/EventHandler.h>
-#include <Ice/Instance.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/LocalException.h>
-#include <IceUtil/Time.h>
+#include "Selector.h"
+#include "EventHandler.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Instance.h"
 
 #ifdef ICE_USE_CFSTREAM
-#   include <CoreFoundation/CoreFoundation.h>
-#   include <CoreFoundation/CFStream.h>
+#    include <CoreFoundation/CFStream.h>
+#    include <CoreFoundation/CoreFoundation.h>
 #endif
 
+#include <chrono>
+#include <thread>
+
 using namespace std;
 using namespace IceInternal;
 
 #if defined(ICE_USE_KQUEUE)
 namespace
 {
-struct timespec zeroTimeout = { 0, 0 };
+    struct timespec zeroTimeout = {0, 0};
 }
 #endif
 
 #if defined(ICE_USE_IOCP)
 
-Selector::Selector(const InstancePtr& instance) : _instance(instance)
-{
-}
-
-Selector::~Selector()
-{
-}
+Selector::Selector(const InstancePtr& instance) : _instance(instance) {}
 
-#ifdef ICE_USE_IOCP
 void
 Selector::setup(int sizeIO)
 {
-    _handle = CreateIoCompletionPort(INVALID_HANDLE_VALUE, ICE_NULLPTR, 0, sizeIO);
-    if(_handle == ICE_NULLPTR)
+    _handle = CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr, 0, sizeIO);
+    if (_handle == nullptr)
     {
         throw Ice::SocketException(__FILE__, __LINE__, GetLastError());
     }
 }
-#endif
 
 void
 Selector::destroy()
 {
-#ifdef ICE_USE_IOCP
     CloseHandle(_handle);
-#endif
 }
 
 void
 Selector::initialize(EventHandler* handler)
 {
-    if(!handler->getNativeInfo())
+    if (!handler->getNativeInfo())
     {
         return;
     }
 
-#ifdef ICE_USE_IOCP
     SOCKET socket = handler->getNativeInfo()->fd();
-    if(socket != INVALID_SOCKET)
+    if (socket != INVALID_SOCKET)
     {
-        if(CreateIoCompletionPort(reinterpret_cast<HANDLE>(socket),
-                                  _handle,
-                                  reinterpret_cast<ULONG_PTR>(handler),
-                                  0) == ICE_NULLPTR)
+        if (CreateIoCompletionPort(
+                reinterpret_cast<HANDLE>(socket),
+                _handle,
+                reinterpret_cast<ULONG_PTR>(handler),
+                0) == nullptr)
         {
             throw Ice::SocketException(__FILE__, __LINE__, GetLastError());
         }
     }
     handler->getNativeInfo()->initialize(_handle, reinterpret_cast<ULONG_PTR>(handler));
-#else
-    EventHandlerPtr h = ICE_GET_SHARED_FROM_THIS(handler);
-    handler->getNativeInfo()->setCompletedHandler(
-        ref new SocketOperationCompletedHandler(
-            [=](int operation)
-            {
-                //
-                // Use the reference counted handler to ensure it's not
-                // destroyed as long as the callback lambda exists.
-                //
-                completed(h.get(), static_cast<SocketOperation>(operation));
-            }));
-#endif
 }
 
 void
@@ -95,15 +72,15 @@ Selector::update(EventHandler* handler, SocketOperation remove, SocketOperation
 {
     handler->_registered = static_cast<SocketOperation>(handler->_registered & ~remove);
     handler->_registered = static_cast<SocketOperation>(handler->_registered | add);
-    if(add & SocketOperationRead && !(handler->_pending & SocketOperationRead))
+    if (add & SocketOperationRead && !(handler->_pending & SocketOperationRead))
     {
         handler->_pending = static_cast<SocketOperation>(handler->_pending | SocketOperationRead);
-        completed(handler, SocketOperationRead); // Start an asynchrnous read
+        completed(handler, SocketOperationRead); // Start an asynchronous read
     }
-    else if(add & SocketOperationWrite && !(handler->_pending & SocketOperationWrite))
+    else if (add & SocketOperationWrite && !(handler->_pending & SocketOperationWrite))
     {
         handler->_pending = static_cast<SocketOperation>(handler->_pending | SocketOperationWrite);
-        completed(handler, SocketOperationWrite); // Start an asynchrnous write
+        completed(handler, SocketOperationWrite); // Start an asynchronous write
     }
 }
 
@@ -117,12 +94,12 @@ Selector::finish(IceInternal::EventHandler* handler)
 void
 Selector::ready(EventHandler* handler, SocketOperation status, bool value)
 {
-    if(((handler->_ready & status) != 0) == value)
+    if (((handler->_ready & status) != 0) == value)
     {
         return; // Nothing to do if ready state already correctly set.
     }
 
-    if(value)
+    if (value)
     {
         handler->_ready = static_cast<SocketOperation>(handler->_ready | status);
     }
@@ -133,36 +110,32 @@ Selector::ready(EventHandler* handler, SocketOperation status, bool value)
 }
 
 EventHandler*
-#ifdef ICE_USE_IOCP
 Selector::getNextHandler(SocketOperation& status, DWORD& count, int& error, int timeout)
-#else
-Selector::getNextHandler(SocketOperation& status, int timeout)
-#endif
 {
-#ifdef ICE_USE_IOCP
     ULONG_PTR key;
     LPOVERLAPPED ol;
     error = ERROR_SUCCESS;
 
-    if(!GetQueuedCompletionStatus(_handle, &count, &key, &ol, timeout > 0 ? timeout * 1000 : INFINITE))
+    if (!GetQueuedCompletionStatus(_handle, &count, &key, &ol, timeout > 0 ? timeout * 1000 : INFINITE))
     {
         int err = WSAGetLastError();
-        if(ol == 0)
+        if (ol == nullptr)
         {
-            if(err == WAIT_TIMEOUT)
+            if (err == WAIT_TIMEOUT)
             {
                 throw SelectorTimeoutException();
             }
             else
             {
+                // This indicates a internal error with the IOCP completion port, we log the error and abort.
                 Ice::SocketException ex(__FILE__, __LINE__, err);
                 Ice::Error out(_instance->initializationData().logger);
                 out << "couldn't dequeue packet from completion port:\n" << ex;
-                IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(5)); // Sleep 5s to avoid looping
+                std::abort();
             }
         }
         AsyncInfo* info = static_cast<AsyncInfo*>(ol);
-        if(info)
+        if (info)
         {
             status = info->status;
         }
@@ -172,7 +145,7 @@ Selector::getNextHandler(SocketOperation& status, int timeout)
     }
 
     AsyncInfo* info = static_cast<AsyncInfo*>(ol);
-    if(info)
+    if (info)
     {
         status = info->status;
     }
@@ -181,56 +154,26 @@ Selector::getNextHandler(SocketOperation& status, int timeout)
         status = reinterpret_cast<EventHandler*>(key)->_ready;
     }
     return reinterpret_cast<EventHandler*>(key);
-#else
-    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
-    while(_events.empty())
-    {
-        if(timeout > 0)
-        {
-            _monitor.timedWait(IceUtil::Time::seconds(timeout));
-            if(_events.empty())
-            {
-                throw SelectorTimeoutException();
-            }
-        }
-        else
-        {
-            _monitor.wait();
-        }
-    }
-    assert(!_events.empty());
-    IceInternal::EventHandlerPtr handler = _events.front().handler;
-    const SelectEvent& event = _events.front();
-    status = event.status;
-    _events.pop_front();
-    return handler.get();
-#endif
 }
 
 void
 Selector::completed(EventHandler* handler, SocketOperation op)
 {
-#ifdef ICE_USE_IOCP
     AsyncInfo* info = 0;
     NativeInfoPtr nativeInfo = handler->getNativeInfo();
-    if(nativeInfo)
+    if (nativeInfo)
     {
         info = nativeInfo->getAsyncInfo(op);
     }
-    if(!PostQueuedCompletionStatus(_handle, 0, reinterpret_cast<ULONG_PTR>(handler), info))
+    if (!PostQueuedCompletionStatus(_handle, 0, reinterpret_cast<ULONG_PTR>(handler), info))
     {
         throw Ice::SocketException(__FILE__, __LINE__, GetLastError());
     }
-#else
-    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
-    _events.push_back(SelectEvent(handler->shared_from_this(), op));
-    _monitor.notify();
-#endif
 }
 
-#elif defined(ICE_USE_KQUEUE) || defined(ICE_USE_EPOLL) || defined(ICE_USE_SELECT) || defined(ICE_USE_POLL)
+#elif defined(ICE_USE_EPOLL) || defined(ICE_USE_KQUEUE)
 
-Selector::Selector(const InstancePtr& instance) : _instance(instance), _interrupted(false)
+Selector::Selector(InstancePtr instance) : _instance(std::move(instance))
 {
     SOCKET fds[2];
     createPipe(fds);
@@ -238,76 +181,60 @@ Selector::Selector(const InstancePtr& instance) : _instance(instance), _interrup
     _fdIntrWrite = fds[1];
     _selecting = false;
 
-#if defined(ICE_USE_EPOLL)
+#    if defined(ICE_USE_EPOLL)
     _events.resize(256);
     _queueFd = epoll_create(1);
-    if(_queueFd < 0)
+    if (_queueFd < 0)
     {
         throw Ice::SocketException(__FILE__, __LINE__, IceInternal::getSocketErrno());
     }
 
     epoll_event event;
     memset(&event, 0, sizeof(epoll_event));
-    event.data.ptr = 0;
+    event.data.ptr = nullptr;
     event.events = EPOLLIN;
-    if(epoll_ctl(_queueFd, EPOLL_CTL_ADD, _fdIntrRead, &event) != 0)
+    if (epoll_ctl(_queueFd, EPOLL_CTL_ADD, _fdIntrRead, &event) != 0)
     {
         Ice::Error out(_instance->initializationData().logger);
-        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+        out << "error while updating selector:\n" << IceInternal::errorToString(IceInternal::getSocketErrno());
     }
-#elif defined(ICE_USE_KQUEUE)
+#    else // ICE_USE_KQUEUE
     _events.resize(256);
     _queueFd = kqueue();
-    if(_queueFd < 0)
+    if (_queueFd < 0)
     {
         throw Ice::SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     struct kevent ev;
     EV_SET(&ev, _fdIntrRead, EVFILT_READ, EV_ADD, 0, 0, 0);
-    int rs = kevent(_queueFd, &ev, 1, 0, 0, 0);
-    if(rs < 0)
+    int rs = kevent(_queueFd, &ev, 1, nullptr, 0, nullptr);
+    if (rs < 0)
     {
         Ice::Error out(_instance->initializationData().logger);
-        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
-    }
-#elif defined(ICE_USE_SELECT)
-    FD_ZERO(&_readFdSet);
-    FD_ZERO(&_writeFdSet);
-    FD_ZERO(&_errorFdSet);
-    FD_SET(_fdIntrRead, &_readFdSet);
-#else
-    struct pollfd pollFd;
-    pollFd.fd = _fdIntrRead;
-    pollFd.events = POLLIN;
-    _pollFdSet.push_back(pollFd);
-#endif
-}
-
-Selector::~Selector()
-{
+        out << "error while updating selector:\n" << IceInternal::errorToString(IceInternal::getSocketErrno());
+    }
+#    endif
 }
 
 void
 Selector::destroy()
 {
-#if defined(ICE_USE_KQUEUE) || defined(ICE_USE_EPOLL)
     try
     {
         closeSocket(_queueFd);
     }
-    catch(const Ice::LocalException& ex)
+    catch (const Ice::LocalException& ex)
     {
         Ice::Error out(_instance->initializationData().logger);
         out << "exception in selector while calling closeSocket():\n" << ex;
     }
-#endif
 
     try
     {
         closeSocket(_fdIntrWrite);
     }
-    catch(const Ice::LocalException& ex)
+    catch (const Ice::LocalException& ex)
     {
         Ice::Error out(_instance->initializationData().logger);
         out << "exception in selector while calling closeSocket():\n" << ex;
@@ -317,7 +244,7 @@ Selector::destroy()
     {
         closeSocket(_fdIntrRead);
     }
-    catch(const Ice::LocalException& ex)
+    catch (const Ice::LocalException& ex)
     {
         Ice::Error out(_instance->initializationData().logger);
         out << "exception in selector while calling closeSocket():\n" << ex;
@@ -330,14 +257,14 @@ Selector::update(EventHandler* handler, SocketOperation remove, SocketOperation
     SocketOperation previous = handler->_registered;
     handler->_registered = static_cast<SocketOperation>(handler->_registered & ~remove);
     handler->_registered = static_cast<SocketOperation>(handler->_registered | add);
-    if(previous == handler->_registered)
+    if (previous == handler->_registered)
     {
         return;
     }
     checkReady(handler);
 
     NativeInfoPtr nativeInfo = handler->getNativeInfo();
-    if(nativeInfo && nativeInfo->fd() != INVALID_SOCKET)
+    if (nativeInfo && nativeInfo->fd() != INVALID_SOCKET)
     {
         updateSelectorForEventHandler(handler, remove, add);
     }
@@ -346,7 +273,7 @@ Selector::update(EventHandler* handler, SocketOperation remove, SocketOperation
 void
 Selector::enable(EventHandler* handler, SocketOperation status)
 {
-    if(!(handler->_disabled & status))
+    if (!(handler->_disabled & status))
     {
         return;
     }
@@ -354,53 +281,50 @@ Selector::enable(EventHandler* handler, SocketOperation status)
     checkReady(handler);
 
     NativeInfoPtr nativeInfo = handler->getNativeInfo();
-    if(!nativeInfo || nativeInfo->fd() == INVALID_SOCKET)
+    if (!nativeInfo || nativeInfo->fd() == INVALID_SOCKET)
     {
         return;
     }
 
-    if(handler->_registered & status)
+    if (handler->_registered & status)
     {
-#if defined(ICE_USE_EPOLL)
+#    if defined(ICE_USE_EPOLL)
         SOCKET fd = nativeInfo->fd();
-        SocketOperation previous = static_cast<SocketOperation>(handler->_registered & ~(handler->_disabled | status));
-        SocketOperation newStatus = static_cast<SocketOperation>(handler->_registered & ~handler->_disabled);
+        auto previous = static_cast<SocketOperation>(handler->_registered & ~(handler->_disabled | status));
+        auto newStatus = static_cast<SocketOperation>(handler->_registered & ~handler->_disabled);
         epoll_event event;
         memset(&event, 0, sizeof(epoll_event));
         event.data.ptr = handler;
-        if(newStatus & SocketOperationRead)
+        if (newStatus & SocketOperationRead)
         {
             event.events |= EPOLLIN;
         }
-        if(newStatus & SocketOperationWrite)
+        if (newStatus & SocketOperationWrite)
         {
             event.events |= EPOLLOUT;
         }
-        if(epoll_ctl(_queueFd, previous ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, fd, &event) != 0)
+        if (epoll_ctl(_queueFd, previous ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, fd, &event) != 0)
         {
             Ice::Error out(_instance->initializationData().logger);
-            out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+            out << "error while updating selector:\n" << IceInternal::errorToString(IceInternal::getSocketErrno());
         }
-#elif defined(ICE_USE_KQUEUE)
+#    else // ICE_USE_KQUEUE
         struct kevent ev;
         SOCKET fd = handler->getNativeInfo()->fd();
         EV_SET(&ev, fd, status == SocketOperationRead ? EVFILT_READ : EVFILT_WRITE, EV_ENABLE, 0, 0, handler);
         _changes.push_back(ev);
-        if(_selecting)
+        if (_selecting)
         {
             updateSelector();
         }
-#else
-        _changes.push_back(make_pair(handler, static_cast<SocketOperation>(handler->_registered & ~handler->_disabled)));
-        wakeup();
-#endif
+#    endif
     }
 }
 
 void
 Selector::disable(EventHandler* handler, SocketOperation status)
 {
-    if(handler->_disabled & status)
+    if (handler->_disabled & status)
     {
         return;
     }
@@ -408,61 +332,55 @@ Selector::disable(EventHandler* handler, SocketOperation status)
     checkReady(handler);
 
     NativeInfoPtr nativeInfo = handler->getNativeInfo();
-    if(!nativeInfo || nativeInfo->fd() == INVALID_SOCKET)
+    if (!nativeInfo || nativeInfo->fd() == INVALID_SOCKET)
     {
         return;
     }
 
-    if(handler->_registered & status)
+    if (handler->_registered & status)
     {
-#if defined(ICE_USE_EPOLL)
+#    if defined(ICE_USE_EPOLL)
         SOCKET fd = nativeInfo->fd();
-        SocketOperation newStatus = static_cast<SocketOperation>(handler->_registered & ~handler->_disabled);
+        auto newStatus = static_cast<SocketOperation>(handler->_registered & ~handler->_disabled);
         epoll_event event;
         memset(&event, 0, sizeof(epoll_event));
         event.data.ptr = handler;
-        if(newStatus & SocketOperationRead)
+        if (newStatus & SocketOperationRead)
         {
             event.events |= EPOLLIN;
         }
-        if(newStatus & SocketOperationWrite)
+        if (newStatus & SocketOperationWrite)
         {
             event.events |= EPOLLOUT;
         }
-        if(epoll_ctl(_queueFd, newStatus ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, fd, &event) != 0)
+        if (epoll_ctl(_queueFd, newStatus ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, fd, &event) != 0)
         {
             Ice::Error out(_instance->initializationData().logger);
-            out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+            out << "error while updating selector:\n" << IceInternal::errorToString(IceInternal::getSocketErrno());
         }
-#elif defined(ICE_USE_KQUEUE)
+#    else // ICE_USE_KQUEUE
         SOCKET fd = nativeInfo->fd();
         struct kevent ev;
         EV_SET(&ev, fd, status == SocketOperationRead ? EVFILT_READ : EVFILT_WRITE, EV_DISABLE, 0, 0, handler);
         _changes.push_back(ev);
-        if(_selecting)
+        if (_selecting)
         {
             updateSelector();
         }
-#else
-        _changes.push_back(make_pair(handler, static_cast<SocketOperation>(handler->_registered & ~handler->_disabled)));
-        wakeup();
-#endif
+#    endif
     }
 }
 
 bool
 Selector::finish(EventHandler* handler, bool closeNow)
 {
-    if(handler->_registered)
+    if (handler->_registered)
     {
         update(handler, handler->_registered, SocketOperationNone);
-#if !defined(ICE_USE_EPOLL) && !defined(ICE_USE_KQUEUE)
-        return false; // Don't close now if selecting
-#endif
     }
 
-#if defined(ICE_USE_KQUEUE)
-    if(closeNow && !_changes.empty())
+#    if defined(ICE_USE_KQUEUE)
+    if (closeNow && !_changes.empty())
     {
         //
         // Update selector now to remove the FD from the kqueue if
@@ -471,12 +389,7 @@ Selector::finish(EventHandler* handler, bool closeNow)
         //
         updateSelector();
     }
-#elif !defined(ICE_USE_EPOLL)
-    if(!_changes.empty())
-    {
-        return false;
-    }
-#endif
+#    endif
 
     return closeNow;
 }
@@ -484,22 +397,22 @@ Selector::finish(EventHandler* handler, bool closeNow)
 void
 Selector::ready(EventHandler* handler, SocketOperation status, bool value)
 {
-    if(((handler->_ready & status) != 0) == value)
+    if (((handler->_ready & status) != 0) == value)
     {
         return; // Nothing to do if ready state already correctly set.
     }
 
-    if(status & SocketOperationConnect)
+    if (status & SocketOperationConnect)
     {
         NativeInfoPtr nativeInfo = handler->getNativeInfo();
-        if(nativeInfo && nativeInfo->newFd() && handler->_registered)
+        if (nativeInfo && nativeInfo->newFd() && handler->_registered)
         {
             // If new FD is set after connect, register the FD with the selector.
             updateSelectorForEventHandler(handler, SocketOperationNone, handler->_registered);
         }
     }
 
-    if(value)
+    if (value)
     {
         handler->_ready = static_cast<SocketOperation>(handler->_ready | status);
     }
@@ -513,14 +426,14 @@ Selector::ready(EventHandler* handler, SocketOperation status, bool value)
 void
 Selector::wakeup()
 {
-    if(_selecting && !_interrupted)
+    if (_selecting && !_interrupted)
     {
         char c = 0;
-        while(true)
+        while (true)
         {
-            if(::write(_fdIntrWrite, &c, 1) == SOCKET_ERROR)
+            if (::write(_fdIntrWrite, &c, 1) == SOCKET_ERROR)
             {
-                if(interrupted())
+                if (interrupted())
                 {
                     continue;
                 }
@@ -536,15 +449,15 @@ Selector::wakeup()
 void
 Selector::startSelect()
 {
-    if(_interrupted)
+    if (_interrupted)
     {
         char c;
-        while(true)
+        while (true)
         {
             ssize_t ret = ::read(_fdIntrRead, &c, 1);
-            if(ret == SOCKET_ERROR)
+            if (ret == SOCKET_ERROR)
             {
-                if(interrupted())
+                if (interrupted())
                 {
                     continue;
                 }
@@ -555,12 +468,12 @@ Selector::startSelect()
         _interrupted = false;
     }
 
-#if !defined(ICE_USE_EPOLL)
-    if(!_changes.empty())
+#    if defined(ICE_USE_KQUEUE)
+    if (!_changes.empty())
     {
         updateSelector();
     }
-#endif
+#    endif
     _selecting = true;
 
     //
@@ -571,96 +484,41 @@ Selector::startSelect()
 }
 
 void
-Selector::finishSelect(vector<pair<EventHandler*, SocketOperation> >& handlers)
+Selector::finishSelect(vector<pair<EventHandler*, SocketOperation>>& handlers)
 {
     _selecting = false;
 
     assert(handlers.empty());
 
-#if defined(ICE_USE_POLL) || defined(ICE_USE_SELECT)
-    if(_interrupted) // Interrupted, we have to process the interrupt before returning any handlers
-    {
-        return;
-    }
-#endif
-
-#if defined(ICE_USE_POLL)
-    for(vector<struct pollfd>::const_iterator r = _pollFdSet.begin(); r != _pollFdSet.end(); ++r)
-#else
-    for(int i = 0; i < _count; ++i)
-#endif
+    for (int i = 0; i < _count; ++i)
     {
         pair<EventHandler*, SocketOperation> p;
 
-#if defined(ICE_USE_EPOLL)
+#    if defined(ICE_USE_EPOLL)
         struct epoll_event& ev = _events[i];
         p.first = reinterpret_cast<EventHandler*>(ev.data.ptr);
-        p.second = static_cast<SocketOperation>(((ev.events & (EPOLLIN | EPOLLERR)) ?
-                                                 SocketOperationRead : SocketOperationNone) |
-                                                ((ev.events & (EPOLLOUT | EPOLLERR)) ?
-                                                 SocketOperationWrite : SocketOperationNone));
-#elif defined(ICE_USE_KQUEUE)
+        p.second = static_cast<SocketOperation>(
+            ((ev.events & (EPOLLIN | EPOLLERR)) ? SocketOperationRead : SocketOperationNone) |
+            ((ev.events & (EPOLLOUT | EPOLLERR)) ? SocketOperationWrite : SocketOperationNone));
+#    else // ICE_USE_KQUEUE
         struct kevent& ev = _events[static_cast<size_t>(i)];
-        if(ev.flags & EV_ERROR)
+        if (ev.flags & EV_ERROR)
         {
             Ice::Error out(_instance->initializationData().logger);
-            out << "selector returned error:\n" << IceUtilInternal::errorToString(static_cast<int>(ev.data));
+            out << "selector returned error:\n" << IceInternal::errorToString(static_cast<int>(ev.data));
             continue;
         }
         p.first = reinterpret_cast<EventHandler*>(ev.udata);
         p.second = (ev.filter == EVFILT_READ) ? SocketOperationRead : SocketOperationWrite;
-#elif defined(ICE_USE_SELECT)
-        //
-        // Round robin for the filedescriptors.
-        //
-        SOCKET fd;
-        p.second = SocketOperationNone;
-        if(i < _selectedReadFdSet.fd_count)
-        {
-            fd = _selectedReadFdSet.fd_array[i];
-            p.second = static_cast<SocketOperation>(p.second | SocketOperationRead);
-        }
-        else if(i < _selectedWriteFdSet.fd_count + _selectedReadFdSet.fd_count)
-        {
-            fd = _selectedWriteFdSet.fd_array[i - _selectedReadFdSet.fd_count];
-            p.second = static_cast<SocketOperation>(p.second | SocketOperationWrite);
-        }
-        else
-        {
-            fd = _selectedErrorFdSet.fd_array[i - _selectedReadFdSet.fd_count - _selectedWriteFdSet.fd_count];
-            p.second = static_cast<SocketOperation>(p.second | SocketOperationConnect);
-        }
-
-        assert(fd != _fdIntrRead);
-        p.first = _handlers[fd];
-#else
-        if(r->revents == 0)
-        {
-            continue;
-        }
-
-        SOCKET fd = r->fd;
-        assert(_handlers.find(fd) != _handlers.end());
-        p.first = _handlers[fd];
-        p.second = SocketOperationNone;
-        if(r->revents & (POLLIN | POLLERR | POLLHUP))
-        {
-            p.second = static_cast<SocketOperation>(p.second | SocketOperationRead);
-        }
-        if(r->revents & (POLLOUT | POLLERR | POLLHUP))
-        {
-            p.second = static_cast<SocketOperation>(p.second | SocketOperationWrite);
-        }
-        assert(p.second);
-#endif
-        if(!p.first)
+#    endif
+        if (!p.first)
         {
             continue; // Interrupted
         }
 
-        map<EventHandlerPtr, SocketOperation>::iterator q = _readyHandlers.find(ICE_GET_SHARED_FROM_THIS(p.first));
+        auto q = _readyHandlers.find(p.first->shared_from_this());
 
-        if(q != _readyHandlers.end()) // Handler will be added by the loop below
+        if (q != _readyHandlers.end()) // Handler will be added by the loop below
         {
             q->second = p.second; // We just remember which operations are ready here.
         }
@@ -670,38 +528,38 @@ Selector::finishSelect(vector<pair<EventHandler*, SocketOperation> >& handlers)
         }
     }
 
-    for(map<EventHandlerPtr, SocketOperation>::iterator q = _readyHandlers.begin(); q != _readyHandlers.end(); ++q)
+    for (auto& readyHandler : _readyHandlers)
     {
         pair<EventHandler*, SocketOperation> p;
-        p.first = q->first.get();
+        p.first = readyHandler.first.get();
         p.second = static_cast<SocketOperation>(p.first->_ready & ~p.first->_disabled & p.first->_registered);
-        p.second = static_cast<SocketOperation>(p.second | q->second);
-        if(p.second)
+        p.second = static_cast<SocketOperation>(p.second | readyHandler.second);
+        if (p.second)
         {
             handlers.push_back(p);
         }
 
         //
-        // Reset the operation, it's only used by this method to temporarly store the socket status
+        // Reset the operation, it's only used by this method to temporarily store the socket status
         // return by the select operation above.
         //
-        q->second = SocketOperationNone;
+        readyHandler.second = SocketOperationNone;
     }
 }
 
 void
 Selector::select(int timeout)
 {
-    if(_selectNow)
+    if (_selectNow)
     {
         timeout = 0;
     }
-    else if(timeout > 0)
+    else if (timeout > 0)
     {
-// kpoll and select use seconds, epoll and poll use milliseconds
-#if !defined(ICE_USE_KQUEUE) && !defined(ICE_USE_SELECT)
-         timeout = timeout * 1000;
-#endif
+        // kqueue use seconds, epoll use milliseconds
+#    ifdef ICE_USE_EPOLL
+        timeout = timeout * 1000;
+#    endif
     }
     else
     {
@@ -709,68 +567,50 @@ Selector::select(int timeout)
     }
 
     int spuriousWakeup = 0;
-    while(true)
+    while (true)
     {
-#if defined(ICE_USE_EPOLL)
+#    if defined(ICE_USE_EPOLL)
         _count = epoll_wait(_queueFd, &_events[0], _events.size(), timeout);
-#elif defined(ICE_USE_KQUEUE)
+#    else // ICE_USE_KQUEUE
         assert(!_events.empty());
-        if(timeout >= 0)
+        if (timeout >= 0)
         {
-            struct timespec ts;
-            ts.tv_sec = timeout;
-            ts.tv_nsec = 0;
-            _count = kevent(_queueFd, 0, 0, &_events[0], static_cast<int>(_events.size()), &ts);
+            timespec ts{.tv_sec = timeout, .tv_nsec = 0};
+            _count = kevent(_queueFd, nullptr, 0, &_events[0], static_cast<int>(_events.size()), &ts);
         }
         else
         {
-            _count = kevent(_queueFd, 0, 0, &_events[0], static_cast<int>(_events.size()), 0);
+            _count = kevent(_queueFd, nullptr, 0, &_events[0], static_cast<int>(_events.size()), nullptr);
         }
-#elif defined(ICE_USE_SELECT)
-        fd_set* rFdSet = fdSetCopy(_selectedReadFdSet, _readFdSet);
-        fd_set* wFdSet = fdSetCopy(_selectedWriteFdSet, _writeFdSet);
-        fd_set* eFdSet = fdSetCopy(_selectedErrorFdSet, _errorFdSet);
-        if(timeout >= 0)
-        {
-            struct timeval tv;
-            tv.tv_sec = timeout;
-            tv.tv_usec = 0;
-            _count = ::select(0, rFdSet, wFdSet, eFdSet, &tv); // The first parameter is ignored on Windows
-        }
-        else
-        {
-            _count = ::select(0, rFdSet, wFdSet, eFdSet, 0); // The first parameter is ignored on Windows
-        }
-#else
-        _count = poll(&_pollFdSet[0], _pollFdSet.size(), timeout);
-#endif
+#    endif
 
-        if(_count == SOCKET_ERROR)
+        if (_count == SOCKET_ERROR)
         {
-            if(interrupted())
+            if (interrupted())
             {
                 continue;
             }
 
+            // This indicates a internal error with the selector, we log the error and abort.
             Ice::SocketException ex(__FILE__, __LINE__, IceInternal::getSocketErrno());
             Ice::Error out(_instance->initializationData().logger);
             out << "selector failed:\n" << ex;
-            IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(5)); // Sleep 5s to avoid looping
+            std::abort();
         }
-        else if(_count == 0 && timeout < 0)
+        else if (_count == 0 && timeout < 0)
         {
-            if(++spuriousWakeup > 100)
+            if (++spuriousWakeup > 100)
             {
                 spuriousWakeup = 0;
                 _instance->initializationData().logger->warning("spurious selector wakeup");
             }
-            IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1));
+            std::this_thread::sleep_for(1ms);
             continue;
         }
         break;
     }
 
-    if(_count == 0 && !_selectNow)
+    if (_count == 0 && !_selectNow)
     {
         throw SelectorTimeoutException();
     }
@@ -779,151 +619,65 @@ Selector::select(int timeout)
 void
 Selector::checkReady(EventHandler* handler)
 {
-    if(handler->_ready & ~handler->_disabled & handler->_registered)
+    if (handler->_ready & ~handler->_disabled & handler->_registered)
     {
-        _readyHandlers.insert(make_pair(ICE_GET_SHARED_FROM_THIS(handler), SocketOperationNone));
+        _readyHandlers.insert(make_pair(handler->shared_from_this(), SocketOperationNone));
         wakeup();
     }
     else
     {
-        map<EventHandlerPtr, SocketOperation>::iterator p = _readyHandlers.find(ICE_GET_SHARED_FROM_THIS(handler));
-        if(p != _readyHandlers.end())
+        auto p = _readyHandlers.find(handler->shared_from_this());
+        if (p != _readyHandlers.end())
         {
             _readyHandlers.erase(p);
         }
     }
 }
 
+#    if defined(ICE_USE_KQUEUE)
 void
 Selector::updateSelector()
 {
-#if defined(ICE_USE_KQUEUE)
-    int rs = kevent(_queueFd, &_changes[0], static_cast<int>(_changes.size()),
-                    &_changes[0], static_cast<int>(_changes.size()), &zeroTimeout);
-    if(rs < 0)
+    int rs = kevent(
+        _queueFd,
+        &_changes[0],
+        static_cast<int>(_changes.size()),
+        &_changes[0],
+        static_cast<int>(_changes.size()),
+        &zeroTimeout);
+    if (rs < 0)
     {
         Ice::Error out(_instance->initializationData().logger);
-        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+        out << "error while updating selector:\n" << IceInternal::errorToString(IceInternal::getSocketErrno());
     }
     else
     {
-        for(int i = 0; i < rs; ++i)
+        for (int i = 0; i < rs; ++i)
         {
             //
             // Check for errors, we ignore EINPROGRESS that started showing up with macOS Sierra
             // and which occurs when another thread removes the FD from the kqueue (see ICE-7419).
             //
-            if(_changes[static_cast<size_t>(i)].flags & EV_ERROR &&
-               _changes[static_cast<size_t>(i)].data != EINPROGRESS)
+            if (_changes[static_cast<size_t>(i)].flags & EV_ERROR &&
+                _changes[static_cast<size_t>(i)].data != EINPROGRESS)
             {
                 Ice::Error out(_instance->initializationData().logger);
                 out << "error while updating selector:\n"
-                    << IceUtilInternal::errorToString(static_cast<int>(_changes[static_cast<size_t>(i)].data));
-            }
-        }
-    }
-    _changes.clear();
-#elif !defined(ICE_USE_EPOLL)
-    assert(!_selecting);
-
-    for(vector<pair<EventHandler*, SocketOperation> >::const_iterator p = _changes.begin(); p != _changes.end(); ++p)
-    {
-        EventHandler* handler = p->first;
-        SocketOperation status = p->second;
-
-        SOCKET fd = handler->getNativeInfo()->fd();
-        if(status)
-        {
-#if defined(ICE_USE_SELECT)
-            if(status & SocketOperationRead)
-            {
-                FD_SET(fd, &_readFdSet);
-            }
-            else
-            {
-                FD_CLR(fd, &_readFdSet);
-            }
-            if(status & SocketOperationWrite)
-            {
-                FD_SET(fd, &_writeFdSet);
+                    << IceInternal::errorToString(static_cast<int>(_changes[static_cast<size_t>(i)].data));
             }
-            else
-            {
-                FD_CLR(fd, &_writeFdSet);
-            }
-            if(status & SocketOperationConnect)
-            {
-                FD_SET(fd, &_writeFdSet);
-                FD_SET(fd, &_errorFdSet);
-            }
-            else
-            {
-                FD_CLR(fd, &_writeFdSet);
-                FD_CLR(fd, &_errorFdSet);
-            }
-            _handlers[fd] = handler;
-#else
-            short events = 0;
-            if(status & SocketOperationRead)
-            {
-                events |= POLLIN;
-            }
-            if(status & SocketOperationWrite)
-            {
-                events |= POLLOUT;
-            }
-            map<SOCKET, EventHandler*>::const_iterator q = _handlers.find(fd);
-            if(q == _handlers.end())
-            {
-                struct pollfd pollFd;
-                pollFd.fd = fd;
-                pollFd.events = events;
-                pollFd.revents = 0;
-                _pollFdSet.push_back(pollFd);
-                _handlers.insert(make_pair(fd, handler));
-            }
-            else
-            {
-                for(vector<struct pollfd>::iterator r = _pollFdSet.begin(); r != _pollFdSet.end(); ++r)
-                {
-                    if(r->fd == fd)
-                    {
-                        r->events = events;
-                        break;
-                    }
-                }
-            }
-#endif
-        }
-        else
-        {
-#if defined(ICE_USE_SELECT)
-            FD_CLR(fd, &_readFdSet);
-            FD_CLR(fd, &_writeFdSet);
-            FD_CLR(fd, &_errorFdSet);
-#else
-            for(vector<struct pollfd>::iterator r = _pollFdSet.begin(); r != _pollFdSet.end(); ++r)
-            {
-                if(r->fd == fd)
-                {
-                    _pollFdSet.erase(r);
-                    break;
-                }
-            }
-#endif
-            _handlers.erase(fd);
         }
     }
     _changes.clear();
-#endif
 }
+#    endif
 
 void
-Selector::updateSelectorForEventHandler(EventHandler* handler,
-                                        ICE_MAYBE_UNUSED SocketOperation remove,
-                                        ICE_MAYBE_UNUSED SocketOperation add)
+Selector::updateSelectorForEventHandler(
+    EventHandler* handler,
+    [[maybe_unused]] SocketOperation remove,
+    [[maybe_unused]] SocketOperation add)
 {
-#if defined(ICE_USE_EPOLL)
+#    if defined(ICE_USE_EPOLL)
     SocketOperation previous = handler->_registered;
     previous = static_cast<SocketOperation>(previous & ~add);
     previous = static_cast<SocketOperation>(previous | remove);
@@ -933,29 +687,29 @@ Selector::updateSelectorForEventHandler(EventHandler* handler,
     memset(&event, 0, sizeof(epoll_event));
     event.data.ptr = handler;
     SocketOperation status = handler->_registered;
-    if(handler->_disabled)
+    if (handler->_disabled)
     {
         status = static_cast<SocketOperation>(status & ~handler->_disabled);
         previous = static_cast<SocketOperation>(previous & ~handler->_disabled);
     }
-    if(status & SocketOperationRead)
+    if (status & SocketOperationRead)
     {
         event.events |= EPOLLIN;
     }
-    if(status & SocketOperationWrite)
+    if (status & SocketOperationWrite)
     {
         event.events |= EPOLLOUT;
     }
     int op;
-    if(!previous && status)
+    if (!previous && status)
     {
         op = EPOLL_CTL_ADD;
     }
-    else if(previous && !status)
+    else if (previous && !status)
     {
         op = EPOLL_CTL_DEL;
     }
-    else if(previous == status)
+    else if (previous == status)
     {
         return;
     }
@@ -963,48 +717,57 @@ Selector::updateSelectorForEventHandler(EventHandler* handler,
     {
         op = EPOLL_CTL_MOD;
     }
-    if(epoll_ctl(_queueFd, op, fd, &event) != 0)
+    if (epoll_ctl(_queueFd, op, fd, &event) != 0)
     {
         Ice::Error out(_instance->initializationData().logger);
-        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+        out << "error while updating selector:\n" << IceInternal::errorToString(IceInternal::getSocketErrno());
     }
-#elif defined(ICE_USE_KQUEUE)
+#    else // ICE_USE_KQUEUE
     SOCKET fd = handler->getNativeInfo()->fd();
     assert(fd != INVALID_SOCKET);
-    if(remove & SocketOperationRead)
+    if (remove & SocketOperationRead)
     {
         struct kevent ev;
         EV_SET(&ev, fd, EVFILT_READ, EV_DELETE, 0, 0, handler);
         _changes.push_back(ev);
     }
-    if(remove & SocketOperationWrite)
+    if (remove & SocketOperationWrite)
     {
         struct kevent ev;
         EV_SET(&ev, fd, EVFILT_WRITE, EV_DELETE, 0, 0, handler);
         _changes.push_back(ev);
     }
-    if(add & SocketOperationRead)
+    if (add & SocketOperationRead)
     {
         struct kevent ev;
-        EV_SET(&ev, fd, EVFILT_READ, EV_ADD | (handler->_disabled & SocketOperationRead ? EV_DISABLE : 0), 0, 0,
-               handler);
+        EV_SET(
+            &ev,
+            fd,
+            EVFILT_READ,
+            EV_ADD | (handler->_disabled & SocketOperationRead ? EV_DISABLE : 0),
+            0,
+            0,
+            handler);
         _changes.push_back(ev);
     }
-    if(add & SocketOperationWrite)
+    if (add & SocketOperationWrite)
     {
         struct kevent ev;
-        EV_SET(&ev, fd, EVFILT_WRITE, EV_ADD | (handler->_disabled & SocketOperationWrite ? EV_DISABLE : 0), 0, 0,
-               handler);
+        EV_SET(
+            &ev,
+            fd,
+            EVFILT_WRITE,
+            EV_ADD | (handler->_disabled & SocketOperationWrite ? EV_DISABLE : 0),
+            0,
+            0,
+            handler);
         _changes.push_back(ev);
     }
-    if(_selecting)
+    if (_selecting)
     {
         updateSelector();
     }
-#else
-    _changes.push_back(make_pair(handler, static_cast<SocketOperation>(handler->_registered & ~handler->_disabled)));
-    wakeup();
-#endif
+#    endif
     checkReady(handler);
 }
 
@@ -1012,111 +775,78 @@ Selector::updateSelectorForEventHandler(EventHandler* handler,
 
 namespace
 {
+    void selectorInterrupt(void* info) { reinterpret_cast<Selector*>(info)->processInterrupt(); }
 
-void selectorInterrupt(void* info)
-{
-    reinterpret_cast<Selector*>(info)->processInterrupt();
-}
-
-void eventHandlerSocketCallback(CFSocketRef, CFSocketCallBackType callbackType, CFDataRef, const void* d, void* info)
-{
-    if(callbackType == kCFSocketReadCallBack)
-    {
-        reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationRead);
-    }
-    else if(callbackType == kCFSocketWriteCallBack)
-    {
-        reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationWrite);
-    }
-    else if(callbackType == kCFSocketConnectCallBack)
-    {
-        reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationConnect,
-                                                                    d ? *reinterpret_cast<const SInt32*>(d) : 0);
-    }
-}
-
-class SelectorHelperThread : public IceUtil::Thread
-{
-public:
-
-    SelectorHelperThread(Selector& selector) : _selector(selector)
-    {
-    }
-
-    virtual void run()
+    void
+    eventHandlerSocketCallback(CFSocketRef, CFSocketCallBackType callbackType, CFDataRef, const void* d, void* info)
     {
-        _selector.run();
-
-#if TARGET_IPHONE_SIMULATOR != 0
-        //
-        // Workaround for CFSocket bug where the CFSocketManager thread crashes if an
-        // invalidated socket is being processed for reads/writes. We add this sleep
-        // mostly to prevent spurious crashes with testing. This bug is very unlikely
-        // to be hit otherwise.
-        //
-        IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
-#endif
+        if (callbackType == kCFSocketReadCallBack)
+        {
+            reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationRead);
+        }
+        else if (callbackType == kCFSocketWriteCallBack)
+        {
+            reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationWrite);
+        }
+        else if (callbackType == kCFSocketConnectCallBack)
+        {
+            reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(
+                SocketOperationConnect,
+                d ? *reinterpret_cast<const SInt32*>(d) : 0);
+        }
     }
 
-private:
-
-    Selector& _selector;
-};
-
-CFOptionFlags
-toCFCallbacks(SocketOperation op)
-{
-    CFOptionFlags cbs = 0;
-    if(op & SocketOperationRead)
+    CFOptionFlags toCFCallbacks(SocketOperation op)
     {
-        cbs |= kCFSocketReadCallBack;
-    }
-    if(op & SocketOperationWrite)
-    {
-        cbs |= kCFSocketWriteCallBack;
-    }
-    if(op & SocketOperationConnect)
-    {
-        cbs |= kCFSocketConnectCallBack;
+        CFOptionFlags cbs = 0;
+        if (op & SocketOperationRead)
+        {
+            cbs |= kCFSocketReadCallBack;
+        }
+        if (op & SocketOperationWrite)
+        {
+            cbs |= kCFSocketWriteCallBack;
+        }
+        if (op & SocketOperationConnect)
+        {
+            cbs |= kCFSocketConnectCallBack;
+        }
+        return cbs;
     }
-    return cbs;
 }
 
-}
-
-EventHandlerWrapper::EventHandlerWrapper(EventHandler* handler, Selector& selector) :
-    _handler(ICE_GET_SHARED_FROM_THIS(handler)),
-    _streamNativeInfo(StreamNativeInfoPtr::dynamicCast(handler->getNativeInfo())),
-    _selector(selector),
-    _ready(SocketOperationNone),
-    _finish(false)
+EventHandlerWrapper::EventHandlerWrapper(EventHandler* handler, Selector& selector)
+    : _handler(handler->shared_from_this()),
+      _streamNativeInfo(dynamic_pointer_cast<StreamNativeInfo>(handler->getNativeInfo())),
+      _selector(selector),
+      _ready(SocketOperationNone),
+      _finish(false)
 {
-    if(_streamNativeInfo)
+    if (_streamNativeInfo)
     {
         _streamNativeInfo->initStreams(this);
     }
-    else if(handler->getNativeInfo())
+    else if (handler->getNativeInfo())
     {
         SOCKET fd = handler->getNativeInfo()->fd();
-        CFSocketContext ctx = { 0, this, 0, 0, 0 };
-        _socket.reset(CFSocketCreateWithNative(kCFAllocatorDefault,
-                                               fd,
-                                               kCFSocketReadCallBack |
-                                               kCFSocketWriteCallBack |
-                                               kCFSocketConnectCallBack,
-                                               eventHandlerSocketCallback,
-                                               &ctx));
+        CFSocketContext ctx = {0, this, 0, 0, 0};
+        _socket.reset(CFSocketCreateWithNative(
+            kCFAllocatorDefault,
+            fd,
+            kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack,
+            eventHandlerSocketCallback,
+            &ctx));
 
         // Disable automatic re-enabling of callbacks and closing of the native socket.
         CFSocketSetSocketFlags(_socket.get(), 0);
-        CFSocketDisableCallBacks(_socket.get(), kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack);
+        CFSocketDisableCallBacks(
+            _socket.get(),
+            kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack);
         _source.reset(CFSocketCreateRunLoopSource(kCFAllocatorDefault, _socket.get(), 0));
     }
 }
 
-EventHandlerWrapper::~EventHandlerWrapper()
-{
-}
+EventHandlerWrapper::~EventHandlerWrapper() = default;
 
 void
 EventHandlerWrapper::updateRunLoop()
@@ -1124,24 +854,26 @@ EventHandlerWrapper::updateRunLoop()
     SocketOperation op = _handler->_registered;
     assert(!op || !_finish);
 
-    if(_socket)
+    if (_socket)
     {
-        CFSocketDisableCallBacks(_socket.get(), kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack);
-        if(op)
+        CFSocketDisableCallBacks(
+            _socket.get(),
+            kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack);
+        if (op)
         {
             CFSocketEnableCallBacks(_socket.get(), toCFCallbacks(op));
         }
 
-        if(op && !CFRunLoopContainsSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode))
+        if (op && !CFRunLoopContainsSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode))
         {
             CFRunLoopAddSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode);
         }
-        else if(!op && CFRunLoopContainsSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode))
+        else if (!op && CFRunLoopContainsSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode))
         {
             CFRunLoopRemoveSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode);
         }
 
-        if(_finish)
+        if (_finish)
         {
             CFSocketInvalidate(_socket.get());
         }
@@ -1149,22 +881,22 @@ EventHandlerWrapper::updateRunLoop()
     else
     {
         SocketOperation readyOp = _streamNativeInfo->registerWithRunLoop(op);
-        if(!(op & (SocketOperationWrite | SocketOperationConnect)) || _ready & SocketOperationWrite)
+        if (!(op & (SocketOperationWrite | SocketOperationConnect)) || _ready & SocketOperationWrite)
         {
             _streamNativeInfo->unregisterFromRunLoop(SocketOperationWrite, false);
         }
 
-        if(!(op & (SocketOperationRead | SocketOperationConnect)) || _ready & SocketOperationRead)
+        if (!(op & (SocketOperationRead | SocketOperationConnect)) || _ready & SocketOperationRead)
         {
             _streamNativeInfo->unregisterFromRunLoop(SocketOperationRead, false);
         }
 
-        if(readyOp)
+        if (readyOp)
         {
             ready(readyOp, 0);
         }
 
-        if(_finish)
+        if (_finish)
         {
             _streamNativeInfo->closeStreams();
         }
@@ -1180,7 +912,7 @@ EventHandlerWrapper::readyCallback(SocketOperation op, int error)
 void
 EventHandlerWrapper::ready(SocketOperation op, int error)
 {
-    if(!_socket)
+    if (!_socket)
     {
         //
         // Unregister the stream from the runloop as soon as we got the callback. This is
@@ -1192,14 +924,14 @@ EventHandlerWrapper::ready(SocketOperation op, int error)
     }
 
     op = static_cast<SocketOperation>(_handler->_registered & op);
-    if(!op || _ready & op)
+    if (!op || _ready & op)
     {
         return;
     }
 
-    if(_socket)
+    if (_socket)
     {
-        if(op & SocketOperationConnect)
+        if (op & SocketOperationConnect)
         {
             _streamNativeInfo->setConnectError(error);
         }
@@ -1212,9 +944,9 @@ EventHandlerWrapper::ready(SocketOperation op, int error)
 bool
 EventHandlerWrapper::checkReady()
 {
-    if((_ready | _handler->_ready) & ~_handler->_disabled & _handler->_registered)
+    if ((_ready | _handler->_ready) & ~_handler->_disabled & _handler->_registered)
     {
-        _selector.addReadyHandler(this);
+        _selector.addReadyHandler(shared_from_this());
         return false;
     }
     else
@@ -1238,14 +970,14 @@ EventHandlerWrapper::update(SocketOperation remove, SocketOperation add)
     SocketOperation previous = _handler->_registered;
     _handler->_registered = static_cast<SocketOperation>(_handler->_registered & ~remove);
     _handler->_registered = static_cast<SocketOperation>(_handler->_registered | add);
-    if(previous == _handler->_registered)
+    if (previous == _handler->_registered)
     {
         return false;
     }
 
     // Clear ready flags which might not be valid anymore.
     _ready = static_cast<SocketOperation>(_ready & _handler->_registered);
-    return _handler->getNativeInfo();
+    return _handler->getNativeInfo() != nullptr;
 }
 
 bool
@@ -1254,7 +986,7 @@ EventHandlerWrapper::finish()
     _finish = true;
     _ready = SocketOperationNone;
     _handler->_registered = SocketOperationNone;
-    return _handler->getNativeInfo();
+    return _handler->getNativeInfo() != nullptr;
 }
 
 Selector::Selector(const InstancePtr& instance) : _instance(instance), _destroyed(false)
@@ -1266,25 +998,32 @@ Selector::Selector(const InstancePtr& instance) : _instance(instance), _destroye
     _source.reset(CFRunLoopSourceCreate(0, 0, &ctx));
     _runLoop = 0;
 
-    _thread = new SelectorHelperThread(*this);
-    _thread->start();
+    _thread = std::thread(
+        [this]
+        {
+            run();
 
-    Lock sync(*this);
-    while(!_runLoop)
-    {
-        wait();
-    }
-}
+#    if TARGET_IPHONE_SIMULATOR != 0
+            //
+            // Workaround for CFSocket bug where the CFSocketManager thread crashes if an
+            // invalidated socket is being processed for reads/writes. We add this sleep
+            // mostly to prevent spurious crashes with testing. This bug is very unlikely
+            // to be hit otherwise.
+            //
+            this_thread::sleep_for(100ms);
+#    endif
+        });
 
-Selector::~Selector()
-{
+    unique_lock lock(_mutex);
+    _conditionVariable.wait(lock, [this] { return _runLoop != 0; });
 }
 
 void
 Selector::destroy()
 {
+    thread t;
     {
-        Lock sync(*this);
+        unique_lock lock(_mutex);
 
         //
         // Make sure any pending changes are processed to ensure remaining
@@ -1294,22 +1033,24 @@ Selector::destroy()
         CFRunLoopSourceSignal(_source.get());
         CFRunLoopWakeUp(_runLoop);
 
-        while(!_changes.empty())
+        while (!_changes.empty())
         {
             CFRunLoopSourceSignal(_source.get());
             CFRunLoopWakeUp(_runLoop);
-
-            wait();
+            _conditionVariable.wait(lock);
         }
+        t = std::move(_thread);
     }
 
-    _thread->getThreadControl().join();
-    _thread = 0;
+    if (t.joinable())
+    {
+        t.join();
+    }
 
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     _source.reset(0);
 
-    //assert(_wrappers.empty());
+    // assert(_wrappers.empty());
     _readyHandlers.clear();
     _selectedHandlers.clear();
 }
@@ -1317,33 +1058,33 @@ Selector::destroy()
 void
 Selector::initialize(EventHandler* handler)
 {
-    Lock sync(*this);
-    _wrappers[handler] = new EventHandlerWrapper(handler, *this);
+    lock_guard lock(_mutex);
+    _wrappers[handler] = make_shared<EventHandlerWrapper>(handler, *this);
 }
 
 void
 Selector::update(EventHandler* handler, SocketOperation remove, SocketOperation add)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     const EventHandlerWrapperPtr& wrapper = _wrappers[handler];
-    if(wrapper->update(remove, add))
+    if (wrapper->update(remove, add))
     {
         _changes.insert(wrapper);
-        notify();
+        _conditionVariable.notify_one();
     }
 }
 
 void
 Selector::enable(EventHandler* handler, SocketOperation op)
 {
-    Lock sync(*this);
-    if(!(handler->_disabled & op))
+    lock_guard lock(_mutex);
+    if (!(handler->_disabled & op))
     {
         return;
     }
     handler->_disabled = static_cast<SocketOperation>(handler->_disabled & ~op);
 
-    if(handler->_registered & op)
+    if (handler->_registered & op)
     {
         _wrappers[handler]->checkReady();
     }
@@ -1352,8 +1093,8 @@ Selector::enable(EventHandler* handler, SocketOperation op)
 void
 Selector::disable(EventHandler* handler, SocketOperation op)
 {
-    Lock sync(*this);
-    if(handler->_disabled & op)
+    lock_guard lock(_mutex);
+    if (handler->_disabled & op)
     {
         return;
     }
@@ -1363,14 +1104,14 @@ Selector::disable(EventHandler* handler, SocketOperation op)
 bool
 Selector::finish(EventHandler* handler, bool closeNow)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     std::map<EventHandler*, EventHandlerWrapperPtr>::iterator p = _wrappers.find(handler);
     assert(p != _wrappers.end());
     EventHandlerWrapperPtr wrapper = p->second;
-    if(wrapper->finish())
+    if (wrapper->finish())
     {
         _changes.insert(wrapper);
-        notify();
+        _conditionVariable.notify_one();
     }
     _wrappers.erase(p);
     return closeNow;
@@ -1379,12 +1120,12 @@ Selector::finish(EventHandler* handler, bool closeNow)
 void
 Selector::ready(EventHandler* handler, SocketOperation status, bool value)
 {
-    if(((handler->_ready & status) != 0) == value)
+    if (((handler->_ready & status) != 0) == value)
     {
         return; // Nothing to do if ready state already correctly set.
     }
 
-    if(value)
+    if (value)
     {
         handler->_ready = static_cast<SocketOperation>(handler->_ready | status);
     }
@@ -1393,7 +1134,7 @@ Selector::ready(EventHandler* handler, SocketOperation status, bool value)
         handler->_ready = static_cast<SocketOperation>(handler->_ready & ~status);
     }
 
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     std::map<EventHandler*, EventHandlerWrapperPtr>::iterator p = _wrappers.find(handler);
     assert(p != _wrappers.end());
     p->second->checkReady();
@@ -1402,15 +1143,15 @@ Selector::ready(EventHandler* handler, SocketOperation status, bool value)
 void
 Selector::startSelect()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
     //
     // Re-enable callbacks for previously selected handlers.
     //
-    vector<pair<EventHandlerWrapperPtr, SocketOperation> >::const_iterator p;
-    for(p = _selectedHandlers.begin(); p != _selectedHandlers.end(); ++p)
+    vector<pair<EventHandlerWrapperPtr, SocketOperation>>::const_iterator p;
+    for (p = _selectedHandlers.begin(); p != _selectedHandlers.end(); ++p)
     {
-        if(p->first->checkReady())
+        if (p->first->checkReady())
         {
             _changes.insert(p->first);
         }
@@ -1419,14 +1160,14 @@ Selector::startSelect()
 }
 
 void
-Selector::finishSelect(std::vector<std::pair<EventHandler*, SocketOperation> >& handlers)
+Selector::finishSelect(std::vector<std::pair<EventHandler*, SocketOperation>>& handlers)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     handlers.clear();
-    for(set<EventHandlerWrapperPtr>::const_iterator p = _readyHandlers.begin(); p != _readyHandlers.end(); ++p)
+    for (set<EventHandlerWrapperPtr>::const_iterator p = _readyHandlers.begin(); p != _readyHandlers.end(); ++p)
     {
         SocketOperation op = (*p)->readyOp();
-        if(op)
+        if (op)
         {
             _selectedHandlers.push_back(pair<EventHandlerWrapperPtr, SocketOperation>(*p, op));
             handlers.push_back(pair<EventHandler*, SocketOperation>((*p)->_handler.get(), op));
@@ -1441,40 +1182,34 @@ Selector::select(int timeout)
     //
     // Wait for handlers to be ready.
     //
-    Lock sync(*this);
-    while(!_destroyed)
+    unique_lock lock(_mutex);
+    while (!_destroyed)
     {
-        while(!_changes.empty())
+        while (!_changes.empty())
         {
             CFRunLoopSourceSignal(_source.get());
             CFRunLoopWakeUp(_runLoop);
 
-            wait();
+            _conditionVariable.wait(lock);
         }
 
-        if(_readyHandlers.empty())
+        if (_readyHandlers.empty())
         {
-            if(timeout > 0)
+            if (timeout > 0)
             {
-                bool timedOut = !timedWait(IceUtil::Time::seconds(timeout));
-                if(_readyHandlers.empty())
+                if (_conditionVariable.wait_for(lock, chrono::seconds(timeout)) == cv_status::no_timeout)
                 {
-                    if(timedOut)
-                    {
-                        throw SelectorTimeoutException(); // Actual timeout
-                    }
-                    // Signaled but no ready handlers - spurious wakeup, continue waiting
-                    continue;
+                    break;
                 }
-                break; // Ready handlers
+                throw SelectorTimeoutException();
             }
             else
             {
-                wait();
+                _conditionVariable.wait(lock);
             }
         }
 
-        if(_changes.empty())
+        if (_changes.empty())
         {
             break;
         }
@@ -1484,17 +1219,17 @@ Selector::select(int timeout)
 void
 Selector::processInterrupt()
 {
-    Lock sync(*this);
-    if(!_changes.empty())
+    lock_guard lock(_mutex);
+    if (!_changes.empty())
     {
-        for(set<EventHandlerWrapperPtr>::const_iterator p = _changes.begin(); p != _changes.end(); ++p)
+        for (set<EventHandlerWrapperPtr>::const_iterator p = _changes.begin(); p != _changes.end(); ++p)
         {
             (*p)->updateRunLoop();
         }
         _changes.clear();
-        notify();
+        _conditionVariable.notify_one();
     }
-    if(_destroyed)
+    if (_destroyed)
     {
         CFRunLoopStop(_runLoop);
     }
@@ -1504,9 +1239,9 @@ void
 Selector::run()
 {
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         _runLoop = CFRunLoopGetCurrent();
-        notify();
+        _conditionVariable.notify_one();
     }
 
     CFRunLoopAddSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode);
@@ -1517,18 +1252,18 @@ Selector::run()
 void
 Selector::ready(EventHandlerWrapper* wrapper, SocketOperation op, int error)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     wrapper->ready(op, error);
 }
 
 void
-Selector::addReadyHandler(EventHandlerWrapper* wrapper)
+Selector::addReadyHandler(EventHandlerWrapperPtr wrapper)
 {
     // Called from ready()
     _readyHandlers.insert(wrapper);
-    if(_readyHandlers.size() == 1)
+    if (_readyHandlers.size() == 1)
     {
-        notify();
+        _conditionVariable.notify_one();
     }
 }