ulimit is a tool in Linux that limits the use of process resources, and supports setting file size, file descriptors, number of processes, memory, and CPU time. 1. Common options include -f (file size), -n (file descriptor), -u (number of processes), -v (virtual memory), -t (CPU time), and -l (locked memory). 2. Supports soft limits (-S, currently in effect but cannot exceed hard limits) and hard limits (-H, set by root). 3. The temporary setting fails after restarting. Persistence needs to be written to the script under /etc/security/limits.conf or /etc/profile.d/. The systemd service also needs to add the Limit parameter to the service file. 4. Pay attention to permission issues (ordinary users cannot increase hard limits), effective scope (only the current shell and subsequent processes), verification method (ulimit -a or /proc//limits) and avoid excessive restrictions causing program exceptions.

In Linux systems, if you want to limit the resources a process can use (such as memory, number of open files, CPU time, etc.), ulimit is a very practical tool. It can be set directly through the shell, without the need for additional software installation, and is suitable for quick configuration.

1. Common resource restrictions and meanings

Before using ulimit , first understand some common resource restriction options:

• -f : Maximum file size (unit is KB)
• -n : The maximum number of file descriptors that can be opened
• -u : The maximum number of processes that can be run by the user
• -v : Upper limit for virtual memory usage (unit is KB)
• -t : CPU usage time upper limit (unit is seconds)
• -l : Lock the upper limit of memory size

These restrictions can be set in the current shell session and affect the process started later. For example:

 ulimit -v 2000000 # Restrict the maximum virtual memory of the process to 2GB

But it should be noted that the setting of ulimit is only valid for the current session and fails after restarting. If you want to persist, you need to write to the configuration file (I will talk about it later).

2. Set soft and hard limits

There are two modes ulimit : soft limit and hard limit :

• Soft limit: The currently effective limit value can be reduced or increased by the user, but cannot exceed the hard limit.
• Hard limit: The upper limit set by the root user cannot break through.

You can use -S or -H to set soft or hard limits respectively. For example:

 ulimit -S -n 1024 # Set soft limits, open up to 1024 files ulimit -H -n 2048 # Set hard limits, allow up to 2048 files

It is usually recommended to set hard limits first and soft limits, otherwise it may fail due to permission issues.

3. Persist ulimit configuration

The temporary setting of ulimit only takes effect on the current terminal, and restart or new terminal will be invalid. To allow the restrictions to take effect for a long time, you can write settings to the system configuration file:

• If you only want to set it for a certain user, modify /etc/security/limits.conf

  Example:

   username soft nofile 1024
  username hard nofile 2048

• If you want to set it for all users, you can create a new .sh file under /etc/profile.d/ and add the ulimit command, for example:

   ulimit -n 1024
  ulimit -v 2000000

  Note: Some services may be started by systemd, and they will not read the shell configuration file. They need to add the parameter LimitNOFILE=1024 to the service file separately.

  ---

  4. Things to note in practical application

  • Permission issue : Only root users can increase the hard limit, and ordinary users can only lower or maintain the original settings.
  • Effective scope : ulimit affects the process started by the current shell. If it is a background service or daemon, special processing may be required.
  • Verify whether it is effective : You can use ulimit -a to view all current restrictions, or check /proc/<pid>/limits</pid> to confirm the limitations of the specific process.
  • Risk of excessive limits : Setting too low limits may cause program crashes or functional abnormalities, such as database connection failure, logs not being written in, etc.

  ---

  Basically that's it. By mastering these key points, you can flexibly control the use of process resources.

  The above is the detailed content of How to limit the resources a process can use with ulimit?. For more information, please follow other related articles on the PHP Chinese website!