blocks|key|4746817|text|从两个或多个不同的线程内部访问同一对象不会在运行时或调试器中产生错误，但它很可能会以您不想要的方式干扰对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4746818|在多线程环境中安全地处理它的方法是使用互斥锁和信号量。对于互斥锁，请检查wikipedia+link。|offset|length|4746819|Mutexes通常用于限制一个线程一次只能访问一个对象的情况。|4746820|另一方面，信号量是一种更通用的情况(互斥量实际上是信号量的特例)，它有一个计数器，即每个线程将根据信号量的激活/停用而增加/减少。当信号量达到0时，它将锁定自身和导致它的线程。有关信号量的更多信息，请查看wikipedia+page|4746821|如果你想要更具体的建议，那么我建议你给我们关于你的目标操作系统和/或你正在使用的API的信息，因为任何与线程(互斥、信号量等)有关的信息。特定于操作系统|4746822|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Mutual_exclusion|1|http://en.wikipedia.org/wiki/Semaphore_%2528programming%2529^0|0|10|E|0|0|0|2U|E|1|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@$D|12|E|13|1|14]]|A|$]]|$1|J|3|K|5|6|7|15|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]]]

Accessing the same object from inside two or more different threads would not generate an error either in run time or in a debugger BUT it most probably would screw around with the object in ways that you did not intend to.

The way to handle it in a multi-threaded environment safely is to use mutexes and semaphores.
For mutexes check the <a href="http://en.wikipedia.org/wiki/Mutual_exclusion" rel="nofollow">wikipedia link</a>.

Mutexes are generally used when you want to limit the access to an object by only one thread at a time.

Semaphores on the other hand are a more generic case (mutexes are actually a special case of a semaphore) which have a counter that each thread will increase/decrease depending on the activation/deactivation of the semaphore. When the semaphore reaches 0 it will lock itself and the thread that caused it. For more information on semaphores check the <a href="http://en.wikipedia.org/wiki/Semaphore_%28programming%29" rel="nofollow">wikipedia page</a>

If you want more specific advice, then I suggest you give us information on the Operating system you are targeting and/or the API you are using since anything having to do with threads (mutexes,semaphores e.t.c.) are OS-specific

blocks|key|709273|text|两个不同的线程同时写入单个对象或资源会破坏它，这个问题是竞争条件。在多线程程序中，争用条件既不是编译时错误，也不是运行时错误/异常。竞争条件是管理共享资源的一个软件缺陷，也就是进程间通信，并且很糟糕，因为它们破坏了幕后的数据。多次运行相同的程序将导致输出是预期的结果，而在其他时候则不是预期的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|709274|通过使用互斥来防止线程中的竞争条件。如果使用互斥锁只有一个对象或资源可用，则例如LCD显示器或单个对象，否则如果存在多个使用信号量，则示例是四个USB端口。资源是数据和设备。数据是变量、对象、数据结构等。设备是LCD显示器、打印机、USB端口等。|709275|将程序看作是一个连续的单线程，并决定需要完成的分离任务，可以省去更多的调试时间。文字处理程序是由几个线程组成的多线程程序。这些线程的假想示例是:读取文本文件、显示文本、保存文本文件，以及可能每五分钟运行一次的自动保存。线程应该是可以执行的操作，并注意字处理器中的所有线程都将文本作为资源。|709276|如果您已经有了code或检查值，请在每个线程中的对象之前和之后使用printf语句，而不是cout。请参阅printf而不是cout+here的原因。|offset|length|709277|所有操作系统都有进程间通信，但API有所不同。Linux使用POSTIX+API，Windows使用Win32或Windows+API，但使用方式相同。|709278|阅读材料http://drdobbs.com/cpp/199200938?pgno=1|709279|%5E-将文章中的一些内容总结为所写的内容|709280|entityMap|0|LINK|mutability|MUTABLE|url|http://www.devx.com/tips/Tip/37205|1|http://drdobbs.com/cpp/199200938?pgno=1^0|0|0|0|1V|4|0|0|0|4|13|1|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@$H|13|I|14|1|15]]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@$H|18|I|19|1|1A]]|A|$]]|$1|N|3|O|5|6|7|1B|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]|X|$5|S|T|U|A|$V|Y]]]]

Two different threads writing to a single object or resource at the same time will corrupt it and this problem is a race condition. In multi threaded programs race conditions are neither a compile-time error or a run-time error/exception. Race condition is a software flaw in managing to share resources, aka interprocess communication, and are nasty because they wreck the data behind the scenes. Running the same program multiple times will result in the output is the result that was expected and in other times not being what was expected.

Preventing race conditions in threads by using mutual exclusion. If only one object or resource is available use mutex, an example is LCD display or a single object, otherwise if there is multiple use a semaphore, an example is four USB ports. Resources are data, and devices. Data is variables, objects, data structures and etc. Devices are LCD display, printers, USB ports, and etc.

Looking at the program as a sequential single thread and decide the separating tasks that need to be done can save the trouble of more time debugging. A word processor is a multi threaded program that is made of a few threads. The imaginary example of the threads are: to read a text file, to display text, to save a text file, and maybe auto-save that runs every five minutes. Threads should be actions that can be preformed and notice all threads in the word processor have text as a resource.

If you already have code or checking values use printf statement instead of cout before and after the object in each thread. See the reason for printf instead of cout <a href="http://www.devx.com/tips/Tip/37205" rel="nofollow">here</a>.

All operating systems have interprocess communication, but the API is different. Linux uses POSTIX API and Windows uses Win32 or Windows API, but are used the same way. 

