COM线程模型 - STA - Part I

最新推荐文章于 2024-01-29 19:19:41 发布
最新推荐文章于 2024-01-29 19:19:41 发布
阅读量843 收藏 1
点赞数
分类专栏： COM 文章标签： Windows 7 COM

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

 

COM里面的线程模型应该是COM里面比较困难的一部分了，我自己也是花了很多时间，而且也还不是很懂。最近又重新看了一下线程模型，为了加深自己的学习，特地写下这篇文章。

MSDN上有很多信息，比如

http://msdn.microsoft.com/en-us/library/windows/desktop/ms680112(v=vs.85).aspx

这里面就有很多关于STA的信息。建议仔细阅读，特别是新手。

STA规则

这里罗列几条重要的规则：

[plain] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. Rules for single-threaded apartments are simple, but it is important to follow them carefully:  
  2. • Every object should live on only one thread (within a single-threaded apartment).  
  3. • Initialize the COM library for each thread.  
  4. • Marshal all pointers to objects when passing them between apartments.  
  5. • Each single-threaded apartment must have a message loop to handle calls from other processes and apartments within the same process. Single-threaded apartments without objects (client only) also need a message loop to dispatch the broadcast messages that some applications use.  
  6. • DLL-based or in-process objects do not call the COM initialization functions; instead, they register their threading model with the ThreadingModel named-value under the InprocServer32 key in the registry. Apartment-aware objects must also write DLL entry points carefully. There are special considerations that apply to threading in-process servers. For more information, see In-Process Server Threading Issues.   
Rules for single-threaded apartments are simple, but it is important to follow them carefully: 
• Every object should live on only one thread (within a single-threaded apartment). 
• Initialize the COM library for each thread. 
• Marshal all pointers to objects when passing them between apartments. 
• Each single-threaded apartment must have a message loop to handle calls from other processes and apartments within the same process. Single-threaded apartments without objects (client only) also need a message loop to dispatch the broadcast messages that some applications use. 
• DLL-based or in-process objects do not call the COM initialization functions; instead, they register their threading model with the ThreadingModel named-value under the InprocServer32 key in the registry. Apartment-aware objects must also write DLL entry points carefully. There are special considerations that apply to threading in-process servers. For more information, see In-Process Server Threading Issues.

简单翻译一下：

[plain] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. STA的规则很简单，但是需要小心的遵守这些规则：  
  2. • 每一个STA COM 对象只能存在于一个线程中 （在一个STA套间内） 
  3. • 每一个线程都需要初始化COM库 
  4. • 在套间之间传递com对象指针的时候，需要列集(marshal) 
  5. • 每一个STA套间必须拥有一个消息循环，用来处理从其他进程或者当前进程的其他套间过来的消息。（后面一句没有理解，就不翻译了，以免误导。）其实，我个人感觉如果一个STA套间创建了一个COM对象，只要这个COM对象不传递到其他线程，消息循环是可以省略的。但是如果COM对象需要传递到其他进程，那么就必须创建一个消息循环。 
  6. • COM对象本身并不需要调用COM的初始化函数；相反，他们会把他们的线程模型放在注册表中的一个叫做InprocServer32的键下面。后面的也不是很了解。以后弄明白了再说。  
STA的规则很简单，但是需要小心的遵守这些规则： 
• 每一个STA COM 对象只能存在于一个线程中 （在一个STA套间内）
• 每一个线程都需要初始化COM库
• 在套间之间传递com对象指针的时候，需要列集(marshal)
• 每一个STA套间必须拥有一个消息循环，用来处理从其他进程或者当前进程的其他套间过来的消息。（后面一句没有理解，就不翻译了，以免误导。）其实，我个人感觉如果一个STA套间创建了一个COM对象，只要这个COM对象不传递到其他线程，消息循环是可以省略的。但是如果COM对象需要传递到其他进程，那么就必须创建一个消息循环。
• COM对象本身并不需要调用COM的初始化函数；相反，他们会把他们的线程模型放在注册表中的一个叫做InprocServer32的键下面。后面的也不是很了解。以后弄明白了再说。

还是用几个例子来说明吧。

简单的STA COM组件

先来创建一个VS solution，很简单，里面有2个工程，一个是console，一个是ATL工程。看上去就像：

然后给MyCom增加一个接口，其实就是用ATL向导来做的，很简单，但是还是截一些图吧，这样更加形象。

图1

图2

图3

