Comment tuer un processus qui s'exécute sur un port particulier dans Linux?

J'ai essayé de fermer le tomcat à l'aide ./shutdown.sh de tomcat /bin répertoire. Mais a constaté que le serveur n'a pas été fermé correctement. Et donc j'ai été incapable de redémarrer
Mon tomcat est en cours d'exécution sur le port 8080.

Je veux tuer le tomcat processus en cours d'exécution sur 8080. J'ai d'abord envie d'avoir la liste des processus en cours d'exécution sur un port spécifique (8080) afin de sélectionner les processus pour tuer.

double possible de script shell pour tuer le processus à l'écoute sur le port 3000?

InformationsquelleAutor veer7 | 2012-07-20

748

Ce fuser 8080/tcp permettra de vous imprimer le PID du processus lié sur ce port.

Et ce fuser -k 8080/tcp va tuer le processus.

Ne fonctionne que sous Linux. De plus universel est l'utilisation de lsof -i4 (ou 6 pour IPv6).
- est-ce à près possible d'un socket connecté au port 8080 ainsi?
- Bien sûr, tous les descripteurs de fichiers sont fermés lorsque le processus de finition.
- Il n'est pas correctement fermer le port. Le port est mis en état TIME_WAIT après le processus père est tué. Le système d'exploitation sera alors éventuellement de fermer complètement le port après environ 60 secondes. Cela signifie que vous ne pouvez pas réutiliser le port pendant au moins 60 secondes (sauf si vous donnez la réutilisation de l'option à la prise).
- j'utilise linux et j'ai bash: fuser: command not found.
- Sur Darwin, doit utiliser une version différente de fuser. Prend seulement un fichier, ne prend pas en charge -k.
- 'fuser -k -n tcp 8080' va tuer le processus est trop
- merci cela fonctionne pour moi
- unité de fusion est une partie de psmisc. Dans le cas où vous obtenez fuser: command not found, installer psmisc. Pour CentOS/RHEL 7, exécutez sudo yum install psmisc
InformationsquelleAutor nudzo
500

Pour afficher la liste des processus à l'écoute sur le port 8080:
```
lsof -i:8080
```
Pour tuer tous les processus de l'écoute sur le port 8080:
```
kill $(lsof -t -i:8080)
```
ou plus violemment:
```
kill -9 $(lsof -t -i:8080)
```
(-9 correspond à la SIGKILL - terminate immediately/hard kill signal: voir Liste de Tuer des Signaux et Quel est le but de l'-9 option dans la commande kill?. Si aucun signal n'est spécifiée pour kill, le TERME de signal.k.un. -15 ou soft kill est envoyé, ce qui n'est pas assez pour tuer un processus.).
- tuer: utilisation: kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... ou kill-l [sigspec] c'est Ce que j'obtiens lorsque j'exécute vos commandes
- avez-vous avec le super utilisateur sudo
- Travaillé sur mon Mac ainsi
- Je voudrais ajouter que, parfois, vous n'avez pas les permissions pour voir l'id de processus, dans ce cas, vous devez faire sudo lsof -i:8080.
- pourquoi le deuxième des conseils est de plus en plus violents ?
- plus violemment signifie qu'il tue mon navigateur web à 🙁 Ici est la meilleure solution de Gal Bracha: kill -9 $(lsof-t -i:3000 -sTCP:ÉCOUTER)
- correspond à SIGKILL - terminate immediately/hard kill: voir Liste de Tuer des Signaux et Quel est le but de l'-9 option dans la commande kill?)
- sur cette base, avec sudo: killport() {sudo kill -9 $(sudo lsof -t -i:${1} -sTCP:LISTEN)} et puis killport 8080
InformationsquelleAutor Franck Dernoncourt
227

Utilisez la commande
```
 sudo netstat -plten |grep java
```
utilisé grep java comme tomcat utilise java que leurs processus.

Il affichera la liste de processus avec le numéro de port et l'identifiant du processus
```
tcp6       0      0 :::8080                 :::*                    LISTEN      
1000       30070621    16085/java
```
le nombre avant /java est un id de processus. Maintenant utiliser kill commande de tuer le processus
```
kill -9 16085
```
-9 implique le processus sera tué par la force.
- Vous voudrez peut-être ajouter que l'on pourrait avoir besoin de racine privilegues pour obtenir des noms de processus via netstat.
- vous pouvez voir ceux que vous propre w/out les privilèges de root.
- J'ai besoin des privilèges root pour la commande netstat. Est-il un moyen de savoir réellement ce que le processus de partir? Aussi loin que je pouvais dire que j'avais fermé toutes les applications, mais il peut avoir été dans une fenêtre de terminal, où j'ai, par inadvertance, a poussé le processus en tâche de fond. Je devrais peut-être ont couru le terminal de commande 'ps' pour voir tous les processus de la première...
- merci, $kill(lsof-t -i:8080)
InformationsquelleAutor veer7
99

Vous pouvez utiliser la commande lsof.
Laissez un numéro de port comme ici c'est 8090
```
lsof -i:8090
```
Cette commande renvoie une liste de processus ouverts sur ce port.

Quelque chose comme...
```
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
ssh 75782 eoin 5u IPv6 0x01c1c234 0t0 TCP localhost:8090 (LISTEN)
```
Gratuit le port, tuez le processus de l'utiliser(l'id de processus est 75782)...
```
kill -9 75782
```
Ce a travaillé pour moi.
voici le lien de l'original post: lien
- pour tuer le processus avec force, vous aurez besoin d'utiliser -9 comme kill -9 75782; car parfois quelques processus ne sont pas les tuer avec juste tuer
- Ce fut le seul à travailler sur Mac OS trop
InformationsquelleAutor Kop4lyf
90

Je voudrais ajouter ce one-liner pour tuer seulement ÉCOUTER sur le port spécifique:

kill -9 $(lsof -t -i:3000 -sTCP:LISTEN)
- Je pense que cela devrait être la meilleure réponse. Merci @Gal Bracha
- C'est la meilleure solution car elle ne tue pas mon navigateur!
- solution la plus rapide 😉
InformationsquelleAutor Gal Bracha
60

Si vous voulez tuer un processus en cours d'exécution sur le numéro de port 8080 puis vous devez d'abord trouver le port 8080 numéro d'identification du processus(PID) et puis la tuer. Exécutez la commande suivante pour trouver le port 8080 numéro PID:
```
sudo lsof -t -i:8080
```
Ici,
- sudo - commande pour demander le privilège admin(id utilisateur et mot de passe).
- lsof - liste de fichiers(Également utilisé pour la liste des processus connexes)
- -t - seulement les ID de processus
- -je - afficher uniquement les connexions internet des processus connexes
- :8080 - seulement les processus dans ce numéro de port
De sorte que vous pouvez maintenant facilement tuer votre PID à l'aide de la commande suivante:
```
sudo kill -9 <PID>
```
Ici,
- tuer - commande de tuer le processus
- -9 - force
Vous pouvez utiliser une commande pour tuer un processus sur un port spécifique à l'aide de la commande suivante:
```
sudo kill -9 $(sudo lsof -t -i:8080)
```
De plus, vous pouvez consultez le lien suivant
Comment tuer un processus sur un port spécifique sur linux
- merci s'accoupler. sudo kill -9 $(sudo lsof -t -i:8080) a fonctionné pour moi
InformationsquelleAutor mahfuz110244
38

Cela s'imprime sur la sortie standard les id de tout ce qui tourne sur <port_number>:
```
fuser -n tcp <port_number> 
```
Il imprime aussi des trucs à stderr, donc:
```
fuser -n tcp <port_number> 2> /dev/null
```
Nous pouvons fournir ces id pour la kill commande:
```
sudo kill $(fuser -n tcp <port_number> 2> /dev/null)
```
Vous pouvez également mettre cela dans une fonction si vous le faites beaucoup:
```
function killport() {
    sudo kill $(fuser -n tcp $1 2> /dev/null)
}
```
InformationsquelleAutor Brian Peterson
32

De connaître le pid du service qui s'exécute sur le port particulier :
```
netstat -tulnap | grep :*port_num*
```
vous obtiendrez la description de ce processus. Maintenant, l'utilisation de tuer ou de kill -9 pid. Facilement tués.

e.g

netstat -ap | grep :8080
```
tcp6       0      0 :::8080       :::*    LISTEN      1880/java 
```
Maintenant:
```
kill -9 1880
```
N'oubliez pas d'exécuter toutes les commandes root

InformationsquelleAutor Sanjay s.
20

Obtenir le PID de la tâche et de le tuer.
```
lsof -ti:8080 | xargs kill
```
InformationsquelleAutor Rahul Garg
18

essayer comme cela,
```
 sudo fuser -n tcp -k 8080
```
InformationsquelleAutor Adil Abbasi
12
1. lsof -i tcp:8000
  Cette commande répertorie les informations sur les processus en cours d'exécution dans le port 8000
2. kill -9 [PID]
  Cette commande supprime le processus
- Je viens de remarquer que je downvoted cela par hasard il y a quelques semaines, si vous modifiez votre réponse légèrement, je devrais être capable de l'enlever
InformationsquelleAutor Nandhitha Ramaraj
11

Linux: d'Abord, vous pouvez trouver le PID de cette commande si vous connaissez le port :
```
netstat -tulpn 
```
exemple:-
```
 Local Address  Foreign Address  State    PID/Program name

  :::3000       :::*             LISTEN    15986/node 
```
Vous pouvez alors prendre le kill du processus. exécutez la commande suivante:

kill -9 PID

Expample: -

kill -9 15986

InformationsquelleAutor Kundan Kumar
10

Linux: Vous pouvez utiliser cette commande si vous connaissez le port :
```
netstat -plten | grep LISTEN | grep 8080
```
AIX:
```
netstat -Aan | grep LISTEN | grep 8080
```
Vous prenez alors la première colonne (exemple: f100050000b05bb8) et exécutez la commande suivante:
```
rmsock f100050000b05bb8 tcpcb
```
tuer le processus.
- rmsock: command not found
InformationsquelleAutor ben rhouma moez
6

kill -9 `fuser 8080/tcp|xargs -n 1`, cette commande supprime aussi le processus qui est à l'écoute sur le port 8080 en TCP connexion

InformationsquelleAutor Harshit Garg
5

Vous pouvez savoir liste de tous les ports de course dans le système avec ses détails (pid, adresse...). :
```
netstat -tulpn
```
Vous pouvez savoir les détails d'un numéro de port particulier en fournissant un numéro de port dans la commande suivante :
```
sudo netstat -lutnp | grep -w '{port_number}'
```
ex: sudo netstat -lutnp | grep -w "8080'
Plus de détails seront donnés comme ceci :
```
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
```
si vous voulez tuer un processus en utilisant pid puis : kill -9 {PID}

si vous voulez tuer un processus en utilisant le numéro de port : fuser -n tcp {port_number}

utilisation sudo si vous n'êtes pas en mesure d'accéder à tout.

InformationsquelleAutor YAP
1
```
sudo apt-get install psmisc (or sudo yum install psmisc)
sudo fuser 80/tcp
```
Résultat:
80/tcp: 1858 à 1867 1868 1869 1871

Tuer processus un par un

kill -9 1858

InformationsquelleAutor Fadid

de construire sur ce @veer7 dit:

si vous voulez savoir ce qui était sur le port, le faire avant de vous tuer.

$ 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

Utiliser " ps " et le numéro du processus qui netstat rapporté

InformationsquelleAutor JesseBoyd

Autre manière avec Git Bash:

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

InformationsquelleAutor Lucas Moyano Angelini

-2

Dans Windows, il sera netstat -ano | grep "8080" et nous obtenons le message suivant TCP 0.0.0.0:8080 0.0.0.0:0 LISTENING 10076

ON peut tuer le PID à l'aide de taskkill /F /PID 10076
- La question est clairement demandant de l'aide Linux; pas de Windows.
InformationsquelleAutor Chaklader

Vous devez vous connecter pour publier un commentaire.