netty问题清单
netty写一个服务器
bio为何每个连接都要new一个线程去处理
while(true){
Socket socket = socket.accept() //阻塞
new Thread(new Runable(){@override ....}).start();
//假如一堆请求任务的处理时间是[10,5,1,20,3]，现在这个5个请求都同时发起了，如果对每个连接都直接进行处理，那么客户端的平均等待时间就是（10+15+16+36+39）/5=23.2秒
//使用了多线程后：客户端的平均等待时间就是（10+5+1+20+3）/5=7.8秒
//由此可见：每个连接都必需要new一个线程去处理
socket.getInputStream().read(new byte[1024]) //阻塞的
socket.getOutputStream().write(new byte[1024],0,len) //阻塞的
//如此多的阻塞，就导致大多数的线程在哪停着，cpu还要频繁的在这些线程之间来回的切换
}
代码实现单线程的nio
一个线程去处理连接，读入，写出这些事，它在阻塞阶段就会隔一段时间就去查询一些，它所等待的那些（感兴趣的事：即有无新的连接，读入，写出等事件）有没有发生，发生了，就被唤醒去处理这些事。
一个连接就是一个通道
单线程的nio是只有一个大管家
ServerSocketChannel是对ServerSocket逻辑上的封装，它是双向的，支持同时读入和写出。服务端有很多的插口，selector会对这些插口标记上一个key。（一个key就是一个事件）。即selector往插口上扔的监听器
accept()是建立通道。selector是等待事件的发生
bio是byte为单位，nio是buffer为单位
对于单线程的selector，如果读写阻塞了，那么selector将不能再处理新的连接了
ServerSocketChannel ssc = ServerSocketChannel.open(); //bio中是ServerSocket，nio封装后就是ServerSocketChannel，//新建NIO通道
ssc.socket().bind(new InetSocketAddress("127.0.0.1", 8888));//设置初值，//创建基于NIO通道的socket连接，//新建socket通道的端口
ssc.configureBlocking(false);//;//使通道为非阻塞
System.out.println("server started, listening on :" + ssc.getLocalAddress());
Selector selector = Selector.open();
ssc.register(selector, SelectionKey.OP_ACCEPT);将NIO通道绑定到选择器,当然绑定后分配的主键为skey
while(true) {
selector.select();获取通道内是否有选择器的关心事件, 意思是有多少学生报告
Set<SelectionKey> keys = selector.selectedKeys();获取通道内关心事件的集合 ，这里的集合就是老师和学生的编号集合，如果key是学生的，那就是老学生来问问题，如果key是老师的，那就是招生办的老师带着一个新生来注册
Iterator<SelectionKey> it = keys.iterator();
while(it.hasNext()) {遍历每个key （学生key和老师key）
SelectionKey key = it.next();
it.remove();
handle(key);
}
}
}
private static void handle(SelectionKey key) {
if(key.isAcceptable()) {
try {
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
SocketChannel sc = ssc.accept(); //判断是新生，监听连接事件
sc.configureBlocking(false);
sc.register(key.selector(), SelectionKey.OP_READ );//判断是老生，即已建立连接，监听读事件
} catch (IOException e) {
e.printStackTrace();
} finally {
}
} else if (key.isReadable()) { //flip
SocketChannel sc = null;
try {
sc = (SocketChannel)key.channel();
ByteBuffer buffer = ByteBuffer.allocate(512);
buffer.clear();
int len = sc.read(buffer);
if(len != -1) {
System.out.println(new String(buffer.array(), 0, len));
}
ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes());
sc.write(bufferToWrite);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(sc != null) {
try {
sc.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
如何实现响应式的nio【单线程+线程池的nio】【NIO-reactor模式】
响应式的nio是一个大管家（selector）领着线程池里的一堆工人（线程）。它不是每个客户端分配一个线程，而是把一堆客户端分配给一个线程池（一堆线程在哪等着，有人要读吗，有人要写吗，selector查询到有一个，蹦，给你，你去处理，你空着的，蹦，给你，你去处理）—即boss和worker【netty就是对这个模型的封装】----------单线程+线程池
ExecutorService pool = Executors.newFixedThreadPool(50); //启动50个线程
private Selector selector;
//中文测试
/**
*
* @throws IOException
*/
public static void main(String[] args) throws IOException {
PoolServer server = new PoolServer();
server.initServer(8000);
server.listen();
}
/**
*
* @param port
* @throws IOException
*/
public void initServer(int port) throws IOException {
//
ServerSocketChannel serverChannel = ServerSocketChannel.open();
//
serverChannel.configureBlocking(false);
//
serverChannel.socket().bind(new InetSocketAddress(port));
//
this.selector = Selector.open();
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("服务端启动成功！");
}
/**
*
* @throws IOException
*/
@SuppressWarnings("unchecked")
public void listen() throws IOException {
// 轮询访问selector
while (true) {
//
selector.select();
//
Iterator ite = this.selector.selectedKeys().iterator();
while (ite.hasNext()) {
SelectionKey key = (SelectionKey) ite.next();
//
ite.remove();
//
if (key.isAcceptable()) {
ServerSocketChannel server = (ServerSocketChannel) key.channel();
//
SocketChannel channel = server.accept();
//
channel.configureBlocking(false);
//
channel.register(this.selector, SelectionKey.OP_READ);//注册读事件
//
} else if (key.isReadable()) {
//
key.interestOps(key.interestOps()&(~SelectionKey.OP_READ));
//
pool.execute(new ThreadHandlerChannel(key));//线程池里哪个线程空着，就让谁来处理
}
}
}
}
}
/**
*
* @param
* @throws IOException
*/
class ThreadHandlerChannel extends Thread{
private SelectionKey key;
ThreadHandlerChannel(SelectionKey key){
this.key=key;
}
@Override
public void run() {
//
SocketChannel channel = (SocketChannel) key.channel();
//
ByteBuffer buffer = ByteBuffer.allocate(1024);//非常难用的一个api，这是如此，才不用原生的java的nio，这就导致了netty的火爆，它就是因为解决了ByteBuffer的api难用的这个问题而火爆了起来，成为了最流行的网络编程框架。
//
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
int size = 0;
while ((size = channel.read(buffer)) > 0) {
buffer.flip();
baos.write(buffer.array(),0,size);
buffer.clear();
}
baos.close();
//
byte[] content=baos.toByteArray();
ByteBuffer writeBuf = ByteBuffer.allocate(content.length);
writeBuf.put(content);
writeBuf.flip();
channel.write(writeBuf);//
if(size==-1){
channel.close();
}else{
//
key.interestOps(key.interestOps()|SelectionKey.OP_READ);
key.selector().wakeup();
}
}catch (Exception e) {
System.out.println(e.getMessage());
}
}
nio和消息队列有啥关系
消息队列：客户端疯狂向服务端发消息，服务端的线程对这些消息未必处理的过来，解决办法就是先将这些消息存入到消息队列里面。另外的线程再不断地将这些消息拿过来做处理。（就是一个消息暂存器）—一个连接一个队列。通道是客户端和服务端通信地一个虚拟地通道，读入，写出，读入，写出。通道是对serversocket地封装。通道和队列是完全两个不同地概念
有了AIO，为何还有nio
在linux底层，aio和nio都是用epoll【他是底层编程的一种模型，epoll是轮询模型，aio是又加了一层轮询9又包了一层，aio的api更好用），无论上层如何封装，底层都是轮询，故不如直接使用nio】实现的。netty封装的是nio（功能已足够强大，但api不好用），它的api更像aio（api更好用）
NIO是有事没事都在轮询（转一圈）。AIO是有事了你再通知我，我再去轮询。（这里面是操作系统底层的实现了，这个通知是由操作系统/内核来发起通知了）
原理
客户端需要连接的时候，交给操作系统去连接，操作系统一旦连上了，就会通知（发一个消息）这个大管家selector。这是大管家做哪等就行。cpu的速度要比网络的速度快很多（几百万倍），（单线程能处理客户端同时百万连接）。线程并非越多越好，它会增加上下文切换的开销。网络io/磁盘io都需要os的处理
netty
（至少你要懂概念，要能说得出来，代码可以暂时写不来。给我点时间，稍稍练习一下，我就可以上手）如果把网络编程比作切菜，nio封装的网络模型想把斧子，netty封装的更像一把菜刀，更适合用来切菜
437
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
