Shulou(Shulou.com)06/03 Report--

Blog outline:

First, the installation and function introduction of the apache server; second, the detailed explanation of the three working modes of Apache service; third, the modification of the working mode of apache; fourth, the optimization and modification of the working mode of apache; fifth, the difference between processes and threads.

Preface

We all know that the common web servers on Linux are: apache, nginx, tomcat!

The differences are as follows:

Apache: modular server, supporting many modules, using servlet processing model, synchronous blocking model, changeable working mode, slow processing speed and stable operation for high concurrency scenarios. Nginx: lightweight web server, with few supporting modules, needs the support of third-party modules, adopts epoll processing model, asynchronous non-blocking, suitable for high concurrency scenarios, and simple configuration. Open source subprojects under the tomcat:apache Software Foundation, also known as containers, mainly deal with pages written in java, but can also deal with html pages, with small concurrent links.

So, this post revolves around the apache server.

First, the installation and function introduction of apache server

Introduction to the features of apache Service version 2.4:

MPM supports loading at run time, supports envet working mode, supports asynchronous read and write; each module can specify the log level of output; enhanced expression parser, which separates .html .php through regular matching expressions; request configuration:; millisecond keep alive timeout; supports FQDN virtual host FQDN: global qualified domain name, virtual host can be defined by host host name; support custom variables

As long as you have some understanding of the relevant concepts, let's start the installation.

Prepare before installation:

Download the dependency package I provided and upload it to the web server. Web server is centos 7.x version 1. Start installation: [root@apache ~] # rz # xshell Use the rz command to upload the downloaded tar package to the web server # the following is to extract all source code packages [root@apache ~] # tar zxf openssl-1.0.1u.tar.gz-C / usr/src [root@apache ~] # tar zxf pcre-8.39.tar.gz-C / usr/src [root@apache ~] # tar zxf zlib-1.2.8.tar.gz-C / usr/src [root@apache ~] # tar zxf httpd-2. 4.23.tar.gz-C / usr/src [root@apache ~] # tar zxf apr-1.5.2.tar.gz-C / usr/src [root@apache ~] # tar zxf apr-util-1.5.4.tar.gz-C / usr/src# below start installing the dependency package required for apache [root@apache ~] # cd / usr/src/apr-1.5.2/ [root@apache apr-1.5.2] #. / configure-- Prefix=/usr/local/apr & & make & & make install [root@apache apr-1.5.2] # cd.. / apr-util-1.5.4/ [root@apache apr-util-1.5.4] #. / configure-- prefix=/usr/local/apr-util-- with-apr=/usr/local/apr & & make & & make install [root@apache zlib-1.2.8] # cd.. / zlib-1.2.8/ [root@apache zlib- 1.2.8] #. / configure-- prefix=/usr/local/zlib & & make & & make install [root@apache pcre-8.39] # cd.. / pcre-8.39/ [root@apache pcre-8.39] #. / configure-- prefix=/usr/local/pcre & & make & & make install [root@apache pcre-8.39] # cd. / openssl-1.0.1u/ [root@apache openssl-1.0.1u] #. / config- FPIC-- prefix=/usr/local/openssl enable-shared & & make & & make install# dependency installation is complete Start installing http service [root@apache openssl-1.0.1u] # cd.. / httpd-2.4.23/ [root@apache httpd-2.4.23] #. / configure-- prefix=/usr/local/http-2.4.23-- enable-so-- enable-cgi-- enable-cgid-- enable-ssl-- with-ssl=/usr/local/openssl-- enable-rewrite-- with-pcre=/usr/local/pcre-- with-z=/usr/local / zlib-with-apr=/usr/local/apr-with-apr-util=/usr/local/apr-util-enable-modules=most-enable-mods-shared=most-enable-mpms-shared=all-with-mpm=event-enable-proxy--enable-proxy-fcgi-enable-expires-enable-deflate & & make & & make install [root@apache httpd-2.4.23] # cd / usr/local/http-2.4.23/bin/ [root@apache bin] # ln-sf / Usr/local/http-2.4.23/bin/* / usr/local/bin/ # soft link the apache command [root@apache bin] # apachectl start # to start the apache service Will prompt the following information, it doesn't matter. # if you want to solve the problem, simply add the domain name to the main configuration file of apache: AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using fe80::c94:cd92:5c18:a1. Set the 'ServerName' directive globally to suppress this message

