COM线程模型 - STA接口 - Part II -（跨线程传递对象，消息循环）

最新推荐文章于 2024-03-06 14:08:23 发布
最新推荐文章于 2024-03-06 14:08:23 发布
阅读量669 收藏 1
点赞数
分类专栏： COM 文章标签： Windows 7 COM

From : http://blog.csdn.net/zj510/article/details/38829069

 

前面一篇文章讲述了STA客户调用STA对象和MTA客户调用STA对象，其实并不难理解。

现在就来讲一下如何把一个COM对象传递到另外一个线程。

先来看看STA套间里面创建STA对象，并且传递到另外一个线程的情况。

STA客户创建STA对象，然后传递到另外一个线程

我们先改一下代码，这段代码很简单，只是修改上个文章里面的客户代码。其实就是主线程创建一个COM对象，然后传递到线程里面，起5个线程。

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. // TestCom.cpp : Defines the entry point for the console application. 
  2. // 
  3.  
  4. #include "stdafx.h" 
  5.  
  6. #include <atlbase.h> 
  7. #include <thread> 
  8. #include <vector> 
  9.  
  10. #include "../MyCom/MyCom_i.h" 
  11. #include "../MyCom/MyCom_i.c" 
  12.  
  13.  
  14. void Test(CComPtr<ICircle>& spCircle) 
  15. { 
  16.     WCHAR temp[100] = { 0 }; 
  17.     swprintf_s(temp, L"STA calling thread (used passed in com object): %d\n", ::GetCurrentThreadId()); 
  18.     OutputDebugStringW(temp); 
  19.  
  20.     CoInitialize(NULL); 
  21.  
  22.     spCircle->Draw(CComBSTR(L"yellow")); 
  23.  
  24.     CoUninitialize(); 
  25. } 
  26.  
  27. int _tmain(int argc, _TCHAR* argv[]) 
  28. { 
  29.     CoInitialize(NULL); 
  30.     WCHAR temp[100] = { 0 }; 
  31.     swprintf_s(temp, L"Main thread: %d\n", ::GetCurrentThreadId()); 
  32.     OutputDebugStringW(temp); 
  33.  
  34.     { 
  35.         CComPtr<ICircle> spCircle; 
  36.         spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC); 
  37.  
  38.         spCircle->Draw(CComBSTR(L"red")); 
  39.  
  40.         std::vector<std::thread> vThreads; 
  41.         for (int i = 0; i < 5; i++) 
  42.         { 
  43.             vThreads.push_back(std::thread(Test, spCircle)); 
  44.         } 
  45.  
  46.         for (auto& t: vThreads) 
  47.         { 
  48.             t.join(); 
  49.         } 
  50.     } 
  51.  
  52.  
  53.     CoUninitialize(); 
  54.  
  55.     return 0; 
  56. }  
// TestCom.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <atlbase.h>
#include <thread>
#include <vector>

#include "../MyCom/MyCom_i.h"
#include "../MyCom/MyCom_i.c"


void Test(CComPtr<ICircle>& spCircle)
{
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"STA calling thread (used passed in com object): %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	CoInitialize(NULL);

	spCircle->Draw(CComBSTR(L"yellow"));

	CoUninitialize();
}

int _tmain(int argc, _TCHAR* argv[])
{
	CoInitialize(NULL);
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"Main thread: %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	{
		CComPtr<ICircle> spCircle;
		spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC);

		spCircle->Draw(CComBSTR(L"red"));

		std::vector<std::thread> vThreads;
		for (int i = 0; i < 5; i++)
		{
			vThreads.push_back(std::thread(Test, spCircle));
		}

		for (auto& t: vThreads)
		{
			t.join();
		}
	}


	CoUninitialize();

	return 0;
}

运行了一下，得到：


