Multiplexing/Demux
Multiplexing/demultiplexing
Multiplexing at send host:
gathering data from multiple
sockets, enveloping data with
header (later used for
demultiplexing)
Demultiplexing at rcv host:
delivering received segments
to correct socket
= socket
application
transport
network
link
= process
P3
P1
P1
application
transport
network
P2
P4
application
transport
network
link
link
physical
host 1
physical
host 2
physical
host 3
CPSC 441 - Transport Layer
3-2
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 441 - Transport Layer
3-3
Connectionless demultiplexing
 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)
 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
CPSC 441 - Transport Layer
3-4
Connectionless demux (cont)
DatagramSocket serverSocket = new DatagramSocket(6428);
P2
SP: 6428
SP: 6428
DP: 9157
DP: 5775
SP: 9157
client
IP: A
P1
P1
P3
DP: 6428
SP: 5775
server
IP: C
DP: 6428
Client
IP:B
SP provides “return address”
CPSC 441 - Transport Layer
3-5
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 441 - Transport Layer
3-6
Connection-oriented demux
(cont)
P1
P4
P5
P2
P6
P1P3
SP: 5775
DP: 80
S-IP: B
D-IP:C
SP: 9157
client
IP: A
DP: 80
S-IP: A
D-IP:C
SP: 9157
server
IP: C
DP: 80
S-IP: B
D-IP:C
Client
IP:B
CPSC 441 - Transport Layer
3-7
Connection-oriented demux:
Threaded Web Server
P1
P2
P4
P1P3
SP: 5775
DP: 80
S-IP: B
D-IP:C
SP: 9157
client
IP: A
DP: 80
S-IP: A
D-IP:C
SP: 9157
server
IP: C
DP: 80
S-IP: B
D-IP:C
Client
IP:B
CPSC 441 - Transport Layer
3-8
Java Threads
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.
Threading Mechanisms
 Create a class that extends the Thread
class
 Create a class that implements the
Runnable interface
Thread
MyThread
(objects are threads)
[a]
11
Runnable
MyClass
(objects with run() body)
[b]
Thread
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();
12
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();
}
}
13
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();
14
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();
}
}
15
Example of Java Threads
ThreadExample implements Runnable
interface; it can be passed to the
public class ThreadExample implements Runnable {
constructor of Thread
private String greeting;
Each instance
public ThreadExample(String greeting) {
of
this.greeting = greeting;
Returns
ThreadExample
}
reference to
contains own
Returns
public void run( ) {
current thread
greeting
name of
while(true) {
string
thread as
System.out.println(Thread.currentThread( ).getName( ) + ": "+greeting);
string
try {
Suspend the
TimeUnit.MILLISECONDS.sleep(((long) Math.random( ) * 100));
thread; Thread
} catch(InterruptedException e) {
sleeps for random
}
amount of time.
}
1. Create new instance of
}
ThreadExample with different
public static void main(String [ ] args) {
greeting
new Thread(new ThreadExample(“Greeting 1")).start( );
2. Passes new instance to the
new Thread(new ThreadExample(“Greeting 2")).start( );
constructor of Thread.
new Thread(new ThreadExample(“Greeting 3")).start( );
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);
}
}
}