C ++ _多线程笔记

#include<iostream>
#include <thread>//创建线程需要添加的头文件

using namespace std;
/*thread join(阻塞：主等子) detach（主子分离） */
int main ()
{
    
    
    
    return 0;
}

第三节：线程传参详解，detach()大坑，成员函数做线程函数
    （1）传递临时对象作为线程函数
        （1.1）要避免的陷阱（解释1）
        （1.2）要避免的陷阱（解释2）
        （1.3）总结
    （2）临时对象作为线程参数继续讲
        （2.1）线程ID的概念
        （2.2）临时对象构造时机抓捕
    （3）传递类对象、智能指针作为线程参数
    （4）用成员函数指针做线程函数

第四节：创建多个线程、数据共享问题分析、案列代码
    （1）创建和等待多个线程
    （2）数据共享问题分析
        （2.1）只读的数据-->是安全稳定的，不需要特别的处理手段，直接读就可以。
        （2.2）有读有写
        （2.3）其他案例
    （3）共享数据的保护案例代码

代码编写：
创建和等待多个线程：
-----------------------------------------------------------------------------------------------------------
                //线程入口函数(多个线程的入口函数)
                void myPrint(int inum)
                {
                    cout<<"myPrint线程开始执行了！！！！，线程编号 = "<<inum << endl;
                    //......干各种事情
                    
                    
                    cout<< "myPrint线程结束执行了！！！！，线程编号 = "<<inum <<endl;
                    return ;
                    
                }

int main ()
                {
                    //一、创建和等待多个线程
                    vector <thread> mythreads;
                    //创建10个线程，线程入口函数同一使用myPrint
                    for (int i = 0;i< 10;i++)
                    {
                        mythreads.push_back(thread(myPrint,i));//创建10 个线程，同时这10 个线程已近开始执行
                    }
                    
                    for(auto iter = mythreads.begin();iter != mythreads.end();++iter)
                    {
                        iter->join();//等待10 个线程都返回
                    }
                    
                    cout << "I LOVe "<<endl;
                }
--------------------------------------------------------------------------------------------------------
    总结a：多个线程执行顺序是乱的，跟操作系统内部对线程的运行调度机制有关
        b:主线程等待所有子线程运行结束，最后主线程结束，老师推荐这种join的写法，跟容易写出稳定的程序，
        c:咱们把thread对象放入容器管理，看起来像个thread对象数组，这对我们一次创建大量的线程并对大量线程进行管理很方便。

第五节：互斥量概念、用法、死锁演示及解决详解
（1）互斥量的基本概念
（2）互斥量的用法
    （2.1）lock \unlock
     (2.2) std :: lock_guard ()类模板-->自动上解锁
（3）死锁
    （3.1）死锁演示
    （3.2）死锁的一般解决方案-->顺序一致
    （3.3）std::lock() 函数模板
    （3.4）std::lock_guardde std::adopt_lock参数
    
    
第六节：unique_lock 详解
    （1）unique_lock 取代lock_quard
    （2）unique_lock的第二个参数
        （2.1）std::adopt_lock
        （2.2）std::try_to_lock
        （2.3）std::defer_lock
    （3）unique_lock的成员函数
        （3.1）lock()
        （3.2）unlock()
        （3.3）try_lock()
        （3.4）release()
    （4）unique_lock 所有权的传递
    
第七节 单例设计模式共享数据分析、解决、call_once
    （1）设计模式大概谈
    （2）单例设计模式
    （3）单例设计模式共享数据问题分析，解决
    （4）std::call_once()

第八节 conditition_variable 、wait、notify_one 、notify_all
    （1）条件变量std::conditition_variable、 wait()、 notify_one()
    （2）上述代码深入思考
    （3）notify_all()
    
第九节 async 、future 、packaged_task、promise
    （1）std::async、 std::future创建后台任务并返回值
    （2）std::packaged_task
    （3）std::promise
    （4）小结

第十节 future 其他的成员函数 、 shared_future 、 atomic
    （1）std::future的其他成员函数
    （2）std::shared_future
    （3）原子操作std::atomic
        （3.1）原子操作概念引出范例
        （3.2）基本的std::atomic 用法范例
        （3.3）老师的心得
第十一节 std::atomic续谈、std::async 深入谈
        （1）原子操作std::atomic续谈
        （2）std::async 深入谈
            （2.1）std::async 参数详述
            （2.2）std::async 和std::thread 的区别
            （2.3）std::async 不确定性问题的解决

第十二节Windows临界区、其他各种mutex互斥量
    （1）Windows临界区
    （2）多次进入临界区试验
    （3）自动析构技术
    （4）recursive_mutex 递归的独占互斥量
    （5）带超时的互斥量std::timed_mutex和std::recursive_timed_mutex
    
    
第十三节 补充知识、线程池浅谈、数量谈、总结
    （1）补充一些知识点
        （1.1）虚假唤醒
        （1.2）atomic
    （2）浅谈线程池
        （2.1）场景设想
        （2.2）实现方式
    （3）线程创建数量谈
    （4）C++多线程总结