面试题：网络编程之非阻塞Socket异常捕获与资源管理

思路
- 当捕获到Socket异常时，要及时关闭相关的Socket连接以释放文件描述符。在多线程环境下，需要注意线程安全问题，避免多个线程同时操作同一个Socket导致资源释放混乱。对于内存方面，要确保在异常发生时，与Socket相关的动态分配内存（如接收缓冲区等）能正确释放。
实现方式
- 使用RAII（Resource Acquisition Is Initialization）原则：
  - 在C++中，可以定义一个类来管理Socket资源。例如：

#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

class SocketRAII {
public:
    SocketRAII() : sockfd(-1) {}
    ~SocketRAII() {
        if (sockfd != -1) {
            close(sockfd);
        }
    }
    int getSockfd() { return sockfd; }
    bool createSocket() {
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd == -1) {
            return false;
        }
        return true;
    }
private:
    int sockfd;
};

 - 在使用Socket的代码中，将Socket资源的管理交给这个类。当SocketRAII对象生命周期结束时（例如函数结束或者对象被销毁），其析构函数会自动关闭Socket，释放文件描述符。

线程安全考虑：
- 如果多个线程可能访问同一个SocketRAII对象，需要使用互斥锁（std::mutex）来保护对Socket的操作。例如：

#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <mutex>

class SocketRAII {
public:
    SocketRAII() : sockfd(-1) {}
    ~SocketRAII() {
        std::lock_guard<std::mutex> lock(mtx);
        if (sockfd != -1) {
            close(sockfd);
        }
    }
    int getSockfd() {
        std::lock_guard<std::mutex> lock(mtx);
        return sockfd;
    }
    bool createSocket() {
        std::lock_guard<std::mutex> lock(mtx);
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd == -1) {
            return false;
        }
        return true;
    }
private:
    int sockfd;
    std::mutex mtx;
};

内存管理：
- 如果在使用Socket过程中动态分配了内存（如接收缓冲区），同样要在捕获到异常时释放。例如：

#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <mutex>
#include <cstdlib>

class SocketRAII {
public:
    SocketRAII() : sockfd(-1), buffer(nullptr) {}
    ~SocketRAII() {
        std::lock_guard<std::mutex> lock(mtx);
        if (sockfd != -1) {
            close(sockfd);
        }
        if (buffer) {
            free(buffer);
        }
    }
    int getSockfd() {
        std::lock_guard<std::mutex> lock(mtx);
        return sockfd;
    }
    bool createSocket() {
        std::lock_guard<std::mutex> lock(mtx);
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd == -1) {
            return false;
        }
        buffer = malloc(1024);
        if (!buffer) {
            close(sockfd);
            sockfd = -1;
            return false;
        }
        return true;
    }
private:
    int sockfd;
    void* buffer;
    std::mutex mtx;
};

异常处理：
- 在捕获到Socket异常时，要调用相应的资源释放方法。例如：

int main() {
    SocketRAII socketObj;
    if (!socketObj.createSocket()) {
        // 捕获到创建Socket异常，此时SocketRAII对象析构函数会自动释放资源
        std::cerr << "Failed to create socket" << std::endl;
        return 1;
    }
    // 后续使用socketObj.getSockfd()进行Socket操作
    return 0;
}

在Java中，可以使用try - finally块来确保资源释放：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NonBlockingSocketExample {
    public static void main(String[] args) {
        SocketChannel socketChannel = null;
        try {
            socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            socketChannel.connect(new InetSocketAddress("example.com", 80));
            // 进行Socket操作
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socketChannel != null) {
                try {
                    socketChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在上述Java代码中，try - finally块确保无论try块中是否抛出异常，SocketChannel都会被关闭，从而释放文件描述符。如果在try块中有动态分配的内存（如ByteBuffer），也应在finally块中正确释放（对于ByteBuffer等对象，Java的垃圾回收机制会在适当时候回收其占用的堆内存，但如果涉及直接内存（ByteBuffer.allocateDirect），可能需要显式调用cleaner.clean()方法释放）。

星途面试题库

面试题：网络编程之非阻塞Socket异常捕获与资源管理

知识考点

面试题答案