Contagem de threads de um processo no Linux

Quando um programa é executado no Linux, uma instância desse programa é carregada na memória junto com todos os recursos necessários. Esta instância do programa na memória é chamada de processo. Os processos Linux — e mais especificamente os processos pesados (HWPs) — incluem muita sobrecarga quando são criados ou quando são transferidos de outro processo. Mas um thread é um processo leve (LWP) em um sistema operacional de computador que pode compartilhar recursos como código, dados, arquivo I/O, stack e tabelas de sinais. É isso que os torna leves. Ao contrário dos processos, os threads não precisam liberar e recriar todas as tabelas antes que possam ser trocadas. Portanto, eles podem ser trocados com mais facilidade e frequência.

No entanto, o Linux não distingue entre um processo e um thread no nível do sistema operacional. Threads ainda são processos no Linux, apenas threads podem compartilhar determinados recursos com outros processos. Ao contrário de outros sistemas operacionais, o Linux não fornece estruturas de dados ou opções de agendamento específicas de threads. O kernel não faz distinção aqui.

Mas threads ou processos leves ainda podem ser usados no Linux para obter paralelismo e processamento multicore, dividindo um processo em vários threads. Dessa forma, cada thread pode ser executado em um núcleo de processador separado para obter um verdadeiro paralelismo. Como os processos leves já são muito leves no Linux, alternar entre threads não acarreta grandes sobrecargas.

Este artigo abordará as limitações de threads e processos em um sistema Linux, como encontrar esses limites, como aumentar o número máximo de threads e, por fim, alguns comandos comuns para verificar o número de threads por processo em um sistema Linux.

Limitações de threads em um Linux

Como qualquer sistema operacional, existem certos limites para threads no Linux. O Linux armazena configurações como arquivos, e a maioria dos parâmetros de configuração do kernel são armazenados no caminho /proc/sys/kernel/. A configuração para o número máximo de threads que o kernel pode executar é armazenada em proc/sys/kernel/threads-max.

Usar o command neste arquivo exibirá o número máximo de threads para o sistema. Por exemplo, na figura 1 o número máximo de threads é 3.935. Isso foi executado em um servidor de single-core usado para hospedar um site estático, portanto, o número máximo de threads é baixo em comparação com processadores multi-core:

O comando sysctl também pode ser usado com uma opção e pode ser filtrado usando grep para verificar a mesma configuração do kernel. A Figura 2 mostra o output do comando abaixo:

sysctl -a | grep threads-max

Você pode ver acima que ambos os comandos fornecem a mesma saída. Da mesma forma, existe um parâmetro de configuração do kernel para o número máximo de processos que um kernel pode executar simultaneamente. Esta configuração está presente em um arquivo em /proc/sys/kernel/pid_max. Podemos acessar este arquivo para ver o número, conforme mostrado na figura 3 abaixo:

O output na figura 3 é do mesmo servidor de núcleo único, portanto o número é baixo. Esse número também está próximo do ponto em que os IDs ou PIDs do processo são agrupados, portanto, podemos encontrar periodicamente PIDs duplicados durante a manutenção.

Como o Linux não diferencia processos e threads, o número máximo de processos também é o número máximo de threads. Se o sistema atingir o limite e nenhum dos processos estiver pronto para ser eliminado, o sistema não será capaz de criar novos processos e, por consequência, não será capaz de criar novos threads.

Aumentando o número máximo de threads em um Linux

O número de threads no Linux é limitado por alguns fatores, principalmente o tamanho da memória virtual. A fórmula usada para calcular o número máximo de threads para um sistema é:

Número máximo de threads = tamanho da memória virtual / (tamanho do stack * 1024 * 1024)

Como mostra a fórmula, aumentar o tamanho da memória virtual ou diminuir o tamanho do stack por thread levará a um aumento no número máximo de threads. Para fazer esse ajuste com mais precisão, o comando ulimit pode ser usado para verificar o tamanho atual da pilha em um sistema:

ulimit -a | grep "stack size"

A Figura 4 abaixo mostra o tamanho do stack de um servidor single-core

Nós podemos mudar o tamanho do stack usando o mesmo comando ulimit

ulimit -s 8192

Comandos de thread que são úteis em um Linux

Linux fornece alguns comandos para listar todos os processos e threads facilmente, e para filtrar threads para um processo específico. A seção seguinte mostra como usar esses comandos para obter informações relacionadas ao thread.

Processo de informação

O comando ps, juntamente com suas opções, é usado para listar todos os processos em execução em um sistema Linux e informações úteis sobre eles. Porém, sem nenhuma opção, o comando fornece apenas um snapshot dos processos atuais, conforme visto na figura 5 abaixo:

Usar a opção e também lista todos os nomes de processos. A captura de tela na figura 6 mostra uma parte do output deste comando:

Para obter mais dados na sintaxe BSD, as opções auxiliares podem ser usadas da seguinte forma:

ps aux

Este comando fornecerá informações como a porcentagem de CPU e memória usada por um processo, o comando usado para executar esse processo e há quanto tempo o processo está em execução.

Número de processos usando proc

As informações relacionadas a cada processo são armazenadas em um arquivo próprio no diretório /proc. Usando o ID do processo, você pode ler o arquivo de status para saber o número de threads que esse processo específico criou.

Na figura 7 abaixo, o processo com PID 42 criou 1 thread. O comando para obter a contagem de threads de um processo é:

cat /proc/<pid>/status

O arquivo de status fornece muito mais informações sobre um processo do que apenas o número de threads. Para encontrar o número de threads de um processo, existe mais um método que usa o mesmo diretório /proc.

Assim como todo processo possui um diretório criado sob seu PID, todo thread possui um diretório criado sob seu ID de thread. Ele é encontrado no diretório /proc/<pid>/task. O número total de diretórios no diretório de tarefas é o número de threads criados para um processo.

Isso pode ser conseguido canalizando o output do comando ls para o comando wc para contar o número de diretórios conforme mostrado abaixo:

ls /proc/<pid>/task | wc -l

Fig 8 mostra o output do comando para o mesmo processo mostrado na figura 7

Número de threads usando ps por processo

O comando ps ajuda a obter informações sobre os threads de um processo. Com a capacidade de mostrar as informações apenas de um determinado PID, é mais fácil obter a contagem de um processo individual.

As opções são as seguintes:

• h: Sem cabeçalhos. Isso é complicado quando o comando ps é usado no modo BSD. Por padrão, porém, usar esta opção não exibirá cabeçalhos.
• H: Modo thread. Isso mostrará informações sobre threads.
• p: Filtrar por PID. Esta opção usa um PID como argumento para filtrar os processos pelo PID fornecido.

Como antes, a saída deste comando é então canalizada para o comando wc para contar o número de linhas e obter a contagem de threads. O comando completo é o seguinte:

ps hH p <PID> | wc -l

Todos os três métodos fornecem consistentemente os mesmos resultados.

Resumo

Threads são usados para acelerar a execução de processos aumentando o paralelismo, uma vez que cada thread pode ser executado em um núcleo de processador. Threads também podem ser usados para garantir que um processo não esteja bloqueando outros processos ou threads enquanto aguarda a conclusão de um arquivo I/O ou outra operação.

Mas, assim como os processos, há limites de quantos processos ou threads podem ser executados simultaneamente em um sistema Linux. Este número pode ser aumentado alterando a configuração de alguns parâmetros do kernel.

Como o Linux faz pouca distinção entre threads e processos, todos os limites aplicáveis aos processos também se aplicam aos threads. Ao usar esses comandos simples mencionados acima, os administradores do Linux podem verificar o número de threads de um determinado processo.