I uppg3a låser båda trådarna mutexen m1 och m2 innan de hanterar den kritiska resursen (int)thread. De gör detta med pthread_mutex_lock(&m1) (&m2). I manualsidan för pthread_mutex_lock står det "The mutex object referenced by mutex shall be locked by calling pthread_mutex_lock()" men vårt fall heter mutex objekten m1 och m2. Vidare i manualsidan ser vi "If the mutex is already locked, the calling thread shall block until the mutex becomes available". Detta betyder att mutexen kommer att låsas om den är ledig vid ett anrop till pthread_mutex_lock, om mutexen är upptagen så kommer tråden som kallade pthread_mutex_lock att blockera vilket betyder att inga av tråden instruktioner exekveras av CPUn. Blockeringen kommer att pågå tills mutexen blir ledig, tråden kommer då att låsa mutexen och CPUn kan utföra trådens instruktioner igen. 

För att släppa en mutex används pthread_mutex_unlock vi ser i manualsidan "The pthread_mutex_unlock() function shall release the mutex object referenced by mutex". Mutexen blir då ledig och kan låsas av vilken tråd som helst. 

Man måste vara försiktig när man programmerar med mutexar så att inte låsningar (deadlocks) uppstår. T.ex. kan vi gå igenom ett händelseförlopp i uppg3a.c. Tråd 1 t1 får tillgång till CPUn och låser mutex m1 pthread_mutex_lock(&m1) för att sedan sova i 1 sekund sleep(1). Tråd 2 t2 får då tillgång till CPUn och låser mutex m2 pthread_mutex_lock(&m2) för att sedan sova i 1 sekund. T2 vaknar och försöker låsa mutex m1, men m1 är redan låst så t2 börjar blockera och vänta på att m1 blir ledig. T1 vaknar och försöker låsa mutex m2, men m2 är redan låst så t1 börjar blockera och vänta på att m2 blir ledig. I detta läga väntar båda trådarna på en mutex som den andra tråden har låst, ingen av trådarna kan fortsätta köra och således har en deadlock uppstått. Ingen av trådarna kan komma ut resursen thread så thread förblir 0 och därför skrivs bara en massa nollor ut. 

Man kan förhindra att en sådan deadlock uppstår, till exempel kan man används pthread_mutex_trylock() när man försöker låsa en mutex. I manualsidan ser vi "The pthread_mutex_trylock() function shall be equivalent to pthread_mutex_lock(), except that if the mutex object referenced by mutex is currently locked (by any thread, including the current thread), the call shall return immediately". Detta betyder att tråden inte kommer att gå in i ett blocked stadie även om mutexen redan är låst. Det är viktigt att hantera detta så att vi inte manipulerar någon resurs som ska vara låst och skyddad. Vidare i manualsidan läser vi "The pthread_mutex_trylock() function shall return zero if a lock on the mutex object referenced by mutex is acquired. Otherwise, an error number is returned to indicate the error". Pthread_mutex_trylock() kommer alltså att returnera 0 om mutexen är ledig och tråden lyckas låsa den. Vi kan därefter utföra en kritisk sektion för en resurs. Om vi får ett returvärde som inte är 0 så har vi inte låst mutexen och vi kan agera enligt detta. Vi bör alltså ändra 2 rader i uppg3b.c till: if(!pthread_mutex_trylock(&m1) för att programmet ska fungera som tänkt. 

Ett exempel på hur man kan hantera pthread_mutex_trylock() kan vara enligt uppg3b.c. 
Ett händelseförlopp kan se ut så här: tråd 1 t1 låser mutex m1, CPUn börjar exekvera t2 istället och t2 låser m2. T2 försöker sedan låsa m1 med pthread_mutex_trylock(&m1) men eftersom m1 redan är låst så returneras ett heltal som indikerar error. T2 tar emot heltalet, läser av det och eftersom det inte är 0 så låser t2 upp mutex m2. CPUn går över till t1 som försöker låsa m2 pthread_mutex_trylock(&m2) viket går bra och 0 returneras. T1 tar emot heltalet 0 och kan utföra sin kritiska sektion eftersom att den har låsa båda mutexarna. När sektionen är klar låser t1 upp båda mutexarna och vilken tråd som helt får nu chans att låsa dem. En deadlock kan inte uppstå här eftersom att trådarna låter varandra gå före om de inte lyckas låsa båda mutexarna. Programmet kommer alltså under hela sin livslängd att kunna skriva ut 0, 1 och 2.
 
