阻塞(Block)
非阻塞(Non-Block)
IO类型
同步异步针对请求,阻塞非阻塞针对客户端
客户端发送求情之后,一直等待服务端响应,客户端阻塞,请求,同步
public class BIOServer {
ServerSocket server;
public BIOServer(int port){
try {
server = new ServerSocket(port);
System.out.println("BIO服务已启动,监听端口是:" + port);
} catch (IOException e) {
e.printStackTrace();
}
}
public void listen() throws IOException{
while(true){
Socket client = server.accept();
System.out.println(client.getPort());
InputStream is = client.getInputStream();
byte [] buff = new byte[1024];
int len = is.read(buff);
if(len > 0){
String msg = new String(buff,0,len);
System.out.println("收到" + msg);
}
}
}
public static void main(String[] args) throws IOException {
new BIOServer(8080).listen();
}
public class BIOClient {
public static void main(String[] args) throws UnknownHostException, IOException {
Socket client = new Socket("localhost", 8080);
OutputStream os = client.getOutputStream();
String name = UUID.randomUUID().toString();
System.out.println("客户端发送数据:" + name);
os.write(name.getBytes());
os.close();
client.close();
}
}
客户端发送求情之后,时不时过来检查服务端响应,客户端非阻塞,请求,同步
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
public class NIOServerDemo {
private int port = 8080;
private Selector selector;
private ByteBuffer buffer = ByteBuffer.allocate(1024);
public NIOServerDemo(int port) {
try {
this.port = port;
ServerSocketChannel server = ServerSocketChannel.open();
server.bind(new InetSocketAddress(this.port));
server.configureBlocking(false);
selector = Selector.open();
server.register(selector, SelectionKey.OP_ACCEPT);
} catch (Exception e) {
e.printStackTrace();
}
}
public void listen() {
System.out.println("listen on " + this.port + ".");
try {
while (true) {
selector.select();
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> iter = keys.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
iter.remove();
process(key);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
private void process(SelectionKey key) throws IOException {
if (key.isAcceptable()) {
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel channel = server.accept();
channel.configureBlocking(false);
key = channel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
SocketChannel channel = (SocketChannel) key.channel();
int len = channel.read(buffer);
if (len > 0) {
buffer.flip();
String content = new String(buffer.array(), 0, len);
key = channel.register(selector, SelectionKey.OP_WRITE);
key.attach(content);
System.out.println("读取内容:" + content);
}
} else if (key.isWritable()) {
SocketChannel channel = (SocketChannel) key.channel();
String content = (String) key.attachment();
channel.write(ByteBuffer.wrap(("输出:" + content).getBytes()));
channel.close();
}
}
public static void main(String[] args) {
new NIOServerDemo(8080).listen();
}
}
操作系统的性能决定AIO的性能
客户端发送请求之后,去做别的事,等服务端给出响应之后,再过来处理业务逻辑