그림과 텍스트를 통해 Java I/O 작업 및 최적화에 대한 자세한 소개

이 글은 주로 Java I/O 연산 및 최적화 관련 정보를 자세하게 소개하고 있습니다. 필요한 친구는 다음

요약을 참고하세요.

스트림 시작점과 끝점이 있는 연속 바이트 집합은 데이터 전송에 대한 일반적인 용어 또는 추상화입니다. 즉, 두 장치 간의 데이터 전송을 스트림이라고 합니다. 스트림의 본질은 데이터 전송 특성에 따라 스트림을 다양한 범주로 추상화하여 보다 직관적인 데이터 작업을 가능하게 합니다.

Java I/O

I/O, 입출력(Input/Output)의 약자. I/O에 관한 한 개념적으로 5가지 모델이 있습니다: 차단 I/O, 비차단 I/O, I/O 다중화(선택 및 폴링), 신호 구동 I/O(SIGIO), 비동기 I/O( POSIX aio_functions). 운영 체제마다 위 모델을 지원하는 방식이 다르며 UNIX에서는 IO 멀티플렉싱을 지원합니다. 시스템마다 이름이 다릅니다. FreeBSD에서는 kqueue라고 하고, Linux에서는 epoll이라고 합니다. IOCP는 비동기 I/O를 지원하기 위해 Windows 2000에서 탄생했습니다.

Java는 비동기 I/O를 지원하기 위해 Java1.4에서 도입된 NIO1.0이 ​​탄생했으며 I/O 재사용을 기반으로 합니다. 각 플랫폼의 재사용 방법. Linux는 epoll을 사용하고 BSD는 kqueue를 사용하며 Windows는 겹쳐진 I/O를 사용합니다.

Java I/O 관련 방법은 다음과 같습니다.

동기화 및 차단(I/O 방법): 서버 구현 모드에서 연결을 위한 스레드를 시작합니다. , 스레드가 I/O를 개인적으로 처리하고 완료될 때까지 I/O를 기다립니다. 즉, 클라이언트가 연결 요청을 받으면 서버는 처리를 위해 스레드를 시작해야 합니다. 그러나 이 연결이 아무 작업도 수행하지 않으면 불필요한 스레드 오버헤드가 발생합니다. 물론 이 단점은 스레드 풀 메커니즘을 통해 개선될 수 있습니다. I/O의 한계는 스트림 지향, 차단 및 직렬 프로세스라는 것입니다. 각 클라이언트의 소켓 연결 I/O에는 처리할 스레드가 필요하며, 이 기간 동안 소켓이 닫힐 때까지 이 스레드가 점유됩니다. 이 기간 동안에는 TCP 연결, 데이터 읽기, 데이터 반환이 모두 차단됩니다. 즉, 이 기간 동안 스레드가 차지하는 많은 CPU 시간 조각과 메모리 자원이 낭비되었습니다. 또한, 소켓 연결이 설정될 때마다 새로운 스레드가 생성되어 소켓과 별도로 통신합니다(차단 통신 사용). 이 방식은 응답속도가 빠르고 제어가 용이하다. 연결 수가 적을 때 매우 효과적이지만 연결마다 스레드를 생성하는 것은 의심할 여지없이 시스템 리소스를 낭비합니다.

