CN103186383A

CN103186383A - 协同设计中维持关联操作语义一致性的方法

Info

Publication number: CN103186383A
Application number: CN201310130471XA
Authority: CN
Inventors: 高丽萍; 杨辉; 陈庆奎; 郭淑娴; 张玉本
Original assignee: University of Shanghai for Science and Technology
Current assignee: University of Shanghai for Science and Technology
Priority date: 2013-04-16
Filing date: 2013-04-16
Publication date: 2013-07-03

Abstract

本发明提供了一种协同设计中维持关联操作语义一致性的方法，其特征在于：将关联操作分解为本地操作及全局操作；操作转换框架中，添加两个操作历史序列，将关联操作、本地操作分别存放在两个操作历史序列中，存放全局操作在已有操作历史序列中，三个操作历史序列维持关联操作和分解操作关联关系；释放远程编辑操作后，执行消解以前冲突步骤和避免将来冲突步骤，其中，“撤销-转换-执行-转换-重新执行”（Undo-VT-Do-VT-Redo）过程被引入到操作转换策略框架中，用于控制远程操作的执行过程，避免将来冲突步骤：某个全局执行操作所对应的本地执行操作将被应用虚拟转换函数并被重新执行，更新本地内存空间。

Description

协同设计中维持关联操作语义一致性的方法

技术领域

本发明涉及计算机支持的协同设计工作领域，特别涉及一种协同设计中维持关联操作语义一致性的方法。

背景技术

在采用复制式架构的二维协同设计系统中存在两种类型的操作：独立操作和关联操作。独立操作例如Line、Box等不需要参照其它实体信息就能够独立完成参数设定，而关联操作例如Mirror、Array、Copy-Paste等则需要通过参照其它实体信息来完成参数设定。传统的无锁一致性维护算法例如操作转换策略算法及地址空间转换算法等对独立操作的处理采用直接执行，而对关联操作的处理采用先分解后执行。在分解过程中由于没有保留各分解操作之间的关联约束关系，导致各分解操作之间以相互独立的状态执行，因此参照实体及被参照实体之间的关联关系无法得到保证，破坏了关联操作的意愿。

考虑以下例子：人员甲、人员乙正在针对一个建筑的外观进行协同设计。当人员甲完成了窗户的外形设计后，人员乙发起了镜像关联操作（Mirror）用于在某个对称的位置创建另外一个窗户。在人员乙进行镜像关联操作（Mirror）对象选取和参照直线设定过程中，人员甲修改了窗户的高度。由于缺乏对镜像关联操作（Mirror）的语义一致性的维持，操作结束之后得到两个具有不同高度的窗户实体。

关联操作的意愿被破坏会增大设计人员的工作量，缺陷体现在：设计过程中，需对所参照的对象保持紧密关注度，一旦发现参照对象发生了修改，目标对象也要执行相应的修改操作；完成实体的意愿修改需要更多步骤。如图1所示，该场景中含有第一实体对象1（Obj1），人员甲欲以该第一实体对象（Obj1）为参照对象通过Mirror镜像关联操作产生另外一个对称对象为第二实体对象（Obj2）。当人员甲在选择镜像关联操作（Mirror）的参照对象时，人员乙同时发出了对第一实体对象（Obj1）的属性修改操作。当人员甲、人员乙两个操作都完成，镜像关联操作（Mirror）后2，镜像对象的第一实体对象（Obj1）与被参照的第二实体对象（Obj2）之间的属性即、高度并不一致。为达到属性一致的目的，必须再次执行更新操作3（Update）。

维持关联操作的语义一致性存有以下可能的解决方案：第一种策略是采用加锁策略（Lock Strategy），当关联操作开始前，通过加锁申请锁定参照实体，以避免其它用户修改或者删除该参照实体。加锁策略算法虽然简单且易于实施，然而锁的引入却与复制式架构提高并发度的宗旨相违背，降低了系统的响应度；第二种策略是延迟转发策略（Delay-Send Strategy），该策略延迟关联操作的分解操作的转发，直到原操作在本地全部执行完成。该延迟转发策略策略（Delay-Send Strategy）跟上述加锁策略（Lock Strategy）相比具有较好的并发度，但仍然存在下述不足之处，首先，在关联操作的执行过程中，由于时间较长，其它站点会产生较多的并发操作，因此导致处理过程更加复杂；其次，该策略仅能维持不同的目标实体之间的一致性，却不能够维持参照实体和目标实体之间的约束关联关系。例如，在粘贴复制（Copy-Paste）操作中，该策略能够保证所有的由拷贝产生的实体都是相同的，但却不能保证被拷贝实体与原实体之间是相同的。

发明内容

为了克服上述缺点，本发明的目的在于提供一种维持关联操作语义一致性的方法。采用了一种“消解以前-避免将来”策略（Check last–Avoid future，CLAF）。该策略中“撤销-转换-执行-转换-重新执行”（Undo-VT-Do-VT-Redo）过程被引入到操作转换策略框架（OT框架）中用于控制远程操作的执行过程。

本发明提供的一种协同设计中维持关联操作语义一致性的方法，具有这样的特征，具有以下步骤:将关联操作分解为至少一个本地执行操作及至少一个全局执行操作；在操作转换策略框架中，添加第一操作历史序列、第二操作历史序列，将关联操作、本地执行操作分别存放在第一操作历史序列、第二操作历史序列中，存放全局执行操作在已有操作历史序列中，利用第一操作历史序列、第二操作历史序列以及已有操作历史序列来维持原有的关联操作、本地执行操作以及全局执行操作之间的关联关系；以及释放远程编辑操作后，执行消解以前冲突步骤和避免将来冲突步骤，其中，当消解以前冲突步骤检测到远程编辑操作的目标对象是前面某个全局执行操作的参照对象时，执行以下步骤：撤销掉全局执行操作，即、Undo撤销过程；将虚拟转换函数应用在远程编辑操作上，用于根据并发操作来进行相应的虚拟转换，远程编辑操作转换为转换远程编辑操作，即、更新VT转换过程；执行转换远程编辑操作，即、Do执行过程；针对远程编辑操作，将虚拟转换函数应用在全局执行操作上，将全局执行操作转换为转换全局执行操作，即、全局VT转换过程；以及执行转换全局执行操作，即、Redo重新执行过程，避免将来冲突步骤，执行以下步骤：某个全局执行操作所对应的本地执行操作将被应用虚拟转换函数并被重新执行，更新本地内存空间。

在本发明的中协同设计中维持关联操作语义一致性的方法，还可以具有这样的特征：还具有以下步骤，从用户界面释放一个操作后，生成过程将操作转化成为操作转换算法能够直接处理的格式；当操作为原子操作时，将被立即被执行，并存放到已有操作历史序列中；当操作为关联操作的分解操作时，分以下两种情况，当为本地执行操作时，被立即执行并被存放到第二操作历史序列中，当为全局执行操作，被执行并被存放到已有操作历史序列中；然后，将针对本地执行本地操作的操作进行包含转换，以更新第二操作历史序列中操作对象的位置信息。

