JPH076043A - Multithreaded server - Google Patents

Abstract

(57) [Summary] [Purpose] Enables processing of request messages even while storing received sample data in memory.
An object of the present invention is to obtain a multi-threaded server that can speed up the processing for a request message and can prevent the loss of the request message. [Structure] The request messages held by the second receiving units 16 and 17 are sequentially taken out, and the first receiving unit 11 receives the process according to the content of the request message and the memory 1
This is performed based on the sample data stored in 3.15.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a multithread server which can respond to a request message from an external device in real time.

[0002]

2. Description of the Related Art FIG. 22 is a block diagram showing a conventional multithreaded server. In the figure, 1 is a plant, 2 is a client, 3 is a network (may be a backplane bus), and a client 2 and a network 3 are shown.
External device. A receiver 4 receives the sample data from the plant 1 and a request message from an external device, and a receiver 5 activates one of the child threads 6, 7 and 8 depending on the content of the request message received by the receiver 4. At the same time, when the receiver 4 receives the sample data, the mother thread for storing the sample data in the memory 9, 6, 7,
Reference numeral 8 denotes a child thread that performs processing according to a request message sent from an external device based on the sample data stored in the memory 9.
7, 8 are generated by the mother thread 5 at the time of startup. Reference numeral 9 is a memory for storing sample data, 10 is a FIFO queue for temporarily holding the processing results of the child threads 6, 7, 8 and 20 is a processing queue for holding the processing results held in the FIFO queue 10 It is a transmitter that transmits to the device.

Next, the operation will be described. First, the receiver 4 receives sample data from the plant 1 or a request message from an external device. Then, the mother thread 5 stores the sample data in the memory 9 when the receiver 4 receives the sample data from the plant 1, and the request message when the receiver 4 receives the request message from the external device. Either one of the child threads 6, 7, or 8 is generated and activated in accordance with the content of.

For example, when the mother thread 5 activates the child thread 6, the child thread 6 performs processing according to the request message based on the sample data stored in the memory 9. Then, the processing result of the child thread 6 is transmitted to the FIFO queue 10 and is temporarily retained. And transmitter 2
0 fetches the processing results held in the FIFO queue 10 in the order in which they are held and sends them to the external device. That is, FIG.
As shown in FIG. 3, even if the processing result held first in the FIFO queue 10 has a lower priority than the processing result held later, the processing result held first has a lower priority. The child threads 6, 7, and 8 can perform processing in parallel, but cannot access the memory 9 at the same time.

[0005]

Since the conventional multi-thread server is configured as described above, the receiver 4 receives the sample data from the plant 1 and the like and the request message from the external device, and the mother thread 5 receives the sample data. Must determine the subsequent processing. Therefore, for example, when the sample data is received during the process of responding to the received request message, the sample data is stored in the memory 9 until the process is completed. However, if the storage of the sample data is not completed by the arrival of the next sample data, the sample data may be missed.

Further, since the receiver 4 does not have a function of holding a plurality of request signals and the like, before the mother thread 5 fetches the request message and the like (for convenience, referred to as old request message) received by the receiver 4, If the request message or the like is sent from the external device, the old request message is lost.

Further, since the transmitter 20 takes out and transmits in the order held in the FIFO queue 10, even if the processing result held later is required to be faster than the processing result held first, There is a problem that the processing result held later is kept waiting until the processing result held earlier is transmitted, and the request of the external device cannot be sufficiently satisfied.

Further, since the transmitter 20 sends the processing result without confirming the existence of a thread (see FIG. 3) that performs processing other than the transmission, the transmitter 20
Even if the processing of the thread is required to have higher speed than the transmission processing of No. 2, there is a problem that the processing of the thread is kept waiting until the transmission processing of the transmitter 20 is completed.

Further, the mother thread 5 generates the child threads 6, 7, and 8 each time it executes the processing in response to the request message.
The memory area necessary for the processing of 8 must be secured,
Therefore, since the unnecessary memory area gradually increases in the memory space, it becomes necessary to perform the garbage collection, and there is a problem that the response to the request message becomes impossible during that period.

Further, the mother thread 5 needs to generate the child threads 6, 7, and 8 each time when executing the processing responding to the request message, but when the stack area is insufficient, Could not be created, and there was a problem that the process had to wait until the stack area was released.

Further, the child threads 6, 7, and 8 can perform processing in parallel, but the memory 9
Since it is not possible to access the two simultaneously, there is a problem that the efficiency of parallel processing is reduced and high speed processing cannot be performed.

The invention of claim 1 has been made to solve the above problems, and enables the processing of the request message even when the received sample data is stored in the memory, and the request message is processed. It is an object of the present invention to obtain a multi-threaded server that can speed up the processing of the request message and can prevent the loss of the request message.

In addition to the above object, the invention of claim 2 is a multi-threaded system capable of sufficiently satisfying the request of an external device by enabling sequential transmission from the processing result requiring high speed.
Aim to get the server.

According to the third aspect of the invention, when there is a process requiring high speed processing, the process requiring high speed processing can be prioritized over the process of transmitting the processing result to the external device. Aim to get a multithreaded server.

It is an object of the present invention to obtain a multithreaded server which can prevent loss of a request message and can perform processing from the request message requiring high speed.

It is an object of the invention of claim 5 to obtain a multi-threaded server that does not need to perform garbage collection and that does not prevent a response to a request message.

It is an object of the present invention to provide a multithreaded server capable of preventing a delay in processing a request message due to lack of a stack area.

The invention of claim 7 improves the efficiency of parallel processing and enables multi-thread processing capable of high-speed processing.
Aim to get the server.

It is an object of the invention of claim 8 to obtain a multi-thread server capable of ensuring the real-time property of a cyclically-starting thread that performs processing periodically.

It is an object of the inventions of claims 9 and 10 to obtain a multi-thread server capable of minimizing the waiting time of a timer thread.

[0021]

A multithreaded server according to a first aspect of the present invention sequentially takes out request messages held by a second receiving section, and performs a process according to the contents of the request message in a first way. This is performed based on the sample data received by the receiving unit and stored in the memory.

The multithreaded server according to the second aspect of the present invention temporarily holds the processing results of the processing execution unit, and when a plurality of processing results are held, the external devices are sequentially processed in descending order of priority. Is to be sent to.

In the multithreaded server according to the invention of claim 3, when the processing result of the processing execution unit is transmitted to the external device, if there is competition with other processing, the multithread server has priority over the other processing. The processing is performed only when the frequency is high.

