diff --git a/src/sync.h b/src/sync.h
index d2fa35c03..eb2e498ef 100644
--- a/src/sync.h
+++ b/src/sync.h
@@ -1,280 +1,280 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SYNC_H
 #define BITCOIN_SYNC_H
 
 #include "threadsafety.h"
 
 #include <condition_variable>
 #include <mutex>
 #include <thread>
 
 /////////////////////////////////////////////////
 //                                             //
 // THE SIMPLE DEFINITION, EXCLUDING DEBUG CODE //
 //                                             //
 /////////////////////////////////////////////////
 
 /*
 CCriticalSection mutex;
     std::recursive_mutex mutex;
 
 LOCK(mutex);
     std::unique_lock<std::recursive_mutex> criticalblock(mutex);
 
 LOCK2(mutex1, mutex2);
     std::unique_lock<std::recursive_mutex> criticalblock1(mutex1);
     std::unique_lock<std::recursive_mutex> criticalblock2(mutex2);
 
 TRY_LOCK(mutex, name);
     std::unique_lock<std::recursive_mutex> name(mutex, std::try_to_lock_t);
 
 ENTER_CRITICAL_SECTION(mutex); // no RAII
     mutex.lock();
 
 LEAVE_CRITICAL_SECTION(mutex); // no RAII
     mutex.unlock();
  */
 
 ///////////////////////////////
 //                           //
 // THE ACTUAL IMPLEMENTATION //
 //                           //
 ///////////////////////////////
 
 #ifdef DEBUG_LOCKORDER
 void EnterCritical(const char *pszName, const char *pszFile, int nLine,
                    void *cs, bool fTry = false);
 void LeaveCritical();
 std::string LocksHeld();
 void AssertLockHeldInternal(const char *pszName, const char *pszFile, int nLine,
                             void *cs) ASSERT_EXCLUSIVE_LOCK(cs);
 void AssertLockNotHeldInternal(const char *pszName, const char *pszFile,
                                int nLine, void *cs);
 void DeleteLock(void *cs);
 
 /**
  * Call abort() if a potential lock order deadlock bug is detected, instead of
  * just logging information and throwing a logic_error. Defaults to true, and
  * set to false in DEBUG_LOCKORDER unit tests.
  */
 extern bool g_debug_lockorder_abort;
 #else
 static inline void EnterCritical(const char *pszName, const char *pszFile,
                                  int nLine, void *cs, bool fTry = false) {}
 static inline void LeaveCritical() {}
 static inline void AssertLockHeldInternal(const char *pszName,
                                           const char *pszFile, int nLine,
                                           void *cs) ASSERT_EXCLUSIVE_LOCK(cs) {}
 static inline void AssertLockNotHeldInternal(const char *pszName,
                                              const char *pszFile, int nLine,
                                              void *cs) {}
 static inline void DeleteLock(void *cs) {}
 #endif
 #define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
 #define AssertLockNotHeld(cs)                                                  \
     AssertLockNotHeldInternal(#cs, __FILE__, __LINE__, &cs)
 
 /**
  * Template mixin that adds -Wthread-safety locking annotations and lock order
  * checking to a subset of the mutex API.
  */
 template <typename PARENT> class LOCKABLE AnnotatedMixin : public PARENT {
 public:
     ~AnnotatedMixin() { DeleteLock((void *)this); }
 
     void lock() EXCLUSIVE_LOCK_FUNCTION() { PARENT::lock(); }
 
     void unlock() UNLOCK_FUNCTION() { PARENT::unlock(); }
 
     bool try_lock() EXCLUSIVE_TRYLOCK_FUNCTION(true) {
         return PARENT::try_lock();
     }
 
     using UniqueLock = std::unique_lock<PARENT>;
 };
 
 /**
  * Wrapped mutex: supports recursive locking, but no waiting
  * TODO: We should move away from using the recursive lock by default.
  */
 typedef AnnotatedMixin<std::recursive_mutex> CCriticalSection;
 
 /** Wrapped mutex: supports waiting but not recursive locking */
 typedef AnnotatedMixin<std::mutex> CWaitableCriticalSection;
 
 /**
  * Just a typedef for std::condition_variable, can be wrapped later if desired.
  */
 typedef std::condition_variable CConditionVariable;
 
 #ifdef DEBUG_LOCKCONTENTION
 void PrintLockContention(const char *pszName, const char *pszFile, int nLine);
 #endif
 
 /** Wrapper around std::unique_lock style lock for Mutex. */
 template <typename Mutex, typename Base = typename Mutex::UniqueLock>
 class SCOPED_LOCKABLE CCriticalBlock : public Base {
 private:
     void Enter(const char *pszName, const char *pszFile, int nLine) {
         EnterCritical(pszName, pszFile, nLine, (void *)(Base::mutex()));
 #ifdef DEBUG_LOCKCONTENTION
         if (!Base::try_lock()) {
             PrintLockContention(pszName, pszFile, nLine);
 #endif
             Base::lock();
 #ifdef DEBUG_LOCKCONTENTION
         }
 #endif
     }
 
     bool TryEnter(const char *pszName, const char *pszFile, int nLine) {
         EnterCritical(pszName, pszFile, nLine, (void *)(Base::mutex()), true);
         Base::try_lock();
         if (!Base::owns_lock()) LeaveCritical();
         return Base::owns_lock();
     }
 
 public:
     CCriticalBlock(Mutex &mutexIn, const char *pszName, const char *pszFile,
                    int nLine, bool fTry = false)
         EXCLUSIVE_LOCK_FUNCTION(mutexIn)
         : Base(mutexIn, std::defer_lock) {
         if (fTry)
             TryEnter(pszName, pszFile, nLine);
         else
             Enter(pszName, pszFile, nLine);
     }
 
     CCriticalBlock(Mutex *pmutexIn, const char *pszName, const char *pszFile,
                    int nLine, bool fTry = false)
         EXCLUSIVE_LOCK_FUNCTION(pmutexIn) {
         if (!pmutexIn) return;
 
         *static_cast<Base *>(this) = Base(*pmutexIn, std::defer_lock);
         if (fTry)
             TryEnter(pszName, pszFile, nLine);
         else
             Enter(pszName, pszFile, nLine);
     }
 
     ~CCriticalBlock() UNLOCK_FUNCTION() {
         if (Base::owns_lock()) LeaveCritical();
     }
 
     operator bool() { return Base::owns_lock(); }
 };
 
 template <typename MutexArg>
 using DebugLock = CCriticalBlock<typename std::remove_reference<
     typename std::remove_pointer<MutexArg>::type>::type>;
 
 #define PASTE(x, y) x##y
 #define PASTE2(x, y) PASTE(x, y)
 
 #define LOCK(cs)                                                               \
     DebugLock<decltype(cs)> PASTE2(criticalblock,                              \
                                    __COUNTER__)(cs, #cs, __FILE__, __LINE__)
 #define LOCK2(cs1, cs2)                                                        \
     DebugLock<decltype(cs1)> criticalblock1(cs1, #cs1, __FILE__, __LINE__);    \
     DebugLock<decltype(cs2)> criticalblock2(cs2, #cs2, __FILE__, __LINE__);
 #define TRY_LOCK(cs, name)                                                     \
     DebugLock<decltype(cs)> name(cs, #cs, __FILE__, __LINE__, true)
 #define WAIT_LOCK(cs, name)                                                    \
     DebugLock<decltype(cs)> name(cs, #cs, __FILE__, __LINE__)
 
 #define ENTER_CRITICAL_SECTION(cs)                                             \
     {                                                                          \
         EnterCritical(#cs, __FILE__, __LINE__, (void *)(&cs));                 \
         (cs).lock();                                                           \
     }
 
 #define LEAVE_CRITICAL_SECTION(cs)                                             \
     {                                                                          \
         (cs).unlock();                                                         \
         LeaveCritical();                                                       \
     }
 
 class CSemaphore {
 private:
     std::condition_variable condition;
     std::mutex mutex;
     int value;
 
 public:
-    CSemaphore(int init) : value(init) {}
+    explicit CSemaphore(int init) : value(init) {}
 
     void wait() {
         std::unique_lock<std::mutex> lock(mutex);
         condition.wait(lock, [&]() { return value >= 1; });
         value--;
     }
 
     bool try_wait() {
         std::lock_guard<std::mutex> lock(mutex);
         if (value < 1) {
             return false;
         }
         value--;
         return true;
     }
 
     void post() {
         {
             std::lock_guard<std::mutex> lock(mutex);
             value++;
         }
         condition.notify_one();
     }
 };
 
 /** RAII-style semaphore lock */
 class CSemaphoreGrant {
 private:
     CSemaphore *sem;
     bool fHaveGrant;
 
 public:
     void Acquire() {
         if (fHaveGrant) return;
         sem->wait();
         fHaveGrant = true;
     }
 
     void Release() {
         if (!fHaveGrant) return;
         sem->post();
         fHaveGrant = false;
     }
 
     bool TryAcquire() {
         if (!fHaveGrant && sem->try_wait()) fHaveGrant = true;
         return fHaveGrant;
     }
 
     void MoveTo(CSemaphoreGrant &grant) {
         grant.Release();
         grant.sem = sem;
         grant.fHaveGrant = fHaveGrant;
         fHaveGrant = false;
     }
 
     CSemaphoreGrant() : sem(nullptr), fHaveGrant(false) {}
 
-    CSemaphoreGrant(CSemaphore &sema, bool fTry = false)
+    explicit CSemaphoreGrant(CSemaphore &sema, bool fTry = false)
         : sem(&sema), fHaveGrant(false) {
         if (fTry)
             TryAcquire();
         else
             Acquire();
     }
 
     ~CSemaphoreGrant() { Release(); }
 
-    operator bool() { return fHaveGrant; }
+    operator bool() const { return fHaveGrant; }
 };
 
 #endif // BITCOIN_SYNC_H