C++11 多线程 线程管理基础

线程管理基础

C++11 所有的线程都封装在<thread>头文件中，使用命名空间std说明。

最简单的例子：

#include <iostream>
#include <thread>

void hello() {
    std::cout << "hello world !\n";
}

int main() {
    std::thread t(hello);  // 定义一个线程，注意是直接构造执行的
    t.join();              // 在这里进行等待
    return 0;
}

每个线程都必须有一个初始函数，新线程在函数中执行。join()的作用是等待线程执行完毕，然后向下执行。该例子中，如果没有join，那么可能出现主线程执行完毕，子线程还未完成，出现异常。

C++线程库启动线程可以归结为构造一个std::thread对象，使用可调用类型进行构造。传入带有函数调用符类型的参数实例，可以用来替代默认的构造函数。

join和detach的区别：

• join是用于等待线程执行完毕后，再向下执行
• detach是声明是线程再后台执行，不必等待线程执行完毕，主线程可以继续向下执行。而且此时不能有其他的std::thread对象能引用它。
• 两者都不能对没有执行的线程进行操作，保险的做法是先进行joinable的判断，然后调用函数。

线程使用的注意事项：尽量不要在线程中访问局部变量的引用或者指针，保险的做法是复制数据到线程中。
线程本身不能返回数据，因此需要使用引用的方式。。

以下是构造线程的一般方法：

#include <iostream>
#include <thread>
#include <string>
#include <algorithm>

// 最普通方式
void do_some_work() {
    std::cout << "do some work !\n";
}

// 函数对象方式
class back_ground_task {
  public:
    void operator()()const {
        do_something();
        do_something_else();
    }
    void do_something()const {
        std::cout << "do something !\n";
    }
    void do_something_else()const {
        std::cout << "do something else !\n";
    }
};

// 析构方保护线程
class thread_guard {
  public:
    explicit thread_guard(std::thread& t_): t(t_) {}
    ~thread_guard() {
        if(t.joinable()) {
            t.join();
        }
    }
    thread_guard(thread_guard const&) = delete;
    thread_guard& operator=(thread_guard const&) = delete;
  private:
    std::thread& t;
};

// 参数测试
void arg_test(int i, const std::string& str) {
    std::cout << "i=" << i << ", string=" << str << std::endl;
}

// 类成员函数测试
class X {
  public:
    void func(int i) {
        std::cout << "X func i=" << i << std::endl;
    }
};

// 引用方式传递参数
void ref_func_test(std::string& str) {
    str += str;
}

void do_work(int i) {
    std::cout << "create thread: " << i << std::endl;
}

void create_epoch_threads(int n) {
    std::vector<std::thread>threads;
    // 量产线程
    for(unsigned j = 0; j < n; ++j) {
        threads.emplace_back(std::thread(do_work, j));
    }
    // 对每个线程进行join操作
    std::for_each(threads.begin(), threads.end(),
                  std::mem_fn(&std::thread::join));
}

int main() {
    // 最基本方式
    std::thread t(do_some_work);
    t.join();
    // 函数对象的方式
    back_ground_task f;
    std::thread t1(f);
    t1.join();
    // 使用类构造的方式
    std::thread t2(do_some_work);
    thread_guard g(t2);
    // 匹配参数
    std::thread t3(arg_test, 2, "arg test");
    t3.join();
    // 引用传递
    std::string str("test_ref_");
    std::thread t4(ref_func_test, std::ref(str));  // 注意std::ref
    t4.join();
    std::cout << str << std::endl;
    // 类成员函数
    X my_x;
    std::thread t5(&X::func, &my_x, 10);
    t5.join();
    // 批量生产线程
    create_epoch_threads(3);
    return 0;
}

转移线程所有权

线程没有拷贝操作！！！ ，所有权的转移都是通过std::move实现的。这种类型的资源是不能直接赋值的，没有意义，只能直接创建。

线程的所有权可以在函数外进行转移。

std::thread f() {
    void some_function();
    return std::thread(some_function);
}

std::thread g() {
    void some_other_function(int);
    std::thread t(some_other_function, 42);
    return t;
}

编译器有ROV，不用担心出现多余的拷贝，这里返回值就是相当于移动操作。

所有权可以在函数内部传递，同样的也可以作为函数的参数，不过要使用std::move进行操作。

