在nodejs / socket.io伸缩应用程序中序列化资源

Question

Currently my nodejs/socket.io server runs in a single thread but there are ways to make it more scalable ( here for example) that I can adopt in the future. But this make all the instances of server running on different processes that are clustered, in that way resources are not serialized anymore and it raises a problem about concurrency. There is a way to serialize certain code segment in different processes on a nodejs/socket.io server basing on a key? For example:

lock(key) 

/*make stuff*/

unlock(key)

This is a example, but it will be appreciate if I can accomplish the same task with promises (I don't know how).

Answer 1

There is no completely generic cross process mutex that magically suspends all other nodejs processes while you are processing something.

There are, however, many different types of tools that can be used to solve a particular problem.

The #1 tool is to use appropriate design to minimize or eliminate race conditions between your processes. How exactly to do this is specific to exactly what problem you are trying to solve so we can provide a lot more helpful info if you describe the specific problem. One common way this is done is by using a common data store and designing your code to use atomic operations within the database. This then uses the database capabilities itself as your control mechanism (something a multi-user database is typically designed to handle very well).

Beyond that, you can use database locks, file locks or other cross process communications mechanisms.

Here's a description of using redis: implement mutex in node.js

Here's a module that offers a nodejs cross process mutex (which actually uses file locking under the covers): https://github.com/Perennials/mutex-node

And another module: https://www.npmjs.com/package/rwlock

Any of these locking mechanisms could certainly be wrapped in a promise interface.