blocks|key|1107712|text|我找到了一个笑脸post+on+the+MSDN+forum，它似乎回答了你的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1107713|1107714|blockquote|1107715|1107716|1107717|您可以同时对多个BeginSends进行排队。您不需要锁定|ordered-list-item|1107718|1107719|编辑：|1107720|更多有趣的信息：|1107721|如果您在Remark+section+of+the+MSDN+doc+BeginSend()中向下滚动一点，您会发现可能与您相关的回调方法的有趣用法。|1107722|1107723|+...如果希望在调用BeginSend方法后阻止原始线程，请使用WaitHandle.WaitOne方法。...|1107724|1107725|entityMap|0|LINK|mutability|MUTABLE|url|http://social.msdn.microsoft.com/Forums/en-US/netfxnetcom/thread/53aa930e-ce51-4993-a23b-040905aed46f/|1|http://msdn.microsoft.com/en-us/library/38dxf7kt.aspx^0|8|M|0|0|0|0|0|0|0|0|0|0|4|U|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|D|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]|$1|E|3|-4|5|F|7|1B|8|@]|9|@]|C|$]]|$1|G|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]|$1|I|3|J|5|K|7|1E|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|S|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]|$1|T|3|U|5|F|7|1N|8|@]|9|@]|C|$]]|$1|V|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]|$1|W|3|-4|5|6|7|1P|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]|14|$5|Z|10|11|C|$12|15]]]]

I found a smiliar <a href="http://social.msdn.microsoft.com/Forums/en-US/netfxnetcom/thread/53aa930e-ce51-4993-a23b-040905aed46f/" rel="noreferrer">post on the MSDN forum</a> which seems to answer to your question.

<blockquote>
 <ol>
 <li>You can queue multiple BeginSends at the same time. You don't need to lock</li>
 </ol>
</blockquote>

Edit:

Even more interesting informations:

If you scroll down a bit in the <a href="http://msdn.microsoft.com/en-us/library/38dxf7kt.aspx" rel="noreferrer">Remark section of the MSDN doc</a> BeginSend(), you will find interesting use of callback methods that could be relevant for you.

<blockquote>
 [...] If you want the original thread to block after you call the BeginSend method, use the WaitHandle.WaitOne method. [...]
</blockquote>

