<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
		>
<channel>
	<title>Comments on: windows的消息队列与消息循环#1</title>
	<atom:link href="http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/feed/" rel="self" type="application/rss+xml" />
	<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/</link>
	<description>learn, think, share, communication</description>
	<lastBuildDate>Sat, 26 Nov 2011 03:23:20 +0000</lastBuildDate>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3.1</generator>
	<item>
		<title>By: yunkezou@163.com</title>
		<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/comment-page-1/#comment-482</link>
		<dc:creator>yunkezou@163.com</dc:creator>
		<pubDate>Sun, 03 Apr 2011 18:04:12 +0000</pubDate>
		<guid isPermaLink="false">http://www.windameister.org/blog/2010/03/27/windows%e7%9a%84%e6%b6%88%e6%81%af%e9%98%9f%e5%88%97%e4%b8%8e%e6%b6%88%e6%81%af%e5%be%aa%e7%8e%af/#comment-482</guid>
		<description>谢谢您写的文章．谢谢!!!</description>
		<content:encoded><![CDATA[<p>谢谢您写的文章．谢谢!!!</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: windam</title>
		<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/comment-page-1/#comment-135</link>
		<dc:creator>windam</dc:creator>
		<pubDate>Sun, 09 Jan 2011 11:31:30 +0000</pubDate>
		<guid isPermaLink="false">http://www.windameister.org/blog/2010/03/27/windows%e7%9a%84%e6%b6%88%e6%81%af%e9%98%9f%e5%88%97%e4%b8%8e%e6%b6%88%e6%81%af%e5%be%aa%e7%8e%af/#comment-135</guid>
		<description>&lt;blockquote&gt;
&lt;a href=&quot;#comment-42&quot; rel=&quot;nofollow&quot;&gt;
&lt;strong&gt;&lt;em&gt;redcoder:&lt;/em&gt;&lt;/strong&gt;
&lt;/a&gt;
 &lt;p&gt;写得很不错。一直以来我总不太清楚模态对话框的消息循环机制。甚至以为模态对话框是通过一个单独的线程，然后通过某些内核对象来实现的同步效果的。现在你的文章让我解除了这个疑虑。至于你说的消息队列和线程的关系，推荐看下《windows核心编程》最后一章。我想你的推论是正确的，线程启动初期是没有队列的，windows由于消息驱动的特性对其做了一个扩展，就是加上消息队列。同时可能出于效率或者其他方面的原因，只有在需要的时候他才为你实例化一个队列，这就解释了为什么PeekMessage（）之后，就有了队列的原因。&lt;/p&gt;
&lt;/blockquote&gt;

很感谢您的提醒，读完了《Windows核心编程》关于窗口消息和输入模型两章之后我的疑惑也解开了，此文中的相关内容稍后会重新整理 :)</description>
		<content:encoded><![CDATA[<blockquote><p>
<a href="#comment-42" rel="nofollow"><br />
<strong><em>redcoder:</em></strong><br />
</a></p>
<p>写得很不错。一直以来我总不太清楚模态对话框的消息循环机制。甚至以为模态对话框是通过一个单独的线程，然后通过某些内核对象来实现的同步效果的。现在你的文章让我解除了这个疑虑。至于你说的消息队列和线程的关系，推荐看下《windows核心编程》最后一章。我想你的推论是正确的，线程启动初期是没有队列的，windows由于消息驱动的特性对其做了一个扩展，就是加上消息队列。同时可能出于效率或者其他方面的原因，只有在需要的时候他才为你实例化一个队列，这就解释了为什么PeekMessage（）之后，就有了队列的原因。</p>
</blockquote>
<p>很感谢您的提醒，读完了《Windows核心编程》关于窗口消息和输入模型两章之后我的疑惑也解开了，此文中的相关内容稍后会重新整理 <img src='http://www.windameister.org/blog/wp-includes/images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' /> </p>
]]></content:encoded>
	</item>
	<item>
		<title>By: redcoder</title>
		<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/comment-page-1/#comment-42</link>
		<dc:creator>redcoder</dc:creator>
		<pubDate>Fri, 24 Dec 2010 06:34:24 +0000</pubDate>
		<guid isPermaLink="false">http://www.windameister.org/blog/2010/03/27/windows%e7%9a%84%e6%b6%88%e6%81%af%e9%98%9f%e5%88%97%e4%b8%8e%e6%b6%88%e6%81%af%e5%be%aa%e7%8e%af/#comment-42</guid>
		<description>写得很不错。一直以来我总不太清楚模态对话框的消息循环机制。甚至以为模态对话框是通过一个单独的线程，然后通过某些内核对象来实现的同步效果的。现在你的文章让我解除了这个疑虑。至于你说的消息队列和线程的关系，推荐看下《windows核心编程》最后一章。我想你的推论是正确的，线程启动初期是没有队列的，windows由于消息驱动的特性对其做了一个扩展，就是加上消息队列。同时可能出于效率或者其他方面的原因，只有在需要的时候他才为你实例化一个队列，这就解释了为什么PeekMessage（）之后，就有了队列的原因。</description>
		<content:encoded><![CDATA[<p>写得很不错。一直以来我总不太清楚模态对话框的消息循环机制。甚至以为模态对话框是通过一个单独的线程，然后通过某些内核对象来实现的同步效果的。现在你的文章让我解除了这个疑虑。至于你说的消息队列和线程的关系，推荐看下《windows核心编程》最后一章。我想你的推论是正确的，线程启动初期是没有队列的，windows由于消息驱动的特性对其做了一个扩展，就是加上消息队列。同时可能出于效率或者其他方面的原因，只有在需要的时候他才为你实例化一个队列，这就解释了为什么PeekMessage（）之后，就有了队列的原因。</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: RyanHuang</title>
		<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/comment-page-1/#comment-39</link>
		<dc:creator>RyanHuang</dc:creator>
		<pubDate>Fri, 20 Aug 2010 13:38:54 +0000</pubDate>
		<guid isPermaLink="false">http://www.windameister.org/blog/2010/03/27/windows%e7%9a%84%e6%b6%88%e6%81%af%e9%98%9f%e5%88%97%e4%b8%8e%e6%b6%88%e6%81%af%e5%be%aa%e7%8e%af/#comment-39</guid>
		<description>我认为你理解的是正确的, 消息队列就是这样运作的, 但是我想可能你少介绍了PostMessage和SendMessage的区别, 我发现很多人对这2个也存在误解</description>
		<content:encoded><![CDATA[<p>我认为你理解的是正确的, 消息队列就是这样运作的, 但是我想可能你少介绍了PostMessage和SendMessage的区别, 我发现很多人对这2个也存在误解</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: windam</title>
		<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/comment-page-1/#comment-37</link>
		<dc:creator>windam</dc:creator>
		<pubDate>Fri, 25 Jun 2010 01:56:59 +0000</pubDate>
		<guid isPermaLink="false">http://www.windameister.org/blog/2010/03/27/windows%e7%9a%84%e6%b6%88%e6%81%af%e9%98%9f%e5%88%97%e4%b8%8e%e6%b6%88%e6%81%af%e5%be%aa%e7%8e%af/#comment-37</guid>
		<description>谢谢你的质疑，我对Windows内核的消息队列是如何实现的并不是很熟悉，本文的结论是建立在使用者的角度观察到的现象。
在任意线程中都可以调用GetMessage获取消息，也可以用PostThreadMessage向任何线程发送消息。并且如果一个线程没有调用过GetMessage或者PeekMessage，PostThreadMessage会失败。
上述现象使我推测每个线程中都会有消息队列存在。（但这一观点并未从微软的官方文档中获得支持，我会再去做进一步查证:-) ）
对windows操作系统的消息队列运作机理，如果您有更多的信息，非常希望不吝分享。</description>
		<content:encoded><![CDATA[<p>谢谢你的质疑，我对Windows内核的消息队列是如何实现的并不是很熟悉，本文的结论是建立在使用者的角度观察到的现象。<br />
在任意线程中都可以调用GetMessage获取消息，也可以用PostThreadMessage向任何线程发送消息。并且如果一个线程没有调用过GetMessage或者PeekMessage，PostThreadMessage会失败。<br />
上述现象使我推测每个线程中都会有消息队列存在。（但这一观点并未从微软的官方文档中获得支持，我会再去做进一步查证:-) ）<br />
对windows操作系统的消息队列运作机理，如果您有更多的信息，非常希望不吝分享。</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: nicolas</title>
		<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/comment-page-1/#comment-36</link>
		<dc:creator>nicolas</dc:creator>
		<pubDate>Fri, 25 Jun 2010 01:29:58 +0000</pubDate>
		<guid isPermaLink="false">http://www.windameister.org/blog/2010/03/27/windows%e7%9a%84%e6%b6%88%e6%81%af%e9%98%9f%e5%88%97%e4%b8%8e%e6%b6%88%e6%81%af%e5%be%aa%e7%8e%af/#comment-36</guid>
		<description>系统就创建了两个消息队列，一个system queue，一个appliation queue，你为什么说，系统会为每个线程或窗口程序都创建一个消息队列呢？怎么会有这样的结论？</description>
		<content:encoded><![CDATA[<p>系统就创建了两个消息队列，一个system queue，一个appliation queue，你为什么说，系统会为每个线程或窗口程序都创建一个消息队列呢？怎么会有这样的结论？</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: semicircle</title>
		<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/comment-page-1/#comment-35</link>
		<dc:creator>semicircle</dc:creator>
		<pubDate>Thu, 10 Jun 2010 14:30:48 +0000</pubDate>
		<guid isPermaLink="false">http://www.windameister.org/blog/2010/03/27/windows%e7%9a%84%e6%b6%88%e6%81%af%e9%98%9f%e5%88%97%e4%b8%8e%e6%b6%88%e6%81%af%e5%be%aa%e7%8e%af/#comment-35</guid>
		<description>&lt;blockquote&gt;
&lt;a href=&quot;#comment-31&quot; rel=&quot;nofollow&quot;&gt;
&lt;strong&gt;&lt;em&gt;windam:&lt;/em&gt;&lt;/strong&gt;
&lt;/a&gt;
 &lt;blockquote&gt;
&lt;a href=&quot;#comment-30&quot; rel=&quot;nofollow&quot;&gt;
&lt;strong&gt;&lt;em&gt;semicircle:&lt;/em&gt;&lt;/strong&gt;
&lt;/a&gt;
1. 其实，按照我的理解，消息队列和线程(任务)是没有必然的关联性的，mq是mq, pthread是pthread。一个线程(任务)可以去阻塞receive在某个消息队列上，也可以同时阻塞在多个消息队列上(select/overlapped io), 也可以不去接收任何消息，一个线程也可以一直循环忙自己的事，然后每循环一次去消息队列上”扫一眼“有没有新消息而不阻塞。
    所以，”消息队列是操作系统为每个需要处理消息的线程创建的“，这个说法略欠妥当。
    2.  模态对话框，用消息循环解释的很精髓~
    3.  读完了，我有个想法，这些由界面线程响应的消息是由谁发出的？原理上，界面响应能否不依赖于界面线程？为什么？….对了，这是windows，相关的代码是不是不可见了？
&lt;/blockquote&gt;
你说的线程与消息队列没有必然关联性，我觉得是有可能的，但是我现在缺乏这方面的证据来证实或者证伪我的猜想。
本文有关线程与消息的关系，我是按照我的理解来写的，并没有找到非常权威的参考。从明面上的api调用（GetMessage及PostThreadMessage）上来看，消息队列似乎是与线程相关联的，比如PostThreadMessage就需要传递一个线程id作为参数。GetMessage调用本身则已经包含了调用发出者是当前线程的语境。
最后各种窗体的消息的发出者，我认为应该是底层的设备驱动，键盘按键，鼠标移动点击，都会触发中断，操作系统会让键盘鼠标驱动把相关的数据准备好，放在一个缓冲区里，而后再由操作系统内核将这些数据包装成一个个消息，然后按照对应的目标发送给各个窗口。牵扯底层的知识，我了解的就不是很全面了，最近正在补这方面的短板:)
另外，如果有深入剖析Windows操作系统在线程与消息方面的值得推荐的书籍或者文章的话，还请不吝介绍一下:)
==============
补充一下，刚才同一位底层很熟悉的大牛请教了一下关于线程和消息队列的问题。
一个线程，凡是通过任何的api调用的途径，中间经过了win32k.sys的，都会自动检查并将线程转为GDI线程。消息队列也就应该有了。
&lt;/blockquote&gt;
呃 ... 这么大段的回复，我刚看到，怎么不会给我邮箱里回一份呢...</description>
		<content:encoded><![CDATA[<blockquote><p>
<a href="#comment-31" rel="nofollow"><br />
<strong><em>windam:</em></strong><br />
</a></p>
<blockquote><p>
<a href="#comment-30" rel="nofollow"><br />
<strong><em>semicircle:</em></strong><br />
</a><br />
1. 其实，按照我的理解，消息队列和线程(任务)是没有必然的关联性的，mq是mq, pthread是pthread。一个线程(任务)可以去阻塞receive在某个消息队列上，也可以同时阻塞在多个消息队列上(select/overlapped io), 也可以不去接收任何消息，一个线程也可以一直循环忙自己的事，然后每循环一次去消息队列上”扫一眼“有没有新消息而不阻塞。<br />
    所以，”消息队列是操作系统为每个需要处理消息的线程创建的“，这个说法略欠妥当。<br />
    2.  模态对话框，用消息循环解释的很精髓~<br />
    3.  读完了，我有个想法，这些由界面线程响应的消息是由谁发出的？原理上，界面响应能否不依赖于界面线程？为什么？….对了，这是windows，相关的代码是不是不可见了？
</p></blockquote>
<p>你说的线程与消息队列没有必然关联性，我觉得是有可能的，但是我现在缺乏这方面的证据来证实或者证伪我的猜想。<br />
本文有关线程与消息的关系，我是按照我的理解来写的，并没有找到非常权威的参考。从明面上的api调用（GetMessage及PostThreadMessage）上来看，消息队列似乎是与线程相关联的，比如PostThreadMessage就需要传递一个线程id作为参数。GetMessage调用本身则已经包含了调用发出者是当前线程的语境。<br />
最后各种窗体的消息的发出者，我认为应该是底层的设备驱动，键盘按键，鼠标移动点击，都会触发中断，操作系统会让键盘鼠标驱动把相关的数据准备好，放在一个缓冲区里，而后再由操作系统内核将这些数据包装成一个个消息，然后按照对应的目标发送给各个窗口。牵扯底层的知识，我了解的就不是很全面了，最近正在补这方面的短板:)<br />
另外，如果有深入剖析Windows操作系统在线程与消息方面的值得推荐的书籍或者文章的话，还请不吝介绍一下:)<br />
==============<br />
补充一下，刚才同一位底层很熟悉的大牛请教了一下关于线程和消息队列的问题。<br />
一个线程，凡是通过任何的api调用的途径，中间经过了win32k.sys的，都会自动检查并将线程转为GDI线程。消息队列也就应该有了。
</p></blockquote>
<p>呃 &#8230; 这么大段的回复，我刚看到，怎么不会给我邮箱里回一份呢&#8230;</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: windam</title>
		<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/comment-page-1/#comment-31</link>
		<dc:creator>windam</dc:creator>
		<pubDate>Tue, 30 Mar 2010 13:08:45 +0000</pubDate>
		<guid isPermaLink="false">http://www.windameister.org/blog/2010/03/27/windows%e7%9a%84%e6%b6%88%e6%81%af%e9%98%9f%e5%88%97%e4%b8%8e%e6%b6%88%e6%81%af%e5%be%aa%e7%8e%af/#comment-31</guid>
		<description>&lt;blockquote&gt;
&lt;a href=&quot;#comment-30&quot; rel=&quot;nofollow&quot;&gt;
&lt;strong&gt;&lt;em&gt;semicircle:&lt;/em&gt;&lt;/strong&gt;
&lt;/a&gt;
 &lt;p&gt;1. 其实，按照我的理解，消息队列和线程(任务)是没有必然的关联性的，mq是mq, pthread是pthread。一个线程(任务)可以去阻塞receive在某个消息队列上，也可以同时阻塞在多个消息队列上(select/overlapped io), 也可以不去接收任何消息，一个线程也可以一直循环忙自己的事，然后每循环一次去消息队列上”扫一眼“有没有新消息而不阻塞。&lt;br&gt;
    所以，”消息队列是操作系统为每个需要处理消息的线程创建的“，这个说法略欠妥当。&lt;br&gt;
    2.  模态对话框，用消息循环解释的很精髓~&lt;br&gt;
    3.  读完了，我有个想法，这些由界面线程响应的消息是由谁发出的？原理上，界面响应能否不依赖于界面线程？为什么？….对了，这是windows，相关的代码是不是不可见了？&lt;/p&gt;
&lt;/blockquote&gt;

你说的线程与消息队列没有必然关联性，我觉得是有可能的，但是我现在缺乏这方面的证据来证实或者证伪我的猜想。

本文有关线程与消息的关系，我是按照我的理解来写的，并没有找到非常权威的参考。从明面上的api调用（GetMessage及PostThreadMessage）上来看，消息队列似乎是与线程相关联的，比如PostThreadMessage就需要传递一个线程id作为参数。GetMessage调用本身则已经包含了调用发出者是当前线程的语境。

最后各种窗体的消息的发出者，我认为应该是底层的设备驱动，键盘按键，鼠标移动点击，都会触发中断，操作系统会让键盘鼠标驱动把相关的数据准备好，放在一个缓冲区里，而后再由操作系统内核将这些数据包装成一个个消息，然后按照对应的目标发送给各个窗口。牵扯底层的知识，我了解的就不是很全面了，最近正在补这方面的短板:)

另外，如果有深入剖析Windows操作系统在线程与消息方面的值得推荐的书籍或者文章的话，还请不吝介绍一下:)

==============

补充一下，刚才同一位底层很熟悉的大牛请教了一下关于线程和消息队列的问题。
一个线程，凡是通过任何的api调用的途径，中间经过了win32k.sys的，都会自动检查并将线程转为GDI线程。消息队列也就应该有了。</description>
		<content:encoded><![CDATA[<blockquote><p>
<a href="#comment-30" rel="nofollow"><br />
<strong><em>semicircle:</em></strong><br />
</a></p>
<p>1. 其实，按照我的理解，消息队列和线程(任务)是没有必然的关联性的，mq是mq, pthread是pthread。一个线程(任务)可以去阻塞receive在某个消息队列上，也可以同时阻塞在多个消息队列上(select/overlapped io), 也可以不去接收任何消息，一个线程也可以一直循环忙自己的事，然后每循环一次去消息队列上”扫一眼“有没有新消息而不阻塞。<br />
    所以，”消息队列是操作系统为每个需要处理消息的线程创建的“，这个说法略欠妥当。<br />
    2.  模态对话框，用消息循环解释的很精髓~<br />
    3.  读完了，我有个想法，这些由界面线程响应的消息是由谁发出的？原理上，界面响应能否不依赖于界面线程？为什么？….对了，这是windows，相关的代码是不是不可见了？</p>
</blockquote>
<p>你说的线程与消息队列没有必然关联性，我觉得是有可能的，但是我现在缺乏这方面的证据来证实或者证伪我的猜想。</p>
<p>本文有关线程与消息的关系，我是按照我的理解来写的，并没有找到非常权威的参考。从明面上的api调用（GetMessage及PostThreadMessage）上来看，消息队列似乎是与线程相关联的，比如PostThreadMessage就需要传递一个线程id作为参数。GetMessage调用本身则已经包含了调用发出者是当前线程的语境。</p>
<p>最后各种窗体的消息的发出者，我认为应该是底层的设备驱动，键盘按键，鼠标移动点击，都会触发中断，操作系统会让键盘鼠标驱动把相关的数据准备好，放在一个缓冲区里，而后再由操作系统内核将这些数据包装成一个个消息，然后按照对应的目标发送给各个窗口。牵扯底层的知识，我了解的就不是很全面了，最近正在补这方面的短板:)</p>
<p>另外，如果有深入剖析Windows操作系统在线程与消息方面的值得推荐的书籍或者文章的话，还请不吝介绍一下:)</p>
<p>==============</p>
<p>补充一下，刚才同一位底层很熟悉的大牛请教了一下关于线程和消息队列的问题。<br />
一个线程，凡是通过任何的api调用的途径，中间经过了win32k.sys的，都会自动检查并将线程转为GDI线程。消息队列也就应该有了。</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: semicircle</title>
		<link>http://www.windameister.org/blog/2010/03/27/windows-message-queue-and-message-loop/comment-page-1/#comment-30</link>
		<dc:creator>semicircle</dc:creator>
		<pubDate>Sun, 28 Mar 2010 10:10:15 +0000</pubDate>
		<guid isPermaLink="false">http://www.windameister.org/blog/2010/03/27/windows%e7%9a%84%e6%b6%88%e6%81%af%e9%98%9f%e5%88%97%e4%b8%8e%e6%b6%88%e6%81%af%e5%be%aa%e7%8e%af/#comment-30</guid>
		<description>1. 其实，按照我的理解，消息队列和线程(任务)是没有必然的关联性的，mq是mq, pthread是pthread。一个线程(任务)可以去阻塞receive在某个消息队列上，也可以同时阻塞在多个消息队列上(select/overlapped io), 也可以不去接收任何消息，一个线程也可以一直循环忙自己的事，然后每循环一次去消息队列上&quot;扫一眼“有没有新消息而不阻塞。
    所以，”消息队列是操作系统为每个需要处理消息的线程创建的“，这个说法略欠妥当。
    2.  模态对话框，用消息循环解释的很精髓~
    3.  读完了，我有个想法，这些由界面线程响应的消息是由谁发出的？原理上，界面响应能否不依赖于界面线程？为什么？....对了，这是windows，相关的代码是不是不可见了？</description>
		<content:encoded><![CDATA[<p>1. 其实，按照我的理解，消息队列和线程(任务)是没有必然的关联性的，mq是mq, pthread是pthread。一个线程(任务)可以去阻塞receive在某个消息队列上，也可以同时阻塞在多个消息队列上(select/overlapped io), 也可以不去接收任何消息，一个线程也可以一直循环忙自己的事，然后每循环一次去消息队列上&#8221;扫一眼“有没有新消息而不阻塞。<br />
    所以，”消息队列是操作系统为每个需要处理消息的线程创建的“，这个说法略欠妥当。<br />
    2.  模态对话框，用消息循环解释的很精髓~<br />
    3.  读完了，我有个想法，这些由界面线程响应的消息是由谁发出的？原理上，界面响应能否不依赖于界面线程？为什么？&#8230;.对了，这是windows，相关的代码是不是不可见了？</p>
]]></content:encoded>
	</item>
</channel>
</rss>

