C++中Boost多线程、线程同步的示例分析

小编给大家分享一下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 #include 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 #include 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 #include using namespace std;void fun1(const int &id){cout << "threads id "<
线程的创建方式
chunli@Linux:~/boost$ cat main.cpp #include #include using namespace std;void fun1(const int &id){        cout << "threads id "<
线程的join
chunli@Linux:~/boost$ cat main.cpp #include #include using namespace std;void fun1(const int &id){cout << "threads id "<
加入join,回收线程
chunli@Linux:~/boost$ cat main.cpp #include #include using namespace std;void fun1(const int &id){cout << "threads id "<
线程中断
chunli@Linux:~/boost$ cat main.cpp #include #include 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: startedthread #1: startedthread #3: startedthread #2: endedchunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out thread #1: startedthread #3: startedthread #2: startedthread #2: endedchunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out thread #thread #2: started1: startedthread #3: startedthread #2: endedchunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out thread #3: startedthread #1: startedthread #2: startedthread #2: endedchunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out thread #2: startedthread #3: startedthread #thread #2: ended1: startedchunli@Linux:~/boost$ 只有2线程不会被打断
线程中断2,
chunli@Linux:~/boost$ cat main.cpp #include #include 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 0thread #1: 0thread #3: 0thread #2: 1 2 3 4 5 6 7 8 9 10 11 2 3 4 5 6 7 8 9 10 11 2 3 4 5 6 7 8 9 10 1chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out 0thread #1: 0thread #2: 0thread #3: 1 2 3 4 5 6 7 8 9 10 11 2 3 4 5 6 7 8 9 10 11 2 3 4 5 6 7 8 9 10 1chunli@Linux:~/boost$
线程组
chunli@Linux:~/桌面/qt_pro/01/untitled$ cat main.cpp #include #include 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<
boost 线程的死锁
chunli@Linux:~/boost$ cat main.cpp #include #include 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 ^Cchunli@Linux:~/boost$
boost 线程递归锁
chunli@Linux:~/boost$ cat main.cpp #include #include 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 #"<
unique_lock 锁,离开作用域自动释放
chunli@Linux:~/boost$ cat main.cpp #include #include #include using namespace std;using boost::thread;boost::mutex m;int k = 0;void decrement(){    boost::unique_lock lock(m);    for(int i = 0;i<=100;++i)    {        k-=i;    }    cout << "after decrement k="< lock(m);    for(int i = 0;i<=100;++i)    {        k+=i;    }    cout << "after increment k="<
unique_lock 锁 示例 2,可以显式的释放锁
chunli@Linux:~/boost$ cat main.cpp #include #include #include using namespace std;using boost::thread;boost::mutex m;void updateString(){    boost::unique_lock 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 #include 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 #include 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 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 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 #include 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 lockFrom(from.m, boost::adopt_lock);//    boost::unique_lock 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 lockFrom(from.m, boost::adopt_lock);        boost::this_thread::sleep(boost::posix_time::seconds(1));        boost::lock_guard 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 lockFrom(from.m); // #1//    boost::this_thread::sleep(boost::posix_time::seconds(1));//    boost::lock_guard 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.45Balance of a2: 334.55chunli@Linux:~/boost$
boost upgrade_lock
chunli@Linux:~/boost$ cat main.cpp #include #include using namespace std;using boost::thread;boost::shared_mutex m;int k = 1;void f(int id) {        boost::upgrade_lock lock(m);        cout << "thread #" << id << ": " << k << endl;        if (k < 6) {                // boost::unique_lock lock2(boost::move(lock)); // alternate:                boost::upgrade_to_unique_lock 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: 1thread #1: 4thread #3: 7chunli@Linux:~/boost$
以上是"C++中Boost多线程、线程同步的示例分析"这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注行业资讯频道！