非阻塞write（）无限大-java

我有一个简单的网页抓取。而OP_WRITE会一直触发选择器，因此select（）永远不会结束。Select始终返回1，尽管频道已完成其工作并已关闭，但仍在等待写入。我怎么处理？我的CPU也非常高

代码如下：

public static void main(String [] args)
{

try
{
    String adder="";

    Selector selector= simpleFetcher.selector;
    selector = Selector.open();

    Charset charset = Charset.forName("ISO-8859-1");

    try{

    //add to selector the host and settings
    addHost(selector, "localhost", 80);
    addHost(selector, "site.org", 80);

    } catch (UnresolvedAddressException ex) {System.out.println("Address Not exist "+ex.getMessage());}

    while(true)
    {

    int selectedn = selector.select(2000);
    if (selectedn==0)
    {
        Set<SelectionKey> SelectorKeys = selector.keys();
        Iterator<SelectionKey> iterator  = SelectorKeys.iterator();

        while(iterator.hasNext())
        {
            SelectionKey k = (SelectionKey) iterator.next();
            SocketChannel channel = (SocketChannel) k.channel();

            String rHost;
            InetAddress addr = channel.socket().getInetAddress();
            rHost= addr.getHostAddress();
            System.out.println(rHost+" is timeout");

        }
        System.out.println("adder:"+adder);
        selector.close();

        System.out.println("No more keys.. Exiting");
        return;
    }

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

    while(iterator.hasNext())
    {
        SelectionKey key = (SelectionKey) iterator.next();
        iterator.remove();

        if (key.isValid()==false) {System.out.println("key not valid"); continue;}


        try{
            if (key.isConnectable())
            {

                System.out.println("Will connect right now");

                SocketChannel channel = (SocketChannel) key.channel();

                if (!channel.finishConnect()) { System.out.println("Not finished connection. continue.."); continue; }
                if (channel.isConnectionPending()==false && channel.socket().isClosed()==true) System.out.println("CLOSED?");


                SelectionKey k = channel.register(key.selector(),SelectionKey.OP_READ);
                SelectionKey k2 = channel.register(key.selector(),SelectionKey.OP_WRITE);
                //SelectionKey k = channel.register(key.selector(),SelectionKey.OP_READ | SelectionKey.OP_WRITE);
                k.attach(ByteBuffer.allocate(4000));


                System.out.println("Just Connected");
                continue;
            }
            if (key.isReadable())
            {
                int readB;
                System.out.println("Ready for reading..");
                SocketChannel channel = (SocketChannel) key.channel();
                ByteBuffer buffer = (ByteBuffer) key.attachment();
                CharBuffer charbuffer = buffer.asCharBuffer();

                if ((readB=channel.read(buffer)) !=-1) 
                {
                    System.out.println("Key accepted - reading..");
                    int current_capacity=buffer.position();

                    buffer.flip();
                    CharBuffer c = charset.decode(buffer);
                    char[] arr = c.array();


                    String data = new String(arr);

                    String[] lines = data.split("\\r\\n\\r\\n");
                    if (lines.length>1) 
                    {
                        String header = lines[0];
                        String rest_body = lines[1];
                        //System.out.println("Header is: "+header);
                        //System.out.println("Body is: "+rest_body);
                        adder+=header+rest_body;
                    }
                    else { adder+=new String(arr); }


                }
                else 
                {
                    key.channel().close();
                    key.cancel();
                    System.out.println("Key cancled");
                    System.out.println(adder);

                    continue;
                }
                if (readB==0) System.out.println("The READ RETURNS 0");

                    System.out.println();
                    buffer.clear();

                continue;

            }
            if (key.isWritable())
            {

                //System.out.println("Ready to write");

                    SocketChannel channel = (SocketChannel) key.channel();
                    String rHost;

                    Socket s = channel.socket();
                    s.shutdownOutput();



                    InetAddress addr = channel.socket().getInetAddress();
                    rHost= addr.getHostAddress();
                    //System.out.println(rHost);

                    if (s.isOutputShutdown()) continue;

                    String bytestowrite="GET / HTTP/1.1\r\nHost: "+rHost+"\r\nUser-agent: Agent 1.0 Experimental\r\nAccept: */*\r\nAccept-Language: en-US,en;q=0.5\r\nConnection: keep-alive\r\n\r\n";
                    ByteBuffer buffer = ByteBuffer.wrap(bytestowrite.getBytes());

                    while(buffer.hasRemaining()) channel.write(buffer);
                    key.cancel();
                continue;
            }


        } catch (IOException ex) {
            System.out.println("EXCEPTION: "+ex.getMessage());
            key.cancel(); 
            try { key.channel().close();} 
            catch (IOException cex) {}; 
        }

        System.out.println("End of iterator loop");
    }
    }
}catch (IOException ex) {System.out.println("Timeout");}



}

