3

私はマルチスレッドの学習を開始し、共有リソースを介してスレッドを同期するための未来と約束に出会いました。そこで、Futures と Promises (単一の生産者と単一の消費者) を使用して、有名なダブル バッファリングの問題を実装することを考えました。私が考えた基本的な方法論は次のとおりです。

プロデューサー スレッド:

loop:    
    locks_buffer1_mutex    
    fills_buffer1   
    unlocks_buffer1_mutex    
    passes number 1 to Consumer thread using promise.setvalue()    
    locks_buffer2_mutex    
    fills_buffer2   
    unlocks_buffer2_mutex    
    passes number 2 to Consumer thread using promise.setvalue()
back_to_loop

ConsumerThread :

loop:
   wait_for_value_from_promise
   switch
      case 1:
         lock_buffer1_mutex
          process(buffer1)
         unlock_buffer1_mutex
         print_values
         break
       case 2:
         lock_buffer2_mutex
         process(buffer2)
         unlock_buffer2_mutex
         print_values
         break
back_to_loop

コードは次のとおりです。

#include <iostream>
#include <thread>
#include <vector>
#include <future>
#include <mutex>
#include <iterator>


std::mutex print_mutex;
std::mutex buffer1_mutex;
std::mutex buffer2_mutex;

std::vector<int> buffer1;
std::vector<int> buffer2;

bool notify;


void DataAcquisition(std::promise<int> &p)
{
    std::this_thread::sleep_for(std::chrono::seconds(2));
    while(true)
    {
        {
            std::lock_guard<std::mutex> buff1_lock(buffer1_mutex);
            for(int i=0;i<200;i++)
            {
                buffer1.push_back(i);
            }
        }
        p.set_value(1);
        {
            std::lock_guard<std::mutex> buff2_lock(buffer2_mutex);
            for(int i=0;i<200;i++)
            {
                buffer2.push_back(199-i);
            }
        }
        p.set_value(2);
    }
}

void DataExtraction(std::future<int> &f)
{
    std::vector<int>::const_iterator first,last;
    std::vector<int> new_vector;
    std::ostream_iterator<int> outit(std::cout, " ");

    while(true)
    {
        int i = f.get();
        std::cout << "The value of i is :" << i << std::endl;
        switch(i)
        {
            case 1:
                {
                    std::lock_guard<std::mutex> buff1_lock(buffer1_mutex);
                    first = buffer1.begin();
                    last = first + 10;
                }
                new_vector = std::vector<int>(first,last);
                {
                    std::lock_guard<std::mutex> print_lock(print_mutex);
                    std::copy(new_vector.begin(),new_vector.end(),outit);
                }
                break;
              case 2:
                {
                    std::lock_guard<std::mutex> buff2_lock(buffer2_mutex);
                    first = buffer2.begin();
                    last = first + 10;
                }
                new_vector = std::vector<int>(first,last);
                {
                    std::lock_guard<std::mutex> print_lock(print_mutex);
                    std::copy(new_vector.begin(),new_vector.end(),outit);
                }
                break;
           }
    }
}

int main()
{
    std::promise<int> p;
    std::future<int> f = p.get_future();


    std::thread thread1(DataAcquisition,std::ref(p));
    std::thread thread2(DataExtraction,std::ref(f));

    thread1.join();
    thread2.join();

    return 0;
}

このコードを実行すると、彼の巨大な問題に出くわしましたが、私はまったく気づいていません

terminate called after throwing an instance of 'std::future_error' terminate called recursively
  what(): 0 1 2 3 4 5 6 7 8 9 Promise already satisfied
Press <RETURN> to close the window

このエラーについてググったところ、リンクとコンパイル時に -lpthread スイッチをリンクすることをお勧めします。しかし、問題を解決できませんでした。

私を助けてください、どこが間違っているのですか..

4

1 に答える 1

3

次のコードで示されているように、set_valueを複数回呼び出すことはできません。promise

#include <future>

int main() {
    std::promise<int> p;
    p.set_value(1);
    p.set_value(2); // Promise already satisfied
}

別のアプローチを探す必要があります。たとえば、2 つのstd::condition_variableを使用できます。プロデューサーで設定し、コンシューマーで待機します。

于 2015-04-28T09:33:55.267 に答える