[Advanced] What are the differences and similarities between workman and swoole?
Workerman and Swoole are very popular at this stage. You have to get to know each other when you have time, otherwise you are not in the PHP circle. Swoole is a socket communication framework implemented in C language, while Workerman is a socket communication framework implemented in pure PHP. There are also many differences in the process models between the two.
Let’s first talk about the process model of swoole. Take a look at the following analysis diagram.
master process
This process is more complex, and it is also the core process in my opinion. This is a process that contains multiple threads, namely One main thread and n reactor threads (the number can be configured). Among them, the main thread is used to accept new connections, and then evaluates the number of connections each reactor thread is responsible for maintaining, and then allocates them to the reactor thread with the smallest number to ensure that the load of each reactor thread is balanced to the greatest extent. Essentially, once a socket is readable or writable, it is sent by the reactor thread to the worker process or sent to the client. In addition, the main thread is also responsible for taking over all signals to avoid interruption when the reactor thread receives signals. To put it bluntly, the master process is responsible for the accept and hosting of the connection, and the readability and writability of the socket (the sending and receiving of data). In essence, the master process is responsible for IO. It should also be noted that the reactor thread is a completely asynchronous and non-blocking working method.
manager process
The manager process is the mother of the worker process and the taskworker process. To put it more arrogantly, the manager process forks the worker process and the taskworker process. Management, therefore, the manager process must be responsible for the maintenance obligations of the worker process and taskworker process, including monitoring their status, restarting a new process when they hang up unexpectedly (avoiding zombie processes), and smooth restarting (that is the legend) reload).
worker process
The worker process is forked by the manager process. To put it bluntly, this process is just moving bricks to work (business code mentioned many times in official documents). In fact, it is the normal process. Those curd business logic codes, do you understand? But what's more interesting about the worker process is that this process can work asynchronously or synchronously. If you don’t understand what it means, just memorize it first and become familiar with it before talking about it.
taskworker process
The taskworker process (hereinafter referred to as the tasker process) is actually essentially a worker process, but it is a special worker process. If there are some time-consuming and labor-intensive operations in your worker process, you can first throw them to the tasker process and do other things yourself. When the tasker is finished, the worker process will retrieve them. This is very convenient. However, the tasker process can only work in synchronous mode and cannot use asynchronous mode. This is why the tasker process cannot use timers, but the worker process can use timers.
Let’s briefly summarize and talk about how these processes work together. To put it simply, the master process is responsible for taking sales jobs, but the specific work is done by the worker process. If the worker process feels that some processes are too busy and complicated, it can let the tasker process do it. The manager process is the human resources support department of the logistics worker process and taker process, responsible for their life and death and eating, drinking and sleeping.
The process model of Workerman is relatively simple. First of all, compared to swoole, Workerman does not have the reactor thread in swoole. Secondly, Workerman does not have the worker process and tasker process used to handle ordinary business. . In the case of workerman, the socket is handled by the worker process, while in swoole it is handled by the reactor thread in the main process. After receiving the data, swoole can process the business through its own worker process (somewhat similar to the fpm process).
workerman is a high-performance PHP socket server framework. Workerman is based on PHP multi-process and libevent event polling library. PHP developers only need to implement one or two interfaces to develop their own network applications, such as Rpc Services, chat room servers, mobile game servers, etc.
Workerman's goal is to make it easier for PHP developers to develop high-performance socket-based application services without having to understand the details of PHP sockets and PHP multi-processes. Workerman itself is a PHP multi-process server framework with PHP process management and socket communication modules, so it can run independently without relying on php-fpm, nginx or apache and other containers.
Workerman has two process models
1. Basic master worker model
2. Master gateway worker model
The master worker model workflow and inter-process relationship are as follows :
Master worker model description:
The master process is the main process, and the conf configuration is read during the startup process. According to the configuration of each application Create a listening socket with IP and port, and then create a corresponding number of child processes, that is, worker processes, based on the number of processes in the configuration. The worker process will automatically inherit the listening socket created by the master process, so that the worker process can independently accept and process client connections. Then the master process enters the signal monitoring logic and listens for the worker process exit signal (after the worker process exits, the system will automatically send a SIGHCLD signal to the master process, and the master process will re-create the child process and replace the missing child process), master The process will also listen to the stop signal (SIGINT) and smooth restart service signal (SIGHUP) sent by the workermand script.
The worker process is a child process derived from the master process and automatically inherits the listening socket of the master process. Each The worker process accepts and handles client connections independently.
The master worker model is more suitable for simple business applications or short connection applications
The master gateway worker model workflow and the relationship between processes are as follows:
Master gateway worker model description:
This model has an additional gateway process group. The workflow is basically the same as the master worker model. The difference is that the worker process does not When dealing directly with the client, there is an additional gateway process between the client and the worker process. The gateway processes network IO and maintains the client's long connection.
The master gateway worker model is very suitable for long connection applications
When our business code uses swoole and workererman in a synchronous blocking manner, swoole is very much like the two-in-one nginx fpm, and workererman It is only equivalent to nginx

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

AI Hentai Generator
Generate AI Hentai for free.

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics



Using Swoole coroutines in Laravel can process a large number of requests concurrently. The advantages include: Concurrent processing: allows multiple requests to be processed at the same time. High performance: Based on the Linux epoll event mechanism, it processes requests efficiently. Low resource consumption: requires fewer server resources. Easy to integrate: Seamless integration with Laravel framework, simple to use.

How to use Swoole to implement a high-performance HTTP reverse proxy server Swoole is a high-performance, asynchronous, and concurrent network communication framework based on the PHP language. It provides a series of network functions and can be used to implement HTTP servers, WebSocket servers, etc. In this article, we will introduce how to use Swoole to implement a high-performance HTTP reverse proxy server and provide specific code examples. Environment configuration First, we need to install the Swoole extension on the server

Swoole and Workerman are both high-performance PHP server frameworks. Known for its asynchronous processing, excellent performance, and scalability, Swoole is suitable for projects that need to handle a large number of concurrent requests and high throughput. Workerman offers the flexibility of both asynchronous and synchronous modes, with an intuitive API that is better suited for ease of use and projects that handle lower concurrency volumes.

Swoole Process allows users to switch. The specific steps are: create a process; set the process user; start the process.

Performance comparison: Throughput: Swoole has higher throughput thanks to its coroutine mechanism. Latency: Swoole's coroutine context switching has lower overhead and smaller latency. Memory consumption: Swoole's coroutines occupy less memory. Ease of use: Swoole provides an easier-to-use concurrent programming API.

To restart the Swoole service, follow these steps: Check the service status and get the PID. Use "kill -15 PID" to stop the service. Restart the service using the same command that was used to start the service.

Swoole in action: How to use coroutines for concurrent task processing Introduction In daily development, we often encounter situations where we need to handle multiple tasks at the same time. The traditional processing method is to use multi-threads or multi-processes to achieve concurrent processing, but this method has certain problems in performance and resource consumption. As a scripting language, PHP usually cannot directly use multi-threading or multi-process methods to handle tasks. However, with the help of the Swoole coroutine library, we can use coroutines to achieve high-performance concurrent task processing. This article will introduce

Swoole is a high-performance PHP network development framework. With its powerful asynchronous mechanism and event-driven features, it can quickly build high-concurrency and high-throughput server applications. However, as the business continues to expand and the amount of concurrency increases, the CPU utilization of the server may become a bottleneck, affecting the performance and stability of the server. Therefore, in this article, we will introduce how to optimize the CPU utilization of the server while improving the performance and stability of the Swoole server, and provide specific optimization code examples. one,