In the multithreaded server according to the fourth aspect of the present invention, when the second receiving unit holds a plurality of request messages, request messages with higher priority are sequentially extracted.

In the multithreaded server according to the invention of claim 5, a memory area required when each thread executes a process is secured in advance for each thread, and when the thread executes the process. The corresponding memory area is allocated.

A multithreaded server according to a sixth aspect of the present invention is configured such that threads required for processing are generated in advance and are put in a standby state.

According to a seventh aspect of the present invention, the multithread server reads the sample data stored at the predetermined address from the processing execution unit while storing the sample data received by the first receiving unit in the memory. When there is a request, the read request is rejected only when the address related to the read request matches the address currently storing the sample data.

The multithread server according to the invention of claim 8 activates the periodic activation type thread at every prescribed activation period, and when the periodic activation type thread does not terminate the processing even after a prescribed time has elapsed after the activation. Is provided with a timer thread for interrupting the processing and releasing the acquired resource.

In the multithreaded server according to the invention of claim 9, when a timer thread is waiting because a thread having a lower priority than the timer thread has acquired the semaphore, the priority is temporarily given to the timer thread. The semaphore has a priority inheritance function that makes the priority of a thread with a low frequency equal to the priority of the timer thread.

The multi-thread according to the invention of claim 10
The server provides a flag indicating whether or not the shared resource is used and a semaphore for reading and writing the flag for each thread, and the thread having a lower priority than the timer thread acquires the semaphore. When the timer thread is in a waiting state, the semaphore has a priority inheritance function that temporarily sets the priority of the thread having the low priority to the priority of the timer thread.

[0031]

The multithreaded server according to the first aspect of the present invention is provided with the second receiving unit for holding the request message, so that the loss of the request message is prevented, and
The request messages held by the second receiving unit are sequentially taken out, and the processing according to the content of the request message is performed first.
Since the processing execution unit that performs the processing based on the sample data received by the receiving unit of the first embodiment and stored in the memory is provided, the sample data is received from the first receiving unit even when the request message is received from the second receiving unit. Can be stored in memory.

The multithread according to the invention of claim 2
The server temporarily holds the processing result of the processing execution unit, and when a plurality of processing results are held, by providing a transmitting unit that sequentially transmits to the external device from the processing result with high priority, It becomes possible to transmit sequentially from the processing result which requires high speed.

The multithread according to the invention of claim 3
The server is provided with a transmission unit that performs processing only when the processing result of the processing execution unit is transmitted to an external device and conflicts with other processing when the priority is higher than the other processing. As a result, when there is a process requiring high speed processing, the process requiring high speed processing is prioritized over the process of transmitting the processing result to the external device.

The multithread according to the invention of claim 4
When the second receiving unit holds a plurality of request messages, the server is provided with a processing execution unit that sequentially extracts request messages with high priorities, so that loss of request messages can be prevented and high speed operation can be achieved. Can be performed from the processing for the required request message of.

The multithread according to the invention of claim 5
The server has a process execution unit that reserves a memory area required for each thread to execute a process in advance and allocates a corresponding memory area when each thread executes a process. This eliminates the need for garbage collection.

The multithread according to the invention of claim 6
The server is provided with a processing execution unit that previously generates a thread required for processing and puts it in a standby state, and thus delays processing of a request message due to lack of stack area.

The multithread according to the invention of claim 7
The server, when storing the sample data received by the first receiving unit in the memory and receiving a read request for the sample data stored at the predetermined address from the process executing unit, determines that the address related to the read request is , Parallel processing of reading and writing data while preventing the conflict of data contents caused by reading and writing the same data at the same time by rejecting the reading request only when it matches the address currently storing the sample data Will be possible.

The multithread according to the invention of claim 8
The server activates the periodic activation thread at every prescribed activation cycle, and if the periodic activation thread does not end the processing even after a prescribed time has elapsed after the activation, the server interrupts the processing and acquires. By providing the timer thread for releasing the resources, it becomes possible to surely start another cycle-starting thread every predetermined start-up cycle.

The multithread according to the invention of claim 9
If the timer thread is waiting because the thread with a lower priority than the timer thread has acquired the semaphore, the server temporarily assigns the priority of the thread with a lower priority to that timer thread. Since the semaphore has the priority inheritance function that makes it the same as the priority, even if a thread with a low priority has acquired the semaphore, the thread with a low priority can be processed promptly. The waiting time for a semaphore to acquire is shortened.

According to the tenth aspect of the invention, in the multithreaded server, a flag indicating whether or not a shared resource is used and a semaphore for reading and writing the flag are provided for each thread, and a priority is given to the timer thread. If the timer thread is waiting because the low thread has acquired the semaphore, the priority inheritance that temporarily sets the priority of the thread with the low priority to the priority of the timer thread By giving the function to that semaphore, even if the thread with the low priority has acquired the semaphore, the processing with the thread with the low priority is performed promptly.Therefore, wait until the timer thread acquires the semaphore. Time is reduced.

[0041]

【Example】

Example 1. An embodiment of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram showing a multithreaded server according to a first embodiment of the present invention. In the figure, the same reference numerals as those of the conventional one indicate the same or corresponding portions, and the explanation thereof will be omitted. 11 is a FIFO queue (first receiving unit) that receives the sample data from the plant 1, 12 is a cyclic start-up thread that writes the sample data received by the FIFO queue 11 to the ring buffer 13 at a constant cycle, and 13 is the sample data Ring buffer (memory) to store,
Reference numeral 14 is a disk 1 in which some sample data slightly past the index (address) of the ring buffer 13 currently being written by the cyclically activated thread 12 are collected.
Reference numeral 5 is a periodic start type thread for writing in a constant cycle, and 15 is a disk (memory).

Reference numeral 16 is a receiver for receiving a request message from the client 2 via the network 3,
Reference numeral 7 denotes a FIFO queue that holds the request message received by the receiver 16, and the receiver 16 and the FIFO queue
The queue 17 constitutes a second receiver.

Further, 18 sequentially fetches the request messages held by the FIFO queue 17 and activates one of the child threads 6, 7 and 8 in accordance with the content of the request message to change the content of the request message. The corresponding processing is performed by the ring buffer 13 and the disk 1.
5 is a mother thread that is executed based on the sample data stored in 5, and the processing execution unit is composed of the mother thread 18 and the child threads 6, 7, and 8.

