So going back to our producer consumer 
idea here. We're going to have a producer producing 
a value and a consumer consuming a value but now we have two consumers. 
And let's say we guarantee sequential consistency in our model. 
What breaks here? Well, if we guarantee sequential 
consistency, and we have a reader excuse, me, a producer and a consumer. 
That code sequence that I showed originally actually works out pretty 
well. Because we are not having any of those 
reordering of, let's say, this store and like this read or something. 
We're not actually getting those reorderings to happen, because sequential 
consistency has basically outlawed those. But all of a sudden if we have two 
consumers. And we go and stare at this piece of code 
carefully. This is our original piece of code. 
One of the things that happens is they check the head, 
pointer To see if it's equal to tall which means something invaluable. 
And if two, process two threads or two processees try to do that simultaneously, 
they are going to fall through at this point. 
And what could happen, is they could both try to read the same value. 
So let's say you actually have two consumers, consumer one and consumer two 
that are interleaved and we just basically do every other cycle executing 
every other instruction from the two copies of this consumer code interleaved. 
And, what's going to happen is they're going to read the same value out of the 
queue. Well, we really don't want that. 
We want to somehow guarantee that this block here happens while no other threads 
or processes are executing the same block here of code. 
So we're going to introduce this notion of locks and semaphores, and we'll talk 
more about it next time, but the basic idea is that you have, 
something. Now, it could be a piece of hardware or it could be a memory location 
which guards the execution of a critical section or a piece of code. 
And you can either have those be such that only one process or one processor 
can execute that piece of code at the same time. 
That's mutual exclusion and that's, a mutex. 
Or you can think of a more general notion of a semaphore. 
Where you can have some number N, where N processes can enter a critical section 
concurrently. An example of that as I said before in 
class, why we want to do that, is let's say you have two sets of resources. 
Like, two outbound queues on your network card. 
And you have P processors and you want two people to try to go use it at the 
same time. But you don't care which two. 
But it can't be three. You need something that's more general 
than just a mutex or a single-user lock. Okay, so we're going to stop here and 
we'll talk more about locks and semaphores including hopefully some 
people speak Dutch. Because that's, because we need to know 
that to get the names of some of these semaphores.