I am going to explain my understanding of this OS construct and appreciate some polite correction.

I understand thread-safety clearly and simply.

If there is some setup where

* *X*: some condition
* *Y*: do something

and

```
if X
   do Y

```

is atomic, meaning that if at the exact moment in time

* doing *Y*
* not *X*

there is some problem.

By my understanding, the lowest-level solution of this is to use shared objects (*mutexes*). As an example, in the solution to the "Too Much Milk" Problem

```
    Thead A     |     Thread B
-------------------------------------
leave Note A    |  leave Note B
while Note B    |  if no Note A 
  do nothing    |    if no milk
if no milk      |      buy milk
  buy milk      |  remove Note B
remove Note A   |

```

`Note A` and `Note B` would be the shared objects, i.e. some piece of memory accessible by both threads A and B.

This is can be generalized (beyond milk) for `2`-thread case like

```
    Thead A     |     Thread B
-------------------------------------
leave Note A    |  leave Note B
while Note B    |  if no Note A 
  do nothing    |    if X
if X            |      do Y
  do Y          |  remove Note B
remove Note A   |

```

and there is some way to generalize it for the `N`-thread case (so I'll continue referring to the `2`-thread case for simplicity).

Possibly incorrect assumption #1: **This is the lowest-level solution known (possible?).**

Now one of the defficiencies of this solution is the *spinning* or *busy-wait*

```
while Note B
  do nothing

```

because if the `do Y` is an expensive task then the thread scheduler will keep switching to `Thread A` to perform this check, i.e. the thread is still "awake" and using processing power even when we "know" its processing is to perform a check that will fail for some time.

The question then becomes: *Is there some way we could make `Thread A` "sleep", so that it isn't scheduled to run until `Note B` is gone, and then "wake up"???*

The *Condition Variable* design pattern provides a solution and it built on top of mutexes.

**Possibly incorrect assumption #2:** Then, isn't there still some spinning under the hood? Is the average amount of spinning somehow reduced?

I could use a logical explanation like only S.O. can provide ;)