Ho un semplice server TCP che ascolta su una porta.

var net = require("net");

var server = net.createServer(function(socket) {
    socket.end("Hello!\n");
});

server.listen(7777);

Lo avvio con node server.jse poi lo chiudo con Ctrl + Z su Mac. Quando provo a eseguirlo di nuovo con node server.jsottengo questo messaggio di errore:

node.js:201
        throw e; // process.nextTick error, or 'error' event on first tick
          ^
Error: listen EADDRINUSE
at errnoException (net.js:670:11)
at Array.0 (net.js:771:26)
at EventEmitter._tickCallback (node.js:192:41)

Sto chiudendo il programma nel modo sbagliato? Come posso evitare che ciò accada?

Per terminare il programma, dovresti usare Ctrl+ C. Se lo fai, invia SIGINT, il che consente al programma di terminare con grazia, svincolandosi da tutte le porte su cui è in ascolto.

Vedi anche: https://superuser.com/a/262948/48624

Ctrl+ lo Zsospende, il che significa che può ancora essere in esecuzione.

Ctrl+ Clo ucciderà effettivamente.

puoi anche ucciderlo manualmente in questo modo:

ps aux | grep node

Trova l'ID processo (secondo da sinistra):

kill -9 PROCESS_ID

Questo può anche funzionare

killall node

O in alternativa puoi fare tutto ciò in una riga:

kill -9 $(ps aux | grep '\snode\s' | awk '{print $2}')

È possibile sostituire il nodo all'interno di '\ snode \ s' con qualsiasi altro nome di processo.

Riprendi e termina il processo:

Ctrl+ lo Zsospende, il che significa che è ancora in esecuzione come processo in background sospeso.

Probabilmente sei ora al prompt del terminale ...

1. Dare il comando fgper riprendere il processo in primo piano.

2. digitare Ctrl+ Cper ucciderlo correttamente.

In alternativa, puoi ucciderlo manualmente in questo modo:

( NOTA: i seguenti comandi potrebbero richiedere root, così anche il sudo ...tuo amico)

pkill -9 node

o, se non hai pkill, questo potrebbe funzionare:

killall node

o forse questo:

kill $(ps -e | grep node | awk '{print $1}')

a volte il processo elencherà il suo grep, nel qual caso avrai bisogno di:

kill $(ps -e | grep dmn | awk '{print $2}')

.

h / t @ruffin dai commenti sulla domanda stessa. Ho avuto lo stesso problema e il suo commento mi ha aiutato a risolverlo da solo.

è possibile digitare .exit per uscire dal nodo js REPL

Se si esegue Node.js in modo interattivo (REPL):

Ctrl+ Cti riporterà a> prompt, quindi digita:

process.exit()

o usa semplicemente Ctrl+ D.

$ sudo killall nodein un altro terminale funziona su Mac , mentre killall nodenon funziona:

$ killall node
No matching processes belonging to you were found

su linux prova: pkill node

Su Windows:

Taskkill /IM node.exe /F

o

from subprocess import call

call(['taskkill', '/IM', 'node.exe', '/F'])

Anche se questa è una risposta tardiva, ho trovato questo dai documenti NodeJS :

L'evento 'exit' viene emesso quando si esce dalla REPL ricevendo il .exitcomando come input, l'utente premendo <ctrl>-Cdue volte per segnalare SIGINT o premendo <ctrl>-Dper segnalare 'end' sul flusso di input. Il callback del listener viene richiamato senza argomenti.

Quindi per riassumere è possibile uscire da:

1. Digitando .exitnodejs REPL.
2. Premendo <ctrl>-Cdue volte.
3. premendo <ctrl>-D.
4. process.exit(0)significa un'uscita naturale da REPL. Se si desidera restituire qualsiasi altro stato, è possibile restituire un numero diverso da zero.
5. process.kill(process.pid) è il modo per uccidere usando nodejs api dal tuo codice o da REPL.

Sto aggiungendo questa risposta perché per molti progetti con distribuzioni di produzione, abbiamo script che fermano questi processi, quindi non è necessario.

Un modo semplice per gestire i processi del Node Server è utilizzare il foreverpacchetto (daNPM ).

Esempio:

