On Optimistic and Pessimistic Initialization

When you want to initialize a shared resource in a multithreaded application, you have two possibilities to choose from – optimistic and pessimistic. The difference between them is visible from the pseudocode.

var
  Shared: T;

procedure OptimisticInitializer;
var
  temp: T;
begin
  if not assigned(Shared) then begin
    temp := T.Create;
    if not AtomicallyTestAndStore(Shared, nil, temp) then
      temp.Free;
  end;
end;

procedure PessimisticInitializer;
begin
  if not assigned(Shared) then begin
    Lock;
    try
      if not assigned(Shared) then
        Shared := T.Create;
    finally Unlock; end;
  end;
end;

Both approaches have one common point – they only initialize the shared resource if it is not already initialized. After that, the execution follows two completely different paths.

Optimistic initializer always creates new resource. Then it tries to store the resource in the shared variable in an atomic matter and if that fails, it throws the temporary resource away. [Read Atomic Interface Initialization for detailed info.] This means that at some point in time, multiple copies of the resource may be created, but all except one will be promptly destroyed.

Advantage: No locking (only microlocking on the CPU level).
Disadvantage: Duplicate resources may be created at some point.

Pessimistic initializer first locks the resource (using some form of a critical section), then tests again if the resource is still uninitialized (another thread may have created it just before Lock was called) and then creates the resource and unlocks the lock.

Advantage: Only a single resource is created.
Disadvantage: Locking, additional critical section.

It is unclear which approach is better. Although locking slows the application more than microlocking, creating duplicate resources may slow it down even more. On the other hand, pessimistic initializer requires additional lock, but that won’t make much difference if you don’t create millions of shared objects. In most cases, shared resource will stay initialized most of the time, initialization code will be rarely called (possibly just once per shared object) and the complexity of initializer will not change the program performance in any meaningful way so the choice of initializer will manly be a matter of personal taste.

OmniThreadLibrary supports both optimistic and pessimistic approach, former through the Atomic<T> class and latter through the Locked<T> class.

var
  optimistic: T;
  pessimistic: Locked<T>;

Atomic<T>.Initialize(optimistic, CreateT);
pessimistic.Initialize(CreateT);

[CreateT is just a function that creates new instance of type T.]

The optimistic initializer expects the T to be a class or an interface. The pessimistic initializer is not limited in any way – you can use it with any type supported by the compiler. You could, for example, pessimistically initialize an integer.

var
  a1: Locked<integer>;

  a1.Initialize(function: integer begin Result := 42 end);

An interesting reading on initializers in .NET is Coordination Data Structures – LazyInit<T>, written by Pedram Rezaei.