C/C++基础，Boost创建线程、线程同步

已于 2023-03-05 01:02:43 修改
阅读量1.8k 收藏 7
点赞数
分类专栏： C/C++基础 ROS 文章标签： c++ 开发语言
于 2022-11-04 09:17:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34761779/article/details/127681991
版权

Boost::thread构建线程的方法：

（1）thread()：构造一个表示当前执行线程的线程对象； 
（2）explicit thread(const boost::function0<void>& threadfunc)： 
     boost::function0<void>可以简单看为：一个无返回(返回void)，无参数的函数。这里的函数也可以是类重载operator()构成的函数；该构造函数传入的是函数对象而并非是函数指针，这样一个具有一般函数特性的类也能作为参数传入。

方式一：全局函数创建线程

#include <iostream>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
//Linux make: g++ -o main main8.c -lboost_system -lboost_thread

using namespace boost;

void thread1(int x){
	std::cout << "x= " << x << std::endl;
	for (int i = 0; i < 5; i++){
		std::cout << "thread1: " << i << std::endl;
	}
}
void thread2(int x){
	std::cout << "x= " << x << std::endl;
	for (int i = 0; i < 5; i++){
		std::cout << "thread2: " << i << std::endl;
	}
}

int main(){
	//boost::thread thrd1(&thread1, 2);//线程中传入函数thrd1 地址,并传入参数2
	//boost::thread thrd2(&thread2, 3);
	boost::thread thrd1(boost::bind(&thread1, 1));//使用boost::bind()函数，实现函数绑定
	boost::thread thrd2(boost::bind(&thread2, 2));
	thrd1.join();
	thrd2.join();
	return 0;
}

        如果线程需要绑定的函数有参数则需要使用boost::bind。比如想使用 boost::thread创建一个线程来执行函数：void f(int i)，如果这样写：boost::thread thrd(f)是不对的，因为thread构造函数声明接受的是一个没有参数且返回类型为 void 的类别，而且不提供参数 i 的值 f 也无法运行，这时就可以写：boost::thread thrd(boost::bind(f,1))。涉及到有参函数的绑定问题基本上都是boost::thread、boost::function、boost::bind结合起来使用。 

方式二：用类内函数创建线程

#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
//Linux make: g++ -o main main8.c -lboost_system -lboost_thread

class HelloWorld{
public:
	void hello(){
		std::cout << "Hello world, I'm a thread!" << std::endl;
	}
	void start(){
		boost::thread thrd(boost::bind(&HelloWorld::hello,this));
		thrd.join();
	}
};

int main(int argc, char* argv[]){
	HelloWorld hello;
	hello.start();
	return 0;
}

方式三：用类内函数创建线程

#include <boost/thread/thread.hpp>
#include <iostream> 
//Linux make: g++ -o main main8.c -lboost_system -lboost_thread

class HelloWorld{
public:
	static void hello(){
		std::cout << "Hello world, I'm a thread!" << std::endl;
	}
	static void start(){
		boost::thread thrd(hello);
		thrd.join();
	}
};

int main(int argc, char* argv[]){
	HelloWorld::start();
	return 0;
}

方式四：类外用类内函数创建线程

#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <string>
#include <iostream>

class HelloWorld{
public:
	void hello(const std::string& str){
		std::cout << str << std::endl;
	}
};

int main(int argc, char* argv[]){
	HelloWorld obj;
	boost::thread thrd(boost::bind(&HelloWorld::hello, &obj, "Hello world, I'm a thread!"));
	thrd.join();
	return 0;
}

更多方式参考 

