it-swarm-eu.dev

Come uccidere un processo in esecuzione su una particolare porta in Linux?

Ho provato a chiudere Tomcat utilizzando ./shutdown.sh dalla directory /bin di Tomcat. Ma ho scoperto che il server non è stato chiuso correttamente. E quindi non sono stato in grado di riavviare
My Tomcat è in esecuzione sulla porta 8080.

Voglio uccidere il processo Tomcat in esecuzione su 8080. Prima desidero avere l'elenco dei processi in esecuzione su una porta specifica (8080) per selezionare quale processo uccidere.

482
veer7

Usa il comando

 Sudo netstat -plten |grep Java

usato grep Java come Tomcat usa Java come loro processi.

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

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

il numero prima di /Java è un id di processo. Ora usa il comando kill per terminare il processo

kill -9 16085

-9 implica che il processo verrà ucciso con forza.

213
veer7

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

E questo fuser -k 8080/tcp ucciderà quel processo.

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

690
nudzo

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)

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

432

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, uccidere il processo che lo utilizza (l'ID del processo è 75782) ...

kill -9 75782

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

97
Kop4lyf

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

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

72
Gal Bracha

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

Sudo lsof -t -i:8080

Qui,

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

Ora puoi facilmente uccidere il tuo PID usando il seguente comando:

Sudo kill -9 <PID>

Qui,

  • kill - comando per uccidere il processo
  • -9 - forzatamente

Puoi usare un comando per uccidere un processo su una porta specifica usando il seguente comando:

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

Per ulteriori informazioni puoi vedere il seguente link Come uccidere un processo su una porta specifica su linux

56
mahfuz110244

Questo stampa per lo stdout degli ID di processo di tutto ciò che gira su <port_number>

fuser -n tcp <port_number> 

Inoltre stampa alcune cose su stderr, quindi:

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

Possiamo quindi fornire questi id di processo al comando kill:

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)
}
36
Brian Peterson

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

netstat -tulnap | grep :*port_num*

otterrai la descrizione di quel processo. Adesso 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

31
Sanjay s.

prova così,

 Sudo fuser -n tcp -k 8080
17
Adil Abbasi

Ottieni il PID dell'attività e uccidilo.

lsof -ti:8080 | xargs kill
12
Rahul Garg

Linux : Innanzitutto puoi trovare PID di questo comando se conosci la porta:

netstat -tulpn 

esempio:-

 Local Address  Foreign Address  State    PID/Program name

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

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

kill -9 PID

Esempio: - 

kill -9 15986

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

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

11

Linux : puoi usare questo comando se conosci 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.

9
ben rhouma moez

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

6
Harshit Garg

Puoi sapere l'elenco di tutte le porte che eseguono in sistema insieme ai suoi dettagli (pid, indirizzo ecc.):

netstat -tulpn

Puoi sapere i dettagli di un particolare numero di porta fornendo il numero di porta nel seguente comando:

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

ex: Sudo netstat -lutnp | grep -w '8080' I dettagli verranno forniti in questo modo:

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

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

se si vuole uccidere un processo usando il numero di porta : fuser -n tcp {port_number}

usa Sudo se non sei in grado di accedervi.

4
YAP
Sudo apt-get install psmisc (or Sudo yum install psmisc)
Sudo fuser 80/tcp

Risultato: 80/tcp: 1858 1867 1868 1869 1871

Uccidi il processo uno per uno

uccidi -9 1858 

1
Fadid

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
}

per costruire su ciò che @ veer7 ha detto: 

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

0
JesseBoyd