CN1231440A - 数据处理方法、记录介质及数据处理设备 - Google Patents

Abstract

即使基于未来的消息传递正在执行时,对象由于某种问题进入等待状态,对象也不需执行暂停处理而从等待状态中退出。当消息从客户对象发送到服务对象时,数据区被保留下来。若服务对象执行的处理过程正确完成,表示处理结果的数据存储在数据区;若未正确完成,表示服务对象状态的数据存储在数据区。通过读出数据区中的数据,若服务对象的处理过程已经正确完成,客户对象接收处理结果的数据;若未正确完成,客户对象接收状态数据。

Description

数据处理方法、记录介质及数据处理设备

本发明涉及在对象间交换消息时所使用的一种数据处理方法。本发明也涉及一种记录执行上述数据处理方法的操作系统的记录介质，以及一种具有上述记录介质的数据处理设备。

随着近来软件设计技术的进步，基于面向对象技术的软件得到了发展。当面向对象技术被应用于软件时，软件的功能，例如应用程序，可以通过对象的形式形成模块。通过以消息的形式彼此交换所需要的信息，对象以模块的形式完成其功能。这种消息交换称作“消息传递”。

作为一种执行消息传递的方法，人们已经提出了不同的技术并已将它们付诸实施。其中一种技术是基于“未来”的消息传递。基于未来的消息传递的基本操作如图1所示。在图1中，所示消息发送对象为客户对象，所示消息接收对象为服务对象。

如图1中箭头B1所示，在基于未来的消息传递中，消息从客户对象发送到服务对象，以请求服务对象执行预处理。此时，用于存储服务对象所执行的处理结果的数据区被保留出来。该数据区用于存储将由客户对象接收的结果并称之为“未来”。

如图1中实线B2所示，服务对象根据从客户对象发送的消息请求执行处理。当处理完成时，服务对象将处理结果存储在未来中，如图1中箭头B3所示。

同时，客户对象在将上述消息发送给服务对象后继续处理，如图1中实线B4所示。因此，当客户对象需要服务对象所执行的处理结果时，它就读出存储在未来中的数据，如图1中箭头B5所示。

此时，如果服务对象所执行的处理结果还没有被存储在未来中，那么客户对象处于等待状态，如图1中虚线B6所示。当服务对象发送的处理结果存储在未来中时，该处理结果从未来传递到客户对象，如图1中箭头B7所示。

也就是说，如果服务对象所执行的处理结果存储在未来中，那么客户对象立即接收该处理结果。但是，如果服务对象所执行的处理结果还没有被存储在未来中，在该结果存储在未来中之前客户对象保持在等待状态。

如图1所示，在基于未来的消息传递中，客户对象在将消息发送给服务对象后需要等待服务对象所执行的处理结果的状况会频繁地出现。

上述状况不仅可能发生在服务对象的处理过程尚未完成的时候，也可能发生在服务对象由于例如出现中断服务对象的正常执行的错误已经挂起的时候。上述状况也可能发生在当消息传递由于其所需的通信信道，例如网络，发生故障而不能进行的时候。

如果对象不能从等待状态退出，在用户看来系统就成为由于未知原因而终止的一种机顶箱。

因此，希望有一种具有基于未来消息传递功能的操作系统，该操作系统即使在生对象由于某种原因进入等待状态时仍能继续进行对象的处理，以使运行在该操作系统上的软件可以稳定运行。

在传统的操作系统中，随着等待状态的出现，不管等待状态出现的原因是什么，为了终止上述状态，通常将执行暂停处理。但是，在这种方法中，等待状态一直持续到暂停处理被启动，因此损耗时间取决于为启动暂停处理所设置的周期。另外，即使等待状态被暂停处理终止，仍无法说明出现等待状态的原因，该原因可能会进一步导致另一个等待状态的出现。

鉴于已有技术的上述背景情况，本发明的目的是提供一种数据处理方法，其中即使对象由于某种问题进入等待状态，同时正在执行基于未来的消息传递时，对象仍可以不需执行暂停处理而从等待状态中退出。

本发明的另一个目的是提供一种记录执行上述数据处理方法的操作系统的记录介质，以及一种具有这种记录介质的数据处理设备。

为了实现上述目的，本发明一方面是提供一种数据处理方法，在这种数据处理方法中，消息从客户对象发送到服务对象，服务对象响应该消息的请求执行处理过程并将处理结果返回到客户对象。在这种方法中，当消息从客户对象发送到服务对象时，用于存储表示服务对象所执行的处理结果的结果数据区，以及存储表示服务对象状态的状态数据区被保留下来。如果服务对象所执行的处理过程正确完成，则结果数据存储在数据区。如果服务对象所执行的处理过程没有正确完成，则状态数据存储在数据区。如果服务对象所执行的处理过程已经正确完成，通过读出存储在数据区内的数据，客户对象接收结果数据。如果服务对象所执行的处理过程没有正确完成，客户对象接收状态数据。

根据前面提到的数据处理方法，如果服务对象所执行的处理没有正确完成，表示服务对象状态的状态数据经上述数据区被传递到客户对象。这样，当消息传递正在执行时，即使客户对象由于某种问题进入等待状态，服务对象的状态可以不需要执行暂停处理而通知给客户对象，由此使客户对象可以从等待状态中退出。

本发明另一方面是提供一种记录操作系统的记录介质。所述操作系统包括消息发送装置，作为描述对象的应用程序接口，用于向另一个对象发送请求其执行处理过程并返回处理结果的消息。前面提到的操作系统根据所述消息发送装置将消息从客户对象发送到服务对象并保留一个数据区，该数据区一部分用来存储表示服务对象所执行的处理结果的结果数据，一部分用来存储表示服务对象状态的状态数据。如果服务对象所执行的处理过程已经正确完成，操作系统进一步在数据区中存储结果数据。如果服务对象所执行的处理过程没有正确完成，操作系统在数据区中存储状态数据。

如果服务对象所执行的处理过程没有正确完成，记录在记录介质上的操作系统在上述数据区中存储表示服务对象状态的状态数据。因此，通过读出存储在数据区中的数据，客户对象能够接收状态数据。这样，当消息传递正在执行时，即使客户对象由于某种原因进入等待状态，服务对象的状态也可以不需要执行暂停处理而通知给客户对象，从而使客户对象从等待状态中退出。

本发明再一方面是提供一种数据处理设备，该数据处理设备包括一种将操作系统记录在其上的记录介质。该操作系统包括消息发送装置，作为描述对象的应用程序接口，用于向另一个对象发送请求其执行处理过程并返回处理结果的消息。前面提到的操作系统根据该消息发送装置将消息从客户对象发送到服务对象并保留一个数据区，该数据区一部分用来存储表示服务对象所执行的处理结果的结果数据，一部分用来存储表示服务对象状态的状态数据。如果服务对象所执行的处理过程已经正确完成，操作系统在数据区中存储结果数据。如果服务对象所执行的处理过程没有正确完成，操作系统在数据区中存储状态数据。

如果服务对象所执行的处理过程没有正确完成，记录在记录介质上的具备数据处理设备的操作系统在上述数据区存储服务对象的状态数据。因此，通过读出存储在数据区内的数据，客户对象能够接收状态数据。这样，当消息传递正在执行时，即使客户对象由于某种原因进入等待状态，服务对象的状态可以不需要执行暂停处理而通知给客户对象，由此使客户对象从等待状态中退出。

在本说明书中，用于管理应用程序执行的软件从广义上称为“操作系统”。也就是说，本说明书所描述的操作系统不仅包括用于管理硬件的基本软件，而且包括在基本软件上运行用于管理硬件及应用程序执行的、被称为“中件”的软件。此外，本说明书所描述的操作系统包括实现虚拟计算机系统的软件，在虚拟计算机系统中，通过单个计算机实现多程序执行环境，在用户看来好象是多个计算机在运行。

图1是通过利用未来执行的消息传递的基本操作；

图2是结合了本发明的一例电视机的结构示意图；

图3是安装在图2所示的电视机中的操作系统；

图4是当处理过程在传统条件下进行时，利用方法“SendWithRBox”执行消息传递方案的例子；

图5是当异常发生时利用方法“SendWithRBox”执行消息传递方案的例子；

图6是服务对象所执行的消息传递方案的例子，其中，处理请求由不同的服务对象接收并返回处理结果；

图7是利用方法“SendWithContinuation”执行消息传递方案的例子；及

图8是在不同元空间之间执行消息传递方案的例子。

下面参照附图详细描述本发明的实施例。

1．硬件环境

首先参照图2对一种结合本发明的数据处理设备的例子进行描述。作为本发明的实施例，描述了一种装有结合本发明的数据处理功能的电视机。但本发明对其他类型的数据处理设备也是适用的。也就是说，本发明可以广泛地应用于在其上运行操作系统的数据处理设备，例如，除电视机以外的视听设备(即通常所说的“AV设备”)，办公设备以及普通计算机。

图2所示为结合本发明的数据处理设备的电视机，电视机通过天线或电缆线(均未标出)接收广播站发出的信号，根据信号在图像显示部件(例如阴极射线管或液晶板)上显示图像，并通过扬声器输出声音。

电视机不仅具备普通电视机的功能，而且能够接收来自外部的程序和数据。如图2所示，电视机包括：通过总线/输入输出(IO)桥1与总线2相连的电视功能部件3，通过总线/存储器桥4与总线2相连的处理器5，通过总线存储器桥4与处理器5相连的只读存储器(ROM)6和随机存取存储器(RAM)7，操作面板8，外部存储设备9，通信部件10以及图形设备11，操作面板8、外部存储设备9、通信部件10以及图形设备11均与总线2相连。

电视功能部件3具有将通过天线或电缆(均未标出)接收到的信号还原成图像和声音的功能。电视功能部件3通过总线/IO桥1与总线2相连，以便能够向其他部件传送或从其他部件接收信号。

作为控制电视机个体部件的计算部件的处理器5，通过总线/存储器桥4与总线2相连。ROM6和RAM7通过总线存储器桥4与处理器5相连。

ROM6中存储了由处理器5执行的用于控制的操作系统和应用程序。存储在ROM6中的操作系统是一种实现面向对象定位的面向对象的操作系统。

