STYLE: Rename private and internal data members from "Lock" to "Mutex"

N-Dekker · dzenanz · commit 0150e4692408 · 2023-09-19T11:47:55.000-04:00
Replaced the word "Lock" with "Mutex", in the identifier of private and internal member variables that are declared as `std::mutex`: MersenneTwisterRandomVariateGenerator::m_InstanceLock FFTWGlobalConfiguration::m_Lock FFTWGlobalConfigurationGlobals::m_CreationLock FEMFactoryBase::m_CreationLock m_MetricCalculationLock (from RegistrationFunction classes) MultiThreaderBaseGlobals::globalDefaultInitializerLock PlatformMultiThreader::m_SpawnedThreadActiveFlagLock ioDefaultSplitterLock createImageIOLock Follow-up to commit d0a8534 "ENH: using standard library's mutex primitives", Dženan Zukić, October 31, 2018.
diff --git a/Modules/Core/Common/include/itkMersenneTwisterRandomVariateGenerator.h b/Modules/Core/Common/include/itkMersenneTwisterRandomVariateGenerator.h
@@ -324,7 +324,7 @@ class ITKCommon_EXPORT MersenneTwisterRandomVariateGenerator : public RandomVari
   CreateInstance();
 
   // Local lock to enable concurrent access to singleton
-  std::mutex m_InstanceLock{};
+  std::mutex m_InstanceMutex{};
 
   // Static/Global Variable need to be thread-safely accessed
 
