Does ReentrancyGuard locks every addresses while a `nonReentrant` function is called?

I am looking to secure a function within a contract from reEntrancy attacks, by attaching the nonReentrant modifier to it.

function myFunction(...) public nonRentrant {
    // ...

My question is:
a) Does the lock status (_status) applies to all addresses potentially interacting with the contract?
b) Does it only applies only to the address interacting with the nonReentrant function?

Basically, what happen if two addresses make a call to the nonReentrant function at the same time.

I understand that it brings the function to a “lock state”, by switching the _status variable via the modifier. But what happen if two addresses (= 2 users) interact with the function at the same time?

modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;   // <== what happen here if the function get called by another address here while still executing

        // By storing the original value once again, a refund is triggered (see
        _status = _NOT_ENTERED;

Let’s imagine 2 users, A and B.

  1. user A calls myFunction()
    1.1 ==> the function gets locked via the modifier
    1.2 ==> the function starts execution (running the code within)
  2. user B calls myFunction() (while the contract is still executing call made by user A)
  • Will user B be able to execute the function?
  • Or does he has to wait for the call from user A to finish? (because _status = _ENTERED)?

In the 2nd scenario, I would imagine that my contract should have to keep track of all the addresses currently executing call via a mapping, so my code should look like below:

mapping (address => bool) private _locks;

modifier nonReentrant {
    require(_locks[msg.sender] != true, "ReentrancyGuard: reentrant call");

    _locks[msg.sender] = true;

    _locks[msg.sender] = false;

function myFunction(...) public nonReentrant {
    // ...

:computer: Environment

  • Truffle v5.3.7
  • Solidity 0.8.^

Hi, welcome! :wave:

Actually, one time, only one address can execute functions, if there are two users to call the same functions, they have got to execute one by one.