Apache Kafka es un almacenamiento de datos distribuido diseñado para la entrada y el procesamiento de datos de transmisión en tiempo real. La transmisión de datos es información generada continuamente por miles de fuentes de datos, todas las cuales transmiten registros de datos al mismo tiempo. Una plataforma de transmisión debe ser capaz de hacer frente a la entrada constante de datos y procesarlos de forma secuencial y progresiva.
¿Qué es Multithreading y por qué lo necesitamos?
La capacidad de una unidad central de procesamiento (CPU) (o un solo núcleo en un procesador multinúcleo) para proporcionar muchos subprocesos de ejecución al mismo tiempo, respaldados por el sistema operativo, se conoce como subprocesos múltiples. Los subprocesos múltiples se pueden usar para mejorar la velocidad de la aplicación en instancias en las que el trabajo se puede dividir en unidades más pequeñas que pueden operar en paralelo sin comprometer la consistencia de los datos. Kafka le permite hacer crecer su sistema distribuido mediante el uso de particiones, que son subconjuntos ordenados de mensajes en un tema.
Recientemente notó una tendencia en la que los desarrolladores, en lugar de garantizar que un cómputo pueda procesar eficientemente los datos de una sola partición, toman la ruta fácil de expandir las particiones/vms para obtener el rendimiento necesario. Es el equivalente a tirar dinero al problema.
Los temas de Kafka dividen los registros en partes más pequeñas llamadas particiones, que se pueden procesar individualmente sin comprometer la precisión de los hallazgos, sentando las bases para el procesamiento paralelo. Esto se logra comúnmente escalando, lo que implica el uso de muchos consumidores dentro del mismo grupo, cada uno de los cuales procesa datos de un subconjunto de particiones de temas y opera en un solo subproceso.
Porque leer y procesar mensajes en un solo hilo es suficiente para la mayoría Casos de uso de Kafkael apache consumidor kafka El paradigma de subprocesamiento es ampliamente utilizado. El ciclo de sondeo funciona sin problemas cuando el procesamiento no requiere actividades de E/S.
Consumidores de Kafka
Los consumidores que compran Kafka suelen hacerlo como parte de un grupo. Cuando muchos consumidores se suscriben a un tema y son miembros del mismo grupo de consumidores, cada consumidor recibe mensajes de un subconjunto de las particiones del tema.
Agregar consumidores adicionales a un grupo de consumidores es la técnica más común para escalar el consumo de datos de un tema de Kafka. Los consumidores de Kafka realizan con frecuencia acciones de alta latencia, como escribir en una base de datos o realizar un cálculo lento en los datos. Cuando un solo consumidor no puede seguir el ritmo al que fluyen los datos en un tema, escalamos agregando más consumidores que comparten la carga haciendo que cada consumidor posea solo un subconjunto de las particiones y los mensajes.
Beneficios de los subprocesos múltiples
Multithreading permite que muchas partes de un programa se ejecuten al mismo tiempo. Los subprocesos son procesos ligeros disponibles dentro del proceso. Multithreading permite realizar múltiples tareas para aprovechar al máximo la CPU.
Las siguientes son algunas de las ventajas de la programación multiproceso:
Compartir recursos
Los recursos de un proceso, incluida la memoria, los datos y los archivos, se comparten entre todos los subprocesos. Al compartir recursos, un solo programa puede tener varios subprocesos en el mismo espacio de direcciones.
Sensibilidad
La capacidad de respuesta del programa permite que un programa continúe funcionando incluso si una parte del mismo se detiene debido a subprocesos múltiples. Si el proceso está haciendo una operación larga, esto también se puede hacer.
Arquitectura multiprocesador
Los subprocesos múltiples permiten que cada subproceso en una arquitectura multiprocesador se ejecute en un procesador diferente en paralelo. Esto mejora la concurrencia del sistema. En un sistema de un solo procesador, solo se puede ejecutar un proceso o subproceso a la vez.
¿Qué es el subproceso por modelo de consumidor?
Se crea una instancia de cada subproceso y se conecta al agente de Kafka en el subproceso por modelo de consumidor. El agente kafka asigna las particiones cuyos mensajes se enviarán a estos subprocesos.
Un solo subproceso se conecta a Kafka en modo de consumidor de subprocesos múltiples y puede adquirir datos de varias particiones o particiones individuales. Una vez que se han proporcionado los datos al subproceso, el subproceso puede distribuir los mensajes a otros grupos de subprocesos para su procesamiento en paralelo. En este método, el subproceso del consumidor determina qué subproceso secundario manejará qué tipos de mensajes. Sin embargo, en esta circunstancia, la gestión de compensaciones se vuelve extremadamente difícil.
Spring puede generar fácilmente varios subprocesos para conectarse a Kafka. Veamos cómo los dos se comportan de manera diferente. Tenemos un solo tema de prueba con diez particiones y una sola VM que ejecuta una sola aplicación Spring concurrente.
Subproceso 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);
}
/**
* Establece la concurrencia para el oyente kafka
*
* @devolver
*/
@Frijol
KafkaListenerContainerFactory pública concurrente
{
ConcurrentKafkaListenerContainerFactory
factory.setConsumerFactory(consumerFactory());
fábrica.setConcurrency(1);
fábrica de vuelta;
}
Esta división está siendo escuchada por el grupo de consumidores spring-group. A continuación se muestra cómo se comporta la concurrencia única:
GRUPO TEMA PARTICIÓN CONSUMIDOR ID HOST CLIENTE ID
grupo de primavera tema de prueba 8 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 2 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 1 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 4 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 5 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 6 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 3 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 7 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 9 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 0 consumidor-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumidor-1
Si observa detenidamente el resultado anterior, notará que la identificación del consumidor de la aplicación es la misma para las 10 particiones, lo que indica que es un solo hilo que las conecta a todas.
Veamos qué sucede cuando la concurrencia aumenta a 2,
GRUPO TEMA PARTICIÓN CONSUMIDOR ID HOST CLIENTE ID
grupo de primavera tema de prueba 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
grupo de primavera tema de prueba 6 consumidor-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consumidor-2
grupo de primavera tema de prueba 7 consumidor-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consumidor-2
grupo de primavera tema de prueba 9 consumidor-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consumidor-2
grupo de primavera tema de prueba 4 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 2 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 3 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 1 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
grupo de primavera tema de prueba 0 consumidor-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consumidor-1
Como puede ver en la captura de pantalla anterior, ahora hay dos subprocesos, cada uno con cinco particiones.
Kafka intentará distribuir las particiones de manera uniforme entre los subprocesos que pertenezcan al mismo grupo de consumidores. Tendremos un hilo dedicado para cada partición si creamos diez hilos concurrentes.
Conclusión
En este artículo, entendemos algunas cosas sobre subprocesos múltiples y aprendemos el modelo de subprocesos.
