Como matar um processo em execução em uma porta específica no Linux?

Tentei fechar o tomcat usando ./shutdown.shdo /bindiretório tomcat . Mas descobriu que o servidor não estava fechado corretamente. E, portanto, não consegui reiniciar.
Meu tomcat está sendo executado na porta 8080.

Eu quero matar o processo do tomcat em execução 8080. Eu quero primeiro ter a lista de processos em execução em uma porta específica (8080) para selecionar qual processo matar.

Isso fuser 8080/tcpimprimirá o PID do processo vinculado a essa porta.

E isso fuser -k 8080/tcpmatará esse processo.

Funciona apenas no Linux. Mais universal é o uso de lsof -i4(ou 6 para IPv6).

Para listar qualquer processo que esteja ouvindo a porta 8080:

lsof -i:8080

Para matar qualquer processo que esteja ouvindo a porta 8080:

kill $(lsof -t -i:8080)

ou mais violentamente:

kill -9 $(lsof -t -i:8080)

( -9corresponde ao SIGKILL - terminate immediately/hard killsinal: consulte Lista de sinais de interrupção e qual é o objetivo da opção -9 no comando kill? Se nenhum sinal for especificado kill, o sinal TERM conhecido como -15ou soft killserá enviado, o que às vezes não é suficiente para matar um processo.).

Use o comando

 sudo netstat -plten |grep java

usado grep javacomo tomcatusos javacomo seus processos.

Ele mostrará a lista de processos com o número da porta e o ID do processo

tcp6       0      0 :::8080                 :::*                    LISTEN      
1000       30070621    16085/java

o número anterior /javaé uma identificação de processo. Agora use o killcomando para matar o processo

kill -9 16085

-9 implica que o processo será morto com força.

Eu adicionaria este one-liner para matar apenas LISTEN na porta específica:

kill -9 $(lsof -t -i:3000 -sTCP:LISTEN)

Você pode usar o comando lsof. Vamos número da porta como aqui é 8090

lsof -i:8090

Este comando retorna uma lista de processos abertos nessa porta.

Algo como…

COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
ssh 75782 eoin 5u IPv6 0x01c1c234 0t0 TCP localhost:8090 (LISTEN)

Para liberar a porta, interrompa o processo usando-a (a identificação do processo é 75782)…

kill -9 75782

Este funcionou para mim. aqui está o link da postagem original: link

Se você deseja matar um processo em execução na porta número 8080, primeiro você precisa encontrar o número de identificação do processo da porta 8080 (PID) e depois matá-lo. Execute o seguinte comando para localizar o PID do número da porta 8080:

sudo lsof -t -i:8080

Aqui,

• sudo - comando para solicitar privilégios de administrador (ID do usuário e senha).
• lsof - lista de arquivos (também usado para listar processos relacionados)
• -t - mostra apenas o ID do processo
• -i - mostra apenas o processo relacionado às conexões com a Internet
• : 8080 - mostra apenas processos neste número de porta

Agora você pode facilmente matar seu PID usando o seguinte comando:

sudo kill -9 <PID>

Aqui,

• kill - comando para matar o processo
• -9 - com força

Você pode usar um comando para matar um processo em uma porta específica usando o seguinte comando:

sudo kill -9 $(sudo lsof -t -i:8080)

Para mais, você pode ver o seguinte link Como matar um processo em uma porta específica no Linux

A melhor maneira de matar todos os processos em uma porta específica;

kill -9 $(sudo lsof -t -i:8080)

Isso imprime para stdout os IDs do processo de tudo em execução <port_number>:

fuser -n tcp <port_number> 

Ele também imprime algumas coisas no stderr, portanto:

fuser -n tcp <port_number> 2> /dev/null

Podemos então fornecer esses IDs de processo ao killcomando:

sudo kill $(fuser -n tcp <port_number> 2> /dev/null)

Você também pode colocar isso em uma função se fizer muito:

function killport() {
    sudo kill $(fuser -n tcp $1 2> /dev/null)
}

Obtenha o PID da tarefa e mate-o.

lsof -ti:8080 | xargs kill

Para conhecer o pid de serviço em execução em uma porta específica:

netstat -tulnap | grep :*port_num*

você obterá a descrição desse processo. Agora use kill ou kill -9 pid. Facilmente morto.

por exemplo

netstat -ap | grep :8080

tcp6       0      0 :::8080       :::*    LISTEN      1880/java 

Agora:

kill -9 1880

Lembre-se de executar todos os comandos como root

Um forro

kill -9 $(lsof -t -i tcp:8080)

explicação aqui: use uma combinação de lsof and kill

root@localhost:~# lsof -i tcp:8080
COMMAND   PID USER   FD   TYPE  DEVICE SIZE/OFF NODE NAME
java    23672 sine  238u  IPv6 3028222      0t0  TCP localhost:http-alt (LISTEN)

selecione pid e use kill

kill 23672

tente assim,

 sudo fuser -n tcp -k 8080

Escolha o número da porta e aplique o comando grep in netstat, como mostrado abaixo

netstat -ap | grep :7070

