Multiplexing/Demux

CPSC Transport Layer 3-2 Multiplexing/demultiplexing application transport network link physical P1 application transport network link physical application transport network link physical P2 P3 P4 P1 host 1 host 2 host 3 = process= socket delivering received segments to correct socket Demultiplexing at rcv host: gathering data from multiple sockets, enveloping data with header (later used for demultiplexing) Multiplexing at send host:

CPSC Transport Layer 3-3 How demultiplexing works r host receives IP datagrams m each datagram has source IP address, destination IP address m each datagram carries 1 transport-layer segment m each segment has source, destination port number r host uses IP addresses & port numbers to direct segment to appropriate socket source port #dest port # 32 bits application data (message) other header fields TCP/UDP segment format

CPSC Transport Layer 3-4 Connectionless demultiplexing r Create sockets with port numbers: DatagramSocket mySocket1 = new DatagramSocket(12534); DatagramSocket mySocket2 = new DatagramSocket(12535); r UDP socket identified by two-tuple: ( dest IP address, dest port number) r When host receives UDP segment: m checks destination port number in segment m directs UDP segment to socket with that port number r IP datagrams with different source IP addresses and/or source port numbers directed to same socket

CPSC Transport Layer 3-5 Connectionless demux (cont) DatagramSocket serverSocket = new DatagramSocket(6428); Client IP:B P2 client IP: A P1 P3 server IP: C SP: 6428 DP: 9157 SP: 9157 DP: 6428 SP: 6428 DP: 5775 SP: 5775 DP: 6428 SP provides “return address”

CPSC Transport Layer 3-6 Connection-oriented demux r TCP socket identified by 4-tuple: m source IP address m source port number m dest IP address m dest port number r recv host uses all four values to direct segment to appropriate socket r Server host may support many simultaneous TCP sockets: m each socket identified by its own 4-tuple r Web servers have different sockets for each connecting client m non-persistent HTTP will have different socket for each request

CPSC Transport Layer 3-7 Connection-oriented demux (cont) Client IP:B P1 client IP: A P1P2P4 server IP: C SP: 9157 DP: 80 SP: 9157 DP: 80 P5P6P3 D-IP:C S-IP: A D-IP:C S-IP: B SP: 5775 DP: 80 D-IP:C S-IP: B

CPSC Transport Layer 3-8 Connection-oriented demux: Threaded Web Server Client IP:B P1 client IP: A P1P2 server IP: C SP: 9157 DP: 80 SP: 9157 DP: 80 P4 P3 D-IP:C S-IP: A D-IP:C S-IP: B SP: 5775 DP: 80 D-IP:C S-IP: B

Java Threads

Introduction r TCP echo server shown in earlier tutorial handles one client at a time. r This server is known as iterative server. r Iterative servers handle clients sequentially, finishing with one client before servicing the next. r Java threads: Helps servers handle many client simultaneously.

11 Threading Mechanisms  Create a class that extends the Thread class  Create a class that implements the Runnable interface Thread MyThread Runnable MyClass Thread (objects are threads) (objects with run() body) [a][b]

12 1st method: Extending Thread class r Create a class by extending Thread class and override run() method: class MyThread extends Thread { public void run() { // thread body of execution }  Create a thread: MyThread thr1 = new MyThread();  Start Execution of threads: thr1.start(); r Create and Execute: new MyThread().start();

13 Template class MyThread extends Thread { public void run() { System.out.println(" this thread is running... "); } class ThreadEx1 { public static void main(String [] args ) { MyThread t = new MyThread(); t.start(); }

14 2nd method: Threads by implementing Runnable interface r Create a class that implements the interface Runnable and override run() method: class MyThread implements Runnable {..... public void run() { // thread body of execution } r Creating Object: MyThread myObject = new MyThread(); r Creating Thread Object: Thread thr1 = new Thread( myObject ); r Start Execution: thr1.start();

15 Template class MyThread implements Runnable { public void run() { System.out.println(" this thread is running... "); } class ThreadEx2 { public static void main(String [] args ) { Thread t = new Thread(new MyThread()); t.start(); }

Example of Java Threads public class ThreadExample implements Runnable { private String greeting; public ThreadExample(String greeting) { this.greeting = greeting; } public void run( ) { while(true) { System.out.println(Thread.currentThread( ).getName( ) + ": "+greeting); try { TimeUnit.MILLISECONDS.sleep(((long) Math.random( ) * 100)); } catch(InterruptedException e) { } public static void main(String [ ] args) { new Thread(new ThreadExample(“Greeting 1")).start( ); new Thread(new ThreadExample(“Greeting 2")).start( ); new Thread(new ThreadExample(“Greeting 3")).start( ); } Each instance of ThreadExample contains own greeting string ThreadExample implements Runnable interface; it can be passed to the constructor of Thread Returns reference to current thread Returns name of thread as string Suspend the thread; Thread sleeps for random amount of time. 1.Create new instance of ThreadExample with different greeting 2.Passes new instance to the constructor of Thread. 3.Calls new Thread instance's start() Each thread independently executes run() of ThreadExample, while the main thread terminates. Upon execution an interleaving of three greeting messages is printed

Multithreaded Java Server import java.io.*; import java.net.*; public class MultiThreadServer implements Runnable { Socket csocket; MultiThreadServer(Socket csocket) { this.csocket = csocket; } public static void main(String args[]) throws Exception { ServerSocket ssock = new ServerSocket(1234); System.out.println("Listening"); while (true) { Socket sock = ssock.accept(); System.out.println("Connected"); new Thread(new MultiThreadServer(sock)).start(); } public void run() { try { PrintStream pstream = new PrintStream(csocket.getOutputStream()); for (int i = 100; i >= 0; i--) { pstream.println(i + " counts"); } pstream.close(); csocket.close(); } catch (IOException e) { System.out.println(e); }