Realtidssystem. - Semaforer, trådsynkronisering - EDA698 - Realtidssystem (Helsingborg) Elin A. Topp 2015-09-02

Realtidssystem - Semaforer, trådsynkronisering - EDA698 - Realtidssystem (Helsingborg) Elin A. Topp 2015-09-02 Stora delar baserad på: Föreläsningsmaterial EDA040 (Klas Nilsson, Mathias Haage) samt EDA698 (Mats Lilja) 1

Förtydligande: Kursens fokus och mål Praktik-Fokus: Trådar i OS-process semaforer monitorer meddelanden i kö (mailbox / event queue) Teori-Fokus: Trådarnas samspel dödläge / svält / livelock exekveringstider prioriteter schemaläggning och schemaläggningsanalys Man ska kunna bygga flertrådiga program som i princip kan uppfylla realtidskrav Man ska kunna läsa kod av flertrådiga program och kunna lösa problem i koden Man ska bygga upp en förståelse för vad som kan hända när flera trådar måste hanteras Man ska bygga upp en uppfattning om vilka verktyg som finns för att utföra en analys av ett tilltänkt system och kunna utföra enklare analyser 2

Dagens agenda Recap: Exekveringstillstånd, kontextbyte, gemensam resurshantering Synkronisering / Ömsesidig uteslutning: Semaforer MutexSem Signalling Counting semaphore 3

Exekveringstillstånd Due to scheduler / kernel / OS Running Priority, time-sharing Ready Due to application By this : wait, synchronized call Blocked By other: notify, synchronized return Schemaläggningstillstånd (scheduling state) Running Ready (genom t.ex. Semaphore.give()) Blocked (genom t.ex. Semaphore.take()) 5

Pre-emption 6

Pre-emption Det finns olika strategier för tillåtelse av kontextbyten: 6

Pre-emption Det finns olika strategier för tillåtelse av kontextbyten: Non-pre-emptive scheduling ( icke-avbrytbar schemaläggning): Tråden som kör kan inte avbrytas tills den släpper CPUn frivilligt explicit genom att anropa yield() eller implicit genom (synchronized) operationer som kan blockera. 6

Pre-emption Det finns olika strategier för tillåtelse av kontextbyten: Non-pre-emptive scheduling ( icke-avbrytbar schemaläggning): Tråden som kör kan inte avbrytas tills den släpper CPUn frivilligt explicit genom att anropa yield() eller implicit genom (synchronized) operationer som kan blockera. Pre-emption point based scheduling ( avbrytningspunktbaserad schemaläggning): Tråden som kör kan avbrytas vid vissa punkter i programmet (definierad genom språket eller run-time systemet) 6

Pre-emption Det finns olika strategier för tillåtelse av kontextbyten: Non-pre-emptive scheduling ( icke-avbrytbar schemaläggning): Tråden som kör kan inte avbrytas tills den släpper CPUn frivilligt explicit genom att anropa yield() eller implicit genom (synchronized) operationer som kan blockera. Pre-emption point based scheduling ( avbrytningspunktbaserad schemaläggning): Tråden som kör kan avbrytas vid vissa punkter i programmet (definierad genom språket eller run-time systemet) Pre-emptive scheduling ( avbrytbar schemaläggning): Tråden som kör kan avbrytas när som helst av schemaläggaren (som styrs av hårdvaru-interrupts). 6

Pre-emption Det finns olika strategier för tillåtelse av kontextbyten: Non-pre-emptive scheduling ( icke-avbrytbar schemaläggning): Tråden som kör kan inte avbrytas tills den släpper CPUn frivilligt explicit genom att anropa yield() eller implicit genom (synchronized) operationer som kan blockera. Pre-emption point based scheduling ( avbrytningspunktbaserad schemaläggning): Tråden som kör kan avbrytas vid vissa punkter i programmet (definierad genom språket eller run-time systemet) Pre-emptive scheduling ( avbrytbar schemaläggning): Tråden som kör kan avbrytas när som helst av schemaläggaren (som styrs av hårdvaru-interrupts). För att det ska bli rätt med schemaläggningen och väntetiderna, antar våra program att kärnan är pre-emptive, dvs. trådar kan avbrytas vid behov och då hanterar systemet kontextbytet på ett korrekt sätt. 6

Exekverande tråd vs trådobjekt En exekverande tråd är en enhet i run-time-systemet (löptidssystem), som man får tillgång till via ett trådobjekt. Trådobjektet är - innan start() har anropats - som vilket objekt som helst; start() är ingenting vi behöver implementera, det är en del av systemets nativa (native) kod. När någontrådobjekt.start() anrops, ger native-metoden start() anropet vidare till någon OSrutin som skapar den exekverande tråden. start() anropar run() som beskriver arbetet som ska utföras. Om man enbart anropar run() utförs detta i den anropande trådens kontext, dvs det blir ingen förgrening! 7

Concurrent computing Jämlöpande exekvering Mjukvaran måste utföra alla beräkningar logiskt korrekt reagera på inmatningar jämlöpande " 0 " 2 " "0 " 5 5 % $ alltid ha konsistent data att arbeta med " 5 + % +1 &$! 0" %3 6$ "##$%"$# " "% + 5! &% 2! + 0" " "$ 8

