Java SelectionKey.attachment方法代码示例

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
void doRead(SelectionKey key) throws InterruptedException {
  int count = 0;
  Connection c = (Connection)key.attachment();
  if (c == null) {
    return;  
  }
  c.setLastContact(Time.now());
  
  try {
    count = c.readAndProcess();
  } catch (InterruptedException ieo) {
    LOG.info(Thread.currentThread().getName() + ": readAndProcess caught InterruptedException", ieo);
    throw ieo;
  } catch (Exception e) {
    // a WrappedRpcServerException is an exception that has been sent
    // to the client, so the stacktrace is unnecessary; any other
    // exceptions are unexpected internal server errors and thus the
    // stacktrace should be logged
    LOG.info(Thread.currentThread().getName() + ": readAndProcess from client " +
        c.getHostAddress() + " threw exception [" + e + "]",
        (e instanceof WrappedRpcServerException) ? null : e);
    count = -1; //so that the (count < 0) block is executed
  }
  if (count < 0) {
    closeConnection(c);
    c = null;
  }
  else {
    c.setLastContact(Time.now());
  }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
public void handleKey(SelectionKey key) {

        if (key.isValid() && key.isConnectable()) {
            //out node
            addOutNode(key);
        } else if (key.isValid() && key.isAcceptable()) {
            // in Node
            addInNode(key);
        } else {
            // read or write
            ConnectionHandler handler = (ConnectionHandler) key.attachment();
            if (handler != null) {
                ConnectionHandler.handleKey(key);
            }
        }
    }
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void doWrite(SelectionKey sk){
    SocketChannel channel=(SocketChannel)sk.channel();
    EchoClient echoClient=(EchoClient)sk.attachment();
    LinkedList<ByteBuffer> outq=echoClient.getOutputQueue();

    ByteBuffer bb=outq.getLast();
    try {
        int len=channel.write(bb);
        if(len==-1){
            disconnect(sk);
            return;
        }
        if(bb.remaining()==0){
            outq.removeLast();
        }
    }catch (Exception e){
        e.printStackTrace();
        System.out.println("fail to write to client");
        disconnect(sk);
    }

    if(outq.size()==0){
        sk.interestOps(SelectionKey.OP_READ);
    }

}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/**
 * In the case we are using the java select() method, this method is used to
 * trash the buggy selector and create a new one, registering all the
 * sockets on it.
 */
@Override
protected void registerNewSelector() throws IOException {
    synchronized (selector) {
        Set<SelectionKey> keys = selector.keys();

        // Open a new selector
        Selector newSelector = Selector.open();

        // Loop on all the registered keys, and register them on the new selector
        for (SelectionKey key : keys) {
            SelectableChannel ch = key.channel();

            // Don't forget to attache the session, and back !
            NioSession session = (NioSession) key.attachment();
            SelectionKey newKey = ch.register(newSelector, key.interestOps(), session);
            session.setSelectionKey(newKey);
        }

        // Now we can close the old selector and switch it
        selector.close();
        selector = newSelector;
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void cancelKey(final SelectionKey key) {
	if (log.isTraceEnabled())
		log.trace("Adding key for cancel event:" + key);

	ObjectReader reader = (ObjectReader) key.attachment();
	if (reader != null) {
		reader.setCancelled(true);
		reader.finish();
	}
	Runnable cx = new Runnable() {
		@Override
		public void run() {
			if (log.isTraceEnabled())
				log.trace("Cancelling key:" + key);

			NioReceiver.cancelledKey(key);
		}
	};
	receiver.addEvent(cx);
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
@Override
protected void setCometTimeouts(SocketWrapper<NioChannel> socketWrapper) {
	// Comet support
	SelectionKey key = socketWrapper.getSocket().getIOChannel()
			.keyFor(socketWrapper.getSocket().getPoller().getSelector());
	if (key != null) {
		NioEndpoint.KeyAttachment attach = (NioEndpoint.KeyAttachment) key.attachment();
		if (attach != null) {
			attach.setComet(comet);
			if (comet) {
				Integer comettimeout = (Integer) request
						.getAttribute(org.apache.coyote.Constants.COMET_TIMEOUT_ATTR);
				if (comettimeout != null) {
					attach.setTimeout(comettimeout.longValue());
				}
			}
		}
	}
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
@Override
public void run() {
	SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());
	KeyAttachment ka = null;

	if (key != null) {
		ka = (KeyAttachment) key.attachment();
	}

	// Upgraded connections need to allow multiple threads to access the
	// connection at the same time to enable blocking IO to be used when
	// NIO has been configured
	if (ka != null && ka.isUpgraded() && SocketStatus.OPEN_WRITE == status) {
		synchronized (ka.getWriteThreadLock()) {
			doRun(key, ka);
		}
	} else {
		synchronized (socket) {
			doRun(key, ka);
		}
	}
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void cancelAllKeys() {
    SelectionKey sk = null;
    FDTSelectionKey fsk = null;
    for (Iterator<SelectionKey> it = selector.keys().iterator(); it.hasNext(); ) {
        try {
            sk = it.next();

            if (sk != null) {
                fsk = (FDTSelectionKey) sk.attachment();
                if (fsk != null) {
                    fsk.cancel();
                }
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }// for()
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
public static void handleRead(SelectionKey key) throws IOException {

		SocketChannel sc = (SocketChannel) key.channel();
		ByteBuffer buf = (ByteBuffer) key.attachment();
		long bytesRead = sc.read(buf);
		while (bytesRead > 0) {
			buf.flip();
			while (buf.hasRemaining()) {
				 buf.get();
			}
			buf.clear();
			bytesRead = sc.read(buf);
		}
		if (bytesRead == -1) {
			sc.close();
		}
	}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/**
 * 函数doWrite()也接收一个SelectionKey，当然针对一个客户端来说，
 * 这个SelectionKey实例和doRead()拿到的SelectionKey是同一个。
 * 因此，通过SelectionKey我们就可以在这两个操作中共享EchoClient实例
 * @param sk
 */
private void doWrite(SelectionKey sk) {
    SocketChannel channel = (SocketChannel) sk.channel();
    EchoClient echoClient = (EchoClient) sk.attachment();
    LinkedList<ByteBuffer> outq = echoClient.getOutputQueue();
    //获得列表顶部元素，准备写回客户端
    ByteBuffer bb = outq.getLast();
    try {
        //进行写回操作
        int len = channel.write(bb);
        if (len == -1) {
            disconnect(sk);
            return;

        }
        if (bb.remaining() == 0) {
            // The buffer was completely written, remove it.
            //如果全部发送完成，则移除这个缓存对象
            outq.removeLast();

        }
    } catch (Exception e) {
        System.out.println("Failed to write to client.");
        e.printStackTrace();
        disconnect(sk);

    }
    //在doWrite()中最重要的，也是最容易被忽略的是在全部数据发送完成后（也就是outq的长度为0），需要将写事件（OP_WRITE）从感兴趣的操作中移除。
    // 如果不这么做，每次Channel准备好写时，都会来执行doWrite()方法。而实际上，你又无数据可写，这显然是不合理的。因此，这个操作很重要。
    if (outq.size() == 0) {
        sk.interestOps(SelectionKey.OP_READ);

    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/** Set the selected interest set on the port and run it. */
protected void invokeCallbacks() {
    final Set<SelectionKey> selectedKeys = m_selector.selectedKeys();
    ArrayList<Runnable> generatedTasks = null;
    for(SelectionKey key : selectedKeys) {
        final VoltPort port = (VoltPort) key.attachment();
        if (port == null) {
            continue;
        }
        try {
            port.lockForHandlingWork();
            key.interestOps(0);

            final Runnable runner = getPortCallRunnable(port);

            if (m_useExecutorService) {
                if (generatedTasks == null) generatedTasks = new ArrayList<Runnable>();
                generatedTasks.add(runner);
            } else {
                runner.run();
            }
        }
        catch (CancelledKeyException e) {
            e.printStackTrace();
            // no need to do anything here until
            // shutdown makes more sense
        }
    }

    if (generatedTasks != null && !generatedTasks.isEmpty()) {
        synchronized (m_tasks) {
            m_tasks.addAll(generatedTasks);
            if (m_tasks.size() > 1) {
                m_tasks.notifyAll();
            } else {
                m_tasks.notify();
            }
        }
    }

    selectedKeys.clear();
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/**
 * Called to initiate a unit of work by this worker thread on the provided
 * SelectionKey object. This method is synchronized, as is the run() method,
 * so only one key can be serviced at a given time. Before waking the worker
 * thread, and before returning to the main selection loop, this key's
 * interest set is updated to remove OP_READ. This will cause the selector
 * to ignore read-readiness for this channel while the worker thread is
 * servicing it.
 */
public synchronized void serviceChannel(SelectionKey key) {
	if (log.isTraceEnabled())
		log.trace("About to service key:" + key);
	ObjectReader reader = (ObjectReader) key.attachment();
	if (reader != null)
		reader.setLastAccess(System.currentTimeMillis());
	this.key = key;
	key.interestOps(key.interestOps() & (~SelectionKey.OP_READ));
	key.interestOps(key.interestOps() & (~SelectionKey.OP_WRITE));
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
protected void socketTimeouts() {
        long now = System.currentTimeMillis();
        if ( (now-lastCheck) < getSelectorTimeout() ) return;
        //timeout
        Selector tmpsel = this.selector.get();
        Set<SelectionKey> keys =  (isListening()&&tmpsel!=null)?tmpsel.keys():null;
        if ( keys == null ) return;
        for (Iterator<SelectionKey> iter = keys.iterator(); iter.hasNext();) {
            SelectionKey key = iter.next();
            try {
//                if (key.interestOps() == SelectionKey.OP_READ) {
//                    //only timeout sockets that we are waiting for a read from
//                    ObjectReader ka = (ObjectReader) key.attachment();
//                    long delta = now - ka.getLastAccess();
//                    if (delta > (long) getTimeout()) {
//                        cancelledKey(key);
//                    }
//                }
//                else
                if ( key.interestOps() == 0 ) {
                    //check for keys that didn't make it in.
                    ObjectReader ka = (ObjectReader) key.attachment();
                    if ( ka != null ) {
                        long delta = now - ka.getLastAccess();
                        if (delta > getTimeout() && (!ka.isAccessed())) {
                            if (log.isWarnEnabled())
                                log.warn("Channel key is registered, but has had no interest ops for the last "+getTimeout()+" ms. (cancelled:"+ka.isCancelled()+"):"+key+" last access:"+new java.sql.Timestamp(ka.getLastAccess())+" Possible cause: all threads used, perform thread dump");
                            ka.setLastAccess(now);
                            //key.interestOps(SelectionKey.OP_READ);
                        }//end if
                    } else {
                        cancelledKey(key);
                    }//end if
                }//end if
            }catch ( CancelledKeyException ckx ) {
                cancelledKey(key);
            }
        }
        lastCheck = System.currentTimeMillis();
    }
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/**
 * Iterate over the queue of connections ready to resume selection,
 * and restore their interest ops selection mask.
 */
private void processInterestOpsUpdateRequests() {
    SelectionKey key;
    while (!stopped && (key = updateQueue.poll()) != null) {
        if (!key.isValid()) {
            cleanupSelectionKey(key);
        }
        NIOServerCnxn cnxn = (NIOServerCnxn) key.attachment();
        if (cnxn.isSelectable()) {
            key.interestOps(cnxn.getInterestOps());
        }
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
public void run() throws IOException {
    Selector selector = Selector.open();

    // will register the socket on the selector
    TunnelServer tunnelServer = new TunnelServer(port, selector);

    Log.i(TAG, "Relay server started");

    long nextCleaningDeadline = System.currentTimeMillis() + UDPConnection.IDLE_TIMEOUT;
    while (true) {
        long timeout = Math.max(0, nextCleaningDeadline - System.currentTimeMillis());
        selector.select(timeout);
        Set<SelectionKey> selectedKeys = selector.selectedKeys();

        long now = System.currentTimeMillis();
        if (now >= nextCleaningDeadline) {
            tunnelServer.cleanUp();
            nextCleaningDeadline = now + CLEANING_INTERVAL;
        } else if (selectedKeys.isEmpty()) {
            throw new AssertionError("selector.select() returned without any event, an invalid SelectionKey was probably been registered");
        }

        for (SelectionKey selectedKey : selectedKeys) {
            SelectionHandler selectionHandler = (SelectionHandler) selectedKey.attachment();
            selectionHandler.onReady(selectedKey);
        }
        // by design, we handled everything
        selectedKeys.clear();
    }
}