Multithreading 多线程bubblesort。与delphi 7配合很好，但与Lazarus配合不好？编译器错误？

首先，我想向您展示我的代码：

unit BSort;

{==============================================================================}

{$mode objfpc}{$H+}

{==============================================================================}

interface

{==============================================================================}

uses
  Classes, SysUtils;

{==============================================================================}

type
  TcompFunc = function(AValue1, AValue2 : Integer) : boolean;
  TIntegerArray = array of integer;
  PIntegerArray = ^TIntegerArray;

{==============================================================================}

procedure BubbleSort(var AMatrix : TIntegerArray; ACompFunc : TCompFunc);
function V1LargerV2(AValue1, AValue2 : Integer) : Boolean;

{==============================================================================}

implementation

{==============================================================================}

procedure Swap(var AValue1, AValue2 : Integer);
var
  Tmp : Integer;
begin
  Tmp := AValue1;
  AValue1 := AValue2;
  AValue2 := Tmp;
end;

{==============================================================================}

function V1LargerV2(AValue1, AValue2 : Integer) : Boolean;
begin
  result := AValue1 > AValue2;
end;

{------------------------------------------------------------------------------}

procedure BubbleSort(var AMatrix : TIntegerArray; ACompFunc : TCompFunc);
var
  i,j : Word;
begin
  for i := Low(AMatrix) to High(AMatrix) - 1 do
    for j := Low(AMatrix) to High(AMatrix) - 1 do
    begin
      if ACompFunc(AMatrix[j], AMatrix[j+1]) then
        Swap(AMatrix[j], AMatrix[j+1]);
    end;
end;

{==============================================================================}

end.

unit MultiThreadSort;

{==============================================================================}

{$mode objfpc}{$H+}

{==============================================================================}

interface

{==============================================================================}

uses
  Classes, SysUtils, BSort;

{==============================================================================}

type
  TSortThread = class(TThread)
      FMatrix : PIntegerArray;
    protected
      procedure Execute; override;
    public
      constructor Create(var AMatrix : TIntegerArray);
    public
      property Terminated;
  end;

{==============================================================================}

implementation

{==============================================================================}

constructor TSortThread.Create(var AMatrix : TIntegerArray);
begin
  inherited Create(False);
  FreeOnTerminate := False;
  FMatrix := @AMatrix;
end;

{------------------------------------------------------------------------------}

procedure TSortThread.Execute;
begin
  BubbleSort(FMatrix^, @V1LargerV2);
end;

{==============================================================================}

end.


program sortuj;

{==============================================================================}

{$mode objfpc}{$H+}

{==============================================================================}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes, SysUtils, MultiThreadSort, BSort, Crt;

{==============================================================================}

const
  Zakres = 20;

{==============================================================================}

var
  Start  : Double;
  Stop   : Double;
  Time   : array[0..1] of Double;
  Matrix : array[0..9] of TIntegerArray;
  i,j    : Word;

{==============================================================================}

procedure Sort(var AMatrix : TIntegerArray);
var
  SortThread : array[0..1] of TSortThread;
  Matrix     : array[0..1] of TIntegerArray;
  Highest    : Integer;
  i, j, k    : Word;
begin
  // Znalezienie największej liczby w tablicy.
  Highest := Low(Integer);
  for i := Low(AMatrix) to High(AMatrix) do
    if AMatrix[i] > Highest then
      Highest := AMatrix[i];

  // Zerowanie tablic pomocniczych.
  for i := 0 to 1 do
    SetLength(Matrix[i], 0);

  // Podział tablicy do sortowania na dwie tablice:
  // - pierwsza od najniższej do połowy najwyższej liczby.
  // - druga od połowy najwyższej do najwyższej liczby.
  j := 0;
  k := 0;
  for i := Low(AMatrix) to High(AMatrix) do
    if AMatrix[i] < Highest div 2 then
    begin
      SetLength(Matrix[0], Length(Matrix[0]) + 1);
      Matrix[0,j] := AMatrix[i];
      Inc(j);
    end
    else
    begin
      SetLength(Matrix[1], Length(Matrix[1]) + 1);
      Matrix[1,k] := AMatrix[i];
      Inc(k);
    end;

  //Tworzenie i start wątków sortujacych.
  for i := 0 to 1 do
    SortThread[i] := TSortThread.Create(Matrix[i]);

  // Oczekiwanie na zakończenie watków sortujących.
  //for i := 0 to 1 do
  //  SortThread[i].WaitFor;
  //  while not SortThread[i].Terminated do
  //    sleep(2);

  Sleep(10);
  SortThread[0].WaitFor;
  Sleep(10);
  SortThread[1].WaitFor;
  Sleep(10);

  // Zwalnianie wątków sortujacych.
  for i := 0 to 1 do
    FreeAndNil(SortThread[i]);

  // Łączenie tablic pomocniczych w jedną.
  k := 0;
  for i := 0 to 1 do
    for j := Low(Matrix[i]) to High(Matrix[i]) do
    begin
      AMatrix[k] := Matrix[i,j];
      Inc(k);
    end;