在本发明的中协同设计中维持关联操作语义一致性的方法，还可以具有这样的特征：其中，操作转换策略框架能处理的有插入全局执行操作、删除全局执行操作、更新全局执行操作、选择本地执行操作以及复制本地执行操作。

在本发明的中协同设计中维持关联操作语义一致性的方法，还可以具有这样的特征：其中，虚拟转换函数用于将第一操作的执行效果包含在第二操作中，可修改目标对象的属性值，虚拟转换函数的前体条件为：第二操作限制并发于第一操作，后续条件为：第一操作的目标对象的属性值被更新为第二操作修正后的新值。

在本发明的中协同设计中维持关联操作语义一致性的方法，还可以具有这样的特征：其中，包含转换用于将第一操作的执行效果包含在第二操作中，可修改目标对象的位置信息，包含转换的前体条件为：第二操作并发于第一操作，后续条件为：第一操作的参照对象和目标对象的位置值都随着第二操作的执行而做出相应的变换。

本发明的效果在于：

本发明提供的协同设计中维持关联操作语义一致性的方法使所有的站点都取得了一致状态，并且无论其中的关联操作还是独立操作都能保持语义一致，避免由远程编辑操作引起的意愿冲突，本发明提出的“消解以前-避免之后（CLAF）”策略使关联操作语义得到了一致保持。

附图说明

图1是本发明的对象修改过程；

图2是本发明的在操作转换策略框架中添加本地执行操作和原有关联操作的示意图；

图3是本发明的GOTO算法中操作历史列表执行操作转换前后对比图；

图4是本发明的GOTO2算法中操作历史列表执行操作转换前后对比图；

图5是本发明的GOTO2算法中7种可能的情况分析图；

图6是本发明的仅使用GOTO算法的限制并发依赖关系的传递性图；

图7是本发明的使用GOTO2算法之后的限制并发依赖关系的传递性图；

图8是本发明的从线性操作历史序列到限制并发依赖树的映射过程；

图9是本发明的含N个操作组成的环的版本将被分解为N个不同的版本；

图10是本发明中详细实施例中初始文档状态；

图11是本发明中详细实施例中不同站点的操作执行顺序；

图12是本发明中详细实施例中各站点执行不同操作之后的文档状态；

图13是本发明中操作[O1,..,Ok]的限制并发依赖关系图；

图14是本发明中操作Oi在[O1,O2,..Oi-1,Oi+1,…,Ok]操作之前到达图；

图15是本发明中操作Oi在序列[O1,O2,…,Ok]之间到达图；

图16是本发明中操作Oi在序列[O1,O2,…,Ok]之后到达图。

具体实施案例

下面结合实施例和附图对本发明进一步说明。

图2是本发明的实施例中在操作转换策略框架中添加本地执行操作和原有关联操作的示意图。

原有的剪切粘贴（Cut-Paste）关联操作被分解为一个选择（Select）本地执行操作、一个复制（Copy）本地执行操作、一个删除（Delete）全局执行操作以及四个插入（Insert）全局执行操作。如图2所示，在操作转换策略（OT）框架4中添加第一操作历史序列5、第二操作历史序列6，分别用于存放关联操作7和分解后的本地执行操作8。操作转换策略（OT）框架中原来已有操作历史序列9用于存放全局执行操作10。第一操作历史序列5、第二操作历史序列6以及已有操作历史序列9用于维持原有的关联操作7和分解后的本地执行操作8、全局执行操作10之间的关联关系。当远程编辑操作中的一个更新（Update）操作从远程站点被释放后，以下消解以前冲突步骤和避免将来冲突步骤将被执行，

消解以前冲突（Check-last）步骤：当该步骤检测到远程编辑操作的更新（Update）操作的目标对象是前面某个插入（Insert）操作的参照对象，其中，远程编辑操作不仅为更新操作，也可为插入、删除等操作，执行以下步骤：

（1）该插入（Insert）操作被撤销（Undo）掉，即、撤销（Undo）过程；

（2）由于更新（Update）操作本身也有可能受到全局执行操作（All-exe）的原有操作历史序列中并发操作的影响，因此，需利用虚拟转换函数，将虚拟转换函数（VT函数）应用在更新（Update）操作上，用于根据并发操作执行相应的虚拟转换，更新（Update）操作被转换为转换更新（V-update）操作，即、针对更新操作的VT转换过程；

（3）执行转换更新（V-update）操作，即、执行（Do）过程）；

（4）针对更新（Update）操作，也将虚拟转换函数（VT函数）应用在插入（Insert）操作上，全局执行操作即、该插入（Insert）操作被转换为转换插入（V-insert）操作，即、针对全局执行操作的VT转换过程；

（5）再来执行上述转换插入（V-insert）操作，即重新执行（Redo）过程。

避免将来冲突（Avoid-future）步骤中，执行以下步骤：

该插入（Insert）操作所对应的原操作的本地分解操作（Select及Copy）将被应用虚拟转换函数（VT函数）后并重新执行，以更新本地内存空间，避免了由更新（Update）操作引起的意愿冲突，经过处理以后的插入（Insert）操作都将包含更新（Update）操作的执行效果，避免以后冲突的发生。

另外，当一个操作从用户界面释放后，生成（Generate）过程负责将该操作转化成为（OT）算法能够直接处理的格式，如以下函数1所示，存在一个修改操作产生过程。

如果该操作是一个原子操作，它将被立即被执行，并附加到全局执行操作的已有操作历史序列（All-exe Op HB）中；如果该操作是一个关联操作的分解操作，有两种情况可能发生：如果为一个本地执行操作（Local-exe Op），则该操作被立即执行，并被附加本地执行操作的第二操作历史序列（Local-exe Op HB）中；如果为一个全局执行操作（All-exe Op），则该操作被执行，并被附加到全局执行操作的已有操作历史序列（All-exeOp HB）中，此后，将包含转换（IT转换）应用在本地执行操作（Local-exe Op）中的操作，以更新用于存放本地执行操作的第二操作历史序列（Local-exe Op HB）中操作对象的位置信息。

其中，本发明提供的方法中定义了5种操作转换策略（OT）框架能够处理的操作，其中3种属于全局执行操作：插入（Insert）操作、删除（Delete）操作和更新（Update）操作，另外2种属于本地执行操作：选择（Select）操作和复制（Copy）操作。由对象捕捉本地执行操作所产生的约束关系存放在全局执行操作的约束类型（referenceType）参数中。将各个操作的格式定义如下：

Insert(Obj,“Obj_Type(Key1(value1),Key2(value2),…,Keyn1(valuen1))”,referenceObj,referenceType,originalOp)；

Delete(Obj,referenceObj,originalOp)；

