During some lock debugging on a dual-core Linux system I noticed that threads are blocked acquiring `cs_vNodes` and `cs_main` for long periods when the system is under moderate load from unrelated processes -- the unlucky lock acquirer is waiting for single-digit seconds once every 10 minutes or so (not coinciding with new blocks) up to around a 30 second wait every few hours. It looks like `ThreadMessageHandler` is taking locks and then due to being set to `THREAD_PRIORITY_BELOW_NORMAL`, it's being descheduled (even in trivial lock-holding regions like `GetHeight`) and holding up for arbitrarily long periods other threads that use these core locks.

So I'm wondering, what are the benefits of running the message handler at low priority?

messageHandlerCondition.notify_one();
        }
    }
    return true;
}
int CNetMessage::readHeader(const char *pch, unsigned int nBytes)
{
    
    unsigned int nRemaining = 24 - nHdrPos;
    unsigned int nCopy = std::min(nRemaining, nBytes);
    memcpy(&hdrbuf[nHdrPos], pch, nCopy);
    nHdrPos += nCopy;
    
    if (nHdrPos < 24)
        return nCopy;
    
    try {
        hdrbuf >> hdr;
    }
    catch (const std::exception&) {
        return -1;
    }
    
    if (hdr.nMessageSize > MAX_SIZE)
            return -1;
    
    in_data = true;
    return nCopy;
}
int CNetMessage::readData(const char *pch, unsigned int nBytes)