KR20040055920A - Multi-threaded socket polling server system - Google Patents

Abstract

PURPOSE: A server system for polling a multithread socket is provided to cover a weak point of a single thread model and offer a performance better than a simple multithread model by keeping the processing threads and dynamically assigning the socket generated when a connection is requested to the processing threads. CONSTITUTION: A server socket thread(10) assigns one client socket(20) to one connection request transmitted through the network. A socket pool(200) stores the client socket approved from the server socket thread. A thread pool(400) processes the multi-request of a client by having the threads(450-1¯450-n), and returns the client socket to the socket pool after each thread processes the request of the client socket having the data once. A polling thread(300) selects the client socket having the data from the socket pool depending on a registration order, and assigns the selected client socket to each thread.

Description

MULTI-THREADED SOCKET POLLING SERVER SYSTEM}

The present invention relates to a multithreaded socket polling server system, and more particularly to a multithreaded socket polling server system.

The performance of a high performance server system that needs to simultaneously handle connection requests from multiple clients delivered over a network is highly dependent on input and output (network communication). In other words, the CPU of a server system waits for 99.9% of its time idle while waiting for input from an external device (in the case of a socket server, from the network). The greater the bandwidth difference between clients, the worse it gets.

Among the methods that can be considered to handle client connection request in such server system, fork () function can be used to create an independent child process or to use thread to handle each client connection request. How to handle all client requests using a single thread and the socket's select () function (hereafter referred to as the "single thread socket polling model") There is this.

1 is a structural diagram of a simple multi-threaded model.

One client socket 20 is allocated for one connection request sent to the server socket thread 10 through the network, and the client socket 20 authorized from the server socket thread 10 is a thread pool. 30 is stored.

The threads 35-1, 35-2, 35-3,..., 35-n handle the transmission and reception of data originating from the assigned client socket 20, and each client socket 20 is a dedicated thread 35-n. 1, 35-2, 35-3, ..., 35-n, so the completed result is immediately sent to the clients 40-1, 40-2, 40-3, ..., 40-n.

This simple multithreaded model is simple to implement and provides fast processing for connection requests from any number of clients.

On the other hand, as the number of clients increases, the same number of threads must be created. In other words, as the number of connection requests increases, the number of processing processes or threads increases, causing the server system to put a heavy burden on the task switching time and virtual memory allocation. In the worst case, it may be inoperable. This problem can be avoided by using a thread pool to control the maximum number of processes or threads.

However, a fundamental problem with the multithreaded model is that the processing thread takes up resources and idles until no data is sent from the client, which wastes resources on the server system.

2 is a structural diagram of a single threaded socket polling model.

One client socket 20 is allocated for one connection request sent to the server socket thread 10 through the network, and the client socket 20 authorized from the server socket thread 10 is a socket pool. Stored at 50.

The single processing thread 60 handles the transmission and reception of data generated from the allocated client socket 20. The polling process selects the client sockets 20 having the data in order, processes the request, and then processes the socket pool ( Return to 50).

This single-threaded socket polling model only increases the memory space for client sockets, which is much less expensive than threads, and is not significantly affected by the increase in the number of client connections. In other words, because it uses a single thread, thread management is simple and it can accept connection requests from multiple clients.

However, as the number of clients requesting a connection increases, the waiting time for each socket for the connection request is actually processed. This is a problem that occurs because the processing thread processes the sockets in the order in which they are requested. Latency is very dependent on the amount of data sent and received between client and server. Therefore, before implementing a single-threaded socket polling server, consideration of the amount of data sent and received should be preceded first.

Also, the design and implementation of the server using the select () function is more difficult and complex than the implementation of a simple multithreaded model using multiple processes or multiple threads using the fork () function.

The present invention has been proposed to solve the above-mentioned problems of the prior art, and maintains a plurality of processing threads and dynamically allocates the sockets generated at the time of a connection request to these processing threads to compensate for the shortcomings of the single-threaded model. The goal is to provide a multithreaded socket polling model that has better performance than a simple multithreaded model.

The multi-threaded socket polling server system according to the present invention for realizing the above object includes a server socket thread for allocating one client socket for one connection request transmitted through a network, and the server socket thread authorized from the server socket thread. A socket pool for storing client sockets and a plurality of threads to handle multiple requests of the client, each of which processes only one request of the client socket with data, and returns the client socket to the socket pool after processing And a polling thread that selects the client sockets having data from the socket pool in order of registration and assigns them to each thread of the thread pool.

1 is a structural diagram of a multi-threaded model according to the prior art,

2 is a structural diagram of a single threaded socket polling model according to the prior art;

3 is a structural diagram of a multi-threaded socket polling model according to the present invention;

4 is a graph showing a result of measuring performance while varying the number of client connection requests for two conventional models and the present invention model;

5 is a graph showing a result of measuring performance while varying the size (length) of a message transmitted for two conventional models and a model of the present invention;

FIG. 6 is a graph illustrating a result of measuring performance according to a change in thread pool capacity for a conventional multithreaded model and a multithreaded socket polling model of the present invention; FIG.

There may be a plurality of embodiments of the present invention. Hereinafter, preferred embodiments will be described in detail with reference to the accompanying drawings. This embodiment allows for a better understanding of the objects, features and advantages of the present invention.

The multi-threaded socket polling model according to the present invention takes advantage of the conventional simple multi-threaded model and the single-threaded socket polling model, which prevents thread overhead and resource waste of the server system, and is not affected by the number of network connections. You can control the size of the thread pool to meet your limited resource requirements.