@@ -337,7 +337,7 @@ class ITKCommon_EXPORT MersenneTwisterRandomVariateGenerator : public RandomVari
 inline void
 MersenneTwisterRandomVariateGenerator::Initialize(const IntegerType seed)
 {
-  const std::lock_guard<std::mutex> mutexHolder(m_InstanceLock);
+  const std::lock_guard<std::mutex> mutexHolder(m_InstanceMutex);
   this->m_Seed = seed;
   // Initialize generator state with seed
   // See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
diff --git a/Modules/Core/Common/include/itkPlatformMultiThreader.h b/Modules/Core/Common/include/itkPlatformMultiThreader.h
@@ -162,7 +162,7 @@ class ITKCommon_EXPORT PlatformMultiThreader : public MultiThreaderBase
   /** Storage of MutexFunctions and ints used to control spawned
    *  threads and the spawned thread ids. */
   int                         m_SpawnedThreadActiveFlag[ITK_MAX_THREADS]{};
-  std::shared_ptr<std::mutex> m_SpawnedThreadActiveFlagLock[ITK_MAX_THREADS]{};
+  std::shared_ptr<std::mutex> m_SpawnedThreadActiveFlagMutex[ITK_MAX_THREADS]{};
   ThreadProcessIdType         m_SpawnedThreadProcessID[ITK_MAX_THREADS]{};
   WorkUnitInfo                m_SpawnedThreadInfoArray[ITK_MAX_THREADS]{};
 
diff --git a/Modules/Core/Common/src/itkMultiThreaderBase.cxx b/Modules/Core/Common/src/itkMultiThreaderBase.cxx
@@ -67,7 +67,7 @@ struct MultiThreaderBaseGlobals
   // API is ever used by the developer, the developers choice is
   // respected over the environmental variable.
   bool       GlobalDefaultThreaderTypeIsInitialized{ false };
-  std::mutex globalDefaultInitializerLock;
+  std::mutex globalDefaultInitializerMutex;
 
   // Global value to control which threader to be used by default. First it is initialized with the default preprocessor
   // definition from CMake configuration value, for compile time control of default. This initial value can be
@@ -114,7 +114,7 @@ MultiThreaderBase::GetGlobalDefaultUseThreadPool()
 void
 MultiThreaderBase::SetGlobalDefaultThreaderPrivate(ThreaderEnum threaderType)
 {
-  // m_PimplGlobals->globalDefaultInitializerLock must be already held here!
+  // m_PimplGlobals->globalDefaultInitializerMutex must be already held here!
 
   m_PimplGlobals->m_GlobalDefaultThreader = threaderType;
   m_PimplGlobals->GlobalDefaultThreaderTypeIsInitialized = true;
@@ -126,15 +126,15 @@ MultiThreaderBase::SetGlobalDefaultThreader(ThreaderEnum threaderType)
   itkInitGlobalsMacro(PimplGlobals);
 
   // Acquire mutex then call private method to do the real work.
-  const std::lock_guard<std::mutex> lock(m_PimplGlobals->globalDefaultInitializerLock);
+  const std::lock_guard<std::mutex> lock(m_PimplGlobals->globalDefaultInitializerMutex);
 
   MultiThreaderBase::SetGlobalDefaultThreaderPrivate(threaderType);
 }
 
 MultiThreaderBase::ThreaderEnum
 MultiThreaderBase::GetGlobalDefaultThreaderPrivate()
 {
-  // m_PimplGlobals->globalDefaultInitializerLock must be already held here!
+  // m_PimplGlobals->globalDefaultInitializerMutex must be already held here!
 
   if (!m_PimplGlobals->GlobalDefaultThreaderTypeIsInitialized)
   {
@@ -182,7 +182,7 @@ MultiThreaderBase::GetGlobalDefaultThreader()
   itkInitGlobalsMacro(PimplGlobals);
 
   // Acquire mutex then call private method to do the real work.
-  const std::lock_guard<std::mutex> lock(m_PimplGlobals->globalDefaultInitializerLock);
+  const std::lock_guard<std::mutex> lock(m_PimplGlobals->globalDefaultInitializerMutex);
 
   return MultiThreaderBase::GetGlobalDefaultThreaderPrivate();
 }
@@ -233,7 +233,7 @@ MultiThreaderBase::SetGlobalDefaultNumberOfThreads(ThreadIdType val)
 {
   itkInitGlobalsMacro(PimplGlobals);
 
-  const std::lock_guard<std::mutex> lock(m_PimplGlobals->globalDefaultInitializerLock);
+  const std::lock_guard<std::mutex> lock(m_PimplGlobals->globalDefaultInitializerMutex);
 
   m_PimplGlobals->m_GlobalDefaultNumberOfThreads =
     std::clamp<ThreadIdType>(val, 1, m_PimplGlobals->m_GlobalMaximumNumberOfThreads);
@@ -263,7 +263,7 @@ MultiThreaderBase::GetGlobalDefaultNumberOfThreads()
 {
   itkInitGlobalsMacro(PimplGlobals);
 
-  const std::lock_guard<std::mutex> lock(m_PimplGlobals->globalDefaultInitializerLock);
+  const std::lock_guard<std::mutex> lock(m_PimplGlobals->globalDefaultInitializerMutex);
 
   if (m_PimplGlobals->m_GlobalDefaultNumberOfThreads == 0) // need to initialize
   {
diff --git a/Modules/Core/Common/src/itkPlatformMultiThreader.cxx b/Modules/Core/Common/src/itkPlatformMultiThreader.cxx
@@ -57,7 +57,7 @@ PlatformMultiThreader::PlatformMultiThreader()
 #endif
 
     m_SpawnedThreadActiveFlag[i] = 0;
-    m_SpawnedThreadActiveFlagLock[i] = nullptr;
+    m_SpawnedThreadActiveFlagMutex[i] = nullptr;
     m_SpawnedThreadInfoArray[i].WorkUnitID = i;
   }
 }
diff --git a/Modules/Core/Common/src/itkPlatformMultiThreaderPosix.cxx b/Modules/Core/Common/src/itkPlatformMultiThreaderPosix.cxx
@@ -109,11 +109,11 @@ PlatformMultiThreader::SpawnThread(ThreadFunctionType f, void * UserData)
 
   for (; id < ITK_MAX_THREADS; ++id)
   {
-    if (!m_SpawnedThreadActiveFlagLock[id])
+    if (!m_SpawnedThreadActiveFlagMutex[id])
     {
-      m_SpawnedThreadActiveFlagLock[id] = std::make_shared<std::mutex>();
+      m_SpawnedThreadActiveFlagMutex[id] = std::make_shared<std::mutex>();
     }
-    const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagLock[id]);
+    const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagMutex[id]);
 
     if (m_SpawnedThreadActiveFlag[id] == 0)
     {
@@ -131,7 +131,7 @@ PlatformMultiThreader::SpawnThread(ThreadFunctionType f, void * UserData)
   m_SpawnedThreadInfoArray[id].UserData = UserData;
   m_SpawnedThreadInfoArray[id].NumberOfWorkUnits = 1;
   m_SpawnedThreadInfoArray[id].ActiveFlag = &m_SpawnedThreadActiveFlag[id];
-  m_SpawnedThreadInfoArray[id].ActiveFlagLock = m_SpawnedThreadActiveFlagLock[id];
+  m_SpawnedThreadInfoArray[id].ActiveFlagLock = m_SpawnedThreadActiveFlagMutex[id];
 
   pthread_attr_t attr;
 
@@ -161,13 +161,13 @@ PlatformMultiThreader::TerminateThread(ThreadIdType WorkUnitID)
   }
 
   {
-    const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagLock[WorkUnitID]);
+    const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagMutex[WorkUnitID]);
     m_SpawnedThreadActiveFlag[WorkUnitID] = 0;
   }
 
   pthread_join(m_SpawnedThreadProcessID[WorkUnitID], nullptr);
 