Concurrent computing Jämlöpande exekvering Mjukvaran måste utföra alla beräkningar logiskt korrekt reagera på inmatningar jämlöpande " 0 " 2 " "0 " 5 5 % $ alltid ha konsistent data att arbeta med " 5 + % +1 &$! 0" %3 6$ " "% + 5! Software application borde vara ett reaktivt system, &% 2! + 0" " "$ "##$%"$# 8

Concurrent computing Jämlöpande exekvering Mjukvaran måste utföra alla beräkningar logiskt korrekt reagera på inmatningar jämlöpande " 0 " 2 " "0 " 5 5 % $ alltid ha konsistent data att arbeta med " 5 + % +1 &$! 0" %3 6$ " "% + 5! Software application borde vara ett reaktivt system, &% 2! + 0" " "$ som svarar både på tidsenheter som går (varje månad ska lönen läggas "##$%"$# till på kontot), 8

Kapplöpning class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().start(); sleep( 1); System.out.println( World! ); public void run() { System.out.print( and goodbye ); Vem får resursen (println, dvs konsolen...?) Det behövs alltså fler egenskaper och mekanismer, samt regler för programmering av multi-trådade program, än bara möjligheten att skapa trådar och låta dem köra samtidigt. 9

Kapplöpning class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().start(); sleep( 1); System.out.println( World! ); pc:~ user$ java HelloWorld Hello World! and goodbye pc:~ user$ public void run() { System.out.print( and goodbye ); Vem får resursen (println, dvs konsolen...?) Det behövs alltså fler egenskaper och mekanismer, samt regler för programmering av multi-trådade program, än bara möjligheten att skapa trådar och låta dem köra samtidigt. 9

Kapplöpning class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().start(); sleep( 1); System.out.println( World! ); public void run() { System.out.print( and goodbye ); pc:~ user$ java HelloWorld Hello World! and goodbye pc:~ user$ pc:~ user$ java HelloWorld Hello and goodbye World! pc:~ user$ Vem får resursen (println, dvs konsolen...?) Det behövs alltså fler egenskaper och mekanismer, samt regler för programmering av multi-trådade program, än bara möjligheten att skapa trådar och låta dem köra samtidigt. 9

Kapplöpning class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().start(); sleep( 1); System.out.println( World! ); public void run() { System.out.print( and goodbye ); pc:~ user$ java HelloWorld Hello World! and goodbye pc:~ user$ pc:~ user$ java HelloWorld Hello and goodbye World! pc:~ user$ pc:~ user$ java HelloWorld Hello and goodbye World! pc:~ user$ Vem får resursen (println, dvs konsolen...?) Det behövs alltså fler egenskaper och mekanismer, samt regler för programmering av multi-trådade program, än bara möjligheten att skapa trådar och låta dem köra samtidigt. 9

Kapplöpning class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().start(); sleep( 1); System.out.println( World! ); public void run() { System.out.print( and goodbye ); pc:~ user$ java HelloWorld Hello World! and goodbye pc:~ user$ pc:~ user$ java HelloWorld Hello and goodbye World! pc:~ user$ pc:~ user$ java HelloWorld Hello and goodbye World! pc:~ user$ pc:~ user$ java HelloWorld Hello and goodbye World! pc:~ user$ Vem får resursen (println, dvs konsolen...?) Det behövs alltså fler egenskaper och mekanismer, samt regler för programmering av multi-trådade program, än bara möjligheten att skapa trådar och låta dem köra samtidigt. 9

Kapplöpning class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().start(); sleep( 1); System.out.println( World! ); public void run() { System.out.print( and goodbye ); pc:~ user$ java HelloWorld Hello World! and goodbye pc:~ user$ pc:~ user$ java HelloWorld Hello and goodbye World! pc:~ user$ pc:~ user$ java HelloWorld Hello and goodbye World! pc:~ user$ pc:~ user$ java HelloWorld Hello and goodbye World! pc:~ user$ pc:~ user$ java HelloWorld Hello World! and goodbye Vem får resursen (println, dvs konsolen...?) Det behövs alltså fler egenskaper och mekanismer, samt regler för programmering av multi-trådade program, än bara möjligheten att skapa trådar och låta dem köra samtidigt. 9

Bankkontot igen Situation 1: A: Läs 5000 B: Läs 5000 A: Belopp = 5000-1000 B: Belopp = 5000 + 10000 A: Skriv 4000 B: Skriv 15000 A: Läs 5000 Situation 2: B: Läs 5000 B: Belopp = 5000 + 10000 B: Skriv 15000 A: Belopp = 5000-1000 A: Skriv 4000 Två aktiviteter (program, trådar (threads), processer) utförs samtidigt, då de hanterar samma resurser. I båda situationer blir resultatet fel. Här behövs det alltså någon mekanism för ömsesidig uteslutning (mutual exclusion) för att hantera kritiska sekvenser (critical sections) och odelbara aktioner (atomic actions). 10

Kritiska sekvenser (Critical sections) Delar av ett program (en sekvens) som behöver tillgång till en delad resurs. Får inte bli avbruten av en annan programsekvens, eller av en ny upprop till sig själv. Kraven kan uppfyllas med hjälp av Semaforer, Monitorer eller Postlådor (Mailboxes) På låg nivå (native code) kan man också slå av interrupts (avbrott). 11

Begrepp / abstraktioner för jämlöpande exekvering 12

Begrepp / abstraktioner för jämlöpande exekvering Vad är det som ett programmeringsspråk måste stödja för att kunna erbjuda jämlöpande exekvering? 12

Begrepp / abstraktioner för jämlöpande exekvering Vad är det som ett programmeringsspråk måste stödja för att kunna erbjuda jämlöpande exekvering? Tråd - en aktivitet, programsekvens 12

Begrepp / abstraktioner för jämlöpande exekvering Vad är det som ett programmeringsspråk måste stödja för att kunna erbjuda jämlöpande exekvering? Tråd - en aktivitet, programsekvens Exekveringsstatus - aktiv / inaktiv, använd av en tråd eller ej; kontext + aktivitetsstatus 12

Begrepp / abstraktioner för jämlöpande exekvering Vad är det som ett programmeringsspråk måste stödja för att kunna erbjuda jämlöpande exekvering? Tråd - en aktivitet, programsekvens Exekveringsstatus - aktiv / inaktiv, använd av en tråd eller ej; kontext + aktivitetsstatus Synkronisering - hantering av gemensamma resurser 12

Kan man få till ömsesidig uteslutning utan systemanrop? class T extends Thread { public void run() { while( true) { noncriticalsection(); preprotocol(); criticalsection(); postprotocol(); class T2 extends Thread { public void class run() T extends { Thread { while( true) public { void run() { noncriticalsection(); while( true) { preprotocol(); noncriticalsection(); criticalsection(); preprotocol(); postprotocol(); criticalsection(); postprotocol(); Critical Section (CS) Jämför Bankkonto-exemplet Vi kommer titta på konstruktionen av pre-/postprotocol Antagandet: En tråd kommer inte att blockeras inom dess kritiska sekvens (critical section). Krav: Ömsesidig uteslutning, ingen dödläge, inget svält, hög verkningsgrad (efficiency). 14

Ömsesidig uteslutning, tråden class T extends Thread { public void run() { while( true) { noncriticalsection(); preprotocol(); criticalsection(); postprotocol(); 15

Ömsesidig uteslutning, kraven Det här måste uppfyllas: 1. Ömsesidig uteslutning (Mutual exclusion): Exekvering av en kod i en kritisk sekvens får inte flätas ihop med någon annan tråds kodsekvens. 2. Inget dödläge (No deadlock): Om en eller fler tråd(ar) försöker starta exekvering av en kritisk sekvens, måste det finnas någon av dem som faktiskt kan göra det. 3. Ingen svält (No starvation): En tråd måste få möjlighet att någon gång påbörja exekveringen av dess kritiska sekvens. 4. Effektivitet (Efficiency): Liten overhead (förvaltningskostnad) när det finns enbart en tråd, det hela måste fungera bra även om det bara finns en tråd (det får inte finnas en obligatorisk väntemoment på en annan tråd när en sådan inte kan garanteras finnas). Kan de här kraven uppfyllas med vanlig Java-kod? 16

Ömsesidig uteslutning - version 1 - int turn = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( turn!= 1); cs1(); turn = 2; class T2 extends Thread { public void run() { while( true) { noncs2(); while( turn!= 2); cs2(); turn = 1; 17

Ömsesidig uteslutning - version 1 - int turn = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( turn!= 1); cs1(); turn = 2; class T2 extends Thread { public void run() { while( true) { noncs2(); while( turn!= 2); cs2(); turn = 1; Ömsesidig uteslutning: OK 17

Ömsesidig uteslutning - version 1 - int turn = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( turn!= 1); cs1(); turn = 2; class T2 extends Thread { public void run() { while( true) { noncs2(); while( turn!= 2); cs2(); turn = 1; Ömsesidig uteslutning: OK Inget dödläge: OK, en av dem kan alltid köra. 17

Ömsesidig uteslutning - version 1 - int turn = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( turn!= 1); cs1(); turn = 2; class T2 extends Thread { public void run() { while( true) { noncs2(); while( turn!= 2); cs2(); turn = 1; Ömsesidig uteslutning: OK Inget dödläge: OK, en av dem kan alltid köra. Inget svält: OK, omväxlande protokoll. 17

Ömsesidig uteslutning - version 1 - int turn = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( turn!= 1); cs1(); turn = 2; class T2 extends Thread { public void run() { while( true) { noncs2(); while( turn!= 2); cs2(); turn = 1; Ömsesidig uteslutning: OK Inget dödläge: OK, en av dem kan alltid köra. Inget svält: OK, omväxlande protokoll. Effektivitet / en tråd?: NEJ (en tråd kommer hänga sig efter max en omgång), plus vi har en busy-wait (ineffektiv). För många trådar dessutom rörig. 17

Ömsesidig uteslutning - version 1 - int turn = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( turn!= 1); cs1(); turn = 2; class T2 extends Thread { public void run() { while( true) { noncs2(); while( turn!= 2); cs2(); turn = 1; Ömsesidig uteslutning: OK Inget dödläge: OK, en av dem kan alltid köra. Inget svält: OK, omväxlande protokoll. Effektivitet / en tråd?: NEJ (en tråd kommer hänga sig efter max en omgång), plus vi har en busy-wait (ineffektiv). För många trådar dessutom rörig. Ej acceptabelt! 17

Ömsesidig uteslutning - version 2 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( c2!= 1); c1 = 0; cs1(); c1 = 1; class T2 extends Thread { public void run() { while( true) { noncs2(); while( c1!= 1); c2 = 0; cs1(); c2 = 1; 18

Ömsesidig uteslutning - version 2 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( c2!= 1); c1 = 0; cs1(); c1 = 1; class T2 extends Thread { public void run() { while( true) { noncs2(); while( c1!= 1); c2 = 0; cs1(); c2 = 1; Ömsesidig uteslutning: NEJ... (testa sammanflätning) 18

Ömsesidig uteslutning - version 2 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( c2!= 1); c1 = 0; cs1(); c1 = 1; class T2 extends Thread { public void run() { while( true) { noncs2(); while( c1!= 1); c2 = 0; cs1(); c2 = 1; Ömsesidig uteslutning: NEJ... (testa sammanflätning) c1 = 1; c2 = 1; while( c2!= 1); while( c1!= 1); c1 = 0; c2 = 0; cs1(); cs2(); 18

Ömsesidig uteslutning - version 2 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); while( c2!= 1); c1 = 0; cs1(); c1 = 1; class T2 extends Thread { public void run() { while( true) { noncs2(); while( c1!= 1); c2 = 0; cs1(); c2 = 1; Ömsesidig uteslutning: NEJ... (testa sammanflätning) c1 = 1; c2 = 1; while( c2!= 1); while( c1!= 1); c1 = 0; c2 = 0; cs1(); cs2(); Ingen lösning, även om det kan fungera länge tills det kraschar (genom interrupt i noncs1, eller noncs2!) 18

Ömsesidig uteslutning - version 3 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); c1 = 0; while( c2!= 1); cs1(); c1 = 1; class T2 extends Thread { public void run() { while( true) { noncs2(); c2 = 0; while( c1!= 1); cs1(); c2 = 1; 19

Ömsesidig uteslutning - version 3 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); c1 = 0; while( c2!= 1); cs1(); c1 = 1; class T2 extends Thread { public void run() { while( true) { noncs2(); c2 = 0; while( c1!= 1); cs1(); c2 = 1; Ömsesidig uteslutning: OK 19

Ömsesidig uteslutning - version 3 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { public void run() { while( true) { noncs1(); c1 = 0; while( c2!= 1); cs1(); c1 = 1; class T2 extends Thread { public void run() { while( true) { noncs2(); c2 = 0; while( c1!= 1); cs1(); c2 = 1; Ömsesidig uteslutning: OK Inget dödläge: Nej (alltså ja): 19

Ömsesidig uteslutning - version 3 - class T1 extends Thread { public void run() { while( true) { noncs1(); c1 = 0; while( c2!= 1); cs1(); c1 = 1; int c1, c2; c1 = c2 = 1; class T2 extends Thread { public void run() { while( true) { noncs2(); c2 = 0; while( c1!= 1); cs1(); c2 = 1; Ömsesidig uteslutning: OK Inget dödläge: Nej (alltså ja): c1 = 0; c2 = 0; while( c2!= 1); // I all evighet... while( c1!= 1); //... och lite till... 19

Ömsesidig uteslutning - version 3 - class T1 extends Thread { public void run() { while( true) { noncs1(); c1 = 0; while( c2!= 1); cs1(); c1 = 1; int c1, c2; c1 = c2 = 1; class T2 extends Thread { public void run() { while( true) { noncs2(); c2 = 0; while( c1!= 1); cs1(); c2 = 1; Ömsesidig uteslutning: OK Inget dödläge: Nej (alltså ja): c1 = 0; c2 = 0; while( c2!= 1); // I all evighet... while( c1!= 1); //... och lite till... Ingen lösning, även om det kan fungera länge tills det kraschar (genom interrupt i noncs1, eller noncs2)! 19

Ömsesidig uteslutning - version 4 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ c1 = 1; //** c1 = 0; cs1(); c1 = 1; //.. class T2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ c2 = 1; //** c2 = 0; cs2(); c2 = 1; //.. 20

Ömsesidig uteslutning - version 4 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ c1 = 1; //** c1 = 0; cs1(); c1 = 1; //.. class T2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ c2 = 1; //** c2 = 0; cs2(); c2 = 1; //.. Ömsesidig uteslutning: OK 20

Ömsesidig uteslutning - version 4 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ c1 = 1; //** c1 = 0; cs1(); c1 = 1; //.. class T2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ c2 = 1; //** c2 = 0; cs2(); c2 = 1; //.. Ömsesidig uteslutning: OK Inget dödläge: OK (//** är yield) 20

Ömsesidig uteslutning - version 4 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ c1 = 1; //** c1 = 0; cs1(); c1 = 1; //.. class T2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ c2 = 1; //** c2 = 0; cs2(); c2 = 1; //.. Ömsesidig uteslutning: OK Inget dödläge: OK (//** är yield) Inget svält: NEJ, det kan hända att en tråd får köra, men kommer aldrig så långt att den får verkligen utföra CS (kallas livelock om det händer fler trådar så att hela systemet jobbar utan att göra något). 20

Ömsesidig uteslutning - version 4 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ c1 = 1; //** c1 = 0; cs1(); c1 = 1; //.. class T2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ c2 = 1; //** c2 = 0; cs2(); c2 = 1; //.. Ömsesidig uteslutning: OK Inget dödläge: OK (//** är yield) Inget svält: NEJ, det kan hända att en tråd får köra, men kommer aldrig så långt att den får verkligen utföra CS (kallas livelock om det händer fler trådar så att hela systemet jobbar utan att göra något). Ej acceptabelt! 20

Ömsesidig uteslutning - version 4 - int c1, c2; c1 = c2 = 1; class T1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ c1 = 1; //** c1 = 0; cs1(); c1 = 1; //.. Ömsesidig uteslutning: OK Inget dödläge: OK (//** är yield) Inget svält: NEJ, det kan hända att en tråd får köra, men kommer aldrig så långt att den får verkligen utföra CS (kallas livelock om det händer fler trådar så att hela systemet jobbar utan att göra något). Ej acceptabelt! class T2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ c2 = 1; //** c2 = 0; cs2(); c2 = 1; //.. c1 = 0; c2 = 0; while( c1!= 1) { c2 = 1;... while( c2!= 1); cs1(); c1 = 1; noncs1(); c1 = 0;... c2 = 0; while( c1!= 1) { c2 = 1; while( c2!= 1); cs1(); c1 = 1;... 20

Dekkers algoritm int c1, c2, turn; c1 = c2 = turn = 1; class DA1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ if( turn == 2) { c1 = 1; while( turn == 2); c1 = 0; cs1(); c1 = 1; turn = 2; class DA2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ if( turn == 1) { c2 = 1; while( turn == 1); c2 = 0; cs2(); c2 = 1; turn = 1; 21

Dekkers algoritm int c1, c2, turn; c1 = c2 = turn = 1; class DA1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ if( turn == 2) { c1 = 1; while( turn == 2); c1 = 0; cs1(); c1 = 1; turn = 2; class DA2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ if( turn == 1) { c2 = 1; while( turn == 1); c2 = 0; cs2(); c2 = 1; turn = 1; Ömsesidig uteslutning: OK 21

Dekkers algoritm int c1, c2, turn; c1 = c2 = turn = 1; class DA1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ if( turn == 2) { c1 = 1; while( turn == 2); c1 = 0; cs1(); c1 = 1; turn = 2; class DA2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ if( turn == 1) { c2 = 1; while( turn == 1); c2 = 0; cs2(); c2 = 1; turn = 1; Ömsesidig uteslutning: OK Inget dödläge: OK 21

Dekkers algoritm int c1, c2, turn; c1 = c2 = turn = 1; class DA1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ if( turn == 2) { c1 = 1; while( turn == 2); c1 = 0; cs1(); c1 = 1; turn = 2; class DA2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ if( turn == 1) { c2 = 1; while( turn == 1); c2 = 0; cs2(); c2 = 1; turn = 1; Ömsesidig uteslutning: OK Inget dödläge: OK Inget svält: OK (inte bara yield, men blockerar tills CS har körts en gång minst) 21

Dekkers algoritm int c1, c2, turn; c1 = c2 = turn = 1; class DA1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ if( turn == 2) { c1 = 1; while( turn == 2); c1 = 0; cs1(); c1 = 1; turn = 2; class DA2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ if( turn == 1) { c2 = 1; while( turn == 1); c2 = 0; cs2(); c2 = 1; turn = 1; Ömsesidig uteslutning: OK Inget dödläge: OK Inget svält: OK (inte bara yield, men blockerar tills CS har körts en gång minst) Effektivitet / en tråd?: Inte bra. 21

Dekkers algoritm int c1, c2, turn; c1 = c2 = turn = 1; class DA1 extends Thread { //... noncs1(); c1 = 0; while( c2!= 1){ if( turn == 2) { c1 = 1; while( turn == 2); c1 = 0; cs1(); c1 = 1; turn = 2; class DA2 extends Thread { //... noncs2(); c2 = 0; while( c1!= 1){ if( turn == 1) { c2 = 1; while( turn == 1); c2 = 0; cs2(); c2 = 1; turn = 1; Ömsesidig uteslutning: OK Inget dödläge: OK Inget svält: OK (inte bara yield, men blockerar tills CS har körts en gång minst) Effektivitet / en tråd?: Inte bra. Dekkers algoritm fungerar bra för många trådar, men blir då komplex, den löser problemet ömsesidig uteslutning, MEN med busy-wait. Kan vara användbar i vissa system med flera processorer. 21

Ömsesidig uteslutning - Semafor - MutexSem mutex = new MutexSem(); class T1 extends Thread { public void run() { while( true) { noncs1(); mutex.take(); cs1(); mutex.give(); class T2 extends Thread { public void run() { while( true) { noncs2(); mutex.take(); cs2(); mutex.give(); 22

Ömsesidig uteslutning - Semafor - MutexSem mutex = new MutexSem(); class T1 extends Thread { public void run() { while( true) { noncs1(); mutex.take(); cs1(); mutex.give(); class T2 extends Thread { public void run() { while( true) { noncs2(); mutex.take(); cs2(); mutex.give(); Ömsesidig uteslutning: OK 22

Ömsesidig uteslutning - Semafor - MutexSem mutex = new MutexSem(); class T1 extends Thread { public void run() { while( true) { noncs1(); mutex.take(); cs1(); mutex.give(); class T2 extends Thread { public void run() { while( true) { noncs2(); mutex.take(); cs2(); mutex.give(); Ömsesidig uteslutning: OK Inget dödläge: OK 22

Ömsesidig uteslutning - Semafor - MutexSem mutex = new MutexSem(); class T1 extends Thread { public void run() { while( true) { noncs1(); mutex.take(); cs1(); mutex.give(); class T2 extends Thread { public void run() { while( true) { noncs2(); mutex.take(); cs2(); mutex.give(); Ömsesidig uteslutning: OK Inget dödläge: OK Inget svält: OK (give() startar upp den blockerade tråden direkt) 22

Ömsesidig uteslutning - Semafor - MutexSem mutex = new MutexSem(); class T1 extends Thread { public void run() { while( true) { noncs1(); mutex.take(); cs1(); mutex.give(); class T2 extends Thread { public void run() { while( true) { noncs2(); mutex.take(); cs2(); mutex.give(); Ömsesidig uteslutning: OK Inget dödläge: OK Inget svält: OK (give() startar upp den blockerade tråden direkt) Effektivitet / en tråd: OK. Blockerade trådar sövs (sleep), dvs de använder inte CPUn. 22

Ömsesidig uteslutning - Semafor - MutexSem mutex = new MutexSem(); class T1 extends Thread { public void run() { while( true) { noncs1(); mutex.take(); cs1(); mutex.give(); class T2 extends Thread { public void run() { while( true) { noncs2(); mutex.take(); cs2(); mutex.give(); Ömsesidig uteslutning: OK Inget dödläge: OK Inget svält: OK (give() startar upp den blockerade tråden direkt) Effektivitet / en tråd: OK. Blockerade trådar sövs (sleep), dvs de använder inte CPUn. Acceptabelt! 22

Semafor - basfakta 23

Semafor - basfakta Semaforer utgör en minimal mekanism för ömsesidig uteslutning 23

Semafor - basfakta Semaforer utgör en minimal mekanism för ömsesidig uteslutning En semafor är egentligen bara en integer-variabel med två metoder, take() och give(): 23

Semafor - basfakta Semaforer utgör en minimal mekanism för ömsesidig uteslutning En semafor är egentligen bara en integer-variabel med två metoder, take() och give(): class SemaphorePrinciple { int count; public void take() { while( count < 1) suspend executing thread // here, currentthread() is used! --count; public void give() { if( any thread suspended ) resume the first one in queue ; count++; 23

Semafor - basfakta Semaforer utgör en minimal mekanism för ömsesidig uteslutning En semafor är egentligen bara en integer-variabel med två metoder, take() och give(): class SemaphorePrinciple { int count; public void take() { while( count < 1) suspend executing thread // here, currentthread() is used! --count; public void give() { if( any thread suspended ) resume the first one in queue ; count++; OBS 1: take och give är odelbara (atomic) operationer, som kräver systemsupport när de ska implementeras (t ex deaktivera hårdvaruinterrupts). 23

Semafor - basfakta Semaforer utgör en minimal mekanism för ömsesidig uteslutning En semafor är egentligen bara en integer-variabel med två metoder, take() och give(): class SemaphorePrinciple { int count; public void take() { while( count < 1) suspend executing thread // here, currentthread() is used! --count; public void give() { if( any thread suspended ) resume the first one in queue ; count++; OBS 1: take och give är odelbara (atomic) operationer, som kräver systemsupport när de ska implementeras (t ex deaktivera hårdvaruinterrupts). OBS 2: take blockerar den anropande tråden sålänge count == 0. Detta kan inte implementeras i vanlig Java-kod. 23

Typer av semaforer 24

Typer av semaforer MutexSem - MutualExclusion semaphore: Den som tar flaggan får jobba med gemensamma resurser, den som vill ha den samtidigt, får vänta (blockeras). 24

Typer av semaforer MutexSem - MutualExclusion semaphore: Den som tar flaggan får jobba med gemensamma resurser, den som vill ha den samtidigt, får vänta (blockeras). CountingSem - Counting semaphore, signalling: Den som gör plats / en resurs tillgänglig, signalerar genom att lägga en flagga på högen, den som vill utnyttja en resursplats tar en flagga från högen. Finns inga fria flaggor, måste den som vill ha en vänta. 24

Semaforer vs omvärlden 25

Semaforer vs omvärlden Mutual exclusion (MutexSem): Tåg ska köra mellan Malmö och Lund när det för tillfället råder enkelspårsdrift. 25

Semaforer vs omvärlden Mutual exclusion (MutexSem): Tåg ska köra mellan Malmö och Lund när det för tillfället råder enkelspårsdrift. Signaling (CountingSem): Check-In på Kastrup: Man väntar i en lång rad och blir tilldelad en fri disk så fort det finns en sådan. 25

Semaforer vs omvärlden Mutual exclusion (MutexSem): Tåg ska köra mellan Malmö och Lund när det för tillfället råder enkelspårsdrift. Signaling (CountingSem): Check-In på Kastrup: Man väntar i en lång rad och blir tilldelad en fri disk så fort det finns en sådan. Rendezvous: Last från ett godståg ska lastas om / kopplas om på ett annat tåg utan att något ska lagras. Båda tågen måste alltså stå i omlastningsområdet samtidigt. 25

Signalera med en sorts signal 26

Signalera med en sorts signal Patienten på rummet behöver hjälp och trycker på signalknappen - lampan utanför rummet tänds och larmet i expeditionen går. (signal.give()) 26

Signalera med en sorts signal Patienten på rummet behöver hjälp och trycker på signalknappen - lampan utanför rummet tänds och larmet i expeditionen går. (signal.give()) Sjuksköterskan kommer in i rummet och slår av signalen - lampan och larmet släcks och alla utanför vet att problemet åtgärdas - ingen annan behöver eller ska komma och hjälpa. (signal.take()) 26

Signalera med en sorts signal Patienten på rummet behöver hjälp och trycker på signalknappen - lampan utanför rummet tänds och larmet i expeditionen går. (signal.give()) Sjuksköterskan kommer in i rummet och slår av signalen - lampan och larmet släcks och alla utanför vet att problemet åtgärdas - ingen annan behöver eller ska komma och hjälpa. (signal.take()) Detta kan hända på flera rum samtidigt, eller med korta mellanrum. Sålänge det finns sjuksköterskor kan de ta över rum efter rum, sen måste kanske en patient vänta lite längre. Om ingen larmar, måste sjuksköterskorna vänta på nästa problem att lösa. (signal.give() + signal.give() + signal.take() + signal.give() + signal.take() + signal.take()) 26

Signalera med två olika signaler 27

Signalera med två olika signaler Chefen och Sekreteraren har ett postfack för att överlämna dokument till varandra, egentligen är det dock bara Sekreteraren som lägger dit dokument, och chefen som hämtar ut dem därifrån. I facket får det enbart ligga ett dokument åt gången. 27

Signalera med två olika signaler Chefen och Sekreteraren har ett postfack för att överlämna dokument till varandra, egentligen är det dock bara Sekreteraren som lägger dit dokument, och chefen som hämtar ut dem därifrån. I facket får det enbart ligga ett dokument åt gången. Sekreteraren ser att facket är tomt genom att en tom -lampa lyser på hans kontor. Han går till facket, lägger dit ett dokument som chefen måste signera, och trycker på en knapp som släcker tom -lampan och sedan slår på en det finns ett dokument -lampa på chefens kontor. (free.take() + avail.give()) 27

Signalera med två olika signaler Chefen och Sekreteraren har ett postfack för att överlämna dokument till varandra, egentligen är det dock bara Sekreteraren som lägger dit dokument, och chefen som hämtar ut dem därifrån. I facket får det enbart ligga ett dokument åt gången. Sekreteraren ser att facket är tomt genom att en tom -lampa lyser på hans kontor. Han går till facket, lägger dit ett dokument som chefen måste signera, och trycker på en knapp som släcker tom -lampan och sedan slår på en det finns ett dokument -lampa på chefens kontor. (free.take() + avail.give()) Chefen ser lampan, kommer till facket, tar dokumentet, släcker det finns ett dokument - lampan och slår på tom -lampan hos sekreteraren. (avail.take() + free.give()) 27

Semaforer - användning i kod Tråd A: Tråd B: Mutual exclusion (ömsesidig uteslutning)... mutex.take(); *** mutex.give();...... mutex.take(); *** mutex.give();... Signaling (signalering)... buffer.give();...... buffer.take();... Rendezvous *** entry.give(); exit.take(); ***... entry.take(); *** exit.give();... 28

Semaforer i Java (Mutex) Deklarera: import se.lth.cs.realtime.semaphore.*; Semaphore mutex1; // inte tydligt om man vill ha en mutex MutexSem mutex2; // bättre. Skapa / initialisera: /*inte så bra:*/ mutex1 = new CountingSem(); mutex1 = new CountingSem(1); /*bättre:*/ mutex2 = new MutexSem(); // tilldelar värdet 0 till count // tilldelar värdet 1 till count // tilldelar 1 (eller true) till intern status Tillämpning: mutex2.take(); amount += change; mutex2.give(); Förutom att det är tydligare, får man bättre felidentifiering och bättre timing om man skapar ömsesidig uteslutning med en MutexSem istf en CountingSem 29

Mutex i trådar import se.lth.cs.realtime.semaphore.*; class ThreadTest { public static void main(string[] args) { class RogersThread extends Thread { String thename; Semaphore thesem; Thread t1,t2; Semaphore s; s = new MutexSem(); t1 = new RogersThread("Thread one",s); t2 = new RogersThread("Thread two",s); t1.start(); t2.start(); public RogersThread( String n, Semaphore s){ thename = n; thesem = s; public void run() { thesem.take(); for(int t=1;t<=100;t++) { System.out.println(theName + ":" + t); sleep(1); thesem.give(); 30

Signal i trådar import se.lth.cs.realtime.semaphore.*; class ThreadTest { public static void main(string[] args) { class RogersThread extends Thread { String thename; CountingSem mysem, hissem; Thread t1,t2; CountingSem s1, s2; s1 = new CountingSem(1); s2 = new CountingSem(0); t1 = new RogersThread("One",s1, s2); t1.start(); t2 = new RogersThread("Two",s2, s1); t2.start(); public RogersThread( String n, CountingSem s1, CountingSem s2){ thename = n; mysem = s1; hissem = s2; public void run() { for(int t=1;t<=100;t++) { mysem.take(); System.out.println(theName + ":" + t); hissem.give(); sleep(1); 31

Objekt och blockering 32

Objekt och blockering Trådobjekt (som alltså kan referera till en exekverande tråd) kallas för aktiva objekt. 32

Objekt och blockering Trådobjekt (som alltså kan referera till en exekverande tråd) kallas för aktiva objekt. Andra objekt (beskriven genom vanliga Java-klasser), som blir kallade eller drivna genom aktiva objekt (trådar) kallas för passiva objekt. T ex en semafor ;-) 32

Objekt och blockering Trådobjekt (som alltså kan referera till en exekverande tråd) kallas för aktiva objekt. Andra objekt (beskriven genom vanliga Java-klasser), som blir kallade eller drivna genom aktiva objekt (trådar) kallas för passiva objekt. T ex en semafor ;-) Semaforer erbjuder blockerande operationer; hur blir de representerade? 32

Objekt och blockering Trådobjekt (som alltså kan referera till en exekverande tråd) kallas för aktiva objekt. Andra objekt (beskriven genom vanliga Java-klasser), som blir kallade eller drivna genom aktiva objekt (trådar) kallas för passiva objekt. T ex en semafor ;-) Semaforer erbjuder blockerande operationer; hur blir de representerade? : Exekverande (executing) : Blockerad (blocked) Tråd (aktivt objekt) Semafor (passivt objekt) : möjligen blockerande (potential blocking) 32

Sekvens med mutex / blockerade trådar T1 mutex T2 take take give give Anrop till take - give i följd måste komma från samma tråd. Stöds av MutexSem klassen. 33

Signalering T1 give give give signal take take take take T2 En tråd kallar take, en annan give. Stöds av CountingSem klassen. 34

Rendezvous T1 give entry exit take T2 sync take give sync Säker dataöverföring / manipulation med T1 från T2 under sync-tiden. T1 har exklusiv tillgång till datan genom att hålla i semaforen förutom mellan sitt give och T2s give 35

Övning 1 + Övning 2 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! Övning 1 handlar om semaforer och deras tillämpning 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! Övning 1 handlar om semaforer och deras tillämpning Teoretiska uppgifter som ska bearbetas under övningen (var gärna förberedd!) 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! Övning 1 handlar om semaforer och deras tillämpning Teoretiska uppgifter som ska bearbetas under övningen (var gärna förberedd!) Laboration 1 introduceras lite kort (mer under övning 2) 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! Övning 1 handlar om semaforer och deras tillämpning Teoretiska uppgifter som ska bearbetas under övningen (var gärna förberedd!) Laboration 1 introduceras lite kort (mer under övning 2) Labbgrupper (två studenter vanligtvis) ska bildas 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! Övning 1 handlar om semaforer och deras tillämpning Teoretiska uppgifter som ska bearbetas under övningen (var gärna förberedd!) Laboration 1 introduceras lite kort (mer under övning 2) Labbgrupper (två studenter vanligtvis) ska bildas (Praktiska uppgifter som ska lösas vid datorn med hjälp av Eclipse-workspace) 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! Övning 1 handlar om semaforer och deras tillämpning Teoretiska uppgifter som ska bearbetas under övningen (var gärna förberedd!) Laboration 1 introduceras lite kort (mer under övning 2) Labbgrupper (två studenter vanligtvis) ska bildas (Praktiska uppgifter som ska lösas vid datorn med hjälp av Eclipse-workspace) Övning 2 är till förberedelse för Laboration 1 (väckarklocka) 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! Övning 1 handlar om semaforer och deras tillämpning Teoretiska uppgifter som ska bearbetas under övningen (var gärna förberedd!) Laboration 1 introduceras lite kort (mer under övning 2) Labbgrupper (två studenter vanligtvis) ska bildas (Praktiska uppgifter som ska lösas vid datorn med hjälp av Eclipse-workspace) Övning 2 är till förberedelse för Laboration 1 (väckarklocka) Uppgiften kommer att förklaras lite mera djupgående 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! Övning 1 handlar om semaforer och deras tillämpning Teoretiska uppgifter som ska bearbetas under övningen (var gärna förberedd!) Laboration 1 introduceras lite kort (mer under övning 2) Labbgrupper (två studenter vanligtvis) ska bildas (Praktiska uppgifter som ska lösas vid datorn med hjälp av Eclipse-workspace) Övning 2 är till förberedelse för Laboration 1 (väckarklocka) Uppgiften kommer att förklaras lite mera djupgående (Labbgrupper ska bildas, om så inte skett innan) 36

Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - TA MED MATERIALET! Övning 1 handlar om semaforer och deras tillämpning Teoretiska uppgifter som ska bearbetas under övningen (var gärna förberedd!) Laboration 1 introduceras lite kort (mer under övning 2) Labbgrupper (två studenter vanligtvis) ska bildas (Praktiska uppgifter som ska lösas vid datorn med hjälp av Eclipse-workspace) Övning 2 är till förberedelse för Laboration 1 (väckarklocka) Uppgiften kommer att förklaras lite mera djupgående (Labbgrupper ska bildas, om så inte skett innan) Övningstillfället ska utnyttjas till att skapa ett design-förslag till laborationen, som ska granskas både i SPA-uppsättning och av läraren 36

Dagens resultat Trådar, kapplöpningsproblem, hantering av gemensamma resurser Semaforer Typer av semaforer Användning av semaforer Man ska kunna lösa uppgifterna till övning 1 och påbörja arbetet med övning 2 / lab1 Lästips: e-bok: delar av Kap 5 (s 103-129) kompendium: Kap 2-1 (Threads) samt 2-2 (Semaphores) 37