façon fil de sécurité pour incrémenter et retourner un entier Delphi

Question

Dans une application mono-thread j'utiliser le code comme ceci:

Interface 
    function GetNextUID : integer; 
Implementation 
    function GetNextUID : integer; 
    const 
     cUID : integer = 0; 
    begin 
     inc(cUID); 
     result := cUID; 
    end; 

Cela pourrait bien entendu être mis en œuvre comme un objet singleton, etc. - je Je donne juste l'exemple le plus simple possible.

Q: Comment puis-je modifier cette fonction (ou concevoir une classe) pour obtenir le même résultat en toute sécurité à partir de threads concurrents?

Answer 1

Vous pouvez utiliser les Interlocked* fonctions:

function GetNextUID : integer; 
    {$J+} // Writeble constants 
    const 
     cUID : integer = 0; 
    begin 
     Result := InterlockedIncrement(cUID); 
    end; 

plus modernes versions Delphi ont rebaptisé ces méthodes en Atomic* (comme AtomicDecrement, AtomicIncrement, etc.), de sorte que le code exemple devient ceci:

function GetNextUID : integer; 
    {$J+} // Writeble constants 
    const 
     cUID : integer = 0; 
    begin 
     Result := AtomicIncrement(cUID); 
    end; 

Answer 2

Le moyen le plus simple serait probablement d'appeler simplement InterlockedIncrement pour faire le travail.

Answer 3

Avec les compilateurs Delphi modernes, il est préférable d'utiliser la fonction Increment de la classe TInterlocked de l'unité System.SyncObjs. Quelque chose comme ceci:

type 
    TMyClass = class 
    class var 
     FIdCounter: int64; 
    var 
     FId: int64; 
    constructor Create; 
    end; 

constructor TMyClass.Create; 
begin 
    FId := TInterlocked.Increment(FIdCounter); 
end; 

Cela permet de garder le code indépendant de la plate-forme.