Java SelectionKey.OP_ACCEPT属性代码示例

public void registerForEvent(EventHandler eventHandler)
{
    if (orb.transportDebugFlag) {
        dprint(".registerForEvent: " + eventHandler);
    }

    if (isClosed()) {
        if (orb.transportDebugFlag) {
            dprint(".registerForEvent: closed: " + eventHandler);
        }
        return;
    }

    if (eventHandler.shouldUseSelectThreadToWait()) {
        synchronized (deferredRegistrations) {
            deferredRegistrations.add(eventHandler);
        }
        if (! selectorStarted) {
            startSelector();
        }
        selector.wakeup();
        return;
    }

    switch (eventHandler.getInterestOps()) {
    case SelectionKey.OP_ACCEPT :
        createListenerThread(eventHandler);
        break;
    case SelectionKey.OP_READ :
        createReaderThread(eventHandler);
        break;
    default:
        if (orb.transportDebugFlag) {
            dprint(".registerForEvent: default: " + eventHandler);
        }
        throw new RuntimeException(
            "SelectorImpl.registerForEvent: unknown interest ops");
    }
}
 

public void unregisterForEvent(EventHandler eventHandler)
{
    if (orb.transportDebugFlag) {
        dprint(".unregisterForEvent: " + eventHandler);
    }

    if (isClosed()) {
        if (orb.transportDebugFlag) {
            dprint(".unregisterForEvent: closed: " + eventHandler);
        }
        return;
    }

    if (eventHandler.shouldUseSelectThreadToWait()) {
        SelectionKey selectionKey ;
        synchronized(deferredRegistrations) {
            selectionKey = eventHandler.getSelectionKey();
        }
        if (selectionKey != null) {
            selectionKey.cancel();
        }
        selector.wakeup();
        return;
    }

    switch (eventHandler.getInterestOps()) {
    case SelectionKey.OP_ACCEPT :
        destroyListenerThread(eventHandler);
        break;
    case SelectionKey.OP_READ :
        destroyReaderThread(eventHandler);
        break;
    default:
        if (orb.transportDebugFlag) {
            dprint(".unregisterForEvent: default: " + eventHandler);
        }
        throw new RuntimeException(
            "SelectorImpl.uregisterForEvent: unknown interest ops");
    }
}
 

/**
 * Translates native poll revent ops into a ready operation ops
 */
private boolean translateReadyOps(int ops, int initialOps,
                                 SelectionKeyImpl sk) {
    int intOps = sk.nioInterestOps();
    int oldOps = sk.nioReadyOps();
    int newOps = initialOps;

    if ((ops & Net.POLLNVAL) != 0) {
        /* This should only happen if this channel is pre-closed while a
         * selection operation is in progress
         * ## Throw an error if this channel has not been pre-closed */
        return false;
    }

    if ((ops & (Net.POLLERR | Net.POLLHUP)) != 0) {
        newOps = intOps;
        sk.nioReadyOps(newOps);
        return (newOps & ~oldOps) != 0;
    }

    if (((ops & Net.POLLIN) != 0) &&
        ((intOps & SelectionKey.OP_ACCEPT) != 0))
            newOps |= SelectionKey.OP_ACCEPT;

    sk.nioReadyOps(newOps);
    return (newOps & ~oldOps) != 0;
}
 

@Override
public void translateAndSetInterestOps(int ops, SelectionKeyImpl sk) {
    int newOps = 0;

    /* Translate ops */
    if ((ops & SelectionKey.OP_ACCEPT) != 0)
        newOps |= Net.POLLIN;
    /* Place ops into pollfd array */
    sk.selector.putEventOps(sk, newOps);

}
 

@SuppressWarnings("InfiniteLoopStatement")
public void start() throws Exception {

    try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()) {
        serverSocketChannel.bind(new InetSocketAddress("localhost", PORT));

        serverSocketChannel.configureBlocking(false); //non blocking mode
        int ops = SelectionKey.OP_ACCEPT;
        Selector selector = Selector.open();
        serverSocketChannel.register(selector, ops, null);

        logger.info("Started on port: " + PORT);

        while (true) {
            selector.select();//blocks
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                try {
                    if (key.isAcceptable()) {
                        SocketChannel client = serverSocketChannel.accept(); //non blocking accept
                        System.out.println("Connection Accepted: " + client.getLocalAddress());

                        client.configureBlocking(false);
                        client.register(selector, SelectionKey.OP_READ);

                    } else if (key.isReadable()) {
                        SocketChannel channel = (SocketChannel) key.channel();

                        ByteBuffer buffer = ByteBuffer.allocate(CAPACITY);
                        int read = channel.read(buffer);
                        if (read != -1) {
                            String result = new String(buffer.array()).trim();
                            if (!result.isEmpty())
                                System.out.println("Message received: " + result + " from: " + channel.getRemoteAddress());
                        } else {
                            key.cancel();
                            System.out.println("Connection closed, key canceled");
                        }
                    }
                } catch (IOException e) {
                    logger.log(Level.SEVERE, e.getMessage());
                } finally {
                    iterator.remove();
                }
            }
        }
    }
}
 

