CompilerTech

导航

[转载] COM 套间

http://www.vckbase.com/index.php/wv/1315

简序

大学毕业前的最后一学期，在一家公司实习，当时的工作需要用到一些操作系统提供的组件。那时候只知道COM这个名词，并不知道到底是怎么回事，只知道上网 到处找别人的源码解决自己的问题；那段日子到现在回忆起来都是灰色的，每天呆坐在电脑前，一个网站一个网站的查找自己需要的源码。但并不清楚自己到底在做 什么；那时候对自己能不能成为一个程序员充满了怀疑。在实习结束返校的火车上，一夜间，我把一本《COM本质论》翻看了120多页。当我和当时的女友吹嘘 自己一夜可以看100多页书的时候，她马上问我：看懂多少？当时我哑口无言。她忍受不了我那段日子的失落和抱怨，从那时候起，我们结束了那段简短的感情。 到如今我还在一个人漂泊着，而上周她成为了别人的妻子。想不到用什么方式去纪念我迄今为止经历过的唯一一段感情，我和她的感情并不完全是因为COM结束 的，但由于对COM的迷惑，使我走向了迷茫，失落；对自己失去了信心，在她面前变成了一个悲观失望的人。写这篇文章权当对这份感情的一份纪念吧。

企者不立，跨着不行。很多格言都告诉我们做什么事情都必须从基础开始，对COM的理解也是这个道理。当三年前我看《COM 本质论》的时候，对虚函数也只是一知半解，只是知道通过它可以实现多态。但到底怎么实现就不清楚了。看不懂COM太正常了。知道看过Stanley B.Lippman的《Inside the C++ Object Model》，对C++的内存结构有了基本的理解，我才明白了接口的意义。这篇文章是写给初学者的，顺便给大家一些建议，如果一本书你看不懂的时候，可以 先放放，先找一些基础的读物来看看。这样可以少走一些弯路。

Don Box 在《COM 本质论》中说，对接口，类对象和套间有了彻底的理解，那么使用COM，没有翻不过去的山头。如果你对C++有深入的理解，那么《COM本质论》中对接口和 类对象的阐述很清晰，理解并不困难。但套间是一个比较抽象的概念，而书上对这部分只是理论的叙述，没有提供具体的例子，理解起来就更困难了。在此我把自己 找到的一些例子和自己的理解总结以下，以期给初学者提供一些入门的方法。闲话打住，开始正文吧。

一、关于多线程（Multithreading）

子曰：本立道生。也就是说我们明白事物所存在的原因，自然也就明白事物是怎么回事了。如果我们清楚了套间(Apartment)的产生原因，再去理解套 间，就容易许多了。我们先来看看，为什么需要套间？套间是为解决多线程中使用组件而产生的，首先我们来了解一下多线程。 

1、理解进程（Processes）和线程（Threading）

理解线程，先从进程（Processes）开始，一般书上对进程的描述都比较抽象，都说进程是一个运行的程序的实例，进程拥有内存，资源。我这儿试着用一 段汇编程序来解释一下进程，看看能不能帮你加深一下印象。我们先来看一段简单的汇编程序（你不理解汇编的话，建议找本书看看，一点不懂汇编，很难对其它高 级语言有太深的理解）。

01.; 汇编程序示例
02.data_seg segment  ；定义数据段
03.n_i  dw   ?
04.data_seg ends
05. 
06.stack_seg segment ；定义堆栈
07.dw 128 dup(0)
08.tos label word
09.statck_seg ends
10. 
11.code1 segment   ；定义代码段
12.main proc far
13.assume cs:ccode,ds;data,seg,ss:stack_seg
14.start:
15.move ax,stack_seg   ；将定义的堆栈段的地址保存到ss
16.mov ss,ax
17.mov sp,offset tos     ；将堆栈的最后地址保存到sp，堆栈是从下到上访问的
18. 
19.push ds　　；保存旧的数据段
20.sub ax,ax
21.push ax
22. 
23.mov ax,data_seg     ；将定义的数据段保存到ds
24.mov ds,ax
25. 
26.call fact               ；调用子函数
27. 
28.…….             ；其它操作省略
29.ret　　   ；返回到系统
30.main endp
31. 
32.fact proc near　　　　   ；子函数定义
33. 
34.……              ；具体操作省略
35.ret　　；返回到调用处
36.fact endp
37. 
38.code1 ends
39.end start
40.示例1：汇编程序结构

从以上程序我们看到，一个程序可以分为代码段，数据段，堆栈段等几部分。汇编编译器在编译的时候会将这些文件转化为成一个标准格式（在windows下被 称为PE文件格式）的文件（很多时候可执行文件被命名为二进制文件，我不喜欢这个名字，我觉得它容易给人误解；事实上计算机上所有的文件都是0和1组成 的，都是二进制文件；真正不同的就是处理这些文件的方式；EXE文件需要操作系统来调用，TXT文件需要写字本来打开；但其本质上并没有什么不同，只是在 不同的组合上，二进制数有不同的意义）。该文件格式会把我们的代码按格式安放在不同的部分。程序必须在内存中，才可以执行。在程序运行前，操作系统会按照 标准格式将这些内容加载到内存中。这些数据加载到内存中也需要按照一定的格式，CPU提供了DS,CS，SS等段寄存器，这样代码段的开始位置需要被CS 指定，数据段的开始位置需要用DS来指定，SS需要指向堆栈的开始位置等。在DOS下，每次只能运行一个程序，这些内容基本构成了进程。但在 Windows下，丰富了进程的内容，还包括一些数据结构用来维护我们程序中用到的图标，对话框等内容，以及线程。其实进程就是程序在内存中的组织形式， 有了这样的组织形式，程序才可能运行。也就是说，当程序加载到内存中去后，就形成了一个进程。

我们知道，CPU中拥有众多的寄存器，EAX，EBX等，而CPU的指令一般都是通过寄存器来实现的。其中有一个寄存器叫做EIP（Instruction Pointer，指令寄存器），程序的有序执行，是靠它来完成的。看下面的例子：

