10.3 Critical sections

When programming threads, it is sometimes necessary to avoid concurrent access to certain resources, or to avoid having a certain routine executed by two threads. This can be done using a Critical Section. The FPC heap manager uses critical sections when multithreading is enabled.

The TRTLCriticalSection type is an Opaque type; it depends on the OS on which the code is executed. It should be initialized before it is rst used, and should be disposed of when it is no longer necessary.

To protect a piece of code, a call to EnterCriticalSection should be made: When this call returns, it is guaranteed that the current thread is the only thread executing the subsequent code. The call may have suspended the current thread for an indenite time to ensure this.

When the protected code is nished, LeaveCriticalSection must be called: this will enable other threads to start executing the protected code. To minimize waiting time for the threads, it is important to keep the protected block as small as possible.

The denition of these calls is as follows:

procedure InitCriticalSection(var cs: TRTLCriticalSection);
procedure DoneCriticalSection(var cs: TRTLCriticalSection);
procedure EnterCriticalSection(var cs: TRTLCriticalSection);
procedure LeaveCriticalSection(var cs: TRTLCriticalSection);

The meaning of these calls is again almost obvious:

InitCriticalSection: Initializes a critical section. This call must be made before either EnterCrititicalSection or LeaveCriticalSection is used.
DoneCriticalSection: Frees the resources associated with a critical section. After this call neither EnterCrititicalSection nor LeaveCriticalSection may be used.
EnterCriticalSection: When this call returns, the calling thread is the only thread running the code between the EnterCriticalSection call and the following LeaveCriticalsection call.
LeaveCriticalSection: Signals that the protected code can be executed by other threads.

Note that the LeaveCriticalsection call must be executed. Failing to do so will prevent all other threads from executing the code in the critical section. It is therefore good practice to enclose the critical section in a Try..finally block. Typically, the code will look as follows:

Var
  MyCS : TRTLCriticalSection;

Procedure CriticalProc;

begin
  EnterCriticalSection(MyCS);
  Try
    // Protected Code
  Finally
    LeaveCriticalSection(MyCS);
  end;
end;

Procedure ThreadProcedure;

begin
  // Code executed in threads...
CriticalProc;
  // More Code executed in threads...
end;

begin
  InitCriticalSection(MyCS);
  // Code to start threads.
  DoneCriticalSection(MyCS);
end.

[next] [prev] [prev-tail] [front] [up]