At this point, apache's web page is available.

The relevant explanations for the configuration items when installing the apache service are as follows:

-- enable-so: enable dos support, and you can add additional features after compilation is completed-- enable-cgi: enable cgi general network management interface-- enable-cgid: enable cig general network management interface management program-- enable-ssl:http encrypted transport protocol, and support https protocol. -- enable-rewrite: enable address rewriting function Used to implement hotlink protection-- with- service name = / PATH path: specify the path that depends on the service during installation-- enable-mods-shared=most: install common modules during installation-- enable-mpms-shared=all: install all working modes of apache-- enable-proxy: enable http proxy function-- enable-proxy-fcgi: fcgi protocol that supports the fastcgi Fast Universal Gateway interface-- enable-expires: supports caching-- enable-deflate: supports compression.

Now that the installation is complete, let's talk about the three working modes of apache services.

2. Detailed explanation of the three working modes of Apache service

The three modes of operation of apache services are:

Prefork: pre-spawned child process; worker: multi-process + multi-thread; event: multi-process + multi-thread + epoll processing model; 1. Prefork working mode:

The prefork pattern can be regarded as a very old but stable pattern. When apache starts, it pre-spawns some fork child processes (default is 5), each with only one thread, then waits for the request to come in, and always tries to keep some idle child processes, in order to reduce the overhead of frequently creating and destroying processes. There is only one thread in each child process, and a thread can process only one request at a point in time.

In Unix systems, the parent process usually runs as root to bind port 80, while the child process generated by apache usually runs as a low-privileged user. The user running the child process must have read access to the contents of its service, but must have as few permissions as possible to resources other than the service content.

Comparison of advantages and disadvantages of prefork mode:

Advantages: mature, compatible with all new and old modules. Processes are completely independent of each other, making it very stable. At the same time, there is no need to worry about thread safety. The extension of our commonly used mod_php,PHP does not need to support thread safety, and the prefork mode is very safe. Disadvantages: a process takes up more system resources and consumes more memory. Moreover, it is not good at handling highly concurrent requests, in which case it puts the request in a queue until a process is available before the request is processed.

Summary: prefork working mode is the most efficient, but it uses a lot of memory and is not good at dealing with scenarios with high concurrency. 2. Worker working mode

Compared with prefork mode, worker mode uses multi-process + multi-threading mode. It also pre-fork several child processes (a relatively small number), each of which can generate a number of service threads and a listener thread that accesses the request and passes it to the service thread for processing and reply.

Threads are lighter than processes because threads usually share the memory space of the parent process, so the memory footprint is reduced and performs better than prefork mode in high concurrency scenarios.

In the multi-process + multi-thread mode of worker mode, each process is independent. If an exception occurs in a thread, only part of the service of Apache is affected, not the whole service. Other processes can still work.

Comparison of advantages and disadvantages of worker mode:

Advantages: take up less memory and perform better with high concurrency. Cons: thread safety must be considered because multiple child threads share the memory address of the parent process. If you use keep-alive 's long connection, there may be few requests in between, then blocking occurs, the thread is suspended, and you have to wait until the timeout before it is released. If too many threads are occupied in this way, it will also lead to the availability of unserviced threads in high concurrency scenarios. (this problem will also occur in prefork mode) 3. Event working mode

This is the latest mode in Apache, and it is already steadily available in the current version. It is very similar to the worker mode, the biggest difference is that it solves the problem of resource waste of long-occupied threads in the keep-alive scenario (some threads hang there waiting because they are keep-alive, and there are almost no requests until the timeout).

In the event working mode, there is a special thread to manage these keep-alive-type threads, pass the request to the service thread when a real request comes, and then allow it to be released after execution. In this way, a thread can handle several requests, achieving asynchronous non-blocking.

The event working mode fails when it encounters some incompatible modules and falls back to worker mode, where a worker thread processes a request. Official modules, all of which support event.

Note that event MPM requires Epoll support from the Linux system (Linux 2.6 +) to enable it.

Also, what needs to be added is HTTPS's connection (SSL), which still runs in a worker-like way, and threads are occupied until the connection is closed.