1.……
2.mov eax，4
3.mov ebx，5
4.……

假如我们的程序运行到mov eax，4，那么EIP就会指向该句代码所在的内存的地址。当这行代码执行完毕之后，那么EIP会自动加一，那么它就会指向mov ebx，4。而程序的执行就是靠EIP的不断增加来完成的（跳转的话，EIP就变成了跳转到的地址）。在Windows系统下，进程并不拥有 EIP，EAX，那么只有进程，一个程序就无法运行。而拥有这些寄存器的是线程，所以说进程是静态的。

我们知道一个CPU下只有一个EIP，一个EAX，也就是说同一时刻只能有一个线程可以运行，那么所说的多线程又是什么呢？事实上同一时刻也只有一个线程 在运行，每个线程运行一段时间后，它会把它拥有的EIP，EAX等寄存器让出来，其它线程占有这些寄存器后，继续运行。因为这段时间很短，所以我们感觉不 出来。这样我们就可以在一边听音乐的时候，一边玩俄罗斯方块了。为了实现不同的线程之间的转换，CPU要求操作系统维护一份固定格式的数据（该数据存在于 内存中），这份数据叫做Task-State Segment(TSS)，在这份数据结构里，维护着线程的EAX，EIP，DS等寄存器的内容。而CPU还有一个寄存器叫做Task Register（TR），该寄存器指向当前正在执行的线程的TSS。而线程切换事实上就是TR指向不同的TSS，这样CPU就会自动保存当前的 EAX，EBX的信息到相应的TSS中，并将新的线程的信息加载到寄存器。

事实上线程不过上一些数据结构，这些结构保存了程序执行时候需要的一些信息。我们可以在windows提供的头文件中找到一些影子，安装VC后在它的 include目录下有一个Winnt.h文件。在该文件中，我们可以找到这样一个struct(_CONTEXT)。这就是线程切换时需要的数据结构 （我不确定Windows内部是否用的就是这个结构，但应该和这份数据相差无几）。

01.//
02.// Context Frame
03.//
04.//  This frame has a several purposes: 1) it is used as an argument to
05.//  NtContinue, 2) is is used to constuct a call frame for APC delivery,
06.//  and 3) it is used in the user level thread creation routines.
07.//
08.//  The layout of the record conforms to a standard call frame.
09.//
10. 
11.typedef struct _CONTEXT {
12. 
13.//
14.// The flags values within this flag control the contents of
15.// a CONTEXT record.
16.//
17.// If the context record is used as an input parameter, then
18.// for each portion of the context record controlled by a flag
19.// whose value is set, it is assumed that that portion of the
20.// context record contains valid context. If the context record
21.// is being used to modify a threads context, then only that
22.// portion of the threads context will be modified.
23.//
24.// If the context record is used as an IN OUT parameter to capture
25.// the context of a thread, then only those portions of the thread''s
26.// context corresponding to set flags will be returned.
27.//
28.// The context record is never used as an OUT only parameter.
29.//
30. 
31.DWORD ContextFlags;
32. 
33.//
34.// This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
35.// set in ContextFlags.  Note that CONTEXT_DEBUG_REGISTERS is NOT
36.// included in CONTEXT_FULL.
37.//
38. 
39.DWORD   Dr0;
40.DWORD   Dr1;
41.DWORD   Dr2;
42.DWORD   Dr3;
43.DWORD   Dr6;
44.DWORD   Dr7;
45. 
46.//
47.// This section is specified/returned if the
48.// ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
49.//
50. 
51.FLOATING_SAVE_AREA FloatSave;
52. 
53.//
54.// This section is specified/returned if the
55.// ContextFlags word contians the flag CONTEXT_SEGMENTS.
56.//
57. 
58.DWORD   SegGs;
59.DWORD   SegFs;
60.DWORD   SegEs;
61.DWORD   SegDs;
62. 
63.//
64.// This section is specified/returned if the
65.// ContextFlags word contians the flag CONTEXT_INTEGER.
66.//
67. 
68.DWORD   Edi;
69.DWORD   Esi;
70.DWORD   Ebx;
71.DWORD   Edx;
72.DWORD   Ecx;
73.DWORD   Eax;
74. 
75.//
76.// This section is specified/returned if the
77.// ContextFlags word contians the flag CONTEXT_CONTROL.
78.//
79. 
80.DWORD   Ebp;
81.DWORD   Eip;
82.DWORD   SegCs;　　　　    // MUST BE SANITIZED
83.DWORD   EFlags;　　　　   // MUST BE SANITIZED
84.DWORD   Esp;
85.DWORD   SegSs;
86. 
87.//
88.// This section is specified/returned if the ContextFlags word
89.// contains the flag CONTEXT_EXTENDED_REGISTERS.
90.// The format and contexts are processor specific
91.//
92. 
93.BYTE    ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION];
94. 
95.} CONTEXT;

好了，线程就先讲这么多了。如果对进程和线程的内容感兴趣，可以到Intel的网站下载PDF格式的电子书《IA-32 Intel Architecture Software Developer’s Manual》，纸版的书也可以在这儿预定（他们会免费邮寄给你）。通过这套书，你可以对CPU的结构有一个清晰的认识。另外可以找几本讲解 Windows系统的书看看，不过这类的好书不多，最著名的是《Advance Windows》，不过也是偏向于实用，对系统结构的讲解不多。也是，要完全去了解这部分的细节，太困难了，毕竟微软没有给我们提供这部分的源码。幸好， 其实我们理解它大致的原理就足够用了。

2、多线程存在的问题

我们首先看一段多线程程序（该程序可以在Code的MultiThreading中找到）：

