Selector类的使用(二)

客官°小女子只卖身不卖艺 2021-08-29 19:26 293阅读 0赞

#### 返回此选择器的键集 ####

`public abstract Set<SelectionKey> keys`方法的作用是返回此选择器的键集。不可直接修改键集。仅在已取消某个键并且已注销其通道后才移除该键。试图修改键集会导致抛出  
UnsupportedOperationException异常。

1627674070
    1360875712
    1625635731
    
    1627674070
    1625635731
    1360875712

#### 带超时的select ####

`public abstract int select(long timeout)`方法的作用是选择一组键， 其相应的通道已为I/O操作准备就绪。此方法执行处于阻塞模式的选择操作。

仅在至少选择一个通道、调用此选择器的wakeup()方法、当前的线程已中断，或者给定的超时期满(以先到者为准)后，此方法才返回。

此方法不提供实时保证:它安排了超时时间，就像调用Object. wait(long)方法一样。参数timeout代表如果为正，则在等待某个通道准备就绪时最多阻塞timeout毫秒;如果为零，则无限期地阻塞;必须为非负数。返回值代表已更新其准备就绪操作集的键的数目，该数目可能为零。

#### selectNow()方法 ####

`public abstract int selectNow()`方法的作用是选择一组键，其相应的通道已为I/O操作准备就绪。此方法执行非阻塞的选择操作。如果自从前一次选择操作后，没有通道变成可选择的，则此方法直接返回零。调用此方法会清除所有以前调用wakeup()方法所得的结果。返回值代表由选择操作更新其准备就绪操作集的键的数目，该数目可能为零。

