devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++多线程生产者消费者的实现_c++多线程生产者消费者怎么实现

作者：你好赵伟 | 2024-03-19 14:24:43

赞

踩

c++多线程生产者消费者怎么实现

分为四种情况：单生产者单消费者；单生产者多消费者；多生产者单消费者；多生产者多消费者。

单生产者单消费者：

  1. #include<iostream>
  2. #include<chrono>
  3. #include<mutex>
  4. #include<condition_variable>
  5. #include<thread>
  6.  
  7.  
  8. using namespace std;
  9.  
  10. static int pool_max = 10, max_size = 15, pool_size = 0, producer_count = 0, consumer_count = 0;
  11.     /* 产品池容量大小   最多生产产品的个数 当前池中的产品个数 生产了个产品数量  消费了的产品数量 */
  12.  
  13. mutex m_c, m_p, m;
  14. /* 多消费者时的互斥量   多生产者时的互斥量  产品池的互斥量 */
  15.  
  16. condition_variable p_not_full, p_not_empty;
  17. /* 生产者等待产品池不满   消费者等待产品池非空 */
  18.  
  19.  
  20. void ProducerS ()
  21. {
  22.     while (true)
  23.     {
  24.         unique_lock<mutex> lck(m);
  25.         while (pool_size == pool_max)
  26.         {
  27.             cout << "Pool full\t Wait..." << endl;
  28.             p_not_full.wait(lck);
  29.         }
  30.         pool_size++;
  31.         producer_count++;
  32.         cout << "Producer generate : " << producer_count << endl;
  33.         if (pool_size == 1)
  34.         {
  35.             cout << "Notify consumer...\n";
  36.             p_not_empty.notify_one();
  37.         }
  38.         if (producer_count == max_size) break;
  39.         lck.unlock();
  40.         this_thread::sleep_for(chrono::milliseconds(1000));
  41.     }
  42.     cout << "Producer Single exit\t id is : " << this_thread::get_id() << endl;
  43. }
  44.  
  45. void ConsumerS()
  46. {
  47.     while (true)
  48.     {
  49.         unique_lock<mutex> lck(m);
  50.         while (pool_size == 0)
  51.         {
  52.             cout << "Pool empty\t Wait...\n";
  53.             p_not_empty.wait(lck);
  54.         }
  55.         pool_size--;
  56.         consumer_count++;
  57.         cout << "Consumer consume : " << consumer_count << endl;
  58.         if (pool_size == pool_max-1)
  59.         {
  60.             cout << "Notify producer...\n";
  61.             p_not_full.notify_one();
  62.         }
  63.         if (consumer_count == max_size) break;
  64.         lck.unlock();
  65.         this_thread::sleep_for(chrono::milliseconds(1500));
  66.     }
  67.     cout << "Consumer Single exit\t id is : " << this_thread::get_id() << endl;
  68. }
  69.  
  70. void TestPsCs()
  71. {
  72.     thread t_c(ConsumerS);
  73.     thread t_p(ProducerS);
  74.  
  75.     t_c.join();
  76.     t_p.join();
  77. }
  78.  
  79.  
  80. int main(void)
  81. {
  82.     TestPsCs();
  83.     return 0;
  84. }

运行截图：