注意图3中，我们选择了Apartment类型，也就是STA.搜索一下注册表，会发现注册表中有一项来表示COM的线程模型，这个应该就是上面的规则5所说的吧。


到这里，我们就增加了一个ICircle接口了。这是个空接口，给它增加一个函数吧。还是傻瓜式的用ATL向导。

第一步

第二步：

增加了一个很简单的函数，写几行代码吧，很简单，打一个log：

[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.  
  9.     return S_OK; 
  10. }  
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);


	return S_OK;
}


在测试程序里面，写几行代码，直接贴出来了，因为真的非常简单：

[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.  
  8. #include "../MyCom/MyCom_i.h" 
  9. #include "../MyCom/MyCom_i.c" 
  10.  
  11. void Test1() 
  12. { 
  13.     WCHAR temp[100] = { 0 }; 
  14.     swprintf_s(temp, L"calling thread: %d\n", ::GetCurrentThreadId()); 
  15.     OutputDebugStringW(temp); 
  16.  
  17.     CoInitialize(NULL); 
  18.  
  19.     { 
  20.         CComPtr<ICircle> spCircle; 
  21.         if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC))) 
  22.         { 
  23.             spCircle->Draw(CComBSTR(L"red")); 
  24.         } 
  25.     } 
  26.  
  27.  
  28.     CoUninitialize(); 
  29. } 
  30.  
  31. int _tmain(int argc, _TCHAR* argv[]) 
  32. { 
  33.     Test1(); 
  34.  
  35.     return 0; 
  36. }  
// TestCom.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <atlbase.h>

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

void Test1()
{
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"calling thread: %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	CoInitialize(NULL);

	{
		CComPtr<ICircle> spCircle;
		if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC)))
		{
			spCircle->Draw(CComBSTR(L"red"));
		}
	}


	CoUninitialize();
}

int _tmain(int argc, _TCHAR* argv[])
{
	Test1();

	return 0;
}


运行一下，我们可以得到这个结果：

OK, 到这里为止，我们就简单写了个COM组件，COM组件里有一个接口叫做ICircle,这个接口里面有个方法叫做Draw。然后在测试程序（console程序）里面调用了一下，得到上面的结果：

1. 调用线程用CoInitialize()初始化

2. 调用线程的号码是2872

3. COM组件的Draw函数里面也打印了线程号，也是2872.

在上面的代码里面，我们可以说是：

1. 我们创建了一个STA的COM组件

2. 我们创建了一个STA的调用环境。

通常我们提交COM的线程模型，其实指的是两方面：一个是客户程序的线程模式，一个是组件所支持的线程模式。客户程序的线程模式只有两种，单线程公寓(STA)和多线程公寓(MTA)。组件所支持的线程模式有四种：Single(单线程)、Apartment(STA)、Free(MTA)、Both(STA+MTA)。

注意，公寓和套间是同一个概念，这只是翻译而已，都是指apartment。

那么我们现在可以说，上面的例子是STA的客户程序调用STA COM组件。

STA客户程序调用STA COM组件

现在来分析一下这种情况的方方面面。首先我要推荐一篇文章，相当nice：http://www.codeproject.com/Articles/9190/Understanding-The-COM-Single-Threaded-Apartment-Pa

建议一个字一个字的读。在这篇文章里面提到了2点：

  1. An STA object created inside an STA thread will reside in the same STA as its thread.
  2. All objects inside an STA will receive method calls only from the thread of the STA.

很简单，意思是说如果一个STA线程创建了一个STA对象，那么这个对象就存在于当前这个创建它的线程里面。第二点是说一个STA套间里面所有的对象都只接收来自这个套间里面线程的方法调用。

用个图来表示就大概是这个样子：

一个进程里面可以有多个STA套间，每个STA套间里面可以有多个STA对象。

如果一个客户程序创建了一个STA套间，然后在这个套间里面调用STA对象，这是最简单的一种情况。这种情况下：

1. 客户程序直接调用STA对象；

2. STA COM对象运行在客户程序创建的STA套间的线程里面；

3. 像上面的例子，我们创建的STA COM对象并不会传递到其他线程，那么也就不需要消息循环了。（看上面的代码，根本没有消息循环）

OK, 我们再来看看另外一种情况，MTA客户程序来调用STA COM 对象。

MTA客户程序调用STA COM组件

稍微改一下客户程序，很是简单，就是把刚才的CoInitialize(NULL)改成了CoInitializeEx(NULL, COINIT_MULTITHREADED),代码如下,就是新增了Test2()函数。

