delphi及C++ Builder异步处理与javascript

1、用于实现异步事件、异步方法、及其异步结果回调的可自定义的通用类型

2、你可引用以下基于接口化对象和异步结果的接口的抽象类，去实现异步方法或异步事件的自定义类

2.1、用于实现所有异步过程调用的基类TBaseAsyncResult

2.2、IAsyncResult异步请求结果

3、应用

3.1、我们不经意地习惯使用“同步模型”来控制代码的“顺序”执行流程

3.2、我们也习惯使用跨平台网络请求的“同步方法”来控制代码的“顺序”执行流程

3.3、如何在处理本地长耗时的网络请求中直接使用“异步模型”

4、javascript中的多线程

4.1、javascript是单线程的吗

4.2、javascript线程的执行上下文

本客户相关博文，喜欢的就点个赞，鼓励我的原创技术写作：

继上一篇《Delphi中的匿名方法》中谈到的匿名方法，本文进一步叙述用该匿名方法，实现的异步处理。仍然是从System.Classes底层系统的RTL运行时刻库说起：

1、用于实现异步事件、异步方法、及其异步结果回调的可自定义的通用类型


  TAsyncProcedureEvent = procedure (const ASyncResult: IAsyncResult) of object;
  TAsyncFunctionEvent = procedure (const ASyncResult: IAsyncResult; out Result: TObject) of object;
  TAsyncConstArrayProcedureEvent = procedure (const ASyncResult: IAsyncResult; const Params: array of const) of object;
  TAsyncConstArrayFunctionEvent = procedure (const ASyncResult: IAsyncResult; out Result: TObject; const Params: array of const) of object;
  TAsyncConstArrayProc = reference to procedure (const Params: array of const);
  TAsyncConstArrayFunc<TResult> = reference to function (const Params: array of const): TResult;

  TAsyncCallback = reference to procedure (const ASyncResult: IAsyncResult);
  TAsyncCallbackEvent = TAsyncProcedureEvent;

这些可自定义具体实现方法的通用类型，均提供了IAsyncResult异步请求接口供外部传入。你可以实例化它们并传入该参数。

2、你可引用以下基于接口化对象和异步结果的接口的抽象类，去实现异步方法或异步事件的自定义类

2.1、用于实现所有异步过程调用的基类TBaseAsyncResult

切勿将此实例作为实例引用传递。其目的是仅通过IAsyncResult接口引用此对象。不注意这一警告将导致无法预测的行为。请参阅Invoke方法的相关信息。

// System.Classes

  TBaseAsyncResult = class abstract(TInterfacedObject, IAsyncResult)
  private type
    TAsyncFlag = (Completed, Synchronous, Invoked, Cancelled, ForceSize = SizeOf(Integer) * 8 - 1); // make the size the same as Integer.
    TAsyncFlags = set of TAsyncFlag;
  private
    class constructor Create;
    class destructor Destroy;
  private
    FContext: TObject;
    FAsyncFlags: TAsyncFlags;
    FInvokingThread: TThreadID;
    FAsyncHandle: TMultiWaitEvent;
    procedure SetFlagsAtomic(Value, Mask: TAsyncFlags);
    function GetAsyncContext: TObject;
    function GetAsyncWaitEvent: TMultiWaitEvent;
    function GetCompletedSynchronously: Boolean;
    function GetIsCompleted: Boolean;
    function GetIsCancelled: Boolean;

    property AsyncWaitEvent: TMultiWaitEvent read GetAsyncWaitEvent;
  protected
    /// <summary>
    ///    This field will hold the acquired exception instance raised from the execution of the async method call.
    ///    It will be re-raised in the context of the invoking thread when the corresponding EndXXXX method is called.
    /// </summary>
    FInvokingException: TObject;
    /// <summary>
    ///    Override this method to dispatch the actual asynchronous procedure call. Descendants will use whatever context
    ///    or other state information contained in the instance to pass along to the procedure or function.
    /// </summary>
    procedure AsyncDispatch; virtual; abstract;
    /// <summary>
    ///    Override this method to perform any extra state or signaling required by the descendant. The descendant must
    ///    call this inherited method in order to properly set the completion and possibly signal the FAsyncHandle if
    ///    previously created. Failure to call this method can result in a dead lock or hang.
    /// </summary>
    procedure Complete; virtual;
    /// <summary>
    ///    Calls the actual target asynchronous method within the context of however it is scheduled. This could be
    ///    in the context of the main or GUI thread, or within a background thread. This depends on the implementation
    ///    of a specific asynchronous BeginXXXX method call.
    /// </summary>
    procedure DoAsyncDispatch;
    /// <summary>
    ///    Override this method to schedule the asynchronous procedure call in the manner specific to
    ///    a given instance, component or class. By default, this will schedule the async procedure onto
    ///    the main thread or execute the procedure synchronously if already on the main thread.
    ///    Other classes may schedule the procedure call into a separate thread or thread pool.
    /// </summary>
    procedure Schedule; virtual;
    /// <summary>
    ///    This constructor must be called from a descendent protected constructor.
    /// </summary>
    constructor Create(const AContext: TObject); overload;
    /// <summary>
    ///    Opaque user-supplied context. This context is available via the IAsyncResult.GetAsyncContext and descendents
    ///    if this class.
    /// </summary>
    property Context: TObject read FContext;
    ///  <summary>
    ///    Returns true if the operation can be cancelled. When cancelling the async operation, do any additional processing.
    ///  </summary>
    ///  <remarks>
    ///    By default, all Async cannot be cancelled. If descendants support cancelling asynchronous tasks,
    ///  they must override this behaviour and do the required processing;
    ///  </remarks>
    function DoCancel: Boolean; virtual;
  public
    /// <summary>
    ///    This constructor should never be called directly. Only descendents should be constructed using the
    ///    protected Create constructor above. Calling this constructor will raise an exception.
    /// </summary>
    constructor Create; overload;
    destructor Destroy; override;

    ///  <summary>
    ///    Cancels the async operation. Returns True when the asynchronous operation can be cancelled.
    ///  </summary>
    function Cancel: Boolean;
    /// <summary>
    ///    This method must be called prior in order to return itself as an IAsyncResult and actually schedule/invoke the
    ///    async call.
    /// </summary>
    function Invoke: IAsyncResult;
    /// <summary>
    ///    As long as the rules for only ever accessing this object through the IAsynsResult interface, this method
    ///    should only ever be called by a given "EndInvoke" method by casting the IAsyncResult interface instance
    ///    back to a specific descendant instance of this class. Never call this method directly outside the context
    ///    of an "EndInvoke" style method.
    /// </summary>
    procedure WaitForCompletion;

    /// <summary>
    ///    This method is called from VCL.TControl (and possibly other similar) descendants in order to call the
    ///    asynchronous procedure/function as a result of a posted Window message.
    /// </summary>
    class procedure Dispatch(const AsyncResult: TBaseAsyncResult); reintroduce; static; inline;

    ///  <summary>
    ///    Set to True when the asynchronous call has been cancelled.
    ///  </summary>
    property IsCancelled: Boolean read GetIsCancelled;
  end;

