神奇cpp

这个屌丝很懒，什么也没留下！

热门标签

boost.asio使用简介_boost::asio

作者：神奇cpp | 2024-06-20 18:59:54

踩

boost::asio

文章目录

前言
一、计时器使用
二、Sockets简介
参考网址

前言

The Boost.Asio库是为使用C++进行系统编程的程序员设计的，在系统编程中，通常需要访问操作系统功能（如网络）。特别是Boost。Asio致力于实现以下目标：

便携性。该库应支持一系列常用的操作系统，并在这些操作系统之间提供一致的行为。
可扩展性。该库应促进可扩展到数千个并发连接的网络应用程序的开发。每个操作系统的库实现都应该使用最能实现这种可伸缩性的机制。
效率该库应支持分散采集I/O等技术，并允许程序最大限度地减少数据复制。
从已建立的API（如BSD套接字）中建模概念。BSD套接字API被广泛地实现和理解，并且在许多文献中都有涉及。其他编程语言通常使用类似的接口来连接API。在合理的范围内，Boost。Asio应该利用现有的做法。
易于使用。图书馆应采用工具包而非框架方法，为新用户提供较低的进入门槛。也就是说，它应该尽量减少前期投资，及时学习一些基本规则和指导方针。之后，库用户应该只需要了解正在使用的特定函数。
进一步抽象的基础。该库应允许开发提供更高抽象级别的其他库。例如，常用协议（如HTTP）的实现。

尽管Boost.Asio最初主要专注于网络，其异步I/O的概念已经扩展到包括其他操作系统资源，如串行端口、文件描述符等。

即： Boost.Asio是可实现异步IO的网络编程库，它封装了socket, bind, listen, epoll等操作

一、计时器使用

在Linux系统上，boost::asio::steady_timer 是通过timerfd_create 和 timerfd_settime 等系统调用函数实现的。这些函数允许应用程序创建和设置定时器，并且可以以稳定的时间间隔触发定时器事件。

#include <sys/timerfd.h>
int timerfd_create(int clockid, int flags);
1
2

1. 创建计时器，阻塞等待

// 只有一个线程

#include <boost/asio.hpp>
// 使用asio库必须建立至少一个io执行上下文对象，如io_context,thread_pool
// io执行上下文提供了对io功能的访问
boost::asio::io_contex io;
boost::asio::steady_timer t(io, boost::asio::chrono::second(5)); // 对象构造出来后计时器就已经执行了
/*若这里的执行时间较长，则wait不阻塞*/
t.wait();  // wait 至到计时器结束

1
2
3
4
5
6
7
8

2. 创建计时器，非阻塞等待

// 只有一个线程

void print(const boost::system::error_code& e)
{}
boost::asio::io_contex io;
boost::asio::steady_timer t(io, boost:;asio::chrono::seconds(5));
// 该函数接受一个可调用对象，函数签名：void(const boost::system::error_code&)
t.async_wait(&print)
io.run();  // 阻塞，至到所有工作都处理完
1
2
3
4
5
6
7

3. 周期性计时器

// 只有一个线程

#include <functional>
#include <boost/asio.hpp>
void print(const boost::system::error_code&, boost::asio::steady_timer*, t, int *count)
{
  if (*count < 5)
  {
    ++(*count);
    // expires_at设置到期时间点，expiry()返回到期的时间点
    // expiry返回一个time_point
    t->expires_at(t->expiry() + boost::asio::chrono::seconds(1));
    // 异步等待，当到期时注册的函数会被调用
    t->async_wait(std::bind(print, boost::asio::placeholders::error, t, count));
  }
}

boost::asio::io_context io;
int count = 0;
boost::asio::steady_timer t(io, boost::asio::chrono::seconds(1));
t.async_wait(std::bind(print, boost::asio::placeholders::error, &t, &count));
io.run()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

std::bind为创建一个可调用对象，可更改该对象的函数签名

void fun(int a, int b, int c, int d) {}
auto bind_fun = std::bind(fun, a, b, std::placeholders::_1, d);
bind_fun(c);


    std::_Placeholder<9> s;
    auto b_fun = std::bind(fun, 1, s);  // fun后面为传入函数的参数
    b_fun(1,2,3,4,5,6,7,8,9); // 分别是placeholders::_1 _2 _3 ... _9
