SocketChannel.read: примеры (JAVA)

Короткие примеры использования

Примеры показывают основные варианты: блокирующий/неблокирующий режим, чтение в один буфер, рассеянное чтение и значения возврата.

// Серверная часть, упрощённо
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.bind(new InetSocketAddress(5000));
SocketChannel sc = ssc.accept(); // блокирует до подключения
ByteBuffer buf = ByteBuffer.allocate(1024);
int read = sc.read(buf);
// результат в buf [position == read]

// Возможный результат
read = 128  // прочитано 128 байтов
// Если клиент закрыл соединение, read = -1

SocketChannel sc = SocketChannel.open(new InetSocketAddress("example.com", 80));
sc.configureBlocking(false);
ByteBuffer buf = ByteBuffer.allocate(256);
int read = sc.read(buf);

// Возможные результаты
read = 0   // нет данных в момент вызова
read = 30  // прочитаны данные
read = -1  // соединение закрыто удалённой стороной

SocketChannel sc = SocketChannel.open(new InetSocketAddress("localhost", 6000));
ByteBuffer h = ByteBuffer.allocate(4);
ByteBuffer b = ByteBuffer.allocate(1024);
ByteBuffer[] arr = new ByteBuffer[]{h, b};
long read = sc.read(arr); // заполняет h, затем b

// Возможный результат
read = 512  // 4 байта в h, 508 в b (в сумме 512)
read = -1   // конец потока

SocketChannel sc = SocketChannel.open();
sc.close();
try {
  ByteBuffer buf = ByteBuffer.allocate(10);
  sc.read(buf);
} catch (ClosedChannelException e) {
  // обработка
}

// Результат
ClosedChannelException выбрасывается

Похожие Java-решения и их особенности

• InputStream.read - традиционный блокирующий потоковый API (переходит от байтового потока, проще для синхронных задач).
• Channels.newInputStream(socketChannel) - адаптер, позволяющий использовать потоковый API поверх канала.
• AsynchronousSocketChannel.read - для неблокирующего асинхронного чтения с Future или CompletionHandler, полезно при большом количестве соединений без селектора.
• DatagramChannel - для UDP, если нужен безсоединительный режим.
• Socket.getInputStream / NetworkStream - при работе с высокоуровневым сокетом и потоками удобнее использовать InputStream.

Выбор зависит от требований: для низкоуровневого высокопроизводительного I/O и интеграции с селекторами предпочтительнее SocketChannel; для простоты и синхронного кода - InputStream.

Альтернативы в других языках и отличия

• Python (socket)

  import socket
  s = socket.socket()
  s.connect(('example.com', 80))
  data = s.recv(1024)

  # data - bytes, b'HTTP/1.1 ...' или b'' при закрытии

  Отличие: sync API похож по семантике; asyncio предоставляет асинхронные читатели.
• Node.js (JavaScript)

  const net = require('net');
  const s = net.connect(80, 'example.com');
  s.on('data', (chunk) => { console.log(chunk.length); });

  // Выводит длину полученных чанков

  Отличие: событийная модель, буферы и обратные вызовы вместо явного чтения.
• PHP (sockets)

  $sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
  socket_connect($sock, 'example.com', 80);
  $buf = socket_read($sock, 1024);

  // $buf - строка с полученными байтами или false при ошибке

  Отличие: процедурный API, нет ByteBuffer; управление позициями выполняется вручную.
• C# (.NET)

  var client = new TcpClient("example.com", 80);
  var ns = client.GetStream();
  byte[] buf = new byte[1024];
  int read = ns.Read(buf, 0, buf.Length);

  // read - число прочитанных байтов, 0 при удалённом закрытии

  Отличие: синхронный NetworkStream похож по семантике; имеется async/await версия ReadAsync.
• Go (Golang)

  conn, _ := net.Dial("tcp", "example.com:80")
  b := make([]byte, 1024)
  n, _ := conn.Read(b)

  // n - число прочитанных байтов, 0 при EOF

  Отличие: простая модель с интерфейсом Reader; встроенная поддержка легковесных горутин.
• Lua (LuaSocket)

  local socket = require('socket')
  s = socket.tcp()
  s:connect('example.com', 80)
  local data = s:receive(1024)

  -- data - строка или nil, err при ошибке

  Отличие: высокоуровневые функции receive упрощают чтение размеров или строк.
• Kotlin

  val channel = SocketChannel.open(InetSocketAddress("example.com", 80))
  val buf = ByteBuffer.allocate(1024)
  val read = channel.read(buf)

  // read - как в Java
  

  Отличие: API совпадает с Java; есть корутинные библиотеки для асинхронности.
• SQL - прямого соответствия нет. Для работы с BLOB в JDBC используются методы InputStream из ResultSet.

Ключевые отличия: в Java NIO присутствуют ByteBuffer и возможность рассеивающего чтения, в других языках чаще используются простые массивы байтов и событийные либо блокирующие модели.

Типичные ошибки при использовании

• Необработанное значение -1. Пример ошибки:

  int r = channel.read(buf);
  // далее используется buf без проверки r == -1

  // При EOF данные не обновляются, последующая логика может работать с мусором

