Windows 多线程编程入门（2）

心已赠人 2023-10-17 21:40 29阅读 0赞

简单总结下C++自带的 std::thread  
优点：  
1. 简单，易用  
2. 跨平台，**pthread只能用在POSIX系统上（其他系统有其独立的thread实现）**  
3. 提供了更多高级功能，比如future  
4. 更加C++（**跟匿名函数，std::bind，RAII等C++特性更好的集成**）

缺点：  
1. 没有RWlock。**有一个类似的shared\_mutex，不过它属于C++14,你的编译器很有可能不支持。**  
2. **操作线程和Mutex等的API较少**。毕竟为了跨平台，只能选取各原生实现的子集。如果你需要设置某些属性，需要通过API调用返回原生平台上的对应对象，再对返回的对象进行操作。

**joinable函数**  
检查线程是否可被 join。检查当前的线程对象是否表示了一个活动的执行线程，**由默认构造函数创建的线程是不能被 join 的**。另外，**如果某个线程 已经执行完任务，但是没有被 join 的话，该线程依然会被认为是一个活动的执行线程，因此也是可以被 join 的。**

t.joinable();

**native\_handle函数**  
由于 **std::thread 的实现和操作系统相关**，因此该函数返回与 std::thread 具体实现相关的线程句柄，例如**在符合 Posix 标准的平台下(如 Unix/Linux)是 Pthread 库**

**yield函数**  
当前线程放弃执行，操作系统调度另一线程继续执行。

std::this_thread::yield();

**hardware\_concurrency 函数**  
此函数为静态函数，用于检测硬件并发特性，返回当前平台的线程实现所支持的线程并发数目，但返回值仅仅只作为系统提示(hint)。

**条件变量**  
作为线程同步的重要方法，std::thread，也支持了condition\_variable：当某些条件不满足时，停止执行直到该条件被满足。

在经典的生产者消费者模式下，**生产者和消费者就是通过condition variable来实现同步的**。当有限的生产力无法满足日益增长的消费需求时，**消费者进程就会去睡一觉，直到它想要的东西生产出来才醒来**。

**condition\_variable需要和 unique\_lock搭配使用**。在一个线程调用wait之前，它必须持有unique\_lock锁。**当wait被调用时，该锁会被释放**，线程会陷入沉睡，等待着王子生产者发过来的唤醒信号。当生产者调用同一个condition\_variable的 **notify\_all方法**时，**所有沉睡在该变量前的消费者会被唤醒，并尝试重新获取之前释放的unique\_lock**，继续执行下去。（注意这里发生了锁争用，只有一个消费者能够获得锁，其他消费者得等待该消费者释放锁）。**如果只想叫醒一个线程，可以用notify\_one**。

**wait**可以接受两个参数。此时**第二个参数用于判断当前是否要沉睡**。

[]{ return msgQueue.size() > 0;});
    
    while (msgQueue.size() <= 0) {
        condvar.wait()
    }

这里把沉睡的线程比作睡美人，万一王子变成了青蛙，来不及唤醒她，那睡美人不就得睡到天荒地老海枯石烂？

为了解决这个问题，通过**wait\_until和wait\_for**，你可以**设定线程的等待时间**。设置**notify\_all\_at\_thread\_exit**也许能帮得上忙。

**atomic**  
它提供了一组轻量级的、作用在单个变量上的原子操作。atomic位于头文件atomic。内容不会被线程的切换所打断。

