NIO与Socket编程技术指南 (高洪岩)（Z-Library）

# NIO与Socket编程技术指南 ## 【One-Line Pitch】 A comprehensive, code-driven guide to Java NIO and Socket programming that walks you from buffer fundamentals through advanced channel and selector APIs, ideal for Java developers aiming to move beyond web frameworks toward high-performance, high-concurrency server development. ## 【Book Arc】 - **Opening (~0%–10%)**: Establishes why NIO and Socket matter for Java career growth, positions them alongside multithreading and concurrency as core Java SE technologies, and introduces the four-step Socket lifecycle (connect, request, respond, close) that frames all later examples. - **Early (~10%–32%)**: Dives deep into buffer fundamentals—capacity, limit, position, and mark—with extensive verification experiments, then covers flip(), clear(), arrayOffset(), and the difference between direct and non-direct buffers with performance comparisons. - **Middle (~32%–52%)**: Explores bulk operations like put(byte[]) and get(byte[]), including exception handling for BufferOverflowException and BufferUnderflowException, batch-processing strategies for partial reads/writes, and converting ByteBuffer to CharBuffer with proper Chinese character encoding via UTF-16BE. - **Late (~52%–75%)**: Moves into channel APIs and Socket integration, showing how NIO channels build on traditional Socket concepts to enable non-blocking I/O patterns. - **Ending (~75%–100%)**: Covers selector-based multiplexing and advanced Socket Option tuning, emphasizing how parameter optimization affects real-world network program performance. ## 【Key Takeaways】 - **Buffer state variables are the core mental model** (Early): capacity, limit, position, and mark form an invariant system—position cannot exceed limit, limit cannot exceed capacity, and mark is discarded when limit or position moves below it. Understanding these rules prevents subtle bugs in all buffer operations. - **flip() is the read/write transition switch** (Early): After writing data, flip() sets limit to current position and resets position to zero, making the buffer ready for reading. This single method eliminates the verbose manual pattern of setting limit and position separately. - **Direct buffers trade allocation cost for I/O speed** (Early): allocateDirect() creates buffers that interact directly with the operating system's I/O, showing measurable performance gains in large-scale write operations compared to heap-based buffers, though allocation itself is more expensive. - **Bulk operations require remaining-space awareness** (Middle): put(byte[]) throws BufferOverflowException when the array exceeds remaining space, while get(byte[]) throws BufferUnderflowException when the destination array is larger than available data—both require batch-processing loops for safe handling. - **Chinese character handling demands explicit encoding** (Middle): Converting ByteBuffer to CharBuffer via asCharBuffer() defaults to UTF-16BE; using getBytes("utf-16BE") before wrapping ensures correct Chinese text rendering and avoids garbled output. - **Socket options are performance levers** (Opening): Beyond code optimization, tuning Socket Option parameters directly impacts network program efficiency—the book treats these as first-class topics rather than afterthoughts. - **NIO builds on, not replaces, Socket knowledge** (Opening): Core NIO channel classes are Socket-based, so mastering ServerSocket/Socket fundamentals first is a prerequisite for understanding NIO's non-blocking abstractions. ## 【Reading Tips】 - **Skim the opening career-pitch sections** (~0%–3%): The motivational framing and technology overview are useful context but not essential—move quickly to buffer fundamentals. - **Deep-read the buffer verification experiments** (~10%–32%): The seven rule-verification tests and flip()/clear() examples are the book's strongest teaching material; run these code samples yourself to internalize the state-machine behavior. - **Treat exception scenarios as checklists** (Middle): The put/get bulk operation exceptions and their batch-processing solutions are practical patterns you'll reuse—mark these sections for reference. - **Pay special attention to the Chinese encoding section** (Middle): If you work with internationalized text, the UTF-16BE conversion pattern is a concrete solution to a common real-world problem. - **Expect code-heavy, explanation-light prose**: This is an API walkthrough, not a conceptual treatise—use the examples as executable documentation and supplement with your own experiments. ## 【Coverage Limits】 The excerpts cover buffer APIs thoroughly and touch on Socket fundamentals, but do not include detailed coverage of channel classes, selector multiplexing, or advanced Socket Option implementations—these appear later in the book but fall outside the sampled material. ##