버퍼/채널 방식 보드게임 제작에 사용된 라이브러리 정리

import java.io.IOException;
import java.net.InetSocketAddress;              // 1
import java.nio.channels.SelectionKey;          // 2
import java.nio.channels.Selector;              // 3
import java.nio.channels.ServerSocketChannel;   // 4
import java.nio.channels.SocketChannel;         // 5
import java.util.*;
import java.util.concurrent.TimeUnit;           // 6

import java.io.IOException;
import java.nio.channels.SocketChannel;
import java.util.Random;
import java.util.concurrent.TimeUnit;

import java.io.IOException;
import java.nio.ByteBuffer;             // 1
import java.nio.channels.SocketChannel;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.security.SecureRandom;
import java.util.*;

import java.nio.channels.SocketChannel;
import java.util.StringTokenizer;       // 1

selector = Selector.open();

public static Selector open() throws IOException {
    return SelectorProvider.provider().openSelector();
}

ServerSocketChannel sschannel = ServerSocketChannel.open();

public static ServerSocketChannel open() throws IOException {
    return SelectorProvider.provider().openServerSocketChannel();
}

sschannel.bind(new InetSocketAddress(5001));

public InetSocketAddress(int port) {
    this(InetAddress.anyLocalAddress(), port);
}

sschannel.bind(new InetSocketAddress(5001));

public final ServerSocketChannel bind(SocketAddress local) throws IOException {
    return bind(local, 0);
}

sschannel.configureBlocking(false);

public final SelectableChannel configureBlocking(boolean block) throws IOException {
    synchronized (regLock) {
        if (!isOpen())
            throw new ClosedChannelException();
        boolean blocking = !nonBlocking;
        if (block != blocking) {
            if (block && haveValidKeys())
                throw new IllegalBlockingModeException();
            implConfigureBlocking(block);
            nonBlocking = !block;
        }
    }
    return this;
}

sschannel.register(selector, SelectionKey.OP_ACCEPT);

public final SelectionKey register(Selector sel, int ops)
    throws ClosedChannelException
{
    return register(sel, ops, null);
}

selector.select();

Set<SelectionKey> keys = selector.selectedKeys();

Iterator<SelectionKey> iterator = keys.iterator();

if (key.isAcceptable()) {
    SocketChannel client = sschannel.accept();
}

socketChannel.read(byteBuffer)

public int read(ByteBuffer buf) throws IOException {
Objects.requireNonNull(buf);

readLock.lock();
try {
    ensureOpenAndConnected();
    boolean blocking = isBlocking();
    int n = 0;
    try {
        beginRead(blocking);

        // check if connection has been reset
        if (connectionReset)
            throwConnectionReset();

        // check if input is shutdown
        if (isInputClosed)
            return IOStatus.EOF;

        configureSocketNonBlockingIfVirtualThread();
        n = IOUtil.read(fd, buf, -1, nd);       // 1
        if (blocking) {
            while (IOStatus.okayToRetry(n) && isOpen()) {
                park(Net.POLLIN);
                n = IOUtil.read(fd, buf, -1, nd);
            }
        }
    } catch (ConnectionResetException e) {
        connectionReset = true;
        throwConnectionReset();
    } finally {
        endRead(blocking, n > 0);
        if (n <= 0 && isInputClosed)
            return IOStatus.EOF;
    }
    return IOStatus.normalize(n);               // 2
} finally {
    readLock.unlock();
}

socketChannel.write(buffer);

@Override
public int write(ByteBuffer buf) throws IOException {
    Objects.requireNonNull(buf);
    writeLock.lock();
    try {
        ensureOpenAndConnected();
        boolean blocking = isBlocking();
        int n = 0;
        try {
            beginWrite(blocking);
            configureSocketNonBlockingIfVirtualThread();
            n = IOUtil.write(fd, buf, -1, nd);  // 1
            if (blocking) {
                while (IOStatus.okayToRetry(n) && isOpen()) {
                    park(Net.POLLOUT);
                    n = IOUtil.write(fd, buf, -1, nd);
                }
            }
        } finally {
            endWrite(blocking, n > 0);
            if (n <= 0 && isOutputClosed)
                throw new AsynchronousCloseException();
        }
        return IOStatus.normalize(n);
    } finally {
        writeLock.unlock();
    }
}

StringTokenizer tokenizer = new StringTokenizer(received, "#"); // 1
String what = tokenizer.nextToken();                            // 2
String data = tokenizer.nextToken();                            // 2

public StringTokenizer(String str, String delim) {      // 1
    this(str, delim, false);
}

public StringTokenizer(String str, String delim, boolean returnDelims) {    // 2
    currentPosition = 0;
    newPosition = -1;
    delimsChanged = false;
    this.str = str;
    maxPosition = str.length();
    delimiters = delim;
    retDelims = returnDelims;
    setMaxDelimCodePoint();
}

private void setMaxDelimCodePoint() {       // 3
    if (delimiters == null) {
        maxDelimCodePoint = 0;
        return;
    }

    int m = 0;
    int c;
    int count = 0;
    for (int i = 0; i < delimiters.length(); i += Character.charCount(c)) {
        c = delimiters.charAt(i);
        if (c >= Character.MIN_HIGH_SURROGATE && c <= Character.MAX_LOW_SURROGATE) {
            c = delimiters.codePointAt(i);
            hasSurrogates = true;
        }
        if (m < c)
            m = c;
        count++;
    }
    maxDelimCodePoint = m;

    if (hasSurrogates) {
        delimiterCodePoints = new int[count];
        for (int i = 0, j = 0; i < count; i++, j += Character.charCount(c)) {
            c = delimiters.codePointAt(j);
            delimiterCodePoints[i] = c;
        }
    }
}