精华内容
下载资源
问答
  • 如何shell脚本自杀

    2018-03-28 02:32:00
    有些时候我们写的shell脚本中有一些后台任务,当脚本的流程已经执行到结尾处或将其kill掉时,这些后台任务会直接挂靠在init/systemd进程下,而不会随着脚本退出而停止。 例如: [root@mariadb ~]# ...

    bash&shell系列文章:http://www.cnblogs.com/f-ck-need-u/p/7048359.html


    1.脚本自杀正文

    有些时候我们写的shell脚本中有一些后台任务,当脚本的流程已经执行到结尾处或将其kill掉时,这些后台任务会直接挂靠在init/systemd进程下,而不会随着脚本退出而停止。

    例如:

    [root@mariadb ~]# cat test1.sh 
    #!/bin/bash
    echo $BASHPID
    sleep 50 &
    
    [root@mariadb ~]# ps -elf | grep slee[p]
    0 S root      10806      1  0  80   0 - 26973 hrtime 19:26 pts/1    00:00:00 sleep 50

    从结果中可以看到,脚本退出后,sleep进程的父进程变为了1,也就是挂在了init/systemd进程下。

    这时我们可以在脚本中直接使用kill命令杀掉sleep进程。

    [root@mariadb ~]# cat test1.sh 
    #!/bin/bash
    echo $BASHPID
    sleep 50 &
    kill $!

    但是,如果这个sleep进程是在循环中(for、while、until均可),那就麻烦了。

    例如下面的例子,直接将循环放入后台,杀掉sleep、或者exit、或者杀掉脚本自身进程、或者让脚本自动退出、甚至exec退出当前脚本shell都是无效的。

    [root@mariadb ~]# cat test1.sh 
    #!/bin/bash
    echo $BASHPID
    
    while true;do
        sleep 50
        echo 1
    done &
    
    killall sleep
    kill $BASHPID

    为了分析,新建一个脚本test2.sh:

    #!/bin/bash
    echo $BASHPID
    
    while true;do
        sleep 50
        echo 1
    done &
    
    sleep 60

    然后在脚本执行的60秒内查看test2.sh进程的信息:

    [root@mariadb ~]# pstree -p | grep "test2.sh"
                |        `-bash(2687)---test2.sh(2923)-+-sleep(2925)
                |                                      `-test2.sh(2924)---sleep(2926)

     其中pid=2923的test2.sh进程是脚本自身进程,pid=2924的test2.sh进程是while开始运行后为while提供执行环境的子shell进程(为什么会生成这个进程,见我的另一篇文章)。

    所以,对于前面的test1.sh进程,杀掉了 $BASHPID 对应的test1.sh进程后,其实还有一个为while提供运行环境的test1.sh进程,且这个进程在 $BASHPID 结束后,会挂在init/systemd下。

    [root@mariadb ~]# ./test1.sh 
    10859
    ./test1.sh: line 7: 10862 Terminated              sleep 50
    Terminated
    1
    [root@mariadb ~]# pstree -p | grep sleep
               |-test1.sh(10860)---sleep(10863)

    这就是shell脚本中的一个"疑难杂症",CTRL+C中止了脚本进程,这个脚本却还在后台不断运行,且时不时地输出点信息到终端(我这里是循环中的echo命令输出的)

    除非我们手动杀掉新生成的test1.sh,否则这个脚本将无限循环下去。但是,这不是很麻烦吗?

    那么如何实现"脚本自杀"?其实很简单,只要在脚本退出前,使用killall命令杀掉脚本进程即可。

    [root@mariadb ~]# cat test1.sh 
    #!/bin/bash
    echo $BASHPID
    
    while true;do
        sleep 50
        echo 1
    done &
    
    killall `basename $0`

    这样,在脚本退出前,两个test1.sh进程都会被杀掉。

    再考虑一个问题,如果脚本已经执行到了while中的后台任务,但在执行到killall命令之前按下了CTRL+C,这时由于没有执行killall,后台任务也将挂在新的脚本进程下。我们的目的是保证脚本终止,其内进程一定终止。所以我们需要对这种情况做出合理的处理。

    可以使用trap捕捉ctrl+c信号,捕捉到的时候执行killall命令即可。例如:

    [root@mariadb ~]# cat test1.sh 
    #!/bin/bash
    
    trap "killall `basename $0`" SIGINT
    echo $BASHPID
    
    while true;do
        sleep 50
        echo 1
    done &
    
    killall `basename $0`

    这样就能保证脚本终止时,其内一切任务都将终止的目的。

     上面的脚本并不健壮,因为 ./test1.sh 和 bash test1.sh 两种执行方式的进程名称不一样,前者的进程名称为test1.sh,后者的进程名称为bash,所以killall没法同时解决这两种情况。为了健壮性,可以加上杀后台进程"$!"的代码,并将killall换成pkill,且通过筛选全路径的方式杀掉进程:

    [root@mariadb ~]# cat test1.sh 
    #!/bin/bash
    
    trap "pkill -f `basename $0`" SIGINT
    echo $BASHPID
    
    while true;do
        sleep 50
        echo 1
    done &
    pid=$!
    kill $pid pkill
    -f `basename $0`
    为了让脚本自杀更健壮、更通用化,并省去上面结尾处的一大堆额外命令。可以在trap中一次性完成这些任务:
    #!/bin/bash
    
    trap "pkill -f $(basename $0);exit 1" SIGINT SIGTERM EXIT ERR
    
    while true;do
        sleep 1
        echo "hello world!"
    done &
    
    # do something
    sleep 60

    可能写100个shell脚本也遇不到需要一个脚本需要将while/for/until这样的语句放入后台的。但有时候也是有用的。例如,有个需求:每秒去a.txt文件中同步数据到b.txt中,然后每分钟对b.txt文件做处理。

    #!/bin/bash
    
    while true;do
        (a.txt--->b.txt)
        sleep 1
    done &
    
    while true;do
        (b.txt)
        sleep 60
    done

    此外,对一些比较复杂的需求(我个人遇到过多次),可能也会使用到后台的循环。

    本文只是提供一种杀脚本的解决方案。很多情形并非如我这里所描述的,例如不是while循环放后台,而是循环内的sleep放后台,这时(脚本终止时)sleep会挂在init/systemd下,不过这很简单。相信读懂了本文,各位已经了解了一些trap的功能以及处理这类问题的逻辑,也知道其他各种情形如何处理。

    最后,有一种更方便更精确的自杀手段:man kill。在该man手册中解释了,如果kill的pid值为0,表示发送信号给当前进程组中所有进程,对shell脚本来说这意味着杀掉脚本中产生的所有进程。方案如下:

    #!/bin/bash
    
    trap "echo 'signal_handled:';kill 0" SIGINT SIGTERM
    
    while true;do
        sleep 5
        echo "hello world! hello world!"
    done &
    sleep 60

     

    2.补充:bash内置命令的特殊性

    为什么上文运行脚本进程,脚本中的后台while会新生成一个脚本进程?在这里补充说明下。

     

    究其原因,是因为while/for/until等是bash内置命令,它们的特殊性在于它们有一个很替它们着想的爹:bash进程。bash进程对他们的孩子非常负责,所有能直接执行的内置命令都不会创建新进程,它们直接在当前bash进程内部调用执行,所以我们用ps/top等工具是捕捉不到cd、let、expr等等内置命令的。但正因为爹太负责,把孩子们宠坏了,这些bash内置命令的执行必须依赖于bash进程才能执行。

    内置命令中还有几个比较特殊的关键字:while、for、until、if、case等,它们无法直接执行,需要结合其他关键字(如do/done/then等)才能执行。非后台情况下,它们的爹会直接带它们执行,但当它们放进后台后,它们必须先找个bash爹提供执行环境:

    • 如果是在当前shell中放进后台,则这个爹是新生成的bash进程。这个新的bash进程只负责一件事,就是负责这个后台,为它的孩子们提供它们依赖的bash环境。
    • 如果是在脚本中放进后台,则这个爹就是脚本进程。由于脚本不是内置命令,它能直接负责这个后台(因为脚本进程也算是bash进程的特殊变体,也相当于一个新的bash进程)。

    验证下就知道咯。

    目前bash进程信息为:

    [root@xuexi ~]# pstree -p | grep bash
               |-sshd(1142)-+-sshd(5396)---bash(5398)---mysql(5659)
               |            `-sshd(7006)-+-bash(7008)
               |                         `-bash(12280)-+-grep(13294)

    将for、unitl、while、case、if等语句放进后台。例如:

    [root@xuexi ~]# if true;then sleep 10;fi &  

    然后再查bash进程信息:

    [root@xuexi ~]# pstree -p | grep bash
               |-sshd(1142)-+-sshd(5396)---bash(5398)---mysql(5659)
               |            `-sshd(7006)-+-bash(7008)---bash(13295)---sleep(13296)
               |                         `-bash(12280)-+-grep(13298)

    不难看出,sleep进程之前先生成了一个pid=13295的bash进程。(注:如果这几个特殊关键字不进入后台,则是当前在bash进程下执行的)

    无论它们的爹是脚本进程还是新的bash进程,它们都是当前shell下的子shell。如果某个子shell中有后台进程,当杀掉子shell,意味着杀掉了它们的爹。非内置bash命令不依赖于bash,所以直接挂在init/systemd下,而bash内置命令严重依赖于bash爹,没有爹就没法执行,所以在杀掉bash进程(上面pid=7008)的时候,bash爹(pid=13295)会立即带着它下面的进程(sleep)挂在init/systemd下。

    再来验证下咯。还是刚才的后台命令。

    [root@xuexi ~]# while true;do sleep 2;done &

    另一个窗口,查看bash进程信息:

    [root@xuexi ~]# pstree -p | grep bash 
               |-sshd(1142)-+-sshd(5396)---bash(5398)---mysql(5659)
               |            `-sshd(7006)-+-bash(7008)---bash(13468)---sleep(13526)
               |                         `-bash(12280)-+-grep(13528)

    杀掉pid=7008的bash进程(为什么不杀pid=13468的bash进程?它是为while提供环境的bash进程,杀了这个相当于杀了while循环结构)。注意,这个bash进程是交互式登陆shell,默认情况下会忽略SIGTERM信号,所以只能使用SIGKILL信号来杀。

    [root@xuexi ~]# kill -9 7008
    
    [root@xuexi ~]# pstree -p | grep bash
               |-bash(13468)---sleep(13562)
               |-sshd(1142)-+-sshd(5396)---bash(5398)---mysql(5659)
               |            `-sshd(7006)---bash(12280)-+-grep(13564)

    可以看到,新生成了一个bash进程,而且这个bash进程是挂在init/systemd下的,这意味着该bash和终端无关。看下面的状态为"?"。

    [root@xuexi ~]# ps aux | grep bas[h]
    root       5398  0.0  0.1 116548  3300 pts/0    Ss   09:04   0:00 -bash
    root      12280  0.0  0.1 116568  3340 pts/2    Ss   14:43   0:00 -bash
    root      13468  0.0  0.1 116556  1924 ?        S    15:49   0:00 -bash

    bash进程竟然会挂在init/systemd下?如此奇怪现象,可能你除了这里外永远也不会遇到。

    转载于:https://www.cnblogs.com/f-ck-need-u/p/8661501.html

    展开全文
  • 我们知道启动springboot的项目有三种方式: 运行主方法启动 使用命令 mvn spring-boot:run”在命令行启动该应用 ...下面我们来说说服务器上如何后台启动springboot项目。实际上,实现的方法有很多种,这里就列两种还

    我们知道启动springboot的项目有三种方式:

    • 运行主方法启动
    • 使用命令 mvn spring-boot:run”在命令行启动该应用
    • 运行“mvn package”进行打包时,会打包成一个可以直接运行的 JAR 文件,使用“java -jar”命令就可以直接运行。

    我们在开发的时候,通常会使用前两种,而在部署的时候往往会使用第三种。但是,我们在使用java -jar来运行的时候,并非后台运行。

    下面我们来说说服务器上如何后台启动springboot项目。实际上,实现的方法有很多种,这里就列两种还比较好用的方式:

    nohup和Shell

    该方法主要通过使用nohup命令来实现,该命令的详细介绍如下:

    示例:nohup 命令

    用途:不挂断地运行命令。

    语法:nohup Command [ Arg … ][ & ]

    描述:nohup 命令运行由 Command 参数和任何相关的 Arg 参数指定的命令,忽略所有挂断(SIGHUP)信号。在注销后使用 nohup 命令运行后台中的程序。要运行后台中的 nohup 命令,添加 &到命令的尾部。

    nohup java -jar xxx.jar &

    这样执行后,nohup会把执行结果中的日志输出到当前文件夹下面的nohup.out文件中,通常情况下我们使用以上命令即可。 

    我们也可以手动指定一个参数来规定日志文件的输出地点,如:

    nohup java -jar xxx.jar > catalina.out  2>&1 &

    如果不需要输出日志,可以使用如下命令

    nohup java -jar xxx.jar >/dev/null &

    所以,我们只需要使用nohup java -jar yourapp.jar &命令,就能让yourapp.jar在后台运行了。但是,为了方便管理,我们还可以通过Shell来编写一些用于启动应用的脚本,比如下面几个:

    • 关闭应用的脚本:stop.sh
    #!/bin/bash
    PID=$(ps -ef | grep yourapp.jar | grep -v grep | awk '{ print $2 }')
    if [ -z "$PID" ]
    then
        echo Application is already stopped
    else
        echo kill $PID
        kill $PID
    fi
    • 启动应用的脚本:start.sh
    #!/bin/bash
    nohupjava -jar yourapp.jar --server.port=8888 &
    • 整合了关闭和启动的脚本:run.sh,由于会先执行关闭应用,然后再启动应用,这样不会引起端口冲突等问题,适合在持续集成系统中进行反复调用。
    #!/bin/bash
    echostop application
    sourcestop.sh
    echostart application
    sourcestart.sh

    系统服务

    在Spring Boot的Maven插件中,还提供了构建完整可执行程序的功能,什么意思呢?就是说,我们可以不用java -jar,而是直接运行jar来执行程序。这样我们就可以方便的将其创建成系统服务在后台运行了。主要步骤如下:

    • 在pom.xml中添加Spring Boot的插件,并注意设置executable配置
    <build>
      <plugins>
        <plugin>
          <groupId>org.springframework.boot</groupId> 
          <artifactId>spring-boot-maven-plugin</artifactId> 
          <configuration>
            <executable>true</executable>
          </configuration>
        </plugin>
      </plugins>
    </build>
    • 在完成上述配置后,使用mvn install进行打包,构建一个可执行的jar包

    • 创建软连接到/etc/init.d/目录下

    sudo ln -s /var/yourapp/yourapp.jar /etc/init.d/yourapp
    • 在完成软连接创建之后,我们就可以通过如下命令对yourapp.jar应用来控制启动、停止、重启操作了
    /etc/init.d/yourapp start|stop|restart

    综上,一般情况下我们使用以下命令即可:

    nohup java -jar xxx.jar &

    编写springboot 启动停止脚本

    #!/bin/bash
    #设置环境变量
    export JAVA_HOME=/usr/local/jdk1.8.0_181
    export JRE_HOME=/$JAVA_HOME/jre
    export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
    export PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
     
    #这里可替换为你自己的执行程序,其他代码无需更改
    APP_NAME=filename.jar
    #使用说明,用来提示输入参数
    usage() {
        echo "Usage: sh restart.sh [start|stop|restart|status]"
        exit 1
    }
     
    #检查程序是否在运行
    #grep -v反选匹配 awk指定文件某一行
    is_exist(){
      pid=`ps -ef|grep $APP_NAME|grep -v grep|awk '{print $2}'`
      #如果不存在返回1,存在返回0    
      if [ -z "${pid}" ]; then
       return 1
      else
        return 0
      fi
    }
     
    #启动方法
    start(){
      is_exist
      if [ $? -eq 0 ]; then
        echo "${APP_NAME} is already running. pid=${pid}"
      else
        nohup java -jar ${APP_NAME} --spring.profiles.active=uat >/null 2>&1 &
      fi
    }
     
    #停止方法
    stop(){
      is_exist
      if [ $? -eq "0" ]; then
        kill -9 $pid
      else
        echo "${APP_NAME} is not running"
      fi 
    }
     
    #输出运行状态
    status(){
      is_exist
      if [ $? -eq "0" ]; then
        echo "${APP_NAME} is running. Pid is ${pid}"
      else
        echo "${APP_NAME} is NOT running."
      fi
    }
     
    #重启
    restart(){
      stop
      sleep 5
      start
    }
     
    #根据输入参数,选择执行对应方法,不输入则执行使用说明
    case "$1" in
      "start")
        start
        ;;
      "stop")
        stop
        ;;
      "status")
        status
        ;;
      "restart")
        restart
        ;;
      *)
        usage
        ;;
    esac

    创建文件之后,赋予执行权限,命令执行文件即可。

    chmod u+x file.sh

    使用命令:

    Usage: sh restart.sh [start|stop|restart|status]

    转载:

    linux下后台启动springboot项目

    展开全文
  • 现在多数的服务器都是Linux系统的,需要通过shell来进行操作,而利用shell脚本,可以大大提高开发维护的效率。 知识剖析 什么是shell shell是一个命令行解释器,它为用户提供了一个向Linux内核发送请求以便于运行...

    背景

    现在多数的服务器都是Linux系统的,需要通过shell来进行操作,而利用shell脚本,可以大大提高开发维护的效率。

    知识剖析

    什么是shell

    shell是一个命令行解释器,它为用户提供了一个向Linux内核发送请求以便于运行程序的界面系统级程序,用户可以用shell来启动,挂起,停止甚至是编写一些程序。

    shell还是一个功能强大的编程语言,易编写,易调试。shell是解释执行的脚本语言,在shell中可以直接调用Linux命令。

    shell的两种主要语法有bourne和C,这两种语法彼此不兼容。bourne家族主要包括sh,ksh,Bash, psh,zsh,C家族主要用在unix,包括csh,tsh. 查看当前shell的类型的方法是:echo $SHELL

    概念辨析,shell是指一种应用程序,这个应用程序提供了一个界面,用户通过这个界面访问操作系统内核的服务。

    shell脚本(shell script),是一种为shell编写的脚本程序,业界所说的shell通常都是指shell脚本。

    shell有两种执行方式

    交互式:解释执行用户的命令,用户输入一条命令,shell就执行一条。

    批处理:用户事先写一个shell脚本,其中有很多命令,让shell一次把这些命令执行完,而不必一条一条地敲命令。

    编码

    首先,创建shell脚本文件:vim xxxx.sh ,后缀为.sh

    脚本执行有两种方式:1.赋予执行权限,chmod 755 xxxx.sh     2. 通过Bash调用执行脚本bash hello.sh

    特殊符号

    $ 调用变量的值

    ` `  反引号,引用系统命令

    $( )   引用系统命令

    '  '  单引号,在其中的特殊符号没有特殊含义。

    "  "   双引号,在其中的特殊符号没有特殊含义,但有三个除外:$  ,  ``  ,  \   

    管道符

    命令1  |  命令2     命令1的正确输出作为命令2的操作对象。

    输入输出重定向

    命令 > 文件   ,以覆盖的方式,把命令输出到指定的文件中

    命令 >> 文件   ,以追加的方式,把命令输出到指定的文件中。

    输出重定向

    命令 < 文件

    命令 < 标识符

    以下是在任务三中统计ngiinx响应时间的脚本:

    #!/bin/bash

    #nginx logs

    H=100

    cd /usr/local/nginx/logs/

    tail -n $H access.log|awk '{print $25,$26,$7 }'

    echo "统计了 $H 条数据"

    echo "响应时间0.01秒以内"

    tail -n $H access.log|awk 'BEGIN{sum=0}{if($26<0.01)sum++;}END{print sum}'

    echo "响应时间0.01~0.02秒"

    tail -n $H access.log|awk 'BEGIN{sum=0}{if(($26>=0.01)&&($26<0.02))sum++;}END{print sum}'

    echo "响应时间0.02~0.03秒"

    tail -n $H access.log|awk 'BEGIN{sum=0}{if(($26>=0.02)&&($26<0.03))sum++;}END{print sum}'

    echo "响应时间0.03~0.04"

    tail -n $H access.log|awk 'BEGIN{sum=0}{if(($26>=0.03)&&($26<0.04))sum++;}END{print sum}'

    echo "响应时间0.04及以上"

    tail -n $H access.log|awk 'BEGIN{sum=0}{if($26>=0.04)sum++;}END{print sum}'

    echo "访问量"

    tail -n $H access.log|awk '{print $7}' | wc -l

    tail -n $H access.log|awk '{print $11}' |sort | uniq -c |wc -l

    echo "#######统计完成######"

    展开全文
  • 本文介绍如何使用Shell脚本来开启和停止jar程序的后台运行,以及如何实现out大文件的切分。另外,补充一些后台运行的小知识。 启动脚本:start_upload.sh 1 2 3 #!/bin/sh nohup java -jar UploadSchedule.jar >...

    本文介绍如何使用Shell脚本来开启和停止jar程序的后台运行,以及如何实现out大文件的切分。另外,补充一些后台运行的小知识。

    启动脚本:start_upload.sh
    1
    2
    3
    #!/bin/sh
    nohup java -jar UploadSchedule.jar >> /usr/local/tomcat9/webapps/upload-to-oss/nohup_upload.out 2>&1 &
    echo $! > /var/run/UploadSchedule.pid
     启动脚本说明:

    1、开启后台执行,并将程序产生的日志文件写入out文件;
    2、将当前进程id写入/var/run/UploadSchedule.pid,以供在停止脚本中使用此pid来停止当前进程。

    停止脚本:stop_upload.sh
    1
    2
    3
    #!/bin/sh
    PID=$(cat /var/run/UploadSchedule.pid)
    kill -9 $PID
     停止脚本说明:

    1、首先获取进程id;
    2、然后杀掉该进程。

    文件切分:split_nohup.sh
    程序不中断,一直在后台运行,那么产生的log也会持续输出到out问价,导致out文件越来越大。当需要根据out文件进行一些日志查找的时候,非常不方便。所以定期对out文件进行切分,按日期将当日out文件切分成若干小文件,从而方便处理及错误查找定位。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #!/bin/bash
    log_path=/usr/local/tomcat9/webapps/upload-to-oss
     
    if [ -f "$log_path/nohup_upload.out" ];then
    current_date=`date -d "-1 day" "+%Y%m%d"`
    cp $log_path/nohup_upload.out $log_path/nohup_upload_${current_date}.out
    cat /dev/null > $log_path/nohup_upload.out
    split -b 5242880 -d -a 4 $log_path/nohup_upload_${current_date}.out $log_path/nohup_upload_${current_date}_
    rm -rf $log_path/nohup_upload_${current_date}.out
    fi
    切分脚本说明:

    1、如果out文件存在,将nohup_upload.out文件复制一份,命名为nohup_upload_当前日期(比如nohup_upload_20200328.out);
    2、将nohup_upload.out文件清空;
    3、对nohup_upload_20200328.out文件进行切分,切分后的文件命名格式为nohup_upload_20200328_0001,nohup_upload_20200328_0002;

    -b 指定每个小文件的大小(单位byte)
    -d 以数字作为后缀
    -a 指定后缀的长度
    4、将原文件(nohup_upload_20200328.out)删除。

    执行开启/停止命令
    1
    2
    3
    4
    5
    # 启动
    ./start_upload.sh
     
    # 停止
    ./stop_upload.sh
    一些后台运行的小知识
    &和nohup区别:
    &的意思是在后台运行。意思是说, 当你在执行 ./start_upload.sh & 的时候, 即使你用Ctrl + C, 那么start_upload.sh照样运行(因为对SIGINT信号免疫)。 但是要注意, 如果你直接关掉Shell后, 那么, start_upload.sh进程同样消失。 因为对SIGHUP信号不免疫。

    nohup的意思是忽略SIGHUP信号, 所以当运行nohup ./start_upload.sh的时候, 关闭Shell,start_upload.sh进程还是存在的(对SIGHUP信号免疫)。 但是如果你直接在Shell中用Ctrl + C, 那么,start_upload.sh进程也是会消失的(因为对SIGINT信号不免疫)

    所以,要让进程真正不受Shell中Ctrl + C和Shell关闭的影响, 就用nohup和&同时用。

    展开全文
  • *) echo "USAGE:$0{status|start|stop|restart}" exit 1 esac # Scripts return values exit $RETVAL 总结 到此这篇关于使用shell开发keepalived启动脚本的文章就介绍到这了,更多相关shell keepalived启动脚本内容...
  • 在Shell中要如何调用别的shell脚本,或别的脚本中的变量,函数呢,由于业务需要,在用户的根目录下总shell里面调用其它的子shell来启停程序,所以就先写个简单的停止程序的例子? 下面举一个简单例子,然后再扩展,...
  • 本文介绍如何使用Shell脚本来开启和停止jar程序的后台运行,以及如何实现out大文件的切分。另外,补充一些后台运行的小知识。启动脚本:start_upload.sh#!/bin/shnohup java -jar UploadSchedule.jar >> /usr/...
  • Shell脚本运行中的停止方法

    千次阅读 2020-08-21 20:53:26
    Linux系统Shell中提交了一个脚本,但是需要停止这个进程,如何处理? 方式1 killall file-flume-kafka 说明:killall是一个命令,不是kill all,file-flume-kafka是脚本名,此方法简单粗暴。 方式二 ssh $i "ps -...
  • 使用Shell脚本启动/停止Java的jar程序

    千次阅读 2020-03-28 21:33:17
    本文介绍如何使用Shell脚本来开启和停止jar程序的后台运行,以及如何实现out大文件的切分。另外,补充一些后台运行的小知识。
  • 一篇教会你写90%的shell脚本 转载自:华清远见的文章 - 知乎 https://zhuanlan.zhihu.com/p/264346586 shell是外壳的意思,就是操作系统的外壳。我们可以通过shell命令来操作和控制操作系统,比如Linux中的Shell...
  • shell脚本语法

    2017-12-18 15:15:44
    shell脚本的开头一般是#!/bin/bash 或#!/bin/sh ,#!是一个特殊的表示符,其后,跟着解释此脚本的shell路径;这两者存在一定差别,例如:shell sh执行出现错误后会停止执行,而shell bash是一直执行到低。 如何运行...
  • 本篇文章不介绍如何配置如何停止springboot的配置,网上有很多可以搜一下。 原理是通过本地localhost的http请求停止相关服务。 #此命令是一整行,我为了方便显示进行换行了。 curl -H &amp;amp;amp;amp;amp;quot...
  • Mac上安装Jenkins之后,Jenkins默认已经启动,那如何手动的启动与停止呢? 1.Jenkins 安装之后会在Mac /Library/LaunchDaemons/目录中产生一个 org.jenkins-ci.plist文件,启动与停止均使用此文件。 2. 启动...
  • 技术交流QQ群:1027579432,欢迎你的...可以通过对脚本进行编程,使其在收到特定信号时执行某些命令,从而控制shell脚本的操作。 2.1 重温Linux信号 Linux系统和应用程序可以生成超过30个信号,下面列出了Linux编程
  • 如何停止Android Monkey脚本 最近用monkey来包apk的性能测试,发现一旦monkey跑起来以后,即使将数据线和PC断开,monkey脚本还是会继续运行下去。结果找到了一个办法去停止它: 1. adb shell 2. top | grep ...
  • 原文地址:【Liunx每日一问】在一个Linux Shell脚本中,如何使输入的信息有提示呢?作者:融智技术学院 问题:在一个Shell脚本中,我想要停止输入,并且提示用户选择。标准的是‘Yes,No或Cancel’ 典型问题。我怎样...
  • Shell脚本 - 编程进阶06

    2020-06-02 20:09:35
    1、编写服务脚本 /root/bin/testsrv.sh,完成如下要求 (1)脚本可接受参数:start, stop, restart, status; (2)如果参数非此四者之一,提示使用格式后报错退出;...考虑:如果事先已然停止过了,该如何处理? (5
  • 简单的Shell脚本编程

    2020-06-12 17:50:23
    ping可以用来测试本机与目标主机是否联通、联通速度如何、稳定性如何。 用法为:“ping 参数 目标主机”。其中参数为零到多个,目标主机可以是IP或者域名。 参数 解释 -c ping指定次数后停止ping; -W 以...
  • 写在前面:案例、常用、归类、...Ctrl+Z组合键生产SIGTSTP信号,停止进程后程序仍然留在内存中,能够从停止的地方继续运行。 捕获信号 #!/bin/bash # testing output in a background job trap "echo Haha" SIGINT ...
  • 最近的开发过程中需要在Python中执行shell命令,现将学习到的使用方式记录下来主要参考Python官网的subprocess介绍:... 遇到阻塞性的shell命令,如top,会停止执行下面的语句要如何处理——利用linux的特性:comman...
  • 在Mac上使用jenkins的过程里,执行某些shell脚本时出现报错,查看报错信息发现是当前用户没有权限删除某个文件夹导致的。于是在网上搜了很多资料,发现可用的是少之又少,于是自己写篇博客总结一下如何在OSX操作系统...
  • 首先在写脚本之前,你要知道关于rsync的理论知识与实操,才能写好...停止命令: kill rsync进程号 pkill rsync killall rsync 话不多说,上脚本: #!/bin/bash ##################################### # File...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 121
精华内容 48
关键字:

如何停止shell脚本