01.#include < iostream >
02.#include < windows.h >
03. 
04.int g_i = 10;  //一个全局变量
05. 
06.DWORD WINAPI ThreadProc(LPVOID lpv)
07.{
08.g_i += 10;
09.std::cout <<"In the Thread " << ::GetCurrentThreadId() << ",the first g_i is "  <<  g_i  <<  "!"  << std::endl;
10.Sleep(5000); //睡眠
11.g_i += 10;
12.std::cout <<"In the Thread " << ::GetCurrentThreadId() << ",the secend g_i is "  <<  g_i  << "!" << std::endl;
13.return 0;
14.}
15. 
16.int main(int argc, char* argv[])
17.{
18. 
19.DWORD threadID[2];
20.HANDLE hThreads[2];
21. 
22.for(int i = 0; i <= 1; i++ )         //创建两个线程
23.hThreads[i] = ::CreateThread(NULL,
24.　　      0,
25.　　      ThreadProc,
26.　　      NULL,
27.　　      0,
28.　　      &threadID[i]);
29. 
30. 
31.WaitForMultipleObjects(2,hThreads,TRUE,INFINITE);   //等待线程结束
32. 
33.for(i = 0; i <= 1; i++ )
34.::CloseHandle(hThreads[i]);             //关闭线程句柄
35.system("pause");
36.return 0;
37.}
38.示例程序2-多线程程序

这段程序的本意是让全局变量累次加10，并打印出操作后的数值。但我们运行程序后的结果如下，可以看到程序的运行结果非我们所愿。打印出的结果是一串乱序的文字。 

 

如何解决这个问题呢？我们需要利用同步机制来控制我们的多线程程序，现在我们使用临界区来解决这个问题。代码如下：（在Code的MultiThreading中将进入临界区和离开临界区的代码前的注释去掉就可以了）

01.#include < iostream >
02.#include < windows.h >
03. 
04.int g_i = 10;  //一个全局变量
05. 
06.CRITICAL_SECTION cs;  //一个临界区变量
07. 
08.DWORD WINAPI ThreadProc(LPVOID lpv)
09.{
10.EnterCriticalSection(&cs);  //进入临界区
11. 
12.g_i += 10;
13.std::cout < <  "In the Thread " < <   ::GetCurrentThreadId() < <   ",the first g_i is "  < <   g_i < <    "!"  < <   std::endl;
14.::LeaveCriticalSection(&cs);
15.Sleep(5000); //睡眠
16.EnterCriticalSection(&cs);
17.g_i += 10;
18.std::cout < <    "In the Thread " < <  ::GetCurrentThreadId() < <  ",the secend g_i is "  < <  g_i < <  "!" < <  std::endl;
19.::LeaveCriticalSection(&cs);
20.return 0;
21.}
22. 
23.int main(int argc, char* argv[])
24.{
25. 
26.DWORD threadID[2];
27.HANDLE hThreads[2];
28.InitializeCriticalSection(&cs);
29.for(int i = 0; i < = 1; i++ )            //创建两个线程
30.hThreads[i] = ::CreateThread(NULL,
31.　　　　0,
32.　　　　ThreadProc,
33.　　　　NULL,
34.　　　　0,
35.　　　　&threadID[i]);
36. 
37.WaitForMultipleObjects(2,hThreads,TRUE,INFINITE);   //等待线程结束
38.for(i = 0; i < = 1; i++ )
39.::CloseHandle(hThreads[i]);             //关闭线程句柄
40. 
41.system("pause");
42.return 0;
43.}

再次运行，结果就是我们所需要的了。 

     

如上所示我们通过在代码中加入EnterCriticalSection和LeaveCriticalSection来实现对数据的保护，如我们只在程序 开头和结尾填加这两个函数的话，也不会太复杂，但是这样也就失去了多线程的意义。程序不会更快，反而会变慢。所以我们必须在所有需要保护的地方，对我们的 操作进行保护。程序如果庞大的话，这将是一个烦琐而枯燥的工作，而且很容易出错。如果是我们自己使用的类的话，我们可以选择不使用多线程，但组件是提供给 别人用的。开发者无法阻止组件使用者在多线程程序中使用自己提供的组件，这就要求组件必须是多线程安全的。但并不是每个开发者都愿意做这样的工作，微软的 COM API设计者为了平衡这个问题，就提出了套间的概念。 

注意：以上只是一个简单的例子，事实上多线程中需要保护的部分一般集中在全局数据和静态数据之上，因为这样的数据每个进程只有一份，如上所示的g_i。 （想对多线程程序有更深入的认识，可以找侯捷翻译的《Win32多线程程序设计》看看，90年代出的书，到现在还畅销，足可以说明它的价值）

二、套间所要解决的问题 　　

从多线程的描述中，我们知道，套间所要解决的问题是帮助组件的开发者在实现多线程下调用组件时候的同步问题。我们还是先看一段简短的程序。

我们首先使用ATL创建一个简单的组件程序，该程序有一个接口(ITestInterface1)，该接口支持一个方法TestFunc1。（该组件可以 在附加的源码的“Apartment\TestComObject1”目录下找到）我们通过以下的程序调用该组件。(该程序可以在附加的源码的 “Apartment\ErrorUseApartment”目录下找到)

01.#define _WIN32_WINNT 0x0400
02.#include < windows.h >
03.#include < iostream >
04. 
05.#include "..\TestComObject1\TestComObject1_i.c"
06.#include "..\TestComObject1\TestComObject1.h"
07. 
08.DWORD WINAPI ThreadProc(LPVOID lpv)
09.{
10. 
11.HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
12. 
13.if ( FAILED(hr) )
14.{
15.std::cout << "CoinitializeEx failed!" << std::endl;
16.return 0;
17.}
18. 
19.ITestInterface1 *pTest = NULL;
20. 
21.hr = ::CoCreateInstance(CLSID_TestInterface1,
22.0,
23.CLSCTX_INPROC,
24.IID_ITestInterface1,
25.(void**)&pTest);
26. 
27.if ( FAILED(hr) )
28.{
29.std::cout << "CoCreateInstance failed!" << std::endl;
30.return 0;
31.}
32. 
33.hr = pTest->TestFunc1();
34. 
35.if ( FAILED(hr) )
36.{
37.std::cout << "TestFunc1 failed!" << std::endl;
38.return 0;
39.}
40. 
41.pTest->Release();
42.::CoUninitialize();
43.return 0;
44.}
45. 
46.int main(int argc, char* argv[])
47.{
48.HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
49. 
50.if ( FAILED(hr) )
51.{
52.std::cout << "CoinitializeEx failed!" << std::endl;
53.return 0;
54.}
55. 
56.ITestInterface1 *pTest = NULL;
57. 
58.hr = ::CoCreateInstance(CLSID_TestInterface1,
59.0,
60.CLSCTX_INPROC,
61.IID_ITestInterface1,
62.(void**)&pTest);
63. 
64.if ( FAILED(hr) )
65.{
66.std::cout << "CoCreateInstance failed!" << std::endl;
67.return 0;
68.}
69. 
70.DWORD threadID;
71.HANDLE hThreads  =   ::CreateThread(NULL, //创建一个进程
72.0,
73.ThreadProc,
74.NULL,  //将pTest作为一个参数传入新线程
75.0,
76.&threadID);
77.hr = pTest->TestFunc1();
78. 
79.if ( FAILED(hr) )
80.{
81.std::cout << "TestFunc1 failed!" << std::endl;
82.return 0;
83.}
84. 
85.::WaitForSingleObject(hThreads,INFINITE);   //等待线程结束
86.::CloseHandle(hThreads);                //关闭线程句柄
87.pTest->Release();
88.::CoUninitialize();
89.system("pause");
90.return 0;
91.}

