1. What happens when many clients want to contact the server at the same time ?
The iterative approach consist in “enqueuing” the requests (this is done automatically by the system) and serving them one by one :
Accept the next connection and build the socket
Read request
Process request (send the response)
This will inevitably mean that if there is a client with a small request (for example, a small file request) will have to wait until the large requests are over
If more than the allowed number of clients at socket queue request a service during this time they are rejected !!!
There may be also some delays in attending clients by waiting some information (client are asked to type in something)
There are many Disk I/O operations in a file serving scenario which are normally “slow”and do not require network traffic or CPU
So there is a lot of resources standing idle with this schema
NOTAS

2. The Concurrent Server
A concurrent server can attend many clients at the same time
While transferring a file, it can still keep listening for requests
Every time a request comes, a new parallel line of statements execution is started for attending this request. After this the server can “hear” again at the server socket for further requests
Different approaches have been developed to implement parallel lines of executions within a program
The operative system plays an important role
NOTAS

3. The Concurrent Server Algorithm
Master program of the server
1. Create a server socket
2. Wait for and accept a client’s request
3. Create a parallel line of execution to attend the requirement of the new client
4. Goto 2.
Slave (parallel) process :
1. Receive the parameters of the communication established by the master (socket or input/output data streams)
2. Attend client’s request (read filename, transfer data)
3. Return (disappear !)
NOTAS

4. Parallel Lines of execution
If there is only 1 CPU, why create parallel processes?
It often makes server programming easier.
Because there are more CPU involved !!!!!
The concept of parallel processes implemented at the S.O level appeared with UNIX and C.
In C a new process can be created by executing the fork() statement
int i = fork() creates an exact copy of the running process. Both continue executing the same program with the same variables.
For the “father” the value of i will be the id of the created process. For the child process this value will be 0
When programming concurrent servers the father will be the main process accepting requests and the child will process the client’s request
NOTAS