2.2、IAsyncResult异步请求结果

IAsyncResult异步请求结果：是系统级别的RTL运行时刻库，分别实现了跨平台的API接口，供你使用，它来自System.Types：

/// <summary>
/// 从THTTPClient或继承于它的TRestClient客户端网络通讯库的各种“BeginXXX”方法返回的接口，以提供代码的异步执行：
/// </summary>
IAsyncResult = interface
/// <summary>
/// 返回与此实例关联的用户指定上下文：
/// </summary>
function GetAsyncContext: TObject;
/// <summary>
///   返回一个适合用于阻塞的事件，直到异步调用完成。此事件也适合在列表中使用，以允许等待所有或任何信号。请参阅TMultiWaitEvent。WaitForXXX类函数：
/// </summary>
function GetAsyncWaitEvent: TMultiWaitEvent;
/// <summary>
///   如果给定的异步调用能够同步完成，则返回true。换句话说，特定调用在返回之前完成：
/// </summary>
function GetCompletedSynchronously: Boolean;
/// <summary>
///   异步调用完成时返回True：
/// </summary>
function GetIsCompleted: Boolean;
/// <summary>
///   取消异步调用后返回True：
/// </summary>
function GetIsCancelled: Boolean;
/// <summary>
///   取消异步操作。当可以取消异步调用时，返回True：
/// </summary>
function Cancel: Boolean;

/// <summary>
/// 只读属性：与此实例关联的用户指定上下文：
/// </summary>
property AsyncContext: TObject read GetAsyncContext;
/// <summary>
///   只读属性：事件。适用于阻塞，直到异步调用完成。此事件也适合在列表中使用，以允许等待所有或任何信号。请参阅TMultiWaitEvent。WaitForXXX类函数：
/// </summary>
property AsyncWaitEvent: TMultiWaitEvent read GetAsyncWaitEvent;
/// <summary>
///   只读属性：如果给定的异步调用能够同步完成，则设置为true。换句话说，特定调用在返回之前完成：
/// </summary>
property CompletedSynchronously: Boolean read GetCompletedSynchronously;
/// <summary>
///   只读属性：异步调用完成时设置为True：
/// </summary>
property IsCompleted: Boolean read GetIsCompleted;
/// <summary>
///   只读属性：取消异步调用后设置为True：
/// </summary>
property IsCancelled: Boolean read GetIsCancelled;
end;

你可以将IAsyncResult异步请求结果作为参数，传入章节1所叙述的各种异步事件或其回调类型（ 1、用于实现异步事件、异步方法、及异步结果回调的通用类）。

3、应用

3.1、我们不经意地习惯使用“同步模型”来控制代码的“顺序”执行流程

3.1.1、具名线程的同步

