C++ multithreading to process multiple customer carts simultaneously - c++

Question

I am required to process many shopping carts in front of many queues using multithreading. I created a container for database from a given file holds strings barocdes, item name, and price. Also created a container for customer carts from given file that holds strigns cart number and barcode of items. The requirement is to lock the process when scanning a single item only NOT the whole items of a cart to let other queues process their cart then printing the receipts. I put mutex lock before and after scanning statement but failed to store each cart items separated on other carts. I set everything well but the process function I have an issue with, becasue the receipts I got has a mess or truncated. I am new with multithreading concepts and spent long time with is code but I stuck and I need an advise of what is wrong on my function. Thanks in advance.
#include <fstream>
#include <cstdlib>
#include <string>
#include <iostream>
#include <vector>
#include <regex>
#include <algorithm>
#include <tuple>
#include <bitset>
#include <math.h>
#include <sstream>
#include <unordered_map>
#include <condition_variable>
#include <thread>
#include <mutex>
#include <queue>
#include <iomanip>
using namespace std;
std::mutex dataBaseMut;
//********************************************
class cartManager
{
//this function parametes are database and SINGLE queue
void processCarts(const unordered_map<string, pair<string, string>>&
dataBase
, queue<pair<string, vector<string>>>& singleQue)
{
// deque to hold cartNo, itemName, and price
string totalPrice = "";
string cartNo;
string cartItem;
string itemPrice;
string barcode;
bool errorFlag = false;;
//if signle queue is not empty, then process the carts
while (!singleQue.empty())
{
int frontCartSize;
//detemine the queue size
int singleQueSzie = singleQue.size();
//get cartNo of cart that is in front of deque
cartNo = singleQue.front().first;
int j = 0;
//get cartSize of cart that is in front of deque
frontCartSize = singleQue.front().second.size();
// process in front cart items till end of items
for (; j < frontCartSize; j++)
{
string notfound = " ";
stringstream items;
dataBaseMut.lock();
// search barode of an item in data base
auto it = dataBase.find(singleQue.front().second[j]);
//if not found then search it in errorlog
if (it == dataBase.end())
{
for (int i = 0; i < errorLogProducts.size(); i++)
{
if (errorLogProducts[i] == singleQue.front().second[j])
{
string cartItem = singleQue.front().second[j];
errorFlag = true;
}
}
}
else // if found,then get info of the item from data base
{
cartNo = singleQue.front().first; // get cart number
cartItem = it->second.first; // get item name
itemPrice = it->second.second; //get item price
//push all above into a vector
cartNo_Item_Price.push_back(make_tuple(cartNo,
make_pair(cartItem, itemPrice)));
}
dataBaseMut.unlock();
//if you reach the end of items of a cart, then remove it from deque
if (j == singleQue.front().second.size() - 1)
{
singleQue.pop(); // remove processed cart
}
}
}
}
//********************************
};
[![top of receipt][1]][1]
[![bottom of receipt][2]][2]
[1]: https://i.stack.imgur.com/wouq6.png
[2]: https://i.stack.imgur.com/Tq5tT.png

Answer 1

In your main you create a new cartManager for each thread. I believe it is not what you did on purpose.
threads.emplace_back
(
&cartManager::processCarts, cartManager(),
ref(dataBase), ref(all_queues[q])
);
Instead of passing cartManager() pass &manager. Why it is important? Because of creating a brand new cartManager for each thread, your function has a different this context. That means, all your threads has its own dataBaseMut - so nothing is synchronized between your threads because of that!
You don't need to modify dataBase in processCarts - in that case, pass it by const reference: in that case, it's obvious to other people (and to you) that it is not something that may be modified in processCarts.
Now opening the file is synchronized (in case you fix the very first issue I described in this answer), but only opening! Writing to the file is not synchronized, so there is a chance that your threads write to the same file simultaneously. What may happen in that case? A mess! Thus, not only opening the file should be synchronized, but writing as well. I would suggest creating a class that is in charge of writing to a file and is thread safe (it's safe to call its methods from different threads). And that class would take care of synchronizing the access to a file.

Answer 2

It's hard to say without the whole source code, but what is wrong in your code is that opening of your file outFile is not protected by your mutex. This should be a reason why you have a mess in your file.