带有 std::thread 和这个的 ctor 初始值设定项列表

Question

我已经阅读了一些关于 'this' 在构造函数的初始化列表中不安全的内容。我有一个相当大的应用程序，我跟踪了一些未定义的行为，以在构造函数的初始化列表中使用 std::thread 和 'this'。当我将 std::thread 构造移出初始化列表并移入构造函数时，应用程序可以正常运行。

我试着用一个例子重现这个问题，但它运行得很好。谁能解释为什么 std::thread、'this' 和初始化列表的组合可能会产生未定义的行为。我认为这与调用 std::thread 构造函数时 'this' 未完全初始化有关，但这只是猜测。

我希望能够重现问题。在 ubuntu 16.04 上尝试使用 g++4.9.2 和 g++5.4。我用 -g 和 -O0 编译来调试。还尝试使用 -O2 和 -O3。

#include <chrono>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <thread>

//g++ -std=c++11 -g -O0 -pthread init_thread.cpp -o init_thread

/* ------------------------------------------------------------------------- +
 |   TEMPLATE FUNCTIONS
 + ------------------------------------------------------------------------- */
#if __cplusplus < 201402L
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
#endif


/* ------------------------------------------------------------------------- +
 |   CLASSES
 + ------------------------------------------------------------------------- */
class X
{
public:
    X() = delete;

    X(int x) : x_(x)
    {
        t_ = std::thread(&X::foo, this);
        printf("Ctor X\n");
    }

    ~X()
    {
        {
            std::lock_guard<std::mutex> lck(mtxState_);
            state_ = State::terminated;
        }
        cv_.notify_one();
        if (t_.joinable())
        {
            t_.join();
        }
        printf("Dtor X\n");
    }

private:
    enum class State
    {
        suspended,
        running,
        terminated
    };

    int x_;
    mutable std::mutex mtxState_;
    State state_ { State::running };
    mutable std::condition_variable cv_;
    std::thread t_;

    void foo()
    {
        while (state_ != State::terminated)
        {
            switch (state_)
            {
                case State::suspended:
                    {
                        std::unique_lock<std::mutex> lck(mtxState_);
                        cv_.wait(lck, [this] { return state_ != State::suspended; });
                    }
                    break;
                case State::running:
                    {
                        printf("do something X...\n");
                        std::this_thread::sleep_for(std::chrono::milliseconds(100));
                    }
                default:
                    break;
            }
        }
    };
};


class I
{
public:
    I() = delete;
    I(int i) {};
};


class A : I
{
public:
    A() = delete;

    A(int a) : I(a), a_(a), x_obj_with_thread_(make_unique<X>(15)), t_(std::thread(&A::foo, this))
    {
        printf("Ctor A\n");
    }

    ~A()
    {
        {
            std::lock_guard<std::mutex> lck(mtxState_);
            state_ = State::terminated;
        }
        cv_.notify_one();
        if (t_.joinable())
        {
            t_.join();
        }
        printf("Dtor A\n");
    }

private:
    enum class State
    {
        suspended,
        terminated
    };

    int a_;
    mutable std::mutex mtxState_;
    State state_ { State::suspended };
    mutable std::condition_variable cv_;
    std::thread t_;
    std::unique_ptr<X> x_obj_with_thread_;

    void foo()
    {
        while (state_ != State::terminated)
        {
            switch (state_)
            {
                case State::suspended:
                    {
                        std::unique_lock<std::mutex> lck(mtxState_);
                        cv_.wait(lck, [this] { return state_ != State::suspended; });
                    }
                    break;
                default:
                    printf("do something A...\n");
                    break;
            }
        }
    };
};

class B : I
{
public:

    B() = delete;

    B(int b) : I(b), b_(b), x_obj_with_thread_(make_unique<X>(15))
    {
        t_ = std::thread(&B::bar, this);
        printf("Ctor B\n");
    }

    ~B()
    {
        {
            std::lock_guard<std::mutex> lck(mtxState_);
            state_ = State::terminated;
        }
        cv_.notify_one();
        if (t_.joinable())
        {
            t_.join();
        }
        printf("Dtor B\n");
    }

private:
    enum class State
    {
        suspended,
        terminated
    };

    int b_;
    mutable std::mutex mtxState_;
    State state_ { State::suspended };
    mutable std::condition_variable cv_;
    std::thread t_;
    std::unique_ptr<X> x_obj_with_thread_;

    void bar()
    {
        while (state_ != State::terminated)
        {
            switch (state_)
            {
                case State::suspended:
                    {
                        std::unique_lock<std::mutex> lck(mtxState_);
                        cv_.wait(lck, [this] { return state_ != State::suspended; });
                    }
                    break;
                default:
                    printf("do something B...\n");
                    break;
            }
        }
    };
};


void testA()
{
    for (int i=0; i < 100000; i++)
    {
        printf("A iteration %i\n", i);
        A a(15);
    }
}

void testB()
{
    for (int i=0; i < 100000; i++)
    {
        printf("B iteration %i\n", i);
        B b(15);
    }
}

int main() 
{
    std::thread a(testA);
    std::thread b(testB);
    a.join();
    b.join();
    return 0;
}

Answer 1

根据标准，在初始化列表中使用成员函数会导致未定义的行为：

Member functions (including virtual member functions) can be called from member initializers, but the behavior is undefined if not all direct bases are initialized at that point.

直接基类按从左到右的顺序初始化。

然而在你的例子中，问题是对象本身（this）的初始化没有完成，它已经被传递给线程，被条件变量捕获并被引用。

以下代码因为互斥量未初始化而崩溃了一次，但我无法使其始终如一地重现：

class withthread
{
public:

    withthread(): b(false),t(std::thread(&withthread::func,this))

    {

    }
    ~withthread()
    {
        t.join();
    }
    void func()
    {
        int d=5;
        while ( --d  ) {
            std::unique_lock<std::mutex> l(m);
            v.wait(l,[this]() {this->b=true;return b;});
            cout << 2 << endl;
        }
    }
    std::thread t;
    std::mutex m;
    std::condition_variable v;
    bool b;
};

int main(){
    withthread w1 ;
    withthread *w ;
    w = new withthread();
    delete w;
    return 0;
}

Answer 2

在constructor member-init-list里面（就是constructor定义中prototype(X(int x))和body({…})之间的东西的正式名称），this isable up到您访问的数据成员已被初始化的程度。数据成员的初始化顺序不是由它们在 member-init-list 中的顺序定义的，而是它们在 class 定义中的顺序定义的（例如，如果前者的顺序与后者的顺序不匹配，Clang 会发出警告） .

所以原则上，只要线程是最后一个class成员，这个是完全可用的（除非在构造函数体中执行任何额外的初始化，在member-init-list被执行之后执行运行通过。

看你的代码classA，好像你有运行进入初始化顺序错误我描述的是：你的unique_per成员定义在线程之后，但是你误假设将 unique_ptr 放在 member-init-list 的第一位将改变它们的初始化顺序。事实并非如此，您可能会运行陷入与此相关的问题。在 B 中，线程首先被默认初始化：将它留在成员初始化列表之外并不意味着它不是首先被默认初始化！然后在构造函数体中，你实际上启动了一个线程运行ning 一个函数。

带有 std::thread 和这个的 ctor 初始值设定项列表

ctor initializer list with std::thread and this

c++

multithreading

this

initializer-list

c++11