Objektorienterad Realtidsprogrammering 2000 Java: kort introduktion. Trådar. Något om mutex, Dekkers algoritm och monitorer. Javas ("inbyggda monitor") synchronized.

Java Java är konstruerat på SUN Starkt typat Första versionen släpptes 1995 Starkt typat Dvs det går att avgöra typkompatibilitet av alla uttryck i programmet vid kompileringstillfället. Virtuell maskin (VM) som gör det maskinoberoende En speciell VM per plattformstyp överbryggar olikheter i plattformarnas arkitektur Klassbibliotek språkklasser, stränghantering, grafik, gränssnitt, fönster, Internet, händelsehantering, processer, collections, mm Bindning till WWW med applets och liknande Har fått sin huvudsakliga spridning via Internet Syntax som C. Semantik och klasser mer som Smalltalk

Arkitektur kompilera källkod java bytekod (javac) kör (java) en virtuell maskin per plattformstyp Pc VM Mac VM Unix VM

Java: mitt första "program" Skapa en fil med namnet MyFirstProgram.java Skriv följande kod i filen: import java.io.*; public class MyFirstProgram{ public static void main (String [] args){ System.out.println("Mitt första program!"); }

Då genereras en körbar fil MyFirstProgram.class ... kompilera och kör Kompilera >javac MyFirstProgram.java Då genereras en körbar fil MyFirstProgram.class Kör genom att starta Javas virtuella maskin med program/klassnamnet som argument >java MyFirstProgram Mitt första program! Regeln är att klassens static void main-metod alltid exekveras

Ett "Javaprograms" struktur En klass ser ut på följande sätt public class KlassNamn extends SuperKlassNamn{ attribut (instans- och klassvariabler) metoder (instans- och klassmetoder) konstruktörer } Kallas också för medlemmar En metod modifierare returtyp funktionsnamn(argument){ programsatser }

Konstruera klass Klassnamn = filnamn En klass skall ha samma namn som den fil den placeras i Klassen Circle i filen Circle.java En fil kan innehålla flera klasser men bara en av dem kan vara deklarerad public, Det är den publika klassens namn som motsvarar filens Definition av klass, mall public class KlassNamn extends SuperKlassNamn{ Modifierare TypIvar1 ivar1; Modifierare MetodTyp metod1(TypArg1 arg1) {} public KlassNamn() {} } instansvariabler metoder konstruktörer

Deklarera och instansiera Deklaration av instans KlassNamn variabelNamn; Instansiering variabelNamn = new KlassNamn(); alternativt, både deklaration och instansiering på en gång KlassNamn variabelNamn = new KlassNamn();

Kompilera och köra Environmentvariabel För bekväm hantering sätt path (se systemdokumentation) så att kompilator, virtuell maskin och bibliotek enkelt hittas Plattformsberoende hur detta går till Kompilera med javac filnamn javac KlassNamn.java om allt går bra skapas då en fil med namnet KlassNamn.class Kör med java klassnamn java KlassNamn

Typer I Java måste alla variabler och metoder deklareras med typ Typ variabel; Det finns primitiva typer som int, char, float och boolean int x; En variabel kan ges ett initialt värde vid deklarationen int x = 10; Man kan också använda typer som är implementerade som vanliga klasser String course = "O2R";

Modifierare En modifierare kan användas för att ange vilka objekt som kan accessa en klass eller dess medlemmar (dvs dess attribut eller metoder), mest grundläggande är: static indikerar att medlemmen är klassvariabel eller klassmetod public medlemmen är accessbar överallt där dess klass är accessbar protected medlemmen endast accessbar i klassen, dess subklasser eller i aktuellt package (vi återkommer till package vid senare tillfälle) private medlemmen endast accessbar i den klass som definierar den ingen modifierare accessbar av andra klasser i samma paket

Exempel public class BankAccount{ protected int balance = 0; public void deposit (int amount) { balance = balance + amount; } public void withdraw (int amount) { balance = balance - amount; public int balance (){ return balance;

... BankAccount account1, account2; int transfer; account1 = new BankAccount(); account2 = new BankAccount(); account1.deposit(200); account2.deposit(100); transfer = 75; account1.withdraw(transfer); account2.deposit(transfer); account2.balance(); // resultat 175

Klasser En klass och dess metoder skrivs i en enda fil med samma namn som klassen En fil kan innehålla både klass som används av andra klasser och hjälpklasser, s.k. inre klasser En klass kan vara public, dvs åtkomlig för alla, protected, dvs endast åtkomlig för klasser i samma paket eller subklasser, paketåtkomstbar, dvs endast åtkomlig av andra klasser i samma paket eller slutligen private, dvs bara åtkomlig av klasser i dess omedelbara omgivning (~fil)

Interface Ett interface beskriver API-et för en viss grupp av klasser (som deklarerar att dom implementerar detta gränssnitt) Ett interface placeras, precis som en klass, i en fil med samma namn som interfacet med suffixet .java kompileras med javac för att generera en .class-fil Ett interface deklarerar endast metodapier (och eventuellt konstanter) Motsvarar en pure abstract class i C++

Trådar En tråd, lättviktsprocess eller exekveringsomgivning är en viss sekvens av kontroll inom ett program I Java skapas en tråd som antingen subklass till klassen Thread eller genom att implementera gränssnittet Runnable i båda fallen skrivs en metod run som definierar vad som skall göras i tråden Program med två trådar

Subklassa Thread eller implementera Runnable Beskriva egen tråd genom att subklassa Thread class MyThread extends Thread { public void run() { //Här beskriver vi vad som skall göras så länge tråden "lever" //ofta en while-loop med stoppvillkor } «interface» Runnable relevanta delar av Thread samt Runnable Thread run(): void run(): void MyThread run(): void

implementerar Runnable Alternativ notation för att visa att Thread implementerar Runnable Exempel Runnable public class MyThread extends Thread { public void run() { int x = 0; while(x < 100) { System.out.println("x: " + x); x++; } Vi testar tråden, dvs startar via meddelandet start MyThread myThread = new MyThread(); myThread.start(); Thread MyThread

... trådar med Runnable «interface» Runnable I många fall fungerar det inte att subklassa Thread utan vi vill kanske ha en annan superklass Då kan vi istället implementera Runnable public class MyRunnable implements Runnable { public void run() { int x = 0; while(x < 100) { System.out.println("x: " + x); x++; } run() MyRunnable run()

... och testar genom att starta en instans av vår klass via klassen Thread Thread wrappingThread = new Thread(new MyRunnable()); wrappingThread.start(); Vi ser på fler exempel från Suns tutorial om trådar Thread relevanta delar av Thread if (target != null) { target.run(); } target : Runnable run(): void Thread(Runnable r) target = r;

Uppdatering av gemensam resurs Antag att vi har följande program (beskrivet med ett aktivitetsdiagram) Ge värden för a, b, c och d m1 = max(a, b); m2 = max(c, d); m = max(m1, m2); Här har det ingen betydelse om m1 eller m2 beräknas först då satserna disjunkta

... med tidsberoende beteende Om vi istället betraktar följande program j = 10; j.print(); j = 100; Så är resultatet (utskriften via print) beroende av vilken av grenarna som utförs först

Bankkonto med flera trådar kan ge problem BankAccount b1 = balance; balance = b1 + amount; int balance = 0 deposit(int amount) withdraw(int amount) b2 = balance; balance = b2 - amount; vi initierar kontot (sätter in 500) account.balance = 500 Tråd 1 //visa kontohavare1 balansen account.balance.display() //kontohavare1 tar ut belopp account.withdraw(100) // visa hur mycket som finns på kontot Tråd 2 //visa kontohavare2 balansen account.balance.display() //kontohavare2 sätter in belopp account.deposit(200) // visa hur mycket som finns på kontot

Bankkonto och flera trådar, problem Om flera trådar samtidigt har möjlighet att uppdatera bankkontot så får vi tidsberoende resultat Beroende av ordning kommer kontot nu ha 400, 600 eller 700 Tråd1 Tråd2 b1 b2 balance b1 = balance 500 500 b2 = balance 500 balance = b2 + 200 700 balance = b1 - 100 400 Möjlighet 1 Möjlighet 2-3 (samma resultat om tråd 2 först) Tråd1 Tråd2 b1 b2 balance b1 = balance 500 500 balance = b1 - 100 400 b2 = balance 400 balance = b2 + 200 600 Tråd1 Tråd2 b1 b2 balance b1 = balance 500 500 b2 = balance 500 balance = b1 - 100 400 balance = b2 + 200 700 Möjlighet 4

Kritiska regioner I bankkontoexemplet kan vi identifiera kritiska regioner som måste exekveras tillsammans Både kodkroppen i withdraw och deposit är kritiska regioner vi vill skydda kritisk region en process i taget i regionen ingen annan process ska få komma in om någon annan redan där helst skall ingen process behöva vänta i det oändliga på att komma in b1 = balance; balance = b1 + amount; Kritisk region b2 = balance; balance = b2 - amount;

Mutex Kritiska regioner kan skyddas med olika tekniker för inbördes exklusiv exekvering (mutexbegin/mutexend) Man använder lås innan man exekverar kritisk region och släpper det när man är klar med kodavsnittet Man kan skydda med semafor monitor brevlåda Vi kommer titta närmare på monitorer, semaforer och relaterade tekniker mutexbegin; b1 = balance; balance = b1 + amount; mutexend;

Dekkers algoritm En implementation av mutexbegin/mutexend av den Holländska matematikern Dekker mutexbegin: need(me) = true; while(need(other)) { if(turn != me) { need(me) = false; while(turn != me); } mutexend: turn = other;

... Korrekt Men hopplös komplicerad om vi har fler än två processer använder busy-wait vilket vi också vill undvika

Monitorer En monitor är ett objekt som kan fungera som ett staket runt kritisk data En monitor används för att låsa en viss kritisk region. Medan kodsekvens/objekt finns i monitorn kan ingen annan exekvera denna region/del av objektet

Exklusiv exekvering av delar av objekt I Java finns en inbyggd konstruktion för att hantera kritiska regioner Om man använder nyckelordet synchronized antingen i en metoddeklaration synchronized void metod() { //... } eller genom att låsa ett objekt i ett visst kodblock synchronized(lockObject)

... Det förstnämnda fallet är ekvivalent med att skriva void metod() {synchronized(this) { //... } Vad som händer är att alla synkroniserada kodavsnitt placeras i en monitor för objektet i vilket bara en tråd i taget kan befinna sig Dvs alla synchronized-deklarerade metoder och kodavsnitt låses Andra metoder och kodavsnitt är inte låsta

Bankkonto med flera trådar: lös problemet med synchronized En enkel lösning på problemet är att använda synchronized i dom kritiska regionerna synchronized(this) { b1 = balance; balance = b1 + amount; } BankAccount deposit(int amount) withdraw(int amount) int balance = 0 synchronized(this) { b2 = balance; balance = b2 - amount; } Nu kommer dom kritiska regionerna köras odelade och endast en av regionerna kan köras i taget

...bankkonto Enklast är att deklarera metoderna som synkroniserade public class SynchronizedBankAccount1{ protected int balance = 0; public synchronized void deposit (int amount) { balance = balance + amount; } public synchronized void withdraw (int amount) { balance = balance - amount; public int balance (){ return balance;

...bankkonto alternativ med subklass Alternativt skulle vi kunna subklassa och skriva över dom metoder som behöver synkroniseras public class SynchronizedBankAccount2 extends BankAccount{ public synchronized void deposit (int amount) { super.deposit(amount); } public synchronized void withdraw (int amount) { super.withdraw(amount); Metoder som inte är synkroniserade i superklasser kan skrivas över i subklass och samtidigt deklareras som synkroniserade