-  m_SpawnedThreadActiveFlagLock[WorkUnitID] = nullptr;
+  m_SpawnedThreadActiveFlagMutex[WorkUnitID] = nullptr;
 }
 #endif
 
diff --git a/Modules/Core/Common/src/itkPlatformMultiThreaderWindows.cxx b/Modules/Core/Common/src/itkPlatformMultiThreaderWindows.cxx
@@ -104,11 +104,11 @@ PlatformMultiThreader::SpawnThread(ThreadFunctionType f, void * UserData)
 
   for (; id < ITK_MAX_THREADS; ++id)
   {
-    if (!m_SpawnedThreadActiveFlagLock[id])
+    if (!m_SpawnedThreadActiveFlagMutex[id])
     {
-      m_SpawnedThreadActiveFlagLock[id] = std::make_shared<std::mutex>();
+      m_SpawnedThreadActiveFlagMutex[id] = std::make_shared<std::mutex>();
     }
-    const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagLock[id]);
+    const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagMutex[id]);
 
     if (m_SpawnedThreadActiveFlag[id] == 0)
     {
@@ -126,7 +126,7 @@ PlatformMultiThreader::SpawnThread(ThreadFunctionType f, void * UserData)
   m_SpawnedThreadInfoArray[id].UserData = UserData;
   m_SpawnedThreadInfoArray[id].NumberOfWorkUnits = 1;
   m_SpawnedThreadInfoArray[id].ActiveFlag = &m_SpawnedThreadActiveFlag[id];
-  m_SpawnedThreadInfoArray[id].ActiveFlagLock = m_SpawnedThreadActiveFlagLock[id];
+  m_SpawnedThreadInfoArray[id].ActiveFlagLock = m_SpawnedThreadActiveFlagMutex[id];
 
   // Using _beginthreadex on a PC
   //
@@ -148,13 +148,13 @@ PlatformMultiThreader::TerminateThread(ThreadIdType WorkUnitID)
   }
 
   {
-    const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagLock[WorkUnitID]);
+    const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagMutex[WorkUnitID]);
     m_SpawnedThreadActiveFlag[WorkUnitID] = 0;
   }
 
   WaitForSingleObject(m_SpawnedThreadProcessID[WorkUnitID], INFINITE);
   CloseHandle(m_SpawnedThreadProcessID[WorkUnitID]);
-  m_SpawnedThreadActiveFlagLock[WorkUnitID] = nullptr;
+  m_SpawnedThreadActiveFlagMutex[WorkUnitID] = nullptr;
 }
 #endif
 
diff --git a/Modules/Filtering/FFT/include/itkFFTWGlobalConfiguration.h b/Modules/Filtering/FFT/include/itkFFTWGlobalConfiguration.h
@@ -367,7 +367,7 @@ class ITKFFT_EXPORT FFTWGlobalConfiguration : public Object
 
   static FFTWGlobalConfigurationGlobals * m_PimplGlobals;
 
-  std::mutex  m_Lock;
+  std::mutex  m_Mutex;
   bool        m_NewWisdomAvailable{ false };
   int         m_PlanRigor{ 0 };
   bool        m_WriteWisdomCache{ false };
diff --git a/Modules/Filtering/FFT/src/itkFFTWGlobalConfiguration.cxx b/Modules/Filtering/FFT/src/itkFFTWGlobalConfiguration.cxx
@@ -48,7 +48,7 @@ struct FFTWGlobalConfigurationGlobals
     : m_Instance(nullptr){};
 
   FFTWGlobalConfiguration::Pointer m_Instance;
