C++并发编程 thread

std::thread

　　C++11在标准库中为多线程提供组件, 使用线程需要包含头文件 thread, 其命名空间为 std.

启动新线程

每个进程至少有一个线程: 执行main()函数的线程, 其余线程有其各自的入口函数(线程函数)。
当线程执行完线程函数后, 线程也会退出. 如果不传入线程函数(类似这种形式std::thread t;), 线程不会运行. 线程函数不能重载, 否则不能编译.
在为一个线程创建了一个 std::thread 对象后, 如果线程已启动(不传入线程序函数时, 线程不会启动), 必须要明确是加入(join)还是分离线程(detach).

        // 启动一个线程:
        void MyThread(const std::string& str)
        {
            PRINT_LINE_INFO();
            std::cout << str << std::endl;
        }
        //std::thread t(MyThread, "Hello C...");
        std::thread t([] {
            MyThread("Hello C...");
            MyThread("Hello C2...");
        });               
        // 对于类方法, 需要使用 std::bind.
        std::thread t(std::bind(&ThreadExample::MyThread, this, "msg"));
        ThreadGuard tg(t);

如果 std::thread 对象销毁之前还没有调用 join 或 detach, 程序就会终止( std::thread 的析构函数会调用 std::terminate() ). 因此, 即便是有异常存在, 也需要确保线程能够正确的加入(joined)或分离(detached).
调用 join 或 detach 之前需要调用 joinable() 判断一下线程是否运行. 如果 joinable() 返回 false, 则不需要.
join()是简单粗暴的等待线程完成, 此时创建 std::thread 对象的线程(以下称主线程)将被阻塞. 如果在线程启动后到主线程在调用 join() 前的代码中发生了异常, 此时将会导致主线程永远没有机会执行.
针对此问题, 需要使用 RAII 机制来解决, 如创建一个 ThreadGuard 对象, 在析构函数中保证总是可以调用到 join.

        #ifndef _THREAD_GUARD_
        #define _THREAD_GUARD_

        #include <thread>

        class ThreadGuard
        {
        public:
            ThreadGuard(std::thread& t_) : t(t_){}

            ~ThreadGuard()
            {
                if (t.joinable())
                {
                    t.join();
                }
            }

            ThreadGuard(const ThreadGuard &) = delete;
            ThreadGuard& operator=(const ThreadGuard &) = delete;

        private:
            std::thread& t;
        };

        #endif // _THREAD_GUARD_

如果是分离线程, 必须保证可访问数据的有效性, 否则会产生未定义的行为, 如同单线程中一个对象被销毁后再访问一样.
处理这种情况的常规方法: 使线程函数的功能齐全, 将数据复制到线程中. 如果使用一个可调用的对象作为线程函数，这个对象就会复制到线程中，而后原始对象就可以销毁. 下面是错误的使用方法示例:

        class Func
        {
            int& i;
        public:
            Func(int& i_) : i(i_) {}
            void operator() ()
            {
                for (unsigned j = 0; j < 10; ++j)
                {
                    // 潜在访问隐患：悬空引用 i 
                    std::cout << i << " ";
                }
                std::cout << std::endl;
            }
        };
        { // 某个作用域内
            int* p = new int(100);
            Func f(*p);
            std::thread t(f);
            t.detach(); // 不等待线程结束
            delete p;
        } // 新线程可能还在运行

线程函数

　　线程函数可以有不同的参数, 向线程传递参数，只要在构造 std::thread 对象时，按照线程函数参数列表一一对应传入即可。线程函数有几点需要注意的地方:

(1) 默认的参数会被拷贝到独立的线程中，即使是引用的形式, 如果需要需要传递引用, 需要使用 std::ref 显示说明(并且线程函数参数也需要声明为引用).

        void ThreadParamRef(std::string& str)
        {
            str += " --> add";
        }

        void ThreadParam(std::string str)
        {
            str += " --> add";
        }    
    
        std::string str("Hello C++ Thread...");
        //std::thread t(ThreadParamRef, str);
        std::thread t(ThreadParamRef, std::ref(str)); // 只有这种形式才能在线程执行完毕后输出 Hello C++ Thread... --> add 
        //std::thread t(ThreadParam, std::ref(str));
        t.join();
        std::cout << str << std::endl;

