есть классическая задача для многопоточности Продавец-покупатель. Она много где описывается, но обычно не где не описывается решение для агресивной политики доступа, т.е. когда пауз между продай - купи нету, и каждый наровит впихнуть/взять как можно больше.
У меня же задача, чуть более сложней. Когда два разных потока пытаются получить доступ к одному и томуже ресурсу притом один (1) чисто на запись, второй (2) на чтение и запись. ведущий поток это (1), так как если не будет данных то (2) читать ничего не сможет. Это легко решается с помощью condition_variable.
А вот как организовать возможность разделение доступа к ресурсу между (1) и (2) я не могу понять.
Должны корректно выполнятся следующие ситуации:
1) если (1) постоянно пишет в ресурс, то как только (2) попробует чтото прочитаться из ресурса (и не сможет этого сделать) то последушию запросы (1) временно блокируются что бы (2) смог получить доступ к ресурсу
2) если (2) постоянно читает/пишет в ресурс, то как только (1) попробует чтото записать в ресурса (и не сможет этого сделать) то последушию запросы (2) временно блокируются что бы (1) смог получить доступ к ресурсу
При этому (1) и (2) не должны покадить то место в котором они не смогли получить доступ, а должны доджаться когда они этот доступ получат.
Это примерно выглядет так
| Код |
template <typename T>
class SharedBuffer
{
template<typename Y>
friend std::ostream& operator<<(std::ostream& os, const SharedBuffer<Y>&);
public:
SharedBuffer(void);
~SharedBuffer(void);
// Добавляем в конец хранилища новые данные
void push(std::list<T>&);
// Возвращает копию первого элемента, и удаляет его из хранилища
T pop();
private:
std::list<T> _data;
// блокировка на чтение/запись
boost::mutex _mtx;
// есть что прочитать !
boost::condition_variable _cond;
};
template <typename T>
void SharedBuffer<T>::push(std::list<T>& buff)
{
boost::lock_guard<boost::mutex> lock(this->_mtx);
this->_data.insert(_data.end(), buff.begin(), buff.end());
this->_cond.notify_one();
}
template <typename T>
T SharedBuffer<T>::pop()
{
boost::unique_lock<boost::mutex> lock(this->_mtx);
this->_cond.wait(lock, [this] {
return !this->_data.empty();
});
T t;
if(!this->_data.empty())
{
t = this->_data.front();
this->_data.pop_front();
return t;
}
// сюда ни когда не дойдект
throw "Попытка получить данные из пустого хрпанилица";
return T();
}
|
Этот работает для случая когда есть искуственная пауза между вызовами push->push и pop->pop
т.е. для случая
| Код |
поток 1:
while(1)
x.push()
поток 2:
while(1)
x.pop()
|
вероятность что pop() сможет влесть в работу потока1 крайне мала. |
)