RAM7作为处理器5的工作区。更明确地说，处理器5通过利用RAM7作为工作区来运行存储在ROM6中的操作系统和应用程序，从而控制电视机中的个体部件。

操作面板8是用于接收由用户输入的操作的输入部件，表示诸如电视机的频道开关或音量控制的指示信号从该操作面板8输入。更明确地说，操作面板8是由具有大量用于输入不同信号的按钮及指示设备(即鼠标)所组成的。通过操作面板8输入的信号经总线2和总线存储器桥4输入到处理器5。然后处理器5根据从操作面板8中输入的信号执行预定的计算处理，从而来控制个体部件。

外部存储设备9例如由硬盘驱动部件且成，用来记录如图像和声音的数据、控制电视机所需的控制数据以及通过通信部件10从外部下载的应用程序等。

通信部件10，是用于执行与外部信号源进行数据通信的输入/输出部件，由调制解调器、终端适配器等组成。

图形设备11对记录在外部存储设备9上的数据以及通过通信部件10接收的来自外部信号源的数据进行处理，并显示相应的图像。

电视机不仅包括电视功能部件3所提供的普通电视功能，而且接收通过通信部件10来自外部信号源的数据。更准确地说，电视机例如能通过通信部件10从外部网络接收新的软件模块，从而对操作系统及应用程序的版本进行升级。

在电视机中，处理器5运行存储在ROM6中的操作系统也在操作系统上执行存储在ROM6和外部存储设备9中的应用程序，从而对电视机的个体部件进行控制。也就是说，电视机具有作为记录操作系统的计算机可读的记录介质的ROM6。

特别是当希望操作系统被改写时，操作系统可以存储在RAM7或外部存储设备9上。

2．软件环境

现在描述上述电视机的软件环境

2-1操作系统的示意结构

前面提到的电视机中使用的操作系统是面向对象的操作系统。换言之，运行在该操作系统上的软件，例如应用程序，以对象的形式形成模块，对象间的相互作用以消息传递的方式进行。

这种操作系统具有微内核，如图3所示，微内核提供操作系统的基本功能，从而可在微内核上同时提供多程序执行环境成为可能。在下面的描述中，操作系统提供的程序执行环境称为“元空间”。

更准确地说，作为元空间，操作系统提供了由多个对象构成的mCOOP元空间，以及由多个对象构成的mDrive元空间。将用于描述应用程序对象的应用程序接口(下文称为“API”)分配给每个元空间。在下面的描述中，在元空间中使用的对象称为“元对象”。

mCOOP元空间是主要用于运行面向对象的应用程序的元空间(例如，用于执行控制操作面板8的图形用户接口的应用程序)。在mCOOP元空间中，“m”代表元空间，“COOP”代表并行面向对象的程序设计。

mDrive元空间是一种运行主要用于控制硬件的设备驱动程序的元空间(例如，用于控制图形设备11的设备驱动程序或用于控制通信部件10通过网络传送和接收数据的设备驱动程序)。在mDrive元空间中，“m”代表元空间，“Drive”代表运行设备驱动程序(Device Driver)的元空间。

也就是说，在这个操作系统中，mCOOP元空间和mDrive元空间靠微内核工作。形成对象模块的应用程序在mCOOP元空间中运行，形成对象模块的设备驱动程序在mDrive元空间中运行。

作为靠微内核工作的元空间，这个操作系统不仅能够提供mCOOP元空间和mDrive元空间，也能提供例如用于运行面向过程的应用程序(例如使电视功能部件3显示动画的应用程序)的元空间。

组成mCOOP元空间的元对象包括例如对象“mCOOPMailer”和对象“mCOOPFaultHandler”。对象“mCOOPMailer”是用于在mCOOP元空间中运行的应用程序之间执行消息传递的元对象。对象“mCOOPFaultHandler”是一种用于执行异常处理的元对象。事实上，mCOOP元空间不仅由上述元对象组成，也由其他元对象所组成。

组成mDrive元空间的元对象例如包括对象“mDriveMailer”和对象“mDriveFaultHandler”。对象“mDriverMailer”是用于在mDrive元空间中运行的设备驱动程序间执行消息传递的元对象。对象“mDriveFaultHandler”是用于执行异常处理的元对象。实际上，mDrive元空间同mCOOP元空间一样，不仅由上述元对象组成，也由其他元对象组成。

下面详细讨论这种操作系统提供基于未来的消息传递功能。在以下的描述中，在基于未来的消息传递中，发送消息给另一个对象请求其执行处理过程的对象称为“客户对象”。相反地，从客户对象接收消息并根据该消息执行处理的对象称为“服务对象”。

2-2mCOOP元空间API

为了在mCOOP元空间中执行基于未来的消息传递，前面提到的操作系统提供了下面的方法，即将API用于描述在mCOOP元空间中操作的对象。在本说明书中，API是通过对象管理群接口定义语言(OMGIDL)的描述方法来表示的。

sError SendWithRBox(in OID destObjID,in Selectormeth,inanymsg,in size_tsizeOfMsg,outRIDrBoxID)

sErrorReceive(inRIDrBoxID,in anymsg,insize_tsizeOfMsg)

sErrorReply(in anyresultMsg,in size_t sizeOfResultMsg)

sErrorDelegate(in OID destObjID,in Selector meth,in any msg,in size_t sizeOfMsg)

下面详细讨论上述方法。

2-2-1 SendWithRBox()

sError SendWithRBox(in OID destObjID,in Selectormeth,in any msg,in size_tsizeOtMsg,outRIDrBoxID)

方法“SendWithRBox”是将消息从客户对象发送到服务对象的消息发送方法。即客户对象在向服务对象发送消息后，当客户对象需要获得服务对象所执行的处理结果时，就使用方法“SendWithRBox”。

变量“destobjID”是“OID”型变量，“OID”型是用来指定对象的数据类型。指定服务对象的值在变量“destObjID”中设定。

变量“meth”是“Selector”型变量，“Selector”型是用来定方法的数据类型。指定用于描述请求处理的服务对象的方法的值在变量“meth”中设定。

变量“msg”是“any”型变量，“any”型是随机性数据类型。指向存储传递给服务对象消息的区域的指针在变量“msg”中设定。

变量“sizeOfMsg”是“size_t”型变量，“size_t”型是用于确定数据大小的数据类型。表示将要被传递到服务对象中的消息大小的值在变量“sizeOfMsg”中设定。

当方法“SendWithRBox”被发布时，用于存储服务对象所执行的处理结果的数据区“RBox”被对象“mCOOPMailer”保留出来，这将在后面论述。数据区“RBox”是存储客户对象将要接收的结果的区域，称为“未来”。

消息发送给服务对象后，方法“SendWithRBox”获得“RID”型标识符“rBoxID”,“RID”类型是用于指定数据区“RBox”的数据类型。标识符“rBoxID”是当方法“SendWithRBox”已经发布时，用于指定被对象“mCOOPMailer”保留的数据区“RBox”的标识符。

方法“SendWithRBox”获得“sError”类型的值作为返回值，“sError”型是表示错误代码的数据类型。也就是说如果在发布这种方法过程中“SendWithRBox”的处理过程没有正确完成，那么表示错误原因的错误代码作为返回值被返回。如果处理正确完成，表示处理已经正确完成的值作为返回值被返回。

2-2-2 ReceiveO

sError Receive(in RID rBoxID,in any msg,in size_t sizeOfMsg)

方法“Receive”是用来读出存储在数据区”RBox”中数据的数据读出方法。也就是说，在方法“SendWithRBox”发布后，当客户对象接收服服务对象所执行的处理结果时，使用方法“Receive”。

变量“rBoxID”是“RID”类型的自变量，“RID”型是用来指定数据区“RBox”的数据类型。用于指定存储服务对象所执行的处理结果的数据区“RBox”的标识符在变量“rBoxID”中设定。也就是说，一旦发布方法“SendWithRBox”，就在变量“rBoxID”中设定所得到的标识符“rBoxID”的值。

变量“msg”是“any”型变量，“any”型是随机性数据类型。指向存储接收消息的区域的指针在变量“msg”中设定。

变量“sizeOfMsg”是“size_t”型变量，“size_t”型是指定数据大小的数据类型。表示存储接收到的消息区域大小的值在变量“sizeOtMsg”中设定。

方法“Receive”获取“sError”型的值作为返回值，“sError”型是表示错误代码的数据类型。也就是说，如果在发布这种方法过程中“Receive”的处理过程没有正确完成，那么表示错误原因的错误代码将作为返回值被返回。如果处理正确完成，那么表示处理已经正确完成的值将作为返回值被返回。

2-2-3 Reply()

sError Reply(in any resultMsg,in size_t sizeOfResultMsg)

在客户对象已经发布方法“SendWithRBox”后，当服务对象将处理结果返回给客户对象时，使用方法“Reply”。

变量“resultMsg”是“any”型变量，“any”型是随机性数据类型。指向存储将要被发送到客户对象的消息的区域的指针在变量“resultMsg”中设定。

变量“sizeOfResultMsg”是“size_t”型变量，“size_t”型是指定数据大小的数据类型。表示将要被发送到客户对象的消息大小的值在变量“sizeOfResultMsg”中设定。

方法“Reply”获得“sError”型的值作为返回值，“sError”型是表示错误代码的数据类型。也就是说，如果在发布这种方法过程中“Reply”处理过程没有正确完成，那么表示错误原因的错误代码将作为返回值被返回。如果处理正确完成，那么表示处理已经正确完成的值将作为返回值被返回。

2-2-4 Delegate()

sError Delegate(in OID destObjID,in Seletor meth,in any msg,in size_tsizeOfMsg)

方法“Delegate”是在对象中委托授权的授权委托方法。更准确地说，在多个服务对象中，委托授权将服务对象所执行的处理结果返回到客户对象时，使用方法“Delegate”。

在以下描述中，上面提到的授权称为“回答授权”。在服务对象中，委托回答授权的对象称为“授权委托对象”，而被委托接收回答授权的对象称为“被委托授权对象”。

变量“destObjID”是“OID”型变量，“OID”型是用于指定对象的数据类型。表示被委托授权对象的值在变量“destObjID”中设定。

变量“meth”是“Selector”型变量，“Selector”型是用于指定方法的数据类型。表示用来描述被请求的处理过程的被委托授权对象的方法的值在变量“meth”中设定。

