Accept: примеры (JAVA)

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

Consumer.accept

import java.util.function.Consumer;

Consumer printer = s -> System.out.println("Получено: " + s);
printer.accept("hello");

Получено: hello

BiConsumer.accept (Map.forEach)

import java.util.Map;
import java.util.HashMap;

Map<String,Integer> counts = new HashMap<>();
counts.put("a",1);
counts.put("b",2);
counts.forEach((k,v) -> System.out.println(k + " -> " + v));

a -> 1
b -> 2

ServerSocket.accept (блокирующий)

import java.net.ServerSocket;
import java.net.Socket;

try (ServerSocket server = new ServerSocket(9000)) {
    Socket client = server.accept(); // блокирует пока не придёт соединение
    System.out.println("Соединение от: " + client.getRemoteSocketAddress());
}
catch (Exception e) {
    e.printStackTrace();
}

(ожидаемое поведение) блокировка до входящего клиента, затем вывод 'Соединение от: /IP:порт'

ServerSocketChannel.accept (неблокирующий)

import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;

ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.bind(new InetSocketAddress(9001));
ssc.configureBlocking(false);
SocketChannel sc = ssc.accept(); // может вернуть null
System.out.println(sc == null ? "Нет подключений" : "Есть подключение");
ssc.close();

Нет подключений

CompletableFuture.acceptEither

import java.util.concurrent.CompletableFuture;

CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> { sleep(200); return "A"; });
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> { sleep(100); return "B"; });

f1.acceptEither(f2, s -> System.out.println("Первый завершившийся: " + s));
// вспомогательная функция sleep реализована для примера

Первый завершившийся: B

Похожие методы в Java и их особенности

• Consumer.andThen - композиция двух действий: сначала выполняется текущий Consumer, затем переданный. Удобно для цепочек обработки.
• IntConsumer/LongConsumer/DoubleConsumer - примитивные специализации Consumer, исключающие автоупаковку, предпочтительны при работе с примитивами для повышения производительности.
• AsynchronousServerSocketChannel.accept(CompletionHandler) - асинхронный приём соединений с колбэком, подходит для масштабируемых неблокирующих серверов без селекторов.
• Selector + ServerSocketChannel - альтернатива для управления множеством каналов в одном потоке; предпочтение зависит от модели приложения и требований к производительности.

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

JavaScript (Node.js)

const net = require('net');
const server = net.createServer(socket => {
  console.log('Подключение от', socket.remoteAddress);
});
server.listen(9000);

(сервер принимает подключения, колбэк вызывается при каждом подключении)

Python (socket)

import socket
srv = socket.socket()
srv.bind(('0.0.0.0', 9000))
srv.listen()
conn, addr = srv.accept()
print('Соединение от', addr)

Соединение от ('127.0.0.1', 52344)

C#

using System.Net.Sockets;

var listener = new TcpListener(System.Net.IPAddress.Any, 9000);
listener.Start();
var client = listener.AcceptTcpClient(); // блокирующий
Console.WriteLine("Connected: " + client.Client.RemoteEndPoint);

Connected: 127.0.0.1:52344

Go

package main
import (
  "fmt"
  "net"
)
func main() {
  l, _ := net.Listen("tcp", ":9000")
  conn, _ := l.Accept()
  fmt.Println("Connected from", conn.RemoteAddr())
}

Connected from 127.0.0.1:52344

Kotlin - использует те же API, что и Java, при этом синтаксис лямбд и SAM-конверсии упрощает передачу Consumer:

val printer: (String) -> Unit = { println("Получено: $it") }
printer("hi")

Получено: hi

PHP - для сокетов: socket_accept(), для функционального стиля - замыкания/вызов callable через call_user_func.

$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
socket_bind($socket, '0.0.0.0', 9000);
socket_listen($socket);
$client = socket_accept($socket);
if ($client) echo "Подключён клиент\n";

Подключён клиент

Отличия: в большинстве языков сетевой "accept" - отдельный метод у слушающего сокета; функциональные эквиваленты (Consumer) реализуются через функции/делегаты/замыкания. Java выделяет интерфейсы в стандартной библиотеке (Consumer, BiConsumer) и имеет как блокирующие, так и неблокирующие/асинхронные сетевые API.

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

• NullPointerException - попытка вызвать accept на null (например, Consumer c = null; c.accept(x)). Пример:

  import java.util.function.Consumer;
  
  Consumer<String> c = null;
  c.accept("test");

  Exception in thread "main" java.lang.NullPointerException