Update(Obj,“Key(old_Value,new_Value,)”,referenceObj,referenceType,originalOp)；

Select(Obj,originalOp)；

Copy(Obj,originalOp)，

在此，Obj和referenceObj指的是线性地址空间中实体绝对位置的序列值。Obj_Type指明要创建的实体的类型，例如Line、Rectag、Box等。Key用来标识不同的属性类型，例如Position、Radius等。refereneceType代表约束类型，例如平行（Par）、相切（Tan）、端点相交（Endp）等，originalOp代表原有的关联操作。

其中，虚拟转换函数（VT函数）与包含转换函数（IT函数）相类似，都可将第一操作的执行效果包含在第二操作中。二者之间不同之处在于：包含转换函数（IT函数）通过修改目标对象的位置信息来反映其它操作对线性地址空间的影响；而虚拟转换函数（VT函数）则是要修改目标对象的属性值来反映其它操作对操作属性值的影响。虚拟转换函数（VT函数）具有前继条件和后续条件。

VT(O_a,O_b)：Oa’，O_a代表第一操作、O_b代表第二操作，输入参数的前继条件：O_b

限制并发于O_a；输出参数的后续条件：

并且O_a的目标对象的属性值被更新为O_b修正后的新值。将虚拟转换函数（VT函数）的定义如下述函数2至函数6所示。

在本发明提供的方法中，包含转换函数（IT函数）定义为：IT(O_a,O_b)：O_a’，O_a代表第一操作、O_b代表第二操作，输入参数的前提条件：O_b||O_a//O_b并发于O_a；输出参数的后续条件：O_b->O_a’，并且，O_a的参照对象和目标对象的位置值都随着O_b操作的执行而做出相应的变换。这里，“->”表示如果前面实体发生改变，后面的实体也会随之发生改变。

表1为第一操作相对第二操作之间可能的转换类型，如以下表1得出：1）如果O_b是一个插入（Insert）操作，由于插入（Insert）操作会创建一个新的实体，新实体在产生之前，其它操作是不能够对尚未产生的实体进行对照操作的，因此无论O_a是什么类型的操作，都不需要执行虚拟转换(VT)；2）如果O_b是一个删除（Delete）操作或者更新（Update）操作，O_b操纵的是一个已经存在的实体，因此无论O_a是什么类型的操作，O_b都需要执行对O_a的虚拟转换(VT)；3）如果O_b是一个更新（Update）操作，由于不会影响实体的位置值，因此不需要执行包含转换（IT）或者排他转换（ET）。

表1

已知的，操作之间的限制并发关系，O_a代表第一操作、O_b代表第二操作，O_b与O_a之间的限制并发可以表达成

或者

又称为O_b限制并发后续于O_a或者O_a限制并发前继于O_b。操作间的限制并发关系具有传递性，O_c代表第三操作，即：如果且

那么有

为了区分直接限制并发关系和传递限制并发关系，后者被表达成

那么，本发明提供的方法中，第一操作Oa为删除（Delete）操作，第二操作O_b可能是插入（Insert）操作、删除（Delete）操作或者更新（Update）操作：

1）当O_b是插入（Insert）操作时，将不存在第三操作Oc满足

因为插入操作（O_b）与第三操作Oc并发，而且插入操作O_b正在插入的实体对象是第三操作Oc产生时不存在的实体。因此，第三操作Oc的参照实体不会受到插入操作（O_b）的目标实体的影响；

2）当O_b是删除（Delete）操作或者更新（Update）操作时，由于

且

无论第三操作Oc是插入（Insert）、删除（Delete）或更新（Update）操作，根据上述操作间的限制并发关系具有传递性，因此有：

即、删除（Delete）操作

插入（Insert）、删除（Delete）或更新（Update）操作。

另外，当第一操作Oa为更新（Update）操作，第二操作O_b可能是插入（Insert）操作或者更新（Update）操作：

1）当O_b是插入（Insert）操作时，将不存在第三操作Oc满足：

由于插入操作O_b与第三操作Oc并发，且插入操作O_b正在插入的实体对象是第三操作Oc产生时不存在的实体。因此第三操作Oc的参照实体不会受插入操作O_b的目标实体的影响；

2）当O_b也为更新（Update）操作时，由于

且

无论第三操作Oc是插入（Insert）、更新（Update）操作，根据上述操作间的限制并发关系具有传递性，因此有：即、更新（Update）操作

插入（Insert）、更新（Update）操作。

图3是本发明的实施例中GOTO算法中操作历史列表执行操作转换策略前后对比图。

在操作转换策略（OT）的通用条件操作转换策略算法（Generic OperationTransformation Optimized，GOTO）中，本发明中操作（O）的执行形式（EO）及执行上下文（EC(O)）可通过将待执行的操作（O）针对操作历史序列（HB）中的操作执行一系列包含转换（IT）或者排他（ET）转换来获得。

已知的，如图3所示，上述GOTO算法11将第一序列HB(O)12转化成与之等价的第二序列HB(O’)13，以使所有因果前继于O的操作都被置于与之并发的操作之前，即、HB(O’)=HB(O)’.left+HB(O)’.right。其中HB(O)’.left为因果前继于操作O的操作子集组成；HB(O)’.right为并发于操作O的操作子集组成。在执行操作O之前，只需要将操作O相对于HB(O)’.right执行包含转换（IT）即可，并且，有EC(O’)=HB(O’)。

然而，为了维护限制并发操作中的依赖关系，有以下几个方面需要重新考虑：1）如果序列操作历史序列（HB）中存在操作O的限制并发后续操作，则这些操作必须首先被撤销掉（Undo），并将执行上下文（EC(O)）设置为限制并发后续操作被撤销掉（Undo）之后的文档状态；2）限制并发后续操作必须针对其前继操作执行相应的虚拟转换（VT），从而包含前继操作的执行效果。本发明提出了一种扩展后的GOTO算法，即、第二通用条件操作转换策略算法（GOTO2），如图4所示为GOTO2算法14中的序列中操作的转换过程，如此得到HB(O’)=HB(O)’.left+HB(O)’.middle+HB(O)’.right，其中，HB(O)’.left15跟上述GOTO算法中具有相同的含义，为因果前继于操作O的操作子集组成；HB(O)’.middle16为由并发操作中所有与操作O具有限制并发前继关系及普通并发关系的操作组成的子序列；HB(O)’.right17则为由操作O的限制并发后续操作组成的子序列。操作O的执行上下文为EC(O’)=HB(O)’.left+HB(O)’.middle。GOTO2算法详细描述如下述函数7所示。

图5是本发明的实施例中GOTO2算法中7种可能的情况分析图。如图5所示，描述了上述GOTO2算法中可能出现的操作转换策略的7中不同情形。