好像每一次COM调用都是在客户线程里面。其实我也不知道为什么会这样，但是我觉得这是不对的，这样做的后果是不可预测的。而且根据STA的定义，STA对象应该是串行化的执行同一个对象的方法。为此，我又特地在COM函数里面sleep一下，如：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. STDMETHODIMP CCircle::Draw(BSTR color) 
  2. { 
  3.     // TODO: Add your implementation code here 
  4.     WCHAR temp[100] = { 0 }; 
  5.     swprintf_s(temp, L"ICircle::Draw, color: %s, tid: %d\n", color, ::GetCurrentThreadId()); 
  6.     OutputDebugStringW(temp); 
  7.  
  8.     std::this_thread::sleep_for(std::chrono::milliseconds(100)); 
  9.  
  10.     OutputDebugStringW(L"ICircle::Draw, end\n"); 
  11.     return S_OK; 
  12. }  
STDMETHODIMP CCircle::Draw(BSTR color)
{
	// TODO: Add your implementation code here
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"ICircle::Draw, color: %s, tid: %d\n", color, ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	std::this_thread::sleep_for(std::chrono::milliseconds(100));

	OutputDebugStringW(L"ICircle::Draw, end\n");
	return S_OK;
}

运行结果是：

好像是并发的，根本就不是串行的，这个根本不符合STA的定义啊。为什么？

其实我们这么调，根本就是错的。如果回顾一下前面的文章，里面有几条规则

1. STA对象只能存在于一个线程中；

2. 如果要跨线程传递COM对象的话，一定要做Marshal

3. 一个STA对象只接受来自创建它的STA线程的调用。

等等。

上面的做法在主线程创建了一个STA对象，然后直接把它传递了其他线程，这根本不符合STA接口的规则，不知道会发生什么事，而且调用也不是线性的。

那么正确的做法应该是怎么样的呢？

Marshal和Unmarshal

通常中文翻译成列集和散集，我还是习惯叫做Marshal和unmarshal。

好，我们现在不直接com指针给线程了，我们先marshal，然后在线程函数里面unmarsha，如：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. // TestCom.cpp : Defines the entry point for the console application. 
  2. // 
  3.  
  4. #include "stdafx.h" 
  5.  
  6. #include <atlbase.h> 
  7. #include <thread> 
  8. #include <vector> 
  9.  
  10. #include "../MyCom/MyCom_i.h" 
  11. #include "../MyCom/MyCom_i.c" 
  12.  
  13.  
  14. void Test(LPSTREAM pStream) 
  15. { 
  16.     WCHAR temp[100] = { 0 }; 
  17.     swprintf_s(temp, L"STA calling thread (used passed in com object): %d\n", ::GetCurrentThreadId()); 
  18.     OutputDebugStringW(temp); 
  19.  
  20.     CoInitialize(NULL); 
  21.  
  22.     CComPtr<ICircle> spCircle; 
  23.     HRESULT hr = CoGetInterfaceAndReleaseStream(pStream, IID_ICircle, (LPVOID*)&spCircle);  // unmarshal to get a com object 
  24.     if (SUCCEEDED(hr)) 
  25.     { 
  26.         spCircle->Draw(CComBSTR(L"yellow")); 
  27.     } 
  28.      
  29.  
  30.     CoUninitialize(); 
  31. } 
  32.  
  33. int _tmain(int argc, _TCHAR* argv[]) 
  34. { 
  35.     CoInitialize(NULL); 
  36.     WCHAR temp[100] = { 0 }; 
  37.     swprintf_s(temp, L"Main thread: %d\n", ::GetCurrentThreadId()); 
  38.     OutputDebugStringW(temp); 
  39.  
  40.     { 
  41.         CComPtr<ICircle> spCircle; 
  42.         spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC); 
  43.  
  44.         spCircle->Draw(CComBSTR(L"red")); 
  45.  
  46.         std::vector<std::thread> vThreads; 
  47.         for (int i = 0; i < 5; i++) 
  48.         { 
  49.             LPSTREAM pStream = nullptr; 
  50.             CoMarshalInterThreadInterfaceInStream(IID_ICircle, spCircle, &pStream);  // marshal 
  51.  
  52.             vThreads.push_back(std::thread(Test, pStream));  // pass a stream instead of com object 
  53.         } 
  54.  
  55.         for (auto& t: vThreads) 
  56.         { 
  57.             t.join(); 
  58.         } 
  59.     } 
  60.  
  61.  
  62.     CoUninitialize(); 
  63.  
  64.     return 0; 
  65. }  