Further, 19 is a child thread 6, 7,
A FIFO queue for temporarily holding the processing result of 8, 20
Is a transmitter for transmitting the processing result held by the FIFO queue 19 to the client 2 via the network 3, and the transmitter includes the FIFO queue 19 and the transmitter 20.

Next, the operation will be described. First, the sample data is transmitted from the plant 1 every 10 msec, for example, and the FIFO queue 11 receives the sample data. Then, the sample data received in the FIFO queue 11 is periodically stored in the ring buffer 13 by the cyclic activation type thread 12. When the sample data is accumulated in the ring buffer 13 to some extent, the cyclically-starting thread 14 collectively stores some sample data in the disk 15. When storing the sample data in the ring buffer 13 and the disk 15,
Time information is also stored together so that it can be known when the sampled data is sampled.

On the other hand, the request message is transmitted from the client 2 via the network 3 at irregular intervals, and the receiver 16 receives the request message. Then, the request message received by the receiver 16 is temporarily transferred to the FIFO queue 17
Stored in. Then, the mother thread 18 sequentially takes in the request messages stored in the FIFO queue 17, and one of the child threads 6, 7, and 8 is generated and activated according to the content of the request message (child threads 6, 7). , 8, the memory area required for the process is dynamically secured when starting. (Details will be described later). Here, there are the following request messages. Notifies that an event has occurred when an event occurs. Periodic transfer of sample data at the current time. Batch transfer of sample data from a certain time in the past to a certain time.

Then, the child threads 6, 7, and 8 started by the mother thread 18 perform processing according to the contents of the request message based on the sample data stored in the ring buffer 13 and the disk 15 (necessary). If the sample data to be processed is not stored in the ring buffer 13, the disk 15 is accessed).
For example, if the content of the request message is the above content, the client 2 is notified that an event has been activated.
To send to. If the content of the request message is the above content, the ring buffer 13
A process of reading the corresponding sample data from the above and transmitting it to the client 2 is performed.

Then, the processing results of the child threads 6, 7, and 8 are transmitted to the FIFO queue 19 and temporarily held. Since the child threads 6, 7, and 8 can perform parallel processing, the FIFO queue 19 may hold a plurality of processing results. Then, the transmitter 20 sequentially fetches the processing result held in the FIFO queue 19 and the client 2 receives the processing result via the network 3.
To end the series of processing.

As described above, in the first embodiment, the dedicated FIFO queue 11 for receiving the sample data transmitted from the plant 1 is provided in addition to the receiver 16 for receiving the request message. It is now possible to sample the sample data independently of the processing, so that the processing of the request message does not interfere with the sample processing, and the sample processing can be performed with time constraints. It can be carried out. Further, since the FIFO queue 17 for temporarily holding the request message is provided, even if a plurality of other request messages are transmitted from the client 2 before the processing for the previously transmitted request message is completed, The situation where the request message is lost does not occur. The first embodiment corresponds to the invention of claim 1.

Example 2. In the first embodiment described above, when a plurality of processing results are held in the FIFO queue 19, the FIFO
Although the one in which the processing results are transmitted in the order held in the queue 19 has been described, as shown in FIG. 2, when a plurality of processing results are held, the processing results with higher priority are sequentially transmitted to the client 2. You may do it. In FIG. 2, 19a, 19b, and 19c are components of the FIFO queue 19, and temporarily hold the processing results of the child threads 6, 7, and 8, respectively. Also, 21
Is a transmitter (transmitting unit) that sequentially transmits to the client 2 from the processing result with the highest priority when the FIFO queue 19 holds a plurality of processing results.

Next, the operation will be described. First, the request message has different contents as described above, and therefore, there is a priority related to a time constraint when responding to each client 2. For example, if the child thread 6 is to process the above request message,
It has an extremely high priority P _mq2 because it needs to be transmitted to the client 2 within a certain time so that the client 2 can respond to the event occurrence in time. If the child thread 7 is to process the above-mentioned request message, the child thread 7 needs to be transmitted within a valuable time for the client 2 to use as the latest sample data. It has the highest priority P _mq1 next to the processing of thread 6. Further, when the child thread 8 performs the processing for the above request message, such processing has a lower priority P _mq0 than the processing of the child threads 6 and 7 because there is little trouble even if the transmission is delayed a little. ing. P _mq0 <P _mq1 <P _mq2

In this case, the child thread 8
From the processing result of the priority P _{mq0 to} the FIFO queue 19c is stored and immediately thereafter, the child thread 6
It is _{assumed that} the processing result of the priority P _mq2 is transmitted to and stored in the FIFO queue 19a. In the first embodiment, the FIFO
Since the transmission is performed in the order stored in the queue 19, the processing result of the child thread 8 is transmitted first. However, in the second embodiment, since the transmission is performed in consideration of the priority of the processing result, a child with a high priority is transmitted. The processing result of the thread 6 will be transmitted first. This enables processing according to the request of the client 2. The second embodiment corresponds to the invention of claim 2.

Example 3. In the second embodiment, the transmitter 21 transmits the processing result without confirming the existence of the thread 22 that performs processing other than the transmission. However, as shown in FIG.
A thread 22 that performs processing other than transmission when performing processing of transmitting the processing results of 7 and 8 to the client 2.
When the transmission thread of the transmitter 21 has a higher priority than the processing priority P _etc of the thread 22, the transmission processing may be performed. In the figure, 21a, 21b, and 21c are transmission threads of the transmitter 21, 22 is a thread that performs other processing other than transmission, and 23 is a semaphore.

Next, the operation will be described. For example, send
The priority of each thread 21a, 21b, 21c is P
_tr2 , P _tr1 , P_tr0 And the relationship of high priority is as follows
It is supposed to be. P_tr0 <P_tr1 <P_etc <P_tr2

In this case, when the transmission thread 21a performs the transmission process, the priority P of the transmission thread 21a is set.
_{Since tr2} is higher than the priority P _{etc of} the thread 22, the transmission process is immediately performed even if the thread 22 exists. On the other hand, when the transmission thread 21c performs the transmission process, the priority P _tr0 of the transmission thread 21c is the thread 2
Since the priority is lower than the priority P _{etc of} 2, the transmission process waits until the process of the thread 22 ends.

The semaphore 23 is provided to prevent a plurality of transmission threads 21a, 21b, 21c from simultaneously transmitting to the network 3. Semaphore 23
The number of sending threads that can acquire
Only the transmission thread that has acquired (the transmission thread 21a has acquired in the example of FIG. 3) can transmit to the network 3.