type
  ThreadWechat = class(TThread)
  private
    FifTerminated: Boolean;  //:外部控制参数_控制线程执行过程中强行中断并释放线程
    //F_GetTickCount_:Cardinal;//:_为了兼容IDE版本_重写继承函数GetTickCount

    FTerminated: Boolean;    //:继承字段_属性Terminated读
    /// <summary>线程当前的处理步骤:</summary>
    FStep:string;
    /// <summary>线程执行Execute中_当前微信实例在执行的_不采用匿名方法的函数:</summary>
    FProcObject:TThreadparamStrMethod;//procedure(var aStr:string;aCurWechat:TObject) of object;

    procedure _Sync_;
    /// <summary>线程执行Execute中_当前微信实例aCurWechat在执行什么API事务aStr:</summary>
    procedure doExecute_Api(var aStr:string;aCurWechat:TObject);
    /// <summary>线程同步Synchronize中_当前微信实例aCurWechat在同步什么API事务aStr:</summary>
    procedure doSynchronize_Api(var aStr:string;aCurWechat:TObject);
      //:以下,用上面通用Execute及其Synchronize替代_需要外部传入FApi的字符串及FcurWechat及FcurProgressBar来识别:

  protected
    /// <summary>微信类实例__是否终止了线程的执行:</summary>
    property Terminated: Boolean read FTerminated; //property ReturnValue:Integer read FReturnValue write FReturnValue;
    /// <summary>微信类实例__线程执行函数:</summary>
    procedure Execute; override;
    /// <summary>线程自旋计时_为了兼容不同的IDE版本:</summary>
    function _GetTickCount_: Cardinal;
    /// <summary>供外部询问线程处理的当前步骤:</summary>
    property FStep_No:string read FStep;
    /// <summary>供外部询问线程处理的当前方法:</summary>
    property FProc_WhatMethod:TThreadparamStrMethod read FProcObject;
  public
    /// <summary>传入_当前线程处理的当前微信实例调用哪个Api唯一标识_通用的不采用匿名方法:</summary>
    FApi:string;
    /// <summary>传入_当前线程处理的当前微信实例唯一标识_通用的不采用匿名方法:</summary>
    FcurWechat:TObject;
    /// <summary>传入_当前线程处理的当前微信实例的唯一同步的进度条_通用的不采用匿名方法:</summary>
    FcurProgressBar:TObject;//TObject; TProgressBar
    /// <summary>传入_线程执行Execute中_当前微信实例要执行的类方法函数_不采用匿名方法的函数:</summary>
    FProcObjectSync:TTickCountMethod;//procedure of Object;

    constructor Create(CreateSuspended: Boolean);
    destructor Destroy;

  end;

3.1.1、匿名线程的同步


procedure TFormGY.PopupMenu2Click(Sender: TObject);
begin
  SJGY.ShowALayoutMenu_DisposeOf(self);

  // ====这是名称为01的等待对话框=====
  SJGY.MyWaitShow('正在查询，请稍后......', self, '01', TAlphaColorRec.White, TAlphaColorRec.Red, TAlphaColorRec.Red); // 显示等待提示动画
  TThread.CreateAnonymousThread( // 创建一个单线程，完成ATask
    procedure
    begin // 线程里的代码写这里（确保不要有对界面元素的操作）
      // 如保存到数据库
      sleep(5000); // 这里模拟等待5秒钟

      TThread.Synchronize(nil,
        procedure // 界面交互代码要用这个包起来，在主线程中执行
        begin
          SJGY.MyWaithide(self, '01'); // 隐藏等待提示动画
          SJGY.ToastConfirm('查询完毕！', self, 1);
        end);

    end).Start;
end;

3.1.2、匿名线程升级版的同步模型

// 欢迎使用【通用跨平台移动框架】，详询欢迎加ＱＱ群：174483085

  TAnonymousThread<T1, T2> = class(TThread)
  private
    class var FRunningThreads: TList<TThread>;
  private
    FThreadFunc: TFunc<T1, T2>;
    FOnErrorProc: TProc<Exception>;
    FOnFinishedProc: TProc<T1, T2>;
    FaT: T1;
    FResult: T2;
    FStartSuspended: boolean;
  private
    procedure ThreadTerminate(Sender: TObject);
  protected
    procedure Execute; override;
  public
    constructor Create(aT: T1; AThreadFunc: TFunc<T1, T2>;
      AOnFinishedProc: TProc<T1, T2>; AOnErrorProc: TProc<Exception>;
      ACreateSuspended: boolean = False; AFreeOnTerminate: boolean = True);

    class constructor Create;
    class destructor Destroy;
  end; //:来超备注2021-10-12:TAnonymousThread:SJGY.ShowDownLoadDialog下载对话框中应用:很有用
  // =========匿名线程增强结束>>>>>>>>>>>>>>================

3.2、我们也习惯使用跨平台网络请求的“同步方法”来控制代码的“顺序”执行流程

try
MyHTTPResponse := MyHTTPClient.Get(LowerCase(Wx_ApiProxy + Getkflist + '?') + queryString, nil, nil );
Result_SyncCode:= MyHTTPResponse.StatusCode; // = 200 本系统的返回码__非微信的
try
ResultJsonStr_MyHTTPResponse := (MyHTTPResponse.ContentAsString(TEncoding.UTF8));
// 客服头像的URL链接,服务端不应当URL解码给客户端否则不安全,客户端解析的时候注意应当URL解码“\/”等特殊符号__TNetEncoding.URL.Decode
finally
if Assigned(JO1_MyHTTPResponse) then JO1_MyHTTPResponse.DisposeOf;
end;
except // Wx异常有异常时专用的响应 :
try
ResultJsonStr_MyHTTPResponse := (MyHTTPResponse.ContentAsString(TEncoding.UTF8));
JO1_MyHTTPResponse := TJSONObject.ParseJSONValue( ResultJsonStr_MyHTTPResponse ) as TJSONObject;
if JO1_MyHTTPResponse <> nil then
begin
Result_SyncCode:= JO1_MyHTTPResponse.GetValue<integer>('errcode');
Resolution_WxAPIErrcode( Result_SyncCode); // 错误处理
end;
finally
ResultJsonStr_MyHTTPResponse := '';
if Assigned(JO1_MyHTTPResponse) then JO1_MyHTTPResponse.DisposeOf;
end;

