c++ 多线程

线程的基本了解

• 线程是被CPU执行调度的最小单位。被包含于进程中。例如打开网页时，可以打开一个网页，也可以点击+号打开第二个网页。每一个网页都是一个多线程，而整个程序被称为多进程。所以每个进程至少包含一个线程。
• c++98中没有明确的提出线程这一概念，直到c++11中引入了线程技术。在使用线程时，需要引入头文件thread。

创建一个线程

void fun1()//线程1
{
    cout << "这是一个线程" << endl;
}

void fun2(int num)
{
    cout << "这是线程" << num << endl;
}

int main()//主线程
{

    thread t1(fun1);//子线程1
    thread t2(fun2, 2);//子线程2，当线程有入参时，只需要依次在thread参数列表中一次加入即可
    t1.join();
    t2.join();
    return 0;
}

以上代码中使用了join()函数，那么join是用来干什么的呢？一下我们对join函数进行一下了解。当主线程调用线程时，我们是应该等待线程执行完毕再去进行执行主线程还是两者同时执行呢？这就会引发程序的崩溃。join函数的产生就是用来使得主线程必须要等待子线程执行完毕再去进行执行主线程剩余的代码，而另一个detach函数则是不用等待子线程执行完毕继续执行主线程的代码。然而detach的使用需要十分注意，一不小心就会让程序崩溃。

mutex

c++11中引入了锁的概念，需要包含头文件mutex。锁的产生原因就是因为当两个线程共同访问同一块资源时，会发生哄抢的行为。就像某件热门商品打折，会造成秩序错乱的情况。

void share(string msg)
{
    cout << msg << "调用共享资源" << endl;

}

void fun1()//线程1
{
    string msg = "线程1";
    for (int i = 0; i < 10; i++)
    {
        share(msg);
    }
}

void fun2()
{
    string msg = "线程2";
    for (int i = 0; i < 10; i++)
    {
        share(msg);
    }
}

int main()//主线程
{

    thread t1(fun1);
    thread t2(fun2);
    t1.join();
    t2.join();
    cout << "这是主线程" << endl;
    return 0;
}

代码中可以看到两个线程同时需要访问share这个函数，你们share这个函数就是共享资源。调用的结果如下，可以看到输出的样子是惨不忍睹，非常错乱。

改进后如下

mutex m;
void share(string msg)
{
    m.lock();//当有线程访问时，对此区域进行上锁
    cout << msg << "调用共享资源" << endl;
    m.unlock();//使用完后解锁
}

void fun1()//线程1
{
    string msg = "线程1";
    for (int i = 0; i < 10; i++)
    {
        share(msg);
    }
}

void fun2()
{
    string msg = "线程2";
    for (int i = 0; i < 10; i++)
    {
        share(msg);
    }
}

int main()//主线程
{

    thread t1(fun1);
    thread t2(fun2);
    t1.join();
    t2.join();
    cout << "这是主线程" << endl;
    return 0;
}

lock_guard
解锁和上锁操作的优化版。lock_guard类没有拷贝构造、没有移动构造。类中只有构造和析构函数，所以用这个类定义的锁只能被开关，无法被复制等操作，并且在出作用域时，会自动销毁。

mutex m;
void share(string msg)
{
    lock_guard<mutex> lock(m);//m初始化直接上锁,离开这个函数被自动销毁
    cout << msg << "调用共享资源" << endl;
}

void fun1()//线程1
{
    string msg = "线程1";
    for (int i = 0; i < 10; i++)
    {
        share(msg);
    }
}

void fun2()
{
    string msg = "线程2";
    for (int i = 0; i < 10; i++)
    {
        share(msg);
    }
}

int main()//主线程
{
    
    thread t1(fun1);
    thread t2(fun2);
    t1.join();
    t2.join();
    cout << "这是主线程" << endl;
    return 0;
}

unique_lock
unique_lock 和lock_guard是十分相似的。区别在于unique_lock的构造函数有很多种，并且支持所有权的传递。

//unique_lock初始化方式和lock_guard一样时，效果和lock_guard一样
mutex m;
void share(string msg)
{
    unique_lock<mutex> lock(m);
    cout << msg << "调用共享资源" << endl;
}

void fun1()//线程1
{
    string msg = "线程1";
    for (int i = 0; i < 10; i++)
    {
        share(msg);
    }
}

void fun2()
{
    string msg = "线程2";
    for (int i = 0; i < 10; i++)
    {
        share(msg);
    }
}

int main()//主线程
{
    
    thread t1(fun1);
    thread t2(fun2);
    t1.join();
    t2.join();
    cout << "这是主线程" << endl;
    return 0;
}

第二个参数

adopt_lock：起标志作用，表示已经被上锁。在用这个参数之前，需要对锁进行lock操作

mutex m;
void share(string msg)
{
    m.lock();
    unique_lock<mutex> lock(m,adopt_lock);
    cout << msg << "调用共享资源" << endl;
}

try_to_lock:当m这把锁已经lock，unique_lock未获得这把锁的使用权，则输出没有获得锁，当在此之前未上锁，结果则相反。并且这个函数不会阻塞。

void share(string msg)
{
    m.lock();
    unique_lock<mutex> lock(m,try_to_lock);
    if (lock.owns_lock())
    {
        cout << msg << "调用共享资源" << endl;
    }
    else
    {
        cout << "未获得锁" << endl;
    }
    m.unlock();
}

所有权的传递以及释放锁的问题

void fun1()
{
    unique_lock<mutex> un1(m);
    unique_lock<mutex> un2(move(un1));//将m的所有权传递给un2
    unique_lock<mutex> un3(un2);//复制传递，违法

    mutex* ptr = un2.release();//释放un2的所有权，此时编程普通的锁，需要自己解锁
    cout << "子线程" << endl;
    ptr->unlock();
}

int main()//主线程
{
    thread t1(fun1);
    t1.join();
    cout << "这是主线程" << endl;
    return 0;
}