end;

{==============================================================================}

begin
  Randomize;
  ClrScr;

  for i := 0 to 9 do
  begin
    SetLength(Matrix[i],Zakres);
    Write('Losowanie ', i, ' tablicy...');
    for j := 0 to Zakres - 1 do
      Matrix[i,j] := Random(100) - 50;
    Writeln('Wylosowana');
  end;

  Writeln;
  Start := TimeStampToMsecs(DateTimeToTimeStamp(Now));
  for i := 0 to 9 do
  begin
    Write('Sortowanie ', i, ' tablicy...');
    BubbleSort(Matrix[i],@V1LargerV2);
    Writeln('Posortowana');
  end;
  Stop := TimeStampToMsecs(DateTimeToTimeStamp(Now));
  Time[0] := Stop - Start;

  Writeln;
  for i := 0 to 9 do
  begin
    Write('Losowanie ',i,' tablicy...');
    for j := 0 to Zakres do
      Matrix[i,j] := Random(100) - 50;
    Writeln('Wylosowana');
  end;

  Writeln;
  Start := TimeStampToMsecs(DateTimeToTimeStamp(Now));
  for i := 0 to 9 do
  begin
    Write('Sortowanie dwuwatkowe ', i, ' tablicy...');
    Sort(Matrix[i]);
    Writeln('Posortowana');
  end;
  Stop := TimeStampToMsecs(DateTimeToTimeStamp(Now));
  Time[1] := Stop - Start;

  Writeln;
  Writeln('Sortowanie bąbelkowe : ',Time[0]);
  Writeln('Sortowanie dwuwatkowe: ',Time[1]);
  Readln;
end.

