mutex.lock();//что если обьектов много и какой-то из них забыли закрыть
    try {
        ....
    }
    finally{
        mutex.unlock();
    }

    {
        boost::mutex::lock l(mutex);
        .............
    }

try
{
    throw new FirstException();
}
finally
{
      throw new SecondExpection(); // все, пользователь никогда не узнает о FirstException
}

try
{
    throw FirstException();
}
catch(...)
{
      throw SecondExpection(); // все, пользователь никогда не узнает о FirstException
}

D>Подход с деструкторами-очистителями в C++ очень сильно ограничен, и нормально покрывает только самые простые (и по-большей части чисто технические) случаи, типа каких-нибудь smart pointer'ов. Любая очистка требующая новых ресурсов/допускающая отказы, сразу же вызывает тот жуткий код, который Вы напишете в ответ на вопрос из 1-го абзаца

r1.open();
try {
  r2.open();//вдруг при инициализации r2 возникнет исключение - надо закрыть r1
  try {
    r3.open();//вдруг при инициализации r3 возникнет исключение - надо закрыть r1 и r2
    try {
      //наконец-то делаем то, что хотели
      ......
    }
    finally {
      r3.close();
    }
  }
  finally {
    r2.close();
  }
}
finally {
  r1.close();
}

{
  r1.open();
  r2.open();
  r3.open();
  //делаем то, что хотим!!!
  ............
  //метод close автоматически вызовется в деструкторах
}

D>>Подход с деструкторами-очистителями в C++ очень сильно ограничен, и нормально покрывает только самые простые (и по-большей части чисто технические) случаи, типа каких-нибудь smart pointer'ов. Любая очистка требующая новых ресурсов/допускающая отказы, сразу же вызывает тот жуткий код, который Вы напишете в ответ на вопрос из 1-го абзаца

using(var r1 = new R1())
using(var r2 = new R2())
using(var r3 = new R3())
{
   // чего-то делаем
}

//  C++ 
func() 
{ 
   class_with_possible_ressource  cwpr; 
   dosomethingwith(cwpr); 
} 

//  Java 
func() 
{ 
  class_with_possible_ressource  cwpr = new class_with_possible_ressource; 
  if (cwpr->did_initialise_properly()) 
  { 
     try 
     { 
       dosomethingwith(cwpr); 
     } 
     finally 
     { 
        try 
        { 
           idisp = (IDisposable)cwpr; 
           idisp->Dispose(); 
        } 
        catch (...) 
        { 
        } 
     } 
  } 
}

So the Java func above is as easy to understand as the C++-one?? Come
on — you do not really mean that. Also you have a huge problem writing
generic code in Java .... those ugly and presumably costly runtime
checks have to be made all the time.
(с)peter koch

lock dec eax

S>lock dec eax
S>

int InterlockedDecrement (int *value)
{
    __asm
    {
        mov    ecx, DWORD ptr [value]
        mov    eax, -1
        lock xadd DWORD ptr [ecx],eax
        dec    eax
    }
}

ЮЖ>Где-то я все это уже слышал...

void func() 
{
  class_with_possible_ressource cwpr = new class_with_possible_ressource();
  try
  {
       dosomethingwith(cwpr);
  }
  finally
  {
     if (cwpr instanceof Closeable) {
       try {
          ((Closeable)cwpr).close();
       } catch {
          terminate();
       }
     }
  }
}

void func() 
{
  class_with_possible_ressource cwpr = new class_with_possible_ressource();
  try
  {
       dosomethingwith(cwpr);
  }
  finally
  {
     if (cwpr instanceof Closeable) {
       ((Closeable)cwpr).close();
     }
  }
}

void func() 
{
  using(var cwpr = new class_with_possible_ressource()) 
    dosomethingwith(cwpr);
}

1.6.7.6 Destructors
A destructor is a member that implements the actions required to destruct an instance of a class. Destructors cannot have parameters, they cannot have accessibility modifiers, and they cannot be invoked explicitly. The destructor for an instance is invoked automatically during garbage collection.
The garbage collector is allowed wide latitude in deciding when to collect objects and run destructors. Specifically, the timing of destructor invocations is not deterministic, and destructors may be executed on any thread. For these and other reasons, classes should implement destructors only when no other solutions are feasible.
The using statement provides a better approach to object destruction.

MyClass::MyClass():
myMember(this)
{}

D>Ну и напоследок, я всё-таки соглашусь с koch'ом: в Java сделано неудобно И посему C# рулит

D>void func() 
D>{
D>  using(var cwpr = new class_with_possible_ressource()) 
D>    dosomethingwith(cwpr);
D>}
D>

void func()
{
     dosomethingwith(class_with_possible_ressource());
}

This is achieved by most Java compilers by compiling the Java language code halfway (to Java bytecode) – simplified machine instructions specific to the Java platform. The code is then run on a virtual machine (VM), a program written in native code on the host hardware that interprets and executes generic Java bytecode. (In some JVM versions, bytecode can also be compiled to native code, either before or during program execution, resulting in faster execution.)

(In some JVM versions, bytecode can also be compiled to native code, either before or during program execution, resulting in faster execution.)

MyClass::MyClass():
myMember(this)
{}