Als backend engineer hebben we te maken met situaties waarin de gegevens asynchroon moeten worden verwerkt. Laten we vandaag eens kijken hoe het in Java wordt gedaan en op verschillende manieren.

Thread

De zeer eenvoudige maar zo krachtige component van Java-concurrency is: Thread. The Thread of Java is eigenlijk geassocieerd met de Thread van het besturingssysteem. De zeer eenvoudige manier om een Thread is door het uit te breiden en de run :

Het starten van de draad veroorzaakt de run() genoemd te worden.
Je mag vragen; ja, Thread heeft tal van andere methoden die kunnen worden overschreven:

  • In de meeste gevallen willen we andere methoden van de thread niet overschrijven.
  • Zodra we de Thread class, de uitbreidingsklasse verliest zijn vermogen om verder uit te breiden omdat Java geen ondersteuning biedt voor meerdere overervingen.
  • Elke thread heeft zijn eigen object wanneer we het uitbreiden, en het is niet goed voor de gezondheid van het geheugen als er tonnen zijn Objects of the extended Thread gemaakt.

Java lost deze problemen op met de Runnable-interface. In werkelijkheid, Thread heeft een overbelaste methode die Runnable nodig heeft.

Runnable

Runnable is een interface die maar één methode heeft: run(). Ja, Runnable is een functionele interface en de instantie ervan kan worden gemaakt met de lambda-functie. Toch is het een gemakkelijke manier om dit te doen; voor complexe dingen willen we het misschien implementeren. Zie hier het verschil. Het draait allemaal om de eis:

Hoewel Runnable een . heeft run(), het is geen Thread maar gewoon een Java-klasse totdat het wordt bestuurd door (doorgegeven aan) Thread. Het starten van de thread zorgt ervoor dat het uitvoerbare object run() genoemd te worden.

Ja, Java heeft het opgelost in versie 1.5, en het is Callable.

Callable<V>

Callable is een generieke interface. Waarom? Voer deze opdracht van de geretourneerde waarde uit als de generieke voer deze opdracht uit. Oproepbaar is ook een functionele interface en call() is de enige methode, een methode zonder argumenten die Exception genereert en generiek run deze opdrachtwaarde retourneert.

De implementatie van Callable lijkt erg op Runnable:

Zie hier, de aanroep verwerkt de gegevens en retourneert een waarde die na de uitvoering kan worden verzameld. Maar is er een groot verschil in het aanroepen ervan? We gebruiken ExecutorService aanroepen en Future om het resultaat vast te houden. Laten we het hebben over waarom.

Zoals u kunt zien, is er geen gecontroleerd gedrag bij het maken en uitvoeren van de threads (ook uitvoerbaar of oproepbaar). We willen misschien het aantal threads dat tegelijkertijd wordt uitgevoerd, beheren, aangezien elk van hen is gekoppeld aan de threads van het besturingssysteem. Het aantal threads dat we uitvoeren, moet kleiner zijn dan het aantal beschikbare CPU-cores. Alles bij elkaar lost Java het op door: ExecutorService koppel.
Hierboven staat een informatief artikel over Asynchrone programmering in Java: deel I.
Neem gerust contact met ons op via het opmerkingengedeelte, voor het geval je vragen hebt over de instructies die we hierboven hebben gedeeld.