How to avoid concurrent callbacks to user defined routine?

I am attempting to modify some Boost code so that it is compatible with Autoit. The original project can be found here. My version can be found here. I could use some help in determining how to prevent multiple concurrent callbacks into the user supplied Autoit routine.

Here is the existing on_read callback --

/// Callback registered by async_read. It calls user registered callback to actually process the data. And then issue another async_read to wait for data from server again.
/// \param ec instance of error code
/// \param bytes_transferred
void
on_read(
beast::error_code ec,
std::size_t bytes_transferred) {
if(EnableVerbose)
{
boost::lock_guard<boost::mutex> guard(mtx_);
std::wcout << L"<WsDll-" ARCH_LABEL "> in on read" << std::endl;
}		
boost::ignore_unused(bytes_transferred);
{
boost::lock_guard<boost::mutex> guard(mtx_);
if(!Is_Connected) {
return;
}
}
// error occurs
if (ec) {
if(on_fail_cb)
on_fail_cb(L"read");
return fail(ec, L"read");
}
const std::string data = beast::buffers_to_string(buffer_.data());
const std::wstring wdata(data.begin(), data.end());
if(EnableVerbose)
{
boost::lock_guard<boost::mutex> guard(mtx_);
std::wcout << L"<WsDll-" ARCH_LABEL "> received[" << bytes_transferred << L"] " << wdata << std::endl;
}		
//  The next section is where my issue resides
if (on_data_cb)
on_data_cb(wdata.c_str(), wdata.length());
buffer_.consume(buffer_.size());
if(EnableVerbose)
{
boost::lock_guard<boost::mutex> guard(mtx_);
std::wcout << L"<WsDll-" ARCH_LABEL "> issue new async_read in on_read" << std::endl;
}		
ws_.async_read(
buffer_,
beast::bind_front_handler(
&session::on_read,
shared_from_this()));
// Close the WebSocket connection
// ws_.async_close(websocket::close_code::normal,
//     beast::bind_front_handler(
//         &session::on_close,
//         shared_from_this()));
}

The code if (on_data_cb) on_data_cb(wdata.c_str(), wdata.length()); executes the callback into Autoit, and I need to know how I can prevent this from executing more than once at a time. I am not well versed in C++ / Boost, so please be gentle.

The gentle answer would be to point to the documentation: Strands: Use Threads Without Explicit Locking

In reality you don't show enough code. For example, we have no way of knowing

• what execution context is being used. If you're using a io_context with a single service thread run()-ing it, you already have the implicit strand and a guarantee that no handlers ever run simultaneously

• what executor the IO object(s) bind to. In your code, the only object visible is ws_ which we'll assume for to be something like

   net::io_context                ctx_;
  websocket::stream<tcp::socket> ws_{ctx_};
  

  Now, in case you want to have multiple threads servicing ctx_ you could bind the ws_ to a strand executor instead:

   websocket::stream<tcp::socket> ws_{make_strand(ctx_)};
  

  Now, as long as you make sure your own accesses (e.g. async_ initiations) are on the proper strand, your code is already safe. If you want - and you don't mind hardcoding the executor type, you can assert this:

  auto strand = ws_.get_executor().target<net::strand<net::io_context::executor_type>>();
  assert(strand && strand->running_in_this_thread());

> ### Pro tip:
>
> If you really commit to a particular executor type, consider statically binding that type:
>
> using Context = net::io_context::executor_type;
> using Executor = net::io_context::executor_type;
> using Strand = net::strand<net::io_context::executor_type>;
> using Socket = net::basic_stream_socket<tcp, Strand>;
>
> Context ctx_;
> websocket::stream<Socket> ws_{make_strand(ctx_)};
>
> This avoids the overhead of type-erased executors, and you can
> simplify the assert:
>
> assert(ws_.get_executor().running_in_this_thread());

Side Notes

• Instead of locking a full mutex to inspect a boolean, use atomic_bool.

• Use standard library features (std::mutex, std::lock_guard) to make easier better

• Consider building for the ANSI build, or check your widening approaches:

   const std::wstring wdata(data.begin(), data.end());
  

  is an antipattern. Look here https://en.cppreference.com/w/cpp/string/multibyte or here for more information https://en.cppreference.com/w/cpp/locale/ctype/widen

Demo

Obligatory "live" code:

Live On Coliru

#include <boost/asio.hpp>
#include <boost/beast.hpp>
#include <iostream>
namespace net       = boost::asio;
namespace beast     = boost::beast;
namespace websocket = beast::websocket;
using net::ip::tcp;
static std::mutex s_consoleMtx;
static void fail(beast::error_code ec, std::string txt) {
std::cerr << txt << ": " << ec.message() << " at " << ec.location() << std::endl;
}
#define ARCH_LABEL "STACKO"
struct session : std::enable_shared_from_this<session> {
using Context  = net::io_context::executor_type;
using Executor = net::io_context::executor_type;
using Strand   = net::strand<net::io_context::executor_type>;
using Socket   = net::basic_stream_socket<tcp, Strand>;
Context                   ctx_;
websocket::stream<Socket> ws_{make_strand(ctx_)};
static bool const  EnableVerbose = true;
std::atomic_bool   Is_Connected  = false;
beast::flat_buffer buffer_;
std::function<void(std::string)>         on_fail_cb;
std::function<void(char const*, size_t)> on_data_cb;
/// Callback registered by async_read. It calls user registered
/// callback to actually process the data. And then issue another
/// async_read to wait for data from server again. 
/// \param ec instance of error code 
/// \param bytes_transferred
void on_read(beast::error_code ec, [[maybe_unused]] size_t bytes_transferred) {
if (EnableVerbose) {
std::lock_guard<std::mutex> guard(s_consoleMtx);
std::cout << "<WsDll-" ARCH_LABEL "> in on read" << std::endl;
}
if (!Is_Connected)
return;
// error occurs
if (ec) {
if (on_fail_cb)
on_fail_cb("read");
return fail(ec, "read");
}
std::string const data = beast::buffers_to_string(buffer_.data());
if (EnableVerbose) {
std::lock_guard<std::mutex> guard(s_consoleMtx);
std::cout << "<WsDll-" ARCH_LABEL "> received[" << bytes_transferred << "] " << data << std::endl;
}
if (on_data_cb)
on_data_cb(data.c_str(), data.length());
buffer_.consume(buffer_.size());
if (EnableVerbose) {
std::lock_guard<std::mutex> guard(s_consoleMtx);
std::cout << "<WsDll-" ARCH_LABEL "> issue new async_read in on_read" << std::endl;
}
assert(ws_.get_executor().running_in_this_thread());
ws_.async_read(buffer_, beast::bind_front_handler(&session::on_read, shared_from_this()));
}
};