c++ 线程库

线程

        在编程中，线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。线程自身不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可以与同属进程的其他线程共享进程所拥有的全部资源。

        使用线程,可以实现一段程序不同的地方并发的执行,极大的提高运行效率

        在c++11之前,线程库主要由操作系统或第三方软件提供,linux下为pthread库,windows下为Win32 API ,这样的代码可移植性较差,c++11引入了线程库thread ,这样做可以把可移植性问题交给不同平台的编译器,减少了出问题的概率.

创建线程与线程赋值

        线程不支持拷贝构造和拷贝赋值

#include <thread>
void fun(string str)
{
    cout << str << endl;
}
int main() {
    thread t1(fun, "helloworld");
    thread t2;
    // t2 = t1;                   错误,不支持赋值重载
    // t2 = move(t1);             不报错,但不应该这么写
    t2 = thread(fun, "helloworld"); // 正确,支持移动构造和移动赋值

    t1.join();
    t2.join();
    system("pause");
    return 0;
}

常用类方法

• join()     线程等待,一般用于主线程(如果主线程先于其他线程退出,此时其他线程的资源没人可以回收,就会报错)
• get_id()  返回线程id,类型为thread::id 
• joinable() 返回一个布尔值,如果该线程没有被回收返回true,否则为false
• detach()  将本线程与主线程分离开,二者不再有联系(慎用!!!)

线程函数参数为引用时

        由于线程不支持拷贝构造与拷贝赋值,所以线程在构造时使用的是参数的拷贝,如果函数的一个参数为引用,将无法实现传递,这时就需要一个神奇的函数ref

​
void fun(int& a)
{
    ++a;
    cout << a << endl;
}

int main() {
    int a = 0;

    thread t[5];
    for (int i = 0; i < 5; i++) {
        // t[i] = thread(fun, a);  // 错误,引用无法直接传递
        t[i] = thread(fun, ref(a));     //引用需要调用 ref 

    }
    for (int i = 0; i < 5; i++) {
        t[i].join();
    }
    cout << a << endl;
    system("pause");
    return 0;
}

​

原子性操作

        多线程最主要的问题是共享数据带来的问题( 即线程安全 ) 。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦 。

        传统的解决方案是通过加锁保证同一时间内只允许一个线程进行修改和操作数据,不过这种方式也存在一些问题,比如当代码不是很长而加锁部分占据代码的很大一部分时,将会非常影响效率

        在c++11中引入了一种新的解决方案,即原子操作,原子操作是指不可被中断的一个或一系列操作,适当的使用原子操作会比锁的效率更高

        需包含头文件 <atomin>

对于内置类型

也可自定义类型

atmoic < T > t ;     // 声明一个类型为 T 的原子类型变量 t

#include <atomic>
int main()
{
 atomic<int> a1(0);
 //atomic<int> a2(a1);   // 编译失败
 atomic<int> a2(0);
 //a2 = a1;               // 编译失败
 return 0; }

锁

需包含头文件 mutex

头文件mutex包含4种锁

1.std::mutex 

• lock  上锁
• unlock 解锁
• try_lock  尝试去锁

• 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前,该线程一直拥有该锁
• 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住
• 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

• 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock释放互斥量
• 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉
• 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)