• Забыть вызвать flip() перед чтением из буфера после записи:

  ByteBuffer buf = ByteBuffer.allocate(10);
  channel.read(buf);
  // читаем байты напрямую из buf.array() без flip

  // position указывает на конец записи; чтение с позиции 0 выдаст не те данные или пустоту

• Попытка чтения в заполненный буфер (limit == position): вернёт 0. Частая причина - неправильное управление позициями.
• Использование неблокирующего канала без селектора и ожидания: постоянные вызовы read могут вернуть 0 и вызвать спинлок.
• Игнорирование исключений асинхронного закрытия: закрытие канала из другой нити может привести к AsynchronousCloseException.
• Неверное использование array-backed буфера: ByteBuffer.wrap(byte[]) устанавливает position 0; при неправильном limit часть данных может быть перезаписана.

Пример корректной обработки EOF и flip:

ByteBuffer buf = ByteBuffer.allocate(256);
int r = channel.read(buf);
if (r < 0) {
  // EOF
} else if (r == 0) {
  // нет данных сейчас
} else {
  buf.flip();
  byte[] out = new byte[buf.remaining()];
  buf.get(out);
}

// Корректная обработка чтения

Изменения и история

API SocketChannel.read формировался вместе с NIO (Java 1.4) и оставался стабильным в последующих релизах Java. Ключевые события:

• Java 1.4 - введение NIO и SocketChannel/ScatteringByteChannel.
• Java 7 - добавлен AsynchronousSocketChannel для асинхронного неблокирующего I/O (а не изменение SocketChannel.read).
• Последние релизы - оптимизации производительности и внутренние улучшения JVM и сетевых подсистем; сигнатуры метода остались прежними.

Следует учитывать, что в новых версиях появляются расширенные опции сокетов в java.net.StandardSocketOptions, которые влияют на поведение канала на уровне ОС (например, TCP_NODELAY, SO_RCVBUF). Эти опции не меняют семантику read, но влияют на поток данных.

Расширенные и редкие сценарии использования

Несколько подробных примеров с пояснениями: селектор, рассеянное чтение с частичным заполнением, декодирование текста, чтение и запись в файл.

Selector sel = Selector.open();
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.bind(new InetSocketAddress(7000));
ssc.configureBlocking(false);
ssc.register(sel, SelectionKey.OP_ACCEPT);
while (true) {
  sel.select();
  Iterator<SelectionKey> it = sel.selectedKeys().iterator();
  while (it.hasNext()) {
    SelectionKey key = it.next();
    it.remove();
    if (key.isAcceptable()) {
      SocketChannel sc = ssc.accept();
      sc.configureBlocking(false);
      sc.register(sel, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
    } else if (key.isReadable()) {
      SocketChannel sc = (SocketChannel) key.channel();
      ByteBuffer buf = (ByteBuffer) key.attachment();
      int r = sc.read(buf);
      if (r < 0) {
        sc.close();
      } else if (r > 0) {
        buf.flip();
        // обработка buf
        buf.compact();
      }
    }
  }
}

// Сервер может обслуживать много соединений без выделения отдельной нити на каждое

SocketChannel sc = SocketChannel.open(...);
ByteBuffer h = ByteBuffer.allocate(8); // заголовок
ByteBuffer p = ByteBuffer.allocate(1024); // тело
ByteBuffer[] bufs = {h, p};
long n = 0;
while (n < 12) { // читается минимум 12 байт для примера
  long r = sc.read(bufs);
  if (r < 0) break;
  n += r;
}
// h может быть заполнен полностью, а p частично

// n = фактическое число прочитанных байтов; распределение между h и p зависит от поступающих данных

CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
ByteBuffer buf = ByteBuffer.allocate(512);
CharBuffer cb = CharBuffer.allocate(512);
while (channel.read(buf) >= 0) {
  buf.flip();
  CoderResult res = decoder.decode(buf, cb, false);
  buf.compact();
  cb.flip();
  // обработка символов в cb
  cb.compact();
}
// затем завершить декодирование
buf.flip();
decoder.decode(buf, cb, true);
decoder.flush(cb);

// Корректная обработка многобайтовых символов, размеченных между пакетами

try (SocketChannel sc = SocketChannel.open(new InetSocketAddress("remote", 9000));
     FileChannel fc = FileChannel.open(Paths.get("out.bin"), StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
  ByteBuffer buf = ByteBuffer.allocateDirect(8192);
  while (true) {
    buf.clear();
    int r = sc.read(buf);
    if (r < 0) break;
    if (r == 0) continue; // в неблокирующем режиме может быть 0
    buf.flip();
    while (buf.hasRemaining()) fc.write(buf);
  }
}

// Содержимое сетевого потока записано в файл efficiently

SocketChannel sc = SocketChannel.open(...);
Thread t = new Thread(() -> {
  try {
    ByteBuffer b = ByteBuffer.allocate(1024);
    while (sc.read(b) >= 0) {
      b.clear();
    }
  } catch (ClosedByInterruptException e) {
    // поток был прерван, канал закрыт автоматически
  } catch (IOException e) {
    // другие ошибки
  }
});
t.start();
// где-то позже
t.interrupt(); // может вызвать ClosedByInterruptException

// Поведение демонстрирует взаимодействие прерываний и закрытия канала