linux ulimit命令

ulimit命令描述
ulimit用于shell启动进程所占用的资源.
想象一个状况：我们的Linux主机里面同时登陆了十个人，这十个人同时打开了100个文件，每个文件的大小为10MB，请问一下我们的Linux主机内存要有多大才够？10*100*10=10000MB=10GB，这样，系统不挂掉才怪，为了预防这种情况的发生，所以我们的bash是可以限制用的某些系统资源的，包括可以打开的文件数量、可以使用的CPU时间、可以使用的内存总容量。如何设置？用ulimit吧！

ulimit 用于限制 shell 启动进程所占用的资源，支持以下各种类型的限制：所创建的内核文件的大小、进程数据块的大小、Shell 进程创建文件的大小、内存锁住的大小、常驻内存集的大小、打开文件描述符的数量、分配堆栈的最大大小、CPU 时间、单个用户的最大线程数、Shell 进程所能使用的最大虚拟内存。同时，它支持硬资源和软资源的限制。
作为临时限制，ulimit 可以作用于通过使用其命令登录的 shell 会话，在会话终止时便结束限制，并不影响于其他 shell 会话。而对于长期的固定限制，ulimit 命令语句又可以被添加到由登录 shell 读取的文件中，作用于特定的 shell 用户。

用户进程的有效范围
                  
ulimit 作为对资源使用限制的一种工作，是有其作用范围的。那么，它限制的对象是单个用户，单个进程，还是整个系统呢？事实上，ulimit 限制的是当前 shell 进程以及其派生的子进程。举例来说，如果用户同时运行了两个 shell 终端进程，只在其中一个环境中执行了 ulimit – s 100，则该 shell 进程里创建文件的大小收到相应的限制，而同时另一个 shell 终端包括其上运行的子程序都不会受其影响：

命令格式
ulimit [options] [limit]

参数
-H：hard limit，严格的设置，必定不能超过这个设置的数值
-S：sof limit，警告的设置，可以超过这个设置值，但是若超过则有警告信息。在设置上，通常soft会比hard小，举例来说，soft可设置为80而hard设置为100，那么可以使用到90（因为没有超过100），但介于80~100之间时，系统会有警告信息通知您
-a：后面不接任何参数，可列出所有的限制额度
-c size：设置core文件的最大值.单位:blocks，当某些进程发生错误时，系统可能会将该进程在内存中的信息写成文件（排错用），这种文件就被称为内核文件（core file）。次为限制每个内核文件的最大容量。
-f size：此shell可以创建的最大文件容量（一般可能设置为2GB）单位为KB
-d size: 设置数据段（segment）的最大值.单位:kbytes；
-l size: 设置在内存（lock）中锁定进程的最大值.单位:kbytes；
-t size: 设置CPU使用时间的最大上限.单位:seconds
-n size: 设置内核可以同时打开的文件描述符的最大值.单位:n
-u size：单一用户可以使用的最大进程（process）数量
-s size: 设置堆栈的最大值.单位:kbytes
-v size:设置虚拟内存的最大值.单位:kbytes
具体的 options 含义以及简单示例可以参考以下表格。 

选项 [options]	含义	例子
-H	设置硬资源限制，一旦设置不能增加。	ulimit – Hs 64；限制硬资源，线程栈大小为 64K。
-S	设置软资源限制，设置后可以增加，但是不能超过硬资源设置。	ulimit – Sn 32；限制软资源，32 个文件描述符。
-a	显示当前所有的 limit 信息。	ulimit – a；显示当前所有的 limit 信息。
-c	最大的 core 文件的大小， 以 blocks 为单位。	ulimit – c unlimited； 对生成的 core 文件的大小不进行限制。
-d	进程最大的数据段的大小，以 Kbytes 为单位。	ulimit -d unlimited；对进程的数据段大小不进行限制。
-f	进程可以创建文件的最大值，以 blocks 为单位。	ulimit – f 2048；限制进程可以创建的最大文件大小为 2048 blocks。
-l	最大可加锁内存大小，以 Kbytes 为单位。	ulimit – l 32；限制最大可加锁内存大小为 32 Kbytes。
-m	最大内存大小，以 Kbytes 为单位。	ulimit – m unlimited；对最大内存不进行限制。
-n	可以打开最大文件描述符的数量。	ulimit – n 128；限制最大可以使用 128 个文件描述符。
-p	管道缓冲区的大小，以 Kbytes 为单位。	ulimit – p 512；限制管道缓冲区的大小为 512 Kbytes。
-s	线程栈大小，以 Kbytes 为单位。	ulimit – s 512；限制线程栈的大小为 512 Kbytes。
-t	最大的 CPU 占用时间，以秒为单位。	ulimit – t unlimited；对最大的 CPU 占用时间不进行限制。
-u	用户最大可用的进程数。	ulimit – u 64；限制用户最多可以使用 64 个进程。
-v	进程最大可用的虚拟内存，以 Kbytes 为单位。	ulimit – v 200000；限制最大可用的虚拟内存为 200000 Kbytes。