동기식 비차단(NIO 방식): 서버 구현 모드에서는 요청에 대한 스레드를 시작하고 각 스레드는 I/O를 개인적으로 처리하지만 다른 스레드는 I/O를 기다리지 않고 I/O가 준비되었는지 확인하기 위해 폴링합니다. O 완료. 즉, 클라이언트가 보낸 연결 요청이 멀티플렉서에 등록되고, 멀티플렉서는 연결에 대한 I/O 요청이 있을 때만 처리를 위해 스레드를 시작합니다. NIO는 버퍼 지향적이고 비차단적이며 선택기 기반입니다. 스레드를 사용하여 여러 데이터 전송 채널을 폴링하고 모니터링합니다. 어떤 채널이 준비되었는지(즉, 처리할 수 있는 데이터 집합이 있는지) 처리됩니다. . 서버는 소켓 연결 목록을 저장한 후 이 목록을 폴링하여 특정 소켓 포트에 읽을 데이터가 있는 것으로 확인되면 해당 소켓 연결의 읽기 작업을 호출합니다. 특정 소켓 포트에 쓰기 위해 소켓 연결의 해당 쓰기 작업이 호출됩니다. 특정 포트의 소켓 연결이 중단되면 해당 소멸자 메서드가 호출되어 포트를 닫습니다. 이는 서버 리소스를 최대한 활용하고 효율성을 크게 향상시킬 수 있습니다.

비동기 비차단(AIO 방식, JDK7 릴리스): 서버 구현 모드는 유효한 요청에 대해 스레드를 시작하고 클라이언트의 I /O 요청 운영 체제는 이를 먼저 완료한 다음 처리를 위해 스레드를 시작하도록 서버 응용 프로그램에 알립니다. 각 스레드는 I/O를 개인적으로 처리할 필요가 없고 이를 운영 체제에 위임하므로 기다릴 필요가 없습니다. 작업이 완료되면 시스템에서 나중에 알려줍니다. 이 모드는 Linux의 epoll 모델을 사용합니다.

연결 수가 적을 때는 기존 I/O 모드가 작성하기 쉽고 사용이 더 간단합니다. 그러나 연결 수가 계속 증가함에 따라 기존 I/O 처리에는 연결당 하나의 스레드가 필요합니다. 스레드 수가 적을 때는 스레드 수가 증가할수록 프로그램의 효율성이 높아집니다. , 스레드 수가 증가함에 따라 감소합니다. 따라서 기존 차단 I/O의 병목 현상은 너무 많은 연결을 처리할 수 없다는 것입니다. 비차단 I/O의 목적은 이러한 병목 현상을 해결하는 것입니다. 비차단 IO 처리 연결을 위한 스레드 수와 연결 수 사이에는 연결이 없습니다. 예를 들어 시스템이 10,000개의 연결을 처리하는 경우 비차단 I/O는 10,000개의 스레드를 시작할 필요가 없습니다. 또는 처리를 위한 2,000개의 스레드. 비차단 IO는 연결을 비동기적으로 처리하기 때문에 연결이 서버에 요청을 보내면 서버는 연결 요청을 요청 "이벤트"로 처리하고 이 "이벤트"를 해당 기능에 할당하여 처리합니다. 이 처리 함수를 실행을 위해 스레드에 넣고 실행 후 스레드를 반환하여 하나의 스레드가 여러 이벤트를 비동기적으로 처리할 수 있습니다. 차단 I/O 스레드는 요청을 기다리는 데 대부분의 시간을 소비합니다.

Java NIO

Java.nio 패키지는 Java 1.4 버전 이후에 추가된 새로운 패키지로, 특히 I/O 작업의 효율성을 향상시키는 데 사용됩니다.

표 1은 I/O와 NIO의 비교를 보여줍니다.

표 1. I/O VS NIO

I/O	NIO
面向流	面向缓冲
阻塞 IO	非阻塞 IO
无	选择器

NIO는 블록 기반으로 데이터를 블록 단위로 처리하는 기본 단위입니다. NIO에서 가장 중요한 두 가지 구성 요소는 버퍼와 채널입니다. 버퍼는 연속적인 메모리 블록이며 NIO가 데이터를 읽고 쓰는 전송 장소입니다. 채널은 버퍼링된 데이터의 소스 또는 대상을 식별하며 버퍼에 데이터를 읽거나 쓰는 데 사용되며 버퍼에 액세스하기 위한 인터페이스입니다. 채널은 읽거나 쓸 수 있는 양방향 채널입니다. 스트림은 단방향입니다. 애플리케이션은 채널을 직접 읽고 쓸 수 없지만 버퍼를 통해 이를 수행해야 합니다. 즉, 채널은 버퍼를 통해 데이터를 읽고 씁니다.

