blocks|key|3953282|text|因为编译器没有意识到shutdown_ok将在不同线程中的函数外部被修改。也许编译器发现在Shutdown()函数中shutdown_ok的计算结果总是为false，因此删除了if语句。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3953283|void+Shutdown+(void)
{++++++++
++++shutdown+=+1;
++++while+(1)
++++{
++++++++shutdown+=+0;
++++}
}|code-block|syntax|javascript|3953284|可以将变量标记为volatile，这是对编译器的一个提示，即可以用编译器无法预测的方式修改变量。|3953285|3953286|+C%2B%2B标准7.1.5.1/8:注意：volatile是对实现的一个提示，以避免涉及对象的激进优化，因为对象的值可能会通过实现无法检测到的方式更改...一般而言，C%2B%2B中volatile的语义与C中的语义相同。|blockquote|BOLD|3953287|3953288|3953289|但是，编译器可能会使volatile变量具有标准中未指定的某些行为。例如，Visual+C%2B%2B+compilers+make+volatile+variables+behave+like+memory+locks，但实际上任何标准都不能保证这种行为。|3953290|因此，volatile不能被视为解决所有多线程问题的灵丹妙药。对于这项工作，最好使用适当的线程和并发原语。|3953291|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/12a04hfd.aspx^0|A|B|19|A|1M|B|2G|2|0|0|8|8|0|0|1|F|J|8|2D|8|0|0|0|A|8|1R|8|11|1X|0|0|3|8|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1J|8|@$9|1K|A|1L|B|Q]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1S|8|@$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@$9|1X|A|1Y|1|1Z]]|E|$]]|$1|V|3|W|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|23|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]]]

Because the compiler does not realize that <code>shutdown_ok</code> will be modified outside the function in a different thread. Perhaps the compiler figured out that <code>shutdown_ok</code> will always evaluate to false inside the <code>Shutdown()</code> function and thus removed the <code>if</code> statement.

<pre><code>void Shutdown (void)
{ 
 shutdown = 1;
 while (1)
 {
 shutdown = 0;
 }
}
</code></pre>

One can mark a variable as <code>volatile</code>, which serves as a hint to the compiler that the variable can be modified in ways the compiler cannot predict.

<blockquote>
 C++ standard 7.1.5.1/8: [Note: <code>volatile</code> is a hint to the implementation to avoid aggressive optimization involve the object because the value of the object might be changed by means undetectable by an implementation... In general, the semantics of <code>volatile</code> are intended to be the same in C++ as they are in C.]
</blockquote>

However, compilers may make <code>volatile</code> variables take on certain behaviors that are not specified in the standard. For example, <a href="http://msdn.microsoft.com/en-us/library/12a04hfd.aspx" rel="nofollow">Visual C++ compilers make <code>volatile</code> variables behave like memory locks</a>, but such behavior is not actually guaranteed by any standard.

For this reason, <code>volatile</code> cannot be treated as a magic bullet that will solve all your multithreading problems. You're much better off using proper threading and concurrency primitives for this job.

blocks|key|289254|text|关闭的定义是什么？它在哪里定义的？我怀疑这需要是一个volatile变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|289255|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Volatile_variable^0|Q|8|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]]]]

What is the definition of shutdown? Where is it defined? I suspect that this needs to be a <a href="http://en.wikipedia.org/wiki/Volatile_variable" rel="nofollow">volatile</a> variable.

blocks|key|289298|text|我认为'shutdown_ok‘的'volatile’修饰符应该避免这种情况。它告诉编译器，变量可以被另一个线程修改，因此它应该总是引用它，而不是使用一个寄存器来保存它的值的副本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|289299|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think 'volatile' modifier for 'shutdown_ok' should avoid this. It tells the compiler that the variable can be modified by another thread so that it should always refer to it instead of using for example a register to hold a copy of its value.

blocks|key|3953396|text|事情没有按照你期望的方式运行的最可能的原因是编译器并不期望关闭会发生变化，所以它很乐意优化它。解决方案是使用适当的线程同步原语，如信号量或condvars，以获得您期望的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3953397|备注|3953398|人们会建议将shutdown设为volatile，或许可以安全地假设写入int是原子的。这可能在大多数情况下都有帮助。但即便如此，你仍然可能会遇到问题。在多核机器上，读写操作可能会意外地重新排序，从而导致您错过了一个重要的信号。英特尔有专门的LOCK指令来处理这些情况，但编译器通常不会生成锁定。在ARM上，您有一条DMB指令，但这也不太可能由编译器生成。|offset|length|style|CODE|3953399|底线当做线程同步时，使用操作系统原语，不要尝试推出你自己的。你会弄错的|3953400|entityMap^0|0|0|G|8|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

