Samenvatting: Begrip van BIO en NIO
Onlangs heb ik waarschijnlijk naar de broncode van ZooKeeper en Mina gekeken en ontdekt dat ze allebei geïmplementeerd zijn in Java NIO, dus het is noodzakelijk om uit te zoeken wat NIO is. Het volgende is mijn eigen samenvatting gebaseerd op online informatie; om tijd te besparen tekende ik het diagram nonchalant, zolang ik de betekenis maar kon bereiken.
Introductie:
BIO: Synchronous blocking IO, de serverimplementatiemodus is om één thread tegelijk te verbinden, dat wil zeggen, wanneer de client een verbindingsverzoek heeft, moet de server een thread starten voor verwerking; als deze verbinding niets doet, veroorzaakt dat onnodige thread-overhead, natuurlijk kan dit worden verbeterd via het threadpool-mechanisme.
NIO: Synchrone niet-blokkerende IO, de serverimplementatiemodus is één verzoek per thread, dat wil zeggen, het verbindingsverzoek dat door de client wordt gestuurd wordt geregistreerd op de multiplexer, en de multiplexer start een thread voor verwerking wanneer de verbinding een I/O-verzoek heeft.
AIO (NIO.2): Asynchrone niet-blokkerende IO, de serverimplementatiemodus is om effectief één thread aan te vragen, en de I/O-verzoeken van de client worden eerst door het besturingssysteem afgerond en vervolgens de serverapplicatie geïnformeerd om de thread te starten voor verwerking.
BIOGRAFIE
Synchrone blokkerende IO, ik geloof dat iedereen die netwerkprogrammering van besturingssystemen of een andere taal van netwerkprogrammering heeft geleerd, bekend is; in de while-lus roept de server de accept-methode aan om te wachten op het verbindingsverzoek van de ontvangende client; zodra een verbindingsverzoek is ontvangen, kan er een communicatiesocket op deze communicatiesocket worden opgezet voor lees- en schrijfoperaties, op dat moment kan het geen andere client-verbindingsverzoeken meer ontvangen, alleen wachten op de uitvoering van de operatie met de momenteel verbonden client.
Als BIO meerdere clientverzoeken tegelijk wil kunnen verwerken, moet het multithreading gebruiken, dat wil zeggen, elke keer wachten acceptblokken op een clientverzoek, zodra een verbindingsverzoek is ontvangen, wordt een communicatiesocket opgericht en wordt een nieuwe thread geopend om het data-lees- en schrijfverzoek van deze socket te verwerken, waarna het vervolgens direct doorgaat met het accepteren en wachten op andere clientverbindingsverzoeken, dat wil zeggen, er wordt een thread aangemaakt voor elk clientverbindingsverzoek dat afzonderlijk wordt verwerkt, het schema is waarschijnlijk als volgt:
C:/Users/kevin/AppData/Local/YNote/data/kevinsir2003@163.com/8107c3f773ad4d2aa1a5a476e650ef84/094528_zqyy.jpeg
Hoewel de server op dit moment een hoge gelijktijdigheid heeft, dat wil zeggen dat hij meerdere clientverzoeken tegelijk kan verwerken, brengt dit een probleem met zich mee: naarmate het aantal open threads toeneemt, verbruikt hij te veel geheugenbronnen, waardoor de server vertraagt of zelfs crasht, en NIO kan dit probleem tot op zekere hoogte oplossen.
NIO
De sleutel tot synchrone niet-blokkerende IO is het adopteren van een gebeurtenisgestuurd idee om een multiplexer te implementeren.
Het grootste verschil tussen NIO en BIO is dat je alleen een thread hoeft te openen om IO-events van meerdere clients af te handelen.
Het is een multiplexer die IO-gebeurtenissen van meerdere clients kan afluisteren:
A. Als de server luistert naar het client-verbindingsverzoek, zal hij een communicatiesocket voor deze (kanaal in Java) opzetten en vervolgens terugkeren om verder te luisteren.
B. Als de server luistert naar de gegevens die worden verzonden door de client die een communicatiesocket heeft aangemaakt, roept hij de bijbehorende interface aan om de ontvangen data te verwerken, en als er meerdere clients tegelijk zijn, kunnen de gegevens ook op hun beurt worden verwerkt.
C. Luister naar de verbindingsverzoeken van meerdere klanten en ontvang dataverzoeken, en luister ook wanneer je data moet versturen.
C:/Users/kevin/AppData/Local/YNote/data/kevinsir2003@163.com/41709898aa0a4f8a830d7c348ed05fbb/094528_of9c.jpeg
Kortom, in één thread kun je de multiplexinginterface (select in Java) aanroepen om IO-verzoeken van meerdere clients tegelijk te blokkeren en te luisteren, en zodra een IO-verzoek is ontvangen, wordt de bijbehorende functie aangeroepen om het te verwerken.
Respectieve toepassingsscenario's
Op dit punt heb je misschien gemerkt dat zodra een verzoek arriveert (of het nu meerdere tegelijk zijn of slechts één), de bijbehorende IO-verwerkingsfunctie wordt aangeroepen om het af te handelen, dus:
(1) NIO is geschikt voor scenario's met een groot aantal verbindingen, maar de verbindingen zijn relatief kort (lichte bediening), zoals Jetty, Mina, ZooKeeper, enz., die allemaal zijn geïmplementeerd op Java Nio.
(2) De BIO-methode is geschikt voor scenario's waarin het aantal verbindingen relatief klein en vast is, wat veel serverresources vereist en beperkt is tot applicaties.
|
Geplaatst op 17-05-2019 15:34:50
|
|
|
Leer leren