1. Multiplexing/Demux

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

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

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

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
DP: 5775
SP: 5775
SP provides “return address”
CPSC Transport Layer

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

7. Connection-oriented demux (cont)P1
client
IP: A P4 P5 P6 P2 P1 P3
SP: 5775
DP: 80
S-IP: B
D-IP:C
SP: 9157
SP: 9157
DP: 80
DP: 80
Client
IP:B
server
IP: C
S-IP: A
S-IP: B
D-IP:C
D-IP:C
CPSC Transport Layer

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

9. Java Threads

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

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

12. 1st method: Extending Thread class
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();
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
Create a class that implements the interface Runnable and override run() method:
class MyThread implements Runnable {
.....
public void run()
// thread body of execution }
Creating Object:
MyThread myObject = new MyThread();
Creating Thread Object:
Thread thr1 = new Thread( myObject );
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();

16. Example of Java Threads
ThreadExample implements Runnable interface; it can be passed to the constructor of Thread
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
Returns reference to current thread
Returns name of thread as string
Suspend the thread; Thread sleeps for random amount of time.
Create new instance of ThreadExample with different greeting
Passes new instance to the constructor of Thread.
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

17. 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);