1、-a参数，下面是root用户的ulimit默认输出

[root@awake ~]# ulimit -a
core file size       (blocks, -c)    0 //0为关闭即不生产core文件，linux下默认是不产生core文件的，要用ulimit -c unlimited开启，并不限制文件大小，设置运行时产生调试信息。
data seg size        (kbytes, -d)    unlimited //啥是数据段？总之这里开启了，并且无限制。
scheduling priority  (-e)            0         //啥是调度优先级？
file size            (blocks, -f)    unlimited //可创建的单一文件的大小
pending signals      (-i)            7795      //啥是等待信号？
max locked memory    (kbytes, -l)    64        //最大可加锁内存大小，以Kbytes为单位，应该是这个用户也就是root的最大独享内存？
max memory size      (kbytes, -m)    unlimited //最大内存大小，无限制（系统有多少就用多少吗？）
open files           (-n)            1024      //同时可打开的文件数量
pipe size            (512 bytes, -p) 8         //管道缓存区大小，不知是干什么的
POSIX message queues (bytes, -q)     819200    //POSIX消息队列
real-time priority   (-r)            0         //实时优先级，不知
stack size           (kbytes, -s)    10240     //线程堆栈大小，10MB
cpu time             (seconds, -t)   unlimited //占用cpu的时间，无限制
max user processes   (-u)            7795      //用户最大可用的进程数，最多可以使用7795个
virtual memory       (kbytes, -v)    unlimited //虚拟内存
file locks           (-x)            unlimited //文件锁，

2、block概念
其实本来这几个概念不是非常难，主要是NND他们的名字都相同，都叫“Block Size”。
a、硬盘上的 block size, 应该是"sector size"，linux的扇区大小是512byte
b、有文件系统的分区的block size, 是"block size"，大小不一，能用tune2fs工具查看，单一文件系统能够支持的单一文件大小与block的大小有关，例如block size为1024byte时，单一文件可达16GB，如果block size为4096byte时，单一文件可达2TB。

[root@RHEL6 ~]# tune2fs -l /dev/sda3 | grep "Block size"
Block size:               4096

c、没有文件系统的分区的block size，也叫“block size”，大小指的是1024 byte
e、Kernel buffer cache 的block size, 就是"block size"，大部分PC是1024
f、磁盘分区的"cylinder size"，用fdisk 能查看。


3、开启或关闭core文件的生成

ulimit -c 可以查看是否打开此选项，若为0则为关闭；其他参数值也是如此查看
ulimit -c 0可手动关闭
ulimit -c 1000 为设置core文件大小最大为1000k
ulimit -c unlimited 设置core文件大小为不限制大小

4、实例限制用户仅能创建10MB以下额容量文件

[root@awake ~]# ulimit -f 10240                          //设置用户可以创建的文件最大值block=10240k即为10M
[root@RHEL6 ~]# ulimit -a | grep "^file size"            //查看
file size (blocks, -f) 10240
[root@awake ~]# dd if=/dev/zero of=desfile bs=1M count=20 //使用dd在当前目录下创建一个名为desfile大小为20M的文件。
File size limit exceeded

5、我们可以通过以下几种方式来使用 ulimit：

• 在用户的启动脚本中

  如果用户使用的是 bash，就可以在用户的目录下的 .bashrc 文件中，加入 ulimit – u 64，来限制用户最多可以使用 64 个进程。此外，可以在与 .bashrc 功能相当的启动脚本中加入 ulimt。

• 在应用程序的启动脚本中

  如果用户要对某个应用程序 myapp 进行限制，可以写一个简单的脚本 startmyapp。

   ulimit – s 512 
   myapp

  以后只要通过脚本 startmyapp 来启动应用程序，就可以限制应用程序 myapp 的线程栈大小为 512K。

