System.AtomicCmpExchange

• Übergeordnet: System

Delphi

function AtomicCmpExchange(var Target; NewValue: <Integer or NativeInt or Pointer>; Comparand: <Integer or NativeInt or Pointer>; [out Succeeded: Boolean]): Integer; overload;
function AtomicCmpExchange(var Target; NewValue: <Integer or NativeInt or Pointer>; Comparand: <Integer or NativeInt or Pointer>; [out Succeeded: Boolean]): Int64; overload;
function AtomicCmpExchange(var Target; NewValue: <Integer or NativeInt or Pointer>; Comparand: <Integer or NativeInt or Pointer>; [out Succeeded: Boolean]): Pointer; overload;
function AtomicCmpExchange(var Target; NewValue: <Integer or NativeInt or Pointer>; Comparand: <Integer or NativeInt or Pointer>; [out Succeeded: Boolean]): NativeInt; overload;
function AtomicCmpExchange(var Target; NewValue: <Integer or NativeInt or Pointer>; Comparand: <Integer or NativeInt or Pointer>; [out Succeeded: Boolean]): Integer; overload;
function AtomicCmpExchange(var Target; NewValue: <Integer or NativeInt or Pointer>; Comparand: <Integer or NativeInt or Pointer>; [out Succeeded: Boolean]): Int64; overload;
function AtomicCmpExchange(var Target; NewValue: <Integer or NativeInt or Pointer>; Comparand: <Integer or NativeInt or Pointer>; [out Succeeded: Boolean]): Pointer; overload;
function AtomicCmpExchange(var Target; NewValue: <Integer or NativeInt or Pointer>; Comparand: <Integer or NativeInt or Pointer>; [out Succeeded: Boolean]): NativeInt; 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

• System.AtomicExchange
• System.AtomicDecrement
• System.AtomicIncrement
• Migrieren von Delphi-Code zu mobilen Anwendungen vom Desktop aus
• DCCIOS32.EXE: Der Delphi-Compiler für den iOS-Simulator
• DCCIOSARM.EXE: Der Delphi-Compiler für 32-Bit-iOS-Geräte
• DCCIOSARM64.EXE: Der Delphi-Compiler für 64-Bit-iOS-Geräte