USB迷 | 专注于互联网分享

    最新消息： USBMI致力于为网友们分享Windows、安卓、IOS等主流手机系统相关的资讯以及评测、同时提供相关教程、应用、软件下载等服务。
    你的位置： 首页 > 维修 > thread类

    thread类

    维修 admin 56浏览 0评论

    thread类

    目录

    • 引言
    • thread类介绍
    • 原子性操作库(atomic)
    • lock_guard与unique_lock
      • lock_guard
      • unique_lock

    引言

    在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接
    口，这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了，使得C++在
    并行编程时不需要依赖第三方库。要使用标准库中的线程，必须包含< thread >头文件。

    thread类介绍

    函数名功能

    • thread() ：构造一个线程对象，没有关联任何线程函数，即没有启动任何线程

    • thread(fn,args1, args2,…)：构造一个线程对象，并关联线程函数fn，args1，args2，…为线程函数的参数

    • get_id()：获取线程id

    • jionable() ：判断线程是否还在执行，joinable代表的是一个正在执行中的线程。

    • jion() ：该函数调用后会阻塞住线程，当该线程结束后，主线程继续执行

    • detach()：在创建线程对象后马上调用，用于把被创建线程与线程对象分离开，分离
      的线程变为后台线程，创建的线程的"死活"就与主线程无关

    线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态。
    当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程。

    当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。
    线程函数一般情况下可按照以下三种方式提供：

    • 函数指针
    • lambda表达式
    • 函数对象

    以下为创建线程对象并关联线程函数实例：

    #include <iostream>
using namespace std;
#include <thread>void ThreadFunc(int a)
{cout << "Thread1" << a << endl;
}
class TF
{
public:void operator()(){cout << "Thread3" << endl;}
};
int main()
{// 线程函数为函数指针thread t1(ThreadFunc, 10);// 线程函数为lambda表达式thread t2([] {cout << "Thread2" << endl; });// 线程函数为函数对象TF tf;thread t3(tf);t1.join();t2.join();t3.join();cout << "Main thread!" << endl;return 0;
}

    传入参数需要注意的一些细节：
    例如如果传入引用类型的话，需要加上ref进行转化。

    class A
{
public:void fun1(int a, int b){cout << "fun1(int, int)" << a << b << endl;}
};void fun(int& a)
{a *= 2;
}void fun1(int* ptr)
{*ptr *= 2;
}int main()
{A a;//成员函数需要显示取地址，隐含的this指针地址也要传入thread t1(&A::fun1, &a, 10, 20);t1.join();int a2 = 1;thread t2(fun, a2);t2.join();cout << a2 << endl;thread t3(fun1, &a2);t3.join();cout << a2 << endl;//参数如果为引用类型，需要加ref转换thread t4(fun, ref(a2));t4.join();cout << a2 << endl;return 0;
}

    原子性操作库(atomic)

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

    int sum = 0;void fun(int n)
{for (int i = 0; i < n; ++i){sum++;}
}
    • C++98中传统的解决方式：可以对共享修改的数据可以加锁保护。
    #include<mutex>int sum = 0;
mutex mtx;void fun(int n)
{for (int i = 0; i < n; ++i){mtx.lock();sum++;mtx.unlock();}
}

    虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。

    • 因此C++11中引入了原子操作。

    所谓原子操作：即不可被中断的一个或一系列操作，C++11引入的原子操作类型，使得线程间数据的同步变得非常高效。

    #include<atomic>atomic<int> sum(0);void fun(int n)
{for (int i = 0; i < n; ++i){sum++;}
}

    lock_guard与unique_lock

    在多线程环境下，如果想要保证某个变量的安全性，只要将其设置成对应的原子类型即可，即高效又不容易出现死锁问题。但是有些情况下，我们可能需要保证一段代码的安全性，那么就只能通过锁的方式来进行控制。

    mutex mtx;
void fun1()
{mtx.lock();cout << "fun1()" << endl;int n;cin >> n;if (n == 0)return;mtx.unlock();
}

    上述代码的缺陷：锁控制不好时，可能会造成死锁，最常见的比如在锁中间代码返回，或者在锁的范围内抛异常。

    lock_guard

    通过RAII的方式，对其管理的互斥量进行了封装，在需要加锁的地方，只需要实例化一个lock_guard，调用构造函数成功上锁，出作用域前，lock_guard对象要被销毁，调用析构函数自动解锁，可以有效避免死锁
    问题    。

    mutex mtx;template <class Mtx>
