1、BIO
当并发量大时,BIO程序不支持
(1) 原生
package Thread;
import com.sun.security.ntlm.Server;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
//BIO程序
public class SocketServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9000);
while (true){
System.out.println("等待连接");
Socket clientSocket = serverSocket.accept();
System.out.println("有客户端连接了。。");
handler(clientSocket);
}
}
private static void handler(Socket clientSocket) throws IOException {
byte[] bytes = new byte[1024];
System.out.println("准备read。。");
int read = clientSocket.getInputStream().read(bytes);
System.out.println("read完毕。。");
if (read != -1) {
System.out.println("接收到客户端的数据: " + new String(bytes, 0, read));
}
}
}
(2)改造后 稍微优化一些
package Thread;
import com.sun.security.ntlm.Server;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
//BIO程序
public class SocketServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9000);
while (true){
System.out.println("等待连接");
//阻塞方法
Socket clientSocket = serverSocket.accept();
System.out.println("有客户端连接了。。");
//用子线程去处理 可以适当缓解并发,当连接量大时,CPU会100%
new Thread(new Runnable() {
@Override
public void run() {
try {
handler(clientSocket);
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
}
}
private static void handler(Socket clientSocket) throws IOException {
byte[] bytes = new byte[1024];
System.out.println("准备read。。");
int read = clientSocket.getInputStream().read(bytes);
System.out.println("read完毕。。");
if (read != -1) {
System.out.println("接收到客户端的数据: " + new String(bytes, 0, read));
}
}
}
(3)用线程池再次优化后,并发量控制在500,性能依然较低。这是BIO天然劣势,jdk优化后,使用NIO实现
2、NIO
NIO程序底层架构图
(1) 入门版本的NIO
redis单线程实现高并发,大概原理跟这个类似 详见以下代码
package Thread;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class NioServer {
//保持客户端连接
static List<SocketChannel> channelList = new ArrayList<>();
public static void main(String[] args) throws IOException {
//创建NIO ServerSocketChannel,与BIO的serverSocket类似
ServerSocketChannel serverSocket = ServerSocketChannel.open();
//绑定端口
serverSocket.socket().bind(new InetSocketAddress(9000));
//设置ServerSocketChannel为非阻塞
serverSocket.configureBlocking(false);
System.out.println("服务启动成功");
while (true){
//非阻塞模式accept方法不会阻塞,否则会阻塞
//NIO的非阻塞是由操作系统内部实现的,底层调用了Linux内核的accept函数
SocketChannel socketChannel = serverSocket.accept();
if (serverSocket != null) {
System.out.println("连接成功"); //如果有客户端连接
//设置SocketChannel为非租塞
socketChannel.configureBlocking(false);
//保存客户端连接在list中
channelList.add(socketChannel);
}
//遍历连接进行数据读取
Iterator<SocketChannel> iterator = channelList.iterator();
while (iterator.hasNext()){
SocketChannel sc = iterator.next();
ByteBuffer byteBuffer = ByteBuffer.allocate(128);
//非租塞模式read方法不会阻塞,否则回阻塞
int len = sc.read(byteBuffer);
//如果有数据,把数据打印出来
if (len > 0) {
System.out.println("接收到消息: " + new String(byteBuffer.array()));
} else if (len == -1) {
iterator.remove();
System.out.println("客户端断开连接");
}
}
}
}
}
弊端:
假设有十万的连接,都放到channelList,
但是同一时刻,只有几十个连接有数据。
遍历10万个连接,只有几十个有数据,会造成资源浪费。
(2) 改造后的NIO
package Thread;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
public class NioSelectorServer {
public static void main(String[] args) throws IOException {
//创建NIO ServerSocketChannel,与BIO的serverSocket类似
ServerSocketChannel serverSocket = ServerSocketChannel.open();
//绑定端口
serverSocket.socket().bind(new InetSocketAddress(9000));
//设置ServerSocketChannel为非阻塞
serverSocket.configureBlocking(false);
//打开Selector处理Channel,即创建epoll
Selector selector = Selector.open();
//把ServerSocketChannel注册到selector上,并且selector对客户端accept连接操作感兴趣
SelectionKey selectionKey = serverSocket.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("服务启动成功");
while (true){
//阻塞等待需要处理的时间发生 多路复用
selector.select();
//获取selector中注册的全部事件的 SelectionKey 实例
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
//遍历selectionKeys对事件进行处理
while (iterator.hasNext()){
SelectionKey key = iterator.next();
// 如果是OP_ACCEPT事件,则进行连接获取和事件注册
if (key.isAcceptable()) {
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel socketChannel = server.accept();
socketChannel.configureBlocking(false);
//这里只注册了读事件,如果需要给客户端发送数据可以注册写实事件
SelectionKey selkey = socketChannel.register(selector, SelectionKey.OP_READ);
System.out.println("客户端连接成功");
} else if (key.isReadable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(128);
int len = socketChannel.read(byteBuffer);
//如果有数据,把数据打印出来
if (len > 0) {
System.out.println("接收到消息: " + new String(byteBuffer.array()));
} else if (len == -1) {
System.out.println("客户端断开连接");
socketChannel.close();
}
}
//从事件集合里删除本次处理的key,防止下次select重复chuli
iterator.remove();
}
}
}
}