 是 C++11 中引入的一个库，用于实现多线程编程。它允许程序创建和管理线程，从而实现并发执行。

（1）默认构造函数：创建一个空的 thread 执行对象。

thread() _NOEXCEPT
{
	// construct with no thread
	_Thr_set_null(_Thr);
}

template<class Fn,class ... Args>
explicit thread(Fn&& fn,Args&& ... args);

表示既可以传入左值也可以传入右值。

// 如果拷贝构造函数（被禁用），意味着 thread 不可被拷贝构造。 
thread(const thread&) = delete;

 对象必须在他们销毁之前被主线程 

#include <iostream>
#include <thread>

using namespace std;

void thread_func(int &a)
{
	cout << "thread_func: a = " << (a += 10) << endl;
}

int main()
{
	int x = 10;
	thread t1(thread_func, ref(x));
	thread t2(move(t1)); // t1 线程失去所有权

	thread t3;
	t3 = move(t2); // t2 线程失去所有权

	// t1.join(); //执行会报错：已放弃 (核心已转储)
	t3.join();

	cout << "main end: x = " << x << endl;

	return 0;
}

：判断线程是否可以加入等待。

：等该线程执行完成后才返回。

调用之后，目标线程就成为了守护线程，驻留后台运行，与之关联的

对象失去对目标线程的关联，无法再通过

对象取得该线程的控制权。当线程主函数执行完之后，线程就结束了，运行时库负责清理与该线程相关的资源。

创建线程，提供线程函数或者函数对象，并可以同时指定线程函数的参数。

#include <iostream>
#include <thread>

using namespace std;

void thread_func1()
{
	cout << "thread_func1()" << endl;
}

int main()
{
	
	thread t1(&thread_func1);	// 只传递函数
	t1.join();					// 阻塞等待线程函数执行结束

	return 0;
}

#include <iostream>
#include <thread>

using namespace std;

void thread_func2(int a, int b)
{
	cout << "thread_func2(): a + b =" << a + b << endl;
}

int main()
{
	int a = 10;
	int b = 16;

	thread t2(thread_func2, a, b);
	t2.join();

	return 0;
}

#include <iostream>
#include <thread>

using namespace std;

void thread_func3(int &c)
{
	cout << "thread_func3(): &c = " << &c 
	cout << " --> c + 10 =" << (c += 10) << endl;
}

int main()
{
	int c = 10;
	
	thread t3(thread_func3, ref(c));
	t3.join();
	cout << "main --> 3 : &c = " << &c << ", c = " << c << endl;

	return 0;
}

#include <iostream>
#include <thread>

using namespace std;

class A
{
public:
	void func4(int a)
	{
		cout << "thread:" << name_ << ", fun4 a = " << a << endl;
	}
	void setName(string name) 
	{ 
		name_ = name; 
	}
	void displayName() 
	{ 
		cout << "this:" << this << ", name:" << name_ << endl; 
	}
	void play() 
	{ 
		std::cout << "play call!" << std::endl; 
	} 

private: 
	string name_;
};


int main()
{
	cout << "test--------------------------" << endl;
	A *a_ptr = new A();
	a_ptr->setName("hello,C++11");
	thread t4(A::func4, a_ptr, 10);
	t4.join();
	delete a_ptr;
	
	A *a_ptr2 = new A();
	a_ptr2->setName("hello,C++14");
	thread t42(&A::func4, a_ptr2, 10);// 传入类的函数地址、类地址、参数
	t42.join();
	delete a_ptr;

	return 0;
}

最好使用取地址符&的方式传入类函数，避免兼容问题。

将子线程从主线程中分离出来，主线程不再具有管理此子线程的能力。

#include <iostream>
#include <thread>

using namespace std;

void thread_func5()
{
	cout << "func5 into sleep " << endl;
	this_thread::sleep_for(chrono::seconds(2));
	cout << "func5 leave " << endl;
}


int main()
{
	thread t5(&thread_func5);
	t5.detach();
	// t5.join() // 抛出异常
	cout << "t5 id : " << t5.get_id() << endl; // 抛出异常
	cout << "t5 joinable: " << t5.joinable() << endl;

	return 0;
}

