CN115756831A - 一种适用于异构接口的二阶段异步任务结果代理系统及方法 - Google Patents

Abstract

本发明属于计算机软件领域，更具体地，涉及一种适用于异构接口的二阶段异步任务结果代理方法，包括：自研接口、第三方接口、第三方结果容器、自研结果容器、第三方结果代理容器；所述自研接口模块包括自研抽象接口、自研实现接口；所述自研实现接口接收任务A和任务B；当任务A提交时，创建一个自研结果容器对象；所述第三方接口用于接收与执行任务B；所述自研结果容器用于存储任务A的结果；所述自研结果容器接收任务B，并调用第三方接口；所述第三方结果容器用于接收任务B的结果；所述第三方结果代理容器在类型上继承或实现第三方结果容器。本发明不需要对被代理的结果容器及其相关库做任何修改，就可以无缝衔接两个异构接口的异步任务。

Description

一种适用于异构接口的二阶段异步任务结果代理系统及方法

技术领域

本发明属于计算机软件领域，更具体地，涉及一种适用于异构接口的二阶段异步任务结果代理系统及方法。

背景技术

随着计算机技术和网络技术的拓展及普及，计算机网络在人们学习、教育、工作和生活等多方面起到了不容忽视的作用，逐渐成为人们生活的必需品，人们对于计算机网络的依赖性与日俱增。在现代计算机软件领域，跨系统任务已经相当普遍，这种任务通常伴随大量的网络IO，因此，以异步的方式执行这些任务可以有效减少资源开销。除此之外，系统内也会存在某些异步任务，这些异步任务相比同步执行，会显著提高性能。

异步任务的普遍使用，也给软件技术领域带来了新的挑战，其中之一就是对任务结果的监听及处理。

现代面向对象编程语言或库中，通常会有Future这一概念。Future代表一个任务的结果容器。在线程触发(或提交)一个异步任务时，调用的函数会同步地返回一个Future对象，此时Future中没有任务执行的结果。当经过某一段时间后，其他线程或其他系统完成了任务，并将任务结果设置到Future中，至此，任何对Future的访问都可以获取到任务的结果。

许多编程语言或库中，也存在将多个任务按顺序执行，并返回最终Future的方法。但是，在异构的库或接口之间，例如在自主研发的库与编程语言的标准工具库之间，进行异步任务结果的监听、传递、处理，是一件亟待解决的事情。

发明内容

本发明提出了一种适用于异构接口的二阶段异步任务结果代理系统及方法，其典型应用场景如下：

向自研接口提交一个异步任务Task_A，并指定在Task_A完成后向第三方接口提交一个异步任务Task_B，提交Task_A同步地返回一个Future_B对象。其中，自研接口代表使用本发明所述方法开发的异步任务接口。第三方接口代表已经存在的标准库或其他开源库的异步任务接口。Task代表一个函数或函数指针或策略对象，具体取决于所用编程语言。Future代表异步任务的结果容器。

本发明所述方法即为自研接口及其关联组件的实现方式。

本发明详细的技术方案如下：

一种适用于异构接口的二阶段异步任务结果代理系统及方法，其特征在于，包括：自研接口、第三方接口、第三方结果容器、自研结果容器、第三方结果代理容器；

所述自研接口包括自研抽象接口(Interface_A)、自研实现接口(A_Implement)；

所述自研实现接口用于提交任务A和任务B；当任务A提交时，会创建一个Future_A对象即申请一个空间存放Future_A并同步返回；当任务B提交时，会将提交操作委托给第三方接口；

所述第三方接口用于提交并执行任务B，当任务B提交时，第三方接口实现应同步返回一个Future_B对象；

所述自研结果容器用于存放任务A产生的结果，同时还记录了产生结果后，应执行的下一个任务即任务B。在自研结果容器中还未产生结果时，如果尝试获取任务结果，则返回空指针或有条件的挂起线程；

所述第三方结果容器用于存放任务B的结果；

所述第三方结果代理容器存有第三方结果容器且在类型上继承或实现第三方结果容器Future_B类型；用于使第三方结果容器适配自研接口。