3.2.1、你会习惯性地使用：

function THTTPClient.Get(const AURL: string; const AResponseContent: TStream; const AHeaders: TNetHeaders): IHTTPResponse;

function THTTPClient.Post(const AURL: string; const ASourceFile: string;
const AResponseContent: TStream; const AHeaders: TNetHeaders): IHTTPResponse;

function THTTPClient.Put(const AURL, ASourceFile: string;
const AResponseContent: TStream; const AHeaders: TNetHeaders): IHTTPResponse;

function THTTPClient.Patch(const AURL: string; const ASource, AResponseContent: TStream;
const AHeaders: TNetHeaders): IHTTPResponse;

function THTTPClient.Delete(const AURL: string; const AResponseContent: TStream; const AHeaders: TNetHeaders): IHTTPResponse;

function THTTPClient.Options(const AURL: string; const AResponseContent: TStream;
const AHeaders: TNetHeaders): IHTTPResponse;

function THTTPClient.GetRange(const AURL: string; AStart, AnEnd: Int64; const AResponseContent: TStream;
const AHeaders: TNetHeaders): IHTTPResponse;

function THTTPClient.Trace(const AURL: string; const AResponseContent: TStream; const AHeaders: TNetHeaders): IHTTPResponse;

function THTTPClient.Head(const AURL: string; const AHeaders: TNetHeaders): IHTTPResponse;

等等，它们，从本质上来讲，都是“阻塞式”的“网络请求”，即在网络客户端默认的或你自定义的请求和响应超时时间内，阻塞式地完成请求并返回响应的接口，直到返回响应或返回超时为止。内部，它是这样工作的：

// System.Net.HttpClient.pas
function THTTPClient.Execute(const ARequest: IHTTPRequest; const AContentStream: TStream; const AHeaders: TNetHeaders): IHTTPResponse;
var
LHeader: TNetHeader;
begin
if ARequest.IsCancelled then
(ARequest as THTTPRequest).DoResetCancel;

if AHeaders <> nil then //: 遍历请求头，设置Header头的键值对数值 :
for LHeader in AHeaders do
ARequest.SetHeaderValue(LHeader.Name, LHeader.Value);

// System.Net.URLClient.pas
// : 获取响应的实例并执行它，但它内部直接忽略了三个异步参数为nil, nil, nil, :
Result := DoGetResponseInstance(Self, nil, nil, nil, ARequest, AContentStream) as IHTTPResponse;
ExecuteHTTP(ARequest, AContentStream, Result);
end;

// DoGetResponseInstance的原型：
function TURLClient.DoGetResponseInstance(
  const AContext: TObject;        // 执行上下文的实例
  const AProc: TProc;                            // 传入的异步执行的匿名方法
  const AsyncCallback: TAsyncCallback;           // 需要回调的异步方法
  const AsyncCallbackEvent: TAsyncCallbackEvent; // 需要回调的异步事件 
  const ARequest: IURLRequest;    // URI请求的接口类型的实例
  const AContentStream: TStream   // 响应的内容流
): IAsyncResult; // 返回异步结果的操作系统API实现的接口类型的实例
begin
  raise ENetURIClientException.CreateRes(@SNetSchemeFunctionNotImplemented);
  // 当网络发生故障时，返回错误提示字符串并释放相关的内部资源引用
end;
可见，同步模型下，直接忽略了三个异步模型相关的类型参数：

const AProc: TProc; // 传入的异步执行的匿名方法
const AsyncCallback: TAsyncCallback; // 需要回调的异步方法
const AsyncCallbackEvent: TAsyncCallbackEvent; // 需要回调的异步事件

3.2.2、即：默认的各种请求，我们是没有刻意地去引用“响应接口”的“异步结果接口属性”的：

  IURLResponse = interface(IInterface)
    ['{5D687C75-5C36-4302-B0AB-989DDB7558FE}']
    //......（省略）
    // 默认的各种请求，我们是没有刻意地去引用异步结果接口属性的：
    /// <summary>AsyncResult异步结果接口属性的Getter：</summary>
    function GetAsyncResult: IAsyncResult;
    /// <summary>对异步结果接口IAsyncResult的引用，用于控制相应请求的异步执行：</summary>
    property AsyncResult: IAsyncResult read GetAsyncResult;
  end;

一旦，你引用了“异步结果接口属性”，或者直接用3.3、中的“异步模型”进行网络请求，那么，请求及其响应，将会以“异步的方式”被执行。

3.2.2、请求引用“异步结果接口属性”执行异步响应