t5 id : thread::id of a non-executing thread
t5 joinable: 0


#include <iostream>
#include <thread>

using namespace std;

int main()
{

	thread t6(func6);
	thread t7(move(t6));
	//t6.join(); // 抛出异常 
	
	cout << "t6 id : " << t6.get_id() << endl;
	cout << "t6 joinable: " << t6.joinable() << endl;
	cout << "t7 joinable: " << t7.joinable() << endl;
	t7.join();

	return 0;
}

t6 id : thread::id of a non-executing thread
t6 joinable: 0
t7 joinable: 1
this is func6 !


封装线程，子类能继承，然后子类能实现具体的业务逻辑。创建线程通过

来实现，参数列表和使用构造函数创建是一样的。

#ifndef _OWER_THREAD_H_
#define _OWER_THREAD_H_

#include <thread>

class Ower_Thread {
public:
	Ower_Thread(); // 构造函数
	virtual ~Ower_Thread(); // 析构函数
	bool start(); 
	void stop(); 
	bool isAlive() const; // 线程是否存活

	std::thread::id id()
	{
		return th_->get_id();
	}
	std::thread* getThread()
	{
		return th_;
	}

	void join();	// 等待当前线程结束, 不能在当前线程上调用
	void detach();	//能在当前线程上调用
	static size_t CURRENT_THREADID();

protected: 
	void threadEntry(); 
	virtual void run() = 0; // 运行 
protected: 
	bool running_; //是否在运行 
	std::thread *th_;
};

#endif

#include "ower_thread.h"
#include <sstream>
#include <iostream>
#include <exception>

Ower_Thread::Ower_Thread() :
	running_(false), th_(NULL)
{

}

Ower_Thread::~Ower_Thread()
{
	if (th_ != NULL)
	{
		//如果到调用析构函数的时候，调用者还没有调用join则触发detach，此时是一个比较危险的动 作，用户必须知道他在做什么
		if (th_->joinable())
		{
			std::cout << "~Ower_Thread detach"<<std::endl; 
			th_->detach();
		}
		delete th_;
		th_ = NULL;
	}
	std::cout << "~Ower_Thread()" << std::endl;
}

bool Ower_Thread::start()
{
	if (running_)
	{
		return false;
	}
	try
	{
		th_ = new std::thread(&Ower_Thread::threadEntry, this);
	}
	catch (...)
	{
		throw "[Ower_Thread::start] thread start error";
	}
	return true;
}

void Ower_Thread::stop()
{
	running_ = false;
}

bool Ower_Thread::isAlive()const
{
	return running_;
}

void Ower_Thread::join() 
{
	if (th_->joinable()) 
	{
		th_->join(); // 不是detach才去join 
	} 
}

void Ower_Thread::detach()
{ 
	th_->detach(); 
}

size_t Ower_Thread::CURRENT_THREADID()
{
	// 声明为thread_local的本地变量在线程中是持续存在的，不同于普通临时变量的生命周期， 
	// 它具有static变量一样的初始化特征和生命周期，即使它不被声明为static。
	static thread_local size_t threadId = 0;
	if (threadId == 0)
	{
		std::stringstream ss;
		ss << std::this_thread::get_id();
		threadId = strtol(ss.str().c_str(), NULL, 0);
	}

	return threadId;
}


void Ower_Thread::threadEntry()
{
	running_ = true;
	try
	{
		run();
	}
	catch (std::exception &ex)
	{
		running_ = false;
		throw ex;
	}
	catch (...)
	{
		running_ = false;
		throw;
	}
	running_ = false;
}

#include <iostream>
#include <chrono>
#include "ower_thread.h"

using namespace std;

class A:public Ower_Thread
{
public:
	void run()
	{
		while (running_)
		{
			cout << "class A" << endl;
			this_thread::sleep_for(chrono::seconds(5));
		}
		cout << "----- leave class A " << endl;
	}


};

class B :public Ower_Thread
{
public:
	void run()
	{
		while (running_)
		{
			cout << "class B" << endl;
			this_thread::sleep_for(chrono::seconds(2));
		}
		cout << "----- leave class B " << endl;
	}


};


