next previous Lite mer om synkronisering. Mer om Java och trådar. RMI Objektorienterad Realtidsprogrammering 2000 Objektorienterad Realtidsprogrammering 2000 Föreläsning 5

previous next 2 Synkronisering. Java. RMI. Exempel:visualisering av partiklar [ur Lea] Givet följande exempel, hittar vi två kritiska regioner class Particle { protected int x; protected int y; protected final Random rng = new Random(); public Particle(int initialX, int initialY) { x = initialX; y = initialY; } public void move() { x += rng.nextInt(10) - 5; y += rng.nextInt(20) - 10; } public void draw(Graphics g) { int lx, ly; lx = x; ly = y; g.drawRect(lx, ly, 10, 10); } Kritiska regioner Lösning skriv så här: public synchronized void move() { x += rng.nextInt(10) - 5; y += rng.nextInt(20) - 10; } public void draw(Graphics g) { int lx, ly; synchronized (this) { lx = x; ly = y; } g.drawRect(lx, ly, 10, 10); }

previous next 3 Synkronisering. Java. RMI.... Utan synkronisering –så kan tex ett gammalt lx och ett nytt ly användas ihop vilket ju ger felaktigt resultat Med synkronisering –Så skyddas dom kritiska regionerna Vad synkroniseriar vi då? –Enkel regel Tre olika saker att synkronisera [ur Lea s 6] –Lås alltid vid uppdateringar av objektets fält –Lås alltid vid access av fält som kan förändras –Lås aldrig då meddelanden skickas till andra objekt

previous next 4 Synkronisering. Java. RMI.... Resten av exemplet illustrerar –hur vi kan definera ett grafiskt fönster –hur vi kan skriva en applet –mer om hur trådar kan användas –lite mer Javaspecifika saker som hur anonyma klasser och grafiska objekt kan konstrueras

previous next 5 Synkronisering. Java. RMI. Vi börjar med att definera den del som ritar partiklarna på fönsterytan class ParticleCanvas extends Canvas { private Particle[] particles = new Particle[0]; ParticleCanvas(int size) { setSize(new Dimension(size, size)); } // Intended to be called by applet synchronized void setParticles(Particle[] ps) { if (ps == null) throw new IllegalArgumentException("Cannot set null"); particles = ps; } protected synchronized Particle[] getParticles() { return particles; }

previous next 6 Synkronisering. Java. RMI.... public void paint(Graphics g) { // override Canvas.paint Particle[] ps = getParticles(); for (int i = 0; i < ps.length; ++i) ps[i].draw(g); }

previous next 7 Synkronisering. Java. RMI. Sen appleten med flera trådar class ParticleApplet extends Applet { protected Thread[] threads; // null when not running protected final ParticleCanvas canvas = new ParticleCanvas(100); public void init() { add(canvas); } protected Thread makeThread(final Particle p) { // utility Runnable runloop = new Runnable() { public void run() { try { for(;;) { p.move(); canvas.repaint(); Thread.sleep(100); // 100msec is arbitrary } catch (InterruptedException e) { return; } } }; return new Thread(runloop); } Då appleten startar, init() Definition av anonym subklass till Runnable här emellan Definition av anonym subklass till Runnable här emellan

previous next 8 Synkronisering. Java. RMI.... public synchronized void start() { int n = 10; // just for demo if (threads == null) { // bypass if already started Particle[] particles = new Particle[n]; for (int i = 0; i < n; ++i) particles[i] = new Particle(50, 50); canvas.setParticles(particles); threads = new Thread[n]; for (int i = 0; i < n; ++i) { threads[i] = makeThread(particles[i]); threads[i].start(); }

previous next 9 Synkronisering. Java. RMI.... public synchronized void stop() { if (threads != null) { // bypass if already stopped for (int i = 0; i < threads.length; ++i) threads[i].interrupt(); threads = null; }

previous next 10 Synkronisering. Java. RMI. Ömsesidig uteslutning Ett vanligt problem är att flera processer behöver dela en resurs Typiskt skriver en process och en annan läser vad som skrivs (då det finns något att läsa) För att åstadkomma detta så behöver vi sätt att kommunicera mellan processerna –Fast vi vill inte ha några direkta referenser dem emellan En process skall kunna vänta på förändring medan en annan meddelar om att sådan skett Jmf mönstret Observer där ett objekt meddelar (publicerar) att förändring skett till beroende objekt (prenumeranter)

previous next 11 Synkronisering. Java. RMI. Kommunicera mellan trådar i Java Som vi såg på F4 kan vi använda wait and notify för att vänta på respektive meddela om att en viss resurs är tillgänglig –wait() Vänta ända till notifikation sker (dvs ingen tidsgräns) –wait(milliseconds) Vänta till notifikation sker men vänta max givet antal millisekunder –notify() Meddela precis en (slumpvis utvald) väntande process –notifyAll() Meddela alla väntande processer (i slumpvis ordning)

previous next 12 Synkronisering. Java. RMI. Exempel: tre trådar som skriver på terminalen class MyThreadNotifyer2 extends Thread { Object toNotify; public MyThreadNotifyer2(Object t) { toNotify = t; } public void info() { synchronized(toNotify) { toNotify.notifyAll(); System.out.println("."); try{toNotify.wait(200);} catch(InterruptedException e) {}; } public void run() { for(int i = 1; i < 21; i++) { info(); } Vänta max 200 ms

previous next 13 Synkronisering. Java. RMI.... public class MyThreadTest2 extends Thread { int start = 0; Object sync; public MyThreadTest2(int s, Object sync) { start = s; this.sync = sync; } public void info(int i) { synchronized(sync) { try{sync.wait();} catch(InterruptedException e) {}; System.out.println(i); } public void run() { for(int i = start; i < (start + 10); i++) { info(i); }

previous next 14 Synkronisering. Java. RMI.... public static void main(String[] args) { Object sync = new Object(); MyThreadTest2 myThread1 = new MyThreadTest2(1, sync); MyThreadTest2 myThread2 = new MyThreadTest2(100, sync); MyThreadNotifyer2 notifier = new MyThreadNotifyer2(sync); myThread1.start(); myThread2.start(); notifier.start(); //Vi väntar på en inmatning från terminalen try{System.in.read();} catch(Exception e) {} }

previous next 15 Synkronisering. Java. RMI. Exempel: producer-consumer public class Producer extends Thread { private CubbyHole cubbyhole; private int number; public Producer(CubbyHole c, int number) { cubbyhole = c; this.number = number; } public void run() { for (int i = 0; i < 10; i++) { cubbyhole.put(i); System.out.println("Producer #" + this.number + " put: " + i); try { sleep((int)(Math.random() * 100)); } catch (InterruptedException e) { } } Producer

previous next 16 Synkronisering. Java. RMI.... public class Consumer extends Thread { private CubbyHole cubbyhole; private int number; public Consumer(CubbyHole c, int number) { cubbyhole = c; this.number = number; } public void run() { int value = 0; for (int i = 0; i < 10; i++) { value = cubbyhole.get(); System.out.println("Consumer #" + this.number + " got: " + value); } Consumer

previous next 17 Synkronisering. Java. RMI.... public class CubbyHole { private int contents; private boolean available = false; public synchronized int get() { while (available == false) { try { wait(); } catch (InterruptedException e) { } } available = false; notifyAll(); return contents; } Delad resurs

previous next 18 Synkronisering. Java. RMI.... public synchronized void put(int value) { while (available == true) { try { wait(); } catch (InterruptedException e) { } } contents = value; available = true; notifyAll(); }

previous next 19 Synkronisering. Java. RMI. …”huvudprogram” public class ProducerConsumerTest { public static void main(String[] args) { CubbyHole c = new CubbyHole(); Producer p1 = new Producer(c, 1); Consumer c1 = new Consumer(c, 1); p1.start(); c1.start(); }

previous next 20 Synkronisering. Java. RMI. Semaforer En semafor är en mekanism för att erbjuda inbördes uteslutning Semaforer utvecklades först av E.W. Dijkstra under mitten av 60-talet En semafor är en delad heltalsvariabel som efter initieringen enbart kan accessas via signal och wait (eller motsvarande namn) –wait -metoden kontrollerar om heltalsvärdet är positivt och i så fall minskar den med ett annars sätta anropande process att vänta – signal -metoden kontrollerar om processer väntar på den i så fall får en av dem fortsätta annars ökas värdet av semaforen med ett Implementationsskiss –wait(): if s > 0 then s := s - 1 else suspend calling process –signal(): if processes are waiting then wake up process else s := s + 1

previous next 21 Synkronisering. Java. RMI. Semafor i Java class Semaphore implements Sync { protected long permits; // current number of available permits public Semaphore(long initialPermits) { permits = initialPermits; } public synchronized void release() { ++permits; notify(); }

previous next 22 Synkronisering. Java. RMI.... public void acquire() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); synchronized(this) { try { while (permits <= 0) wait(); --permits; } catch (InterruptedException ie) { notify(); throw ie; }

previous next 23 Synkronisering. Java. RMI....en metod med time out på väntandet public boolean attempt(long msecs)throws InterruptedException{ if (Thread.interrupted()) throw new InterruptedException(); synchronized(this) { if (permits > 0) { // Same as acquire but messier --permits; return true; } else if (msecs <= 0) // avoid timed wait if not needed return false; else { try { long startTime = System.currentTimeMillis(); long waitTime = msecs; Forts nästa sida

previous next 24 Synkronisering. Java. RMI.... for (;;) { wait(waitTime); if (permits > 0) { --permits; return true; } else { // Check for time-out long now = System.currentTimeMillis(); waitTime = msecs - (now - startTime); if (waitTime <= 0) return false; } catch(InterruptedException ie) { notify(); throw ie; }

previous next 25 Synkronisering. Java. RMI. Olika typer av semaforer, tex Blocked-Set –Signal väcker en godtycklig väntande process Blocked-Queue –Signal väcker i FIFO-ordning Blocked-Priority –Väcker den med högst prioritet (om lika i FIFO-rdning)

previous next 26 Synkronisering. Java. RMI. Exempel: bounded buffer med semafor class BufferArray { protected final Object[] array; // the elements protected int putPtr = 0; // circular indices protected int takePtr = 0; BufferArray(int n) { array = new Object[n]; } synchronized void insert(Object x) { // put mechanics array[putPtr] = x; putPtr = (putPtr + 1) % array.length; } synchronized Object extract() { // take mechanics Object x = array[takePtr]; array[takePtr] = null; takePtr = (takePtr + 1) % array.length; return x; }

previous next 27 Synkronisering. Java. RMI.... class BoundedBufferWithSemaphores { protected final BufferArray buff; protected final Semaphore putPermits; protected final Semaphore takePermits; public BoundedBufferWithSemaphores(int capacity) throws IllegalArgumentException { if (capacity <= 0) throw new IllegalArgumentException(); buff = new BufferArray(capacity); putPermits = new Semaphore(capacity); takePermits = new Semaphore(0); } public void put(Object x) throws InterruptedException { putPermits.acquire(); buff.insert(x); takePermits.release(); }

previous next 28 Synkronisering. Java. RMI.... public Object take() throws InterruptedException { takePermits.acquire(); Object x = buff.extract(); putPermits.release(); return x; } public Object poll(long msecs) throws InterruptedException { if (!takePermits.attempt(msecs)) return null; Object x = buff.extract(); putPermits.release(); return x; } public boolean offer(Object x, long msecs throws InterruptedException { if (!putPermits.attempt(msecs)) return false; buff.insert(x); takePermits.release(); return true; }

previous next 29 Synkronisering. Java. RMI. Channel class SynchronousChannel /* implements Channel */ { protected Object item = null; // to hold while in transit protected final Semaphore putPermit; protected final Semaphore takePermit; protected final Semaphore taken; public SynchronousChannel() { putPermit = new Semaphore(1); takePermit = new Semaphore(0); taken = new Semaphore(0); }

previous next 30 Synkronisering. Java. RMI.... public void put(Object x) throws InterruptedException { putPermit.acquire(); item = x; takePermit.release(); // Must wait until signalled by taker InterruptedException caught = null; for (;;) { try { taken.acquire(); break; } catch(InterruptedException ie) { caught = ie; } } if (caught != null) throw caught; // can now rethrow }

previous next 31 Synkronisering. Java. RMI.... public Object take() throws InterruptedException { takePermit.acquire(); Object x = item; item = null; putPermit.release(); taken.release(); return x; }

previous next 32 Synkronisering. Java. RMI. Prioritering av processer Vi kan definiera processer med olika prioritet –En process med högre prioritet går före en process med lägre prioritet Preemptive –Att processer med högre prioritet får exekvera före och kan avbryta processer med lägre prioritet kallas för ”preemptive” I Java kan en tråds prioritet sättas med setPriority(int newPriority) –där newPriority  [1, 10] se Suns tutorial för exempel

previous next 33 Synkronisering. Java. RMI. Prioritetsinvertering Problem: En process med lägre prioritet kan blockera en process med högre prioritet Orsak: En process med lägre prioritet, p low, kan ha fått tillgång till en resurs (icke preemptive tex fil eller skrivare) en process med lite högre prioritet, p medium, vill exekvera och får det samtidigt som en annan process, p high, vill exekvera och ha tillgång till resursen som, p low, håller. Dvs p high avbryter och väntar på samma resurs som p low har. Vilket resulterar att p medium får exekvera och p low kan inte släppa resursen Botemedel Vid blockering av p high så höjs prioriteten för den process som har resursen till p high :s prioritet p low p medium p high

next previous RMI, Remote Method Invocation Distribuerad programmering med Javas RMI

previous next 35 Synkronisering. Java. RMI. Remote Method Invocation, RMI Distributionspaketet RMI introducerades i Java 1.1 RMI gör det enkelt att dela på objekt mellan olika plattformar –objekt i en maskin kan transparent anropa objekt tillhörande andra maskiner –kompilerad kod kan flyttas och exekvera i olika virtuella maskiner RMI kräver dock att både klient och server kör Java

previous next 36 Synkronisering. Java. RMI. Vad behöver göras för att distribuera objekt? 1Skapa gränssnitt för objekt som skall kunna anropas av objekt på andra maskiner. –Detta gränssnitt (interface) används av både server och klient –interfacet skall utvidga java.rmi.Remote –varje metod i interfacet skall deklarera att det kastar java.rmi.RemoteException 2Vi behöver skapa en klient –Som använder objektet på servern 3Ett objekt som implementerar gränssnittet i steg 1 4En server som skapar en instans av det distribuerade objektet (som också implementerar samma gränssnitt som objektets representation hos klienten)

previous next 37 Synkronisering. Java. RMI. Hur representeras objektet hos server respektive klient? Hos servern skapas en vanlig instans som implementerar det distribuerade gränssnittet Då man (via namnservern) "ber om" en instans av det distribuerade objektet hos klienten skickas en stubbe från servern till klienten Hos klienten skapas en proxy som från klientens sida ser ut som om objektet befann sig på dess lokala maskin (dvs det ser ut som ett vanligt objekt som implementerar det givna "distributionsgränssnittet") Proxyn ansvarar för att på ett transparent sätt vidarebefordra meddelanden från klient till det riktiga objektet på servern samt att returnera resultatet tillbaks till anroparen –Dvs klienten skall inte kunna skilja ett meddelande till objektet på servern från ett meddelande till ett "vanligt" lokalt objekt

previous next 38 Synkronisering. Java. RMI. Transport av seriealiserat objekt från klient till server Ett litet exempel som visar hur vi kan konstruera en klass och ett objekt på klientsidan och skicka det till en server för exekvering Konstruktion av interface för objektet som skall implementeras på servern och anropas av klienten import java.rmi.*; interface HelloWithTransport extends Remote { public void sayHelloVia(HelloTransportInterface transportObject) throws java.rmi.RemoteException; } Interface för objekt som skall kunna transporteras import java.io.Serializable; interface HelloTransportInterface extends Serializable{ public void say(String saying); } Objekt som kan anropas av annan nod Objekt som kan anropas av annan nod Objekt som kan flyttas Objekt som kan flyttas

previous next 39 Synkronisering. Java. RMI. Konstruktion av Server... import java.rmi.*; import java.rmi.server.*; public class HelloServerTransport extends UnicastRemoteObject implements HelloWithTransport { public HelloServerTransport() throws RemoteException { super(); } public void sayHelloVia(HelloTransportInterface transportObject) throws RemoteException { transportObject.say("Hello Internetprogrammers (via transport)!"); } Subklassa UnicastRemoteObject och implementera det egna HelloWithTransport Subklassa UnicastRemoteObject och implementera det egna HelloWithTransport och metoden som definieras i HelloWithTransport som sen kommer användas av klienter och metoden som definieras i HelloWithTransport som sen kommer användas av klienter Superklassens konstruktör ser till att "vår" instans exporteras

previous next 40 Synkronisering. Java. RMI.... public static void main(String [] args) { if (System.getSecurityManager() == null) System.setSecurityManager(new RMISecurityManager()); try { HelloServerTransport h = new HelloServerTransport(); Naming.rebind(”//host/hellowithtransport", h); System.out.println("Hello with Callback Server ready."); } catch(RemoteException re) { System.out.println("RemoteException in HelloServerTransport.main: " + re); } catch(Exception e) { System.out.println("Exception in HelloServerTransport.main: " + e); }}} Skapa instans Ge "distribuerat" namn

previous next 41 Synkronisering. Java. RMI. Klient import java.rmi.*; import java.io.*; public class HelloClientWithTransport { public static class MyTransportObject implements HelloTransportInterface { public void say(String saying){ System.out.println("From the client: " + saying); } } public static void main(String [] args) { System.out.println("Client started"); if (System.getSecurityManager() == null) System.setSecurityManager(new RMISecurityManager()); try { HelloWithTransport h = (HelloWithTransport) Naming.lookup(”//host/hellowithtransport"); Skapa referens till servern

previous next 42 Synkronisering. Java. RMI.... //Transportera koden för ett objekt och exekvera hos servern. MyTransportObject transport = new MyTransportObject (); h.sayHelloVia(transport); } catch(Exception e) { System.out.println("Exception in HelloClientWithTransport.main: " + e); } }} Skapa instans (av klienten) Anropa metod hos servern med klienten som argument

previous next 43 Synkronisering. Java. RMI. Kompilera Kompilera båda interfacen, servern och klienten med javac, dvs >javac HelloWithTransport.java >javac HelloTransportInterface.java >javac HelloServerTransport.java >javac HelloClientWithTransport.java Kör också rmic på servern, dvs >rmic HelloServerTransport

previous next 44 Synkronisering. Java. RMI. Testkörning Vi kör exemplet på följande sätt (svar i kursivt): Starta namnserver >rmiregistry Starta server >java HelloServerTransport Hello with Callback Server ready. Starta klient >java HelloClientWithTransport Client started Iockmed att klienten startas kommer också följande skrivas på severns terminal: From the client: Hello Internetprogrammers (via transport)!

previous next 45 Synkronisering. Java. RMI. Definiera, kompilera och kör Kortfattat gör på följande sätt –Skapa interface –Kompilera interfacet med javac InterfaceNamn.java –Skapa server som instansierar serverobjekt och binder det till namnservern –Kompilera servern med javac ServerKlass.java –Kör rmic på serverklassen (så skapas stubbe och skelettklasser), dvs rmic ServerKlass –Skriv klient som refererar objekt i namnservern och skickar meddelanden till det –Kompilera klienten ( javac KlientKlass.java ) –Starta namnservern ( rmiregistry ) –Starta server ( java ServerKlass ) –Starta klint ( Java KlientKlass )

previous next 46 Synkronisering. Java. RMI. RMI mer beskrivningar och fler exempel Läs också gärna tutorialen som du hittar på följande adress: Läs också gärna tutorialen som du hittar på följande adress: Vi tittar också på dom tre exemplen på följande sida dvs följande: Transport av serialiserat objekt Calbackrutin Meddelandesystem Vi tittar också på dom tre exemplen på följande sida dvs följande: Transport av serialiserat objekt Calbackrutin Meddelandesystem