RMI - Remote Method Invocation SYSTEM SOFTWARE 1

Transcription

1 RMI - Remote Method Invocation SYSTEM SOFTWARE 1

2 RMI Motivation Architecture Implementation of Remote Objects Parameter Passing Callbacks RMI and Threads Distributed Garbage Collection Distribution and Class Loading Literature SYSTEM SOFTWARE 2

3 Motivation Normal method calls Based on object references within JVM client request server response client server Remote methods calls Method calls between objects in different JVMs Requires a remotereference request response request response JVM 1 JVM 2 SYSTEM SOFTWARE 3

4 Problems with Remote Method Invocations Object references What is a remote reference? How can one get a reference to an object in a different? Method calls How can the jump address of remote method be determined? Parameter passing and return values How are parameter passed and values returned from a remote method? Object creation How can one create an object in a remote JVM? Garbage collection When can a remote object be garbage collection? Class loading How and from where can the class of a remote object be loaded? SYSTEM SOFTWARE 4

5 RMI Motivation Architecture Implementation of Remote Objects Parameter Passing Callbacks RMI and Threads Distributed Garbage Collection Distribution and Class Loading Literature SYSTEM SOFTWARE 5

6 Proxy Pattern request() Client Subject interface interface the client sees and the server has to implement Subject implementation implements interface to provide functions Subject proxy used by client implements interface by delegating requests to real implementation SYSTEM SOFTWARE 6

7 Proxy Pattern in RMI Proxy server server_skeleton server_stub client request request response response JVM 2 JVM 1 Stub represents proxy for client Proxy sends requests over network to server Skeleton receives requests and forwards request to server implementation Server handles requests Results is sent back by skeleton Stub returns result to client SYSTEM SOFTWARE 7

8 Communication Architecture Client and server applications Stubs and skeletons Remote reference layer Network connection Network connection based on TCP/IP sockets JVM JVM JVM JVM SYSTEM SOFTWARE 8

9 Remote Object Registration and Lookup Registry service support Registration of remote objects with RMI-URL Lookup for remote objects Provided by RMI registration service utility rmiregistry RMI service classes Naming, Registry, and LocateRegistry SYSTEM SOFTWARE 9

