One place for hosting & domains

      Cómo usar ps, kill y nice para administrar procesos en Linux


      Introducción


      Un servidor Linux, como cualquier otro equipo con el que pueda estar familiarizado, ejecuta aplicaciones. Para el equipo, estos se consideran “procesos”.

      Mientras que Linux se encargará de la administración de bajo nivel, entre bastidores, en el ciclo de vida de un proceso, se necesitará una forma de interactuar con el sistema operativo para administrarlo desde un nivel superior.

      En esta guía, explicaremos algunos aspectos sencillos de la administración de procesos. Linux proporciona una amplia colección de herramientas para este propósito.

      Exploraremos estas ideas en un VPS de Ubuntu 12.04, pero cualquier distribución moderna de Linux funcionará de manera similar.

      Cómo ver los procesos en ejecución en Linux


      top


      La forma más sencilla de averiguar qué procesos se están ejecutando en su servidor es ejecutar el comando top:

      top***
      
      top - 15:14:40 up 46 min,  1 user,  load average: 0.00, 0.01, 0.05 Tasks:  56 total,   1 running,  55 sleeping,   0 stopped,   0 zombie Cpu(s):  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st Mem:   1019600k total,   316576k used,   703024k free,     7652k buffers Swap:        0k total,        0k used,        0k free,   258976k cached   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND               1 root      20   0 24188 2120 1300 S  0.0  0.2   0:00.56 init                   2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd               3 root      20   0     0    0    0 S  0.0  0.0   0:00.07 ksoftirqd/0            6 root      RT   0     0    0    0 S  0.0  0.0   0:00.00 migration/0            7 root      RT   0     0    0    0 S  0.0  0.0   0:00.03 watchdog/0             8 root       0 -20     0    0    0 S  0.0  0.0   0:00.00 cpuset                 9 root       0 -20     0    0    0 S  0.0  0.0   0:00.00 khelper               10 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kdevtmpfs
      

      La parte superior de la información ofrece estadísticas del sistema, como la carga del sistema y el número total de tareas.

      Se puede ver fácilmente que hay 1 proceso en ejecución y 55 procesos en reposo (es decir, inactivos/que no usan los recursos de la CPU).

      La parte inferior tiene los procesos en ejecución y las estadísticas de uso.

      htop


      Una versión mejorada de top, llamada htop, está disponible en los repositorios. Instálelo con este comando:

      sudo apt-get install htop
      

      Si ejecutamos el comando htop, veremos que hay una pantalla más fácil de usar:

      htop***
      
        Mem[|||||||||||           49/995MB]     Load average: 0.00 0.03 0.05   CPU[                          0.0%]     Tasks: 21, 3 thr; 1 running   Swp[                         0/0MB]     Uptime: 00:58:11   PID USER      PRI  NI  VIRT   RES   SHR S CPU% MEM%   TIME+  Command  1259 root       20   0 25660  1880  1368 R  0.0  0.2  0:00.06 htop     1 root       20   0 24188  2120  1300 S  0.0  0.2  0:00.56 /sbin/init   311 root       20   0 17224   636   440 S  0.0  0.1  0:00.07 upstart-udev-brid   314 root       20   0 21592  1280   760 S  0.0  0.1  0:00.06 /sbin/udevd --dae   389 messagebu  20   0 23808   688   444 S  0.0  0.1  0:00.01 dbus-daemon --sys   407 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.02 rsyslogd -c5   408 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.00 rsyslogd -c5   409 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.00 rsyslogd -c5   406 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.04 rsyslogd -c5   553 root       20   0 15180   400   204 S  0.0  0.0  0:00.01 upstart-socket-br
      

      Puede aprender más sobre cómo usar top y htop aquí.

      Cómo usar ps para realizar una lista de procesos


      top y htop proporcionan una buena interfaz para ver los procesos en ejecución, similar a la de un administrador de tareas gráfico.

      Sin embargo, estas herramientas no siempre son lo suficientemente flexibles para cubrir adecuadamente todos los escenarios. Un poderoso comando llamado ps generalmente es la respuesta a estos problemas.

      Cuando se invoca sin argumentos, el resultado puede ser un poco escaso:

      ps***
      
        PID TTY          TIME CMD  1017 pts/0    00:00:00 bash  1262 pts/0    00:00:00 ps
      

      Este resultado muestra todos los procesos asociados con el usuario actual y la sesión de terminal. Eso tiene sentido porque, actualmente, solo estamos ejecutando bash y ps con este terminal.

      Para obtener un panorama más completo de los procesos en este sistema, podemos ejecutar lo siguiente:

      ps aux***
      
      USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND root         1  0.0  0.2  24188  2120 ?        Ss   14:28   0:00 /sbin/init root         2  0.0  0.0      0     0 ?        S    14:28   0:00 [kthreadd] root         3  0.0  0.0      0     0 ?        S    14:28   0:00 [ksoftirqd/0] root         6  0.0  0.0      0     0 ?        S    14:28   0:00 [migration/0] root         7  0.0  0.0      0     0 ?        S    14:28   0:00 [watchdog/0] root         8  0.0  0.0      0     0 ?        S<   14:28   0:00 [cpuset] root         9  0.0  0.0      0     0 ?        S<   14:28   0:00 [khelper] . . .
      

      Estas opciones ordenan a ps que muestre los procesos de propiedad de todos los usuarios (independientemente de su asociación con el terminal) en un formato fácil de usar.

      Para ver una vista de estructura jerárquica, en la que se ilustran las relaciones jerárquicas, podemos ejecutar el comando con las siguientes opciones:

      ps axjf***
      
       PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND     0     2     0     0 ?           -1 S        0   0:00 [kthreadd]     2     3     0     0 ?           -1 S        0   0:00  _ [ksoftirqd/0]     2     6     0     0 ?           -1 S        0   0:00  _ [migration/0]     2     7     0     0 ?           -1 S        0   0:00  _ [watchdog/0]     2     8     0     0 ?           -1 S<       0   0:00  _ [cpuset]     2     9     0     0 ?           -1 S<       0   0:00  _ [khelper]     2    10     0     0 ?           -1 S        0   0:00  _ [kdevtmpfs]     2    11     0     0 ?           -1 S<       0   0:00  _ [netns] . . .
      

      Como puede ver, el proceso kthreadd se muestra como proceso principal de kstadd/0 y los demás.

      Una nota sobre las ID de procesos


      En Linux y sistemas tipo Unix, a cada proceso se le asigna un ID de proceso o PID. Esta es la forma en que el sistema operativo identifica y realiza un seguimiento de los procesos.

      Una forma rápida de obtener el PID de un proceso es con el comando pgrep:

      pgrep bash***
      
      1017
      

      Esto simplemente consultará el ID del proceso y lo mostrará en el resultado.

      El primer proceso que se generó en el arranque, llamado init, recibe el PID “1”.

      pgrep init***
      
      1
      

      Entonces, este proceso es responsable de engendrar todos los demás procesos del sistema. Los procesos posteriores reciben números PID mayores.

      Un proceso principal es el proceso que se encargó de generarlo. Los procesos principales tienen un PPID, que puede ver en los encabezados de las columnas en muchas aplicaciones de administración de procesos, incluidos top, htop y ps.

      Cualquier comunicación entre el usuario y el sistema operativo sobre los procesos implica traducir entre los nombres de procesos y los PID en algún momento durante la operación. Este es el motivo por el que las utilidades le indican el PID.

      Las relaciones principal-secundario


      Para crear un proceso secundario se deben seguir dos pasos: fork(), que crea un nuevo espacio de direcciones y copia los recursos propiedad del principal mediante copy-on-write para que estén disponibles para el proceso secundario; y exec(), que carga un ejecutable en el espacio de direcciones y lo ejecuta.

      En caso de que un proceso secundario muera antes que su proceso principal, el proceso secundario se convierte en un zombi hasta que el principal haya recopilado información sobre él o haya indicado al núcleo que no necesita esa información. Luego, los recursos del proceso secundario se liberarán. Sin embargo, si el proceso principal muere antes que el secundario, init adoptará el secundario, aunque también puede reasignarse a otro proceso.

      Cómo enviar señales a los procesos en Linux


      Todos los procesos en Linux responden a señales. Las señales son una forma de decirle a los programas que terminen o modifiquen su comportamiento.

      Cómo enviar señales a los procesos por PID


      La forma más común de pasar señales a un programa es con el comando kill.

      Como es de esperar, la funcionalidad predeterminada de esta utilidad es intentar matar un proceso:

      kill PID_of_target_process

      Esto envía la señal TERM al proceso. La señal TERM indica al proceso debe terminar. Esto permite que el programa realice operaciones de limpieza y cierre sin problemas.

      Si el programa tiene un mal comportamiento y no se cierra cuando se le da la señal TERM, podemos escalar la señal pasando la señal KILL:

      kill -KILL PID_of_target_process

      Esta es una señal especial que no se envía al programa.

      En su lugar, se envía al núcleo del sistema operativo, que cierra el proceso. Eso se utiliza para eludir los programas que ignoran las señales que se les envían.

      Cada señal tiene un número asociado que puede pasar en vez del nombre. Por ejemplo, puede pasar “-15” en lugar de “-TERM” y “-9” en lugar de “-KILL”.

      Cómo usar señales para otros fines


      Las señales no solo se utilizan para cerrar programas. También pueden usarse para realizar otras acciones.

      Por ejemplo, muchos demonios se reinician cuando reciben la señal HUP o la señal de colgar. Apache es un programa que funciona así.

      sudo kill -HUP pid_of_apache

      El comando anterior hará que Apache vuelva a cargar su archivo de configuración y reanude sirviendo contenidos.

      Puede enumerar todas las señales que puede enviar con kill escribiendo lo siguiente:

      kill -l***
      
      1) SIGHUP    2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP  6) SIGABRT  7) SIGBUS   8) SIGFPE   9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM . . .
      

      Cómo enviar señales a los procesos por nombre


      Aunque la forma convencional de enviar señales es mediante el uso de PID, también hay métodos para hacerlo con nombres de procesos regulares.

      El comando pkill funciona casi exactamente igual que kill, pero funciona con un nombre de proceso en su lugar:

      pkill -9 ping
      

      El comando anterior es el equivalente a:

      kill -9 `pgrep ping`
      

      Si quiere enviar una señal a todas las instancias de un determinado proceso, puede utilizar el comando killall:

      killall firefox
      

      El comando anterior enviará la señal TERM a todas las instancias de firefox que se estén ejecutando en el equipo.

      Cómo ajustar las prioridades de los procesos


      A menudo, querrá ajustar qué procesos reciben prioridad en un entorno de servidor.

      Algunos procesos pueden considerarse como una misión crítica para su situación, mientras que otros pueden ejecutarse siempre que haya recursos sobrantes.

      Linux controla la prioridad a través de un valor llamado niceness.

      Las tareas de alta prioridad se consideran menos buenas porque no comparten los recursos tan bien. Por otro lado, los procesos de baja prioridad son buenos porque insisten en tomar solo los recursos mínimos.

      Cuando ejecutamos top al principio del artículo, había una columna marcada como “NI”. Este es el valor bueno del proceso:

      top***
      
      Tasks: 56 total, 1 running, 55 sleeping, 0 stopped, 0 zombie Cpu(s):  0.0%us,  0.3%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st Mem:   1019600k total,   324496k used,   695104k free,     8512k buffers Swap:        0k total,        0k used,        0k free,   264812k cached   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            1635 root      20   0 17300 1200  920 R  0.3  0.1   0:00.01 top                    1 root      20   0 24188 2120 1300 S  0.0  0.2   0:00.56 init                   2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd               3 root      20   0     0    0    0 S  0.0  0.0   0:00.11 ksoftirqd/0
      

      Los valores buenos pueden oscilar entre “-19/-20” (máxima prioridad) y “19/20” (mínima prioridad) dependiendo del sistema.

      Para ejecutar un programa con un determinado valor bueno, podemos usar el comando nice:

      nice -n 15 command_to_execute

      Esto solo funciona cuando se inicia un nuevo programa.

      Para alterar el valor bueno de un programa que ya se está ejecutando, usamos una herramienta llamada renice:

      renice 0 PID_to_prioritize

      Nota: Mientras que nice funciona necesariamente con un nombre de comando, renice funciona invocando al PID del proceso

      Conclusión


      La administración de procesos es un tema que a veces resulta difícil de entender para los nuevos usuarios, debido a que las herramientas utilizadas son diferentes a sus contrapartes gráficas.

      Sin embargo, las ideas son familiares e intuitivas, y, con un poco de práctica, se convertirá en algo natural. Dado que los procesos interviene en todo lo que se hace con un sistema informático, aprender a controlarlos de forma eficaz es una habilidad esencial.

      Por Justin Ellingwood



      Source link

      Como usar o ps, kill e nice para gerenciar processos no Linux


      Introdução


      Um servidor Linux, assim como qualquer outro computador que você conheça, executa aplicativos. Para o computador, eles são considerados “processos”.

      Embora o Linux lide nos bastidores com o gerenciamento de baixo nível no ciclo de vida de um processo, você precisará de uma maneira de interagir com o sistema operacional para gerenciá-lo de um nível superior.

      Neste guia, vamos discutir alguns aspectos simples do gerenciamento de processos. O Linux oferece uma coleção abundante de ferramentas para esse propósito.

      Vamos explorar essas ideias em um VPS Ubuntu 12.04, mas qualquer distribuição moderna do Linux funcionará de maneira similar.

      Como visualizar processos em execução no Linux


      top


      A maneira mais fácil de descobrir quais processos estão sendo executados no seu servidor é executando o comando top:

      top***
      
      top - 15:14:40 up 46 min,  1 user,  load average: 0.00, 0.01, 0.05 Tasks:  56 total,   1 running,  55 sleeping,   0 stopped,   0 zombie Cpu(s):  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st Mem:   1019600k total,   316576k used,   703024k free,     7652k buffers Swap:        0k total,        0k used,        0k free,   258976k cached   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND               1 root      20   0 24188 2120 1300 S  0.0  0.2   0:00.56 init                   2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd               3 root      20   0     0    0    0 S  0.0  0.0   0:00.07 ksoftirqd/0            6 root      RT   0     0    0    0 S  0.0  0.0   0:00.00 migration/0            7 root      RT   0     0    0    0 S  0.0  0.0   0:00.03 watchdog/0             8 root       0 -20     0    0    0 S  0.0  0.0   0:00.00 cpuset                 9 root       0 -20     0    0    0 S  0.0  0.0   0:00.00 khelper               10 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kdevtmpfs          
      

      A porção superior de informações mostra estatísticas do sistema, como a carga do sistema e o número total de tarefas.

      É possível ver facilmente que há 1 processo em execução e 55 processos estão suspensos (ou seja, ociosos/sem utilizar recursos da CPU).

      A parte inferior mostra os processos em execução e suas estatísticas de uso.

      htop


      Uma versão melhorada de top, chamada htop, está disponível nos repositórios. Instale-o com este comando:

      sudo apt-get install htop
      

      Se executarmos o comando htop, veremos que as informação são exibidas de uma maneira mais inteligível:

      htop***
      
        Mem[|||||||||||           49/995MB]     Load average: 0.00 0.03 0.05   CPU[                          0.0%]     Tasks: 21, 3 thr; 1 running   Swp[                         0/0MB]     Uptime: 00:58:11   PID USER      PRI  NI  VIRT   RES   SHR S CPU% MEM%   TIME+  Command  1259 root       20   0 25660  1880  1368 R  0.0  0.2  0:00.06 htop     1 root       20   0 24188  2120  1300 S  0.0  0.2  0:00.56 /sbin/init   311 root       20   0 17224   636   440 S  0.0  0.1  0:00.07 upstart-udev-brid   314 root       20   0 21592  1280   760 S  0.0  0.1  0:00.06 /sbin/udevd --dae   389 messagebu  20   0 23808   688   444 S  0.0  0.1  0:00.01 dbus-daemon --sys   407 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.02 rsyslogd -c5   408 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.00 rsyslogd -c5   409 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.00 rsyslogd -c5   406 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.04 rsyslogd -c5   553 root       20   0 15180   400   204 S  0.0  0.0  0:00.01 upstart-socket-br
      

      Aprenda mais sobre como usar o top e htop aqui.

      Como usar o ps para listar processos


      Tanto o top quanto o htop fornecem uma interface agradável para visualizar processos em execução, de maneira semelhante a um gerenciador de tarefas gráfico.

      No entanto, essas ferramentas nem sempre são flexíveis o suficiente para abranger adequadamente todos os cenários. Um comando poderoso chamado ps é geralmente a resposta para esses problemas.

      Quando chamado sem argumentos, o resultado pode ser um pouco confuso:

      ps***
      
        PID TTY          TIME CMD  1017 pts/0    00:00:00 bash  1262 pts/0    00:00:00 ps
      

      Esse resultado mostra todos os processos associados ao usuário e sessão de terminal atuais. Isso faz sentido porque estamos executando apenas o bash e ps com esse terminal atualmente.

      Para conseguirmos uma visão mais completa dos processos neste sistema, podemos executar o seguinte:

      ps aux***
      
      USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND root         1  0.0  0.2  24188  2120 ?        Ss   14:28   0:00 /sbin/init root         2  0.0  0.0      0     0 ?        S    14:28   0:00 [kthreadd] root         3  0.0  0.0      0     0 ?        S    14:28   0:00 [ksoftirqd/0] root         6  0.0  0.0      0     0 ?        S    14:28   0:00 [migration/0] root         7  0.0  0.0      0     0 ?        S    14:28   0:00 [watchdog/0] root         8  0.0  0.0      0     0 ?        S<   14:28   0:00 [cpuset] root         9  0.0  0.0      0     0 ?        S<   14:28   0:00 [khelper] . . .
      

      Essas opções dizem ao ps para mostrar processos de propriedade de todos os usuários (independentemente da sua associação de terminais) em um formato facilmente inteligível.

      Para ver um modo de exibição em árvore, onde relações hierárquicas são mostradas, executamos o comando com essas opções:

      ps axjf***
      
       PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND     0     2     0     0 ?           -1 S        0   0:00 [kthreadd]     2     3     0     0 ?           -1 S        0   0:00  _ [ksoftirqd/0]     2     6     0     0 ?           -1 S        0   0:00  _ [migration/0]     2     7     0     0 ?           -1 S        0   0:00  _ [watchdog/0]     2     8     0     0 ?           -1 S<       0   0:00  _ [cpuset]     2     9     0     0 ?           -1 S<       0   0:00  _ [khelper]     2    10     0     0 ?           -1 S        0   0:00  _ [kdevtmpfs]     2    11     0     0 ?           -1 S<       0   0:00  _ [netns] . . .
      

      Como se vê, o processo kthreadd é mostrado como um pai do processo ksoftirqd/0 e de outros.

      Uma nota sobre IDs de processo


      No Linux e em sistemas do tipo Unix, cada processo é atribuído a um ID de processo, ou PID. É assim que o sistema operacional identifica e mantém o controle dos processos.

      Uma maneira rápida de obter o PID de um processo é com o comando pgrep:

      pgrep bash***
      
      1017
      

      Isso irá simplesmente consultar o ID do processo e retorná-lo.

      Ao primeiro processo gerado na inicialização do sistema, chamado init, é atribuído o PID de “1″.

      pgrep init***
      
      1
      

      Esse processo é então responsável por gerar todos os processos no sistema. Os processos posteriores recebem números PID maiores.

      O pai de um processo é o processo que foi responsável por gerá-lo. Os processos pais possuem um PPID, que pode ser visto no cabeçalho da coluna correspondente em muitos aplicativos de gerenciamento de processos, incluindo o top, htop e ps.

      Qualquer comunicação entre o usuário e o sistema operacional em relação aos processos envolve a tradução entre os nomes de processos e PIDs em algum ponto durante a operação. É por isso que os utilitários informam o PID.

      Relacionamentos pai/filho


      A criação de um processo filho acontece em dois passos: fork(), que cria espaços de endereço e copia os recursos de propriedade do pai via copia em gravação para que fique disponível ao processo filho; e exec(), que carrega um executável no espaço de endereço e o executa.

      Caso um processo filho morra antes do seu pai, o filho torna-se um zumbi até que o pai tenha coletado informações sobre ele ou indicado ao kernel que ele não precisa dessas informações. Os recursos do processo filho serão então libertados. No entanto, se o processo pai morrer antes do filho, o filho será adotado pelo init, embora também possa ser reatribuído a outro processo.

      Como enviar sinais de processos no Linux


      Todos os processos no Linux respondem a sinais. Os sinais são uma maneira ao nível de SO de dizer aos programas para terminarem ou modificarem seu comportamento.

      Como enviar sinais de processos por PID


      A maneira mais comum de passar sinais para um programa é com o comando kill.

      Como se espera, a funcionalidade padrão desse utilitário é tentar encerrar um processo:

      <pre>kill <span class=“highlight”>PIDoftarget_process</span></pre>

      Isso envia o sinal TERM ao processo. O sinal TERM pede ao processo para encerrar. Isso permite que o programa execute operações de limpeza e seja finalizado sem problemas.

      Se o programa estiver se comportando incorretamente e não se encerrar quando um sinal TERM for passado, podemos escalar o sinal passando o sinal KILL:

      <pre>kill -KILL <span class=“highlight”>PIDoftarget_process</span></pre>

      Esse é um sinal especial que não é enviado ao programa.

      Ao invés disso, ele é dado ao kernel do sistema operacional, que encerra o processo. Isso é usado para passar por cima de programas que ignoram os sinais que lhe são enviados.

      Cada sinal possui um número associado que pode ser passado ao invés de seu nome. Por exemplo, é possível passar “-15″ ao invés de ”-TERM” e ”-9″ ao invés de ”-KILL”.

      Como usar sinais para outros fins


      Os sinais não são usados apenas para encerrar programas. Eles também podem ser usados para realizar outras ações.

      Por exemplo, muitos daemons são reiniciados quando recebem o HUP, ou sinal de desligamento. O Apache é um programa que funciona dessa forma.

      <pre>sudo kill -HUP <span class=“highlight”>pidofapache</span></pre>

      O comando acima fará com que o Apache recarregue seu arquivo de configuração e retome o serviço de conteúdo.

      Liste todos os sinais que podem ser enviados com o kill digitando:

      kill -l***
      
      1) SIGHUP    2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP  6) SIGABRT  7) SIGBUS   8) SIGFPE   9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM . . .
      

      Como enviar sinais de processos pelo nome


      Embora a maneira convencional de enviar sinais seja através do uso de PIDs, também existem métodos para fazer isso com os nomes regulares dos processos.

      O comando pkill funciona de maneira bastante similar ao kill, com a diferença de operar com um nome de processo:

      pkill -9 ping
      

      O comando acima é equivalente a:

      kill -9 `pgrep ping`
      

      Se quiser enviar um sinal para todas as instâncias de um determinado processo, utilize o comando killall:

      killall firefox
      

      O comando acima enviará o sinal TERM para todas as instâncias do firefox em execução no computador.

      Como ajustar prioridades de processos


      Geralmente, é desejável ajustar quais processos recebem prioridade em um ambiente de servidor.

      Alguns processos podem ser considerados críticos para sua situação, enquanto outros podem ser executados sempre que houver recursos sobrando no sistema.

      O Linux controla a prioridade através de um valor chamado niceness (gentileza).

      As tarefas de alta prioridade são consideradas menos nice (gentis), porque não compartilham recursos tão bem. Por outro lado, os processos de baixa prioridade são nice, porque insistem em utilizar apenas a menor quantidade de recursos.

      Quando executamos o top no início do artigo, havia uma coluna marcada “NI”. Esse é o valor de gentileza do processo:

      top***
      
       Tasks:  56 total,   1 running,  55 sleeping,   0 stopped,   0 zombie Cpu(s):  0.0%us,  0.3%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st Mem:   1019600k total,   324496k used,   695104k free,     8512k buffers Swap:        0k total,        0k used,        0k free,   264812k cached   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            1635 root      20   0 17300 1200  920 R  0.3  0.1   0:00.01 top                    1 root      20   0 24188 2120 1300 S  0.0  0.2   0:00.56 init                   2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd               3 root      20   0     0    0    0 S  0.0  0.0   0:00.11 ksoftirqd/0
      

      Os valores de gentileza podem variar entre “-19/-20” (prioridade mais alta) e ”19/20” (prioridade mais baixa), dependendo do sistema.

      Para executar um programa com um certo valor de gentileza, podemos usar o comando nice:

      <pre>nice -n 15 <span class=“highlight”>commandtoexecute</span></pre>

      Isso funciona apenas ao iniciar um novo programa.

      Para alterar o valor de gentileza de um programa que já está sendo executado, usamos uma ferramenta chamada renice:

      <pre>renice 0 <span class=“highlight”>PIDtoprioritize</span></pre>

      Nota: embora o comando nice opere necessariamente com um nome de comando, o renice opera chamando o PID do processo

      Conclusão


      O gerenciamento de processos é um tópico que pode ser de difícil compreensão para novos usuários, pois as ferramentas usadas são diferentes de seus equivalentes gráficos.

      No entanto, as ideias são habituais e intuitivas e, com um pouco de prática, se tornarão naturais. Como os processos estão envolvidos em tudo o que é feito em um sistema de computador, aprender como controlá-los de maneira eficaz é uma habilidade essencial.

      <div class=“author”>Por Justin Ellingwood</div>



      Source link

      Cómo usar las instrucciones break, continue y pass cuando se trabaja con bucles en Python 3


      Introducción

      Usar bucles for y bucles while en Python le permite automatizar y repetir tareas de manera eficiente.

      Sin embargo, a veces, es posible que un factor externo influya en la forma en que se ejecuta su programa. Cuando esto sucede, es posible que prefiera que su programa cierre un bucle por completo, omita parte de un bucle antes de continuar o ignore ese factor externo. Puede hacer estas acciones con las instrucciones break, continue y pass.

      Instrucción break

      En Python, la instrucción break le proporciona la oportunidad de cerrar un bucle cuando se activa una condición externa. Debe poner la instrucción break dentro del bloque de código bajo la instrucción de su bucle, generalmente después de una instrucción if condicional.

      Veamos un ejemplo en el que se utiliza la instrucción break en un bucle for:

      number = 0
      
      for number in range(10):
          if number == 5:
              break    # break here
      
          print('Number is ' + str(number))
      
      print('Out of loop')
      
      

      En este pequeño programa, la variable number se inicia en 0. Luego, una instrucción for construye el bucle siempre que la variable number sea inferior a 10.

      En el bucle for, existe una instrucción if que presenta la condición de que si la variable number es equivalente al entero 5, entonces el bucle se romperá.

      En el bucle también existe una instrucción print() que se ejecutará con cada iteración del bucle for hasta que se rompa el bucle, ya que está después de la instrucción break.

      Para saber cuándo estamos fuera del bucle, hemos incluido una instrucción print() final fuera del bucle for.

      Cuando ejecutemos este código, el resultado será el siguiente:

      Output

      Number is 0 Number is 1 Number is 2 Number is 3 Number is 4 Out of loop

      Esto muestra que una vez que se evalúa el entero number como equivalente a 5, el bucle se rompe porque se indica al programa que lo haga con la instrucción break.

      La instrucción break hace que un programa interrumpa un bucle.

      Instrucción continue

      La instrucción continue da la opción de omitir la parte de un bucle en la que se activa una condición externa, pero continuar para completar el resto del bucle. Es decir, la iteración actual del bucle se interrumpirá, pero el programa volverá a la parte superior del bucle.

      La instrucción continue se encuentra dentro del bloque de código abajo de la instrucción del bucle, generalmente después de una instrucción if condicional.

      Usando el mismo programa de bucle for que en la sección anterior Instrucción break, emplearemos la instrucción continue en vez de la instrucción break:

      number = 0
      
      for number in range(10):
          if number == 5:
              continue    # continue here
      
          print('Number is ' + str(number))
      
      print('Out of loop')
      
      

      La diferencia al usar la instrucción continue en vez de una instrucción break radica en que nuestro código continuará a pesar de la interrupción cuando la variable number se evalúe como equivalente a 5. Veamos el resultado:

      Output

      Number is 0 Number is 1 Number is 2 Number is 3 Number is 4 Number is 6 Number is 7 Number is 8 Number is 9 Out of loop

      Aquí, Number is 5 nunca aparece en el resultado, pero el bucle continúa después de ese punto para imprimir líneas para los números 6 a 10 antes de cerrarse.

      Puede usar la instrucción continue para evitar código condicional profundamente anidado o para optimizar un bucle eliminando los casos frecuentes que desee rechazar.

      La instrucción continue hace que un programa omita determinados factores que surgen dentro de un bucle, pero luego continuará con resto de este.

      Instrucción Pass

      Cuando se activa una condición externa, la instrucción pass permite manejar la condición sin que el bucle se vea afectado de ninguna manera; todo el código continuará leyéndose a menos que se produzca la instrucción break u otra instrucción.

      Igual que con las demás instrucciones, la instrucción pass se encuentra dentro del bloque de código abajo de la instrucción del bucle, normalmente después de una instrucción if condicional.

      Usando el mismo bloque de código que antes, sustituiremos la instrucción break o continue con una instrucción pass:

      number = 0
      
      for number in range(10):
          if number == 5:
              pass    # pass here
      
          print('Number is ' + str(number))
      
      print('Out of loop')
      
      

      La instrucción pass que se produce después de la instrucción condicional if le indica al programa que continúe ejecutando el bucle e ignore el hecho de que la variable number se evalúa como equivalente a 5 durante una de sus iteraciones.

      Ejecutaremos el programa y consideraremos el resultado:

      Output

      Number is 0 Number is 1 Number is 2 Number is 3 Number is 4 Number is 5 Number is 6 Number is 7 Number is 8 Number is 9 Out of loop

      Al usar la instrucción pass en este programa, observamos que el programa se ejecuta exactamente como lo haría si no hubiera instrucción condicional en el programa. La instrucción pass le indica al programa que ignore esa condición y continúe ejecutando el programa como de costumbre.

      La instrucción pass puede crear clases mínimas o actuar como marcador de posición al trabajar en un nuevo código y pensar en un nivel de algoritmo antes de preparar detalles.

      Conclusión

      Las instrucciones break, continue y pass en Python le permitirán usar los bucles for y los bucles while en su código de manera más eficaz.

      Para trabajar más con las instrucciones break y pass, puede seguir el tutorial de nuestro proyecto “Cómo crear un Twitterbot con Python 3 y la Biblioteca Tweepy”.



      Source link