进一步地，所述自研抽象接口包括Interface_A.submit函数：

所述Interface_A.submit函数，用于接收任务A和任务B，该函数返回值类型为Future_B类型；

所述自研实现接口用于实现Interface_A.submit函数。

所述Interface_A.submit函数按顺序执行两个异步任务，先执行任务A，在任务A完成后，再执行任务B。任务A可以被自研实现接口直接处理，任务A具体形式可以是函数、函数指针、策略对象，或其他受编程语言支持的类型。任务B可以被第三方接口处理，任务B的具体形式由第三方库(标准库或其他开源库)定义。

进一步地，所述自研结果容器包括：

Future_A.state字段，用于标记此容器中是否产生了结果(因为任务结果可能是空指针，所以要判断容器是否产生了结果，就必须有一个单独的标记字段)；

Future_A.result字段，用于存放任务结果，其类型为任意类型；

Future_A.next字段，用于记录此容器产生结果后，需要执行的第二个任务，其类型为Task_B；

Future_A.future字段，用于保存Future_B的代理对象即用于保存FutureProxy，其类型为FutureProxy类型；

Future_A.set函数，用于为此容器设置结果，该函数接收一个参数，类型为任意类型。

进一步地，所述第三方结果代理容器包括：

FutureProxy.future字段，用于存放被代理的第三方结果容器，其类型为Future_B；

FutureProxy.set函数，用于设置被代理的第三方结果容器，该函数接收一个参数，类型为Future_B；

FutureProxy.get函数，用于获取被代理的第三方结果容器中的任务结果，该函数返回类型为任意类型。

进一步地，所述第三方结果容器包括：

Future_B.get函数，用于获取任务结果，即任务B的结果。

优选地，所述Future_A.set函数的执行流程如下：

a1，将Future_A.state字段由0置为1,表示此容器已产生结果；

a2，将任务一的结果赋值给Future_A.result字段；

a3，插入完全内存屏障或插入等效代码；

a4，调用第三方接口的submit函数，提交Future_A.next字段的任务B。如果执行任务B需要任务A的结果，则先将Future_A.result字段通过已知的被支持方式传入任务B，Interface_B.submit函数的调用会同步地返回一个Future_B对象；

a5，获取Future_A.future字段的FutureProxy对象，调用FutureProxy对象的FutureProxy.set函数，将步骤a4返回的Future_B对象作为参数传入。根据权利要求2所述的适用于异构接口的二阶段异步任务结果代理方法，其特征在于，所述A_Implement.submit函数的执行流程如下：

b1，检查两个任务A和任务B，任何一个为空指针，则终止程序；

b2，创建一个Future_A对象(自研结果容器)，并传入任务B；

b3，通过已知方式执行任务A，使任务A产生结果，并以结果作为参数调用b2创建的自研结果容器；

b4，获取步骤b2创建的Future_A对象的Future_A.future字段，即一个FutureProxy对象；

b5，返回步骤b4中获取的FutureProxy对象；

b6，当步骤b3执行的任务A产生结果时，将以这个结果为参数，调用Future_A对象(自研结果容器)的Future_A.set函数。

进一步地，所述FutureProxy.set函数的执行流程如下：

c1，检查参数，如果为空指针，则终止程序；

c2，将入参(一个Future_B对象)赋值给FutureProxy.future字段；

c3，插入完全内存屏障或插入等效代码；

c4，进行与Future_B(第三方结果容器)产生结果时等效的操作。

进一步地，所述FutureProxy.get函数的执行流程如下：

d1，插入完全内存屏障或插入等效代码；

d2，读取FutureProxy.future字段，该字段保存了一个Future_B对象。如果读取到空指针，则进行与Future_B还未产生结果时等效的操作；

d3，调用步骤d2读取到的Future_B对象的Future_B.get函数，并将调用结果返回。

d2所述的等效操作，包括但不限于：挂起线程、返回空指针。

本发明的技术优势在于：

1、本发明提供一种适用于异构接口的二阶段异步任务结果代理系统及方法，不需要对被代理的结果容器及其相关库做任何修改，就可以无缝衔接两个异构接口的异步任务。