버퍼를 사용하여 데이터를 읽고 쓰는 작업은 일반적으로 다음 네 단계를 따릅니다.

1. 버퍼에 데이터 쓰기

2. 호출 Flip() 메서드;

3. 는 Buffer에서 데이터를 읽습니다.

4. 은clear() 메서드 또는 Compact() 메서드를 호출합니다.
   

버퍼에 데이터가 기록되면 버퍼는 얼마나 많은 데이터가 기록되는지 기록합니다. 데이터를 읽으려면 Flip() 메서드를 통해 버퍼를 쓰기 모드에서 읽기 모드로 전환해야 합니다. 읽기 모드에서는 이전에 버퍼에 기록된 모든 데이터를 읽을 수 있습니다.

모든 데이터를 읽은 후에는 다시 쓸 수 있도록 버퍼를 지워야 합니다. 버퍼를 지우는 방법에는 두 가지가 있습니다. 즉,clear() 또는 Compact() 메서드를 호출하는 것입니다. Clear() 메서드는 전체 버퍼를 지웁니다. Compact() 메서드는 이미 읽은 데이터만 지웁니다. 읽지 않은 데이터는 버퍼의 시작 부분으로 이동되고 새로 작성된 데이터는 버퍼에서 읽지 않은 데이터 뒤에 배치됩니다.

버퍼에는 다양한 유형이 있으며, 다양한 버퍼는 버퍼의 데이터를 작동하는 다양한 방법을 제공합니다.

그림 1 버퍼 인터페이스 계층 다이어그램

버퍼가 데이터를 쓰는 경우는 두 가지 상황이 있습니다.

1. 채널에서 버퍼로 쓰기 예를 들어, 채널은 파일에서 데이터를 읽고 이를 채널에 씁니다.

2. 은 데이터를 쓰기 위해 put 메소드를 직접 호출합니다.

버퍼에서 데이터를 읽는 방법에는 두 가지가 있습니다.

1. 버퍼에서 채널로 데이터 읽기

2. 버퍼에서 데이터를 읽으려면 get() 메서드를 사용하세요.

Buffer의 rewin 방식은 위치를 다시 0으로 설정하므로 Buffer에 있는 모든 데이터를 다시 읽을 수 있습니다. 제한은 변경되지 않고 여전히 버퍼에서 읽을 수 있는 요소(바이트, 문자 등) 수를 나타냅니다.

clear() 및 Compact() 메소드

버퍼의 데이터를 읽고 나면 버퍼를 다시 쓸 준비가 되어야 합니다. 이는clear() 또는 Compact() 메소드를 통해 수행될 수 있습니다.

clear() 메소드가 호출되면 위치는 다시 0으로 설정되고 제한은 용량 값으로 설정됩니다. 즉, 버퍼가 지워집니다. 버퍼의 데이터는 지워지지 않지만 이러한 표시는 버퍼에 데이터 쓰기를 시작할 위치를 알려줍니다.

버퍼에 읽지 않은 데이터가 있는 경우 Clear() 메서드를 호출하면 데이터가 "잊혀집니다". 그렇지 않았습니다. 버퍼에 아직 읽지 않은 데이터가 있고 해당 데이터가 나중에 필요하지만 일부 데이터를 먼저 쓰고 싶다면 Compact() 메서드를 사용하십시오. Compact() 메서드는 읽지 않은 모든 데이터를 버퍼의 시작 부분에 복사합니다. 그런 다음 읽지 않은 마지막 요소 바로 뒤에 위치를 설정합니다. Clear() 메소드와 마찬가지로 Limit 속성은 여전히 ​​용량으로 설정됩니다. 이제 버퍼에 데이터를 쓸 준비가 되었지만 읽지 않은 데이터는 덮어쓰지 않습니다.