该段程序将main中定义的ITestInterface1对象，通过指针传到了新建的线程中。运行该段程序，结果如下，又是一串乱序的文字串。也就是说 我们需要在TestComObject1中对TestFunc1进行线程同步控制。但大多数人并不想这样做，因为我们开发的组件大多数情况下并不会在多线 程执行。但为了避免低概率事件发生后的不良后果，套间出场了。 

 

三、套间如何实现数据的同步

我们已经知道套间的目的是用来实现数据的同步，那么套间如何来实现呢？如果我们能保证COM对象中的函数只能在该对象中的另一个函数执行完以后，才能开始 执行（也就是说组件中的函数只能一个一个的执行），那么我们的问题就可以解决了。是的，你可以发现，这样的话，就失去了多线程的优势；但套间的目的是保证 小概率下的线程安全，损耗一些性能，应该比出现逻辑错误强点。 

那么又如何保证同一对象下的所有方法都必须按顺序逐个执行呢？微软的COM API设计者们借用了Windows的消息机制。我们先来看一下windows的消息机制图。 

     

我们可以看到所有线程发出的消息都回首先放到消息队列中，然后在通过消息循环分发到各自窗口去，而消息队列中的消息只能一个处理完后再处理另一个，借助消 息机制，就可以实现COM的函数一个一个的执行，而不会同时运行。Windows的消息机制是通过窗口来实现的，那么一个线程要接收消息，也应该有一个窗 口。 COM API的设计者在它们的API函数中实现了一个隐藏的窗口。在我们调用CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)的时候，会生成这个窗口。（如果你对softice等动态调试工具熟悉的话，可以通过跟踪源码来跟踪 CoInitializeEx函数，可以发现它会调用API函数CreateWindowEx）。该窗口是隐藏的,有了这个窗口，就可以支持消息机制，就 有办法来实现对象中函数的逐一执行。这样当对象指针被传到其它线程的时候，从外部调用该对象的方法的时候，就会先发一个消息到原线程，而不再直接访问对象 了。套间的原理大致就是这样。我们再来看看COM中的套间类型。

四、套间的类型

     

我们首先看看ATL为我们提供的线程类型：Single，Apartment，Both，Free。我们还是通过例子来说明它们的不同。我们仍然用我们使用刚才实现的TestComObject1来进行测试，先对它实现的唯一方法进行一下说明。

1.STDMETHODIMP CTestInterface1::TestFunc1()
2.{
3.// TODO: Add your implementation code here
4.std::cout << "In the itestinferface1''s object, the thread''s id is " << ::GetCurrentThreadId() << std::endl;
5.return S_OK;
6.}

该方法非常简单，就是打印出该方法运行时，所在的线程的ID号。如果在不同的线程中调用同一个对象的时候，通过套间，发送消息，最终该对象只应该在一个线程中运行，所以它的线程ID号应该是相同的。我们将通过该ID值来验证套间的存在。

1、Single

先来看我们的示例程序（在Code/Apartment/SingleApartment目录下可以找到该工程）：

01.#define _WIN32_WINNT 0x0400
02.#include < windows.h >
03.#include < iostream >
04. 
05.#include "..\TestComObject1\TestComObject1_i.c"
06.#include "..\TestComObject1\TestComObject1.h"
07. 
08.DWORD WINAPI ThreadProc(LPVOID lpv)
09.{
10. 
11.HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
12. 
13.if ( FAILED(hr) )
14.{
15.std::cout << "CoinitializeEx failed!" << std::endl;
16.return 0;
17.}
18. 
19.ITestInterface1 *pTest = NULL;
20. 
21.hr = ::CoCreateInstance(CLSID_TestInterface1,
22.0,
23.CLSCTX_INPROC,
24.IID_ITestInterface1,
25.(void**)&pTest);
26. 
27.if ( FAILED(hr) )
28.{
29.std::cout << "CoCreateInstance failed!" << std::endl;
30.return 0;
31.}
32. 
33.hr = pTest->TestFunc1();
34. 
35.if ( FAILED(hr) )
36.{
37.std::cout << "TestFunc1 failed!" << std::endl;
38.return 0;
39.}
40. 
41.pTest->Release();
42.::CoUninitialize();
43.return 0;
44.}
45. 
46.int main(int argc, char* argv[])
47.{
48.HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
49. 
50.if ( FAILED(hr) )
51.{
52.std::cout << "CoinitializeEx failed!" << std::endl;
53.return 0;
54.}
55. 
56.ITestInterface1 *pTest = NULL;
57. 
58.hr = ::CoCreateInstance(CLSID_TestInterface1,
59.0,
60.CLSCTX_INPROC,
61.IID_ITestInterface1,
62.(void**)&pTest);
63. 
64.if ( FAILED(hr) )
65.{
66.std::cout << "CoCreateInstance failed!" << std::endl;
67.return 0;
68.}
69. 
70.hr = pTest->TestFunc1();
71. 
72.if ( FAILED(hr) )
73.{
74.std::cout << "TestFunc1 failed!" << std::endl;
75.return 0;
76.}
77. 
78.DWORD threadID;
79.HANDLE hThreads[1];
80.hThreads[0]  =   ::CreateThread(NULL,   //创建一个进程
81.0,
82.ThreadProc,
83.(LPVOID)pTest,  //将pTest作为一个参数传入新线程
84.0,
85.&threadID);
86. 
87.::WaitForSingleObject(hThreads,INFINITE);   //等待线程结束
88.::CloseHandle(hThreads);                //关闭线程句柄
89.pTest->Release();
90.::CoUninitialize();
91.system("pause");
92.return 0;
93.}