2、本发明提供一种适用于异构接口的二阶段异步任务结果代理系统及方法，不需要限制第三方库的设计实现方式，其他的一些异步任务结果代理方法可能会要求指定的第三方库或要求第三方库符合指定的接口规范。本设计方法对第三方库的要求在逻辑上是必须的，如果没有接口B的submit函数，则任务无法开始异步执行，如果没有Future_B，则任务结果无法获取。

3、本发明提供一种适用于异构接口的二阶段异步任务结果代理系统及方法，给开发者保留了足够大的设计空间，其他的一些异步任务结果代理方法可能对任务的形式或执行方式有要求。

4、本发明提供一种适用于异构接口的二阶段异步任务结果代理系统及方法，可以保证线程安全，方法中多处都使用了内存屏障，开发者也可以去除其认为不必要的内存屏障，提高性能。

附图说明

图1是本发明实施例1中的UML类示意图。

图2是本发明实施例1中的流程示意图(左)。

图3是本发明实施例1中的流程示意图(右)。

具体实施方式

下面结合附图与实施例对本公开做进一步说明。

应该指出，以下详细说明都是示例性的，旨在对本公开提供进一步的说明。除非另有指明，本文使用的所有技术和科学术语具有与本公开所属技术领域的普通技术人员通常理解的相同含义。

需要注意的是，这里所使用的术语仅是为了描述具体实施方式，而非意图限制根据本公开的示例性实施方式。如在这里所使用的，除非上下文另外明确指出，否则单数形式也意图包括复数形式，此外，还应当理解的是，当在本说明书中使用术语“包含”和/或“包括”时，其指明存在特征、步骤、操作、器件、组件和/或它们的组合。

在不冲突的情况下，本公开中的实施例及实施例中的特征可以相互组合。

实施例1

本实施例提供一种适用于异构接口的二阶段异步任务结果的代理系统，结合图1所示，包括：自研接口、第三方接口即Interface_B、第三方结果容器即Future_B、自研结果容器即Future_A、第三方结果代理容器即FutureProxy；所述自研接口包括自研抽象接口即Interface_A、自研实现接口A_Implement。

所述Interface_A接收任务A即Task_A和任务B即Task_B，并传输至A_Implement进行处理，当Task_A提交时，创建一个Future_A对象即申请一个空间存放Future_A(同理，创建一个Future_B对象即申请一个空间存放Future_B；创建一个FutureProxy对象即申请一个空间存放FutureProxy)。

所述Interface_B用于提交并执行Task_B。

所述Future_A用于存放Task_A产生的结果，同时还记录了产生结果后，应执行的下一个任务即Task_B。在Future_A中还未产生结果时，如果尝试获取任务结果，则返回空指针或有条件的挂起线程；所述Future_A还用于接收Task_B，并将Task_B作为参数调用Interface_B。

所述Future_B用于存放Task_B的结果。

所述FutureProxy存有Future_B且在类型上继承或实现Future_B，用于观察最终Task_B是否完成。

进一步地，所述自研抽象接口还包括：

submit函数即Interface_A.submit，用于接收Task_A和Task_B，该函数返回值类型为Future_B类型；

所述A_Implement用于实现Interface_A.submit。

所述Interface_A.submit按顺序执行两个异步任务，先执行第Task_A，在Task_A完成后，再处理Task_B。Task_A为被A_Implement直接处理的任务Task_A，其具体形式为函数、函数指针、策略对象或其他受编程语言支持的参数类型。Task_B是可以被Interface_B处理的任务，其具体形式由相应的第三方数据库定义。

进一步地，所述Future_A包括：

Future_A.state字段，用于标记此容器中是否产生了结果(因为任务结果可能是空指针，所以要判断容器是否产生了结果，就必须有一个单独的标记字段)；

Future_A.result字段，用于存放任务结果，其类型为任意类型；

Future_A.next字段，用于记录此容器产生结果后，需要执行的第二个任务，其类型为Task_B；