버퍼 매개변수

버퍼에는 세 가지 중요한 매개변수인 위치, 용량 및 제한이 있습니다.

용량은 Buffer 생성 시 결정되는 Buffer의 크기를 의미합니다.

limit 버퍼가 쓰기 모드일 때 쓸 수 있는 데이터의 양을 나타내고, 읽기 모드일 때 읽을 수 있는 데이터의 양을 나타냅니다.

위치 버퍼가 쓰기 모드일 때, 읽기 모드에서는 다음에 쓸 데이터의 위치를 ​​나타내며, 현재 읽을 데이터의 위치를 ​​나타냅니다. 데이터를 읽거나 쓸 때마다 position+1, 즉 Limit과 position은 Buffer를 읽고 쓸 때 의미가 달라집니다. Buffer의 Flip 메소드를 호출하여 쓰기 모드에서 읽기 모드로 변경 시 제한(읽기) = 위치(쓰기), 위치(읽기) = 0이 됩니다.

분산 및 집계

NIO는 분산 및 수집이라는 구조화된 데이터를 처리하는 방법을 제공합니다. 분산이란 데이터를 하나의 버퍼가 아닌 일련의 버퍼로 읽는 것을 의미합니다. 반면 집계는 데이터를 버퍼 세트에 기록합니다. 분산 및 집계의 기본 사용법은 단일 버퍼에서 작동할 때의 사용법과 매우 유사합니다. 분산형 읽기에서는 채널이 각 버퍼를 차례로 채웁니다. 하나의 버퍼가 채워지면 다음 버퍼도 채우기 시작합니다. 어떤 의미에서 버퍼 배열은 하나의 큰 버퍼와 같습니다. 파일의 특정 구조가 알려지면 파일 구조에 맞는 여러 버퍼를 구성할 수 있으므로 각 버퍼의 크기는 파일의 각 세그먼트 구조 크기와 정확히 일치합니다. 이때, 분산 판독을 통해 콘텐츠를 해당하는 각 Buffer에 한번에 모아둘 수 있어 작업이 단순화됩니다. 지정된 형식으로 파일을 생성해야 하는 경우 먼저 적절한 크기의 Buffer 객체를 생성하고 Aggregate Write 방식을 사용하면 파일을 빠르게 생성할 수 있습니다. 목록 1에서는 FileChannel을 예로 사용하여 분산 및 수집을 사용하여 구조화된 파일을 읽고 쓰는 방법을 보여줍니다.

목록 1. 분산 및 수집을 사용하여 구조화된 파일 읽기 및 쓰기

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