单生产者多消费者：

  1. #include<iostream>
  2. #include<chrono>
  3. #include<mutex>
  4. #include<condition_variable>
  5. #include<thread>
  6.  
  7.  
  8. using namespace std;
  9.  
  10. static int pool_max = 10, max_size = 15, pool_size = 0, producer_count = 0, consumer_count = 0;
  11.     /* 产品池容量大小   最多生产产品的个数 当前池中的产品个数 生产了个产品数量  消费了的产品数量 */
  12.  
  13. mutex m_c, m_p, m;
  14. /* 多消费者时的互斥量   多生产者时的互斥量  产品池的互斥量 */
  15.  
  16. condition_variable p_not_full, p_not_empty;
  17. /* 生产者等待产品池不满   消费者等待产品池非空 */
  18.  
  19.  
  20. void ProducerS ()
  21. {
  22.     while (true)
  23.     {
  24.         unique_lock<mutex> lck(m);
  25.         while (pool_size == pool_max)
  26.         {
  27.             cout << "Pool full\t Wait..." << endl;
  28.             p_not_full.wait(lck);
  29.         }
  30.         pool_size++;
  31.         producer_count++;
  32.         cout << "Producer generate : " << producer_count << endl;
  33.         if (pool_size == 1)
  34.         {
  35.             cout << "Notify consumer...\n";
  36.             p_not_empty.notify_one();
  37.         }
  38.         if (producer_count == max_size) break;
  39.         lck.unlock();
  40.         this_thread::sleep_for(chrono::milliseconds(1000));
  41.     }
  42.     cout << "Producer Single exit\t id is : " << this_thread::get_id() << endl;
  43. }
  44.  
  45. void ConsumerM()
  46. {
  47.     while (true)
  48.     {
  49.         unique_lock<mutex> lck_c(m_c);
  50.         if (consumer_count == max_size) break;
  51.  
  52.         unique_lock<mutex> lck(m);
  53.         while (pool_size == 0)
  54.         {
  55.             cout << "Pool empty\t Wait...\n";
  56.             p_not_empty.wait(lck);
  57.         }
  58.         pool_size--;
  59.         consumer_count++;
  60.         cout << "Consumer : " << this_thread::get_id() << "\tconsume : " << consumer_count << endl;
  61.         if (pool_size == pool_max-1)
  62.         {
  63.             cout << "Notify producer...\n";
  64.             p_not_full.notify_one();
  65.         }
  66.         if (consumer_count == max_size) break;
  67.         lck_c.unlock();
  68.         lck.unlock();
  69.         this_thread::sleep_for(chrono::milliseconds(1500));
  70.     }
  71.     cout << "Consumer Single exit\t id is : " << this_thread::get_id() << endl;
  72. }
  73.  
  74.  
  75. void TestPsCM()
  76. {
  77.     const int c_t_i = 5;
  78.     thread t_c[c_t_i];
  79.     for (int i = 0; i<c_t_i; ++i)
  80.         t_c[i] = thread(ConsumerM);
  81.     thread t_p(ProducerS);
  82.  
  83.     for (int i = 0; i<c_t_i; ++i)
  84.         t_c[i].join();
  85.     t_p.join();
  86. }
  87.  
  88.  
  89. int main(void)
  90. {
  91.     TestPsCM();
  92.     return 0;
  93. }

运行截图：

多生产者单消费者：

  1. #include<iostream>
  2. #include<chrono>
  3. #include<mutex>
  4. #include<condition_variable>
  5. #include<thread>
  6.  
  7.  
  8. using namespace std;
  9.  
  10. static int pool_max = 10, max_size = 15, pool_size = 0, producer_count = 0, consumer_count = 0;
  11.     /* 产品池容量大小   最多生产产品的个数 当前池中的产品个数 生产了个产品数量  消费了的产品数量 */
  12.  
  13. mutex m_c, m_p, m;
  14. /* 多消费者时的互斥量   多生产者时的互斥量  产品池的互斥量 */
  15.  
  16. condition_variable p_not_full, p_not_empty;
  17. /* 生产者等待产品池不满   消费者等待产品池非空 */
  18.  
  19.  
  20. void ProducerM ()
  21. {
  22.     while (true)
  23.     {
  24.         unique_lock<mutex> lck_p(m_p);
  25.         if (producer_count == max_size) break;
  26.  
  27.         unique_lock<mutex> lck(m);
  28.         while (pool_size == pool_max)
  29.         {
  30.             cout << "Pool full\t Wait..." << endl;
  31.             p_not_full.wait(lck);
  32.         }
  33.         pool_size++;
  34.         producer_count++;
  35.         cout << "Producer : " << this_thread::get_id() << "\tgenerate : " << producer_count << endl;
  36.         if (pool_size == 1)
  37.         {
  38.             cout << "Notify consumer...\n";
  39.             p_not_empty.notify_one();
  40.         }
  41.         if (producer_count == max_size) break;
  42.         lck.unlock();
  43.         lck_p.unlock();
  44.         this_thread::sleep_for(chrono::milliseconds(1000));
  45.     }
  46.     cout << "Producer Single exit\t id is : " << this_thread::get_id() << endl;
  47. }
  48.  
  49. void ConsumerS()
  50. {
  51.     while (true)
  52.     {
  53.         unique_lock<mutex> lck(m);
  54.         while (pool_size == 0)
  55.         {
  56.             cout << "Pool empty\t Wait...\n";
  57.             p_not_empty.wait(lck);
  58.         }
  59.         pool_size--;
  60.         consumer_count++;
  61.         cout << "Consumer : " << this_thread::get_id() << "\tconsume : " << consumer_count << endl;
  62.         if (pool_size == pool_max-1)
  63.         {
  64.             cout << "Notify producer...\n";
  65.             p_not_full.notify_one();
  66.         }
  67.         if (consumer_count == max_size) break;
  68.         lck.unlock();
  69.         this_thread::sleep_for(chrono::milliseconds(1500));
  70.     }
  71.     cout << "Consumer Single exit\t id is : " << this_thread::get_id() << endl;
  72. }
  73.  
  74.  
  75. void TestPmCs()
  76. {
  77.     const int p_t_i = 5;
  78.     thread t_c(ConsumerS);
  79.     thread t_p[p_t_i];
  80.     for (int i = 0; i<p_t_i; ++i)
  81.         t_p[i] = thread(ProducerM);
  82.  
  83.     for (int i = 0; i<p_t_i; ++i)
  84.         t_p[i].join();
  85.     t_c.join();
  86. }
  87.  
  88.  
  89. int main(void)
  90. {
  91.     TestPmCs();
  92.     return 0;
  93. }

