1, thread类提供了native_handle()成员函数，用于获得与操作系统相关的原生线程句柄，操作系统原生的线程库就可以用原生线程句柄操作线程

#include <iostream>
#include <thread>
#include <pthread.h>        // Linux的pthread线程库头文件。
using namespace std;

void func()    // 线程任务函数。
{
    for (int ii=1;ii<=10;ii++)
    {
        cout << "ii=" << ii << endl;
        this_thread::sleep_for(chrono::seconds(1));    // 休眠1秒。
    }
}

int main()
{
    thread tt(func);          // 创建线程。

    this_thread::sleep_for(chrono::seconds(5));    // 休眠5秒。

    pthread_t thid= tt.native_handle();  // 获取Linux操作系统原生的线程句柄。

    pthread_cancel(thid);  // 取消线程。

    tt.join();   // 等待线程退出。
}

2， mutex互斥锁

#include <iostream>
#include <thread>                // 线程类头文件。
#include <mutex>                // 互斥锁类的头文件。
using namespace std;

mutex mtx;        // 创建互斥锁，保护共享资源cout对象。

// 普通函数。
void func(int bh, const string& str) {
    for (int ii = 1; ii <= 10; ii++)
    {
        mtx.lock();      // 申请加锁。
        cout << "第" << ii << "次表白：亲爱的" << bh << "号，" << str << endl;
        mtx.unlock();  // 解锁。
        this_thread::sleep_for(chrono::seconds(1));     // 休眠1秒。
    }
}

int main()
{
    // 用普通函数创建线程。
    thread t1(func, 1, "我是一只傻傻鸟。");
    thread t2(func, 2, "我是一只傻傻鸟。");
    thread t3(func, 3, "我是一只傻傻鸟。");
    thread t4(func, 4, "我是一只傻傻鸟。");
    thread t5(func, 5, "我是一只傻傻鸟。");

    t1.join();         // 回收线程t1的资源。
    t2.join();         // 回收线程t2的资源。
    t3.join();         // 回收线程t3的资源。
    t4.join();         // 回收线程t4的资源。
    t5.join();         // 回收线程t5的资源。
}

3, recursive_mutex类

#include <iostream>
#include <mutex>        // 互斥锁类的头文件。
using namespace std;

class AA
{
    // 递归互斥锁允许同一线程多次获得互斥锁，可以解决同一线程多次加锁造成的死锁问题
    recursive_mutex m_mutex;
public:
    void func1() {
        m_mutex.lock();
        cout << "调用了func1()\n";
        m_mutex.unlock();
    }

    void func2() {
        m_mutex.lock();
        cout << "调用了func2()\n";
        func1();
        m_mutex.unlock();
    }
};

int main()
{
    AA aa;
    //aa.func1();
    aa.func2();
}