MongoDb concurrency best practices

Question

I am new with MongoDb, I am creating an application that manage a very big list of items (resources), and for each resources the application should manage a kind of booking.

My idea is to embed booking document inside resource document, and to avoid concurrency problem I need to lock the resource during booking.

I see that MongoDB allow locks at collection level, but this will create a bottleneck on the booking functionality because all resources inside the collection will be looked until the current booking is in progress, so for a large amount of users and large amount of resources this solution will have poor performance. In addition to that, in case of a deadlock occurred booking a resource, all resources will be locked.

Are there alternative solutions or best practices to improve performance and scalability of this use case? A possible solution should be to have a lock not at collection level but a document level (the resource in my example), in this way a user booking a resource doesn't lock another user to book another resource, even if (also in this case) I am not sure of the final result because write commands are not executed in parallel: I suppose I'll probably also need a cluster of servers to manage multiple writes in parallel.

Answer 1

You are absolutely right, you should definitely not lock the entire collection for just updating a single document.

Now this problem depends on how you update your document. If you update your document with a single update query, then since document update is atomic you would have no problem.

But if you first have to read the document, change the document, save the document, then you would have the concurrency problem. Just before you save the changed document, it could be updated by some other request and the document you have read would no longer be up to date, hence your new updates will not be right either.

The simple solution to this concurrency problem is solved by storing a version number(usually _v ) in each of your documents. And for every update you increment the version number. Then every time you do a read & change & update, you make sure that the version of your read document and the version of that document in the database are identical. When the version number differs the update will fail and you can simply try again.

If you are using node.js , then you are probably using mongoose and mongoose will generate _v and do concurrency checks behind the scenes. So you do not have to do any extra job to solve this concurrency issue.