以下是运行结果： 

    

可以看到，在main中我们创建了一个ITestInterface1接口对象，并调用TestFunc1，此处会输出一个线程 ID――ThreadID1。之后主线程生成一个线程，在该线程中，我们会再次生成一个ITestInterface1接口对象，此处再次调用 TestFunc1，可以看到输出了另一个线程ID――ThreadID2。因为是不同的对象，所以它们的线程ID号不同。(注意了，此处并没有跨线程调 用对象，并不在套间的保护范围)

好了，我们该来看看Single类型的套间了。如果你和我一样懒，不想为此去写一个single类型的接口，那么打开你的注册表。

    

找到我们的接口ID，在InprocServer32项下，将ThreadingModel的值改为Single，或者将该项删除（这样也代表是Single套间）。我们再来运行该程序，再看运行结果。 

 

当打印出一个线程ID的时候，程序就停止了。Why？刚开始，我也被搞的头晕脑胀。到MSDN中查找WaitForSingleObject，原来 WaitForSingleObject会破坏程序中的消息机制，这样在创建的线程中，TestFunc1需要通过消息机制来运行，消息机制破坏，就无法 运行了。哎！还的再改程序。在查查《Win32多线程程序设计》，原来在GUI中等待线程需要用MsgWaitForMultipleObjects。好 的，我们需要重新写一个函数，专门用来实现消息同步。

01.DWORD ApartMentMsgWaitForMultipleObject(HANDLE *hHandle,DWORD dwWaitCout, DWORD dwMilliseconds)
02.{
03.BOOL bQuit = FALSE;
04.DWORD dwRet;
05. 
06.while(!bQuit)
07.{
08.int rc;
09.rc = ::MsgWaitForMultipleObjects
10.　　(
11.dwWaitCout,　// 需要等待的对象数量
12.hHandle,    // 对象树组
13.FALSE,      //等待所有的对象
14.(DWORD)dwMilliseconds,  // 等待的时间
15.(DWORD)(QS_ALLINPUT | QS_ALLPOSTMESSAGE)　　// 事件类型　　 
16.　　);
17.//等待的事件激发
18.if( rc ==  WAIT_OBJECT_0 )
19.{          
20.dwRet = rc;
21.bQuit = TRUE;
22.}
23.//其他windows消息
24.else if( rc == WAIT_OBJECT_0 + dwWaitCout )        
25.{
26.MSG msg;
27.while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
28.{
29.TranslateMessage (&msg);
30.DispatchMessage(&msg);
31.}          
32.}
33.}
34.return dwRet;
35.}

该函数用来处理消息的同步，也够麻烦的，还需要自己写这段程序。这段程序的意思是如果等待的事件被激发，那么设置bQuit为TURE，那么退出消息循环。如果接收到其它的消息的话，再分发出去。好了，把我们的程序再改一下：

1.//  ::WaitForSingleObject(hThreads,INFINITE);   //等待线程结束
2.ApartMentMsgWaitForMultipleObject(hThreads,1,INFINITE);

我们再来看一下运行结果。 

    

我们可以看到两处调用TestFunc1，得到的线程ID是相同的。我们再通过VC的调试功能来看看第二个TestFunc1的运行过程。我们在两个 TesfFunc1调用处设置断点，然后通过F11跟踪进TestFunc1来看看它的调用过程。以下是在Main中的调用过程。

　　

通过Call Stack，我们可以看到，此处是在main中直接调用的。我们再来看第二处调用：

　　

我们可以看到TestFunc1的调用需要通过一连串的API方法来实现。你感兴趣的话，可以通过反汇编的方法来跟踪一下这些API，看看它们具体实现了 什么，这里我们可以看到这些函数在dll中的大致位置，你可以使用W32DASM等反汇编工具打开这些dll，大致研究一下这些函数。

好了，我们已经看到了Single套间的作用。那么Single套间究竟是什么意思呢？就是说每个被标志为Single的接口，在一个进程中只会存活在一 个套间中。该套间就是进程创建的第一个套间。你可以将Main中与pTest相关的代码都去掉，只保留CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)和线程的创建，再次运行该程序，可以发现创建线程中的TestFunc1仍然是通过消息来实现的。

好了看过了Single，我们还是在注册表中，将ThreadingModel改为Apartment。通过修改注册表就可以实现对套间类型的控制，证明 了套间和我们的程序本身没有什么关系，ATL的选项所做的作用也只是通过它来添加注册表。套间只是对系统的一种提示，由COM API通过注册表信息来帮我们实现套间。

2、Apartment

在第二部分（套间所要解决的问题），我们曾经提供了一个不同线程共享接口对象的方法，该方法是错误的（我们也可以通过程序阻止这种用法，稍候再叙）。此处我们提供一种正确的做法。以下代码在Apartment/Apartmenttest下可以找到。