Here, when the semaphore 23 is provided, the following problems occur. That is, when the transmission thread 21c having a low priority acquires the semaphore 23 and then the transmission thread 21a having a high priority is stored in the FIFO queue 19a, the transmission thread 2 having a low priority is transmitted.
Since 1c has acquired the semaphore 23, the transmission thread 21a having a high priority must wait for the transmission processing of the transmission thread 21c, but since the priority of the transmission thread 21c is lower than the priority of the thread 22, transmission is performed. The thread 21c waits until the processing of the thread 22 is completed. Therefore, although the thread 21a has a high priority, as a result, there is a problem that the transmission processing cannot be performed until the processing of the thread 22 and the transmission thread 21c is completed.

Therefore, by giving the semaphore 23 a priority inheritance function (sending thread priority changing function), the above-mentioned problem can be solved. That is, the transmission process of the transmission thread 21c is prioritized over the thread 22 by temporarily increasing the priority of the transmission thread 21c to the priority of the transmission thread 21a. Sending thread 21c
When the processing of step 2 is completed, the transmission thread 21a moves to the semaphore 2
3 is acquired, and the priority of the transmission thread 21a is thread 2
Since the priority is higher than 2, the transmission thread 21a can perform transmission without waiting for the processing of the thread 22. Therefore, the waiting time of the transmission thread 21a can be shortened.
The third embodiment corresponds to the invention of claim 3.

Example 4. In the first embodiment described above, the case where the mother thread 18 takes out and processes the request messages in the order in which the request messages are held in the FIFO queue 17 has been described. However, as shown in FIG. When the priority of the request message stored later in 17 is higher than the priority of the request message stored earlier in 17, the mother thread 18 may fetch and process the request message stored later. As a result, the processing can be performed from the processing for the request message requiring high speed. The fourth embodiment corresponds to the invention of claim 4.

Example 5. In the above-described first embodiment, when the mother thread 18 generates and starts any one of the child threads 6, 7, and 8 according to the content of the request message, the one that dynamically secures the memory area required for the processing will be described. However, as shown in FIG. 5, a memory area required for each child thread 6, 7, 8 to execute a process is secured in advance for each thread 6, 7, 8 and each thread 6, 7, 8 is secured. Corresponding memory areas may be allocated when the processes are executed by 7 and 8. In the first embodiment, the mother thread 18 creates the child threads 6, 7, and 8 each time, but the child threads 6, 7, and 8 may be created in advance and set in the standby state. .

Hereinafter, FIG. 5 will be described in detail. Figure 5
, 31 is a thread pool, 32, 33, and 34 are memory areas required when the child threads 6, 7, and 8 perform processing, respectively, a pointer to a function to execute a thread, and an argument to the function. Information such as a priority of a thread, a cycle and a deadline in the case of a cyclic activation type thread, and a type of event to be waited for (in the following, an activation event) in the case of an event activation type thread are stored. In addition, each child thread 6, 7, 8
Is in a standby state at initialization.

Further, 35 is a thread pool management table for managing the thread pool 31, 36 is a management table semaphore, 37 is a waiting child thread 6, 7, 8
, 38 is a request semaphore for notifying the thread pool 31 of the activation request of the mother thread 18, 39 is an area for storing the thread IDs of the child threads 6, 7, and 8 that have accepted the activation request, and 40 is A reception semaphore for notifying the receipt of the request from the thread pool 31 to the mother thread 18, 41 is the mother thread 1
It is an activation semaphore for transmitting an activation instruction from 8 to the thread pool 31. Reference numeral 42 is a thread that uses the thread pool 31 in addition to the mother thread 18.

Next, the operation will be described. First, the mother thread 18 locks the management table semaphore 36 in order to gain access to the thread pool management table 35 (operation 1). Then, if the lock on the management table semaphore 36 fails, the lock is retried after a certain period of time. If the lock on the management table semaphore 36 succeeds, the waiting thread stored in the area 37 is confirmed (operation 2), and if it is “0”, it is determined that the thread cannot be started and exception processing is performed, or , Try again after a certain time. If it is "1" or more, a signal is transmitted to the request semaphore 38 (operation 3).

Also, the child threads 6 and 8 waiting
Are all waiting for the arrival of signals from the request semaphore 38, and the signals from the mother thread 18 are received by any one of these waiting child threads 6, 8. In the case of this example, it is assumed that it is received by the child thread 6.

The child thread 6 writes its thread ID in the area 39 (operation 5) in order to inform the mother thread 18 that the thread which received the activation is itself (operation 5), and then sends a signal to the reception semaphore 40. (Operation 6), wait for arrival of a signal to the activation semaphore 41.

On the other hand, the mother thread 18 waits for the arrival of the signal to the reception semaphore 40 after the end of the operation 3, and upon receiving the signal from the child thread 6 (operation 7), receives the request from the area 39. Thread ID
Is read (operation 8).

Here, the mother thread 18 writes information necessary for activation into the memory area 32 secured in advance (operation 9), and when the writing is completed, sends a signal to the activation semaphore 41 (operation 10). ). When the child thread 6 receives the signal from the activation semaphore 41 (operation 11), the number of waiting threads in the area 37 is reduced by "1" (operation 12), and the management table semaphore 3
The lock to 6 is released (operation 13).

As described above, the memory areas 32, 3 which are required in advance by the child threads 6, 7, 8 are executed.
By securing 3, 34, it is possible to prevent an unnecessary memory from increasing in the memory space due to repeated memory area securing. Therefore, it is not necessary to perform garbage collection. In addition, since the child threads 6, 7, and 8 are created in advance at the time of initialization, the situation in which the child threads 6, 7, and 8 cannot be created due to the lack of the stack area does not occur. Therefore, the conventional problem that the process has to wait until the stack area is released is solved. The fifth embodiment corresponds to the inventions of claims 5 and 6.

Next, the configuration and operation in the thread pool 31 of the child thread which is not required to be real-time will be described. FIG. 6 is a configuration diagram of activation information included in the child thread in the thread pool 31. It includes a pointer to a function to be executed, an argument from the mother thread 18 which issued a start request to the function, and an execution priority. FIG. 7 is a flowchart showing the operation of the child thread in the thread pool 31. When the mother thread 18 or another thread 42 receives an end interrupt, the control is transferred to step ST11.

