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

SocketChannelImpl 解析四(关闭通道等)

    博客分类:
  • NIO
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: ...

    亚洲电子商务发展案例研究

    本书由国际发展研究中心(IDRC)和东南亚研究院(ISEAS)联合出版,旨在探讨亚洲背景下电子商务的发展与实践。IDRC自1970年起,致力于通过科学技术解决发展中国家的社会、经济和环境问题。书中详细介绍了IDRC的ICT4D项目,以及如何通过项目如Acacia、泛亚网络和泛美项目,在非洲、亚洲和拉丁美洲推动信息通信技术(ICTs)的影响力。特别强调了IDRC在弥合数字鸿沟方面所作出的贡献,如美洲连通性研究所和非洲连通性项目。ISEAS作为东南亚区域研究中心,专注于研究该地区的发展趋势,其出版物广泛传播东南亚的研究成果。本书还收录了电子商务在亚洲不同国家的具体案例研究,包括小型工匠和开发组织的电子商务行动研究、通过互联网直接营销手工艺品、电子营销人员的创新方法以及越南电子商务发展的政策影响。

    少儿编程scratch项目源代码文件案例素材-Leap On.zip

    少儿编程scratch项目源代码文件案例素材-Leap On.zip

    ANSYS Maxwell电磁仿真在高速无刷电机设计中的应用与优化技巧

    内容概要:本文详细介绍了ANSYS Maxwell电磁仿真软件在高速无刷电机(特别是吸尘器电机)设计中的应用。主要内容涵盖电机设计中的常见挑战及其解决方案,如定子槽开口设计、气隙磁密控制、Halbach阵列的应用、定子斜槽角度选择、散热设计以及PWM控制策略等。文中通过具体实例展示了如何利用Maxwell进行参数化扫描、瞬态场仿真、温度场耦合仿真等操作,从而优化电机性能并提高效率。此外,还讨论了仿真与实际情况之间的差异及应对措施。 适合人群:从事电机设计、电磁仿真及相关领域的工程师和技术人员。 使用场景及目标:适用于希望深入了解高速无刷电机设计原理及优化方法的专业人士。目标是在实际项目中运用Maxwell电磁仿真工具,解决设计难题,提升产品性能。 其他说明:文章强调了仿真并非万能,但合理的仿真手段能够极大促进产品研发进程。文中提供了多个实用的Python和MATLAB脚本示例,帮助读者更好地理解和应用相关技术。

    Java多态的一些小知识点

    这是我记录的第一篇笔记和博客,我现在大一下,我想以此为契机激励自己记笔记,加深对特定知识的印象!目前我在学习黑马的Java,同时期也会学一些数据结构和相关算法,我也会将这部分笔记上传。最后我想说的是一些最近的感想 1.不要美化你没走过的路 2.来都来了那就坚持走下去,不给自己留遗憾!!

    Matlab构建双输入深度学习模型:融合时序与频域特征的技术指南

    内容概要:本文详细介绍了如何利用Matlab构建并训练双输入深度学习模型,特别是针对不同长度的一维序列数据(如时序信号及其FFT频谱)。首先,作者展示了如何生成用于实验的仿真数据,接着深入探讨了网络架构的设计思路,包括采用CNN-LSTM处理时序特征以及纯CNN提取频域特征的方式。文中强调了数据预处理的重要性,如归一化处理,并提供了具体的训练选项设置方法。此外,还分享了一些实用的小贴士,如如何正确地进行模型评估和调整网络结构以适应不同的应用场景。最后,作者提到了一些常见的错误及解决办法,帮助读者避开潜在的陷阱。 适合人群:对深度学习感兴趣的科研工作者、研究生及以上水平的学生,尤其是那些希望将理论应用于实践的人群。 使用场景及目标:适用于需要同时处理多种类型数据的研究项目,如机械故障诊断、情感分析等领域。通过本教程的学习,读者能够掌握构建高效双输入深度学习模型的方法,从而提高数据分析的效果。 其他说明:本文不仅提供完整的代码示例,还包括了许多实践经验分享,有助于初学者更好地理解和应用所学知识。

    基于COMSOL的三相电力变压器温度场与流体场耦合计算模型及其实现技巧

    内容概要:本文详细介绍了使用COMSOL进行三相电力变压器温度场与流体场耦合计算的具体步骤和技术要点。首先讨论了变压器温升问题的重要性和现有仿真与实测数据之间的偏差,接着阐述了电磁-热-流三场耦合建模的难点及其解决方法。文中提供了关键的材料属性设置代码,如变压器油的密度和粘度随温度变化的关系表达式,并强调了网格划分、求解器配置以及后处理阶段需要注意的技术细节。此外,还分享了一些实用的经验和技巧,例如采用分离式步进求解策略、优化网格划分方式等,确保模型能够顺利收敛并获得精确的结果。最后,作者推荐了几种常用的湍流模型,并给出了具体的参数设置建议。 适用人群:从事电力系统设计、变压器制造及相关领域的工程师和技术人员,特别是那些希望深入了解COMSOL软件在复杂多物理场耦合计算方面应用的人群。 使用场景及目标:适用于需要对变压器内部温度分布和油流情况进行精确模拟的研究或工程项目。主要目的是提高仿真精度,使仿真结果更加贴近实际情况,从而指导产品设计和优化运行参数。 其他说明:文中不仅包含了详细的理论解释和技术指导,还提供了一些实际案例供读者参考。对于初学者来说,可以从简单的单相变压器开始练习,逐步掌握复杂的三相变压器建模技能。同时,作者提醒读者要注意单位的一致性和材料属性的准确性,这是避免许多常见错误的关键所在。

    PSD信号处理电路(PCB 原理图 封装库)亲测可用.zip

    PSD信号处理电路(PCB 原理图 封装库)亲测可用.zip

    少儿编程scratch项目源代码文件案例素材-3D游戏.zip

    少儿编程scratch项目源代码文件案例素材-3D游戏.zip

    信号分析+频率分析+频率合成+外部信号输入+光学分析

    信号分析,可导入外部信号文件 分析信号合成频率。 也可设置信号频率合成信号源。 信号合成,可导入外部频率文件 合成信号数据。也可调整频率数值合成信号源。 应用于通信领域, 光学领域,声波领域,信号和频率通过图形进行展示,所见所得,

    少儿编程scratch项目源代码文件案例素材-3D 汽车.zip

    少儿编程scratch项目源代码文件案例素材-3D 汽车.zip

    永磁同步电机FOC控制四种方法模型及Simulink仿真实践

    内容概要:本文详细介绍了永磁同步电机(PMSM)基于磁场定向控制(FOC)的四种不同控制策略及其Simulink仿真模型。首先,经典双闭环PI控制提供了稳定的基础控制方式,适用于大多数应用场景。其次,电流滞环控制采用Bang-Bang控制策略,虽然响应速度快但能耗较高。第三种方法是滑模转速控制,利用非线性切换函数提高系统的抗扰动能力,但在稳态时存在轻微抖振。最后,PR控制在静止坐标系上实现了高精度的电流跟踪,特别适合固定频率应用。每种控制方法都有详细的参数设定和仿真波形展示,帮助读者深入理解各控制策略的特点和适用范围。 适合人群:从事电机控制系统研究与开发的技术人员,尤其是有一定MATLAB/Simulink基础的研发人员。 使用场景及目标:①掌握永磁同步电机FOC控制的基本原理和技术细节;②通过具体实例和仿真模型验证不同控制策略的效果;③选择最适合特定应用场景的控制方法并进行优化。 其他说明:文中还提到了一些实用技巧,如参数调整的经验法则、常见问题的解决方案以及仿真环境配置注意事项。附带的参考文献有助于进一步深入了解相关理论背景。

    基于模型预测控制(MPC)的无人艇分布式编队协同控制仿真与实现

    内容概要:本文详细介绍了利用模型预测控制(MPC)实现无人艇分布式编队协同控制的方法和技术。首先,通过简化的动力学模型和MATLAB代码展示了无人艇的基本行为预测。接着,深入探讨了编队协同控制的关键要素,包括代价函数的设计、信息交换机制以及分布式MPC的具体实现步骤。文中还提供了具体的Python代码示例,涵盖了从单个无人艇的动力学建模到多智能体之间的协作控制。此外,作者分享了一些实用技巧,如如何处理通信延迟、传感器噪声等问题,并展示了仿真效果,证明了所提出方法的有效性和鲁棒性。 适合人群:对无人艇编队控制、模型预测控制(MPC)、分布式系统感兴趣的科研人员、工程师及高校学生。 使用场景及目标:适用于研究和开发无人艇编队控制系统,特别是希望通过分布式控制实现高效、灵活的编队任务。目标是在复杂的海洋环境中,使无人艇能够自主完成编队、跟踪指定路径并应对各种干扰因素。 其他说明:文中提供的代码片段和理论解释有助于理解和实现无人艇编队控制的实际应用。建议读者在实验过程中结合实际情况进行参数调整和优化。

    220V转12V工业电源设计方案详解:6W与12W高效低成本电路设计及认证要点

    内容概要:本文详细介绍了两种成熟的220V转12V工业电源设计方案,分别是6W和12W的反激式电源设计。文中不仅提供了详细的电路设计参数,如变压器绕制方法、元件选择、PCB布局技巧,还分享了许多实用的经验和技术细节,确保设计方案能够顺利通过相关认证。同时,文章对比了两种方案的成本和性能差异,帮助读者在实际应用中做出合适的选择。 适合人群:从事电源设计的工程师,尤其是对220V转12V工业电源设计感兴趣的初学者和有一定经验的研发人员。 使用场景及目标:适用于需要将220V交流电转换为12V直流电的应用场合,如工业设备、智能家居、医疗设备等。目标是提供高效、稳定且成本可控的电源解决方案。 其他说明:文章强调了变压器设计和EMI测试中的注意事项,以及如何在保证性能的前提下降低成本。此外,还提到了一些常见的认证问题及其解决办法。

    能源领域中基于储能电站服务的冷热微网系统双层优化模型及其应用

    内容概要:本文探讨了基于储能电站服务的冷热微网系统双层优化模型,旨在解决储能配置和运行调度在不同时间尺度下的优化问题。文中首先介绍了双层规划模型的构建,上层负责长时间尺度的储能配置,涉及储能系统的容量、充放电功率等关键参数;下层则专注于短时间尺度的微网优化运行,涵盖太阳能、风力发电等能源设备的功率输出。接着,文章阐述了如何通过KKT条件将双层模型转化为单层模型,并使用大M法将其线性化处理,以便于求解。最后,通过使用Gurobi等求解器进行求解,实现了储能系统的优化配置和高效运行。 适合人群:从事能源领域的研究人员和技术人员,尤其是对储能系统和微网优化感兴趣的读者。 使用场景及目标:适用于需要优化储能配置和微网运行的企业或研究机构,目标是提高能源利用效率,降低成本,促进可持续能源的发展。 其他说明:文章提供了详细的Python代码示例,帮助读者理解和实现双层优化模型的具体步骤。此外,还讨论了一些实际应用中的注意事项,如大M值的选择和求解器的配置等。

    永磁同步电机MTPA与弱磁控制的MATLAB/Simulink仿真建模及优化

    内容概要:本文介绍了永磁同步电机(PMSM)的最大转矩电流比(MTPA)控制和弱磁控制的MATLAB/Simulink仿真模型及其设计原理。首先阐述了这两种控制方式的背景和技术意义,接着详细解释了MTPA控制和弱磁控制的具体实现方法,包括关键公式和代码片段。然后展示了如何在Simulink中构建完整的仿真模型,涵盖各个控制模块的搭建,如电流环、速度环的PI调节器等。最后通过仿真结果分析验证了所提出的控制策略的有效性和优越性。 适合人群:从事电机控制系统研究的技术人员、高校相关专业师生、对永磁同步电机控制感兴趣的工程技术人员。 使用场景及目标:适用于需要深入了解并掌握永磁同步电机高性能控制技术的研究人员,帮助他们理解和实现高效的电机控制策略,特别是在工业自动化、电动汽车等领域。 其他说明:文中提供了详细的代码示例和仿真波形图,有助于读者更好地理解和复现实验结果。同时指出了调试过程中可能遇到的问题及解决方案,便于初学者避免常见错误。

    基于Matlab/Simulink的异步电机V/F开环与转差频率闭环调速系统仿真

    内容概要:本文详细介绍了利用Matlab/Simulink进行异步电机调速仿真的具体实现方法。首先探讨了最经典的恒压频比(V/F)开环控制系统,通过设置三相电源模块、V/F控制器和SVPWM逆变器,实现了电压和频率的线性增长,展示了开环系统在不同负载情况下的性能特点。接着引入了更为复杂的转差频率闭环控制方案,通过加入转速外环和转差频率内环,以及PID调节器,显著提高了系统的稳定性,特别是在负载突变时的表现。最后讨论了SVPWM控制的优势,强调其在改善电压波形质量和降低谐波方面的优越性。 适合人群:从事电机控制领域的研究人员和技术人员,尤其是有一定Matlab/Simulink基础的工程师。 使用场景及目标:适用于需要深入了解异步电机调速原理和仿真实现的研究项目。主要目标是掌握V/F开环和转差频率闭环两种控制方式的具体实现步骤,理解各自的特点和应用场景,同时学会优化系统参数以提高性能。 其他说明:文中提供了详细的代码片段和仿真技巧,帮助读者更好地理解和应用相关理论。建议读者在实践中结合实际硬件参数进行调整,确保仿真结果的准确性。

    Prius 2004永磁同步电机设计:从Excel到温升仿真的全链路实操与参数化建模

    内容概要:本文详细介绍了丰田Prius 2004永磁同步电机的设计流程和技术要点,涵盖了从初步设计到最终仿真的各个环节。首先,利用Excel进行初始参数计算,如定子叠厚、绕组匝数等,确保设计的基础合理性。接着,通过Maxwell有限元仿真进行参数化建模,优化磁钢尺寸、气隙长度等关键参数,并通过批处理脚本提高仿真效率。同时,借助橡树岭国家实验室提供的实测数据,验证仿真结果的准确性,确保材料属性和损耗计算的精确性。此外,MotorCAD用于温升仿真,设置合理的冷却系统参数,防止电机过热。最后,提供了详细的建模教程,帮助初学者避开常见错误。 适用人群:从事电机设计的工程师和技术人员,尤其是对永磁同步电机感兴趣的从业者。 使用场景及目标:适用于希望深入了解Prius 2004永磁同步电机设计的技术人员,旨在通过实际案例掌握从理论计算到仿真验证的完整设计流程,提升电机设计能力。 其他说明:文中不仅提供了具体的公式和代码示例,还分享了许多实用的实战经验和避坑指南,使读者能够更快地上手并应用到实际工作中。

    电力系统中基于功率同步控制的并网变流器暂态稳定性分析及其应用

    内容概要:本文深入探讨了基于功率同步控制(PSC)的并网变流器在弱电网条件下的暂态稳定性。首先介绍了PSC的基本原理和核心算法,展示了如何通过相位图和小信号模型进行稳定性分析。文中详细解释了K_p和K_i参数对系统稳定性的影响,并提供了具体的Python和Matlab代码示例。接着讨论了弱电网环境中系统的特殊行为,如相位轨迹的发散与收敛,以及如何通过调整虚拟惯量J和阻尼系数D来提高系统的稳定性。最后分享了一些实际工程中的调试经验和技巧,强调了仿真与实测数据相结合的重要性。 适合人群:从事电力系统研究和开发的技术人员,特别是关注并网变流器稳定性和弱电网环境下的控制系统设计的专业人士。 使用场景及目标:适用于评估和改进并网变流器在弱电网条件下的性能,确保其在各种工况下的稳定运行。目标是帮助工程师理解和掌握PSC的工作机制,以便更好地应对实际工程项目中的挑战。 阅读建议:读者可以通过本文提供的代码示例和图表,结合自身的实践经验,逐步理解PSC的工作原理及其在弱电网环境下的表现。同时,应注意将理论分析与实际测量相结合,以获得更全面的认识。

Global site tag (gtag.js) - Google Analytics