变量“msg”是“any”型变量，“any”型是随机性数据类型。指向存储将要被发送到被委托授权对象的消息的区域的指针在变量“msg”中设定。

变量“sizeOfMsg”是“size_t”型变量，“size_t”型是指定数据大小的数据类型。表示将要被发送到被委托授权对象的消息的大小的值在变量“sizeOfMsg”中设定。

方法“Delegate”获得“sError”型的值作为返回值，“sError”型是表示错误代码的数据类型。也就是说，如果在发布这种方法过程中“Delegate"的处理过程没有正确完成，那么表示错误原因的错误代码将作为返回值被返回。如果处理正确完成，那么表示处理已经正确完成的值将作为返回值被返回。

2-3 mDrive元空间API

为了在mDrive元空间中执行基于未来的消息传递，前面提到的操作系统提供下面的方法，即用API描述mDrive元空间中运行的对象。

API按照OMGIDL的方法表示。

sError SendWithContinuation(in OID destObjID,in Selector meth,in any msg,insize_t sizeOfMsg,in Selector contMeth)

sError Kick(incontID contID,in any msg,in size_t sizeOfMsg)

下面详细描述上述方法。

2-3-1 SendWithConinuation()

sError SendWithContinuation(in OID destObjID,in Selector meth,in any msg,insize_t sizeOtMsg,in SelectorcontMeth)

方法“SendWithContinuation”是将消息从客户对象发送到服务对象的消息发送方法。在客户对象将消息发送给服务对象后，一旦客户对象在接收服务对象的处理结果需要执行指定的方法(在下文中称为“连续方法”)时，使用方法“SendWithContinuation”。

变量“destObjID”是“OID”型变量，“OID”型是用来指定对象的数据类型。用于确定服务对象的值在变量“destObjID”中设定。

变量“meth”是“Selector”型变量，“Selector”型是用来指定方法的数据类型。表示用于描述被请求的处理过程的服务对象的方法的值在变量“meth”中设定。

变量“msg”是“any”型变量，“any”型是随机性数据类型。指向存储将被传递给服务对象的消息的区域的指针在变量“msg”中设定。

变量“sizeOfMsg”是“size_t”型变量，“size_t”型是指定数据大小的数据类型。表示将要被传递到服务对象的消息的大小的值在变量“sizeOfMsg”中设定。

变量“contMeth”是“Selector”型变量，“Selector”型是用于指定方法的数据类型。用于指定连续方法的值在变量“contMeth”中设定。

一旦发布方法“SendWithContinuation”，数据区“Continuation”就被对象“mDriveMailer”保留出来，这将在后面进行论述，与连续方法有关的信息存储在数据区“Continuation”中。数据区“Continuation”是用来存储将要由客户对象来执行的连续方法的区域，称为“未来”。

方法“SendWithContinuation”获取“sError”型的值作为返回值，“sError”型是表示错误代码的数据类型。也就是说，如果在发布这种方法过程中“SendWithContinuation”的处理过程没有正确完成，那么表示错误原因的错误代码将作为返回值被返回。如果处理正确完成，那么表示处理已经正确完成的值将作为返回值被返回。

2-3-2Kick()

sError Kick(in ContID contID,in any msg,in size_t sizeOfMsg)

在客户对象发布方法“SendWithContinuation”后，当服务对象指示客户对象执行连续方法时，使用方法“Kick”。

变量“contID”是“contID”型变量，“contID”型是用来指定数据区“Continuation”的数据类型。一旦发布方法“SendWithContinuation”，指定对象“mDriveMailer”所保留的数据区“Continuation”的标识符在变量“contID”中设定。

变量“msg”是“any”型变量，“any”型是随机性数据类型。指向存储将要传递给客户对象的消息的区域的指针在变量“msg”中设定。

变量“sizeOfMsg”是“size_t”型变量，“size_t”型是指定数据大小的数据类型。表示将要被传递到客户对象的消息大小的值在变量“sizeOfMsg”中设定。

方法“Kick”获得“sError”型的值作为返回值，“sError”型是表示错误代码的数据类型。也就是说，如果在发布这种方法过程中“Kick’的处理过程没有正确完成，那么表示错误原因的错误代码将作为返回值被返回。如果处理正确完成，那么表示处理已经正确完成的值将作为返回值返回。

2-4用于消息传递的数据区

在mCOOP元空间中执行消息传递时，前面提到的操作系统将数据区“RBox”作为未来，并且也利用数据区“DeliveryBoxA”将信息从客户对象传递到服务对象。

另外，在mDrive元空间中执行消息传递时，前面提到的操作系统将数据区“Continuation”作为未来，并且也利用数据区“DeliveryBoxB”将信息从客户对象传递到服务对象。

为了存储用于管理对象执行状态的信息，上述操作系统为每个对象保留出数据区“Thread”。操作系统也存储与未来有关的信息在数据区“Thread”中。在mCOOP元空间和mDrive元空间中对象以单线程形式操作，一个线程对应一个对象。与线程有关的信息作为管理对象执行状态的信息存储在数据区“Thread”中。

数据区“RBox”,“DeliveryBoxA”,“Continuation”,“DeliveryBoxB”以及“Thread”均是被操作系统用于提供消息传递功能或管理对象的数据区。这些数据区由操作系统进行管理，以免被应用程序或设备驱动程序直接访问。下面将详细论述上述数据区。

2-4-1RBox

一旦发布方法“SendWithRBox”，数据区“RBox”就被对象“mCOOPMailer”保留出来。更准确地说，通过建立具有表1所示属性的类(下文称为“类‘RBox’”)的示例，完成对象“mCOOPMailer”对数据区“RBox”的保留。在表1中，类“RBox”的属性中，仅列出用于执行mCOOP元空间中消息传递的基本形式所需的最少属性。也可以包括除表1中所示属性以外的其他属性。

表1

Rbox
	ThreadID    creatorbool        readyvoid*      resultMsgt_size      sizeOfResultMsgsError      status

表1显示出类“RBox”具有“ThreadID”型的属性“Creator”,“ThreadID”型是用于指定为每个对象设置的数据区“Thread”的数据类型。

类“RBox”也具有“bool”型的属性“Ready”,“bool”型是逻辑值数据类型；具有“void^*”型的属性“resultMsg”,“void^*”型是表示指针的数据类型；以及具有“size_t”型的属性“sizeOfResultMsg”,“size_t”型是用于指定数据大小的数据量。用于存储服务对象所执行的处理的结果数据的区域均具有这些属性。

作为存储表示服务对象状态的数据区，类“RBox”还具有“sError”型的属性“status”,“sError”型是指定错误代码的数据类型。

用于指定与建立数据区“RBox”的对象(即发布方法“SendWithRBox”的客户对象)相关的数据区“Thread”的标识符在属性“Creator”中设定。在mCOOP元空间中，如上所述，对象以单线程操作，而且一个数据区“Thread”被指派给一个对象。因此，如果数据区“Thread”由属性“Creator”指定，那么相应的客户对象就确定下来了。

表示服务对象的处理结果是否已被返回的值在属性“Ready”中设定。换句话说，属性“ready”是表示将要从服务对象返回到客户对象的结果消息是否已准备就绪的标志。

指向存储将作为服务对象的处理结果被传递到客户对象的消息的区域的指针在属性“resultMsg”中设定。

表示作为服务对象的处理结果将被传递到客户对象的消息的大小的值在属性“sizeOfResultMsg”中设定。

表示作为将要报告给客户对象的信息的服务对象状态的代码在属性“status”中设定。更准确地说，如果服务对象的处理过程由于出现中断其正常执行的异常情况而没有正确完成，那么指示在执行正常处理过程中错误的消息从对象“mCOOPFaultHandler”报告给对象“mCOOPMailer”，这将在后面进行论述。这样，指示服务对象状态的错误代码通过对象“mCOOPMailer”在属性“status”中设定。如果服务对象正确执行了处理过程，表示服务对象处于正常状态的值在属性“status”中设定。

当客户对象发布方法“Receive”时，客户对象参照属性“ready”以便确定服务对象所执行的处理结果是否已经返回。如果服务对象的处理结果已经返回，客户对象参照属性“resultMsg”以便指定存储将传送给客户对象的消息的区域作为服务对象的处理结果，从而上述区域读出具有属性“sizeOfResultMsg”表示的大小的数据。结果，读出将要传递到客户对象的消息并传递到客户对象。

2-4-2DeliveryBoxA

一旦发布方法“SendWithRBox”，数据区“DeliveryBoxA”就被对象“mCOOPMailer”保留出来以从客户对象向服务对象传递信息。更准确地说，通过建立具有表2所示属性的类(下文称为“类‘DeliveryBoxA’”)的例示，对象“mCOOPMailer”完成对数据区“DeliveryBoxA”的保留。在类“DeliveryBoxA”的属性中，表2仅列出用于在mCOOP元空间中执行消息传递的基本形式所需的最少属性。也可以包括除表2中所示属性以外的其他属性。

表2

DeliveryBoxA
	RID      rBoxIDVoid*   msgt_size   sizeOfMsg

表2显示出类“DeliveryBoxA”具有“RID”型的属性“rBoxID”,“RID”型是用于指定数据区“RBox”的数据类型；具有“Void^*”型的属性“msg”,“Void^*”型是表示指针的数据类型；以及具有“size_t”型的属性“sizeOfMsg”,“size_t”型是用于指定数据大小的数据量。

在“rBoxID”属性中设定指定数据区“RBox”的标识符，用于执行利用数据区“DeliveryBoxA”进行的消息传递。

指向存储将从客户对象传递到服务对象的消息的区域的指针在属性“msg”中设定。

表示将从客户对象传递到服务对象的消息的大小的值在属性“sizeOfMsg”中设定。

通过使用以建立类“DeliveryBoxA”的例示而保留出来的数据区“DeliveryBoxA”，操作系统将与数据区“RBox ”有关的信息连同从客户对象发送到服务对象的消息一道进行发送。换句话说，利用数据区“DeliveryBoxA”，操作系在mCOOP元空间中能同时处理消息和未来。

2-4-3 Continuation