Future_A.future字段，用于保存Future_B的代理对象即用于保存FutureProxy，其类型为FutureProxy类型；

Future_A.set函数，用于为此容器设置结果，该函数接收一个参数，类型为任意类型。

进一步地，所述FutureProxy包括：

FutureProxy.future字段，用于存放被代理Future_B，其类型为Future_B类型；

FutureProxy.set函数，用于设置被代理的结果容器，该函数接收一个参数，类型为Future_B类型；

FutureProxy.get函数，用于获取被代理的Future_B中的任务结果，该函数返回类型为任意类型。

进一步地，所述Future_B包括：

Future_B.get函数，用于获取Task_B的任务结果。

优选地，Future_A.set函数的执行流程如下：

a1，将Future_A.state字段由0置为1,表示此容器已产生结果；

a2，将Task_A的结果赋值给Future_A.result字段；

a3，插入完全内存屏障或插入等效代码；

a4，调用Interface_B，即调用Interface_B.submit函数，提交Future_A.next字段的Task_B。如果执行Task_B需要Task_A的结果，则先将Future_A.result字段通过已知的被支持方式传入Task_B，Interface_B.submit函数的调用会同步地返回一个Future_B对象，；

a5，获取Future_A.future字段的FutureProxy，调用FutureProxy的第二set函数，将步骤a4返回的Future_B对象作为参数传入。

进一步地，所述A_Implement.submit的执行流程如下：

b1，检查两个Task_A和Task_B，任何一个为空指针，则终止程序；

b2，创建一个Future_A对象，并传入Task_B；

b3，通过已知方式执行Task_A，Task_A产生结果，并以结果作为参数调用b2创建的Future_A对象的Future_A.set函数；

b4，获取步骤b2创建的Future_A的future字段，即一个FutureProxy对象；

b5，返回步骤b4中获取的FutureProxy对象；

进一步地，FutureProxy.set函数的执行流程如下：

c1，检查参数，如果为空指针，则终止程序；

c2，将入参赋值给FutureProxy.future字段；

c3，插入完全内存屏障或插入等效代码；

c4，进行与Future_B产生结果时等效的操作。

进一步地，所述FutureProxy.get函数的执行流程如下：

d1，插入插入完全内存屏障或插入等效代码；

d2，读取FutureProxy.future字段。如果读取到空指针，则进行与Future_B还未产生结果时等效的操作；

d3，调用步骤d2读取到的Future_B对象的Future_B.get函数，并将调用结果返回。

进一步地，所述等效操作，包括但不限于：挂起线程、返回空指针。

一种适用于异构接口的二阶段异步任务结果代理系统的实现方法结合图2、图3包括：

自研接口接收任务A和任务B，并传输至自研实现接口：

自研实现接口的submit函数接收任务A并调用线程执行任务A并将任务B传输至自研结果容器的Future_A.next字段；当任务A完成后，将任务A的结果作为参数调用自研结果容器的Future_A.set函数；

自研结果容器的Future_A.set函数调用第三方接口的submit函数执行任务B，并接收结果；当任务B提交后，同步得到了一个Future_B对象，将这个Future_B对象作为参数，保存到FutureProxy.future字段中，并调用FutureProxy.set函数；

所述第三方接口模块的submit函数执行任务B，并将任务B的结果传输至第三方结果容器。

第三方结果代理容器的FutureProxy.get函数获取第三方结果容器的任务B的结果；

FutureProxy在类型上继承或Future_B。

具体过程如下：

1.确定任务A：Task_A和任务B：Task_B；

2.将步骤1中的Task_A和Task_B分别作为第一个参数和第二个参数，调用自研接口，此时会实际调用A_Implement的A_Implement.submit函数，具体执行步骤如下：

2.1.检查两个入参分别为Task_A和Task_B，有任何一个是空指针，则终止本次程序，若都不为空指针则继续一下操作；

2.2.创建一个Future_A对象，所述Future_A包括：

Future_A.state字段，用于标记此容器中是否产生了结果；

Future_A.result字段，用于存放任务结果；

Future_A.next字段，用于记录此容器产生结果后，需要执行的Task_B；