public int getInterestOps()
{
    return SelectionKey.OP_ACCEPT;
}
 

protected int doSelect(long timeout) throws IOException
{
    if (channelArray == null)
        throw new ClosedSelectorException();
    processDeregisterQueue();
    if (interruptTriggered)
    {
        resetWakeupSocket();
        return 0;
    }

    ArrayList read = new ArrayList();
    ArrayList write = new ArrayList();
    ArrayList error = new ArrayList();
    for (int i = 0; i < channelArray.get_Count(); i++)
    {
        SelectionKeyImpl ski = (SelectionKeyImpl)channelArray.get_Item(i);
        int ops = ski.interestOps();
        if (ski.channel() instanceof SocketChannelImpl)
        {
            // TODO there's a race condition here...
            if (((SocketChannelImpl)ski.channel()).isConnected())
            {
                ops &= SelectionKey.OP_READ | SelectionKey.OP_WRITE;
            }
            else
            {
                ops &= SelectionKey.OP_CONNECT;
            }
        }
        if ((ops & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0)
        {
            read.Add(ski.getSocket());
        }
        if ((ops & (SelectionKey.OP_WRITE | SelectionKey.OP_CONNECT)) != 0)
        {
            write.Add(ski.getSocket());
        }
        if ((ops & SelectionKey.OP_CONNECT) != 0)
        {
            error.Add(ski.getSocket());
        }
    }
    read.Add(wakeupSourceFd);
    try
    {
        begin();
        int microSeconds = 1000 * (int)Math.min(Integer.MAX_VALUE / 1000, timeout);
        try
        {
            if (false) throw new SocketException();
            // FXBUG docs say that -1 is infinite timeout, but that doesn't appear to work
            Socket.Select(read, write, error, timeout < 0 ? Integer.MAX_VALUE : microSeconds);
        }
        catch (SocketException _)
        {
            read.Clear();
            write.Clear();
            error.Clear();
        }
    }
    finally
    {
        end();
    }
    processDeregisterQueue();
    int updated = updateSelectedKeys(read, write, error);
    // Done with poll(). Set wakeupSocket to nonsignaled  for the next run.
    resetWakeupSocket();
    return updated;
}
 

public void unregisterForEvent(EventHandler eventHandler)
{
    if (orb.transportDebugFlag) {
        dprint(".unregisterForEvent: " + eventHandler);
    }

    if (isClosed()) {
        if (orb.transportDebugFlag) {
            dprint(".unregisterForEvent: closed: " + eventHandler);
        }
        return;
    }

    if (eventHandler.shouldUseSelectThreadToWait()) {
        SelectionKey selectionKey ;
        synchronized(deferredRegistrations) {
            selectionKey = eventHandler.getSelectionKey();
        }
        if (selectionKey != null) {
            selectionKey.cancel();
        }
        if (selector != null) {
            selector.wakeup();
        }
        return;
    }

    switch (eventHandler.getInterestOps()) {
    case SelectionKey.OP_ACCEPT :
        destroyListenerThread(eventHandler);
        break;
    case SelectionKey.OP_READ :
        destroyReaderThread(eventHandler);
        break;
    default:
        if (orb.transportDebugFlag) {
            dprint(".unregisterForEvent: default: " + eventHandler);
        }
        throw new RuntimeException(
            "SelectorImpl.uregisterForEvent: unknown interest ops");
    }
}
 

/**
 * Returns an operation set identifying this channel's supported
 * operations.
 *
 * <P> SCTP server channels only support the accepting of new
 * associations, so this method returns
 * {@link java.nio.channels.SelectionKey#OP_ACCEPT}.
 *
 * @return  The valid-operation set
 */
@Override
public final int validOps() {
    return SelectionKey.OP_ACCEPT;
}