Delphi 知识并行编程 Tasks

自Delphi XE7以来，支持了并行编程库 Parallel Programming Library （PPL）。那么什么是PPL呢？PPL是Delphi RTL的一部分，它为多线程（或并行）编程提供了极大便利。

PPL适用于Delphi所支持的所有平台，并提供了一些先进的功能，如运行任务、连接任务、等待任务执行等。PPL不同 Thread，因为PPL 支持线程池，而且能够自动管理基于CPU上的负载），不用开发者关心和创建这些线程。

Delphi的PPL的使用相当简单，不需要对你的应用程序进行大的改动。在程序中加入System.Threading单元就可以这个库。

问题是我们如何以及何时可以使用PPL？嗯，在通常的情况下，你考虑一个任务，这并不意味着你将不再创建线程，但是，在许多情况下，你将使用排序的任务而非普通的线程。

使用简单的PPL，典型的代码示例如下：

procedure TMainForm.btnITaskClick(Sender: TObject);
var
  LTask: ITask;
begin
  LTask := TTask.Run(
  procedure
  var
    LResult: Integer;
  begin
    Sleep(1000); //并行做一些事情...
    LResult := Random(100); //获取执行结果 "result"
    //Queue 在主进程中执行（主进程执行方法一）
    TThread.Queue(nil,
      procedure
      begin
        TaskEnd(LResult); //TaskEnd 被主 UI 调用
      end);
     //或者 Synchronize 在主进程中执行（主进程执行方法二）
     TThread.Synchronize(TThread.Current,
       procedure
       begin
         ShowMessage ('Hello');
       end);

   end);
end;

上述函数使用起来非常简单，但是当有很多任务运行时，同时还需要处理异常时，事情就不是那么简单了。

此时，我们可以扩充下ITask接口，例如扩充为：Async.Run<T>。对Async.Run<T>方法的完整调用是由三个匿名的方法组成。

一个后台任务：这是一个返回某种数据的函数。它运行在在一个使用PPL任务的后台线程中运行。

一个成功回调：这是一个过程，用于获得后台任务的结果。它在主UI线程中运行。

一个错误回调：这是一个过程，用于获取由后台任务引发的异常，如果有的话。它在主UI线程中运行。

整体结构看起来如下：

Async.Run<String>(
function: String
begin
//这是 "后台 "匿名方法。运行在后台线程中运行，其结果被传递到
//到 "成功 "回调过程中。
//在当前架构情况下，结果是一个字符串。
end,
procedure(const Value: String)
begin
//这是 "成功 "回调。在UI线程中运行并
//获取 "后台 "匿名方法的结果。
end,
procedure(const Ex: Exception)
begin
//这是 "错误 "回调。
//在UI线程中运行，只有在 "后台 "匿名方法产生异常时才会被调用。
//"后台 "匿名方法引发异常时才会被调用。
end)

下面是一个完整的 AsyncTask.pas 单元：

unit AsyncTask;
interface
uses
  System.SysUtils,
  System.Threading; //The PPL unit
type
  //"后台 "任务
  TAsyncBackgroundTask<T> = reference to function: T;
  //"成功 "回调过程
  TAsyncSuccessCallback<T> = reference to procedure(const TaskResult: T);
  //"错误 "回调过程
  TAsyncErrorCallback = reference to procedure(const E: Exception);
  //如果用户没有提供默认的 "错误 "回调，则下面为默认的 "错误 "回调。
  TAsyncDefaultErrorCallback = reference to procedure(const E: Exception;
       const ExptAddress: Pointer);
  //主类
  Async = class sealed   //一个sealed （封闭）的类不能通过继承来扩展。
  public
    class function Run<T>(Task: TAsyncBackgroundTask<T>; 
    Success: TAsyncSuccessCallback<T>;
    Error  : TAsyncErrorCallback = nil): ITask;
  end;
var
  //默认的 "错误 "回调。它是一个公共变量，以便于可以覆盖默认行为
  DefaultTaskErrorHandler: TAsyncDefaultErrorCallback = nil;

implementation
uses
  System.Classes;

class function Async.Run<T>(Task: TAsyncBackgroundTask<T>; 
  Success: TAsyncSuccessCallback<T>;
  Error: TAsyncErrorCallback): ITask;
var
  LRes: T;
begin
  //“后台 ”任务从这里开始
  Result := TTask.Run(
  procedure
  var
    Ex: Pointer;
    ExceptionAddress: Pointer;
  begin
    Ex := nil;
    try
      LRes := Task(); //运行实际的任务
      if Assigned(Success) then
        begin
          //调用成功回调，传递结果。
          TThread.Queue(nil,
          procedure
            begin
              Success(LRes);
            end);
        end;
    except
       //让我们扩充异常对象。
      Ex := AcquireExceptionObject;
      ExceptionAddress := ExceptAddr;
      //在主线程上排队，调用错误回调。
      TThread.Queue(nil,
      procedure
      var
        LCurrException: Exception;
      begin
        LCurrException := Exception(Ex);
        try
          if Assigned(Error) then
            Error(LCurrException) //调用 "错误 "回调
          else
            DefaultTaskErrorHandler(LCurrException, ExceptionAddress);
        finally
          //释放异常对象。它是必要的，因为上面 "扩充 "了异常对象的自然寿命
          //异常对象的自然寿命超过了 except 块
          FreeAndNil(LCurrException);
        end;
      end);
    end; //except
  end); //task.run
end;

initialization

//这是默认的错误回调。
DefaultTaskErrorHandler :=
  procedure(const E: Exception; const ExceptionAddress: Pointer)
  begin
    ShowException(E, ExceptionAddress);
  end;
end.

上面我们知道Async.Run<T>是如何实现的，现在让我们看看如何使用它。打开一个主Form，放置一个

btnSimple按钮。

procedure TMainForm.btnSimpleClick(Sender: TObject);
begin
Async.Run<Integer>(
 function: Integer //在后台长时间运行
 begin
   Sleep(2000);
   Result := Random(100);
 end,
 procedure(const Value: Integer) //在用户界面中显示结果
  begin
    //将结果写在一个备忘录中
   Log('RESULT: ' + Value.ToString);
  end);
end;

在上面这种情况下，长的和假的操作是在匿名方法中执行的。作为一个返回整数的函数。当该函数结束时，其返回值被传递给另一个匿名方法，它是一个过程，并在UI线程中运行。

线程中运行，这样它就可以与用户进行交互。如果你运行该程序并点击这个按钮，你可以验证UI在长操作的时候没有被冻结。(实际上是一个Sleep(2000)的调用)运行时，UI没有被冻结。

放置第二个按钮为btnWithException，显示了如何处理可能在后台线程中引发的异常。

procedure TMainForm.btnWithExceptionClick(Sender: TObject);
begin
Async.Run<String>(
  function: String
  begin
    raise Exception.Create('This is an error message');
  end,
  procedure(const Value: String)
  begin
    // never called
  end,
  procedure(const Ex: Exception)
  begin
    Log('Exception: ' + sLineBreak + Ex.Message);
  end);
end;

相当简单，是不是？如果在后台出了问题，相关的异常对象被传递给错误回调。请注意，这个错误块

不是一个标准的Delphi异常块，它只是一个匿名方法，实际可以获得一个异常对象。

Delphi 知识 并行编程 Tasks

猜你喜欢

Delphi 知识并行编程 Tasks