public static void main(String[] args) { 
            try { 
                ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
                serverSocketChannel.bind(new InetSocketAddress("localhost", 8888));
                serverSocketChannel.configureBlocking(false);
    
                Selector selector = Selector.open();
                serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
                boolean isRun = true;
                while (isRun) { 
                    System.out.println("while (isRun == true) " + System.currentTimeMillis());
                    int keyCount = selector.selectNow();
                    System.out.println("while (isRun == true) " + System.currentTimeMillis());
                    Set<SelectionKey> keys = selector.selectedKeys();
                    Iterator<SelectionKey> it = keys.iterator();
                    while (it.hasNext()) { 
                        System.out.println("进入while");
                        SelectionKey key = it.next();
                        if (key.isAcceptable()) { 
                            ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                            Socket socket = channel.socket().accept();
                            socket.close();
                        }
                        it.remove();
                    }
                }
                serverSocketChannel.close();
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]

#### 唤醒操作 ####

`public abstract Selector wakeup()`方法的作用是使尚未返回的第一个选择操作立即返回。

*  如果另一个线程目前正阻塞在select()或select(long)方法的调用中，则该调用将立即返回。
 *  如果当前未进行选择操作，那么在没有同时调用selectNow()方法的情况下，对上述方法的下一次调用将立即返回。

在任一情况下，该调用返回的值可能是非零的。如果未同时再次调用此方法，则照常阻塞select()或select(long)方法的后续调用。在两个连续的选择操作之间多次调用此方法与只调用一次的效果相同。

private  static Selector selector;
    
        public static void main(String[] args) throws IOException { 
            Thread thread = new Thread() { 
                @Override
                public void run() { 
                    try { 
                        Thread.sleep(2000);
                        selector.wakeup();
                        Set<SelectionKey> set1 = selector.keys();
                        Set<SelectionKey> set2 = selector.selectedKeys();
                        System.out.println("执行wakeup()方法之后的selector的信息：");
                        System.out.println("set1.size()=" + set1.size());
                        System.out.println("set2.size()=" + set2.size());
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            };
            thread.start();
    
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress("localhost", 8888));
            serverSocketChannel.configureBlocking(false);
    
            selector = Selector.open();
            SelectionKey selectionKey = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            int keyCount = selector.select();
            Set<SelectionKey> keySet = selector.selectedKeys();
            Iterator<SelectionKey> it = keySet.iterator();
            while (it.hasNext()) { 
                SelectionKey key = it.next();
                if (key.isAcceptable()) { 
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    Socket socket = channel.socket().accept();
                    socket.close();
                }
                it.remove();
            }
            serverSocketChannel.close();
            System.out.println("main end!");
        }

![在这里插入图片描述][20200610104246227.png]

### Selector使用中的细节问题 ###

1. 对SelectionKey执行cancel()方法后的效果：

调用该键的cancel()方法来取消键，该键都被添加到其选择器的已取消键集中。取消某个键会导致在下一次select()方法选择操作期间注销该键的通道，而在注销时将从所有选择器的键集中移除该键。

public static void main(String[] args) { 
            try { 
                ServerSocketChannel serverSocketChannel1 = ServerSocketChannel.open();
                serverSocketChannel1.bind(new InetSocketAddress("localhost", 7777));
                serverSocketChannel1.configureBlocking(false);
    
                ServerSocketChannel serverSocketChannel2 = ServerSocketChannel.open();
                serverSocketChannel2.bind(new InetSocketAddress("localhost", 8888));
                serverSocketChannel2.configureBlocking(false);
    
                Selector selector = Selector.open();
    
                SelectionKey selectionKey1 = serverSocketChannel1.register(selector, SelectionKey.OP_ACCEPT);
                SelectionKey selectionKey2 = serverSocketChannel2.register(selector, SelectionKey.OP_ACCEPT);
    
                Thread client = new Thread() { 
                    @Override
                    public void run() { 
                        try { 
                            Socket socket1 = new Socket("localhost", 7777);
                            OutputStream outputStream1 = socket1.getOutputStream();
                            outputStream1.write("我是中国人，我来自客户端to7777!".getBytes());
                            socket1.close();
                            Socket socket2 = new Socket("localhost", 8888);
                            OutputStream outputStream2 = socket2.getOutputStream();
                            outputStream2.write("我是中国人，我来自客户端to8888!".getBytes());
                            socket2.close();
                        } catch (IOException e) { 
                            e.printStackTrace();
                        }
                    }
                };
                client.start();
    
                Thread getInfo = new Thread() { 
                    @Override
                    public void run() { 
                        try { 
                            Thread.sleep(10000);
                            System.out.println();
                            Set<SelectionKey> keys = selector.keys();
                            Set<SelectionKey> selectedKeys = selector.selectedKeys();
                            System.out.println("select()方法执行第2次后的信息：");
                            System.out.println("keys.size()=" + keys.size());
                            System.out.println("selectedKeys.size()=" + selectedKeys.size());
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                };
                getInfo.start();
    
                Thread.sleep(2000);//目的是让客户端连接服务端
                boolean isRun = true;
                while (isRun) { 
                    int keyCount = selector.select();
                    Set<SelectionKey> keys = selector.keys();
                    Set<SelectionKey> selectedKeys = selector.selectedKeys();
                    System.out.println("取消之前的信息：");
                    System.out.println("keys.size()=" + keys.size());
                    System.out.println("selectedKeys.size()=" + selectedKeys.size());
                    System.out.println();
                    Iterator<SelectionKey> it = selectedKeys.iterator();
                    while (it.hasNext()) { 
                        SelectionKey key = it.next();
                        if (key.isAcceptable()) { 
                            ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                            ServerSocket serverSocket = channel.socket();
                            Socket socket = serverSocket.accept();
                            InputStream inputStream = socket.getInputStream();
                            byte[] byteArray = new byte[1024];
                            int readLength = inputStream.read(byteArray);
                            while (readLength != -1) { 
                                System.out.println(new String(byteArray, 0, readLength));
                                readLength = inputStream.read(byteArray);
                            }
                            inputStream.close();
                            socket.close();
                            //it.remove();
                            if (serverSocket.getLocalPort() == 7777) { 
                                key.cancel();
                                System.out.println("取消之后的信息：");
                                System.out.println("keys.size()=" + keys.size());
                                System.out.println("selectedKeys.size()=" + selectedKeys.size());
                            }
                        }
                    }
                }
                serverSocketChannel1.close();
                serverSocketChannel2.close();
            } catch (IOException e) { 
                e.printStackTrace();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 1]  
对SelectionKey执行cancel()方法操作会将SelectionKey放入取消键集中，并且在下-一次执行select()方法时删除这个SelectionKey 所有的键集，并且通道被注销，因此，在控制台的最后输出两个1。

2. 对通道执行close()方法后的效果：  
关闭某个键的通道，通道对应的键都被添加到其选择器的已取消键集中，会导致在下一次select()方法选择操作期间注销该键的通道，而在注销时将从所有选择器的键集中移除该键。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 3]  
对ServerSocketChannel调用close()方法后，在下一次select()方法选择时将ServerSocketChannel对应的SelectionKey从所有键集中删除，并且将这个ServerSocketChannel通道从Selector中注销。

3. 在新创建的选择器中，3个集合都是空集合：

public static void main(String[] args) { 
            try { 
                Selector selector = Selector.open();
                Set<SelectionKey> keys = selector.keys();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                System.out.println("keys.size()=" + keys.size());
                System.out.println("selectionKeys.size()=" + selectionKeys.size());
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }

keys.size()=0
    selectionKeys.size()=0

#### 删除键集中的键会导致UnsupportedOperationException异常 ####

try { 
                ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
                serverSocketChannel.bind(new InetSocketAddress("localhost", 7777));
                serverSocketChannel.configureBlocking(false);
    
                Selector selector = Selector.open();
                SelectionKey selectionKey = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    
                selector.keys().remove(selectionKey);
            } catch (IOException e) { 
                e.printStackTrace();
            }

![在这里插入图片描述][20200610120750805.png]  
说明：键集中的元素不可以显式的修改。

5. 多线程环境下删除键集中的键会导致ConcurrentModificationException异常：  
一般情况下，选择器的键和已选择键集由多个并发线程使用是不安全的。如果这样的线程可以直接修改这些键集之一，那么应该通过对该键集本身进行同步来控制访问。这些键集的iterator()方法所返回的迭代器是快速失败的:如果在创建迭代器后以任何方式(调用迭代器自身的remove(方法除外)修改键集，则会抛出ConcurrentModificationException。

=6. 阻塞在select()或select(long)方法中的线程通过选择器的close()方法被中断：

private static Thread mainThread = Thread.currentThread();
    
        public static void main(String[] args) { 
            try { 
                ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
                serverSocketChannel.bind(new InetSocketAddress("localhost", 7777));
                serverSocketChannel.configureBlocking(false);
    
                Selector selector = Selector.open();
    
                serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    
                Thread client = new Thread() { 
                    @Override
                    public void run() { 
                        try { 
                            Thread.sleep(2000);
                            //interrupt()含义是不想让想成工作了，也就是要销毁线程
                            //interrupt()方法只是对线程对象打一个标记，
                            //代表这个线程要销毁，因为，要结合interrupted()进行判断，
                            //如果结果为true，以break退出while(true)，结束当前线程的执行
                            mainThread.interrupt();//中断主线程
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                };
                client.start();
    
                boolean isRun = true;
                while (isRun) { 
                    System.out.println("begin " + System.currentTimeMillis());
                    int keyCount = selector.select();
                    mainThread.interrupted();//清除中断状态，继续循环
                    System.out.println("end " + System.currentTimeMillis() + " keyCount=" + keyCount);
                    Set<SelectionKey> keys = selector.keys();
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iterator = selectionKeys.iterator();
                    while (iterator.hasNext()) { 
                        SelectionKey key = iterator.next();
                        iterator.remove();
                        if (key.isAcceptable()) { 
                            ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                            ServerSocket serverSocket = channel.socket();
                            Socket socket = serverSocket.accept();
                            socket.close();
                        }
                    }
                    serverSocketChannel.close();
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }

![在这里插入图片描述][202006101316417.png]

8. 调用Selector.close()方法删除全部并且通道注销：

注意：指定close()方法后，除了再次调用close()和wakeup()方法外，调用Selector的其他方法均出现异常。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]: /images/20210813/2dc7ce5a630945f5a370819cc0889389.png
[20200610104246227.png]: /images/20210813/5198c8c44ec74d109728e21d3ac76929.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 1]: /images/20210813/d660d80d1f7a40f0985b4efebf0032a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 2]: /images/20210813/69e24fa468f34076bb993d1a8e7b470a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 3]: /images/20210813/4f4242d87e8b4079829c032f8f772243.png
[20200610120750805.png]: /images/20210813/ba44375dfe144e0c8d0a88b7fa34733a.png
[202006101316417.png]: /images/20210813/b32207de10ad4700a3e9839e8bceac3a.png