Next, the structure and operation of the thread pool 31 of the cyclic activation type threads will be described. FIG. 8 is a configuration diagram of the start information included in the child thread in the thread pool 31. It contains a pointer to the function to be executed in each cycle, arguments from the mother thread 18 that issued a start request to the function, execution priority, start cycle, and deadline for processing per cycle. . In addition, FIG.
Is a flowchart showing the operation of the child thread in the thread pool 31. When the mother thread 18 or another thread 42 is to stop the cyclically activated thread being executed, the end flag of each cyclically activated thread is set. Stand up. Each cyclically activated thread checks the end flag for each cycle, and if it is set, the processing is ended and the thread returns to the waiting state.

Next, the structure and operation of the thread pool 31 of event-triggered threads will be described. Figure 10
FIG. 4 is a configuration diagram of activation information included in a child thread in the thread pool 31. It includes a pointer to a function to be executed when an event occurs, an argument from the mother thread 18 that issued a start request to the function, execution priority, information about the start event, and a processing deadline. FIG. 11 is a flow chart showing the operation of the child thread in the thread pool 31. When the mother thread 18 or another thread 42 puts an event-triggered thread waiting for an event into a waiting state, an end event is transmitted to that thread. The thread receiving the end event returns to the waiting state.

The child threads 6, 7, and 8 in the thread pool 31 can be made to perform any operation of a thread that does not require real-time processing, a periodic activation thread, and an event activation thread. The type of thread to be activated is included in the activation information passed from the mother thread 18 to each child thread 6, 7, 8 in the thread pool 31. The child threads 6, 7, and 8 in the thread pool 31 determine the processing to be performed based on this information. Further, FIG. 12 shows the thread pool 31.
FIG. 13 is a configuration diagram of activation information of each child thread 6, 7, and 8 in FIG. 13, and FIG. 13 is a flowchart showing the operation of each child thread in the thread pool 31.

Here, the number in the thread pool 31 is n. Processing is passed to these threads in response to a thread activation request (request message) sent from the client 2. The upper limit of the number of threads that perform emergency notification when an event occurs is n ₁ , the number of threads that are currently activated is i ₁ , the upper limit of the number of threads that periodically transfer sample data is n ₂ , and the current activation is The number of active threads is i ₂ , the upper limit of the number of threads that transfer sample data in an arbitrary period when an event occurs is n ₃ , and the number of threads that are currently activated is i ₃ . Moreover, it is assumed that there is the following relationship. n ₁ + n ₂ + n ₃ > n n ₁ ≦ n n ₂ ≦ n n ₃ ≦ n

In this case, i ₁ and i ₂ are small,
When there is the following relationship, a maximum number n _{3 of} threads that transfer sample data for an arbitrary period can be activated. i ₁ + i ₂ + i ₃ ≦ n (1) Then, the client 2 sends an activation request for the thread that performs the emergency notification or the thread that performs the periodic transfer, and the formula (1)
When the relationship of (3) is no longer satisfied, some of the threads that transfer sample data for an arbitrary period are suspended or terminated so as to satisfy this relationship.

Example 6. FIG. 14 is a configuration diagram illustrating an operation in which a plurality of threads perform writing and reading with respect to the ring buffer 13 and the disk 15. Hereinafter, description will be made according to the function of the thread that accesses the ring buffer 13 or the like.

Write Thread First, the cyclically activated thread 12 (write thread)
Writes to the ring buffer 13 every cycle.
The index of the ring buffer 13 to be written moves one by one for each writing. Here, an area 51 for storing an index (index indicated by x in the figure) which the cyclically activated thread 12 is currently writing.
Is prepared in advance. Since the area 51 is accessed by a plurality of threads, a semaphore 52 is provided for mutual exclusion of the area 51.

During the writing, the periodically activated thread 12 writes the index in the area 51 every time the writing index is changed in order to prevent other threads from accessing the index being written.
The time required for each thread to access the area 51 is small, and since the semaphore 52 has the priority inheritance function, each thread does not have to wait a long time to acquire the semaphore 52.

Backup Thread The cyclic thread 14 (backup thread) stores the sample data in the ring buffer 13 in the disk 15 before the data is lost. Several files for backup are prepared on the disk 15, and can be seen from each thread as if they are arranged in a ring shape as shown in the figure. Periodically activated thread 14
Transfers several pieces of sample data at a time which is later than the sample data of the index written by the cyclically activated thread 12 on the ring buffer 13 to the disk all at once.

Since the moving speeds of the indexes on the ring buffer 13 accessed by the periodic thread 12 and the periodic thread 14 are equal, and the periodic thread 14 reads out an index far apart from the index written by the periodic thread 12. , Cycle thread 1
2 and the periodic thread 14 never access the same index at the same time. In addition, the file on the disk 15 is written up to the capacity determined for each file, and when the capacity is reached, the file is closed and writing to the next file is started.

Here, also on the disk 15, an area 53 relating to the file currently being written is prepared, and a semaphore 54 is provided for mutual exclusion of the area 53. The information stored in the area 53 is the number of the file currently being written and the time of the earliest sample data on that file. Therefore, the cyclic startup thread 14 writes the number of the file currently being written in the area 53. Also, when writing to a new file, the time of the first sample data written to that file is written to the area 53.

Thread that Performs Periodic Reading For example, when the child thread 7 is a cyclic activation type thread, the child thread 7 reads the latest sample data stored in the ring buffer 13 for each cycle. The child thread 7 reads the contents of the area 51 for each cycle, and the current cycle start-type thread 12
Reads the contents of the index (index indicated by ◯ in the figure) immediately before the index being written by.

Thread for Reading for Arbitrary Period For example, when the child thread 8 is a thread for reading for an arbitrary period, the child thread 8 reads sample data from arbitrary time to arbitrary time at arbitrary intervals. If some of the requested sample data is not on the ring buffer 13 and the disk 15,
Whether only the sample data on the ring buffer 13 and the disk 15 should be read from the ring buffer 13 prior to the reading,
5 to determine whether to read.

The time of the oldest sample data on the currently written file stored in the area 53 is compared with the time of the sample data to be read. If the latter is past, unless it is past sample data that has already been lost from the disk 15,
Read from the disk 15. If the latter is the same as the former or the latter is newer than the former, it is read from the ring buffer 13 unless it is newer than the sample data stored in the index indicated by the area 51 (indicated by Δ in the figure). There is an index).

