为什么这个非阻塞IO调用失败？

Question

背景

• 我想使用Java的非阻塞SocketChannel发送大量(30MB,但将来可能会大得多)数据量
  • 为什么不阻塞？这样就不会阻止计算要发送的下一个字节等待网络
• 当我在阻塞模式下使用SocketChannel时,传输完成没有问题
• 当我设置的SocketChannel非阻塞,它完成显著快,但服务器没有收到所有数据
  • 但是,服务器确实收到了一些数据

题

• 为什么我的大(30MB)文件传输在使用非阻塞Java NIO SocketChannel时失败,我该如何解决？

档

• 我扼杀了程序并编写了示例,以便它可以一次性运行 javac *.java && java Main

  • 它为服务器创建了Future,为客户端创建了Future,让客户端向服务器发送30MB的随机字节,然后在主线程上阻塞,直到两个Futures完成(尽管服务器从未这样做)

• 注意:这主要是关于TheClient.java

  • 如果意见之间的界限<CommentOutToMakeWork>,并</CommentOutToMakeWork>已被注释掉,在一个SocketChannel将被阻塞和传输将完成

Main.java:

import java.io.IOException;
import java.lang.InterruptedException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
  public static void main(String[] args) throws ExecutionException, IOException, InterruptedException {
    final SocketAddress address = new InetSocketAddress("127.0.0.1", 12345);
    final int size              = 30 * 1000 * 1000;

    ExecutorService executor = Executors.newFixedThreadPool(2);
    TheServer theServer      = new TheServer(address, size);
    TheClient theClient      = new TheClient(address, size);

    Future<String> serverFuture = executor.submit(theServer);
    Thread.sleep(2000);
    Future<String> clientFuture = executor.submit(theClient);

    System.out.println("MAIN: Received from client: " + clientFuture.get());
    System.out.println("MAIN: Received from server: " + serverFuture.get());
    executor.shutdown();
  }
}

TheClient.java:

import java.io.IOException;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Random;
import java.util.concurrent.Callable;

class TheClient implements Callable<String> {
  private TheClient() {}
  public TheClient(SocketAddress address, int size) {
    this.size = size;
    this.from = new byte[size];
    this.serverAddress = address;
    new Random().nextBytes(from);
  }

  private int           size;
  private byte[]        from;
  private SocketAddress serverAddress;

  public String call() throws IOException {
    SocketChannel socketChannel = SocketChannel.open();
    System.out.println("CLIENT: Attempting to connect to server...");
    socketChannel.connect(serverAddress);
    // <CommentOutToMakeWork>
    socketChannel.configureBlocking(false);
    // </CommentOutToMakeWork>
    System.out.println("CLIENT: Connection established. Sending " + size + " bytes.");

    // For this example, this is one large write, but even my actual
    // program, which uses a loop and puts smaller chunks onto the channel,
    // is too fast for the SocketChannel.

    socketChannel.write(ByteBuffer.wrap(from));

    System.out.println("CLIENT: Write completed.");
    return "CLIENT: Success!";
  }
}

TheServer.java:

import java.io.IOException;
import java.io.InputStream;
import java.net.SocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.util.Random;
import java.util.concurrent.Callable;

class TheServer implements Callable<String> {
  private TheServer() {}
  public TheServer(SocketAddress address, int size) {
    this.size = size;
    this.to = new byte[size];
    this.serverAddress = address;
  }
  private int           size;
  private byte[]        to;
  private SocketAddress serverAddress;

  public String call() throws IOException {
    ServerSocketChannel serverChannel = ServerSocketChannel.open().bind(serverAddress);
    System.out.println("SERVER: Awaiting connection...");
    InputStream clientSocketInputStream = serverChannel.accept().socket().getInputStream();
    System.out.println("SERVER: Connection established. Attempting to read " + size + " bytes.");
    for (int i = 0; i < size; ++i) {
      to[i] = (byte) clientSocketInputStream.read();
    }
    System.out.println("SERVER: Read completed.");
    return "SERVER: Success!";
  }
}

Answer 1

我相信答案在于WritableByteChannel.write文档:

除非另有说明,否则只有在写入所有r请求的字节后才会返回写操作.某些类型的通道(取决于它们的状态)可能只写入一些字节或者根本不写.例如,处于非阻塞模式的套接字通道不能再写入套接字输出缓冲区中可用的字节数.

因此,看起来您需要使用返回值write来查找已编写的内容,并在未完全编写时处理该情况.从描述中不清楚的是你如何处理这种情况 - 你可能会发现你需要做一些调度,以便在套接字输出缓冲区耗尽时继续写入.