• 直接在控制台输入

   user@tc511-ui:~>ulimit – p 256

  限制管道的缓冲区为 256K。

6、用户进程的有效范围

ulimit 作为对资源使用限制的一种工作，是有其作用范围的。那么，它限制的对象是单个用户，单个进程，还是整个系统呢？事实上，ulimit 限制的是当前 shell 进程以及其派生的子进程。举例来说，如果用户同时运行了两个 shell 终端进程，只在其中一个环境中执行了 ulimit – s 100，则该 shell 进程里创建文件的大小收到相应的限制，而同时另一个 shell 终端包括其上运行的子程序都不会受其影响：

Shell 进程 1

 ulimit – s 100 
 cat testFile > newFile 
 File size limit exceeded

Shell 进程 2

 cat testFile > newFile 
 ls – s newFile 
 323669 newFile

那么，是否有针对某个具体用户的资源加以限制的方法呢？答案是有的，方法是通过修改系统的 /etc/security/limits （RHEL6.4的文件位置是/etc/security/limit.conf）配置文件。该文件不仅能限制指定用户的资源使用，还能限制指定组的资源使用。该文件的每一行都是对限定的一个描述，格式如下：

domain 表示用户或者组的名字，还可以使用 * 作为通配符。Type 可以有两个值，soft 和 hard。Item 则表示需要限定的资源，可以有很多候选值，如 stack，cpu，nofile 等等，分别表示最大的堆栈大小，占用的 cpu 时间，以及打开的文件数。通过添加对应的一行描述，则可以产生相应的限制。例如：

 * hard noflle 100

该行配置语句限定了任意用户所能创建的最大文件数是 100。

现在已经可以对进程和用户分别做资源限制了，看似已经足够了，其实不然。很多应用需要对整个系统的资源使用做一个总的限制，这时候我们需要修改 /proc 下的配置文件。/proc 目录下包含了很多系统当前状态的参数，例如 /proc/sys/kernel/pid_max，/proc/sys/net/ipv4/ip_local_port_range 等等，从文件的名字大致可以猜出所限制的资源种类。由于该目录下涉及的文件众多，在此不一一介绍。有兴趣的读者可打开其中的相关文件查阅说明。

回页首

7、ulimit 管理系统资源的例子

ulimit 提供了在 shell 进程中限制系统资源的功能。本章列举了一些使用 ulimit 对用户进程进行限制的例子，详述了这些限制行为以及对应的影响，以此来说明 ulimit 如何对系统资源进行限制，从而达到调节系统性能的功能。

7.1使用 ulimit 限制 shell 的内存使用

在这一小节里向读者展示如何使用 – d，– m 和 – v 选项来对 shell 所使用的内存进行限制。
首先我们来看一下不设置 ulimit 限制时调用 ls 命令的情况：

图 2. 未设置 ulimit 时 ls 命令使用情况

大家可以看到此时的 ls 命令运行正常。下面设置 ulimit：

>ulimit -d 1000 -m 1000 -v 1000

这里再温习一下前面章节里介绍过的这三个选项的含义：

-d：设置数据段的最大值。单位：KB。

-m：设置可以使用的常驻内存的最大值。单位：KB。

-v：设置虚拟内存的最大值。单位：KB。

通过上面的 ulimit 设置我们已经把当前 shell 所能使用的最大内存限制在 1000KB 以下。接下来我们看看这时运行 ls 命令会得到什么样的结果：

 haohe@sles10-hehao:~/code/ulimit> ls test -l 
 /bin/ls: error while loading shared libraries: libc.so.6: failed to map segment 
 from shared object: Cannot allocate memory

从上面的结果可以看到，此时 ls 运行失败。根据系统给出的错误信息我们可以看出是由于调用 libc 库时内存分配失败而导致的 ls 出错。那么我们来看一下这个 libc 库文件到底有多大：

图 3. 查看 libc 文件大小

从上面的信息可以看出，这个 libc 库文件的大小是 1.5MB。而我们用 ulimit 所设置的内存使用上限是 1000KB，小于 1.5MB，这也就充分证明了 ulimit 所起到的限制 shell 内存使用的功能。

7.2使用 ulimit 限制 shell 创建的文件的大小

接下来向读者展示如何使用 -f 选项来对 shell 所能创建的文件大小进行限制。