远程操作的过程中，如果操作O没有因果就绪，说明本地站点上尚有操作O的产生前站点上已经执行过的操作未到达，此时操作O被置入等待队列中延缓执行。否则，执行（Execute）过程首先调用上述GOTO2过程来获得操作O的执行形式（EO）及操作O的执行上下文（EC(O)）。之后，限制并发依赖树（Constrain Concurrent Tree,CCTs）中的结点由下至上依次执行撤销（Undo）操作。执行形式（EO）在转换了的文档环境下执行。为了在本地执行操作中包含执行形式（EO）的执行效果，本地执行（Local-exe）中的所有操作要相对于执行形式（EO）执行包含转换（IT转换），并重新执行。此后，限制依赖树中所有操作从上至下相对于其直接并发前继操作执行包含转换（IT转换）和虚拟转换（VT转换），并重新执行。下述过程1为远程操作的过程。

其中，操作O的限制并发依赖树递归定义为：限制并发依赖树（CCTs）是n（n≥1）个结点的有限集，满足如下两个条件：有且仅有一个根结点（Root），且Root=O；其余的结点可分为m（n≥0）个子集CCT1、CCT2、…、CCTm，其中每个子树本身又是一颗树，并称其根的子树。假设每颗子树的根为Root1、Root2、…、Rootm，则有（1=<i<=m）。

由于限制并发操作具有传递性，那么两个具有间接限制并发关系的操作在中间操作没有到达之前，有可能检测不到。图6是本发明的仅使用GOTO算法的限制并发依赖关系的传递性图；图7是本发明的使用GOTO2算法的限制并发依赖关系的传递性图。

在下例中，O₁=Update(1,”Radius(20,30)”,null,);//修改Obj₁圆的半径

O₂=Select(2,null,1);O₃=Tan(2,1,null,1);

O₄=Update(2,”Position((110,105,0),(139.223,116.1304,0))”,1,“Tan(-,1)”,1);//Tan(-,1)表示顺时针的第一个切点

O₅=Select(2,null,1);O₆=SetParemeter(...);//这里省略了具体的参数值

O₇=Insert([3,4,5,6,7],“Line(Position(57,61,0),Position(33,109,0),1,Array(…));Line(Position(45,42,0),Position(-9,45,0),1,Array(…));Line(Position(56,21,0),Position(26,-24,0),1,Array(…));Line(Position(79,21,0),Position(103,-28,0),1,Array(…));Line(Position(91,40,0),Position(145,36,0),1,Array(…))”,1);//Array中的具体参数被省略

在第三站点（site3），当操作O1到达时，序列（HB）中包含第四、第七操作（O4,O7）。由于

操作O4被撤销（Undo）并根据操作O1执行虚拟转换，从而得到O4’=Update(2,”Position((110,105,0),(128,119,0),1,Tan(-,1))”,1)。然而在采用上述GOTO算法进行控制时，第四操作O4和第七操作O7之间的关系在操作O1到达之前并不再被检测及处理。因此，当虚拟转换后的第四操作（O4’）被重新执行时，第七操作O7不会相对于上述O4’执行虚拟转换，如图6所示，从而导致第三站点（site3）18出现错误的执行结果，即、线与圆无法相切。为了解决以上问题，本发明提出采用GOTO2算法，如图7所示，当操作O被执行之前，所有满足

的操作Ok都应该被置于操作O之后。当另一个操作O’到达时仅需要将其插入到限制并发操作列表的第一个操作之前，从而导致第三站点（site3）19出现正确的执行结果，即、线与圆相切。修正后的上述GOTO2算法如下函数8所示：

查找后续（Find Following）函数会找到所有的限制并发后续操作，并将这些操作构建成一棵限制并发依赖树。该函数通过递归调用的方式来由上至下构建操作O的限制并发依赖树。查找后续（Find Following）过程首先查看操作列表L[EO1,…,EOm]中所有的操作以找出操作列表L中所有操作O的直接限制并发后续操作，并用这些操作为根结点来构建限制并发依赖树（CCTs）中的第二层，限制并发依赖树（CCTs）的根结点是通过操作O来构建的。该过程在所有子树上进行递归调用，直到找不到满足条件的操作为止。查找后续（Find Following）函数如下函数9所示。

图8描述了查找后续（Find Following）函数中线性操作历史序列限制并发依赖树的构建过程20。其中，实线部分表示限制并发关系

而虚线部分表示从线性地址空间21到依赖树22的映射关系。下述过程2为修改后的控制过程、下述过程3为VTF函数。修改后的控制过程通过调用VTF函数来对限制并发依赖树（CCTs）中的结点由上至下依次执行虚拟转换（VT）和包含转换（IT）。这样，操作O的执行效果会被反映到限制并发依赖树（CCTs）中的每个结点上。

关联操作的目标对象和参照对象之间的依赖关系已能正确维持。然而，由于限制并发关系具有传递性，有可能出现两个操作相互并发依赖的情形，从而导致限制并发意愿冲突的产生，体现在限制依赖树中就是出现限制环。在这种情形下，尽管所有的操作都没有试图修改同一个目标对象，传统的冲突定义无法检测到冲突的发生。然而各操作之间相互参照，却不能同时得到满足，由此产生了限制冲突（Constrain Conflict）现象。

限制冲突（Constrain Conflict）现象是由于限制并发的传递性而产生的。给出限制冲突的定义，指出限制冲突与传统冲突的区别，并给出基于MV（Multi-version）技术的冲突解决方案。

在操作转换策略（OT）算法中，冲突

被定义为：

第一更新操作Ua和第二更新操作Ub相互冲突，表达成

当且仅当：（1）上述Ua和上述Ub相互并发；（2）它们操纵的是同一个实体对象，即：Ua.p=Ub.p；（3）它们操纵的是一个属性类型，即Ua.key=Ub.key。根据已知定义，冲突当且仅当多个用户同时修改同一个实体的同一个属性时才会发生。不同实体之间的限制并发传递关系也会导致意愿冲突的产生。

在操作转换策略（OT）算法中，操作之间限制冲突的定义：

第一操作Oa和第二操作Ob相互限制冲突，表达成

当且仅当：

且

如图9中所示，上部的虚线23代表第一操作O、第二操作O1和第三O3之间由于限制并发关系产生的限制冲突。当第一操作O到达时，限制树中形成一个环，限制冲突产生。多版本（Multi-version，MV）机制通过保持同一个实体的多个版本来保留多个冲突更新操作的执行效果。

采用多版本（Multi-version，MV）机制将限制树中的环进行破解，以产生多个版本的方法来进行冲突消解。假设冲突环中有若干（N）个结点，那么其中就有若干（N）条限制边。通过将这若干（N）条限制边中的某一条删除掉的方法，可以得到若干（N）个不同的执行版本。

在采用多版本（Multi-version，MV）机制来消除限制冲突中，如图9所示，一个环中包含以下的操作序列<O,O1,…,On-1,O>。对于冲突解决，讨论以下三种情况：

当移除限制并发关系