001.#define _WIN32_WINNT 0x0400
002.#include < windows.h >
003.#include < iostream >
004. 
005.#include "..\TestComObject1\TestComObject1_i.c"
006.#include "..\TestComObject1\TestComObject1.h"
007. 
008.DWORD WINAPI ThreadProc(LPVOID lpv)
009.{
010.//HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
011.HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
012. 
013.if ( FAILED(hr) )
014.{
015.std::cout << "CoinitializeEx failed!" << std::endl;
016.return 0;
017.}
018. 
019.IStream *pStream = (IStream*)lpv;
020. 
021.ITestInterface1 *pTest = NULL;
022. 
023.hr = ::CoGetInterfaceAndReleaseStream(pStream,
024.IID_ITestInterface1,
025.(void**)&pTest);
026.if ( FAILED(hr) )
027.{
028.std::cout << "CoGetInterfaceAndReleaseStream failed!" << std::endl;
029.return 0;
030.}
031. 
032. 
033.hr = pTest->TestFunc1();
034. 
035.if ( FAILED(hr) )
036.{
037.std::cout << "TestFunc1 failed!" << std::endl;
038.return 0;
039.}
040. 
041.pTest->Release();
042.::CoUninitialize();
043.return 0;
044.}
045. 
046.DWORD ApartMentMsgWaitForMultipleObject(HANDLE *hHandle,DWORD dwWaitCout, DWORD dwMilliseconds)
047.{
048. 
049.BOOL bQuit = FALSE;
050.DWORD dwRet;
051. 
052.while(!bQuit)
053.{
054.int rc;
055.rc = ::MsgWaitForMultipleObjects
056.(
057.dwWaitCout,　　　　// 需要等待的对象数量
058.hHandle,            // 对象树组
059.FALSE,              //等待所有的对象
060.(DWORD)dwMilliseconds,  // 等待的时间
061.(DWORD)(QS_ALLINPUT | QS_ALLPOSTMESSAGE)　　// 事件类型　　 
062.);
063. 
064.if( rc ==  WAIT_OBJECT_0 )
065.{          
066.dwRet = rc;
067.bQuit = TRUE;
068. 
069.}
070.else if( rc == WAIT_OBJECT_0 + dwWaitCout )        
071.{
072.MSG msg;
073.while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
074.{
075.　　TranslateMessage (&msg);
076.　　DispatchMessage(&msg);
077.}          
078.}
079.}
080.return dwRet;
081.}
082. 
083.int main(int argc, char* argv[])
084.{
085.//HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
086.HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
087. 
088.if ( FAILED(hr) )
089.{
090.std::cout << "CoinitializeEx failed!" << std::endl;
091.return 0;
092.}
093. 
094.ITestInterface1 *pTest = NULL;
095. 
096.hr = ::CoCreateInstance(CLSID_TestInterface1,
097.0,
098.CLSCTX_INPROC,
099.IID_ITestInterface1,
100.(void**)&pTest);
101. 
102.if ( FAILED(hr) )
103.{
104.std::cout << "CoCreateInstance failed!" << std::endl;
105.return 0;
106.}
107. 
108.hr = pTest->TestFunc1();
109. 
110.if ( FAILED(hr) )
111.{
112.std::cout << "TestFunc1 failed!" << std::endl;
113.return 0;
114.}
115. 
116.IStream *pStream = NULL;
117. 
118.hr = ::CoMarshalInterThreadInterfaceInStream(IID_ITestInterface1,
119.pTest,
120.&pStream);
121. 
122.if ( FAILED(hr) )
123.{
124.std::cout << "CoMarshalInterThreadInterfaceInStream failed!" << std::endl;
125.return 0;
126.}
127. 
128. 
129.DWORD threadID;
130.HANDLE hThreads[1];
131.hThreads[0]  =   ::CreateThread(NULL,           //创建一个进程
132.　　　　0,
133.　　　　ThreadProc,
134.　　　　(LPVOID)pStream,  //将pStream作为一个参数传入新线程
135.　　　　0,
136.　　　　&threadID);
137.ApartMentMsgWaitForMultipleObject(hThreads,1,INFINITE);
138.::CloseHandle(hThreads);                //关闭线程句柄
139.pTest->Release();
140.::CoUninitialize();
141.system("pause");
142.return 0;
143.}

我们通过CoGetInterfaceAndReleaseStream将main中的pTest变为pStream，然后将pStream作为参数传入 到线程中，然后再通过CoGetInterfaceAndReleaseStream将pSteam变为接口指针。再来看看运行的结果：

　　

可以看到两次运行，线程ID是相同的。好的，我们接着改变注册表，再将Apartment变为Free。然后再将两处的HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);改为HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED)。编译后再次执行该程序，再来看执行结果。

　　

我们可以看到两个线程的ID是不同的。你可以通过VC的Debug来看这两组程序的TesFunc1的调用情况，在第二种情况下，创建的线程中不会通过消息机制来调用该函数。 

通过对比，我们可以知道所说的套间，就是通过消息机制来控制不同线程中对对象的调用。这样就不需要组件的实现者来实现数据的同步。

3、Free

上节的例子，已经为我们提示了我们Free套间，其实系统对我们的组件不做控制，这样就需要组件的开发者对数据的同步做出控制。

4、Both

所谓Both，就是说该对象既可以运行在Apartment中，也可以运行在Free套间中。该类型的前提是它应该是Free类型的套间，也就是说组件自己实现了数据的同步。然后设置成Both类型。 

为什么需要Both类型的套间呢？想想假如我们在我们的组件中调用另一个组件，这样我们就需要在我们的组件中为所调用的组件来开辟一个套间。我们的套间是 一个Apartment，而调用的组件是Free类型的，这样这两个对象就必须存在于不同的两个套间中。而跨套间的调用，需要通过中间代理来实现，这样必 然会损失性能。但如果我们调用的套间类型是Both的话，它就可以和我们的组件同享一个套间，这样就可以提高效率。

五、缺省套间

继续我们的测试，首先在注册表中将我们的接口类型改回Apartment。然后新建一个工程DefaultApartment。C++文件中的实现代码如下。

