java.nio.channels.Selector Java Examples

@Override
public void run() {
	final Selector selector = this.selector;
	for (;;) {
		++acceptCount;
		try {
			selector.select(1000L);
			Set<SelectionKey> keys = selector.selectedKeys();
			try {
				for (SelectionKey key : keys) {
					if (key.isValid() && key.isAcceptable()) {
						accept();
					} else {
						key.cancel();
					}
				}
			} finally {
				keys.clear();
			}
		} catch (Throwable e) {
			LOGGER.warn(getName(), e);
		}
	}
}
 

public static void main(String argv[]) throws Exception {
    int waitTime = 4000;
    Selector selector = Selector.open();
    try {
        selector.wakeup();

        long t1 = System.currentTimeMillis();
        selector.select(waitTime);
        long t2 = System.currentTimeMillis();
        long totalTime = t2 - t1;

        if (totalTime > waitTime)
            throw new RuntimeException("Test failed");
    } finally {
        selector.close();
    }
}
 

public SelectorThread(final SelectorConfig sc, final IMMOExecutor<T> executor, final IPacketHandler<T> packetHandler, final IClientFactory<T> clientFactory, final IAcceptFilter acceptFilter) throws IOException
{
    super.setName("SelectorThread-" + super.getId());

    HELPER_BUFFER_SIZE = sc.HELPER_BUFFER_SIZE;
    HELPER_BUFFER_COUNT = sc.HELPER_BUFFER_COUNT;
    MAX_SEND_PER_PASS = sc.MAX_SEND_PER_PASS;
    MAX_READ_PER_PASS = sc.MAX_READ_PER_PASS;
    SLEEP_TIME = sc.SLEEP_TIME;
    DIRECT_WRITE_BUFFER = ByteBuffer.allocateDirect(sc.WRITE_BUFFER_SIZE) .order(BYTE_ORDER);
    WRITE_BUFFER = ByteBuffer.wrap(new byte[sc.WRITE_BUFFER_SIZE]).order(BYTE_ORDER);
    READ_BUFFER = ByteBuffer.wrap(new byte[sc.READ_BUFFER_SIZE]).order(BYTE_ORDER);
    STRING_BUFFER = new NioNetStringBuffer(64 * 1024);
    _pendingClose = new NioNetStackList<MMOConnection<T>>();
    _bufferPool = new ArrayList<>();
    
    for (int i = 0; i < HELPER_BUFFER_COUNT; i++)
        _bufferPool.add(_bufferPool.size(), ByteBuffer.wrap(new byte[HELPER_BUFFER_SIZE]).order(BYTE_ORDER));

    _acceptFilter = acceptFilter;
    _packetHandler = packetHandler;
    _clientFactory = clientFactory;
    _executor = executor;
    _selector = Selector.open();
}
 

protected Selector getSharedSelector() throws IOException {
    if (SHARED && SHARED_SELECTOR == null) {
        synchronized ( NioSelectorPool.class ) {
            if ( SHARED_SELECTOR == null )  {
                synchronized (Selector.class) {
                    // Selector.open() isn't thread safe
                    // http://bugs.sun.com/view_bug.do?bug_id=6427854
                    // Affects 1.6.0_29, fixed in 1.7.0_01
                    SHARED_SELECTOR = Selector.open();
                }
                log.info("Using a shared selector for servlet write/read");
            }
        }
    }
    return  SHARED_SELECTOR;
}
 

public static NioSelectedKeySet keySet(final Selector selector)
{
    NioSelectedKeySet tmpSet = null;

    if (null != PUBLIC_SELECTED_KEYS_FIELD)
    {
        try
        {
            tmpSet = new NioSelectedKeySet();

            SELECTED_KEYS_FIELD.set(selector, tmpSet);
            PUBLIC_SELECTED_KEYS_FIELD.set(selector, tmpSet);
        }
        catch (final Exception ignore)
        {
            tmpSet = null;
        }
    }

    return tmpSet;
}
 

/**
 * @tests AbstractSelectableChannel#configureBlocking(boolean)
 */
public void test_configureBlocking_Z_IllegalBlockingMode() throws Exception {
    SocketChannel sc = SocketChannel.open();
    sc.configureBlocking(false);
    Selector acceptSelector = SelectorProvider.provider().openSelector();
    SelectionKey acceptKey = sc.register(acceptSelector,
            SelectionKey.OP_READ, null);
    assertEquals(sc.keyFor(acceptSelector), acceptKey);
    SelectableChannel getChannel = sc.configureBlocking(false);
    assertEquals(getChannel, sc);
    try {
        sc.configureBlocking(true);
        fail("Should throw IllegalBlockingModeException");
    } catch (IllegalBlockingModeException e) {
        // expected
    }
}
 