一旦发布方法“SendWithContinuation”，数据区“Continuation”被对象“mDriverMailer”保留出来以便在其中存储与连续方法有关的信息。更准确地说，通过建立具有表3所示属性的类(下文称为“类Continuation’”)的例示，执行对象“mDriverMailer”对数据区“Continuation”的保留。在类“Continuation”的属性中，表3仅列出用于实现在mDrive元空间中进行消息传递的基本形式所需的最少属性。也可以包括表3所示属性以外的其他属性。

表3

Continuation
	ThreadID    creatorSelector    meth

表3显示出类“Continuation”具有“ThreadID”型的属性“creator”，“ThreadID”型是用于指定为每个对象所设定的数据区“Thread”的数据类型以及具有“Selector”型的属性“meth”,“Selector”型是用来指定方法的数据类型。

在属性“creator”中设定指定数据区“Thread”的标识符，数据区“Thread”与已建立数据区“Continuation”的对象(即发布方法“SendWithContinuation”的客户对象)相关。在mDrive元空间中，如上所述，对象以单线程运行，而且一个数据区“Thread”对应一个对象。因此，当数据区“Thread”由属性“creator”指定时，相应的客户对象就确定下来了。

表示客户对象的连续方法的值在属性“meth”中设定。

当服务对象发送方法“kick”时，客户对象参照属性“meth”以便指定客户对象的连续方法，从而启动指定的连续方法。

2-4-4 DeliveryBoxB

一旦发布了方法“SendWithContinuation”，为了将消息从客户对象传递到服务对象，对象“mDriveMailer”将数据区“DeliveryBoxB”保留出来。更准确地说，通过建立具有表4所示属性的类(下文称为“类’DeliveryBoxB”)的例示，完成对象“mDriveMailer”对数据区“DeliveryBoxB”的保留。在类“DeliveryBoxB”的属性中，表4仅列出用于执行在mDrive元空间中进行消息传递的基本形式所需的最少属性。也可以包括表4所示属性以外的其他属性。表4

DeliveryBoxB
	ContID    ContIDVoid*    msgt_size    sizeOfMsg

表4显示出类“DeliveryBoxB”具有“ContID”型的属性“ContID”,“ContID”型是用于指定数据区“Continuation”的数据类型；具有“Void^*”型的属性“msg”,“Void^*”型是表示指针的数据类型；以及具有“size_t”型的属性“sizeOfMsg”,“size_t”型是用来指定数据大小的数据类型。

在属性“ContID”中设定用于指定数据区“Continuation”的标识符，数据区“Continuation”利用数据区“DeliveryBoxB”进行消息传递。

指向存储将从客户对象传递到服务对象的消息的区域的指针在属性“msg”中设定。

表示将要从客户对象传递到服务对象的消息的大小的值在属性“sizeOfMsg”中设定。

通过利用由建立类“DeliveryBoxB”的例示而保留出来的数据区“DeliveryBoxB”，操作系统将与数据区“Continuation”有关的信息连同从客户对象发送到服务对象的消息一道进行发送。换句话说，利用数据区“DeliveryBoxB”，操作系统能同时在mDrive元空间中处理消息和未来。

2-4-5 Thread

在mCOOP元空间和mDlive元空间中，如上所述，对象以单线程运行，并且一个线程对应一个对象。与每个线程有关的信息作为管理对象执行状态的信息存储在数据区“Thread”中。即操作系统为每个对象保留数据区“Thread”以便在其中存储管理对象执行状态的信息。

作为管理对象执行状态的信息，例如，表示对象是处于等待状态是处于执行状态的信息，存储于数据区“Thread”内。在执行基于未来的消息传递中，与未来有关的信息也存储在数据区“Thread”内。

更准确地说，现在假定对象是在mCOOP元空间中运行。在执行基于未来的消息传递中，对象“mCOOPMailer”将标识符“rBoxID”作为与未来有关的消息存储在与对象相应的数据区“Thread”内，标识符“rBoxID”指定用于消息传递的数据区“RBox”。

现在假定对象是在mDrive元空间中运行。在完成基于未来的消息传递过程中，对象“mDriveMailer”将标识符“contID”存储在与对象相应的数据区“Thread”内，该标识符“contID”指定用于消息传递的数据区“Continuation”。

2-5消息传递

下面将通过具体方案，例如利用前面提到的方法和数据区执行消息传递的具体方案进行详细说明。

图4-8所示为在消息传递过程中所执行的处理和消息交换的移动。在图4-8中，虚线箭头表示操作系统内处理和消息交换的移动，实线箭头表示从应用程序观点看处理和消息交换的移动。

2-5-1利用SendWithRBox()的消息传递

下面将描述处理过程处于正常状态以及出现异常情况时，利用方法“SendWithRBox”在mCOOP元空间中执行消息传递。

2-5-1-1在正常状态下执行处理过程时

参考图4，首先描述没有出现异常情况的正常状态下执行数据处理过程时，利用方法“SendWithRBox”在mCOOP元空间中执行消息传递。

图4所示为在对象A和对象B之间利用方法“SendWithRBox”在mCOOP元空间中执行消息传递的基本方案，对象A和对象B均作为mCOOP元空间中的应用程序运行。也就是说，在本例中，对象A是客户对象，对象B是服务对象。

当对象A发布方法“SendWithRBox”时，如ST1-1所示，处理过程被移动到对象“mCOOPMailer”，如虚线箭头ST1-2所示，根据方法“SendWithRBox”对象“mCOOPMailer”执行处理过程，如ST1-3所示。

对象“mCOOPMailer”首先保留出存储服务对象(本例中为对象B)所执行的处理结果的数据区“RBox”，并在数据区“RBox”的属性“creator”中设置指定与对象A相应的数据区“Thread”的标识符。

然后，对象“mCOOPMailer”保留出数据区“DeliveryBoxA”，并在其中存储指定数据区“RBox”的标识符“rBoxID”及方法“SendWithRBox”所发送的消息。

用于指定数据区“RBox”的标识符“rBoxID”存储在数据区“DeliveryBoxA”内，更准确地说，指定数据区“RBox”的标识符“rBoxID”的值在数据区“DeliveryBoxA”的属性“rBoxID”中设定。

方法“SendWithRBox”发送的消息存储在数据区“DeliveryBoxA”内，更准确地说，方法“SendWithRBox”的变量“msg”的值在数据区“DeliveryBoxA”的属性“msg”中设定，同时，方法“SendWithRBox”的变量“sizeOfMsg”的值也在数据区“DeliveryBoxA”的属性“sizeOfMsg”中设定。

此后，对象“mCOOPMailer”将存储在数据区“DeliveryBoxA”内的数据，即方法“SendWithRBox”发送的消息，以及指定被保留出的数据区“RBox”的标识符“rBoxID”传递到对象B，如虚线箭头ST1-4所示，从而启动对象B的方法。

在这种情况下，仅有消息被传递给对象B的方法，标识符“rBoxID”存储在与对象B相应的数据区“Thread”内。换句话说，传递给对象B的标识符“rBoxID”处于操作系统的管理下，从应用程序的观点看，发送给对象B的仅仅是消息。

在通过将存储在数据区“DeliveryBoxA”内的数据从对象“mCOOPMailer”传递到对象B启动对象B的方法过程中，对象B由方法“SendWithRBox”的变量“destObjID”指定，同时对象B的方法由方法“SendWithRBox”的变量“meth”指定。

一旦完成了前面提到的处理，如虚线箭头ST1-5所示，对象“mCOOPMailer”就将指定被保留的数据区“RBox”的标识符“rBoxID”返回到对象A，同时也将表示处理过程已经正确完成的值作为返回到方法“SendWithRBox”的值返回到对象A。然后，对象“rmCOOPMailer”促使对象A重新启动处理过程。对象A现在准备执行处理过程，如果存在任何剩余处理过程，则对象A重新启动该处理过程。

按照上述处理，消息从对象A传递到对象B，如实线箭头ST1-6所示，从应用程序的观点看，仿佛对象A和对象B在同时运行。

接着，当对象A发布方法“Receive”时，如ST1-7所示，处理过程被移动到对象“mCOOPMailer”，如虚线箭头ST1-8所示，对象“mCOOPMailer”执行响应方法“Receive”的处理过程，如ST1-9所示。更准确地说，对象“mCOOPMailer”访问由方法“Receive”的变量“rBoxID”所指定的数据区“RBox”。如果对象B所执行的处理结果存储在数据区“RBox”内，那么对象“mCOOPMailer”将结果传递给对象A。如果对象B执行的处理结果没有存储在数据区“RBox”内，那么对象“mCOOPMailer”将对象A的状态从执行状态变为等待状态。

在本例中，当对象A发布方法“Receive”时，对象B尚未发布方法“Reply”，这样，对象B所执行的处理结果还没有存储在数据区“RBox”内。因此，如虚线箭头ST1-10所示，对象“mCOOPMailer”将对象B的处理结果尚未存储在数据区“RBox”内的情况通知对象A，并将对象A的状态从执行状态变为等待状态。

所以，当对象B发布方法“Reply”时，如ST1-11所示，处理过程被移动到对象“mCOOPMailer”，如虚线箭头ST1-12所示，同时对象“mCOOPMailer”根据方法“Reply”执行处理过程，如ST1-13所示。更准确地说，如果对象A已经发布了方法“Receive”，对象“mCOOPMailer”将对象B执行的处理结果传递到对象A。如果对象A尚未发布方法“Receive”，则对象“mCOOPMailer”将对象B的处理结果存储在数据区“RBox”中。

在本例中，当对象B发布方法“Reply”时，对象A已经发布了方法“Receive”。因此，对象“mCOOPMailer”将对象B的处理结果直接传递给对象A，如虚线箭头ST1-14所示，而不用将处理结果存储在数据区“RBox”中。一旦在正常状态下完成了将对象B的处理结果传递给对象A的处理过程，对象“mCOOPMailer”就将表示处理已经正确完成的值作为返回到方法“Reply”的值返回到对象B，如虚线箭头ST1-15所示。然后，对象“mCOOPMailer”促使对象B重新启动处理。对象B现在准备执行处理过程，如果存在任何剩余处理，对象B重新启动处理过程。

根据前面所提到的处理过程，对象B所执行的处理结果将传递到对象A中，如实线箭头ST1-16所示，从应用程序的观点看，仿佛对象A和对象B是在同时运行。