As described above, according to the sixth embodiment, the FIFO
When the child threads 7 and 8 request reading of the sample data stored at a predetermined address while storing the sample data received by the queue 11 in the ring buffer 13, the address at which the sample data is currently stored Since it is possible to read only the contents of the troublesome address, that is, when the address related to the read request matches the address currently storing the sample data, the read request is rejected. The parallel processing of data reading and writing is possible while preventing the contradiction of the data content caused by reading and writing the same data at the same time, and as a result, there is an effect that the processing can be performed at high speed. The sixth embodiment corresponds to the invention of claim 7.

Example 7. In the first to sixth embodiments, the end of the process of the cyclic activation type thread is not particularly referred to, but if the process is not completed even after a predetermined time has elapsed after the activation of the cyclic activation type thread, the process is interrupted. The resources that have been acquired may be released. As a result, according to the first to sixth embodiments, if the processing of a certain cycle-start type thread is complicated and the processing is not completed within the processing time, another cycle-start type thread that requires real-time processing is provided. Although there was a problem such as the delay in the start of processing of the thread, it becomes possible to reliably start another cyclically activated thread at every predetermined activation cycle.

FIG. 15 is a block diagram showing a multithreaded server according to a seventh embodiment of the present invention. In FIG.
Reference numeral 1 denotes a timer thread that manages the activation and termination of the cyclically activated threads 7, 12, and 14 that are activated cyclically among the child threads 6, 7, and 8 generated by the mother thread 18. Activates the periodic activation type threads 7, 12, 14 at every prescribed activation period, and at the same time, activates the periodic activation type threads 7, 12, 1
4 has a function of interrupting the processing and releasing the acquired resource when the processing is not finished even after a lapse of a predetermined time (deadline) after the activation. Reference numeral 62 is a thread management table (resource) that stores information on each thread (see FIG. 16).

Next, the operation will be described. First, in the thread management table 62, as shown in FIG. 16, a U flag indicating whether or not the thread is a cyclic activation type thread, and whether or not the thread is executing processing for each cycle. E flag, the time until the activation time of the thread is the number of activations of the timer thread 61 (for example, if the activation cycle of the timer thread 61 is 100ms and the time until the activation time of the thread is 200ms, the number of activations is 2
Field (shown as a negative value if it has already started), a UW field that indicates the time until the next startup of the thread by the number of times the timer thread 61 has started, and a deadline of the thread. A UD field indicating the number of times the timer thread 61 is activated, a period field for storing the period of the thread, and a deadline field for storing the deadline of the thread are stored.

The information about each thread stored in the thread management table 62 is managed by the mother thread 18. Specifically, when the mother task 18 creates a child thread according to a request message, etc. , Information of the child thread is registered in the thread management table 62. On the other hand, the disappearance of the thread,
When a stop request etc. is received, the registration of the thread is deleted.

Therefore, by decoding the stored contents of the thread management table 62, it is possible to obtain information such as which thread is a cyclic activation type thread, the activation cycle of the thread, and the deadline of the thread. Therefore, the timer thread 61 deciphers the stored contents of the thread management table 62 in each cycle that is extremely shorter than the activation cycle of the cyclic activation type thread.

Then, when a certain periodic activation type thread reaches the activation time, the timer thread 61 activates the periodic activation type thread by notifying the periodic activation type thread of the activation signal. In addition, if the processing does not end even after a lapse of a predetermined time from the activation of the cyclic startup thread, the processing of the cyclic startup thread is forced by notifying the periodic startup thread of timeout. In addition to suspending, the necessary timeout processing such as releasing the resources acquired by the periodic startup thread is executed so as not to interfere with the processing of other periodic startup threads.

As described above, according to the seventh embodiment, when the timer thread 61 does not end the processing even after the lapse of a predetermined time after the activation of the cyclic thread, the processing is interrupted and acquired. Since resources are released, even if processing is not completed within the processing time due to the complexity of processing of a certain cyclic startup thread, the startup of other cyclic startup threads will not be affected. It is possible to secure the real-time property of the cyclically activated thread.
The seventh embodiment corresponds to the invention of claim 8.

Example 8. In the above-described seventh embodiment, mutual exclusion of reading and writing from and to the thread management table 62, which is a shared resource between threads, is not particularly mentioned. However, since the thread management table 62 is a shared resource between threads, a plurality of threads are It is possible to read and write the same data at the same time. When the same data is read and written at the same time, the data content may be inconsistent due to the influence of the simultaneous reading and writing. Therefore, it is necessary to mutually exclude the reading and writing. For example, if the periodically activated thread or the like rewrites the contents of the thread management table 62 while the timer thread 61 is reading the contents of the thread management table 62, the timer thread 61 may not be able to obtain correct data.

Therefore, as a mutual exclusion method, a method is conceivable in which the threads can read and write to the thread management table 62 only when the semaphore is acquired. For example, the following problems may occur. That is, when the timer thread 61 is in a waiting state because the thread 7 having a lower priority than the timer thread 61 has acquired the semaphore, in order for the timer thread 61 to acquire and start the semaphore, The thread 7 or the like having a low priority has to finish the processing and release the semaphore, but the thread 7 or the like has a low priority, and thus waits for the processing of another thread to finish. In this case, in this case, the thread 7 and the like cannot finish the processing, and thus cannot release the semaphore, and as a result, the timer thread 61 cannot start. Incidentally, since the timer thread 61 is a thread for managing the activation of other threads, the timer thread 61 is set to have a higher priority than the mother thread 18, the cyclic activation type thread, and the like.

The eighth embodiment is intended to perform mutual exclusion of reading and writing with respect to the thread management table 62 while solving the above problems, and the configuration of the eighth embodiment is shown below. That is, in the eighth embodiment, as shown in FIG. 16, semaphores 63 and 64 are provided in order to perform mutual exclusion of reading and writing to the thread management table 62, and the thread 7 having a lower priority than the timer thread 61 and the like semaphore. When the timer thread 61 is in a waiting state because it has acquired 63 and 64, priority is given to temporarily set the priority of the thread 7 having a low priority to the priority of the timer thread 61. Semaphore 6 degree inheritance function
It is provided to 3, 64.

As a result, the thread 7 with the originally low priority is
Since the priority of the thread 7 and the like temporarily becomes the same as the priority of the timer thread 61 having a high priority, the thread 7 and the like may be in a standby state due to the execution of the processing of another thread due to the priority. Almost disappeared, and as a result, the processing of the thread 7 and the like is performed promptly and the semaphores 63 and 64 are released.
You will be able to obtain 64. Therefore, the real-time property of the cyclically activated thread can be secured and the reliability of the device is improved.

Here, FIG. 17 is a flow chart showing the operation of the timer thread 61. The operation will be briefly described. The timer thread 61 has a granularity of the start time, the cycle, and the time indicating the deadline of the cyclic start type thread. It is started with the (minimum unit) as the cycle. For example, if the activation time, the cycle, and the deadline are all expressed in 100 ms units, the timer thread 61 is activated in the 100 ms cycle. Then, the timer thread 61 is activated in each cycle, acquires the semaphore 63 for reading the U flag in step ST51, and acquires the semaphore 64 for reading the E flag in steps ST67 and ST72. Further, the semaphore 63 is released in step ST53, and the semaphore 64 is released in steps ST69 and ST74.

Next, FIG. 18 is a flow chart showing the operation in which the mother thread 18 registers the cyclically activated thread in the thread management table 62. The operation will be briefly described. After the semaphore 63 is acquired in step ST81, the step is performed. The U flag is read in ST82, and the semaphore 63 is released in step ST83 (hereinafter, the critical section U1 during steps ST81 to 83).
That). Further, after the semaphore 63 is acquired in step ST86, the U flag is written and read in step ST87, and the semaphore 63 is released in step ST88 (hereinafter, steps ST86 to 88 are referred to as critical section U2).