时24，如图9中的第一版本(a)，此时只需要将第一操作O移动到限制环的最末端，并修改第二操作O1的参照实体为空即可，消解之后的结果序列为<O1,…,On-1,O>。

当移除

之间的某一个限制并发关系时25，如图9中的第二版本(b)，其中i,j∈[1,n-1]（图8(b)），需要执行以下步骤：

（1）从下向上依次Undo满足

（p∈[1,n-1]）的操作组成的限制并发依赖树中的所有操作。Oj的参照实体（referenceObj）被设置为空（null），且Oj的new_value要被设置为old_value，也就是说，Oi的执行效果要从Oj中被排除掉，从而消除Oi和Oj之间的限制并发关系。以图9中第二版本(b)为例，撤销（Undo）的顺序为<O5,O6,O3>，且操作O3的参照实体（referenceObj）被设置为空（null），设置O3.Obj.new_value=O1.Obj.old_value；

（2）调用VTF(Oj,CCTs)过程将限制并发依赖树（CCTs）中除了操作O之外的操作针对其父操作结点执行虚拟转换（VT）；

（3）从上到下依次执行限制并发依赖树（CCTs）中转换之后的操作；

（4）重新安排操作O的限制并发前继操作和限制并发后续操作的前后顺序。

当移除之间的限制并发关系时26，如图9中的第三版本(c)，在这种情况下只需要将操作O移动到限制环的最前端，并将第三操作O3的参照实体（referenceObj）设置为空（null）即可，消解之后的操作序列为：<O,O1,…,On-1>。

下述函数10为能解决上述限制冲突

的上述GOTO2算法详细描述。

在此，给出详细实施例做进一步说明，图10是详细实施例中初始文档状态27，图11是详细实施例中不同站点的操作执行顺序28。其中，各个操作为：

O₁=Insert(20,”Circle(Position(137.5,220,0),20)”,null,null)；//操作O₁想要在Object₁之上插入一个圆。

O₂=Copy(20,1)；//操作O₂是Copy-Paste操作的分解操作。

O₃=Insert(21,“Circle(Position(200,220,0),20)”,20,ATTR,1)；//操作O₃Copy-Paste操作的另外一个分解操作，操作O₃想要复制出一份与Object₂₀完全相同对象。

O₄=Update(20,“Radiu(20,25)”,null,null)；//操作O₄想要把Object₂₀的半径从20修改为25。

O₅=Insert(22,”Line(Position(175,120,0),Position(210,60,0))”,null,null)；//操作O₅想要插入一个新的Line对象。

O₆=Insert(21,”Line(Position(200,130,0),Position(280,130,0))”,null,null)；//操作O₆想要插入另外一个新Line对象。

O₇=Insert(22,“Circle(Postion(272.5,220,0),25)”,20,ATTR,1)；//操作O₇是Copy-Paste操作的另外一个分解操作,用于插入一个与Object₂₀相同的实体

O₈=Update(22,“Position((200,130,0),(180,130,0))”,null,null)；//操作O₈想要将Object₂₂的第二个结点的位置从position(200,130,0)变为positioin(180,130,0)。

O₉=Update(22,“Position((175,120,0),(200,130,0))”,24,“Endp(2,1)”)；/操作O₉想要修改Object₂₄的第一个结点的位置使之与Object₂₂的第一个结点重合。

O₁₀=Select(25,1)；

O₁₁=Insert(25,“Line(Position(305,120,0),Position(270,60,0))”,23,“Mirror(Line(Position(240,130,0),Position(160,60,0)))”,1)；//操作O₁₁是Mirror操作的分解操作,想要生成Object₂₄相对于Line(Position(305,120,0),Position(270,60,0))的对称对象。

本发明用符号Doc(i,j)来表示站点i在执行完操作j之后的文档状态，并用EOy○EOx(Doc(i,j))来表示在Doc(i,j)上依次执行EOx、EOy之后的文档状态。如图12所示为各个操作的执行形式及各个站点在执行后各操作之后的文档状态。第一站点site1、第二站点site2以及第三站点site3的初始的文档状态分别为Doc(1,0)、Doc(2,0)以及Doc(3,0)，三者相同。

第一站点site1具有下述操作29:

（1）执行操作O₁、O₄、O₆：

EC(O₁)=HB={}；Doc(1,6)=O₆○O₄○O₁(Doc(1,0))；

（2）执行操作O₃：

EC(O₃)=HB={EO₁,EO₄,EO₆}；

由于EO₁->O₃、

且EO₆||O₃，O₃需要相对于EO₄执行相应的包含/虚拟转换，且需要对EO₆执行包含转换。这样就可以得到：

EO₃=IT(VT(IT(O₃,EO₄),EO₄),EO₆)=Insert(21,“Circle(Position(200,220,0),25)”,20,ATTR,1)；

Doc(1,3)=EO₆(Doc(1,6))；

（3）执行操作O₈：

Doc(1,8)=EO₈(Doc(1,3))；

（4）执行操作O₇：

HB={EO₁,EO₄,EO₆,EO₃,EO₈}；由于EO₆||O₇、EO₃->O₇且EO₈||O₇，

EC(O₇)=HB’={EO₁,EO₄,EO₃’,EO₆’,EO₈’}，其中：

EO₃’=Insert(21,“Circle(Position(200,220,0),25)”,20,ATTR,1)；EO₆’=Insert(23,”Line(Position(200,130,0),Position(280,130,0))”,null,null”,null,null)；EO₈’=Update(23,“Position((200,130,0),(180,130,0))”,null,null)；

则：EO₇=IT(IT(IT(O₇,EO₃’),EO₆’),EO₈’)=Insert(22,“Circle(Position(272.5,220,0),25)”,20,ATTR,1)；

Doc(1,7)=EO₇(Doc(1,8))；

（5）执行操作O₅：

HB={EO₁,EO₄,EO₃,EO₆,EO₈,EO₇}；由于EO₆||O₅、EO₈||O₅且EO₇||O₅，

EO₅=IT(IT(IT(O₅,EO₆),EO₈),EO₇)=Insert(22,”Line(Position(175,120,0),Position(210,60,0))”,null,null)；

Doc(1,5)=EO₅(Doc(1,7))；

（6）执行操作O₉：

HB={EO₁,EO₄,EO₃,EO₆,EO₈,EO₇,EO₅}；由于EO₆->O₉、

EO₇->O₉且EO₅->O₉，

EC(O₉)={EO₁,EO₄,EO₃,EO₆,EO₇’,EO₅’,EO₈’}，其中：

EO₇’=Insert(23,“Circle(Position(272.5,220,0),25)”,20,ATTR,1)；

EO₅’=Insert(22,”Line(Position(175,120,0),Position(210,60,0))”,null,null)；

EO₈’=Update(24,“Position((200,130,0),(180,130,0))”,null,null)；

