更新面试题

Author: jujunchen

22. ShardingJDBC.md

@@ -1,4 +1,4 @@
-# 22.Sharding-JDBC
+# 22.分库分表
 
 [toc]
 
@@ -10,6 +10,8 @@
 >
 > 数据库分库分表思路：https://www.cnblogs.com/butterfly100/p/9034281.html
 
+## Sharding-JDBC
+
 ### 分库分表的方式
 
 - 垂直分库

25.Netty.md

@@ -0,0 +1,173 @@
+# 25.Netty
+
+### TCP 的粘包和拆包
+
+TCP 是以流的方式来处理数据的，一个完整的包可能会被TCP拆分成多个包进行发送，也可能把小的封装成一个大的数据包发送。
+
+### BIO、NIO、AIO的区别
+
+BIO：一个连接一个线程，客户端有连接请求时服务器端就需要启动一个线程进行处理，线程开销大。是面向流的，阻塞流，流是单向的。
+
+NIO： 一个请求一个线程，但客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有IO请求时才启动一个线程进行处理。面向缓存区，非阻塞，channe是双向的。
+
+AIO：一个有效请求一个线程，客户端的IO请求都是由OS先完成了再通知服务器应用去启动线程进行处理
+
+### NIO 的组成
+
+Buffer：与Channel进行交互，数据从Channel读入缓冲区，从缓冲区写入Channel中
+
+flip方法：反转缓冲区，将position给limit，然后将position置为0，就是读写切换
+
+clear方法：清除此缓冲区，将position置为0，把capacity的值给limit
+
+rewind方法：重置此缓冲区，将position置为0
+
+DirectByteBuffer：可减少一次系统空间到用户空间的拷贝
+
+Channel：与数据源的连接，是双向的，只能与Buffer交互
+
+Selector：允许单个线程管理多个Channel
+
+Pipe：两个线程之间的单向数据连接，数据会被写到sink通道，从source通道读取
+
+
+
+NIO服务端建立过程：
+
+1. ServerSocketChannel.open 创建服务端Channel
+2. bind 绑定服务端端口
+3. 配置非阻塞模式
+4. Selector.open 打开一个selector
+5. 注册关注的事件到selector上
+
+```java
+// 服务端代码
+public class NioServer {
+
+    public static void main(String[] args) {
+        try(ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()) {
+            serverSocketChannel.socket().bind(new InetSocketAddress(3388));
+
+            Selector selector = Selector.open();
+            serverSocketChannel.configureBlocking(false);
+            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
+
+            System.out.println("服务器准备就绪，开始监听，端口3388");
+
+
+            while (true) {
+                int wait = selector.select();
+                if (wait == 0)
+                    continue;
+
+                Set<SelectionKey> keys = selector.selectedKeys();
+                Iterator<SelectionKey> iterator = keys.iterator();
+                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
+
+                while (iterator.hasNext()) {
+
+                    SelectionKey key = iterator.next();
+
+                    if (key.isAcceptable()) {
+                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
+                        SocketChannel channel = server.accept();
+                        channel.configureBlocking(false);
+                        channel.register(selector, SelectionKey.OP_READ);
+                    } else if(key.isReadable()) {
+                        SocketChannel server = (SocketChannel) key.channel();
+                        int len = server.read(byteBuffer);
+                        if (len > 0) {
+                            byteBuffer.flip();
+                            String content = new String(byteBuffer.array(), 0, len);
+                            System.out.println(content);
+
+                            server.configureBlocking(false);
+                            server.register(selector, SelectionKey.OP_WRITE);
+                        }
+                        byteBuffer.clear();
+                    } else if (key.isWritable()) {
+                        SocketChannel server = (SocketChannel) key.channel();
+                        server.write(ByteBuffer.wrap("Hello Client!".getBytes()));
+                    }
+
+                    iterator.remove();
+                }
+
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+
+//客户端代码
+public class NIOClient {
+
+    public static void main(String[] args) {
+        try(SocketChannel channel = SocketChannel.open()) {
+            channel.connect(new InetSocketAddress(3388));
+
+            //发送数据
+            if (channel.isConnected()) {
+                channel.write(ByteBuffer.wrap("Hello Server!".getBytes()));
+            }
+
+            ByteBuffer buffer = ByteBuffer.allocate(1024);
+            int len = channel.read(buffer);
+            String content = new String(buffer.array(), 0, len);
+            System.out.println(content);
+        }catch (Exception e) {
+
+        }
+
+    }
+}
+```
+
+### Netty 的特点
+
+一个高性能、异步事件驱动的NIO框架。
+
+使用更高效的socket底层，处理了epoll空轮询引起的cpu占用飙升（Netty检测到空轮询的时候，主动重建Selector）
+
+采用decoder/encoder 支持，对TCP粘包/拆包进行自动化处理
+
+可配置IO线程数、TCP参数，TCP 接收和发送缓冲区使用直接内存代替堆内存，通过内存池的方式循环利用 ByteBuf
+
+通过引用计数器及时申请释放不再引用的对象，降低了 GC 频率
+
+使用单线程串行化的方式，高效的 Reactor 线程模型
+
+大量使用了 volitale、使用了 CAS 和原子类、线程安全类的使用、读写锁的使用
+
+### Netty 使用的线程模型
+
+Netty 通过 Reactor 线程模型基于多路复用器接收并处理用户请求，内部实现了两个线程池，boss 线程池和 work 线程池，
+
+其中 boss 线程池的线程负责处理请求的 accept 事件，当接收到 accept 事件的请求时，把对应的 socket 封装到一个，
+
+NioSocketChannel 中，并交给 work线程池，其中 work 线程池负责请求的 read 和 write 事件，由对应的 Handler 处理。
+
+### Netty 的零拷贝实现
+
+- Direct Buffer
+
+  使用堆外内存进行Socket读写，避免JVM堆内存与内核缓存之间的拷贝
+
+- CompositeByteBuf
+
+​			将多个缓存区“逻辑上”合并为一个缓冲区，避免物理上的数据拷贝
+
+- 文件传输的零拷贝 FileRegion
+
+​			利用操作系统的 `sendfile` 系统调用，直接在文件描述符和套接字之间传输数据，完全跳过用户态
+
+- 缓存区包装 Wrapped Buffers
+
+​			通过包装现有数据（如字节数组、`ByteBuffer`）创建 `ByteBuf`，避免数据贝,`Unpooled.wrappedBuffer(...)` 方法直接引用原始数据，而非复制
+
+- 延迟缓冲区拷贝 Lazy Copy
+
+​		在某些场景下（如缓冲区切片 `slice()`），仅记录原始缓冲区的引用和偏移量，不立即拷贝数据，直到必要时才执行拷贝。