运行截图：

多生产者多消费者：

  1. #include<iostream>
  2. #include<chrono>
  3. #include<mutex>
  4. #include<condition_variable>
  5. #include<thread>
  6.  
  7.  
  8. using namespace std;
  9.  
  10. static int pool_max = 10, max_size = 15, pool_size = 0, producer_count = 0, consumer_count = 0;
  11.     /* 产品池容量大小   最多生产产品的个数 当前池中的产品个数 生产了个产品数量  消费了的产品数量 */
  12.  
  13. mutex m_c, m_p, m;
  14. /* 多消费者时的互斥量   多生产者时的互斥量  产品池的互斥量 */
  15.  
  16. condition_variable p_not_full, p_not_empty;
  17. /* 生产者等待产品池不满   消费者等待产品池非空 */
  18.  
  19.  
  20. void ProducerM ()
  21. {
  22.     while (true)
  23.     {
  24.         unique_lock<mutex> lck_p(m_p);
  25.         if (producer_count == max_size) break;
  26.  
  27.         unique_lock<mutex> lck(m);
  28.         while (pool_size == pool_max)
  29.         {
  30.             cout << "Pool full\t Wait..." << endl;
  31.             p_not_full.wait(lck);
  32.         }
  33.         pool_size++;
  34.         producer_count++;
  35.         cout << "Producer : " << this_thread::get_id() << "\tgenerate : " << producer_count << endl;
  36.         if (pool_size == 1)
  37.         {
  38.             cout << "Notify consumer...\n";
  39.             p_not_empty.notify_one();
  40.         }
  41.         if (producer_count == max_size) break;
  42.         lck.unlock();
  43.         lck_p.unlock();
  44.         this_thread::sleep_for(chrono::milliseconds(1000));
  45.     }
  46.     cout << "Producer Single exit\t id is : " << this_thread::get_id() << endl;
  47. }
  48.  
  49. void ConsumerM()
  50. {
  51.     while (true)
  52.     {
  53.         unique_lock<mutex> lck_c(m_c);
  54.         if (consumer_count == max_size) break;
  55.  
  56.         unique_lock<mutex> lck(m);
  57.         while (pool_size == 0)
  58.         {
  59.             cout << "Pool empty\t Wait...\n";
  60.             p_not_empty.wait(lck);
  61.         }
  62.         pool_size--;
  63.         consumer_count++;
  64.         cout << "Consumer : " << this_thread::get_id() << "\tconsume : " << consumer_count << endl;
  65.         if (pool_size == pool_max-1)
  66.         {
  67.             cout << "Notify producer...\n";
  68.             p_not_full.notify_one();
  69.         }
  70.         if (consumer_count == max_size) break;
  71.         lck.unlock();
  72.         lck_c.unlock();
  73.         this_thread::sleep_for(chrono::milliseconds(1500));
  74.     }
  75.     cout << "Consumer Single exit\t id is : " << this_thread::get_id() << endl;
  76. }
  77.  
  78.  
  79. void TestPmCm()
  80. {
  81.     const int p_t_i = 5, c_t_i = 7;
  82.     thread t_c[c_t_i];
  83.     thread t_p[p_t_i];
  84.     for (int i=0; i<c_t_i; ++i)
  85.         t_c[i] = thread(ConsumerM);
  86.     for (int i = 0; i<p_t_i; ++i)
  87.         t_p[i] = thread(ProducerM);
  88.  
  89.     for (int i=0; i<c_t_i; ++i)
  90.         t_c[i].join();
  91.     for (int i = 0; i<p_t_i; ++i)
  92.         t_p[i].join();
  93. }
  94.  
  95.  
  96. int main(void)
  97. {
  98.     TestPmCm();
  99.     return 0;
  100. }

运行截图：

 

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号