EO₉=IT(VT(O₉,EO₈’),EO₈’)=Update(22,“Position((175,120,0),(180,130,0))”,24,“Endp(2,1)”)；Doc(1,9)=EO₉(Doc(1,5))；

（7）执行操作O₁₀、O₁₁：

HB={EO₁,EO₄,EO₃,EO₆,EO₇,EO₅,EO₈,EO₉}；由于EO₈||O₁₁且

EC(O₁₁)={EO₁,EO₄,EO₃,EO₆,EO₇,EO₅,EO₈,EO₉}，且：

EO₁₁=IT(VT(IT(O₁₁,EO₈),EO₉),EO₉)=Insert(25,“Line(Position(300,130,0),Position(270,60,0))”,24,“Mirror(Line(Position(240,130,0),Position(160,60,0)))”,1)；

Doc(1,11)=EO₁₁○EO₁₀(Doc(1,9)；

第二站点site2具有下述操作30:

（1）执行操作O₁：

EC(O₁)=HB={}；EO₁=O₁；Doc(2,1)=EO₁(Doc(2,0))；

（2）执行操作O₂、O₃：

EC(O₃)=HB={EO₁}；EO₃=O₃；Doc(2,3)=EO₃(Doc(2,1))；

（3）执行操作O₄：

HB={EO₁,EO₃}，且Local_exe HB={EO₂}；由于O₁->O₄，且

O₃首先被撤销以包含O₄的执行效果，且EC(O₄)={O₁}；

EO₃’=IT(VT(EO₃,O₄),O₄)=Insert(21,“Circle(Position(200,220,0),15)”,25,ATTR,1)；

执行O₄后，EO₂’=IT(EO₂,EO₄)=O₂=Copy(20,1)，重新执行EO₂’，以更新本地内存中剪贴板的内容；

Doc(2,4)=EO₃’○EO₄(Doc(2,3))；

（4）执行操作O₇：

Doc(2,7)=O₇(Doc(2,4))；

（5）执行操作O₅：

HB={EO₁,EO₄,EO₃,EO₇}；由于EO₇||O₅，

EO₅=IT(O₅,EO₇)=Insert(22,”Line(Position(175,120,0),Position(210,60,0))”,null,null)；

Doc(2,5)=EO₅(Doc(2,7))；

（6）执行操作O₆：

HB={EO₁,EO₄,EO₃,EO₇,EO₅}；由于EO₃||O₆、EO₇||O₅且EO₅||O₆，

EO₆=IT((IT(O₆,EO₃),EO₇),EO₅)=Insert(24,”Line(Position(200,130,0),Position(280,130,0))”,null,null)；

Doc(2,6)=EO₆(Doc(2,5))；

（7）执行操作O₉：

Doc(2,9)=O₉(Doc(2,6))；

（8）执行操作O₈：

HB={EO₁,EO₄,EO₃,EO₇,EO₅,EO₆,EO₉}；由于EO₃->O₈、EO₇||O₈、EO₅||O₈、EO₆->O₈且

EO₆首先被转换到EO₇之前，然后EO₉’被撤销掉，得到：

EC(O₈)=HB’={EO₁,EO₄,EO₃,EO₆’,EO₇’,EO₅’}，其中：

EO₆’=Insert(24,”Line(Position(200,130,0),Position(280,130,0))”,null,null)；

EO₇’=Insert(23,“Circle(Position(272.5,220,0),25)”,20,ATTR,1)；

EO₉’=Update(22,“Position((175,120,0),(200,130,0))”,22,“Endp(2,1)”)；

EO₈=IT(O₈,EO₇’),EO₅’)=Update(24,“Position((200,130,0),(180,130,0))”,null,null)；

EO₉”=IT(VT(EO₉’,EO₈),EO₈)=Update(22,“Position((175,120,0),(180,130,0))”,22,“Endp(2,1)”);

Doc(2,8)=EO₉”○EO₈(Doc(2,9))；

（9）执行操作O₁₁:

HB={EO₁,EO₄,EO₃,EO₆,EO₇,EO₅,EO₈,EO₉}；由于且

O₁₁要针对O₉执行包含和虚拟转换，从而得到：

Doc(2,11)=EO₁₁(Doc(2,8))；

第三站点site3具有下述操作31:

（1）执行操作O₁、O₃：

Doc(3,3)=O₃○O₁(Doc(3,0))；

（2）执行操作O₄：

HB={EO₁,EO₃}；由于O₁->O₄且

O₃首先被撤销掉而包含O4的执行效果，且EC(O₄)={O₁}；

EO₄=O₄；且在执行完O₄之后，EO₂’=VT(IT(EO₂,EO₄),EO₄)=O₂=Copy(20,1)；

然后，EO₂’被重新执行，以更新本地剪贴板中的信息；

Doc(3,4)=EO₃’○EO₄(Doc(3,3))；

（3）执行操作O₅：

Doc(3,5)=O₅(Doc(3,4))；

（4）执行O₆：

EC(O₆)=HB={EO₁,EO₄,EO₃,EO₅}；由于EO₄->O₆、EO₃||O₆且EO₅||O₆，

EO₆=IT(IT(O₆,EO₃),EO₅)=Insert(23,”Line(Position(200,130,0),Position(280,130,0))”,null,null)；Doc(3,6)=EO₆(Doc(3,5))；

（5）执行操作O₇：

EC(O₇)=HB={EO₁,EO₄,EO₃,EO₅,EO₆}；由于EO₃->O₇、EO₅||O₇且EO₆||O₇，

EO₇=IT(IT(O₇,EO₅),EO₆)=Insert(23,“Circle(Position(272.5,220,0),25)”,20,ATTR,1)；

Doc(3,7)=EO₇(Doc(3,6))；

（6）执行操作O₁₀、O₁₁：

Doc(3,11)=O₁₁(Doc(3,7))；

（7）执行操作O₈：

EC(O₈)=HB={EO₁,EO₄,EO₃,EO₅,EO₆,EO₇,EO₁₁}；由于EO₆->O₈、EO₇||O₈且EO₁₁||O₈，

EO₈=IT(O₈,EO₁₁)=Update(24,“Position((200,130,0),(180,130,0))”,null,null);

Doc(3,8)=EO₈(Doc(3,11))；

（8）执行操作O₉：

HB={EO₁,EO₄,EO₃,EO₅,EO₆,EO₇,EO₁₁,EO₈}；

由于且首先操作EO₁₁与EO₈要相互交换，从而得到：

HB’={EO₁,EO₄,EO₃,EO₅,EO₆,EO₇,EO₈’,EO₁₁’}，其中：

EO₈’=Update(24,“Position((200,130,0),(180,130,0))”,null,null)；

EO₁₁’=Insert(25,“Line(Position(305,120,0),Position(270,60,0))”,23,“Mirror(Line(Position(240,130,0),Position(160,60,0)))”,1)；

之后，O₁₁’首先被undo掉用以包含O₉的执行效果；

