swoole event handling process

The main content of this article is about the analysis of the swoole event processing process. Interested friends can learn about it. I hope this article can be helpful to you.

To understand the swoole event processing process, first understand the two network event processing modes.

Reactor mode

It requires the main thread (I/O processing unit) to only monitor whether there is an event on the file descriptor, and if so, immediately notify the worker thread/process of the event. (logical unit). Other than that, the main thread doesn't do any other work. Reading and writing data, accepting new connections, and processing customer requests are all done in worker threads.

Proactor mode

Two implementations

Use the I/O asynchronous model to implement the Proactor mode. Principle: All I/O operations are handed over to the main thread, which cooperates with the kernel to handle them, and business logic operations are handed over to the logic unit. For example, use aio_read to achieve this.

Workflow:

1. The main thread calls the aio_read function to register the read completion event on the socket with the kernel.
2. The main thread continues to process other I/O events.
3. When the data on the socket is read into the user buffer, the kernel sends a signal to the application (logical unit) to notify the application that the data is available.
4. The application reads the data (client request), and after processing, calls the aio_write function to register the write event on the socket with the kernel.
5. The main thread continues to process other logic.
6. When the data in the user buffer is written to the socket, the kernel sends a signal to the application to notify the application that the data has been sent.
7. The application has a pre-defined signal processing function to handle the aftermath, such as closing the socket.

Use the I/O synchronization model to implement the Proactor mode. Principle: The main thread performs the read and write operations of I/O event data, and the business logic operations are handed over to the logic unit. For example, use epoll to achieve this.

Workflow:

1. The main thread registers the read readiness event on the socket in the epoll kernel event table.
2. The main thread calls epoll_wait to wait for data to be read on the socket.
3. After epoll_wait returns, the main thread reads data from the socket, then encapsulates the read data into a request object (client's request), and inserts it into the request queue.
4. So the consumer thread of the queue processes the request object, and then registers the write-ready event on the socket in the epoll kernel event table.
5. The main thread calls epoll_wait to wait for the socket to be writable.
6. When the socket is writable, epoll_wait notifies the main thread. The main thread writes the request result to the socket.

swoole event architecture diagram

As can be seen from the figure, if we combine the Reactor thread and the Work process and treat it as a worker thread , swoole uses the reactor event processing mode.

The steps a request goes through are as follows:

1. The server main thread waits for the client to connect.

2. The Reactor thread processes the connected socket, reads the request data on the socket (Receive), encapsulates the request and delivers it to the work process.

3. The Work process is a logical unit that processes business data.

4. Work process results are returned to the Reactor thread.

5. The Reactor thread writes the result back to the socket (Send).

Related tutorials: swoole video tutorial

The above is the detailed content of swoole event handling process. For more information, please follow other related articles on the PHP Chinese website!