单元b排序；
{==============================================================================}
{$mode objfpc}{$H+}
{==============================================================================}
接口
{==============================================================================}
使用
类，sysutil；
{==============================================================================}
类型
TcompFunc=函数（AValue1，AValue2:整数）：布尔值；
TinteGrarray=整数数组；
PIntegerArray=^TIntegerArray；
{==============================================================================}
程序BubbleSort（var AMatrix:TinteGraray；ACompFunc:TCompFunc）；
函数V1LargerV2（AValue1，AValue2:Integer）：布尔型；
{==============================================================================}
实施
{==============================================================================}
过程交换（var AValue1，AValue2：整数）；
变量
Tmp：整数；
开始
Tmp:=AValue1；
AValue1:=AValue2；
AValue2:=Tmp；
结束；
{==============================================================================}
函数V1LargerV2（AValue1，AValue2:Integer）：布尔型；
开始
结果：=AValue1>AValue2；
结束；
{------------------------------------------------------------------------------}
程序BubbleSort（var AMatrix:TinteGraray；ACompFunc:TCompFunc）；
变量
i、 j:单词；
开始
对于i:=低（AMatrix）到高（AMatrix）-1 do
对于j:=低（AMatrix）到高（AMatrix）-1 do
开始
如果是ACompFunc（AMatrix[j]，AMatrix[j+1]），那么
交换（AMatrix[j]，AMatrix[j+1]）；
结束；
结束；
{==============================================================================}
结束。
单元多线程排序；
{==============================================================================}
{$mode objfpc}{$H+}
{==============================================================================}
接口
{==============================================================================}
使用
类、SysUtils、BSort；
{==============================================================================}
类型
TSortThread=class（TThread）
FMatrix:Pintegerray；
受保护的
程序执行；推翻
公众的
构造函数创建（var-AMatrix:tintegerray）；
公众的
财产终止；
结束；
{==============================================================================}
实施
{==============================================================================}
构造函数TSortThread.Create（var AMatrix:tintegerray）；
开始
继承创建（False）；
FreeOnTerminate:=False；
FMatrix:=@AMatrix；
结束；
{------------------------------------------------------------------------------}
程序TSortThread.Execute；
开始
BubbleSort（FMatrix^，@V1LargerV2）；
结束；
{==============================================================================}
结束。
程序sortuj；
{==============================================================================}
{$mode objfpc}{$H+}
{==============================================================================}
使用
{$IFDEF UNIX}{$IFDEF UseCThreads}
cthreads，
{$ENDIF}{$ENDIF}
类、SysUtils、多线程排序、BSort、Crt；
{==============================================================================}
常数
Zakres=20；
{==============================================================================}
变量
开始：双倍；
停止：加倍；
时间：双精度数组[0..1]；
矩阵：TinteGraray的数组[0..9]；
i、 j:单词；
{==============================================================================}
程序排序（var-AMatrix:tintegerray）；
变量
SortThread:TSortThread的数组[0..1]；
矩阵：TinteGraray的数组[0..1]；
最高：整数；
i、 j，k：单词；
开始
//Znalezienie największej liczby w Tablici。
最高：=低（整数）；
对于i:=低（AMatrix）到高（AMatrix）do
如果AMatrix[i]>最高，则
最高：=AMatrix[i]；
//Zerowanie tablic pomocniczych。
对于i:=0到1 do
集合长度（矩阵[i]，0）；
//Podziałtablicy do sortowania na dwie tablice：
//-pierwsza od najniższej do połowy najwyższej liczby。
//-najwyższej do najwyższej liczby药店。
j:=0；
k:=0；
对于i:=低（AMatrix）到高（AMatrix）do
如果AMatrix[i]<最高div 2，则
开始
设置长度（矩阵[0]，长度（矩阵[0]）+1）；
矩阵[0，j]：=AMatrix[i]；
公司（j）；
结束
其他的
开始
设置长度（矩阵[1]，长度（矩阵[1]）+1）；
矩阵[1，k]：=AMatrix[i]；
公司(k),；
结束；
//Tworzenie我从wątków sortujacych开始。
对于i:=0到1 do
SortThread[i]：=TSortThread.Create（矩阵[i]）；
//Oczekiwanie na zakończenie watków sortujących。
//对于i:=0到1 do
//SortThread[i].WaitFor；
//而不是SortThread[i]。终止了do
//睡眠（2）；
睡眠（10）；
SortThread[0]。WaitFor；
睡眠（10）；
SortThread[1]。WaitFor；
睡眠（10）；
//茨瓦尼亚尼·wątkow sortujacych。
对于i:=0到1 do
FreeAndNil（SortThread[i]）；
//我是犹太人。
k:=0；
对于i:=0到1 do
对于j:=低（矩阵[i]）到高（矩阵[i]）do
开始
AMatrix[k]：=矩阵[i，j]；
公司(k),；
结束；
结束；
{==============================================================================}
开始
随机化；
clrsc；
对于i:=0到9 do
开始
集合长度（矩阵[i]，Zakres）；
写（'Losowanie'，我，'Tablici…'）；
对于j:=0到Zakres-1 do
矩阵[i，j]：=随机（100）-50；
书面形式（“Wylosowana”）；
结束；
书面语；
开始：=TimeStampToMsecs（DateTimeToTimeStamp（现在））；
对于i:=0到9 do
开始
写（'Sortowanie'，我，'tablicy…'）；
BubbleSort（矩阵[i]，@V1LargerV2）；
书面语（“Posortowana”）；
结束；
停止：=TimeStampToMsecs（DateTimeToTi
program project1;    
uses
  Classes, Crt;    
type
  TSortThread = class(TThread)
    protected
      procedure Execute; override;
    public
      constructor Create;
  end;

constructor TSortThread.Create;
begin
  inherited Create(False);
  FreeOnTerminate := False;
end;

procedure TSortThread.Execute;
begin
end;

var
  SortThread :  TSortThread;
begin
  Write('test ...');
  SortThread := TSortThread.Create;
  Writeln('created');
  SortThread.WaitFor;
  SortThread.Free;
  Writeln('complete');
  Readln;
end.