System.AtomicCmpExchange

Aus RAD Studio API Documentation
Wechseln zu: Navigation, Suche

Delphi

function AtomicCmpExchange(var Target: Integer; NewValue: Integer; Comparand: Integer): Integer; overload;
function AtomicCmpExchange(var Target: Int64; NewValue: Int64; Comparand: Int64): Int64; overload;
function AtomicCmpExchange(var Target: Pointer; NewValue: Pointer; Comparand: Pointer): Pointer; overload;
function AtomicCmpExchange(var Target: Integer; NewValue: Integer; Comparand: Integer; out Succeeded: Boolean): Integer; overload;
function AtomicCmpExchange(var Target: Int64; NewValue: Int64; Comparand: Int64; out Succeeded: Boolean): Int64; overload;
function AtomicCmpExchange(var Target: Pointer; NewValue: Pointer; Comparand: Pointer; out Succeeded: Boolean): Pointer; overload;

Eigenschaften

Typ Sichtbarkeit Quelle Unit Übergeordnet
function public System.pas System System


Beschreibung

Die "atomic" intrinsische Funktion Vergleichen und Austauschen vergleicht den Inhalt von Target mit einem gegebenen Wert (Comparand). Nur wenn beide Werte gleich sind, wird der Inhalt von Target durch den neuen Wert ersetzt.

Diese Funktion gibt immer den ursprünglichen Wert von (Target) zurück. Wenn der Parameter Succeeded angegeben ist, wird Succeeded bei einem Werteaustausch der Wert True zugewiesen (auch wenn Target und NewValue gleich sind); ansonsten wird False zugewiesen.

Die Unit System enthält vier "atomic" intrinsische Funktionen, mit denen Speicherwerte unteilbar ausgetauscht, verglichen und ausgetauscht, inkrementiert und dekrementiert werden können.

AtomicCmpExchange wird zum Vergleichen und Austauschen von Speicherwerten verwendet.

Mit unteilbaren Operationen werden:

  • Primitive, blockierende Multithreaded-Klassen implementiert
  • Primitive Klassen bereitgestellt, die für die Implementierung von sogenannten "nicht-blockierenden" Strukturen erforderlich sind

Beispiel-Code

program SystemAtomicCmpExchange;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils, Winapi.Windows;

var
  Target,
  Comparand,
  Return : Integer;
  Succeeded : Boolean;

const
  ReplaceValue = Integer(5);

begin
  try
    WriteLn('System.AtomicCmpExchange');
    WriteLn;

    Target := 1;
    Comparand := 0;
    WriteLn(Format('Initial values: Target: %d, Comparand: %d, ReplaceValue : %d',
      [Target, Comparand, ReplaceValue]));
    Return := System.AtomicCmpExchange(Target, ReplaceValue, Comparand, Succeeded);
    WriteLn(Format('After calling:  Target: %d, Comparand: %d, Return: %d, Succeeded: %s',
      [Target, Comparand, Return, BoolToStr(Succeeded, true)]));

    WriteLn;

    Target := 1;
    Comparand := 1;
    WriteLn(Format('Initial values: Target: %d, Comparand: %d, ReplaceValue : %d',
      [Target, Comparand, ReplaceValue]));
    Return := System.AtomicCmpExchange(Target, ReplaceValue, Comparand, Succeeded);
    WriteLn(Format('After calling:  Target: %d, Comparand: %d, Return: %d, Succeeded: %s',
      [Target, Comparand, Return, BoolToStr(Succeeded, true)]));

    WriteLn;
    WriteLn('InterlockedCompareExchange');
    WriteLn;

    Target := 1;
    Comparand := 0;
    WriteLn(Format('Initial values: Target: %d, Comparand: %d, ReplaceValue : %d',
      [Target, Comparand, ReplaceValue]));
    Return := InterlockedCompareExchange(Target, ReplaceValue, Comparand);
    WriteLn(Format('After calling:  Target: %d, Comparand: %d, Return: %d',
      [Target, Comparand, Return]));

    WriteLn;

    Target := 1;
    Comparand := 1;
    WriteLn(Format('Initial values: Target: %d, Comparand: %d, ReplaceValue : %d',
      [Target, Comparand, ReplaceValue]));
    Return := InterlockedCompareExchange(Target, ReplaceValue, Comparand);
    WriteLn(Format('After calling:  Target: %d, Comparand: %d, Return: %d',
      [Target, Comparand, Return]));
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Siehe auch