1

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

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

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

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

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

编辑（添加一些代码）

线程创建和等待

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 和临界区使用

    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

我读了这个为什么使用更多线程使得它比使用更少线程慢，所以据我了解，Linux 和 Kylix 编译的上下文切换比 win32 的上下文切换花费更多的 CPU 资源。

4

1 回答 1

0

排序字符串列表有很多内存分配，即调用内存管理器。内存管理器本身是线程安全的，这意味着它在内部使用了某种临界区。因此，如果一百个线程在没有全局临界区的情况下同时运行，它们将对 MM 进行调用，这意味着内部锁（而不是全局临界区的一个锁）

这就是为什么纯斐波那契函数（没有字符串列表构建和排序）按预期工作的原因——它没有内部的隐藏锁

于 2015-04-28T08:42:05.427 回答