Apache Kafka is een gedistribueerde gegevensopslag die is ontworpen voor realtime invoer en verwerking van streaminggegevens. Streaminggegevens is informatie die continu wordt gegenereerd door duizenden gegevensbronnen, die allemaal tegelijkertijd gegevensrecords verzenden. Een streamingplatform moet de constante instroom van data aankunnen en sequentieel en progressief verwerken.
Wat is multithreading en waarom hebben we het nodig?
Het vermogen van een centrale verwerkingseenheid (CPU) (of een enkele kern in een multi-coreprocessor) om gelijktijdig vele uitvoeringsthreads te bieden, ondersteund door het besturingssysteem, wordt multithreading genoemd. Multithreading kan worden gebruikt om de applicatiesnelheid te verbeteren in gevallen waarin het werk kan worden opgedeeld in kleinere eenheden die parallel kunnen werken zonder de consistentie van de gegevens in gevaar te brengen. Met Kafka kun je je gedistribueerde systeem laten groeien door partities te gebruiken, dit zijn geordende subsets van berichten in een onderwerp.
Het heeft onlangs een trend opgemerkt waarbij ontwikkelaars, in plaats van ervoor te zorgen dat een berekening efficiënt gegevens van een enkele partitie kan verwerken, de gemakkelijke route nemen om de partities/vms uit te breiden om de benodigde doorvoer te krijgen. Het is het equivalent van geld naar het probleem gooien.
Kafka-onderwerpen verdelen records in kleinere delen, partities genaamd, die afzonderlijk kunnen worden verwerkt zonder de nauwkeurigheid van de bevindingen in gevaar te brengen, waardoor de basis wordt gelegd voor parallelle verwerking. Dit wordt gewoonlijk bereikt door te schalen, waarbij veel consumenten binnen dezelfde groep worden gebruikt, waarbij elk gegevens uit een subset van onderwerppartities verwerkt en in een enkele thread werkt.
Omdat het lezen en verwerken van berichten in een enkele thread voor de meesten voldoende is Kafka-gebruiksgevallende Apache Kafka-consument threading paradigma wordt veel gebruikt. De poll-lus werkt soepel wanneer de verwerking geen I/O-activiteiten vereist.
Kafka-consumenten
Consumenten die Kafka kopen, doen dat meestal in groepsverband. Wanneer veel consumenten zich abonneren op een onderwerp en lid zijn van dezelfde consumentengroep, ontvangt elke consument berichten van een subset van de partities van het onderwerp.
Het toevoegen van extra consumenten aan een consumentengroep is de meest gebruikelijke techniek om het gegevensverbruik van een Kafka-onderwerp te schalen. Consumenten van Kafka voeren vaak acties met hoge latentie uit, zoals het schrijven naar een database of het uitvoeren van een tijdrovende berekening op de gegevens. Wanneer een enkele consument de snelheid waarmee gegevens naar een onderwerp stromen niet kan bijhouden, schalen we door meer consumenten toe te voegen die de belasting delen door elke consument slechts een subset van de partities en berichten te laten bezitten.
Voordelen van multithreading
Met multithreading kunnen veel delen van een programma tegelijkertijd worden uitgevoerd. Threads zijn lichtgewicht processen die beschikbaar zijn binnen het proces. Multithreading maakt multitasking mogelijk om het meeste uit de CPU te halen.
Hieronder volgen enkele voordelen van multithreaded programmeren:
Bronnen delen
De bronnen van een proces, inclusief geheugen, gegevens en bestanden, worden door alle threads gedeeld. Met het delen van bronnen kan een enkel programma meerdere threads in dezelfde adresruimte hebben.
Ontvankelijkheid
Dankzij de responsiviteit van het programma kan een programma blijven werken, zelfs als een deel ervan is stopgezet vanwege multithreading. Als het proces een langdurig proces is, kan dit ook worden gedaan.
Multiprocessor-architectuur
Dankzij multithreading kan elke thread in een architectuur met meerdere processors parallel op een andere processor worden uitgevoerd. Dit verbetert de gelijktijdigheid van het systeem. In een systeem met één processor kan slechts één proces of thread tegelijk worden uitgevoerd.
Wat is thread per consumentenmodel?
Elke thread wordt geïnstantieerd en verbonden met de Kafka-makelaar in de thread per consumentenmodel. De partities waarvan de berichten naar deze threads worden verzonden, worden toegewezen door de kafka-broker.
Een enkele thread maakt verbinding met Kafka in multi-threaded consumentenmodus en kan gegevens ophalen van meerdere / enkele partities. Als de gegevens eenmaal aan de thread zijn geleverd, kan de thread de berichten distribueren naar andere pools van threads voor parallelle verwerking. Bij deze methode bepaalt de consumententhread welke onderliggende thread welke soorten berichten zal verwerken. In deze omstandigheden wordt offsetbeheer echter buitengewoon moeilijk.
Spring kan gemakkelijk meerdere threads genereren om verbinding te maken met Kafka. Laten we eens kijken hoe de twee zich anders gedragen. We hebben een enkel testonderwerp met tien partities en een enkele VM waarop een enkele gelijktijdige lente-applicatie draait.
Onderwerp per consumentenmodel
/**
* 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);
}
/**
* Stelt gelijktijdigheid in voor kafka-luisteraar
*
* @opbrengst
*/
@Boon
public ConcurrentKafkaListenerContainerFactory
{
ConcurrentKafkaListenerContainerFactory
fabriek.setConsumerFactory(consumerFactory());
fabriek.setConcurrency(1);
terug fabriek;
}
Naar deze verdeling wordt geluisterd door de consumentengroep Spring-groep. Het volgende is hoe enkele gelijktijdigheid zich gedraagt:
GROEPSONDERWERP PARTITIE CONSUMENT-ID HOST CLIENT-ID
spring-group test-topic 8 consument-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consument-1
spring-group test-topic 2 consument-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consument-1
spring-group test-topic 1 consument-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consument-1
spring-group test-topic 4 consumer-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumer-1
spring-group test-topic 5 consument-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consument-1
spring-group test-topic 6 consument-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consument-1
spring-group test-topic 3 consument-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consument-1
spring-group test-topic 7 consumer-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consumer-1
spring-group test-topic 9 consument-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consument-1
spring-group test-topic 0 consument-1-01a5779b-940b-44cf-b8c6-2e414aa38eb1 /172.22.0.1 consument-1
Als je goed kijkt naar de bovenstaande uitvoer, zul je merken dat de consumenten-ID van de applicatie hetzelfde is voor alle 10 partities, wat aangeeft dat het een enkele thread is die ze allemaal verbindt.
Laten we eens kijken wat er gebeurt als de gelijktijdigheid wordt verhoogd tot 2,
GROEPSONDERWERP PARTITIE CONSUMENT-ID HOST CLIENT-ID
spring-groep test-topic 8 consument-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consument-2
spring-groep test-topic 5 consument-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consument-2
spring-groep test-topic 6 consument-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consument-2
spring-group test-topic 7 consumer-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consumer-2
spring-groep test-topic 9 consument-2-8ab0213d-683c-4f92-b3c8-767701905994 /172.22.0.1 consument-2
spring-groep test-onderwerp 4 consument-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consument-1
spring-groep test-topic 2 consument-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consument-1
spring-groep test-onderwerp 3 consument-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consument-1
spring-groep test-onderwerp 1 consument-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consument-1
spring-groep test-onderwerp 0 consument-1-886f1a6e-f316-4e17-90d2-599a582682e4 /172.22.0.1 consument-1
Zoals je kunt zien in de bovenstaande schermafbeelding, zijn er nu twee threads, elk met vijf partities.
Kafka zal proberen partities gelijkmatig te verdelen over threads die tot dezelfde consumentengroep behoren. We hebben een speciale thread voor elke partitie als we tien gelijktijdige threads maken.
Conclusie
In dit artikel begrijpen we een paar dingen over multithreading en leren we het threading-model.
