批量信号量并发

女爷i 2022-10-17 13:58 184阅读 0赞

## 信号量并发： ##

#include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <queue>
    #include <semaphore.h>
    #include <unistd.h>
    #include <memory>
    #include <mutex>
    #include <condition_variable>
    
    using namespace std;
    pthread_mutex_t m_queue_lock;
    pthread_cond_t m_cond;;
    condition_variable cond;
    mutex mu;        
    mutex mu1;        
    
    int wakeups = 0;
    void* thread_func(void* _pool) {
        cout  << *((int*)_pool) << " seq " << endl;
        while(1) {
            std::unique_lock<std::mutex> lock(mu);            
            cond.wait(lock, [&]()->bool{ return wakeups>0;});
            int v = wakeups--;
            cout  << *((int*)_pool) << " hello " << v << endl;
        }
    }
    void* thread_func1(void* _pool) {
        cout  << *((int*)_pool) << " seq " << endl;
        while(1) {
            int v = 0;
            {
                std::unique_lock<std::mutex> lock(mu);            
                cond.wait(lock, [&]()->bool{ return wakeups >0;});
                v = wakeups--;
            }
            sleep(5);
            {
                std::unique_lock<std::mutex> lock(mu1);
                cout  << *((int*)_pool) << " hello " << v << endl;
            }
            sleep(5);
        }
    }
    void* thread_func2(void* _pool) {
        cout  << *((int*)_pool) << " seq " << endl;
        while(1) {
            pthread_mutex_lock(&m_queue_lock);
            pthread_cond_wait(&m_cond, &m_queue_lock);
            pthread_mutex_unlock(&m_queue_lock);
    
            sleep(5);
            cout  << *((int*)_pool) << " hello" << endl;
            sleep(5);
        }
    }
    
    int main() {
    
        pthread_mutex_init(&m_queue_lock, NULL);
        pthread_cond_init(&m_cond, NULL);
    
        pthread_t* m_pids = new pthread_t[100];
        for (int i = 0; i < 10; ++i) {
            pthread_create(&m_pids[i], NULL, &thread_func1, &i);
        }
        sleep(2);
        cout << "begin" << endl;
    
        {
            std::lock_guard<std::mutex> lock(mu);            
            //std::unique_lock<std::mutex> lock(mu1);
            wakeups = 100;
            //cond.notify_one();
            cond.notify_all(); 
        }
        /*
        {
    
            pthread_mutex_lock(&m_queue_lock);
            pthread_cond_broadcast(&m_cond);
            //pthread_cond_signal(&m_cond);
            pthread_mutex_unlock(&m_queue_lock);
        }
        */
        sleep(1000);
    }

wait和notify调换，改动少许逻辑就是，countdownlatch了；