Next, FIG. 19 is a flow chart showing the operation for the mother thread 18 to delete the registration of the cyclic activation type thread from the thread management table 62. To briefly explain the operation, the semaphore 63 is acquired in step ST91. After that, the U flag is written in step ST92, and the semaphore 63 is released in step ST93 (hereinafter, steps ST91 to ST93 are referred to as critical section U3).

Next, FIG. 20 is a flow chart showing the operation of each cyclic activation type thread. To briefly explain the operation, the semaphore 64 is acquired in step ST103, and then the E flag is written in step ST104.
In step ST105, the semaphore 64 is released (hereinafter,
A critical section E1 is defined between steps ST103 and ST105). After the semaphore 64 is acquired in step ST111, the E flag is written and read in step ST112, and the semaphore 6 is read in step ST113.
4 is released (hereinafter, steps ST111 to 113 are referred to as critical section E2).

As is clear from the above, the timer thread 6
When 1 is started, the semaphores 63 and 64 have a priority inheritance function, so that the critical section is kept waiting by the critical section even if it is the most waited time. It is limited to the time required to execute any one of U1, U2 and U3 and the time required to execute one of the critical sections E1 and E2. The added time is at most the time required for reading and writing the two flags, which is extremely short compared to all the processing performed by the timer thread 61, and is a negligible time. By the way, the eighth embodiment is claimed in claim 9.
It corresponds to the invention of.

Example 9. Although the semaphores 63 and 64 are provided on the entire U flag or E flag in the eighth embodiment, as shown in FIG. 21, an S flag indicating whether or not the thread management table 62 is used and A semaphore 65 for reading and writing the S flag is provided for each thread, and since the thread 7 having a lower priority than the timer thread 61 has acquired the semaphore 65, the timer thread 61 is in a waiting state. In this case, the semaphore 65 may be provided with a priority inheritance function for temporarily setting the priority of the thread 7 having a low priority to the priority of the timer thread 61. Has the same effect as. The ninth embodiment corresponds to the invention of claim 10.

[0102]

As described above, according to the first aspect of the present invention, the request messages held by the second receiving section are sequentially taken out, and the first receiving section performs the processing according to the content of the request message. Since it is configured to be performed based on the sample data received and stored in the memory, the sample data can be received and stored in the memory even while the request message is being received. There is an effect that the processing can be performed while keeping the time constraint.

According to the second aspect of the present invention, the processing results of the processing execution unit are temporarily stored, and when a plurality of processing results are stored, the processing results of higher priority are sequentially transmitted to the external device. With this configuration, the processing results that require high speed can be sequentially transmitted, and as a result, it is possible to sufficiently satisfy the requirements of the external device.

According to the third aspect of the present invention, when the processing result of the processing execution unit is transmitted to the external device, if there is competition with other processing, the priority is higher than the other processing. Since it is configured to perform only processing, if there is processing that requires high speed processing, the processing that requires high processing speed can be given priority over processing that sends processing results to an external device. There is an effect that becomes.

According to the fourth aspect of the invention, when the second receiving unit holds a plurality of request messages, the request messages having higher priority are sequentially taken out, so that loss of the request messages is prevented. In addition to the above, there is an effect that the processing can be performed from the processing for the request message requiring high speed.

According to the fifth aspect of the present invention, a memory area required when each thread executes a process is secured in advance for each thread, and the memory area corresponding to each thread when executing the process is reserved. Since there is no need to perform a garbage collection, it is possible to prevent a situation in which the response to the request message due to the garbage collection is prevented from occurring.

According to the sixth aspect of the present invention, the threads required for processing are generated in advance and set in the standby state. Therefore, the processing for the request message is delayed due to lack of the stack area. There is an effect that can prevent.

According to the invention of claim 7, while the sample data received by the first receiving section is being stored in the memory, the processing execution section makes a request for reading the sample data stored at the predetermined address. In this case, because the read request is rejected only when the address related to the read request matches the address that currently stores the sample data, there is a contradiction in the data content caused by reading and writing the same data at the same time. It is possible to perform parallel processing of reading and writing data while preventing it, and as a result, it is possible to perform high-speed processing.

According to the eighth aspect of the present invention, the cyclically-starting thread is started at every predetermined starting cycle, and if the cyclically-starting thread does not end the processing even after a predetermined time has passed after the starting, Since the timer thread that suspends the processing and releases the acquired resource is provided, it becomes possible to reliably start other periodic activation type threads at every prescribed activation period, and the real time of the periodic activation type thread. There is an effect that can secure the sex.

According to the ninth aspect of the invention, when the timer thread is waiting because the thread having a lower priority than the timer thread has acquired the semaphore,
Since the semaphore has a priority inheritance function that temporarily sets the priority of the thread with the low priority to the priority of the timer thread, the data content generated by reading and writing the same data at the same time As a result of the timer thread being able to quickly acquire the semaphore while preventing the contradiction, there is an effect that the real-time property of the periodically activated thread can be secured and the reliability of the device is improved.

