Cum să omorâți un proces care rulează pe un anumit port în Linux?

Acest fuser 8080/tcp vă va imprima PID-ul procesului legat de acel port.

Și acest fuser -k 8080/tcp va ucide acel proces.

Funcționează numai pe Linux. Mai universală este utilizarea lui lsof -i4 (sau 6 pentru IPv6).

Pentru a lista orice proces care ascultă portul 8080:

lsof -i:8080

Pentru a opri orice proces care ascultă portul 8080:

kill $(lsof -t -i:8080)

sau mai violent:

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

(-9 corespunde semnalului SIGKILL - terminate immediately/hard kill: consultați Lista semnalelor de ucidere și Care este scopul opțiunii -9 din comanda kill?. Dacă nu este specificat niciun semnal pentru kill, este trimis semnalul TERM, alias -15 sau soft kill, care uneori nu este nu este suficient pentru a ucide un proces.).

Utilizați comanda

 sudo netstat -plten |grep java

utilizate grep java ca tomcat utilizează java ca procese.

Va afișa lista de procese cu numărul de port și id-ul procesului

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

numărul înainte de /java este un ID de proces. Acum utilizați comanda kill pentru a opri procesul

kill -9 16085

-9 implică că procesul va fi ucis cu forță.

Opțiunea 1 O singură linie pentru a elimina doar LISTEN pe un anumit port:

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

Opțiunea 2 Dacă aveți instalat npm, puteți rula și

npx kill-port 3000

Puteți folosi comanda lsof. Lăsați numărul portului ca aici să fie 8090

lsof -i:8090

Această comandă returnează o listă de procese deschise pe acest port.

Ceva asemănător cu…

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

Pentru a elibera portul, opriți procesul folosindu-l (ID-ul procesului este 75782)...

kill -9 75782

Acesta a funcționat pentru mine. iată linkul din postarea originală: link

O căptușeală

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

Explicație aici: utilizați o combinație de lsof și 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)

selectați pid și utilizați kill

kill 23672

Dacă doriți să omorâți un proces care rulează pe numărul portului 8080, mai întâi trebuie să găsiți numărul de identificare a procesului portului 8080 (PID) și apoi să îl omorâți. Rulați următoarea comandă pentru a găsi numărul de port 8080 PID:

sudo lsof -t -i:8080

Aici,

• sudo - comandă pentru a solicita privilegiul de administrator (ID utilizator și parolă).
• lsof - listă de fișiere (utilizată și pentru a enumera procesele asociate)
• -t - arată numai ID-ul procesului
• -i - arată numai procesul legat de conexiunile la internet
• :8080 - arată numai procesele din acest număr de port

Deci, acum vă puteți ucide cu ușurință PID folosind următoarea comandă:

sudo kill -9 <PID>

Aici,

• kill - comandă pentru a ucide procesul
• -9 - cu forţă

Puteți folosi o comandă pentru a opri un proces pe un anumit port folosind următoarea comandă:

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

Pentru mai multe, puteți vedea următorul link Cum să omorâți un proces pe un anumit port pe Linux

Cel mai bun mod de a ucide toate procesele pe un anumit port;

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

Acest lucru se tipărește pentru a elimina ID-urile de proces a tot ce rulează pe <port_number>:

fuser -n tcp <port_number> 

De asemenea, imprimă unele lucruri în stderr, deci:

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

Apoi putem furniza aceste ID-uri de proces la comanda kill:

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

De asemenea, puteți pune acest lucru într-o funcție dacă o faceți mult:

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

Pentru a cunoaște pid-ul serviciului care rulează pe un anumit port:

netstat -tulnap | grep :*port_num*

veți primi descrierea procesului respectiv. Acum folosiți kill sau kill -9 pid. Ucis ușor.

e.g

netstat -ap | grep :8080

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

Acum:

kill -9 1880

Nu uitați să rulați toate comenzile ca root

Obțineți PID-ul sarcinii și omorâți-l.

lsof -ti:8080 | xargs kill

Mai întâi trebuie să rulați (înlocuiți-vă cu numărul de port):

fuser -k 3000/tcp

Aceasta va elibera portul. După ce rulați comanda de mai sus, rulați:

service docker restart

Și problema ta este rezolvată.

incearca asa,

 sudo fuser -n tcp -k 8080

Alegeți numărul portului și aplicați grep în comanda netstat, așa cum se arată mai jos

netstat -ap | grep :7070

Ieșire consolă

tcp 0 0 :::7070 :::* ASCULTĂ 3332/java

Opriți serviciul pe baza PID (Numărul de identificare a procesului)