// TestCom.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <atlbase.h>
#include <thread>
#include <vector>

#include "../MyCom/MyCom_i.h"
#include "../MyCom/MyCom_i.c"


void Test(LPSTREAM pStream)
{
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"STA calling thread (used passed in com object): %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	CoInitialize(NULL);

	CComPtr<ICircle> spCircle;
	HRESULT hr = CoGetInterfaceAndReleaseStream(pStream, IID_ICircle, (LPVOID*)&spCircle);  // unmarshal to get a com object
	if (SUCCEEDED(hr))
	{
		spCircle->Draw(CComBSTR(L"yellow"));
	}
	

	CoUninitialize();
}

int _tmain(int argc, _TCHAR* argv[])
{
	CoInitialize(NULL);
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"Main thread: %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	{
		CComPtr<ICircle> spCircle;
		spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC);

		spCircle->Draw(CComBSTR(L"red"));

		std::vector<std::thread> vThreads;
		for (int i = 0; i < 5; i++)
		{
			LPSTREAM pStream = nullptr;
			CoMarshalInterThreadInterfaceInStream(IID_ICircle, spCircle, &pStream);  // marshal

			vThreads.push_back(std::thread(Test, pStream));  // pass a stream instead of com object
		}

		for (auto& t: vThreads)
		{
			t.join();
		}
	}


	CoUninitialize();

	return 0;
}


就这么运行下，完蛋了，除了主线程的那个Draw调用成功，其他辅助线程里面的调用，Draw函数都出不来了。这又是为什么？

现在就该消息循环出场了。之前有讲过，如果COM对象不需要传递到其他线程的话，那么其实不需要消息循环，但是如果需要传递到其他线程的话，就一定要创建一个消息循环。

消息循环

这里讲的消息循环，其实就是Windows的消息循环。当其他线程调用COM对象的函数的时候（通过列集，散列），其实COM系统就是往创建COM对象的线程发送windows消息。因有关消息循环可以参考这篇文章里面的描述，相对到位。http://www.codeproject.com/Articles/9190/Understanding-The-COM-Single-Threaded-Apartment-Pa

我这里截取了一部分，但是我觉得大家有兴趣应该仔细阅读。

反正，STA对象的线性调用其实就是通过Windows的消息循环来实现的。