public class NIOScatteringandGathering {
 public void createFiles(String TPATH){
 try {
 ByteBuffer bookBuf = ByteBuffer.wrap("java 性能优化技巧".getBytes("utf-8"));
ByteBuffer autBuf = ByteBuffer.wrap("test".getBytes("utf-8"));
int booklen = bookBuf.limit();
int autlen = autBuf.limit();
ByteBuffer[] bufs = new ByteBuffer[]{bookBuf,autBuf};
File file = new File(TPATH);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
try {
FileOutputStream fos = new FileOutputStream(file);
FileChannel fc = fos.getChannel();
fc.write(bufs);
fos.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

ByteBuffer b1 = ByteBuffer.allocate(booklen);
ByteBuffer b2 = ByteBuffer.allocate(autlen);
ByteBuffer[] bufs1 = new ByteBuffer[]{b1,b2};
File file1 = new File(TPATH);
try {
FileInputStream fis = new FileInputStream(file);
FileChannel fc = fis.getChannel();
fc.read(bufs1);
String bookname = new String(bufs1[0].array(),"utf-8");
String autname = new String(bufs1[1].array(),"utf-8");
System.out.println(bookname+" "+autname);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

 }

 public static void main(String[] args){
 NIOScatteringandGathering nio = new NIOScatteringandGathering();
 nio.createFiles("C://1.TXT");
 }
}

출력은 아래 목록 2에 표시됩니다.

목록 2. 실행 결과

java 性能优化技巧 test

목록 3에 표시된 코드는 기존 I/O, 바이트 기반 NIO용입니다. , 그리고 시간이 많이 걸리는 400만 개의 데이터가 있는 파일의 읽기 및 쓰기 작업을 평가 기준으로 사용하여 세 가지 메모리 매핑 NIO 방법의 성능을 비교했습니다.

목록 3. 세 가지 I/O 방법 비교 테스트

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class NIOComparator {
 public void IOMethod(String TPATH){
 long start = System.currentTimeMillis();
 try {
DataOutputStream dos = new DataOutputStream(
 new BufferedOutputStream(new FileOutputStream(new File(TPATH))));
for(int i=0;i<4000000;i++){
dos.writeInt(i);//写入 4000000 个整数
}
if(dos!=null){
dos.close();
}
 } catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
 } catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
 }
 long end = System.currentTimeMillis();
 System.out.println(end - start);
 start = System.currentTimeMillis();
 try {
DataInputStream dis = new DataInputStream(
 new BufferedInputStream(new FileInputStream(new File(TPATH))));
for(int i=0;i<4000000;i++){
dis.readInt();
}
if(dis!=null){
dis.close();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

 end = System.currentTimeMillis();
 System.out.println(end - start);
 }

 public void ByteMethod(String TPATH){
 long start = System.currentTimeMillis();
 try {
FileOutputStream fout = new FileOutputStream(new File(TPATH));
FileChannel fc = fout.getChannel();//得到文件通道
ByteBuffer byteBuffer = ByteBuffer.allocate(4000000*4);//分配 Buffer
for(int i=0;i<4000000;i++){
byteBuffer.put(int2byte(i));//将整数转为数组
}
byteBuffer.flip();//准备写
fc.write(byteBuffer);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 long end = System.currentTimeMillis();
 System.out.println(end - start);

 start = System.currentTimeMillis();
 FileInputStream fin;
try {
fin = new FileInputStream(new File(TPATH));
FileChannel fc = fin.getChannel();//取得文件通道
ByteBuffer byteBuffer = ByteBuffer.allocate(4000000*4);//分配 Buffer
fc.read(byteBuffer);//读取文件数据
fc.close();
byteBuffer.flip();//准备读取数据
while(byteBuffer.hasRemaining()){
byte2int(byteBuffer.get(),byteBuffer.get(),byteBuffer.get(),byteBuffer.get());//将 byte 转为整数
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 end = System.currentTimeMillis();
 System.out.println(end - start);
 }

 public void mapMethod(String TPATH){
 long start = System.currentTimeMillis();
 //将文件直接映射到内存的方法
 try {
FileChannel fc = new RandomAccessFile(TPATH,"rw").getChannel();
IntBuffer ib = fc.map(FileChannel.MapMode.READ_WRITE, 0, 4000000*4).asIntBuffer();
for(int i=0;i<4000000;i++){
ib.put(i);
}
if(fc!=null){
fc.close();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 long end = System.currentTimeMillis();
 System.out.println(end - start);

 start = System.currentTimeMillis();
 try {
FileChannel fc = new FileInputStream(TPATH).getChannel();
MappedByteBuffer lib = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
lib.asIntBuffer();
while(lib.hasRemaining()){
lib.get();
}
if(fc!=null){
fc.close();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 end = System.currentTimeMillis();
 System.out.println(end - start);

 }

 public static byte[] int2byte(int res){
 byte[] targets = new byte[4];
 targets[3] = (byte)(res & 0xff);//最低位
 targets[2] = (byte)((res>>8)&0xff);//次低位
 targets[1] = (byte)((res>>16)&0xff);//次高位
 targets[0] = (byte)((res>>>24));//最高位，无符号右移
 return targets;
 }

 public static int byte2int(byte b1,byte b2,byte b3,byte b4){
 return ((b1 & 0xff)<<24)|((b2 & 0xff)<<16)|((b3 & 0xff)<<8)|(b4 & 0xff);
 }

 public static void main(String[] args){
 NIOComparator nio = new NIOComparator();
 nio.IOMethod("c://1.txt");
 nio.ByteMethod("c://2.txt");
 nio.ByteMethod("c://3.txt");
 }
}

목록 3의 실행 출력은 목록에 표시됩니다. 4.

목록 4. 출력 실행

1139
906
296
157
234
125

위의 설명과 목록 3에 표시된 코드 외에도 NIO의 버퍼는 시스템의 물리적 메모리에 직접 액세스할 수 있는 DirectBuffer 클래스를 제공합니다. DirectBuffer는 ByteBuffer를 상속하지만 일반 ByteBuffer와는 다릅니다. 일반 ByteBuffer는 여전히 JVM 힙에 공간을 할당하고 최대 메모리는 최대 힙에 의해 제한되는 반면 DirectBuffer는 물리적 메모리에 직접 할당되며 힙 공간을 차지하지 않습니다. 일반 ByteBuffer에 액세스할 때 시스템은 항상 간접 작업을 위해 "커널 버퍼"를 사용합니다. DirectrBuffer의 위치는 이 "커널 버퍼"와 동일합니다. 따라서 DirectBuffer를 사용하는 것은 기본 시스템에 더 가까운 방법이므로 일반 ByteBuffer보다 빠릅니다. ByteBuffer에 비해 DirectBuffer는 읽기 및 쓰기 액세스 속도가 훨씬 빠르지만 DirectrBuffer를 생성하고 삭제하는 비용이 ByteBuffer보다 높습니다. DirectBuffer와 ByteBuffer를 비교하는 코드는 목록 5에 표시됩니다.

목록 5. DirectBuffer VS ByteBuffer

import java.nio.ByteBuffer;

public class DirectBuffervsByteBuffer {
 public void DirectBufferPerform(){
 long start = System.currentTimeMillis();
 ByteBuffer bb = ByteBuffer.allocateDirect(500);//分配 DirectBuffer
 for(int i=0;i<100000;i++){
 for(int j=0;j<99;j++){
 bb.putInt(j);
 }
 bb.flip();
 for(int j=0;j<99;j++){
 bb.getInt(j);
 }
 }
 bb.clear();
 long end = System.currentTimeMillis();
 System.out.println(end-start);
 start = System.currentTimeMillis();
 for(int i=0;i<20000;i++){
 ByteBuffer b = ByteBuffer.allocateDirect(10000);//创建 DirectBuffer
 }
 end = System.currentTimeMillis();
 System.out.println(end-start);
 }

 public void ByteBufferPerform(){
 long start = System.currentTimeMillis();
 ByteBuffer bb = ByteBuffer.allocate(500);//分配 DirectBuffer
 for(int i=0;i<100000;i++){
 for(int j=0;j<99;j++){
 bb.putInt(j);
 }
 bb.flip();
 for(int j=0;j<99;j++){
 bb.getInt(j);
 }
 }
 bb.clear();
 long end = System.currentTimeMillis();
 System.out.println(end-start);
 start = System.currentTimeMillis();
 for(int i=0;i<20000;i++){
 ByteBuffer b = ByteBuffer.allocate(10000);//创建 ByteBuffer
 }
 end = System.currentTimeMillis();
 System.out.println(end-start);
 }

 public static void main(String[] args){
 DirectBuffervsByteBuffer db = new DirectBuffervsByteBuffer();
 db.ByteBufferPerform();
 db.DirectBufferPerform();
 }
}

실행 출력은 목록 6에 표시됩니다.

목록 6. 출력 실행

920
110
531
390

목록 6에서 볼 수 있듯이 DirectBuffer를 자주 생성하고 삭제하는 데 드는 비용은 다음과 같습니다. 힙에 DirectBuffer를 생성하고 파괴하는 것보다 훨씬 더 큰 메모리 공간을 할당합니다. -XX:MaxDirectMemorySize=200M –Xmx200M 매개 변수를 사용하여 VM 인수에서 최대 DirectBuffer 및 최대 힙 공간을 구성합니다. 코드는 설정된 힙 공간이 너무 작으면(예: 1M) 오류가 발생합니다. Listing 7에 표시된 대로.

목록 7. 실행 오류

Error occurred during initialization of VM
Too small initial heap for new size specified

GC는 힙 공간만 기록하므로 DirectBuffer 정보는 GC에 인쇄되지 않습니다. 메모리 재활용. ByteBuffer는 힙에 공간을 할당하기 때문에 GC 배열이 상대적으로 빈번하다는 것을 알 수 있습니다. Buffer를 자주 생성해야 하는 상황에서는 DirectBuffer를 생성하고 소멸하는 코드가 상대적으로 비싸기 때문에 DirectBuffer를 사용해서는 안 됩니다. 그러나 DirectBuffer를 재사용할 수 있다면 시스템 성능이 크게 향상될 수 있습니다. 목록 8은 DirectBuffer를 모니터링하기 위한 코드 조각입니다.

목록 8. DirectBuffer 모니터링 코드 실행

import java.lang.reflect.Field;

public class monDirectBuffer {

public static void main(String[] args){
try {
Class c = Class.forName("java.nio.Bits");//通过反射取得私有数据
Field maxMemory = c.getDeclaredField("maxMemory");
maxMemory.setAccessible(true);
Field reservedMemory = c.getDeclaredField("reservedMemory");
reservedMemory.setAccessible(true);
synchronized(c){
Long maxMemoryValue = (Long)maxMemory.get(null);
Long reservedMemoryValue = (Long)reservedMemory.get(null);
System.out.println("maxMemoryValue="+maxMemoryValue);
System.out.println("reservedMemoryValue="+reservedMemoryValue);
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

는 목록 9에 표시됩니다.

목록 9. 출력 실행

maxMemoryValue=67108864
reservedMemoryValue=0

NIO는 사용하기 어렵기 때문에 많은 회사에서 자체 JDK NIO 패키지를 출시했습니다. Apache의 Mina, JBoss의 Netty, Sun의 Grizzly 등과 같은 프레임워크는 전송 계층의 TCP 또는 UDP 프로토콜을 직접 캡슐화하며, 그중 Netty는 NIO 프레임워크일 뿐이므로 웹 컨테이너의 추가 지원이 필요하지 않습니다. 즉, 웹 컨테이너는 제한되지 않습니다.

Java AIO

AIO 관련 클래스 및 인터페이스:

java.nio.channels.AsynchronousChannel：标记一个 Channel 支持异步 IO 操作；
java.nio.channels.AsynchronousServerSocketChannel：ServerSocket 的 AIO 版本，创建 TCP 服务端，绑定地址，监听端口等；
java.nio.channels.AsynchronousSocketChannel：面向流的异步 Socket Channel，表示一个连接；
java.nio.channels.AsynchronousChannelGroup：异步 Channel 的分组管理，目的是为了资源共享。
一个 AsynchronousChannelGroup 绑定一个线程池，这个线程池执行两个任务：处理 IO 事件和派发 CompletionHandler。AsynchronousServerSocketChannel 
创建的时候可以传入一个 AsynchronousChannelGroup，那么通过 AsynchronousServerSocketChannel 创建的 AsynchronousSocketChannel 将同属于一个组，共享资源；
java.nio.channels.CompletionHandler：异步 IO 操作结果的回调接口，用于定义在 IO 操作完成后所作的回调工作。
AIO 的 API 允许两种方式来处理异步操作的结果：返回的 Future 模式或者注册 CompletionHandler，推荐用 CompletionHandler 的方式，
这些 handler 的调用是由 AsynchronousChannelGroup 的线程池派发的。这里线程池的大小是性能的关键因素。

AIO를 간략하게 소개하는 프로그램 예제입니다. 공장.

목록 10. 서버 프로그램

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutionException;

public class SimpleServer {
public SimpleServer(int port) throws IOException { 
final AsynchronousServerSocketChannel listener = 
 AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(port));
//监听消息，收到后启动 Handle 处理模块
listener.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
public void completed(AsynchronousSocketChannel ch, Void att) { 
listener.accept(null, this);// 接受下一个连接 
handle(ch);// 处理当前连接 
}

@Override
public void failed(Throwable exc, Void attachment) {
// TODO Auto-generated method stub

} 

});
}

public void handle(AsynchronousSocketChannel ch) { 
ByteBuffer byteBuffer = ByteBuffer.allocate(32);//开一个 Buffer 
try { 
 ch.read(byteBuffer).get();//读取输入 
} catch (InterruptedException e) { 
 // TODO Auto-generated catch block 
 e.printStackTrace(); 
} catch (ExecutionException e) { 
 // TODO Auto-generated catch block 
 e.printStackTrace(); 
} 
byteBuffer.flip(); 
System.out.println(byteBuffer.get()); 
// Do something 
} 

}

목록 11. 클라이언트 프로그램

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class SimpleClientClass {
private AsynchronousSocketChannel client; 
public SimpleClientClass(String host, int port) throws IOException, 
         InterruptedException, ExecutionException { 
 this.client = AsynchronousSocketChannel.open(); 
 Future<?> future = client.connect(new InetSocketAddress(host, port)); 
 future.get(); 
} 

public void write(byte b) { 
 ByteBuffer byteBuffer = ByteBuffer.allocate(32);
 System.out.println("byteBuffer="+byteBuffer);
 byteBuffer.put(b);//向 buffer 写入读取到的字符 
 byteBuffer.flip();
 System.out.println("byteBuffer="+byteBuffer);
 client.write(byteBuffer); 
} 

}

목록 12.주요 기능

import java.io.IOException;
import java.util.concurrent.ExecutionException;

import org.junit.Test;

public class AIODemoTest {

@Test
public void testServer() throws IOException, InterruptedException { 
 SimpleServer server = new SimpleServer(9021); 
 Thread.sleep(10000);//由于是异步操作，所以睡眠一定时间，以免程序很快结束
} 

@Test 
public void testClient() throws IOException, InterruptedException, ExecutionException { 
SimpleClientClass client = new SimpleClientClass("localhost", 9021); 
 client.write((byte) 11); 
}

public static void main(String[] args){
AIODemoTest demoTest = new AIODemoTest();
try {
demoTest.testServer();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
demoTest.testClient();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

다음 기사에 소스를 소개하는 글이 게재될 예정입니다. AIO 세부정보 코드, 디자인 컨셉, 디자인 패턴 등

결론

I/O와 NIO의 중요한 차이점은 I/O를 사용할 때 멀티스레딩을 도입하는 경우가 많다는 것입니다. 각 연결은 별도의 스레드를 사용하는 반면 NIO는 단일 스레드 또는 소수의 멀티스레드만 사용합니다. . , 각 연결은 하나의 스레드를 공유합니다. NIO의 비차단 특성에는 시스템 리소스를 소비하는 지속적인 폴링이 필요하므로 비동기식 비차단 모드 AIO가 탄생했습니다. 이 글에서는 I/O, NIO, AIO 등 세 가지 입출력 동작 모드를 하나씩 소개하고, 간단한 설명과 예시를 통해 독자들이 기본적인 동작과 최적화 방법을 익힐 수 있도록 노력하고 있다.

위 내용은 Java I/O 연산과 최적화에 대해 사진과 글로 자세히 소개한 내용입니다. 더 많은 관련 내용은 PHP 중국어 홈페이지(www.php.cn)를 참고해주세요!