O Node possui vários threads, mas o JavaScript em execução no V8 é um único rosqueado. O módulo Child_Process do Node é usado para criar processos filhos e podemos fazer pleno uso da CPU por meio de processos filhos. exemplo:
A cópia do código é a seguinte:
var fork = requer ('Child_process'). Fork;
// Obtenha o número da CPU da máquina atual
var cpus = requer ('os'). cpus ();
for (var i = 0; i <cpus.length; i ++) {
// gerar um novo processo
fork ('./ trabalhador.js');
}
Aqui estão algumas maneiras de criar processos, incluindo o Fork:
1.spawn (comando, [args], [options]), inicie um novo processo para executar o comando de comando, args é um parâmetro de linha de comando
2.Exec (comando, [opções], retorno de chamada), inicie um novo processo para executar o comando comando, o retorno de chamada é usado para obter informações padrão de entrada, saída padrão e erro no final do processo.
3.Execfile (arquivo, [args], [opções], [retorno de chamada]), inicia um novo processo para executar o arquivo executável. O retorno de chamada é usado para obter informações padrão de entrada, saída padrão e erro no final do processo.
4.Fork (Modulepath, [args], [Opções]), inicie um novo processo para executar um módulo de arquivo JavaScript e o processo infantil do nó é criado neste momento.
Comunicação de Interprocessos do Nó
Processo pai
A cópia do código é a seguinte:
// parent.js
var fork = requer ('Child_process'). Fork;
// Fork Retorna o objeto de processo filho n
var n = fork ('./ Child.js');
// Mensagem do evento Handle
n.on ('mensagem', função (m) {
// recebe uma mensagem enviada pelo processo filho
console.log ('recebeu mensagem:' + m);
});
// Envie uma mensagem para o processo filho
n.send ({hello: 'World'});
Subprocesso
A cópia do código é a seguinte:
// child.js
// Mensagem do evento Handle
process.on ('mensagem', função (m) {
console.log ('recebeu mensagem:' + m);
});
// O método de envio existe para enviar mensagens para o processo pai.
process.send ({foo: 'bar'});
Deve -se notar que o método de envio aqui é síncrono, portanto, não é recomendável enviar grandes quantidades de dados (você pode usar o Pipe, consulte http://nodejs.org/api/all.html#child_process_child_process_spawn_command_args_options para detalhes).
Em casos especiais, o valor do atributo CMD na mensagem contém o prefixo node_ (por exemplo: {cmd: 'node_foo'} mensagem), essa mensagem não será enviada ao evento da mensagem (mas ao evento internoMessage) e são usados internamente por nó.
O protótipo do método de envio é:
A cópia do código é a seguinte:
Send (mensagem, [sendHandle])
Aqui, o SendHandle (Handle) pode ser usado para enviar:
1.Net.nativo, nativo C ++ TCP Socket ou oleoduto
2.Net.Server, servidor TCP
3.net.socket, soquete TCP
4.dgram.nativo, soquete UDP nativo C ++
5.dgram.socket, soquete UDP
Enviar ao enviar o SendHandle, ele não é (e não pode) enviar diretamente objetos JavaScript, mas enviar um descritor de arquivo (eventualmente enviado como uma string json). Outros processos podem restaurar o objeto correspondente através deste descritor de arquivo.
Agora veja um exemplo:
Processo pai
A cópia do código é a seguinte:
// parent.js
var fork = requer ('Child_process'). Fork;
var n = fork ('./ Child.js');
var server = requer ('net'). createServer ();
Server.Listen (7000, function () {
// Envie o servidor TCP para o processo infantil
n.send ('servidor', servidor);
}). on ('conexão', function () {
console.log ('conexão - pai');
});
Subprocesso
A cópia do código é a seguinte:
process.on ('mensagem', função (m, h) {
if (m === 'servidor') {
h.on ('conexão', function () {
console.log ('conexão - criança');
});
}
});
O acesso a este programa via porta 7000 pode resultar na saída como pai de conexão ou filho da conexão. Aqui, o processo filho e o processo pai ouvem a porta 7000 ao mesmo tempo. De um modo geral, vários processos ouvindo a mesma porta causarão uma exceção do Eaddrinuu. Nesse caso, dois processos diferentes usam o mesmo descritor de arquivo e a camada subjacente do nó define a opção SO_REUSEADDR no soquete ao ouvir a porta, o que permite que esse soquete seja reutilizado entre diferentes processos. Quando vários processos ouvem a mesma porta, o descritor de arquivo só pode ser usado por um processo ao mesmo tempo, e esses processos usam soquetes preventivamente.
módulo de cluster
Um novo módulo de cluster foi adicionado à v0.8 no nó, através do qual o módulo de cluster pode facilmente criar um grupo de processos ouvindo a mesma porta em uma máquina física. exemplo:
A cópia do código é a seguinte:
var cluster = requer ('cluster');
var http = requer ('http');
var numcpus = requer ('os'). cpus (). comprimento;
// Verifique se o processo é um processo mestre
if (cluster.ismaster) {
for (var i = 0; i <numcpus; ++ i)
// gerar um novo processo de trabalhador (apenas o processo mestre pode ser chamado)
cluster.fork ();
cluster.on ('exit', função (trabalhador, código, sinal) {
console.log ('trabalhador' + trabalhador.process.pid + 'die');
});
} outro {
http.createServer (function (req, res) {
Res.Writehead (200);
Res.End ('Hello World/N');
}). Ouça (8000);
}
Chamamos o método de escuta no processo do trabalhador e a solicitação de escuta será passada para o processo mestre. Se o processo mestre já tiver um servidor ouvindo atender aos requisitos do processo do trabalhador, o identificador deste servidor será passado para o trabalhador. Se não existir, o processo mestre criará um e depois passará a alça para o processo do trabalhador.
Documentação mais detalhada sobre cluster: http://www.nodejs.org/api/cluster.html