Modify the working mode of apache [root@apache bin] # / etc/init.d/httpd-M # View the module loaded by apache [root@apache bin] # / etc/init.d/httpd-V # View the working mode of apache. # omit part of the content Server's Module Magic Number: 20120211:61Server loaded: APR 1.5.2 APR-UTIL 1.5.4Compiled using: APR 1.5.2 APR-UTIL 1.5.4Architecture: 64-bitServer MPM: event # this line is its working mode threaded: yes (fixed thread count) forked: yes (variable process count). # omit part of the content [root@apache bin] # cd / usr/local/http-2.4.23/conf/ # switch to the specified directory [ Root@apache conf] # vim httpd.conf. # omit part of the content Include conf/extra/httpd-mpm.conf # locate the httpd-mpm here Remove the opening comment symbol. # omit part of the content LoadModule mpm_event_module modules/mod_mpm_event.so#LoadModule mpm_prefork_module modules/mod_mpm_prefork.so#LoadModule mpm_worker_module modules/mod_mpm_worker.so # locate the worker to this line # the three lines above are the three working modes of the apache service, which mode of work is required Just comment out the original working mode # and remove the comment symbol from the desired working mode line, and then start the service (note: start, not restart). # omit part of the content # for example, I now change it to worker working mode, then the configuration is as follows: Include conf/extra/httpd-mpm.conf # locate httpd-mpm here Remove the opening comment symbol. # omit part of the content # LoadModule mpm_event_module modules/mod_mpm_event.so#LoadModule mpm_prefork_module modules/mod_mpm_prefork.soLoadModule mpm_worker_module modules/mod_mpm_ worker.so [root @ apache conf] # / etc/init.d/httpd restart # when restarting, the following information may be prompted because of the domain name It doesn't matter AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using fe80::c94:cd92:5c18:a1. Set the 'ServerName' directive globally to suppress this message# if you want to resolve those prompts, open the apache's main configuration file and make changes: [root@apache conf] # pwd # determine the current path / usr/local/http-2.4.23/conf [root@apache conf] # vim httpd.conf # Open the file and change the line below, which is native IP, if there is a domain name You can directly write the domain name ServerName 192.168.20.4 # without the annotation symbol at the beginning [root@apache conf] # / etc/init.d/httpd-V # to view the working mode of apache again: Apache/2.4.23 (Unix) Server built: Oct 10 2019 20:52:01Server's Module Magic Number: 20120211:61Server loaded: APR 1.5.2, APR-UTIL 1.5.4Compiled using: APR 1.5.2 APR-UTIL 1.5.4Architecture: 64-bitServer MPM: worker # you can find that the change takes effect. # part of the content is omitted. IV. Optimization and modification of apache working mode.

Changing the working mode above is actually calling a configuration file somewhere else, and the calling configuration file is conf/extra/httpd-mpm.conf, which is why when you change the working mode above, you need to remove the comments on the line Include conf/extra/httpd-mpm.conf first, just to call this configuration file.

[root@apache conf] # cat extra/httpd-mpm.conf | egrep-v'^ # | ^ $'# View the contents of its file And filter out comments and blank lines PidFile "logs/httpd.pid" StartServers 5 MinSpareServers 5 MaxSpareServers 10 MaxRequestWorkers 250 MaxConnectionsPerChild 0 StartServers 3 MinSpareThreads 75 MaxSpareThreads 250 ThreadsPerChild 25 MaxRequestWorkers 400 MaxConnectionsPerChild 0 StartServers 3 MinSpareThreads 75 MaxSpareThreads 250 ThreadsPerChild 25 MaxRequestWorkers 400 MaxConnectionsPerChild 0 ThreadStackSize 65536 StartThreads 250 MinSpareThreads 25 MaxSpareThreads 250 MaxThreads 1000 MaxConnectionsPerChild 0 StartServers 2 MinSpareThreads 5 MaxSpareThreads 10 MaxConnectionsPerChild 0 ThreadsPerChild 150 MaxConnectionsPerChild 0 MaxMemFree 2048 MaxMemFree 100

As the above configuration file is too cumbersome to explain, a figure is attached here, which you can refer to to change the above configuration:

Now that my working mode is worker, I can change the above configuration item to optimize its performance by changing as follows (I will deliberately change the value out of its range, make an error, and write its error solution):