在图4所示的例子中，方法“Receive”在方法“Reply”发布前就已经发布。也可以选择将方法“Receive”在方法“Reply”发布后再发布。在这种情况下，对象A能够在不进入等待状态的情况下立即接收对象B所执行的处理结果。

如果对象A在对象B发布方法“Reply”后发布方法“Receive”，那么对象“mCOOPMailer”执行下面的处理过程。一旦对象B发布方法“Reply”，对象“mCOOPMailer”就将对象B所执行的处理结果存储在数据区“RBox”中。然后，当对象A发布方法“Receive”时，对象“mCOOPMailer”立即从数据区“RBox”中读出对象B的处理结果并将其传递给对象A。

对象B所执行的处理结果存储在数据区“RBox”内。更准确地说，表示对象B的处理结果已经返回的值在数据区“RBox”的属性“ready”中设定，指向存储作为对象B的处理结果将传递给对象A的消息的区域的指针，即方法“Reply”的变量“resultMsg”所表示的指针在数据区“RBox”的属性“resultMsg”中设定，同时，表示作为对象B的处理结果将传递给对象A的消息的大小的值，即方法“Reply”的变量“sizeOfResultMsg”所表示的值，在数据区“RBox”的属性“sizeOfResultMsg”中设定。

在从数据区“RBox”中读出对象B的处理结果并将其传递到对象A的过程中，对象“mCOOPMailer”首先从数据区“RBox”读出数据区“RBox”的属性“resultMsg”和属性“sizeOfResultMsg”，数据区“RBox”由方法“Receive”的变量“rBoxID”指定，然后再从属性“resultMsg”所表示的数据区中读出具有用属性“sizeOfResultMsg”表示的大小的数据。读出数据将作为从对象B传递到对象A的消息。然后，对象“mCOOPMailer”将读出数据存储在由方法“Receive”的变量“msg”所表示的区域中。方法“Receive”的变量“sizeOfMsg”设定由方法“Receive”的变量“msg”所表示区域的大小。

根据上述处理过程，当方法“Receive”在方法“Reply”发布后发布时，以及当方法“Receive”在方法“Reply”被发布前发布时，对象B所执行的处理结果传递给对象A，仿佛对象A和对象B是在同时运行。

2-5-1-2当出现异常时

下面参考图5，首先描述当出现中断服务对象正常处理过程的异常情况下，利用方法“SendWithRBox”在mCOOP元空间中执行消息传递。

图5所示为在对象A和对象B之间利用方法“SendWithRBox”在mCOOP元空间中执行消息传递的基本方案，对象A和对象B均作为mCOOP元空间中的应用程序运行。也就是说，在本例中，对象A是客户对象，对象B是服务对象。在本方案中，假设方法“Receive”被对象A发布后对象B出现异常且不能工作。

在本方案中，图5中所示的步骤ST2-1,ST2-2,ST2-3,ST2-4,ST2-5,ST2-6,ST2-7,ST2-8,ST2-9以及ST2-10分别与图4中所示的步骤ST1-1,ST1-2,ST1-3,ST1-4,ST1-5,ST1-6,ST1-7,ST1-8,ST1-9以及ST1-10相类似，因此省略其说明。

在本方案中，处理进行到步骤ST2-10后，当对象A处于等待状态且对象B处于执行处理状态时，出现中断对象B正常处理过程的异常情况。

当中断对象B正常处理过程的异常情况出现时，如ST2-11所示，处理过程被移动到对象“mCOOPFaultHandler”，如虚线箭头ST2-12所示，对象“mCOOPFaultHandler”执行预定的异常情况处理，如ST2-13所示。接着，对象“mCOOPFaultHandler”向对象“mCOOPMailer”报告对象B由于出现异常而不能工作，如虚线箭头ST2-14所示。

此时，对象A在发布方法“Receive”后处于等待状态。接着，对象“mCOOPMailer”将表示对象B由于出现异常而不能工作的错误代码作为返回到方法“Receive”的值返回给对象A，如虚线箭头ST2-15所示。同时促使对象A重新启动处理过程。对象A现在准备执行处理过程，如果存在任何剩余处理过程，对象A重新启动处理过程。

根据前面提到的处理过程，尽管对象A不能从对象B接收期望获得的结果消息，但是对象A将表示对象B不能工作的错误代码作为返回值接收，并能恢复执行处理过程。然后，对象A响应出现的错误执行处理过程。

例如，表示对象B出现异常的消息可以通过图像显示设备显示出来，并通知用户将该处理过程复位。也可以选择将可替换对象B的对象通过网络从外部信号源下载下来，消息传递可以再次执行。

在图5所示的方案中，方法“Receive”被对象A发布后，对象B出现异常。但对象B出现异常也可以发生在方法“Receive”被对象A发布前。

如果在对象A发布方法“Receive”前对象B已经出现异常，则对象“mCOOPMailer”在数据区“RBox”的属性“status”中设定表示对象B由于出现异常而不能工作的错误代码。

然后，当对象A发布方法“Receive”时，对象“mCOOPMailer”读出在数据区“RBox”的属性“status”中设定的错误代码，并将该错误代码作为返回到方法“Receive”的值返回给对象A。然后对象“mCOOPMailer”促使对象A恢复处理过程。以与前述方案类似的方式，对象A现在准备执行处理过程，如果存在任何剩余处理，则对象A重新启动处理过程。

如上所述，表示对象B因出现异常而不能工作的错误代码在数据区“RBox”的属性“status”中设定。这将防止对象A一旦发布方法“Receive”就进入耗时的等待状态，而且对象A会立即识别出对象B因出现异常不能工作。

在前述方案中，是对象B发生异常。在其他情况下，如果结果消息因某种原因不能返回到对象A，错误代码在数据区“RBox”的属性“status”中设定。通过这种设置，即使结果消息因某种原因不能返回到对象A，错误代码仍可以返回到对象A，以使对象A能从等待状态恢复到操作状态，否则将导致对象A进入等待状态并中止系统。

2-5-2利用Delegate()进行消息传递

下面参考图6，描述当处理请求被接收且通过不同的服务对象返回处理结果时，利用方法“Delegate”所执行的消息传递。

图6所示为在对象A，对象B及对象C之间在mCOOP元空间中执行的消息传递的方案，对象A，对象B及对象C均作为mCOOP元空间中的应用程序运行。在本方案中，回答授权被从对象B委托给对象C。

也就是说，在本例中，对象A是客户对象，而对象B和对象C是服务对象。对象B委托对象C将处理结果返回到对象A。也就是说，对象B既作为服务对象又作为授权委托对象。对象C既作为服务对象又作为被委托授权对象。

当对象A发布方法“SendWithRBox”时，如ST3-1所示，处理过程被移动到对象“mCOOPMailer”，如虚线箭头ST3-2所示，对象“mCOOPMailer”根据方法“SendWithRBox”执行处理过程，如ST3-3所示。

对象“mCOOPMailer”首先保留出数据区“RBox”以存储服务对象所执行的处理结果，然后在数据区“RBox”的属性“creator”中设定用于指定与对象A相应的数据区“Thread”的标识符。

然后，对象“mCOOPMailer”保留出数据区“DeliveryBoxA”，并在其中存储表示数据区“RBox”的标识符“rBoxID”及方法“SendWithRBox”发送的消息。

指定数据区“RBox”的标识符“rBoxID”存储在数据区“DeliveryBoxA”内。更准确地说，指定数据区“RBox”的标识符“rBoxID”的值在数据区“DeliveryBoxA”的属性“rBoxID”中设定。

方法“SendWithRBox”发送的消息存储在数据区“DeliveryBoxA”内。更准确地说，方法“SendWithRBox”的变量“msg”的值在数据区“DeliveryBoxA”的属性“msg”中设定，方法“SendWithRBox”的变量“sizeOfMsg”的值也在数据区“DeliveryBoxA”的属性“sizeOfMsg”中设定。

此后，对象“mCOOPMailer”将存储在数据区“DeliveryBoxA”内的数据，即方法“SendWithRBox”所发送的消息，以及表示被保留出的数据区“RBox”的标识符“rBoxID”传递到对象B，如虚线箭头ST3-4所示，从而启动对象B的方法。

在这种情况下，仅消息被发送到对象B的方法，标识符“rBoxID”存储在与对象B相应的数据区“Thread”内。换句话说，将传递给对象B的标识符“rBoxID”处于操作系统的管理下，从应用程序的观点看，已被发送给对象B的仅仅是消息。

在通过将存储在数据区“DeliveryBoxA”内的数据从对象“mCOOPMailer”传递到对象B启动对象B的方法中，对象B由方法“SendWithRBox”的变量“destObjID”指定，对象B的方法由方法“SendWithRBox”的变量“meth”指定。

一旦完成了前面提到的处理过程，如虚线箭头ST3-5所示，对象“mCOOPMailer”将指定被保留的数据区“RBox”的标识符“rBoxID”返回到对象A，同时也将表示处理过程已经正确完成的值作为返回到方法“SendWithRBox”的值返回到对象A。然后对象“mCOOPMailer”促使对象A重新启动处理过程。对象A现在准备执行处理过程，如果存在任何剩余处理过程，对象A重新启动处理过程。

按照上述理过程，消息从对象A传递到对象B，如实线箭头ST3-6所示，从应用程序的观点看，仿佛对象A和对象B在同时运行。

随后，一旦对象A发布方法“Receive”，如ST3-7所示，处理过程被移动到对象“mCOOPMailer”，如虚线箭头ST3-8所示，对象“mCOOPMailer”执行响应方法“Receive”的处理过程，如ST3-9开示。更准确地说，对象“mCOOPMailer”访问由方法“Receive”的变量“rBoxID”所指定的数据区“RBox”。如果服务对象所执行的处理结果存储在数据区“RBox”内，那么对象“mCOOPMailer”将结果传递给对象A。如果服务对象的处理结果没有存储在数据区“RBox”内，那么对象“mCOOPMailer”将对象A的状态从执行状态变为等待状态。

在本例中，当对象已经发布了方法“Receive”时，服务对象还没有发布方法“Reply”。因此，服务对象所执行的处理结果尚未存储在数据区“RBox”内。这样，如虚线箭头ST3-10所示，对象“mCOOPMailer”将服务对象的处理结果没有存储在数据区“RBox”内的情况通知对象A，并将对象A的状态从执行状态变为等待状态。