ok，现在我们来尝试给我们的主调STA客户加上消息循环。代码也很简单，直接贴：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. // TestCom.cpp : Defines the entry point for the console application. 
  2. // 
  3.  
  4. #include "stdafx.h" 
  5.  
  6. #include <atlbase.h> 
  7. #include <thread> 
  8. #include <vector> 
  9. #include <windows.h> 
  10.  
  11. #include "../MyCom/MyCom_i.h" 
  12. #include "../MyCom/MyCom_i.c" 
  13.  
  14. LRESULT CALLBACK WndProc_Notify(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam) 
  15. { 
  16.  
  17.     return DefWindowProc(hWnd, wMsg, wParam, lParam); 
  18. } 
  19.  
  20. void CreateWnd(void) 
  21. { 
  22.  
  23.     WNDCLASS wc = { 0 }; 
  24.     wc.style = 0; 
  25.     wc.lpfnWndProc = WndProc_Notify; 
  26.     wc.cbClsExtra = 0; 
  27.     wc.cbWndExtra = 0; 
  28.     //    wc.hInstance = g_hInstance; 
  29.     wc.hIcon = NULL; 
  30.     wc.hCursor = LoadCursor(NULL, IDC_ARROW); 
  31.     wc.hbrBackground = (HBRUSH)GetSysColorBrush(COLOR_WINDOW); 
  32.     wc.lpszMenuName = NULL; 
  33.     wc.lpszClassName = TEXT("NOTIFY_MSG_LOOP"); 
  34.  
  35.     RegisterClass(&wc); 
  36.  
  37.     HWND g_hNotifyMsgLoop = CreateWindowExW(0, 
  38.         wc.lpszClassName, 
  39.         wc.lpszClassName, 
  40.         WS_OVERLAPPEDWINDOW, 
  41.         0, 
  42.         0, 
  43.         200, 
  44.         200, 
  45.         NULL, 
  46.         NULL, 
  47.         NULL, 
  48.         0); 
  49.  
  50.     //  ShowWindow(g_hNotifyMsgLoop, SW_HIDE); 
  51. } 
  52.  
  53.  
  54. void Test(LPSTREAM pStream) 
  55. { 
  56.     CreateWnd(); 
  57.  
  58.     WCHAR temp[100] = { 0 }; 
  59.     swprintf_s(temp, L"STA calling thread (used passed in com object): %d\n", ::GetCurrentThreadId()); 
  60.     OutputDebugStringW(temp); 
  61.  
  62.     CoInitialize(NULL); 
  63.  
  64.     CComPtr<ICircle> spCircle; 
  65.     HRESULT hr = CoGetInterfaceAndReleaseStream(pStream, IID_ICircle, (LPVOID*)&spCircle);  // unmarshal to get a com object 
  66.     if (SUCCEEDED(hr)) 
  67.     { 
  68.         spCircle->Draw(CComBSTR(L"yellow")); 
  69.     } 
  70.      
  71.  
  72.     CoUninitialize(); 
  73. } 
  74.  
  75. int _tmain(int argc, _TCHAR* argv[]) 
  76. { 
  77.     CoInitialize(NULL); 
  78.     WCHAR temp[100] = { 0 }; 
  79.     swprintf_s(temp, L"Main thread: %d\n", ::GetCurrentThreadId()); 
  80.     OutputDebugStringW(temp); 
  81.  
  82.     { 
  83.         CComPtr<ICircle> spCircle; 
  84.         spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC); 
  85.  
  86.         spCircle->Draw(CComBSTR(L"red")); 
  87.  
  88.         std::vector<std::thread> vThreads; 
  89.         for (int i = 0; i < 5; i++) 
  90.         { 
  91.             LPSTREAM pStream = nullptr; 
  92.             CoMarshalInterThreadInterfaceInStream(IID_ICircle, spCircle, &pStream);  // marshal 
  93.  
  94.             vThreads.push_back(std::thread(Test, pStream));  // pass a stream instead of com object 
  95.         } 
  96.  
  97.         MSG msg; 
  98.         while (GetMessage(&msg, NULL, 0, 0)) 
  99.         { 
  100.             TranslateMessage(&msg); 
  101.             DispatchMessage(&msg); 
  102.         } 
  103.  
  104.         for (auto& t: vThreads) 
  105.         { 
  106.             t.join(); 
  107.         } 
  108.     } 
  109.  
  110.  
  111.     CoUninitialize(); 
  112.  
  113.     return 0; 
  114. }  
// TestCom.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <atlbase.h>
#include <thread>
#include <vector>
#include <windows.h>

#include "../MyCom/MyCom_i.h"
#include "../MyCom/MyCom_i.c"

LRESULT CALLBACK WndProc_Notify(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
{

	return DefWindowProc(hWnd, wMsg, wParam, lParam);
}

void CreateWnd(void)
{

	WNDCLASS wc = { 0 };
	wc.style = 0;
	wc.lpfnWndProc = WndProc_Notify;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	//    wc.hInstance = g_hInstance;
	wc.hIcon = NULL;
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)GetSysColorBrush(COLOR_WINDOW);
	wc.lpszMenuName = NULL;
	wc.lpszClassName = TEXT("NOTIFY_MSG_LOOP");

	RegisterClass(&wc);

	HWND g_hNotifyMsgLoop = CreateWindowExW(0,
		wc.lpszClassName,
		wc.lpszClassName,
		WS_OVERLAPPEDWINDOW,
		0,
		0,
		200,
		200,
		NULL,
		NULL,
		NULL,
		0);

	//	ShowWindow(g_hNotifyMsgLoop, SW_HIDE);
}


void Test(LPSTREAM pStream)
{
	CreateWnd();

	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"STA calling thread (used passed in com object): %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	CoInitialize(NULL);

	CComPtr<ICircle> spCircle;
	HRESULT hr = CoGetInterfaceAndReleaseStream(pStream, IID_ICircle, (LPVOID*)&spCircle);  // unmarshal to get a com object
	if (SUCCEEDED(hr))
	{
		spCircle->Draw(CComBSTR(L"yellow"));
	}
	

	CoUninitialize();
}