EO₉=IT(VT(O₉,EO₈’),EO₈’)=Update(22,“Position((175,120,0),(180,130,0))”,22,“Endp(2,1)”)；

EO₁₁”=IT(VT(EO₁₁’,EO₉),EO₉)=Insert(25,“Line(Position(300,130,0),Position(270,60,0))”,24,“Mirror(Line(Position(240,130,0),Position(160,60,0)))”,1);

Doc(3,9)=EO₁₁”○EO₉(Doc(3,8));

最后第一站点Doc(1,11)、第二站点Doc(2,11)以及第三站点Doc(3,9)都取得了一致的文档状态，并且其中的关联及独立操作：镜像（Mirror）操作、复制粘贴（Copy-Paste）操作及更新（Update）操作的语义都保持了一致。

本发明提供的方法中所有站点上的所有操作都依据操作转换策略（OT）算法来处理并执行，则在所有站点最后的文档状态都能达到一致，并且所有用户的意愿都能得到维持。提供的“消解以前-避免将来”策略（Check last–Avoid future，CLAF）的正确性是以操作转换策略（OT）策略的正确性为基础的。操作转换策略(OT)算法保证所有的操作只有满足因果就绪时条件下才能执行，并保证所有并发但并非限制并发的操作的乱序执行,即、按照任意的顺序执行并发操作，都能取得一致的结果。“消解以前-避免将来”策略（CLAF）中的操作之间的关系除了具有操作转换策略OT策略中所处理的因果关系（→）、并发关系（||）外，另外还有一种特殊的并发关系，称为限制并发关系

由于因果关系和并发关系的处理都是由传统的操作转换策略（OT）算法来完成的，要证明CLAF策略的有效性只要证明限制并发操作执行的乱序性即可，即指无论限制并发操作按照何种顺序到达，不同站点上文档最终状态都能保持一致。采用数学归纳方法来说明：

图13是本发明中操作[O1,..,Ok]的限制并发依赖关系32，如图13所示，可假设有n个限制并发依赖操作O₁、O₂、…、O_n，且满足

那么，总共有n!种可能的到达顺序。此时需要证明，无论O₁、O₂、…、O_n按照何种顺序到达，最终的执行结果都是[O₁,O₂’,O₃’,…,O_n’]，且O₂’=VT(IT(O₂,O₁),O₁)、O₃’=VT(IT(O₃,O₂’),O₂’)、…、O_n’=VT(IT(O_n,O_n-1’),O_n-1’)。

1）如果n=1，则所有站点的执行顺序都只能有一种，即：[O₁]；

2）如果n=2，分两种情况：

（1）如果O₁在O₂之前到达，则执行过程如下：

i.执行O₁，且HB变为[O₁]；

ii.O₂’=VT(IT(O₂,O₁),O₁)；

iii.执行O₂’，且HB变为[O₁,O₂’]；

（2）如果O₂在O₁之前到达，则执行过程如下：

i.执行O₂，且HB变为[O₂]；

ii.Undo(O₂)，且HB变为[]；

iii.执行O₁，且HB变为[O₁]；

iv.O₂’=VT(IT(O₂,O₁),O₁)；

v.执行O₂’，且HB变为[O₁,O₂’]；

根据（1）和（2）可以判定无论O₁、O₂以何种顺序到达，最终结果都是[O₁,O₂’]，且所有站点上O₁、O₂的执行状态都是一致的。

3）如果n=k，假设n=k-1时结论成立。

即对于序列[O₁,O₂,…,O_i-1,O_i,O_i+1,…,O_k]，且满足

（见图10），[O₁,…,O_i-1]子序列及[O_i+1,…,O_k]子序列，其中的操作无论以何种顺序到达，最后的执行子序列都为[O₁,O₂’,...,O_i-1’]、[O_i+1,O_i+2’,…,O_k’]，其中O₂’=VT(IT(O₂,O₁),O₁)、…、O_i-1’=VT(IT(O_i-1,O_i-2’),O_i-2’)、O_i+2’=VT(IT(O_i+2,O_i+1),O_i+1)、…、O_k’=VT(IT(O_k,O_k-1’),O_k-1’)。而由于子序列[[O₁,O₂,…O_i-1]与[O_i+1,…O_k]]中的元素在缺少O_i操作的情况下无法判断其限制并发关系，所以无法判断其执行顺序。

下面分3种情况来讨论由于O_i到达顺序的不同，所导致的不同的执行过程及最终结果：

图14是本发明中操作Oi在[O1,O2,..Oi-1,Oi+1,…,Ok]操作之前到达33。当O_i在[O₁,O₂,..O_i-1,O_i+1,…,O_k]操作之前到达时，则执行过程如下：

执行O_i，且HB变为[O_i]；

无论子序列[O₁-O_i-2]和子序列[O_i+1,…,O_k]以何种顺序到达，执行结果都为[O₁,…,O_i-2’]及[O_i+1’,…,O_k’]，且O₂’=VT(IT(O₂,O₁),O₁)、…、O_i-2’=VT(IT(O_i-2,O_i-3’),O_i-3’)；

O_i+1’=VT(IT(O_i+1,O_i),O_i),…,O_k’=VT(IT(O_k,O_k-1’),O_k-1’)，则HB为[O_i]+，子序列[O₁,…O_i-2’]及[O_i+1’,…O_k’]的一个穿插组合；

当O_i-1到达时，首先执行Undo(O_k’,…,O_i+1’,O_i)，且HB变为[O₁,…O_i-2’]；O_i-1’=VT(IT(O_i-1,O_i-2’),O_i-2’)；

执行O_i-1’，且HB变为[O₁,…O_i-2’,O_i-1’]；O_i’=VT(IT(O_i,O_i-1’),O_i-1’)；

执行O_i’，且HB变为[O₁,…O_i-2’,O_i-1’,O_i’]；O_i+1’=VT(IT(O_i+1,O_i’),O_i’),…,O_k’=VT(IT(O_k,O_k-1’),O_k-1’)；执行O_i+1’,…O_k’,且HB变为[O₁,…,O_i’,O_i+1’,…O_k’]。

图15是本发明中操作Oi在序列[O1,O2,…,Ok]之间到达34。当O_i在序列[O₁,O₂,…,O_k]之间到达时，则执行过程如下：

对于子序列[O1,…Oi-1]，无论以何种顺序执行，其在Oi到达之后，都将通过一系列的Undo、VT、Redo过程转化为[O1,O2’,…,Oi-1’,Oi’]且O2’=VT(IT(O2,O1),O1)、…、Oi’=VT(IT(Oi,Oi-1’),Oi-1’)；

