KR20080059934A - A thread management method and system of the server using non-blocking input and output - Google Patents

Abstract

A method and a system for managing threads in a server using non-blocking I/O(Input/Output) are provided to improve server access/response times for a client request by changing the user thread into a waiting state promptly executed again in response to the client request without blocking the thread from transmitting data to a client or receiving the data from the client. A server(100) processes a request of clients(200-20n) through a communication agent(120) using a thread pool(110) and non-blocking I/O. The thread pool stores the prepared threads(112-114) in a thread repository(111) having a stack structure and removes the unnecessary thread through a thread manager(115). The communication agent includes a connector(122) and a connection processor(121) using the non-blocking I/O. The connector receives first connection of the client, and the connection processor transfers the client request to the thread pool by generating client information or transmitting data received from the client to the thread pool when the client is connected. A connector repository(123) transfers client connection between the connector and the connection processor. A selector(130) selects the threads suitable for a job requested from the client.

Description

A thread management method and system of the server using non-blocking input and output}

1 is a system configuration according to a preferred embodiment of the present invention.

2 is a flowchart of a process of a client connecting to a server.

3 is a flowchart illustrating a process in which a client requests a job from a server.

4 is a flow diagram of a process for processing a client request sent to a thread pool in accordance with the present invention.

4A is a flowchart illustrating a step S_322 of creating a thread.

4B is a flow diagram illustrating a step in which a thread performs a task in accordance with a client's work request.

5 is a flowchart illustrating a process in which a client terminates connection.

6 is a flowchart illustrating a process of managing threads in a thread pool.

** Explanation of symbols for main parts of drawings **

100 ... server 200, 201, 202, 20n ... client

110 ... Thread Manager 112, 113, 114 ... Threads

120 Communication Agent 121 Connection Processing Unit

122 ... Connection 123 ... Connection storage

130 ... Selector 300 ... Internet

The present invention relates to a thread management method of a server performing a client's work request in a thread server system. More specifically, a thread used for a client's request (connection, execution) in a thread server environment is again used. The present invention relates to a method of improving the connection time and response time of a server for a client request by switching to a wait state that can be executed immediately for the client request.

The Internet has become so popular that many people use it every day for personal entertainment purposes, business purposes, or both. As customers of electronic information and business services, people now have easy access to sources on a global scale. Can be. When a user interacts with a software application and requests content over the Internet, the delay or inefficiency of the return response can have a very negative impact on the user's satisfaction and even cause the user to move to another source. . Therefore, the delivery of requested content quickly and efficiently is very important for user satisfaction, and therefore, it is important to ensure that the system on the server side of the network operates as efficiently as possible.

In other words, as the number of services increases and the number of users increases, the previous server performance cannot satisfy the system requirements. Therefore, stable and improved performance is required in the same hardware specification.

Conventionally, whenever a client connects to a server, a thread is processed to process a client's request in real time, but the connection is processed. However, when a large number of clients are connected at the same time because they use a lot of time and resources to create a thread in real time Normal operation was not possible.

To solve this problem, a thread pool model was developed.

Thread pools allow you to create multiple threads in advance and use them one at a time when needed.

Since the server in the thread pool environment communicates between the client and the server by using blocking i / o, a thread may be blocked while the server receives or sends data to the client. It could not handle a large number of client requests smoothly.

In the blocking input / output method, a thread used for a client's request is excluded from memory, and the thread must be waited for the excluded thread to be activated again for the client's request. It takes a lot of time and resources to be reloaded and converted to a standby state, which results in a long connection time and response time for a client request.

Accordingly, an object of the present invention is to solve the above problem, and to improve the connection speed and response speed when a client accesses a server in a thread server environment.

In order to achieve the above object, the present invention maintains a thread used in a client in a non-blocking state so that the thread can receive data from the client or send data to the client. This allows you to keep waiting until you can do the rest.

The present invention relates to a method of connecting a server and a client in a network. More specifically, a thread used for a client's request (connection, execution) in a thread server environment can be executed immediately for the client's request. The present invention relates to a method of improving the connection time and response time of a server for a client request by allowing a transition to a wait.

Hereinafter, the present invention will be described in detail.

In a threaded server environment, when a client connects to the server, the server authenticates the connection and stores the connection for the authenticated connection in the connection store.

If there is a connection stored in the above, the connection is registered with the selector and the connection completion is transmitted to the client.

The server waits until there is a connection capable of reading data sent by the client according to the client's work request, and loads the data sent by the client by obtaining a connection capable of reading data.

You may not be able to load all the data at once, so repeat until you have loaded all the data.

Loading all the above data pulls a thread from the thread pool.

If no thread can be loaded from the thread pool, a new thread is created and used as far as possible.

