OI
¿Qué es IO?Se refiere a la interfaz entre una computadora y el mundo exterior, o entre un programa y el resto de la computadora.
boca. Es tan importante para cualquier sistema informático que la mayor parte de todas las E/S están integradas en el sistema operativo.
de. Los programas individuales suelen dejar que el sistema haga la mayor parte del trabajo por ellos.
En la programación Java, hasta hace poco, se utilizaban flujos para completar la E/S. Todas las E/S se tratan como una sola
Los bytes se mueven un byte a la vez a través de un objeto llamado Stream. Stream I/O se utiliza para comunicarse con el mundo exterior
tocar. También se utiliza internamente para convertir objetos a bytes y nuevamente a objetos.
BIO
Java BIO es Block I/O, IO síncrono y de bloqueo.
BIO es la implementación del código bajo el paquete tradicional java.io.
NÍO
¿Qué es NIO? NIO tiene la misma función y propósito que la E/S original. La diferencia más importante entre ellos son los datos.
El método de embalaje y transmisión. La E/S original procesa los datos en forma de flujo, mientras que NIO procesa los datos en forma de bloques.
Los sistemas de E/S orientados a flujos procesan datos un byte a la vez. Un flujo de entrada produce un byte de datos, un
El flujo de salida consume un byte de datos. Es muy fácil crear filtros para la transmisión de datos. Encadene varios filtros para que cada uno
Los filtros sólo son responsables de parte de un único mecanismo de procesamiento complejo, que es relativamente simple. En el lado negativo, orientado a la corriente
La E/S suele ser bastante lenta.
Un sistema de E/S orientado a bloques procesa datos en bloques. Cada operación se produce o consume en un solo paso.
Un bloque de datos. Procesar datos en fragmentos es mucho más rápido que procesar datos en bytes (transmisión). Pero la E/S orientada a bloques carece de
La elegancia y simplicidad de algunas E/S orientadas al flujo.
AIO
Java AIO es asíncrono sin bloqueo, que es IO asíncrono sin bloqueo.
205
>
estilo de E/S
Diferencias y conexiones
BIO (Bloqueo de E/S): modo de E/S de bloqueo sincrónico, la lectura y escritura de datos deben bloquearse en un hilo
Espere a que se complete. Aquí asumimos un escenario de agua hirviendo, con una fila de teteras hirviendo agua. El modo de funcionamiento de BIO es:
Pida a un hilo que permanezca en una tetera hasta que hierva antes de procesar la siguiente tetera. Pero en realidad el hilo
No se hizo nada mientras se esperaba que hirviera la tetera.
NIO (Nueva E/S): admite modos de bloqueo y sin bloqueo, pero aquí usamos su modo de E/S síncrono sin bloqueo
Para ilustrar, ¿qué es el no bloqueo sincrónico? Si tomamos agua hirviendo como ejemplo, el enfoque de NIO es decirle a un hilo que no
Sondee continuamente el estado de cada hervidor para ver si el estado de algún hervidor ha cambiado, para continuar con el siguiente paso.
AIO (E/S asíncrona): modelo de E/S asíncrono sin bloqueo. Áreas asincrónicas sin bloqueo y sincrónicas sin bloqueo
¿Dónde más? El no bloqueo asincrónico no requiere un hilo para sondear los cambios de estado de todas las operaciones de IO. Después de los cambios de estado correspondientes,
El sistema notificará al hilo correspondiente para que lo maneje. En correspondencia con el agua hirviendo, se instala un interruptor en cada hervidor.
Después de encenderlo, el hervidor me notificará automáticamente que el agua está hirviendo.
Escenarios aplicables para cada
El método BIO es adecuado para arquitecturas con un número relativamente pequeño y fijo de conexiones y tiene requisitos relativamente altos en cuanto a recursos del servidor.
La concurrencia se limita a las aplicaciones, la única opción antes de JDK1.4, pero el programa es intuitivo, simple y fácil de entender.
El método NIO es adecuado para arquitecturas con una gran cantidad de conexiones y conexiones relativamente cortas (operaciones livianas), como servidores de chat, concurrentes.
Limitada a aplicaciones, la programación es más complicada y JDK1.4 comienza a admitirla.
El método AIO es adecuado para arquitecturas con una gran cantidad de conexiones y conexiones relativamente largas (operaciones pesadas), como servidores de álbumes de fotos.
Llamar al sistema operativo para participar en operaciones concurrentes requiere una programación compleja y JDK7 comienza a admitirlo.
Uso
Utilice BIO para leer y escribir archivos.
//Inicializa el objeto
Usuario1 usuario = nuevo Usuario1();
usuario.setName("hollis");
usuario.setAge(23);
System.out.println(usuario);
E/
S
<
206
//Escribir objeto en el archivo
ObjectOutputStream oos = nulo;
intentar {
oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
oos.writeObject(usuario);
} captura (IOException e) {
e.printStackTrace();
} finalmente {
IOUtils.closeQuietly(oos);
}
//Leer Obj del archivo
Archivo archivo = nuevo Archivo("tempFile");
ObjectInputStream ois = nulo;
intentar {
ois = nuevo ObjectInputStream(nuevo FileInputStream(archivo));
Usuario1 nuevoUsuario = (Usuario1) ois.readObject();
System.out.println(nuevoUsuario);
} captura (IOException e) {
e.printStackTrace();
} captura (ClassNotFoundException e) {
e.printStackTrace();
} finalmente {
IOUtils.closeQuietly(ois);
intentar {
FileUtils.forceDelete(archivo);
} captura (IOException e) {
e.printStackTrace();
}
}
Utilice NIO para leer y escribir archivos.
lectura nula estáticaNIO() {
Nombre de ruta de cadena = "C:\\Users\\adew\\Desktop\\jd-gui.cfg";
FileInputStream fin = nulo;
intentar {
fin = new FileInputStream(nuevo archivo(nombre de ruta));
Canal FileChannel = fin.getChannel();
int capacidad = 100;//
bytes
ByteBuffer bf = ByteBuffer.allocate(capacidad);
System.out.println("
El límite es:
" + bf.limit() + "
La capacidad es:
" + bf.capacit
y()
+ "
La posición es:
" + bf.position());
longitud interna = -1;
mientras ((longitud = canal.leer(bf)) != -1) {
207
>
estilo de E/S
/*
*
Tenga en cuenta que después de leer, establezca la posición en
0
y
limite
la capacidad
para
prepararse para la lectura en el búfer de bytes la próxima vez.
Empezar a almacenar desde
0
*/
bf.clear();
byte[] bytes = bf.array();
System.out.write(bytes, 0, longitud);
Sistema.out.println();
System.out.println("
El límite es:
" + bf.limit() + "
La capacidad es:
" + bf.capa
ciudad()
+ "
La posición es:
" + bf.position());
}
canal.cerrar();
} captura (FileNotFoundException e) {
e.printStackTrace();
} captura (IOException e) {
e.printStackTrace();
} finalmente {
si (fin! = nulo) {
intentar {
fin.cerrar();
} captura (IOException e) {
e.printStackTrace();
}
}
}
}
escritura vacía estáticaNIO() {
Nombre de archivo de cadena = "out.txt";
FileOutputStream fos = nulo;
intentar {
fos = new FileOutputStream(nuevo archivo(nombre de archivo));
Canal FileChannel = fos.getChannel();
ByteBuffer src = Charset.forName("utf8").encode("
Hola, hola, hola, hola, tú
Aceptar
");
//
La capacidad y
el límite del búfer de bytes
cambiarán con la longitud de los datos y no son fijos.
System.out.println("
Capacidad y
límite de inicialización
:
" + src.capacity() + ","
+ src.limit());
longitud entera = 0;
mientras ((longitud = canal.write(src)) != 0) {
/*
* Tenga en cuenta que no es necesario
borrar
aquí
. Escriba los datos del búfer en el canal por segunda vez y continúe la vez anterior.
Leer el pedido
*/
E/S
流
<
208
System.out.println ("
Longitud de escritura
:" + longitud);
}
} captura (FileNotFoundException e) {
e.printStackTrace();
} captura (IOException e) {
e.printStackTrace();
} finalmente {
si (fos != nulo) {
intentar {
fos.cerrar();
} captura (IOException e) {
e.printStackTrace();
}
}
}
}
Utilice AIO para leer y escribir archivos.
clase pública ReadFromFile {
public static void main (String [] args) lanza una excepción {
Archivo de ruta = Paths.get("/usr/a.txt");
Canal AsynchronousFileChannel = AsynchronousFileChannel.open(archivo);
Búfer ByteBuffer = ByteBuffer.allocate(100_000);
Futuro<Entero>
resultado
= canal.read(buffer, 0);
mientras (!resultado.isDone()) {
ProfitCalculator.calculateTax();
}
BytesRead entero = resultado.get();
System.out.println("Bytes leídos [" + bytesRead + "]");
}
}
clase Calculadora de beneficios {
Calculadora de beneficios pública() {
}
public static void calcularTax() {
}
}
clase pública WriteToFile {
public static void main (String [] args) lanza una excepción {
AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(
Paths.get("/asynchronous.txt"), StandardOpenOption.READ,
StandardOpenOption.WRITE, StandardOpenOption.CREATE);
CompletionHandler<
Entero, Objeto
> controlador = nuevo CompletionHandler<
Inte
ger, Objeto
>() {
209
>
estilo de E/S
@Anular
vacío público completado (resultado entero, objeto adjunto) {
System.out.println("Adjunto: " + archivo adjunto + " " + resultado
+ "bytes escritos");
System.out.println("ID de subproceso de CompletionHandler: "
+ Thread.currentThread().getId());
}
@Anular
Error de vacío público (e arrojable, archivo adjunto de objeto) {
System.err.println("El archivo adjunto: " + archivo adjunto + " falló con:");
e.printStackTrace();
}
};
System.out.println("ID del hilo principal: " + Thread.currentThread().getId
());
fileChannel.write(ByteBuffer.wrap("Muestra".getBytes()), 0, "Primera escritura
",
manipulador);
fileChannel.write(ByteBuffer.wrap("Box".getBytes()), 0, "Segunda escritura",
manipulador);
}
}