C++基础知识（7）多线程

C++的多线程是windows模式的，进程作为一个仓库，线程才是程序执行的最小单元。

1. 线程的创建

主线程：一个程序执行起来就是一个进程，而mian()函数就是主线程，一旦主线程执行完毕，整个进程就会结束。
子线程：在一个线程执行时，我们可以创建另外一个线程，两个线程各自执行，互不干涉。
注意：子线程与主线程是平级的，主线程执行完毕，会向所有子线程发送信号，使所有子线程强制结束，可以理解为子线程是主线程的辅助线程。

1. 子线程的创建方式

#include<iostream>
#include<thread>
void testTreadMain()
{
    std::thread myTread(); // 括号中只要是一个可调用对象就可以了
    std::thread myTread([]() {
        std::cout << "Hello World" << std::endl; 
    });
}

2. 子线程创建之后，对于子线程的状态，且必须调用下面两个状态的一种：
   （1）主线程需要等待子线程处理数据完毕，使用join()函数，主线程就会处于挂起状态。
   （2）子线程与主线程并行执行，互不干扰，但主线程要先结束，使用detach()子线程就会被C++运行库接管，就算主线程执行完毕，子线程会由C++运行库清理相关资源。

std::thread myTread([]() {
    std::cout << "Hello World" << std::endl;
    });
// 方式一：主线程挂起，等待子线程结束
myTread.join();  
// 方式二：子线程就会被C++运行库接管
myTread.detach();

2. 传递线程参数

传递参数时，我们有值传递，引用传递，指针传递三种方式。

void test(int i, int& refI, int* pi) 
{
    /*
    * 接收传递参数
    * i（地址与原i不同）
    * refI（地址与原i不同）
    * pi（值就是原来i的地址）
    **/ 
}
void testTreadMain()
{
    int i = 10;
    std::thread myTread(test, i, i, &i);
}

上述三种方法发现，使用指针传递时，调用的是原来的地址。原因是主线程在向子线程传参时，会传递两次，首先传递实参的副本到thread的tuple中，再以右值（临时对象）的形式传递给子线程。而指针传递时就是地址的值，所以传的一定是原来的地址。
注意：
（1）如果使用detach()，当主线程结束后，i被回收，虽然不会出错，但指针传递的参数再使用一定会出现问题。因此使用detach()时不要使用指针传递。
（2）在使用detach()时，不要使用隐式类型转化，有可能主线程都结束了，子线程还没进行完隐式类型转化。
（3）在传递类时，一定使用引用接收。使用值接收会使用两次复制构造函数。
（4）因为使用普通的引用传递，会调用一次复制构造函数，不是原来的对象，无法对原值进行修改，因此std::ref诞生了。

void test(int& refI)
{
    refI = 200;
}
void testTreadMain()
{
    int i = 10;
    std::thread myTread(test, std::ref(i)); // 原值传过去，i改为200，也不会调用复制构造函数
}

3. 线程的ID

查看线程的id：std::this_thread::get_id()

4. 数据共享与数据保护

数据保护问题相当于操作系统中的读者写着问题。如++操作是先将数据存入寄存器中，再加1，再将寄存器中的值返回。
只要线程对共享数据进行写操作，就一定需要数据保护。

4.1 互斥锁

互斥锁和操作系统的pv操作类似。

#include<iostream>
#include<thread>
#include<mutex>
unsigned g_num = 0; // 定义共享资源
std::mutex myMutex; // 定义互斥锁
void test() 
{
    myMutex.lock();
    for (unsigned i = 0; i < 1000000; i++)
    {
        ++g_num;
    }
    myMutex.unlock();
}
void testTreadMain()
{
    std::thread myTread(test);
    myMutex.lock();
    for (unsigned i = 0; i < 1000000; i++)
    {
        ++g_num;
    }
    myMutex.unlock();
    myTread.join();
}

如果在锁中，抛出了异常，那么myMutex永远不会解锁，即卡死。所以C++为我们提供了一种智能锁lock_guard。
智能锁的原理创建的对象即构造时调用lock()，析构时调用unlock()。

#include<iostream>
#include<thread>
#include<mutex>
unsigned g_num = 0;
std::mutex myMutex;
void test() 
{
    for (unsigned i = 0; i < 1000000; i++)
    {
        std::lock_guard<std::mutex> lg(myMutex); // lock_guard标准使用方法，让其覆盖尽量小的范围
        ++g_num;
    }
}
void testTreadMain()
{
    std::thread myTread(test);
    std::thread myTread1(test);
    myTread.join();
    myTread1.join();
}

4.2 原子操作

我们可以将一个数据设置为不可分割状态，一个处理器处理时，其它处理器无法进行处理。

#include<iostream>
#include<thread>
#include<atomic>
std::atomic<unsigned> g_num = 0;
void test() 
{
    for (unsigned i = 0; i < 1000000; i++)
    {
        ++g_num;
    }
}
void testTreadMain()
{
    std::thread myTread(test);
    std::thread myTread1(test);
}

注意：对于单个数据，使用atomic即可，对于大片大片的代码，使用互斥锁。

5. 死锁

C++提供了解决死锁，即不会死锁的函数。
std::lock：保证多个锁绝对不会死锁。
std::adopt_lock：自动释放锁。

#include<iostream>
#include<thread>
#include<mutex>
std::mutex myMutex1;
std::mutex myMutex2;
void test() 
{
    for (unsigned i = 0; i < 1000000; i++)
    {
        std::lock(myMutex1, myMutex2); // 保证myMutex1，myMutex2绝对不会死锁，但需要手动释放
        std::lock_guard<std::mutex> lg1(myMutex1, std::adopt_lock); // std::adopt_lock自动释放锁
        /*
        * 执行的代码
        */
        std::lock_guard<std::mutex> lg2(myMutex2, std::adopt_lock);
    }
}
void testTreadMain()
{
    std::thread myTread(test);
    for (unsigned i = 0; i < 1000000; i++)
    {
        for (unsigned i = 0; i < 1000000; i++)
        {
            std::lock(myMutex1, myMutex2);
            std::lock_guard<std::mutex> lg2(myMutex2, std::adopt_lock);
            /*
            * 执行的代码
            */
            std::lock_guard<std::mutex> lg1(myMutex1, std::adopt_lock);
        }
    }
}