Installa per sempre

npm install forever -g

Esegui Node Server

forever start -al ./logs/forever.log -ao ./logs/out.log -ae ./logs/err.log server.js

Risultato:

info: Forever processing file: server.js

Server nodo di arresto

forever stop server.js

Risultato

info: Forever stopped process: uid command script forever pid id logfile uptime [0] sBSj "/usr/bin/nodejs/node" ~/path/to/your/project/server.js 23084 13176 ~/.forever/forever.log 0:0:0:0.247

Ciò spegnerà in modo pulito l'applicazione Server.

Se si desidera arrestare il server con npm stopo qualcosa del genere. È possibile scrivere il codice che interrompe il processo del server come:

require('child_process').exec(`kill -9 ${pid}`)

Controlla questo link per i dettagli: https://gist.github.com/dominhhai/aa7f3314ad27e2c50fd5

Ho riscontrato un problema in cui ho più server di nodo in esecuzione e voglio semplicemente ucciderne uno e ridistribuirlo da uno script.

Nota: questo esempio è in una shell bash su Mac.

Per fare ciò, mi assicuro di rendere la mia nodechiamata il più specifica possibile. Ad esempio, anziché chiamare node server.jsdalla directory delle app, chiamonode app_name_1/app/server.js

Quindi posso ucciderlo usando:

kill -9 $(ps aux | grep 'node\ app_name_1/app/server.js' | awk '{print $2}')

Questo ucciderà solo il processo del nodo che esegue app_name_1 / app / server.js.

Se hai corso node app_name_2/app/server.js questo processo del nodo continuerà a essere eseguito.

Se decidi di volerlo uccidere, puoi usarlo killall nodecome altri hanno già detto.

Risposta tardiva ma su Windows, aprendo il task manager con CTRL + ALT + CANC e poi uccidendo i processi Node.js si risolverà questo errore.

puoi lavorare seguendo il comando per essere specifico nell'uccisione di localserver (qui: 8000)

http: // localhost: 8000 / kill PID (processId):

$:lsof -i tcp:8000

Ti darà i seguenti gruppi di TCP:

COMANDO PID UTENTE TIPO FD MISURA DISPOSITIVO / OFF NOME NOME

nodo 21521 ubuntu 12u IPv6 345668 0t0 TCP *: 8000 (ASCOLTA)

$:kill -9 21521

Ucciderà processId corrispondente a TCP *: 8000

Per MacOS

1. Terminale aperto

2. Esegui il codice qui sotto e premi invio

    sudo kill $(sudo lsof -t -i:4200)

È possibile utilizzare il fusore per ottenere ciò che si desidera eseguire.

Per ottenere gli ID di processo delle attività in esecuzione su una porta è possibile eseguire:

fuser <<target_port>>/tcp

Diciamo che la porta è 8888, il comando diventa:

fuser 8888/tcp

E per terminare un processo in esecuzione su una porta, è sufficiente aggiungere l'opzione -k.

fuser <<target_port>>/tcp -k

Esempio (la porta è 8888):

fuser 8888/tcp -k

Questo è tutto! Chiuderà il processo in ascolto sulla porta. Di solito lo faccio prima di eseguire la mia applicazione server.

Il mio caso d'uso: su MacOS , eseguo / riesegui server a più nodi su porte diverse da uno script

correre :"cd $PATH1 && node server1.js & cd $PATH2 && node server2.js & ..."

stop1 :"kill -9 $(lsof -nP -i4TCP:$PORT1 | grep LISTEN | awk '{print $2}')"

stop2, stop3 ...

rieseguire :"stop1 & stop2 & ... & stopN ; run

per ulteriori informazioni sulla ricerca di un processo da una porta: chi è in ascolto su una determinata porta TCP su Mac OS X?

Per windows prima cerca il PID con il tuo numero di porta

netstat -ano | findStr "portNumber"

Dopodiché, uccidi l'attività, assicurati di essere nella radice dell'unità "c" e il comando saràtaskkill /F /PID your pid

se stai usando VS Code e terminal seleziona prima il nodo dal menu a discesa sul lato destro e poi fai Ctrl + C. Quindi funzionerà

Premere y quando richiesto.

Grazie