bei meiner Frage geht es zwar um Multithreading aber mich interessiert hier der C++ Aspekt.

Ich habe z.b. eine Klasse ScopedLock

template< typename SyncType >
  class ScopedLock : NotCopyable
  {
    SyncType & sync;
  public:
    ScopedLock( SyncType & s ):sync(s){ sync.lock(); }
    ~ScopedLock(){ sync.unlock(); }
  };

Nun habe ich in einer Klasse eine Methode in der ich 2 verschiedene Mutexe nutzen muss:

void SomeClass::foo()
{
  ScopedLock< Mutex > lock1(mutex1);
  ScopedLock< Mutex > lock2(mutex2);
  // Do foo
}

Nun frage ich mich ob garantiert wird das der Destruktor von lock2 zuerst aufgerufen wird ( wegen dem unlock() ) und dannach erst der Destruktor lock1

Sollte dem nicht so sein hab ich nämlich ein Problem wenn ich das wie oben schreibe.

Oder bin ich gezwungen das so zu verwenden?

void SomeClass::foo()
{
  ScopedLock< Mutex > lock1(mutex1);
  {
    ScopedLock< Mutex > lock2(mutex2);
    // Do foo
  }
}

Die Frage ist rein hypothetisch aber würde mich trotzdem brennend interessieren.

BR

evilissimo

Afaik werden Destruktoren immer in umgekehrter Reihenfolge zu den Konstruktoren aufgerufen, d.h. in deinem Beispiel erst lock2, dann lock1.

richtig, das problem an diesem code ist eher der potentielle deadlock beim konstruieren.