1:
2:
3:
4:

{Nur zur veranschaulichung, im Programm werden die neuen Daten,
welche Thread A ermittelt hat, an das Array in Thread B angehängt.}

ThreadB.FileInfo := ThreadA.FileInfo;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

procedure TMyThread.Execute;
begin
  while not Terminated and HoleNeueAufgabe do
  begin
    FAufgabe.Execute;
  end;
end;

procedure TDateiAufgabe.Execute;
begin
  Lies1GBDaten;
  ErzeugeNeueDateiAufgabeWennWeitereDateien;
  UmfangreicheBerechnungen;
  ErgebnisAbliefern;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:

{typen}
type
  TContentQueuePart = class
    public
      Content: TContent;
      Next: TContentQueuePart;
end;
 TContentQueue = class
  private
    Head, Tail: TContentQueuePart;
  public
    function IsEmpty: Boolean;
    procedure add( aContent: TContent );
    function Take: TContent;
  end;
{proceduren}
function TContentQueue.IsEmpty: Boolean;
begin
Result := (Head=nil) or not Assigned( Head );
end;

procedure TContentQueue.add( aContent: TContent );
begin
if IsEmpty then
  begin
  Head := TContentQueuePart.Create;
  Head.Content := aContent;
  Tail := Head;
  //Tail.Next := nil;  // not so important
  end
else
  begin
  Tail.Next := TContentQueuePart.Create;
  Tail := Tail.next;
  Tail.Content := aContent;
  //Tail.Next := nil;  // not so important
  end;
end;


function TContentQueue.Take: TContent;
begin
if IsEmpty then
  begin
  Result := nil;
  end
else
  begin
  Result := Head.Content;
  // Speicher vom Pointer freigeben und ehemaligen Head freigeben
  // OHNE Content zu löschen ?
  Head := Head.next;
  end;
end;					

1:
2:
3:
4:
5:
6:

function TMyThreadedQueue.Count : integer;
begin
  Lock; //Sperrt den Zugriff auf die Queue
  Result:=Count; //Anzahl Einträge in der Queue ermitteln
  UnLock; //Entsperrt die Queue - und der Ärger beginnt
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

...
var
  globalCriticalSection: TCriticalSection;
...
procedure TWorkThread.Execute;
var
  i: integer; //Routinemäßig eingefügt
  Data: TMyObject;
begin
  while not Terminated do
  begin
    globalCriticalSection.Enter;
    if MyQueue.Count > 0 then
    begin
      Data:=MyQueue.Pop;
      GlobalCriticalSection.Leave;
      ...
      Data.Free;
    end
    else
      GlobalCriticalSection.Leave;
  Sleep(500);
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

// im Konstruktor oder so:
TMonitor.SetSpinCount(MyQueue, 500);

procedure TWorkThread.Execute;
var
  Data: TMyObject;
begin
  while not Terminated do
  begin
    Data := nil;
    TMonitor.Enter(MyQueue);
    try
      if MyQueue.Count > 0 then
        Data := MyQueue.Pop;
    finally
      TMonitor.Exit(MyQueue);
    end;
    if Assigned(Data) then
    begin
      try
        ...
      finally
        Data.Free;
      end;
    end
    else
      Sleep(500);
  end;
end;					

1:
2:
3:
4:
5:

type
 leereKlasse = class
  private
  public
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

 
type 
  TMyClass = class()
    destructor Destroy; override;
  end;

destructor TMyClass.Destroy;
begin
  {hier eigene Sachen aufräumen/freigeben}

  {Sachen die im Vorfahren deklariert sind aufräumen}
  inherited;

  {eventuell auch hier eigene Sachen aufräumen/freigeben die nicht vom Vorfahren abhängig sind}
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

type
  TMyObject = class;

  TMyWriter = class
  private
    FStream: TStream;
  public
    procedure WriteToStream(AObject: TMyObject);
    property Stream: TStream read FStream write FStream;
  end;

procedure TMyObject.ExportTo(AStream: TStream);
var
  Writer: TMyWriter;
begin
  Writer := TMyWriter.Create;
  try
    Writer.Stream := AStream;
    Writer.WriteToStream(Self);
  finally
    Writer.Free;
  end;
end;