blocks|key|1751029|text|.NET套接字实例不是线程安全的，因为同时调用某些方法(相同或不同的方法)可能会导致状态不一致。但是，就自身的而言，BeginSend()+BeginReceive()+和方法是线程安全的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|1751030|对每个(或两者)都有多个未完成呼叫是安全的。|1751031|在BeginReceive()的情况下，当调用的顺序中有数据可用时，它们将得到服务。例如，如果您的处理很长，但您希望其他接收尽可能快地发生，则这会很有用。当然，在这种情况下，您的代码可能会同时处理多个回执，您可能需要自己的同步逻辑来保护您的应用程序状态。|1751032|对于BeginSend()，每个调用都会尝试将发送的数据推入套接字缓冲区，一旦被套接字缓冲区接受，您的回调就会被调用(您将在其中调用EndSend())。如果没有足够的缓冲区空间用于任何调用，它将阻塞。|1751033|注意:不要假设默认的8k缓冲区意味着“我可以用8k的数据快速调用BeginSend()，然后它就会阻塞”，因为以下情况是正确的：|1751034|1751035|+8K是一个“标称大小”的数字，缓冲区可能会缩小并在一定程度上增大|ordered-list-item|1751036|当您排队等待8K的调用时，将在网络上发送数据以减少排队的8K+data|1751037|1751038|一般而言：|1751039|1751040|如果您在线程内多次调用BeginSend()，则可以确保发送将按调用顺序离开计算机。|unordered-list-item|1751041|如果您从多个线程调用BeginSend()，则无法保证顺序，除非您使用其他阻塞机制强制实际调用按特定顺序发生。但是，每个调用都会在一个连续的网络字节流中正确地发送数据。|1751042|1751043|entityMap^0|1M|B|1Y|E|2D|A|1M|B|1Y|E|0|0|M|0|0|3J|1|E|0|0|2T|2|B|1U|9|0|0|1S|W|B|0|0|0|X|0|0|Z|0|0|0|5|0|0|0|16|B|B|0|0|2C|A|B|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|D]|$9|1F|A|1G|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|E|@]|F|$]]|$1|I|3|J|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|D]]|E|@]|F|$]]|$1|K|3|L|5|6|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|D]|$9|1U|A|1V|B|D]]|E|@]|F|$]]|$1|M|3|N|5|6|7|1W|8|@$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|D]]|E|@]|F|$]]|$1|O|3|-4|5|6|7|21|8|@]|E|@]|F|$]]|$1|P|3|Q|5|R|7|22|8|@$9|23|A|24|B|C]]|E|@]|F|$]]|$1|S|3|T|5|R|7|25|8|@$9|26|A|27|B|C]]|E|@]|F|$]]|$1|U|3|-4|5|6|7|28|8|@]|E|@]|F|$]]|$1|V|3|W|5|6|7|29|8|@$9|2A|A|2B|B|C]]|E|@]|F|$]]|$1|X|3|-4|5|6|7|2C|8|@]|E|@]|F|$]]|$1|Y|3|Z|5|10|7|2D|8|@$9|2E|A|2F|B|C]|$9|2G|A|2H|B|D]]|E|@]|F|$]]|$1|11|3|12|5|10|7|2I|8|@$9|2J|A|2K|B|C]|$9|2L|A|2M|B|D]]|E|@]|F|$]]|$1|13|3|-4|5|6|7|2N|8|@]|E|@]|F|$]]|$1|14|3|-4|5|6|7|2O|8|@]|E|@]|F|$]]]|15|$]]

.NET Socket instances are not thread-safe in that simultaneous calls to some methods (the same or different ones) may cause inconsistent state. However, the <code>BeginSend()</code> and <code>BeginReceive()</code> methods are thread-safe with respect to themselves.

It is safe to have multiple outstanding calls to each (or both).

In the case of <code>BeginReceive()</code>, they will be serviced when data is available in the order called. This can be useful if, for example, your processing is lengthy but you want other receives to occur as quickly as possible. Of course in this case you may have your code processing multiple receipts simultaneously and you may need your own synchronization logic to protect your application state.

In the case of <code>BeginSend()</code>, each call will attempt to push the sent data into the socket buffer, and as soon as it is accepted there, your callback will be called (where you will call <code>EndSend()</code>). If there is insufficient buffer space for any call, it will block.

Note: don't assume that the default 8k buffer means "I can quickly call <code>BeginSend()</code> with exactly 8k of data, then it will block," as the following are true:

<ol>
<li>The 8K is a "nominal size" number, and the buffer may shrink and grow somewhat</li>
<li>As you are queing up the 8K worth of calls, data will be being sent on the network reducing that 8K of queued data</li>
</ol>

In general:

<ul>
<li>If you call <code>BeginSend()</code> several times within a thread, you are assured that the sends will leave the machine in the order they were called.</li>
<li>If you call <code>BeginSend()</code> from several threads, there is no guarantee of order unless you use some other blocking mechanism to force the actual calls to occur in some specific order. Each call however will send its data properly in one contiguous stream of network bytes.</li>
</ul>

Consider the <code>Socket.BeginSend()</code> method. If two thread pool threads were to call this method simultaneously, would their respective messages end up mixing with each other or does the socket class keep this from happening?

Are Asynchronous writes to a socket thread safe?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

考虑Socket.BeginSend()方法。如果两个线程池线程同时调用此方法，它们各自的消息是否会相互混合，或者套接字类会阻止这种情况发生吗？

问异步写入套接字线程是否安全？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问异步写入套接字线程是否安全？EN