小编给大家分享一下C++中Boost多线程、线程同步的示例分析，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！
计算
安全
数据库
网络和加速
企业服务
线程的创建 boost_thread,boost_system
多线程的创建
线程的参数传递
线程的创建方式
线程的join
加入join,回收线程
线程中断
线程中断2,
线程组
boost 线程的死锁
boost 线程递归锁
线程互斥锁,线程同步
unique_lock 锁,离开作用域自动释放
unique_lock 锁 示例 2,可以显式的释放锁
boost 1次初始化
boost 条件变量
boost 线程锁,一个账户往另外一个账户转钱案例
boost upgrade_lock知识背景:
理解什么是线程,什么是进程,区别是什么,如何使用多进程多线程
线程的创建 boost_thread,boost_system
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
void fun()
{
cout << "Hello Boost threads !" << endl;
}
int main()
{
boost::thread t1(fun);
t1.join();
return 0;
}
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
Hello Boost threads !
chunli@Linux:~/boost$多线程的创建
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
void fun1(){cout << "Hello Boost threads 1!" << endl;}
void fun2(){cout << "Hello Boost threads 2!" << endl;}
void fun3(){cout << "Hello Boost threads 3!" << endl;}
int main()
{
boost::thread t1(fun1); t1.join();
boost::thread t2(fun2); t2.join();
boost::thread t3(fun3); t3.join();
return 0;
}
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
Hello Boost threads 1!
Hello Boost threads 2!
Hello Boost threads 3!
chunli@Linux:~/boost$线程的参数传递
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
void fun1(const int &id){cout << "threads id "<<id << endl;}
void fun2(const int &id){cout << "threads id "<<id << endl;}
void fun3(const int &id){cout << "threads id "<<id << endl;}
int main()
{
boost::thread t1(fun1,1); t1.join();
boost::thread t2(fun2,2); t2.join();
boost::thread t3(fun3,3); t3.join();
return 0;
}
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
threads id 1
threads id 2
threads id 3
chunli@Linux:~/boost$线程的创建方式
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
void fun1(const int &id)
{
cout << "threads id "<<id << endl;
}
struct MyThread
{
void operator()(const int &id)
{
cout << "threads id "<<id << endl;
}
void fun(const int &id)
{
cout << "threads id "<<id << endl;
}
};
int main()
{
boost::thread t1(fun1,1);//自由函数
t1.join();
MyThread mythread;
boost::thread t2(mythread,2);//函数对象
t2.join();
boost::thread t3(&MyThread::fun,mythread,3); //成员函数
t3.join();
boost::thread t4(MyThread(),4); //临时对象
t4.join();
boost::thread t5(boost::ref(mythread),5);//对象引用
t5.join();
return 0;
}
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
threads id 1
threads id 2
threads id 3
threads id 4
threads id 5
chunli@Linux:~/boost$线程的join
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
void fun1(const int &id){cout << "threads id "<<id << endl;}
int main()
{
boost::thread t1(fun1,1);
//t1.join();
cout << "main end!" << endl;
return 0;
}
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
main end!
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
main end!threads id 1
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
main end!
threads id 1
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
main end!
threads id 1chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
main end!
threads id 1
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
main end!
threads id 1
chunli@Linux:~/boost$
可以看出,如果没有join的等待,结果是不可预期的.加入join,回收线程
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
void fun1(const int &id){cout << "threads id "<<id << endl;}
int main()
{
boost::thread t1(fun1,1);
t1.join();
cout << "main end!" << endl;
return 0;
}
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
threads id 1
main end!
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
threads id 1
main end!
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
threads id 1
main end!
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
threads id 1
main end!
chunli@Linux:~/boost$线程中断
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
void f1(const int& id)
{
cout << "thread #" << id << ": started" << endl;
boost::system_time const timeout = boost::get_system_time()+ boost::posix_time::seconds(3);
thread::sleep(timeout);//sleep不会放弃时间片
cout << "thread #" << id << ": ended" << endl;
}
void f2(const int& id)
{
cout << "thread #" << id << ": started" << endl;
thread::yield();//预定义中断点.主动放弃时间片
cout << "thread #" << id << ": ended" << endl;
}
void f3(const int& id)
{
cout << "thread #" << id << ": started" << endl;
boost::this_thread::interruption_point();//预定义中断点
cout << "thread #" << id << ": ended" << endl;
}
int main()
{
thread t1(f1, 1); t1.interrupt();
thread t2(f2, 2);
thread t3(f3, 3); t3.interrupt();
t1.join();
t2.join();
t3.join();
}
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
thread #2: started
thread #1: started
thread #3: started
thread #2: ended
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
thread #1: started
thread #3: started
thread #2: started
thread #2: ended
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
thread #thread #2: started1: started
thread #3: started
thread #2: ended
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
thread #3: started
thread #1: started
thread #2: started
thread #2: ended
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
thread #2: started
thread #3: started
thread #thread #2: ended
1: started
chunli@Linux:~/boost$
只有2线程不会被打断线程中断2,
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
void print(const int& id)
{
boost::this_thread::disable_interruption di;//创建一个不可被打断的对象
cout << boost::this_thread::interruption_enabled() << endl;
cout << "thread #" << id << ": ";
//boost::this_thread::sleep(boost::posix_time::seconds(2));
boost::system_time const timeout = boost::get_system_time() + boost::posix_time::seconds(2);
thread::sleep(timeout);
for (int i = 1; i < 11; ++i)
{
cout << i << ' ';
}
cout << endl;
boost::this_thread::restore_interruption ri(di);//到这里,对象不可被打断
cout << boost::this_thread::interruption_enabled() << endl;
//实际上,是可以被打断
}
int main()
{
//线程还没有运行结束,叫被打断
thread t1(print, 1);
thread t2(print, 2);
thread t3(print, 3); t3.interrupt();
t1.join();
t2.join();
t3.join();
}
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
0
thread #1: 0
thread #3: 0
thread #2: 1 2 3 4 5 6 7 8 9 10
1
1 2 3 4 5 6 7 8 9 10
1
1 2 3 4 5 6 7 8 9 10
1
chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out
0
thread #1: 0
thread #2: 0
thread #3: 1 2 3 4 5 6 7 8 9 10
1
1 2 3 4 5 6 7 8 9 10
1
1 2 3 4 5 6 7 8 9 10
1
chunli@Linux:~/boost$
线程组
chunli@Linux:~/桌面/qt_pro/01/untitled$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
void f1(){ cout << "fun1 " << endl;}
void f2(){ cout << "fun2 " << endl;}
int main()
{
boost::thread_group group;
for(int i = 0;i<3;++i)
{
group.create_thread(f1);
}
group.add_thread(new boost::thread(f2));
cout<<group.size()<<endl;
group.join_all();
}
chunli@Linux:~/桌面/qt_pro/01/untitled$ g++ main.cpp -lboost_thread -lboost_system -Wall && ./a.out
fun1 4
fun1
fun2
fun1
chunli@Linux:~/桌面/qt_pro/01/untitled$ g++ main.cpp -lboost_thread -lboost_system -Wall && ./a.out
fun1
fun1
fun1
4
fun2
chunli@Linux:~/桌面/qt_pro/01/untitled$boost 线程的死锁
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
boost::mutex m;
void function1()
{
m.lock();
cout << "function 1 \n";
m.unlock();
}
void function2()
{
m.lock();
cout << "function 2 \n";
function1();
m.unlock();
}
int main()
{
thread t1(function1); t1.join();
thread t2(function2); t2.join();
}
chunli@Linux:~/boost$ g++ main.cpp -lboost_thread -lboost_system&& ./a.out
function 1
function 2
^C
chunli@Linux:~/boost$boost 线程递归锁
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
boost::recursive_mutex m;
void function1()
{
m.lock();
cout << "function 1 \n";
m.unlock();
}
void function2()
{
m.lock();
cout << "function 2 \n";
function1();
m.unlock();
}
int main()
{
thread t1(function1); t1.join();
thread t2(function2); t2.join();
}
chunli@Linux:~/boost$ g++ main.cpp -lboost_thread -lboost_system -lpthread && ./a.out
function 1
function 2
function 1
chunli@Linux:~/boost$线程互斥锁,线程同步
boost::mutex m;
void function1(int id)
{
m.lock();
cout <<"thread #"<<id<<":";
for(int i=0;i<15;i++)
cout << i<<' ';
cout << endl;
m.unlock();
}
int main()
{
thread t1(function1,1); t1.join();
thread t2(function1,2); t2.join();
thread t3(function1,3); t3.join();
thread t4(function1,4); t4.join();
thread t5(function1,5); t5.join();
thread t6(function1,6); t6.join();
}
chunli@Linux:~/boost$ g++ main.cpp -lboost_thread -lboost_system -lpthread && ./a.out
thread #1:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
thread #2:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
thread #3:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
thread #4:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
thread #5:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
thread #6:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
chunli@Linux:~/boost$unique_lock 锁,离开作用域自动释放
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <list>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
boost::mutex m;
int k = 0;
void decrement()
{
boost::unique_lock<boost::mutex> lock(m);
for(int i = 0;i<=100;++i)
{
k-=i;
}
cout << "after decrement k="<<k << endl;
}
void increment()
{
boost::unique_lock<boost::mutex> lock(m);
for(int i = 0;i<=100;++i)
{
k+=i;
}
cout << "after increment k="<<k << endl;
}
int main()
{
boost::thread t1(increment); t1.join();
boost::thread t2(decrement); t2.join();
}
chunli@Linux:~/boost$ g++ main.cpp -lboost_thread -lboost_system -lpthread && ./a.out
after increment k=5050
after decrement k=0
chunli@Linux:~/boost$unique_lock 锁 示例 2,可以显式的释放锁
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <vector>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
boost::mutex m;
void updateString()
{
boost::unique_lock<boost::mutex> lock(m);//lock
lock.unlock();//unlock
lock.lock();
}
int main()
{
thread t1(updateString); t1.join();
thread t2(updateString); t2.join();
}
chunli@Linux:~/boost$ g++ main.cpp -lboost_thread -lboost_system -lpthread && ./a.out
chunli@Linux:~/boost$boost 1次初始化
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
boost::once_flag once = BOOST_ONCE_INIT; // 注意这个操作不要遗漏了
void func() {
cout << "Will be called but one time!" << endl;
}
void threadFunc() {
// func();
boost::call_once(&func, once);
}
int main() {
boost::thread_group threads;
for (int i = 0; i < 5; ++i)
threads.create_thread(&threadFunc);
threads.join_all();
}
chunli@Linux:~/boost$ g++ main.cpp -lboost_thread -lboost_system && ./a.out
Will be called but one time!
chunli@Linux:~/boost$boost 条件变量
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
boost::condition_variable cond; // 关联多个线程的条件变量
boost::mutex m; // 保护共享资源 k 的互斥体
int k = 0; // 共享资源
void f1(const int& id)
{
boost::unique_lock<boost::mutex> lock(m);
while (k < 5)
{
cout << "thread #" << id << ": k < 5, waiting ..." << endl;
cond.wait(lock); // #1
}
cout << "thread #" << id << ": now k >= 5, printing ..." << endl;
}
void f2(const int& id)
{
boost::unique_lock<boost::mutex> lock(m);
cout << "thread #" << id << ": k will be changed ..." << endl;
k += 5;
cond.notify_all(); // #2 不需lock
}
int main() {
// 如果f2()中是 cond.notify_one()，结果？
boost::thread t1(f1, 1);
boost::thread t2(f1, 2);
boost::thread t3(f2, 100);
t1.join();
t2.join();
t3.join();
}
chunli@Linux:~/boost$ g++ main.cpp -lboost_thread -lboost_system && ./a.out
thread #1: k < 5, waiting ...
thread #2: k < 5, waiting ...
thread #100: k will be changed ...
thread #1: now k >= 5, printing ...
thread #2: now k >= 5, printing ...
chunli@Linux:~/boost$boost 线程锁,一个账户往另外一个账户转钱案例
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
class Account {
boost::mutex m;
double balance;
public:
Account() :
balance() {
}
Account(const double& bal) :
balance(bal) {
}
double getBalance() const {
return balance;
}
friend void transfer(Account& from, Account& to, double amount);
};
//// version 3: OK （使用lock() 和 unique_lock）
//void transfer(Account& from, Account& to, double amount) {
// boost::lock(from.m, to.m);
// boost::unique_lock<boost::mutex> lockFrom(from.m, boost::adopt_lock);
// boost::unique_lock<boost::mutex> lockTo(to.m, boost::adopt_lock);
//
// from.balance -= amount;
// to.balance += amount;
//}
// version 2: OK （使用lock() 和 lock_guard）
void transfer(Account& from, Account& to, double amount) {
boost::lock(from.m, to.m);
boost::lock_guard<boost::mutex> lockFrom(from.m, boost::adopt_lock);
boost::this_thread::sleep(boost::posix_time::seconds(1));
boost::lock_guard<boost::mutex> lockTo(to.m, boost::adopt_lock);
from.balance -= amount;
to.balance += amount;
}
// version 1: 可能造成死锁
//void transfer(Account& from, Account& to, double amount) {
// boost::lock_guard<boost::mutex> lockFrom(from.m); // #1
// boost::this_thread::sleep(boost::posix_time::seconds(1));
// boost::lock_guard<boost::mutex> lockTo(to.m); // #2
// from.balance -= amount;
// to.balance += amount;
//}
int main() {
Account a1(1200.00);
Account a2(300.00);
boost::thread t1(transfer, boost::ref(a1), boost::ref(a2), 134.85);
boost::thread t2(transfer, boost::ref(a2), boost::ref(a1), 100.30);
t1.join();
t2.join();
cout << "Balance of a1: " << a1.getBalance() << endl;
cout << "Balance of a2: " << a2.getBalance() << endl;
}
chunli@Linux:~/boost$ g++ main.cpp -lboost_thread -lboost_system -lpthread && ./a.out
Balance of a1: 1165.45
Balance of a2: 334.55
chunli@Linux:~/boost$boost upgrade_lock
chunli@Linux:~/boost$ cat main.cpp
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using boost::thread;
boost::shared_mutex m;
int k = 1;
void f(int id) {
boost::upgrade_lock<boost::shared_mutex> lock(m);
cout << "thread #" << id << ": " << k << endl;
if (k < 6) {
// boost::unique_lock<boost::shared_mutex> lock2(boost::move(lock)); // alternate:
boost::upgrade_to_unique_lock<boost::shared_mutex> lock2(lock);
k += 3;
}
}
int main() {
boost::thread t1(f, 1);
boost::thread t2(f, 2);
boost::thread t3(f, 3);
t1.join();
t2.join();
t3.join();
}
chunli@Linux:~/boost$ g++ main.cpp -lboost_thread -lboost_system -lpthread && ./a.out
thread #2: 1
thread #1: 4
thread #3: 7
chunli@Linux:~/boost$以上是“C++中Boost多线程、线程同步的示例分析”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注亿速云行业资讯频道！
亿速云「云服务器」，即开即用、新一代英特尔至强铂金CPU、三副本存储NVMe SSD云盘，价格低至29元/月。点击查看>>
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
