Блокировки и конкурентный доступ

// Отделите правило языка от удачного запуска CriticalInvariant.
program CriticalInvariant;
uses System.SyncObjs;
var Lock: TCriticalSection; Balance: Integer;
procedure Transfer(Delta: Integer);
begin
  Lock.Acquire;
  try
    if Balance + Delta < 0 then Exit;
    Inc(Balance, Delta);
  finally
    Lock.Release;
  end;
end;
begin end.

// Много потоков могут помещать сообщения в потокобезопасную очередь; итог меняет один владелец.
program MessageOwner;
{$APPTYPE CONSOLE}
uses System.Generics.Collections, System.SysUtils, System.Types;
type
  TStateOwner = class
  private
    FPending: TThreadedQueue<Integer>;
    FTotal: Integer;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Enqueue(Value: Integer);
    procedure ProcessAll;
  end;
constructor TStateOwner.Create;
begin
  inherited;
  FPending := TThreadedQueue<Integer>.Create(100, 0, 0);
end;
destructor TStateOwner.Destroy;
begin
  FPending.Free;
  inherited;
end;
procedure TStateOwner.Enqueue(Value: Integer);
begin
  if FPending.PushItem(Value) <> wrSignaled then
    raise EInvalidOpException.Create('queue is full');
end;
procedure TStateOwner.ProcessAll;
var
  Value: Integer;
begin
  while FPending.PopItem(Value) = wrSignaled do
    Inc(FTotal, Value);
  Writeln(FTotal);
end;
var
  Owner: TStateOwner;
begin
  Owner := TStateOwner.Create;
  try
    Owner.Enqueue(2);
    Owner.Enqueue(3);
    Owner.ProcessAll;
  finally
    Owner.Free;
  end;
end.

// Проследите фактическое поведение ContentionMeasure.
program ContentionMeasure;
uses System.Diagnostics, System.SyncObjs;
var
  Lock: TCriticalSection;
  Watch: TStopwatch;
procedure ReadShared;
begin
  Watch := TStopwatch.StartNew;
  Lock.Acquire;
  try
    Writeln('wait ticks=', Watch.ElapsedTicks);
  finally
    Lock.Release;
  end;
end;
begin
  Lock := TCriticalSection.Create;
  try
    ReadShared;
  finally
    Lock.Free;
  end;
end.

// Проследите фактическое поведение LockOrder.
program LockOrder;
uses System.SyncObjs;
var A, B: TCriticalSection;
procedure First;
begin
  A.Acquire;
  try
    B.Acquire;
    try { update both } finally B.Release; end;
  finally A.Release; end;
end;
procedure Second;
begin
  B.Acquire;
  try
    A.Acquire;
    try { update both } finally A.Release; end;
  finally B.Release; end;
end;
begin end.

// Определите реальную гарантию в BoundedQueue.
program BoundedQueue;
uses System.Generics.Collections, System.SyncObjs;
type
  TWorkQueue = class
    FQueue: TThreadedQueue<string>;
  public
    constructor Create;
    destructor Destroy; override;
  end;
constructor TWorkQueue.Create;
begin
  FQueue := TThreadedQueue<string>.Create(100, 1000, 1000);
end;
destructor TWorkQueue.Destroy;
begin
  FQueue.DoShutDown;
  FQueue.Free;
  inherited;
end;
begin end.

// Определите реальную гарантию в MonitorWait.
program MonitorWait;
var
  Gate: TObject;
  Ready: Boolean;
procedure WaitReady;
begin
  TMonitor.Enter(Gate);
  try
    while not Ready do
      TMonitor.Wait(Gate);
  finally
    TMonitor.Exit(Gate);
  end;
end;
procedure SignalReady;
begin
  TMonitor.Enter(Gate);
  try
    Ready := True;
    TMonitor.PulseAll(Gate);
  finally
    TMonitor.Exit(Gate);
  end;
end;
begin
  Gate := TObject.Create;
  try
    SignalReady;
    WaitReady;
  finally
    Gate.Free;
  end;
end.