-  std::mutex                       m_CreationLock;
+  std::mutex                       m_CreationMutex;
 };
 
 WisdomFilenameGeneratorBase::WisdomFilenameGeneratorBase() = default;
@@ -148,7 +148,7 @@ FFTWGlobalConfiguration::GetInstance()
   itkInitGlobalsMacro(PimplGlobals);
   if (!m_PimplGlobals->m_Instance)
   {
-    const std::lock_guard<std::mutex> lockGuard(m_PimplGlobals->m_CreationLock);
+    const std::lock_guard<std::mutex> lockGuard(m_PimplGlobals->m_CreationMutex);
     // Need to make sure that during gaining access
     // to the lock that some other thread did not
     // initialize the singleton.
@@ -734,7 +734,7 @@ FFTWGlobalConfiguration::ExportWisdomFileDouble(const std::string &
 std::mutex &
 FFTWGlobalConfiguration::GetLockMutex()
 {
-  return GetInstance()->m_Lock;
+  return GetInstance()->m_Mutex;
 }
 
 void
diff --git a/Modules/IO/ImageBase/src/itkImageIOBase.cxx b/Modules/IO/ImageBase/src/itkImageIOBase.cxx
@@ -937,7 +937,7 @@ ImageIOBase::ReadBufferAsASCII(std::istream & is, void * buffer, IOComponentEnum
 
 namespace
 {
-std::mutex                       ioDefaultSplitterLock;
+std::mutex                       ioDefaultSplitterMutex;
 ImageRegionSplitterBase::Pointer ioDefaultSplitter;
 
 } // namespace
@@ -949,7 +949,7 @@ ImageIOBase::GetImageRegionSplitter() const
   {
     // thread safe lazy initialization,  prevent race condition on
     // setting, with an atomic set if null.
-    const std::lock_guard<std::mutex> lock(ioDefaultSplitterLock);
+    const std::lock_guard<std::mutex> lock(ioDefaultSplitterMutex);
     if (ioDefaultSplitter.IsNull())
     {
       ioDefaultSplitter = ImageRegionSplitterSlowDimension::New().GetPointer();
diff --git a/Modules/IO/ImageBase/src/itkImageIOFactory.cxx b/Modules/IO/ImageBase/src/itkImageIOFactory.cxx
@@ -26,15 +26,15 @@ namespace itk
 
 namespace
 {
-std::mutex createImageIOLock;
+std::mutex createImageIOMutex;
 }
 
 ImageIOBase::Pointer
 ImageIOFactory::CreateImageIO(const char * path, IOFileModeEnum mode)
 {
   std::list<ImageIOBase::Pointer> possibleImageIO;
 
-  const std::lock_guard<std::mutex> mutexHolder(createImageIOLock);
+  const std::lock_guard<std::mutex> mutexHolder(createImageIOMutex);
 
   for (auto & allobject : ObjectFactoryBase::CreateAllInstance("itkImageIOBase"))
   {
diff --git a/Modules/Numerics/FEM/include/itkFEMFactoryBase.h b/Modules/Numerics/FEM/include/itkFEMFactoryBase.h
@@ -75,7 +75,7 @@ class ITKFEM_EXPORT FEMFactoryBase : public ObjectFactoryBase
   {
     if (m_Factory == nullptr)
     {
-      const std::lock_guard<std::mutex> lockGuard(m_CreationLock);
+      const std::lock_guard<std::mutex> lockGuard(m_CreationMutex);
       // Need to make sure that during gaining access
       // to the lock that some other thread did not
       // initialize the singleton.
@@ -110,7 +110,7 @@ class ITKFEM_EXPORT FEMFactoryBase : public ObjectFactoryBase
   ~FEMFactoryBase() override;
 
 private:
-  static std::mutex       m_CreationLock;
+  static std::mutex       m_CreationMutex;
   static FEMFactoryBase * m_Factory;
 };
 } // end namespace itk
diff --git a/Modules/Numerics/FEM/src/itkFEMFactoryBase.cxx b/Modules/Numerics/FEM/src/itkFEMFactoryBase.cxx
@@ -42,7 +42,7 @@
 namespace itk
 {
 FEMFactoryBase * FEMFactoryBase::m_Factory = nullptr;
-std::mutex       FEMFactoryBase::m_CreationLock;
+std::mutex       FEMFactoryBase::m_CreationMutex;
 
 FEMFactoryBase::FEMFactoryBase() = default;
 
diff --git a/Modules/Registration/GPUPDEDeformable/include/itkGPUDemonsRegistrationFunction.h b/Modules/Registration/GPUPDEDeformable/include/itkGPUDemonsRegistrationFunction.h
@@ -292,7 +292,7 @@ class ITK_TEMPLATE_EXPORT GPUDemonsRegistrationFunction
   mutable GPUReduction<float>::Pointer m_GPUSquaredDifference{};
 
   /** Mutex lock to protect modification to metric. */
-  mutable std::mutex m_MetricCalculationLock{};
+  mutable std::mutex m_MetricCalculationMutex{};
 };
 } // end namespace itk
 
diff --git a/Modules/Registration/GPUPDEDeformable/include/itkGPUDemonsRegistrationFunction.hxx b/Modules/Registration/GPUPDEDeformable/include/itkGPUDemonsRegistrationFunction.hxx
@@ -376,7 +376,7 @@ GPUDemonsRegistrationFunction<TFixedImage, TMovingImage, TDisplacementField>::Re
 {
   const std::unique_ptr<const GlobalDataStruct> globalData(static_cast<GlobalDataStruct *>(gd));
 
-  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationLock);
+  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationMutex);
   m_SumOfSquaredDifference += globalData->m_SumOfSquaredDifference;
   m_NumberOfPixelsProcessed += globalData->m_NumberOfPixelsProcessed;
   m_SumOfSquaredChange += globalData->m_SumOfSquaredChange;
diff --git a/Modules/Registration/PDEDeformable/include/itkDemonsRegistrationFunction.h b/Modules/Registration/PDEDeformable/include/itkDemonsRegistrationFunction.h
@@ -258,7 +258,7 @@ class ITK_TEMPLATE_EXPORT DemonsRegistrationFunction
   mutable double        m_SumOfSquaredChange{};
 
   /** Mutex lock to protect modification to metric. */
-  mutable std::mutex m_MetricCalculationLock{};
+  mutable std::mutex m_MetricCalculationMutex{};
 };
 } // end namespace itk
 
diff --git a/Modules/Registration/PDEDeformable/include/itkDemonsRegistrationFunction.hxx b/Modules/Registration/PDEDeformable/include/itkDemonsRegistrationFunction.hxx
@@ -237,7 +237,7 @@ DemonsRegistrationFunction<TFixedImage, TMovingImage, TDisplacementField>::Relea
 {
   const std::unique_ptr<const GlobalDataStruct> globalData(static_cast<GlobalDataStruct *>(gd));
 
-  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationLock);
+  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationMutex);
   m_SumOfSquaredDifference += globalData->m_SumOfSquaredDifference;
   m_NumberOfPixelsProcessed += globalData->m_NumberOfPixelsProcessed;
   m_SumOfSquaredChange += globalData->m_SumOfSquaredChange;
diff --git a/Modules/Registration/PDEDeformable/include/itkESMDemonsRegistrationFunction.h b/Modules/Registration/PDEDeformable/include/itkESMDemonsRegistrationFunction.h
@@ -323,7 +323,7 @@ class ITK_TEMPLATE_EXPORT ESMDemonsRegistrationFunction
   mutable double        m_SumOfSquaredChange{};
 
   /** Mutex lock to protect modification to metric. */
-  mutable std::mutex m_MetricCalculationLock{};
+  mutable std::mutex m_MetricCalculationMutex{};
 };
 } // end namespace itk
 
