C++多线程chap2多线程通信和同步1

这里，只是记录自己的学习笔记。

顺便和大家分享多线程的基础知识。然后从入门到实战。有代码。

知识点来源：

https://edu.51cto.com/course/26869.html

---

1.多线程同步通信

1.1多线程状态

1.1.1线程状态说明：

•   初始化 ( Init ) ：该线程正在创建。
•   就绪 ( Ready )：该线程在继续列表中，等待CPU调度。
•   运行 (Running)：该线程正在运行。
•   阻塞 ( Blocked )：该线程被阻塞挂起。Blocked状态包括：pend（锁、事件、信号量等阻塞）、suspend（主动pend）、delay（延时阻塞）、pendtime（因为锁、事件、信号量时间等 超时等待）。
•   退出  ( Exit ) ：该线程运行结束，等待父线程回收其控制块资源。

1.1.2 竞争状态（Race Condition）和临界区（Critical Section）

竞争状态（Race Condition）

• 多线程同时读写共享数据。

临界区（Critical Section）

• 读写共享数据的代码片段

避免竞争状态策略，对临界区进行保护，同时只能有一个线程进入临界区。

mutex 的 lock()  和 try_lock()  方法的使用。

#include <iostream>
#include <thread>
#include <string>
#include <mutex>
using namespace std;
static mutex mux;

void TestThread() {
    
    //对于锁，尽可能晚的申请；尽可能早的释放。。。

    //获取锁资源，如果没有则阻塞等待
    mux.lock();//处于阻塞状态，cpu资源是释放的。。。
    cout << "========================================" << endl;
    cout << "test 001" << endl;
    cout << "test 002" << endl;
    cout << "test 003" << endl;
    cout << "========================================" << endl;
    mux.unlock();
}


void TestThread2() {

    for (;;) {
        //注意，调用 try_lock 是有开销的，在try_lock之后，必须跟一个sleep_for等待若干时间（释放cpu资源），否则一直try_lock会把cpu资源耗尽。
        if (!mux.try_lock()) {
            cout << "....." <<flush<< endl;
            this_thread::sleep_for(3000ms);
            continue;
        }
        cout << "========================================" << endl;
        cout << "test 001" << endl;
        cout << "test 002" << endl;
        cout << "test 003" << endl;
        cout << "========================================" << endl;
        mux.unlock();
        this_thread::sleep_for(1000ms);
    }
}



int main()
{
    //for (int i = 0; i < 10; i++) {
    //    thread th(TestThread);
    //    th.detach();
    //}

    for (int i = 0; i < 10; i++) {
        thread th(TestThread2);
        th.detach();
    }

    getchar();
    return 0;
}

互斥锁等待坑，线程抢占不到资源.

特别注意，unlock之后，不要再立即进入lock。预留一点时间出来。

#include <iostream>
#include <thread>
#include <string>
#include <mutex>
using namespace std;

//互斥锁等待坑，线程抢占不到资源
static mutex mux;

void ThreradMainMux(int i) {
    //
    for (;;) {

        mux.lock();
        cout << i << "[in]" << endl;
        this_thread::sleep_for(1000ms);
        mux.unlock();

        //特别注意，unlock之后，不要再立即进入lock。预留一点时间出来。
        this_thread::sleep_for(1ms);
    }
}

int main() {
    for (int i = 0; i < 3; i++)
    {
        thread th(ThreradMainMux,i);
        th.detach();
    }

    getchar();
    return 0;
}

超时锁的应用 timed_mutex（避免长时间死锁）

#include <iostream>
#include <string>
#include <mutex>
#include <thread>
using namespace std;



//超时锁的应用 timed_mutex（避免长时间死锁）

timed_mutex  tmux;

void ThreadMainTime(int i) {
    for (;;) {
        if (!tmux.try_lock_for(std::chrono::milliseconds(1000))) {
            cout << i << "[try_lock_for] timeout" << endl;
            continue;
        }
        cout << i << "[in]" << endl;

        this_thread::sleep_for(2000ms);
        tmux.unlock();
        this_thread::sleep_for(1ms);
    }
}


int main() {

    for (int i = 0; i < 3; i++) {
        thread th(ThreadMainTime, i);

        th.detach();
    }

    getchar();
    return 0;
}

//递归锁（可重入） recursive mutex 和 recursive_timed_mutex 用于业务组合

// 同一个线程中的同一把锁可以锁多次，避免了一些不必要的死锁
//组合业务，用到同一把锁

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
using namespace std;
//递归锁（可重入） recursive mutex 和 recursive_timed_mutex 用于业务组合


// 同一个线程中的同一把锁可以锁多次，避免了一些不必要的死锁
//组合业务，用到同意把锁
recursive_mutex rmux;


void Task1() {
    rmux.lock();
    cout << "task1  [in]" << endl;
    rmux.unlock();
}


void Task2() {
    rmux.lock();
    cout << "task2  [in]" << endl;
    rmux.unlock();
}


void ThreadMainRec(int i) {
    for (;;) {
        rmux.lock();
        Task1();
        cout << i << "[in]" << endl;
        this_thread::sleep_for(2000ms);
        Task2();
        rmux.unlock();
        this_thread::sleep_for(1ms);
    }
}


int main() {
    for (int i = 0; i < 3; i++) {
        thread th(ThreadMainRec, i);
        th.detach();
    }


    getchar();
    return 0;
}