void f(std::thread t);
void g() {
    void some_function();
    f(std: thread(some_function));   // 可以直接在参数处进行构造
    std::thread t(some_function);    // 直接进行移动操作
    f(std::move(t));
}

可以使用类构造的方式，直接传入线程，而不是各个参数。这样，可以更加简化操作。

#include <iostream>
#include <thread>

void do_something(int i) {
    /*do some thing here*/
    for(int j = 0; j < 10; ++j) {
        i = j;
    }
}

struct func {
    int& i;
    func(int& i_): i(i_) {}
    void operator()() {
        for(unsigned j = 0; j < 1000000; ++j) {
            do_something(i);
        }
    }
};

class scoped_thread {
  public:
    explicit scoped_thread(std::thread t_): t(std::move(t_)) {
        if(!t.joinable()) {
            throw std::logic_error("No thread");
        }
    }
    ~scoped_thread() {
        t.join();
    }
    scoped_thread(scoped_thread const&) = delete;
    scoped_thread& operator=(scoped_thread const&) = delete;
  private:
    std::thread t;
};

void f() {
    int some_local_state;
    scoped_thread t(std::thread(func(some_local_state)));
    // do something in current thread
}

int main() {
    f();
}

运行时线程的数量

std::thread::hardware_concurrency()函数返回CPU核心的数量或者是一个程序中最多能同时并发的函数数量。

给出一个多线程版本的std::accumulate函数。

#include <algorithm>
#include <thread>
#include <iostream>
#include <vector>
#include <ctime>

template <typename Iterator, typename T>
struct accumulate_block {
    void operator()(Iterator first, Iterator last, T& result) {
        result = std::accumulate(first, last, result);
    }
};

template<typename Iterator, typename T>
T parallel_accumulate(Iterator first, Iterator last, T init) {
    unsigned long const length = std::distance(first, last);
    if(length <= 0)
        return init;
    // 每个线程最少的任务数量和可能线程最多数量
    unsigned long const min_per_thread = 25;
    unsigned long const max_threads =
        (length + min_per_thread - 1) / min_per_thread;

    unsigned long const hardware_threads = std::thread::hardware_concurrency();
    unsigned long const num_threads =
        std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);
    // 每个线程分配的任务
    unsigned long const block_size = length / num_threads;

    // 存放结果
    std::vector<T>results(num_threads);
    // 存放线程，注意不要放置主线程
    std::vector<std::thread>threads(num_threads - 1);
    // 并行化计算
    Iterator block_start = first;
    for(unsigned long i = 0; i < (num_threads - 1); ++i) {
        Iterator block_end = block_start;
        std::advance(block_end, block_size);
        threads[i] = std::thread(accumulate_block<Iterator, T>(),
                                 block_start, block_end, std::ref(results[i]));
        block_start = block_end;
    }
    // 计算可能的剩余量，并等待所有线程结束
    accumulate_block<Iterator, T>()(block_start, last, results[num_threads - 1]);
    std::for_each(threads.begin(), threads.end(),
                  std::mem_fn(&std::thread::join));
    // 每个线程计算的结果进行汇总
    return std::accumulate(results.begin(), results.end(), init);
}

int main() {
    using LL = unsigned long long;
    LL N = 200000000;
    LL init = 0;
    std::vector<LL>vec(N);
    for(LL i = 0; i < N; ++i) {
        vec[i] = 1;
    }
    using Iter = std::vector<LL>::iterator;
    // 并行化计算
    auto start = clock();
    std::cout << parallel_accumulate<Iter, int>(vec.begin(), vec.end(), init) << std::endl;
    auto stop = clock();
    std::cout << "time=" << stop - start << std::endl;
    // 串行计算
    start = clock();
    std::cout << std::accumulate(vec.begin(), vec.end(), init) << std::endl;
    stop = clock();
    std::cout << "time=" << stop - start << std::endl;
    return 0;
}
/*
输出结果：
200000000
time=469
200000000
time=1924

运行环境：Intel I7 4710MQ，四核
时间差不多是4倍
*/

补充：std::accumulate()是累加函数，std::advance()是迭代器移动函数，必须是前向或者双向迭代器才可以。

注意：不能从线程中直接返回一个值，在这里采取引用的方式进行解决。

识别线程

C++中，线程的标识符类型是std::thread::id。使用std::thread的get_id()成员直接获取。一般来说，这种方式是用来对线程进行检测的，以判断是否需要进行有关的操作。