void versionLockSync() {
std::thread tWriter(lock_writer);
std::thread tReader(lock_reader);
std::this_thread::sleep_for(std::chrono::seconds(4));
finish_reader = true;
finish_writer = true;
tReader.join();
tWriter.join();
}
void versionMultipleLockSync() {
std::thread tReader(multiple_lock_reader,1);
std::thread tReader2(multiple_lock_reader,2);
std::thread tReader3(multiple_lock_reader,3);
std::thread tWriter(multiple_lock_writer);
std::this_thread::sleep_for(std::chrono::seconds(4));
finish_reader = true;
finish_writer = true;
tReader.join();
tReader2.join();
tReader3.join();
tWriter.join();
}
TEST(PumpTest, QueueRandomSleep) {
std::atomic_int queue_size(0);
const int messages_limit(21);
const int concurrency_limit(5);
std::atomic_int received_messages;
std::atomic_int sent_messages;
std::mutex mutex;
std::condition_variable condition;
ioremap::grape::concurrent_pump pump;
pump.concurrency_limit = concurrency_limit;
auto reader = [&] {
received_messages = 0;
while (true) {
std::unique_lock<std::mutex> lock(mutex);
if (received_messages >= messages_limit && queue_size == 0) {
break;
}
if (queue_size == 0) {
continue;
}
// read message
++received_messages;
--queue_size;
pump.complete_request();
lock.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 50));
}
};
sent_messages = 0;
auto writer = [&] {
std::unique_lock<std::mutex> lock(mutex);
if (sent_messages >= messages_limit) {
pump.stop();
pump.complete_request();
return;
}
assert(queue_size < concurrency_limit);
// write message
++sent_messages;
++queue_size;
lock.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 50));
};
std::thread tReader(reader);
pump.run(writer);
tReader.join();
EXPECT_EQ(sent_messages, messages_limit);
EXPECT_EQ(received_messages, messages_limit);
}
