C++ 螺纹C++；锁

我需要一些线程同步机制。我想知道下面的实现哪一个更好

classA{

public:
   int sharedResourceA;
   pthread_mutex_t mutex1;
   functionA();
   int nonSharedResources;

}

classA::functionA(){
  pthread_mutex_lock( &mutex1 );
  use sharedResourceA;
  pthread_mutex_unlock( &mutex1 );
}

classA objA;
pthread_mutex_lock(&objA.mutex1) //use lock because another thread can call obj.functionA
  use objA.sharedResources;
pthread_mutex_unlock(&objA.mutex1)

use objA.nonSharedResources = blah //without lock because is non shared

或者我不应该在classA中创建锁，而是在应用程序中创建锁。例如：

classA objA;
pthread_mutex_t mutex2;
pthread_mutex_lock(mutex2) //use lock because another thread can call obj.functionA
  use objA.sharedResources;
pthread_mutex_unlock(mutex2)

pthread_mutex_lock(mutex2) //use lock because another thread can call obj.functionA
  functionA();
pthread_mutex_unlock(mutex2)

use objA.nonSharedResources = blah //without lock because is non shared

---

我认为第一个更好，因为如果您需要多次实例化ClassA，那么您需要为第二个解决方案创建尽可能多的全局锁

---

如果您在类内部进行对象封装，并且在方法后面隐藏受保护资源的使用，那么它也尊重对象封装。此外，如果共享资源变得不共享，那么如果使用全局锁，您可以在代码中更改类方法，而不是重构资源的每次使用。

我认为第一个更好，因为如果您需要多次实例化ClassA，您需要为第二个解决方案创建尽可能多的全局锁

---

如果您在类内部进行对象封装，并且在方法后面隐藏受保护资源的使用，那么它也尊重对象封装。此外，如果共享资源变得不共享，那么如果使用全局锁，您可以在代码中更改类方法，而不是重构资源的每次使用。

如果Function使用一些共享资源，它应该确保以正确的方式访问它们，即确保线程安全。这是对你提出的第一个选择的投票

有更有效的方法来使用互斥体：请参阅boost:：recursive_mutex和boost:：recursive_mutex:：scoped_lock。使用此选项，您可以确保即使关键部分中的某些内容抛出，您的互斥锁也将被解锁。例如：

使用名称空间boost

struct C

{

function f ()
{
    //non critical section
    //...

    //critical section        
    {
        //acquire the mutex
        recursive_mutex::scoped_lock lock(mutex);
       //do whatever you want. Can throw if it needs to:)
    }//exiting the scope causes the mutex to be released     

   //non critical section again

}

private:

recursive\u mutex mutex；

}
如果functionA使用一些共享资源，它应该确保以正确的方式访问它们，即确保线程安全。这是对你提出的第一个选择的投票

有更有效的方法来使用互斥体：请参阅boost:：recursive_mutex和boost:：recursive_mutex:：scoped_lock。使用此选项，您可以确保即使关键部分中的某些内容抛出，您的互斥锁也将被解锁。例如：

使用名称空间boost

struct C

{

function f ()
{
    //non critical section
    //...

    //critical section        
    {
        //acquire the mutex
        recursive_mutex::scoped_lock lock(mutex);
       //do whatever you want. Can throw if it needs to:)
    }//exiting the scope causes the mutex to be released     

   //non critical section again

}

private:

recursive\u mutex mutex；

 <代码>  
第一，C++中的锁的习惯用法是创建一个使用RAII.< /P>的锁类。
那你可以走了
Lock l(mutex1);
// do stuff under mutex1 lock;
// Lock is freed at end of scope

（我打赌boost有锁，我们自己做的）

第二。（范围问题）。如果类A在内部使用共享资源，那么它应该在内部锁定它们。否则

打电话的人怎么知道该怎么做
你怎么能确定是他们干的
如果您更改了实现呢
应用程序级锁应该在调用方使用共享资源时使用，使用的是类，函数和文件W。注意，在这种情况下，类仍然有自己的内部锁。
 第一，在C++中做锁的惯用方式是创建一个使用RAII.< /P>的锁类。
那你可以走了

Lock l(mutex1);
// do stuff under mutex1 lock;
// Lock is freed at end of scope

（我打赌boost有锁，我们自己做的）

第二。（范围问题）。如果类A在内部使用共享资源，那么它应该在内部锁定它们。否则

打电话的人怎么知道该怎么做
你怎么能确定是他们干的
如果您更改了实现呢
当调用者是使用共享资源的调用者，并且正在使用classA、funcX和file W编写更大的文件时，应使用应用程序级锁。请注意，在这种情况下，classA可能仍然有自己的内部锁，您确实需要确保，在获得互斥锁并执行使用共享资源的代码时，该代码决不能引发异常，否则将不会调用相应的互斥解锁。您可以通过使用RAII创建一个简单的类来解决这个问题，该类在构造函数中接受指向互斥体的指针并锁定它，然后在析构函数中解锁互斥体。这样，一旦类对象超出作用域，解锁就会自动完成。看起来不错，您确实需要确保在获得互斥锁并执行使用共享资源的代码时，此代码决不能引发异常，否则不会调用相应的互斥锁解锁。您可以通过使用RAII创建一个简单的类来解决这个问题，该类在构造函数中接受指向互斥体的指针并锁定它，然后在析构函数中解锁互斥体。这样，一旦类对象超出范围，解锁就会自动完成。