O Apache Kafka é um armazenamento de dados distribuído projetado para entrada e processamento em tempo real de dados de streaming. Dados de streaming são informações geradas continuamente por milhares de fontes de dados, todas as quais transmitem registros de dados ao mesmo tempo. Uma plataforma de streaming deve ser capaz de lidar com o fluxo constante de dados e processá-los de forma sequencial e progressiva.
O que é Multithreading e por que precisamos dele?
A capacidade de uma unidade de processamento central (CPU) (ou um único núcleo em um processador multinúcleo) de fornecer muitos threads de execução simultaneamente, com suporte do sistema operacional, é chamada de multithreading. O multithreading pode ser usado para melhorar a velocidade do aplicativo em casos em que o trabalho pode ser dividido em unidades menores que podem operar em paralelo sem comprometer a consistência dos dados. O Kafka permite que você aumente seu sistema distribuído usando partições, que são subconjuntos ordenados de mensagens em um tópico.
Recentemente, ele notou uma tendência em que os desenvolvedores, em vez de garantir que uma computação possa processar dados de forma eficiente de uma única partição, seguem o caminho fácil de expandir as partições/vms para obter a taxa de transferência necessária. É o equivalente a jogar dinheiro no problema.
Os tópicos do Kafka dividem os registros em partes menores chamadas partições, que podem ser processadas individualmente sem comprometer a precisão das descobertas, estabelecendo as bases para o processamento paralelo. Isso geralmente é feito por dimensionamento, que envolve o uso de muitos consumidores dentro do mesmo grupo, cada um processando dados de um subconjunto de partições de tópicos e operando em um único encadeamento.
Como ler e processar mensagens em um único encadeamento é suficiente para a maioria Casos de uso do Kafkao apache Consumidor Kafka O paradigma de threading é amplamente utilizado. O loop de pesquisa funciona sem problemas quando o processamento não requer atividades de E/S.
Consumidores de Kafka
Os consumidores que compram Kafka costumam fazê-lo como parte de um grupo. Quando muitos consumidores assinam um tópico e são membros do mesmo grupo de consumidores, cada consumidor recebe mensagens de um subconjunto das partições do assunto.
Adicionar consumidores extras a um grupo de consumidores é a técnica mais comum para dimensionar o consumo de dados de um tópico Kafka. Os consumidores do Kafka frequentemente executam ações de alta latência, como gravar em um banco de dados ou realizar uma computação demorada nos dados. Quando um único consumidor não consegue acompanhar a taxa na qual os dados fluem para um tópico, dimensionamos adicionando mais consumidores que compartilham a carga fazendo com que cada consumidor possua apenas um subconjunto das partições e mensagens.
Benefícios do multithreading
O multithreading permite que muitas partes de um programa sejam executadas ao mesmo tempo. Threads são processos leves disponíveis dentro do processo. O multithreading permite que a multitarefa aproveite ao máximo a CPU.
A seguir estão algumas das vantagens da programação multithread:
Compartilhando recursos
Os recursos de um processo, incluindo memória, dados e arquivos, são compartilhados entre todas as threads. Usando o compartilhamento de recursos, um único programa pode ter vários encadeamentos no mesmo espaço de endereço.
Capacidade de resposta
A capacidade de resposta do programa permite que um programa continue a operar mesmo se uma parte dele for interrompida devido ao multithreading. Se o processo estiver fazendo uma operação demorada, isso também pode ser feito.
Arquitetura de multiprocessadores
O multithreading permite que cada thread em uma arquitetura de multiprocessador seja executado em um processador diferente em paralelo. Isso melhora a simultaneidade do sistema. Em um sistema de processador único, apenas um processo ou thread pode ser executado por vez.
O que é thread por modelo de consumidor
Cada encadeamento é instanciado e conectado ao agente Kafka no encadeamento por modelo de consumidor. As partições cujas mensagens serão enviadas para esses encadeamentos são atribuídas pelo agente kafka.
Um único thread se conecta ao Kafka no modo de consumidor multithread e pode adquirir dados de várias partições / únicas. Uma vez que os dados tenham sido fornecidos ao encadeamento, o encadeamento pode distribuir as mensagens para outros conjuntos de encadeamentos para processamento em paralelo. Nesse método, o thread consumidor determina qual thread filho manipulará quais tipos de mensagens. No entanto, nesta circunstância, a gestão de compensação torna-se extremamente difícil.
O Spring pode gerar facilmente vários threads para se conectar ao Kafka. Vamos ver como os dois se comportam de forma diferente. Temos um único tópico de teste com dez partições e uma única VM executando um único aplicativo de primavera simultâneo.
Tópico por modelo de consumidor
/**
* Consumer configuration for email topics
*
* @return
*/
@Bean
public ConsumerFactory<String, String> consumerFactory()
{
Map<String, Object> props = new HashMap<>();
Map<String, Object> props = new HashMap<>();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(ConsumerConfig.GROUP_ID_CONFIG, EMAIL_STATUS_CONSUMER_GROUP);
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
StringDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
StringDeserializer.class);
return new DefaultKafkaConsumerFactory<>(props);
}
/**
* Define a simultaneidade para o ouvinte kafka
*
* @Retorna
*/
@Feijão
public ConcurrentKafkaListenerContainerFactory
{
ConcurrentKafkaListenerContainerFactory
factory.setConsumerFactory(consumerFactory());
factory.setConcurrency(1);
retorno de fábrica;
}
Esta divisão está sendo ouvida pelo grupo de consumidores spring-group. Veja a seguir como a simultaneidade única se comporta:
GRUPO TÓPICO PARTIÇÃO CONSUMER-ID HOST CLIENT-ID
spring-group test-topic 8 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
spring-group test-topic 2 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
spring-group test-topic 1 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
spring-group test-topic 4 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
spring-group test-topic 5 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
spring-group test-topic 6 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
spring-group test-topic 3 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
spring-group test-topic 7 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
spring-group test-topic 9 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
spring-group test-topic 0 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
Se você observar atentamente a saída acima, notará que o ID do consumidor do aplicativo é o mesmo para todas as 10 partições, indicando que é um único thread que conecta todas elas.
Vejamos o que acontece quando a simultaneidade é aumentada para 2,
GRUPO TÓPICO PARTIÇÃO CONSUMER-ID HOST CLIENT-ID
spring-group test-topic 8 consumidor-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consumidor-2
spring-group test-topic 5 consumidor-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consumidor-2
spring-group test-topic 6 consumidor-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consumidor-2
spring-group test-topic 7 consumidor-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consumidor-2
spring-group test-topic 9 consumidor-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consumidor-2
spring-group test-topic 4 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
spring-group test-topic 2 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
spring-group test-topic 3 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
spring-group test-topic 1 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
spring-group test-topic 0 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
Como você pode ver na captura de tela acima, agora existem dois threads, cada um com cinco partições.
Kafka tentará distribuir partições uniformemente entre threads pertencentes ao mesmo grupo de consumidores. Teremos um thread dedicado para cada partição se criarmos dez threads simultâneos.
Conclusão
Neste artigo, entendemos algumas coisas sobre multithreading e aprendemos o modelo de threading.