var aAsyncResult : IAsyncResult;
var aAsyncWaitResult : TWaitResult;
var aMultiWaitEvent : TMultiWaitEvent;
var aWaitStr : string;
    if access_token='' then
    begin
      Result := GetJsonString('access_token不能为空');
      exit;
    end;
    MyHTTPClient := THTTPClient.Create;
    MyHTTPClient.ConnectionTimeout := 5000; // 5秒
    MyHTTPClient.ResponseTimeout := 10000;  // 10秒

    MyHTTPClient.ContentType := 'application/json; charset=UTF-8';
    MyHTTPClient.UserAgent := 'Embarcadero URI Client/1.0';

    MyHTTPClient.AutomaticDecompression := [
      THTTPCompressionMethod.Deflate,
      THTTPCompressionMethod.GZip,
      THTTPCompressionMethod.Brotli,
      THTTPCompressionMethod.Any ];

    queryString:='access_token='+access_token; 

    try
      aAsyncResult := MyHTTPClient.Get(
         LowerCase(Wx_ApiProxy + Getkflist + '?') 
           + queryString, nil, nil 
      ).AsyncResult;
      aMultiWaitEvent := aAsyncResult.AsyncWaitEvent.create;
      aAsyncWaitResult := aMultiWaitEvent.waitfor(0);
      while ( aAsyncWaitResult >= 1 )  do // 内部线程的原子信号量等待__不阻塞
      begin
        break;
      end; //TWaitResult = (wrSignaled, wrTimeout, wrAbandoned, wrError, wrIOCompletion);
           //TWaitResult = (0, 1, 2, 3, 4);
      aMultiWaitEvent.SetEvent; // 显式的发出信号
      if aAsyncResult.IsCompleted then // ：如果网络请求被异步地执行完毕，无论对与错，那么：
      begin
        if aAsyncWaitResult = TWaitResult.wrTimeout then aWaitStr :='网络超时...';
        if aAsyncWaitResult = TWaitResult.wrError then aWaitStr :='网络错误...';
        if aAsyncWaitResult = TWaitResult.wrAbandoned then aWaitStr :='请求被放弃了...';
        if aAsyncWaitResult = TWaitResult.wrIOCompletion then aWaitStr :='I/O完成了...';
        if aAsyncWaitResult = TWaitResult.wrSignaledResult then
        begin
          aWaitStr :='正确返回...';
          // 拿到响应结果后，你想做的事情......
        end;
      end;
    finally
      MyHTTPClient.DisposeOf;
    end;

3.2.3、但是，的确，你很少会去关注和直接使用它们分别拥有的3种异步“重载”方法：

3.3、如何在处理本地长耗时的网络请求中直接使用“异步模型”

3.3.1、网络请求中的“异步模型”

如上所述（3.2），如果我们关注每一种请求类型的3种异步“重载”方法，比如Get请求：

/// <summary>向url发送异步“GET”命令</summary>
function BeginGet(const AURL: string; const AResponseContent: TStream = nil;
const AHeaders: TNetHeaders = nil): IAsyncResult; overload;
function BeginGet(const AsyncCallback: TAsyncCallback; const AURL: string; const AResponseContent: TStream = nil;
const AHeaders: TNetHeaders = nil): IAsyncResult; overload;
function BeginGet(const AsyncCallbackEvent: TAsyncCallbackEvent; const AURL: string;
const AResponseContent: TStream = nil; const AHeaders: TNetHeaders = nil): IAsyncResult; overload;