Reading Material
<a href="http://drdobbs.com/cpp/199200938?pgno=1" rel="nofollow">http://drdobbs.com/cpp/199200938?pgno=1</a>

^-Summarized some of the article into what was written

blocks|key|586989|text|它可能会也可能不会。并发修改在大多数线程标准上都是UB的，所以他们不能保证会发生什么。通常，对于简单类型，其中一种或另一种写操作将“获胜”。(对于对齐的简单类型，某些平台保证了这一点。)对于复杂的类型，你可能会被撕裂，最终得到一个“中间”的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|586990|不过，并发写入通常不是您遇到的问题类型。更常见的情况是读-修改-写操作重叠。例如，假设两个线程试图将一个项添加到同一队列或链表。当您向链表添加项时，可能会出现链表“损坏”的情况，如果另一个线程在链表损坏时访问它(在修改过程中，当它部分完成时)，事情可能会崩溃。|586991|将一项添加到链表的头部通常涉及到如下内容：|586992|object->next+=+head->next;
head+=+object;|code-block|syntax|javascript|586993|如果另一个线程在第一行结束后第二行开始之前尝试将对象添加到链表中，结果将不会很好。|586994|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

It may or may not. Concurrent modification is UB on most threading standards, so they make no guarantee about what will happen. Typically, with simple types, one or the other write will "win". (Some platforms guarantee this for aligned, simple types.) With complex types, you may get tearing and wind up with an "in-between" value.

Concurrent writes aren't usually the type of problem you have though. The more common case is overlapping read-modify-write operations. For example, think about two threads trying to add an item to the same queue or linked list. When you add an item to a linked list, there may be a time when the linked list is "broken" and if another thread accesses the linked list while it's broken (in the middle of the modification when it's part way done), things can blow up.

Adding an item to the head of a linked list usually involves something like:

<pre><code>object-&gt;next = head-&gt;next;
head = object;
</code></pre>

If another thread tries to add an object to the linked list after the first line completes but before the second line starts, the results will not be pretty.

blocks|key|586684|text|如果您使用的是linux或OS，那么可以使用valgrind工具之一(+hellgrind或drd+)来检测没有相应互斥的线程进行的一些内存访问。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|586685|然而，这并不是万无一失的，我也不会依赖它来捕捉你所有的问题。对任何共享资源都要非常小心。|586686|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If you're on linux or OS X, then you can use one of the valgrind tools ( hellgrind or drd ) to detect some memory accesses by threads without corresponding mutexes.

However this is not foolproof, and I'd not rely on it catching all your problems .. be very careful with any shared resource.

blocks|key|586700|text|似乎没有人回答如何实时调试多线程代码，这真的很难。仅仅是极短的延迟就会使程序的行为不同，并且只有在某些竞争条件发生时才会出现错误。这只能用极快的跟踪来研究，而Visual+Studio的速度太慢了。更糟糕的是，当两个线程同时调用trace方法时，它会变得非常慢。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|586701|编写自己的、非阻塞的(!)跟踪到内存中。只需将信息写入环形缓冲区即可。我的C%2B%2B不够好，但在C#中，代码应该是这样的：|586702|const+int+maxMessages+=+0x100;
const+int+indexMask+=+maxMessages-1;
string[]+messages+=+new+string[maxMessages];
int+messagesIndex+=+-1;

public+void+Trace(string+message)+{
++int+thisIndex+=+Interlocked.Increment(ref+messagesIndex)+&+indexMask;
++messages[thisIndex]+=+message;
}|code-block|syntax|javascript|586703|有关这种方法的更详细描述，请参阅:+CodeProject:+Debugging+multithreaded+code+in+real+time+1|offset|length|586704|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeproject.com/Articles/792532/Debugging-multithreaded-code-in-real-time^0|0|0|0|21|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

It seems nobody answered how to debug multi threaded code in real time, which is REALLY difficult. Just extremely short delays make the program behave differently and the error may occur only when certain race conditions happen. This can only be investigated with extremely fast tracing, for which Visual Studio is way too slow. Even worse, the trace method becomes really slow when 2 threads call it simultaneously.

It is quite easy to write your own, non blocking (!) trace into memory. Just write the information into a ring buffer. My C++ is not good enough, but in C# the code would look something like this:

<pre><code>const int maxMessages = 0x100;
const int indexMask = maxMessages-1;
string[] messages = new string[maxMessages];
int messagesIndex = -1;

public void Trace(string message) {
 int thisIndex = Interlocked.Increment(ref messagesIndex) &amp; indexMask;
 messages[thisIndex] = message;
}
</code></pre>

A more detailed description for this approach which also collects thread and timing information and outputs the trace nicely is at:
CodeProject: Debugging multithreaded code in real time <a href="http://www.codeproject.com/Articles/792532/Debugging-multithreaded-code-in-real-time" rel="nofollow">1</a>

If there is some code that 2 threads trying to write to the same object at the same time, my understanding is that it will not generate any compile-time error, which is the part of the reason why debugging multithreading program is so difficult. But will this generate a run-time error / exception?

Can anyone suggest any good multithreading debug techniques? 

Thanks.

debug multithread program

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

如果有一些代码被两个线程同时写入同一个对象，我的理解是它不会产生任何编译时错误，这就是调试多线程程序如此困难的部分原因。但是这会产生运行时错误/异常吗？有没有人能推荐一些好的多线程调试技术？谢谢。

问调试多线程程序
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问调试多线程程序EN