Allows the client to perform the requested task on the loaded thread.

When the loaded thread performs all the tasks requested by the client, the result of the operation is sent to the client, and the thread is waited and stored in the thread pool again.

When the client sends a connection termination request to the server, the server releases the registration for the connection between the client and the server that made the connection termination request at the selector.

In the present invention, the thread pool model is used.

The structure of the thread pool uses a double ended queue (DEQUE), which is in the form of a linear list (stack) where insertions and deletions are allowed at both ends of the list.

In the linear list queue, one end is used for threads upon client's request, and the other end is used for thread management, which limits the number of threads.

For example, if a thread is required at the request of a client, the thread is loaded from the far left of the linear list of thread pools, and the used thread is loaded from the far left. In this case, the far right of the linear list may be rarely used without a client's request. Therefore, by checking the time when the rightmost thread is used among the threads in the linear list, destroying the unused thread after a certain time has elapsed can reduce server resources.

Reusing threads that were last used by acting like a linear list, or stack, is faster because a recently used thread can be run again.

In the present invention, since the thread pool is used as a stack, the bottommost (= rightmost) thread can be inspected to know when the thread is used.

Therefore, the lowest thread is loaded one by one and the thread is deleted if it has not been used for more than the specified time.

In the above, the linear list is generally a structure having a shape extending in the horizontal direction, and the stack is a structure having a shape formed up and down. In this linear list or stack structure, it is common sense that the stacking method is loaded from right to left and bottom to top, respectively, so the rightmost thread is not used frequently in the linear list, and the lowest thread is used in the stack. Not often used Therefore, the part described as a linear list should check the rightmost thread, and the stack must check the lowest thread.

When there are not many threads to be loaded from the thread pool due to the large number of client connections, it is preferable to create a new thread to execute the client's request, but the number of threads that can be created in the thread pool is greater than a certain number. It is preferable to limit.

If you keep creating as many threads as you need, you can increase the context exchange time for each thread and affect the service.

In the present invention, the used thread is not blocked.

In other words, non-blocking the threads used in the thread pool server environment so that the threads are not blocked at the time of read / write and load the threads immediately according to the client's work request. can do.

The above thread separates the thread that accepts the client's connection from the thread that receives the client's data for immediate connection processing.

In addition, the above thread can separate the receiving part of the client data, so that one client connection can use the thread pool only when necessary without requesting the continuous use of one thread, thereby reducing the number of run threads. .

The selector detects an I / O event (connect, accept, read, write) occurring in a network connection between the registered server and the client, and informs the network connection between the server and the client where an immediate I / O event occurs.

Since the connection can be immediately processed by the selector, it is possible to eliminate the blocking until the previous read / write operation is possible.

In the above, registering with the selector means that the selector can detect the I / O event of the connection.

In the present invention, since the data sent from the client to the server is all received in one thread using non-blocking i / o, instead of the method in which one thread was continuously used for a conventional client connection, For a task requested by a client, a thread is taken from the thread pool, used, and returned to the thread pool.

Creating a thread in a threaded environment consumes a lot of resources, but the thread stored in the thread pool of the present invention is a wait state rather than a run during the time a client receives data sent to the server. Rather than creating a thread at the same time as the connection, you can reduce the response, or response, by creating and using the thread in advance.

Hereinafter, the present invention will be described in detail with reference to the accompanying drawings.

1 is a system configuration according to a preferred embodiment of the present invention.

The server 100 processes a request of the client 200 through the Internet 300 through the communication agent 120 using the thread pool 110 and non-blocking input / output (non blocking i / o).

The thread pool 110 contains threads 112, 113, and 114 prepared in advance in the stack storage 111 having a stack structure, and removes unnecessary threads through the thread manager 115.

The communication agent 120 has a connection unit 122 and a connection processing unit 121 using non-blocking input / output (non blocking i / o). The connection unit 122 serves to accept a client's first connection, and the connection processing unit 121 generates client information or receives data sent by the client when the client connects, and transmits a client's request to the thread pool 110. Play a role. Client connection transfer between the connection unit 122 and the connection processing unit 121 is through the connection storage 123.

The selector 130 detects an I / O event (connect, accept, read, write) occurring in a network connection between the registered server and the client, and informs the network connection between the server and the client where an immediate I / O event occurs. In this case, the threads 112, 113, and 114 suitable for the work request of the client 300 are selected.

2 is a flowchart of a process of a client connecting to a server.

Requesting connection by the client 300 (S_100);

Accepting the connection at the connection unit 122 of the server 100 (S_110);

Storing the connection with the client 200 which has accepted the connection in a connection storage 123 of a server (S_120);

Transmitting the wake-up message to the connection processing unit 121 after storing the connection storage 123 (S_130);

