Quand TInterfacedObject.Destroy est appelé (une classe ScopedLock)

Question

Je me demande quand une instance d'une classe dérivée de TInterfacedObject est détruite et qui appelle le destructeur. J'ai écrit une classe ScopedLock, qui devrait automatiquement appeler la méthode Release d'un objet de synchronisation lorsque l'instance sort de la portée. C'est un concept RAII connu en C++, mais je ne sais pas s'il est garanti que le destructeur est appelé, quand l'instance de verrouillage sort de sa portée.

ILock = interface 
end; 

ScopedLock<T: TSynchroObject> = class(TInterfacedObject, ILock) 
strict private 
    sync_ : T; 
public 
    constructor Create(synchro : T); reintroduce; 
    destructor Destroy;override; 
end; 

implementation 
{ ScopedLock<T> } 

constructor ScopedLock<T>.Create(synchro: T); 
begin 
    inherited Create;; 
    sync_ := synchro; 
    sync_.Acquire; 
end; 

destructor ScopedLock<T>.Destroy; 
begin 
    sync_.Release; 
    inherited; 
end; 

{ Example } 
function Example.Foo: Integer; 
var 
    lock : ILock; 
begin 
    lock := ScopedLock<TCriticalSection>.Create(mySync); 
    // ... 
end; // mySync released ? 

Cela fonctionne très bien dans un cas de test simple, mais est-ce sécuritaire?

Answer 1

Oui, c'est économiser. Votre code

function Example.Foo: Integer; 
var 
    lock : ILock; 
begin 
    lock := ScopedLock<TCriticalSection>.Create(mySync); 
    // ... 
end; 

est compilé comme le pseudo-code suivant

function Example.Foo: Integer; 
var 
    lock : ILock; 
begin 
    lock := ScopedLock<TCriticalSection>.Create(mySync); 
    lock._AddRef; // ref count = 1 
    try 
// .. 
    finally 
    lock._Release; // ref count = 0, free lock object 
    end; 

Vous pouvez voir que lorsque verrouillage var est hors de portée son compte ref est décrémenté, est devenu nul et objet de verrouillage est automatiquement détruit.

Answer 2

Le seul problème est si la fonction est en ligne: la variable locale contenant la référence ILock sera promue à la portée de la fonction appelant la fonction inline. Cela pourrait faire que le verrou vive plus longtemps que vous le vouliez. D'autre part, il n'est pas nécessaire de déclarer une variable pour contenir la référence d'interface si vous écrivez une fonction (par exemple une fonction de classe appelée Create) qui renvoie une référence d'interface (par opposition à une référence d'objet). Le compilateur créera un local caché pour recevoir la valeur de retour (car tous les types gérés comme les interfaces et les chaînes sont retournés en passant une variable de résultat). Ce local caché agira comme le local explicite.

j'ai écrit plus ici: http://blog.barrkel.com/2010/01/one-liner-raii-in-delphi.html

Answer 3

Je ne vois pas que l'approche que vous épousez, tout juste, est en fait mieux que le bon vieux try/finally. Vous avez pris une solution claire et explicite et l'avez remplacée par une solution obscure et opaque.

Le vrai travail Le code Delphi est plein de Try/Finally et donc ça devrait être un idiome naturel. Je ne vois pas l'inconvénient de l'écriture:

mySync.Acquire; 
Try 
    //do stuff 
Finally 
    mySync.Release; 
End;