3a.
t1 och t2 inleder med att sova en slumpmässig tid mellan 1-3 sekunder innan
de försöker få tillgång till den kritiska sektionen. Beroende på hur lång tid trådarna sovit innan de försöker
låsa mutexarna så kan låsning uppstå. Enligt manualsidan för pthread_mutex_lock så kommer en tråd blockeras om
den försöker låsa en mutex som redan är låst fram tills att mutexen blir tillgänglig. "The mutex object referenced by
mutex shall be locked by calling pthread_mutex_lock(). If the mutex is already locked, the calling thread shall
block until the mutex becomes available". Mutexen blir tillgänlig genom att
tråden kallar på funktionen pthread_mutex_unlock(): "The pthread_mutex_unlock() funcation shall release the
mutex object referenced by mutex". Detta innebär att t.ex.
om båda trådarna sover lika länge i början av trådfunktionen (under första rundan i while-loopen) så
kommer då låsning uppstå då då t1 hinner låsa m1 men ej låsa m2 innan t2 hunnit låsa m2 (sleep(1) säkerställer detta).
Det omvända gäller för t2: den hinner låsa m2 och väntar på att låsa m1, men t1 kommer hinna låsa m1 innan.
Ingen av trådarna kommer alltså få chansen att kalla på pthread_mutex_unlock() för att häva låsningen.
I dessa fall kommer trådarna blockeras och fastna mellan:

pthread_mutex_lock(&m1/&m2); //m1 i tf1 och m2 i tf2
sleep(1);
//Här blockeras trådarna vid låsningen.
pthread_mutex_lock(&m2/&m1); //m2 i tf1 och m1 i tf2

Då trådarna blockeras i låsningen så kommer bara 0 skrivas ut då variabeln thread bara kan tilldelas ett annat
värde längre ner i den kritiska sektionen (som då trådarna inte får tillgång till vid låsning).
Låsningen är alltså beroende av tidsskillnaden mellan trådarna. Det är därför uppg3a.c ibland börjar med att skriva ut
annat än nollor. I dessa fall har tidsskillnaden mellan att trådarna försökt låsa mutexarna inte möjliggjort låsning.


3b.
I fallet uppg3b.c kan låsningen i uppg3b.c stävjas genom att använda funktionen pthread_mutex_trylock(). Denna funktion är,
enligt manualsidan pthread_mutex_trylock, ekvivalent med pthread_mutex_lock() förutom i fallet då mutexen är låst. "The
pthread_mutex_unlock 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 immidiately." I detta fall
returnerar pthread_mutex_trylock värdet 0. "The pthread_mutex_trylock() function shall return zero if a lock on the mutex
object referenced by mutex is aquired". I koden i uppg3b.c ser vi att båda trådarna tillåts att låsa den första mutexen:
m1 i tf1 och m2 i tf2. Efter detta undersöks om den andra mutexen är låst. I fallet då den är öppen så tillåts tråden fortsätta
med att utföra instruktioner i den kritiska sektionen i if-satsen då den har ensamrätt till denna. I fallet då den andra mutexen
är låst kommer if-satsen inte utföras och tråden låser då istället direkt upp den första mutexen för att sedan återgå till början
av while-loopen igen där den sover en slumpmässig tid. Detta förhindrar helt att låsning kan uppstå.