diff --git a/Modules/Registration/PDEDeformable/include/itkESMDemonsRegistrationFunction.hxx b/Modules/Registration/PDEDeformable/include/itkESMDemonsRegistrationFunction.hxx
@@ -409,7 +409,7 @@ ESMDemonsRegistrationFunction<TFixedImage, TMovingImage, TDisplacementField>::Re
 {
   const std::unique_ptr<const GlobalDataStruct> globalData(static_cast<GlobalDataStruct *>(gd));
 
-  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationLock);
+  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationMutex);
   m_SumOfSquaredDifference += globalData->m_SumOfSquaredDifference;
   m_NumberOfPixelsProcessed += globalData->m_NumberOfPixelsProcessed;
   m_SumOfSquaredChange += globalData->m_SumOfSquaredChange;
diff --git a/Modules/Registration/PDEDeformable/include/itkFastSymmetricForcesDemonsRegistrationFunction.h b/Modules/Registration/PDEDeformable/include/itkFastSymmetricForcesDemonsRegistrationFunction.h
@@ -242,7 +242,7 @@ class ITK_TEMPLATE_EXPORT FastSymmetricForcesDemonsRegistrationFunction
   mutable double        m_SumOfSquaredChange{};
 
   /** Mutex lock to protect modification to metric. */
