public void serve(int port) throws IOException { ServerSocketChannel serverChannel = ServerSocketChannel.open(); serverChannel.configureBlocking(false); ServerSocket ss = serverChannel.socket(); InetSocketAddress address = new InetSocketAddress(port); // Binds the server to the selected port ss.bind(address); // Opens the Selector for handling channels Selector selector = Selector.open(); // Registers the ServerSocket with the Selector to accept connections serverChannel.register(selector, SelectionKey.OP_ACCEPT); final ByteBuffer msg = ByteBuffer.wrap("Hi!\r\n".getBytes()); while (true) { try { // Waits for new events to process; blocks until the next incoming event selector.select(); } catch (IOException e) { e.printStackTrace(); break; } // Obtains all SelectionKey instances that received events Set<SelectionKey> readyKeys = selector.selectedKeys(); Iterator<SelectionKey> iterator = readyKeys.iterator(); while (iterator.hasNext()) { SelectionKey key = iterator.next(); iterator.remove(); try { // Checks if the event is a new connection ready to be accepted if (key.isAcceptable()) { ServerSocketChannel server = (ServerSocketChannel) key.channel(); SocketChannel client = server.accept(); client.configureBlocking(false); // Accepts client and registers it with the selector client.register( selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, msg.duplicate()); System.out.println("Accepted connection from " + client); } // Checks if the socket is ready for writing data if (key.isWritable()) { SocketChannel client = (SocketChannel) key.channel(); ByteBuffer buffer = (ByteBuffer) key.attachment(); while (buffer.hasRemaining()) { // Writes data to the connected client if (client.write(buffer) == 0) { break; } } // Closes the connection client.close(); } } catch (IOException e) { key.cancel(); try { key.channel().close(); } catch (IOException e1) { } } } } }
public int ready() throws IOException { if (descriptor.getChannel() instanceof SelectableChannel) { int ready_stat = 0; java.nio.channels.Selector sel = SelectorFactory.openWithRetryFrom( null, ((SelectableChannel) descriptor.getChannel()).provider()); SelectableChannel selchan = (SelectableChannel) descriptor.getChannel(); synchronized (selchan.blockingLock()) { boolean is_block = selchan.isBlocking(); try { selchan.configureBlocking(false); selchan.register(sel, java.nio.channels.SelectionKey.OP_READ); ready_stat = sel.selectNow(); sel.close(); } catch (Throwable ex) { } finally { if (sel != null) { try { sel.close(); } catch (Exception e) { } } selchan.configureBlocking(is_block); } } return ready_stat; } else { return newInputStream().available(); } }
private void driveClientIO() throws IOException, GearmanException { for (GearmanJobServerSession sess : sessionsMap.values()) { int interestOps = SelectionKey.OP_READ; if (sess.sessionHasDataToWrite()) { interestOps |= SelectionKey.OP_WRITE; } try { sess.getSelectionKey().interestOps(interestOps); } catch (IllegalStateException ise) { LOG.warn("Unable to drive IO for session " + sess + "," + " skipping.", ise); continue; } } ioAvailable.selectNow(); Set<SelectionKey> keys = ioAvailable.selectedKeys(); LOG.trace( "Driving IO for client " + this + ". " + keys.size() + " session(s) currently available for IO"); Iterator<SelectionKey> iter = keys.iterator(); while (iter.hasNext()) { SelectionKey key = iter.next(); GearmanJobServerSession s = sessionsMap.get(key); s.driveSessionIO(); } }
@Override public void run() { try { selector = Selector.open(); while (true) { processSelectionQueue(); int nKeys = selector.select(selectWaitTime); // blocking if (nKeys == 0) { continue; } else { logger.trace(String.format("Selector %d, keys num: %d", selectorNum, nKeys)); } Set<SelectionKey> keys = selector.selectedKeys(); Iterator<SelectionKey> iter = keys.iterator(); while (iter.hasNext()) { SelectionKey key = iter.next(); iter.remove(); logger.trace("Key operations: " + key.readyOps()); if (key.isWritable()) { doWrite(key); } } } } catch (IOException e) { throw new RuntimeException(e); } }
private void dispose(Selector localSelector, LinkedBlockingQueue localSelectorTasks) { Assert.eval(Thread.currentThread() == this); if (localSelector != null) { for (Object element : localSelector.keys()) { try { SelectionKey key = (SelectionKey) element; cleanupChannel(key.channel(), null); } catch (Exception e) { logger.warn("Exception trying to close channel", e); } } try { localSelector.close(); } catch (Exception e) { if ((Os.isMac()) && (Os.isUnix()) && (e.getMessage().equals("Bad file descriptor"))) { // I can't find a specific bug about this, but I also can't seem to prevent the // exception on the Mac. // So just logging this as warning. logger.warn("Exception trying to close selector: " + e.getMessage()); } else { logger.error("Exception trying to close selector", e); } } } }
public void run() { try { while (!flag) { System.out.println("waiting connected......."); selector.select(); Iterator<SelectionKey> keys = selector.selectedKeys().iterator(); while (keys.hasNext()) { SelectionKey key = keys.next(); keys.remove(); if (key.isAcceptable()) { ServerSocketChannel ssc = (ServerSocketChannel) key.channel(); SocketChannel sc = ssc.accept(); sc.configureBlocking(false); SelectionKey clientKey = sc.register(selector, SelectionKey.OP_READ); System.out.println(sc.socket().getInetAddress().getHostAddress() + " 已连接"); } if (key.isReadable()) { read(key); } } } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
@Test public void testReceiveIntoExistingBuffer() throws Exception { Selector selector = mock(Selector.class); when(selector.select(SteamSocket.timeout)).thenReturn(1); mockStatic(Selector.class); when(Selector.open()).thenReturn(selector); when(this.channel.register(selector, SelectionKey.OP_READ)).thenReturn(null); this.socket.buffer = ByteBuffer.allocate(10); final SteamSocket socket = this.socket; when(this.channel.read(any(ByteBuffer.class))) .thenAnswer( new Answer<Integer>() { public Integer answer(InvocationOnMock invocationOnMock) throws Throwable { socket.buffer.put("test".getBytes()); return 4; } }); assertEquals(4, this.socket.receivePacket(4)); ByteBuffer buffer = this.socket.buffer; assertEquals(0, buffer.position()); assertEquals(4, buffer.capacity()); assertEquals("test", new String(buffer.array())); }
public void run() { try { while (running) { int k; try { k = selector.select(); } catch (IOException e) { manager.getLogger().info("Exception thrown by accept thread selector " + e); break; } if (k <= 0) { continue; } Set<SelectionKey> keys = selector.selectedKeys(); Iterator<SelectionKey> i = keys.iterator(); while (i.hasNext()) { SelectionKey key = i.next(); ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel(); SocketChannel channel; try { channel = serverChannel.accept(); } catch (IOException e) { manager.getLogger().info("Exception thrown by server socket when accepting " + e); continue; } manager.addChannel(channel); } } } finally { cleanup(); } }
private void do_selection() throws IOException { // wait for events // timeout 1000ms -> check for pendingChanges at least every second if (selector.select(1000) == 0) return; // wakeup to work on selected keys Iterator keys = selector.selectedKeys().iterator(); while (keys.hasNext()) { SelectionKey key = (SelectionKey) keys.next(); keys.remove(); if (!key.isValid()) { continue; } if (key.isAcceptable()) { accept(key); } else if (key.isReadable()) { read(key); } else if (key.isWritable()) { write(key); } else if (key.isConnectable()) { connect(key); } } }
/** * Serves the incoming connections. * * @throws IOException * @throws DirectoryException */ private void serveIncomingConnections() throws IOException, DirectoryException { int selectorState = selector.select(); // We can't rely on return value of select to determine if any keys // are ready. // see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4850373 for (Iterator<SelectionKey> iterator = selector.selectedKeys().iterator(); iterator.hasNext(); ) { SelectionKey key = iterator.next(); iterator.remove(); if (key.isAcceptable()) { // Accept the new client connection. ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel(); SocketChannel clientChannel = serverChannel.accept(); if (clientChannel != null) { acceptConnection(clientChannel); } } if (selectorState == 0 && enabled && !shutdownRequested && logger.isTraceEnabled()) { // Selected keys was non empty but select() returned 0. // Log warning and hope it blocks on the next select() call. logger.trace( "Selector.select() returned 0. " + "Selected Keys: %d, Interest Ops: %d, Ready Ops: %d ", selector.selectedKeys().size(), key.interestOps(), key.readyOps()); } } }
@Override public void run() { while (true) { try { synchronized (_pendingRequest) { Iterator changes = _pendingRequest.iterator(); while (changes.hasNext()) { ChangeRequest change = (ChangeRequest) changes.next(); if (!processPendingRequest(change)) break; changes.remove(); } } // wait events from selected channels _selector.select(); Iterator selectedKeys = _selector.selectedKeys().iterator(); while (selectedKeys.hasNext()) { SelectionKey key = (SelectionKey) selectedKeys.next(); selectedKeys.remove(); if (!key.isValid()) { continue; } processSelect(key); } } catch (Exception e) { logger.warning(Util.getErrorMessage(e)); } } }
/* * (non-Javadoc) * * @see java.lang.Runnable#run() */ @Override public void run() { while (!stop) { try { selector.select(1000); Set<SelectionKey> selectedKeys = selector.selectedKeys(); Iterator<SelectionKey> it = selectedKeys.iterator(); SelectionKey key = null; while (it.hasNext()) { key = it.next(); it.remove(); try { handleInput(key); } catch (Exception e) { if (key != null) { key.cancel(); if (key.channel() != null) key.channel().close(); } } } } catch (Throwable t) { t.printStackTrace(); } } // 多路复用器关闭后,所有注册在上面的Channel和Pipe等资源都会被自动去注册并关闭,所以不需要重复释放资源 if (selector != null) try { selector.close(); } catch (IOException e) { e.printStackTrace(); } }
/** Selects on sockets and informs their Communicator when there is something to do. */ public void communicate(int timeout) { try { selector.select(timeout); } catch (IOException e) { // Not really sure why/when this happens yet return; } Iterator<SelectionKey> keys = selector.selectedKeys().iterator(); while (keys.hasNext()) { SelectionKey key = keys.next(); keys.remove(); if (!key.isValid()) continue; // WHY Communicator communicator = (Communicator) key.attachment(); if (key.isReadable()) communicator.onReadable(); if (key.isWritable()) communicator.onWritable(); if (key.isAcceptable()) communicator.onAcceptable(); } // Go through the queue and handle each communicator while (!queue.isEmpty()) { Communicator c = queue.poll(); c.onMemo(); } }
public static void main(String[] args) throws IOException { ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.socket().bind(new InetSocketAddress(PORT)); System.out.println("Server listening at port : " + PORT); serverSocketChannel.configureBlocking(false); Selector selector = Selector.open(); serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); while (true) { int n = selector.select(); if (n == 0) { continue; } Iterator<SelectionKey> it = selector.selectedKeys().iterator(); while (it.hasNext()) { SelectionKey key = it.next(); if (key.isAcceptable()) { ServerSocketChannel ssc = (ServerSocketChannel) key.channel(); SocketChannel sc = ssc.accept(); sc.configureBlocking(false); sc.register(selector, SelectionKey.OP_READ); System.out.println("accept client : " + sc); acceptClient(sc); } if (key.isReadable()) { readData(key); } it.remove(); } } }
public static void main(String[] argv) throws Exception { Pipe[] pipes = new Pipe[PIPES_COUNT]; Pipe pipe = Pipe.open(); Pipe.SinkChannel sink = pipe.sink(); Pipe.SourceChannel source = pipe.source(); Selector sel = Selector.open(); source.configureBlocking(false); source.register(sel, SelectionKey.OP_READ); for (int i = 0; i < PIPES_COUNT; i++) { pipes[i] = Pipe.open(); Pipe.SourceChannel sc = pipes[i].source(); sc.configureBlocking(false); sc.register(sel, SelectionKey.OP_READ); Pipe.SinkChannel sc2 = pipes[i].sink(); sc2.configureBlocking(false); sc2.register(sel, SelectionKey.OP_WRITE); } for (int i = 0; i < LOOPS; i++) { sink.write(ByteBuffer.allocate(BUF_SIZE)); int x = sel.selectNow(); sel.selectedKeys().clear(); source.read(ByteBuffer.allocate(BUF_SIZE)); } for (int i = 0; i < PIPES_COUNT; i++) { pipes[i].sink().close(); pipes[i].source().close(); } pipe.sink().close(); pipe.source().close(); sel.close(); }
@Override public void run() { Thread.currentThread().setName(threadName); while (started) { processRegisterTaskQueue(); try { if (selector.select(1000) > 0) { Iterator<SelectionKey> iter = selector.selectedKeys().iterator(); while (iter.hasNext()) { SelectionKey key = iter.next(); iter.remove(); // 处理Key if (key.isReadable()) { processReadableKey(key); } else if (key.isWritable()) { processWritableKey(key); } } // TODO shutdown } } catch (IOException e) { logger.warn("Unexpected exception in the selector loop.", e); // Prevent possible consecutive immediate failures that lead to // excessive CPU consumption. try { Thread.sleep(1000); } catch (InterruptedException t) { // Ignore. } } } }
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); }
@Override public void run() { try { System.out.println("[Server Opened]"); selector = Selector.open(); ssc.register(selector, SelectionKey.OP_ACCEPT); while (true) { int canalsPreparats = selector.select(); if (canalsPreparats == 0) { continue; } Set<SelectionKey> clausSeleccionades = selector.selectedKeys(); Iterator<SelectionKey> iterador = clausSeleccionades.iterator(); while (iterador.hasNext()) { SelectionKey clau = iterador.next(); // CONCURRENCIA claus // Les claus son un recurs compartit, ja que quan finalitza // el joc, el métode update() les cancela. Per aquest motiu // quan en fem us, synchronitzem el objecte, i comprovem // que siguin vàlides synchronized (this) { if (clau.isValid() && clau.isAcceptable()) { ferAccept(clau); } else if (clau.isValid() && clau.isReadable()) { rebre(clau); } } iterador.remove(); } } } catch (IOException ex) { } }
boolean initiateConnection(Connection conn_, Peer peer) { TCPConnection conn = (TCPConnection) conn_; try { SocketChannel channel = SocketChannel.open(); InetSocketAddress localAddress = new InetSocketAddress(conn.host_id, 0); channel.socket().bind(localAddress); channel.configureBlocking(false); try { InetSocketAddress remoteAddress = new InetSocketAddress(peer.host(), peer.port()); if (channel.connect(remoteAddress)) { // This only happens on Solaris when connecting locally logger.log(Level.FINEST, "Connected!"); conn.state = Connection.State.connected_out; conn.channel = channel; selector.wakeup(); channel.register(selector, SelectionKey.OP_READ, conn); initiateCER(conn); return true; } } catch (java.nio.channels.UnresolvedAddressException ex) { channel.close(); return false; } conn.state = Connection.State.connecting; conn.channel = channel; selector.wakeup(); channel.register(selector, SelectionKey.OP_CONNECT, conn); } catch (java.io.IOException ex) { logger.log( Level.WARNING, "java.io.IOException caught while initiating connection to '" + peer.host() + "'.", ex); } return true; }
private boolean scheduleWriteIfNecessary(final SctpChannelImpl channel) { final Thread currentThread = Thread.currentThread(); final Thread workerThread = thread; if (currentThread != workerThread) { if (channel.writeTaskInTaskQueue.compareAndSet(false, true)) { boolean offered = writeTaskQueue.offer(channel.writeTask); assert offered; } if (!(channel instanceof SctpAcceptedChannel) || ((SctpAcceptedChannel) channel).bossThread != currentThread) { final Selector workerSelector = selector; if (workerSelector != null) { if (wakenUp.compareAndSet(false, true)) { workerSelector.wakeup(); } } } else { // A write request can be made from an acceptor thread (boss) // when a user attempted to write something in: // // * channelOpen() // * channelBound() // * channelConnected(). // // In this case, there's no need to wake up the selector because // the channel is not even registered yet at this moment. } return true; } return false; }
private void loop() { while (true) { try { selector.select(); Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator(); while (selectedKeys.hasNext()) { SelectionKey key = selectedKeys.next(); selectedKeys.remove(); if (!key.isValid()) { continue; } // Check what event is available and deal with it if (key.isAcceptable()) { accept(key); } else if (key.isReadable()) { read(key); } else if (key.isWritable()) { write(key); } } } catch (Exception e) { e.printStackTrace(); System.exit(1); } } }
@Override public void release() { try { mcastObject(null, slaves.length); flushBuffers(0); } catch (Exception e) { log.warn("Failed to send termination to slaves.", e); } try { discoverySelector.close(); } catch (Throwable e) { log.warn("Error closing discovery selector", e); } try { communicationSelector.close(); } catch (Throwable e) { log.warn("Error closing comunication selector", e); } for (SocketChannel sc : slaves) { try { sc.socket().close(); } catch (Throwable e) { log.warn("Error closing channel", e); } } try { if (serverSocketChannel != null) serverSocketChannel.socket().close(); } catch (Throwable e) { log.warn("Error closing server socket channel", e); } }
// actual connection logic private void _connect() throws IOException { // Continuous loop that is only supposed to end when "close" is called. selector.select(); Set<SelectionKey> keys = selector.selectedKeys(); Iterator<SelectionKey> i = keys.iterator(); while (i.hasNext()) { SelectionKey key = i.next(); i.remove(); if (key.isConnectable()) { if (socketChannel.isConnectionPending()) { socketChannel.finishConnect(); } socketChannel.register(selector, SelectionKey.OP_READ); _writeHandshake(); } if (key.isReadable()) { try { _read(); } catch (NoSuchAlgorithmException nsa) { this.onError(nsa); } } } }
public void run() { while (true) { try { synchronized (changeRequests) { Iterator changes = changeRequests.iterator(); while (changes.hasNext()) { ChangeRequest change = (ChangeRequest) changes.next(); switch (change.type) { case ChangeRequest.CHANGEOPS: SelectionKey key = change.socket.keyFor(selector); key.interestOps(change.ops); } } changeRequests.clear(); } selector.select(); Iterator selectedKeys = selector.selectedKeys().iterator(); while (selectedKeys.hasNext()) { SelectionKey key = (SelectionKey) selectedKeys.next(); selectedKeys.remove(); if (!key.isValid()) continue; if (key.isAcceptable()) accept(key); else if (key.isReadable()) read(key); else if (key.isWritable()) write(key); } } catch (IOException e) { e.printStackTrace(); } } }
@Override public void run() { final Selector selector = this.selector; for (; ; ) { ++reactCount; try { selector.select(1000L); register(selector); Set<SelectionKey> keys = selector.selectedKeys(); try { for (SelectionKey key : keys) { Object att = key.attachment(); System.out.println("attchment " + att); if (att != null && key.isValid()) { int readyOps = key.readyOps(); if ((readyOps & SelectionKey.OP_READ) != 0) { read((NIOConnection) att); } else if ((readyOps & SelectionKey.OP_WRITE) != 0) { write((NIOConnection) att); } else { key.cancel(); } } else { key.cancel(); } } } finally { keys.clear(); } } catch (Throwable e) { LOGGER.warn(name, e); } } }
private void close(SctpServerChannelImpl channel, ChannelFuture future) { boolean bound = channel.isBound(); try { if (channel.serverChannel.isOpen()) { channel.serverChannel.close(); Selector selector = channel.selector; if (selector != null) { selector.wakeup(); } } // Make sure the boss thread is not running so that that the future // is notified after a new connection cannot be accepted anymore. // See NETTY-256 for more information. channel.shutdownLock.lock(); try { if (channel.setClosed()) { future.setSuccess(); if (bound) { fireChannelUnbound(channel); } fireChannelClosed(channel); } else { future.setSuccess(); } } finally { channel.shutdownLock.unlock(); } } catch (Throwable t) { future.setFailure(t); fireExceptionCaught(channel, t); } }
/** * Start the server running - accepting connections, receiving messages. If the server is already * running, it will not be started again. This method is designed to be called in its own thread * and will not return until the server is stopped. * * @throws RuntimeException if the server fails */ public void run() { // ensure that the server is not started twice if (!state.compareAndSet(State.STOPPED, State.RUNNING)) { started(true); return; } Selector selector = null; ServerSocketChannel server = null; try { selector = Selector.open(); server = ServerSocketChannel.open(); server.socket().bind(new InetSocketAddress(port)); server.configureBlocking(false); server.register(selector, SelectionKey.OP_ACCEPT); started(false); while (state.get() == State.RUNNING) { selector.select(100); // check every 100ms whether the server has been requested to stop for (Iterator<SelectionKey> it = selector.selectedKeys().iterator(); it.hasNext(); ) { SelectionKey key = it.next(); try { // remove key from the ready list it.remove(); if (key.isConnectable()) { ((SocketChannel) key.channel()).finishConnect(); } if (key.isAcceptable()) { // accept connection SocketChannel client = server.accept(); client.configureBlocking(false); client.socket().setTcpNoDelay(true); // channel is registered for further events such as read or write SelectionKey acceptKey = client.register(selector, SelectionKey.OP_READ); connection(acceptKey); } if (key.isReadable()) { for (ByteBuffer message : readIncomingMessage(key)) { messageReceived(message, key); } } } catch (IOException ioe) { resetKey(key); disconnected(key); } } } } catch (Throwable e) { throw new RuntimeException("Server failure: " + e.getMessage()); } finally { try { selector.close(); server.socket().close(); server.close(); state.set(State.STOPPED); stopped(); } catch (Exception e) { // do nothing - server failed } } }
void unregisterChannels(SelectionKeyRegistrationReference registrationReference) throws Exception { registrationReference.cancelRegistration(); SelectorIntraband defaultIntraband = (SelectorIntraband) registrationReference.getIntraband(); Selector selector = defaultIntraband.selector; Set<SelectionKey> keys = selector.keys(); while (!keys.isEmpty()) { selector.wakeup(); } SelectionKey readSelectionKey = registrationReference.readSelectionKey; SelectionKey writeSelectionKey = registrationReference.writeSelectionKey; SelectableChannel readSelectableChannel = readSelectionKey.channel(); SelectableChannel writeSelectableChannel = writeSelectionKey.channel(); while (readSelectableChannel.keyFor(selector) != null) ; while (writeSelectableChannel.keyFor(selector) != null) ; writeSelectableChannel.close(); readSelectableChannel.close(); }
public boolean waitEvent(long timeout) { int rc = 0; try { if (timeout == 0) { // waitEvent(0) is called every read/send of SocketBase // instant readiness is not strictly required // On the other hand, we can save lots of system call and increase performance return rcursor < wcursor.get(); } else if (timeout < 0) { rc = selector.select(0); } else { rc = selector.select(timeout); } } catch (IOException e) { throw new ZError.IOException(e); } if (rc == 0) { return false; } selector.selectedKeys().clear(); return true; }
@Override public void run() { while (!Thread.interrupted()) { try { selector.select(); } catch (IOException e) { continue; } processRegisterChannels(); Set<SelectionKey> keys = selector.selectedKeys(); for (SelectionKey key : keys) { try { handle(key); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } catch (Throwable throwable) { Logger.error("ChannelKey handle fail.", throwable); try { TimeUnit.MILLISECONDS.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } keys.clear(); } }