int main()
{
	A a;
	a.start();
	B b;
	b.start();

	this_thread::sleep_for(chrono::seconds(5));

	a.stop();
	a.join(); // 需要我们自己join
	b.stop();
	b.join(); // 需要我们自己join

	cout << "Hello World!" << endl;

	return 0;
}

g++ -o my_thread test.cc ower_thread.cc -lpthread -std=c++11


$ ./my_thread
class B
class A
class B
class B
class A
class B
class B
----- leave class A 
----- leave class B 
Hello World!
~Ower_Thread()
~Ower_Thread()


此命名空间对一组访问当前线程的函数进行分组。

返回：返回调用线程的线程 ID，此值唯一标识线程。成员类型的对象唯一标识线程

// thread::get_id / this_thread::get_id
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::thread::id, std::this_thread::get_id
#include <chrono>         // std::chrono::seconds
 
std::thread::id main_thread_id = std::this_thread::get_id();

void is_main_thread() {
  if ( main_thread_id == std::this_thread::get_id() )
    std::cout << "This is the main thread.\n";
  else
    std::cout << "This is not the main thread.\n";
}

int main() 
{
  is_main_thread();
  std::thread th (is_main_thread);
  th.join();
}

调用线程生成，为实现提供了重新调度的机会。当线程等待其他线程前进而不阻塞时，应调用此函数。

// this_thread::yield example
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::this_thread::yield
#include <atomic>         // std::atomic

std::atomic<bool> ready(false);

void count1m(int id) {
	while (!ready) {             // wait until main() sets ready...
		std::this_thread::yield();
	}
	for (volatile int i = 0; i<1000000; ++i) {}
	std::cout << id;
}

int main()
{
	std::thread threads[10];
	std::cout << "race of 10 threads that count to 1 million:\n";
	for (int i = 0; i<10; ++i) threads[i] = std::thread(count1m, i);
	ready = true;               // go!
	for (auto& th : threads) th.join();
	std::cout << '\n';

	return 0;
}

阻止在指定的时间段内执行调用线程。

当前线程的执行将停止，直到至少从现在开始。其他线程继续执行。

参数：调用线程恢复执行的时间跨度。请注意，多线程管理操作可能会导致超出此范围的某些延迟。是表示特定相对时间的对象。

#include <iostream>       // std::cout, std::endl
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds
 
int main() 
{
  std::cout << "countdown:\n";
  for (int i=10; i>0; --i) {
    std::cout << i << std::endl;
    std::this_thread::sleep_for (std::chrono::seconds(1));
  }
  std::cout << "Lift off!\n";

  return 0;
}

 提供了一个方便的方式来实现多线程编程，使得开发者能够充分利用现代多核处理器的能力。通过灵活的线程管理和同步机制，可以有效地实现并发计算。

在 Linux 和其他 Unix-like 系统上使用 

）实现的。因此，当编译一个使用 

 的 C++ 程序时，需要在编译命令中添加 

g++ -std=c++11 -o my_program my_program.cpp -lpthread

在使用某些高级的编译器（例如 g++ 版本 5 及更高版本）时，如果使用了 

 或者更高版本的选项，编译器可能会自动链接 

，因为 Windows 有自己实现的线程库，

C++多线程编程：深入剖析std::thread的使用方法

本文将深入解析C++11中多线程编程的核心组件：thread的使用方法。从thread的创建、启动和管理等方面展开讲解，同时介绍了如何处理线程间的通信和同步问题，以及如何利用thread提高程序的性能和并发能力。通过详细的示例代码和实际场景的案例全面了解和掌握thread的功能和灵活性。

编程语言

C++11 引入的 std::thread 库用于多线程编程，支持创建、管理和同步线程。其构造函数多样，包括默认、初始化、拷贝（禁用）、移动构造函数。主要成员函数有 get_id、joinable、join、detach 等，并有示例展示其用法。

编译器

Windows

Linux

Unix

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

C++多线程编程：深入剖析std::thread的使用方法

C++多线程编程：深入剖析std::thread的使用方法

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