When the wake-up message is received, obtaining a connection with the client 200 from the connection storage 123 of the server 100 and checking whether the number of allowed connections is exceeded (S_130);

Registering the connection with the client in the selector 130 if the number of connections is not exceeded (S_140);

If the connection is registered, processing connection completion and transmitting a connection success to the client 200 (S_150);

Terminating the connection with the client if the number of connections is exceeded in step S_140 and transmitting a failure to the connection (S_160);

Is made of.

Next, the steps for requesting a task from the connected client to the server will be described in a flowchart.

3 is a flowchart illustrating a process in which a client requests a job from a server.

Requesting a job from the client 200 to the server 100 (S_200);

Loading a client connection ready to load data according to a work request of the client when it is confirmed that there is a client connection capable of reading data from the selector 130 of the server 200 (S_210);

Loading the connection and loading data sent by the client (S_220);

Confirming whether all data is loaded in the client (S_230);

Requesting to perform a task to a thread pool when all data sent by the client is loaded (S_240);

Is made of.

The job is processed according to the request, and the process of processing the job will be described with reference to FIG. 4.

4 is a flowchart illustrating a process of processing a client request delivered to a thread pool according to the present invention.

Receiving a task execution request of the client in the thread pool (110) of the server (S_300);

Checking whether there is a thread available for the work execution request (S_310);

If there are no available threads, comparing the number of current threads with the number of allowed threads (S_320);

Generating new threads by a predetermined number not exceeding the allowed number of threads, if the additional threads can be created (S_321);

Executing the created thread in an operating state (S_325);

Switching the executed thread to a standby state and storing the executed thread in a thread storage 111 of a thread pool (S_326);

Generating a message indicating that the client's request cannot be processed (S_330) if the thread cannot be created further (S_331);

Requesting a thread from the thread storage 111 if there is a thread available in the above (S_340);

Transferring a job to be processed to a thread loaded by the request (S_350);

Delivering a wake-up message to the thread (S_360);

The thread performing a task requested by the client (S_370);

Transmitting a result of the thread performing a task to a client (S_380);

Storing the thread on which the operation is performed in the thread storage 111 of the thread pool (S_390);

Is made of.

In the present invention, when the server is first started, threads cannot be created indefinitely.

Running the created thread in the operating state causes the thread to be ready when the thread is created. Therefore, the thread must be executed to run the thread, and then switch back to the wait state and store it in the thread pool of the thread pool so that the requested thread can immediately execute the client's work request.

A step (S_322) of generating the thread in the above process will be described with reference to FIG. 4A.

Checking whether a predetermined number of threads can be created (S_322);

If it is not possible to create a predetermined number of threads, modifying the maximum number of threads that can be created (S_323);

Generating a predetermined number of threads if a predetermined number of threads can be created, and generating a modified number of threads if a predetermined number of threads cannot be generated (S_324);

Is made of.

In the above process, the step (S_370) in which the thread performs the work according to the work request of the client will be described with reference to FIG. 4B.

The thread for processing the work request of the client checks the wake-up message (S_371);

performing a work according to a work request of a client when receiving a wake-up message (S_372);

Storing the time used for the thread and transitioning the thread to a standby state (S_373);

Is made of.

If there is no thread to use above, you should create a new thread. If you run out of threads, create one each time. Therefore, it creates a certain number at a time. It is preferred that the above constant number be adjusted by one skilled in the art.

The thread is waiting for the task to be processed in a wait state, so the task can be processed by changing the state to a run state with a wake-up message.

The last time used (= idle time) is saved because the thread that has not been used for a certain time must be deleted during the thread management process.

As described above, even if the client connection is ready for loading on the non-blocking i / o of the present invention, it may not be able to load all the data. Should be determined.

5 is a flowchart illustrating a process of terminating connection by a client.

Requesting, by the client, to terminate the connection to the server (S_400);

Receiving a connection termination request of the client at a server (S_410);

Receiving a connection termination request from the server, deregistering and terminating the connection of the client requesting the termination from the selector (130) (S_420);

Is made of.

In the present invention, even if the connection between the server and the client is terminated, the selector 130 continues to manage. Therefore, it is necessary to unregister the terminated client connection.

Threads that have not been used for a certain amount of time should be deleted from the thread pool to prevent server overload and to manage resources efficiently. 6 is a flowchart illustrating a process of managing threads in a thread pool.

Checking whether a predetermined time has elapsed (S_500);

If the specified time has elapsed, checking each thread from the rightmost thread in the stack of the thread pool (S_510);

Determining whether the thread can be loaded in the check (S_520);

Determining whether the thread idle time is greater than a set timeout time when the thread can be loaded (S_530);

Terminating and deleting the thread if it is older than the timeout time in the determination (S_540);