public Listener() throws IOException {
  address = new InetSocketAddress(bindAddress, port);
  // Create a new server socket and set to non blocking mode
  acceptChannel = ServerSocketChannel.open();
  acceptChannel.configureBlocking(false);

  // Bind the server socket to the local host and port
  bind(acceptChannel.socket(), address, backlogLength);
  port = acceptChannel.socket().getLocalPort(); //Could be an ephemeral port
  // create a selector;
  selector= Selector.open();

  // Register accepts on the server socket with the selector.
  acceptChannel.register(selector, SelectionKey.OP_ACCEPT);
  this.setName("IPC Server listener on " + port);
  this.setDaemon(true);
}
 

public static void main(String[] args) throws Exception {
    final Selector sel = Selector.open();

    Runnable r = new Runnable() {
        public void run() {
            try {
                sel.select();
            } catch (IOException x) {
                x.printStackTrace();
            }
        }
    };

    // start thread to block in Selector
    Thread t = new Thread(r);
    t.start();

    // give thread time to start
    Thread.sleep(1000);

    // interrupt, close, and wakeup is the magic sequence to provoke the NPE
    t.interrupt();
    sel.close();
    sel.wakeup();
}
 

private void startSelector()
{
    try {
        selector = Selector.open();
    } catch (IOException e) {
        if (orb.transportDebugFlag) {
            dprint(".startSelector: Selector.open: IOException: ", e);
        }
        // REVISIT - better handling/reporting
        RuntimeException rte =
            new RuntimeException(".startSelector: Selector.open exception");
        rte.initCause(e);
        throw rte;
    }
    setDaemon(true);
    start();
    selectorStarted = true;
    if (orb.transportDebugFlag) {
        dprint(".startSelector: selector.start completed.");
    }
}
 

protected void clearOpWrite(AbstractNioChannel<?> channel) {
    Selector selector = this.selector;
    SelectionKey key = channel.channel.keyFor(selector);
    if (key == null) {
        return;
    }
    if (!key.isValid()) {
        close(key);
        return;
    }

    int interestOps = channel.getRawInterestOps();
    if ((interestOps & SelectionKey.OP_WRITE) != 0) {
        interestOps &= ~SelectionKey.OP_WRITE;
        key.interestOps(interestOps);
        channel.setRawInterestOpsNow(interestOps);
    }
}
 

@Test
void selectorRemovesKeysOnChannelCloseWhenSelecting() throws Exception {
  Pipe pipe = Pipe.open();

  Selector selector = Selector.open();
  SelectableChannel source = pipe.source();
  source.configureBlocking(false);

  SelectionKey key = source.register(selector, OP_READ);
  assertTrue(selector.keys().contains(key));

  source.close();
  assertTrue(selector.keys().contains(key));

  selector.selectNow();
  assertFalse(selector.keys().contains(key));
}
 

public void put(Selector s) throws IOException {
    if ( SHARED ) return;
    if ( enabled ) active.decrementAndGet();
    if ( enabled && (maxSpareSelectors==-1 || spare.get() < Math.min(maxSpareSelectors,maxSelectors)) ) {
        spare.incrementAndGet();
        selectors.offer(s);
    }
    else s.close();
}
 

@Test
public void testRebuildSelector() throws Exception {
    EventLoopGroup group = new NioEventLoopGroup(1);
    final NioEventLoop loop = (NioEventLoop) group.next();
    try {
        Channel channel = new NioServerSocketChannel();
        loop.register(channel).syncUninterruptibly();

        Selector selector = loop.unwrappedSelector();
        assertSame(selector, ((NioEventLoop) channel.eventLoop()).unwrappedSelector());
        assertTrue(selector.isOpen());

        // Submit to the EventLoop so we are sure its really executed in a non-async manner.
        loop.submit(new Runnable() {
            @Override
            public void run() {
                loop.rebuildSelector();
            }
        }).syncUninterruptibly();

        Selector newSelector = ((NioEventLoop) channel.eventLoop()).unwrappedSelector();
        assertTrue(newSelector.isOpen());
        assertNotSame(selector, newSelector);
        assertFalse(selector.isOpen());

        channel.close().syncUninterruptibly();
    } finally {
        group.shutdownGracefully();
    }
}
 

