linux最大进程数、最大打开文件数
ulimit 是一种 linux 系统的内键功能，它具有一套参数集，用于为由它生成的 shell 进程及其子进程的资源使用设置限制。本文将在后面的章节中详细说明 ulimit 的功能，使用以及它的影响，并以具体的例子来详细地阐述它在限制资源使用方面的影响。
ulimit 的功能和用法
ulimit 功能简述
假设有这样一种情况，当一台 Linux 主机上同时登陆了 10 个人，在系统资源无限制的情况下，这 10 个用户同时打开了 500 个文档，而假设每个文档的大小有 10M，这时系统的内存资源就会受到巨大的挑战。
而实际应用的环境要比这种假设复杂的多，例如在一个嵌入式开发环境中，各方面的资源都是非常紧缺的，对于开启文件描述符的数量，分配堆栈的大小，CPU 时间，虚拟内存大小，等等，都有非常严格的要求。资源的合理限制和分配，不仅仅是保证系统可用性的必要条件，也与系统上软件运行的性能有着密不可分的联系。这时，ulimit 可以起到很大的作用，它是一种简单并且有效的实现资源限制的方式。
ulimit 用于限制 shell 启动进程所占用的资源，支持以下各种类型的限制：所创建的内核文件的大小、进程数据块的大小、Shell 进程创建文件的大小、内存锁住的大小、常驻内存集的大小、打开文件描述符的数量、分配堆栈的最大大小、CPU 时间、单个用户的最大线程数、Shell 进程所能使用的最大虚拟内存。同时，它支持硬资源和软资源的限制。
作为临时限制，ulimit 可以作用于通过使用其命令登录的 shell 会话，在会话终止时便结束限制，并不影响于其他 shell 会话。而对于长期的固定限制，ulimit 命令语句又可以被添加到由登录 shell 读取的文件中，作用于特定的 shell 用户。
在下面的章节中，将详细介绍如何使用 ulimit 做相应的资源限制。
如何使用 ulimit
ulimit 通过一些参数选项来管理不同种类的系统资源。在本节，我们将讲解这些参数的使用。
ulimit 命令的格式为：ulimit [options] [limit]
具体的 options 含义以及简单示例可以参考以下表格。
表 1. ulimit 参数说明
选项 [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。
我们可以通过以下几种方式来使用 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。
用户进程的有效范围
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 配置文件。该文件不仅能限制指定用户的资源使用，还能限制指定组的资源使用。该文件的每一行都是对限定的一个描述，格式如下：
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 等等，从文件的名字大致可以猜出所限制的资源种类。由于该目录下涉及的文件众多，在此不一一介绍。有兴趣的读者可打开其中的相关文件查阅说明。
回页首
ulimit 管理系统资源的例子
ulimit 提供了在 shell 进程中限制系统资源的功能。本章列举了一些使用 ulimit 对用户进程进行限制的例子，详述了这些限制行为以及对应的影响，以此来说明 ulimit 如何对系统资源进行限制，从而达到调节系统性能的功能。
使用 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 内存使用的功能。
使用 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 所能创建的最大文件。
使用 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 创建的数量。
使用 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 了，这样在总内存使用限制不变的情况下，我们可以通过本小节介绍的方法来增加可以创建的线程数，从而达到改善程序的多线程性能。
回页首
总结
综上所述，linux 系统中的 ulimit 指令，对资源限制和系统性能优化提供了一条便捷的途径。从用户的 shell 启动脚本，应用程序启动脚本，以及直接在控制台，都可以通过该指令限制系统资源的使用，包括所创建的内核文件的大小、进程数据块的大小、Shell 进程创建文件的大小、内存锁住的大小、常驻内存集的大小、打开文件描述符的数量、分配堆栈的最大大小、CPU 时间、单个用户的最大线程数、Shell 进程所能使用的最大虚拟内存，等等方面。本文中的示例非常直观的说明了 ulimit 的使用及其产生的效果，显而易见，ulimit 对我们在 Linux 平台的应用和开发工作是非常实用的。
运行在Linux系统上的Java程序运行了一段时间后出现"Too many open files"的异常情况。
这种情况常见于高并发访问文件系统，多线程网络连接等场景。程序经常访问的文件、socket在Linux中都是文件file，系统需要记录每个当前访问file的name、location、access authority等相关信息，这样的一个实体被称为file entry。“open files table”(图中橙色标识)存储这些file entry，以数组的形式线性管理。文件描述符(file descriptor)作为进程到open files table的指针，也就是open files table的下标索引，将每个进程与它所访问的文件关联起来了。
每个进程中都有一个file descriptor table管理当前进程所访问(open or create)的所有文件，文件描述符关联着open files table中文件的file entry。细节不表，对于open files table能容纳多少file entry。Linux系统配置open files table的文件限制，如果超过配置值，就会拒绝其它文件操作的请求，并抛出Too many open files异常。这种限制有系统级和用户级之分。
系统级：
系统级设置对所有用户有效。可通过两种方式查看系统最大文件限制
1 cat /proc/sys/fs/file-max
2 sysctl -a 查看结果中fs.file-max这项的配置数量
如果需要增加配置数量就修改/etc/sysctl.conf文件，配置fs.file-max属性，如果属性不存在就添加。
配置完成后使用sysctl -p来通知系统启用这项配置
用户级：
Linux限制每个登录用户的可连接文件数。可通过 ulimit -n来查看当前有效设置。如果想修改这个值就使用 ulimit -n 命令。
对于文件描述符增加的比例，资料推荐是以2的幂次为参考。如当前文件描述符数量是1024，可增加到2048，如果不够，可设置到4096，依此类推。
在出现Too many open files问题后，首先得找出主要原因。最大的可能是打开的文件或是socket没有正常关闭。为了定位问题是否由Java进程引起，通过Java进程号查看当前进程占用文件描述符情况：
lsof -p $java_pid 每个文件描述符的具体属性
lsof -p $java_pid | wc -l 当前Java进程file descriptor table中FD的总量
分析命令的结果，可判断问题是否由非正常释放资源所引起。
如果我们只是普通用户，只是暂时的修改ulimit -n，可以直接shell命令来修改(ulimit -n 1024000)。但是这个设置时暂时的保留!当我们退出bash后，该值恢复原值。
如果要永久修改ulimit，需要修改/etc/security/limits.conf。
vim /etc/security/limits.conf
# 添加如下的行
* soft nofile 2048
* hard nofile 2048
以下是说明：
* 代表针对所有用户
noproc 是代表最大进程数
nofile 是代表最大文件打开数
添加格式：
[username | @groupname] type resource limit
[username | @groupname]：设置需要被限制的用户名，组名前面加@和用户名区别。也可以用通配符*来做所有用户的限制。
type：有 soft，hard 和 -，soft 指的是当前系统生效的设置值。hard 表明系统中所能设定的最大值。soft 的限制不能比hard 限制高。用 - 就表明同时设置了 soft 和 hard 的值。
resource：
core - 限制内核文件的大小(kb)
date - 最大数据大小(kb)
fsize - 最大文件大小(kb)
memlock - 最大锁定内存地址空间(kb)
nofile - 打开文件的最大数目
rss - 最大持久设置大小(kb)
stack - 最大栈大小(kb)
cpu - 以分钟为单位的最多 CPU 时间
noproc - 进程的最大数目
as - 地址空间限制
maxlogins - 此用户允许登录的最大数目
实例：
username soft nofile 2048
username hard nofile 2048
@groupname soft nofile 2048
@groupname hard nofile 2048
1、查看系统及最大打开文件数
[root@localhost ~]# cat /proc/sys/fs/file-max
65535
2、查看当前用户最大打开文件数
# ulimit -Hn //查看硬限制
# ulimit -Sn //查看软限制
二、设置最大打开文件数
1、系统及的设置
# vi /etc/sysctl.conf
增加：
fs.file-max = 100000
立即生效：
# sysctl -p
2、用户级设置
vi /etc/security/limits.conf
设置如下：
httpd soft nofile 4096
httpd hard nofile 10240
httpd是用户，可以使用通配符*表示所有用户。
要使 limits.conf 文件配置生效，必须要确保 pam_limits.so 文件被加入到启动文件中。
查看 /etc/pam.d/login 文件中有：
session required /lib/security/pam_limits.so
也可以在/etc/profile后面加上ulimit -n 10240
使用如下命令立即生效：
# su - httpd
$ ulimit -Hn 10240
$ ulimit -Sn 4096
一、查看最大打开文件数
1、查看系统及最大打开文件数
[root@localhost ~]# cat /proc/sys/fs/file-max
65535
2、查看当前用户最大打开文件数
# ulimit -Hn //查看硬限制
# ulimit -Sn //查看软限制
二、设置最大打开文件数
1、系统及的设置
# vi /etc/sysctl.conf
增加：
fs.file-max = 100000
立即生效：
# sysctl -p
2、用户级设置
vi /etc/security/limits.conf
设置如下：
httpd soft nofile 4096
httpd hard nofile 10240
httpd是用户，可以使用通配符*表示所有用户。
要使 limits.conf 文件配置生效，必须要确保 pam_limits.so 文件被加入到启动文件中。
查看 /etc/pam.d/login 文件中有：
session required /lib/security/pam_limits.so
也可以在/etc/profile后面加上ulimit -n 10240
使用如下命令立即生效：
# su - httpd
$ ulimit -Hn 10240
$ ulimit -Sn 4096
一个进程，能打开的最大文件个数
################################################################################
打开文件是什么意思?
打开文件是为了获得操作这个文件的句柄。句柄是用来标识对象的。
对句柄形象的理解是你把东西存到管理处，拿到一个存储格子的号码。
如果句柄是一个整数(文件句柄就是这样），更容易想到它的实现是一个固定地址的数组。
句柄的实现, 也可以是一个指针。
应用程序启动后，组成这个程序的各对象是住留在内存的。如果简单地理解，似乎我们只要获知这个内存的首地址，
那么就可以随时用这个地址访问对象。
但是，系统内存管理器经常在内存中来回移动对象，以此来满足各种应用程序的内存需要。
对象被移动意味着它的地址变化了。如何满足这种要求。
为了解决这个问题，操作系统为各应用程序腾出一些内存储地址，用来专门登记各应用对象在内存中的地址变化，
而这个地址(存储单元的位置)本身是不变的。内存管理器在移动对象位置后，把对象新的地址告知这个句柄地址来保存。
这样我们只需记住这个句柄地址就可以间接地知道对象具体在内存中的哪个位置。
这个地址是在对象装载(Load)时由系统分配给的，当系统卸载时(Unload)又释放给系统。
句柄地址(稳定)→记载着→对象在内存中的地址(不稳定)
程序退出会自动关闭文件句柄吗?
程序退出，分配的内存将全部归还系统， 未关闭的句柄也会归还。
------------------------------------------------------------
可打开的文件个数测试代码
------------------------------------------------------------
[hjj@hjj /home/testapp]$ cat fileopennum.c
#include
#include
int main(int argc, char *argv[])
{
int i=0;
int fd;
char name[256];
while(1)
{
sprintf(name,"name%04d.tst",i);
fd=open(name, O_WRONLY|O_CREAT,0777);
if(fd == -1)
{
perror("error create file fd:");
printf("file name:%s\n", name);
break;
}
printf("%s opened,fd:%d\n", name,fd);
i++;
}
printf("press a key to continue...\n");
int c=getchar();
return 0;
}
[hjj@hjj /home/testapp]$ make
g++ -g -c -o fileopennum.o fileopennum.c
g++ -o fileopennum fileopennum.o
[hjj@hjj /home/testapp]$ ./fileopennum
name0000.tst opened,fd:3
name0001.tst opened,fd:4
name0002.tst opened,fd:5
....
name40953.tst opened,fd:40956
name40954.tst opened,fd:40957
name40955.tst opened,fd:40958
name40956.tst opened,fd:40959
error create file fd:: Too many open files
file name:name40957.tst
press a key to continue...
------------------------------------------------------------
lsof 查看打开的文件
------------------------------------------------------------
注意： fd 0,1,2 已经被保留为:stdin,stdout,stderr
下面命令，事件会很漫长...
[hjj@hjj /home/testapp]$ lsof |grep name
fileopenn 19077 hjj 3w REG 253,2 0 3671931 /home/testapp/name0000.tst
fileopenn 19077 hjj 4w REG 253,2 0 3673172 /home/testapp/name0001.tst
fileopenn 19077 hjj 5w REG 253,2 0 3673179 /home/testapp/name0002.tst
fileopenn 19077 hjj 6w REG 253,2 0 3673183 /home/testapp/name0003.tst
.....
下面命令，会很快...
[hjj@hjj /home/testapp]$ lsof -c fileopen
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
fileopenn 19077 hjj cwd DIR 253,2 1372160 3671071 /home/testapp
fileopenn 19077 hjj rtd DIR 253,0 4096 2 /
fileopenn 19077 hjj txt REG 253,2 9172 3671438 /home/testapp/fileopennum
fileopenn 19077 hjj mem REG 253,0 156928 1441817 /lib64/ld-2.12.so
fileopenn 19077 hjj mem REG 253,0 1926800 1441931 /lib64/libc-2.12.so
fileopenn 19077 hjj mem REG 253,0 599384 1442023 /lib64/libm-2.12.so
fileopenn 19077 hjj mem REG 253,0 93320 1447971 /lib64/libgcc_s-4.4.7-20120601.so.1
fileopenn 19077 hjj mem REG 253,0 989840 3100263 /usr/lib64/libstdc++.so.6.0.13
fileopenn 19077 hjj 0u CHR 136,0 0t0 3 /dev/pts/0
fileopenn 19077 hjj 1u CHR 136,0 0t0 3 /dev/pts/0
fileopenn 19077 hjj 2u CHR 136,0 0t0 3 /dev/pts/0
fileopenn 19077 hjj 3w REG 253,2 0 3671931 /home/testapp/name0000.tst
fileopenn 19077 hjj 4w REG 253,2 0 3673172 /home/testapp/name0001.tst
fileopenn 19077 hjj 5w REG 253,2 0 3673179 /home/testapp/name0002.tst
....
下面的命令，针对部分名称最合适，支持通配符。
[hjj@hjj /home/testapp]$ lsof name*
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
fileopenn 20373 hjj 3w REG 253,2 0 3671931 name0000.tst
fileopenn 20373 hjj 4w REG 253,2 0 3673172 name0001.tst
fileopenn 20373 hjj 5w REG 253,2 0 3673179 name0002.tst
....
退出了程序，再用lsof name* 已经没有name...文件句柄了。
文件句柄的可打开个数，由一个系统参数控制，open files
[hjj@hjj /home/testapp]$ ulimit -a
core file size (blocks, -c) 0
data seg size (kbytes, -d) unlimited
scheduling priority (-e) 0
file size (blocks, -f) unlimited
pending signals (-i) 14706
max locked memory (kbytes, -l) 64
max memory size (kbytes, -m) unlimited
open files (-n) 40960
pipe size (512 bytes, -p) 8
POSIX message queues (bytes, -q) 819200
real-time priority (-r) 0
stack size (kbytes, -s) 10240
cpu time (seconds, -t) unlimited
max user processes (-u) 10240
virtual memory (kbytes, -v) unlimited
file locks (-x) unlimited
------------------------------------------------------------
永久修改open files 个数限制。
------------------------------------------------------------
[hjj@hjj /home/testapp]$ cat /etc/security/limits.conf
hjj soft nofile 40960
hjj hard nofile 40960
# End of file
什么是硬限制，硬限制是实际的限制，而软限制，是warnning限制，只会給出warning，
ulimit命令本身就有分软硬设置，加-H就是硬，加-S就是软，没有加上的话，就是两个一起改
默认显示的是软限制.
