What happens when two threads ATTEMPT to lock the same resource at the exact same time?

Question

What happens when two threads attempt to lock the same object at the exact same microsecond (or whatever is the smallest length of time a CPU slice or instruction can be mea

Answer 1

This isn't possible, locks couldn't do what they promise. This requires processor support since it is the only one that can ensure that multiple cores don't try to access the same memory location at the same time. An example is this bit of assembly code, used by the x86 version of the CLR in its Monitor.TryEnter() method:

FASTCALL_FUNC CompareExchangeUP,12
        _ASSERT_ALIGNED_4_X86 ecx
        mov     eax, [esp+4]    ; Comparand
        cmpxchg [ecx], edx
        retn    4               ; result in EAX
FASTCALL_ENDFUNC CompareExchangeUP

The cmpxchg processor instruction provides the atomicity guarantee. It is the kind of instruction that any modern core has, the generic name for it is "compare-and-swap". You'll find more about this instruction in this Wikipedia article.

Answer 2

Modern locks, in pretty much all environments, are designed such that it isn't possible for two threads to lock an object at the same time. It is possible for modern processors to have two threads running on two different cores attempt to take a lock at very nearly the same time, but they all implement synchronization mechanisms that allow software to tell them not to allow it.

For example, x86-64 has MONITOR and MWAIT instructions. They essentially implement, at the microprocessor level, the semantics of .NET's lock(){}, System.Threading.Monitor.Wait() and System.Threading.Monitor.Enter()/.Exit().