001.#define _WIN32_WINNT 0x0400
002.#include < windows.h >
003.#include < iostream >
004. 
005.#include "..\TestComObject1\TestComObject1_i.c"
006.#include "..\TestComObject1\TestComObject1.h"
007. 
008.DWORD WINAPI ThreadProc(LPVOID lpv)
009.{
010.HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
011.//HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
012. 
013.if ( FAILED(hr) )
014.{
015.std::cout << "CoinitializeEx failed!" << std::endl;
016.return 0;
017.}
018. 
019.IStream *pStream = (IStream*)lpv;
020.ITestInterface1 *pTest = NULL;
021.hr = ::CoGetInterfaceAndReleaseStream(pStream,
022.IID_ITestInterface1,
023.(void**)&pTest);
024.if ( FAILED(hr) )
025.{
026.std::cout << "CoGetInterfaceAndReleaseStream failed!" << std::endl;
027.return 0;
028.}
029. 
030.std::cout << "ThradProc''s threadid is " << ::GetCurrentThreadId() << std::endl; //输出ThradProc的线程ID
031. 
032. 
033.hr = pTest->TestFunc1();
034. 
035.if ( FAILED(hr) )
036.{
037.std::cout << "TestFunc1 failed!" << std::endl;
038.return 0;
039.}
040. 
041.pTest->Release();
042.::CoUninitialize();
043.return 0;
044.}
045. 
046.DWORD ApartMentMsgWaitForMultipleObject(HANDLE *hHandle,DWORD dwWaitCout, DWORD dwMilliseconds)
047.{
048. 
049.BOOL bQuit = FALSE;
050.DWORD dwRet;
051. 
052.while(!bQuit)
053.{
054.int rc;
055.rc = ::MsgWaitForMultipleObjects
056.(
057.dwWaitCout,　　　　// 需要等待的对象数量
058.hHandle,            // 对象树组
059.FALSE,              //等待所有的对象
060.(DWORD)dwMilliseconds,  // 等待的时间
061.(DWORD)(QS_ALLINPUT | QS_ALLPOSTMESSAGE)　　// 事件类型　　 
062.);
063. 
064.if( rc ==  WAIT_OBJECT_0 )
065.{          
066.dwRet = rc;
067.bQuit = TRUE;
068. 
069.}
070.else if( rc == WAIT_OBJECT_0 + dwWaitCout )        
071.{
072.MSG msg;
073. 
074.while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
075.{
076.　　TranslateMessage (&msg);
077.　　DispatchMessage(&msg);
078.}          
079.}
080.}
081. 
082.return dwRet;
083.}
084. 
085.int main(int argc, char* argv[])
086.{
087.HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
088.//HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
089. 
090.if ( FAILED(hr) )
091.{
092.std::cout << "CoinitializeEx failed!" << std::endl;
093.return 0;
094.}
095. 
096.ITestInterface1 *pTest = NULL;
097. 
098.hr = ::CoCreateInstance(CLSID_TestInterface1,
099.0,
100.CLSCTX_INPROC,
101.IID_ITestInterface1,
102.(void**)&pTest);
103. 
104.if ( FAILED(hr) )
105.{
106.std::cout << "CoCreateInstance failed!" << std::endl;
107.return 0;
108.}
109. 
110.std::cout << "main''s threadid is " << ::GetCurrentThreadId() << std::endl;  //打印main的线程ID
111. 
112.hr = pTest->TestFunc1();
113. 
114.if ( FAILED(hr) )
115.{
116.std::cout << "TestFunc1 failed!" << std::endl;
117.return 0;
118.}
119. 
120.IStream *pStream = NULL;
121. 
122.hr = ::CoMarshalInterThreadInterfaceInStream(IID_ITestInterface1,
123.pTest,
124.&pStream);
125. 
126.if ( FAILED(hr) )
127.{
128.std::cout << "CoMarshalInterThreadInterfaceInStream failed!" << std::endl;
129.return 0;
130.}
131. 
132. 
133.DWORD threadID;
134.HANDLE hThreads[1];
135.hThreads[0] =   ::CreateThread(NULL,            //创建一个进程
136.　　　　0,
137.　　　　ThreadProc,
138.　　　　(LPVOID)pStream,  //将pStream作为一个参数传入新线程
139.　　　　0,
140.　　　　&threadID);
141. 
142.ApartMentMsgWaitForMultipleObject(hThreads,1,INFINITE);
143.::CloseHandle(hThreads);                //关闭线程句柄
144.pTest->Release();
145.::CoUninitialize();
146.system("pause");
147.return 0;
148.}

此部分代码与我们测试Apartment时的代码基本相同，只是新增了输出main和创建线程的ID的语句。好的，我们来运行程序，可以得到如下的结果：

 

我们可以看到main的线程ID和两个TestFunc1的线程ID相同。也就是说两个TestFunc1都是在main的线程中运行的。 

将我们的程序做些变动，将CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)改为 CoInitializeEx(NULL, COINIT_MULTITHREADED)。然后接着运行程序。我们再来看运行的结果。

 

我们可以看到两个TestFunc1的线程ID和main的不同了，和我们创建的线程也不同。这是为什么呢？CoInitializeEx是一个创建套间 的过程，我们使用CoInitializeEx(NULL, COINIT_MULTITHREADED)后，没有为我们的组件创建合适的套间。这时候系统（也就是COM API，这里应该是通过CoCreateInstance来实现的）就会帮我们将我们的接口对象放入缺省套间，该套间并不运行在当前的线程中。我们再次在 Debug下跟踪运行过程，可以发现在main中调用TestFunc1，也需要通过众多的API函数帮助完成，也就是说此处也是通过消息机制来完成的， 这样性能上肯定会有影响。

六、阻止接口指针的非法使用

在第二部分我们给出了一个通过直接传输接口指针到另外线程的例子，事实上这种方法是错误的，但COM API并没有帮助我们阻止这样的错误。这个任务可以由我们自己来完成。

因为套间是和线程相关的，Apartment类型的接口方法只应该运行在一个套间中（其实这就是一个协议，并不是强制性的），那么我们可以通过线程的相关性质来实现。

在线程中我们可以通过Thread Local Storage（TLS）来保存线程的相关信息，同一函数运行在不同的线程中，那么它所拥有的TLS也不相同。

我们来动手改造我们的类实现，将CTestferface1进行改造。

