这篇“C++11线程、互斥量及条件变量怎么创建”文章的知识点大部分人都不太理解,所以小编给大家总结了以下内容,内容详细,步骤清晰,具有一定的借鉴价值,希望大家阅读完这篇文章能有所收获,下面我们一起来看看这篇“C++11线程、互斥量及条件变量怎么创建”文章吧。
C++11之前,C++语言没有对并发编程提供语言级别的支持,这使得我们在编程写可移植的并发程序时,存在诸多不便。现在C++11增加了线程以及线程相关的类,很方便地支持了并发编程,使得编写多线程程序的可移植性得到了很大的提高
//创建线程需要引入头文件thread #include<thread> #include<iostream> void ThreadMain() { cout << "begin thread main" << endl; } int main() { //创建新线程t并启动 thread t(ThreadMain); //主线程(main线程)等待t执行完毕 if (t.joinable()) //必不可少 { //等待子线程退出 t.join(); //必不可少 } return 0; }
我们都知道,对于一个单线程来说,也就main线程或者叫做主线程,所有的工作都是由main线程去完成的。而在多线程环境下,子线程可以分担main线程的工作压力,在多个CPU下,实现真正的并行操作。
在上述代码中,可以看到main线程创建并启动了一个新线程t,由新线程t去执行ThreadMain()函数,jion函数将会把main线程阻塞住,知道新线程t执行结束,如果新线程t有返回值,返回值将会被忽略
我们可以通过函数this_thread::get_id()来判断是t线程还是main线程执行任务
void ThreadMain() { cout << "线程" << this_thread::get_id()<< ":begin thread main" << endl; } int main() { //创建新线程t并启动 thread t(ThreadMain); //主线程(main线程)等待t执行完毕 if (t.joinable()) //必不可少 { //等待子线程退出 cout << "线程" << this_thread::get_id() << ":正在等待" << endl; t.join(); //必不可少 } return 0; }
执行结果:
void func() { cout << "do func" << endl; } int main() { thread t(func); return 0; }
上诉代码运行可能会抛出异常,因为线程对象t可能先于线程函数func结束,应该保证线程对象的生命周期在线程函数func执行完时仍然存在
为了防止线程对象的生命周期早于线程函数fun结束,可以使用线程等待join
void func() { while (true) { cout << "do work" << endl; this_thread::sleep_for(std::chrono::seconds(1));//当前线程睡眠1秒 } } int main() { thread t(func); if (t.joinable()) { t.join();//main线程阻塞 } return 0; }
虽然使用join能有效防止程序的崩溃,但是在某些情况下,我们并不希望main线程通过join被阻塞在原地,此时可以采用detach进行线程分离。但是需要注意:detach之后main线程就无法再和子线程发生联系了,比如detach之后就不能再通过join来等待子线程,子线程任何执行完我们也无法控制了
void func() { int count = 0; while (count < 3) { cout << "do work" << endl; count++; this_thread::sleep_for(std::chrono::seconds(1));//当前线程睡眠1秒 } } int main() { thread t(func); t.detach(); this_thread::sleep_for(std::chrono::seconds(1));//当前线程睡眠1秒 cout << "线程t分离成功" << endl; return 0; }
执行结果:
线程的创建和执行,无非是给线程指定一个入口函数嘛,例如main线程的入口函数就main()函数,前面编写的子线程的入口函数是一个全局函数。除了这些之外线程的入口函数还可以是函数指针、仿函数、类的成员函数、lambda表达式等,它们都有一个共同的特点:都是可调用对象。线程的入口函数指定,可以为任意一个可调用对象。
普通函数作为线程的入口函数
void func() { cout << "hello world" << endl; } int main() { thread t(func); if (t.joinable()) { t.join(); } return 0; }
类的成员函数作为线程的入口函数
class ThreadMain { public: ThreadMain() {} virtual ~ThreadMain(){} void SayHello(std::string name) { cout << "hello " << name << endl; } }; int main() { ThreadMain obj; thread t(&ThreadMain::SayHello, obj, "fl"); thread t1(&ThreadMain::SayHello, &obj, "fl"); t.join(); t1.join(); return 0; }
t和t1在传递参数时存在不同:
t是用对象obj调用线程函数的语句,即线程函数将在obj对象的上下文中运行。这里obj是通过值传递给线程构造函数的,因此在线程中使用的是对象obj的一个副本。这种方式适用于类定义在局部作用域中时,需要将其传递给线程的情况。
t1是使用对象的指针&obj调用线程函数的语句,即线程函数将在对象obj的指针所指向的上下文中运行。这里使用的是对象obj的指针,因此在线程中使用的是原始的obj对象。这种方式适用于类定义在全局或静态作用域中时,需要将其传递给线程的情况。
如果需要在类的成员函数中,创建线程,以类中的另一个成员函数作为入口函数,再执行
class ThreadMain { public: ThreadMain() {} virtual ~ThreadMain(){} void SayHello(std::string name) { cout << "hello " << name << endl; } void asycSayHello(std::string name) { thread t(&ThreadMain::SayHello, this, name); if (t.joinable()) { t.join(); } } }; int main() { ThreadMain obj; obj.asycSayHello("fl"); return 0; }
在asycSayHello的成员函数中,如果没有传递this指针,会导致编译不通过
原因就是参数列表不匹配,因此需要我们显示的传递this指针,表示以本对象的成员函数作为参数的入口函数
lambda表达式作为线程的入口函数
int main() { thread t([](int i){ cout << "test lambda i = " << i << endl; }, 123); if (t.joinable()) { t.join(); } return 0; }
执行结果:
在类的成员函数中,以lambda表达式作为线程的入口函数
class TestLmadba { public: void Start() { thread t([this](){ cout << "name is " << this->name << endl; }); if (t.joinable()) { t.join(); } } private: std::string name = "fl"; }; int main() { TestLmadba test; test.Start(); return 0; }
在类的成员函数中,以lambda表达式作为线程的入口函数,如果需要访问兑现的成员变量,也需要传递this指针
仿函数作为线程的入口函数
class Mybusiness { public: Mybusiness(){} virtual ~Mybusiness(){} void operator()(void) { cout << "Mybusiness thread id is " << this_thread::get_id() << endl; } void operator()(string name) { cout << "name is " << name << endl; } }; int main() { Mybusiness mb; thread t(mb); if (t.joinable()) { t.join(); } thread t1(mb, "fl"); if (t1.joinable()) { t1.join(); } return 0; }
执行结果:
线程t以无参的仿函数作为函数入口,而线程t1以有参的仿函数作为函数入口
函数指针作为线程的入口函数
void func() { cout << "thread id is " << this_thread::get_id() << endl; } void add(int a, int b) { cout << a << "+" << b << "=" << a + b << endl; } int main() { //采用C++11扩展的using来定义函数指针类型 using FuncPtr = void(*)(); using FuncPtr1 = void(*)(int, int); //使用FuncPtr来定义函数指针变量 FuncPtr ptr = &func; thread t(ptr); if (t.joinable()) { t.join(); } FuncPtr1 ptr1 = add; thread t1(ptr1, 1, 10); if (t1.joinable()) { t1.join(); } return 0; }
执行结果:
function和bind作为线程的入口函数
void func(string name) { cout << this_thread::get_id() << ":name is " << name << endl; } int main() { function<void(string)> f(func); thread t(f, "fl"); if (t.joinable()) { t.join(); } thread t1(bind(func, "fl")); if (t1.joinable()) { t1.join(); } return 0; }
执行结果:
线程不能拷贝和复制,但可以移动
//赋值操作 void func(string name) { cout << this_thread::get_id() << ":name is " << name << endl; } int main() { thread t1(func, "fl"); thread t2 = t1; thread t3(t1); return 0; }
编译报错:
在线程内部,已经将线程的赋值和拷贝操作delete掉了,所以无法调用到
//移动操作 void func(string name) { cout << this_thread::get_id() << ":name is " << name << endl; } int main() { thread t1(func, "fl"); thread t2(std::move(t1)); if (t1.joinable()) { t1.join(); } if (t2.joinable()) { t2.join(); } return 0; }
执行结果:
线程被移动之后,线程对象t1将不代表任何线程了,可以通过调试观察到
当多个线程同时访问同一个共享资源时,如果不加以保护或者不做任何同步操作,可能出现数据竞争或不一致的状态,导致程序运行出现问题。
为了保证所有的线程都能够正确地、可预测地、不产生冲突地访问共享资源,C++11提供了互斥量。
互斥量是一种同步原语,是一种线程同步手段,用来保护多线程同时访问的共享数据。互斥量就是我们平常说的锁
C++11中提供了4种语义的互斥量
std::mutex:独占的互斥量,不能递归
std::timed_mutex:带超时的独占互斥量,不能递归使用
std::recursive_mutex:递归互斥量,不能带超时功能
std::recursive_timed_mutex:带超时的递归互斥量
这些互斥量的接口基本类似,一般用法是通过lock()方法来阻塞线程,知道获得互斥量的所有权为止。在线程获得互斥量并完成任务之后,就必须使用unlock()来解除对互斥量的占用,lock()和unlock()必须成对出现。try_lock()尝试锁定互斥量,如果成功则返回true,失败则返回false,它是非阻塞的。
int num = 0; std::mutex mtx; void func() { for (int i = 0; i < 100; ++i) { mtx.lock(); num++; mtx.unlock(); } } int main() { thread t1(func); thread t2(func); if (t1.joinable()) { t1.join(); } if (t2.joinable()) { t2.join(); } cout << num << endl; return 0; }
执行结果:
使用lock_guard可以简化lock/unlock的写法,同时也更安全,因为lock_guard在构造时会自动锁定互斥量,而在退出作用域后进行析构时自动解锁,从而保证了互斥量的正确操作,避免忘记unlock操作,因此,尽量用lock_guard。lock_guard用到了RALL技术,这种技术在类的构造函数中分配资源,在析构函数中释放资源,保证资源在出了作用域之后就释放。上面的例子使用lock_guard后会更简介,代码如下:
void func() { for (int i = 0; i < 100; ++i) { lock_guard<mutex> lock(mtx); num++; } }
一般来说,当某个线程执行操作完毕后,释放锁,然后需要等待几十毫秒,让其他线程也去获取锁资源,也去执行操作。如果不进行等待的话,可能当前线程释放锁后,又立马获取了锁资源,会导致其他线程出现饥饿。
递归锁允许同一线程多次获得该互斥锁,可以用来解决同一线程需要多次获取互斥量时死锁的问题。在以下代码中,一个线程多次获取同一个互斥量时会发生死锁:
class Complex { public: std::mutex mtx; void SayHello() { lock_guard<mutex> lock(mtx); cout << "Say Hello" << endl; SayHi(); } void SayHi() { lock_guard<mutex> lock(mtx); cout << "say Hi" << endl; } }; int main() { Complex complex; complex.SayHello(); return 0; }
执行结果:
这个例子运行起来就发生了死锁,因为在调用SayHello时获取了互斥量,之后再调用SayHI又要获取相同的互斥量,但是这个互斥量已经被当前线程获取 ,无法释放,这时就会产生死锁,导致程序崩溃。
要解决这里的死锁问题,最简单的方法就是采用递归锁:std::recursive_mutex,它允许同一个线程多次获取互斥量
class Complex { public: std::recursive_mutex mtx;//同一线程可以多次获取同一互斥量,不会发生死锁 void SayHello() { lock_guard<recursive_mutex> lock(mtx); cout << "Say Hello" << endl; SayHi(); } void SayHi() { lock_guard<recursive_mutex> lock(mtx); cout << "say Hi" << endl; } };
执行结果:
需要注意的是尽量不要使用递归锁比较好,主要原因如下:
1、需要用到递归锁定的多线程互斥量处理往往本身就是可以简化的,允许递归互斥量很容易放纵复杂逻辑的产生,而非导致一些多线程同步引起的晦涩问题
2、递归锁的效率比非递归锁的效率低
3、递归锁虽然允许同一个线程多次获得同一个互斥量,但可重复的最大次数并为具体说明,一旦超过一定次数,再对lock进行调用就会抛出std::system错误
4.3 带超时的互斥量std::timed_mutex和std::recursive_timed_mutex
std::timed_mutex是超时的独占锁,srd::recursive_timed_mutex是超时的递归锁,主要用在获取锁时增加超时锁等待功能,因为有时不知道获取锁需要多久,为了不至于一直在等待获互斥量,就设置一个等待超时时间,在超时时间后还可做其他事。
std::timed_mutex比std::mutex多了两个超时获取锁的接口:try_lock_for和try_lock_until,这两个接口是用来设置获取互斥量的超时时间,使用时可以用一个while循环去不断地获取互斥量。
std::timed_mutex mtx; void work() { chrono::milliseconds timeout(100); while (true) { if (mtx.try_lock_for(timeout)) { cout << this_thread::get_id() << ": do work with the mutex" << endl; this_thread::sleep_for(chrono::milliseconds(250)); mtx.unlock(); } else { cout << this_thread::get_id() << ": do work without the mutex" << endl; this_thread::sleep_for(chrono::milliseconds(100)); } } } int main() { thread t1(work); thread t2(work); if (t1.joinable()) { t1.join(); } if (t2.joinable()) { t2.join(); } return 0; }
执行结果:
在上面的例子中,通过一个while循环不断地去获取超时锁,如果超时还没有获取到锁时就休眠100毫秒,再继续获取锁。
相比std::timed_mutex,std::recursive_timed_mutex多了递归锁的功能,允许同一个线程多次获得互斥量。std::recursive_timed_mutex和std::recursive_mutex的用法类似,可以看作在std::recursive_mutex的基础上增加了超时功能
lock_guard和unique_lock的功能完全相同,主要差别在于unique_lock更加灵活,可以自由的释放mutex,而lock_guard需要等到生命周期结束后才能释放。
它们的构造函数中都有第二个参数
unique_lock:
lock_guard:
可以从源码中看到,unique_lock的构造函数中,第二个参数的种类有三种,分别是adopt_lock,defer_lock和try_to_lock。lock_guard的构造函数中,第二个参数的种类只有一种,adopt_lock
这些参数的含义分别是:
adopt_lock:互斥量已经被lock,构造函数中无需再lock(lock_ guard与unique_lock通用)
defer_lock:互斥量稍后我会自行lock,不需要在构造函数中lock,只初始化一个没有加锁的mutex
try_to_lock:主要作用是在不阻塞线程的情况下尝试获取锁,如果互斥量当前未被锁定,则返回std::unique_lock对象,该对象拥有互斥量并且已经被锁定。如果互斥量当前已经被另一个线程锁定,则返回一个空的std::unique_lock对象
mutex mtx; void func() { //mtx.lock();//需要加锁,否则在lock的生命周期结束后,会自动解锁,则会导致程序崩溃 unique_lock<mutex> lock(mtx, std::adopt_lock); cout << this_thread::get_id() << " do work" << endl; } int main() { thread t(func); if (t.joinable()) { t.join(); } return 0; }
执行结果:
adopt_lock就表示构造unique_lock<mutex>时,认为mutex已经加过锁了,就不会再加锁了,它就把加锁的权限和时机交给了我们,由我们自己控制
mutex mtx; void func() { while (true) { unique_lock<mutex> lock(mtx, std::defer_lock); cout << "func thread id is " << this_thread::get_id() << endl; this_thread::sleep_for(chrono::milliseconds(500)); } } int main() { thread t1(func); thread t2(func); if (t1.joinable()) { t1.join(); } if (t2.joinable()) { t2.join(); } return 0; }
执行结果:
本来我们的意愿是t1和t2每个时刻只能有一个线程打印"func thread id is…",但是实际上却发生了竞争的关系,原因就在于defer_lock在构造unique_lock<mutex>时,认为mutex在后面会加锁,也就没有加锁,所以打印结果才发生混乱,因此需要我们手动改进一下
void func() { while (true) { unique_lock<mutex> lock(mtx, std::defer_lock); lock.lock(); cout << "func thread id is " << this_thread::get_id() << endl; this_thread::sleep_for(chrono::milliseconds(500)); //lock.unlock(); //可以加,也可以不加 //因为内部有一个标准为,如果我们自己手动解锁了,由于标志位的改变,在调用lock的析构函数时,就不会进行解锁操作 } }
执行结果:
为了保证在多线程环境中某个函数仅被调用一次,比如,需要在初始化某个对象,而这个对象只能初始化一次时,就可以用std::call_once来保证函数在多线程环境中只能被调用一次。使用std::call_once时,需要一个once_flag作为call_once的入参,用法比较简单
call_once函数模板
在使用call_once时,第一个参数是类型为once_flag的标志位,第二个参数是一个可调用对象,第三个为可变参数,表示的可调用对象中的参数
std::once_flag flag; void do_once() { std::call_once(flag, [](){ cout << "call once" << endl; }); } int main() { const int ThreadSize = 5; vector<thread> threads; for (int i = 0; i < ThreadSize; ++i) { threads.emplace_back(do_once); } for (auto& t : threads) { if (t.joinable()) { t.join(); } } return 0; }
执行结果:
条件变量是C++11提供的另外一种用于等待的同步机制,它能够阻塞一个或者多个贤臣,直到收到另一个线程发出的通知或者超时,才会唤醒当前阻塞的线程。条件变量需要和互斥量配合起来使用。C++11提供了两种条件变量:
condition_valuable,配合std::unique<mutex>进行wait操作
condition_valuable_any,和任意带有lock,unlock语义的mutex搭配使用,比较灵活,但效率比condition_valuable差一些
可以看到condition_valuable_any比condition_valuable更灵活,因为它通用,对所有的锁都适用,而condition_valuable的性能更好。我们应该根据具体的应用场景来选择合适的条件变量
条件变量的使用条件如下:
拥有条件变量的线程获取互斥量
循环检测某个条件,如果条件不满足,则阻塞直到条件满足;如果条件满足,则向下执行
某个线程满足条件执行完毕之后调用notify_onc或者notify_all唤醒一个或者所有等待的线程
一个简单的生产者消费者模型
mutex mtx; condition_variable_any notEmpty;//没满的条件变量 condition_variable_any notFull;//不为空的条件变量 list<string> list_; //缓冲区 const int custom_threads_size = 3;//消费者的数量 const int produce_threads_size = 4;//生产者的数量 const int max_size = 10; void produce(int i) { while (true) { lock_guard<mutex> lock(mtx); notEmpty.wait(mtx, []{ return list_.size() != max_size; }); stringstream ss; ss << "生产者" << i << "生产的东西"; list_.push_back(ss.str()); notFull.notify_one(); } } void custome(int i) { while (true) { lock_guard<mutex> lock(mtx); notFull.wait(mtx, []{ return !list_.empty(); }); cout << "消费者" << i << "消费了 " << list_.front() << endl; list_.pop_front(); notEmpty.notify_one(); } } int main() { vector<std::thread> producer; vector<std::thread> customer; for (int i = 0; i < produce_threads_size; ++i) { producer.emplace_back(produce, i); } for (int i = 0; i < custom_threads_size; ++i) { customer.emplace_back(custome, i); } for (int i = 0; i < produce_threads_size; ++i) { producer[i].join(); } for (int i = 0; i < custom_threads_size; ++i) { customer[i].join(); } return 0; }
在上述案例中,list<string> list_是一个临界资源,无论是生产者生产数据,还是消费者消费数据,都要往list_中插入数据或者删除数据,为了防止出现数据竞争或不一致的状态,导致程序运行出现问题,因为每次操作list_时都需要进行加锁操作。
当list_没有满的情况下,生产者可以生产数据,如果满了,则会阻塞在条件变量notFull下,需要消费者通过notify_one()随机唤醒一个生产者。
当list_不为空的情况下。消费者可以消费数据,如果空了,则会阻塞在条件变量notEmpty下,需要生产者通过notify_one()随机唤醒一个消费者。
以上就是关于“C++11线程、互斥量及条件变量怎么创建”这篇文章的内容,相信大家都有了一定的了解,希望小编分享的内容对大家有帮助,若想了解更多相关的知识内容,请关注亿速云行业资讯频道。
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。