-  mutable std::mutex m_MetricCalculationLock{};
+  mutable std::mutex m_MetricCalculationMutex{};
 };
 } // end namespace itk
 
diff --git a/Modules/Registration/PDEDeformable/include/itkFastSymmetricForcesDemonsRegistrationFunction.hxx b/Modules/Registration/PDEDeformable/include/itkFastSymmetricForcesDemonsRegistrationFunction.hxx
@@ -262,7 +262,7 @@ FastSymmetricForcesDemonsRegistrationFunction<TFixedImage, TMovingImage, TDispla
 {
   const std::unique_ptr<const GlobalDataStruct> globalData(static_cast<GlobalDataStruct *>(gd));
 
-  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationLock);
+  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationMutex);
   m_SumOfSquaredDifference += globalData->m_SumOfSquaredDifference;
   m_NumberOfPixelsProcessed += globalData->m_NumberOfPixelsProcessed;
   m_SumOfSquaredChange += globalData->m_SumOfSquaredChange;
diff --git a/Modules/Registration/PDEDeformable/include/itkLevelSetMotionRegistrationFunction.h b/Modules/Registration/PDEDeformable/include/itkLevelSetMotionRegistrationFunction.h
@@ -282,7 +282,7 @@ class ITK_TEMPLATE_EXPORT LevelSetMotionRegistrationFunction
   mutable double        m_SumOfSquaredChange{};
 
   /** Mutex lock to protect modification to metric. */
-  mutable std::mutex m_MetricCalculationLock{};
+  mutable std::mutex m_MetricCalculationMutex{};
 
   bool m_UseImageSpacing{};
 };
diff --git a/Modules/Registration/PDEDeformable/include/itkLevelSetMotionRegistrationFunction.hxx b/Modules/Registration/PDEDeformable/include/itkLevelSetMotionRegistrationFunction.hxx
@@ -377,7 +377,7 @@ LevelSetMotionRegistrationFunction<TFixedImage, TMovingImage, TDisplacementField
 {
   const std::unique_ptr<const GlobalDataStruct> globalData(static_cast<GlobalDataStruct *>(gd));
 
-  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationLock);
+  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationMutex);
   m_SumOfSquaredDifference += globalData->m_SumOfSquaredDifference;
   m_NumberOfPixelsProcessed += globalData->m_NumberOfPixelsProcessed;
   m_SumOfSquaredChange += globalData->m_SumOfSquaredChange;
diff --git a/Modules/Registration/PDEDeformable/include/itkSymmetricForcesDemonsRegistrationFunction.h b/Modules/Registration/PDEDeformable/include/itkSymmetricForcesDemonsRegistrationFunction.h
@@ -243,7 +243,7 @@ class ITK_TEMPLATE_EXPORT SymmetricForcesDemonsRegistrationFunction
   mutable double        m_SumOfSquaredChange{};
 
   /** Mutex lock to protect modification to metric. */
-  mutable std::mutex m_MetricCalculationLock{};
+  mutable std::mutex m_MetricCalculationMutex{};
 };
 } // end namespace itk
 
