十年网站开发经验 + 多家企业客户 + 靠谱的建站团队
量身定制 + 运营维护+专业推广+无忧售后,网站问题一站解决
在C++11之前,涉及到多线程问题,都是和平台相关的,比如Windows和Linux下各有自己的接口,这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行了支持,使得C++在并行编程时不需要依赖第三方库,而且在原子操作中还引入了原子类的概念。
线程库(thread) 线程对象的构造方式一、调用无参的构造函数
thread提供了无参的构造函数,调用无参的构造函数创建出来的线程对象没有关联任何线程函数,即没有启动任何线程。比如:
thread t1;
由于thread提供了移动赋值函数,因此当后续需要让该线程对象与线程函数关联时,可以以带参的方式创建一个匿名对象,然后调用移动赋值将该匿名对象关联线程的状态转移给该线程对象。比如:
void func(int n)
{for (int i = 0; i<= n; i++)
{cout<< i<< endl;
}
}
int main()
{thread t1;
//...
t1 = thread(func, 10);
t1.join();
return 0;
}
场景: 实现线程池的时候就是需要先创建一批线程,但一开始这些线程什么也不做,当有任务到来时再让这些线程来处理这些任务。
二、调用带参的构造函数
thread的带参的构造函数的定义如下:
templateexplicit thread (Fn&& fn, Args&&... args);
参数说明:
fn
:可调用对象,比如函数指针、仿函数、lambda表达式、被包装器包装后的可调用对象等。args...
:调用可调用对象fn时所需要的若干参数。调用带参的构造函数创建线程对象,能够将线程对象与线程函数fn进行关联。比如:
void func(int n)
{for (int i = 0; i<= n; i++)
{cout<< i<< endl;
}
}
int main()
{thread t2(func, 10);
t2.join();
return 0;
}
三、调用移动构造函数
thread提供了移动构造函数,能够用一个右值线程对象来构造一个线程对象。比如:
void func(int n)
{for (int i = 0; i<= n; i++)
{cout<< i<< endl;
}
}
int main()
{thread t3 = thread(func, 10);
t3.join();
return 0;
}
说明一下:
thread中常用的成员函数如下:
成员函数 | 功能 |
---|---|
join | 对该线程进行等待,在等待的线程返回之前,调用join函数的线程将会被阻塞 |
joinable | 判断该线程是否已经执行完毕,如果是则返回true,否则返回false |
detach | 将该线程与创建线程进行分离,被分离后的线程不再需要创建线程调用join函数对其进行等待 |
get_id | 获取该线程的id |
swap | 将两个线程对象关联线程的状态进行交换 |
此外,joinable
函数还可以用于判定线程是否是有效的,如果是以下任意情况,则线程无效:
调用thread的成员函数get_id
可以获取线程的id,但该方法必须通过线程对象来调用get_id
函数,如果要在线程对象关联的线程函数中获取线程id,可以调用this_thread
命名空间下的get_id
函数。比如:
void func()
{cout<< this_thread::get_id()<< endl; //获取线程id
}
int main()
{thread t(func);
t.join();
return 0;
}
this_thread
命名空间中还提供了以下三个函数:
函数名 | 功能 |
---|---|
yield | 当前线程“放弃”执行,让操作系统调度另一线程继续执行 |
sleep_until | 让当前线程休眠到一个具体时间点 |
sleep_for | 让当前线程休眠一个时间段 |
线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的,就算线程函数的参数为引用类型,在线程函数中修改后也不会影响到外部实参,因为其实际引用的是线程栈中的拷贝,而不是外部实参。比如:
void add(int& num)
{num++;
}
int main()
{int num = 0;
thread t(add, num);
t.join();
cout<< num<< endl; //0
return 0;
}
如果要通过线程函数的形参改变外部的实参,可以参考以下三种方式:
方式一:借助std::ref函数
当线程函数的参数类型为引用类型时,如果要想线程函数形参引用的是外部传入的实参,而不是线程栈空间中的拷贝,那么在传入实参时需要借助ref函数保持对实参的引用。比如:
void add(int& num)
{num++;
}
int main()
{int num = 0;
thread t(add, ref(num));
t.join();
cout<< num<< endl; //1
return 0;
}
方式二:地址的拷贝
将线程函数的参数类型改为指针类型,将实参的地址传入线程函数,此时在线程函数中可以通过修改该地址处的变量,进而影响到外部实参。比如:
void add(int* num)
{(*num)++;
}
int main()
{int num = 0;
thread t(add, &num);
t.join();
cout<< num<< endl; //1
return 0;
}
方式三:借助lambda表达式
将lambda表达式作为线程函数,利用lambda函数的捕捉列表,以引用的方式对外部实参进行捕捉,此时在lambda表达式中对形参的修改也能影响到外部实参。比如:
int main()
{int num = 0;
thread t([&num]{num++; });
t.join();
cout<< num<< endl; //1
return 0;
}
join与detach启动一个线程后,当这个线程退出时,需要对该线程所使用的资源进行回收,否则可能会导致内存泄露等问题。thread库给我们提供了如下两种回收线程资源的方式:
join方式
主线程创建新线程后,可以调用join函数等待新线程终止,当新线程终止时join
函数就会自动清理线程相关的资源。
join
函数清理线程的相关资源后,thread对象与已销毁的线程就没有关系了,因此一个线程对象一般只会使用一次join
,否则程序会崩溃。比如:
void func(int n)
{for (int i = 0; i<= n; i++)
{cout<< i<< endl;
}
}
int main()
{thread t(func, 20);
t.join();
t.join(); //程序崩溃
return 0;
}
但如果一个线程对象join
后,又调用移动赋值函数,将一个右值线程对象的关联线程的状态转移过来了,那么这个线程对象又可以调用一次join
。比如:
void func(int n)
{for (int i = 0; i<= n; i++)
{cout<< i<< endl;
}
}
int main()
{thread t(func, 20);
t.join();
t = thread(func, 30);
t.join();
return 0;
}
但采用join
的方式结束线程,在某些场景下也可能会出现问题。比如在该线程被join
之前,如果中途因为某些原因导致程序不再执行后续代码,这时这个线程将不会被join
。
void func(int n)
{for (int i = 0; i<= n; i++)
{cout<< i<< endl;
}
}
bool DoSomething()
{return false;
}
int main()
{thread t(func, 20);
//...
if (!DoSomething())
return -1;
//...
t.join(); //不会被执行
return 0;
}
因此采用join
方式结束线程时,join
的调用位置非常关键,为了避免上述问题,可以采用RAII的方式对线程对象进行封装,也就是利用对象的生命周期来控制线程资源的释放。比如:
class myThread
{public:
myThread(thread& t)
:_t(t)
{}
~myThread()
{if (_t.joinable())
_t.join();
}
//防拷贝
myThread(myThread const&) = delete;
myThread& operator=(const myThread&) = delete;
private:
thread& _t;
};
使用方式如下:
joinable
判断这个线程是否需要被join
,如果需要那么就会调用join
对其该线程进行等待。例如刚才的代码中,使用myThread类对线程对象进行封装后,就能保证线程一定会被join
。
int main()
{thread t(func, 20);
myThread mt(t); //使用myThread对线程对象进行封装
//...
if (!DoSomething())
return -1;
//...
t.join();
return 0;
}
detach方式
主线程创建新线程后,也可以调用detach
函数将新线程与主线程进行分离,分离后新线程会在后台运行,其所有权和控制权将会交给C++运行库,此时C++运行库会保证当线程退出时,其相关资源能够被正确回收。
detach
的方式回收线程的资源,一般在线程对象创建好之后就立即调用detach
函数。detach
函数分离线程之前被销毁掉,这时就会导致程序崩溃。joinable
判断这个线程是否需要被join
,如果需要那么就会调用terminate
终止当前程序(程序崩溃)。四种互斥量
在C++11中,mutex中总共包了四种互斥量:
1、std::mute
mutex锁是C++11提供的最基本的互斥量,mutex对象之间不能进行拷贝,也不能进行移动。
mutex中常用的成员函数如下:
成员函数 | 功能 |
---|---|
lock | 对互斥量进行加锁 |
try_lock | 尝试对互斥量进行加锁 |
unlock | 对互斥量进行解锁,释放互斥量的所有权 |
线程函数调用lock
时,可能会发生以下三种情况:
unlock
之前,该线程一致拥有该锁。线程调用try_lock
时,类似也可能会发生以下三种情况:
unlock
之前,该线程一致拥有该锁。try_lock
调用返回false,当前的调用线程不会被阻塞。2、std::recursive_mutex
recursive_mutex叫做递归互斥锁,该锁专门用于递归函数中的加锁操作。
unlock
。除此之外,recursive_mutex也提供了lock
、try_lock
和unlock
成员函数,其的特性与mutex大致相同。
3、std::timed_mutex
timed_mutex中提供了以下两个成员函数:
try_lock_for
:接受一个时间范围,表示在这一段时间范围之内线程如果没有获得锁则被阻塞住,如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间之内还是没有获得锁),则返回false。try_lock_untill
:接受一个时间点作为参数,在指定时间点未到来之前线程如果没有获得锁则被阻塞住,如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间点到来时还是没有获得锁),则返回false。除此之外,timed_mutex也提供了lock
、try_lock
和unlock
成员函数,其的特性与mutex相同。
4、std::recursive_timed_mutex
recursive_timed_mutex就是recursive_mutex和timed_mutex的结合,recursive_timed_mutex既支持在递归函数中进行加锁操作,也支持定时尝试申请锁。
加锁示例
在没有使用互斥锁保证线程安全的情况下,让两个线程各自打印1-100的数字,就会导致控制台输出错乱。比如:
void func(int n)
{for (int i = 1; i<= n; i++)
{cout<< i<< endl;
}
}
int main()
{thread t1(func, 100);
thread t2(func, 100);
t1.join();
t2.join();
return 0;
}
如果要让两个线程的输出不会相互影响,即不会让某一次输出中途被另一个线程打断,那么就需要用互斥锁对打印过程进行保护。
这里加锁的方式有两种,一种是在for循环体内进行加锁,一种是在for循环体外进行加锁。比如:
void func(int n, mutex& mtx)
{mtx.lock(); //for循环体外加锁
for (int i = 1; i<= n; i++)
{//mtx.lock(); //for循环体内加锁
cout<< i<< endl;
//mtx.unlock();
}
mtx.unlock();
}
int main()
{mutex mtx;
thread t1(func, 100, ref(mtx));
thread t2(func, 100, ref(mtx));
t1.join();
t2.join();
return 0;
}
说明一下:
经验分享:
使用互斥锁时可能出现的问题
使用互斥锁时,如果加锁的范围太大,那么极有可能在中途返回时忘记了解锁,此后申请这个互斥锁的线程就会被阻塞住,也就是造成了死锁问题。比如:
mutex mtx;
void func()
{mtx.lock();
//...
FILE* fout = fopen("data.txt", "r");
if (fout == nullptr)
{//...
return; //中途返回(未解锁)
}
//...
mtx.unlock();
}
int main()
{func();
return 0;
}
因此使用互斥锁时如果控制不好就会造成死锁,最常见的就是此处在锁中间代码返回,此外还有一个比较常见的情况就是在锁的范围内抛异常,也很容易导致死锁问题。
因此C++11采用RAII的方式对锁进行了封装,于是就出现了lock_guard和unique_lock。
lock_guard
lock_guard是C++11中的一个模板类,其定义如下:
templateclass lock_guard;
lock_guard类模板主要是通过RAII的方式,对其管理的互斥锁进行了封装。
lock
进行加锁。unlock
自动解锁。通过这种构造对象时加锁,析构对象时自动解锁的方式就有效的避免了死锁问题。比如:
mutex mtx;
void func()
{lock_guardlg(mtx); //调用构造函数加锁
//...
FILE* fout = fopen("data.txt", "r");
if (fout == nullptr)
{//...
return; //调用析构函数解锁
}
//...
} //调用析构函数解锁
int main()
{func();
return 0;
}
从lock_guard对象定义到该对象析构,这段区域的代码都属于互斥锁的保护范围。
如果只想用lock_guard保护某一段代码,可以通过定义匿名的局部域来控制lock_guard对象的生命周期。比如:
mutex mtx;
void func()
{//...
//匿名局部域
{lock_guardlg(mtx); //调用构造函数加锁
FILE* fout = fopen("data.txt", "r");
if (fout == nullptr)
{ //...
return; //调用析构函数解锁
}
} //调用析构函数解锁
//...
}
int main()
{func();
return 0;
}
模拟实现lock_guard
模拟实现lock_guard类的步骤如下:
lock
函数进行加锁。unlock
进行解锁。代码如下:
namespace cl
{templateclass lock_guard
{public:
lock_guard(Mutex& mtx)
:_mtx(mtx)
{ mtx.lock(); //加锁
}
~lock_guard()
{ mtx.unlock(); //解锁
}
lock_guard(const lock_guard&) = delete;
lock_guard& operator=(const lock_guard&) = delete;
private:
Mutex& _mtx;
};
}
unique_lock
但由于lock_guard太单一,用户没有办法对锁进行控制,因此C++11又提供了unique_lock。
unique_lock与lock_guard类似,unique_lock类模板也是采用RAII的方式对锁进行了封装。在创建unique_lock对象调用构造函数时也会调用lock进行加锁,在unique_lock对象销毁调用析构函数时也会调用unlock进行解锁。
但lock_guard不同的是,unique_lock更加的灵活,提供了更多的成员函数:
比如如下场景就适合使用unique_lock:
如下图:
线程安全问题
多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的,那么没问题,因为只读操作不会影响到数据,更不会涉及对数据的修改,所以所有线程都会获得同样的数据。但是,当一个或多个线程要修改共享数据时,就会产生很多潜在的麻烦。比如:
void func(int& n, int times)
{for (int i = 0; i< times; i++)
{n++;
}
}
int main()
{int n = 0;
int times = 100000; //每个线程对n++的次数
thread t1(func, ref(n), times);
thread t2(func, ref(n), times);
t1.join();
t2.join();
cout<< n<< endl; //打印n的值
return 0;
}
上述代码中分别让两个线程对同一个变量n进行了100000次++
操作,理论上最终n的值应该是200000,但最终打印出n的值却是小于200000的。
根本原因就是++
操作并不是一个原子操作,该操作分为三步:
load
:将共享变量n从内存加载到寄存器中。update
:更新寄存器里面的值,执行+1操作。store
:将新值从寄存器写回共享变量n的内存地址。++
操作对应的汇编代码如下:
因此可能当线程1刚将n的值加载到寄存器中就被切走了,也就是只完成了++
操作的第一步,而线程2可能顺利完成了一次完整的++
操作才被切走,而这时线程1继续用之前加载到寄存器中的值完成剩余的两步操作,最终就会导致两个线程分别对共享变量n进行了一次++
操作,但最终n的值却只被++
了一次。
加锁解决线程安全问题
C++98中对于这里出现的线程安全的问题,会选择对共享修改的数据进行加锁保护。比如:
void func(int& n, int times, mutex& mtx)
{mtx.lock();
for (int i = 0; i< times; i++)
{//mtx.lock();
n++;
//mtx.unlock();
}
mtx.unlock();
}
int main()
{int n = 0;
int times = 100000; //每个线程对n++的次数
mutex mtx;
thread t1(func, ref(n), times, ref(mtx));
thread t2(func, ref(n), times, ref(mtx));
t1.join();
t2.join();
cout<< n<< endl; //打印n的值
return 0;
}
这里可以选择在for循环体里面进行加锁解锁,也可以选择在for循环体外进行加锁解锁。但效果终究是不尽人意的,在for循环体里面进行加锁解锁会导致线程的频繁进行加锁解锁操作,在for循环体外面进行加锁解锁会导致两个线程的执行逻辑变为串行,而且如果锁控制得不好,还容易造成死锁。
原子类解决线程安全问题
C++11中引入了原子操作类型,使得线程间数据的同步变得非常高效。如下:
原子类型名称 | 对应的内置类型名称 |
---|---|
atomic_bool | bool |
atomic_char | char |
atomic_schar | signed char |
atomic_uchar | unsigned char |
atomic_int | int |
atomic_uint | unsigned int |
atomic_short | short |
atomic_ushort | unsigned short |
atomic_long | long |
atomic_ulong | unsigned long |
atomic_llong | long long |
atomic_ullong | unsigned long long |
atomic_char16_t | char16_t |
atomic_char32_t | char32_t |
atomic_wchar_t | wchar_t |
注意: 需要用大括号对原子类型的变量进行初始化。
程序员不需要对原子类型进行加锁解锁操作,线程能够对原子类型变量互斥访问。比如刚才的代码可以改为:
void func(atomic_int& n, int times)
{for (int i = 0; i< times; i++)
{n++;
}
}
int main()
{atomic_int n = {0 };
int times = 100000; //每个线程对n++的次数
thread t1(func, ref(n), times);
thread t2(func, ref(n), times);
t1.join();
t2.join();
cout<< n<< endl; //打印n的值
return 0;
}
除此之外,也可以使用atomic类模板定义出任意原子类型。比如上述代码还可以改为:
void func(atomic& n, int times)
{for (int i = 0; i< times; i++)
{n++;
}
}
int main()
{atomicn = 0;
int times = 100000; //每个线程对n++的次数
thread t1(func, ref(n), times);
thread t2(func, ref(n), times);
t1.join();
t2.join();
cout<< n<< endl; //打印n的值
return 0;
}
说明一下:
operator=
等。operator=
默认删除掉了。++
操作,还支持原子的--
、加一个值、减一个值、与、或、异或操作。condition_variable中提供的成员函数,可分为wait系列和notify系列两类。
wait系列成员函数
wait系列成员函数的作用就是让调用线程进行阻塞等待,包括wait
、wait_for
和wait_until
。
下面先以wait
为例进行介绍,wait函数提供了两个不同版本的接口:
//版本一
void wait(unique_lock& lck);
//版本二
templatevoid wait(unique_lock& lck, Predicate pred);
函数说明:
为什么调用wait系列函数时需要传入一个互斥锁?
wait_for和wait_until函数的使用方式与wait函数类似:
注意: 调用wait系列函数时,传入互斥锁的类型必须是unique_lock。
notify系列成员函数
notify系列成员函数的作用就是唤醒等待的线程,包括notify_one
和notify_all
。
notify_one
:唤醒等待队列中的首个线程,如果等待队列为空则什么也不做。notify_all
:唤醒等待队列中的所有线程,如果等待队列为空则什么也不做。注意: 条件变量下可能会有多个线程在进行阻塞等待,这些线程会被放到一个等待队列中进行排队。
实现两个线程交替打印1-100尝试用两个线程交替打印1-100的数字,要求一个线程打印奇数,另一个线程打印偶数,并且打印数字从小到大依次递增。
该题目主要考察的就是线程的同步和互斥。
但如果只有同步和互斥是无法满足题目要求的。
鉴于此,这里还需要定义一个flag变量,该变量的初始值设置为true。
flag
的值,而让线程2调用wait函数阻塞等待时,传入的可调用对象返回!flag
的值。代码如下:
int main()
{int n = 100;
mutex mtx;
condition_variable cv;
bool flag = true;
//奇数
thread t1([&]{int i = 1;
while (i<= 100)
{ unique_lockul(mtx);
cv.wait(ul, [&flag]()->bool{return flag; }); //等待条件变量满足
cout<< this_thread::get_id()<< ":"<< i<< endl;
i += 2;
flag = false;
cv.notify_one(); //唤醒条件变量下等待的一个线程
}
});
//偶数
thread t2([&]{int j = 2;
while (j<= 100)
{ unique_lockul(mtx);
cv.wait(ul, [&flag]()->bool{return !flag; }); //等待条件变量满足
cout<< this_thread::get_id()<< ":"<< j<< endl;
j += 2;
flag = true;
cv.notify_one(); //唤醒条件变量下等待的一个线程
}
});
t1.join();
t2.join();
return 0;
}
你是否还在寻找稳定的海外服务器提供商?创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源,准确流量调度确保服务器高可用性,企业级服务器适合批量采购,新人活动首月15元起,快前往官网查看详情吧