Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Overview

Praecipuam cognitionem NIO in ava gradu describit, pro basic recognitione

1. NIO Overview

In Java, NIO (Non-obturans I/O vel Novum I/O) nova copia input/output operationis API in Java SE 1.4 et versionibus subsequentibus introducta est.

Comparato exemplari translaticio IO, altiorem efficientiam ac magis concurrentem capacitatem processus praebet. Clavis notae NIO est eius pluma non-obclusio, quae unum filum ad plures canales I/O administrandum permittit, eoque magis meliore applicatione effectus in missionibus summus concursus est.

Usus missionis Javae NIO apprime convenit pro condicionibus in quibus magnus numerus coniunctionum concurrentium ad discursum opus est. Exempli gratia, in servo retis, unum linum administrare potest milia hospitum clientium sine necessitate ut filum independens pro singulis connexionibus collocare possit. . Potest signanter minuere systema resource consummatio et amplio facultates processui

2. Tres partes maioris NIO in Java

1. canales

Channel est medium notitiarum influentium in Java NIO. Bidirectionale est et ad data vel scribenda notitia adhiberi potest. Praecipua utilitas canalium est quod non-obturbant, quod significat unum linum posse plures canales administrare. Cum nullae eventus in canali occurrent, filum non obstruetur et alia negotia tractari potest. Pelagus channel types includit:

• FileChannel: pro lima operationes legere et scribere. Potest adhiberi ut notitias ex quiddam tabellae scribere, vel notitias ex tabella legere in quiddam.
• SocketChannel: TCP nexus in communicationibus retis adhiberi possunt, ac legere et scribere notitias adhiberi possunt.
• ServerSocketChannel: novos hospites SocketChannel accipiebant, similes traditionibus ServerSocket.
• DatagramChannel: Pro communicatione UDP adhibita, quae mittere et accipere potest datagrams.

2. Buffers

Obiectum quiddam est notitiarum copiarum in NIO. Est byte ordinata quae notitias scribere et notitias ex eo legere potest. Aliquid quiddam habet capacitatis specificae et duas praecipuas proprietates habet: situm et modum.

• capacitas: Maximum numerum elementorum ut quiddam reponunt.
• Position: Index elementi nunc operatus est, qui mutat cum notitia legitur vel scribitur.
• Limit: Modus in lege, maximum valorem quam positio attingere potest;

Genera sunt buffersByteBuffer、CharBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBufferetDoubleBufferunaquaeque typum primitivae notae typi respondet.

3. Selectors

Lector multiplex in NIO est qui unum filum ad monitorias eventus ex multiplicibus canalibus praebet, ut legere, scribere, coniungere, eventa accipere. Lector notificat applicationem cum unus e canalibus paratus est ad operationes I/O. Usus selectorum valde melioratur concursus processus facultatum applicationum retis, quia non opus est filo pro singulis connexionibus creare.

Summa methodorum selectorum includit:

• select(): Caudices usque ad unum saltem alveum I/O operationibus paratum est.
• selectedKeys(): Redit Pone continens objecta SelectionKey omnium canalium praeparatorum.
• wakeup(): Interpellare claususselect()translatio.

SelectionKeyEst consociatio inter selectores et canales.

3. Network programming

1. Clausus I / O *

Hoc est exemplar antiquissimum I/O. Hoc modo, cum filum legere vel scribere operationem inchoat, linum impeditur donec operatio I/O perficiatur. Si nulla data est operatio legere legere, vel operatio scribe statim perfici non potest, sequela exspectabit donec operatio compleatur.

Features:

• Simplex programming exemplum: facile ad intelligendum et efficiendum.
• Resource opus: Quaelibet connexio filum independens requirit, inde in stricto numero staminum et consummatio resource altae.
• Euismod limitations: In missionibus summus concursus, filum mutans et contextus commutationes pretiosae sunt et facile utres fieri possunt.

2. Non Clausus I / O *

Non-obstructionum I/O pars est compagis Javae NIO (Novi I/O) quae fila sine interclusa operationes legere et scribere sinit. Si nulla data sit legere operatio legere, aut operatio scribentis statim perfici non potest, linum non suspenditur et alia negotia pergere potest.

Features:

• mollitiem: Stamina plures nexus tractare possunt quia non impediuntur exspectationes operationum I/O.
• auxit multiplicitate: programmator explicite inspiciendus est an operatio compleatur quae difficultatem programmandi auget.
• Euismod improvementsIn summo concursu missionum, caput causatum e sequela commutatione signanter reduci potest.

3. Multiplexing

Multiplexio est ad monitorem multiplex fasciculi descriptorum simul per unum linum, et solum in descriptor cum promptum est (solet enim notitia legere est, vel scribere quiddam est writable). Selectores in Java ad multiplicationem efficiendam adhibentur.

