Das Video kommt von YouTube: erst beim Abspielen verbindet sich die Seite mit YouTube (Google).
What is a mutex in C? (pthread_mutex)
Das Wichtigste aus dem Video
Tipp auf eine Zeit – das Video springt genau dorthin.
Transkriptautomatisch erstellt · 63 Zeilen
- so we left at this issue where we have a race condition for writing to the males variable if we launch this again of course we're going to get
- a different number than 2 million which is what we would expect if we would just do everything in one thread
- now we know why that is but in this video i'm going to talk about how to solve this issue an answer is using a
- mutex this is how you can solve the issue a mutation is sort of a lock around a section of code so to speak so for example what we could do is let's
- say have a variable called lock set it to zero and set it to one whenever you're doing something and set it to zero whenever
- you're done doing something okay and before all this check if the lock is already one so if the lock is already
- one right before you are trying to set a locked one then you should sort of wait until the lock is zero
- this way uh what would happen is that if a thread tries to actually increment the males variable well it certainly
- will increment it but it will also set the lock to one so if the second thread comes in at the same time and tries to increment
- it it's gonna stop at that condition because the lock is gonna be set to one so only after we're done incrementing
- it's gonna be reset to zero so then the second the second thread could come in and read increment and write in the right order
- right so nowhere you would have a thread that just starts reading and then the other thread will start executing like we had in that example
- i showed you the race condition right so in the race connection we had a read and then the thread got paused for whatever
- reason and then the second that came in and started to read increment right like seven times
- and then this guy had inside its memory said its cpus registers the old value right which was then written to the
- memory like this we can prevent it but how do we wait until the lock is zero well we
- don't really have to implement our own variable with log things and whatnot the pthread the posix thread api actually has something like that
- implemented that we can already use and it's much safer than what we would do here so to start using it so we're gonna
- remove this lock variable we're gonna replace it with a p thread underscore mutex underscore t and call it let's say mutex
- for now for simplicity's sake okay so we have a mutex and well before we can use it we have to initialize it so
- to initialize it we go down here and let's say we initialize it before creating the thread of course i'm going to say pthread mutex
- init right and this guy takes in just two arguments the address to that mutex i'll just add mutex and then some attributes which we're not going to get
- into right now so those those can be set to null and it's going to be all right so just set everything
- basically when we pass here no it's going to set everything to default and that's all right for us and of course with an init comes with
- it comes with a destroy so we're going to have to also destroy the memory that's been allocated here so i'm going to
- call peter mutex destroy and this guy just takes in the address to the mutex no more second parameter right so pictured mutex
- init with the mutex and then destroy and now we have the mutex available to us we haven't used it yet in any way shape or
- form we just initialize it now let's go to actually using it so here these three operations so
- checking if the lock well has been locked has been taken by someone some tread and waiting until that uh lock is unlocked
- and also setting to one the lock once we're done doing all that is being accomplished with just one function and that function is called
- pthread mutex block so lock all it takes is just a reference to our mutex
- and that's it so this just this one function does all that for us so we don't have to care about waiting and not waiting and
- finishing waiting for all that now in place of this operation setting our lock to zero basically
- unlocking the mutex is just the call to pthread mutex unlock as you might have guessed and we just pass in the mutex and that
- is it my friends all you have to do is just call lock and unlock and all of a sudden the result is going to be correct so now
- if we try to launch this it's going to take a bit longer but we do get the right
- result 2 million right 2 million even though we have incremented it a million times and it's in a multi-threaded context
- it works and we can even increment it more times like let's say 10 million and it's still going to work it might take a bit longer
- but it is still going to work there you go that is 20 yeah 20 million so what does this do
- actually well this locking and unlocking of mutexes is basically protecting think about it as sort of
- some brackets between a part of a code that you want to protect to protect against what protect against
- other threads executing it at the same time so if at any point a thread is executing this
- this line of code there's not gonna be any other thread that's gonna execute this same line of code simply because there's a mutex
- around it if we didn't have the mutex we didn't have this we wouldn't have this um certainty and then
- we could get into race conditions of course not all the time not all instructions have to be like that because
- if all instructions are going to be executed only by one thread at one point in time might as well just have one single
- thread executed yellow right now the idea is that we want in this case correct data and this program on its own doesn't do anything
- useful so it's just a good example so that you understand what's going on behind the scenes and why mutexes are
- needed and before anyone asks this actually works with more than just one thread so if i for example try to create two more threads let's
- copy and paste this and i'm gonna initialize here p3 and p4 and this case going to be p b 4 p
- 3 okay and then i'm going to join it two more times so let's say p3 and p4 here and guess just for correctness
- sake let's do it let's give it a different uh error number everywhere not really a big deal but just to be
- safe and now if we try to execute with four four threads you'll notice that we are gonna get
- a pretty long wait time but we're gonna get a result of 40 million without those threats that result
- probably would have been in the 20 million let's actually check and see if i try to launch this without the
- locks and unlocks as you can see it's one or it's 15 million so that was a pretty bad result if we didn't use stress but
- notice it was faster so it is much better to use to do not use mutexes whenever possible but in this case we kind of have to
- it's just an example you'll see in the future exactly when to when and why to use mutexes now one more thing that i forgot to
- mention is that a race condition can only occur on a multi-core processor if you have a single core processor
- then it's very unlikely that you will encounter a race condition but as nowadays most like 99 of the cpus out there are multi-core
- even though low powered ones you are going to encounter this okay that's about it for today thank you so much for watching if you have any
- questions leave them down comments below or on our discord server of course the source code of today's video will be also down in
- the description below on our website thank you so much for watching and take care bye
Zum Nachlesen
MutexEin kritischer Abschnitt (engl. critical section oder critical region) ist derjenige Teil im ausführbaren Code, in dem ein wegen des Mutex ungestörter …
SpinlockEs ist eine Sperre (Lock) zum Schutz einer gemeinsam genutzten Ressource durch konkurrierende Prozesse bzw. Threads (siehe Kritischer Abschnitt) nach dem …
ProzesssynchronisationGemeinsamer Zugriff auf Daten. Dabei muss verhindert werden, dass durch gleichzeitigen Zugriff Inkonsistenzen in den Daten entstehen. Dies wird durch Mutex- …
Kritischer AbschnittKritische Abschnitte bestehen aus mehreren Einzelanweisungen, deren Zwischenergebnisse inkonsistente Zustände darstellen, auf die die anderen Threads keinen …