线程的基本使用
thread
创建线程的函数，头文件thread。参数可以是函数名、仿函数、lambda表达式、类等等。
创新互联是一家专业提供
江汉企业网站建设,专注与做网站、
网站设计、
H5高端网站建设、小程序制作等业务。10年已为江汉众多企业、政府机构等服务。创新互联专业网站建设公司优惠进行中。join
等待子线程执行完毕
子线程和子进程的死亡是有些区别的。主进程执行完成后，如果子进程没有执行完会被系统init托管；主线程执行完后，如果子线程还没有执行完，子线程会被强制结束。这就有了join函数，等待子线程执行完后在继续执行。
detach
守护线程，detach的作用是使主线程结束后，子线程不会强制结束
joinable
判断线程是否执行了join或者detach这两个函数，没有调用返回true
线程传递参数注意事项
线程中函数参数
- 如果线程中的函数参数是引用类型，传递的其实也是拷贝。如果不给参数增加std::ref的话，除了指针都是值传递
- 如果使用的detach后，使用指针传递要注意参数内存释放的时机，如果主线程结束后，子线程的参数内存肯定是会被释放的
- 如果想改变主线程中的参数，在传递参数的时候可以加上std::ref，此时要注意内存问题
- 如果传递int这种简单类型，推荐使用值传递，不要用引用
- 如果传递类对象，参数需要用const &去接，这样可以少执行一次拷贝构造
- 拒接使用隐士转换当参数，隐式转换实在子线程中进行转换的，可能出现内存问题，要使用显示转换
mutex互斥量用法、死锁
互斥量的用法
包含#include 头文件
死锁
两个线程都已经锁了部分资源，还在互相请求对方已经上锁的资源，都不释放资源，就会造成死锁
解决死锁
unique_lock（类模板）
unique_lock取代lock_guard
unique_lock比lock_guard灵活很多（多出来很多用法），效率差一点。
unique_lockmyUniLock(myMutex);
unique_lock的第二个参数
- std::adopt_lock：
- 表示这个互斥量已经被lock()，即不需要在构造函数中lock这个互斥量了。
- 前提：必须提前lock
- lock_guard中也可以用这个参数
- std::try_to_lock：
- 尝试用mutex的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里；
- 使用try_to_lock的原因是防止其他的线程锁定mutex太长时间，导致本线程一直阻塞在lock这个地方前提：不能提前lock();
- owns_lock()方法判断是否拿到锁，如拿到返回true
- std::defer_lock：
- 如果没有第二个参数就对mutex进行加锁，加上defer_lock是始化了一个没有加锁的mutex
- 不给它加锁的目的是以后可以调用unique_lock的一些方法
- 前提：不能提前lock
unique_lock的成员函数（前三个与std::defer_lock联合使用）
- lock()
- unlock()
- 因为一些非共享代码要处理，可以暂时先unlock()，用其他线程把它们处理了，处理完后再lock()
- try_lock()
- release()
条件锁
condition_variable
std::condition_variable实际上是一个类，是一个和条件相关的类，说白了就是等待一个条件达成。
列举一些他的成员函数
wait()
线程等待，并且会放下锁
wait(线程名，条件函数（可以省略默认true）)
调用该方法后会进入堵塞状态，需要等待比额的线程调用notify_one（）或者notify_all（）来唤醒，唤醒后会尝试继续拿起释放掉的锁
notify_one()
唤醒一个执行过wait还在等待的线程，无法指定唤醒哪一个，是随机唤醒1个
notify_all()
唤醒所有执行了wait还在等待的线程
future、saync
多线程如果函数有返回值，可以使用这两个去接收返回值
std::future result1 = std::async(mythread);
执行futrue的get方法，就可以获得mythread的返回值，如果函数还没有运行完，那么会进入堵塞，一直到有返回值再继续
futrue的wait就是等待返回值，是一个堵塞的方法。
saync的参数
saync有两个参数，第一个参数是如何创建线程，第二个参数是线程函数名字
如果不指定，就是两个随机
std::launch::deferred
该参数线程不会直接创建线程，而且等待执行。
当用户调用get方法的时候，才会执行线程。
注意：他不会创建线程，也是在主线程中执行的方法
std::launch::async
该参数就是直接创建线程直接。是直接执行的
std::packaged_task
类模板，它的模板参数是各种可调用对象，通过packaged_task把各种可调用对象包装起来，方便将来作为线程入口函数来调用。
std::packaged_taskmypt(mythread);
std::thread t1(std::ref(mypt), 1);
并不会直接调用线程，还是需要使用thread去创建显示，他的作用只是打包
可以通过 get_future(); 获取返回值
std::promise类模板我们能够在某个线程中给它赋值，然后我们可以在其他线程中，把这个值取出来
std::promise myprom;
std::thread t1(mythread, std::ref(myprom), 180);
t1.join(); //在这里线程已经执行完了
std::future fu1 = myprom.get_future(); //promise和future绑定，用于获取线程返回值
把他当成一个参数传入，在线程中用setValue来改变他的值，在主线程获取参数
std::async和std::thread()区别：
std::thread()如果系统资源紧张可能出现创建线程失败的情况，如果创建线程失败那么程序就可能崩溃，而且不容易拿到函数返回值（不是拿不到）
std::async()创建异步任务。可能创建线程也可能不创建线程，并且容易拿到线程入口函数的返回值；
由于系统资源限制：
①如果用std::thread创建的线程太多，则可能创建失败，系统报告异常，崩溃。
②如果用std::async，一般就不会报异常，因为如果系统资源紧张，无法创建新线程的时候，async不加额外参数的调用方式就不会创建新线程。而是在后续调用get()请求结果时执行在这个调用get()的线程上。
如果你强制async一定要创建新线程就要使用 std::launch::async 标记。承受的代价是，系统资源紧张时可能崩溃。
③根据经验，一个程序中线程数量 不宜超过100~200 。
std::atomic
原子类，执行不会被中断
只能使用++ – 或者+=类似的运算符才可以保证原子性
Windows临界区
临界区跟上锁类似，有进入临界区，离开临界区，作用和和锁是一样的。
创建临界区
CRITICAL_SECTION my_winsec;
初始化临界区
InitializeCriticalSection(&my_winsec)
进入临界区
EnterCriticalSection(&my_winsec);
是可以重复进入的，mutex是无法重复lock的
离开临界区
LeaveCriticalSection(&my_winsec);
手写自动自动离开的临界区
class CWinLock {public:
CWinLock(CRITICAL_SECTION *pCritmp)
{my_winsec =pCritmp;
EnterCriticalSection(my_winsec);
}
~CWinLock()
{LeaveCriticalSection(my_winsec)
};
private:
CRITICAL_SECTION *my_winsec;
};
递归锁
独占互斥量 std::recursive_mutex
std::mutex 独占式互斥量
std::recursive_mutex：允许在同一个线程中同一个互斥量多次被 lock() ，（但是递归加锁的次数是有限制的，太多可能会报异常），效率要比mutex低。
如果你真的用了 recursive_mutex 要考虑代码是否有优化空间，如果能调用一次 lock()就不要调用多次。
带超时的互斥量 std::timed_mutex 和 std::recursive_timed_mutex
std::timed_mutex：是待超时的独占互斥量std::recursive_timed_mutex：是待超时的递归独占互斥量自旋锁
自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。
获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成busy-waiting。即不断的消耗cpu
它是为实现保护共享资源而提出一种锁机制。其实，自旋锁与互斥锁比较类似，它们都是为了解决对某项资源的互斥使用。无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。但是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，”自旋”一词就是因此而得名。
class CAS
{private:
std::atomicflag;
public:
CAS():flag(false) {}
~CAS() {}
CAS(const CAS& s) = delete;
CAS& operator=(const CAS&) = delete;
void lock()
{bool expect = false;
while (!flag.compare_exchange_strong(expect, true))
{ expect = false;
}
}
void unlock()
{flag.store(false);
}
};
compare_exchange_strong
当前值与期望值(expect)相等时，修改当前值为设定值(desired,第二个参数)，返回true
当前值与期望值(expect)不等时，将期望值(expect)修改为当前值，返回false
总结
自旋锁：线程获取锁的时候，如果锁被其他线程持有，则当前线程将循环等待，直到获取到锁。
自旋锁等待期间，线程的状态不会改变，线程一直是用户态并且是活动的(active)。
自旋锁如果持有锁的时间太长，则会导致其它等待获取锁的线程耗尽CPU。
自旋锁本身无法保证公平性，同时也无法保证可重入性。
基于自旋锁，可以实现具备公平性和可重入性质的锁
读写锁
相比互斥锁，读写锁允许更高的并行性，互斥量要么锁住状态要么不加锁，而且一次只有一个线程可以加锁。
读写锁可以有三种状态：
排他性锁定
lock
锁定互斥。若另一线程已锁定互斥，则lock的调用线程将阻塞执行，直至获得锁。
若已以任何模式（共享或排他性）占有 mutex 的线程调用 lock ，则行为未定义。也就是说，已经获得读模式锁或者写模式锁的线程再次调用lock的话，行为是未定义的。
注意：通常不直接使用std::shared_mutex::lock()，而是通过unique_lock或者lock_guard进行管理。
unlock
解锁互斥。
互斥必须为当前执行线程所锁定，否则行为未定义。如果当前线程不拥有该互斥还去调用unlock，那么就不知道去unlock谁，行为是未定义的。
注意：通常不直接调用 unlock() 而是用 std::unique_lock 与 std::lock_guard 管理排他性锁定。
共享锁定
std::shared_mutex::lock_shared
相比mutex，shared_mutex还拥有lock_shared函数。
该函数获得互斥的共享所有权。若另一线程以排他性所有权保有互斥，则lock_shared的调用者将阻塞执行，直到能取得共享所有权。
若已以任何模式（排他性或共享）占有 mutex 的线程调用 lock_shared ，则行为未定义。即：当以读模式或者写模式拥有锁的线程再次调用lock_shared时，行为是未定义的，可能产生死锁。
若多于实现定义大数量的共享所有者已以共享模式锁定互斥，则 lock_shared 阻塞执行，直至共享所有者的数量减少。所有者的大数量保证至少为 10000。
注意：通常不直接调用 lock_shared() 而是用 std::shared_lock 管理共享锁定。
shared_lock与unique_lock的使用方法类似、
std::shared_mutex::unlock_shared
将互斥从调用方线程的共享所有权释放。
当前执行线程必须以共享模式锁定互斥，否则行为未定义。
通常不直接调用 unlock_shared() 而是用 std::shared_lock 管理共享锁定。
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
分享文章：C++多线程笔记-创新互联
URL标题：
http://cdkjz.cn/article/cciecc.html