对于子序列[Oi+1,…,Ok]，无论以何种顺序执行，其在Oi到达之后，都将通过一系列的Undo、VT、Redo过程转化为[EOi,Oi+1’,…,Ok’]且Oi+1’=VT(IT(Oi+1,EOi),EOi)、…、Ok’=VT(IT(Ok,Ok-1’),Ok-1’)，如果在Oi+1执行之前，Oi-1尚未到达，则EOi=Oi，转下一步骤；否则EOi=Oi’=VT(IT(Oi,Oi-1’),Oi-1’)，此时文档状态变为[O1,…,Oi’,Oi+1’,…,Ok’]，过程结束；

如果EOi=Oi，则当Oi-1到达后，要执行一系列的Undo操作撤销掉[Oi+1,…,Ok]子系列中所有Oi的限制并发后续操作，并撤销Oi本身，执行Oi’=VT(IT(Oi,Oi-1’),Oi-1’)、Oi+1’=VT(IT(Oi+1’,Oi’),Oi+1’)、…、Ok’=VT(IT(Ok’,Ok-1’),Ok’)。并重新执行Oi’、Oi+1’、...等操作，此时HB变为[O1,…,Oi’,Oi+1’,…Ok’]。

图16是本发明中Oi在序列[O1,O2,…,Ok]之后到达35。当O_i在序列[O₁,O₂,…,O_k]之后到达时，则执行过程如下:

对于子序列[O₁,…,O_i-1]，无论以何种顺序执行，都将通过一系列的Undo、VT、Redo过程转化为[O₁,O₂’,…,O_i-1’,O_i’]，且O₂’=VT(IT(O₂,O₁),O₁)、…、O_i’=VT(IT(O_i,O_i-1’),O_i-1’)；

对于子序列[O_i+1,…,O_k]，无论以何种顺序执行，都将通过一系列的Undo、VT、Redo过程转化为[O_i+1,…,O_k’]且O_i+1’=VT(IT(O_i+1,EO_i),EO_i)、…、O_k’=VT(IT(O_k,O_k-1’),O_k-1’)，序列HB为子序列[O₁,O₂’,…_,Oi-1’]与子序列[O_i+1,…,O_k’]的穿插组合；

O_i到达后，要执行O_k’、…、O_i+1的Undo操作，此时HB变为[O₁,O₂’,…,O_i-1’]；

执行O_i’=VT(IT(O_i,O_i-1’),O_i-1’)，O_i+1’=VT(IT(O_i+1,O_i’),O_i’)、…、O_k’=VT(IT(O_k’,O_k-1’),O_k-1’)；

执行O_i’、O_i+1’、…、O_k’，此时HB变为[O₁,…,O_i’,O_i+1’,…O_k’]。

上述分析了O_i可能出现的三种之前、之间以及之后到达的各个状态，当n=k时结论仍然成立。限制并发操作执行具有乱序性，由于因果关系和并发关系的处理都是由传统的操作转换策略（OT）算法来完成的，则本发明提出的CLAF策略是具有有效性，即、无论限制并发操作按照何种顺序到达，不同站点上文档最终状态都能保持一致。

发明的作用与效果

综上所述，本发明的作用和效果在于：

本发明提供的协同设计中维持关联操作语义一致性的方法中的虚拟转换（VT）即消除了并发操作的影响，还保证了分解操作之间的关联关系，关联操作的意愿不被破坏。本发明提出的第二通用条件操作转换策略算法（GOTO2），即、扩展后的通用条件操作转换策略算法（GOTO），维护住了限制并发操作中的依赖关系，解决了由于限制并发操作具有传递性，那么两个具有间接限制并发关系的操作在中间操作没有到达之前有可能被检测不到的问题。

上述实施方式为本发明的优选案例，并不用来限制本发明的保护范围。

Claims

1.一种协同设计中维持关联操作语义一致性的方法，其特征在于，具有以下步骤：

将关联操作分解为至少一个本地执行操作及至少一个全局执行操作；

在操作转换策略框架中，添加第一操作历史序列、第二操作历史序列，将所述关联操作、所述本地执行操作分别存放在所述第一操作历史序列、所述第二操作历史序列中，存放所述全局执行操作在已有操作历史序列中，利用所述第一操作历史序列、所述第二操作历史序列以及所述已有操作历史序列来维持原有的所述关联操作、所述本地执行操作以及所述全局执行操作之间的关联关系；以及

释放远程编辑操作后，执行消解以前冲突步骤和避免将来冲突步骤，

其中，当所述消解以前冲突步骤检测到所述远程编辑操作的目标对象是前面某个所述全局执行操作的参照对象时，执行以下步骤：

撤销掉所述全局执行操作，即、Undo撤销过程；

将虚拟转换函数应用在所述远程编辑操作上，用于根据所述并发操作来进行相应的虚拟转换，所述远程编辑操作转换为转换远程编辑操作，即、更新VT转换过程；

执行所述转换远程编辑操作，即、Do执行过程；

针对所述远程编辑操作，将所述虚拟转换函数应用在所述全局执行操作上，将所述全局执行操作转换为转换全局执行操作，即、全局VT转换过程；以及

执行所述转换全局执行操作，即、Redo重新执行过程，

所述避免将来冲突步骤，执行以下步骤：

某个所述全局执行操作所对应的所述本地执行操作将被应用所述虚拟转换函数并被重新执行，更新本地内存空间。

2.根据权利要求1中所述协同设计中维持关联操作语义一致性的方法，其特征在于，还具有以下步骤：

从用户界面释放一个操作后，生成过程将所述操作转化成为操作转换算法能够直接处理的格式；

当所述操作为原子操作时，将被立即被执行，并存放到所述已有操作历史序列中；

当所述操作为所述关联操作的分解操作时，分以下两种情况，当为所述本地执行操作时，被立即执行并被存放到所述第二操作历史序列中，当为所述全局执行操作，被执行并被存放到所述已有操作历史序列中；

然后，将针对所述本地执行本地操作的所述操作进行包含转换，以更新所述第二操作历史序列中操作对象的位置信息。

3.根据权利要求1中所述协同设计中维持关联操作语义一致性的方法，其特征在于：

其中，所述操作转换策略框架能处理的有插入全局执行操作、删除全局执行操作、更新全局执行操作、选择本地执行操作以及复制本地执行操作。

4.根据权利要求1中所述协同设计中维持关联操作语义一致性的方法，其特征在于，还具有以下步骤：

其中，所述虚拟转换函数用于将第一操作的执行效果包含在第二操作中，可修改目标对象的属性值，所述虚拟转换函数的前体条件为：所述第二操作限制并发于所述第一操作，后续条件为：所述第一操作的所述目标对象的属性值被更新为所述第二操作修正后的新值。

5.根据权利要求2中所述协同设计中维持关联操作语义一致性的方法，其特征在于，还具有以下步骤：

其中，所述包含转换用于将第一操作的执行效果包含在第二操作中，可修改目标对象的位置信息，所述包含转换的前体条件为：所述第二操作并发于所述第一操作，后续条件为：所述第一操作的参照对象和所述目标对象的位置值都随着所述第二操作的执行而做出相应的变换。