基于c++11的多线程基础知识

一，线程的创建

      包含头文件 #include<thread>
      th.join()          阻塞等待子线程退出
      th.detach()     子线程与主线程分离
 
     1.1  传入函数创建线程
            void  ThreadMain()
            {
                  cout<<"begin  thread  main "<<endl;
            }
            int  main()
            {
                   thread  th(ThreadMain);
            }

     1.2  传入类成员函数创建线程
            class  MyThread
            {
              public:
                    void  Main()
                   {
                          cout<<"MyThread  Main"<<name<<endl;
                   }
                   string   name;
            };

            MyThread  mth;
            mth.name = "test  mythread";
            thread  th(&MyThread::Main , &mth);

     1.3  lambda表达式创建线程

            thread  th  ( [](int  i){ cout<<"test  lmbda"<<i<<endl; } , 123   );
            
            class  Testlambda
            {
              public:
                     void  Start()
                     {
                           thread  th( [this]() { cout<<name<<endl; } );
                     }
                     string  name = "test  lambda";
            };

二，多线程

       2.1:  多线程
              初始化状态：该线程正在创建。
              就绪态：该线程在就绪列表中，等待cpu调度
              运行态：该程序正在运行
              阻塞态：被阻塞
              退出：该线程运行结束，等待父线程回收资源

              竞争状态：多线程同事读写共享数据
              临界区： 读写共享数据的代码片段

       2.2：互斥锁
               头文件  #include<mutex>
               mutex  mux;
               mux.lock()
               mux.unlock()
               mux.try_lock()  //尝试去锁，成功返回true
               this_thread::sleep_for(100)

        2.3:  超时锁
               timed_mutex  tmux;
               tmux.try_lock_for( milliseconds( 1000 ) )
               //超时锁，在1000ms内没有获得锁，则返回false  

        2.4:  递归锁，同一个锁，锁多次
               recursive_mutex   rmux;

        2.5:  mutex  gmutex;
                lock_guard<mutex>  lock(gmutex);

          

三，生产者消费者模型

          生产者-消费者模型

          生产者和消费者共享资源变量（list队列）
          生产者生产一个产品，通知消费者消费
          消费者阻塞等待信号-获取信号后消费产品（取出list队列）

        （一） 改变并通知共享变量的线程步骤
               1，获得 std::mutex (常通过 std::unique_lock)
                    unique_lock  lock(mux);

               2,  在获取锁时进行修改
                    msgs_.push_back(data);

              3,  释放锁并通知读取线程
                    lock.unlock();
                    cv.notify_one();  //通知一个等待信号线程
                    cv.notify_all();    //通知所有等待信号线程

        （二）等待信号读取共享变量的线程步骤
              1，获得与改变共享变量线程共同的mutex
                    unique_lock   lock(mux);

              2,  wait()等待信号通知
                    cv.wait(lock);   //解锁lock，并阻塞等待notify_one  notify_all通知
                    msgs_.front();
                    msgs_.pop_front();  //处理数据

                    lambada表达式 cv.wait( lock , [] { return !msgs_.empty(); } );