所以，当对象B发布方法“Reply”时，如ST3-11所示，处理过程被移动到对象“mCOOPMailer”，如虚线箭头ST3-12所示，对象“mCOOPMailer”根据方法“Reply”执行处理过程，如ST3-13所示。

更准确地说，对象“mCOOPMailer”首先保留数据区“DeliveryBoxA”。然后对象“mCOOPMailer”读出存储在与对象B相应的数据区“Thread”内的标识符“rBoxID”，并在数据区“DeliveryBoxA”的属性“rBoxID”中设定标识符“rBoxID”的值。

同时，存储在与对象B相应的数据区“Thread”内的标识符“rBoxID”被清除，由此使对象B不能回答授权。也就是说，对象B通过发布方法“Delegate”失去回答授权，并将回答授权委托给对象C。因为已经失去回答授权，所以对象B不能发布方法“Reply”。换句话说，对象B发布方法“Delegate”，而不是方法“Reply”。

对象“mCOOPMailer”也将方法“Delegate”发送的消息存储在数据区“DeliveryBoxA”内。更准确地说，方法“Delegate”的变量“msg”的值在数据区“DeliveryBoxA”的属性“msg”中设定，方法“Delegate”的变量“sizeOfMsg”的值也在数据区“DeliveryBoxA”的属性“sizeOfMsg”中设定。

然后，对象“mCOOPMailer”将存储在数据区“DeliveryBoxA”中的数据，即方法“Delegate”所发送的消息，以及指定数据区“RBox”的标识符“rBoxID”传递到对象C，如虚线ST3-14所示，从而启动对象C的方法。

在这种情况下，仅消息被发送给对象C的方法，标识符“rBoxID”存储在与对象B相应的数据区“Thread”内。换句话说，将传递给对象C的标识符“rBoxID”处于操作系统的管理下，从应用程序的观点看，已被发送给对象B的仅仅是消息。

在通过将存储在数据区“DeliveryBoxA”内的数据从对象“mCOOPMailer”传递到对象C来启动对象C的方法中，对象C由方法“Delegate”的变量“destObjID”指定，对象C的方法由方法“Delegate”的变量“meth”指定。

一旦完成了前面提到的处理过程，如虚线箭头ST3-15所示，对象“mCOOPMailer”将表示处理过程已经正确完成的值作为返回到方法“Delegate”的值返回到对象B，然后促使对象B重新启动处理过程。对象B现在准备执行处理过程，如果存在任何剩余处理，则对象B重新启动处理过程。

按照上述处理过程，回答授权从对象B委托给对象B，如实线箭头ST3-16所示，从应用程序的观点看，仿佛对象B和对象C在同时运行。

随后，当对象C发布方法“Reply”时，如ST3-17所示，处理过程被移动到对象“mCOOPMailer”，如虚线箭头ST3-18所示，对象“mCOOPMailer”执行响应方法“Reply”的处理过程，如ST3-19所示。更准确地说，如果对象A已经发布了方法“Receive”，那么对象“mCOOPMailer”立即将对象C的处理结果传递到对象A。如果对象A尚未发布方法“Receive”，那么对象“mCOOPMailer”将对象C的处理结果存储在数据区“RBox”中。

在本例中，当对象C发布方法“Reply”时，对象A已经发布了方法“Receive”。因此，如虚线箭头ST3-20所示，对象“mCOOPMailer”立即将对象C的处理结果传递给对象A，而不是存储在数据区“RBox”中。在正常状态下，一旦完成将对象C的处理结果传递给对象A的处理过程，对象“mCOOPMailer”将表示处理已经正确完成的值作为返回到方法“Reply”的值返回给对象C，如虚线箭头ST3-21所示。然后，对象“mCOOPMailer”促使对象C重新启动处理过程。对象C现在准备执行处理过程，如果存在任何剩余处理，则对象C重新启动处理过程。

根据上述处理过程，对象C所执行的处理结果将传递给对象A，如实线箭头ST3-22所示，从应用程序的观点看，仿佛对象A和对象C在同时运行。

在图6所示的例子中，方法“Receive”在方法“Reply”发布前就已经发布。也可选择将方法“Receive”在方法“Reply”发布后再发布。在这种情况下，对象A能够立即接收对象C所执行的处理结果而不用进入等待状态。

如果对象A在对象C发布方法“Reply”后再发布方法“Receive”，对象“mCOOPMailer”执行下面的处理过程。当对象C发布方法“Reply”时，对象“mCOOPMailer”将对象C的处理结果存储在数据区“RBox”中。然后，当对象A发布方法“Receive”时，对象“mCOOPMailer”立即从数据区“RBox”中读出对象C的处理结果并将其传递给对象A。

对象C所执行的处理结果存储在数据区“RBox”中。更准确地说，在数据区“RBox”的属性“ready”中设定表示对象C的处理结果已经返回的值，指向存储作为对象C的处理结果将要传递给对象A的消息的区域的指针，即由方法“Reply”的变量“resultMsg”所表示的指针，在数据区“RBox”的属性“resultMsg”中设定。此外，表示作为对象C的处理结果将要传递到对象A的消息大小的值，即由方法“Reply”的变量“sizeOfResultMsg”所表示的值，在数据区“RBox”的属性“sizeOfResultMsg”中设定。

在从数据区“RBox”读出对象C的处理结果并将其传递给对象A的过程中，对象“mCOOPMailer”首先从数据区“RBox”中读出数据区“RBox”的属性“resultMsg”和属性“sizeOfResultMsg”，数据区“RBox”由方法“Receive”的变量“rBoxID”指定，然后再从属性“resultMsg”表示的数据区中读出具有属性“sizeOfResultMsg”表示的大小的数据。读出数据作为消息将从对象C传递到对象A。然后，对象“mCOOPMailer”将读出数据存储在由方法“Receive”的变量“msg”所表示的区域中。由方法“Receive”的变量“msg”所表示的区域的大小由方法“Receive”的变量“sizeOfMsg”设定。

根据上述处理过程，当方法“Receive”在方法“Reply”被发布后发布时，以及当方法“Receive”在方法“Reply”被发布前发布时，对象C所执行的处理结果传递给对象A，仿佛对象A和对象C在同时运行。

根据上面的叙述，通过引进方法“Delegate”作为描述对象的API，即使存在多个服务对象，仍可以在服务对象间委托回答授权。换言之，通过引进方法“Delegate”，即使存在多个服务对象，并且即使接收处理请求的服务对象与返回处理结果的服务对象不同，消息传递仍能够顺利地执行。

另外，由于方法“Delegate”的引进，在多个服务对象中委托回答授权时，数据区“RBox”和指定数据区“RBox”的标识符“rBoxID”对应用程序来说都是明显的。这提高了应用程序开发的简单性。

如果被方法“Delegate”委托回答授权的对象(本例中指对象C)由于例如出现错误不能工作，并且不能取得结果时，就采用与图5所示方案类似的方式执行异常处理。

更准确地说，在图6所示的例子中，如果被方法“Delegate”委托回答授权的对象C在执行期间因出现错误不能工作而且不能取得结果时，处理过程移动到对象“mCOOPFaultHandler”，由对象“mCOOPFaultHandler”执行预定的异常处理。然后对象“mCOOPFaultHandler”将对象C由于出现错误而不能工作的情况报告给对象“mCOOPMailer”。

在这种情况下，如果对象A已经发布了方法“Receive”并处于等待状态，对象“mCOOPMailer”将表示对象C由于发生错误而不能工作的错误代码作为返回到方法“Receive”的值返回给对象A，然后促使对象A重新启动处理过程。这样，对象A准备执行处理过程，如果存在任何剩余处理，对象A重新启动处理过程。

另一方面，如果对象C在对象A发布方法“Receive”前出现异常，对象“mCOOPMailer”在数据区“RBox”的属性“status”中设定表示对象C由于出现错误而不能工作的错误代码。接着，当对象A发布方法“Receive”时，对象“mCOOPMailer”读出在数据区“RBox”的属性“status”中设定的错误代码，并将错误代码作为返回到方法“Receive”的值返回给对象A。然后，对象“mCOOPMailer”促使对象A新启动处理过程。因此，对象A准备执行处理过程，如果存在任何剩余处理，对象A重新启动该处理过程。

根据前面提到的处理过程，即使被委托回答授权的对象C因某种原因不能将结果消息返回给对象A，对象A仍能从等待状态恢复到执行状态，否则将导致对象A进入等待状态并中止系统。

2-5-3利用SendWithContinuation()进行的消息传递

下面将描述图7所示的mDrive元空间中利用方法“SendWithContinuation”进行的消息传递。

图7所示为对象A和对象B间在mDrive元空间中完成的消息传递的基本方案，对象A，对象B均作为设备驱动程序在mDrive元空间中运行。也就是说，在本例中，对象A是客户对象，对象B是服务对象。

图7中，发布方法“SendWithContinuation”的对象A的方法由“A::A1”表示，由方法“SendWithContinuation”启动并发布方法“Kick”的对象B的方法由“B::B1”表示。此外，方法“Kick”启动的对象A的方法，即连续方法，由“A::A2”表示。

当对象A在方法“A::A1”内发布方法“SendWithContinuation”时，如ST4-1所示，处理过程被移动到对象“mCOOPMailer”，如虚线箭头ST4-2所示，对象“mDriveMailer”根据方法“SendWithContinuation”执行处理过程，如ST4-3所示。

对象“mDriveMailer”首先保留数据区“Continuation”并将与连续方法有关的信息存储在其中。更准确地说，用于指定与对象A相对应的数据区“Thread”的标识符的值在数据区“Continuation”的属性“creator”中设定，方法“SendWithContinuation”的变量“contMeth”的值也在数据区“Continuation”的属性“meth”中设定。

对象“mDriveMailer”也保留数据区“DeliveryBoxB”，将指定数据区“Continuation”的标识符“contID”以及由方法“SendWithContinuation”发送的消息存储在其中。指定数据区“Continuation”的标识符“contID”存储在数据区“DeliveryBoxB”内，更准确地说，指定数据区“Continuation”的标识符“contID”的值在数据区“DeliveryBoxB”的属性“contID”中设定。此外，方法“SendWithContinuation”发送的消息存储在数据区“DeliveryBoxB”内，更准确地说，方法“SendWithContinuation”的变量“msg”的值存储在数据区“DeliveryBoxB”的属性“msg”中，，方法“SendWithContinuation”的变量“sizeOfMsg”的值也在数据区“DeliveryBoxB”的属性“sizeOfMsg”中设定。