• IOException при ServerSocket.accept() - порт занят, закрыт сокет или внутренняя ошибка ввода-вывода. Пример:

  try (ServerSocket s = new ServerSocket(1)) { /* порт привязан */ }
  // второй экземпляр
  new ServerSocket(1);

  java.net.BindException: Address already in use

• Blocking/Deadlock - блокирующий accept может остановить поток выполнения; при неправильном управлении потоками возможна потеря реакции приложения.
• Неблокирующий ServerSocketChannel.accept() - в неблокирующем режиме метод возвращает null, это не ошибка, а ожидаемое поведение; код должен это учитывать.
• Unchecked-исключения в Consumer - если внутри accept бросается RuntimeException, оно пробрасывается вызывающему потоку и может нарушить поток обработки (например, при forEach).

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

• Java 8: введён пакет java.util.function, включая интерфейсы Consumer, BiConsumer и примитивные специализации, а также метод andThen для композиции.
• Java 8 и далее: появление CompletableFuture с методами acceptEither, acceptEitherAsync для обработки результата первого завершившегося будущего.
• NIO: ServerSocketChannel и AsynchronousServerSocketChannel существуют с более ранних версий (Java 1.4 и Java 7 соответственно); добавление асинхронного API улучшило модель обработки входящих соединений.
• В последних версиях Java улучшения касались производительности и корректности, явных изменений сигнатур методов accept в стандартных API не было.

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

Композиция Consumer с andThen и обработка ошибок

import java.util.function.Consumer;

Consumer<String> log = s -> System.out.println("LOG: " + s);
Consumer<String> process = s -> {
    if (s.isEmpty()) throw new IllegalArgumentException("empty");
    System.out.println("Process: " + s.toUpperCase());
};
Consumer<String> safe = log.andThen(s -> {
    try { process.accept(s); }
    catch (Exception e) { System.err.println("Ошибка обработки: " + e.getMessage()); }
});

safe.accept("abc");
safe.accept("");

LOG: abc
Process: ABC
LOG: 
Ошибка обработки: empty

BiConsumer для обновления карты с merge

import java.util.HashMap;
import java.util.Map;

Map<String,Integer> map = new HashMap<>();
map.put("k", 1);
BiConsumer<String,Integer> updater = (k,v) -> map.merge(k, v, Integer::sum);
updater.accept("k", 5);
System.out.println(map);

{k=6}

Неблокирующий сервер с Selector и ServerSocketChannel

import java.nio.channels.*;
import java.net.InetSocketAddress;
import java.util.Iterator;

ServerSocketChannel server = ServerSocketChannel.open();
server.bind(new InetSocketAddress(9002));
server.configureBlocking(false);
Selector selector = Selector.open();
server.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
  selector.select();
  Iterator<SelectionKey> it = selector.selectedKeys().iterator();
  while (it.hasNext()) {
    SelectionKey key = it.next();
    it.remove();
    if (key.isAcceptable()) {
      ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
      SocketChannel client = ssc.accept(); // в этом контексте не null
      client.configureBlocking(false);
      client.register(selector, SelectionKey.OP_READ);
      System.out.println("Принято соединение: " + client.getRemoteAddress());
    }
    // обработка чтения/записи опущена
  }
}

(при подключении клиентов) Принято соединение: /127.0.0.1:52344

AsynchronousServerSocketChannel с CompletionHandler

import java.nio.channels.*;
import java.net.InetSocketAddress;

AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open()
    .bind(new InetSocketAddress(9003));

server.accept(null, new CompletionHandler<AsynchronousSocketChannel,Void>() {
  public void completed(AsynchronousSocketChannel ch, Void att) {
    System.out.println("Асинхронно принято: " + ch);
    server.accept(null, this); // продолжить принимать
  }
  public void failed(Throwable exc, Void att) { exc.printStackTrace(); }
});

// приложение продолжает работать, обработка в колбэках

(при подключении клиентов) Асинхронно принято: sun.nio.ch.AsynchronousSocketChannelImpl@...

acceptEither для выбора результата первого завершившегося CompletableFuture

import java.util.concurrent.*;

CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> { sleep(300); return "one"; });
CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> { sleep(100); return "two"; });

a.acceptEither(b, s -> System.out.println("winner: " + s));
// ожидается вывод от более быстрого

winner: two

Примеры показывают, как метод accept используется как в чисто функциональном контексте, так и в низкоуровневом сетевом коде; выбор подхода определяется требованиями к блокированию, масштабируемости и типу данных.