Realtidssystem. - Semaforer, trådsynkronisering - EDAF85 - Realtidssystem (Helsingborg) Elin A. Topp. Föreläsning 2

Transkript

1 Realtidssystem - Semaforer, trådsynkronisering - EDAF85 - Realtidssystem (Helsingborg) Elin A. Topp Föreläsning 2 Kursens innehåll motsvarar tidigare omgångar under beteckning EDA698 Stora delar baserad på: Föreläsningsmaterial EDA040 (Klas Nilsson, Mathias Haage) samt EDA698 (Mats Lilja) 1

2 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

3 Innehåll Synkronisering / Ömsesidig uteslutning: Semaforer MutexSem Signalling Counting semaphore 3

4 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). 4

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

6 Ö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? 6

7 Ö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; 7

8 Ö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 7

9 Ö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. 7

10 Ö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. 7

11 Ö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. 7

12 Ö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! 7

13 Ö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; 8

14 Ö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) 8

15 Ö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(); 8

16 Ö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!) 8

17 Ö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; 9

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; Ömsesidig uteslutning: OK 9

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): 9

20 Ö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... 9

21 Ö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)! 9

22 Ö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; //.. 10

23 Ö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 10

24 Ö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) 10

25 Ö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). 10

26 Ö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! 10

27 Ö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;... 10

28 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; 11

29 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 11

30 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 11

31 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) 11

32 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. 11

33 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. 11

34 Ö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(); 12

35 Ö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 12

36 Ö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 12

37 Ö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) 12

38 Ö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. 12

39 Ö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! 12

40 Semafor - basfakta 13

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

42 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(): 13

43 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++; 13

44 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++; 13

45 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). 13

46 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. 13

47 Typer av semaforer 14

48 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). 14

49 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. 14

50 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. 14

51 Semaforer vs omvärlden 15

52 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. 15

53 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. 15

54 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. 15

55 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. 15

56 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();... 16

57 Mutex - bara en kan hantera den 17

58 Mutex - bara en kan hantera den Det finns enbart en nyckel till toaletten på ett visst fik. 17

59 Mutex - bara en kan hantera den Det finns enbart en nyckel till toaletten på ett visst fik. Vill man ha nyckeln, måste man fråga efter den vid disken. 17

60 Mutex - bara en kan hantera den Det finns enbart en nyckel till toaletten på ett visst fik. Vill man ha nyckeln, måste man fråga efter den vid disken. Finns inte nyckeln där (toaletten är upptagen), måste man ställa sig i kön. 17

61 Mutex - bara en kan hantera den Det finns enbart en nyckel till toaletten på ett visst fik. Vill man ha nyckeln, måste man fråga efter den vid disken. Finns inte nyckeln där (toaletten är upptagen), måste man ställa sig i kön. När toaletten blir ledig, lämnas nyckeln tillbaka och ges vidare till första personen i kön. 17

62 Mutex - bara en kan hantera den Det finns enbart en nyckel till toaletten på ett visst fik. Vill man ha nyckeln, måste man fråga efter den vid disken. Finns inte nyckeln där (toaletten är upptagen), måste man ställa sig i kön. När toaletten blir ledig, lämnas nyckeln tillbaka och ges vidare till första personen i kön. Står ingen i kön, lämnas nyckeln tillbaka vid disken. 17

63 Mutex - bara en kan hantera den Det finns enbart en nyckel till toaletten på ett visst fik. Vill man ha nyckeln, måste man fråga efter den vid disken. Finns inte nyckeln där (toaletten är upptagen), måste man ställa sig i kön. När toaletten blir ledig, lämnas nyckeln tillbaka och ges vidare till första personen i kön. Står ingen i kön, lämnas nyckeln tillbaka vid disken. Nyckeln måste alltid lämnas (vidare) av den som hämtade den sist. 17

64 Signalera med en sorts signal 18

65 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()) 18

66 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()) 18

67 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()) 18

68 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()) 18

69 Signalera med två olika signaler 19

70 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. 19

71 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()) 19

72 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()) 19

73 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()) 19

74 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 20

75 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(); 21

76 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); 22

77 Objekt och blockering 23

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

79 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 ;-) 23

80 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? 23

81 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) 23

82 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. 24

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

84 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 26

85 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 Blocked Kontext PC (Program Counter), SP (stack pointer) Data (beroende på tillämpning) Registerinnehåll 27

86 Övning 1 + Övning 2 28

87 Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - Kom förberedd! 28

88 Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - Kom förberedd! Övning 1 i häftet handlar om semaforer och deras tillämpning - frågor till dem besvaras 28

89 Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - Kom förberedd! Övning 1 i häftet handlar om semaforer och deras tillämpning - frågor till dem besvaras Vid övningstillfället tittar vi på någon tenta-uppgift kring semaforer 28

90 Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - Kom förberedd! Övning 1 i häftet handlar om semaforer och deras tillämpning - frågor till dem besvaras Vid övningstillfället tittar vi på någon tenta-uppgift kring semaforer Laboration 1 introduceras lite mera 28

91 Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - Kom förberedd! Övning 1 i häftet handlar om semaforer och deras tillämpning - frågor till dem besvaras Vid övningstillfället tittar vi på någon tenta-uppgift kring semaforer Laboration 1 introduceras lite mera 28

92 Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - Kom förberedd! Övning 1 i häftet handlar om semaforer och deras tillämpning - frågor till dem besvaras Vid övningstillfället tittar vi på någon tenta-uppgift kring semaforer Laboration 1 introduceras lite mera Övning 2 är till förberedelse för Laboration 1 (väckarklocka) 28

93 Övning 1 + Övning 2 ÖVNINGAR ÄR INGA FÖRELÄSNINGAR - Kom förberedd! Övning 1 i häftet handlar om semaforer och deras tillämpning - frågor till dem besvaras Vid övningstillfället tittar vi på någon tenta-uppgift kring semaforer Laboration 1 introduceras lite mera Övning 2 är till förberedelse för Laboration 1 (väckarklocka) Tillfället ska utnyttjas till att färdigställa ett design-förslag till laborationen, som ska granskas både i kamrat-granskning och av läraren 28

94 Sammanfattning 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 ) kompendium: Kap 2-1 (Threads) samt 2-2 (Semaphores) 29