bio server程序:
public static void main(String[] args) throws Exception
{
ServerSocket server = new ServerSocket(8888);
while (true)
{
// 阻塞
Socket socket = server.accept();
new Thread(() -> {
try
{
InputStream in = socket.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
while (true)
{
// 阻塞
System.out.println(reader.readLine());
}
}
catch (IOException e)
{
e.printStackTrace();
}
}).start();
}
}
bio的问题是它的read, write方法都是阻塞的, 例如上述程序中的reader.readLine(); 如果客户端连上了但是不发送数据, 服务端就一直阻塞在这里, 就没有办法和新的客户端建立连接
所以不得不为每一个socket都创建一个进程/线程来进行处理, 不让io阻塞住主线程
由此就可以看出bio的开销:
- 创建线程需要开销, client越多, 需要的线程也就越多
- 多线程上下文切换需要开销
而造成这些开销的根本原因就是io是阻塞的, 如果io是非阻塞的, 也就不需要开辟那么多线程了
假设现在有一个read方法是非阻塞的:
// 伪代码
while(true)
{
// 非阻塞
Socket socket = server.accept();
if (socket != null)
{
list.add(socket);
}
foreach(list)
{
// 非阻塞
socket.getInputStream().read();
}
}
上述代码就完成了由一个线程去处理多个socket, 但是仍然存在很大的开销.
例如现在这个list里存了1w个socket, 那么每次foreach都要调1w次read方法.
io都是要操作硬件的, 操作硬件的接口都是由操作系统暴露的(系统调用), 并且这些接口只能在操作系统的掌控/环境下执行(内核态). 而正常程序的运行是在用户态运行的, 用户态到内核态的切换是要开销的(例如保存现场切换堆栈....)
所以有1w个socket要读就进行1w次系统调用是不太合适的, 而且这1w个socket可能也就只有1个socket是有数据可以读的, 而剩下的9999次系统调用都是浪费掉的
所以有了io多路复用器, 这仍是一个用一个线程处理多个socket的技术
while(true)
{
List<Socket> activeList = select(list)
foreach(activeList)
// ...
}
select就是一个io多路复用器, 把1w个socket都仍给它, 由它来返回哪几个是有数据可以读的socket, 再由程序去处理
select相比上一种的好处就是 我一次把1w个socket都丢给了内核态, 在内核态中进行遍历, 然后只返回有数据交互的socket, 大大减少了系统调用的次数
不过内核去遍历所有的socket还是有开销, 所以有了epoll
epoll是一种事件驱动的机制, 在内核中开辟两块空间a和b, 每来一个socket就往a里放, 并且把这个socket绑定一个事件例如accept/read..., 将来该socket对应的事件发生后, 该socket回移到b里, 而应用程序就是每次从b里得到activeList
而从a移到b是靠的网卡的中断
nio就是对epoll的封装, channel就可以看做是fd, 可读可写
selector就可以看做是监听a的监听器
selector.selectedKeys()就是从b获取有事件发生了的fd, 相当于epoll_wait channel.register()就相当于把fd(channel)放到a中, 类比epoll_ctl
public void start()
{
try
{
channel = ServerSocketChannel.open();
// 开启非阻塞模式
channel.configureBlocking(false);
// 得到与channel相关的ServerSocket并绑定端口
channel.socket().bind(new InetSocketAddress(port));
selector = Selector.open();
// 让selector监控channel上的accept事件
channel.register(selector, SelectionKey.OP_ACCEPT);
while (true)
{
// 返回 监控到的所有通道上触发的事件 的个数
// 如果一个也没触发， 就阻塞
selector.select();
// 获取被触发事件的相关信息
Set<SelectionKey> selectionKeys = selector.selectedKeys();
for (SelectionKey key : selectionKeys)
{
handle(key);
}
// 要清空， 不然下一次循环还有这一次的数据
selectionKeys.clear();
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
close();
}
}
private void handle(SelectionKey key) throws IOException
{
// 如果是accept事件(和客户端建立了连接)被触发
if (key.isAcceptable())
{
// 返回当前key所属的通道， 返回的是 this.channel
ServerSocketChannel server = (ServerSocketChannel) key.channel();
// 返回一个用户和客户端通信的SocketChannel
SocketChannel client = server.accept();
client.configureBlocking(false);
// 让selector监控该client通道上的read事件, 以便该客户端向server发送信息时，可以处理
client.register(selector, SelectionKey.OP_READ);
System.out.println("客户端: [" + getClientText(client.socket()) + "]进入聊天室...");
}
// 如果有客户端发来消息
else if (key.isReadable())
{
SocketChannel client = (SocketChannel) key.channel();
// 接收客户端发来的消息
String fwdMsg = receive(client);
// 客户端异常
if (fwdMsg.isEmpty())
{
// 取消 key所属的通道的响应事件的监听
key.cancel();
// selector的状态有所变化, select函数重新执行
selector.wakeup();
}
else
{
// 转发消息, 不要转发给自己
forwardMessage(client, fwdMsg);
if(readyToExit(fwdMsg))
{
key.cancel();
selector.wakeup();
System.out.println(getClientText(client.socket()) + "已下线...");
}
}
}
}
select, epoll都是同步的
他们都只是多路复用器, 程序仅仅是通过多路复用器知道了哪些socket是可以去操作的, 但具体的io操作还是程序自己去发起, 所以是同步的