class LockGuard
{
public:LockGuard(Mtx& mtx):_mtx(mtx){_mtx.lock();}~LockGuard(){_mtx.unlock();}//防拷贝LockGuard(const  LockGuard<Mtx>& lg) = delete;LockGuard& operator=(const  LockGuard<Mtx>& lg) = delete;
private:Mtx& _mtx;
};void fun1()
{LockGuard<mutex> lg(mtx);//mtx.lock();cout << "fun1()" << endl;int n;cin >> n;if (n == 0)return;//mtx.unlock();
}

    lock_guard的缺陷：太单一，用户没有办法对该锁进行控制

    unique_lock

    与lock_guard不同的是，unique_lock更加的灵活，提供了更多的成员函数：

    • 上锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until和unlock
    • 修改操作：移动赋值、交换(swap：与另一个unique_lock对象互换所管理的互斥量所有权)、释放(release：返回它所管理的互斥量对象的指针，并释放所有权)
    • 获取属性：owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相同)、mutex(返回当前unique_lock所管理的互斥量的指针)。

    thread类

    目录

    • 引言
    • thread类介绍
    • 原子性操作库(atomic)
    • lock_guard与unique_lock
      • lock_guard
      • unique_lock

    引言

    在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接
    口，这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了，使得C++在
    并行编程时不需要依赖第三方库。要使用标准库中的线程，必须包含< thread >头文件。

    thread类介绍

    函数名功能

    • thread() ：构造一个线程对象，没有关联任何线程函数，即没有启动任何线程

    • thread(fn,args1, args2,…)：构造一个线程对象，并关联线程函数fn，args1，args2，…为线程函数的参数

    • get_id()：获取线程id

    • jionable() ：判断线程是否还在执行，joinable代表的是一个正在执行中的线程。

    • jion() ：该函数调用后会阻塞住线程，当该线程结束后，主线程继续执行

    • detach()：在创建线程对象后马上调用，用于把被创建线程与线程对象分离开，分离
      的线程变为后台线程，创建的线程的"死活"就与主线程无关

    线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态。
    当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程。

    当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。
    线程函数一般情况下可按照以下三种方式提供：

    • 函数指针
    • lambda表达式
    • 函数对象

    以下为创建线程对象并关联线程函数实例：

    #include <iostream>
using namespace std;
#include <thread>void ThreadFunc(int a)
{cout << "Thread1" << a << endl;
}
class TF
{
public:void operator()(){cout << "Thread3" << endl;}
};
int main()
{// 线程函数为函数指针thread t1(ThreadFunc, 10);// 线程函数为lambda表达式thread t2([] {cout << "Thread2" << endl; });// 线程函数为函数对象TF tf;thread t3(tf);t1.join();t2.join();t3.join();cout << "Main thread!" << endl;return 0;
}

    传入参数需要注意的一些细节：
    例如如果传入引用类型的话，需要加上ref进行转化。

    class A
{
public:void fun1(int a, int b){cout << "fun1(int, int)" << a << b << endl;}
};void fun(int& a)
{a *= 2;
}void fun1(int* ptr)
{*ptr *= 2;
}int main()
{A a;//成员函数需要显示取地址，隐含的this指针地址也要传入thread t1(&A::fun1, &a, 10, 20);t1.join();int a2 = 1;thread t2(fun, a2);t2.join();cout << a2 << endl;thread t3(fun1, &a2);t3.join();cout << a2 << endl;//参数如果为引用类型，需要加ref转换thread t4(fun, ref(a2));t4.join();cout << a2 << endl;return 0;
}

    原子性操作库(atomic)

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

    int sum = 0;void fun(int n)
{for (int i = 0; i < n; ++i){sum++;}
}
    • C++98中传统的解决方式：可以对共享修改的数据可以加锁保护。
    #include<mutex>int sum = 0;
mutex mtx;void fun(int n)
{for (int i = 0; i < n; ++i){mtx.lock();sum++;mtx.unlock();}
}

    虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。

    • 因此C++11中引入了原子操作。

    所谓原子操作：即不可被中断的一个或一系列操作，C++11引入的原子操作类型，使得线程间数据的同步变得非常高效。

    #include<atomic>atomic<int> sum(0);void fun(int n)
{for (int i = 0; i < n; ++i){sum++;}
}

    lock_guard与unique_lock

    在多线程环境下，如果想要保证某个变量的安全性，只要将其设置成对应的原子类型即可，即高效又不容易出现死锁问题。但是有些情况下，我们可能需要保证一段代码的安全性，那么就只能通过锁的方式来进行控制。

    mutex mtx;
void fun1()
{mtx.lock();cout << "fun1()" << endl;int n;cin >> n;if (n == 0)return;mtx.unlock();
}

    上述代码的缺陷：锁控制不好时，可能会造成死锁，最常见的比如在锁中间代码返回，或者在锁的范围内抛异常。

    lock_guard

    通过RAII的方式，对其管理的互斥量进行了封装，在需要加锁的地方，只需要实例化一个lock_guard，调用构造函数成功上锁，出作用域前，lock_guard对象要被销毁，调用析构函数自动解锁，可以有效避免死锁
    问题    。

    mutex mtx;template <class Mtx>
class LockGuard
{
public:LockGuard(Mtx& mtx):_mtx(mtx){_mtx.lock();}~LockGuard(){_mtx.unlock();}//防拷贝LockGuard(const  LockGuard<Mtx>& lg) = delete;LockGuard& operator=(const  LockGuard<Mtx>& lg) = delete;
private:Mtx& _mtx;
};void fun1()
{LockGuard<mutex> lg(mtx);//mtx.lock();cout << "fun1()" << endl;int n;cin >> n;if (n == 0)return;//mtx.unlock();
}

    lock_guard的缺陷：太单一，用户没有办法对该锁进行控制

    unique_lock

    与lock_guard不同的是，unique_lock更加的灵活，提供了更多的成员函数：

    • 上锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until和unlock
    • 修改操作：移动赋值、交换(swap：与另一个unique_lock对象互换所管理的互斥量所有权)、释放(release：返回它所管理的互斥量对象的指针，并释放所有权)
    • 获取属性：owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相同)、mutex(返回当前unique_lock所管理的互斥量的指针)。
    继续浏览有关 的文章

    与本文相关的文章

    发布评论

    评论列表 (0)

    1. 暂无评论