read(file, tmp_buf, len);
write(socket, tmp_buf, len);

// 傳統(tǒng)文件讀取和發(fā)送的偽代碼表示
public class TraditionalFileTransfer {
    public void transferFile(File file, Socket socket) throws IOException {
        byte[] buffer = new byte[8192];  // 用戶空間緩沖區(qū)
        // 1. 從磁盤(pán)讀取到內(nèi)核緩沖區(qū)（DMA拷貝）
        // 2. 從內(nèi)核緩沖區(qū)拷貝到用戶緩沖區(qū)（CPU拷貝）
        FileInputStream fis = new FileInputStream(file);
        int bytesRead;
        while ((bytesRead = fis.read(buffer)) != -1) {
            // 3. 從用戶緩沖區(qū)拷貝到Socket緩沖區(qū)（CPU拷貝）
            // 4. 從Socket緩沖區(qū)拷貝到網(wǎng)卡緩沖區(qū)（DMA拷貝）
            socket.getOutputStream().write(buffer, 0, bytesRead);
        }
    }
}

buf = mmap(file, len);
write(sockfd, buf, len);

#include <sys/socket.h>
ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

$ ethtool -k eth0 | grep scatter-gather
scatter-gather: on

@Service
@Slf4j
public class ZeroCopyFileService {


    private static final int BUFFER_SIZE = 8192;


    /**
     * 使用FileChannel.transferTo實(shí)現(xiàn)零拷貝文件傳輸
     * 這是最高效的零拷貝實(shí)現(xiàn)方式
     */
    public void transferFileWithZeroCopy(File file, ServletResponse response) 
            throws IOException {


        try (FileChannel fileChannel = new FileInputStream(file).getChannel();
             WritableByteChannel outputChannel = Channels.newChannel(response.getOutputStream())) {


            long position = 0;
            long fileSize = fileChannel.size();


            // 使用transferTo進(jìn)行零拷貝傳輸
            while (position < fileSize) {
                long transferred = fileChannel.transferTo(position, fileSize - position, outputChannel);
                if (transferred <= 0) {
                    break;
                }
                position += transferred;
            }


            log.debug("零拷貝文件傳輸完成: {}, 文件大小: {} bytes", file.getName(), fileSize);


        } catch (IOException e) {
            log.error("零拷貝文件傳輸失敗: {}", file.getName(), e);
            throw e;
        }
    }


    /**
     * 使用MappedByteBuffer實(shí)現(xiàn)內(nèi)存映射文件傳輸
     * 適合大文件的分塊處理
     */
    public void transferFileWithMmap(File file, ServletResponse response, 
                                   long chunkSize) throws IOException {


        if (chunkSize <= 0) {
            chunkSize = 1024 * 1024; // 默認(rèn)1MB分塊
        }


        try (FileChannel fileChannel = new RandomAccessFile(file, "r").getChannel()) {
            long fileSize = fileChannel.size();
            long position = 0;


            while (position < fileSize) {
                long size = Math.min(chunkSize, fileSize - position);


                // 創(chuàng)建內(nèi)存映射
                MappedByteBuffer mappedBuffer = fileChannel.map(
                    FileChannel.MapMode.READ_ONLY, position, size);


                // 通過(guò)Channel發(fā)送映射的緩沖區(qū)
                WritableByteChannel outputChannel = Channels.newChannel(response.getOutputStream());
                while (mappedBuffer.hasRemaining()) {
                    outputChannel.write(mappedBuffer);
                }


                // 清理映射
                clean(mappedBuffer);
                position += size;
            }


            log.debug("內(nèi)存映射文件傳輸完成: {}, 文件大小: {} bytes", file.getName(), fileSize);
        }
    }


    /**
     * 清理MappedByteBuffer
     */
    private void clean(MappedByteBuffer buffer) {
        if (buffer == null || !buffer.isDirect()) return;


        try {
            Method cleanerMethod = buffer.getClass().getMethod("cleaner");
            cleanerMethod.setAccessible(true);
            Object cleaner = cleanerMethod.invoke(buffer);
            if (cleaner != null) {
                Method cleanMethod = cleaner.getClass().getMethod("clean");
                cleanMethod.setAccessible(true);
                cleanMethod.invoke(cleaner);
            }
        } catch (Exception e) {
            log.warn("清理MappedByteBuffer失敗", e);
        }
    }
}