[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.  
  8. #include "../MyCom/MyCom_i.h" 
  9. #include "../MyCom/MyCom_i.c" 
  10.  
  11. void Test1() 
  12. { 
  13.     WCHAR temp[100] = { 0 }; 
  14.     swprintf_s(temp, L"STA calling thread: %d\n", ::GetCurrentThreadId()); 
  15.     OutputDebugStringW(temp); 
  16.  
  17.     CoInitialize(NULL); 
  18.  
  19.     { 
  20.         CComPtr<ICircle> spCircle; 
  21.         if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC))) 
  22.         { 
  23.             spCircle->Draw(CComBSTR(L"red")); 
  24.         } 
  25.     } 
  26.  
  27.  
  28.     CoUninitialize(); 
  29. } 
  30.  
  31. void Test2() 
  32. { 
  33.     WCHAR temp[100] = { 0 }; 
  34.     swprintf_s(temp, L"MTA calling thread: %d\n", ::GetCurrentThreadId()); 
  35.     OutputDebugStringW(temp); 
  36.  
  37.     CoInitializeEx(NULL, COINIT_MULTITHREADED); 
  38.  
  39.     { 
  40.         CComPtr<ICircle> spCircle; 
  41.         if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC))) 
  42.         { 
  43.             spCircle->Draw(CComBSTR(L"green")); 
  44.         } 
  45.     } 
  46.  
  47.  
  48.     CoUninitialize(); 
  49. } 
  50.  
  51. int _tmain(int argc, _TCHAR* argv[]) 
  52. { 
  53.     Test1(); 
  54.  
  55.     Test2(); 
  56.  
  57.     return 0; 
  58. }  
// TestCom.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <atlbase.h>

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

void Test1()
{
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"STA calling thread: %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	CoInitialize(NULL);

	{
		CComPtr<ICircle> spCircle;
		if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC)))
		{
			spCircle->Draw(CComBSTR(L"red"));
		}
	}


	CoUninitialize();
}

void Test2()
{
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"MTA calling thread: %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	CoInitializeEx(NULL, COINIT_MULTITHREADED);

	{
		CComPtr<ICircle> spCircle;
		if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC)))
		{
			spCircle->Draw(CComBSTR(L"green"));
		}
	}


	CoUninitialize();
}

int _tmain(int argc, _TCHAR* argv[])
{
	Test1();

	Test2();

	return 0;
}

跑一下，看到：


这次我们看到调用线程和COM运行线程不是同一个，这是为什么？

刚才推荐的文章里面讲的很清楚：All STA objects in a process which are created inside non-STA threads will reside in the default STA.