diff --git a/Modules/Registration/PDEDeformable/include/itkSymmetricForcesDemonsRegistrationFunction.hxx b/Modules/Registration/PDEDeformable/include/itkSymmetricForcesDemonsRegistrationFunction.hxx
@@ -288,7 +288,7 @@ SymmetricForcesDemonsRegistrationFunction<TFixedImage, TMovingImage, TDisplaceme
 {
   const std::unique_ptr<const GlobalDataStruct> globalData(static_cast<GlobalDataStruct *>(gd));
 
-  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationLock);
+  const std::lock_guard<std::mutex> lockGuard(m_MetricCalculationMutex);
   m_SumOfSquaredDifference += globalData->m_SumOfSquaredDifference;
   m_NumberOfPixelsProcessed += globalData->m_NumberOfPixelsProcessed;
   m_SumOfSquaredChange += globalData->m_SumOfSquaredChange;

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ PlatformMultiThreader::PlatformMultiThreader()`
`57`	`57`	`#endif`
`58`	`58`
`59`	`59`	`m_SpawnedThreadActiveFlag[i] = 0;`
`60`		`- m_SpawnedThreadActiveFlagLock[i] = nullptr;`
	`60`	`+ m_SpawnedThreadActiveFlagMutex[i] = nullptr;`
`61`	`61`	`m_SpawnedThreadInfoArray[i].WorkUnitID = i;`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -109,11 +109,11 @@ PlatformMultiThreader::SpawnThread(ThreadFunctionType f, void * UserData)`
`109`	`109`
`110`	`110`	`for (; id < ITK_MAX_THREADS; ++id)`
`111`	`111`	`{`
`112`		`- if (!m_SpawnedThreadActiveFlagLock[id])`
	`112`	`+ if (!m_SpawnedThreadActiveFlagMutex[id])`
`113`	`113`	`{`
`114`		`- m_SpawnedThreadActiveFlagLock[id] = std::make_shared<std::mutex>();`
	`114`	`+ m_SpawnedThreadActiveFlagMutex[id] = std::make_shared<std::mutex>();`
`115`	`115`	`}`
`116`		`- const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagLock[id]);`
	`116`	`+ const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagMutex[id]);`
`117`	`117`
`118`	`118`	`if (m_SpawnedThreadActiveFlag[id] == 0)`
`119`	`119`	`{`
`@@ -131,7 +131,7 @@ PlatformMultiThreader::SpawnThread(ThreadFunctionType f, void * UserData)`
`131`	`131`	`m_SpawnedThreadInfoArray[id].UserData = UserData;`
`132`	`132`	`m_SpawnedThreadInfoArray[id].NumberOfWorkUnits = 1;`
`133`	`133`	`m_SpawnedThreadInfoArray[id].ActiveFlag = &m_SpawnedThreadActiveFlag[id];`
`134`		`- m_SpawnedThreadInfoArray[id].ActiveFlagLock = m_SpawnedThreadActiveFlagLock[id];`
	`134`	`+ m_SpawnedThreadInfoArray[id].ActiveFlagLock = m_SpawnedThreadActiveFlagMutex[id];`
`135`	`135`
`136`	`136`	`pthread_attr_t attr;`
`137`	`137`
`@@ -161,13 +161,13 @@ PlatformMultiThreader::TerminateThread(ThreadIdType WorkUnitID)`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`{`
`164`		`- const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagLock[WorkUnitID]);`
	`164`	`+ const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagMutex[WorkUnitID]);`
`165`	`165`	`m_SpawnedThreadActiveFlag[WorkUnitID] = 0;`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`pthread_join(m_SpawnedThreadProcessID[WorkUnitID], nullptr);`
`169`	`169`
`170`		`- m_SpawnedThreadActiveFlagLock[WorkUnitID] = nullptr;`
	`170`	`+ m_SpawnedThreadActiveFlagMutex[WorkUnitID] = nullptr;`
`171`	`171`	`}`
`172`	`172`	`#endif`
`173`	`173`
Original file line number	Diff line number	Diff line change
`@@ -104,11 +104,11 @@ PlatformMultiThreader::SpawnThread(ThreadFunctionType f, void * UserData)`
`104`	`104`
`105`	`105`	`for (; id < ITK_MAX_THREADS; ++id)`
`106`	`106`	`{`
`107`		`- if (!m_SpawnedThreadActiveFlagLock[id])`
	`107`	`+ if (!m_SpawnedThreadActiveFlagMutex[id])`
`108`	`108`	`{`
`109`		`- m_SpawnedThreadActiveFlagLock[id] = std::make_shared<std::mutex>();`
	`109`	`+ m_SpawnedThreadActiveFlagMutex[id] = std::make_shared<std::mutex>();`
`110`	`110`	`}`
`111`		`- const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagLock[id]);`
	`111`	`+ const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagMutex[id]);`