@RestController
@RequestMapping("/api/file")
@Slf4j
public class ZeroCopyFileController {


    @Autowired
    private ZeroCopyFileService zeroCopyFileService;


    @Value("${file.upload.dir:/tmp/uploads}")
    private String uploadDir;


    /**
     * 零拷貝文件下載
     */
    @GetMapping("/download/{filename}")
    public void downloadFile(@PathVariable String filename, 
                           HttpServletRequest request,
                           HttpServletResponse response) throws IOException {


        File file = new File(uploadDir, filename);
        if (!file.exists() || !file.isFile()) {
            response.sendError(HttpStatus.NOT_FOUND.value(), "文件不存在");
            return;
        }


        // 設(shè)置響應(yīng)頭
        setupFileDownloadHeaders(response, file, filename);


        try {
            // 使用零拷貝傳輸文件
            zeroCopyFileService.transferFileWithZeroCopy(file, response);


            log.info("文件下載完成: {}, 大小: {} bytes, 客戶端: {}", 
                    filename, file.length(), getClientIp(request));


        } catch (IOException e) {
            log.error("文件下載失敗: {}", filename, e);
            if (!response.isCommitted()) {
                response.sendError(HttpStatus.INTERNAL_SERVER_ERROR.value(), 
                                 "文件下載失敗");
            }
        }
    }


    /**
     * 大文件分塊下載（支持?jǐn)帱c(diǎn)續(xù)傳）
     */
    @GetMapping("/download/{filename}/chunked")
    public void downloadFileChunked(@PathVariable String filename,
                                  @RequestHeader(value = "Range", required = false) String rangeHeader,
                                  HttpServletRequest request,
                                  HttpServletResponse response) throws IOException {


        File file = new File(uploadDir, filename);
        if (!file.exists() || !file.isFile()) {
            response.sendError(HttpStatus.NOT_FOUND.value(), "文件不存在");
            return;
        }


        long fileLength = file.length();
        long start = 0;
        long end = fileLength - 1;


        // 處理范圍請(qǐng)求（斷點(diǎn)續(xù)傳）
        if (rangeHeader != null && rangeHeader.startsWith("bytes=")) {
            String[] ranges = rangeHeader.substring(6).split("-");
            start = Long.parseLong(ranges[0]);
            if (ranges.length > 1) {
                end = Long.parseLong(ranges[1]);
            }
            end = Math.min(end, fileLength - 1);


            response.setStatus(HttpStatus.PARTIAL_CONTENT.value());
            response.setHeader("Content-Range", 
                String.format("bytes %d-%d/%d", start, end, fileLength));
        }


        long contentLength = end - start + 1;
        setupFileDownloadHeaders(response, file, filename);
        response.setContentLengthLong(contentLength);


        // 使用內(nèi)存映射進(jìn)行分塊傳輸
        try (RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r");
             FileChannel fileChannel = randomAccessFile.getChannel()) {


            // 定位到指定位置
            WritableByteChannel outputChannel = Channels.newChannel(response.getOutputStream());
            fileChannel.transferTo(start, contentLength, outputChannel);


            log.info("文件分塊下載完成: {} [{} - {}], 客戶端: {}", 
                    filename, start, end, getClientIp(request));


        } catch (IOException e) {
            log.error("文件分塊下載失敗: {}", filename, e);
            if (!response.isCommitted()) {
                response.sendError(HttpStatus.INTERNAL_SERVER_ERROR.value(), 
                                 "文件下載失敗");
            }
        }
    }


    /**
     * 設(shè)置文件下載響應(yīng)頭
     */
    private void setupFileDownloadHeaders(HttpServletResponse response, 
                                        File file, String filename) {
        // 內(nèi)容類型
        String contentType = determineContentType(filename);
        response.setContentType(contentType);


        // 內(nèi)容處置
        String encodedFilename = URLEncoder.encode(filename, StandardCharsets.UTF_8)
            .replaceAll("\\+", "%20");
        response.setHeader("Content-Disposition", 
            "attachment; filename*=UTF-8''" + encodedFilename);


        // 緩存控制
        response.setHeader("Cache-Control", "private, max-age=300");
        response.setHeader("Pragma", "private");
        response.setDateHeader("Expires", 
            System.currentTimeMillis() + 300 * 1000);


        // 文件大小
        response.setContentLengthLong(file.length());


        // 支持?jǐn)帱c(diǎn)續(xù)傳
        response.setHeader("Accept-Ranges", "bytes");
    }