/*time：20180605
      author：MISAYAONE
      */
    #include<iostream>
    #include<thread>
    #include<Windows.h>
    #include<mutex>
    #include<condition_variable>
    #include<queue>
    using namespace std;
    
    mutex mu_msg;
    condition_variable cv_msg;
    //消费者，生产者模式的简单实现（利用条件变量和互斥锁）
    queue<int> msg_queue;
    void producer(int start, int end)
    {
        for (int i=start;i<end;i++)
        {
            mu_msg.lock();
            msg_queue.push(i);
            mu_msg.unlock();
        }
        cout << "msg produced" << endl;
        if (msg_queue.size() > 20)
        {
            cv_msg.notify_all();//沉睡在该变量上的所有线程都将被唤醒，并尝试获取互斥锁（只有一个消费者可获得互斥锁）
        }
    }
    
    void consumer(int demand)
    {
        while (true)
        {
            unique_lock<std::mutex> ulock(mu_msg);
            cv_msg.wait(ulock,[] {
       return msg_queue.size() > 0;});//尝试获取互斥锁，否则等待
            printf("Consume msg %d\n", msg_queue.front());
            msg_queue.pop();
            --demand;
            if (!demand)
            {
                break;
            }
        }
    }
    
    mutex mu;//互斥锁对象
    
    int num = 100;
    void thread_func1()
    {
        for (int i=0;i<10;i++)
        {
            cout <<"thread 1's "<< i << endl;
            Sleep(100);
        }
    
        while (num>0)//这里不能用while，好无知....
        {
            mu.lock();//互斥锁加锁
            cout << "1还在执行" << num << endl;
            num--;
            mu.unlock();//互斥锁解锁
            if (num < 50)
            {
                //当前线程就不再执行
                this_thread::yield();
                break;
            }
        }
    
    
    
    
    }
    
    void thread_func2(int n)
    {
        for (int i = 0; i<n; i++)
        {
            cout <<"thread 2's "<< i << endl;
            Sleep(200);
        }
        while (num>0)
        {
            mu.lock();
            cout <<"2还在执行"<< num << endl;
            num--;
            mu.unlock();
        }
    
    }
    
    class A
    {
    public :
            void thread_func3()
            {
                for (int i = 0; i<10; i++)
                {
                    cout << "class A thread 3's " << i << endl;
                    Sleep(200);
                }
            }
    
    };
    
    class thread_guard
    {
        thread &t;
    public:
        explicit thread_guard(thread& _t):t(_t){}
        ~thread_guard()
        {
            if (t.joinable())
            {
                t.join();
            }
        }
        //拷贝赋值默认去除
        thread_guard(const thread_guard&) = delete;
        thread_guard& operator=(const thread_guard&) = delete;
    };
    
    int main()
    {
        A a;
        thread task00();//默认构造函数
    
        thread task01(thread_func1);//正常构造函数
        thread_guard g(task01);//出现异常后，函数退出，g局部对象对销毁，此时g调用析构函数，会自动执行task01的join函数，从而能够保证join一定会被调用
        thread task02(thread_func2,10);//带args的线程构造函数
        //thread task_i(move(task02));//转移线程所有权，此时再利用task02调用join和detach会报错
        thread task03(&A::thread_func3,a);//传入类的成员函数作为线程构造函数的参数
    
        if (task01.joinable())//此处不可以使用task00线程来判断
        {
            cout << "task01 is joinable" << endl;
        }
    
    
        //join函数顺序执行线程
        task01.join();
        task02.join();
        //task_i.join();
        //task03.join();
    
        //不影响当前代码的执行，几个线程后台自行执行，不阻塞主线程
        //task01.detach();
        //task02.detach();
        //task_i.detach();
        task03.detach();
    
        //lambda匿名函数
        for (int j=0;j<20;j++)
        {
            thread t([j]() {
       cout << j << endl; });
            t.detach();
        }
    
        for (int i = 0; i<10; i++)
        {
            cout << "main thread's " << i << endl;
            Sleep(200);
        }
    
        cout << "task01.get_id() = " << task01.get_id() << endl;//获取线程ID
    
        unsigned int core_num = std::thread::hardware_concurrency();
        cout << "CPU 核数" << core_num << endl;
    
        thread mutiple00(producer, 10, 20);
        thread mutiple01(producer, 20, 30);
        thread mutiple02(producer, 30, 40);
        thread mutiple03(consumer, 5);
        thread mutiple04(consumer, 8);
    
        mutiple00.join();
        mutiple01.join();
        mutiple02.join();
        mutiple03.join();
        mutiple04.join();
    
    
        cin.get();
        return 0;
    }