int _tmain(int argc, _TCHAR* argv[])
{
	CoInitialize(NULL);
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"Main thread: %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	{
		CComPtr<ICircle> spCircle;
		spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC);

		spCircle->Draw(CComBSTR(L"red"));

		std::vector<std::thread> vThreads;
		for (int i = 0; i < 5; i++)
		{
			LPSTREAM pStream = nullptr;
			CoMarshalInterThreadInterfaceInStream(IID_ICircle, spCircle, &pStream);  // marshal

			vThreads.push_back(std::thread(Test, pStream));  // pass a stream instead of com object
		}

		MSG msg;
		while (GetMessage(&msg, NULL, 0, 0))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}

		for (auto& t: vThreads)
		{
			t.join();
		}
	}


	CoUninitialize();

	return 0;
}

就这样，给创建STA对象的线程增加了一个消息循环。现在运行一下，发现：

这次，我们看到每个Draw函数都是串行运行的，draw函数里面的sleep()前后的2个log没有被打乱。而且运行线程都是1376，也就是创建STA对象的线程。这才符合STA要求。

现在我们知道了，如果想要把一个STA对象往另外一个线程传递，就需要：

1. 列集/散列， (marshal/unmarshal)

2. 创建STA对象的线程一定要有个windows消息循环。

至于第二点，看一下msdn上的描述把。反正大概的意思就是，COM系统发现有其他线程（套间）调用COM对象的方法，COM系统就会往创建COM对象的线程发送消息，但是如果那个线程没有消息循环来接收，那就永远都处理不了了。

处理消息循环的时候还有很多细节问题，这个可以查看其他资料。反正真正需要用到消息循环的时候再研究一下。

这里还有另外一种情况，就是MTA客户调用STA对象，然后又想把STA对象传递到其他线程，这又是什么情况呢？下次再研究了...

测试代码：http://download.csdn.net/detail/zj510/7818731

 

妖精的配角
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
COM组件技术多线程
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
04-18 1349
http://wenku.baidu.com/view/fa37624e767f5acfa1c7cd27.html
COM线程模型 - MTA接口 （传递MTA COM对象给STA套间线程）
zj510的专栏
08-28 2069
接上篇，能否把一个MTA套间里面创建的COM对象传递个STA套间
COM线程模型 - STA接口 （跨线程传递对象，消息循环）
zj510的专栏
08-25 3096
前面一篇文章讲述了STA客户调用STA对象和MTA客户调用STA对象。 其实并不难理解
COM线程模型 - STA接口
zj510的专栏
08-25 5447
COM里面的线程模型应该是COM里面比较困难的一部分了，我自己也是花了很多时间，而且也还不是很懂。最近
COM多线程原理与应用
Dean Chen的专栏
12-15 6773
COM多线程原理与应用 目录： COM多线程原理与应用... 1 目录：... 1 前言：... 1 套间：... 1 套间的定义：... 1 套间的分类：... 2 套间的进入和退出：.. 2 对象的同步：... 2 组件对象的同步：... 2 COM对象线程模型：.. 2 进程内对象线程模型的种类：.. 3 ATL对多线程的支持：.. 3 对象引用的保护：... 3...
COM 中的多线程
商少
11-12 1173
COM 线程模型 每一个用户界面线程都 有一个或多个窗口。线程将调用它所拥有的窗口的窗口过程。对于任一窗口, 它将被创 建它的线程所拥有。所以窗口过程总是在同一线程中被执行的, 而不论被处理的消息是 哪个线程发出的。这样做的结果是所有的消息被同步。窗口将可以保证它能按正确的顺 序获取各个消息。 这样, 程序员将用不着编写线程安全的窗口过程.   COM 线程 与Win32 中的用户界面线程...
STA客户跨线程调用STA对象
08-25
综上所述，"STA客户跨线程调用STA对象"涉及到COM编程中的线程模型、消息循环、跨线程通信机制以及同步原语的使用。通过`marshal`和消息循环，我们可以安全地在不同的线程或进程中调用STA对象，同时利用线程安全的...
MTA客户跨线程调用STA对象
08-26
4. **unmarshaling（解封送处理）**：在STA线程中，接收到消息后，需要使用`CoGetInterfaceAndReleaseStream`函数从流中解封送接口指针，以便在当前线程（即STA线程）中安全地使用COM对象。 5. **调用STA对象的方法...
COM线程模型详解
weiweixiaopasta的专栏
04-07 2588
http://blog.chinaunix.net/uid-24862988-id-3799415.html         线程模型是一种数学模型，专门针对多线程编程而提供的算法，但也仅是算法，不是实现。本文讲解COM提出的各个类型的线程模型，再说明COM运行时期库是如何实现它们的，就像说明Windows是如何实现线程这个数学模型的一样，最后指明一下跨套间调用和各种
atl开发指南(第二版)一共四个压缩包之（二）
10-29
atl开发指南(第二版)一共四个压缩包之（二）
COM线程模型-套间
crybird的C/C++
10-11 3948
    Normal 0 7.8 磅 0 2 false false false EN-US ZH-CN X-NONE