Saída do console

tcp 0 0 ::: 7070 ::: * LISTEN 3332 / java

Mate o serviço com base no PID (Número de identificação do processo)

kill -9 3332

1. lsof -i tcp:8000 Este comando lista as informações sobre o processo em execução na porta 8000

2. kill -9 [PID] Este comando mata o processo

Linux : Primeiro, você pode encontrar o PID deste comando se conhecer a porta:

netstat -tulpn 

exemplo:-

 Local Address  Foreign Address  State    PID/Program name

  :::3000       :::*             LISTEN    15986/node 

Você então pega o processo de matar. execute o seguinte comando:

kill -9 PID

Exemplo: -

kill -9 15986

Linux : você pode usar este comando se souber a porta:

netstat -plten | grep LISTEN | grep 8080

AIX :

netstat -Aan | grep LISTEN | grep 8080

Você pega a primeira coluna (exemplo: f100050000b05bb8) e executa o seguinte comando:

rmsock f100050000b05bb8 tcpcb

matar processo.

Você pode conhecer a lista de todas as portas em execução no sistema, juntamente com seus detalhes (pid, endereço etc.):

netstat -tulpn

Você pode saber detalhes de um número de porta específico fornecendo o número da porta no seguinte comando:

sudo netstat -lutnp | grep -w '{port_number}'

ex: sudo netstat -lutnp | grep -w '8080' Detalhes serão fornecidos assim:

Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name

se você quiser matar um processo usando o pid, então :kill -9 {PID}

se você deseja matar um processo usando o número da porta :fuser -n tcp {port_number}

use sudose você não conseguir acessar nenhum.

kill -9 `fuser 8080/tcp|xargs -n 1`, esse comando também mata o processo que escuta na porta 8080 com conexão TCP

sudo apt-get install psmisc (or sudo yum install psmisc)
sudo fuser 80/tcp

Resultado: 80 / tcp: 1858 1867 1868 1869 1871

Mate o processo um por um

kill -9 1858

Estou trabalhando em um sistema Yocto Linux que possui um conjunto limitado de ferramentas Linux disponíveis. Eu queria matar o processo que estava usando uma porta específica (1883).

Primeiro, para ver quais portas estamos ouvindo, usei o seguinte comando:

root@root:~# netstat -lt
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       
tcp        0      0 0.0.0.0:hostmon         0.0.0.0:*               LISTEN      
tcp        0      0 localhost.localdomain:domain 0.0.0.0:*               LISTEN      
tcp        0      0 0.0.0.0:9080            0.0.0.0:*               LISTEN      
tcp        0      0 0.0.0.0:1883            0.0.0.0:*               LISTEN      
tcp        0      0 :::hostmon              :::*                    LISTEN      
tcp        0      0 localhost:domain        :::*                    LISTEN      
tcp        0      0 :::ssh                  :::*                    LISTEN      
tcp        0      0 :::1883                 :::*                    LISTEN      

Em seguida, encontrei o nome do processo usando a porta 1883 da seguinte maneira:

root@root:~# fuser 1883/tcp
290 
root@root:~# ps | grep 290
  290 mosquitt 25508 S    /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf
12141 root      8444 S    grep 290

Como podemos ver acima, é o programa /usr/sbin/mosquittoque está usando a porta 1883.

Por fim, eu matei o processo:

root@root:~# systemctl stop mosquitto

Eu usei systemctlporque neste caso era um serviço systemd.

No meu caso, o cent os tem algum problema na resposta sugerida. Então, eu usei a seguinte solução:

  ss -tanp | grep 65432 | head -1 | grep -Po "(?<=pid=).*(?=,)" | xargs kill

para construir sobre o que @ veer7 disse:

se você quiser saber o que estava na porta, faça isso antes de matá-lo.

$ sudo netstat -plten |grep java
tcp6       0      0 127.0.0.1:8005          :::*                    LISTEN      1000       906726      25296/java      
tcp6       0      0 :::8009                 :::*                    LISTEN      1000       907503      25296/java      
tcp6       0      0 :::8080                 :::*                    LISTEN      1000       907499      25296/java      
$ ps 25296
  PID TTY      STAT   TIME COMMAND
25296 ?        Sl     0:16 /usr/lib/jvm/java-8-openjdk-amd64/bin/java -Dcatalina.base=/hom

Use 'ps' e o número do processo relatado pelo netstat

Outra maneira com o Git Bash:

stopProcessByPortNumber() {
port=":${1}"
portStrLine="$(netstat -ano | findstr LISTENING | findstr $port)"
processId="$(grep -oP '(\d+)(?!.*\d)' <<< $portStrLine)"
echo $processId
taskkill -PID $processId -F
}

1. primeiro verifique o processo netstat -lt
2. verificar identificação do processo fuser <port number>/tcp
3. mate o processo em execução na porta kill <process id>

No Windows, será netstat -ano | grep "8080"e receberemos a seguinte mensagemTCP 0.0.0.0:8080 0.0.0.0:0 LISTENING 10076

Nós podemos matar o PID usando taskkill /F /PID 10076