publicstaticvoidmain（字符串[]args）
{
尝试
{
字符串加法器=”；
选择器选择器=simpleFetcher.Selector；
选择器=selector.open（）；
Charset Charset=Charset.forName（“ISO-8859-1”）；
试一试{
//将选择器添加到主机和设置
addHost（选择器，“localhost”，80）；
addHost（选择器，“site.org”，80）；
}catch（unsolvedAddressException ex）{System.out.println（“地址不存在”+ex.getMessage（））；}
while（true）
{
int selectedn=选择器。选择（2000）；
如果（selectedn==0）
{
设置SelectorKeys=selector.keys（）；
迭代器迭代器=SelectorKeys.Iterator（）；
while（iterator.hasNext（））
{
SelectionKey k=（SelectionKey）迭代器.next（）；
SocketChannel=（SocketChannel）k.channel（）；
弦菱形；
InetAddress addr=channel.socket（）.getInetAddress（）；
rHost=addr.getHostAddress（）；
System.out.println（rHost+“是超时”）；
}
System.out.println（“加法器：“+加法器”）；
selector.close（）；
System.out.println（“不再有键..退出”）；
返回；
}
设置selectedKeys=选择器。selectedKeys（）；
迭代器迭代器=selectedKeys.Iterator（）；
while（iterator.hasNext（））
{
SelectionKey=（SelectionKey）迭代器.next（）；
iterator.remove（）；
如果（key.isValid（）==false）{System.out.println（“key无效”）；继续；}
试一试{
if（key.isConnectable（））
{
System.out.println（“将立即连接”）；
SocketChannel=（SocketChannel）key.channel（）；
如果（！channel.finishConnect（））{System.out.println（“未完成连接。继续”）；continue；}
if（channel.isConnectionPending（）==false&&channel.socket（）.isClosed（）==true）System.out.println（“CLOSED？”）；
SelectionKey k=通道寄存器（key.selector（），SelectionKey.OP_READ）；
SelectionKey k2=channel.register（key.selector（），SelectionKey.OP_WRITE）；
//SelectionKey k=通道.寄存器（key.selector（），SelectionKey.OP_READ | SelectionKey.OP_WRITE）；
k、 附加（ByteBuffer.allocate（4000））；
System.out.println（“刚刚连接”）；
继续；
}
if（key.isReadable（））
{
int readB；
System.out.println（“准备好读取…”）；
SocketChannel=（SocketChannel）key.channel（）；
ByteBuffer缓冲区=（ByteBuffer）键。附件（）；
CharBuffer CharBuffer=buffer.asCharBuffer（）；
if（（readB=channel.read（buffer））！=-1）
{
System.out.println（“接受的键-读取…”）；
int current_capacity=buffer.position（）；
flip（）；
CharBuffer c=字符集解码（buffer）；
char[]arr=c.array（）；
字符串数据=新字符串（arr）；
String[]line=data.split（\\r\\n\\r\\n”）；
如果（线条长度>1）
{
字符串头=行[0]；
字符串rest_body=行[1]；
//System.out.println（“表头为：“+表头”）；
//System.out.println（“主体为：“+rest\u主体”）；
加法器+=头+剩余体；
}
else{adder+=新字符串（arr）；}
}
其他的
{
key.channel（）.close（）；
键。取消（）；
System.out.println（“密钥取消”）；
系统输出打印LN（加法器）；
继续；
}
如果（readB==0）System.out.println（“读取返回0”）；
System.out.println（）；
buffer.clear（）；
继续；
}
if（key.isWritable（））
{
//System.out.println（“准备写入”）；
SocketChannel=（SocketChannel）key.channel（）；
弦菱形；
sockets=channel.Socket（）；
s、 关机输出（）；
InetAddress addr=channel.socket（）.getInetAddress（）；
rHost=addr.getHostAddress（）；
//系统输出打印LN（rHost）；
如果（s.isOutputShutdown（））继续；
String bytestowrite=“GET/HTTP/1.1\r\nHost:“+rHost+”\r\n用户代理：代理1.0实验性\r\n概念：*/*\r\n概念语言：en-US，en；q=0.5\r\n连接：保持活动\r\n\r\n”；
ByteBuffer buffer=ByteBuffer.wrap（bytestowrite.getBytes（））；
while（buffer.haslaining（））channel.write（buffer）；
键。取消（）；
继续；
}
}捕获（IOEX异常）{
System.out.println（“异常：+ex.getMessage（））；
键。取消（）；
请尝试{key.channel（）.close（）；}
捕获（iocex）{}；
}
System.out.println（“迭代器循环结束”）；
}
}
}catch（IOException ex）{System.out.println（“超时”）；}
}

套接字通道几乎总是可写的，这意味着套接字发送缓冲区中几乎总是有可用空间。只有当发送方超过接收方时，这才不再是真的

因此，为

OP_WRITE

注册通道是不正确的，除非它们已经经历了缓冲区满的情况