1

尝试在子线程中访问套接字描述符（使用 bind() 或 listen()）时出现错误：

错误的文件描述符

这是代码（忽略标题）：

class task {
private:
    std::int32_t        socFd;
    std::string         path;
    char                buffer[MAX_SOC_BUFFER];
    struct sockaddr_un  socAddr;

public:
    void init() {
        if ((socFd = socket((std::int32_t)AF_UNIX, (std::int32_t)SOCK_STREAM, 0)) == -1) {
            perror("socket");
            exit(1);
        }

        socAddr.sun_family = AF_UNIX;
        strcpy(socAddr.sun_path, getSocPath().c_str());
    }

    task(const std::string& path) : path{path}
    {
        init();
    }

    auto getSocketFd() ->decltype(socFd) {
        return socFd;
    }

    const std::string& getSocPath() {
        return path;
    }

    auto getSocAddr() -> decltype(socAddr)&
    {
        return socAddr;
    }

    char* getBuff() {
        return buffer;
    }

    virtual ~ task() {
        close(getSocketFd());
    }
};


class server_task : public task{
public:
    void init () {
        ::unlink(getSocPath().c_str());
        size_t len = sizeof(getSocAddr());
        if (bind(getSocketFd(), (struct sockaddr *)&(getSocAddr()), len) == -1) {
            perror("bind");
            exit(1);
        }
    }

    server_task(const std::string& path) : task(path)
    {
        init();
    }

    void operator()() {
        struct sockaddr_un remote;
        if (listen(getSocketFd(), 5) == -1) {
            perror("listen");
            exit(1);
        }
        for(;;) {
            int done, n, socFd2;
            printf("Waiting for a connection...\n");
            socklen_t t = sizeof(remote);
            if ((socFd2 = accept(getSocketFd(), (struct sockaddr *)&remote, &t)) == -1) {
                perror("accept");
                exit(1);
            }
            printf("Connected.\n");
            done = 0;
            do {
                n = recv(socFd2, getBuff(), 100, 0);
                if (n <= 0) {
                    if (n < 0) perror("recv");
                    done = 1;
                }
                if (!done) {
                    std::string buffStr(getBuff());
                    std::transform(buffStr.begin(), buffStr.end(),buffStr.begin(), ::toupper);
                    if (send(socFd2, buffStr.c_str(), n, 0) < 0) {
                        perror("send");
                        done = 1;
                    }
                }
            } while (!done);
            close(socFd2);
        }
    }
};


int main(){
std::vector<std::thread> threads;
server_task server("/tmp/temp_socket");
threads.push_back(std::thread(server));

for(auto& thread : threads)
    thread.join();

return 0;

}

如果我将main()功能更改为：

int main(){
    server_task server("/tmp/temp_socket");
    server();
    return 0;
}

不会发生此类错误。据我了解，文件描述符表在父进程及其子线程之间共享，因此套接字句柄应该是有效的。

我究竟做错了什么？

4

1 回答 1

5 
threads.push_back(std::thread(server));

这会创建对象的至少一个副本server，可能是多个副本，并且由于您尚未定义复制构造函数，因此每个副本共享同一个套接字，而第一个超出范围的副本将关闭该套接字。到新线程启动时，临时副本已被销毁并关闭套接字，因此server_task在新线程中运行的副本指的是已关闭的套接字。

您应该为您的task和server_task类型定义一个移动构造函数，以便转移而不复制套接字的所有权，并将对象移动到线程中：

thread.push_back(std::thread(std::move(server)));

否则您应该通过引用将服务器传递给新线程，因此没有副本：

thread.push_back(std::thread(std::ref(server)));
于 2013-07-24T15:27:50.460 回答