boost::thread 不更新全局变量

Question

我在外部软件中使用包装函数来启动一个新线程，该线程会更新一个全局变量，但这对主线程来说似乎是不可见的。我不能调用 join()，而不是阻塞主线程并使软件崩溃。 boost::async、boost::thread 和 boost::packaged_task 的行为方式都相同。

uint32 *Dval;

bool hosttask1()
{

        while(*Dval<10)
        {
            ++*Dval;
            PlugIn::gResultOut << " within thread global value: " << *Dval << std::endl;    
            Sleep(500);
        }


return false;
}



void SU_HostThread1(uint32 *value)
{

Dval = value; 
*Dval = 2;
PlugIn::gResultOut << " before thread: " << *value <<  " before thread global: " << *Dval << std::endl;

    auto myFuture = boost::async(boost::launch::async,&hosttask1);

    //boost::thread thread21 = boost::thread(&hosttask1);
    //boost::packaged_task<bool> pt(&hosttask1);
    //boost::thread thread21 = boost::thread(boost::move(pt)); 
}

当我调用函数时：

number a=0 
su_hostthread1(a)
sleep(2) //seconds
result(" function returned "+a+"  \n")

OUTPUT:

before thread value: 2 before thread global value: 2
 within thread global value: 3
 within thread global value: 4
 within thread global value: 5
 within thread global value: 6
 function returned 2  
 within thread global value: 7
 within thread global value: 8
 within thread global value: 9
 within thread global value: 10

有什么想法吗？ 提前致谢！

Answer 1

以下代码正确地再现了我打算做的事情。主要是线程更新一个主线程正确观察到的全局变量。

#include "stdafx.h"
#include <iostream>

#include <boost/thread.hpp>
#include <boost/chrono.hpp>

unsigned long *dataR;

bool hosttask1()
{
    bool done = false;
    std::cout << "In thread global value: " << *dataR << "\n"; //*value11 <<  *dataL << 
    unsigned long cc = 0;
    boost::mutex m;

        while (!done)
        {
            m.lock();
            *dataR = cc;
            m.unlock();
            cc++;
            std::cout <<  "In thread loop global value: "<< *dataR << "\n";
            if (cc==5) done = true;
        }


return done;
}

void SU_HostThread1(unsigned long *value)
{
    dataR = value;
    std::cout << "Before thread value: " << *value << " Before thread global value: " << *dataR << "\n"; //*value11 <<  *dataL << 
    auto myFuture = boost::async(boost::launch::async, &hosttask1);
    return;
}

int main()
{
    unsigned long value =1;
    unsigned long *value11;
    value11 = &value;

    SU_HostThread1(value11);

    boost::this_thread::sleep(boost::posix_time::seconds(1));
    std::cout << "done with end value: " << *value11 << "\n";

    return 0;
}

输出：

Before thread value: 1 Before thread global value: 1
In thread global value: 1
In thread loop global value: 0
In thread loop global value: 1
In thread loop global value: 2
In thread loop global value: 3
In thread loop global value: 4
done with end value: 4

然而，当我将它完全复制到外部软件的 SDK 时，主线程并没有更新全局值。有什么想法吗？ 谢谢

在外部软件中输出：

before thread value: 1 before thread global value: 1
In thread global value: 1
In thread loop global value: 0
In thread loop global value: 1
In thread loop global value: 2
In thread loop global value: 3
In thread loop global value: 4
done with end value: 1 

Answer 2

如果您在线程之间共享数据，则必须同步对该数据的访问。两种可能的方式是保护所述数据的互斥锁和原子操作。简单的原因是存在缓存和读/写重新排序（由 CPU 和编译器）。虽然这是一个复杂的话题，在这里的答案中没有什么可以解释的，但是那里有几本好书，还有一堆正确的代码。

Answer 3

这可能是因为编译器在优化代码时通常不会考虑多线程。如果看到你的代码重复检查一个值，它知道在单线程中该值不能改变，所以它只是省略了检查。

如果您将变量声明为volatile，那么它可能会生成效率较低的代码，但会更频繁地进行检查。

当然你也要明白，当一个值被写入的时候，有些情况下它可能不会一次全部写入，所以如果你不幸在它写到一半的时候读回了它，那么你取回一个垃圾值。解决方法是将其声明为 std::atomic （优化器自动将其视为易失性），然后将发出更复杂的代码以确保写入和读取不能相交（或不同的处理器原语可能是用于整数等小对象）

大多数变量不在线程之间共享，当它们共享时，程序员需要在设计期间识别这些变量并平衡优化与线程同步需求。