IO
Was ist IO? Es bezieht sich auf die Schnittstelle zwischen einem Computer und der Außenwelt oder zwischen einem Programm und dem Rest des Computers.
Mund. Es ist für jedes Computersystem so wichtig, dass der Großteil aller E/A tatsächlich in das Betriebssystem integriert ist
von. Einzelne Programme überlassen in der Regel dem System die meiste Arbeit für sie.
In der Java-Programmierung wurden bis vor kurzem Streams verwendet, um I/O abzuschließen. Alle E/A werden als eine einzige behandelt
Bytes werden Byte für Byte durch ein Objekt namens Stream verschoben. Stream I/O wird zur Kommunikation mit der Außenwelt verwendet
berühren. Es wird auch intern verwendet, um Objekte in Bytes und zurück in Objekte umzuwandeln.
BIO
Java BIO ist Block-E/A, synchrone und blockierende E/A.
BIO ist die Code-Implementierung unter dem traditionellen java.io-Paket.
NIO
Was ist NIO? NIO hat die gleiche Rolle und den gleichen Zweck wie das ursprüngliche I/O. Der wichtigste Unterschied zwischen ihnen sind Daten
Die Methode der Verpackung und Übertragung. Die ursprüngliche E/A verarbeitet Daten streamweise, während NIO Daten blockweise verarbeitet.
Stream-orientierte I/O-Systeme verarbeiten Daten byteweise. Ein Eingabestream erzeugt ein Datenbyte, a
Der Ausgabestream verbraucht ein Byte Daten. Es ist sehr einfach, Filter für Streaming-Daten zu erstellen. Verketten Sie mehrere Filter, sodass jeder
Filter sind nur für einen Teil eines einzelnen komplexen Verarbeitungsmechanismus verantwortlich, der relativ einfach ist. Auf der anderen Seite: Stream-orientiert
I/O ist normalerweise ziemlich langsam.
Ein blockorientiertes I/O-System verarbeitet Daten blockweise. Jeder Vorgang wird in einem Schritt produziert oder verbraucht
Ein Datenblock. Die Verarbeitung von Daten in Blöcken ist viel schneller als die Verarbeitung von Daten in (Streaming-)Bytes. Bei blockorientierter E/A fehlt jedoch ein
Die Eleganz und Einfachheit einiger Stream-orientierter I/O.
AIO
Java AIO ist asynchrones, nicht blockierendes, also asynchrones, nicht blockierendes IO.
205
>
E/A-
Fluss
Unterschiede und Zusammenhänge
BIO (Blocking I/O): Synchroner Blockierungs-E/A-Modus, Datenlesen und -schreiben müssen in einem Thread blockiert werden
Warten Sie, bis der Vorgang abgeschlossen ist. Hier gehen wir von einem Szenario aus, in dem Wasser kocht, mit einer Reihe von Kesseln, die Wasser kochen. Der Arbeitsmodus von BIO ist:
Bitten Sie einen Thread, an einem Wasserkocher zu bleiben, bis der Wasserkocher kocht, bevor er den nächsten Wasserkocher verarbeitet. Aber tatsächlich der Thread
Während man darauf wartete, dass der Wasserkocher kocht, wurde nichts unternommen.
NIO (Neue E/A): unterstützt sowohl blockierende als auch nicht blockierende Modi, aber hier verwenden wir den synchronen nicht blockierenden E/A-Modus
Zur Veranschaulichung: Was ist synchrones Nichtblockieren? Wenn wir als Beispiel kochendes Wasser nehmen, besteht der Ansatz von NIO darin, einem Thread zu sagen, dass er es nicht tun soll
Fragen Sie kontinuierlich den Status jedes Wasserkochers ab, um festzustellen, ob sich der Status eines Wasserkochers geändert hat, um mit dem nächsten Schritt fortzufahren.
AIO (Asynchronous I/O): Asynchrones, nicht blockierendes I/O-Modell. Asynchrone nicht blockierende und synchrone nicht blockierende Bereiche
Wo sonst? Für die asynchrone Nichtblockierung ist kein Thread erforderlich, um die Statusänderungen aller E / A-Vorgänge abzufragen. Nach den entsprechenden Statusänderungen
Das System benachrichtigt den entsprechenden Thread, um damit umzugehen. Entsprechend kochendem Wasser ist an jedem Wasserkocher ein Schalter angebracht.
Nach dem Einschalten meldet mir der Wasserkocher automatisch, dass das Wasser kocht.
Anwendbare Szenarien für jedes
Die BIO-Methode eignet sich für Architekturen mit einer relativ kleinen und festen Anzahl von Verbindungen. Diese Methode stellt relativ hohe Anforderungen an Serverressourcen.
Parallelität ist auf Anwendungen beschränkt, die einzige Option vor JDK1.4, aber das Programm ist intuitiv, einfach und leicht zu verstehen.
Die NIO-Methode eignet sich für Architekturen mit einer großen Anzahl von Verbindungen und relativ kurzen Verbindungen (leichte Vorgänge), wie z. B. Chat-Server, gleichzeitig
Die auf Anwendungen beschränkte Programmierung ist komplizierter und JDK1.4 beginnt, sie zu unterstützen.
Die AIO-Methode eignet sich für Architekturen mit einer großen Anzahl von Verbindungen und relativ langen Verbindungen (schwere Vorgänge), wie z. B. Fotoalbumserver.
Das Aufrufen des Betriebssystems zur Teilnahme an gleichzeitigen Vorgängen erfordert eine komplexe Programmierung, und JDK7 beginnt, dies zu unterstützen.
Verwendung
Verwenden Sie BIO zum Lesen und Schreiben von Dateien.
//Initialisiert das Objekt
Benutzer1 Benutzer = neuer Benutzer1();
user.setName("hollis");
user.setAge(23);
System.out.println(user);
I/O
流
<
206
//Obj in Datei schreiben
ObjectOutputStream oos = null;
versuchen {
oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
oos.writeObject(user);
} Catch (IOException e) {
e.printStackTrace();
} Endlich {
IOUtils.closeQuietly(oos);
}
//Obj aus Datei lesen
Datei file = new File("tempFile");
ObjectInputStream ois = null;
versuchen {
ois = new ObjectInputStream(new FileInputStream(file));
User1 newUser = (User1) ois.readObject();
System.out.println(newUser);
} Catch (IOException e) {
e.printStackTrace();
} Catch (ClassNotFoundException e) {
e.printStackTrace();
} Endlich {
IOUtils.closeQuietly(ois);
versuchen {
FileUtils.forceDelete(file);
} Catch (IOException e) {
e.printStackTrace();
}
}
Verwenden Sie NIO zum Lesen und Schreiben von Dateien.
static void readNIO() {
String pathname = "C:\\Benutzer\\adew\\Desktop\\jd-gui.cfg";
FileInputStream fin = null;
versuchen {
fin = new FileInputStream(new File(pathname));
FileChannel-Kanal = fin.getChannel();
int Kapazität = 100;//
Bytes
ByteBuffer bf = ByteBuffer.allocate(capacity);
System.out.println("
Das Limit ist:
" + bf.limit() + "
Die Kapazität ist:
" + bf.capacit
y()
+ "
Die Position ist:
" + bf.position());
int Länge = -1;
while ((length = channel.read(bf)) != -1) {
207
>
E/A-
Fluss
/*
*
Beachten Sie, dass Sie nach dem Lesen die Position auf
0 setzen
und
die Kapazität auf die Kapazität
beschränken
, um das nächste Mal in den Byte-Puffer einzulesen.
Beginnen Sie mit der Speicherung bei
0
*/
bf.clear();
byte[] bytes = bf.array();
System.out.write(bytes, 0, length);
System.out.println();
System.out.println("
Das Limit ist:
" + bf.limit() + "
Die Kapazität ist:
" + bf.capa
Stadt()
+ "
Die Position ist:
" + bf.position());
}
Kanal.close();
} Catch (FileNotFoundException e) {
e.printStackTrace();
} Catch (IOException e) {
e.printStackTrace();
} Endlich {
if (fin != null) {
versuchen {
fin.close();
} Catch (IOException e) {
e.printStackTrace();
}
}
}
}
static void writeNIO() {
String filename = "out.txt";
FileOutputStream fos = null;
versuchen {
fos = new FileOutputStream(new File(filename));
FileChannel-Kanal = fos.getChannel();
ByteBuffer src = Charset.forName("utf8").encode("
Hallo hallo hallo hallo Sie
OK
");
//
Die Kapazität und
das Limit des Bytepuffers
ändern sich mit der Datenlänge und sind nicht festgelegt.
System.out.println("
Initialisierungskapazität und
-limit
:
" + src.capacity() + ","
+ src.limit());
int Länge = 0;
while ((length = channel.write(src)) != 0) {
/*
* Beachten Sie, dass
hier kein
Löschen erforderlich ist
. Schreiben Sie die Daten im Puffer zum zweiten Mal in den Kanal und fahren Sie beim vorherigen Mal fort.
Lesen Sie sich die Bestellung durch
*/
I/O
流
<
208
System.out.println("
Länge schreiben
:" + Länge);
}
} Catch (FileNotFoundException e) {
e.printStackTrace();
} Catch (IOException e) {
e.printStackTrace();
} Endlich {
if (fos != null) {
versuchen {
fos.close();
} Catch (IOException e) {
e.printStackTrace();
}
}
}
}
Verwenden Sie AIO zum Lesen und Schreiben von Dateien.
öffentliche Klasse ReadFromFile {
public static void main(String[] args) löst eine Ausnahme aus {
Path file = Paths.get("/usr/a.txt");
AsynchronousFileChannel channel = AsynchronousFileChannel.open(file);
ByteBuffer buffer = ByteBuffer.allocate(100_000);
Future<
Integer
> result =channel.read(buffer, 0);
while (!result.isDone()) {
ProfitCalculator.calculateTax();
}
Integer bytesRead = result.get();
System.out.println("Bytes read [" + bytesRead + "]");
}
}
Klasse ProfitCalculator {
öffentlicher ProfitCalculator() {
}
public static void berechneTax() {
}
}
öffentliche Klasse WriteToFile {
public static void main(String[] args) löst eine Ausnahme aus {
AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(
Paths.get("/asynchronous.txt"), StandardOpenOption.READ,
StandardOpenOption.WRITE, StandardOpenOption.CREATE);
CompletionHandler<
Integer, Object
> handler = new CompletionHandler<
Inte
ger, Object
>() {
209
>
E/A-
Fluss
@Override
public void abgeschlossen(Integer-Ergebnis, Objektanhang) {
System.out.println("Anhang: " + Anhang + " " + Ergebnis
+ " Bytes geschrieben");
System.out.println("CompletionHandler Thread ID: "
+ Thread.currentThread().getId());
}
@Override
public void failed(Throwable e, Object attachment) {
System.err.println("Anhang: " + Anhang + " fehlgeschlagen mit:");
e.printStackTrace();
}
};
System.out.println("Haupt-Thread-ID: " + Thread.currentThread().getId
());
fileChannel.write(ByteBuffer.wrap("Sample".getBytes()), 0, "First Write
",
Handler);
fileChannel.write(ByteBuffer.wrap("Box".getBytes()), 0, "Second Write",
Handler);
}
}