`
Donald_Draper
  • 浏览: 984460 次
社区版块
存档分类
最新评论

SocketChannelImpl 解析四(关闭通道等)

    博客分类:
  • NIO
阅读更多
SocketChannelImpl 解析一(通道连接,发送数据):http://donald-draper.iteye.com/blog/2372364
SocketChannelImpl 解析二(发送数据后续):http://donald-draper.iteye.com/blog/2372548
SocketChannelImpl 解析三(接收数据):http://donald-draper.iteye.com/blog/2372590
引言:
上一篇文章,我们看了SocketChannelImpl接收数据相关方法,具体为:
    读输入流到buffer,首先同步读写,确保通道,输入流打开,通道连接建立,
清除原始读线程,获取新的本地读线程,委托IOUtil读输入流到buffer;IOUtil读输入流到buffer,首先确保buffer是可写的,否则抛出IllegalArgumentException,然后判断buffer是否为Direct类型,是则委托给readIntoNativeBuffer,否则通过Util从当前线程缓冲区获取一个临时的DirectByteBuffer,然后通过readIntoNativeBuffer读输入流数据到临时的DirectByteBuffer,这一个过程是通过SocketDispatcher的read方法实现,读写数据到DirectByteBuffer中后,将DirectByteBuffer中数据,写到原始buffer中,并将
DirectByteBuffer添加到添加临时DirectByteBuffer到当前线程的缓冲区,以便重用,因为重新DirectByteBuffer为直接操作物理内存,频繁分配物理内存,将耗费过多的资源。
    从输入流读取数据,写到ByteBuffer数组的read方法,首先同步写锁,确保通道,连接建立,输入流打开,委托给IOUtil,从输入流读取数据写到ByteBuffer数组中;IOUtil首先获取存放i个字节缓冲区的IOVecWrapper,遍历ByteBuffer数组m,将buffer添加到iovecwrapper的字节缓冲区数组中,如果ByteBuffer非Direct类型,委托Util从当前线程的缓冲区获取容量为j2临时DirectByteBuffer,并将ByteBuffer写到DirectByteBuffer,并将DirectByteBuffer添加到iovecwrapper的字节缓冲区(Shadow-Direct)数组中,将字节缓冲区的起始地址写到iovecwrapper,字节缓冲区的实际容量写到iovecwrapper;遍历iovecwrapper的字节缓冲区(Shadow-Direct)数组,将Shadow数组中的DirectByteBuffer通过Util添加到本地线程的缓存区中,并清除DirectByteBuffer在iovecwrapper的相应数组中的信息;最后通过
SocketDispatcher,从filedescriptor对应的输入流读取数据,写到iovecwrapper的缓冲区中。
今天SocketChannelImpl的其他方法
//是否正在连接
 public boolean isConnectionPending()
    {
        //同步状态锁
        Object obj = stateLock;
        JVM INSTR monitorenter ;//进入同步
        return state == 1;
        Exception exception;
        exception;
        throw exception;//有异常,则抛出
    }

//完成连接
public boolean finishConnect()
        throws IOException
    {
       //同步读写锁及状态锁
        Object obj = readLock;
        JVM INSTR monitorenter ;//进入同步
        Object obj1 = writeLock;
        JVM INSTR monitorenter ;
        Object obj2 = stateLock;
        JVM INSTR monitorenter ;
        if(!isOpen())//通道关闭,则抛出ClosedChannelException
            throw new ClosedChannelException();
        if(state == 2)
	    //如果已经建立连接,则返回true
            return true;
        if(state != 1)
	    //如果连接不处于正在建立状态,则抛出NoConnectionPendingException
            throw new NoConnectionPendingException();
       ...
        int i = 0;
        begin();//与end方法,协调记录中断器,处理连接中断
        boolean flag;
        synchronized(blockingLock())
        {
            synchronized(stateLock)
            {
                if(isOpen())
                    break MISSING_BLOCK_LABEL_206;
                flag = false;
            }
        }
        synchronized(stateLock)
        {
            readerThread = 0L;
            if(state == 3)
            {
                kill();
                i = 0;
            }
        }
        end(i > 0 || i == -2);
        if(!$assertionsDisabled && !IOStatus.check(i))
            throw new AssertionError();
        obj1;
        JVM INSTR monitorexit ;
        obj;
        JVM INSTR monitorexit ;
        return flag;
        readerThread = NativeThread.current();
        obj7;
        JVM INSTR monitorexit ;
	//检查连接
        if(!isBlocking())
            do
                i = checkConnect(fd, false, readyToConnect);
            while(i == -3 && isOpen());
        else
            do
                i = checkConnect(fd, true, readyToConnect);
            while(i == 0 || i == -3 && isOpen());
        obj4;
        ...
    }

在完成连接方法中,我们需要关注的这下面这段
//检查连接
if(!isBlocking())
    do
        i = checkConnect(fd, false, readyToConnect);
    while(i == -3 && isOpen());
else
    do
        i = checkConnect(fd, true, readyToConnect);
    while(i == 0 || i == -3 && isOpen());

上面这段之所以,在一个循环内检查连接,主要是为了,在完成连接的过程中,如果由于某种原因 被中断,当中断位消除时,继续完成连接。
 private static native int checkConnect(FileDescriptor filedescriptor, boolean flag, boolean flag1)
        throws IOException;

再来看其他方法,
//配置阻塞模式
 protected void implConfigureBlocking(boolean flag)
        throws IOException
    {
        IOUtil.configureBlocking(fd, flag);
    }

//IOUtil
 
 static native void configureBlocking(FileDescriptor filedescriptor, boolean flag)
        throws IOException;

//socket通道支持的配置选项
public final Set supportedOptions()
    {
        return DefaultOptionsHolder.defaultOptions;
    }
//DefaultOptionsHolder
private static class DefaultOptionsHolder
    {

        private static Set defaultOptions()
        {
            HashSet hashset = new HashSet(8);
            hashset.add(StandardSocketOptions.SO_SNDBUF);//发送缓冲区size
            hashset.add(StandardSocketOptions.SO_RCVBUF);//接收缓冲区size
            hashset.add(StandardSocketOptions.SO_KEEPALIVE);//
            hashset.add(StandardSocketOptions.SO_REUSEADDR);//地址重用
            hashset.add(StandardSocketOptions.SO_LINGER);//
            hashset.add(StandardSocketOptions.TCP_NODELAY);//TCP
            hashset.add(StandardSocketOptions.IP_TOS);
            hashset.add(ExtendedSocketOption.SO_OOBINLINE);
	    //返回不可修改的HashSet
            return Collections.unmodifiableSet(hashset);
        }
        static final Set defaultOptions = defaultOptions();
        private DefaultOptionsHolder()
        {
        }
    }

//StandardSocketOptions
/**
 * The size of the socket send buffer.发送缓冲区大小
 * @see Socket#setSendBufferSize
 */
public static final SocketOption<Integer> SO_SNDBUF =
    new StdSocketOption<Integer>("SO_SNDBUF", Integer.class);
 /**
 * The size of the socket receive buffer.接收缓存区大小
 * @see Socket#setReceiveBufferSize
 * @see ServerSocket#setReceiveBufferSize
 */
 public static final SocketOption<Integer> SO_RCVBUF =
     new StdSocketOption<Integer>("SO_RCVBUF", Integer.class);
/**
* Keep connection alive.连接是否保活
*/
public static final SocketOption<Boolean> SO_KEEPALIVE =
    new StdSocketOption<Boolean>("SO_KEEPALIVE", Boolean.class);
/**
 * Re-use address.地址重用
 * @see ServerSocket#setReuseAddress
 */
public static final SocketOption<Boolean> SO_REUSEADDR =
    new StdSocketOption<Boolean>("SO_REUSEADDR", Boolean.class);

/**
 * Linger on close if data is present.如果通道中有数据,延时关闭时间
 * @see Socket#setSoLinger
 */
public static final SocketOption<Integer> SO_LINGER =
    new StdSocketOption<Integer>("SO_LINGER", Integer.class);
 /**
 * Disable the Nagle algorithm.TCP无延时
 * @see Socket#setTcpNoDelay
 */
public static final SocketOption<Boolean> TCP_NODELAY =
    new StdSocketOption<Boolean>("TCP_NODELAY", Boolean.class);
//下面两个配置选择,我们以后碰到再说
/**
 * The Type of Service (ToS) octet in the Internet Protocol (IP) header.
 * @see DatagramSocket#setTrafficClass
 */
public static final SocketOption<Integer> IP_TOS =
    new StdSocketOption<Integer>("IP_TOS", Integer.class);

//ExtendedSocketOption
package sun.nio.ch;
import java.net.SocketOption;
class ExtendedSocketOption
{
    private ExtendedSocketOption()
    {
    }
    static final SocketOption SO_OOBINLINE = new SocketOption() {
        public String name()
        {
            return "SO_OOBINLINE";
        }
        public Class type()
        {
            return java/lang/Boolean;
        }
        public String toString()
        {
            return name();
        }
    };
}

//设置配置选项
public SocketChannel setOption(SocketOption socketoption, Object obj)
        throws IOException
    {
        if(socketoption == null)
            throw new NullPointerException();
	//非支持配置选项,则抛出UnsupportedOperationException
        if(!supportedOptions().contains(socketoption))
            throw new UnsupportedOperationException((new StringBuilder()).append("'").append(socketoption).append("' not supported").toString());
        //同步状态锁,进入同步
	Object obj1 = stateLock;
        JVM INSTR monitorenter ;
        if(!isOpen())
	    //通道关闭,则抛出ClosedChannelException
            throw new ClosedChannelException();
        if(socketoption != StandardSocketOptions.IP_TOS)
            break MISSING_BLOCK_LABEL_108;
        if(!Net.isIPv6Available())
	    //iPv6不可用,则通过Net设置配置项
            Net.setSocketOption(fd, StandardProtocolFamily.INET, socketoption, obj);
        return this;
        ...
        JVM INSTR monitorexit ;
        return;
        Exception exception;
        exception;
        throw exception;
    }

设置配置项,需要关注的是
if(!Net.isIPv6Available())
     //iPv6不可用,则通过Net设置配置项
     Net.setSocketOption(fd, StandardProtocolFamily.INET, socketoption, obj);

//Net
//检查IP6是否可用
 static boolean isIPv6Available()
    {
        if(!checkedIPv6)
        {
            isIPv6Available = isIPv6Available0();
            checkedIPv6 = true;
        }
        return isIPv6Available;
    }
static void setSocketOption(FileDescriptor filedescriptor, ProtocolFamily protocolfamily, SocketOption socketoption, Object obj)
        throws IOException
    {
        if(obj == null)
            throw new IllegalArgumentException("Invalid option value");
        Class class1 = socketoption.type();
	//非整形和布尔型,则抛出断言错误
        if(class1 != java/lang/Integer && class1 != java/lang/Boolean)
            throw new AssertionError("Should not reach here");
        if(socketoption == StandardSocketOptions.SO_RCVBUF || socketoption == StandardSocketOptions.SO_SNDBUF)
        {    //判断接收和发送缓冲区大小
            int i = ((Integer)obj).intValue();
            if(i < 0)
                throw new IllegalArgumentException("Invalid send/receive buffer size");
        }
	//缓冲区有数据,延迟关闭socket的的时间
        if(socketoption == StandardSocketOptions.SO_LINGER)
        {
            int j = ((Integer)obj).intValue();
            if(j < 0)
                obj = Integer.valueOf(-1);
            if(j > 65535)
                obj = Integer.valueOf(65535);
        }
	//UDP单播
        if(socketoption == StandardSocketOptions.IP_TOS)
        {
            int k = ((Integer)obj).intValue();
            if(k < 0 || k > 255)
                throw new IllegalArgumentException("Invalid IP_TOS value");
        }
	//UDP多播
        if(socketoption == StandardSocketOptions.IP_MULTICAST_TTL)
        {
            int l = ((Integer)obj).intValue();
            if(l < 0 || l > 255)
                throw new IllegalArgumentException("Invalid TTL/hop value");
        }
        OptionKey optionkey = SocketOptionRegistry.findOption(socketoption, protocolfamily);
        if(optionkey == null)
            throw new AssertionError("Option not found");
        int i1;
	//转换配置参数值
        if(class1 == java/lang/Integer)
        {
            i1 = ((Integer)obj).intValue();
        } else
        {
            boolean flag = ((Boolean)obj).booleanValue();
            i1 = flag ? 1 : 0;
        }
        boolean flag1 = protocolfamily == UNSPEC;
	//设置文件描述符的值
        setIntOption0(filedescriptor, flag1, optionkey.level(), optionkey.name(), i1);
    }

    private static native void setIntOption0(FileDescriptor filedescriptor, boolean flag, int i, int j, int k)
        throws IOException;

//获取配置选项
 public Object getOption(SocketOption socketoption)
        throws IOException
    {
        if(socketoption == null)
            throw new NullPointerException();
	//检查配置
        if(!supportedOptions().contains(socketoption))
            throw new UnsupportedOperationException((new StringBuilder()).append("'").append(socketoption).append("' not supported").toString());
        Object obj = stateLock;
        JVM INSTR monitorenter ;
	//检查通道打开状态
        if(!isOpen())
            throw new ClosedChannelException();
	//IP_TOS配置项返回值,如果iP6可用,返回0,否则委托给Net
        if(socketoption == StandardSocketOptions.IP_TOS)
            return Net.isIPv6Available() ? Integer.valueOf(0) : Net.getSocketOption(fd, StandardProtocolFamily.INET, socketoption);
        //获取配置项
	Net.getSocketOption(fd, Net.UNSPEC, socketoption);
        obj;
        JVM INSTR monitorexit ;
        return;
        Exception exception;
        exception;
        throw exception;
    }

//Net
static Object getSocketOption(FileDescriptor filedescriptor, ProtocolFamily protocolfamily, SocketOption socketoption)
        throws IOException
    {
        Class class1 = socketoption.type();
	//非整形和布尔型,则抛出断言错误
        if(class1 != java/lang/Integer && class1 != java/lang/Boolean)
            throw new AssertionError("Should not reach here");
        OptionKey optionkey = SocketOptionRegistry.findOption(socketoption, protocolfamily);
        if(optionkey == null)
            throw new AssertionError("Option not found");
        boolean flag = protocolfamily == UNSPEC;
	//获取文件描述的选项配置
        int i = getIntOption0(filedescriptor, flag, optionkey.level(), optionkey.name());
        if(class1 == java/lang/Integer)
            return Integer.valueOf(i);
        else
            return i != 0 ? Boolean.TRUE : Boolean.FALSE;
    }
    private static native int getIntOption0(FileDescriptor filedescriptor, boolean flag, int i, int j)
        throws IOException;

//获取通道Socket
  public Socket socket()
    {
        Object obj = stateLock;
        JVM INSTR monitorenter ;
        if(socket == null)
	    //创建Socket适配器
            socket = SocketAdaptor.create(this);
        return socket;
        Exception exception;
        exception;
        throw exception;
    }

//SocketAdaptor,可简单理解为SocketChannelImpl的代理
public class SocketAdaptor extends Socket
{
    private final SocketChannelImpl sc;
    private volatile int timeout;
    private InputStream socketInputStream;//输入流
    static final boolean $assertionsDisabled = !sun/nio/ch/SocketAdaptor.desiredAssertionStatus();
     //创建socket适配器
     public static Socket create(SocketChannelImpl socketchannelimpl)
    {
        return new SocketAdaptor(socketchannelimpl);
        SocketException socketexception;
        socketexception;
        throw new InternalError("Should not reach here");
    }
    //构造SocketAdaptor
      private SocketAdaptor(SocketChannelImpl socketchannelimpl)
        throws SocketException
    {
        super((SocketImpl)null);
        timeout = 0;
        socketInputStream = null;
        sc = socketchannelimpl;
    }
     public SocketChannel getChannel()
    {
        return sc;
    }

    public void connect(SocketAddress socketaddress)
        throws IOException
    {
        connect(socketaddress, 0);
    }
    public void connect(SocketAddress socketaddress, int i)
        throws IOException
    {
    ...
    sc.configureBlocking(false);
        if(!sc.connect(socketaddress))
    ...
    }
    //绑定地址
    public void bind(SocketAddress socketaddress)
        throws IOException
    {
        try
        {
            sc.bind(socketaddress);
        }
        catch(Exception exception)
        {
            Net.translateException(exception);
        }
    }
    //获取远端socket地址
      public InetAddress getInetAddress()
    {
        SocketAddress socketaddress = sc.remoteAddress();
        if(socketaddress == null)
            return null;
        else
            return ((InetSocketAddress)socketaddress).getAddress();
    }
    //获取本地地址
    public InetAddress getLocalAddress()
    {
        if(sc.isOpen())
        {
            SocketAddress socketaddress = sc.localAddress();
            if(socketaddress != null)
                return ((InetSocketAddress)socketaddress).getAddress();
        }
        return (new InetSocketAddress(0)).getAddress();
    }
   //获取远端socket端口
    public int getPort()
    {
        SocketAddress socketaddress = sc.remoteAddress();
        if(socketaddress == null)
            return 0;
        else
            return ((InetSocketAddress)socketaddress).getPort();
    }
    还有一些方法,我们这里就不一一列出了,相关方法都是通过内部
    socketChannelImpl实例的相应方法实现,所有SocketAdaptor,可简单理解为SocketChannelImpl的代理
}

//SocketAdaptor结构图:





//获取本地socket地址
    public SocketAddress getLocalAddress()
        throws IOException
    {
        Object obj = stateLock;
        JVM INSTR monitorenter ;
        if(!isOpen())
            throw new ClosedChannelException();
        return localAddress;
        Exception exception;
        exception;
        throw exception;
    }
//获取远端Socket地址
    public SocketAddress getRemoteAddress()
        throws IOException
    {
        Object obj = stateLock;
        JVM INSTR monitorenter ;
        if(!isOpen())
            throw new ClosedChannelException();
        return remoteAddress;
        Exception exception;
        exception;
        throw exception;
    }
//关闭输入流
public SocketChannel shutdownInput()
        throws IOException
    {
        Object obj = stateLock;
        JVM INSTR monitorenter ;
        if(!isOpen())
            throw new ClosedChannelException();
        if(!isConnected())
            throw new NotYetConnectedException();
        if(isInputOpen)
        {
	    //为Net关闭fd对应的输入流
            Net.shutdown(fd, 0);
            if(readerThread != 0L)
	        //通知读线程,输入流关闭
                NativeThread.signal(readerThread);
            isInputOpen = false;
        }
        return this;
        Exception exception;
        exception;
        throw exception;
    }
//关闭输出流
    public SocketChannel shutdownOutput()
        throws IOException
    {
        Object obj = stateLock;
        JVM INSTR monitorenter ;
        if(!isOpen())
            throw new ClosedChannelException();
        if(!isConnected())
            throw new NotYetConnectedException();
        if(isOutputOpen)
        {    
	    //为Net关闭fd对应的输出流
            Net.shutdown(fd, 1);
            if(writerThread != 0L)
	        //通知写线程,输出流关闭
                NativeThread.signal(writerThread);
            isOutputOpen = false;
        }
        return this;
        Exception exception;
        exception;
        throw exception;
    }

//Net
static native void shutdown(FileDescriptor filedescriptor, int i)
        throws IOException;

//NativeThread
package sun.nio.ch;
class NativeThread
{
    NativeThread()
    {
    }
    static long current()
    {
        return 0L;
    }
    static void signal(long l)
    {
    }
}

//输出流是否关闭
 public boolean isInputOpen()
{
    Object obj = stateLock;
    JVM INSTR monitorenter ;
    return isInputOpen;
    Exception exception;
    exception;
    throw exception;
}
//输入流是否关闭
public boolean isOutputOpen()
{
    Object obj = stateLock;
    JVM INSTR monitorenter ;
    return isOutputOpen;
    Exception exception;
    exception;
    throw exception;
}
//是否连接
 public boolean isConnected()
{
    Object obj = stateLock;
    JVM INSTR monitorenter ;
    return state == 2;
    Exception exception;
    exception;
    throw exception;
}

//关闭选择通道
protected void implCloseSelectableChannel()
        throws IOException
    {
        synchronized(stateLock)//同步状态锁
        {
	    //置输入流和输出流打开状态为false
            isInputOpen = false;
            isOutputOpen = false;
            if(state != 4)
	        //如果通道没有关闭,则预先关闭fd
                nd.preClose(fd);
            if(readerThread != 0L)
	        //通知读线程,关闭输入流
                NativeThread.signal(readerThread);
            if(writerThread != 0L)
	        //通知写线程,输出流关闭
                NativeThread.signal(writerThread);
            if(!isRegistered())
	        //如果当前没有注册到任何选择器,则调用kill完成实际关闭工作
                kill();
        }
    }

关闭选择通道有两点需要关注
1.
 
//如果通道没有关闭,则预先关闭fd
nd.preClose(fd);

//SocketDispatcher
void preClose(FileDescriptor filedescriptor)
     throws IOException
 {
     preClose0(filedescriptor);
 }
 static native void preClose0(FileDescriptor filedescriptor)
        throws IOException;

2.
 
//如果当前没有注册到任何选择器,则调用kill完成实际关闭工作
kill();

  
 public void kill()
        throws IOException
    {
label0:
        {
            synchronized(stateLock)
            {
                if(state != 4)
                    break label0;
            }
            return;
        }
        if(state != -1)
            break MISSING_BLOCK_LABEL_34;
        state = 4;
        obj;
        JVM INSTR monitorexit ;
        return;
        if(!$assertionsDisabled && (isOpen() || isRegistered()))
            throw new AssertionError();
        if(readerThread == 0L && writerThread == 0L)
        {
	    //委托SocketDispatcher关闭通道
            nd.close(fd);
            state = 4;//已经关闭
        } else
        {
	    //正在关闭
            state = 3;
        }
        obj;
        JVM INSTR monitorexit ;
          goto _L1
        exception;
        throw exception;
_L1:
    }

来看
//委托SocketDispatcher关闭通道
 nd.close(fd);

//SocketDispatcher
void close(FileDescriptor filedescriptor)
      throws IOException
  {
      close0(filedescriptor);
  }
static native void close0(FileDescriptor filedescriptor)
      throws IOException;

从上面可以看出:
实际关闭通道,首先同步状态锁,置输入流和输出流打开状态为false,
如果通道没有关闭,则通过SocketDispatcher预先关闭fd,通知读线程,关闭输入流,
通知写线程,输出流关闭,如果当前没有注册到任何选择器,则调用kill完成实际关闭工作,
即SocketDispatcher关闭fd。
//设置通道兴趣事件
 public void translateAndSetInterestOps(int i, SelectionKeyImpl selectionkeyimpl)
    {
        int j = 0;
        if((i & 1) != 0)
            j |= 1;//读事件
        if((i & 4) != 0)
            j |= 4;//写事件
        if((i & 8) != 0)
            j |= 2;//连接事件
        selectionkeyimpl.selector.putEventOps(selectionkeyimpl, j);
    }
//设置就绪事件
public boolean translateAndSetReadyOps(int i, SelectionKeyImpl selectionkeyimpl)
{
    return translateReadyOps(i, 0, selectionkeyimpl);
}
//更新就绪事件
public boolean translateAndUpdateReadyOps(int i, SelectionKeyImpl selectionkeyimpl)
{
    return translateReadyOps(i, selectionkeyimpl.nioReadyOps(), selectionkeyimpl);
}
public boolean translateReadyOps(int i, int j, SelectionKeyImpl selectionkeyimpl)
{
    int k = selectionkeyimpl.nioInterestOps();
    int l = selectionkeyimpl.nioReadyOps();
    int i1 = j;
    //就绪事件为读1写4连接8,接受连接事件16,不是这四种事件,则返回false
    if((i & 32) != 0)
        return false;
    //下面的这段24,16不是很明白,理解的网友可以给我留言,一起探讨,
    //莫非为8+16,接受连接,并建立连接
    if((i & 24) != 0)
    {
        i1 = k;
        selectionkeyimpl.nioReadyOps(i1);
        readyToConnect = true;//准备连接
        return (i1 & ~l) != 0;
    }
    if((i & 1) != 0 && (k & 1) != 0 && state == 2)
        i1 |= 1;//读事件,已连接
    if((i & 2) != 0 && (k & 8) != 0 && (state == 0 || state == 1))
    {
        i1 |= 8;//连接事件,正在连接
        readyToConnect = true;
    }
    if((i & 4) != 0 && (k & 4) != 0 && state == 2)
        i1 |= 4;//写事件
    selectionkeyimpl.nioReadyOps(i1);
    return (i1 & ~l) != 0;
}
//获取通道文件描述
 public FileDescriptor getFD()
{
    return fd;
}
//获取通道文件描述值
public int getFDVal()
{
    return fdVal;
}


总结:
实际关闭通道,同步状态锁,置输入流和输出流打开状态为false,如果通道没有关闭,则通过SocketDispatcher预先关闭fd,通知读线程,关闭输入流,通知写线程,输出流关闭,如果当前没有注册到任何选择器,则调用kill完成实际关闭工作,
即SocketDispatcher关闭fd。
  • 大小: 81.6 KB
  • 大小: 50.7 KB
分享到:
评论

相关推荐

    jdk 1.8源码包,包含sun源码,绝对真实,自己看大小就懂了,靠谱

    例如,`java.nio.channels.FileChannel`用于读写文件,`java.nio.Selector`则用于监听多个通道的事件。 JDK 1.8还引入了Lambda表达式,这是一种简洁的匿名函数表示方式,使得函数式编程风格在Java中变得更加便捷。...

    Ice-3.7.4.msi for windows版

    6 连接突然断开(比如对方因为段错误而程序停止,或者在连接过程中正常关闭) : 发生在使用代理调用接口的时候(连接丢失) 原因: 已经建立连接的对方突然断开 错误信息: warning: connection exception: ...

    ysoserial-master.zip

    ysoserial是一个用于生成利用不安全的Java对象反序列化的有效负载的概念验证工具。它包含一系列在常见Java库中发现的"gadget chains",可以在特定条件下利用执行不安全的反序列化操作的Java应用程序。ysoserial项目最初在2015年AppSecCali会议上提出,包含针对Apache Commons Collections(3.x和4.x版本)、Spring Beans/Core(4.x版本)和Groovy(2.3.x版本)的利用链

    zigbee CC2530无线自组网协议栈系统代码实现协调器与终端的TI Sensor实验和Monitor使用.zip

    1、嵌入式物联网单片机项目开发例程,简单、方便、好用,节省开发时间。 2、代码使用IAR软件开发,当前在CC2530上运行,如果是其他型号芯片,请自行移植。 3、软件下载时,请注意接上硬件,并确认烧录器连接正常。 4、有偿指导v:wulianjishu666; 5、如果接入其他传感器,请查看账号发布的其他资料。 6、单片机与模块的接线,在代码当中均有定义,请自行对照。 7、若硬件有差异,请根据自身情况调整代码,程序仅供参考学习。 8、代码有注释说明,请耐心阅读。 9、例程具有一定专业性,非专业人士请谨慎操作。

    YOLO算法-自卸卡车-挖掘机-轮式装载机数据集-2644张图像带标签-自卸卡车-挖掘机-轮式装载机.zip

    YOLO系列算法目标检测数据集,包含标签,可以直接训练模型和验证测试,数据集已经划分好,包含数据集配置文件data.yaml,适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法; 包含两种标签格:yolo格式(txt文件)和voc格式(xml文件),分别保存在两个文件夹中,文件名末尾是部分类别名称; yolo格式:<class> <x_center> <y_center> <width> <height>, 其中: <class> 是目标的类别索引(从0开始)。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标,这些坐标是相对于图像宽度和高度的比例值,范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度,也是相对于图像宽度和高度的比例值; 【注】可以下拉页面,在资源详情处查看标签具体内容;

    Oracle10gDBA学习手册中文PDF清晰版最新版本

    **Oracle 10g DBA学习手册:安装Oracle和构建数据库** **目的:** 本章节旨在指导您完成Oracle数据库软件的安装和数据库的创建。您将通过Oracle Universal Installer (OUI)了解软件安装过程,并学习如何利用Database Configuration Assistant (DBCA)创建附加数据库。 **主题概览:** 1. 利用Oracle Universal Installer (OUI)安装软件 2. 利用Database Configuration Assistant (DBCA)创建数据库 **第2章:Oracle软件的安装与数据库构建** **Oracle Universal Installer (OUI)的运用:** Oracle Universal Installer (OUI)是一个图形用户界面(GUI)工具,它允许您查看、安装和卸载机器上的Oracle软件。通过OUI,您可以轻松地管理Oracle软件的安装和维护。 **安装步骤:** 以下是使用OUI安装Oracle软件并创建数据库的具体步骤:

    消防验收过程服务--现场记录表.doc

    消防验收过程服务--现场记录表.doc

    (4655036)数据库 管理与应用 期末考试题 数据库试题

    数据库管理\09-10年第1学期数据库期末考试试卷A(改卷参考).doc。内容来源于网络分享,如有侵权请联系我删除。另外如果没有积分的同学需要下载,请私信我。

    YOLO算法-瓶纸盒合并数据集-3161张图像带标签-纸张-纸箱-瓶子.zip

    YOLO系列算法目标检测数据集,包含标签,可以直接训练模型和验证测试,数据集已经划分好,包含数据集配置文件data.yaml,适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法; 包含两种标签格:yolo格式(txt文件)和voc格式(xml文件),分别保存在两个文件夹中,文件名末尾是部分类别名称; yolo格式:<class> <x_center> <y_center> <width> <height>, 其中: <class> 是目标的类别索引(从0开始)。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标,这些坐标是相对于图像宽度和高度的比例值,范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度,也是相对于图像宽度和高度的比例值; 【注】可以下拉页面,在资源详情处查看标签具体内容;

    职业暴露后的处理流程.docx

    职业暴露后的处理流程.docx

    Java Web开发短消息系统

    Java Web开发短消息系统

    java毕设项目之ssm基于java和mysql的多角色学生管理系统+jsp(完整前后端+说明文档+mysql+lw).zip

    项目包含完整前后端源码和数据库文件 环境说明: 开发语言:Java 框架:ssm,mybatis JDK版本:JDK1.8 数据库:mysql 5.7 数据库工具:Navicat11 开发软件:eclipse/idea Maven包:Maven3.3 服务器:tomcat7

    批量导出多项目核心目录工具

    这是一款可以配置过滤目录及过滤的文件后缀的工具,并且支持多个项目同时输出导出,并过滤指定不需要导出的目录及文件后缀。 导出后将会保留原有的路径,并在新的文件夹中体现。

    【图像压缩】基于matlab GUI DCT图像压缩(含MAX MED MIN NONE)【含Matlab源码 9946期】.zip

    Matlab领域上传的视频均有对应的完整代码,皆可运行,亲测可用,适合小白; 1、代码压缩包内容 主函数:main.m; 调用函数:其他m文件;无需运行 运行结果效果图; 2、代码运行版本 Matlab 2019b;若运行有误,根据提示修改;若不会,私信博主; 3、运行操作步骤 步骤一:将所有文件放到Matlab的当前文件夹中; 步骤二:双击打开main.m文件; 步骤三:点击运行,等程序运行完得到结果; 4、仿真咨询 如需其他服务,可私信博主; 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作

    YOLO算法-挖掘机与火焰数据集-7735张图像带标签-挖掘机.zip

    YOLO算法-挖掘机与火焰数据集-7735张图像带标签-挖掘机.zip

    操作系统实验 Ucore lab5

    操作系统实验 Ucore lab5

    IMG_5950.jpg

    IMG_5950.jpg

    竞选报价评分表.docx

    竞选报价评分表.docx

    java系统,mysql、springboot等框架

    java系统,mysql、springboot等框架

    zigbee CC2530网关+4节点无线通讯实现温湿度、光敏、LED、继电器等传感节点数据的采集上传,网关通过ESP8266上传远程服务器及下发控制.zip

    1、嵌入式物联网单片机项目开发例程,简单、方便、好用,节省开发时间。 2、代码使用IAR软件开发,当前在CC2530上运行,如果是其他型号芯片,请自行移植。 3、软件下载时,请注意接上硬件,并确认烧录器连接正常。 4、有偿指导v:wulianjishu666; 5、如果接入其他传感器,请查看账号发布的其他资料。 6、单片机与模块的接线,在代码当中均有定义,请自行对照。 7、若硬件有差异,请根据自身情况调整代码,程序仅供参考学习。 8、代码有注释说明,请耐心阅读。 9、例程具有一定专业性,非专业人士请谨慎操作。

Global site tag (gtag.js) - Google Analytics