Features:

• Princeps ConcurrencyUnum linum mille nexuum tractare potest, perputo servientis valde meliori.
• EfficiensTantum cum operatio I/O parata est, stamina excitabitur ad stamina mutanda non necessaria.
• Resource salutaris: Praeclusio I/O, servientes sub multiplici exemplari exemplari facultates systematis efficacius uti possunt.

Animadverte:

In applicationibus non interclusio I/O saepe in coniunctione cum multiplicatione adhibetur. Exempli gratia, cultor Selector ad monitorem multiplex SocketChannels uti potest. Cum SocketChannel notitias habet quae legi vel scriptae possunt, Selector servo certiorem faciet, et server hoc SocketChannel specificum processit in modo non-obstructio.

4.NIO VS BIO

4.1 nos rivum alveum

In Java, Flumine et Channel sunt duo diversi modi processus notitiarum rivulorum. Illi ad vexillum IO bibliothecae Javae et ad bibliothecam NIO pertinent. Hic accurata comparatio duorum notionum est;

Stream

Amnis pars exemplar vexillum Javae IO (io obturans) praebet, quod viam sequenti modo legendi et scribendi praebet. Amnis in duo genera dividitur: InputStream et OutputStream, quae notitias respective legere et scribere solebant.Hi rivi byte rivi esse possunt (utInputStream, OutputStream) Vel ingenii amnis (utReader, Writer）。

Features:

• Obstructive: Defalta, Stream operationes intercludunt, hoc est, si nulla data est ad legendum operandum, aut scribenda operatio statim perfici non potest, vocationis filum obstruetur donec operatio perficiatur.
• Unidirectionality: Unusquisque Fluvius directionem habet, aut solum legit aut tantum scribe.
• automatic shutdown: Flumine utendo, vocare soles necesse estclose() methodum facultates dimittere.Incipiens a Java 7, statim propositio potest exsequendam exsequendam operam cum opibusAutoCloseableInterface facultates, inter Stream.

Channel

Channel ad exemplar Javae NIO (New IO) pertinet, quod altiorem gradum abstractionis quam Fluvius praebet, efficacius notitiarum processus permittens. Canales bidirectionales esse possunt, significationes datas legere et scribere possunt.Pelagus Channel types includitFileChannel、SocketChannel、ServerSocketChanneletDatagramChannel。

Features:

• non-obturans : Channel felis in consequat vel non-modus potest interclusio. In modo non-obstructione, si operatio legere non habet notitias ad legendum, aut operatio scribentis statim perfici non potest, operatio statim reddet pro sequela claudendo.
• Quiddam res: Channel operationes per quiddam semper exercentur (Buffer). Data ab alveo in quiddam vel ex quiddam ad canalem scribitur.
• Multiplexing: Channel adhiberi potest una cum Selectore ad multiplicationem consequendam, permittens unum filum ad Monitor I/O operationes plurium canalium ac facultates processus concurrentes emendare.

Summatim

• Lorem scaena: Fluvius aptior est ad expediendas minores notitias vel simplices operationes fasciculi, dum Channel aptior est ad expediendas magnas moles notitiarum, praesertim retis communicationis et magnas operationes fasciculi, quia praebet facultatem altiorem observantiam et melius concurrentiae facultatem.
• Programming complexionem: API Fluminis facilior et facilior est usus; dum API Channel et NIO sunt implicatiores, sed potentiores functiones et efficientiam altiorem praebent.
• Resource administratione: Utrum Fluvius vel Channel sit, facultates apte tractandae sunt et ut claudantur, ubi non opus est ad vitandam scillam subsidii.

4.2.

In Java, I/O exempla operationis distingui possunt secundum duas dimensiones synchronae/asynchronae et interclusionis/non-obstructionis.

4.2.1 Synchroni Clausus I / O

definition : Synchronum interclusio I/O est exemplar maxime traditum I/O. Cum linum vocat operationem I/O (ut legendi vel scribendi), filum obstruetur donec operatio perficiatur. Id est quod filum alia opera praestare non potest donec operatio compleatur.

Features：

• Simplex et facilis usus in codice logica patet.
• Quaelibet I/O operatio filum exclusivum requirit, quod ad missiones concurrentiae altas non convenit et ad lassitudinem resource stamina perducere potest.
• Communiter inInputStream、OutputStream、SocketetServerSocketferenti.

Exemplum:

Utere traditionalInputStreametOutputStreamLegere et scribere files:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class SyncBlockingIOExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.2.2 Synchroni Non Clausus I/O

definition : Synchrono non-obstructione I/O, filum post operationem I/O vocato non obstruetur. Si operatio statim perfici non potest, modus statim revertetur, plerumque valorem specialem reddens (ut -1 vel 0) vel exceptionem ad indicandum coniectans operationem non completam.

Features：

• Status operatio tondendus est donec operatio perficiatur.
• Utilization stamina superior, quia filis alia officia praestare possunt dum I/O exspectatur.
• Exsecutio magis implicata est et indiget ad saepta tractanda et status inhibet.
• Ex Java NIOChannelsetBuffersvocandoconfigureBlocking(false)Constitue alveo non-obturans modus.

Exemplum:

NIO utensFileChannelNam non- interclusio lectionis et scribendi;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.nio.ByteBuffer;

public class SyncNonBlockingIOExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt");
             FileChannel inChannel = fis.getChannel();
             FileChannel outChannel = fos.getChannel()) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            inChannel.configureBlocking(false);
            while (inChannel.read(buffer) > 0) {
                buffer.flip();
                outChannel.write(buffer);
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4.2.3 Synchroni Multiplexing I/O

definition: Synchrona multiplexed I/O exemplar ususSelector(Selector) ad Monitor multiplexChannel eventum.Cum filum vocatSelector.select(), impediet donec unus saltem sitChannelEvents (ut readable, writable, nexum petitionem, etc.) occurrunt.

Features：

• Permittit unum filum administrare pluresChannelmelius concurrit.
• passSelectoretSelectionKeyMechanismus, qui magnum numerum coniunctionum concurrentium efficienter tractare potest.
• Apta ad missiones servo retis, sicut servitores telae et servitores chat.
• Java ex compage NIO.

Exemplum:

NIO utensFileChannelNam non- interclusio lectionis et scribendi;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Set;

public class SyncMultiplexingIOExample {
    public static void main(String[] args) throws IOException {
        try (Selector selector = Selector.open();
             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()) {
            serverSocketChannel.socket().bind(new InetSocketAddress(8080));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                if (selector.select() > 0) {
                    Set<SelectionKey> keys = selector.selectedKeys();
                    for (SelectionKey key : keys) {
                        if (key.isAcceptable()) {
                            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                            SocketChannel clientChannel = ssc.accept();
                            clientChannel.configureBlocking(false);
                            clientChannel.register(selector, SelectionKey.OP_READ);
                        }
                    }
                    keys.clear();
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

4.2.4 Asynchronous Non Clausus I/O*

definition : In exemplari asynchrono non-obstructione I/O, filum statim redit post initium I/O operationis non expectata operatione ad perficiendum. Cum operatione perfecta est, sequela asynchrone notificabitur per munus callback vel eventum notificationis.

Features：

• Efficacissima I/O exemplar, fila omnino non impediuntur et alia negotia statim exercere possunt.
• passAsynchronousChannelInterface et exsecutionem generis eius, utAsynchronousFileChanneletAsynchronousSocketChannel。
• Idoneus est summus concursus et summus perficientur missiones, sicut magni MGE et onus retiacula servientes.
• Java 7 exemplar asynchronum non-obturans I/O induxit.

Exemplum:

NIO utensAsynchronousFileChannelPraestare asynchronum limam legere et scribere;

import java.io.IOException;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.ByteBuffer;
import java.util.concurrent.CountDownLatch;

public class AsyncNonBlockingIOExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        AsynchronousFileChannel inChannel = AsynchronousFileChannel.open(Paths.get("input.txt"), StandardOpenOption.READ);
        AsynchronousFileChannel outChannel = AsynchronousFileChannel.open(Paths.get("output.txt"), StandardOpenOption.WRITE);
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        CountDownLatch latch = new CountDownLatch(1);
        inChannel.read(buffer, 0, buffer, 0, (channel, result) -> {
            buffer.flip();
            outChannel.write(buffer, 0, buffer, 0, null);
            latch.countDown();
        });
        latch.await();
        inChannel.close();
        outChannel.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Nota: asynchronous exemplar requirit auxilium a ratio operandi subiecta (Kernel)

• Windows systemata asynchronum IO per IOCP effectum deducendi
• Asynchronous IO in systemate Linux in versione 2.6 introductus est, sed subesse exsecutionem adhuc utitur multiplicatione ad asynchronum IO simulandum, et nulla utilitas perficiendi est.

4.2.5 Asynchronous Clausus I / O

definition In doctrina, hoc exemplar non est, quia "asynchronum" significat operationem in curriculo perfici et filum non impeditur. Ergo asynchronous interclusio I/O est conceptus contradictorius et in usu non apparebit.

4.2.6 Summary

Opportunum eligendum I/O exemplar est criticum ad perficiendi et subsidiorum administrationem. In missionibus summus concursus, synchrona non-obstructio I/O vel synchrona multiplicata I/O exemplaria electiones communes sunt.

4.3 Nulla exemplum

Nulla-Copy conceptum

Nulla exemplum technologiae significat quod in processu transmissionis notitiarum de loco in locum, notitias inter spatium usoris et spatium nuclei non oportet exscribi, vel saltem numerum talium exemplarium minuere, eo quod efficientiam augeat. ratio. In institutis I/O operationibus, cum notitia e retis vel orbis legitur, primum ad quiddam in spatio nucleo exscriptus est, deinde a spatio nucleo ad quiddam in spatio usoris exscriptus. Contra, in nulla-exemplar, notitia directe in spatio nuclei discursum esse potest, vel ex spatio nucleo ad retis fabrica directe transferri, inde reducendo exemplum operationis CPU, systematis supra caput reducens, et efficientiam transmissionis datae emendans.

Source of nulla exemplum

Conceptus nullius exemplaris primus apparuit in consilio operandi ratio, quaerens solvere solutionem bottleneck causatum notitiarum enucleandi in operationibus traditionalibus I/O. In primis systematibus computatoriis, omnes I/O operationes multae notitiae exemplares inter spatium usoris et nuclei spatium requirebant. Hoc sensim factus est cum reticulis summus velocitatis et magnae capacitatis orbis retiaculorum perficiendi facta est.

Key technica puncta

• Direct I / O *: applicationes ad accessum orbis machinis directe permittit, omissis mechanism fasciculi systematis.
• Memoria mapping (MMAP): tabulae geographicae ad memoriam faciendae ut notitia fasciculi accessi possit sicut memoria, redigens ad describendum.
• Sendfile: Linux systema vocant qui notitias directe ab uno descripto in alium transferre potest, exemplaribus intermediis vitandis.
• DMA Direct Memoria Access）: technologiae hardware graduum quae notitias directe transferri sinit inter fabrica et memoria sine CPU implicatione.

Exsecutio in Java:

Java nulla-exemplar technologiae per compagem NIO (Novum I/O) sustinet. NIO introductusFileChanneletSocketChannel et alia genera, quae efficaciorem I/O operationes praebent. Speciatim,FileChannel.transferTo()etFileChannel.transferFrom()Methodi notitias directe a canali fasciculi ad nervum vel vice versa transferre possunt quin notitias in quiddam onerant, ita ut nullum exemplar obtineant.

Exempli gratia, argumenta fasciculi magni ad retiaculum mittere debes. Traditionalis accessio est primum tabella contenta in quiddam legere, deinde quiddam contenta in retiaculis scribere. Duas operationes exemplum hoc involvit: unum ab orbe ad quiddam, alterum a quiddam ad ornatum.dum usuratransferTo()Cum hac methodo utens, notitia directa ab orbe ad reticulum transferri potest sine necessitate quiddam medium, quod numerum exemplarium reducit et nullum exemplum consequitur.

Exemplum per ByteBuffer:

ByteBufferet aliaBufferclassis (ut *CharBuffer，ShortBufferetc.) praebent buffers quae impleri vel evacuari possunt sine exemplarium inter spatium usoris et nuclei spatium involvente.ByteBufferPotest adhiberi directe vel indirecte in nulla technicarum exemplarium:

1. Direct Buffer：ByteBuffer.allocateDirect(size)creatusByteBuffer Instantiae directe provisae sunt memoriae physicae, praetereunte acervo Javae.Quando tale quiddam comparaturFileChannelor *SocketChannel Cum simul usus est, notitia recta inter physicas memoriam et machinas ferramentis transferri potest sine necessitate additi exemplarium per Iava acervum. Hoc verum dat exemplum nulla in quibusdam suggestis.
2. ususFileChannelof *transferTo()ettransferFrom(): Hae methodi permittunt datam directe condiFileChanneletSocketChanneltraducitur interByteBuffer ut medius. Id significat notitias datas directe ab orbe ad retis vel vice versa transferri posse, quin transcribendum sit inter spatium usoris et spatium nuclei.
3. ususByteBufferof *wrap()methodo：wrap()methodo concedit te involvere existentem byte ordinata vel aliud quiddam in aByteBuffer sic nihil opus est notitias novo quiddam exscribere. Hoc est utile ad vitandum notitias supervacuas describendas.
4. ususByteBufferof *slice()methodo：slice() methodus visum gignit quiddam sine exemplarium notitia subiecta.Hoc significat magnamByteBufferScinditur in multiplex minora buffers sine notitia describendi.

Miscere ByteBuffer cum FileChannel:

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

public class ZeroCopyExample {
    public static void main(String[] args) {
        Path path = Path.of("example.txt");
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
            long transferred = fileChannel.transferTo(0, fileChannel.size(), System.out);
            System.out.println("Transferred bytes: " + transferred);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Animadverte:

Re vera notandum, nullum exemplar nullum omnino esse. Sed etiam in gradu usoris, impossibile est nullas omnino operationes habere exemplares, sed exemplaria reducere quam maxime. et non significat operationem realem exemplar non esse.