Delphi Tips And Tricks: CoInitialize/CoUninitialize Part III

Previously I talked about using CoInitialize and CoUninitialize in very simple situations, a single threaded console application. If you havn't read those posts you can read Part I here, Part II here and the adendum to Part II here. So for this post I'm going to demonstrate the use of CoInitializeEx and CoUninitialize in a multithreaded environment.

This demo consists of two files, two instances of a thread and a couple loops to give your system enough time to actually allow some processing to happen. Below find the code for this demo:

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  ActiveX,
  MyThread in 'MyThread.pas';

var
  Thread1, Thread2: TMyThread;
  Success: HResult;
begin
  Success := CoInitializeEx(nil, COINIT_APARTMENTTHREADED);

  try
    Thread1 := TMyThread.Create(False, 'thread1');
    Thread2 := TMyThread.Create(False, 'thread2');

    try
      // Note my implementation could have a
      // problem if DoStuff completes too quicly.
      DoStuff('main');
      Thread1.Wait;
      Thread2.Wait;
    finally
      Thread1.Free;
      Thread2.Free;
    end;
  finally
    CoUninit(Success, 'main');
  end;
end.

unit MyThread;

interface

uses
  Classes, SyncObjs;

type
  TMyThread = class(TThread)
  private
    FLock: TCriticalSection;
    FText: string;
  protected
    procedure Execute; override;
  public
    constructor Create(CreateSuspended: Boolean; const Text: string);
    destructor Destroy; override;
    procedure Wait;
  end;

procedure CoInitStatus(Success: HResult);
procedure CoUninit(Success: HResult; const Text: string);
procedure DoStuff(const Text: string);

implementation

uses
  SysUtils, ActiveX, Windows;

procedure CoInitStatus(Success: HResult);
begin
  case Success of
    S_OK, S_FALSE: WriteLn('CoInitialize success');
    RPC_E_CHANGED_MODE, E_INVALIDARG,
    E_OUTOFMEMORY, E_UNEXPECTED: WriteLn('CoInitialize failed');
  end;
end;

procedure CoUninit(Success: HResult; const Text: string);
begin
  case Success of
    S_OK, S_FALSE: CoUninitialize;
  end;
end;

procedure DoStuff(const Text: string);
var
  Index: Integer;
begin
  for Index := 0 to 10000 do
    WriteLn(Text + ' ' + IntToStr(Index));
end;

{ TMyThread }

constructor TMyThread.Create(CreateSuspended: Boolean; const Text: string);
begin
  FLock := TCriticalSection.Create;
  inherited Create(CreateSuspended);
  FText := Text;
  UniqueString(FText);
end;

destructor TMyThread.Destroy;
begin
  FLock.Free;
  inherited;
end;

procedure TMyThread.Execute;
var
  Success: HResult;
begin
  FLock.Acquire;
  Success := CoInitializeEx(nil, COINIT_MULTITHREADED);

  try
    DoStuff(FText);
  finally
    CoUninit(Success, FText);
    FLock.Release;
  end;
end;

procedure TMyThread.Wait;
begin
  FLock.Acquire;
  FLock.Release;
end;

end.

I want to bring your attention to two things. First, notice my use of the return value from CoInitializeEx. And second, the first thread to call CoInitializeEx (located in the main function) is also the last one to call CoUninitialize by use of the the function TMyThread.Wait.

I would talk more about it but I think the code explains everything. So read the source and if you have questions ask.

Update: I have moved the critical section to occur before the constructor to TThread to avoid a race condition and called UniqueString on the string passed to the thread as pointed out by Anders Melander.