boost::bind的用法：

        得益于c++的模板以及操作符重载，去看boost::bind的实现就会发现它是一个有n多重载的函数，这些重载主要是为了适应函数的参数个数。

        其实boost::bind的原理是函数对象，而函数对象就是一个重载了()操作符的对象，这样我们就可以像调用一个方法一样来调用一个类上的这个操作符，比如a()，其实你是在调用a这个对象的()方法，而不是调用一个叫a的方法。

        一般来说boost::bind有两种方式的调用，一种是对自由方法，也取非类方法， 一种是对类方法。

  • 自由方法：boost::bind(函数名, 参数1，参数2，...)
  • 类  方  法：boost::bind(&类名::方法名，类实例指针，参数1，参数2）

        这里需要额外注意的问题是，函数对象也可以像自由方法一样被bind，而boost::function也是一种函数对象。 接下来我们需要注意什么情况下需要用_1, _2这样的参数。

        举个例子：void test(int a, int b, int c)

  • boost::bind(test, 1, _1, _2)得到一个函数对象b，当调用b(3,4)时，相当于调用test(1,3,4)
  • boost::bind(test, _2, 3, _1)得到一个函数对象b，当调用b(3,4)时，相当于调用test(4,3,3)   _1表示占位符，中间的3已经传递进去了，b(3,4)，3对应_2，4对应_1，再把占位符的位置按顺序排列就是实际的传递位置
  • boost::bind(test,  1,  2,  3)，那么在调用b()时就相当于调用test(1,  2,  3)

        注意，boost::bind里的参数个数一定要与被bind的函数相同，否则这个函数对象就无法生成了。

Boost::thread线程同步：

一、互斥量

互斥变量mutex的对象类大致如下：

    (1).mutex,独占式互斥量，最简单的，而且是最常用的一种互斥变量。

    (2).timed_mutex ,独占式互斥量,并提供超时锁定功能。

    (3).recursive_mutex: 递归式互斥量，可以多次锁定，相应地也要多次解锁。

    (4).recursive_timed_mutex: 它也是递归式互斥量,提供超时锁定功能。

    (5).shared_mutex: multiple-reader/single-writer 型的共享互斥量(又称读写锁)。

直接操作 mutex，即直接调用 mutex 的 lock / unlock 函数。

#include <boost/thread.hpp> 
#include <iostream> 
#include <unistd.h>
//Linux make: g++ -o main main8.c -lboost_system -lboost_thread

using namespace std;
boost::mutex mutex;

void thread(){ 
	for(int i = 0; i < 5; ++i){ 
		usleep(100000);
		mutex.lock();
		std::cout << "Thread " << boost::this_thread::get_id() << ": " << i << std::endl;
		mutex.unlock();
	}
}

int main(){ 
	boost::thread t1(&thread); 
	boost::thread t2(thread); 
	t1.join(); 
	t2.join(); 
}

g++编译方法： 

g++ -o main main8.c -lboost_system -lboost_thread

二、lock模板类使用

        lock模板类也分为独占式的 和共享式的。lock模板类与mutex对象结合使用，在lock构造函数中调用互斥体mutex的lock方法，mutex对象 被锁住，一旦离开作用域，会自动调用lock的析构函数，释放锁。

(1).boost::unique_lock<T>，其中T可以mutex中的任意一种。(独占式),如：

     boost::unique_lock<boost::mutex>，构造与析构时则分别自动调用lock和unlock方法，不需要手动的释放锁。

(2).boost::shared_lock<T>，其中的T只能是shared_mutex类。(共享锁)

使用 lock_guard 自动加锁、解锁。原理是 RAII，和智能指针类似

#include <iostream>
#include <boost/thread/lock_guard.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
 
boost::mutex mutex;
int count = 0;
 
void Counter() {
  // lock_guard 在构造函数里加锁，在析构函数里解锁。
  boost::lock_guard<boost::mutex> lock(mutex);
 
  int i = ++count;
  std::cout << "count == " << i << std::endl;
}
 
int main() {
  boost::thread_group threads;
  for (int i = 0; i < 4; ++i) {
    threads.create_thread(&Counter);
  }
 
  threads.join_all();
  return 0;
}

使用 unique_lock 自动加锁、解锁

unique_lock 与 lock_guard 原理相同，但是提供了更多功能（比如可以结合条件变量使用）。 注意：mutex::scoped_lock 其实就是 unique_lock<mutex> 的 typedef。(引用)

#include <iostream>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
 
boost::mutex mutex;
int count = 0;
 
void Counter() {
  boost::unique_lock<boost::mutex> lock(mutex);
 
  int i = ++count;
  std::cout << "count == " << i << std::endl;
}
 
int main() {
  boost::thread_group threads;
  for (int i = 0; i < 4; ++i) {
    threads.create_thread(&Counter);
  }
 
  threads.join_all();
  return 0;
}

使用 shared_lock

#include <boost/thread/locks.hpp>
#include <boost/thread.hpp>
#include <boost/thread/shared_mutex.hpp>
#include <iostream>
#include <functional>
#include <boost/function.hpp>
#include <boost/bind.hpp>
using namespace std;

boost::shared_mutex mutex_;//共享锁
boost::mutex g_io_mutex;

void wait(int seconds){
	boost::this_thread::sleep(boost::posix_time::seconds(seconds));
}

class Counter{
public:
	Counter():value_(0) {}

	size_t Get() const{
		boost::shared_lock<boost::shared_mutex> lock(mutex_);  //shared_lock 和share_mutex 配合使用
		return value_;
	}

	void Put(){   //同一时间 只能有一个线程来访问
		boost::unique_lock<boost::shared_mutex> lock(mutex_); //使用lock模板类
		value_++;
	}

private:
	size_t value_;
};

void threadFunc(Counter& counter){
	for (int i = 0; i < 3; ++i){
		counter.Put(); //写入数据，锁住mutex
		size_t value = counter.Get(); //多个线程可以同时读取数据
		boost::lock_guard<boost::mutex> lock(g_io_mutex);  //锁定 cout 打印输出,cout 是非线程安全的
		std::cout << boost::this_thread::get_id() << ' ' << value << std::endl;
	}
}

int main(){
	Counter counter;
	boost::thread_group threads; //boost threads的线程组
	for(int i =0;i< 3;i++){
		threads.create_thread(boost::bind(threadFunc, boost::ref(counter)));//ref传入引用
	}

	threads.join_all();
	return 0;
}

Boost::thread条件变量： 

        condition是一个简单的同步对象，用于使一个线程等待一个特定的条件成立（比如资源可用）。一个condition对象总是和一个mutex对象配合使用。mutex在交给condition对象的wait系列函数时，必须已经通过lock对象加上了锁。当线程陷入等待时，condtion对象将释放mutex上的锁，当wait返回时，mutex上的锁会重新加上，这一unlock/lock动作由conditon对象自动完成。

先看一个示例：

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>
#include <iostream>

int number;
boost::mutex m;
boost::condition full;
boost::condition empty;

void writer(){
	while(1){
		boost::mutex::scoped_lock sl(m);
		if (number == 5) {
			full.wait(m);
		}
			++number;
			std::cout << "after w: " << number << std::endl;
			empty.notify_one();
	}
}

void reader(){
	while(1){
		boost::mutex::scoped_lock sl(m);
		if (number == 0) {
			std::cout << std::endl;
			empty.wait(m); 
		}
			--number;
			std::cout << "after r: " << number <<" ";
			full.notify_one();
	}
}

int main(){
	boost::thread trd1(&writer);
	boost::thread trd2(&reader);
	trd1.join();
	trd2.join();
	return 0;
}

 加延时：

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>
#include <iostream>
#include <unistd.h>

int number;
boost::mutex m;
boost::condition full;
boost::condition empty;

void writer(){
	while(1){
		usleep(500000); //500ms 这里不加延时，会正确打印0-5-4-1，加了延时之后就变成一直打印1010101010...这样的状态
		boost::mutex::scoped_lock sl(m);
		if (number == 5) {
			full.wait(m);
		}
			++number;
			std::cout << "after w: " << number << std::endl;
			empty.notify_one();	//说明这里每次加一个数之后，就立即唤醒reader线程，然后再reader中减减，然后reader又进入了休眠，writer这边又加加，然后循环往复，而writer一直就没有休眠，所以就出现了1010101010...这样的打印
	}
}

void reader(){
	while(1){
		boost::mutex::scoped_lock sl(m);
		if (number == 0) {
			std::cout << std::endl;
			empty.wait(m); 
		}
			--number;
			std::cout << "after r: " << number <<" ";
			full.notify_one();
	}
}

int main(){
	boost::thread trd1(&writer);
	boost::thread trd2(&reader);
	trd1.join();
	trd2.join();
	return 0;
}

为了解决这个问题，使其正常输出0-5-4-1这样的序列，就在每次只有满足条件之后才进行通知，也就是notify_one()函数放在if判断条件里面：

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>
#include <iostream>
#include <unistd.h>

int number;
boost::mutex m;
boost::condition full;
boost::condition empty;

void writer(){
	while(1){
		usleep(500000); //500ms
		boost::mutex::scoped_lock sl(m);
		if (number == 5) {
			empty.notify_one();
			full.wait(m);
		}
			++number;
			std::cout << "after w: " << number << std::endl;
	}
}

void reader(){
	while(1){
		boost::mutex::scoped_lock sl(m);
		if (number == 0) {
			full.notify_one();
			std::cout << std::endl;
			empty.wait(m); 
		}
			--number;
			std::cout << "after r: " << number <<" ";
	}
}

int main(){
	boost::thread trd1(&writer);
	boost::thread trd2(&reader);
	trd1.join();
	trd2.join();
	return 0;
}

可以得到正常的输出

如果再加多个writer和reader线程，结果仍然是不会变的。

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>
#include <iostream>
#include <unistd.h>

int number;
boost::mutex m;
boost::condition full;
boost::condition empty;

void writer(){
	while(1){
		usleep(500000); //500ms
		boost::mutex::scoped_lock sl(m);
		if (number == 5) {
			empty.notify_one();
			full.wait(m);
		}
			++number;
			std::cout << "after w: " << number << std::endl;
	}
}

void reader(){
	while(1){
		boost::mutex::scoped_lock sl(m);
		if (number == 0) {
			full.notify_one();
			std::cout << std::endl;
			empty.wait(m); 
		}
			--number;
			std::cout << "after r: " << number <<" ";
	}
}

int main(){
	boost::thread trd1(&writer);
	boost::thread trd2(&reader);
	boost::thread trd3(&writer);
	boost::thread trd4(&writer);
	boost::thread trd5(&reader);
	trd1.join();
	trd2.join();
	trd3.join();
	trd4.join();
	trd5.join();
	return 0;
}

参考

帮助理解的简单使用：

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>
#include <iostream>
#include <unistd.h>

//Linux make：g++ -o main main8.c -lboost_system -lboost_thread

boost::mutex m;
boost::condition empty;
bool wakethread = false;

void writer(){
	std::cout << "2秒后阻塞reader" << std::endl;
	usleep(2000000);
	wakethread = true;
	usleep(200000);//等待reader被阻塞
	std::cout << "2秒后恢复reader" << std::endl;
	usleep(2000000);
	empty.notify_one();
}

/*
    线程阻塞时的特点：
    该线程放弃CPU的使用权，暂停运行，只有当阻塞的原因消除后才回到就绪状态进行运行
    被其他的线程中断，该线程也会推出阻塞状态，同时抛出InterruptedException的异常
*/

void reader(){
	for(int i=0; i<20; i++){
		while(wakethread){
			wakethread = false;
			//std::cout << wakethread << std::endl;
			std::cout << "reader suspended" << std::endl;
			empty.wait(m);	//在这里就开始阻塞，下面的都不执行了
			std::cout << "begin reader work" << std::endl;  //解除阻塞之后开始从这里执行
		}
		usleep(200000);
		std::cout << "in reader..." << std::endl;
	}
}

int main(){
	boost::thread trd1(&writer);
	boost::thread trd2(&reader);
	trd1.join();
	trd2.join();
	return 0;
}

 

有关多线程状态机的思考： 

1.Switch case中，只有当前case完全退出之后才进行状态的切换

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>
#include <iostream>
#include <unistd.h>
//Linux make: g++ -o main main8.c -lboost_system -lboost_thread

int curTask;
enum{ TASK_NO, TASK_ON, TASK_NEW };
bool isontask = true;

void writer(){
  curTask = TASK_NO;
  std::cout << "curTask = TASK_NO, 1.5秒后切换状态" << std::endl;
  usleep(1500000);
  curTask = TASK_NEW;
  std::cout << "curTask = TASK_NEW" << std::endl;
}

void reader(){
 for(int i=0; i<7; i++){
  switch(curTask){
    case TASK_NO:
      std::cout << "TASK_NO" << std::endl;
      usleep(1000000);
      std::cout << "TASK_NO sleep 1s end......" << std::endl;
      break;
        
    case TASK_NEW:
      std::cout << "TASK_NEW" << std::endl;
      break;
        
    case TASK_ON:
      std::cout << "TASK_ON" << std::endl;
      break;
    }
    usleep(100000);
  }
}

int main(){
 boost::thread trd1(&writer);
 boost::thread trd2(&reader);
 trd1.join();
 trd2.join();
 return 0;
}

        从结果可以看出，在1.5s的时候状态机发生了切换，而此时reader线程还处于sleep状态，当sleep结束需要再打印一下 TASK_NO sleep 1s end...... 直到 break 才进行下一次的条件判断，也就是说必须把当前的case走完，当前线程才会真正的切换状态，而非在 writer 中标志位切换的时候，reader线程就立即进入这个状态了，需要当前状态运行完毕，才会发生状态切换。

2.while循环的退出只跟当前判断的条件有关，而跟case的状态切换无关，除非case中耦合了当前状态

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>
#include <iostream>
#include <unistd.h>
//Linux make: g++ -o main main8.c -lboost_system -lboost_thread

int curTask;
enum{ TASK_NO, TASK_ON, TASK_NEW };
bool isontask = true;

void writer(){
  curTask = TASK_NO;
  std::cout << "curTask = TASK_NO, 1.5秒后切换状态" << std::endl;
  usleep(1500000);
  curTask = TASK_NEW;
  std::cout << "curTask = TASK_NEW" << std::endl;
}

void reader(){
 for(int i=0; i<7; i++){
  switch(curTask){
    case TASK_NO:
        while(isontask){
        std::cout << "TASK_NO in while......" << std::endl;
        usleep(300000);
       }
      break;
      
    case TASK_NEW:
      std::cout << "TASK_NEW" << std::endl;
      break;
        
    case TASK_ON:
      std::cout << "TASK_ON" << std::endl;
      break;
    }
    usleep(100000);
  }
}

int main(){
 boost::thread trd1(&writer);
 boost::thread trd2(&reader);
 trd1.join();
 trd2.join();
 return 0;
}

        可以看到，即使在writer中1.5s后切换了状态， reader线程依然还是处于TASK_NO这个case，没有退出。而while的判断条件耦合了当前状态，即可安全退出while循环，上面的while判断条件换成下面这样的：

while(isontask && curTask==TASK_NO)

输出：

发现可以正常的进行条件的选择和退出了。

哎编码水平有点低，都是坑啊...

小蜗牛冲鸭~
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【BOOST C++ 线程】boost::thread库的基本使用方法总结
gongdiwudu的专栏
11-22 7286
boost::thread的六种使用方法总结，本文初步介绍线程的函数、构造、执行的详细解释。
C++ 多线程创建及同步
weixin_43571468的博客
10-07 694
C++ 多线程创建及同步多线程创建线程同步使用临界区对象实现多线程同步使用互斥对象实现多线程同步使用事件对象实现多线程同步 多线程创建 在C++中使用CreateThread（）函数就可以，其函数参数说明如下 function CreateThread( lpThreadAttributes: Pointer; {安全设置} dwStackSize: DWORD; ...
C++ boost::thread_group 编程
那年聪聪
12-08 2494
多线程编程
boost线程全攻略
faithl820的博客
01-05 1163
转自：https://www.cnblogs.com/renyuan/p/6613638.html 1 创建线程 首先看看boost::thread的构造函数吧，boost::thread有两个构造函数： （1）thread()：构造一个表示当前执行线程的线程对象； （2）explicit thread(const boost::function0& threadfunc)： boost::function0可以简单看为：一个无返回(返回void)，无参数的函数。这里的函数也可以是类重载operat
boost::thread
huangjh2017的博客
02-11 1435
1. 简介thread 库为 c++增加了线程处理的能力，它提供简明清晰的线程、互斥量等概念，可以很容易地创建多线程应用程序。thread 库也是高度移植的，它支持使用最广泛的 Windows 和 POSIX 线程，用它编写的代码不需要修改就可以在Windows、UNIX等操作系统上编译运行。thread 库也是boost库中少数需要编译才能使用的库，并且thread 库需要date_time 库...
boost thread_group
hscoder的博客
01-02 6786
boost库提供thread_group用于管理一组线程，就像是一个线程池，它内部使用std::list#include <boost/thread/thread.hpp> #include <boost/bind.hpp> #include <boost/thread/mutex.hpp> #include <iostream>using namespace std ;boost::mutex i
remove_cunport_and.rar_进程与线程_C/C++_
08-11
标题 "remove_cunport_and.rar_进程与线程_C/C++_" 暗示了这个压缩包中的资源可能是一个关于理解和使用C/C++编程语言处理进程与线程的教程或项目。描述中的"vc"可能指的是Visual C++，一个常用的C++集成开发环境。...
C_C++ 多线程编程精髓_专栏.pdf.zip
07-06
《C/C++ 多线程编程精髓》是深入探讨操作系统层面多线程技术的重要资源，主要涵盖以下几个核心知识点： 1. **线程基础**：线程是操作系统分配CPU执行时间的基本单位，它允许一个进程中同时执行多个独立的代码段。在...
C/C++离线帮助文档
06-12
《C/C++离线帮助文档》是一份专为C++开发者设计的重要参考资料，包含了丰富的C++语言和标准库的知识。这份文档以`.chm`（ Compiled HTML Help）格式提供，是一种常见的离线帮助文档格式，方便用户在无网络环境下查阅...
C++ 多线程和多线程下的单例模式
01-08
本资源描述了C++11 中多线程的创建，C++11中std命名空间中将boost库中的Thread加入，boost多线程从准标准变为标准，其中还介绍了C++ 多线程下的单例模式的使用，本文档为txt文档
boost-asio-study-master.rar_C/C++__C/C++_
08-09
《深入探索Boost.Asio库：C++网络编程实践》 Boost.Asio是C++中一个强大的网络编程库，被广泛用于构建高效的并发网络应用程序。它提供了低级别的套接字操作，以及高级别的服务，如定时器和信号处理，极大地简化了...
C++用boost实现带返回值、输入参数的异步线程池
最新发布
mxdsdo09的博客
11-02 814
1、线程在任务队列中获取任务以及向任务队列中提交任务都需要抢占队列的互斥锁，会造成时间损耗，尤其在任务数多，每个任务需要的时间不是很长的情况下，抢占任务队列互斥锁的时间损耗就显得更加明显。因此，线程池的方式更适合每个task消耗的时间比较长，任务数不是特别多的场景。在真实情况下，每个任务的耗时是不可提前预知的，这样用多线程可能会出现其他个线程跑完了对应批次的任务，而全都在等待最慢那个批次任务的情况，线程池则可以让先跑完的参与到剩下的任务中。写了个简单的测试用例，最终输出为。
【Boost】boost库中thread多线程详解1——thread入门与简介
liujiayu2的专栏
01-26 5223
1. 概述 线程就是，在同一程序同一时间内允许执行不同函数的离散处理队列。 这使得一个长时间去进行某种特殊运算的函数在执行时不阻碍其他的函数变得十分重要。 线程实际上允许同时执行两种函数，而这两个函数不必相互等待。一旦一个应用程序启动，它仅包含一个默认线程。 此线程执行main() 函数。 在main()中被调用的函数则按这个线程的上下文顺序地执行。 这样的程序称为单线程程序。反之，那些创建
Boost 线程
冷月醉雪的博客
12-13 564
1.创建线程     boost::thread类代表一个可执行的线程。缺省构造函数创建一个代表当前执行线程的实例。一个重载的构造函数以一个不需任何参数的函数对象作为参数，并且没有返回值。这个构造函数创建一个新的可执行线程，它调用了那个函数对象。     线程对象只能做两项操作。线程对象可以方便使用==和！=进行比较来确定它们是否代表同一个线程；还可以调用boost::thread::join...
boost C++知识点（四）
qq_23350817的博客
10-26 814
5 多线程 5.1 线程管理 在这个库最重要的一个类就是 boost::thread，它是在 boost/thread.hpp 里定义的，用来创建一个新线程。下面的示例来说明如何运用它。 #include &amp;lt;boost/thread.hpp&amp;gt; #include &amp;lt;iostream&amp;gt; void wait(int seconds) { boost::this_t......
Boost::thread库的使用
qq_20189555的博客
09-07 2309
thread库的使用
boost::thread_group简单使用
wangzhicheng2013的专栏
11-05 439
类似线程池，demo如下： #include <boost/thread.hpp> #include <boost/bind.hpp> #include <iostream> void fun(int i) { std::cout << "fun:" << i << std::endl; } int main() { boost::thread_group threads; for (auto i = 0;i
C++_开发_Boost开源库_介绍_使用
qq_44681788的博客
05-26 5971
C++_开发_Boost开源库_介绍_使用
C++：Boost库
lingshengxiyou的博客
04-06 7384
Boost是一个功能强大,构造精良,跨越平台,代码开源,完全免费的C++程序库。共包含160余个库/组件,涵盖字符串与文本处理、容器、迭代器、算法、图像处理、模板元编程、并发编程等多个领域。由c++标准委员会成员发起倡议并建立boost社区,C++11标准库中三分之二来自boost,并且将来还会有更多的库进入c++标准库,因此boost是一个c++ "准"标准库。支持现有的所有操作系统。Boost库的大多数组件不需要编译链接，源码里直接包含头文件。（注意：包含头文件的时候需要有boost目录，即。
linux下多线程编程+c/c++
06-28
C/C++语言提供了一些多线程编程的库，如pthread库、OpenMP库、Boost库等。其中，pthread库是Linux下最常用的多线程编程库，它提供了一系列的API函数，可以用来创建、管理和同步线程。在C/C++语言中，可以使用pthread...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值