1
2
3
4
5
6
7
8

4.将3写入类封装

#include <functional>
#include <iostream>
#include <boost/asio.hpp>

class printer
{
public:
  printer(boost::asio::io_context& io)
    : timer_(io, boost::asio::chrono::seconds(1)),
      count_(0)
  {
    timer_.async_wait(std::bind(&printer::print, this));  // 没有placeholders也是可以的
  }
  ~printer()
  {
    std::cout << "Final count is " << count_ << std::endl;
  }
  void print()
  {
    if (count_ < 5)
    {
      std::cout << count_ << std::endl;
      ++count_;
      timer_.expires_at(timer_.expiry() + boost::asio::chrono::seconds(1));
      timer_.async_wait(std::bind(&printer::print, this));
    }
  }
private:
  boost::asio::steady_timer timer_;
  int count_;
};

int main()
{
  boost::asio::io_context io;
  printer p(io);
  io.run();
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

5.多线程程序的同步完成事件处理函数

注册的函数会在调用run的线程中执行，如果有多个线程同时调用了run呢？

// 多线程
如果有两个线程同时调用 run() 函数，每个线程都将从 io_context 的事件队列中获取事件并执行它们。由于您的 printer 类在构造函数中设置了两个定时器 t1_ 和 t2_，并且它们都是异步等待的，因此在每个定时器到期时，将触发相应的处理函数 print1() 和 print2()。

当两个线程同时调用 run() 时，它们将竞争 io_context 的事件队列，但由于 io_context 本身是线程安全的，因此它们不会相互干扰或导致竞态条件。每个线程将按照事件在队列中的顺序处理它们。

总体来说，两个线程将会以并发的方式执行 io_context 中的事件，但由于事件的触发和处理是按照事件队列的顺序进行的，因此您的打印机类的 print1() 和 print2() 函数也将按照预期的顺序执行。

#include <functional>
#include <iostream>
#include <thread>
#include <boost/asio.hpp>

using namespace std;
namespace asio = boost::asio;

class printer
{
private:
    // 提供线程安全的序列化执行，以确保异步操作在多线程环境中的顺序性
    asio::strand<asio::io_context::executor_type> strand_;
    asio::steady_timer t1_;
    asio::steady_timer t2_;
    int count_;
public:
    printer(asio::io_context& io)
        : strand_(asio::make_strand(io)),
        t1_(io, asio::chrono::seconds(1)),
        t2_(io, asio::chrono::seconds(1)),
        count_(0)
    {
                     // strand_ 执行器与 print1 方法绑定在一起，这样就确保了 print1 方法在 strand_ 执行器上执行
        t1_.async_wait(asio::bind_executor(strand_, bind(&printer::print1, this)));
        t2_.async_wait(asio::bind_executor(strand_, bind(&printer::print2, this)));
    }
    ~printer()
    {
        cout << "final count is " << count_ << endl;
    }
    void print1()
    {
        if (count_ < 10)
        {
            cout << "T1: " << count_ << " thid: " << this_thread::get_id() << endl;
            ++count_;
            t1_.expires_at(t1_.expiry() + asio::chrono::milliseconds(100));
            t1_.async_wait(asio::bind_executor(strand_, 
                                                bind(&printer::print1, this)));
        }
        else if (count_ < 1000)
        {
            cout << "T1: " << count_ << " thid: " << this_thread::get_id() << endl;
            ++count_;
            t1_.expires_at(t1_.expiry() + asio::chrono::milliseconds(200));
            t1_.async_wait(asio::bind_executor(strand_, 
                                                bind(&printer::print1, this)));
        }
    }
    void print2()
    {
        if (count_ < 1000)
        {
            cout << "T2: " << count_<< " thid: " << this_thread::get_id() << endl;
            ++count_;
            t2_.expires_at(t2_.expiry() + asio::chrono::milliseconds(100));
            t2_.async_wait(asio::bind_executor(strand_, 
                                                bind(&printer::print2, this)));
        }
    }
};

int main()
{
    asio::io_context io;
    printer p(io);
    thread t([&]{io.run();});
    // 不调用run，注册函数就不会被执行
    io.run();
    t.join();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

二、Sockets简介

Daytime Protocol:
服务端无论接受到什么都返回当前日期
Weekday, Month Day, Year Time-Zone
Tuesday, February 22, 1982 17:37:43-PST

1.同步TCP客户端

socket
connet

using boost::asio::ip::tcp;
namespace asio = boost::asio;
try
{
  // 使用asio库必须建立至少一个io执行上下文对象
  asio::io_context io_context;
  // 将xxx解析成xxx
  tcp::resolver resolver(io_context);
  tcp::resolver::results_type endpoints = resolver.resolve(argv[1], "daytime");
  // 创建socket，建立连接
  tcp::socket socket(io_context);
  boost::asio::connect(socket, endpoints);

  for (;;)
  {
    std::array<char, 128> buf;
    boost::system::error_code error;
    // 阻塞读取数据
    size_t len = socket.read_some(boost::asio::buffer(buf), error);

    if (error == boost::asio::error::eof)
      break; // Connection closed cleanly by peer.
    else if (error)
      throw boost::system::system_error(error); // Some other error.

    std::cout.write(buf.data(), len);
  }
}
catch (std::exception& e)
{
  std::cerr << e.what() << std::endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2.同步TCP服务端

socket
bind
listen
accept

boost::asio::io_context io_context;

tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), 13));