3 is a structural diagram of a multi-threaded socket polling model according to the present invention.

The client socket 20 authorized from the server socket thread 10 is stored in the socket pool 200, and the polling thread 300 receives the client socket 20 having data from the socket pool 200. Select and assign to each thread (450-1, 450-2, 450-3, ..., 450-n) of the thread pool (400). The thread pool 400 handles multiple requests from clients. That is, each of the threads 450-1, 450-2, 450-3,..., 450-n processes the request of the client socket 20 having data only once, and immediately after the processing is completed, the corresponding client into the socket pool 200. Return the socket 20. As such, the remaining sockets are selected, allocated, and returned in the order in which they were registered.

The multithreaded socket polling model of the present invention is not affected by the number of connections as in the conventional single threaded model, and can handle multiple requests as in the conventional simple multithreaded model. In addition, by adjusting the capacity of the thread pool 400 it is possible to control the usage of server resources.

The socket buffer 350 in the polling thread 300 is used when all of the threads 450-1, 450-2, 450-3,..., 450-n in the thread pool 400 are all in use. Polling thread 300 is prevented from being idle. That is, even when each of the threads 450-1, 450-2, 450-3,..., 450-n in the thread pool 400 is in use, the polling thread 300 uses the socket buffer 350 to make a thread. Securing a sufficient number of client sockets 20 to supply the pool 400 can continue without stopping.

The select () function, on the other hand, is usually implemented using input / output (I / O) interrupts from the network device driver. On most UNIX computers, select () is provided as a system call. Since Java development tool 1.3 did not provide asynchronous I / O, select () was not provided in Java. As of Java development tool 1.4, this problem has been solved by providing this asynchronous I / O in the java.nio package. However, many Java applications are still built on Java development tool 1.3, so if you want to use polling, you need to implement the select () function.

Although the select () function is not provided in Java Development Tools 1.3 to implement socket polling, you can implement some combination of functions. In the Java language, InputStreams play a similar role as file descriptors in the C / C ++ language. All data transmitted from external devices, including network devices, is transmitted here. The input stream is provided with a function called available () that tells the amount of data that can be read at a time, in bytes, without disturbing the current flow of execution. If there is no data to read, 0 is returned. Otherwise, the size of the non-zero data is returned. You can use this feature to implement select ()-like functionality.

Hereinafter, by presenting a simulation result comparing the performance of the two conventional models and the present invention model, the multi-threaded socket polling model according to the present invention shows similar or better performance than the simple multi-threaded model despite the complicated structure. Demonstrates that it can handle more client requests than the capacity of the pool.

For each of the two models and the present invention, the experiment is performed by varying the number of clients, the length of the message, and the capacity of the thread pool.

4 is a graph of execution time (log values) according to the change in the number of clients of the two conventional models and the present invention model, a is a conventional simple multithreaded model, b is a conventional single threaded socket polling model, and c is the present invention. Multithreaded socket polling model.

Single-threaded socket polling produced the best results when the number of clients was 1, but the rest of the experiments performed worse than the other two cases. The simple multithreaded model and the multi-socket polling model showed similar results, but the multi-socket polling model showed slightly better results when comparing the measured data.

FIG. 5 is a graph showing a result of measuring execution time (log value) according to a change in message size (length) between two conventional models and the present invention model, where a is a conventional simple multithreaded model, and b is a conventional single threaded socket polling model. c is a multithreaded socket polling model of the present invention. The experiment changed to 512, 1024, 2048, and 4096 characters, but did not affect the performance of the three models.

6 is a graph showing the average thread usage and execution time according to the thread pool capacity change of the multi-threaded socket polling model according to the present invention. A is a result of fixing and measuring the thread pool capacity of the simple multi-threaded model to 100 for comparison. C is a measurement result of the multi-threaded socket polling model according to the present invention, and d is an average thread pool usage.

In Figure 6, the average thread usage shows a result almost similar to the capacity of the corresponding thread pool. This tells us that we are using resources allocated efficiently by running out of thread pool capacity.

It is important to note that the multithreaded socket polling model (c) shows almost the same or better results than the simple multithreaded model (a) from the point where the thread pool has a capacity of 20. The experimental results show that the multithreaded socket polling model with a thread pool capacity of 30 shows the same performance as the simple multithreaded model with a thread pool capacity of 100.

In the above description, but limited to one embodiment of the present invention, it is obvious that the technology of the present invention can be easily modified by those skilled in the art. Such modified embodiments should be included in the technical spirit described in the claims of the present invention.

As described above, the present invention maintains a plurality of processing threads and allocates the sockets generated at the time of a connection request to these processing threads to perform a task, so that even if a large number of connection requests from clients are required, there is no need to wait for socket processing. The server system can be more efficient because it can handle more client requests than the thread pool.

Claims (2)

A server socket thread that allocates one client socket for one connection request sent over the network; A socket pool for storing the client socket authorized from the server socket thread; A thread pool that handles multiple requests of a client by holding a plurality of threads, each thread processing a request of the client socket having data only once and returning the corresponding client socket to the socket pool after processing; And a polling thread that selects the client sockets having data from the socket pool in a registered order and assigns them to each thread of the thread pool. The method of claim 1, And the polling thread comprises a socket buffer for temporarily storing the client socket selected from the socket pool when all the threads in the thread pool are in use.