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: 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 
#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 
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 
#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 
^C
chunli@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.45
Balance of a2: 334.55
chunli@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: 1
thread #1: 4
thread #3: 7
chunli@Linux:~/boost$
以上是“C++中Boost多线程、线程同步的示例分析”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！
            
            
                            

                网站题目：C++中Boost多线程、线程同步的示例分析                

                网站路径：http://dzwzjz.com/article/jsodjh.html