for (;;)
{
  tcp::socket socket(io_context);
  acceptor.accept(socket);  // 阻塞，等待客户端连接

  std::string message = make_daytime_string();

  boost::system::error_code ignored_error;
  boost::asio::write(socket, boost::asio::buffer(message), ignored_error);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.异步TCP服务端

std::enable_shared_from_this 是一个 C++11 标准库提供的模板类，位于 <memory> 头文件中。它的作用是允许一个对象可以在 tcp_connection 的成员函数中调用 shared_from_this() 方法来获取指向当前对象的 std::shared_ptr

// 函数原型
template<typename AsyncWriteStream, typename ConstBufferSequence, typename WriteHandler>
void async_write(AsyncWriteStream & s, const ConstBufferSequence & buffers, WriteHandler handler);

    io_context io;

    ip::tcp::socket socket(io);
    socket.connect(ip::tcp::endpoint(ip::address::from_string("127.0.0.1"), 8080));

    std::string data = "Hello, world!";
    async_write(socket, boost::asio::buffer(data),
        [](const boost::system::error_code& error, std::size_t bytes_transferred) {
            if (!error) {
                std::cout << "Data sent successfully." << std::endl;
            } else {
                std::cerr << "Error: " << error.message() << std::endl;
            }
        });

    io.run();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//using namespace boost::asio;  // asio is namespace, 将namespace 中的内容释放出来
//namespace asio = boost::asio; 
//using boost::asio::ip::tcp;   // tcp is class

#include <ctime>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <boost/asio.hpp>
namespace asio = boost::asio;
using boost::asio::ip::tcp;
class tcp_connection : public std::enable_shared_from_this<tcp_connection > {
 private:
  tcp_connection(asio::io_context& io)
   :socket_(io) {}
  void handle_write(const boost::system::error_code&, size_t)
  {}
  tcp::socket socket_;
  std::string message_;
 public:
  typedef std::shared_ptr<tcp_connection> pointer;
  static pointer create(asio::io_context& io)
  { return pointer(new tcp_connection(io)); }
  tcp::socket& socket()
  { return socket_; }
  void start(){
    // message_ = get_time();
    // 该函数保证整个数据块被发送
    message_ = "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n\r\n";    
    asio::async_write(                                                     // 这里用shared_from_this而非
      socket_, asio::buffer(message_), std::bind(&tcp_connection::handle_write, shared_from_this(),
                                                 asio::placeholders::error, asio::placeholders::bytes_transferred)
    );
  }
  
};
class tcp_server{
 private:
  asio::io_context& io_;
  tcp::acceptor acceptor_;
  void start_accept() {
    tcp_connection::pointer new_conn = tcp_connection::create(io_);
    acceptor_.async_accept(new_conn->socket(), 
                           std::bind(&tcp_server::handle_accept, this, new_conn, asio::placeholders::error));
  }
  void handle_accept(tcp_connection::pointer new_conn, const boost::system::error_code& error) {
    if (!error) {
      new_conn->start();
    }
    start_accept();
  }
 public:
  tcp_server(asio::io_context& io) :io_(io), acceptor_(io, tcp::endpoint(tcp::v4(), 9000)) {
    start_accept();
  }
};
int main()
{
    try{
        asio::io_context io;  // 使用asio必须有io上下文对象
        tcp_server server(io);
        io.run();
    } catch (std::exception& e) {
      std::cerr << e.what() << std::endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

只有一个线程
执行流解析：
tcp_server server(io);->start_accept()->async_accept（注册异步接收事件，当事件发生是调用handle_accept）-> io.run()在此处阻塞。
当有事件发生时：从io.run的阻塞处跳转至handle_accept执行->start->async_write（异步写数据）-> start_accept(再次注册) -> 跳回到 io.run()在此处阻塞

4 同步UDP客户端

#include <array>
#include <iostream>
#include <boost/asio.hpp>

using namespace std;
using boost::asio::ip::udp;
namespace ip = boost::asio::ip;
namespace asio = boost::asio;

int main(int argc, char* argv[])
{
    try
    {
        asio::io_context io;
        // 通过host，services获取远程endpoint
        // 获取远程信息，如远程地址，端口，
        udp::resolver resolver(io);
        udp::endpoint receiver_endpoint = 
            // 解引用是安全的，至少返回一个
            *resolver.resolve(udp::v4(), argv[1], "daytime").begin(); ip::address::from_string("127.0.0.1");
        // 
        udp::socket socket(io);
        socket.open(udp::v4());
        array<char, 1> send_buf{0};
        socket.send_to(asio::buffer(send_buf), udp::endpoint(ip::address::from_string(argv[1]), 9000));

        array<char, 128> recv_buf;
        udp::endpoint sender_endpoint;
        // 由receive_from初始化endpoint 获取服务器相关信息
        size_t len = socket.receive_from(asio::buffer(recv_buf), sender_endpoint);
        cout.write(recv_buf.data(), len);
        // cout << recv_buf.data() << endl;
    }
    catch(const std::exception& e)
    {
        std::cerr << "WAHT?:" << e.what() << '\n';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

5 同步UDP服务端

#include <array>
#include <ctime>
#include <iostream>
#include <string>
#include <boost/asio.hpp>

using boost::asio::ip::udp;

std::string make_daytime_string()
{
  using namespace std; // For time_t, time and ctime;
  time_t now = time(0);
  return ctime(&now);
}

int main()
{
  try
  {
    boost::asio::io_context io_context;

    udp::socket socket(io_context, udp::endpoint(udp::v4(), 9000));

    for (;;)
    {
      std::array<char, 1> recv_buf;
      udp::endpoint remote_endpoint;
      socket.receive_from(boost::asio::buffer(recv_buf), remote_endpoint);
      std::string message = "HTTP/1.1 200 OK\r\nContent-Type:text\r\n\r\n";
      message += make_daytime_string();

      boost::system::error_code ignored_error;
      socket.send_to(boost::asio::buffer(message),
          remote_endpoint, 0, ignored_error);
    }
  }
  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

6 异步UDP服务端

#include <array>
#include <ctime>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <boost/asio.hpp>

using boost::asio::ip::udp;

std::string make_daytime_string()
{
  using namespace std; // For time_t, time and ctime;
  time_t now = time(0);
  return ctime(&now);
}

class udp_server
{
public:
  udp_server(boost::asio::io_context& io_context)
    : socket_(io_context, udp::endpoint(udp::v4(), 13))
  {
    start_receive();
  }

private:
  void start_receive()
  {
    socket_.async_receive_from(
        boost::asio::buffer(recv_buffer_), remote_endpoint_,
        std::bind(&udp_server::handle_receive, this,
          boost::asio::placeholders::error,
          boost::asio::placeholders::bytes_transferred));
  }

  void handle_receive(const boost::system::error_code& error,
      std::size_t /*bytes_transferred*/)
  {
    if (!error)
    {
      std::shared_ptr<std::string> message(
          new std::string(make_daytime_string()));

      socket_.async_send_to(boost::asio::buffer(*message), remote_endpoint_,
          std::bind(&udp_server::handle_send, this, message,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));

      start_receive();
    }
  }

  void handle_send(std::shared_ptr<std::string> /*message*/,
      const boost::system::error_code& /*error*/,
      std::size_t /*bytes_transferred*/)
  {
  }

  udp::socket socket_;
  udp::endpoint remote_endpoint_;
  std::array<char, 1> recv_buffer_;
};

int main()
{
  try
  {
    boost::asio::io_context io_context;
    udp_server server(io_context);
    io_context.run();
  }
  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

7 异步TCP/UDP服务

#include <array>
#include <ctime>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <boost/asio.hpp>

using boost::asio::ip::tcp;
using boost::asio::ip::udp;

std::string make_daytime_string()
{
  using namespace std; // For time_t, time and ctime;
  time_t now = time(0);
  return ctime(&now);
}

class tcp_connection
  : public std::enable_shared_from_this<tcp_connection>
{
public:
  typedef std::shared_ptr<tcp_connection> pointer;

  static pointer create(boost::asio::io_context& io_context)
  {
    return pointer(new tcp_connection(io_context));
  }

  tcp::socket& socket()
  {
    return socket_;
  }

  void start()
  {
    message_ = make_daytime_string();

    boost::asio::async_write(socket_, boost::asio::buffer(message_),
        std::bind(&tcp_connection::handle_write, shared_from_this()));
  }

private:
  tcp_connection(boost::asio::io_context& io_context)
    : socket_(io_context)
  {
  }

  void handle_write()
  {
  }

  tcp::socket socket_;
  std::string message_;
};

class tcp_server
{
public:
  tcp_server(boost::asio::io_context& io_context)
    : io_context_(io_context),
      acceptor_(io_context, tcp::endpoint(tcp::v4(), 13))
  {
    start_accept();
  }

private:
  void start_accept()
  {
    tcp_connection::pointer new_connection =
      tcp_connection::create(io_context_);

    acceptor_.async_accept(new_connection->socket(),
        std::bind(&tcp_server::handle_accept, this, new_connection,
          boost::asio::placeholders::error));
  }

  void handle_accept(tcp_connection::pointer new_connection,
      const boost::system::error_code& error)
  {
    if (!error)
    {
      new_connection->start();
    }

    start_accept();
  }

  boost::asio::io_context& io_context_;
  tcp::acceptor acceptor_;
};

class udp_server
{
public:
  udp_server(boost::asio::io_context& io_context)
    : socket_(io_context, udp::endpoint(udp::v4(), 9000))
  {
    start_receive();
  }

private:
  void start_receive()
  {
    socket_.async_receive_from(
        boost::asio::buffer(recv_buffer_), remote_endpoint_,
        std::bind(&udp_server::handle_receive, this,
          boost::asio::placeholders::error));
  }

  void handle_receive(const boost::system::error_code& error)
  {
    if (!error)
    {
      std::shared_ptr<std::string> message(
          new std::string(make_daytime_string()));

      socket_.async_send_to(boost::asio::buffer(*message), remote_endpoint_,
          std::bind(&udp_server::handle_send, this, message));

      start_receive();
    }
  }

  void handle_send(std::shared_ptr<std::string> /*message*/)
  {
  }

  udp::socket socket_;
  udp::endpoint remote_endpoint_;
  std::array<char, 1> recv_buffer_;
};

int main()
{
  try
  {
    boost::asio::io_context io_context;
    tcp_server server1(io_context);
    udp_server server2(io_context);
    io_context.run();
  }
  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

参考网址

https://www.boost.org/doc/libs/1_84_0/doc/html/boost_asio.html
https://www.boost.org/doc/libs/1_84_0/doc/html/boost_asio/tutorial.html

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/740733