首先我们来看一下，没有设置 ulimit -f 时的情况：

图 4. 查看文件

现有一个文件 testFile 大小为 323669 bytes，现在使用 cat 命令来创建一个 testFile 的 copy：

图 5. 未设置 ulimit 时创建复本

从上面的输出可以看出，我们成功的创建了 testFile 的拷贝 newFile。

下面我们设置 ulimt – f 100：

> ulimit -f 100

-f 选项的含义是：用来设置 shell 可以创建的文件的最大值。单位是 blocks。

现在我们再来执行一次相同的拷贝命令看看会是什么结果：

图 6. 设置 ulimit 时创建复本

这次创建 testFile 的拷贝失败了，系统给出的出错信息时文件大小超出了限制。在 Linux 系统下一个 block 的默认大小是 512 bytes。所以上面的 ulimit 的含义就是限制 shell 所能创建的文件最大值为 512 x 100 = 51200 bytes，小于 323669 bytes，所以创建文件失败，符合我们的期望。这个例子说明了如何使用 ulimit 来控制 shell 所能创建的最大文件。

7.3使用 ulimit 限制程序所能创建的 socket 数量

考虑一个现实中的实际需求。对于一个 C/S 模型中的 server 程序来说，它会为多个 client 程序请求创建多个 socket 端口给与响应。如果恰好有大量的 client 同时向 server 发出请求，那么此时 server 就会需要创建大量的 socket 连接。但在一个系统当中，往往需要限制单个 server 程序所能使用的最大 socket 数，以供其他的 server 程序所使用。那么我们如何来做到这一点呢？答案是我们可以通过 ulimit 来实现！细心的读者可能会发现，通过前面章节的介绍似乎没有限制 socket 使用的 ulimit 选项。是的，ulimit 并没有哪个选项直接说是用来限制 socket 的数量的。但是，我们有 -n 这个选项，它是用于限制一个进程所能打开的文件描述符的最大值。在 Linux 下一切资源皆文件，普通文件是文件，磁盘打印机是文件，socket 当然也是文件。在 Linux 下创建一个新的 socket 连接，实际上就是创建一个新的文件描述符。如下图所示（查看某个进程当前打开的文件描述符信息）：

图 7. 查看进程打开文件描述符

因此，我们可以通过使用 ulimit – n 来限制程序所能打开的最大文件描述符数量，从而达到限制 socket 创建的数量。

7.4使用 ulimit 限制 shell 多线程程序堆栈的大小（增加可用线程数量）

在最后一个例子中，向大家介绍如何使用 -s（单位 KB）来对线程的堆栈大小进行限制，从而减少整个多线程程序的内存使用，增加可用线程的数量。这个例子取自于一个真实的案例。我们所遇到的问题是系统对我们的多线程程序有如下的限制：

ulimit -v 200000

根据本文前面的介绍，这意味着我们的程序最多只能使用不到 200MB 的虚拟内存。由于我们的程序是一个多线程程序，程序在运行时会根据需要创建新的线程，这势必会增加总的内存需求量。一开始我们对堆栈大小的限制是 1024 （本例子中使用 1232 来说明）：

# ulimit – s 1232

当我们的程序启动后，通过 pmap 来查看其内存使用情况，可以看到多个占用 1232KB 的数据段，这些就是程序所创建的线程所使用的堆栈：

图 8. 程序线程所使用的堆栈

每当一个新的线程被创建时都需要新分配一段大小为 1232KB 的内存空间，而我们总的虚拟内存限制是 200MB，所以如果我们需要创建更多的线程，那么一个可以改进的方法就是减少每个线程的固定堆栈大小，这可以通过 ulimit – s 来实现：

 # ulimit -s 512

我们将堆栈大小设置为 512KB，这时再通过 pmap 查看一下我们的设置是否起作用：

图 9. 设置 ulimit 后堆栈大小

从上面的信息可以看出，我们已经成功的将线程的堆栈大小改为 512KB 了，这样在总内存使用限制不变的情况下，我们可以通过本小节介绍的方法来增加可以创建的线程数，从而达到改善程序的多线程性能。

想要复原ulimit的设置最简单的方法就是注销再登录，否则就是要重新以ulimit设置才行，不过要注意的是一般身份用户如果以ulimit设置了-f的文件大小，那么他只能继续减小文件容量，不能增加文件容量。