According to the tenth aspect of the invention, a flag indicating whether or not a shared resource is used and a semaphore for reading and writing the flag are provided for each thread, and a thread having a lower priority than the timer thread is provided. If the timer thread is waiting because the semaphore has been acquired, the priority inheritance function that temporarily sets the priority of the thread with the lower priority to the priority of the timer thread is Since the semaphore is configured to have it, the timer thread can acquire the semaphore promptly while preventing the contradiction of the data content caused by reading and writing the same data at the same time, and as a result, the real-time property of the cyclic startup thread can be secured The effect is to improve the reliability of the device.

[Brief description of drawings]

FIG. 1 is a configuration diagram showing a multithreaded server according to a first embodiment of the present invention.

FIG. 2 is a configuration diagram illustrating details of a transmission unit according to a second embodiment.

FIG. 3 is a configuration diagram illustrating details of a transmission unit according to a third embodiment.

FIG. 4 is a configuration diagram showing details of a second receiving unit in the fourth embodiment.

FIG. 5 is a configuration diagram showing a configuration of a throughput mechanism.

FIG. 6 is a configuration diagram of activation information of a child thread in the thread pool 31.

FIG. 7 is a flowchart showing an operation of a child thread in the thread pool 31.

FIG. 8 is a configuration diagram of activation information of a child thread in the thread pool 31.

9 is a flowchart showing the operation of a child thread in the thread pool 31. FIG.

FIG. 10 is a configuration diagram of activation information of a child thread in the thread pool 31.

FIG. 11 is a flowchart showing an operation of a child thread in the thread pool 31.

FIG. 12 is a configuration diagram of activation information included in a child thread in the thread pool 31.

FIG. 13 is a flowchart showing the operation of a child thread in the thread pool 31.

FIG. 14 is a configuration diagram illustrating an operation in which a plurality of threads perform writing and reading with respect to the ring buffer 13 and the disk 15.

FIG. 15 is a diagram showing a multithread according to a seventh embodiment of the present invention
It is a block diagram which shows a server.

FIG. 16 is an explanatory diagram illustrating contents of a thread management table.

FIG. 17 is a flowchart showing the operation of the timer thread.

FIG. 18 is a flowchart showing an operation in which a mother thread registers a cyclically activated thread in a thread management table.

FIG. 19 is a flowchart showing an operation in which the mother thread deletes the registration of the cyclic activation type thread from the thread management table.

FIG. 20 is a flowchart showing the operation of each cyclic activation type thread.

FIG. 21 is an explanatory diagram illustrating contents of a thread management table.

FIG. 22 is a configuration diagram showing a conventional multithreaded server.

FIG. 23 is a configuration diagram showing details of a conventional transmission unit.

[Explanation of symbols]

 1 Plant 2 Client (External Device) 3 Network (External Device) 6, 7, 8 Child Thread (Process Execution Unit) 11 FIFO Queue (First Reception Unit) 13 Ring Buffer (Memory) 15 Disk (Memory) 16 Receiver ( Second receiving unit) 17 FIFO queue (second receiving unit) 18 Mother thread (processing execution unit) 19 FIFO queue (transmitting unit) 20, 21 Transmitter (transmitting unit) 21a, 21b, 21c Transmission thread (transmitting unit) 32, 33, 34 memory area 61 timer thread 62 thread management table (resource) 63 to 65 semaphore

Claims (10)

[Claims] 1. A first receiving unit for receiving sample data from a plant, a memory for storing the sample data received by the first receiving unit, a request message from an external device, and a request thereof. A second receiving unit that holds a message, a process of sequentially taking out the request message held by the second receiving unit, and performing a process according to the content of the request message based on the sample data stored in the memory A multithreaded server comprising: an execution unit; and a transmission unit that temporarily holds the processing result of the processing execution unit and then transmits the processing result to the external device. 2. A first receiving unit for receiving sample data from a plant, a memory for storing the sample data received by the first receiving unit, a request message from an external device, and a request thereof. A second receiving unit that holds a message, a process of sequentially taking out the request message held by the second receiving unit, and performing a process according to the content of the request message based on the sample data stored in the memory An execution unit and a transmission unit that temporarily holds the processing result of the processing execution unit and sequentially transmits the processing results with higher priority to the external device when a plurality of processing results are held. Multithreaded server. 3. The transmission unit, when performing a process of transmitting the processing result of the process execution unit to the external device, conflicts with another process, and has a higher priority than the other process. The multithreaded server according to claim 1 or 2, wherein only the processing is performed. 4. The processing execution unit, when the second reception unit holds a plurality of request messages, sequentially extracts request messages with a high priority. The described multi-threaded server. 5. The process execution unit secures a memory area required for each thread to execute a process in advance, and allocates a memory area corresponding to each thread to execute the process. 3. The multi-threaded server according to claim 1, wherein the multi-threaded server is assigned. 6. The multi-thread server according to claim 1, wherein the processing execution unit generates a thread required for processing in advance and sets it in a standby state. 7. The memory, while storing the sample data received by the first receiving unit, receives a read request of the sample data stored at a predetermined address from the processing executing unit, The multi-thread server according to claim 1 or 2, wherein the read request is rejected only when the address relating to the read request matches the address currently storing the sample data. 8. A timer thread for managing activation and termination of a cyclically activated thread, which is periodically activated after the thread generated by the processing execution unit, is provided, and the timer thread is activated periodically at a predetermined activation cycle. A type thread is activated, and when the periodic activation type thread does not terminate the processing even after a predetermined time has elapsed after the activation, the processing is interrupted to release the acquired resource. 1 or the multithread according to claim 2
server. 9. A semaphore is provided for mutual exclusion of reading and writing to a shared resource between a thread generated by the processing execution unit and the timer thread, and a thread having a lower priority than the timer thread acquires the semaphore. When the timer thread is in the waiting state because of the above, the semaphore has a priority inheritance function that temporarily sets the priority of the thread with the lower priority to the priority of the timer thread. The multi-threaded server according to claim 8, characterized in that: 10. A flag indicating whether or not the shared resource is used and a flag indicating whether or not the shared resource is used for mutual exclusion of reading and writing of the shared resource between the thread generated by the processing execution unit and the timer thread. A semaphore for each thread is provided, and when the timer thread is waiting because the thread with a lower priority than the timer thread has acquired the semaphore, the priority is temporarily low. 9. The multithreaded server according to claim 8, wherein the semaphore has a priority inheritance function for making the priority of the thread the same as the priority of the timer thread.