10 Remote Object Registration and Lookup: Approach LocateRegistry: Access to registry service Registration: bind or rebind for registration of a remote object Must provide a unique id for the object. default port 1099, others allowed try { Bank bank = new BankImpl(); Registry reg = LocateRegistry.createRegistry(1099); reg.bind("bank", bank);... unique object name Remote object then is registered with unique RMI-URL rmi://<hostcomputer>:1099/bank Client can access remote object from server using unique name server and port // Client try { Registry reg = LocateRegistry.getRegistry("<Hostcomputer>", 1099); Bank bank = (Bank) reg.lookup("bank");... unique object name... SYSTEM SOFTWARE 10

11 RMI Motivation Architecture Implementation of Remote Objects Parameter Passing Callbacks RMI and Threads Distributed Garbage Collection Distribution and Class Loading Literature SYSTEM SOFTWARE 11

12 Implementation of Remote Objects Interfaces and classes Interface for remote object must extend interface java.rmi.remote declares public methods for remote object methods must be declared to throw RemoteException «Schnittstelle» java.rmi.remote «Schnittstelle» ServerSpec java.rmi.server.remotestub Server object implementation must implement interface must be exported to RMI system Stub (since Java 1.5 by dynamic proxy) implements Interface extends java.rmi.server.remotestub explicitly created by rmic compiler, or since Java 1.5 by dynamic proxy Skeleton (only used in Java 1.1) extends java.rmi.server.skeleton explicitly created by rmic compiler, or since Java 1.1 by dynamic proxy ServerImpl +() +changed() «Schnittstelle» java.rmi.server.skeleton ServerImpl_Skel ServerImpl_Stub since Java 1.5 also as Dynamic Proxy SYSTEM SOFTWARE 12

13 Example Bank Server The following example shows the implementation of a RMI The following steps are required Developing the application Definition of interfaces for remote objects Implementation of interface for server application Generation for stub and skeleton classes (can be omitted since Java 1.5) Implementation of server main program which creates and registers server object Implementation of client program which accesses remote object Start application Start of rmiregistry (not required since Java 1.5) Start of server program Start of client program SYSTEM SOFTWARE 13

14 Example Bank Server: Interface Bank Interface Bank defines methods for working with accounts package bank.common; import java.rmi.remote; import java.rmi.remoteexception; public interface Bank extends Remote { public static final int PORT = 1099; public long getbalance(int account) throws RemoteException; RemoteExceptions for all remote methods required! public void deposit(int account, long amount) throws RemoteException; public boolean transfer(int from, int to, long amount) throws RemoteException; SYSTEM SOFTWARE 14

15 Example Bank Server: BankImpl Class BankImpl implements interfaces should extend UnicastRemoteObject package bank.server; import java.rmi.remoteexception; import java.rmi.server.unicastremoteobject; import bank.common.bank; Extending UnicastRemoteObject! public class BankImpl extends UnicastRemoteObject implements Bank { private long[] accounts = new long[100]; Constructor with RemoteException! protected BankImpl() throws RemoteException { super(); public synchronized long getbalance(int account) throws RemoteException { return accounts[account]; public synchronized void deposit(int account, long amount) throws RemoteException { accounts[account] += amount; public synchronized boolean transfer(int from, int to, long amount) throws RemoteException { accounts[from] -= amount; accounts[to] += amount; return true; SYSTEM SOFTWARE 15

16 Example Bank Server: Stub and Skeleton Stub and skeleton classes are created by rmi-compiler program rmic > rmic keep BankImpl Or since 1.5 are created dynamically as dynamic proxies (see below) rmic <options> <class names> where <options> includes: -keep Do not delete intermediate generated source files -g Generate debugging info -depend Recompile out-of-date files recursively -nowarn Generate no warnings -verbose Output messages about what the compiler is doing -classpath <path> Specify where to find input source and class files -d <directory> Specify where to place generated class files -J<runtime flag> Pass argument to the java interpreter -v1.1 Create stubs/skeletons for JDK 1.1 stub protocol version -vcompat (default) Create stubs/skeletons compatible with both JDK 1.1 and Java 2 stub protocol versions -v1.2 Create stubs for Java 2 stub protocol version only public final class BankImpl_Stub extends java.rmi.server.remotestub implements Bank, java.rmi.remote {... public final class BankImpl_Skel implements java.rmi.server.skeleton {... SYSTEM SOFTWARE 16

17 Example Bank Server: Server Program Server program must create remote object implementation export it to RMI registry register it under unique URL package bank.server; import java.rmi.registry.locateregistry; import java.rmi.registry.registry; import bank.common.bank; public class BankServer { public BankServer() { try { Bank bank = new BankImpl(); Registry reg = LocateRegistry.createRegistry(Bank.PORT); reg.bind("bank", bank); catch (Exception e) { System.out.println("Trouble: " + e); public static void main(string args[]) { new BankServer(); SYSTEM SOFTWARE 17

18 Example Bank Server: Client Program Client program will retrieve remote object from RMI registry using URL call remote method (by calling methods of stub) catch exceptions package bank.client; import java.rmi.registry.locateregistry; import java.rmi.registry.registry; import bank.common.bank; public class BankClient { Name of server, e.g., "localhost" public static void main(string[] args) { try { Registry reg = LocateRegistry.getRegistry(" Server Adr ", Bank.PORT); Bank bank = (Bank) reg.lookup("bank"); bank.deposit(1, 10000); bank.deposit(2, 20000); boolean success = bank.transfer(1, 2, 3000); if (success) { System.out.println(bank.getBalance(1)); System.out.println(bank.getBalance(2)); else { catch (Exception e) { SYSTEM SOFTWARE 18

19 Exporting Remote Objects Remote objects must be exported to RMI system 2 possibilities Extending UnicastRemoteObject then export is done in constructor of this base class With static method exportobject of UnicastRemoteObject static Remote exportobject(remote obj, int port) throws RemoteException public class BankImpl implements Bank {... public class BankServer { private Bank bank; public BankServer() { try { bank = new BankImpl(); Registry reg = LocateRegistry.createRegistry(Registry.REGISTRY_PORT); Remote rstub = UnicastRemoteObject.exportObject(bank, Bank.PORT); reg.bind("bank", bank);... catch (Exception e) { System.out.println("Trouble: " + e); SYSTEM SOFTWARE 19

20 Unexporting Remote Objects Remote objects can be unexported from RMI (when no longer needed) with static method unexportobject of UnicastRemoteObject public static boolean unexportobject(remote obj, boolean force) throws java.rmi.nosuchobjectexception public class BankServer { private Bank bank; public start() { try { bank = new BankImpl(); Registry reg = LocateRegistry.createRegistry(PORT); RemoteStub bstub = UnicastRemoteObject.export(bank); reg.bind("bank", bstub); catch (Exception e) { System.out.println("Trouble: " + e); public static void main(string[] args) throws Exception { new BankServer().start(); // wait for termination UnicastRemoteObject.unexportObject(bank, true); SYSTEM SOFTWARE 20

21 RMI Excursion: Dynamic Proxy SYSTEM SOFTWARE 23

22 Excursion: Dynamic Proxy package java.lang.reflect Dynamic Proxy allows creating object which implements list of interfaces and delegates method calls to an InvocationHandler created by static method Proxy.newProxyInstance public class Proxy { public static Object newproxyinstance(classloader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException; Implemented interfaces InvocationHandler Application: Foo f = (Foo)Proxy.newProxyInstance(null, new Class[] {Foo.class, handler); Created proxy object now implements interfaces by calling invoke of InvocationHandler public interface InvocationHandler { Object invoke(object proxy, Method method, Object[] args) throws Throwable Reflection API SYSTEM SOFTWARE 24

23 Example Dynamic Proxy: TraceHandler (1/2) TraceHandler implements InvocationHandler prints out a trace message then calls real method class TraceHandler implements InvocationHandler { private Object target; private PrintStream tracelog; public TraceHandler(Object target, PrintStream tracelog) { this.target = target; this.tracelog = tracelog; public Object invoke(object proxy, Method m, Object[] args) throws Throwable { tracelog.print(target + "." + m.getname() + "("); if (args!= null) { for (int i = 0; i < args.length; i++) { tracelog.print(args[i]); if (i < args.length - 1) tracelog.print(", "); tracelog.println(")"); return m.invoke(target, args); Output of trace info Call of real method using reflection API SYSTEM SOFTWARE 25

24 Example Dynamic Proxy: TraceHandler (2/2) Test of Proxy for Integer values which implement Comparable interface Trace of compareto method of Comparable public class ProxyTest { public static void main(string[] args) { Object[] elements = new Object[1000]; // fill elements with proxies for the integers for (int i = 0; i < elements.length; i++) { Integer value = i + 1; Class[] interfaces = value.getclass().getinterfaces(); InvocationHandler handler = new TraceHandler(value, System.out); Object proxy = Proxy.newProxyInstance(null, interfaces, handler); elements[i] = proxy; Integer key = 547; // search for the key int result = Arrays.binarySearch(elements, key); // print match if found if (result >= 0) System.out.println(elements[result]); 500.compareTo(547) 750.compareTo(547) 625.compareTo(547) 562.compareTo(547) 531.compareTo(547) 546.compareTo(547) 554.compareTo(547) 550.compareTo(547) 548.compareTo(547) 547.compareTo(547) { Comparable.class SYSTEM SOFTWARE 26

25 RMI Motivation Architecture Implementation of Remote Objects Parameter Passing Callbacks RMI and Threads Distributed Garbage Collection Distribution and Class Loading Literature SYSTEM SOFTWARE 27

26 Parameter Passing and Return Values Must marshall and unmarshall parameters and return values for network transfer boolean success = bank.transfer(1, 2, 3000); marshall unmarshall :BankClient :Bank_Stub :Bank_Skeleton :Bank_Impl transfer(1,2,3000) transfer(1,2,3000) true 111 true JVM 1 unmarshall marshall JVM 1 SYSTEM SOFTWARE 28

27 Parameter Passing and Return Values Marshalling dependent on type of values Built-in data types (int, double, boolean, char etc.) are transferred as is in byte stream Serializable objects (implement interface Serializable) objects get serialized by internal serialization mechanism and on the other side a copy is created by deserializing it Remote objects (implement interface Remote) a stub is created at the client side all others (not serializable and not remote) cannot be used as parameters or return values in remote method calls Object serialization: see slides on InputOutput streaming SYSTEM SOFTWARE 29

28 Marshalling Serializable Objects Serializable objects implement interface Serializable object information and (non-transient) fields will be serialized public class AccountInfo implements Serializable { private final int id; private final String owner; private final long balance; public AccountInfo(int id, String owner, long balance) { public interface Bank extends Remote { public AccountInfo getaccountinfo(int accountnumber) throws RemoteException; Deserialize object from stream at client side public class BankClient { public static void main(string[] args) { try { AccountInfo info = bank.getaccountinfo(acc1.getid()); deserialized object SYSTEM SOFTWARE 30

29 Marshalling Serializable Objects Will serialize object into byte stream transfer byte stream deserialize and create new object from byte stream :BankClient :Bank_Stub :Bank_Skeleton :Bank_Impl Info info = getaccountinfo(id) getaccountinfo(id) :AccountInfo :AccountInfo Info info = getaccountinfo(id) deserialize serialize getaccountinfo(id) :AccountInfo :AccountInfo JVM 1 new object created JVM 1 SYSTEM SOFTWARE 31

30 Serializable / Not Serializable Data Types Serializable : built-in data types (int, boolean, double, ) arrays with serializable element type String Collections: ArrayList, LinkedList, TreeSet, Calendar, Date, etc. Example of not serializable types : Thread, ClassLoader, etc. Objects local to the VM InputStream, Socket, etc. Objects accessing os resources SYSTEM SOFTWARE 32

31 Marshalling Remote Objects Not the object values is transmitted but a remote reference is created by RMI system client server_stub server_skeleton server getremotemember() getremotemember() create() remote_stub remote_stub remote remote Remote-Reference to remote JVM 1 JVM 2 SYSTEM SOFTWARE 33

32 Extended Bank Example Remote objects Account Customer Bank with extended interface public interface Account extends Remote { public int getid() throws RemoteException; public Customer getcustomer() throws RemoteException; public long getbalance() throws RemoteException; public long withdraw(long amount) throws RemoteException; public void deposit(long diff) throws RemoteException; public interface Customer extends Remote { public String getname() throws RemoteException; public Account[] getaccounts() throws RemoteException; public interface Bank extends Remote { public Customer getcustomer(string name) throws RemoteException; public Customer createcustomer(string name) throws RemoteException; public Account getaccount(int accountnumber) throws RemoteException; public Account createaccount(string customer) throws RemoteException; public void transfer(int from, int to, long amount) throws RemoteException; methods return remote objects SYSTEM SOFTWARE 34

33 Extended Bank Example: BankImpl BankImpl stores sets of customers and accounts and provides access to customers and accounts public class BankImpl extends UnicastRemoteObject implements Bank { private static BankImpl instance; public synchronized static Bank getinstance() { if (instance == null) { try { instance = new BankImpl(); catch (RemoteException e) { return instance; private static int id = 0; private final Map<Integer, AccountImpl> accounts; private final Map<String, CustomerImpl> customers; private BankImpl() throws RemoteException { accounts = new HashMap<Integer, Account>(); customers = new HashMap<String, public synchronized Customer getcustomer(string name) throws RemoteException { return public synchronized Account getaccount(int id) throws RemoteException { return accounts.get(id);... SYSTEM SOFTWARE 35

34 Extended Bank Example: CustomerImpl public class CustomerImpl extends UnicastRemoteObject implements Customer { private final String name; final List<Account> accounts; protected CustomerImpl(String name) throws RemoteException { super(); this.name = name; this.accounts = new public String getname() throws RemoteException { return public synchronized Account[] getaccounts() throws RemoteException { return accounts.toarray(new Account[0]); SYSTEM SOFTWARE 36

35 Extended Bank Example: AccountImpl public class AccountImpl extends UnicastRemoteObject implements Account { private final int id; private final String customer; private long balance; public AccountImpl(int id, String customer) throws RemoteException { super(); this.id = id; this.customer = customer; balance = public int getid() throws RemoteException { return public Customer getcustomer() throws RemoteException { return public synchronized long getbalance() throws RemoteException { return balance; SYSTEM SOFTWARE 37

36 Extended Bank Example: Server Program Server program registers Bank as single access point public class BankServer { private static Bank bank; private static void start() throws Exception { bank = BankImpl.getInstance(); Registry reg = LocateRegistry.createRegistry(Registry.REGISTRY_PORT); reg.bind("bank", bank); System.out.println("Server started on port " + Registry.REGISTRY_PORT); public static void main(string[] args) throws Exception { start(); SYSTEM SOFTWARE 38

37 Extended Bank Example: Client Program Client program then retrieves Bank from RMI registry other remote objects, Customers and Accounts, are then retrieved from Bank public class BankClient { public static void main(string[] args) { try { Registry reg = LocateRegistry.getRegistry("localhost", Bank.PORT); Bank bank = (Bank) reg.lookup("bank"); Customer cust1 = bank.createcustomer("berger"); Customer cust2 = bank.createcustomer("maier"); retrieve Bank Account acc1 = bank.createaccount("berger"); Account acc2 = bank.createaccount("maier"); acc1.deposit(10000); acc2.deposit(20000); boolean success = bank.transfer(acc1.getid(), acc2.getid(), 3000); if (success) { System.out.println(acc1.getBalance()); System.out.println(acc2.getBalance()); else { System.out.println("Transfer not successful"); catch (Exception exc) { exc.printstacktrace(); Create and access remote objects Customer and Account from Bank SYSTEM SOFTWARE 39

38 Combining Serializable and Remote Objects When a Serializable object contains a remote object, the deserialized object will contain a Stub to the remote object public interface Customer extends Remote { public Account[] getaccounts() throws RemoteException; array Serializable, Account Remote public class BankClient { public static void main(string[] args) { try { Account[] accounts = customer.getaccounts(); array of stubs Note: Remote object reference in a Serializable object can be problematic public class RemoteAccountEvent extends EventObject implements Serializable { private final Account account; NOT A GOOD IDEA!! public RemoteAccountEvent(Account source) { Event object contains remote stub! super(source); SYSTEM SOFTWARE 40

39 == and equals for Serializable Objects == of serialized objects with every remote access a new object is created by deserialization public class BankClient_Equals { public static void main(string[] args) { try { Customer berger = bank.getcustomer("berger"); String name1 = berger.getname(); String name2 = berger.getname(); if (name1 == name2) { false!!! equals when Serializable object implements equals public class BankClient_Equals { public static void main(string[] args) { try { Customer berger = bank.getcustomer("berger"); String name1 = berger.getname(); String name2 = berger.getname(); if (name1.equals(name2)) { true!!! SYSTEM SOFTWARE 41

40 == and equals for Remote References == of remote references with every remote access an new stub is created Stub objects are not == public class BankClient_Equals { public static void main(string[] args) { try { Customer cust1 = bank.getcustomer("berger"); Customer cust2 = bank.getcustomer("berger"); if (cust1 == cust2) { false!!! equals of remote references Stub implements equals so that stubs of same remote objects are equals Stub objects are equals when stubs reference same remote object public class BankClient_Equals { public static void main(string[] args) { try { Customer cust1 = bank.getcustomer("berger"); Customer cust2 = bank.getcustomer("berger"); if (cust1.equals(cust2)) { true!!! SYSTEM SOFTWARE 42

41 == and equals for Remote References CustomerImpl implements equals has no effect on client public class CustomerImpl extends UnicastRemoteObject implements Customer {... public synchronized boolean equals(object obj) { if (obj instanceof CustomerImpl) { return name.equals((customerimpl) obj).name; return false; public class BankImpl extends UnicastRemoteObject implements Bank { Server... CarStore erzeugt immer neue CarImpl-Objekte public synchronized Customer getcustomer(string name) throws RemoteException { return new CustomerImpl(name); public class BankClient_Equals { public static void main(string[] args) { try { Customer berger1 = bank.getcustomer("berger"); Customer berger2 = bank.getcustomer("berger"); Diese Objekte werden am Client nicht als equals erkannt if (cust1.equals(cust2)) { new Customer objects with same name are created false, because equals of stub is used and not same remote object SYSTEM SOFTWARE 43

42 Remote References as Parameter public boolean transfer(account from, Account to, long amount) throws RemoteException; Remote reference as parameter problematic client retrieves remote object client hold stub object when using stub as parameter stub is sent back to server connection to original remote object lost better use ids as parameters client server_stub server_skeleton server remote_stub remote callwithref(remote_stub) returnref(remote_stub)?? Remote-Reference to remote_stub remote_stub JVM 1 JVM 2 SYSTEM SOFTWARE 44

43 Extended Bank Example: Bad transfer Method public interface Bank extends Remote { public boolean transfer(account from, Account to, long amount) throws RemoteException; Implementation of remote method public class BankImpl extends UnicastRemoteObject implements Bank public boolean transfer(account from, Account to, long amount) throws RemoteException { if (from == to) { return false; // does not work as expected!! will never become true if (! accounts.containsvalue(to)) { return false; // does not work as expected!! will always be true return transfer(from.getid(), to.getid(), amount); must work with ids anyway SYSTEM SOFTWARE 45

44 RMI Motivation Architecture Implementation of Remote Objects Parameter Passing Callbacks RMI and Threads Distributed Garbage Collection Distribution and Class Loading Literature SYSTEM SOFTWARE 46

45 Callbacks Callbacks are calls from server to client e.g., to send clients change notifications Role of client and server is changed client must provide a remote object server has a remote reference client implements Remote!! client server_stub server_skel server addchangelistener(client) addchangelistener(client_stub) client_skel Remote-Reference to client client_stub changed() JVM 1 JVM 2 SYSTEM SOFTWARE 47

46 Bank Example with Callback Remote listener interface for client public interface RemoteAccountListener extends Remote { public void accountchanged(remoteaccountevent e) throws RemoteException; Account gets add- and removeaccountlistener methods public interface Account extends Remote { public void addremoteaccountlistener(remoteaccountlistener l) throws RemoteException; public void removeremoteaccountlistener(remoteaccountlistener l) throws RemoteException; public class AccountImpl extends UnicastRemoteObject implements Account { private final List<RemoteAccountListener> listeners = public void addremoteaccountlistener(remoteaccountlistener l) throws RemoteException { public void removeremoteaccountlistener(remoteaccountlistener l) throws RemoteException listeners.remove(l); private void fireaccountchanged() { SYSTEM SOFTWARE 48

47 Bank Example with Callback Client has to create and register listener object public class BankClient_Callback { public static void main(string[] args) { try { acc1watcher = new AccountWatcher("Berger"); acc2watcher = new AccountWatcher( Maier"); acc1.addremoteaccountlistener(acc1watcher); acc2.addremoteaccountlistener(acc2watcher); add remote listeners acc1.deposit(10000); acc2.deposit(20000); boolean success = bank.transfer(acc1.getid(), acc2.getid(), 3000); catch (Exception e) { System.out.println("Trouble: " + e); finally { try { acc1.removeremoteaccountlistener(acc1watcher); catch (Exception e) { try { acc2.removeremoteaccountlistener(acc2watcher); catch (RemoteException e) { try { UnicastRemoteObject.unexportObject(acc1Watcher, true); catch (NoSuchObjectExce try { UnicastRemoteObject.unexportObject(acc2Watcher, true); catch (NoSuchObjectExcep private static class AccountWatcher extends UnicastRemoteObject implements RemoteAccountListener { DO NOT FORGET: remove listener and unexport from RMI Listener as remote object private final String name; public AccountWatcher(String name) throws RemoteException { public void accountchanged(remoteaccountevent e) throws RemoteException { SYSTEM SOFTWARE 49

48 RMI Motivation Architecture Implementation of Remote Objects Parameter Passing Callbacks RMI and Threads Distributed Garbage Collection Distribution and Class Loading Literature SYSTEM SOFTWARE 50

49 RMI and Threads Each request executed in its own thread client 1 client 2 request1() Server Thread request2() request3() Synchronisation required Synchronization of remote access operations required!! SYSTEM SOFTWARE 51

50 Bank Example: Synchronization E.g., by synchronization der remote methods public class BankImpl extends UnicastRemoteObject implements Bank public synchronized Customer getcustomer(string name) throws RemoteException { return customers.get(name); synchronized on public synchronized Customer createcustomer(string name) throws RemoteException public synchronized Account getaccount(int id) throws RemoteException public synchronized Account createaccount(string c) throws RemoteException {... public class AccountImpl extends UnicastRemoteObject implements Account { private final List<RemoteAccountListener> listeners; public AccountImpl(int id, String customer) throws RemoteException { this.listeners = new CopyOnWriteArrayList<>(); thread-safe listener list SYSTEM SOFTWARE 52

51 Problem: Long Running Processes Long running code blocks whole application public class BankImpl extends UnicastRemoteObject implements Bank {... public synchronized void makeannualbalance() { // long lasting activity... Long running code blocks other clients Solution: Long running code in background thread! SYSTEM SOFTWARE 53

52 Problem: Reentrancy Java locks are reentrant i.e., thread which holds lock can enter synchronized code of same lock public class BankImpl extends UnicastRemoteObject implements Bank public synchronized void transfer(int from, int to, long amount) throws RemoteException { Account afrom = getaccount(from); Account ato = getaccount(to); with lock to BankImpl public synchronized Account getaccount(int id) throws RemoteException { with lock to BankImpl SYSTEM SOFTWARE 54

53 Problem: Reentrancy When calling remote methods in callbacks, a different thread will execute second client request cannot enter synchronized code and application deadlocks client 1 Server callback() request1() request2() synchronized(this) synchronized(this) Deadlock because different threads SYSTEM SOFTWARE 55

54 Problem: Reentrancy Bank Example: Remote method call in callback public class BankClient extends UnicastRemoteObject { private static class AccountWatcher extends UnicastRemoteObject implements AccountListener { public void accountchanged(accountchangedevent evt) throws RemoteException { bank.getaccount()... ; public class BankImpl extends UnicastRemoteObject... Thread public synchronized void transfer(int from, int to, long am Account afrom = getaccount(from); Account ato = getaccount(to); ato.fireaccountchanged(); Thread public synchronized Account getaccount(int id) throws Remot SYSTEM SOFTWARE 56

55 Problem: Reentrancy Solution: Asynchronous Callbacks client Server callback() request2() request1() synchronized(this) can terminate Callback in asynchronous runnable, non blocking, not synchronized(this) synchronized(this) SYSTEM SOFTWARE 57

56 Problem: Reentrancy Bank Example: Asynchous execution of callback public class AccountImpl extends UnicastRemoteObject implements Account { private final ExecutorService executor = public void deposit(long diff) throws RemoteException { synchronized (this) { balance = balance + diff; fireaccountchangedevent(); First method can terminate private void fireaccountchanged() { final AccountChangedEvent evt = new AccoutChangedEvent( ); for (final AccountListener l : listeners) { executor.submit(() -> { l.accountchanged(evt); ); Do callback in asynchronous Runnable SYSTEM SOFTWARE 58

57 RMI Motivation Architecture Implementation of Remote Objects Parameter Passing Callbacks RMI and Threads Distributed Garbage Collection Distribution and Class Loading Literature SYSTEM SOFTWARE 59

58 Distributed Garbage Collection Normal garbage collector frees objects in VM which cannot be accessed any more Cannot function for remote objects Gargabe collector has no reference to remote object Distributed Garbage Collector works by: Reference Counting: the references of the remote object by clients are counted Lease Time: Does a client not access a remote object for some time the lease time it is allowed to collect the memory of the remote object Clients have to be aware that remote objects can disappear which lead to exceptions Lease Time: System property: java.rmi.dgc.leasevalue Default value 10 min Set as VM argument: java Djava.rmi.dgc.leaseValue=20000 SYSTEM SOFTWARE 60

59 RMI Motivation Architecture Implementation of Remote Objects Parameter Passing Callbacks RMI and Threads Distributed Garbage Collection Distribution and Class Loading Literature SYSTEM SOFTWARE 61

60 Distribution of Code and Class Loading Dynamic loading of classes in clients for stubs for parameter and return values Example: Stub Client Server client server_stub server_skeleton server getremotemember() getremotemember() create() remote_stub remote_stub remote remote Remote-Reference to remote JVM 1 JVM 2 SYSTEM SOFTWARE 62

61 Motivation Dynamic Class Loading public interface Bank extends Remote { public Customer getcustomer(string customername) throws RemoteException; PrivateCustomer Customer BusinessCustomer There are different subclasses of Customer! Client has to have code for those special classes! public class BankImpl extends UnicastRemoteObject implements Bank { public synchronized Customer getcustomer(string customername) throws RemoteException { if ( ) return privateclients.get(customername); else return businessclients.get(customername); Client: There has to be a way that client can load code as needed Concrete object of type PrivateCustomer_Stub or BusinessCustomer_Stub try { Customer customer = account.getcustomer(name); catch (RemoteException remoteexception) { System.err.println(remoteException); SYSTEM SOFTWARE 63

62 Dynamic Class Loading Code usually loaded from download folder of Web server To allow code to be loaded from an external site: a SecurityManager has to be installed program has to get permissions as follows Socket connection to server for RMI connection on port 1099 Socket connection for remote class loading from Web server on port 80 (or 8080) Example: Client program: public class MyClient { public static void main(string[] args) { System.setProperty("java.security.policy", "client.policy"); System.setSecurityManager(new SecurityManager());... Policy file for client: grant { permission java.net.socketpermission server-url: , connect ; permission java.net.socketpermission server-url:80, connect ; permission java.net.socketpermission server-url:8080, connect ; SYSTEM SOFTWARE 64

63 Distribution of Code Code divided in 3 parts server: all classes required for server program download: all classes eventually needed by client and possibly dynamically loaded by client including all dependent classes, e.g., base classes, interfaces client: classes to run the client the policy file (e.g., client.policy) 3 parts deployed then : server: computer running server application download: download folder of Web server client: computer running client application SYSTEM SOFTWARE 65

64 RMI Motivation Architecture Implementation of Remote Objects Parameter Passing Callbacks RMI and Threads Distributed Garbage Collection Distribution and Class Loading Literature SYSTEM SOFTWARE 66

65 Literature Horstmann, Cornell, Core Java 2, Volume II. Advance Features, Sun Microsystems, 2008: Chapter 5 Krüger, Handbuch der Java-Programmierung, 3. Auflage, Addison-Wesley, 2003, Kapitel 46 Fundamentals of RMI, Short Course, SYSTEM SOFTWARE 67