Question

This question is related to Many processes executed by one thread and Socket server or file server implementation using multiple threads: concept not clear.

I am still unclear about a few things. Now the client and server of a socket server or a file server need not be in different machines(ofcourse it can be too).

The requests the servers receive are from different PROCESSES but they are processed by threads(say one per process) and these task threads belong to a different process(the server process). What I am confused about is how can calls from different processes be processed by threads of a single process and these threads communicate using ‘shared memory” architecture that is so “THREAD” and very unlike “PROCESSES”

Thanks

Answer 1

Some simple ground work. Your server process contains one or more threads to process requests from any number of client processes. The clients and server can be on either the same or different machines. Clients and server are “connected” by sockets which are used to send requests from the client to the server. The same socket will be used to provide a response to the client once the request has been processed. Each client will have a unique connection to the server.

There are many ways to implement a server as described above. One possibility is that the server has one thread which handles the sockets using select(). Lets call this the Main Thread. The server process will also have several threads that will be responsible for processing the requests and responding to the clients. Lets call these Worker Threads.

When the Main Thread receives a message from one of the its client’s sockets, the Main Thread will take this request and hand it to one of the Worker Threads for processing. The Worker Thread will take that request and process it and then respond using the original socket.

This server model uses a producer/consumer model where the Main Thread is the producer (in that it takes a request from the socket and produces a piece of work requiring processing) and the consumers are the Worker Threads.

There a several challenges in implementing this type of server all of which are documented and discussed in various Data Structure and Algorithms text, not the least of which are:

• How do the Main and Worker threads communicate?
• How do I protect data shared by the various threads from simultaneous modification?
• How do I select which Worker thread should process a request?

I hope this helps.