(2)  线程参数传递时需要注意不能传入局部变量, 考虑下面的代码，buffer②是一个指针变量，指向本地变量，然后本地变量通过buffer传递到新线程中②。
　　函数有很大的可能，会在字面值转化成 std::string 对象之前崩溃，从而导致线程的一些未定义行为。
　　解决方案就是在传递到 std::thread 构造函数之前就将字面值转化为 std::string 对象。

        void f(int i,std::string const& s);
        void oops(int some_param)
        {
            char buffer[1024]; // 1
            sprintf(buffer, "%i",some_param);
            std::thread t(f,3,buffer); // 2
            t.detach();
        }          
        // 正确的方法
        void f(int i,std::string const& s);
        void not_oops(int some_param)
        {
            char buffer[1024];
            sprintf(buffer,"%i",some_param);
            std::thread t(f,3,std::string(buffer)); // 使用std::string，避免悬垂指针
            t.detach();
        }

　　(3) 线程函数参数传递时, 可以移动, 但不能拷贝. "移动"是指: 原始对象中的数据转移给另一对象，而转移的这些数据在原始对象中不再保存.

        void ThreadParamUniquePtr(std::unique_ptr<int> up)
        {
            std::cout << (up.get() ? *up : -1) << std::endl;
        }
        std::thread t(ThreadParamUniquePtr, std::move(up));
        //std::thread t(ThreadParamUniquePtr, up);  // 不能编译
        //std::thread t(ThreadParamUniquePtr, std::ref(up)); // 要求线程函数参数也为引用才能编译
        t.join();
        std::cout << (up.get() ? *up : -1) << std::endl; // 将输出-1

线程所有权转移

　　线程是资源独占型, 但可以将所有权转移给别的对象. 如果一个 std::thread 对象与一个运行的线程关联, 此时接受一个新的线程所有权时, 其以前关联的线程将直接调用 std::terminate() 终止程序继续运行.

std::thread t1(f);
std::thread t2(f);
// t1 = std::thread(f); // t1 所有权还没有转移, 不能通过赋一个新值来放弃线程
// t1 = std::move(t2); // t1 所有权还没有转移, 不能通过赋一个新值来放弃线程
t1.detach(); 或 t1.join();
t1 = std::move(t2);
std::thread t3 = std::move(t1);
t1 = std::move(t2);

线程对象也可以在函数中进行转移.

std::thread f1()
{
　　return std::thread(f);
}
std::thread f2()
{
　　std::thread t(f);
　　return t;
}
void f3(std::thread t);
void f4()
{
　　f3(std::thread(f));
　　std::thread t(f);
　　f3(std::move(t));
}

由于 std::thread 是可转移的, 如果容器对移动操作支持, 则可以将 std::thread 对象放入其中.

        class Func
        {
            int i;
        public:
            Func(int i_) : i(i_) {}
            void operator() ()
            {
                for (unsigned j = 0; j < 10; ++j)
                {
                    std::cout << i << " ";
                }
                std::cout << std::endl;
            }
        };
        std::vector<std::thread> threads;
        for (int i = 1; i < 10; i++)
        {
            Func f(i);
            //std::thread t(f);
            //v.push_back(t);     // 不能采用这种方式
            //v.push_back(std::move(t));  // 需要使用移动操作才可以
            threads.push_back(std::thread(f));
        }
        std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join)); // 对每个线程调用join()

常用函数

　　std::thread::hardware_concurrency() 返回 CPU 核心线程数. 如果无法查询系统信息时, 返回0. (static 函数)
　　get_id() 返回 std::thread 对象关联的线程的 id. 如果所有权已转移, 或线程函数已返回, 返回0.
　　std::this_thread::get_id() 取得当前线程的 id. (static 函数)

一个更好的ThreadGuard

#ifndef _THREAD_GUARD_
#define _THREAD_GUARD_

template <class _Thread>
class ThreadGuard
{
public:
    explicit ThreadGuard(_Thread& t_) : t(t_) {}

    ~ThreadGuard()
    {
        if (t.joinable())
        {
            t.join();
        }
    }

    ThreadGuard(const ThreadGuard &) = delete;
    ThreadGuard& operator=(const ThreadGuard &) = delete;

private:
    _Thread& t;
};

#endif // _THREAD_GUARD_