[root@apache extra] # pwd / usr/local/http-2.4.23/conf/extra [root@apache extra] # vim httpd-mpm.conf StartServers 5 MinSpareThreads 150 MaxSpareThreads 200001 ThreadsPerChild 25 MaxRequestWorkers 400 MaxConnectionsPerChild 0 [root@apache extra] # / etc/init.d/httpd restart [root@apache extra] # ps-ef | grep httpd | wc-l 8

In the above configuration, although the value of MaxSpareThreads is 200001 (which must exceed its maximum range), there is still no error when restarting. The reason is that the value of MaxRequestWorkers is still 400. This value takes effect and intercepts the value of MaxSpareThreads, so there is no error. Then change it as follows:

[root@apache extra] # vim httpd-mpm.conf StartServers 300 MinSpareThreads 200 MaxSpareThreads 2000001 ThreadsPerChild 25 MaxRequestWorkers 200001 MaxConnectionsPerChild 0 [root@apache extra] # / etc/init.d/httpd restart AH00316: WARNING: MaxRequestWorkers of 200001 is not an integer multiple of ThreadsPerChild of 25, decreasing to nearest multiple 200000, for a maximum of 8000 servers.AH00318: WARNING: MaxRequestWorkers of 200000 would require 8000 servers and would exceed ServerLimit of 16, decreasing to 400. To increase, please see the ServerLimit directive. [root@apache extra] # vim httpd-mpm.conf ServerLimit 2000 StartServers 80 MinSpareThreads 200 MaxSpareThreads 2000 ThreadsPerChild 25 MaxRequestWorkers 2000 MaxConnectionsPerChild 0 [root@apache extra] # / etc/init.d/httpd restart

In the above configuration items, the values of each configuration item have default limits. If you want to change the limit, you need to add the ServerLimit configuration item on the previous line of the configuration item, and the ServerLimit configuration item also has the maximum limit. If you want to modify various values, it is recommended to read the following carefully before making changes.

Worker "StartServers" child processes are generated by the main control process. Each child process contains a fixed number of ThreadsPerChild threads, and each thread processes the request independently. Similarly, in order not to generate threads when the request arrives, MinSpareThreads and MaxSpareThreads set the minimum and maximum number of idle threads. MaxRequestWorkers sets the maximum total number of clients connected at the same time. If the total number of threads in the existing child process does not meet the load, the control process will derive new child processes MinSpareThreads and MaxSpareThreads with maximum default values of 75 and 250, respectively. These two parameters have little effect on the performance of Apache and can be adjusted according to the actual situation. ThreadsPerChild is the most performance-related instruction in worker MPM. The maximum default value for ThreadsPerChild is 64, which is not enough if the load is heavy. The ThreadLimit instruction is used explicitly, and its maximum default value is 20000. The total number of requests that can be processed simultaneously in Worker mode is determined by the total number of child processes multiplied by the ThreadsPerChild value, which should be greater than the equal MaxRequestWorkers. If the load is so heavy that the number of existing child processes cannot be satisfied, the control process will derive new child processes. By default, the maximum number of child processes is 16, and you also need to explicitly declare ServerLimit when you enlarge (the maximum number of processes configured by the system, the maximum is 20000). It is important to note that if ServerLimit is explicitly declared, its value multiplied by ThreadsPerChild must be greater than or equal to MaxRequestWorkers, and MaxRequestWorkers must be an integral multiple of ThreadsPerChild, otherwise Apache will automatically adjust to a corresponding value. Fifth, the difference between process and thread

A thread is an execution unit within a process, and it is also a schedulable entity within a process.

The difference from the process:

Address space: an execution unit within a process; a process has at least one thread; they share the address space of a process; and a process has its own independent address space; resource ownership: a process is a unit of resource allocation and ownership, and threads within the same process share the resources of the process; threads are the basic unit of processor scheduling, but the process is not; both can be executed concurrently.

Processes and threads are the basic units of program running experienced by the operating system, and the system uses this basic unit to realize the concurrency of the system to the application.

The difference between a process and a thread is:

In short, a program has at least one process and a process has at least one thread.

The division scale of threads is smaller than that of processes, which makes multithreaded programs have high concurrency.

In addition, the process has independent memory units during execution, and multiple threads share memory, which greatly improves the process.

The operating efficiency of the order.

-this is the end of this article. Thank you for reading-

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.