Reentrancy protection against multiple entries at once

Question

I'm concerned about the security of the Reentrancy pattern that we can use in Solidity to prevent from calling multiple times a same function at the same time. This protection is nicely implemented here: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/ReentrancyGuard.sol. But for my question, I did a smaller version merging the code of the modifier inside the function:

contract Contract1 {
    bool locked;

    function f() external {
        require(!locked, "Reentrant call");
        locked = true;
        // Do something
        locked = false;
    }
}

According to my understanding, in Solidity, on the Ethereum Virtual Machine, it is impossible to execute more than 1 instruction at a time, each instruction is executed sequentially, not in parallel. That's why before to execute locked = true, first require(!locked, "Reentrant call") have to be executed (and valid).

But would there be a possibility for 2 concurrent requests (let's say from user A and user B, or even from the same user) on f() to sequentially execute those instructions in this order:

1. require(!locked, "Reentrant call")
2. require(!locked, "Reentrant call") (which would also be valid at this stage)
3. locked = true
4. locked = true

If so, // Do something would be executed twice.

Answer 1

But would there be a possibility for 2 concurrent requests?

There can be many concurrent requests for miners to execute many different transactions, all calling the same function in the same contract.

So far your concern is in place.

But once a transaction is executed (i.e., added to the blockchain), it is executed atomically until completion.

So you can rest assure that your protection method works as intended.

Side note:

Instead of toggling bool locked between false and true, you can toggle uint locked between 1 and 2. This will reduce your method's gas consumption significantly, because changing a state variable from zero to non-zero costs a lot more than changing it from non-zero to non-zero.