• Linux如何kill杀掉进程

    2015-12-26 11:50:23
    杀掉进程有两种方法:进程号和进程名字 方法一:杀掉进程号 $ ps 找到进程号 $ kill -9 进程号 方法二:杀掉进程名字 $ ps 同样需要找到进程的名字 $ killall 进程名 最后使用 ps 检查下效果!!
    杀掉进程有两种方法:进程号和进程名字
    方法一:杀掉进程号
    $ ps
    找到进程号
    $ kill -9 进程号

    方法二:杀掉进程名字
    $ ps
    同样需要找到进程的名字
    $ killall 进程名

    最后使用 ps 检查下效果!!
    展开全文
  • 方法一: Terminal终端输入: gnome-system-monitor,就可以打开system monitor 如图: 然后找到相应进程,右击选择...首先需要知道进程id, 例如,想要死firefox的进程,通过 ps -ef|grep firefox,可以查到firefox的进程

    方法一: Terminal终端输入: gnome-system-monitor,就可以打开system monitor

    如图:

    然后找到相应进程,右击选择kill process就可以了


    方法二: 通过kill 进程id的方式可以实现,

    首先需要知道进程id, 例如,想要杀死firefox的进程,通过 ps -ef|grep firefox,可以查到firefox的进程id:


    然后通过 kill 3781 就可以关闭进程了.

    补充: 1. kill -9 来强制终止退出, 例如: kill -9 3781

    2.特殊用法:

    kill -STOP [pid]
    发送SIGSTOP (17,19,23)停止一个进程,而并不消灭这个进程。
    kill -CONT [pid]
    发送SIGCONT (19,18,25)重新开始一个停止的进程。
    kill -KILL [pid]
    发送SIGKILL (9)强迫进程立即停止,并且不实施清理操作。
    kill -9 -1
    终止你拥有的全部进程。

    方法三: killall 通过程序的名字,来杀死进程

    例如: killall firefox
    注意: 该命令可以使用 -9 参数来强制杀死进程, killall -9 firefox

    方法四: pkill 通过程序的名字, 直接杀死所有进程
    例如: pkill firefox

    方法五: 通过xkill 可以杀死图形程序应用, 例如firefox崩溃无响应,可以使用该命令.
    例如: 用法xkill , 会出现一个白色的x, 然后用鼠标单击想要杀死的应用,如图


    以下内容引用自: http://justcoding.iteye.com/blog/1931347

    ◆编者注:
    KILLALL(Section: User (1)/Updated: 1999年9月7日)
    ———————————————–
     
    NAME (名称)
    killall – 以名字方式来杀死进程
     
    SYNOPSIS (总览)
    killall [-egiqvw] [-signal] name …
    killall -l
    killall -V
     
    DESCRIPTION (描述)
    killall 发送一条信号给所有运行任意指定命令的进程. 如果没有指定信号名, 则发送SIGTERM.。
    信号可以以名字 (如 -HUP ) 或者数字 (如 -1 ) 的方式指定. 信号 0 (检查进程是否存在)只能以数字方式指定。
    如果命令名包括斜杠 (/), 那么执行该特定文件的进程将被杀掉, 这与进程名无关。
    如果对于所列命令无进程可杀, 那么 killall 会返回非零值. 如果对于每条命令至少杀死了一个进程, killall 返回 0。Killall 进程决不会杀死自己 (但是可以杀死其它 killall 进程)。
     
    OPTIONS (选项)
    -e
    对 于很长的名字, 要求准确匹配. 如果一个命令名长于 15 个字符, 则可能不能用整个名字 (溢出了). 在这种情况下, killall 会杀死所有匹配名字前 15 个字符的所有进程. 有了 -e 选项,这样的记录将忽略. 如果同时指定了 -v 选项, killall 会针对每个忽略的记录打印一条消息。
    -g
    杀死属于该进程组的进程. kill 信号给每个组只发送一次, 即使同一进程组中包含多个进程。
    -i
    交互方式,在杀死进程之前征求确认信息。
    -l
    列出所有已知的信号名。
    -q
    如果没有进程杀死, 不会提出抱怨。
    -v
    报告信号是否成功发送。
    -V
    显示版本信息。
    -w
    等待所有杀的进程死去. killall 会每秒检查一次是否任何被杀的进程仍然存在, 仅当都死光后才返回. 注意: 如果信号被忽略或没有起作用, 或者进程停留在僵尸状态, killall 可能会永久等待。
    FILES(相关文件)
    /proc proc文件系统的存在位置。
    KNOWN bugS (已知 BUGS)
    以文件方式杀死只对那些在执行时一直打开的可执行文件起作用, 也即, 混杂的可执行文件不能够通过这种方式杀死。
    要警告的是输入 killall name 可能不会在非 Linux 系统上产生预期的效果, 特别是特权用户执行时要小心。

    在两次扫描的间隙, 如果进程消失了而被代之以一个有同样 PID 的新进程, killall -w 侦测不到。

     

    来源:http://www.ubuntuhome.com/ubuntu-kill-command.html

     

    下面来了解相关命令:

    一、查看进程的命令 有ps、pstree、pgrep等:                                       

    1、ps                                             
    显示进程信息,参数可省略 
    -aux   以BSD风格显示进程 常用
    -efH   以System V风格显示进程
    -e , -A 显示所有进程
    a        显示终端上所有用户的进程
    x        显示无终端进程
    u     显示详细信息
    f        树状显示
    w     完整显示信息
    l      显示长列表

    在终端中执行ps aux,
    各列输出字段的含义:

    USER        进程所有者
    PID         进程ID
    PPID         父进程
    %CPU       CPU占用率
    %MEM     内存占用率
    NI          进程优先级。数值越大,占用CPU时间越少
    VSZ          进程虚拟大小
    RSS          页面文件占用
    TTY         终端ID
    STAT         进程状态
    +---D   不可中断    Uninterruptible sleep (usually IO)
    +---R   正在运行,或在队列中的进程
    +---S   处于休眠状态
    +---T   停止或被追踪
    +---Z   僵尸进程
    +---W   进入内存交换(从内核2.6开始无效)
    +---X   死掉的进程

    +---<   高优先级
    +---N   低优先级
    +---L   有些页被锁进内存
    +---s   包含子进程
    +---+   位于后台的进程组;
    +---l   多线程,克隆线程 multi-threaded (using CLONE_THREAD, like NPTL pthreads do)

    PID:进程标识符,系统为每一个进程分配一个识别码,称为PID。        

    ps命令极为常用,其他命令还有:

    2.pstree                        
    树状显示进程信息
    -a 显示完整命令及参数
    -c 重复进程分别显示
    -c 显示进程ID PID
    -n 按 PID 排列进程

    3.pgrep <进程名>                      
    显示进程的PID
    -l 显示进程名和进程PID
    -o 进程起始ID
    -n 进程终止ID

    二、结束进程的命令 有kill、pkill、killall、xkill等:                                    

    kill [信号代码] <进程PID>                 

    根据PID向进程发送信号,常用来结束进程,默认信号为 -9
    信号代码,可取值如下:
    -l [信号数字] 显示、翻译信号代码
    -9 , -KILL 发送 kill 信号退出
    -6 , -ABRT 发送 abort 信号退出
    -15 , -TERM 发送 Termination 信号
    -1 , -HUP 挂起
    -2 , -INT 从键盘中断,相当于 Ctrl+c
    -3 , -QUIT 从键盘退出,相当于 Ctrl+d
    -4 , -ILL 非法指令
    -11 , -SEGV 内存错误
    -13 , -PIPE 破坏管道
    -14 , -ALRM
    -STOP 停止进程,但不结束
    -CONT 继续运行已停止的进程
    -9 -1 结束当前用户的所有进程

    pkill <进程名>                             
    结束进程族。如果结束单个进程,请用 kill

    killall <进程名>                               
    killall和pkill 应用方法差不多,也是直接杀死运行中的程序;如果您想杀掉单个进程,请用kill 来杀掉。

    xkill                           
    在图形界面中点杀进程。
    当xkill运行时鼠标指针变为骷髅图案,哪个图形程序崩溃一点就OK了。如果您想终止xkill ,就按右键取消。
    比如当firefox 出现崩溃不能退出时,点鼠标就能杀死firefox 。
    xkill 调用方法:
    [root@localhost ~]# xkill

     

    来源: http://www.cnblogs.com/1024-wusuopuBUPT/archive/2012/02/16/2354132.html

     

    linux中pkill的简单用法

     

    pkill 和killall 应用方法差不多,也是直接杀死运行中的程序;如果您想杀掉单个进程,请用kill 来杀掉。

     

     必要参数
    -f 显示完整程序
    -l 显示源代码
    -n 显示新程序
    -o 显示旧程序
    -v 与条件不符合的程序
    -x 与条件符合的程序

    选择参数
    -p<进程号> 列出父进程为用户指定进程的进程信息
    -t<终端> 指定终端下的所有程序
    -u<用户> 指定用户的程序

     

      应用方法:

      #pkill 正在运行的程序名

     

      举例:

    Java代码  收藏代码
    1. [root@localhost beinan]# pgrep -l gaim  
    2. 2979 gaim  
    3. [root@localhost beinan]# pkill gaim  
     

      也就是说:

      kill 对应的是 PID

      pkill 对应的是COMMAND

     

      例如在Ubuntu中强制结束一个已成僵尸的名称为:firefox,PID为:1603的进程,可以如下操作:

     

      方法一:

     

      (1)ctrl+alt+t,调出终端,输入 top,然后就可以看到现在系统的进程,是按占用资源从多到少排列的。

      找到要关掉的进程,记下该进程第一列的数字编号(假设是xx),然后输入q,退回终端。

     

      (2)输入:sudo kill xx(对应刚才的编号)。

     

      方法二:

     

      ctrl+alt+t,调出终端,输入:sudo pkill firefox

     

    范例1: 杀死指定进程

    Java代码  收藏代码
    1. root@snail-hnlinux:~# ps -A //显示所有进程  
    2. PID TTY   TIME CMD  
    3.  1 ?  00:00:03 init  
    4.  2 ?  00:00:00 kthreadd  
    5.  3 ?  00:00:00 migration/0  
    6.  4 ?  00:00:00 ksoftirqd/0  
    7.  5 ?  00:00:00 watchdog/0  
    8. ……忽略部分  
    9. 28382 ?  00:00:00 gvfsd-http  
    10. 28391 ?  00:07:07 software-center  
    11. 30467 ?  00:00:31 designer-qt4  
    12. 30487 ?  00:00:06 gnome-terminal  
    13. 30488 ?  00:00:00 gnome-pty-helpe  
    14. 30489 pts/0 00:00:00 bash  
    15. 30670 ?  00:00:00 debconf-communi  
    16. 30749 pts/0 00:00:17 gedit  
    17. 31155 ?  00:00:00 dhclient  
    18. 31325 ?  00:00:01 sshd  
    19. 31327 ?  00:00:00 sshd  
    20. 31400 pts/1 00:00:00 bash  
    21. 31485 pts/2 00:00:00 bash  
    22. 31653 ?  00:00:00 aptd  
    23. 31658 pts/1 00:00:00 ps  
    24. root@snail-hnlinux:~# pidof sshd //查看与sshd相关进程  
    25. 31327 31325 2095  
    26. root@snail-hnlinux:~# pkill -9 sshd //杀死指定进程  

     
    范例2:杀死同义终端下的进程

    Java代码  收藏代码
    1. root@snail-hnlinux:~# pkill -t tty1 //杀死终端1下的所有进程  

     
    范例3: 杀死指定用户进程

    Java代码  收藏代码
    1. root@snail-hnlinux:~# pkill -u hnlinux  


    范例4:反向选择

    Java代码  收藏代码
    1. root@snail-hnlinux:~# pkill -vu hnlinux //杀死不属于hnlinux用户的所有进程


    展开全文
  • kill -9 发送SIGKILL信号给进程,将其终止,但对于以下两种情况不适用 1.该进程是僵尸进程(STAT z),此时进程已经释放所有的资源,但是没有被父进程...kill 只能死处于用户状态的进程。 下面是一个自测试例子:

    kill -9 发送SIGKILL信号给进程,将其终止,但对于以下两种情况不适用

    1.该进程是僵尸进程(STAT z),此时进程已经释放所有的资源,但是没有被父进程释放。僵尸进程要等到父进程结束,或者重启系统才可以被释放。

    2.进程处于“核心态”,并且在等待不可获得的资源,处于“核心态 ”的资源默认忽略所有信号。只能重启系统。

    kill 只能杀死处于用户状态的进程。

    下面是一个自测试例子:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <errno.h>


    int main(int argc ,char *argv[])
    {
        pid_t pid;

        pid = fork();
        if(pid<0){
            perror("fork");
            return -1;
        }else if(pid==0){
            printf("I am a child\n");
            exit(0);
        }else{
            while(1){
                sleep(100);
            }
        }
        return 0;
    }

    由于父进程没有退出,所以执行ps -aux | grep "z",可以查看进程的状态,发现如下(绿色标出部分)

    root       1937  0.0  0.1 389000  4336 ?        Sl   09:12   0:00 /usr/bin/gnome-keyring-daemon --daemonize --login
    root       4447  0.0  0.0 112680   964 pts/2    R+   10:16   0:00 grep --color=auto z
    [root@localhost linux_test]# ps -aux | grep "[zZ]"
    USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
    root          1  0.0  0.1 128164  6828 ?        Ss   09:07   0:01 /usr/lib/systemd/systemd --switched-root --system --deserialize 21
    root       1937  0.0  0.1 389000  4336 ?        Sl   09:12   0:00 /usr/bin/gnome-keyring-daemon --daemonize --login
    root       4385  0.0  0.0      0     0 pts/0    Z+   10:16   0:00 [a.out] <defunct>
    root       4455  0.0  0.0 112680   976 pts/2    S+   10:17   0:00 grep --color=auto [zZ]

    从以上信息 可以得到该进程的进程号是4385

    此时的解决方法有两种

    《1》 cat /proc/4385/status   找到该子进程对应的父进程,将其父进程杀死

    State: Z (zombie)
    Tgid: 4385
    Ngid: 0
    Pid: 4385
    PPid: 4384

    执行kill -9 4384   如果父进程也杀不死,那就只能执行重启了

    《2》重启

    展开全文
  • 目录 前言 ...kill,英语中为死的意思,顾名思义,就是用来死一些东西的命令,在linux中就是用来死系统中的进程。 在Windows系统中,如果应用程序无反应我们会启动任务管理器终止应用...

    目录

     

    前言

    基础

    进阶

    1 查找进程号的方式进行改进

    2 将常规的两步杀死进程合并为一步

    3 强制踢掉登陆用户

    kill的注意事项


    前言

    在Linux的系统中,kill是我们最常见的命令之一。
    kill,英语中为杀死的意思,顾名思义,就是用来杀死一些东西的命令,在linux中就是用来杀死系统中的进程。

    在Windows系统中,如果应用程序无反应我们会启动任务管理器终止应用,而在Linux系统中则使用kill命令,kill命令主要用于强制关闭进程,下面就介绍一下Linux中kill命令的基础用法和进阶用法。

    基础

    一般情况下,想要杀死后台一个进程,我们通常只需要做两步:

    第一步:找到某个应用的进程号:

    ps -aux | grep 应用名称 

    或 ps -ef | grep 应用名称 

    或者 top  | grep 应用名称 

    第二步:杀死进程

    正常杀死进程:kill  -15  pid号

    如杀死上图中pid为10的进程:kill -15 10

    强制杀死进程: kill -9 pid号

    注:杀死进程的时候,推荐是正常杀死进程,而不是强制杀死进程。

    原理解读:

    Kill命令和信号

      当你执行一个“kill”命令,你实际上发送了一个信号给系统,告诉它去终结不正常的应用。总共有60个你可以使用的信号,但是基本上你只需要知道SIGTERM(15)(正常杀死信号)和SIGKILL(9)(强制杀死信号)。

      你可以用这个命令看到所有信号的列表:

      kill -l

    上图:共有64中信号,每种信号均有名称和对应的信号序列号,当想要发送什么信号给系统的时候,只要告知系统该信号的序列号即可。如想要强制结束进程,则需要发送9号信号给系统,应该是这样的:kill -9 pid号。

    实际中常用的只有9种信号(最常用的只有2中:9 和 15):

    <1> 1 终端断线

    <2>2 中断(等同 Ctrl + C)

    <3>3 退出(同 Ctrl + \)

    <4>15 终止(可以使得进程在退出之前清理并释放资源)

    <5> 9 强制终止

    <6>18 继续(与19相反)

    <7>19 暂停(等同 Ctrl + Z)
     

    进阶

    1 查找进程号的方式进行改进

    以查找firefox进程为例:

    常规:ps -aux | grep java

    进阶:pgrep java 

    或:  pidof firefox-bin (不推荐)

    解读:

    pgrep: 这个命令是专门用于进程查询的grep。

    pidof: 看到pidof想到啥?没错pid of xx,字面翻译过来就是 xx的PID。和pgrep相比稍显不足的是,pidof必须给出进程的全名。

    2 将常规的两步杀死进程合并为一步

    进阶1: kill -s 9 `ps -aux | grep firefox | awk '{print $2}'`

                  其中awk '{print $2}' 的作用就是打印(print)出第二列的内容。根据常规篇,可以知道ps输出的第二列正好是PID。就把进程相应的PID通过xargs传递给kill作参数,杀掉对应的进程。

    进阶2: pgrep firefox | xargs kill -s 9

                 “ xargs kill -s 9 ”中的xargs命令是用来把前面命令的输出结果(PID)作为“kill -s 9”命令的参数,并执行该命令。“kill -s 9”会强行杀掉指定进程。

    进阶3:kill -s 9  `pgrep firefox`

    进阶4: pkill -9 firefox

                  前面三个进阶虽然将查找进程和删除进程合并为一个步骤,但是,仍然是两个命令,这里采用pkill命令将查找和杀掉进程的两个命令合并为一个命令了,即:pkill=pgrep + kill,表示找到并杀死进程。

    进阶5:killall -9 firefox

    killall和pkill是相似的,不过如果给出的进程名不完整,killall会报错。pkill或者pgrep只要给出进程名的一部分就可以终止进程。

    3 强制踢掉登陆用户

    有的时候,可能我们的系统中有很多用户在同时登陆这一台服务器,而我们想要踢掉某个不良用户,就可以执行如下操作。

    (1)查看用户登陆信息: who

    (2)查看自己的身份(避免把自己踢掉):whoami

    (3)踢掉用户ats

    pkill -kill -t pts/2(按终端踢,pts/2为所踢用户的终端)

    pkill -u ats(按用户名踢,ats为用户名)
     

     

    kill的注意事项

    1.如果kill时,不指定信号就会默认发送信号15,终止指定进程,使得进程在退出之前清理并释放资源。

    2.使用kill时,root用户将影响用户的进程,非root用户只能影响自己的进程。

    3.使用kill时,当kill向进程发送信号,必须是这些进程的主人。如果杀死一个没有权限杀死的进程或杀死一个不存在的进程,就会报错。如下:
    -bash: kill: (20) - No such process

    4.使用kill时,如果成功地发送了信号,shell会在屏幕上显示出进程的终止信息。(按下Enter键,就会显示出来)

    5.使用kill时,如果使用信号9,使进程强行终止,可能会使数据丢失或者终端无法恢复到正常状态。

    6.init进程,它是一个由内核启动的用户级进程,所有进程都是init进程的子孙,init不可杀。
     

    展开全文
  • 常规篇: ... 首先,用ps查看进程,方法如下: $ ps -ef …… smx 1822 1 0 11:38 ? 00:00:49 gnome-terminal smx 1823 1822 0 11:38 ? 00:00:00 gnome-pty-helper smx 1824 1822 0 11:38
    
    

    转载一篇,最原始的出处已不可考,望见谅!

    常规篇

     首先,用ps查看进程,方法如下:

    $ ps -ef

    ……
    smx       1822     1  0 11:38 ?        00:00:49 gnome-terminal
    smx       1823  1822  0 11:38 ?        00:00:00 gnome-pty-helper
    smx       1824  1822  0 11:38 pts/0    00:00:02 bash
    smx       1827     1  4 11:38 ?        00:26:28 /usr/lib/firefox-3.6.18/firefox-bin
    smx       1857  1822  0 11:38 pts/1    00:00:00 bash
    smx       1880  1619  0 11:38 ?        00:00:00 update-notifier
    ……
    smx      11946  1824  0 21:41 pts/0    00:00:00 ps -ef

    或者:

    $ ps -aux

    ……

    smx       1822  0.1  0.8  58484 18152 ?        Sl   11:38   0:49 gnome-terminal
    smx       1823  0.0  0.0   1988   712 ?        S    11:38   0:00 gnome-pty-helper
    smx       1824  0.0  0.1   6820  3776 pts/0    Ss   11:38   0:02 bash
    smx       1827  4.3  5.8 398196 119568 ?       Sl   11:38  26:13 /usr/lib/firefox-3.6.18/firefox-bin
    smx       1857  0.0  0.1   6688  3644 pts/1    Ss   11:38   0:00 bash
    smx       1880  0.0  0.6  41536 12620 ?        S    11:38   0:00 update-notifier
    ……
    smx      11953  0.0  0.0   2716  1064 pts/0    R+   21:42   0:00 ps -aux

    此时如果我想杀了火狐的进程就在终端输入:

    $ kill -s 9 1827

    其中-s 9 制定了传递给进程的信号是9,即强制、尽快终止进程。各个终止信号及其作用见附录。

    1827则是上面ps查到的火狐的PID。

    简单吧,但有个问题,进程少了则无所谓,进程多了,就会觉得痛苦了,无论是ps -ef 还是ps -aux,每次都要在一大串进程信息里面查找到要杀的进程,看的眼都花了。

    进阶篇:

    改进1

    把ps的查询结果通过管道给grep查找包含特定字符串的进程。管道符“|”用来隔开两个命令,管道符左边命令的输出会作为管道符右边命令的输入。

    $ ps -ef | grep firefox
    smx       1827     1  4 11:38 ?        00:27:33 /usr/lib/firefox-3.6.18/firefox-bin
    smx      12029  1824  0 21:54 pts/0    00:00:00 grep --color=auto firefox

    这次就清爽了。然后就是

    $kill -s 9 1827

    还是嫌打字多?

    改进2——使用pgrep

    一看到pgrep首先会想到什么?没错,grep!pgrep的p表明了这个命令是专门用于进程查询的grep。

    $ pgrep firefox
    1827

    看到了什么?没错火狐的PID,接下来又要打字了:

    $kill -s 9 1827

    改进3——使用pidof:

    看到pidof想到啥?没错pid of xx,字面翻译过来就是 xx的PID。

    $ pidof firefox-bin
    1827
    和pgrep相比稍显不足的是,pidof必须给出进程的全名。然后就是老生常谈:

    $kill -s 9 1827

    无论使用ps 然后慢慢查找进程PID 还是用grep查找包含相应字符串的进程,亦或者用pgrep直接查找包含相应字符串的进程PID,然后手动输入给kill杀掉,都稍显麻烦。有没有更方便的方法?有!

    改进4:

    $ps -ef | grep firefox | grep -v grep | cut -c 9-15 | xargs kill -s 9

    说明:

    “grep firefox”的输出结果是,所有含有关键字“firefox”的进程。

    “grep -v grep”是在列出的进程中去除含有关键字“grep”的进程。

    “cut -c 9-15”是截取输入行的第9个字符到第15个字符,而这正好是进程号PID。

    “xargs kill -s 9”中的xargs命令是用来把前面命令的输出结果(PID)作为“kill -s 9”命令的参数,并执行该命令。“kill -s 9”会强行杀掉指定进程。

    难道你不想抱怨点什么?没错太长了

    改进5:

    知道pgrep和pidof两个命令,干嘛还要打那么长一串!

    $ pgrep firefox | xargs kill -s 9

    改进6:

    $ ps -ef | grep firefox | awk '{print $2}' | xargs kill -9
    kill: No such process

    有一个比较郁闷的地方,进程已经正确找到并且终止了,但是执行完却提示找不到进程。

    其中awk '{print $2}' 的作用就是打印(print)出第二列的内容。根据常规篇,可以知道ps输出的第二列正好是PID。就把进程相应的PID通过xargs传递给kill作参数,杀掉对应的进程。

    改进7

    难道每次都要调用xargs把PID传递给kill?答案是否定的:

    $kill -s 9 `ps -aux | grep firefox | awk '{print $2}'`

    改进8:

    没错,命令依然有点长,换成pgrep。

    $kill -s 9 `pgrep firefox`

    改进9——pkill:

    看到pkill想到了什么?没错pgrep和kill!pkill=pgrep+kill。

    $pkill -9 firefox

    说明:"-9" 即发送的信号是9,pkill与kill在这点的差别是:pkill无须 “s”,终止信号等级直接跟在 “-“ 后面。之前我一直以为是 "-s 9",结果每次运行都无法终止进程。

    改进10——killall

    killall和pkill是相似的,不过如果给出的进程名不完整,killall会报错。pkill或者pgrep只要给出进程名的一部分就可以终止进程。

    $killall -9 firefox


    附录:各种信号及其用途

    Signal Description Signal number on Linux x86[1]
    SIGABRT Process aborted 6
    SIGALRM Signal raised by alarm 14
    SIGBUS Bus error: "access to undefined portion of memory object" 7
    SIGCHLD Child process terminated, stopped (or continued*) 17
    SIGCONT Continue if stopped 18
    SIGFPE Floating point exception: "erroneous arithmetic operation" 8
    SIGHUP Hangup 1
    SIGILL Illegal instruction 4
    SIGINT Interrupt 2
    SIGKILL Kill (terminate immediately) 9
    SIGPIPE Write to pipe with no one reading 13
    SIGQUIT Quit and dump core 3
    SIGSEGV Segmentation violation 11
    SIGSTOP Stop executing temporarily 19
    SIGTERM Termination (request to terminate) 15
    SIGTSTP Terminal stop signal 20
    SIGTTIN Background process attempting to read from tty ("in") 21
    SIGTTOU Background process attempting to write to tty ("out") 22
    SIGUSR1 User-defined 1 10
    SIGUSR2 User-defined 2 12
    SIGPOLL Pollable event 29
    SIGPROF Profiling timer expired 27
    SIGSYS Bad syscall 31
    SIGTRAP Trace/breakpoint trap 5
    SIGURG Urgent data available on socket 23
    SIGVTALRM Signal raised by timer counting virtual time: "virtual timer expired" 26
    SIGXCPU CPU time limit exceeded 24
    SIGXFSZ File size limit exceeded 25
    展开全文
  • kill命令:  1.格式:kill [信号] 进程id  2..查看经常信号:kill -l  3.... 平滑重启进程kill -1 进程id... 强制进程kill -9 进程id #查看进程可用ps aux命令 killall命令:  1.格式:killall [信...
  • 然后使用kill杀掉后,再运行jps还是存在此进程。于是乎开始大量百度,最终找到了解决方案。 说的很清楚了,杀不掉的原因有两种:1.这个进程是僵尸进程 2.此进程是"核心态"进程。 First: 按照方案,我首先重启了下看...
  • 大数据集群HDFS的DataNode的一个节点down掉,去服务器查看,发现datanode节点还在,打算重新启动该节点的datanode,使用hadoop-daemon.sh stop datanode方式停掉datanode发现执行失败,提示使用kill -9杀掉进程,...
  • linux kill 一个进程

    2018-07-26 11:09:04
    1. 用ps查看进程pid  ps -ef|grep php-fpm 2. 杀掉进程  kill 933 3. 查看进程并杀掉 kill -s 9 `ps -ef|grep -v grep |grep 'resign sign'|awk '{print $2}'`  
  • 1.查看mysql程序对应的进程号使用命令: ps ps -e|grep mysql2.杀死mysql进程使用命令: sudo kill -9 mysql的进程号3....sudo killall mysqld4....ps ps -e|grep mysql参考文献: linux如何杀掉进程kill
  • Linux kill 死指定进程
  • 这一个操作需要执行两个命令,通过将这两个命令合并为一个脚本,并将脚本加入环境变量,可以只使用一个命令杀掉进程 编辑脚本gkill #!/bin/bash content=$1 ps -ef | grep ${content} | grep -v grep | awk '{...
  • 2、Linux命令杀掉符合条件的所有进程 Linux用shell一次性杀指定进程的方法 需要把 linux 下符合某一项条件的所有进程 kill 掉,这个时候我们需要运用 ps, grep, cut 和 kill 一起操作。 面给出具体的...
  • Linux 批量杀掉进程 kill -9 查看进程 ps 命令用于查看当前正在运行的进程, grep 是搜索 ,例如:查看php应用进程 ps -ef | grep php 按用户 比如杀掉root用户创建的进程 pgrep -u root | sudo xargs kill...
  • Linux kill 强制关闭 进程
  • linux系统管理中,我们有时候需要kill掉某个用户的所有进程,初学者一般先查询出用户的所有pid,然后一条条kill掉,或者写好一个脚本,实际上方法都有现成的,这边有4种方法,我们以kill用户ttlsa为例. ...
  • 查看进程命令:ps -ef | grep java(查看所有进程里 CMD 是 java 的进程信息) kill 命令用于终止进程 例如:kill -9 12345
  • 话不多说,本文介绍Linux常规操作:查看端口占用进程,根据PID kill掉相关进程。另外补充:根据程序名查看进程PID。 首先,两条命令,lsof命令和netstat命令。 方式一:lsof命令 1、查看占用端口进程的PID: ...
  • linux杀掉tomcat进程

    2017-08-15 16:18:40
    目的 : linux杀掉进程 起因 : 远端服务器同一个 tomcat 起了两个进程 命令 : kill -s 9 tomcat 进程 ID tomcat 进程 ID 可以 ps -ef | grep tomcat 查看
1 2 3 4 5 ... 20
收藏数 34,080
精华内容 13,632