精华内容
下载资源
问答
  • 有助于管理ulimit配置的角色。 例子 --- # Example of how to use the role - hosts: myhost vars: ulimit_config: - domain: '*' type: soft item: core value: 0 - domain: '*' type: hard item: rss ...
  • ulimit

    2018-05-04 14:14:02
    ulimit Linux 运维以及脚本干货: 欢迎分享,欢迎folk, 欢迎留言 https://unnunique.github.io/AADocs/skill-docs/linux/ ...

    ulimit Linux 运维以及脚本干货: 欢迎分享,欢迎folk, 欢迎留言
    https://unnunique.github.io/AADocs/skill-docs/linux/
    https://github.com/unnunique/unnunique.github.io/blob/master/AADocs/skill-docs/linux/index.md

    Linux对于每个用户,系统限制其最大进程数。为提高性能,可以根据设备资源情况,
    设置各linux 用户的最大进程数
    可以用ulimit -a 来显示当前的各种用户进程限制。
    下面我把某linux用户的最大进程数设为10000个:
         ulimit -u 10240
         对于需要做许多 socket 连接并使它们处于打开状态的 Java 应用程序而言,
         最好通过使用 ulimit -n xx 修改每个进程可打开的文件数,缺省值是 1024。
         ulimit -n 4096 将每个进程可以打开的文件数目加大到4096,缺省为1024
         其他建议设置成无限制(unlimited)的一些重要设置是:
         数据段长度:ulimit -d unlimited
         最大内存大小:ulimit -m unlimited
         堆栈大小:ulimit -s unlimited
         CPU 时间:ulimit -t unlimited
         虚拟内存:ulimit -v unlimited
      
         暂时地,适用于通过 ulimit 命令登录 shell 会话期间。
         永久地,通过将一个相应的 ulimit 语句添加到由登录 shell 读取的文件中,
         即特定于 shell 的用户资源文件,如:
    1)、解除 Linux 系统的最大进程数和最大文件打开数限制:
            vi /etc/security/limits.conf
            # 添加如下的行
            * soft noproc 11000
            * hard noproc 11000
            * soft nofile 4100
            * hard nofile 4100
           说明:* 代表针对所有用户,noproc 是代表最大进程数,nofile 是代表最大文件打开数
    2)、让 SSH 接受 Login 程式的登入,方便在 ssh 客户端查看 ulimit -a 资源限制:
            a、vi /etc/ssh/sshd_config
                 把 UserLogin 的值改为 yes,并把 # 注释去掉
            b、重启 sshd 服务:
                  /etc/init.d/sshd restart
    3)、修改所有 linux 用户的环境变量文件:
        vi /etc/profile
        ulimit -u 10000
        ulimit -n 4096
        ulimit -d unlimited
        ulimit -m unlimited
        ulimit -s unlimited
        ulimit -t unlimited
        ulimit -v unlimited
     保存后运行#source /etc/profile 使其生效
    /**************************************
    有时候在程序里面需要打开多个文件,进行分析,系统一般默认数量是1024,
    (用ulimit -a可以看到)对于正常使用是够了,但是对于程序来讲,就太少了。
    修改2个文件。
    
    1./etc/security/limits.conf
    vi /etc/security/limits.conf
    加上:
    * soft nofile 8192
    * hard nofile 20480
    
    2./etc/pam.d/login
    session required /lib/security/pam_limits.so
    /**********
    另外确保/etc/pam.d/system-auth文件有下面内容
    session required /lib/security/$ISA/pam_limits.so
    这一行确保系统会执行这个限制。
    
    /***********
    3.一般用户的.bash_profile
    #ulimit -n 1024
    重新登陆ok
    
    ulimit 的作用
      =======================
    
    ulimit:显示(或设置)用户可以使用的资源的限制(limit),这限制分为软限制(当前限制)
    和硬限制(上限),其中硬限制是软限制的上限值,应用程序在运行过
    程中使用的系统资源不超过相应的软限制,任何的超越都导致进程的终止。
    
    参数 描述
    ulimited 不限制用户可以使用的资源,但本设置对可打开的最大文件数(max open files)
    和可同时运行的最大进程数(max user processes)无效
    -a 列出所有当前资源极限
    -c 设置core文件的最大值.单位:blocks
    -d 设置一个进程的数据段的最大值.单位:kbytes
    -f Shell 创建文件的文件大小的最大值,单位:blocks
    -h 指定设置某个给定资源的硬极限。如果用户拥有 root 用户权限,可以增大硬极限。任何用户均可减少硬极限
    -l 可以锁住的物理内存的最大值
    -m 可以使用的常驻内存的最大值,单位:kbytes
    -n 每个进程可以同时打开的最大文件数
    -p 设置管道的最大值,单位为block,1block=512bytes
    -s 指定堆栈的最大值:单位:kbytes
    -S 指定为给定的资源设置软极限。软极限可增大到硬极限的值。如果 -H 和 -S 标志均未指定,极限适用于以上二者
    -t 指定每个进程所使用的秒数,单位:seconds
    -u 可以运行的最大并发进程数
    -v Shell可使用的最大的虚拟内存,单位:kbytes
    -x
    范例1:
    [root@localhost proc]# ulimit -a
    core file size (blocks, -c) 100
    data seg size (kbytes, -d) unlimited
    file size (blocks, -f) unlimited
    pending signals (-i) 2047
    max locked memory (kbytes, -l) 32
    max memory size (kbytes, -m) unlimited
    open files (-n) 1024
    pipe size (512 bytes, -p) 8
    POSIX message queues (bytes, -q) 819200
    stack size (kbytes, -s) 8192
    cpu time (seconds, -t) unlimited
    max user processes (-u) 2047
    virtual memory (kbytes, -v) unlimited
    file locks (-x) unlimited
    [root@localhost proc]#
    输出的每一行由资源名字、(单位,ulimit命令的参数)、软限制组成。详细解释:
    参数 描述
    core file size core文件的最大值为100 blocks,
    data seg size 进程的数据段可以任意大
    file size 文件可以任意大
    pending signals 最多有2047个待处理的信号
    max locked memory 一个任务锁住的物理内存的最大值为32kB
    max memory size 一个任务的常驻物理内存的最大值
    open files 一个任务最多可以同时打开1024的文件
    pipe size 管道的最大空间为4096字节
    POSIX message queues POSIX的消息队列的最大值为819200字节
    stack size 进程的栈的最大值为8192字节
    cpu time 进程使用的CPU时间
    max user processes 当前用户同时打开的进程(包括线程)的最大个数为2047
    virtual memory 没有限制进程的最大地址空间
    file locks 所能锁住的文件的最大个数没有限制
    范例2:通过ulimit命令来限制文件的大小,从而导致拷贝命令的失败
    [root@localhost]ls temp.txt
    ls: temp.txt: 没有那个文件或目录
    [root@localhost]ulimit -f 1 #设置创建文件的最大块(一块=512字节)
    [root@localhost]cat a.c > temp.txt
    文件大小超出限制
    文件a.c的大小是5002字节,而我们设定的创建文件的大小是512字节x1块=512字节 
    
    
    1、修改用戶進程可打開文件數限制
    
    在Linux平台上,無論編寫客戶端程序還是服務端程序,在進行高並發TCP連接處理時,
    最高的並發數量都要受到系統對用戶單一進程同時可打開文件數量的限制(
    這是因為系統為每個TCP連接都要創建一個socket句柄,每個socket句柄同時也是
    一個文件句柄)。可使用ulimit命令查看系統允許當前用戶進程打開的文件數限制:
    
    [speng@as4 ~]$ ulimit -n
    
    1024
    
    這表示當前用戶的每個進程最多允許同時打開1024個文件,這1024個文件中還得除去每個進程必然打開
    的標準輸入,標準輸出,標準錯誤,服務器監聽socket,進程間通訊的unix域socket等文件,那麼剩
    下的可用於客戶端socket連接的文件數就只有大概1024-10=1014個左右。也就是說缺省情況下,
    基於Linux的通訊程序最多允許同時1014個TCP並發連接。
    
    對於想支持更高數量的TCP並發連接的通訊處理程序,就必須修改Linux對當前用戶的進程同時打開的
    文件數量的軟限制(soft limit)和硬限制(hardlimit)。其中軟限制是指Linux在當前系統能夠承受的
    範圍內進一步限制用戶同時打開的文件數;硬限制則是根據系統硬件資源狀況(主要是系統內存)計算出來
    的系統最多可同時打開的文件數量。通常軟限制小於或等於硬限制。
    
    修改上述限制的最簡單的辦法就是使用ulimit命令:
    
    [speng@as4 ~]$ ulimit -n<file_num>
    
    上述命令中,在<file_num>中指定要設置的單一進程允許打開的最大文件數。如果系統回顯類似於
    "Operation notpermitted"之類的話,說明上述限制修改失敗,實際上是因為在<file_num>中
    指定的數值超過了Linux系統對該用戶打開文件數的軟限製或硬限制。因此,就需要修改Linux系統對用戶的關於打開文件數的軟限制和硬限制。
    
    第一步,修改/etc/security/limits.conf文件,在文件中添加如下行:
    
    speng soft nofile 10240
    
    speng hard nofile 10240
    
    其中speng指定了要修改哪個用戶的打開文件數限制,可用'*'號表示修改所有用戶的限制;
    soft或hard指定要修改軟限制還是硬限制;10240則指定了想要修改的新的限制值,
    即最大打開文件數(請注意軟限制值要小於或等於硬限制)。修改完後保存文件。
    
    第二步,修改/etc/pam.d/login文件,在文件中添加如下行:
    
    session required /lib/security/pam_limits.so
    
    這是告訴Linux在用戶完成系統登錄後,應該調用pam_limits.so模塊來設置系統對該用戶
    可使用的各種資源數量的最大限制(包括用戶可打開的最大文件數限制),而pam_limits.so
    模塊就會從/etc/security/limits.conf文件中讀取配置來設置這些限制值。修改完後保存此文件。
    
    第三步,查看Linux系統級的最大打開文件數限制,使用如下命令:
    
    [speng@as4 ~]$ cat /proc/sys/fs/file-max
    
    12158
    
    這表明這台Linux系統最多允許同時打開(即包含所有用戶打開文件數總和)12158個文件,
    是Linux系統級硬限制,所有用戶級的打開文件數限制都不應超過這個數值。通常這個系統級硬限制
    是Linux系統在啟動時根據系統硬件資源狀況計算出來的最佳的最大同時打開文件數限制,
    如果沒有特殊需要,不應該修改此限制,除非想為用戶級打開文件數限制設置超過此限制的值。
    修改此硬限制的方法是修改/etc/rc.local腳本,在腳本中添加如下行:
    
    echo 22158 > /proc/sys/fs/file-max
    
    這是讓Linux在啟動完成後強行將系統級打開文件數硬限制設置為22158。修改完後保存此文件。
    
    完成上述步驟後重啟系統,一般情況下就可以將Linux系統對指定用戶的單一進程允許同時打開的最大
    文件數限制設為指定的數值。如果重啟後用ulimit-n命令查看用戶可打開文件數限制仍然低於上述步驟中
    設置的最大值,這可能是因為在用戶登錄腳本/etc/profile中使用ulimit -n命令已經將用戶可同時打開的
    文件數做了限制。由於通過ulimit-n修改系統對用戶可同時打開文件的最大數限制時,新修改的值只能小於或
    等於上次ulimit-n設置的值,因此想用此命令增大這個限制值是不可能的。所以,如果有上述問題存在,
    就只能去打開/etc/profile腳本文件,在文件中查找是否使用了ulimit-n限制了用戶可同時打開的最大文件數量,
    如果找到,則刪除這行命令,或者將其設置的值改為合適的值,然後保存文件,用戶退出並重新登錄系統即可。
    
    通過上述步驟,就為支持高並發TCP連接處理的通訊處理程序解除關於打開文件數量方面的系統限制。
    
    2、修改網絡內核對TCP連接的有關限制
    
    在Linux上編寫支持高並發TCP連接的客戶端通訊處理程序時,有時會發現儘管已經解除了
    系統對用戶同時打開文件數的限制,但仍會出現並發TCP連接數增加到一定數量時,
    再也無法成功建立新的TCP連接的現象。出現這種現在的原因有多種。
    
    第一種原因可能是因為Linux網絡內核對本地端口號範圍有限制。此時,進一步分析為什麼無法建立TCP連接
    ,會發現問題出在connect()調用返回失敗,查看系統錯誤提示消息是
    "Can't assign requestedaddress"。同時,如果在此時用tcpdump工具監視網絡,
    會發現根本沒有TCP連接時客戶端發SYN包的網絡流量。這些情況說明問題在於本地Linux系統內核中有限制
    。其實,問題的根本原因在於Linux內核的TCP/IP協議實現模塊對系統中所有的客戶端
    TCP連接對應的本地端口號的範圍進行了限制(例如,內核限製本地端口號的範圍為1024~32768之間)。
    當系統中某一時刻同時存在太多的TCP客戶端連接時,由於每個TCP客戶端連接都要佔用一個
    唯一的本地端口號(此端口號在系統的本地端口號範圍限制中),如果現有的TCP客戶端連接已將所
    有的本地端口號佔滿,則此時就無法為新的TCP客戶端連接分配一個本地端口號了,因此系統會在這
    種情況下在connect()調用中返回失敗,並將錯誤提示消息設為"Can't assignrequested 
    address"。有關這些控制邏輯可以查看Linux內核源代碼,以linux2.6內核為例,可以查看tcp_ipv4.c文件中如下函數:
    
    static int tcp_v4_hash_connect(struct sock *sk)
    
    請注意上述函數中對變量sysctl_local_port_range的訪問控制。
    變量sysctl_local_port_range的初始化則是在tcp.c文件中的如下函數中設置:
    
    void __init tcp_init(void)
    
    內核編譯時默認設置的本地端口號範圍可能太小,因此需要修改此本地端口範圍限制。
    
    第一步,修改/etc/sysctl.conf文件,在文件中添加如下行:
    
    net.ipv4.ip_local_port_range = 1024 65000
    
    這表明將系統對本地端口範圍限制設置為1024~65000之間。請注意,本地端口範
    圍的最小值必須大於或等於1024;而端口範圍的最大值則應小於或等於65535。修改完後保存此文件。
    
    第二步,執行sysctl命令:
    
    [speng@as4 ~]$ sysctl -p
    
    如果系統沒有錯誤提示,就表明新的本地端口範圍設置成功。如果按上述端口範圍進
    行設置,則理論上單獨一個進程最多可以同時建立60000多個TCP客戶端連接。
    
    第二種無法建立TCP連接的原因可能是因為Linux網絡內核的IP_TABLE防火牆對最大
    跟踪的TCP連接數有限制。此時程序會表現為在connect()調用中阻塞,如同死機,如
    果用tcpdump工具監視網絡,也會發現根本沒有TCP連接時客戶端發SYN包的網絡流量。
    由於IP_TABLE防火牆在內核中會對每個TCP連接的狀態進行跟踪,跟踪信息將會放在位於內核
    內存中的conntrackdatabase中,這個數據庫的大小有限,當系統中存在過多的TCP連接時,
    數據庫容量不足,IP_TABLE無法為新的TCP連接建立跟踪信息,於是表現為在connect()調用中阻塞
    。此時就必須修改內核對最大跟踪的TCP連接數的限制,方法同修改內核對本地端口號範圍的限制是類似的:
    
    第一步,修改/etc/sysctl.conf文件,在文件中添加如下行:
    
    net.ipv4.ip_conntrack_max = 10240
    
    這表明將系統對最大跟踪的TCP連接數限制設置為10240。請注意,此限制值要盡量小,以節省對內核內存的佔用。
    
    第二步,執行sysctl命令:
    
    [speng@as4 ~]$ sysctl -p
    
    如果系統沒有錯誤提示,就表明系統對新的最大跟踪的TCP連接數限制修改成功。
    如果按上述參數進行設置,則理論上單獨一個進程最多可以同時建立10000多個TCP客戶端連接。
    
    *******注*******
    
    sysctl -p 報錯net.ipv4.ip_conntrack_max" is an unknown key 則:modprobe ip_conntrack
    
    展开全文
  • 为提高性能,可以根据设备资源情况,设置各linux用户的最大进程数,我们可以用ulimit来显示当前的各种用户进程限制。 ulimit为shell内建命令,可用来控制shell执行程序的资源。 语法格式:ulimit [参数] 常用参数...
  • ulimit设置句柄数

    2021-03-23 14:09:34
    放到服务器上运行一段时间抛出Toomanyopenfiles的异常。...放到服务器上运行一段时间抛出Toomanyopenfiles的异常。  异常信息简单的信息如下:  I/Oexception(java.net.SocketException)caughtwhenprocessingrequest:...
  • 验证-ulimit 验证当前 ulimit
  • ulimit 命令详解

    千次阅读 2019-02-20 10:51:53
    可以用ulimit -a 来显示当前的各种用户进程限制。 下面我把某linux用户的最大进程数设为10000个:  ulimit -u 10240  对于需要做许多 socket 连接并使它们处于打开状态的 Java 应用程序而言,  最好通过使用 ...

    Linux对于每个用户,系统限制其最大进程数。为提高性能,可以根据设备资源情况,设置各linux 用户的最大进程数
    可以用ulimit -a 来显示当前的各种用户进程限制。

    下面我把某linux用户的最大进程数设为10000个:
        ulimit -u 10240
        对于需要做许多 socket 连接并使它们处于打开状态的 Java 应用程序而言,
        最好通过使用 ulimit -n xx 修改每个进程可打开的文件数,缺省值是 1024。
        ulimit -n 4096 将每个进程可以打开的文件数目加大到4096,缺省为1024
        其他建议设置成无限制(unlimited)的一些重要设置是:
        数据段长度:ulimit -d unlimited
        最大内存大小:ulimit -m unlimited
        堆栈大小:ulimit -s unlimited
        CPU 时间:ulimit -t unlimited
        虚拟内存:ulimit -v unlimited
      
        暂时地,适用于通过 ulimit 命令登录 shell 会话期间。
        永久地,通过将一个相应的 ulimit 语句添加到由登录 shell 读取的文件中, 即特定于 shell 的用户资源文件,如:
    1)、解除 Linux 系统的最大进程数和最大文件打开数限制:
            vi /etc/security/limits.conf
            # 添加如下的行
            * soft noproc 11000
            * hard noproc 11000
         

    展开全文
  • linux中ulimit作用

    2021-05-28 15:15:12
    linux中ulimit作用 一、作用 Linux对于每个用户,系统限制其最大进程数。为提高性能,可以根据设备资源情况,设置各linux 用户的最大进程数。 ulimit主要是用来限制进程对资源的使用情况的,它支持各种类型的...

    linux中ulimit作用

    一、作用

    Linux对于每个用户,系统限制其最大进程数。为提高性能,可以根据设备资源情况,设置各linux 用户的最大进程数。

     

    ulimit主要是用来限制进程对资源的使用情况的,它支持各种类型的限制,常用的有:
    
    内核文件的大小限制
    进程数据块的大小限制
    
    Shell进程创建文件大小限制
    
    可加锁内存大小限制
    
    常驻内存集的大小限制
    
    打开文件句柄数限制
    
    分配堆栈的最大大小限制
    
    CPU占用时间限制用户最大可用的进程数限制
    
    Shell进程所能使用的最大虚拟内存限制

     

     

    有个疑问:服务器资源是有限制的,limits.conf会限制资源,但是对于ulimit来说限制是粒度是哪些?  

    1)用户 ? 进程? 

    2)如果是进程的限制,系统中会有多个进程,那所有的进程同时需要受限于用户或整个系统的资源限制。

     

     

    二、用法

    ulimit使用的基本格式为:ulimit [options] [limit]

    具体的options参数含义如下表所示:

     

    选项 含义
    
    -a 显示当前系统所有的limit资源信息。 
    
    -H 设置硬资源限制,一旦设置不能增加。
    
    -S 设置软资源限制,设置后可以增加,但是不能超过硬资源设置。
    
    -c 最大的core文件的大小,以 blocks 为单位。
    
    -f 进程可以创建文件的最大值,以blocks 为单位.
    
    -d 进程最大的数据段的大小,以Kbytes 为单位。
    
    -m 最大内存大小,以Kbytes为单位。
    
    -n 查看进程可以打开的最大文件描述符的数量。
    
    -s 线程栈大小,以Kbytes为单位。
    
    -p 管道缓冲区的大小,以Kbytes 为单位。
    
    -u 用户最大可用的进程数。
    
    -v 进程最大可用的虚拟内存,以Kbytes 为单位。
    
    -t 最大CPU占用时间,以秒为单位。
    
    -l 最大可加锁内存大小,以Kbytes 为单位。

     

     其中ulimit -n用于限制进程能够打开的文件描述符的最大数目。因为任何设备在linux下都是文件,通信的接口也有专门的接口文件负责,所以linux下进程tcp链接的最大并发量也受限于该值。

     

    [root@centos5 ~]# ulimit -a
    core file size          (blocks, -c) 0
    data seg size           (kbytes, -d) unlimited
    max nice                        (-e) 0
    file size               (blocks, -f) unlimited
    pending signals                 (-i) 4096
    max locked memory       (kbytes, -l) 32
    max memory size         (kbytes, -m) unlimited
    open files                      (-n) 1024
    pipe size            (512 bytes, -p) 8
    POSIX message queues     (bytes, -q) 819200
    max rt priority                 (-r) 0
    stack size              (kbytes, -s) 10240
    cpu time               (seconds, -t) unlimited
    max user processes              (-u) 4096
    virtual memory          (kbytes, -v) unlimited
    file locks                      (-x) unlimited||<

    其中 "open files (-n) 1024 "是Linux操作系统对一个进程打开的文件句柄数量的限制(也包含打开的SOCKET数量,可影响MySQL的并发连接数目)。

    这个值可用ulimit 命令来修改,但ulimit命令修改的数值只对当前登录用户的目前使用环境有效,系统重启或者用户退出后就会失效.

     

    有时候为了方便起见,也可以将用户资源的限制统一由一个文件来配置,这个文件就是/etc/security/limits.conf,该文件不但能对指定用户的资源进行限制,还能对指定组的资源进行限制。该文件的使用规则如下:

     <domain> <type> <item> <value> 

    其中:

    domain表示用户或者组的名字,还可以使用 * 作为通配符,表示任何用户或用户组。

    Type 表示限制的类型,可以有两个值,soft 和 hard,分别表示软、硬资源限制。软限制是指限制用户同时打开的文件数目,硬限制是指系统根据硬件资源(主要指内存)计算出来的最多可打开的文件数目。通常软限制低于硬限制;建议不要将软限制和硬限制修改过大。

    item 表示需要限定的资源名称,常用的有nofile、cpu、stack等。分别表示最大打开句柄数、占用的cpu时间、最大的堆栈大小。

    value 表示限制各种资源的具体数值。

    除了limits.conf文件之外,还有一个/etc/security/limits.d目录,可以将资源限制创建一个文件放到这个目录中,默认系统会首先去读取这个目录下的所有文件,然后才去读取limits.conf文件。所有资源限制设置完成后,退出shell终端,再次登录shell终端后,ulimit设置即可自动生效。

     注意:各种配置的生效方式。 

     

    对于需要做许多 socket 连接并使它们处于打开状态的Java 应用程序而言,最好通过使用 ulimit -n xx 修改每个进程可打开的文件数,缺省值是 1024。

    ulimit -n 4096 将每个进程可以打开的文件数目加大到4096,缺省为1024

    其他建议设置成无限制(unlimited)的一些重要设置是:
    数据段长度:ulimit -d unlimited
    最大内存大小:ulimit -m unlimited
    堆栈大小:ulimit -s unlimited
    CPU 时间:ulimit -t unlimited
    虚拟内存:ulimit -v unlimited

     

     

    配置生效方式

        暂时地,适用于通过 ulimit 命令登录 shell 会话期间。
        永久地,通过将一个相应的 ulimit 语句添加到由登录 shell 读取的文件中, 即特定于 shell 的用户资源文件,如:
    1)、解除 Linux 系统的最大进程数和最大文件打开数限制:
            vi /etc/security/limits.conf
            # 添加如下的行
            * soft noproc 11000
            * hard noproc 11000
            * soft nofile 4100
            * hard nofile 4100
          说明:* 代表针对所有用户,noproc 是代表最大进程数,nofile 是代表最大文件打开数
    2)、让 SSH 接受 Login 程式的登入,方便在 ssh 客户端查看 ulimit -a 资源限制:
            a、vi /etc/ssh/sshd_config
                把 UserLogin 的值改为 yes,并把 # 注释去掉
            b、重启 sshd 服务:
                  /etc/init.d/sshd restart
    3)、修改所有 linux 用户的环境变量文件:
        vi /etc/profile
        ulimit -u 10000
        ulimit -n 4096
        ulimit -d unlimited
        ulimit -m unlimited
        ulimit -s unlimited
        ulimit -t unlimited
        ulimit -v unlimited
     保存后运行#source /etc/profile 使其生效

     

    在使用ulimit时,有以下几种使用方法:

    (1)在用户环境变量中加入

    如果用户使用的是bash,那么就可以在用户目录的环境变量文件.bashrc或者.bash_profile中加入“ulimit -u 128”来限制用户最多可以使用128个进程。

    (2)在应用程序的启动脚本中加入

    如果应用程序是tomcat,那么就可以在tomcat的启动脚本startup.sh脚本中加入“ulimit -n 65535”来限制用户最多可以使用65535个文件描述符。

    (3)直接在shell命令终端执行ulimit命令

    这种方法的资源限制仅仅在执行命令的终端生效,退出或者关闭终端后,设置失效,并且这个设置不影响其它shell终端。

     

    公司服务器需要调整 ulimit的stack size 参数调整为unlimited 无限,使用ulimit -s unlimited时只能在当时的shell见效,重开一个shell就失效了。。于是得在/etc/profile 的最后面添加ulimit -s unlimited 就可以了,source /etc/profile使修改文件生效。


    如果碰到类似的错误提示ulimit: max user processes: cannot modify limit: 不允许的操作 ulimit: open files: cannot modify limit: 不允许的操作
    为啥root用户是可以的?普通用户又会遇到这样的问题?
    看一下/etc/security/limits.conf大概就会明白。
    linux对用户有默认的ulimit限制,而这个文件可以配置用户的硬配置和软配置,硬配置是个上限。超出上限的修改就会出“不允许的操作”这样的错误。
    在limits.conf加上
    *        soft    noproc 10240
    *        hard    noproc 10240
    *        soft    nofile 10240
    *        hard    nofile 10240
    就是限制了任意用户的最大进程数和文件数为10240。

     

    如何设置普通用户的ulimit值

    1、vim /etc/profile

    增加 ulimit -n 10240

    source /etc/profile 重新启动就不需要运行这个命令了。

    2、修改/etc/security/limits.conf

    增加

    *      hard     nofile     10240   

    \\限制打开文件数10240

    3、测试,新建普通用户,切换到普通用户使用ulit -a 查看是否修改成功。

     

    查看系统级别资源限制:

    1.系统级别:

    sysctl -a (-a:显示当前所有可用的值)

    系统总限制:cat /proc/sys/fs/file-max 等一系列值,修改/etc/sysctl.conf 中也可以控制

     /proc/sys/fs/file-nr,可以看到整个系统目前使用的文件句柄数量

     

    修改此硬限制的方法是修改/etc/rc.local脚本,在脚本中添加如下行:

    echo 8000037 > /proc/sys/fs/file-max

    这是让Linux在启动完成后强行将系统级打开文件数硬限制设置为800037。

    这表明这台Linux系统最多允许同时打开(即包含所有用户打开文件数总和)800037个文件,是Linux系统级硬限制,所有用户级的打开文件数限制都不应超过这个数值。该值是Linux系统在启动时根据系统硬件资源状况计算出来的最佳的最大同时打开文件数限制,如果没有特殊需要,不应该修改此限制,除非想为用户级打开文件数限制设置超过此限制的值。

     

    查找文件句柄问题的时候,lsof可以很方便看到某个进程开了那些句柄.也可以看到某个文件/目录被什么进程占用了.

     

    2.session 设置:

    ulimit -a # 查看所有的 

    ulimit -S -n1024 #设置当前会话的打开文件数软连接数为 1024.

    ulimit -H -n1024 #设置当前会话的打开文件数硬连接数为 1024.

    ulimit -n 996 #设置当前会话的打开文件数硬&&软连接数都为 1024.

     

    3.设置用户(只针对用户的每个进程):

    #<domain> <type> <item> <value>

    #

    * soft nofile 32768

    * hard nofile 65536

     

    ulimit -n vs. file-max ? 
    简单的说, ulimit -n控制进程级别能够打开的文件句柄的数量, 而max-file表示系统级别的能够打开的文件句柄的数量。

    ulimit -n的设置在重启机器后会丢失,因此需要修改limits.conf的限制,limits.conf中有两个值soft和hard,soft代表只警告,hard代表真正的限制

    Cat /etc/security/limits.conf

    *               soft    nofile          150000  
    *               hard    nofile          150000  

    这里我们把soft和hard设置成一样的。

    “cat /proc/sys/fs/file-max”,或“sysctl -a | grep fs.file-max”查看系统能打开的最大文件数。查看和设置例如:

     

    [root@vm014601 ~]# sysctl -a |grep fs.file-max  
    fs.file-max = 200592  
    [root@vm014601 ~]# echo "fs.file-max = 2005920" >> /etc/sysctl.conf   
    [root@vm014601 ~]# sysctl -p  
    [root@vm014601 ~]# cat /proc/sys/fs/file-max                          
    2005920

     

    file-nr是只读文件,第一个数代表了目前分配的文件句柄数;第二个数代表了系统分配的最大文件句柄数;比如线上系统查看结果:

     

    # cat /proc/sys/fs/file-max  
    1106537  
    # cat /proc/sys/fs/file-nr       
    1088  0       1106537  
    # lsof | wc -l  
    1506

     

    可以看到file-nr和lsof的值不是很一致,但是数量级一致。为什么会不一致?原因如下: 

    写到lsof是列出系统所占用的资源,但是这些资源不一定会占用打开文件号的。如共享内存,信号量,消息队列,内存映射.等,虽然占用了这些资源,但不占用打开文件号.

    我曾经在前端机上很长时间都无法得到lsof | wc -l 的结果,这个时候可以通过file-nr粗略的估算一下打开的文件句柄数。

    展开全文
  • 一般可以通过ulimit命令或编辑/etc/security/limits.conf重新加载的方式使之生效通过ulimit比较直接,但只在当前的session有效,limits.conf中可以根据用户和限制项使用户在下次登录中生效.对于limits.conf的设定是...

    一般可以通过ulimit命令或编辑/etc/security/limits.conf重新加载的方式使之生效

    通过ulimit比较直接,但只在当前的session有效,limits.conf中可以根据用户和限制项使用户在下次登录中生效.

    对于limits.conf的设定是通过pam_limits.so的加载生效的,比如/etc/pam.d/sshd,这样通过ssh登录时会加载limit.

    又或者在/etc/pam.d/login加载生效.

    下面将对各种限制进行分析

    core file size          (blocks, -c) 0

    data seg size           (kbytes, -d) unlimited

    scheduling priority             (-e) 20 a

    file size               (blocks, -f) unlimited a

    pending signals                 (-i) 16382

    max locked memory       (kbytes, -l) 64 a

    max memory size         (kbytes, -m) unlimited a

    open files                      (-n) 1024 a

    pipe size            (512 bytes, -p) 8

    POSIX message queues     (bytes, -q) 819200

    real-time priority              (-r) 0

    stack size              (kbytes, -s) 8192

    cpu time               (seconds, -t) unlimited

    max user processes              (-u) unlimited

    virtual memory          (kbytes, -v) unlimited

    file locks                      (-x) unlimited

    一)限制进程产生的文件大小(file size)

    先来说说ulimit的硬限制和软限制

    硬限制用-H参数,软限制用-S参数.

    ulimit -a看到的是软限制,通过ulimit -a -H可以看到硬限制.

    如果ulimit不限定使用-H或-S,此时它会同时把两类限制都改掉的.

    软限制可以限制用户/组对资源的使用,硬限制的作用是控制软限制.

    超级用户和普通用户都可以扩大硬限制,但超级用户可以缩小硬限制,普通用户则不能缩小硬限制.

    硬限制设定后,设定软限制时只能是小于或等于硬限制.

    下面的测试应用于硬限制和软限制.

    1)软限制不能超过硬限制

    在超级用户下,同时修改硬/软限制,使当前会话只能建100KB的文件

    ulimit -f 100

    查看当前创建文件大小的硬限制为100KB

    ulimit -H -f

    100

    此时限制当前会话的软限制为1000KB,出现不能修改的报错

    ulimit -S -f 1000

    -bash: ulimit: file size: cannot modify limit: Invalid argument

    2)硬限制不能小于软限制

    在超级用户下,用户查看当前的软限制,此时为unlmiited

    ulimit -S -f

    unlimited

    此时修改当前会话创建文件大小的硬限制为1000KB,出现不能修改的报错,说明硬限制不能小于软限制

    ulimit -H -f 1000

    -bash: ulimit: file size: cannot modify limit: Invalid argument

    如果我们把创建文件大小的软限制改为900KB,此后就可以修改它的硬限制了

    ulimit -S -f 900

    ulimit -H -f 1000

    3)普通用户只能缩小硬限制,超级用户可以扩大硬限制

    用普通用户进入系统

    su - test

    查看创建文件大小的硬限制

    ulimit -H -f

    unlimited

    此时可以缩小该硬限制

    ulimit -H -f 1000

    但不能扩大该硬限制

    ulimit -H -f 10000

    4)硬限制控制软限制,软限制来限制用户对资源的使用

    用软限制限制创建文件的大小为1000KB

    ulimit -S -f 1000

    用硬限制限制创建文件的大小为2000KB

    ulimit -H -f 2000

    创建3MB大小的文件

    dd if=/dev/zero of=/tmp/test bs=3M count=1

    File size limit exceeded

    查看/tmp/test的大小为1000KB,说明软限制对资源的控制是起决定性作用的.

    ls -lh /tmp/test

    -rw-r--r-- 1 root root 1000K 2010-10-15 23:04 /tmp/test

    file size单位是KB.

    二)关于进程优先级的限制(scheduling priority)

    这里的优先级指NICE值

    这个值只对普通用户起作用,对超级用户不起作用,这个问题是由于CAP_SYS_NICE造成的.

    例如调整普通用户可以使用的nice值为-10到20之间.

    硬限制nice的限制为-15到20之间.

    ulimit -H -e 35

    软限制nice的限制为-10到20之间

    ulimit -S -e 30

    用nice命令,使执行ls的nice值为-10

    nice -n -10 ls /tmp

    ssh-BossiP2810  ssh-KITFTp2620  ssh-vIQDXV3333

    用nice命令,使执行ls的nice值为-11,此时超过了ulimit对nice的软限制,出现了异常.

    nice -n -11 ls /tmp

    nice: cannot set niceness: Permission denied

    三)内存锁定值的限制(max locked memory)

    这个值只对普通用户起作用,对超级用户不起作用,这个问题是由于CAP_IPC_LOCK造成的.

    linux对内存是分页管理的,这意味着有不需要时,在物理内存的数据会被换到交换区或磁盘上.

    有需要时会被交换到物理内存,而将数据锁定到物理内存可以避免数据的换入/换出.

    采用锁定内存有两个理由:

    1)由于程序设计上需要,比如oracle等软件,就需要将数据锁定到物理内存.

    2)主要是安全上的需要,比如用户名和密码等等,被交换到swap或磁盘,有泄密的可能,所以一直将其锁定到物理内存.

    锁定内存的动作由mlock()函数来完成

    mlock的原型如下:

    int mlock(const void *addr,size_t len);

    测试程序如下:

    #include

    #include

    int main(int argc, char* argv[])

    {

    int array[2048];

    if (mlock((const void *)array, sizeof(array)) == -1) {

    perror("mlock: ");

    return -1;

    }

    printf("success to lock stack mem at: %p, len=%zd\n",

    array, sizeof(array));

    if (munlock((const void *)array, sizeof(array)) == -1) {

    perror("munlock: ");

    return -1;

    }

    printf("success to unlock stack mem at: %p, len=%zd\n",

    array, sizeof(array));

    return 0;

    }

    gcc mlock_test.c -o mlock_test

    上面这个程序,锁定2KB的数据到物理内存中,我们调整ulimit的max locked memory.

    ulimit -H -l 4

    ulimit -S -l 1

    ./mlock_test

    mlock: : Cannot allocate memory

    我们放大max locked memory的限制到4KB,可以执行上面的程序了.

    ulimit -S -l 4

    ./mlock_test

    success to lock stack mem at: 0x7fff1f039500, len=2048

    success to unlock stack mem at: 0x7fff1f039500, len=2048

    注意:如果调整到3KB也不能执行上面的程序,原因是除了这段代码外,我们还会用其它动态链接库.

    四)进程打开文件的限制(open files)

    这个值针对所有用户,表示可以在进程中打开的文件数.

    例如我们将open files的值改为3

    ulimit -n 3

    此时打开/etc/passwd文件时失败了.

    cat /etc/passwd

    -bash: start_pipeline: pgrp pipe: Too many open files

    -bash: /bin/cat: Too many open files

    五)信号可以被挂起的最大数(pending signals)

    这个值针对所有用户,表示可以被挂起/阻塞的最大信号数量

    我们用以下的程序进行测试,源程序如下:

    #include

    #include

    #include

    #include

    #include

    volatile int done = 0;

    void handler (int sig)

    {

    const char *str = "handled...\n";

    write (1, str, strlen(str));

    done = 1;

    }

    void child(void)

    {

    int i;

    for (i = 0; i < 3; i++){

    kill(getppid(), SIGRTMIN);

    printf("child - BANG!\n");

    }

    exit (0);

    }

    int main (int argc, char *argv[])

    {

    signal (SIGRTMIN, handler);

    sigset_t newset, oldset;

    sigfillset(&newset);

    sigprocmask(SIG_BLOCK, &newset, &oldset);

    pid_t pid = fork();

    if (pid == 0)

    child();

    printf("parent sleeping \n");

    int r = sleep(3);

    printf("woke up! r=%d\n", r);

    sigprocmask(SIG_SETMASK, &oldset, NULL);

    while (!done){

    };

    printf("exiting\n");

    exit(0);

    }

    编译源程序:

    gcc test.c -o test

    执行程序test,这时子程序发送了三次SIGRTMIN信号,父程序在过3秒后,接收并处理该信号.

    ./test

    parent sleeping

    child - BANG!

    child - BANG!

    child - BANG!

    woke up! r=0

    handled...

    handled...

    handled...

    exiting

    注意:这里有采用的是发送实时信号(SIGRTMIN),如:kill(getppid(), SIGRTMIN);

    如果不是实时信号,则只能接收一次.

    如果我们将pending signals值改为2,这里将只能保证挂起两个信号,第三个信号将被忽略.如下:

    ulimit -i 2

    ./test

    parent sleeping

    child - BANG!

    child - BANG!

    child - BANG!

    woke up! r=0

    handled...

    handled...

    exiting

    六)可以创建使用POSIX消息队列的最大值,单位为bytes.(POSIX message queues)

    我们用下面的程序对POSIX消息队列的限制进行测试,如下:

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    struct message{

    char mtext[128];

    };

    int send_msg(int qid, int pri, const char text[])

    {

    int r = mq_send(qid, text, strlen(text) + 1,pri);

    if (r == -1){

    perror("mq_send");

    }

    return r;

    }

    void producer(mqd_t qid)

    {

    send_msg(qid, 1, "This is my first message.");

    send_msg(qid, 1, "This is my second message.");

    send_msg(qid, 3, "No more messages.");

    }

    void consumer(mqd_t qid)

    {

    struct mq_attr mattr;

    do{

    u_int pri;

    struct message msg;

    ssize_t len;

    len = mq_receive(qid, (char *)&msg, sizeof(msg), &pri);

    if (len == -1){

    perror("mq_receive");

    break;

    }

    printf("got pri %d '%s' len=%d\n", pri, msg.mtext, len);

    int r = mq_getattr(qid, &mattr);

    if (r == -1){

    perror("mq_getattr");

    break;

    }

    }while(mattr.mq_curmsgs);

    }

    int

    main (int argc, char *argv[])

    {

    struct mq_attr mattr = {

    .mq_maxmsg = 10,

    .mq_msgsize = sizeof(struct message)

    };

    mqd_t mqid = mq_open("/myq",

    O_CREAT|O_RDWR,

    S_IREAD|S_IWRITE,

    &mattr);

    if (mqid == (mqd_t) -1){

    perror("mq_open");

    exit (1);

    }

    pid_t pid = fork();

    if (pid == 0){

    producer(mqid);

    mq_close(mqid);

    exit(0);

    }

    else

    {

    int status;

    wait(&status);

    consumer(mqid);

    mq_close(mqid);

    }

    mq_unlink("/myq");

    return 0;

    }

    编译:

    gcc test.c -o test

    限制POSIX消息队列的最大值为1000个字节

    ulimit -q 1000

    这里我们执行test程序

    ./test

    mq_open: Cannot allocate memory

    程序报告无法分配内存.

    用strace来跟踪test的运行过程,在下面一条语句时报错.

    mq_open("myq", O_RDWR|O_CREAT, 0600, {mq_maxmsg=10, mq_msgsize=128}) = -1 ENOMEM (Cannot allocate memory)

    {mq_maxmsg=10, mq_msgsize=128}即128*10=1280个字节,说明已经超过了1000个字节的POSIX消息队列限制.

    我们将POSIX消息队列的最大值调整为1360时,程序可以运行.

    ulimit -q 1360

    ./test

    got pri 3 'No more messages.' len=18

    got pri 1 'This is my first message.' len=26

    got pri 1 'This is my second message.' len=27

    七)程序占用CPU的时间,单位是秒(cpu time)

    我们用下面的代码对程序占用CPU时间的限制进行测试

    源程序如下:

    # include

    # include

    int main (void)

    {

    double pi=M_PI;

    double pisqrt;

    long i;

    while(1){

    pisqrt=sqrt(pi);

    }

    return 0;

    }

    编译:

    gcc test.c -o test -lm

    运行程序test,程序会一直循环下去,只有通过CTRL+C中断.

    ./test

    ^C

    用ulimit将程序占用CPU的时间改为2秒,再运行程序.

    ulimit -t 2

    ./test

    Killed

    程序最后被kill掉了.

    八)限制程序实时优先级的范围,只针对普通用户.(real-time priority)

    我们用下面的代码对程序实时优先级的范围进行测试

    源程序如下:

    # include

    int main (void)

    {

    int i;

    for (i=0;i<6;i++)

    {

    printf ("%d\n",i);

    sleep(1);

    }

    return 0;

    }

    编译:

    gcc test.c -o test

    切换到普通用户进行测试

    su - ckhitler

    用实时优先级20运行test程序

    chrt -f 20 ./test

    chrt: failed to set pid 0's policy: Operation not permitted

    我们用root将ulimit的实时优先级调整为20.再进行测试.

    su - root

    ulimit -r 20

    切换到普通用户,用实时优先级20运行程序,可以运行这个程序了.

    su - ckhitler

    chrt -r 20 ./test

    0

    1

    2

    3

    4

    5

    以实时优先级50运行程序,还是报错,说明ulimit的限制起了作用.

    chrt -r 50 ./test

    chrt: failed to set pid 0's policy: Operation not permitted

    九)限制程序可以fork的进程数,只对普通用户有效(max user processes)

    我们用下面的代码对程序的fork进程数的范围进行测试

    源程序如下:

    #include

    #include

    int main(void)

    {

    pid_t pid;

    int count=0;

    while (count<3){

    pid=fork();

    count++;

    printf("count= %d\n",count);

    }

    return 0;

    }

    编译:

    gcc test.c -o test

    count= 1

    count= 2

    count= 3

    count= 2

    count= 3

    count= 1

    count= 3

    count= 2

    count= 3

    count= 3

    count= 3

    count= 2

    count= 3

    count= 3

    程序fork的进程数成倍的增加,这里是14个进程的输出.除自身外,其它13个进程都是test程序fork出来的.

    我们将fork的限定到12,如下:

    ulimit -u 12

    再次执行test程序,这里只有12个进程的输出.

    ./test

    count= 1

    count= 2

    count= 3

    count= 1

    count= 2

    count= 3

    count= 2

    count= 3

    count= 3

    count= 2

    count= 3

    count= 3

    count= 3

    十)限制core文件的大小(core file size)

    我们用下面的代码对程序生成core的大小进行测试

    源代码:

    #include

    static void sub(void);

    int main(void)

    {

    sub();

    return 0;

    }

    static void sub(void)

    {

    int *p = NULL;

    printf("%d", *p);

    }

    编译:

    gcc -g test.c -o test

    运行程序test,出现段错误.

    ./test

    Segmentation fault (core dumped)

    如果在当前目录下没有core文件,我们应该调整ulimit对core的大小进行限制,如果core文件大小在这里指定为0,将不会产生core文件.

    这里设定core文件大小为10个blocks.注:一个blocks在这里为1024个字节.

    ulimit -c 10

    再次运行这个程序

    ./test

    Segmentation fault (core dumped)

    查看core文件的大小

    ls -lh core

    -rw------- 1 root root 12K 2011-03-08 13:54 core

    我们设定10个blocks应该是10*1024也不是10KB,为什么它是12KB呢,因为它的递增是4KB.

    如果调整到14个blocks,我们将最大产生16KB的core文件.

    十一)限制进程使用数据段的大小(data seg size)

    一般来说这个限制会影响程序调用brk(系统调用)和sbrk(库函数)

    调用malloc时,如果发现vm不够了就会用brk去内核申请.

    限制可以使用最大为1KB的数据段

    ulimit -d 1

    用norff打开/etc/passwd文件

    nroff /etc/passwd

    Segmentation fault

    可以用strace来跟踪程序的运行.

    strace nroff /etc/passwd

    打印出如下的结果,证明程序在分配内存时不够用时,调用brk申请新的内存,而由于ulimit的限制,导致申请失败.

    munmap(0x7fc2abf00000, 104420)          = 0

    rt_sigprocmask(SIG_BLOCK, NULL, [], 8)  = 0

    open("/dev/tty", O_RDWR|O_NONBLOCK)     = 3

    close(3)                                = 0

    brk(0)                                  = 0xf5b000

    brk(0xf5c000)                           = 0xf5b000

    brk(0xf5c000)                           = 0xf5b000

    brk(0xf5c000)                           = 0xf5b000

    --- SIGSEGV (Segmentation fault) @ 0 (0) ---

    +++ killed by SIGSEGV +++

    Segmentation fault

    我们这里用一个测试程序对data segment的限制进行测试.

    源程序如下:

    #include

    int main()

    {

    int start,end;

    start = sbrk(0);

    (char *)malloc(32*1024);

    end = sbrk(0);

    printf("hello I used %d vmemory\n",end - start);

    return 0;

    }

    gcc test.c -o test

    ./test

    hello I used 0 vmemory

    通过ulimit将限制改为170KB

    再次运行程序

    ./test

    hello I used 167936 vmemory

    十二)限制进程使用堆栈段的大小

    我们用ulimit将堆栈段的大小调整为16,即16*1024.

    ulimit -s 16

    再运行命令:

    ls -l /etc/

    Segmentation fault (core dumped)

    这时用strace跟踪命令的运行过程

    strace ls -l /etc/

    发现它调用getrlimit,这里的限制是16*1024,不够程序运行时用到的堆栈.

    getrlimit(RLIMIT_STACK, {rlim_cur=16*1024, rlim_max=16*1024}) = 0

    注:在2.6.32系统上ls -l /etc/并不会出现堆栈不够用的情况,这时可以用expect来触发这个问题.

    如:

    expect

    Tcl_Init failed: out of stack space (infinite loop?)

    十三)限制进程使用虚拟内存的大小

    我们用ulimit将虚拟内存调整为8192KB

    ulimit -v 8192

    运行ls

    ls

    ls: error while loading shared libraries: libc.so.6: failed to map segment from shared object: Cannot allocate memory

    ls在加载libc.so.6动态库的时候报了错,提示内存不足.

    用strace跟踪ls的运行过程,看到下面的输出,说明在做mmap映射出内存时,出现内存不够用.

    mmap(NULL, 3680296, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = -1 ENOMEM (Cannot allocate memory)

    close(3)                                = 0

    writev(2, [{"ls", 2}, {": ", 2}, {"error while loading shared libra"..., 36}, {": ", 2}, {"libc.so.6", 9}, {": ", 2}, {"failed to map segment from share"..., 40}, {": ", 2}, {"Cannot allocate memory", 22}, {"\n", 1}], 10ls: error while loading shared libraries:

    libc.so.6: failed to map segment from shared object: Cannot allocate memory

    十四)剩下的三种ulimit限制说明(file locks/max memory size/pipe size)

    文件锁的限制只在2.4内核之前有用.

    驻留内存的限制在很多系统里也没有作用.

    管道的缓存不能改变,只能是8*512(bytes),也就是4096个字节.

    作者:yuandianlws 发表于2013-8-26 12:37:01 原文链接

    阅读:90 评论:0 查看评论

    linux的ulimit各种限制之深入分析

    一般可以通过ulimit命令或编辑/etc/security/limits.conf重新加载的方式使之生效 通过ulimit比较直接,但只在当前的session有效,limits.conf中可以根据用 ...

    正确设置Linux的ulimit值的方法

    学习swoole的时候有一个max_conn参数, max_conn 描述:服务器允许维持的最大TCP连接数 说明:设置此参数后,当服务器已有的连接数达到该值时,新的连接会被拒绝.另外,该参数的值不能 ...

    &lbrack;转&rsqb;正确配置Linux系统ulimit值的方法

    在Linux下面部署应用的时候,有时候会遇上Socket/File: Can't open so many files的问题:这个值也会影响服务器的最大并发数,其实Linux是有文件句柄限制的,而且L ...

    正确配置Linux系统ulimit值的方法【转】

    转自:http://www.cnblogs.com/ibook360/archive/2012/05/11/2495405.html 在Linux下面部署应用的时候,有时候会遇上Socket/File ...

    linux 通过 ulimit 改善系统性能

    https://www.ibm.com/developerworks/cn/linux/l-cn-ulimit/ 概述 系统性能一直是一个受关注的话题,如何通过最简单的设置来实现最有效的性能调优,如何 ...

    linux的ulimit命令

    ulimit命令用来限制系统用户对shell资源的访问. 语法: ulimit [-acdfHlmnpsStv] [size] 选项介绍:    -a 显示当前所有的资源限制;    -c size: ...

    linux设置ulimit值永久生效

    小知识的积累,转自 http://hi.baidu.com/moonelf9989/blog/item/1deadf12780fa0c5c2fd789d.html linux 默认打开文件数linux ...

    linux中ulimit作用

    一.作用 Linux对于每个用户,系统限制其最大进程数.为提高性能,可以根据设备资源情况,设置各linux 用户的最大进程数. ulimit主要是用来限制进程对资源的使用情况的,它支持各种类型的限制, ...

    Linux之ulimit详解&lpar;整理&rpar;

    修改:一般可以通过ulimit命令或编辑/etc/security/limits.conf重新加载的方式使之生效通过ulimit比较直接,但只在当前的session有效,limits.conf中可以根 ...

    随机推荐

    js 碎片整理(变量声明,函数作用域)

    1.变量声明: 在非严格模式下,函数可以对未声明的变量赋值,而这样赋值的结果就是该变量就会变成全局变量. (function(){ var a = 1; })(); console.log(a) ; ...

    C&num;中base 关键字的作用

    引用:http://msdn.microsoft.com/en-us/library/hfw7t1ce.aspx base base 关键字用于从派生类中访问基类的成员: 调用基类上已被其他方法重写的 ...

    LaTeX 算法代码排版 --latex2e范例总结

    LaTeX 写作: 算法代码排版 --latex2e范例总结 latex2e 宏包的使用范例: \usepackage[ruled]{algorithm2e}                     ...

    冒泡排序优化JAVA

    本文对传统的冒泡排序进行了一些优化,减少了循环次数. 时间复杂度 若文件的初始状态是正序的,一趟扫描即可完成排序.所需的关键字比较次数 C 和记录移动次数 M 均达到最小值: C(min)=n-1 , ...

    使用JavaScript判断用户是否为手机设备

    最近在做微信服务号开发,其中遇到一个问题是微信服务号查看的个人的消息,如果点击在浏览器中查看(iOS中是在Safari中打开)应该是跳转到登录页面,因为页面需要从后台获取,因为需要服务端判断,如果是存 ...

    采用Unity快速开发高质量游戏的若干优化建议

    http://files.cnblogs.com/123ing/%E9%87%87%E7%94%A8Unity%E5%BF%AB%E9%80%9F%E5%BC%80%E5%8F%91%E9%AB%98 ...

    表单验证与Json配合

    SpringMVC &plus; Spring &plus; MyBatis 学习笔记:SpringMVC和Spring一同工作的时候,AOP事务管理不起作用的解决方法

    系统:WIN8.1 数据库:Oracle 11GR2 开发工具:MyEclipse 8.6 框架:Spring3.2.9.SpringMVC3.2.9.MyBatis3.2.8 SpringMVC 的 ...

    WCF - Versus Web Service

    There are some major differences that exist between WCF and a Web service which are listed below. 这里 ...

    Windows Server 2008 R2 IIS重装

    背景描述: 在一个刚睡醒午觉后的下午,忽然收到客户反馈,说昨天开始应用特别卡,各种卡各种不好用,忽然想到上次说要优化服务器IIS配置还一直没弄,然后迷迷糊糊的就开始进行客户现场服务器IIS配置优化,涉 ...

    展开全文
  • ulimit最详解

    千次阅读 2019-09-20 13:50:53
    这篇文章应该是网络上关于ulimit最全的介绍了,有扩展,有打破沙锅追到底。文章尽可能的保证正确性,参考了多篇国外获得多数赞同的文章。文章实际操作内容均在Ubuntu16.04上测试通过。 术语 释义 File ...
  • ulimit -c unlimited

    2020-03-19 17:17:38
    ulimit -c unlimited ulimint -a 用来显示当前的各种用户进程限制 Linux对于每个用户,系统限制其最大进程数,为提高性能,可以根据设备资源情况, 设置个Linux用户的最大进程数,一些需要设置为无限制: 数据段...
  • 系统性能一直是一个受关注的话题,如何通过最简单的设置来实现最有效的性能调优,如何在有限资源的条件下保证程序的运作,ulimit是我们在处理这些问题时,经常使用的一种简单手段。ulimit是一种Linux系统的内键功能...
  • 一、Linux Shell命令ulimit的用法ulimit用于shell启动进程所占用的资源.2,类别:shell内建命令3,语法格式:ulimit [-acdfHlmnpsStvw] [size]4,参数介绍:-H 设置硬件资源限制.-S 设置软件资源限制.-a 显示当前所有的...
  • linux ulimit设置

    2019-10-23 08:20:31
    ulimit用于shell启动进程所占用的资源. 2,类别: shell内建命令 3,语法格式: ulimit [-acdfHlmnpsStvw] [size] 4,参数介绍: -H 设置硬件资源限制. -S 设置软件资源限制. -a 显示当前所有的资源限制. -c size:设置core...
  • Linux ulimit命令 Linux ulimit命令用于控制shell程序的资源。 ulimit为shell内建指令,可用来控制shell执行程序的资源。 语法 ulimit [-aHS][-c ][-d ][-f ][-m ][-n ][-p ][-s ][-t ][-u ][-v ] 参数: -a 显示...
  • The ulimit command in Linux is an extremely useful command for system admins who manage multi-user systems. 对于管理多用户系统的系统管理员,Linux中的ulimit命令是非常有用的命令。 They need to have ...
  • Linux ulimit 参数

    2021-05-15 17:00:27
    ulimit 全称 User limits - 限制使用系统范围内资源。语法ulimit [-acdfHlmnpsStuv] [limit]参数-S 设置资源的软限制。-H 设置资源的硬限制。-a 列出当前所有资源的限制。-c 允许创建核心文件大小的最大值。-d 进程...
  • Linux命令之ulimit命令

    2021-06-17 14:32:23
    ulimit是一个计算机命令,用于shell启动进程所占用的资源,可用于修改系统资源限制。使用ulimit命令用于临时修改资源限制,如果需要永久修改需要将设置写入配置文件/etc/security/limits.conf。
  • 个人总结:如何设置普通用户的ulimit值1、vim /etc/profile增加 ulimit -n 10240source /etc/profile 重新启动就不需要运行这个命令了。2、修改/etc/security/limits.conf增加* hard nofile 10240\\限制打开文件数...
  • ulimit的使用

    2018-06-05 20:34:14
    转自: ...系统性能一直是一个受关注的话题,如何通过最简单的设置来实现最有效的性能调优,如何在有限资源的条件下保证程序的运作,ulimit 是我们在处理这些问题时,经常使...
  • linux ulimit 调优

    2021-12-16 14:27:07
    #ulimit -n 1024 在应用程序开发过程中,比如向 server 发起连接的客户端超过 1024 个时,server 由于 1024 个最大的文件个数限制而出现打开文件失败,进而出现Too many open files 错误。 在linux中这些限制是分为...
  • ulimit -c unlimited生成core文件

    千次阅读 2020-02-04 11:46:10
    ulimit -c unlimited ulimint -a 用来显示当前的各种用户进程限制Linux对于每个用户,系统限制其最大进程数,为提高性能,可以根据设备资源情况,设置个Linux用户的最大进程数,一些需要设置为无限制:数据段...
  • linux下关于ulimit

    2021-05-10 23:05:31
    使用ulimit -a可以查看当前系统的所有限制值,使用ulimit -n可以查看当前的最大打开文件数。 有3种方法可以更改默认最大打开文件数(1024): 1.在终端直接输入ulimit -SHn 65535可以更改,但这种方式重启机器后...
  • 学习ulimit命令的用法。功能说明:控制shell程序的资源。语 法:ulimit [-aHS][-c ][-d ][-f ][-m ][-n ][-p ][-s ][-t ][-u ][-v ]补充说明:ulimit为shell内建指令,可用来控制shell执行程序的资源。参 数:复制...
  • ulimit命令详解

    2019-12-10 17:43:40
    ulimit命令详解 ulimit用来限制每个用户可使用的资源,如CPU、内存、句柄等。 命令格式: ulimit [-SHacdefilmnpqrstuvx] 参数S:表示软限制,当超过限制值会报警 参数H:表示硬限制,必定不能超过限制值 参数a:将...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 67,024
精华内容 26,809
关键字:

ulimit

友情链接: 2019.02.24 1400W_SEC.rar