/** wake up the selector thread */
private void wakeupSelector() {
  Selector s = getSelector();
  if (s != null && s.isOpen()) {
    this.selector.wakeup();
  }
}
 

public void registerSelector(Selector selector) {
  try {
    // Register the server socket channel, indicating an interest in
    // accepting new connections
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
  } catch (ClosedChannelException e) {
    // this shouldn't happen, ideally...
    // TODO: decide what to do with this.
  }
}
 

/**
 * Receive messages. Invoke the message listener on each message. Continue
 * until a packet indicating the End of Session is received.
 *
 * @param multicastInterface the multicast interface
 * @param multicastGroup the multicast group
 * @param requestAddress the request address
 * @param listener a message listener
 * @throws IOException if an I/O error occurs
 */
public static void receive(NetworkInterface multicastInterface,
        InetSocketAddress multicastGroup, InetSocketAddress requestAddress,
        MessageListener listener) throws IOException {
    DatagramChannel channel = DatagramChannel.open(StandardProtocolFamily.INET);

    channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
    channel.bind(new InetSocketAddress(multicastGroup.getPort()));
    channel.join(multicastGroup.getAddress(), multicastInterface);
    channel.configureBlocking(false);

    DatagramChannel requestChannel = DatagramChannel.open(StandardProtocolFamily.INET);

    requestChannel.configureBlocking(false);

    StatusListener statusListener = new StatusListener();

    try (Selector selector = Selector.open();
            MoldUDP64Client client = new MoldUDP64Client(channel, requestChannel,
                requestAddress, listener, statusListener)) {
        SelectionKey channelKey = channel.register(selector, SelectionKey.OP_READ);

        SelectionKey requestChannelKey = requestChannel.register(selector, SelectionKey.OP_READ);

        while (statusListener.receive) {
            while (selector.select() == 0);

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

            if (selectedKeys.contains(channelKey))
                client.receive();

            if (selectedKeys.contains(requestChannelKey))
                client.receiveResponse();

            selectedKeys.clear();
        }
    }
}
 

/**
 * Replaces the selected keys field from {@link java.util.HashSet} in {@link sun.nio.ch.SelectorImpl}
 * to {@link OptimizedSelectedKeysSet} to avoid overhead which causes a work of GC
 *
 * @param selector selector instance whose selected keys field is to be changed
 * @return <code>true</code> on success
 */
public static boolean tryToOptimizeSelector(Selector selector) {
	OptimizedSelectedKeysSet selectedKeys = new OptimizedSelectedKeysSet();
	try {
		SELECTED_KEYS_FIELD.set(selector, selectedKeys);
		PUBLIC_SELECTED_KEYS_FIELD.set(selector, selectedKeys);
		return true;

	} catch (IllegalAccessException e) {
		logger.warn("Failed setting optimized set into selector", e);
	}

	return false;
}
 

private void applyProperties() throws IOException
{
	if(mode==SERVER)
	{
		selector = Selector.open();
	}
}
 

Reader(String name) throws IOException {
  super(name);

  this.pendingConnections =
      new LinkedBlockingQueue<Connection>(readerPendingConnectionQueue);
  this.readSelector = Selector.open();
}
 

public NIOConnector init() {
    try {
        this.selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        ServerSocket serverSocket = serverSocketChannel.socket();
        InetSocketAddress inetSocketAddress = new InetSocketAddress(80);
        serverSocket.bind(inetSocketAddress);
        serverSocketChannel.register(this.selector, SelectionKey.OP_ACCEPT);
    }catch(IOException e){
        e.printStackTrace();
    }
    return this;
}
 

@Override
public void open(final InetAddress nicAddress, final int port, final int maxBufferSize) throws IOException {
    stopped = false;
    datagramChannel = DatagramChannel.open();
    datagramChannel.configureBlocking(false);

    if (maxBufferSize > 0) {
        datagramChannel.setOption(StandardSocketOptions.SO_RCVBUF, maxBufferSize);
        final int actualReceiveBufSize = datagramChannel.getOption(StandardSocketOptions.SO_RCVBUF);
        if (actualReceiveBufSize < maxBufferSize) {
            logger.warn("Attempted to set Socket Buffer Size to " + maxBufferSize + " bytes but could only set to "
                    + actualReceiveBufSize + "bytes. You may want to consider changing the Operating System's "
                    + "maximum receive buffer");
        }
    }

    // we don't have to worry about nicAddress being null here because InetSocketAddress already handles it
    datagramChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
    datagramChannel.socket().bind(new InetSocketAddress(nicAddress, port));

    // if a sending host and port were provided then connect to that specific address to only receive
    // datagrams from that host/port, otherwise we can receive datagrams from any host/port
    if (sendingHost != null && sendingPort != null) {
        datagramChannel.connect(new InetSocketAddress(sendingHost, sendingPort));
    }

    selector = Selector.open();
    datagramChannel.register(selector, SelectionKey.OP_READ);
}
 

