线程库的基本函数
C++11中增加了线程以及线程相关的类,支持了并发编程,提高了编写的多线程程序的可移植性 C++11中提供的线程类叫做
std::thread,基于这个类创建一个新的线程非常的简单,只需要提供线程函数或者函数对象即可,并且可以同时指定线程函数的参数。 以下了解以下常用API
1. 函数构造
// 1
thread() noexcept;
// 2
thread(thread&& other) noexcept;
// 3
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );
// 4
thread( const thread& ) = delete;。
构造函数①:默认构造函数,构造一个线程对象,在这个线程中不执行任何处理动作
构造函数②:移动构造函数,将 other 的线程所有权转移给新的thread 对象。 之后 other 不再表示执行线程。
构造函数③:创建线程对象,并在该线程中执行函数f中的业务逻辑,args是要传递给函数f的参数
任务函数f的可选类型有很多,具体如下:
- 普通函数,类成员函数,匿名函数,仿函数(这些都是可调用对象类型)
- 可以是可调用对象包装器类型,也可是使用绑定器绑定之后得到的类型(仿函数)
构造函数④:使用=delete显示删除拷贝构造, 不允许线程对象之间的拷贝
2. 公共成员函数
2.1 get_id()
应用程序启动之后默认只有一个线程,这个线程一般称之为
主线程或父线程,通过线程类创建出的线程一般称之为子线程,每个被创建出的线程实例都对应一个线程ID,这个ID是唯一的,可以通过这个ID来区分和识别各个已经存在的线程实例,这个获取线程ID的函数叫做get_id()
//原型
std::thread::id get_id() const noexcept;
eg:
#include <iostream>
#include <thread>
#include <chrono>
using namespace std;
void func(int num, string str)
{
for (int i = 0; i < 10; ++i)
{
cout << "子线程: i = " << i << "num: "
<< num << ", str: " << str << endl;
}
}
void func1()
{
for (int i = 0; i < 10; ++i)
{
cout << "子线程: i = " << i << endl;
}
}
int main()
{
cout << "主线程的线程ID: " << this_thread::get_id() << endl;
thread t(func, 520, "i love you");
thread t1(func1);
cout << "线程t 的线程ID: " << t.get_id() << endl;
cout << "线程t1的线程ID: " << t1.get_id() << endl;
}
thread t(func, 520, "i love you");
- 线程类的构造函数③是一个
变参函数,因此无需担心线程任务函数的参数个数问题 - 任务函数func()一般返回值为void,因为子线程在调用这个函数的时候
不会处理其返回值
- 线程类的构造函数③是一个
thread t1(func1);
- 子线程对象t1中的任务函数func1(),没有参数,因此在线程构造函数中就无需指定了
通过线程对象调用
get_id()就可以知道这个子线程的线程ID:t.get_id(),t1.get_id()
但在上面的示例程序中有bug 有可能子线程中的任务还没有执行完毕,主线程就结束了,最后也得不到我们想要的结果。
当启动了一个线程(创建了一个thread对象)之后,在这个线程结束的时候(std::terminate()),我们如何去回收线程所使用的资源呢?thread库给我们两种选择:
加入式(join())分离式(detach())
我们必须要在线程对象销毁之前在二者之间作出选择,否则程序运行期间会有bug产生。
2.2 join()
join()字面意思是连接一个线程,意味着主动地等待线程的终止(线程阻塞)。 在某个线程中通过子线程对象调用join()函数,调用这个函数的线程被阻塞 子线程对象中的任务函数会继续执行,当任务执行完毕之后join()会清理当前子线程中的相关资源然后返回,同时,调用该函数的线程解除阻塞继续向下执行。
//原型
void join();
解决后如下:
int main()
{
cout << "主线程的线程ID: " << this_thread::get_id() << endl;
thread t(func, 520, "i love you");
thread t1(func1);
cout << "线程t 的线程ID: " << t.get_id() << endl;
cout << "线程t1的线程ID: " << t1.get_id() << endl;
t.join();
t1.join();
}
为了更好的理解join()的使用,再举一个例子,场景如下: 程序中一共有三个线程,其中两个子线程负责分段处理函数,完毕之后,由主线程对这个文件进行下一步处理
#include <iostream>
#include <thread>
using namespace std;
void download1()
{
...
}
void download2()
{
...
}
void doSomething()
{
...
}
int main()
{
thread t1(download1);
thread t2(download2);
// 阻塞主线程,等待所有子线程任务执行完毕再继续向下执行
t1.join();
t2.join();
doSomething();
}
2.3 detach()
detach()函数的作用是进行线程分离,分离主线程和创建出的子线程。 在线程分离之后,主线程退出也会一并销毁创建出的所有子线程 在主线程退出之前,它可以脱离主线程继续独立的运行 任务执行完毕之后,这个子线程会自动释放自己占用的系统资源。
//原型
void detach();
线程分离函数没有参数也没有返回值,只需要在线程成功之后,通过线程对象调用该函数即可
int main()
{
cout << "主线程的线程ID: " << this_thread::get_id() << endl;
thread t(func, 520, "i love you");
thread t1(func1);
cout << "线程t 的线程ID: " << t.get_id() << endl;
cout << "线程t1的线程ID: " << t1.get_id() << endl;
t.detach();
t1.detach();
// 让主线程休眠, 等待子线程执行完毕
this_thread::sleep_for(chrono::seconds(5));
}
注意:detach()不会阻塞线程
子线程和主线程分离之后,主线程就不能再对这个子线程做任何控制
比如:通过join()阻塞主线程等待子线程中的任务执行完毕,或调用get_id()获取子线程的线程ID。
2.5 joinable()
joinable()函数用于判断主线程和子线程是否处理关联(连接)状态
- 返回值为
true:主线程和子线程之间有关联(连接)关系 - 返回值为
false:主线程和子线程之间没有关联(连接)关系
//原型
bool joinable() const noexcept;
eg:
#include <iostream>
#include <thread>
#include <chrono>
using namespace std;
void foo()
{
this_thread::sleep_for(std::chrono::seconds(1));
}
int main()
{
thread t;
cout << "before starting, joinable: " << t.joinable() << endl;
t = thread(foo);
cout << "after starting, joinable: " << t.joinable() << endl;
t.join();
cout << "after joining, joinable: " << t.joinable() << endl;
thread t1(foo);
cout << "after starting, joinable: " << t1.joinable() << endl;
t1.detach();
cout << "after detaching, joinable: " << t1.joinable() << endl;
}
before starting, joinable: 0
after starting, joinable: 1
after joining, joinable: 0
after starting, joinable: 1
after detaching, joinable: 0
给予结果我们可以得到如下结论
- 在创建的子线程对象的时候,如果没有指定任务函数,那么子线程不会启动,主线程和这个子线程也不会进行连接
- 在创建的子线程对象的时候,如果指定了任务函数,子线程启动并执行任务,主线程和这个子线程自动连接成功
- 子线程调用了detach()函数之后,父子线程分离,同时二者的连接断开,调用joinable()返回false
- 在子线程调用了join()函数,子线程中的任务函数继续执行,直到任务处理完毕 这时join()会清理(回收)当前子线程的相关资源,所以这个子线程和主线程的连接也就断开了,因此,调用join()之后再调用joinable()会返回false。
2.6 operator=
线程中的资源是不能被复制的,因此通过=操作符进行赋值操作最终并不会得到两个完全相同的对象。
// move (1)
thread& operator= (thread&& other) noexcept;
// copy [deleted] (2)
thread& operator= (const other&) = delete;
通过以上=操作符的重载声明可以得知:
- 如果other是一个右值,会进行资源所有权的转移
- 如果other不是右值,禁止拷贝,该函数被显示删除(=delete),不可用
3. 静态函数
thread线程类还提供了一个静态方法,用于获取当前计算机的CPU核心数 根据这个结果可以在程序中创建出数量相等的线程
每个线程独占一个CPU核心,这些线程就不用分时复用CPU时间片,此时程序的并发效率是最高的。
//函数原型
static unsigned hardware_concurrency() noexcept;
eg:
#include <iostream>
#include <thread>
using namespace std;
int main()
{
int num = thread::hardware_concurrency();
cout << "CPU number: " << num << endl;
}
4. call_once
在某些特定情况下,某些函数只能在多线程环境下调用一次,比如:要初始化某个对象,而这个对象只能被初始化一次 可以使用
std::call_once()来保证函数在多线程环境下只能被调用一次。使用call_once()的时候,需要一个once_flag作为call_once()的传入参数
//函数原型
// 定义于头文件 <mutex>
template< class Callable, class... Args >
void call_once( std::once_flag& flag, Callable&& f, Args&&... args );
flag:once_flag类型的对象,要保证这个对象能够被多个线程同时访问到f:回调函数,可以传递一个有名函数地址,也可以指定一个匿名函数args:作为实参传递给回调函数
eg:
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
once_flag g_flag;
void do_once(int a, string b)
{
cout << "name: " << b << ", age: " << a << endl;
}
void do_something(int age, string name)
{
static int num = 1;
call_once(g_flag, do_once, 19, "luffy");
cout << "do_something() function num = " << num++ << endl;
}
int main()
{
thread t1(do_something, 20, "ace");
thread t2(do_something, 20, "sabo");
thread t3(do_something, 19, "luffy");
t1.join();
t2.join();
t3.join();
return 0;
}
name: luffy, age: 19
do_something() function num = 1
do_something() function num = 2
do_something() function num = 3