同步读写 - Vafail的个人博客

同步写write_some#

boost::asio提供了几种同步写的api，write_some可以每次向指定的空间写入固定的字节数，如果写缓冲区满了，就只写一部分，返回写入的字节数。

1
void  wirte_to_socket(asio::ip::tcp::socket& sock) {
2
    std::string buf = "Hello World!";
3
    std::size_t  total_bytes_written = 0;
4
    //循环发送
5
    //write_some返回每次写入的字节数
6
    //total_bytes_written是已经发送的字节数。
7
    //每次发送buf.length()- total_bytes_written)字节数据
8

9
    while (total_bytes_written != buf.length()) {
10
        total_bytes_written += sock.write_some(
11
            asio::buffer(buf.c_str()+total_bytes_written,
12
                buf.length()- total_bytes_written));
13
    }
14
}

同步写send#

write_some使用起来比较麻烦，需要多次调用，asio提供了send函数。send函数会一次性将buffer中的内容发送给对端，如果有部分字节因为发送缓冲区满无法发送，则阻塞等待，直到发送缓冲区可用，则继续发送完成。

1
int send_data_by_send(){
2
    std::string raw_ip_address = "127.0.0.1";
3
    unsigned short port_num = 3333;
4

5
    try {
6
        asio::ip::tcp::endpoint
7
            ep(asio::ip::address::from_string(raw_ip_address),
8
                port_num);
9

10
        asio::io_service ios;
11

12
        // Step 1. Allocating and opening the socket.
13
        asio::ip::tcp::socket sock(ios, ep.protocol());
14

15
        sock.connect(ep);
16
        std::string buf = "Hello World!";
17
        int send_length = sock.send(asio::buffer(buf.c_str(), buf.length()));
18
        if (send_length <= 0) {
19
            cout << "send failed" << endl;
20
            return 0;
21
        }
22
    }
23
    catch (system::system_error& e) {
24
        std::cout << "Error occured! Error code = " << e.code()
25
            << ". Message: " << e.what();
26

27
        return e.code().value();
28
    }
29
    return 0;
30
}

同步写write#

类似send方法，asio还提供了一个write函数，可以一次性将所有数据发送给对端，如果发送缓冲区满了则阻塞，直到发送缓冲区可用，将数据发送完成。

1
int send_data_by_wirte() {
2
    std::string raw_ip_address = "127.0.0.1";
3
    unsigned short port_num = 3333;
4

5
    try {
6
        asio::ip::tcp::endpoint
7
            ep(asio::ip::address::from_string(raw_ip_address),
8
                port_num);
9

10
        asio::io_service ios;
11

12
        // Step 1. Allocating and opening the socket.
13
        asio::ip::tcp::socket sock(ios, ep.protocol());
14

15
        sock.connect(ep);
16
        std::string buf = "Hello World!";
17
        int send_length  = asio::write(sock, asio::buffer(buf.c_str(), buf.length()));
18
        if (send_length <= 0) {
19
            cout << "send failed" << endl;
20
            return 0;
21
        }
22
    }
23
    catch (system::system_error& e) {
24
        std::cout << "Error occured! Error code = " << e.code()
25
            << ". Message: " << e.what();
26

27
        return e.code().value();
28
    }
29
    return 0;
30
 }

同步读read_some#

同步读和同步写类似，提供了读取指定字节数的接口read_some

1
std::string read_from_socket(asio::ip::tcp::socket& sock) {
2
    const unsigned char MESSAGE_SIZE = 7;
3
    char buf[MESSAGE_SIZE];
4
    std::size_t total_bytes_read = 0;
5

6
    while (total_bytes_read != MESSAGE_SIZE) {
7
        total_bytes_read += sock.read_some(
8
            asio::buffer(buf + total_bytes_read,
9
                MESSAGE_SIZE - total_bytes_read));
10
    }
11

12
    return std::string(buf, total_bytes_read);
13
}
14

15

16
int read_data_by_read_some() {
17
    std::string raw_ip_address = "127.0.0.1";
18
    unsigned short port_num = 3333;
19

20
    try {
21
        asio::ip::tcp::endpoint
22
            ep(asio::ip::address::from_string(raw_ip_address),
23
                port_num);
24

25
        asio::io_service ios;
26

27
        asio::ip::tcp::socket sock(ios, ep.protocol());
28

29
        sock.connect(ep);
30

31
        read_from_socket(sock);
32
    }
33
    catch (system::system_error& e) {
34
        std::cout << "Error occured! Error code = " << e.code()
35
            << ". Message: " << e.what();
36

37
        return e.code().value();
38
    }
39

40
    return 0;
41
}

同步读receive#

可以一次性同步接收对方发送的数据

1
int read_data_by_receive() {
2
    std::string raw_ip_address = "127.0.0.1";
3
    unsigned short port_num = 3333;
4

5
    try {
6
        asio::ip::tcp::endpoint
7
            ep(asio::ip::address::from_string(raw_ip_address),
8
                port_num);
9

10
        asio::io_service ios;
11

12
        asio::ip::tcp::socket sock(ios, ep.protocol());
13

14
        sock.connect(ep);
15
        const unsigned char BUFF_SIZE = 7;
16
         char buffer_receive[BUFF_SIZE];
17
        int receive_length =  sock.receive(asio::buffer(buffer_receive, BUFF_SIZE));
18
        if (receive_length <= 0) {
19
            cout << "receive failed" << endl;
20
        }
21
    }
22
    catch (system::system_error& e) {
23
        std::cout << "Error occured! Error code = " << e.code()
24
            << ". Message: " << e.what();
25

26
        return e.code().value();
27
    }
28

29
    return 0;
30
}

同步读read#

可以一次性同步读取对方发送的数据

1
int read_data_by_read() {
2
    std::string raw_ip_address = "127.0.0.1";
3
    unsigned short port_num = 3333;
4

5
    try {
6
        asio::ip::tcp::endpoint
7
            ep(asio::ip::address::from_string(raw_ip_address),
8
                port_num);
9

10
        asio::io_service ios;
11

12
        asio::ip::tcp::socket sock(ios, ep.protocol());
13

14
        sock.connect(ep);
15
        const unsigned char BUFF_SIZE = 7;
16
        char buffer_receive[BUFF_SIZE];
17
        int receive_length = asio::read(sock, asio::buffer(buffer_receive, BUFF_SIZE));
18
        if (receive_length <= 0) {
19
            cout << "receive failed" << endl;
20
        }
21
    }
22
    catch (system::system_error& e) {
23
        std::cout << "Error occured! Error code = " << e.code()
24
            << ". Message: " << e.what();
25

26
        return e.code().value();
27
    }
28

29
    return 0;
30
 }

读取直到指定字符#

我们可以一直读取，直到读取指定字符结束

1
std::string  read_data_by_until(asio::ip::tcp::socket& sock) {
2
    asio::streambuf buf;
3

4
    // Synchronously read data from the socket until
5
    // '\n' symbol is encountered.
6
    asio::read_until(sock, buf, '\n');
7

8
    std::string message;
9

10
    // Because buffer 'buf' may contain some other data
11
    // after '\n' symbol, we have to parse the buffer and
12
    // extract only symbols before the delimiter.
13

14
    std::istream input_stream(&buf);
15
    std::getline(input_stream, message);
16
    return message;
17
 }