Question

我在Delphi 7中维护一个应用程序，它有一个可以用CrossKylix编译的服务器部分。对于性能问题，我正在使用多线程和关键部分。

我创建了一个控制台应用程序，创建了100个TThread，每个TThread计算了一个斐波纳契。然后我添加一个临界区，这样一次只有一个线程计算一个斐波那契。正如预期的那样，没有Critical部分，应用程序会更快。

然后我创建了一个创建100 TThread的控制台应用程序，每个TThread在本地TStringList中添加单词并对TStringList进行排序。然后我添加一个临界区，以便一次只执行一个线程。在Windows上，正如预期的那样，应用程序运行得更快，没有“关键”部分在Linux上，CriticalSection版本的运行速度比没有Critical Section的版本快2倍。

Linux上的CPU是具有6个内核的AMD Opteron，因此应用程序应该受益于多线程。

有人可以解释为什么带有Critical部分的版本更快？

编辑（添加一些代码）

线程创建和等待

tmpDeb := Now;
i := NBTHREADS;
while i > 0 do
begin
    tmpFiboThread := TFiboThread.Create(true);
    tmpFiboThread.Init(i, ParamStr(1) = 'Crit');
    Threads.AddObject(IntToStr(i), tmpFiboThread);
    i := i-1;
end;

i := 0;
while i < NBTHREADS do
begin
    TFiboThread(Threads.Objects[i]).Resume;
    i := i+1; 
end;

i := 0;
while i < NBTHREADS do
begin
    TFiboThread(Threads.Objects[i]).WaitFor;
    i := i+1; 
end;

WriteLn('Traitement total en : ' + inttostr(MilliSecondsBetween(Now, tmpDeb)) + ' milliseconds');

TThread和Critical部分使用

    type TFiboThread = class(TThread)
        private
            n : Integer;
            UseCriticalSection : Boolean;
        protected
            procedure Execute; override;

        public      
            ExecTime : Integer;

            procedure Init(n : integer; WithCriticalSect : Boolean);
    end;

var
  CriticalSection : TCriticalSection;

implementation

uses DateUtils;

function fib(n: integer): integer;
var
  f0, f1, tmpf0, k: integer;
begin
    f1 := n + 100000000;
    IF f1 >1 then
    begin
      k := f1-1;
      f0 := 0;
      f1 := 1;
      repeat
        tmpf0 := f0;
        f0 := f1;
        f1 := f1+tmpf0;
        dec(k);
      until k = 0;
    end
    else
      IF f1 < 0 then
        f1 := 0;
    fib := f1;
end;

function StringListSort(n: integer): integer;
var
  tmpSL : TStringList;
  i : Integer;
begin
    tmpSL := TStringList.Create;
    i := 0;
    while i < n + 10000 do
    begin
        tmpSL.Add(inttostr(MilliSecondOf(now)));
        i := i+1;
    end;
    tmpSL.Sort;

    Result := StrToInt(tmpSL.Strings[0]);
    tmpSL.Free;
end;

{ TFiboThread }

procedure TFiboThread.Execute;
var
  tmpStr : String;
  tmpDeb : TDateTime;
begin
    inherited;

    if Self.UseCriticalSection then
        CriticalSection.Enter;

    tmpDeb := Now;

    tmpStr := inttostr(fib(Self.n));
    //tmpStr := inttostr(StringListSort(Self.n));

    Self.ExecTime := MilliSecondsBetween(Now, tmpDeb);

    if Self.UseCriticalSection then
        CriticalSection.Leave;

    Self.Terminate;
end;

procedure TFiboThread.Init(n : integer; WithCriticalSect : Boolean);
begin
    Self.n := n;
    Self.UseCriticalSection := WithCriticalSect;
end;



initialization
    CriticalSection := TCriticalSection.Create;

finalization
    FreeAndNil(CriticalSection);

编辑2

我读了这个why-using-more-threads-makes-it-slower-than-using-less-threads，据我所知，上下文切换使用Linux和Kylix编译比使用win32进行上下文切换需要更多的CPU资源。

Answer 1

排序字符串列表有很多内存分配，即调用内存管理器。内存管理器本身是线程安全的，意味着它内部使用某种关键部分。因此，如果有100个线程在没有全局关键部分的情况下运行模拟，那么它们将完成对MM的调用，这意味着内部锁定（而不是全局关键部分的一个锁定）

这就是为什么纯fibonacci功能（没有stringlist构建和排序）按预期工作 - 它没有内部隐藏锁

kylix上的多线程和TCriticalSection

1 个答案: