为什么JavaSSLSocketImpl创建一个虚拟套接字？

我正在使用以下代码将从ServerSocket.accept（）返回的套接字升级到SSLSocket：

SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket (socket, null, true);
sslSocket.setUseClientMode (false);
sslSocket.setSSLParameters (sslParameters);

在执行sslSocket.close（）之后，我可以看到服务器上留下了一些打开的文件描述符。这些在lsof输出中显示如下：

292u  sock                0,6      0t0 73633829 can't identify protocol

随着时间的推移（因为这是一个服务器），客户机会建立很多连接，这些打开的文件会阻止新的连接发生

我试图通过查看openjdk代码来找到这一问题的根本原因，因为问题似乎不是从我们的代码中产生的。我可以看到，在关闭SSLSocket时，会出现以下代码流：

SSLSocketImpl的close->closeInternal（true）->closeSocket（true）

以下是closeSocket中的代码：

if (!isLayered() || autoClose) {
    super.close();
} else if (selfInitiated) {
    // layered && non-autoclose
    // read close_notify alert to clear input stream
    waitForClose(false);
}

由于它是分层的，并且autoClose是正确的，所以我认为它包含在super.close（）中。下面是超级类中关闭函数的代码：

public synchronized void close() throws IOException {
    if (self == this) {
        super.close();
    } else {
        self.close();
    }
}

那么，自从赛尔夫这将调用self.close（）。这意味着SSLSocket在内部创建的“虚拟”套接字永远不会关闭

首先，我的分析正确吗，SSLSocket的内部套接字始终不会关闭？这是Java中的一个bug，还是我的理解有误，还是我做错了什么

编辑：（回答问题的进一步解释）

self仅来自Openjdk的代码（特别是BaseSSLSocektImpl.java）。让我粘贴一些相关代码，希望能够澄清：

final public class SSLSocketImpl extends BaseSSLSocketImpl {
    SSLSocketImpl(SSLContextImpl context, Socket sock,
            InputStream consumed, boolean autoClose) throws IOException {
        super(sock, consumed);
        // We always layer over a connected socket
        if (!sock.isConnected()) {
            throw new SocketException("Underlying socket is not connected");
        }

        // In server mode, it is not necessary to set host and serverNames.
        // Otherwise, would require a reverse DNS lookup to get the hostname.

        init(context, true);
        this.autoClose = autoClose;
        doneConnect();
    }
//....
}

abstract class BaseSSLSocketImpl extends SSLSocket {    

    final private Socket self;

    BaseSSLSocketImpl(Socket socket) {
        super();
        this.self = socket;
        this.consumedInput = null;
    }

// ....
}

“虚拟”套接字：

public abstract class SSLSocket extends Socket
{
    protected SSLSocket()
        { super(); }

// ...
}

class Socket implements java.io.Closeable {
    public Socket() {
        setImpl();
    }
// This is what I am calling dummy socket which is getting created

    void setImpl() {
        if (factory != null) {
            impl = factory.createSocketImpl();
            checkOldImpl();
        } else {
             impl = new SocksSocketImpl();
        }
        if (impl != null)
            impl.setSocket(this);
    }
}

class SocksSocketImpl extends PlainSocketImpl implements SocksConsts {
 // ...
}}

---

因此，在内部创建了一个socksocketimpl对象，该对象在本机代码中创建套接字（由于缺少更好的单词，我称之为虚拟套接字）。

可以从头开始创建

SSLSocket

，也可以通过

SSLSocketFactory.craeteSocket（socket）

在现有的

套接字上分层。在处理这两种情况时会出现代码中的复杂性。有时
SSLSocket
需要自行关闭，有时包裹的
Socket
，有时两者都不关闭，这取决于它是否包裹，如果包裹，则取决于
autoClose
是否为真。
SSLSocket
可以从头开始创建，也可以在现有的
Socket
上分层，通过
SSLSocketFactory.craeteSocket（Socket，…）
。在处理这两种情况时会出现代码中的复杂性。有时
SSLSocket
需要关闭自身，有时需要关闭已包装的
套接字，有时两者都需要关闭，具体取决于它是否正在包装，如果已包装，则取决于
autoClose
是否为真。
什么是self
这意味着SSLSocket内部创建的“虚拟”套接字永远不会关闭。
---这是什么意思？@Am\u I\u有帮助吗？我已经在原始帖子中添加了一些解释。请让我知道，如果还有一些困惑。什么是自我
这意味着SSLSocket内部创建的“虚拟”套接字永远不会关闭。
---这是什么意思？@Am\u I\u有帮助吗？我已经在原始帖子中添加了一些解释。如果还有些混乱，请告诉我。