    /**
     * 根據(jù)文件名確定內(nèi)容類型
     */
    private String determineContentType(String filename) {
        String extension = FilenameUtils.getExtension(filename).toLowerCase();
        switch (extension) {
            case "pdf": return "application/pdf";
            case "jpg": case "jpeg": return "image/jpeg";
            case "png": return "image/png";
            case "txt": return "text/plain";
            case "zip": return "application/zip";
            default: return "application/octet-stream";
        }
    }


    /**
     * 獲取客戶端IP
     */
    private String getClientIp(HttpServletRequest request) {
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0];
        }
        return request.getRemoteAddr();
    }
}

@Component
@Slf4j
public class AsyncZeroCopyProcessor {


    @Autowired
    private ZeroCopyFileService zeroCopyFileService;


    private final ExecutorService asyncExecutor = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors(),
        new ThreadFactoryBuilder()
            .setNameFormat("zero-copy-async-%d")
            .setDaemon(true)
            .build()
    );


    /**
     * 異步零拷貝文件處理
     */
    public CompletableFuture<Void> processFileAsync(File file, 
                                                   ServletResponse response) {
        return CompletableFuture.runAsync(() -> {
            try {
                zeroCopyFileService.transferFileWithZeroCopy(file, response);
            } catch (IOException e) {
                log.error("異步文件處理失敗: {}", file.getName(), e);
                throw new CompletionException(e);
            }
        }, asyncExecutor);
    }


    /**
     * 批量文件異步傳輸
     */
    public CompletableFuture<Void> processBatchFilesAsync(List<File> files,
                                                         ServletResponse response) {
        List<CompletableFuture<Void>> futures = files.stream()
            .map(file -> processFileAsync(file, response))
            .collect(Collectors.toList());


        return CompletableFuture.allOf(
            futures.toArray(new CompletableFuture[0])
        );
    }


    @PreDestroy
    public void shutdown() {
        asyncExecutor.shutdown();
        try {
            if (!asyncExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                asyncExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            asyncExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

@Component
@Slf4j
public class NettyZeroCopyServer {


    @Value("${netty.server.port:8080}")
    private int port;


    private EventLoopGroup bossGroup;
    private EventLoopGroup workerGroup;
    private ChannelFuture channelFuture;


    /**
     * 啟動(dòng)Netty零拷貝文件服務(wù)器
     */
    @PostConstruct
    public void start() throws InterruptedException {
        bossGroup = new NioEventLoopGroup(1);
        workerGroup = new NioEventLoopGroup();


        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast(new HttpServerCodec());
                        pipeline.addLast(new HttpObjectAggregator(65536));
                        pipeline.addLast(new ZeroCopyFileHandler());
                    }
                })
                .option(ChannelOption.SO_BACKLOG, 128)
                .childOption(ChannelOption.SO_KEEPALIVE, true);


            channelFuture = bootstrap.bind(port).sync();
            log.info("Netty零拷貝文件服務(wù)器啟動(dòng)成功，端口: {}", port);


        } catch (Exception e) {
            log.error("Netty服務(wù)器啟動(dòng)失敗", e);
            stop();
            throw e;
        }
    }


    /**
     * Netty零拷貝文件處理器
     */
    private static class ZeroCopyFileHandler extends SimpleChannelInboundHandler<FullHttpRequest> {


        @Override
        protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) {
            if (!request.decoderResult().isSuccess()) {
                sendError(ctx, HttpResponseStatus.BAD_REQUEST);
                return;
            }


            if (request.method() != HttpMethod.GET) {
                sendError(ctx, HttpResponseStatus.METHOD_NOT_ALLOWED);
                return;
            }


            String uri = request.uri();
            if (!uri.startsWith("/file/")) {
                sendError(ctx, HttpResponseStatus.NOT_FOUND);
                return;
            }


            String filename = uri.substring(6); // 去掉"/file/"
            File file = new File("/data/files", filename);


            if (!file.exists() || file.isDirectory()) {
                sendError(ctx, HttpResponseStatus.NOT_FOUND);
                return;
            }


            // 使用零拷貝發(fā)送文件
            try {
                RandomAccessFile raf = new RandomAccessFile(file, "r");
                long fileLength = raf.length();


                HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
                HttpUtil.setContentLength(response, fileLength);
                response.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/octet-stream");


                // 設(shè)置文件下載頭
                String encodedFilename = URLEncoder.encode(filename, StandardCharsets.UTF_8)
                    .replaceAll("\\+", "%20");
                response.headers().set(HttpHeaderNames.CONTENT_DISPOSITION,
                    "attachment; filename*=UTF-8''" + encodedFilename);


                // 寫(xiě)入HTTP響應(yīng)頭
                ctx.write(response);


                // 使用零拷貝發(fā)送文件內(nèi)容
                FileRegion region = new DefaultFileRegion(raf.getChannel(), 0, fileLength);
                ctx.write(region, ctx.newProgressivePromise())
                   .addListener(new ChannelFutureListener() {
                       @Override
                       public void operationComplete(ChannelFuture future) {
                           if (!future.isSuccess()) {
                               log.error("文件傳輸失敗: {}", filename, future.cause());
                           }
                           try {
                               raf.close();
                           } catch (IOException e) {
                               log.warn("關(guān)閉文件失敗: {}", filename, e);
                           }
                       }
                   });


                // 寫(xiě)入結(jié)束標(biāo)記
                ChannelFuture lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
                lastContentFuture.addListener(ChannelFutureListener.CLOSE);


                log.debug("Netty零拷貝文件發(fā)送完成: {}, 大小: {} bytes", filename, fileLength);


            } catch (Exception e) {
                log.error("文件處理失敗: {}", filename, e);
                sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
            }
        }


        private void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
            FullHttpResponse response = new DefaultFullHttpResponse(
                HttpVersion.HTTP_1_1, status);
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");
            ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
        }


        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            log.error("通道處理異常", cause);
            ctx.close();
        }
    }


    /**
     * 停止服務(wù)器
     */
    @PreDestroy
    public void stop() {
        if (channelFuture != null) {
            channelFuture.channel().close();
        }
        if (bossGroup != null) {
            bossGroup.shutdownGracefully();
        }
        if (workerGroup != null) {
            workerGroup.shutdownGracefully();
        }
        log.info("Netty零拷貝文件服務(wù)器已停止");
    }
}

