blocks|key|3946216|text|看看TypeMock赛车(测试版)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3946217|编辑:实际的Alpha|3946218|http://www.typemock.com/Typemock_software_development_tools.html|3946219|entityMap|0|LINK|mutability|MUTABLE|url|http://www.typemock.com/typemock-racer-product/|1^0|2|8|0|0|0|0|1S|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|H|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|G]]]]

Take a look at <a href="http://www.typemock.com/typemock-racer-product/" rel="nofollow noreferrer">TypeMock</a> Racer (it's in Beta)

edit: actually Alpha

<a href="http://www.typemock.com/Typemock_software_development_tools.html" rel="nofollow noreferrer">http://www.typemock.com/Typemock_software_development_tools.html</a>

blocks|key|5356052|text|通常可以通过使用诸如ManualResetEvent之类的东西来强制执行可预见的争用条件和死锁，以便在释放线程之前将每个线程置于预期状态--即让线程A拥有锁并等待信号……让线程B请求锁，等等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5356053|然而，您通常可能会编写这样的测试来调查可疑的bug，以证明它何时被修复，以及它不会重新浮出水面。您通常会围绕竞争条件进行设计(但要尽可能实际地对其进行测试)。|5356054|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|$]]

It is usually possible to force foreseen race-conditions and deadlocks by using things like ManualResetEvent to get each thread into the expected state before releasing it - i.e. get thread A to have the lock and wait for a signal... get thread B to request the lock, etc...

However - you might typically write such a test to investigate a suspected bug, to prove when it is fixed and that it doesn't re-surface. You would generally design around race conditions (but test them as best as is pragmatic).

blocks|key|3100537|text|我不认为寻找竞争条件真的属于单元测试的范畴。或多或少根据定义，测试竞争条件的唯一方法是伪随机。除非您愿意努力正式证明锁定策略的正确性，否则必须进行一些压力测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3100538|您仍然需要编写单元测试，以验证算法的正确性，而不是锁定策略。|3100539|在对多线程代码进行压力测试时，您需要在以下条件下进行测试:每个线程有一个CPU，多个线程共享CPU，CPU比线程多(如果可能)。|3100540|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I don't think looking for race conditions really falls into the realm of unit testing. More-or-less by definition, the only way to test for race conditions is pseudo-randomly. Unless you're willing to go to the effort of formally proving the correctness of your locking strategy, you'll have to do some stress-testing.

You still need to write unit tests, to verify to correctness of the algorithms, rather than the locking strategy. 

When stress-testing multi-threaded code, you'll want to test under conditions where you have one CPU per thread, where you have multiple threads sharing the CPU, and where you have more CPUs than threads (if possible).

blocks|key|803118|text|您可以编写一个锁类，通过查看锁操作的顺序来检测潜在的死锁。我们通过一个线程上下文来实现这一点，当所有的锁被获取时，所有的锁都会注册到这个线程上下文中(可以将其设为仅调试选项)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|803119|我们的想法是创建一个图，其中节点表示锁，A和B之间的有向边表示“当获取锁B时，锁A正在被持有”。让你的程序在正常加载的情况下运行，然后检查图中的循环。循环意味着即使您的代码没有命中它，也有可能出现死锁。|803120|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|$]]

You can write a lock class that detects potential deadlocks, by looking at the ordering of the lock operations. We do this by having a thread context that all locks register with when they are acquired (can be made a DEBUG only option).

The idea is to create a graph where the nodes represents locks and a directed edge between A and B means 'lock A was being held when lock B was acquired'. Let your program run using normal loads, then check for cycles in the graph. A cycle means there is potential for deadlock even if your code didn't hit it.

blocks|key|807265|text|我想不出一个很好的自动化方法，但我最接近于编写一个单元测试来“暴露”死锁，那就是除了单元测试之外还使用断点。我只是简单地添加了一些关于在何处添加断点的说明。这涉及到一些手动工作，但使用它们，您总是可以暴露最坏的情况下的线程调度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|807266|也许有人已经想出了一种自动化这种类型的功能的好方法？我可以想象自动运行调试器，在特定的行处中断一个线程，让另一个线程运行到特定的条件，然后断言单元测试。|807267|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|$]]

Can't think of a good automated way, but the closest I've come was to writing a unit test that would 'expose' a deadlock was by using breakpoints in addition to a unit test. I simply added some instructions on where to add the breakpoint. There is some manual effort involved, but with them you can always expose your worse case thread schedule.

Perhaps someone has figured a good way to automate this type of functionality? I could imagine automatically running the debugger, breaking one thread at a specific line, letting another one run until a specific condition, then asserting for the unit test.

blocks|key|3946616|text|我之前在代码中使用了由请求中的一些参数触发的人为延迟。例如，一个请求告诉服务器在两次写入之间延迟写入，另一个请求在两次写入之间没有延迟的情况下进行写入。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3946617|Mark+Bessey写道，这只对创建repro有用，对发现问题没有用。|3946618|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|$]]

I have previously used artificial delays in the code that are triggered by some parameters in the request. For example one request tells the server to delay write between two writes and another to do them with no delay in between. 

A Mark Bessey writes, this is only useful for creating repro, not for discovering the problem.

blocks|key|3946629|text|你试过Corensic+Jinx吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3946630|entityMap|0|LINK|mutability|MUTABLE|url|http://www.corensic.com/^0|3|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Have you tried <a href="http://www.corensic.com/" rel="nofollow">Corensic Jinx</a>?

Any suggestions on how to write repeatable unit tests for code that may be susceptible to deadlocks and race conditions?

Right now I'm leaning towards skipping unit tests and focusing on stress tests. The problem with that is you can run a stress test 5 times and see five different results.

EDIT: I know its probably just a dream, but if there were a way to control individual threads and cause them to execute one instruction at a time then I might get somewhere.

Unit Testing, Deadlocks, and Race Conditions

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

对于如何为可能易受死锁和竞争条件影响的代码编写可重复的单元测试，有什么建议吗？现在，我倾向于跳过单元测试，专注于压力测试。这样做的问题是，您可以运行5次压力测试，并看到5种不同的结果。编辑:我知道这可能只是一个梦，但如果有一种方法可以控制单独的线程，使它们一次执行一条指令，那么我可能会有所收获。

问单元测试、死锁和竞争条件
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问单元测试、死锁和竞争条件EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问单元测试、死锁和竞争条件
EN