我们便能够拿到一个“异步结果”的接口IAsyncResult。并且后两种异步“重载”方法，还可以执行方法TAsyncCallback或事件TAsyncCallbackEvent的“异步回调”（其类型声明详见本文章节1：“1、用于实现异步事件、异步方法、及其异步结果回调的可自定义的通用类型”）。

    // Result_AsyncCode:= -9999;
    try
      MyHTTPClient := THTTPClient.Create;
      MyHTTPClient.ConnectionTimeout := 5000; // 5秒
      MyHTTPClient.ResponseTimeout := 10000;  // 10秒

      MyHTTPClient.ContentType := 'application/json; charset=UTF-8';
      MyHTTPClient.UserAgent := 'Embarcadero URI Client/1.0';

      MyHTTPClient.AutomaticDecompression := [THTTPCompressionMethod.Deflate,THTTPCompressionMethod.GZip,THTTPCompressionMethod.Brotli,THTTPCompressionMethod.Any];
      try
        Result := ResultJsonStr_MyHTTPResponse; 
        // ：如果是函数的话，在异步模型中，function的返回值已失去意义void(0)，相当于一个procedure
        ContentStreamResult:=TStringStream.Create('',TEncoding.UTF8);

        AsyncCallback := TAsyncCallback(
        procedure(AsyncResult:IAsyncResult)
        begin
          { // 如果你需要内部拦截等待：
          aMultiWaitEvent := AsyncResult.AsyncWaitEvent.create;
          aAsyncWaitResult := aMultiWaitEvent.waitfor(0);
          while ( aAsyncWaitResult >= TWaitResult.wrSignaled ) do  // 内部线程的原子信号量等待__不阻塞
          begin
            if aAsyncWaitResult <> TWaitResult.wrIOCompletion then break;
            ResultJsonStr_MyHTTPResponse := ContentStreamResult.DataString;
          end; //TWaitResult = (wrSignaled, wrTimeout, wrAbandoned, wrError, wrIOCompletion);
               //TWaitResult = (0, 1, 2, 3, 4);
          FreeAndNil(aMultiWaitEvent); // }
          // 异步模型下，传入的内容流A，异步执行结果的响应对象的流B, 当响应结束后_无论成功或失败，A流的字节大小===B流的字节大小 ：
          if ( (AsyncResult as THttpResponse).GetContentStream.Size = ContentStreamResult.Size  ) then //if ( (AsyncResult as THttpResponse).GetContentStream.Equals(ContentStreamResult)  ) then
          // if ( (AsyncResult as THttpResponse).GetStatusCode >=0  ) then  // 相应类的实现THTTPResponse = class(TURLResponse, IHTTPResponse)
          begin //TThread.Current.Synchronize(nil,procedure begin ShowMessage((AsyncResult as THttpResponse).GetStatusCode.ToString) end); // GetStatusCode = 200
            // + sLineBreak + '异步结果IAsyncResult的执行上下文的类名...'+TObject(AsyncResult.AsyncContext).ClassName; // 异步结果IAsyncResult的执行上下文的类名...为该跨平台的THTTPClient库_比如MSWindows下为---TWinHTTPClient
            ResultJsonStr_MyHTTPResponse:=ContentStreamResult.DataString;
                TThread.Current.Synchronize(nil,procedure begin EnableLogMe:=true; LogMe(Application.MainForm,'ContentStreamResult.DataString：'+ResultJsonStr_MyHTTPResponse + sLineBreak + '异步结果IAsyncResult的执行上下文的类名...'+TObject(AsyncResult.AsyncContext).ClassName ); EnableLogMe:=false; end); // 内部日志
                if Assigned(proc) then TThread.Current.Synchronize(nil,procedure begin proc(ResultJsonStr_MyHTTPResponse); end) else TThread.Current.Synchronize(nil,procedure begin ShowMessage('你不传入方法，我也没法为你做事并回传给你看'); end);
                // ：如果外部传入了方法，我就在【网络-异步模型】的内部按照这个方法帮你干！
            if MyHTTPClient<>nil then MyHTTPClient.DisposeOf;
            FreeAndNil(ContentStreamResult);
            FreeAndNil(aStrlist);
          end;
        end);  // 发出异步请求 ：
        MyHTTPClient.BeginGet( AsyncCallback, LRequestURL, ContentStreamResult, aHeaders );
        // :这是异步调用；同步的话: MyHTTPClient.Get( LRequestURL, nil, nil );
      except
        // ...(略)
      end;
    finally
    end;

原理：它内部的本质，仍旧是，后台线程的安全锁，底层代码如下：

// System.Net.HttpClient

function THTTPClient.InternalExecuteAsync(const AsyncCallback: TAsyncCallback; const AsyncCallbackEvent: TAsyncCallbackEvent;
  const ARequest: IHTTPRequest; const AContentStream: TStream;
  const AHeaders: TNetHeaders; AOwnsSourceStream: Boolean): IAsyncResult;
var
  LHeader: TNetHeader;
  LContentStream: TStream;
  LAsync: IAsyncResult;
  LRequest: THTTPRequest;
{$IFDEF AUTOREFCOUNT}
  LSourceStream: TStream;
{$ENDIF}
begin
  if ARequest.IsCancelled then
    (ARequest as THTTPRequest).DoResetCancel;

  if AHeaders <> nil then
    for LHeader in AHeaders do
      ARequest.SetHeaderValue(LHeader.Name, LHeader.Value);

  LRequest := ARequest as THTTPRequest;
  if AOwnsSourceStream then
    LRequest.FOwnedStream := LRequest.FSourceStream
{$IFDEF AUTOREFCOUNT}
  else
    LSourceStream := LRequest.FSourceStream
{$ENDIF};
  LContentStream := AContentStream;

  LAsync := DoGetResponseInstance(Self,
    procedure
    begin
      try
        ExecuteHTTP(ARequest, LContentStream, (LAsync as THttpResponse));
        // : ！！！！关键！！！！！！！！LAsync as THttpResponse
        //   ： 内部处理了线程中的网络请求的事件循环，响应流、Cookies管理、状态码、中断、与异常
        //   ：    特别的，状态码，处理了200、及401和407的失败回调（如果前置的身份验证authentication失败，则回退到正常路径）
      finally
{$IFDEF AUTOREFCOUNT}
        LSourceStream := nil;
{$ENDIF}
      end;
    end, AsyncCallback, AsyncCallbackEvent, ARequest, AContentStream);
  Result := LAsync;

  // Invoke Async Execution.！！！！关键---线程中的请求结果及调度：！！！！！！！！
  (LAsync as THttpResponse).Invoke;
end;

其中（详见：2.1、用于实现所有异步过程调用的基类TBaseAsyncResult）：

// System.Classes

function TBaseAsyncResult.Invoke: IAsyncResult;
begin
  SetFlagsAtomic([TAsyncFlag.Invoked], [TAsyncFlag.Invoked]);
  FInvokingThread := TThread.CurrentThread.ThreadID;
  // ：当前执行请求的线程引用计数，返回异步请求结果，并进行事件、方法等调度 ：
  _AddRef;
  Result := Self;
  Schedule;
end;

3.3.2、处理本地长耗时的网络任务的两种“通用方法”

3.3.2.1、直接使用“异步请求”的网络模型、传入回调并执行

procedure TForm1.ThreadExec_WechatMethod(aProcName:string='');
var 
    proc: TProc<string>;
    //LWxApi:TWxApi; aProcObjectSync:TTickCountMethod;
    //......(，仅为示例，详细，略)......
  if ( trim(aProcName) = 'Customservice_Getkflist' ) then
  begin//:___定义并启动___◆对话服务_获取所有的客服人员的列表___:
    //callApiOfTWxApi_InThread( LWxApi, trim(aProcName) );
    //   ：===============这是线程中的网络同步模型; 现在换一种方法__调用网络异步模型 :  ========================================================
    proc := procedure(aStr:string) begin {写入方法：}Memo1.Lines.Add(aStr);  {传入事件：}Button_OKClick(Text_Debug); end;
    HTTPClientHandler_Get_Async ( trim(aProcName), nil, TProc<string>(proc) ); //: 传入空的回调方法则不会被执行 :TProc<string>(nil)
    FreeAndNil(LWxApi);
  end;
end;

3.3.2.2、使用线程，在后台线程的同步函数中处理传入的“回调”

type
  //TTickCountProcedure = TProcedure;
  TTickCountMethod = procedure of Object;
  //  :某个类的实例方法
  TThreadparamStrMethod = procedure(var aStr:string;aCurBaidupan:TObject) of Object;
  //  :线程类中带字符串及对象参数的类实例方法

定义需要在后台线程中执行的“网络请求”的通用方法：

procedure TForm1.ThreadExec_WechatMethod(aProcName:string='');
var 
    // proc: TProc<string>; // 改用后台线程同步回调 :
    LWxApi:TWxApi; aProcObjectSync:TTickCountMethod;
    /// <summary>类的实例中是否发布了该方法:</summary>
    /// <remarks>下来请进一步研究System.Classes.TClassFinder</remarks>
    function ifMethodIsDefined(aClassInstance:TObject;aMethodName:string):Boolean;
      var aMethodObject:TTickCountMethod;
    begin
      if (aClassInstance=nil) or (trim(aMethodName)='') then
      begin
        ShowMessage('在执行判断类实例是否定义了某方法的内部函数时，传参错误...'); Result:=false;
      end else
      begin
        @aMethodObject:=aClassInstance.MethodAddress(aMethodName);
        if @aMethodObject = nil then
        begin
          FreeAndNil(aClassInstance); ShowMessage('该API尚未定义无法调用...'); Result:=false;
        end else Result:=true;
      end;
    end;
    /// <summary>返回已在类实例中发布的某方法:</summary>
    /// <remarks>下来请进一步研究System.Classes.TClassFinder</remarks>
    function getMethodDefined(aClassInstance:TObject;aMethodName:string):TTickCountMethod;
      var poinerRecordOfMethod:TMethod;// 方法("包含的指针的code及data")的记录类型
    begin
      Result := nil;
      if (aClassInstance<>nil) and (trim(aMethodName)<>'') then
      begin
        poinerRecordOfMethod.Code := Pointer(aClassInstance.MethodAddress(aMethodName));
        poinerRecordOfMethod.Data := Pointer(aClassInstance);
      end;
      if Assigned( poinerRecordOfMethod.Code ) then // 如果定义了该方法,则返回该方法
        Result := TTickCountMethod( poinerRecordOfMethod );
        // TProcedure<可选参数>针对function ; TTickCountMethod针对procedure (可选参数) of object
    end;
    /// <summary>在线程池的某线程实例中执行对象池中微信类TWxApi的某实例中发布的某个API方法:</summary>
    /// <param name="aClassInstance">微信类TWxApi的某个实例.</param>
    /// <param name="aMethodName">微信类实例中发布的某个API方法.</param>
    /// <remarks></remarks>
    procedure callApiOfTWxApi_InThread(aClassInstance:TObject;aMethodName:string);
    begin
      if ifMethodIsDefined( aClassInstance,trim(aMethodName) ) then
      begin
        aProcObjectSync := getMethodDefined( aClassInstance,trim(aProcName) );
        FapiOfMyWechat.Add( aClassInstance );
        ThreadExec_WechatMethod( aClassInstance, trim(aProcName), aProcObjectSync );
      end;
    end;
begin//___FapiOfMyWechat微信对象池___FaThreads_Wechats处理业务的后台线程池___

  if FaThreads_Wechats = nil then FaThreads_Wechats := TList.Create;
    //___产生微信类的实例___:
    LWxApi := TWxApi.Create;
    LWxApi.FStatus := stWxT_AddedtoList;//:微信对象实例的___运行状态类型仓库管理___:Ord(LWxApi.FStatus)=1

  if ifMethodIsDefined( LWxApi,trim(aProcName) ) = false then exit;

  if ( trim(aProcName) = 'Customservice_Getkflist' ) then
  begin//:___定义并启动___◆对话服务_获取所有的客服人员的列表___:
    callApiOfTWxApi_InThread( LWxApi, trim(aProcName) );
    //   ：===============这是线程中的网络同步模型;
  end;
end;

在后台线程中执行该方法及其回调，并加入线程池统一管理该线程：

procedure TForm1.ThreadExec_WechatMethod(aWxApi:TObject;aProcName:string;aProcObjectSync:TTickCountMethod);
var LThreadWechat:ThreadWechat;
begin
    //定义线程:
    LThreadWechat := ThreadWechat.Create(true);
    LThreadWechat.FreeOnTerminate:=true;
      LThreadWechat.FcurWechat := aWxApi; // :传入的微信类实例
      LThreadWechat.FApi := aProcName;    // :传入调用的●API的方法函数名●
      LThreadWechat.FProcObjectSync := aProcObjectSync;//LWxApi.Get_access_token;
    //线程加入列表___线程池___统一管理便于将来释放等处理:
    FaThreads_Wechats.Add( LThreadWechat );
    //唤醒并启动运行(列表___线程池中的)该线程:
    try
      LThreadWechat.Resume; //ThreadWechat( FaThreads_Wechats.Items[ Lcount_WxApi ] )
      CheckSynchronize;
    finally
    end;
end;

3.3.3、异步模型与同步模型的比较

同步模型：
灵活性：你可以用自定义线程和线程池，管理你的应用中来自网络的和非网络的任务，“不阻塞”的执行、或让其“阻塞”的执行。
功能性：取决于你的应用和代码的“设计模式”的架构与规划。
可扩展性：较好，完全取决于“功能性”。
风险性：如果不精通线程的设计与调度，可能会发生不可预期的“用户态”的系统错误。特别是 I / O冲突，包括来自网络的i/o及来自磁盘读写的i/o（磁盘i/o速度明显低于网络、内存及cpu的处理速度），所以如果在服务端访问第三方平台的API，在并发环境中你可能会期望”使用线程“来避免阻塞，此时，就特别要处理好CPU和I/O的协同和步调，要力争使其步调协调；另外，关于”并行“一般不建议未经特别的代码处理直接用于服务端，它会使cpu多核心同时工作高负荷运行，一般只在特别时段、处理特别事务中使用；否则在处理来自客户端请求的高并发环境中，会使得cpu感觉”疲惫“而响应客户的UE体验。
异步模型：
灵活性：不可自主，一般是做底层封装，如果您有能力也可自行封装；通常是由你使用的编程工具或IDE对接各操作系统底层的“通信模型”来具体实现的。
功能性：受制于编程工具或IDE对各操作系统的“线程模型”的类型封装。
可扩展性：“系统性”较强，取决于编程工具或IDE厂商的规划与进度。比如，浏览器的内核及其开发工具，对H5规范中js的Promise及ES6中async异步模型的语言特征的统一支持和跨平台功能实现。
风险性：较小，编程工具或IDE厂商会系统性地QA及QC处理。I/O方面，它内部已经以统一的模式进行了处理（当然不够灵活）。

4、javascript中的多线程

4.1、javascript是单线程的吗

“javascript是单线程的！”，网上流行这种说法，说的人多了，貌似也就“约定俗成”了。

其实这种说法是不够严谨的，确切的说，“单线程”和“多线程”，本身从概念上讲，是程序“运行时”的属性，某段程序，如果它不被执行或调用，就谈不上说“单线程”还是“多线程”；因而“单线程”还是“多线程”，是程序代码在“运行时”的上下文环境。在程序执行的“上下文环境”中，是单个线程在工作，还是多个线程在同时工作或协同，最初，因为电脑的CPU都是单核心的，我们知道单个CPU在单位时间内就只能作一个worker处理一件“事务”，当时，就只有“单线程”这一种模型；后来，多核心的CPU出现了，多个CPU能够能在同一时刻分别处理不同的事情。

“javascript是单线程”的说法，跟javascript的成长历史有关，最初，它就是为网页做些个“特效”而出现的，当时的浏览器也只是做一些个技术类“文章”写作与共享，浏览器也期望能丰富“互联网”的上的“应用”的范围和实效。那个年代，在服务端，根本没有javascript的身影，只在“浏览器”中应用一些简单功能。

4.2、javascript线程的执行上下文

4.2.1、服务端

在多核心CPU硬件环境下，nodejs能够处理和运行”多线程“。

4.2.2、客户端

在浏览器或嵌入式浏览器（比如App中的webview）环境下，在网页的主线程（即浏览器进程内置js的解释引擎中，负责处理该页面的”渲染线程“ [ 渲染：不熟悉浏览器及其js工作原理的朋友，可以理解为UI界面在被像素化地”绘制“出来之前的内容的生成和呈现过程 ]）中，浏览器只允许javascript代码，以”单个线程“的方式进行作业，这，是由js的宿主，浏览器来决定的。

js代码如何在多线程环境下工作？

多核环境下：（1）、js代码，可以同时运行在”不同页面对应的后台导航器中Navigator，即我们通常所说的专用worker“（即浏览器的非”渲染“子进程）；（2）、不同的js模块，它们还可以工作于浏览器的”后台服务worker“中。（3）、1个个单个的js模块，它也可以分别同时运行在浏览器的不同”标签页“中，通过”多标签页“共享资源。头两种，均不可直接操作负责渲染的页面的”DOM“；而且，不同浏览器的兼容性也各异；当然，绝大部分的功能，绝大部分浏览器的最新版本都基本支持了。

的确，还是有不少限制的，毕竟js还是”年轻的“。

另外就是，js是”弱类型“的，代码多了，特别是”堆“大了，很容易引发因”类型“问题导致的”不宜被发现“的异常。typescript的诞生和逐渐成熟，将会彻底改变和补充这一现状，使得js能支持”强类型“。顺便说下ts，他的发明人和主导者，Anders Hejlsberg安德斯·海尔斯伯格，即咱们一直在使用的Turbo Pascal语言编译器、delphi及c++ 的Builder的IDE的发明人，他还是C#之父，.NET的创立者。