`112`	`112`
`113`	`113`	`if (m_SpawnedThreadActiveFlag[id] == 0)`
`114`	`114`	`{`
`@@ -126,7 +126,7 @@ PlatformMultiThreader::SpawnThread(ThreadFunctionType f, void * UserData)`
`126`	`126`	`m_SpawnedThreadInfoArray[id].UserData = UserData;`
`127`	`127`	`m_SpawnedThreadInfoArray[id].NumberOfWorkUnits = 1;`
`128`	`128`	`m_SpawnedThreadInfoArray[id].ActiveFlag = &m_SpawnedThreadActiveFlag[id];`
`129`		`- m_SpawnedThreadInfoArray[id].ActiveFlagLock = m_SpawnedThreadActiveFlagLock[id];`
	`129`	`+ m_SpawnedThreadInfoArray[id].ActiveFlagLock = m_SpawnedThreadActiveFlagMutex[id];`
`130`	`130`
`131`	`131`	`// Using _beginthreadex on a PC`
`132`	`132`	`//`
`@@ -148,13 +148,13 @@ PlatformMultiThreader::TerminateThread(ThreadIdType WorkUnitID)`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`{`
`151`		`- const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagLock[WorkUnitID]);`
	`151`	`+ const std::lock_guard<std::mutex> lockGuard(*m_SpawnedThreadActiveFlagMutex[WorkUnitID]);`
`152`	`152`	`m_SpawnedThreadActiveFlag[WorkUnitID] = 0;`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`WaitForSingleObject(m_SpawnedThreadProcessID[WorkUnitID], INFINITE);`
`156`	`156`	`CloseHandle(m_SpawnedThreadProcessID[WorkUnitID]);`
`157`		`- m_SpawnedThreadActiveFlagLock[WorkUnitID] = nullptr;`
	`157`	`+ m_SpawnedThreadActiveFlagMutex[WorkUnitID] = nullptr;`
`158`	`158`	`}`
`159`	`159`	`#endif`
`160`	`160`
Original file line number	Diff line number	Diff line change
`@@ -937,7 +937,7 @@ ImageIOBase::ReadBufferAsASCII(std::istream & is, void * buffer, IOComponentEnum`
`937`	`937`
`938`	`938`	`namespace`
`939`	`939`	`{`
`940`		`-std::mutex ioDefaultSplitterLock;`
	`940`	`+std::mutex ioDefaultSplitterMutex;`
`941`	`941`	`ImageRegionSplitterBase::Pointer ioDefaultSplitter;`
`942`	`942`
`943`	`943`	`} // namespace`
`@@ -949,7 +949,7 @@ ImageIOBase::GetImageRegionSplitter() const`
`949`	`949`	`{`
`950`	`950`	`// thread safe lazy initialization, prevent race condition on`
`951`	`951`	`// setting, with an atomic set if null.`
`952`		`- const std::lock_guard<std::mutex> lock(ioDefaultSplitterLock);`
	`952`	`+ const std::lock_guard<std::mutex> lock(ioDefaultSplitterMutex);`
`953`	`953`	`if (ioDefaultSplitter.IsNull())`
`954`	`954`	`{`
`955`	`955`	`ioDefaultSplitter = ImageRegionSplitterSlowDimension::New().GetPointer();`
Original file line number	Diff line number	Diff line change
`@@ -26,15 +26,15 @@ namespace itk`
`26`	`26`
`27`	`27`	`namespace`
`28`	`28`	`{`
`29`		`-std::mutex createImageIOLock;`
	`29`	`+std::mutex createImageIOMutex;`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`ImageIOBase::Pointer`
`33`	`33`	`ImageIOFactory::CreateImageIO(const char * path, IOFileModeEnum mode)`
`34`	`34`	`{`
`35`	`35`	`std::list<ImageIOBase::Pointer> possibleImageIO;`
`36`	`36`
`37`		`- const std::lock_guard<std::mutex> mutexHolder(createImageIOLock);`
	`37`	`+ const std::lock_guard<std::mutex> mutexHolder(createImageIOMutex);`
`38`	`38`
`39`	`39`	`for (auto & allobject : ObjectFactoryBase::CreateAllInstance("itkImageIOBase"))`
`40`	`40`	`{`