Default STA:秘密就在这里了，当客户程序创建一个STA COM对象的时候，系统发现当前套间并不是STA(因为我们使用了CoInitializeEx(NULL, COINIT_MULTITHREADED);来创建的，这是MTA套间。这样，系统就会创建一个Default STA来运行STA对象。这个过程无需程序员关心。

这段话很重要：Developers new to the world of COM Apartments please note well this intriguing phenomenon: that even though a call toCreateInstance() orCoCreateInstance() is made inside a thread, the resulting object can actually be instantiated in another thread. This is performed transparently by COM behind the scenes. Please therefore take note of this kind of subtle maneuvering by COM especially during debugging.

大致意思是说：

刚刚接触COM套间的程序员需要注意这一点：在一个线程里面调用CreateInstance或者CoCreateInstance()创建了一个对象，但是有可能这个对象是在另外一个线程里面被实例化。这个过程是COM系统做的。请在debug的时候注意这一点。

其实这个过程可以用下面的图来说明。

需要重点记住的是：这种情况下，CoCreateInstance返回的并不是真正对象的指针，而是一个代理，proxy。

ok，现在我们知道了为什么COM对象运行线程和客户程序的线程不是同一个。原因很简单，就是因为STA COM对象是在一个default sta里面运行。MTA 客户是不可以直接运行STA COM 对象的。

稍微修改一下代码，再来确定一下这个问题，我们把代码改成如下，其实很简单就是起5个线程来调用Test2().

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. int _tmain(int argc, _TCHAR* argv[]) 
  2. { 
  3.     Test1(); 
  4.  
  5.     std::thread t1(Test2); 
  6.     std::thread t2(Test2); 
  7.     std::thread t3(Test2); 
  8.     std::thread t4(Test2); 
  9.     std::thread t5(Test2); 
  10.  
  11.     t1.join(); 
  12.     t2.join(); 
  13.     t3.join(); 
  14.     t4.join(); 
  15.     t5.join(); 
  16.  
  17.     return 0; 
  18. }  
int _tmain(int argc, _TCHAR* argv[])
{
	Test1();

	std::thread t1(Test2);
	std::thread t2(Test2);
	std::thread t3(Test2);
	std::thread t4(Test2);
	std::thread t5(Test2);

	t1.join();
	t2.join();
	t3.join();
	t4.join();
	t5.join();

	return 0;
}

运行结果：看的很清楚，COM对象是在同一个线程里面运行的。也就是COM系统创建的default STA。


MTA客户调用STA对象也讲完了。有个问题，那么如果是不同的COM 接口，又如何？事实胜于雄辩，测试一下就好了。新增一个接口IMyRect，同样增加一个函数Draw。

客户端程序改成这样：

[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.  
  9. #include "../MyCom/MyCom_i.h" 
  10. #include "../MyCom/MyCom_i.c" 
  11.  
  12. void Test1() 
  13. { 
  14.     WCHAR temp[100] = { 0 }; 
  15.     swprintf_s(temp, L"STA calling thread: %d\n", ::GetCurrentThreadId()); 
  16.     OutputDebugStringW(temp); 
  17.  
  18.     CoInitialize(NULL); 
  19.  
  20.     { 
  21.         CComPtr<ICircle> spCircle; 
  22.         if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC))) 
  23.         { 
  24.             spCircle->Draw(CComBSTR(L"red")); 
  25.         } 
  26.     } 
  27.  
  28.  
  29.     CoUninitialize(); 
  30. } 
  31.  
  32. void Test2() 
  33. { 
  34.     WCHAR temp[100] = { 0 }; 
  35.     swprintf_s(temp, L"MTA calling thread: %d\n", ::GetCurrentThreadId()); 
  36.     OutputDebugStringW(temp); 
  37.  
  38.     CoInitializeEx(NULL, COINIT_MULTITHREADED); 
  39.  
  40.     { 
  41.         CComPtr<ICircle> spCircle; 
  42.         if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC))) 
  43.         { 
  44.             spCircle->Draw(CComBSTR(L"green")); 
  45.         } 
  46.     } 
  47.  
  48.  
  49.     CoUninitialize(); 
  50. } 
  51.  
  52. void Test3() 
  53. { 
  54.     WCHAR temp[100] = { 0 }; 
  55.     swprintf_s(temp, L"MTA calling thread (rect): %d\n", ::GetCurrentThreadId()); 
  56.     OutputDebugStringW(temp); 
  57.  
  58.     CoInitializeEx(NULL, COINIT_MULTITHREADED); 
  59.  
  60.     { 
  61.         CComPtr<IMyRect> spRect; 
  62.         if (SUCCEEDED(spRect.CoCreateInstance(CLSID_MyRect, NULL, CLSCTX_INPROC))) 
  63.         { 
  64.             spRect->Draw(CComBSTR(L"blue")); 
  65.         } 
  66.     } 
  67.  
  68.  
  69.     CoUninitialize(); 
  70. } 
  71. int _tmain(int argc, _TCHAR* argv[]) 
  72. { 
  73.     Test1(); 
  74.  
  75.     std::thread t1(Test2); 
  76.     std::thread t2(Test2); 
  77.     std::thread t3(Test2); 
  78.     std::thread t4(Test3); 
  79.     std::thread t5(Test3); 
  80.  
  81.     t1.join(); 
  82.     t2.join(); 
  83.     t3.join(); 
  84.     t4.join(); 
  85.     t5.join(); 
  86.  
  87.     return 0; 
  88. }  
// TestCom.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

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

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

void Test1()
{
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"STA calling thread: %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	CoInitialize(NULL);

	{
		CComPtr<ICircle> spCircle;
		if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC)))
		{
			spCircle->Draw(CComBSTR(L"red"));
		}
	}


	CoUninitialize();
}

void Test2()
{
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"MTA calling thread: %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	CoInitializeEx(NULL, COINIT_MULTITHREADED);

	{
		CComPtr<ICircle> spCircle;
		if (SUCCEEDED(spCircle.CoCreateInstance(CLSID_Circle, NULL, CLSCTX_INPROC)))
		{
			spCircle->Draw(CComBSTR(L"green"));
		}
	}


	CoUninitialize();
}