kill -9 3332

1. lsof -i tcp:8000 Această comandă listează informațiile despre procesul care rulează în portul 8000

2. kill -9 [PID] Această comandă oprește procesul

Linux: puteți folosi această comandă dacă cunoașteți portul:

netstat -plten | grep LISTEN | grep 8080

AIX:

netstat -Aan | grep LISTEN | grep 8080

Apoi luați prima coloană (exemplu: f100050000b05bb8) și rulați următoarea comandă:

rmsock f100050000b05bb8 tcpcb

procesul de ucidere.

Linux: mai întâi puteți găsi PID-ul acestei comenzi dacă cunoașteți portul:

netstat -tulpn 

exemplu:-

 Local Address  Foreign Address  State    PID/Program name

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

Apoi iei procesul de ucidere. rulați următoarea comandă:

ucide -9 PID

Exemplu: -

ucide -9 15986

Puteți cunoaște lista tuturor porturilor care rulează în sistem împreună cu detaliile acestuia (pid, adresă etc.):

netstat -tulpn

Puteți cunoaște detaliile unui anumit număr de port furnizând numărul de port în următoarea comandă:

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

ex: sudo netstat -lutnp | grep -w '8080' Detaliile vor fi furnizate astfel:

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

dacă doriți să opriți un proces folosind pid, atunci : kill -9 {PID}

dacă doriți să opriți un proces folosind numărul de port: fuser -n tcp {port_number}

utilizați sudo dacă nu puteți accesa niciunul.

Rulați următoarea comandă pentru a găsi numărul de port 8080 PID:

sudo lsof -t -i:8080

Acum vă puteți ucide cu ușurință PID folosind următoarea comandă:

sudo kill -9

Puteți folosi o comandă pentru a opri un proces pe un anumit port folosind următoarea comandă:

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

kill -9 `fuser 8080/tcp|xargs -n 1`, această comandă oprește și procesul care ascultă pe portul 8080 cu conexiune TCP

Pur și simplu rulați această comandă. Nu uitați să înlocuiți portnumber, cu portul dvs. ;)

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

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

Rezultat: 80/tcp: 1858 1867 1868 1869 1871

Ucideți procesul unul câte unul

ucide -9 1858

Aceasta este soluția pentru Windows:

C:\Users\Niroshan>netstat -ano|findstr "PID :8080"

Proto Local Address Foreign Address State PID
TCP 0.0.0.0:8080 0.0.0.0:0 LISTENING 18264

taskkill /pid 18264 /f

Lucrez la un sistem Yocto Linux care are un set limitat de instrumente Linux disponibile. Am vrut să opresc procesul care folosea un anumit port (1883).

Mai întâi, pentru a vedea ce porturi ascultăm, am folosit următoarea comandă:

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      

Apoi, am găsit numele procesului folosind portul 1883 în felul următor:

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

După cum putem vedea mai sus, programul /usr/sbin/mosquitto folosește portul 1883.

În cele din urmă, am oprit procesul:

root@root:~# systemctl stop mosquitto

Am folosit systemctl pentru că în acest caz era un serviciu systemd.

1. mai întâi verificați procesul netstat -lt
2. verificați ID-ul procesului fuser <port number>/tcp
3. omorâți procesul care rulează pe portul kill <process id>

Acest lucru va ucide programele care rulează pe portul 80

sudo fuser -k 80/tcp

Alt mod cu Git Bash:

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

În cazul meu, cent os are o problemă în răspunsul sugerat. Așa că am folosit următoarea soluție:

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

pentru a construi pe ceea ce a spus @veer7:

dacă vrei să știi ce era pe port, fă asta înainte de a-l ucide.

$ 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

Folosiți „ps” și numărul procesului pe care netstat a raportat

Cum să omorâți procesul dacă serviciul de pe port nu răspunde

timeout 1 telnet localhost 8080 2>&1 | if grep -q 'Unable'; then sudo kill -9 $(sudo lsof -t -i:8080); fi

Ce face

1. Porniți „timeout” cu o secundă, pentru a ieși din telnet
2. ' 2›&1 | ' mesaj de eroare conductă fără a ieși
3. Dacă mesajul de eroare conține „Nu se poate”, atunci rulați codul pentru a opri portul de blocare a procesului 8080

Acesta poate fi plasat într-un fișier și rulat în mod regulat din „sudo crontab”

În Windows, va fi netstat -ano | grep "8080" și primim următorul mesaj TCP 0.0.0.0:8080 0.0.0.0:0 LISTENING 10076

Putem ucide PID-ul folosind taskkill /F /PID 10076