Future_A.future字段，用于保存Future_B的代理对象即用于保存FutureProxy；

Future_A.set函数，用于为此容器设置结果，该函数接收一个参数，类型为任意类型。

2.3.将Task_B传入Future_A.next字段；

2.4.调用A_Implement.submit并通过已知方式执行Task_A，Task_A产生结果后，以Task_A的结果作为参数调用步骤2.2创建的Future_A.set函数；(执行Task_A的方式可以是开启一个新线程执行，或在某个线程池中取一个线程执行)

2.5.所述A_Implement(自研实现接口)的submit函数获取步骤2.2创建的Future_A(自研结果容器)的future字段，并创建一个FutureProxy(FutureProxy)；

2.6.返回步骤2.5中创建的FutureProxy对象。

3.Task_A被执行完成后，A_Implement的A_Implement.submit函数以Task_A的结果作为参数调用Future_A的Future_A.set函数，所述Future_A.set具体执行步骤如下：

3.1.将Future_A.state字段由0置为1,表示Future_A已产生结果；

3.2.将入参(即Task_A的结果)赋值给Future_A.result字段；

3.3.插入完全内存屏障或插入等效代码；

3.4.调用Interface_B.submit函数，并将Future_A.next字段的Task_B提交到Interface_B；

3.5.若Task_B的执行需要Task_A的结果，则将Future_A.result字段的内容通过已知的方式将Task_A的结果传入Task_B；

3.6.Interface_B的Interface_B.submit函数执行Task_B并返回一个Future_B对象。(Interface_B为第三方标准库或已知库，不属于本发明的程序范围，作为已知的存在)

3.7.获取Future_A.future字段的FutureProxy，调用FutureProxy.set函数，将步骤3.6返回的Future_B对象作为参数传入。

3.8.FutureProxy.set函数，接收Future_B并将Future_B传入FutureProxy.future字段进行代理。

4.当Task_B被执行完成后，Task_B的结果被设置到了Future_B(Future_B)中，所述Future_B为第三方或标准库的结果容器，作为已存在的结果容器。

5.此时调用FutureProxy的get函数，get函数的执行流程如下：

5.1插入完全内存屏障或插入等效代码。

5.2读取FutureProxy.future字段。

5.3如果读取到空指针，则进行与Future_B还未产生结果时等效的操作，例如返回空指针或有条件的挂起线程。否则执行步骤5.4。

5.4调用步骤5.2读取到FutureProxy.future字段代理的Future_B。

5.5返回步骤5.3或5.4的结果，即显示最终结果。

6.如果在Task_A还未完成，也即Future_B还不存在时，调用FutureProxy.get函数，那么就会如步骤5.3所述，产生与调用Future_B但得不到结果时相同的现象。

显然，本发明的上述实施例仅仅是为清楚地说明本发明技术方案所作的举例，而并非是对本发明的具体实施方式的限定。凡在本发明权利要求书的精神和原则之内所作的任何修改、等同替换和改进等，均应包含在本发明权利要求的保护范围之内。

Claims (10)

1.一种适用于异构接口的二阶段异步任务结果代理系统，其特征在于，包括：自研接口、第三方接口、第三方结果容器、自研结果容器、第三方结果代理容器；

所述自研接口包括自研抽象接口、自研实现接口；

所述自研实现接口接收任务A和任务B；当任务A提交时，创建一个自研结果容器对象；

所述第三方接口模块用于接收与执行任务B；

所述自研结果容器用于接收、执行任务A并储存结果、储存任务B并触发任务B的提交；

所述第三方结果容器用于接收任务B的结果；

所述第三方结果代理容器在类型上继承或实现第三方结果容器；所述第三方结果代理容器中存在一个字段用于保存第三方结果容器。

2.根据权利要求1所述的适用于异构接口的二阶段异步任务结果代理系统，其特征在于，所述自研接口还包括：

Interface_A.submit函数，用于接收并按顺序执行任务A和任务B；

所述自研实现接口用于实现Interface_A.submit函数。

3.根据权利要求1所述的适用于异构接口的二阶段异步任务结果代理系统，其特征在于，所述自研结果容器包括：