01.class ATL_NO_VTABLE CTestInterface1 :
02.public CComObjectRootEx,
03.public CComCoClass,
04.public IDispatchImpl
05.{
06.private:
07.DWORD dwTlsIndex;
08.public:
09.CTestInterface1()
10.{
11.dwTlsIndex = TlsAlloc();
12.HLOCAL l =  LocalAlloc(LMEM_FIXED, 1);
13.TlsSetValue(dwTlsIndex, l);　　 
14.}

我们先声明一个私有成员变量dwTlsIndex，它用来存放TLS的索引值（一个线程的TLS相当于一个数组，可以存放不同的数据）。再将构造函数中填 入保存数据的代码。此处只是简单的分配了一个字节的地址，并将该地址通过TlsSetValue保存到TLS中去。

然后再改造我们的TestFunc1函数。如下：

01.STDMETHODIMP CTestInterface1::TestFunc1()
02.{
03.// TODO: Add your implementation code here
04.LPVOID lpvData = TlsGetValue(dwTlsIndex);
05.if ( lpvData == NULL )
06.return RPC_E_WRONG_THREAD;
07. 
08.std::cout << "In the itestinferface1''s object, the thread''s id is " << ::GetCurrentThreadId() << std::endl;
09.return S_OK;
10.}

这边也很简单，就是简单的通过TlsGetValue去尝试得到dwTlsIndex所标志的内容是否存在。如果不存在，那么就说明程序运行在了不同的套 间中。就会返回RPC_E_WRONG_THREAD，这是COM设计者定义的宏，表示线程的非法使用。（由于我的懒惰，不再写新的COM了，只是简单的 修改了TestComObject1，这部分新加的代码被我注释掉了，你如果想看这部分的效果，去掉注释就可以了）

我们再运行ErrorUseApartment程序，发现TestFunc1已经无法输出线程号，而是直接返回RPC_E_WRONG_THREAD。再次运行ApartmentTest程序，发现这样的处理对它并没有影响。仍然正常运行。

六、什么是套间？

我们从外部表现上对套间进行了了解，而套间究竟是什么？潘爱民译的《Com 本质论》说：套间既不是进程，也不是线程，然而套间拥有进程和线程的某些特性。我觉得，这句话翻译的不到位，总让人感觉套间似乎是和进程或者线程等同的东 西。找来原文看看：An apartment is neither a process nor a thread; however, apartments share some of the properties of both。这里的share被译成了拥有，但我感觉此处翻译为使用或者分享可能更贴切一些。不过原文事实上也很容易给初学者带来误导。其实套间只是保存在 线程中的一个数据结构（还有一个隐藏着的窗口），借用该结构使套间和线程之间建立起某种关系，通过该关系，使得COM API通过该信息可以建立不同套间中的调用机制。这部分涉及到列集，散集（我们调用 CoMarshalInterThreadInterfaceInStream，CoGetInterfaceAndReleaseStream的过 程）。在列集和散集过程中，COM API会帮我们建立一个不同套间中对象通信机制，这部分涉及到了代理，存根和通道的内容。通过代理来发送调用信息，通过通道发送到存根，再通过存根调用实 际的方法（其实那个隐藏的窗口就是为存根来服务的）。所做的这一切不过是为了实现不同套间中可以通过消息来调用对象。你可以找《Com 本质论》来看看，这部分的内容比较繁杂，但我感觉比起套间的概念，还是比较容易的。

具体实现套间，在线程的TLS究竟保存了什么信息呢？罪恶的微软隐藏了这边部分内容，我们无法得到这部分的材料。这可能也是套间理解起来如此困难的一个原 因，套间呈现给我们的是一个抽象的概念。但理解其实际意义后，抽不抽象已经没什么关系，因为它所隐藏的不过是创建和使用套间时候繁杂的调用其它API函数 的过程，事实上并没有太多的神秘可言。对我们开发者来说，能明白套间的意义，已经足够了。

好了，稍微总结一下：套间是保存在线程的TLS中的一个数据结构，通过该结构可以帮助不同的套间之间通过消息机制来实现函数的调用，以保证多线程环境下，数据的同步。

结语

石康说：比尔.盖茨并不是什么天才，软件工作者充其量不过是一个技术工作者，无法和科学工作者同日而语。石康还说：如果给他老人家足够的时间，他也可以写 出一个操作系统。呵呵，大意好象如此，似乎是他老人家在《支离破碎》中的名言，现在记不太清楚了。刚开始觉得他老人家太狂了，不过仔细体会一下，确实如 此。计算机的世界很少有真正高深的东西，有些内容你不理解，肯定是你的某方面的基础不扎实。不理解接口，那是因为你的C++没学好；不理解套间，那是因为 你不懂多线程；不懂多线程那是因为你不懂CPU的结构。

技术革新在眼花缭乱的进行的，.Net，Web services，到处闪现着新鲜的名词，似乎这个世界每天都在变化的。但事实上，从286到386，从dos到图形操作系统后，计算机再没有什么重大的 革新。从我们开发者的角度来看，不过是开发工具的更新。但每次开发工具的更新都能使很多人兴奋异常，激动着下载安装最新版本的工具，追逐着学习最新的开发 语言。总觉的这样就不会被时代所抛弃，总以为开发工具会帮着提升自己的价值。事实上呢？学会拖拉创建窗口的人，可能根本不知道Windows中有一个消息 机制。开发十多年的人会把一个栈中生成的对象的地址作为参数传给接收者。没有学会走的时候，不要去跑。我自己也在迷茫中探索着自己的路，现在有点明白老子 所说的“企者不立，跨者不行”。

好了，废话就此打住吧！只是想告诉你，其实编程并没有那么困难，如果有什么东西没明白，别着急，找基础的东西去看。学好COM也一样，看不懂的话，先把C++中的虚函数学明白，再去了解一下多线程的内容。其实也没那么复杂！

有人说，COM过时了，我也不清楚COM的将来会怎么样，但我觉得理解一个东西总是有乐趣的。与你同勉。

posted on 2014-09-04 14:42  compilerTech  阅读(497)  评论(0)  编辑  收藏  举报