private static void processPendingRegistrations() {
  while (!registrationQueue.isEmpty()) {
    ChannelState state = registrationQueue.remove();
    try {
      final Selector selector = selector();
      if (!state.channel.isConnected()) {
        state.channel.register(selector, SelectionKey.OP_CONNECT, state);
      } else {
        state.channel.keyFor(selector).interestOps(SelectionKey.OP_WRITE);
      }
    } catch (IOException e) {
      state.handleChannelException(e);
    }
  }
}
 

public ChannelListener(final int threadPoolSize, final StreamConsumerFactory consumerFactory, final BufferPool bufferPool, int timeout,
        TimeUnit unit, final boolean readSingleDatagram) throws IOException {
    this.executor = Executors.newScheduledThreadPool(threadPoolSize + 1); // need to allow for long running ChannelDispatcher thread
    this.serverSocketSelector = Selector.open();
    this.socketChannelSelector = Selector.open();
    this.bufferPool = bufferPool;
    this.initialBufferPoolSize = bufferPool.size();
    channelDispatcher = new ChannelDispatcher(serverSocketSelector, socketChannelSelector, executor, consumerFactory, bufferPool,
            timeout, unit, readSingleDatagram);
    executor.schedule(channelDispatcher, 50, TimeUnit.MILLISECONDS);
}
 

public static void closeQuietly(Selector selector) {
    if (selector != null) {
        try {
            selector.close();
        } catch (IOException var2) {
            ;
        }
    }

}
 

Responder()
			throws IOException {
	this.setName("IPC Server Responder");
	this.setDaemon(true);
	writeSelector = Selector.open(); // create a selector
	pending = 0;
}
 

/**
 * Creates message sender.
 *
 * @param localAddress          the localAddress.
 * @param networkTimeoutMillis  a network timeout in milliseconds.
 * @param selectorTimeoutMillis a time the selector should block for while waiting for a channel to become ready,
 *                              must be greater than zero.
 * @param clock                 the clock.
 */
public Sender(final ClusterNodeAddress localAddress, final long networkTimeoutMillis,
        final long selectorTimeoutMillis, final Clock clock) throws IOException {

   super("Sender:" + localAddress.getTcpPort());
   this.selectorTimeoutMillis = selectorTimeoutMillis;
   this.networkTimeoutMillis = networkTimeoutMillis;
   this.localAddress = localAddress;
   this.selector = Selector.open();
   this.clock = clock;
}
 

/**
 * 仅后台维护的主动创建的连接使用
 */
private void openServerChannel(Selector selector, String bindIp, int bindPort)
        throws IOException {
    serverChannel = ServerSocketChannel.open();
    final InetSocketAddress isa = new InetSocketAddress(bindIp, bindPort);
    serverChannel.bind(isa);
    serverChannel.configureBlocking(false);
    serverChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
}
 

public void dumpKeyState(List<Object> dumpto)
{
    Selector selector=_selector;
    Set<SelectionKey> keys = selector.keys();
    dumpto.add(selector + " keys=" + keys.size());
    for (SelectionKey key: keys)
    {
        if (key.isValid())
            dumpto.add(key.attachment()+" iOps="+key.interestOps()+" rOps="+key.readyOps());
        else
            dumpto.add(key.attachment()+" iOps=-1 rOps=-1");
    }
}
 

public NioEventLoop(BaseConfig config, ChunkPool chunkPool) {
    this.config = config;
    this.chunkPool = chunkPool;
    this.workerThreadPool = new ThreadPool(ThreadPool.FixedThread, 2);
    //初始化数据输出类
    nioBufferWriter = new NioBufferWriter(chunkPool, config.getBufferWriterQueueSize(), config.getChunkPoolBlockTime());
    try {
        selector = new SelectedSelector(Selector.open());
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

final Selector getSelector() {
	try {
		initSelector();
	} catch (IOException e) {
		throw new RuntimeException(e);
	}
	return selector;
}