void Test3()
{
	WCHAR temp[100] = { 0 };
	swprintf_s(temp, L"MTA calling thread (rect): %d\n", ::GetCurrentThreadId());
	OutputDebugStringW(temp);

	CoInitializeEx(NULL, COINIT_MULTITHREADED);

	{
		CComPtr<IMyRect> spRect;
		if (SUCCEEDED(spRect.CoCreateInstance(CLSID_MyRect, NULL, CLSCTX_INPROC)))
		{
			spRect->Draw(CComBSTR(L"blue"));
		}
	}


	CoUninitialize();
}
int _tmain(int argc, _TCHAR* argv[])
{
	Test1();

	std::thread t1(Test2);
	std::thread t2(Test2);
	std::thread t3(Test2);
	std::thread t4(Test3);
	std::thread t5(Test3);

	t1.join();
	t2.join();
	t3.join();
	t4.join();
	t5.join();

	return 0;
}

结果如下：


实际上，刚才推荐的文章里面有一句话：All STA objects in a process which are created inside non-STA threads will reside in the default STA.


总结

STA客户调用STA COM组件

1. STA对象在客户创建的STA套间线程里面运行；

2. STA客户直接调用STA COM对象指针；

MTA客户调用STA COM组件

1. STA对象在default STA里面运行，如果有多个STA对象，它们统统在同一个default sta线程里面运行。

2. MTA客户调用STA COM对象的代理。

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

我们接下来就讲讲COM对象的跨线程传递和消息循环。

