• Примитивного типа

• capacity() — общий размер
• limit() — доступный размер
• position() — текущее положение
• remaining() — остаток

• Относительное: get(), get(T[]), get(T[], offset, length)
• Абсолютное: get(index, ...)

• Относительная: put(T), put(T[]), put(T[], offset, length)
• Абсолютная: put(index, ...)
• ReadOnlyBufferException

• T: Byte, Short, Char, Int, Long, Float, Double

• TBuffer.allocate(size)

• byteBuffer.asTBuffer()

• getT(), getT(int)

• putT(), putT(int, T)

• order(), order(byteOrder)
• BIG/LITTLE_ENDIAN

• TBuffer.wrap(T[]) – пустой
• TBuffer.wrap(T[], offset, length) – заполненный

• hasArray()

• array()
• arrayOffset() – начало сдвинутого буфера в массиве

• allocateDirect(size)

• asTBuffer()

• isDirect()

• Проверить isOpen()
• Закрыть close()
• Действие с закрытым каналом ClosedChannelException

• int read(byteBuffer)

• int write(byteBuffer)
• Не всегда полностью

• long read(buffers)
• long read(buffers, offset, length)

• long write(buffers)
• long write(buffers, offset, length)

• Текущая позиция position(), position(long)
• Размер size()
• Уменьшение размера truncate(long)

• Ожидающие ввода-вывода получают AsynchronousCloseException

• Thread.interrupt()
• Канал закрывается
• Поток получает ClosedByInterruptException

• instanceof

• Отображение в память
• Потокобезопасность на блокировках

• FileChannel.open(path, options...)
• fileInputStream.getChannel()
• fileOutputStream.getChannel()
• randomAccessFile.getChannel()

• Чтение read(buffer, position)
• Запись write(buffer, position)

• Всех force(true)
• Без метаданных force(false)

• От себя transferTo(position, n, writableBC)
• К себе transferFrom(readableBC, position, n)

• Только для чтения READ_ONLY
• Копирование при записи PRIVATE
• Разделяемый режим READ_WRITE

• Запись изменений force()
• Загрузить целиком load()

• fileChannel.lock(position, size, shared)
• fileChannel.tryLock(position, size, shared)

• Канал Channel acquiredBy()
• Место и размер position(), size()
• Разделяемость isShared()
• Корректность (не отпущена и канал не закрыт) isValid()

• Привязать bind(socketAddress)
• Узнать порт getLocalAddress()

• Установить setOption(socketOption, value)
• Узнать getOption(socketOption)
• Существующие настройки supportedOptions()

• Размер приёмного буфера SO_RCVBUF
• Переиспользование адреса SO_REUSEADDR

• Изменение configureBlocking(boolean)
• Проверка isBlocking()

• Зарегистрироваться register(selector, ops, context)
• Проверить isRegistered()
• Сертификат keyFor(selector)

• Запись OP_READ
• Чтение OP_WRITE
• Установление соединения OP_CONNECT
• Ожидание соединения OP_ACCEPT

• Создание Selector.open()

• Ожидание select(timeout?)
• Обработка select(consumer<SelectionKey>, timeout?)
• Сколько готовых selectNow()
• Получить готовых selectedKeys()
• Разбудить ждущего wakeup()

• Контекст attachment(), attach(context)
• Доступные действия readyOps(), isReadable(), isWritable(), isConnectable(), isAcceptable()
• Множество интересов interestOps(), interestOps(ops)
• Канал channel()
• Селектор selector()

while (!Thread.interrupted()) {
    selector.select();
    for (final Iterator<SelectionKey> i =
            selector.selectedKeys().iterator(); i.hasNext(); ) {
        final SelectionKey key = i.next();
        try {
            if (key.isAcceptable()) {
                final ServerSocketChannel serverChannel =
                    (ServerSocketChannel) key.channel();
                handle(serverChannel.accept());
            }
        } finally {
            i.remove();
        }
    }
}

while (!Thread.interrupted()) {
    selector.select(key -> {
        try {
            if (key.isAcceptable()) {
                final ServerSocketChannel serverChannel =
                    (ServerSocketChannel) key.channel();
                handle(serverChannel.accept());
            }
        } catch (final IOException e) {
            throw new UncheckedIOException(e);
        }
    });
}

• Не привязанный SocketChannel.open()
• Подсоединенный SocketChannel.open(socketAddress)

• Установить connect(socketAddress)
• Проверить isConnected(), isConnectionPending()
• Дождаться finishConnect()

• Получить сокет socket()
• Прекратить shutdownInput(), shutdownOutput()

• DatagramChannel.open()

• Установить connect(socketAddress)
• Проверить isConnected()
• Разорвать disconnect()

• Получить сокет socket()
• Послать пакет send(buffer, socketAddress)
• Получить пакет SocketAddress receive(buffer)

• Создание Pipe.open()

• Ввода Pipe.SourceChannel source()
• Вывода Pipe.SinkChannel sink()

• Результат типа V
• Future<V> op(...)
• op(..., A attachment, CompletionHandler<V, A>)

• cancel(mayInterruptWhenRunning)
• Операция выполнена частично ⇒ всё сломалось, повторить нельзя

• Успех completed(V value, A att)
• Ошибка failed(throwable, A att)

socketChannel.read(
    buffer,
    context,
    new CompletionHandler<Integer, Context>() {
        public void completed(Integer result, Context context) {
            if (context.process(result)) {
                socketChannel.read(buffer, this);
            }
        }
        public void failed(Throwable e, Context context) {
            context.error(e);
        }
    }
);

• Чтение read(buffer), read(buffer, att, handler)
• Запись write(buffer), write(buffer, att, handler)
• Результат ❬Integer❭ n — число байт
• Параллельная запись может не поддерживаться

• Не привязанный ASC.open()

• Привязать bind(socketAddress)
• Прекратить ввод shutdownInput(),
• Прекратить вывод shutdownOutput()

• ❬Void❭ connect(socketAddress, ...)

• Не привязанный ASSC.open()

• Привязать bind(socketAddress, backlog?)

• ❬AsynchronousSocketChannel❭ accept(...)
• AcceptPendingException

• Создание AFC.open(file, options...)

• ❬Integer❭ read(buffer, position, ...)
• ❬Integer❭ write(buffer, position, ...)

• ❬FileLock❭ lock(...)
• ❬FileLock❭ lock(position, size, shared, ...)

• Сброс кэшей force(metaData)
• Блокировка tryLock(), tryLock(position, size, shared)

• ACG.withThreadPool(executor)
• ACG.withCachedThreadPool(executor, min)
• ACG.withFixedThreadPool(threads, threadFactory)

• ASSC.open(group), ASC.open(group)

• shutdown(), shutdownNow(), isShutdown()
• isTerminated(), awaitTermination(time, unit)

• newChannel(inputStream)

• newInputStream(channel)
• newOutputStream(channel)

• newReader(channel, charset)
• newWriter(channel, charset)

• Возможно — разных

• Стек
• Thread locals

try (
  ExecutorService executor = Executors
      .newVirtualThreadPerTaskExecutor()
) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
}

• Ввод-вывод, очереди, future

  // +
  response.send(
      future1.get() // ‒
      +                   // +
      future2.get() // ‒
  ); // +
  

• synchronized
• native

• startVirtualThread(runnable)
• thread.isVirtual()
• Всегда daemon, NORM_PRIORITY

• Thread start(runnable)
• Thread unstarted(runnable)
• ThreadFactory factory()

• Thread.ofVirtual()
• Thread.ofPlatform()