Future_A.state字段，用于标记此容器中是否产生了结果；

Future_A.result字段，用于存放任务结果；

Future_A.next字段，用于记录此容器产生结果后，需要执行的任务B；

Future_A.future字段，用于保存第二个任务的结果容器代理；

Future_A.set函数，用于为此容器设置结果，该函数接收一个参数，类型为任意类型。

4.根据权利要求1所述的适用于异构接口的二阶段异步任务结果代理系统，其特征在于，所述第三方结果代理容器包括：

FutureProxy.future字段，用于存放第三方结果容器对象；

FutureProxy.set函数，用于设置被代理的结果容器；

FutureProxy.get函数，用于获取被代理的结果容器中的任务结果。

5.根据权利要求1所述的适用于异构接口的二阶段异步任务结果代理系统，其特征在于，所述第三方结果容器包括：

Future_B.get函数，用于获取被代理的结果容器中的任务结果。

6.如权利要求1-5任一一项所述的一种适用于异构接口的二阶段异步任务结果代理系统的实现方法，其特征在于，包括如下步骤：

自研接口接收任务A和任务B，并传输至自研实现接口：

自研实现接口的submit函数接收任务A并调用线程执行任务A并将任务B传输至自研结果容器的Future_A.next字段；当任务A完成后，将任务A的结果作为参数调用自研结果容器的Future_A.set函数；

自研结果容器的Future_A.set函数调用第三方接口的submit函数执行任务B，并接收结果；当任务B提交后，同步得到了一个Future_B对象，将这个Future_B对象作为参数，调用FutureProxy.set函数，并保存到FutureProxy.future字段中；

所述第三方接口模块的submit函数执行任务B，并将任务B的结果传输至第三方结果容器。

第三方结果代理容器的FutureProxy.get函数获取第三方结果容器的任务B的结果。

7.根据权利要求6所述的一种适用于异构接口的二阶段异步任务结果代理系统的实现方法，其特征在于，所述自研结果容器的Future_A.set函数的执行流程如下：

a1，将state字段由0置为1；

a2，将任务结果赋值给result字段；

a3，插入完全内存屏障或插入等效代码；

a4，调用第三方接口模块的submit函数，并将next字段的任务B提交到第三方接口模块，第三方接口模块返回一个Future_B对象；

a5，获取自研结果容器的Future_A.future字段的FutureProxy，调用FutureProxy的set函数，并将步骤a4返回的Future_B对象作为参数传入。

8.根据权利要求6所述的一种适用于异构接口的二阶段异步任务结果代理系统的实现方法，其特征在于，所述自研结果容器的Future_A.submit函数的执行流程如下：

b1，检查任务A和任务B，任何一个为空指针，则终止程序，若都不为空指针则继续一下操作；

b2，创建一个自研结果容器对象；

b3，将任务B传入自研结果容器的Future_A.next字段；

b4，调用自研实现接口并通过已知方式执行任务A，将任务A的结果作为参数调用步骤b2创建的自研结果容器的Future_A.set函数；

b5，获取步骤b2创建的自研结果容器对象的Future_A.future字段，并创建一个第三方结果代理容器；

b6，submit函数在调用后会同步地返回一个Future_B对象；

b7，当步骤b3执行的任务A产生结果时，将以这个结果为参数，调用自研结果容器的Future_A.set函数。

9.根据权利要求4所述的一种适用于异构接口的二阶段异步任务结果代理系统，其特征在于，所述最终结果容器的FutureProxy.get函数的执行流程如下：

d1，插入插入完全内存屏障或插入等效代码；

d2，读取FutureProxy.future字段；

d3，如果读取到空指针，则进行与第三方结果容器还未产生结果时等效的操作，否则执行步骤d4；

d4，调用Future_B.get函数，获取第三方结果容器中的任务结果，并将调用结果返回。

10.根据权利要求9所述的一种适用于异构接口的二阶段异步任务结果代理系统的实现方法，其特征在于，步骤d3所述的等效操作，包括但不限于：挂起线程、返回空指针。

Images