妖精的配角
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程sta模式_C# [STAThread] 单一线程单元模式的含义
weixin_36070998的博客
12-30 1331
[STAThread]STAThread：Single Thread Apartment Thread(单一线程单元线程)，是一种线程模型，用在程序的入口方法上(在C#和VB.NET里是Main()方法)，用来指定当前线程的ApartmentState是STA。用在其他方法上不产生影响。在aspx页面上可以使用AspCompat = "true" 来达到同样的效果。这个属性只在Com Intero...
COM线程模型 - STA接口
zj510的专栏
08-25 5416
COM里面的线程模型应该是COM里面比较困难的一部分了，我自己也是花了很多时间，而且也还不是很懂。最近
STA和MTA线程模式的区别
04-02 304
任何一个WPF程序，Main方法前必须有一个[STAThread]特性，否则编译会失败。这个特性用来申明该应用程序的初始线程模型为STA，以便和COM兼容。STA是.NET之前，旧的COM年代的词汇。 STA: Single-Thread Apartment， 中文叫单线程套间。就是在COM库初始化的时候创建一个内存结构，然后让它和调用CoInitialize的线程相关联。这个内存结构...
套件与COM线程模型(Threading mode)
山穷水尽疑无路，柳暗花明又一村！
02-06 1297
更详细的说明： http://www.codeguru.com/cpp/com-tech/activex/apts/     套件和COM线程模型是进行COM编程时，需要了解的概念。这个概念直接关系到，我们的COM库的运行性能。如果COM库提供的接口都是简单的函数，不涉及到较大的延迟，如数据库操作，网络操作，那么你确实可以不深入了解它。COM库有一个设计目标，提供自动的线程同步功能，也就是客户
3.8、重新理解线程转换状态
u011569827的博客
03-06 209
假设有线程 Thread t 情况1 NEW–>RUNNABLE 当调用t.start()方法时，由 NEW --> RUNNABLE 情况2 RUNNABLE <–> WAITING t线程用synchronized(obj)获取了对象锁后 调用obj.wait() 方法时，t线程从RUNNABLE --> WAITING 调用obj.notify()，obj.notifyAll()， t.interrupt()时 竞争锁成功，t线程从WAITING --> .
broadcom-sta-dkms.zip
最新发布
04-24
sudo dpkg -i broadcom-sta-dkms_*.deb ``` 但需要注意的是，安装之前需要确保系统已经安装了DKMS工具，并且在安装过程中可能会遇到依赖关系的问题，可能需要通过`apt`或`apt-get`来解决。 总的来说，这个压缩包...
MT7601U-ap-sta.rar
08-06
mt7601U-ap/sta驱动源码，AP与STA都有,移植方法参考：https://blog.csdn.net/diandianyangyi/article/details/39202255?utm_source=blogxgwz6
esp-idf-wifi-apsta：带有esp-idf的WIFI_MODE_APSTA示例
02-12
esp-idf-wifi-apsta 带有esp-idf的WIFI_MODE_APSTA示例。 esp-idf包含站点模式（WIFI_MODE_STA）和软ap模式（WIFI_MODE_AP）中的示例，但没有apsta模式（WIFI_MODE_APSTA）中的示例。 我提到。 ESP32芯片具有...
STA客户跨线程调用STA对象
08-25
STA（Single Threaded Apartment）是COM线程模型的一种，其中每个线程都维护一个单独的消息队列，确保线程中的所有COM对象在同一时间只能被一个线程访问，以保持线程安全。 当我们需要一个运行在STA线程中的COM对象...
SDP.rar_SDP-TCP sta_rtsp_sdp
09-23
标签“sdp-tcp_sta”可能指的是SDP中使用TCP作为传输协议的场景，而“rtsp”则与RTSP协议相关。在多媒体通信中，SDP常常与TCP和RTSP一起工作，为多媒体数据的传输和控制提供完整解决方案。 在SDP文档中，我们通常会...
记录应急踩过的坑
weixin_46622976的博客
02-23 3927
Linux应急响应中，我们遇到有ia锁的，通过chattr可能修改不了，原因是crontan 实时写入导致停不了，加/解不了锁，这时候我们要用kill -STOP停掉进程，而不是kill -9。 扩展知识： 爆破应急 1、统计了下日志，确认服务器遭受暴力破解 grep -o "Failed password" /var/log/secure|uniq -c 2、输出登录爆破的第一行和最后一行，确认爆破时间范围： grep "Failed password" /var/log/secure|hea
C# 报错：System.InvalidOperationException:调用线程必须为STA，因为许多UI组件都需要
qq_35320456的博客
01-29 2088
C# 报错：System.InvalidOperationException:调用线程必须为STA，因为许多UI组件都需要
你注意到COM编程中“STA 单线程套间”的重入问题了吗?
pimshell的专栏
08-28 986
在COM编程中，COM线程模型的选择是避免不了的。网上已有大量介绍“COM线程模型”的文章，在这里我只想说“STA 单线程套间”并不像想象中的那么简单，在实际的开发中会出现“重入问题”。“STA 单线程套间”，指的是一个线程只能建立一个套间，在线程中创建的COM对象只属于这个套间，其他线程对此线程中COM对象的调用都必须通过代理对象串行调用。这样，“STA 单线程套间”轻松解决了多线程之间的“
如何调高COM+中STA对象线程池的大小
软件开发资料汇总
01-03 390
微软的设计使然，STA线程模型组件在COM+中，每个CPU支持最多10个实例。 首先，这一切定义描述在http://support.microsoft.com/default.aspx?scid=kb;EN-US;282490中，节选如下：Thread Pool in COM+In COM+, each server application maintains two separate threa
WPF开发dll时，关于STA线程问题的总结（文章过期，请看另一篇！！）
weixin_37591131的博客
07-20 1135
问题起因：调用线程必须为STA,因为许多UI组件都需要 查找资料： 方案1： Thread t = new Thread(new ThreadStart(delegate{ ///do something })); t.SetApartmentState(ApartmentState.STA); t.IsBackground = true; 方案2：window.Dispatcher.Invoke(new Action(delegate{ })...
COM线程模型 - STA接口 （跨线程传递对象，消息循环）
zj510的专栏
08-25 3070
前面一篇文章讲述了STA客户调用STA对象和MTA客户调用STA对象。 其实并不难理解
COM线程模型 - COM服务端（STA组件）创建线程
zj510的专栏
09-15 1857
当我们在COM组件内部创建线程的时候，又是怎么样的一种情况呢? 这里，我们需要分
线程sta模式_如何使代理线程STA
weixin_42134537的博客
01-16 157
I have see some discussion around this topic and concluded that it is not possible. I should use Threads, make it STA and when I need result back, join main thread with the created thread. This can wo...
什么是单线程单元（STA）什么是多线程单元（MTA）
顺其自然~专栏
12-20 2792
最近在解决问题的时候不得不使用线程，从而接触到了STA和MTA，度娘给的解释大多语焉不详。在WikiPedia上面看到了比较清楚的描述，趁着能访问的间隙麻利的摘抄下来分享和自我提升。 单元类型 描述 单线程单元(STA), (ThreadingModel=Apartment) 只用单个线程执行对象的方法。在这样的安排中，来自单元外线程的方法调用被系统编组并自动排队（通过标准的 Windows 消息队列）。因此，COM 运行时提供自动同步以确保对象的每个方法调用始终在调用另一个...
AP-STA-DISCONNECTED
03-28
However, AP-STA-DISCONNECTED typically refers to a message that is displayed when a wireless client (STA) disconnects from an access point (AP). This message can be seen in the logs of networking ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值