Come terminare un processo in esecuzione su una determinata porta in Linux?

Ho provato a chiudere Tomcat utilizzando ./shutdown.shdalla /bindirectory Tomcat . Ma ho scoperto che il server non è stato chiuso correttamente. E quindi non sono riuscito a riavviare Il
mio Tomcat è in esecuzione sulla porta 8080.

Voglio terminare il processo Tomcat in esecuzione 8080. Voglio prima avere l'elenco dei processi in esecuzione su una porta specifica (8080) al fine di selezionare quale processo uccidere.

Questo fuser 8080/tcpstamperà il PID del processo associato su quella porta.

E questo fuser -k 8080/tcpucciderà quel processo.

Funziona solo su Linux. Più universale è l'uso di lsof -i4(o 6 per IPv6).

Per elencare qualsiasi processo che ascolta la porta 8080:

lsof -i:8080

Per terminare qualsiasi processo ascoltando la porta 8080:

kill $(lsof -t -i:8080)

o più violentemente:

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

( -9corrisponde al SIGKILL - terminate immediately/hard killsegnale: vedi Elenco dei segnali di uccisione e Qual è lo scopo dell'opzione -9 nel comando kill?. Se non viene specificato alcun segnale kill, viene inviato il segnale TERM aka -15o soft killviene inviato, che a volte non è sufficiente per uccidere un processo.).

Usa il comando

 sudo netstat -plten |grep java

usati grep javacome tomcatusi javacome i loro processi.

Mostrerà l'elenco dei processi con numero di porta e ID processo

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

il numero prima /javaè un ID processo. Ora usa il killcomando per terminare il processo

kill -9 16085

-9 implica che il processo verrà ucciso forzatamente.

Vorrei aggiungere questo one-liner per eliminare solo ASCOLTA su una porta specifica:

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

Puoi usare il comando lsof. Lascia che il numero di porta come qui sia 8090

lsof -i:8090

Questo comando restituisce un elenco di processi aperti su questa porta.

Qualcosa di simile a…

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

Per liberare la porta, uccidi il processo utilizzandolo (l'id del processo è 75782) ...

kill -9 75782

Questo ha funzionato per me. ecco il link dal post originale: link

Se si desidera interrompere un processo in esecuzione sul numero di porta 8080, prima è necessario trovare il numero di identificazione del processo (PID) della porta 8080 e quindi interromperlo. Eseguire il comando seguente per trovare il PID del numero di porta 8080:

sudo lsof -t -i:8080

Qui,

• sudo - comando per chiedere il privilegio di amministratore (ID utente e password).
• lsof - elenco di file (utilizzato anche per elencare i processi correlati)
• -t - mostra solo l'ID del processo
• -i - mostra solo il processo relativo alle connessioni Internet
• : 8080 - mostra solo i processi in questo numero di porta

Quindi ora puoi facilmente uccidere il tuo PID usando il seguente comando:

sudo kill -9 <PID>

Qui,

• kill - comando per terminare il processo
• -9 - con forza

È possibile utilizzare un comando per terminare un processo su una porta specifica utilizzando il comando seguente:

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

Per di più puoi vedere il seguente link Come uccidere un processo su una porta specifica su Linux

Il modo migliore per terminare tutti i processi su una porta specifica;

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

Questo stampa per stdout gli ID di processo di tutto ciò che è in esecuzione <port_number>:

fuser -n tcp <port_number> 

Stampa anche alcune cose su stderr, quindi:

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

Possiamo quindi fornire questi ID di processo al killcomando:

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

Puoi anche metterlo in una funzione se lo fai molto:

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

Ottieni il PID dell'attività e uccidilo.

lsof -ti:8080 | xargs kill

Per conoscere il pid di servizio in esecuzione su una determinata porta:

netstat -tulnap | grep :*port_num*

otterrai la descrizione di quel processo. Ora usa kill o kill -9 pid. Facilmente ucciso.

per esempio

netstat -ap | grep :8080

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

Adesso:

kill -9 1880

Ricorda di eseguire tutti i comandi come root

Una fodera

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

spiegazione qui: usa una combinazione di 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)

seleziona pid e usa kill

kill 23672

prova così,

 sudo fuser -n tcp -k 8080

Scegli il numero di porta e applica grep nel comando netstat come mostrato di seguito

netstat -ap | grep :7070

Uscita console

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

Uccidi il servizio in base al PID (Process Identification Number)

kill -9 3332

1. lsof -i tcp:8000 Questo comando elenca le informazioni sul processo in esecuzione nella porta 8000

2. kill -9 [PID] Questo comando interrompe il processo

Linux : per prima cosa puoi trovare il PID di questo comando se conosci la porta:

netstat -tulpn 

esempio:-

 Local Address  Foreign Address  State    PID/Program name

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

Quindi prendi il processo di uccisione. eseguire il comando seguente:

uccidere -9 PID

Esempio: -

uccidere -9 15986

Linux : è possibile utilizzare questo comando se si conosce la porta:

netstat -plten | grep LISTEN | grep 8080

AIX :

netstat -Aan | grep LISTEN | grep 8080

Quindi prendi la prima colonna (esempio: f100050000b05bb8) ed esegui il seguente comando:

rmsock f100050000b05bb8 tcpcb

termina il processo.

Puoi conoscere l' elenco di tutte le porte in esecuzione nel sistema insieme ai suoi dettagli (pid, indirizzo ecc.):

netstat -tulpn

È possibile conoscere i dettagli di un determinato numero di porta fornendo il numero di porta nel seguente comando:

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

es: sudo netstat -lutnp | grep -w '8080' I dettagli saranno forniti in questo modo:

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

se vuoi terminare un processo usando pid, allora :kill -9 {PID}

se vuoi terminare un processo usando il numero di porta :fuser -n tcp {port_number}

utilizzare sudose non si è in grado di accedervi.

kill -9 `fuser 8080/tcp|xargs -n 1`, questo comando uccide anche il processo che è in ascolto sulla porta 8080 con connessione TCP

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

Risultato: 80 / tcp: 1858 1867 1868 1869 1871

Uccidi processo uno per uno

uccidere -9 1858

Sto lavorando su un sistema Yocto Linux che ha un set limitato di strumenti Linux disponibili. Volevo terminare il processo che utilizzava una porta particolare (1883).

Innanzitutto, per vedere quali porte stiamo ascoltando ho usato il seguente 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      

Successivamente, ho trovato il nome del processo utilizzando la porta 1883 nel modo seguente:

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

Come possiamo vedere sopra, è il programma /usr/sbin/mosquitto che utilizza la porta 1883.

Infine, ho ucciso il processo:

root@root:~# systemctl stop mosquitto

Ho usato systemctlperché in questo caso era un servizio systemd.

Nel mio caso cent os ha qualche problema nella risposta suggerita. Quindi ho usato la seguente soluzione:

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

basarsi su ciò che ha detto @ veer7 :

se vuoi sapere cosa c'era sulla porta, fallo prima di ucciderlo.

$ 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

Usa 'ps' e il numero del processo che netstat ha riportato

Altro modo con 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. per prima cosa controlla il processo netstat -lt
2. controlla ID processo fuser <port number>/tcp
3. termina il processo in esecuzione sulla porta kill <process id>

In Windows, lo sarà netstat -ano | grep "8080"e verrà visualizzato il seguente messaggioTCP 0.0.0.0:8080 0.0.0.0:0 LISTENING 10076

Possiamo uccidere il PID usando taskkill /F /PID 10076