【C++】C++11------线程库

线程库接口

在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接口，这使得代码的可移植性比较差。

C++11中最重要的特性就是对线程进行支持了，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。

要使用标准库中的线程，必须包含< thread >头文件。

线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态。
当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程 。

#include
#include
using namespace std;
 
void func(int n)
{
    cout << this_thread::get_id() << endl; //打印该线程的id
    for (int i = 0; i < n; ++i)
    {
        cout << i << endl;
    }
}
 
int main()
{
    thread t1(func, 10); //创建线程
    //thread(func, 10).detach(); //创建匿名线程 注意：匿名线程必须在创建时将线程分离，因为后面会找不到
    t1.join(); //线程等待
    // this_thread::sleep_for(std::chrono::seconds(3)); //使当前线程休眠
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。线程函数一般情况下可按照以下三种方式提供：函数指、lambda表达式、函数对象

线程接口使用

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，因此：即使线程参数为引用类型，在线程中修改后也不能修改外部实参，因为其实际引用的是线程栈中的拷贝，而不是外部实参。

当然还有一种方法能够改变参数的值，那就是指针：

注意：如果是类成员函数作为线程参数时，必须将this作为线程函数参数。

class A
{
public:
    int add(int x, int y)
    {
        cout << x + y << endl;
        return x + y;
    }
};
 
int main()
{
    A a;
    //  传入顺序 线程函数，实例化类指针，函数参数
    thread t1(&A::add, &a, 10, 20);
    t1.join();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

lock_guard与unique_lock

在多线程环境下，如果想要保证某个变量的安全性，只要将其设置成对应的原子类型即可，即高效又不容易出现死锁问题。但是有些情况下，我们可能需要保证一段代码的安全性，那么就只能通过锁的方式来进行控制。

int x = 0;
 
void add(int n)
{
    for (int i = 0; i < n; ++i)
    {
        x++;
        cout << this_thread::get_id() << "：" << x << endl;
    }
}
 
int main()
{
    thread t1(add, 10000);
    thread t2(add, 10000);
    t1.join();
    t2.join();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

上面的代码两个线程各自对x加了10000次，但是从结果中可以发现x最后的值只有1992，所以这其中一定出现了线程安全问题。

所以这里需要进行加锁操作，C++11中也新增了加锁的库。

mutex(互斥锁)

①mutex:

  C++11提供的最基本的互斥量，该类的对象之间不能拷贝，也不能进行移动。mutex最常用的三个函数:

注意，线程函数调用lock() 时，可能会发生以下三种情况：

• 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁
• 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住
• 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

线程函数调用try_lock() 时，可能会发生以下三种情况：

• 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量
• 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉
• 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

②recursive_mutex :

其允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，释放互斥量时需要调用与该锁层次深度相同次数的
unlock()，除此之外，std::recursive_mutex 的特性和std::mutex 大致相同。

③timed_mutex:

比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until() 。

try_lock_for()

接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与 std::mutex的 try_lock() 不同，try_lock 如果被调用时没有获得锁则直接返回 false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

try_lock_until()

接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

lock_guard

锁控制不好时，可能会造成死锁，最常见的比如在锁中间代码返回，或者在锁的范围内抛异常。因此：C++11采用RAII的方式对锁进行了封装，即lock_guard和unique_lock。

C++11中lock_guard实现如下

template<class _Mutex>
class lock_guard
{
public:
    // 在构造lock_gard时，_Mtx还没有被上锁
    explicit lock_guard(_Mutex& _Mtx)
        : _MyMutex(_Mtx)
    {
        _MyMutex.lock();
    }
    // 在构造lock_gard时，_Mtx已经被上锁，此处不需要再上锁
    lock_guard(_Mutex& _Mtx, adopt_lock_t)
        : _MyMutex(_Mtx)
    {}
    ~lock_guard() _NOEXCEPT
    {
        _MyMutex.unlock();
    }
    lock_guard(const lock_guard&) = delete;
    lock_guard& operator=(const lock_guard&) = delete;
private:
    _Mutex& _MyMutex;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

对锁进行封装，实现了定义这个类后，在此作用域自动上锁，出了此作用域自动释放锁。有效的避免了死锁问题。
lock_guard的缺陷：太单一，用户没有办法对该锁进行控制，因此C++11又提供了unique_lock。

unique_lock

与lock_gard类似，unique_lock*类模板也是采用RAII的方式对锁进行了封装，并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作，即其对象之间不能发生拷贝。在构造(或移动(move)赋值)时，unique_lock
对象需要传递一个 Mutex 对象作为它的参数，新创建的 unique_lock 对象负责传入的
Mutex对象的上锁和解锁操作。使用以上类型互斥量实例化unique_lock的对象时，自动调用构造函数上锁，unique_lock对象销毁时自动调用析构函数解锁，可以很方便的防止死锁问题。

与lock_guard不同的是，unique_lock更加的灵活，提供了更多的成员函数：

• 上锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until和unlock

• 修改操作：移动赋值、交换(swap：与另一个unique_lock对象互换所管理的互斥量所有权)、释放(release：返回它所管理的互斥量对象的指针，并释放所有权)

• 获取属性：owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相同)、mutex(返回当前unique_lock所管理的互斥量的指针)。

原子性操作库

多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦。

所谓原子操作：即不可被中断的一个或一系列操作，C++11引入的原子操作类型，使得线程间数据的同步变得非常高效 。

对于我们上面见到的两个线程操作同一份公共资源出现的问题，我们也可以用原子性操作进行解决。

#include
atomic<int> x = 0;
void add(int n)
{
    for (int i = 0; i < n; ++i)
    {
        x++;  // 原子操作
        cout << this_thread::get_id() << "：" << x << endl;
    }
}
 
int main()
{
    thread t1(add, 10000);
    thread t2(add, 10000);
    t1.join();
    t2.join();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在C++11中，程序员不需要对原子类型变量进行加锁解锁操作，线程能够对原子类型变量互斥的访问。

更为普遍的，程序员可以使用atomic类模板，定义出需要的任意原子类型。

atmoic<T> t; // 声明一个类型为T的原子类型变量t
1

我们可以看到他支持的类型

条件变量(condition_variable)

使用互斥锁或者是原子性操作只能解决多线程访问临界资源的同步操作问题，但是多线程间存在竞争关系，这样可能会导致一个线程可以连续多次访问临界资源，而其余线程只能等待，出现了线程饥饿问题，使用条件变量可以解决这一问题。
以我们以上实例为例（没有条件变量） 可以看到同一个线程多次连续访问临界资源，另一个线程饥饿

条件变量接口

wait():释放已经申请的锁，进行等待，有需要的时候唤醒

notify_one():唤醒等待队列中的一个线程
notify_all()：唤醒等待队列中的所有线程（慎用）

面试题：1-100之间的数，使用两个线程交替打印，线程1打印奇数，线程2打印偶数。
思路： 使用我们之前的互斥锁和条件变量实现，线程1打印奇数后，唤醒线程2，线程1进入等待，在线程2打印偶数后，唤醒线程1，线程2进入等待，重复此步骤，可以实现。

#include
#include
#include
#include
using namespace std;
int main()
{
	mutex mtx;
	condition_variable cond;

	int n = 100;
	int x = 1;
	thread t1([&,n] 
		{
			while (x < n)
			{
				unique_lock<mutex> lock(mtx);
				if (x % 2 == 0)cond.wait(lock);
				cout << this_thread::get_id() << ": " << x << endl;
				++x;
				cond.notify_one();
			}
		});

	thread t2([&, n]
		{
			while (x < n)
			{
				unique_lock<mutex> lock(mtx);
				if (x % 2 == 1)cond.wait(lock);
				cout << this_thread::get_id() << ": " << x << endl;
				++x;
				cond.notify_one();
			}
		});

	t1.join();
	t2.join();

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41