线程的创建 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 "<
       
        << endl;}void fun2(const int &id){cout << "threads id "<
        
         << endl;}void fun3(const int &id){cout << "threads 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 1threads id 2threads id 3chunli@Linux:~/boost$

线程的创建方式

chunli@Linux:~/boost$ cat main.cpp #include 
     
      #include 
      
       using namespace std;void fun1(const int &id){	cout << "threads id "<
       
        << endl;}struct MyThread{	void operator()(const int &id)	{		cout << "threads id "<
        
         << endl;	}	void fun(const int &id)	{		cout << "threads 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 1threads id 2threads id 3threads id 4threads id 5chunli@Linux:~/boost$

线程的join

chunli@Linux:~/boost$ cat main.cpp #include 
     
      #include 
      
       using namespace std;void fun1(const int &id){cout << "threads 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 1chunli@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 1chunli@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 1chunli@Linux:~/boost$ 可以看出,如果没有join的等待,结果是不可预期的.

加入join,回收线程

chunli@Linux:~/boost$ cat main.cpp #include 
     
      #include 
      
       using namespace std;void fun1(const int &id){cout << "threads 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 1main end!chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out threads id 1main end!chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out threads id 1main end!chunli@Linux:~/boost$ g++ main.cpp -l boost_thread -l boost_system && ./a.out threads id 1main end!chunli@Linux:~/boost$

线程中断

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 #"<
     
      <<":";    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 
     
      #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="<
         
          << endl;}void increment(){    boost::unique_lock
          
            lock(m);    for(int i = 0;i<=100;++i)    {        k+=i;    }    cout << "after increment 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=5050after decrement k=0chunli@Linux:~/boost$

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$