Блог

Что произойдет, если в многопоточном коде несколько потоков одновременно пытаются отправить данные в сокет tcp? будут ли их данные смешаны или разные потоки будут отправлять данные один за другим?

Это зависит от того, какие примитивы вы используете для отправки данных в сокет.

Если вы используете write(2) , send(2) , sendto(2) , или sendmsg(2) и размер вашего сообщения достаточно мал, чтобы полностью поместиться в буферах ядра для сокета, тогда вся запись будет отправлена в виде блока без вкрапления других данных.

Если вы используете fwrite(3) (или любую другую абстракцию ввода-вывода с буферизацией более высокого уровня), то есть вероятность, что ваши данные будут отправлены без вкрапления каких-либо других данных, но я бы не стал полагаться на такое поведение.

Я не могу говорить о sendfile(2) поведении. Я хотел бы думать, что sendfile(2) операция «записывает» все содержимое файла в сокет перед любыми другими write(2) запросами в сокете, но в документации, которую я прочитал, об этом не говорится ни слова, поэтому вам лучше не делать предположение, что оно в каком-либо смысле «атомарное».

Самый безопасный механизм заключается в том, что только один поток когда-либо отправляет данные в сокет.

Действительно, как сказано в предыдущем ответе: «Самый безопасный механизм заключается в том, чтобы только один поток когда-либо отправлял данные в сокет».

Но если вы хотите, чтобы несколько потоков вызывали чтение / запись, вы должны сами гарантировать потокобезопасность. Ниже я написал оболочку для отправки и recv, которая делает это за вас.

Send() и Recv() являются потокобезопасными в том смысле, что они не приведут к сбою, но нет никакой гарантии, что эти данные не будут «перемешаны» с данными, отправленными из других потоков. Поскольку мы, скорее всего, этого не хотим, мы должны блокировать, пока не будут подтверждены все данные потока, отправленные или полученные, или с ошибкой. Такой длительный блокирующий вызов может быть проблематичным, поэтому убедитесь, что вы делаете это в потоках, которые могут обрабатывать длительные операции блокировки.

Для linux:

 #include <sys/types.h>
#include <sys/socket.h>
#include <map>
#include <mutex>



/* blocks until the full amount of bytes requested are read
 * thread safe
 * throws exception on error */
void recv_bytes(int sock, char* buf, int len, int flags){

    static std::map<int, std::mutex> mtx;

    std::lock_guard<std::mutex> lock(mtx[sock]);

    int bytes_received = 0;

    while (bytes_received != len){

        int bytes = recv(sock, buf   bytes_received, len - bytes_received, flags);

        //error check
        if (bytes == -1){
            throw std::runtime_error("Network Exception");
        }

        bytes_received  = bytes;

    } 
}



/* blocks until the full amount of bytes requested are sent
 * thread safe
 * throws exception on error */
void send_bytes(int sock, char* buf, int len, int flags){

    static std::map<int, std::mutex> mtx;

    std::lock_guard<std::mutex> lock(mtx[sock]);

    int bytes_sent = 0; 

    while (bytes_sent != len){

        int bytes_s0 = send(sock, buf, len, flags);

        if (bytes_sent == -1) {
            throw std::runtime_error("Network Exception");
        }

        bytes_sent  = bytes_s0;

    }
}