Java SelectionKey.isWritable方法代码示例

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void process() {
    Iterator<SelectionKey> it = selector.selectedKeys().iterator();
    while (it.hasNext()) {
        SelectionKey key = it.next();
        it.remove();
        if (!key.isValid()) {
            continue;
        }
        ChannelHandler handler = (ChannelHandler) key.attachment();
        if (key.isAcceptable()) {
            handler.accept(key);
        } else if (key.isConnectable()) {
            handler.connect(key);
        } else if (key.isReadable()) {
            handler.read(key);
        } else if (key.isWritable()) {
            handler.write(key);
        }
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
@Override
protected boolean isWritable(DatagramChannel handle) {
    SelectionKey key = handle.keyFor(selector);

    if ((key == null) || (!key.isValid())) {
        return false;
    }

    return key.isWritable();
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
public void flood() throws Exception {
    for (; ; ) {
        while (sel.select() > 0)
            ;

        Iterator it = sel.selectedKeys().iterator();
        while (it.hasNext()) {
            SelectionKey sk = (SelectionKey) it.next();

            if (sk.isWritable()) {
                sk.interestOps(sk.interestOps() & ~SelectionKey.OP_WRITE);
                executor.execute(new WriterTask(sk));
            }

            it.remove();
        }
    }

}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void initializeSelectionSets(Set<SelectionKey> selectionKeys) {
    for (SelectionKey selectionKey : selectionKeys) {
        if (selectionKey.isAcceptable()) {
            acceptableSockets.put((TCPServerSocket)selectionKey.attachment(), false);
            continue; // acceptable sockets are neither readable nor writable
        }
        if (selectionKey.isReadable()) {
            readableSockets.put((TCPClientSocket)selectionKey.attachment(), false);
        }
        if (selectionKey.isWritable()) {
            writableSockets.put((TCPClientSocket)selectionKey.attachment(), false);
        }
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/**
 * Handle a SelectionKey which was selected
 * Runs unlocked as the caller is single-threaded (or if not, should enforce that handleKey is only called
 * atomically for a given ConnectionHandler)
 *
 * @param key
 */
public static void handleKey(SelectionKey key) {
    ConnectionHandler handler = (ConnectionHandler) key.attachment();
    try {
        if (!key.isValid()) {
            // Key has been cancelled, make sure the socket gets closed
            handler.node.destroy();
            return;
        }
        if (key.isReadable()) {
            // Do a socket read and invoke the connection's receiveBytes message
            int len = handler.channel.read(handler.readBuffer);
            if (len == 0) {
                // Was probably waiting on a write
                return;
            } else if (len == -1) {
                // Socket was closed
                key.cancel();
                handler.node.destroy();
                return;
            }
            // "flip" the buffer - setting the limit to the current position and setting position to 0
            handler.node.receiveMessage(handler.readBuffer);
            // Now drop the bytes which were read by compacting readBuff (resetting limit and keeping relative position)
        }
        if (key.isWritable()) {
            handler.writeBytes();
        }
    } catch (Exception e) {
        // This can happen eg if the channel closes while the thread is about to get killed
        // (ClosedByInterruptException), or if handler.connection.receiveBytes throws something
        Log.warn("Error handling SelectionKey: {}", e);
        handler.node.destroy();
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
public static void handleKey(SelectionKey key) {
    ConnectionHandler handler = ((ConnectionHandler)key.attachment());
    try {
        if (handler == null)
            return;
        if (!key.isValid()) {
            handler.closeConnection(); // Key has been cancelled, make sure the socket gets closed
            return;
        }
        if (key.isReadable()) {
            // Do a socket read and invoke the connection's receiveBytes message
            int read = handler.channel.read(handler.readBuff);
            if (read == 0)
                return; // Was probably waiting on a write
            else if (read == -1) { // Socket was closed
                key.cancel();
                handler.closeConnection();
                return;
            }
            // "flip" the buffer - setting the limit to the current position and setting position to 0
            handler.readBuff.flip();
            // Use connection.receiveBytes's return value as a check that it stopped reading at the right location
            int bytesConsumed = checkNotNull(handler.connection).receiveBytes(handler.readBuff);
            checkState(handler.readBuff.position() == bytesConsumed);
            // Now drop the bytes which were read by compacting readBuff (resetting limit and keeping relative
            // position)
            handler.readBuff.compact();
        }
        if (key.isWritable())
            handler.tryWriteBytes();
    } catch (Exception e) {
        // This can happen eg if the channel closes while the thread is about to get killed
        // (ClosedByInterruptException), or if handler.connection.receiveBytes throws something
        Throwable t = Throwables.getRootCause(e);
        log.warn("Error handling SelectionKey: {} {}", t.getClass().getName(), t.getMessage() != null ? t.getMessage() : "", e);
        handler.closeConnection();
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
@Override
public void run() {
    while (true) {
        try {
            if (atomicInteger.get() >= 3) {
                System.out.println("end server");
                break;
            }
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();
                if (key.isAcceptable()) {
                    handAccept(key);
                } else if (key.isWritable()) {
                    handWrite(key);
                    atomicInteger.incrementAndGet();
                } else if (key.isReadable()) {
                    handRead(key);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
@Override
public void run() {
    while (true) {
        try {
            if (atomicInteger.get() >= 3) {
                System.out.println("end client");
                break;
            }
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();
                if (key.isConnectable()) {
                    handConnect(key);
                } else if (key.isWritable()) {
                    handWrite(key);
                } else if (key.isReadable()) {
                    handRead(key);
                    atomicInteger.incrementAndGet();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 

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

    while (running) {

        try {
            select();

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

            if (selectionKeys.isEmpty()) {
                continue;
            }

            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {

                final SelectionKey key = iterator.next();
                iterator.remove();

                if (!key.isValid()) {
                    continue;
                }

                if (key.isAcceptable()) {
                    doAccept(key);
                }

                if (key.isConnectable()) {
                    doConnect(key);
                }

                if (key.isValid() && key.isReadable()) {
                    doRead(key);
                }

                if (key.isValid() && key.isWritable()) {
                    doWrite(key);
                }
            }

        } catch (Throwable t) {
            LOGGER.warn("Unexpected exception in the selector loop.", t);

            // 睡眠1S, 防止连续的异常导致cpu消耗
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignore) {
            }
        }
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void startServer() throws Exception{
        //声明一个selector
        selector= SelectorProvider.provider().openSelector();

        //声明一个server socket channel,而且是非阻塞的。
        ServerSocketChannel ssc=ServerSocketChannel.open();
        ssc.configureBlocking(false);

//        InetSocketAddress isa=new InetSocketAddress(InetAddress.getLocalHost(),8000);
        //声明服务器端的端口
        InetSocketAddress isa=new InetSocketAddress(8000);
        //服务器端的socket channel绑定在这个端口。
        ssc.socket().bind(isa);
        //把一个socketchannel注册到一个selector上，同时选择监听的事件，SelectionKey.OP_ACCEPT表示对selector如果
        //监听到注册在它上面的server socket channel准备去接受一个连接，或 有个错误挂起，selector将把OP_ACCEPT加到
        //key ready set 并把key加到selected-key set.
        SelectionKey acceptKey=ssc.register(selector,SelectionKey.OP_ACCEPT);

        for(;;){
            selector.select();
            Set readyKeys=selector.selectedKeys();
            Iterator i=readyKeys.iterator();
            long e=0;
            while (i.hasNext()){
                SelectionKey sk=(SelectionKey)i.next();
                i.remove();

                if(sk.isAcceptable()){
                    doAccept(sk);
                }else if(sk.isValid()&&sk.isReadable()){
                    if(!geym_time_stat.containsKey(((SocketChannel)sk.channel()).socket())){
                        geym_time_stat.put(((SocketChannel)sk.channel()).socket(),System.currentTimeMillis());
                        doRead(sk);
                    }
                }else if(sk.isValid()&&sk.isWritable()){
                    doWrite(sk);
                    e=System.currentTimeMillis();
                    long b=geym_time_stat.remove(((SocketChannel)sk.channel()).socket());
                    System.out.println("spend"+(e-b)+"ms");
                }
            }
        }
    }
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/**
 * State machine to send data
 * 
 * @param key
 *            SelectionKey
 * @return boolean
 * @throws IOException
 */
public boolean process(SelectionKey key, boolean waitForAck) throws IOException {
	int ops = key.readyOps();
	key.interestOps(key.interestOps() & ~ops);
	// in case disconnect has been called
	if ((!isConnected()) && (!connecting))
		throw new IOException("Sender has been disconnected, can't selection key.");
	if (!key.isValid())
		throw new IOException("Key is not valid, it must have been cancelled.");
	if (key.isConnectable()) {
		if (socketChannel.finishConnect()) {
			completeConnect();
			if (current != null)
				key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
			return false;
		} else {
			// wait for the connection to finish
			key.interestOps(key.interestOps() | SelectionKey.OP_CONNECT);
			return false;
		} // end if
	} else if (key.isWritable()) {
		boolean writecomplete = write(key);
		if (writecomplete) {
			// we are completed, should we read an ack?
			if (waitForAck) {
				// register to read the ack
				key.interestOps(key.interestOps() | SelectionKey.OP_READ);
			} else {
				// if not, we are ready, setMessage will reregister us for
				// another write interest
				// do a health check, we have no way of verify a
				// disconnected
				// socket since we don't register for OP_READ on
				// waitForAck=false
				read(key);// this causes overhead
				setRequestCount(getRequestCount() + 1);
				return true;
			}
		} else {
			// we are not complete, lets write some more
			key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
		} // end if
	} else if (key.isReadable()) {
		boolean readcomplete = read(key);
		if (readcomplete) {
			setRequestCount(getRequestCount() + 1);
			return true;
		} else {
			key.interestOps(key.interestOps() | SelectionKey.OP_READ);
		} // end if
	} else {
		// unknown state, should never happen
		log.warn("Data is in unknown state. readyOps=" + ops);
		throw new IOException("Data is in unknown state. readyOps=" + ops);
	} // end if
	return false;
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
@Override
protected boolean isWritable(NioSession session) {
    SelectionKey key = session.getSelectionKey();
    return key.isValid() && key.isWritable();
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
protected boolean processKey(SelectionKey sk, KeyAttachment attachment) {
	boolean result = true;
	try {
		if (close) {
			cancelledKey(sk, SocketStatus.STOP, attachment.comet);
		} else if (sk.isValid() && attachment != null) {
			attachment.access();// make sure we don't time out valid
								// sockets
			sk.attach(attachment);// cant remember why this is here
			NioChannel channel = attachment.getChannel();
			if (sk.isReadable() || sk.isWritable()) {
				if (attachment.getSendfileData() != null) {
					processSendfile(sk, attachment, false);
				} else {
					if (isWorkerAvailable()) {
						unreg(sk, attachment, sk.readyOps());
						boolean closeSocket = false;
						// Read goes before write
						if (sk.isReadable()) {
							if (!processSocket(channel, SocketStatus.OPEN_READ, true)) {
								closeSocket = true;
							}
						}
						if (!closeSocket && sk.isWritable()) {
							if (!processSocket(channel, SocketStatus.OPEN_WRITE, true)) {
								closeSocket = true;
							}
						}
						if (closeSocket) {
							cancelledKey(sk, SocketStatus.DISCONNECT, false);
						}
					} else {
						result = false;
					}
				}
			}
		} else {
			// invalid key
			cancelledKey(sk, SocketStatus.ERROR, false);
		}
	} catch (CancelledKeyException ckx) {
		cancelledKey(sk, SocketStatus.ERROR, false);
	} catch (Throwable t) {
		ExceptionUtils.handleThrowable(t);
		log.error("", t);
	}
	return result;
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/**
 * State machine to send data
 * @param key SelectionKey
 * @return boolean
 * @throws IOException
 */
public boolean process(SelectionKey key, boolean waitForAck) throws IOException {
    int ops = key.readyOps();
    key.interestOps(key.interestOps() & ~ops);
    //in case disconnect has been called
    if ((!isConnected()) && (!connecting)) throw new IOException("Sender has been disconnected, can't selection key.");
    if ( !key.isValid() ) throw new IOException("Key is not valid, it must have been cancelled.");
    if ( key.isConnectable() ) {
        if ( socketChannel.finishConnect() ) {
            completeConnect();
            if ( current != null ) key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
            return false;
        } else  {
            //wait for the connection to finish
            key.interestOps(key.interestOps() | SelectionKey.OP_CONNECT);
            return false;
        }//end if
    } else if ( key.isWritable() ) {
        boolean writecomplete = write(key);
        if ( writecomplete ) {
            //we are completed, should we read an ack?
            if ( waitForAck ) {
                //register to read the ack
                key.interestOps(key.interestOps() | SelectionKey.OP_READ);
            } else {
                //if not, we are ready, setMessage will reregister us for another write interest
                //do a health check, we have no way of verify a disconnected
                //socket since we don't register for OP_READ on waitForAck=false
                read(key);//this causes overhead
                setRequestCount(getRequestCount()+1);
                return true;
            }
        } else {
            //we are not complete, lets write some more
            key.interestOps(key.interestOps()|SelectionKey.OP_WRITE);
        }//end if
    } else if ( key.isReadable() ) {
        boolean readcomplete = read(key);
        if ( readcomplete ) {
            setRequestCount(getRequestCount()+1);
            return true;
        } else {
            key.interestOps(key.interestOps() | SelectionKey.OP_READ);
        }//end if
    } else {
        //unknown state, should never happen
        log.warn("Data is in unknown state. readyOps="+ops);
        throw new IOException("Data is in unknown state. readyOps="+ops);
    }//end if
    return false;
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
protected boolean processKey(SelectionKey sk, KeyAttachment attachment) {
    boolean result = true;
    try {
        if ( close ) {
            cancelledKey(sk, SocketStatus.STOP, attachment.comet);
        } else if ( sk.isValid() && attachment != null ) {
            attachment.access();//make sure we don't time out valid sockets
            sk.attach(attachment);//cant remember why this is here
            NioChannel channel = attachment.getChannel();
            if (sk.isReadable() || sk.isWritable() ) {
                if ( attachment.getSendfileData() != null ) {
                    processSendfile(sk,attachment, false);
                } else {
                    if ( isWorkerAvailable() ) {
                        unreg(sk, attachment, sk.readyOps());
                        boolean closeSocket = false;
                        // Read goes before write
                        if (sk.isReadable()) {
                            if (!processSocket(channel, SocketStatus.OPEN_READ, true)) {
                                closeSocket = true;
                            }
                        }
                        if (!closeSocket && sk.isWritable()) {
                            if (!processSocket(channel, SocketStatus.OPEN_WRITE, true)) {
                                closeSocket = true;
                            }
                        }
                        if (closeSocket) {
                            cancelledKey(sk,SocketStatus.DISCONNECT,false);
                        }
                    } else {
                        result = false;
                    }
                }
            }
        } else {
            //invalid key
            cancelledKey(sk, SocketStatus.ERROR,false);
        }
    } catch ( CancelledKeyException ckx ) {
        cancelledKey(sk, SocketStatus.ERROR,false);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        log.error("",t);
    }
    return result;
}