当前位置：首页 > news >正文

c++11多线程学习

news 来源：原创 2023/6/7 4:11:32

一.join和detach

C++中的thread对象通常来说表达了执行的线程（thread of execution），这是一个操作系统或者平台的概念。

当thread::join()函数被调用后，调用它的线程会被block，直到线程的执行被完成。基本上，这是一种可以用来知道一个线程已结束的机制。当thread::join()返回时，操作系统的执行的线程已经完成，C++线程对象可以被销毁。

当thread::detach()函数被调用后，执行的线程从线程对象中被分离，已不再被一个线程对象所表达--这是两个独立的事情。C++线程对象可以被销毁，同时OS执行的线程可以继续。如果程序想要知道执行的线程何时结束，就需要一些其它的机制。join()函数在那个thread对象上不能再被调用，因为它已经不再和一个执行的线程相关联。

去销毁一个仍然可以“joinable”的C++线程对象会被认为是一种错误。为了销毁一个C++线程对象，要么join()函数需要被调用（并结束），要么detach()函数被调用。如果一个C++线程对象当销毁时仍然可以被join，异常会被抛出。

因此，你应该在执行流程到析构函数前总是要么join，要么detach一个线程

https://www.cnblogs.com/LuckCoder/p/10950583.html

void function_1() {cout << "函数function_1\n";
}
int main() {thread t1(function_1);//t1.join();t1.detach();if (t1.joinable()) {t1.join();}return 0;
}

二.ref move

string s = "Main";thread t1(Fctor(), s);t1.join();thread t2(Fctor(), ref(s));t2.join();thread t3(Fctor(), move(s));t3.join();thread t4 = move(t3);cout << this_thread::get_id() << endl;cout << t3.get_id() << endl;cout << _Thrd_hardware_concurrency() << endl; //线程最大数

三.lock lock_guard unique_lock

lock：

void shared_print1(string id, int value) {
       m_mutex1.lock();
       cout << "From " << id << " " << value << endl;
       m_mutex1.unlock();
   }

lock_guard：

void shared_print1(string id, int value) {
       // 顺序不一样会发生死锁
       lock_guard<mutex> locker2(m_mutex2);
       lock_guard<mutex> locker1(m_mutex1);

       cout << "From " << id << " " << value << endl;
   }
   void shared_print2(string id, int value) {
       lock_guard<mutex> locker1(m_mutex1);
       lock_guard<mutex> locker2(m_mutex2);
       cout << "From " << id << " " << value << endl;
   }

要么使用lock函数：
lock(m_mutex1, m_mutex2);

unique_lock：

用法更加灵活，但占用更多cpu

void shared_print1(string id, int value) {
       unique_lock<mutex> locker(m_mutex1, defer_lock);
       //..
       locker.lock();
       cout << "From " << id << " " << value << endl;
       locker.unlock();
       //..

       locker.lock();
       //....
       locker.unlock();

       // 只能移动不能复制
       unique_lock<mutex> locker2 = move(locker);
   }

四.call_once

有些代码我们只进行一次，第一种需要不断加锁，第二种只会执行一次

{
           unique_lock<mutex> locker(m_mutex1, defer_lock);
           if (!f.is_open()) {
               f.open("log.txt");
           }

}
call_once(m_flag, [&]() {f.open("log.txt"); });

五.条件变量condition_variable

牵扯到解锁，只能用unique_lock

https://www.cnblogs.com/GuoXinxin/p/11675053.html

deque<int> q;
mutex mu;
condition_variable cond;
void function_1() {int count = 10;while (count > 0) {unique_lock<mutex> locker(mu);q.push_back(count);locker.unlock();cond.notify_one();//cond.notify_all(); //激活所有线程this_thread::sleep_for(chrono::seconds(1));count--;}
}
void function_2() {int data = 0;while (data != 1) {unique_lock<mutex> locker(mu);cond.wait(locker, []() {return !q.empty(); });data = q.back();q.pop_back();locker.unlock();cout << "t2 got a value from t1 : " << data << endl;}
}
int main() {thread t1(function_1);thread t2(function_2);t1.join();t2.join();

生产者消费者问题：

list<int> q;
mutex mu;
condition_variable cond;
int flag;
void function_1() {int count = 0;while (count < 10) {unique_lock<mutex> locker(mu);q.push_back(count);cout << "生产: " << count << endl;locker.unlock();cond.notify_one();count++;}flag = 1;
}
void function_2() {int tmp;while (1) {unique_lock<mutex> locker(mu);cond.wait_for(locker, chrono::seconds(1) ,[]() {return !q.empty(); });if (flag && q.empty()) {break;}tmp = q.front();q.pop_front();cout << "消费： " << tmp << endl;locker.unlock();}
}
int main() {thread t1(function_1);thread t2(function_2);t1.join();t2.join();

六.future promise async

https://blog.csdn.net/jiange_zh/article/details/51602938

int factorial(future<int>& fu) {int res = 1;int N = fu.get();for (int i = 1; i <= N; i++) res *= i;return res;
}
int main() {promise<int> p;future<int> fu = p.get_future();future<int> fu1 = async(launch::async, factorial, ref(fu));p.set_value(4);int x = fu1.get();cout << "Get from child: " << x << endl;

future：

可以处理所有在线程间数据转移的必要同步，但是future模型独享同步结果的所有权。并且通过　get()　函数，一次性的获取数据，让并发访问变的毫无意义。你的并发代码没有办法让多个线程等待同一个事件。

shared_future：

可以完成让多个线程的等待

	promise<int> p;future<int> fu = p.get_future();shared_future<int> sf = fu.share();future<int> fu1 = async(launch::async, factorial, sf);future<int> fu2 = async(launch::async, factorial, sf);future<int> fu3 = async(launch::async, factorial, sf);

七.创建线程的几种方式

https://blog.csdn.net/mmk27_word/article/details/108187405

八.packaged_task

九：时间约束

thread t1(factorial, 5);this_thread::sleep_for(chrono::milliseconds(3)); //时间段chrono::steady_clock::time_point tp = chrono::steady_clock::now() + chrono::milliseconds(3);this_thread::sleep_until(tp); // 时间点mutex mu;unique_lock<mutex> locker(mu);locker.try_lock_for(chrono::microseconds(3));locker.try_lock_until(tp);condition_variable cond;cond.wait_for(locker, chrono::microseconds(3));cond.wait_until(locker, tp);promise<int> p;future<int> f = p.get_future();f.wait_for(chrono::microseconds(3));f.wait_until(tp);