# application.yml
server:
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 10MB
  tomcat:
    max-swallow-size: 10MB
    max-http-form-post-size: 10MB


# 自定義零拷貝配置
zerocopy:
  enabled: true
  buffer-size: 8192
  chunk-size: 1MB
  max-file-size: 1GB
  async-enabled: true
  async-threads: 4

@Component
@Slf4j
public class DirectMemoryMonitor {


    private final BufferPoolMXBean directBufferPool;


    public DirectMemoryMonitor() {
        this.directBufferPool = ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class)
            .stream()
            .filter(pool -> "direct".equals(pool.getName()))
            .findFirst()
            .orElse(null);
    }


    /**
     * 監(jiān)控直接內(nèi)存使用情況
     */
    @Scheduled(fixedRate = 30000)
    public void monitorDirectMemory() {
        if (directBufferPool != null) {
            long used = directBufferPool.getMemoryUsed();
            long total = directBufferPool.getTotalCapacity();
            long count = directBufferPool.getCount();


            if (used > total * 0.8) {
                log.warn("直接內(nèi)存使用率過(guò)高: {}/{} bytes ({} buffers)", used, total, count);
            }


            log.debug("直接內(nèi)存使用: {}/{} bytes, 緩沖區(qū)數(shù)量: {}", used, total, count);
        }
    }


    /**
     * 獲取直接內(nèi)存統(tǒng)計(jì)
     */
    public DirectMemoryStats getDirectMemoryStats() {
        if (directBufferPool == null) {
            return null;
        }


        DirectMemoryStats stats = new DirectMemoryStats();
        stats.setUsedMemory(directBufferPool.getMemoryUsed());
        stats.setTotalCapacity(directBufferPool.getTotalCapacity());
        stats.setBufferCount(directBufferPool.getCount());
        stats.setUsagePercentage((double) stats.getUsedMemory() / stats.getTotalCapacity() * 100);


        return stats;
    }


    @Data
    public static class DirectMemoryStats {
        private long usedMemory;
        private long totalCapacity;
        private long bufferCount;
        private double usagePercentage;
    }
}