此后，对象“mDirveMailer”将存储在数据区“DeliveryBoxB”内的数据，即方法“SendWithContinuation”所发送的消息，以及指定数据区“Continuation”的标识符“contID”传递到对象B，如虚线箭头ST4-4所示，从而启动对象B的方法“B::B1”。

在通过将存储在数据区“DeliveryBoxB”内的数据从对象“mDriveMailer”传递到对象B来启动对象B的方法“B::B1”过程中，对象B由方法“SendWthContinuation”的变量“destObjID”指定，对象B的方法“B::B1”由方法“SendWithContinuation”的变量“meth”指定。

一旦完成了前述处理过程，对象“mDriveMailer”将表示处理过程已经正确完成的值作为返回到方法“SendWithContinuation”的值返回到对象A，如虚线箭头ST4-5所示，然后促使对象A重新启动处理过程。因此，对象A准备执行理过程，如果存在任何剩余处理，则对象A重新启动该处理过程。

按照上述处理过程，消息已从对象A发送到对象B，如实线箭头ST4-6所示，从应用程序的观点看，仿佛对象A和对象B在同时运行。

此后，对象B执行方法“B::B1”，一旦完成对象A所请求的处理过程，对象B就发布方法“Kick”，如ST4-7所示。一旦发布方法“Kick”，处理过程被移动到对象“mDriveMailer”，如虚线箭头ST4-8所示，对象“mDriveMailer”执行响应方法“Kick”的处理过程，如ST4-9所示。

更准确地说，对象“mDriveMailer”首先指定基于方法“Kick”的变量“contID”的数据区“Continuation”，然后再读出存储于数据区“Continuation”内的信息。

作为属性“creator”，表示与对象A相对应的数据区“Thread”的标识符的值存储在数据区“Continuation”内。根据该标识符，对象“mDriveMailer”将对象A指定为响应方法“Kick”而将被启动的对象。方法“SendWithContinuation”的变量“contMeth”的值，即指定连续方法“A::A2”的值，在数据区“Continuation”的属性“meth”中设定。根据变量“contMeth”，对象“mDriveMailer”将方法“A::A2”指定为响应方法“Kick”而将被启动的连续方法。

然后对象“mDriveMailer”启动由存储在数据区“Continuation”中的信息所表示的对象的方法，即对象A的方法“A::A2”，作为连续方法，如虚线箭头ST4-10所示。在启动连续方法“A::A2”时，将被传递到连续方法“A::A2”的消息由方法“Kick”的变量“msg”和“sizeOfMsg”指定。

一旦正确完成对象A的连续方法“A::A2”的启动，对象“mDriveMailer”将表示方法“Kick”的处理过程已经正确完成的值作为返回到方法“Kick”的值返回给对象B，如虚线箭头ST4-11所示。然后，对象“mDriveMailer”促使对象B重新启动处理过程。因此，对象B准备执行处理过程，如果存在任可剩余处理，对象B重新启动处理过程。

根据前面提到的处理过程，对象A的连续方法“A::A2”由对象B启动，如实线箭头ST4-12所示，从设备驱动程序的观点看来，仿佛对象A和对象B在同时运行。

2-5-4在不同元空间之间的消息传递

下面将描述图8所示的在mCOOP元空间和mDrive元空间之间利用方法“Delegate”执行的消息传递。

作为在不同元空间间进行消息传递的方案，图8示出了在对象A，对象B和对象C间的消息传递的方案，对象A和对象B在mCOOP元空间中做为应用程序运行，对象C在mDrive元空间中做为设备驱动程序运行。在本方案中，对象B将回答授权委托给对象C。

也就是说，在本例中，对象A是客户对象，而对象B和对象C是服务对象。对象B委托对象C将处理结果返回给对象A。也就是说，对象B既充当服务对象，又充当授权委托对象。对象C既充当服务对象，又充当被委托授权对象。

在本方案中，图8所示的步骤ST5-1,ST5-2,ST5-3,ST5-4,ST5-5,ST5-6,ST5-7,ST5-8,ST5-9以及ST5-10分别与图2所示的步骤ST3-1,ST3-2,ST3-3,ST3-4,ST3-5,ST3-6,ST3-7,ST3-8,ST3-9以及ST3-10类似，因此省略其说明。

在本方案中，处理进行到步骤ST5-10后，当对象A处于等待状态且对象B正在执行处理过程时，对象B发布用于委托回答授权的方法“Delegate”。

当对象B发布方法“Delegate”时，如ST5-11所示，处理过程被移动到对象“mCOOPMailer”，如虚线箭头ST5-12所示，对象“mCOOPMailer”执行响应方法“Delegate”的处理过程，如ST5-13所示。

在这种情况下，对象“mCOOPMailer”确定被委托授权的对象是否是在mCOOP元空间中操作的对象。如果发现被委托授权的对象是在mCOOP元空间中操作的对象，则处理过程根据图6所示方案运行。但在本例中，被委托授权的对象不是在mCOOP元空间中操作的对象，而是在mDrive元空间中操作的对象C。因此，处理过程从对象“mCOOPMailer”移动到对象“mDriveMailer”，如虚线箭头ST5-14所示。

处理过程从对象“mCOOPMailer”移动到对象“mDriveMailer”是通过微内核来执行的。更准确地说，对象“mCOOPMailer”首先根据方法“Delegate”的变量“destObjID”确定被委托授权的对象所操作的元空间是mDrive元空间。此后，通过利用微内核的功能，对象“mCOOPMailer”请求对象“mDriveMailer”执行所需的处理过程，对象“mDriveMailer”是在操作在mDrive元空间中的对象之间执行消息传递的元对象。因此，处理过程将从对象“mCOOPMailer”移动到对象“mDriveMailer”。

以这种方式，在处理过程从对象“mCOOPMailer”移动到对象“mDriveMailer”后，对象“mDriveMailer”按照方法“Delegate”执行理过程，如ST5-15所示。

更准确地说，对象“mDriveMailer”首先保留出数据区“DeliveryBoxB”。然后对象“mDriveMailer”读出存储在与对象B相应的数据区“Thread”中的标识符“rBoxID”，并在数据区“DeliveryBoxB”的属性“contID”中设定标识符“rBoxID”。

同时，存储在与对象B相应的数据区“Thread”中的的标识符“rBoxID”被清除，从而使对象B不能回答授权。也就是说，对象B通过发布方法“Delegate”丧失回答授权，并将回答授权委托给对象C。由于已经丧失回答授权，因此对象B不能发布方法“Reply”。换句话说，对象B发布方法“Delegate”而不是方法“Reply”。

对象“mDriveMailer”也将方法“Delegate”发送的消息存储在数据区“DeliveryBoxB”中。更准确地说，方法“Delegate”的变量“msg”的值在数据区“DeliveryBoxB”的属性“msg”中设定，方法“Delegate”的变量“sizeOfMsg”的值也在数据区“DeliveryBoxB”的属性“sizeOfMsg”中设定。

然后，对象“mDriveMailer”将存储在数据区“DeliveryBoxB”中的数据，即方法“Delegate”所发送的消息，以及指定数据区“rBox”的标识符“rBoxID”传递到对象C，如虚线箭头ST5-16所示，从而启动对象C的方法。

在这种情况下，仅消息被发送给对象C的方法，标识符“rBoxID”存储在与对象C相应的数据区“Thread”内。换言之，将被传递给对象C的标识符“rBoxID”处于操作系统的管理下，从应用程序的观点看，被发送给对象C的仅仅是消息。

在通过将存储在数据区“DeliveryBoxB”中的数据从对象“mDriveMailer”传递到对象C来启动对象C的方法过程中，对象C由方法“Delegate”的变量“destObjID”指定，对象C的方法由方法“Delegate”的变量“meth”指定。

一旦完成上述处理过程，对象“mDriveMailer”将表示处理过程已经正确完成的值作为返回到方法“Delegate”的值通过对象“mCOOPMailer”返回给对象B，如虚线箭头ST5-17和ST5-18所示，然后促使对象B重新启动处理过程。对象B现在准备执行处理过程，如果存在任何剩余处理，则对象B重新启动该处理过程。

根据前面提到的处理过程，回答授权从对象B委托给对象C，如实心箭头ST5-19所示，从应用程序的观点看，仿佛对象B和对象C在同时运行。

此后，一旦完成对象A所请求的处理过程，对象C就发布方法“Kick”，如ST5-20所示。一旦发布方法“Kick”，处理过程被移动到对象“mDriveMailer”，如虚线箭头ST5-21所示，对象“mDriveMailer”执行响应方法“Kick”的处理过程，如ST5-22所示。

同时，对象“mDriveMailer”读出存储在与对象C相应的数据区“Thread”中的信息。如果指定数据区“Continuation”的标识符“contID”存储在数据区“Thread”中，那么启动连续方法的处理过程按图7所示方案执行。但在本例中，存储在数据区“Thread”中的不是指定数据区“Continuation”的标识符“contID”，而是指定数据区“rBox”的标识符“rBoxID”。

由于指定数据区“rBox”的标识符“rBoxID”存储在数据区“Thread”中，如上所述，处理过程从对象“mDriveMailer”移动到对象“mCOOPMailer”，如虚线箭头ST5-23所示，而不是由对象“mDriveMailer”启动连续方法。

处理过程从对象“mDriveMailer”移动到对象“mCOOPMailer”是通过微内核来完成的。更准确地说，对象“mDriveMailer”首先检查存储在与对象C相应的数据区“Thread”中的标识符是否就是在mDrive元空间中使用的指定数据区“Continuation”的标识符“contID”。在本例中，可以确定存储在与对象C相应的数据区“Thread”中的标识符不是指定数据区“Continuation”的标识符“contID”。

确定通过消息传递进行通信的对象所运行的元空间的信息也存储在与每个对象相应的数据区“Thread”中。存储在与对象C相应的数据区“Thread”中的标识符不是指定数据区“Continuation”的标识符“contID”。这样，与对象C相应的数据区“Thread”被进一步检验以确定通过消息传递进行通信的对象所运行的元空间。结果，在本例中，可以确定，通过消息传递进行通信的对象所运行的元空间是mCOOP元空间。