5. A simplified example of the use of for for implementing concurrent servers
main() {
int pid, msock, ssock;
msock = passivesock(port, “tcp”, qlen);
/* see chapter 10.4 from Internetworking with tcp/ip from Douglas Commer for the implementation */
while(1) {
ssock = accept(msock, &fsin, &alen);
pid = fork();
if (pid == 0) {
process client’s request;
return; }
NOTAS

6. Problems with fork() in UNIX
The creation of a new process is a time costly procedure
In some texts it is suggested to create a set of processes at the beginning which will be activated later by the main program. When a client arrives the parameters of the communication are passed vi pipes to child.
The new created process duplicates all the variables !!!
It is not easy to manage the processes which ended in an abnormal way. They keep the resources !!!.
Sometimes is preferred to use the “select” statement: it basically selects from an array of sockets the first one which has available data to read.
NOTAS

7. In JAVA is better to use Threads
A thread is a sequence or a flow of instructions which are executed in parallel to the main sequence of the program. It has a start and an end.
A thread can only be created and lives inside an already running process. A process can start as many threads as necessary.
Because of this, the main program has a better control of the threads it started. They can be created, started, suspended, or reactivated by the program.
Threads are implemented as methods of a certain class. When this method (normally called run) is activated, it starts to run in parallel to the method that called it.
As any other method, it can define its own set of variables
NOTAS

8. Using threads to implement concurrent servers
Main (master) program:
Create ServerSocket ss;
While(true) {
Socket s = ss.accept();
Create new thread with the socket s as parameter;
start executing thread; }
Define a thread class with a method called run which implements the processing of the clients request
NOTAS

9. Example import java.io.*; import java.net.*;
public class ArchServidor {
public static void main(String[] args) throws Exception {
Socket cs = null;
while(true) {
System.out.println("Waiting for a client ... ");
cs = ss.accept();
System.out.println(cs.getInetAddress()+" contacted ");
System.out.println(“Creating thread to serve request");
ServeFileThread t = new ServeFileThread(cs);
t.start(); }
NOTAS

10. Implementation of Threads
Define a new class which is an extension of the Thread class and overwrite its run() method.
Thread is an existing class
This thread class has a run method (originally with no statements) which will be executed in parallel when activated.
In order to execute this method a program must create an object of the extended class and apply the start() method to it.
The definition of the new Thread class should look like this:
public class MyThread extends Thread {
And somewhere should appear:
public void run() { //instructions to be executed in parallel }
NOTAS

11. Example public class ServeFileThread extends Thread { Socket s;
public ServeFileThread(Socket x) { s = x; }
public void run() {
BufferedReader inSocket = new BufferedReader( new InputStreamReader(cs.getInputStream()));
String fileName = inSocket.readLine();
FileInputStream inFile = new FileInputStream(fileName);
OutputStream outSocket = cs.getOutputStream();
System.out.println("sending file "+fileName);
int b;
byte ab[] = new byte[1024];
while ((b= inFile.read(ab,0,1024) ) != -1) {
outSocket.write(ab,0,b); }
outSocket.close(); inFile.close(); inSocket.close();
NOTAS

12. Sometimes you cannot program the server as an extension of a thread
For example, if the server has to implement a graphical interface it should be declared as an extension of a Frame, if it is programmed as an Applet it must extend the Applet class
The we can use the interface Runnable, which means the Server will also be seen as a Runnable class and has to implement the run method run().
To initiate a parallel execution of the run method a Thread object must be created. In the creation a pointer to the server object (this) should be passed as parameter. With this, the Thread object will have access to the run method.
The run method implemented in the server class will be executed by performing start() on the new created Thread object.
NOTAS

13. A number provider NoSyncronClient N++ NoSincronServer NoSyncronClient
Give Number
Ask number
N++
NoSincronServer
Give Number
Give Number
Ask Number
Ask number
NoSyncronClient
NoSyncronClient

14. Critical regions and semaphores in Java
Java provides basically two methods for controlling concurrent access to resources
You can declare a whole method as a critical region
Just put synchronized at the beginning of the method declaration
You can use the semaphore of any object
Create any object Object o = new Object()
Start the critical region with synchronized(o) {…….}
Another way to use semaphores in java is with wait() and notify()
NOTAS

15. Broadcasting a text to many clients
Hello
Hello
Hello
Hello
Hello
Hello

16. The server: receiving a new client
4444
Client contacts server at 4444

17. The server: receiving a new client
4444
A new socket is placed and the
output channel is opened
They are kept in an array

18. The server: Broadcasting a message
Type a message
When a message is entered
the server will distribute it to
the connected clients
BraodcastServerNF
BroadcastCliente

19. It is now easy to extend this to a chat system
Hello
Hello
Hello
Hello
Hello

20. Conditions for implementing a chat system
Server must be listening to requests of new clients AND to messages which are sent by already connected
Client must be listening to messages from the server AND to the keyboard for messages the user wants to transmit.
There are many approaches for implementing this in TCP/IP
No one is the “absolute correct” solution, all them have their advantages and drawbacks
Normally (like everywhere in computers) “faster” solutions will use more memory

21. Solution 1 The server: The client
A thread listens to new clients trying to join the chat party
When a new client connects, a PrintWriter and a BufferedReader for that client are created. The print Writer is kept in a global vector
A thread is created and receives a pointer to the PrintWriters’ vector and the BufferedReader. It reads the input from the client and writes it to all PrintWriters (clients)
The client
Graphical interface for reading lines from the keyboard (there is a thread which triggers the execution of the actionPerformed method) and sends it to the server
A thread will read input from the server and display it on a text area
See: Chat1Server.java, Chat1ClientThread.java & Chat1Client

22. Solution 1 Schema New Client Thread Client3 Client1 BufferedReader
PrintWriter

23. Solution 2 The server: The client
The server has only one thread listening at one port for attending all the requests of the clients.
The clients contact the server for registering (reg), sending a message (msg) or logging out (des)
The server keeps a PrintWiter vector to keep track about which clients participate in the chat party. Additionally, it keeps a vector with the nicknames of the clients
The client
Graphical interface for reading lines from the keyboard (there is a thread which triggers the execution of the actionPerformed method) and sends it to the server. It also shows the nicknames of the participants
A thread will read input from the server. This can be a message (msg) or a refreshment of the login list
See: CICChat.java & CICServer.java

24. Solution 2 Schema
New Client
Client1
Client2

25. Solution 2
Client3
Client1
Client2

26. Peer-to-peer solution for TCP/IP
Every program should be client and server at the same time
When a new member wants to join the party, he/she shoud contact anyone of the group and ask for the list of contacts
After retrieving the list of contacts (hostnames or addresses) he/she should open an input and output channel with everyone (including the one who provided the list)

27. Peer-to-peer solution: a user starts a chat party by listening on a port for others wanting to join

28. A user wanting to join contacts the initiator
A user wanting to join contacts the initiator. An InputStream and an OutputStream is opened on each

29. A third user may contact anyone and recover the list of participants, in this case each one has the address of the other in the list

30. Then contacts all of them opening Input/Output streams
Then contacts all of them opening Input/Output streams. All them now have two entries on their participant list

31. Particularities of this implementation
The program is written in the ChatPtP.java file
In order to allow testing in one computer, it is necessary to give the port number at which the program will listen for newcomers
java ChatPtP localport starts a new Chat party
java ChatPtP remotehost remoteport localport joins an existing party (on remotehost at remoteport a program is waiting for new members)
The is one thread for listening to newcomers
Another listens for input on keyboard and sends it to all connected participants
There is one thread listening for input for each of the other participants
Not very easy, isn’t it ?

32. Problems of this implementation
What happens if one user leaves the chat party ?
What happens if during the second connection phase (retrieving the list and contacting the participants) another newcomer joins the party by asking a third one for the list ?
This is a very critical problem which has been more or less addressed in some (sometimes hard to understand) papers.

33. A simple concurrent web server
First version: only to serve files (html and images) but it is easily extensible for attending different types of requirements
For each client a new thread is created
The filename of the request is not filtered in order to keep the program small
browser

34. Implementing state in a web server
The server must keep tracking of the different users that contact it
The client must submit this information
The Echo2 class keeps track of a “shopping cart” for different users
The client must submit a request like:
user=username&product=productcode&qtty=number