If the thread cannot be loaded or is older than the timeout time, go to step S_500 and wait until the next check time.

In the above, the idle time means a time when a thread is finally used according to a client's request.

The above process is executed by the thread pool manager 115 of the server.

As mentioned above, the thread pool structure of the present invention has a DEQUE (Double Ended Queue) type, and since only one side of the pool is pulled out and reinserted, the thread pool has the longest idle time when loaded and checked one by one from the other side of the pool. I can bring it. If the idle time of the loaded thread does not exceed the timeout time, all the threads after the thread do not exceed the idle time, so the next check time may be waited for.

According to the present invention, a thread used by a client's work request can be kept in a non-blocking state so that the task can be processed immediately and wait in the wait until the rest can be done. . Therefore, it responds quickly to the client's work request.

Also, by deleting threads that have not been used during the configuration time, you can prevent server overload and manage resources efficiently.

Claims (5)

On a server system in a threaded environment,  A server 100 for processing a request of a client 200 through the Internet 300 through a communication agent 120 using a thread pool 110 and non-blocking input / output (non blocking i / o); A thread pool 110 containing threads 112, 113, and 114 prepared in advance in the thread storage 111 having a stack structure, and removing unnecessary threads through the thread manager 115; And a connection unit 122 and a connection processing unit 121 using non-blocking input / output (non blocking i / o), and the connection unit 122 serves to accept a first connection of a client, and the connection processing unit 121 The communication agent 120 has a role of generating client information or receiving data sent by the client and forwarding the client's request to the thread pool 110 when the client is connected; A connection storage 123 which performs client connection transfer between the connection unit 122 and the connection processing unit 121; By detecting the I / O event (connect, accept, read, write) occurring in the network connection between the registered server and the client, it informs the network connection between the server and the client where the immediate I / O event occurred, and the client 300 Selector 130 for selecting threads 112, 113, and 114 suitable for the work request of the < RTI ID = 0.0 > Server thread management system using non-blocking input and output, characterized in that consisting of. On a server system in a threaded environment, When the client 200 connects to the server 100, the server 100 authenticates the connection, stores the connection of the authenticated connection in the connection storage 111, If there is a connection stored in the register the connection to the selector 130 and delivers the connection completion to the client 200, The server 100 waits until there is a connection for reading data sent by the client according to a client's work request, and loads the data sent by the client by obtaining a connection for reading data. Loading all of the data brings the threads 112, 113, and 114 from the thread pool 110. If there are no threads that can be loaded from the thread pool 110, a new thread is created within the range possible. Perform the operation requested by the client on the loaded thread, When the thread performs all of the requested operation, the result of the operation is sent to the client, the thread is a wait state (wait) and stored in the thread pool (110), characterized in that the server thread management method using non-blocking input and output. In a threaded server system where a client connects to a server, the server authenticates the connection and stores the connection for the authenticated connection in the connection repository. Receiving a task execution request of the client in the thread pool (110) of the server (S_300); Checking whether there is a thread available for the work execution request (S_310); If there are no available threads, comparing the number of current threads with the number of allowed threads (S_320); Generating new threads by a predetermined number not exceeding the allowed number of threads, if the additional threads can be created (S_321); Executing the created thread in an operating state (S_325); Switching the executed thread to a standby state and storing the executed thread in a thread storage 111 of a thread pool 110 (S_326); Generating a message indicating that the client's request cannot be processed (S_330) if the thread cannot be created further (S_331); Requesting a thread from the thread storage 111 if there is a thread available in the above (S_340); Transferring a job to be processed to a thread loaded by the request (S_350); Delivering a wake-up message to the thread (S_360); The thread performing a task requested by the client (S_370); Transmitting a result of the thread performing a task to a client (S_380); Storing the thread on which the work is performed in the thread storage 111 of the thread pool 110 (S_390); Thread management method of the server using non-blocking input and output, characterized in that it comprises a. The method of claim 3, wherein Creating a thread (S_322), Checking whether a predetermined number of threads can be created (S_322); If it is not possible to create a predetermined number of threads, modifying the maximum number of threads that can be created (S_323); Generating a predetermined number of threads if a predetermined number of threads can be created, and generating a modified number of threads if a predetermined number of threads cannot be generated (S_324); Thread management method of the server using non-blocking input and output, characterized in that it further comprises. The method of claim 3, wherein In operation S_370, the thread performs a work according to a work request of a client. The thread for processing the work request of the client checks the wake-up message (S_371); performing a work according to a work request of a client when receiving a wake-up message (S_372); Storing the time used for the thread and transitioning the thread to a standby state (S_373); Thread management method of the server using non-blocking input and output, characterized in that it further comprises.

Images