The most likely reason for things not behaving the way that you expect is that the compiler is not expecting shutdown to change so it is happy to optimize it out. The solution is to use proper thread synchronization primitives like semaphores or condvars to get the behaviour that you are expecting.

<h2>Note</h2>

People will suggest making shutdown <code>volatile</code> and it is probably safe to assume writing to an int is atomic. This may help in probably most cases. But even so you may still get problems. On multicore machines reads and writes may be reordered unexpectedly leaving you to missing an important signal. Intel has a specialized LOCK instruction to deal with these cases but the compiler will not normally generate a LOCK. On ARM you have a DMB instruction but this as well is unlikely to be generated by the compiler.

Bottom line when doing thread synchronization, use the OS primitive and don't try to roll out your own. YOU WILL GET IT WRONG

blocks|key|2357669|text|pthreads的解决方案是使用条件变量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2357670|pthread_cond_t+shutdown_cond+=+PTHREAD_COND_INITIALIZER;
pthread_mutex_t+shutdown_lock+=+PTHREAD_MUTEX_INITIALIZER;

void*+Thread+(void*+nothing)+{

++++while(1)+{
++++++++//+Sleep+if+requested
++++++++if+(+Sleep_c)
++++++++++++++++Sys_Sleep+(Sleep_c);

++++++++Do_stuff();

++++++++pthread_mutex_lock(&shutdown_lock);
++++++++if+(shutdown)+{
++++++++++++shutdown_ok+=+1;
++++++++++++pthread_cond_signal(&shutdown_cond);
++++++++++++pthread_mutex_unlock(&shutdown_lock);
++++++++++++break;
++++++++}
++++++++pthread_mutex_unlock(&shutdown_lock);
++++}
++++return+0;
}

void+Shutdown+(void)
{
++++pthread_mutex_lock(&shutdown_lock);+
++++shutdown+=+1;
++++while+(!shutdown_ok)
++++++++pthread_cond_wait(&shutdown_cond,+&shutdown_lock);
++++shutdown+=+0;
++++pthread_mutex_unlock(&shutdown_lock);
}|code-block|syntax|javascript|2357671|通常，如果您发现自己想要进行繁忙循环，这是您应该使用条件变量的标志。|2357672|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The pthreads solution to this is to use a condition variable:

<pre><code>pthread_cond_t shutdown_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t shutdown_lock = PTHREAD_MUTEX_INITIALIZER;

void* Thread (void* nothing) {

 while(1) {
 // Sleep if requested
 if ( Sleep_c)
 Sys_Sleep (Sleep_c);

 Do_stuff();

 pthread_mutex_lock(&amp;shutdown_lock);
 if (shutdown) {
 shutdown_ok = 1;
 pthread_cond_signal(&amp;shutdown_cond);
 pthread_mutex_unlock(&amp;shutdown_lock);
 break;
 }
 pthread_mutex_unlock(&amp;shutdown_lock);
 }
 return 0;
}

void Shutdown (void)
{
 pthread_mutex_lock(&amp;shutdown_lock); 
 shutdown = 1;
 while (!shutdown_ok)
 pthread_cond_wait(&amp;shutdown_cond, &amp;shutdown_lock);
 shutdown = 0;
 pthread_mutex_unlock(&amp;shutdown_lock);
}
</code></pre>

In general, if you find yourself wanting to busy-loop, it's a sign that you should be using a condition variable.

There's a thread that works normally with a loop

<pre><code>void* Thread (void* nothing) {

 while(1) {
 // Sleep if requested
 if ( Sleep_c)
 Sys_Sleep (Sleep_c);

 Do_stuff();
 if (shutdown) {
 shutdown_ok = 1;
 break;
 }
 }
 return 0;
}
</code></pre>

The function on the main thread that may kill it does

<pre><code> void Shutdown (void) {

 shutdown = 1;
 while (1) // Wait for it
 if (shutdown_ok) {
 shutdown = 0;
 break;
 }
 }
</code></pre>

Now, this works fine on the debugger. But it gets stuck in the while(1) loop [of the shutdown function] in optimized code. Why?

Note: I should probably mutex lock the shared variables.

Why do compiler optimizations disrupt this functionality? (threads involved)

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

有一个使用循环正常工作的线程void* Thread (void* nothing) {    while(1) {        // Sleep if requested        if ( Sleep_c)                Sys_Sleep (Sleep_c);        Do_stuff...

问为什么编译器优化会破坏这种功能？(涉及的线程)
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么编译器优化会破坏这种功能？(涉及的线程)EN