C#中的线程以及[STAThread]、COM（Component Object Model）
最新发布
wanganqiqi的博客
03-06 1476
C#中的线程以及[STAThread]、COM（Component Object Model）
多线程共享COM组件的问题
不亦快斋
12-28 2285
某个线程创建的COM对象，并不能简单的把接口指针传递给别的线程使用。必须先CoMarshalInterThreadInterfaceInStream整编，然后再CoGetInterfaceAndReleaseStream解编。问题来源：今天在一个ADO程序中遇到此问题。在主线程创建了10个数据库连接的连接池。然后一个tcp服务为每个连接创建新线程，新线程从连接池申请一个连接，从数据库获取信息然后返
COM第四部分（高级特性：重用性、跨进程性、多线程模型）
KingOfMyHeart的博客
04-20 689
面向对象思想在COM组件中的体现； 1.封装：用户如果想访问对象内部属性，必须通过对象暴漏在外的接口； 2.多态：体现在成员函数、单个接口和一组接口三个层次上； 3.继承：COM重用性是建立在二进制一级。具体包括包容和聚合两种重用模型。 高级特性一：包容和聚合 包容和聚合都是COM组件体现重用性的两种形式； 1.包容： 外部组件程序包含内部组件程序，客户通过外部组件的接口间接的使用内部组件程序的功...
COM编程攻略（七 COM跨进程组件开发实战）
heusunduo88的博客
03-15 1074
COM编程攻略（七 COM跨进程组件开发实战）
关于跨线程操作的心得
u014430031的博客
08-25 1585
背景：创建线程是为了把任务量大的事情交给线程去做，防止因为主线程（GUI线程）执行逻辑代码产生卡顿造成用户体验不好的现象。这样子就会涉及主线程和子线程的通信问题。子线程包括了逻辑子线程和GUI子线程，一般来说因为GUI子线程有自己的触发事件，跟主线程交互的情况比较少，所以就不讨论了，这里就单单说下逻辑子线程。一般子线程要传递数据或者调用主线程的函数，都会使用信号SIGNAL。 在子线程对象被创造出
COM组件中在工作线程中产生事件的解决方法。
seman的专栏
12-03 787
http://www.mvps.org/vcfaq/com/1.htmhttp://www.mvps.org/vcfaq/com/1.htm
COM组件间调用的性能问题
Neo的专栏
06-08 1677
多线程编程是大家都比较头疼的问题，不小心就会碰到死锁，野指针，同步调用问题等等，虽然在客户端编程方面会带来不少好的体验，比如界面和处理在不同的线程，则不会卡住界面，但是相对于他的副作用来说，让不少人还是望而却步。 　　QQ 客户端就是这样一个例子，从QQ重构的3个大版本来说，也一直在回避这个问题。Hummer在设计的时候为了防止编程的复杂性和后期的难以维护，也主动放弃了多线程特性（部分底层，
COM线程模型与STA套间详解
其中，单一线程公寓（STA）是每个STA套间只包含一个线程的模型，这种模型适用于那些需要同步和消息分发的组件。在STA中，当一个线程被创建后，通过调用`CoInitialize(NULL)`或`CoInitializeEx(NULL, COINIT_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值