然后，通过利用微内核的功能，对象“mDriveMailer”请求对象“mCOOPMailer”执行所需的处理过程，对象“mCOOPMailer”是在mCOOP元空间中运行的对象间用于执行消息传递的元对象。因此，处理过程从对象“mDriveMailer”移动到对象“mCOOPMailer”。

以这种方式，在处理过程已从对象“mDriveMailer”移动到对象“mCOOPMailer”后，对象“mCOOPMailer”按照方法“Kick”执行处理过程，如ST5-24所示。

更准确地说，如果对象A已经发布方法“Receive”，那么对象“mCOOPMailer”将对象C所执行的处理结果传递给对象A。如果对象A尚未发布方法“Receive”，那么对象“mCOOPMailer”将对象C的处理结果存储在数据区“rBox”中。

在本例中，当对象C发布方法“Kick”时，对象A已经发布了方法“Receive”。因此，对象“mCOOPMailer”立即将对象C的处理结果传递给对象A，而不用将其存储在数据区“rBox”中，如虚线箭头ST5-25所示。一旦正确完成将对象C的处理结果传递给对象A的处理过程，对象“mCOOPMailer”通过对象“mDriveMailer”将表示处理过程已经正确完成的值作为返回到方法“Kick”的值返回给对象C，如虚线箭头ST5-26和ST5-27所示。然后对象“mCOOPMailer”促使对象C重新启动处理。对象C现在准备执行处理过程，如果存在任何剩余处理，则对象C重新启动处理过程。

根据上述处理过程，对象C所执行的处理结果被传递给对象A，如实线箭头ST5-28所示，从应用程序的观点看，仿佛对象A和对象C在同时运行。

在图8所示的例子中，方法“Receive”在方法“Kick”发布前已经被发布。也可以选择将方法“Receive”在方法“Kick”被发布后发布。在这种情况下，对象A能立即接收到对象C所执行的处理结果而不用进入等待状态。

如果对象A在对象C发布方法“Kick”后发布方法“Receive”，对象“mCOOPMailer”执行下面的处理过程。对象C发布方法“Kick”时，对象“mCOOPMailer”将对象C的处理结果存储在数据区“RBox”中。然后，当对象A发布方法“Receive”时，对象“mCOOPMailer”立即从数据区“RBox”中读出对象C的处理结果并将其传递给对象A。

对象C所执行的处理结果存储在数据区“RBox”中。更准确地说，表示对象C的处理结果已经返回的值在数据区“RBox”的属性“ready”中设定，指向存储作为对象C的处理结果将传递给对象A的消息的区域的指针，即方法“Kick”的变量“msg”所表示的指针，在数据区“RBox”的属性“resultMsg”中设定。此外，表示作为对象C的处理结果将传递给对象A的消息的大小的值，即方法“Kick”的变量“sizeOfMsg”所表示的值，在数据区“RBox”的属性“sizeOfResultMsg”中设定。

在从数据区“RBox”中读出对象C的处理结果并将其传递给对象A的过程中，对象“mCOOPMailer”首先从方法“Receiver”的变量“rBoxID”所指定的数据区“RBox”读出数据区“RBox”的属性“resultMsg”和属性“sizeOfResultMsg”，然后从属性“resultMsg”所表示的区域中读出具有属性“sizeOfResultMsg”所表示的大小的数据。读出数据作为消息从对象C传递到对象A。然后，对象“mCOOPMailer”将读出数据存储在由方法“Receive”的变量“msg”表示的区域中。由方法“Receive”的变量“msg”所指定的区域的大小在方法“Receive”的变量“sizeOfMsg”中设定。

根据上述处理过程，当方法“Receive”在方法“Kick”被发布后再发布时，以及当方法“Receive”在方法“Kick”被发布前发布时，对象C所执行的处理结果将被传递给对象A，仿佛对象A和对象C在同时运行。

如果被方法“Delegate”委托回答授权的对象(本例中为对象C)由于例如出现错误而不能工作且不能得到结果，那么以与图5所示方案类似的方式执行异常处理。

更准确地说，在图8所示的例子中，如果被方法“Delegate”委托回答授权的对象C在执行期间由于出现错误因而不能工作且不能得到结果，那么处理移动到对象“mDriverFaultHandler”，由对象“mDriverFaultHandler”执行预定的异常处理。然后，对象“mDriverFaultHandler”通过对象“mDriverMailer”将对象C由于出现错误而不能工作的情况报告给对象“mCOOPMailer”。

在这种情况下，如果对象A已经发布了方法“Receive”并处于等待状态，那么对象“mCOOPMailer”将表示对象C由于出现错误而不能工作的错误代码作为返回到方法“Receiver”的值返回给对象A，然后促使对象A重新启动处理。因此，对象A备执行处理过程，如果存在任何剩余处理，则对象A重新启动处理过程。

另一方面，如果在对象A发布方法“Receive”前对象C出现异常，那么对象“mCOOPMailer”在数据区“RBox”的属性“status”中设定表示对象C由于出现错误而不能工作的错误代码。然后，当对象A发布方法“Receive”时，对象“mCOOPMailer”读出设定在数据区“RBox”的属性“status”中的错误代码，并将错误代码作为返回到方法“Receive”的值返回给对象A。然后，对象“mCOOPMailer”促使对象A重新启动处理过程。因此，对象A准备执行处理过程，如果存在任何剩余处理，则对象A重新启动处理过程。

根据前面提到的处理过程，即使被委托具有回答授权的对象C由于某种原因不能将结果消息返回到对象A，对象A仍能从等待状态恢复到执行状态，否则将导致对象A进入等待状态并中止系统。

从前面的详细描述可以看出，本发明具有下列优点。

当消息从客户对象发送到服务对象时，数据区被保留出来。如果服务对象所执行的处理过程没有正确完成，表示服务对象状态的数据通过上述数据区传递给客户对象。

因此，根据本发明，即使当基于未来的消息传递正在执行时客户对象由于某种问题进入等待状态，服务对象的状态可以通知给客户对象而不需执行暂停处理，从而使客户对象可以从等待状态中退出。

另外，在本发明中，如果服务对象所执行的处理过程没有正确完成，表示服务对象状态的数据通过上述数据区传递给客户对象，否则将由于执行暂停处理而浪费时间。这样，客户对象可以快速地从等待状态中退出。

当服务对象所执行的处理过程没有正确完成时，表示服务对象状态的数据传递给客户对象，从而能确定造成等待状态出现的原因。因此，处理过程得以执行以恰当克服所述原因，从而阻止因同样原因引起的另一个等待状态的出现。

Claims (8)

1．一种消息从客户对象发送到服务对象的数据处理方法，所述服务对象响应消息请求执行处理过程并将所述处理过程的结果返回给所述客户对象，所述方法包括步骤：

一旦将所述消息从所述客户对象发送到所述服务对象，保留存储表示所述服务对象所执行的处理结果的结果数据区以及存储表示所述服务对象状态的状态数据区；

当所述服务对象所执行的处理过程已经正确完成时，在数据区中存储结果数据，或者当所述服务对象所执行的处理过程没有正确完成时，在数据区中存储状态数据；及

当所述服务对象所执行的处理过程已经正确完成时，所述客户对象通过读出存储在数据区中的数据而接收结果数据，或者当所述服务对象所执行的处理过程未正确完成时，所述客户对象通过读出存储在数据区中的数据而接收状态数据。

2．跟据权利要求1所述的数据处理方法，还包括步骤：

在所述客户对象将消息发送到所述服务对象后控制所述客户对象继续处理过程，并且当所述客户对象需要所述服务对象所执行的处理结果时，控制所述客户对象读出存储在数据区中的数据；及

读取存储在数据区中的数据时，如果结果数据和状态数据都未存储在数据区，控制所述客户对象进入等待状态，并在结果数据或状态数据存储在数据区以前控制所述客户对象保持在等待状态。

3．一种记录操作系统的记录介质，所述操作系统包括消息发送装置，作为描述对象的应用程序接口，将请求所对象执行处理过程的消息发送给另一个对象并返回处理结果；所述操作系统包括步骤：

根据所述消息发送装置将消息从客户对象发送到服务对象，以及保留数据区，该数据区部分用于存储表示所述服务对象所执行的处理结果的结果数据，部分用于存储表示所述服务对象状态的状态数据；及

当所述服务对象所执行的处理过程已经正确完成时，在数据区中存储结果数据，或当所述服务对象所执行的处理过程未正确完成时，在数据区中存储状态数据。

4．根据权利要求3所述的记录介质，其中所述操作系统包括读出存储在数据区中的数据的数据读出装置，作为用于描述对象的应用程序接口。

5．根据权利要求4所述的记录介质，其中，当结果数据和状态数据都未存储在数据区中时，一旦所述客户对象通过所述数据读出装置读取存储在数据区中的数据，所述操作系统控制所述客户对象进入等待状态，并在结果数据或状态数据存储在数据区以前控制所述客户对象保持在等待状态。

6．一种包括记录操作系统的记录介质的数据处理设备，所述操作系统包括消息发送装置，作为描述对象的应用程序接口，将请求所述对象执行理过程的消息发送给另一个对象并返回处理结果，所述操作系统包括步骤：

根据所述消息发送装置将消息从客户对象发送到服务对象，以及保留数据区，该数据区部分用于存储表示所述服务对象执行的处理结果的结果数据，部分用于存储表示所述服务对象状态的状态数据；及

当所述服务对象所执行的处理过程已经正确完成时，在数据区中存储结果数据，或当所述服务对象所执行的处理过程末正确完成时，在数据区中存储状态数据。

7．根据权利要求6所述的数据处理设备，其中所述操作系统包括用于读出存储在数据区中数据的数据读出装置，作为用于描述对象的应用程序接口。

8．根据权利要求7所述的数据处理设备，其中，当结果数据和状态数据都未存储在数据区中时，一旦所述客户对象通过所述数据读出装置读取存储在数据区中的数据，所述操作系统控制所述客户对象进入等待状态，并在结果数据或状态数据存储在数据区之前控制所述客户对象保持在等待状态。

Images