浅谈线程

线程管理

1. 启动线程

启动一个简单的线程

范例 1

使用普通函数

#include <thread>
#include <iostream>

void do_task()
{
    std::cout << "task thread id:" << std::this_thread::get_id() << std::endl;
}

int main()
{
    //创建一个线程
    std::thread t = std::thread(do_task);
    //堵塞主线程，等待子线程执行完毕
    t.join();

    std::cout << "main thread id:" << std::this_thread::get_id() << std::endl;

    return 0;
}

范例 2

使用lambda

#include <thread>
#include <iostream>


int main()
{
    for (int i = 0; i < 20; ++i) {
        std::thread t = std::thread([i](){
            std::cout << "thread " << i << " id:" << std::this_thread::get_id() << std::endl;
        });
        t.join();
    }

    std::cout << "main thread id:" << std::this_thread::get_id() << std::endl;

    return 0;
}

范例 3

仿函数（重载运算符）

#include <thread>
#include <iostream>

class Task
{
public:
    //重载（）操作符
    void operator()(int i)
    {

        std::cout << "task thread " << i << "id:" << std::this_thread::get_id() << std::endl;
    }
};


int main()
{
    Task task;
    //创建线程，并且传递参数
    std::thread t = std::thread(task, 10);
    //堵塞主线程，等待子线程完成
    t.join();

    std::cout << "main thread id:" << std::this_thread::get_id() << std::endl;

    return 0;
}

2.向线程传递参数

默认的方式是使用拷贝的方式，复制到线程空间，即使参数的类型是引用

使用指针传递参数

#include <thread>
#include <stdio.h>

void task(const char* pBuffer, int n)
{
   fprintf(stdout, "buffer: %s, %d", pBuffer, n);
}

int main()
{
    char* buffer = NULL;
    int n = 10;

    //申请12字节的内存
    buffer = (char*)malloc(sizeof(char) * 12);

    //拷贝到数据到buffer
    strcpy(buffer, "hello thread");

    //传递的参数， 不能是右值的零时变量
    std::thread t = std::thread(task, buffer, n);
    t.join();
    return 0;
}

使用std::ref

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

class ObjectClass
{
public:
    ObjectClass(std::string& data)
    :m_data(data)
    {}

public:
    std::string& m_data;
};

void func(ObjectClass& object)
{
    std::cout << "objectName:" << object.m_data << std::endl;
}

int main()
{
    std::string tag = "object";
    ObjectClass object(tag);
    //创建线程， 使用std::ref传递引用的对象
    std::thread t = std::thread(func, std::ref(object));
    //堵塞线程，等待子线程执行完毕
    t.join();
    return  0;
}

使用类中的方法

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

class ObjectClass
{
public:
    explicit ObjectClass(std::string& tag)
    :m_tag(tag)
    {}

    void func(int n)
    {
        std::cout << "tag:" << this->m_tag << ", n:" << n << std::endl;
    }

private:
    std::string& m_tag;
};

int main()
{
    std::string tag = "object";
    ObjectClass object(tag);
    //使用类方法，放到子线程中使用;
    std::thread t = std::thread(&ObjectClass::func, &object, 10);
    //堵塞线程，等待子线程执行完毕
    t.join();
    return  0;
}

3.线程权限转移

thread 是可移动(movable), 但是不可复制的(copyable)

#include <thread>
#include <iostream>

void do_task()
{
    std::cout << "task thread id:" << std::this_thread::get_id() << std::endl;
}

int main()
{
    //创建一个线程
    std::thread t = std::thread(do_task);
    //线程t的权限移动到t2后,t变得不确定，
    std::thread t2 = std::thread(std::move(t));

    t2.join();

    std::cout << "main thread id:" << std::this_thread::get_id() << std::endl;

    return 0;
}

4.异常的线程处理

局部变量

局部变量引用的误区

#include <thread>
#include <iostream>

void task(int* pInt)
{
    std::cout << "int value:" << *pInt << std::endl;
}

int main()
{
    int i = 10;
    //创建线程
    std::thread t = std::thread(task, &i);
    //分离子线程
    t.detach();

    //主线程执行完毕，i变量资源回收，i的值变的不确定
    return 0;
}

主线程异常

当主线程发生异常时，如何保证子线程正确被回收

范例1

子线程不分离

#include <thread>
#include <iostream>
#include <exception>

void task()
{
    std::cout << "task thread id:" << std::this_thread::get_id() << std::endl;
}


void do_something()
{
    throw std::runtime_error("has exception");
}

int main()
{
    std::thread t(task);

    try {
        //主线程在执行过程中，发生异常，为了正确处理，线程等待，需要加入异常处理
        do_something();
    } catch (std::exception & e)
    {
        //等待子线程完成
        t.join();
        throw e;
    }

    //等待子线程完成
    t.join();

    return 0;
}

范例 2

子线程分离

#include <thread>
#include <iostream>
#include <exception>

void task()
{
    std::cout << "task thread id:" << std::this_thread::get_id() << std::endl;
}


void do_something()
{
    throw std::runtime_error("has exception");
}


int main()
{
    //创建线程
    std::thread t = std::thread(task);
    //线程分离,为了防止在创建线程后发生异常，导致线程无法回收
    t.detach();

    do_something();

    return 0;
}

范例 3

使用资源管理类

#include <thread>
#include <iostream>
#include <exception>

class ThreadGuard
{
public:
    //构造函数
    explicit ThreadGuard(std::thread&t)
    :t(t){}

    //析构函数
    ~ThreadGuard()
    {
        //析构函数时，顺道堵塞主线程，等待子线程执行完毕，这就是资源回收
        if(t.joinable())
        {
            t.join();
        }
    }

private:
    std::thread &t;
};

void task()
{
    std::cout << "task thread id:" << std::this_thread::get_id() << std::endl;
}

void func()
{
    std::thread t = std::thread(task);
    ThreadGuard guard(t);

    //超出作用域后，自动回收资源
}

void do_task()
{
    throw std::runtime_error("exception");
}

int main()
{
    func();
    
    do_task();

    return 0;
}