Bygg en chattserver med Boost.Asio, del 3 - Asynkront med coroutines
Tre steg blev tre nivåer. Så slutade förra delen: daytime-klienten, som synkront var tre rader, blev asynkront
fyrtio rader nästlade lambdas med varsin felkontroll och en felkod som fick smugglas ut via en variabel. Jag lovade
att den skulle bli tre rader igen, fast fortfarande asynkron, och att det skulle ske utan att byta API. Det är
den här delen. Vi skriver om echo-servern, daytime-klienten och chattservern med C++20-coroutines, och varje
async_*-anrop är detsamma som i förra delen. Det enda som ändras är sista argumentet.
Jag förutsätter att du känner till C++20-coroutines i allmänhet: co_await, co_return, och att en coroutine
är en funktion som kan pausa och återupptas. Jag har skrivit fyra artiklar om det, se länkarna sist, och jag
upprepar ingen teori om promise_type eller awaiters här. Du behöver inte ha läst dem alla, men den sista,
Asynkrona operationer med coroutines, är en bra brygga, för där byggde vi för hand precis det Asio ger oss
färdigt. Jag förutsätter också förra delen: den asynkrona modellen, io_context::run(), completion tokens och
shared_from_this().
Artikeln är den tredje av fem, och den är seriens tyngdpunkt. Allt som kommer sedan, TLS, graceful shutdown och WebSocket, skrivs med coroutines. Alla program finns i ett eget GitHub-repo, se länkarna sist. Artikeln visar de rader som bär berättelsen, och i repot finns all kod, plus bygg- och körinstruktioner.
| Del | Innehåll | Chattservern |
|---|---|---|
| 1 | Grunderna och synkron I/O | En klient i taget, sedan en tråd per klient |
| 2 | Asynkront med callbacks | En tråd utan lås, sedan N trådar med strand:ar |
| 3 | Asynkront med coroutines (denna artikel) | Samma server med co_await, plus en egen C++-klient |
| 4 | TLS, UDP och graceful shutdown | Krypterad trafik, servern hittas utan adress, snygg nedstängning |
| 5 | Admin-UI med Boost.Beast och WebSocket | HTTPS och WSS, klientlista och statistik live i webbläsaren |
Samma funktion, fyra tokens
I förra delen var sista argumentet till varje async_*-funktion alltid en lambda, och jag nämnde att det
argumentet heter completion token och att det finns andra sorter. Nu är det dags att se dem. Här är timern
från förra delen, men med samma async_wait() anropat med fyra olika tokens:
auto wait_twice(asio::io_context& ioc, clk::time_point start) -> asio::awaitable<void> {
auto timer = asio::steady_timer{ioc, 800ms};
co_await timer.async_wait(asio::use_awaitable);
std::println("[{:5} ms] 4. use_awaitable: coroutinen fortsätter efter co_await", ms_since(start));
timer.expires_after(200ms);
co_await timer.async_wait(); // ingen token: deferred är default, och den går att co_await:a
std::println("[{:5} ms] 4. (utan token): samma sak, det är så resten av repot ser ut", ms_since(start));
}
int main() {
auto start = clk::now();
auto ioc = asio::io_context{};
// 1. callback: som i del 2.
auto t1 = asio::steady_timer{ioc, 200ms};
t1.async_wait([start](boost::system::error_code) {
std::println("[{:5} ms] 1. callback: handlern körs inne i run()", ms_since(start));
});
// 2. use_future: inget händer i run(), resultatet hämtas med get() nedan.
auto t2 = asio::steady_timer{ioc, 400ms};
auto fut = t2.async_wait(asio::use_future);
// 3. deferred: operationen beskrivs men startar inte förrän den får en token.
auto t3 = asio::steady_timer{ioc, 600ms};
auto op = t3.async_wait(asio::deferred); // samma som t3.async_wait()
std::println("[{:5} ms] 3. deferred: operationen är skapad men inte startad", ms_since(start));
std::move(op)([start](boost::system::error_code) {
std::println("[{:5} ms] 3. deferred: startad med en callback, handlern körs", ms_since(start));
});
// 4. use_awaitable: coroutinen startas med co_spawn och körs i run().
asio::co_spawn(ioc, wait_twice(ioc, start), asio::detached);
// run() i en egen tråd, så att huvudtråden kan blockera i fut.get().
auto runner = std::jthread{[&ioc, start] {
ioc.run();
std::println("[{:5} ms] run() returnerade: inget mer arbete", ms_since(start));
}};
fut.get();
std::println("[{:5} ms] 2. use_future: get() returnerade i huvudtråden", ms_since(start));
}
$ ./build/release/timer/timer
[ 0 ms] 3. deferred: operationen är skapad men inte startad
[ 200 ms] 1. callback: handlern körs inne i run()
[ 400 ms] 2. use_future: get() returnerade i huvudtråden
[ 600 ms] 3. deferred: startad med en callback, handlern körs
[ 800 ms] 4. use_awaitable: coroutinen fortsätter efter co_await
[ 1000 ms] 4. (utan token): samma sak, det är så resten av repot ser ut
[ 1000 ms] run() returnerade: inget mer arbete
Fyra timers, fyra tokens, en och samma funktion. Det är kärnbudskapet i hela serien: callback och coroutine är inte två API:er, utan samma API med olika completion token. Token avgör hur resultatet levereras, inte vad som görs. Så här levererar de:
- Callback. Som i förra delen: handlern körs inne i
run(), när timern gått av. use_future. Anropet returnerar enstd::future<void>, och resultatet hämtas medget(). Det blockerar den anropande tråden, så det är för när en annan tråd än den som körrun()vill vänta. Därför kör programmetrun()i enjthread, och huvudtråden väntar iget(). Lägg märke till att inget skrivs ut inne irun()för token 2. Resultatet går till den som håller futuren.deferred. Anropet returnerar ett operationsobjekt, som beskriver vad som ska göras utan att göra det. Operationen startar först när objektet anropas med en token, här en callback. Det är en byggsten för att sätta ihop operationer, men dess viktigaste egenskap kommer strax.use_awaitable. Anropet returnerar något som går attco_await:a inne i en coroutine. Coroutinen pausar,run()får tillbaka tråden och kör annat, och när timern gått av återupptas coroutinen på raden efterco_await. Det är det den här artikeln handlar om.
Tre nya namn dök upp i token 4. awaitable<T> är returtypen för en coroutine som Asio kan köra, där T är det
den co_return:ar. co_spawn(ex, f(), token) startar en sådan coroutine på en executor, här ioc, och tar
själv en completion token som säger vad som ska hända när coroutinen är klar. detached är den enklaste:
"jag vill inte veta". Vi återkommer till det, för det har en baksida.
Och så den sista raden i wait_twice(), där async_wait() anropas helt utan token. Sedan Boost 1.86 är
deferred default-token, så timer.async_wait() är samma sak som timer.async_wait(asio::deferred). Och
ett deferred-objekt går att co_await:a direkt, för en awaitable vet hur man startar det med rätt token.
Resultatet är att det nästan aldrig behövs någon token alls i coroutine-kod. Resten av artikeln skriver
co_await sock.async_read_some(buf), punkt, och use_awaitable syns bara i det här exemplet.
För dig som kan Node.js. Node gjorde samma resa som Asio, fast några år tidigare. Callbacks blev Promises, som blev
async/await, och i alla tre fallen var det samma underliggande I/O. Handler,use_futureochco_awaitär samma trappa. Två skillnader är värda att ha i huvudet. En Promise är eager: den börjar köra när den skapas. Ett deferred-objekt och enawaitableär lazy: inget händer förrän någonco_await:ar. Och i Node är det funktionen som bestämmer leveransformen,fs.readFiletar en callback ochfs.promises.readFilereturnerar en Promise. I Asio är det anroparen som bestämmer, vid varje anrop, och det är hela poängen med completion tokens.
Det här byggde vi själva
I Asynkrona operationer med coroutines byggde vi en egen liten runtime: en scheduler med en ready-kö, en
trådpool för blockerande I/O, spawn() och run(), och egna awaitables som pausade coroutinen tills datan
fanns. Det var en bra övning, för nu kan du läsa Asios coroutine-stöd som en produktionsklar version av samma
sak:
| Egen runtime | Boost.Asio |
|---|---|
TaskCoroutine<void> |
awaitable<T> |
CoroRuntime::spawn() |
co_spawn(ex, f(), detached) |
CoroRuntime::run() |
io_context::run() |
CoroScheduler, ready-kön som återupptar coroutines på huvudtråden |
executorn, och strand:ar om run() körs i flera trådar |
TaskPool, trådar som utför blockerande I/O |
ingen: epoll och io_uring gör I/O:n asynkron utan extra trådar |
NextLineAwaitable |
det co_await sock.async_read_until(...) ger |
LivenessToken, räknaren som säger om det finns pågående arbete |
io_context:s räkning av utestående operationer, som avgör när run() returnerar |
Den rad som skiljer mest är trådpoolen. I vår runtime läste en worker-tråd filen med ett blockerande anrop och
postade sedan tillbaka coroutinen till schedulern. Asio behöver ingen sådan tråd, för socketen är asynkron på
riktigt: kärnan säger till när det finns data, och run() återupptar coroutinen. Allt annat finns kvar, och
har samma roll.
Echo-server med coroutines
Nu till det som del 2 lovade. Här är echo-servern igen, och den här gången finns det ingen Session-klass:
auto echo(tcp::socket socket) -> awaitable<void> {
auto peer = to_string(socket.remote_endpoint());
std::println("ansluten: {}", peer);
auto buf = std::array<char, 1024>{}; // lokal igen: lever i coroutinens frame
try {
for (;;) {
auto n = co_await socket.async_read_some(asio::buffer(buf));
co_await asio::async_write(socket, asio::buffer(buf, n));
}
} catch (boost::system::system_error const& e) {
if (e.code() != asio::error::eof) std::println("fel mot {}: {}", peer, e.what());
}
std::println("nedkopplad: {}", peer);
}
auto listener(tcp::acceptor acceptor) -> awaitable<void> {
for (;;) {
auto socket = co_await acceptor.async_accept();
co_spawn(acceptor.get_executor(), echo(std::move(socket)), detached);
}
}
int main(int argc, char** argv) try {
auto port = static_cast<unsigned short>(argc > 1 ? std::stoi(argv[1]) : 7000);
auto ioc = asio::io_context{};
auto acceptor = tcp::acceptor{ioc, tcp::endpoint{tcp::v4(), port}};
std::println("echo-server (coroutines) lyssnar på port {}", port);
co_spawn(ioc, listener(std::move(acceptor)), detached);
ioc.run(); // alla coroutines körs här, i den här tråden
} catch (std::exception const& e) {
std::println(stderr, "fel: {}", e.what());
return 1;
}
Jämför med förra delen. Kedjan do_read → do_write → do_read, utspridd över två funktioner och två lambdas,
är en for-loop igen: läs, skriv, läs, skriv. Det är den synkrona echo-servern från del 1, med co_await
framför varje anrop. Men den är inte synkron. Varje co_await pausar coroutinen, lämnar tillbaka tråden till
run(), och run() kör någon annan klients coroutine under tiden. Två nc samtidigt fungerar precis som i
förra delen, i en tråd, med samma serverlogg.
Och nu det viktiga: titta på buf. Den är en lokal variabel igen. I förra delen var hela avsnittet om livslängd
en konsekvens av att do_read() returnerade direkt, så att en lokal buffert hade dött innan handlern kördes.
Därför blev bufferten en medlem, och därför behövde Session äga sig själv via enable_shared_from_this. Nu
returnerar echo() inte förrän klienten kopplat ned. Coroutinen pausar vid co_await, och dess lokala
variabler ligger i coroutinens frame, som lever tills coroutinen är klar. Bufferten, socketen och peer lever
alltså exakt så länge som de behövs, utan en klass och utan en shared_ptr. Språket löser det som förra delen
löste med ett mönster.
Vem äger då coroutinen? co_spawn gör det. Den tar echo(std::move(socket)), som är ett awaitable<void>,
och håller det vid liv tills coroutinen kört klart. Det är samma princip som i förra delen, den utestående
operationen äger sessionen, men nu är "sessionen" en coroutine-frame och ägandet sköts av co_spawn. Accept-loopen
är likadan: en for-loop som väntar på nästa klient och startar en coroutine för den.
Samma server i Node.js
Nu när echo-servern är femton rader är den värd att sätta bredvid sin Node-motsvarighet:
import net from 'node:net';
async function echo(socket) {
const peer = `${socket.remoteAddress}:${socket.remotePort}`;
console.log('ansluten:', peer);
try {
for await (const chunk of socket) {
socket.write(chunk);
}
} catch (err) {
console.log(`fel mot ${peer}: ${err.message}`);
}
console.log('nedkopplad:', peer);
}
const port = Number(process.argv[2] ?? 7000);
net.createServer(echo).listen(port, () => console.log(`echo-server (Node) lyssnar på port ${port}`));
Samma struktur, rad för rad. async function motsvarar awaitable<void>, for await över socketen motsvarar
loopen med co_await async_read_some, och try/catch runt loopen finns på båda sidor. Det som skiljer är att
Node buffrar åt dig: for await lämnar ut varje chunk som redan anlänt, medan Asio inte läser något förrän du
ber om det. Och
net.createServer(echo) är listener() plus co_spawn, inbakat i biblioteket. I förra delen var Node-rutan
tvungen att förklara skillnaden mellan error-first callbacks och error_code. Nu är de två programmen så lika
att det knappt finns något att förklara. Det är det coroutines gör.
Felhantering i coroutines
I förra delen bytte vi till error_code överallt, eftersom det inte fanns någon att kasta ett exception till.
Nu finns det någon. När en operation som co_await:as misslyckas kastar co_await ett
boost::system::system_error, i coroutinen, på raden där anropet står. Så tumregeln från del 1 gäller igen:
exceptions som default, och error_code där fel är normalt flöde.
Det är därför echo() har try/catch runt sin loop. När klienten kopplar ned ger async_read_some eof, som är
ett system_error med koden asio::error::eof, och loopen bryts. Det är lite snålt att använda ett exception
för ett förväntat slut, men i en loop som ska avslutas ändå är det den kortaste koden. När eof inte ska avsluta
något, som i daytime-klienten strax, finns as_tuple:
auto [ec, n] = co_await asio::async_read(socket, asio::dynamic_buffer(reply), asio::as_tuple);
if (ec && ec != asio::error::eof) throw boost::system::system_error{ec, "read"};
as_tuple är en token-adapter: den gör att co_await returnerar en tuple med error_code och antalet byte, i
stället för att kasta. Det finns också redirect_error(ec), som fyller i en error_code-variabel, men
as_tuple med structured bindings är den form jag tycker läses bäst.
Och så baksidan med detached, som jag lovade. Vad händer om ett exception lämnar en coroutine som startats
med co_spawn(ex, f(), detached)? Ingenting. Jag testade med en coroutine som bara kastar: run() returnerade
normalt, programmet avslutade med kod 0, och inte ett ord skrevs ut. detached betyder "jag vill inte veta",
och det gäller även fel. Det är därför varje server-coroutine i repot har try/catch runt sin loop. Vill man ha
ut felet ger man co_spawn en riktig completion handler i stället, och det är så klienterna gör.
Daytime-klienten: tre rader igen
Här är löftet från förra delen infriat. Resolve, connect, read, som var tre nästlade lambdas med varsin felkontroll:
auto daytime(std::string host, std::string port) -> awaitable<void> {
auto ex = co_await asio::this_coro::executor;
auto resolver = tcp::resolver{ex};
auto socket = tcp::socket{ex};
auto reply = std::string{};
auto endpoints = co_await resolver.async_resolve(host, port);
auto ep = co_await asio::async_connect(socket, endpoints);
std::println("ansluten till {}", to_string(ep));
auto [ec, n] = co_await asio::async_read(socket, asio::dynamic_buffer(reply), asio::as_tuple);
if (ec && ec != asio::error::eof) throw boost::system::system_error{ec, "read"};
std::print("svar: {}", reply);
}
Tre co_await i följd, och koden läses uppifrån och ned som den synkrona klienten i del 1. Resultatet av
varje steg är ett returvärde, inte ett argument till nästa lambda. Felkontrollen är borta ur två av tre steg,
för ett fel i resolve eller connect kastar, och det räcker. Och status-variabeln, som förra delen behövde för
att få ut en felkod ur en lambda, är borta ur coroutinen. I stället fångas felet där coroutinen startas:
asio::co_spawn(ioc, daytime(host, port), [&status](std::exception_ptr e) {
if (!e) return;
try {
std::rethrow_exception(e);
} catch (std::exception const& ex) {
std::println(stderr, "fel: {}", ex.what());
status = 1;
}
});
ioc.run();
return status;
Det här är co_spawn med en riktig completion handler i stället för detached. Handlern körs när coroutinen
är klar, med ett std::exception_ptr som är tomt om allt gick bra. Det är enda stället där ett exception från
en coroutine fångas utanför den, och det är det detached hoppar över. Raden co_await asio::this_coro::executor
är ett litet trick för att få tag i den executor coroutinen körs på, så att I/O-objekten kan skapas inne i
coroutinen utan att ioc skickas in som argument.
Mot daytime-servern från del 1 ger det samma svar som förut. Mot en stängd port:
$ ./build/release/daytime-client/daytime-client localhost 9999
fel: Connection refused [system:111]
En detalj: de synkrona anropen i del 1 gav "connect: Connection refused", med operationens namn. Ett kastande
co_await ger bara "Connection refused". Vill man ha prefixet får man fånga och kasta om, eller använda
as_tuple och formatera själv. Jag lät det vara.
Chattserver, steg 3: coroutines i en tråd
Chattservern behåller sin tredelning från förra delen, men Server-klassen har blivit en listener()-funktion
precis som i echo-servern, och Room är oförändrad från steg 2a: ett std::set av sessioner, join, leave
och broadcast, ingen mutex, för allt körs i en tråd. Det nya är Session, som nu består av två coroutines:
reader(): for(;;) { co_await async_read_until en rad; room.broadcast() }
writer(): for(;;) { vänta tills kön har något; co_await async_write ett meddelande }
Läsaren är det du väntar dig:
auto reader() -> awaitable<void> {
try {
for (;;) {
auto n = co_await asio::async_read_until(socket, asio::dynamic_buffer(read_buf), '\n');
auto line = strip_eol(std::string_view{read_buf}.substr(0, n));
room.broadcast(std::format("[{}] {}\n", name, line), super::shared_from_this());
read_buf.erase(0, n);
}
} catch (boost::system::system_error const&) {
// eof, eller operation_aborted när writer() stängt socketen
}
close();
}
Skrivaren är det intressanta. I förra delen var skrivkön deliver() plus do_write() plus en skriv-handler som
tog nästa ur kön, och ett in_flight-fält som höll meddelandet under skrivning utanför kön så att trimningen
aldrig kunde röra det. Nu är skrivaren en coroutine med en loop, och frågan är hur den ska vänta när kön är
tom. Det finns ingen operation att co_await:a, för det som ska hända är att någon annan session anropar
deliver(). Svaret, som är hämtat från Asios eget chat-exempel, är en timer som aldrig går av:
asio::steady_timer timer; // väckarklocka för writer(), går aldrig av
// ... i konstruktorn:
timer.expires_at(asio::steady_timer::time_point::max());
void deliver(std::string msg) {
if (is_full()) {
queue.pop_front();
++dropped;
}
queue.push_back(std::move(msg));
timer.cancel_one();
}
auto writer() -> awaitable<void> {
try {
while (socket.is_open()) {
if (queue.empty()) {
co_await timer.async_wait(asio::as_tuple);
continue;
}
auto msg = std::move(queue.front()); // lokal: lever tills skrivningen är klar
queue.pop_front();
co_await asio::async_write(socket, asio::buffer(msg));
}
} catch (boost::system::system_error const&) {
// skrivfel, eller operation_aborted när reader() stängt socketen
}
close();
}
När kön är tom väntar writer() på timern, som har sin utgångstid satt till oändligt långt fram. deliver()
lägger meddelandet i kön och anropar timer.cancel_one(), som avbryter exakt en väntande async_wait med
operation_aborted. Det är inte ett fel, det är signalen, och därför as_tuple: resultatet blir en tuple som
vi inte ens tittar på, och loopen går ett varv till, ser att kön inte är tom, och skriver. En coroutine som
väntar på en signal från vanlig kod, med bara kärn-Asio. Det finns en experimental::channel också, men timern
räcker och är inte experimentell.
Lägg märke till msg. Meddelandet som skrivs är en lokal variabel i writer(), och lever i coroutinens frame
tills co_await async_write är klart. Förra delens in_flight finns inte, för den fallgropen, att trimningen
vid fullt tak frigör en buffert som en pågående skrivning läser från, kan inte uppstå när bufferten inte ligger
i kön. Själva kön, taket på 1000 och kasta-äldst är oförändrade.
Till sist ägarskapet, för här kommer det tillbaka. Session är fortfarande enable_shared_from_this, trots att
echo-servern klarade sig utan. Skillnaden är att två saker delar objektet: Room håller en shared_ptr i sin
mängd, och de två coroutinerna använder samma socket, kö och timer. start() startar dem så här:
void start() {
auto self = super::shared_from_this();
room.join(self);
std::println("ansluten: {} ({} totalt)", name, room.size());
room.broadcast(std::format("*** {} anslöt\n", name), self);
co_spawn(socket.get_executor(), [self] { return self->reader(); }, detached);
co_spawn(socket.get_executor(), [self] { return self->writer(); }, detached);
}
co_spawn tar här en lambda som returnerar coroutinen, och håller lambdan vid liv tills coroutinen är klar.
Lambdan fångar self, så sessionen lever så länge någon av de två kör. Det är samma shared_ptr-mekanik som i
förra delen, men ägarna är nu två coroutines i stället för en kedja av handlers. Regeln är enkel: så fort två
saker delar ett objekt är ägarskap tillbaka, coroutines eller inte.
close() är idempotent som förut. Den första coroutinen som kommer dit stänger socketen och avbryter timern,
vilket får den andras pågående operation att ge operation_aborted. Den avslutar också och anropar close(),
som då returnerar direkt eftersom socketen redan är stängd. Hela Session är knappt hundra rader, och finns i
repot.
Servern körs i en tråd, med ett enda
ioc.run(). Vill du körarun()i flera trådar som i steg 2b fungerar strand:arna likadant med coroutines:co_spawn(asio::make_strand(ioc), ...)för varje session, så körs allt i den coroutinen på den strand:en, och rummet får posta till sin egen strand precis som förut. Jag lämnar det i en tråd här, så att fokus ligger på syntaxen.
Samma resultat som förut
Två nc chattar som i förra delen, och simulatorn med 200 klienter visar en tråd. Head-of-line-experimentet,
med en klient som slutat läsa, en nc som läser och 40 000 rader från en tredje, ger samma resultat som i steg
2a: den vakna får alla rader, och den pausade loggas när den kopplar ned:
nedkopplad: 127.0.0.1:33264 (1 kvar, kastade 24372 meddelanden)
Inget nytt, och det är poängen. Servern beter sig exakt som förra delens, med samma garantier och samma prestanda. Det som ändrats är hur koden ser ut.
En egen klient
Hittills har nc varit klient, och det har räckt. Men en chattklient måste göra två saker samtidigt: läsa
rader från tangentbordet och skicka dem, och läsa rader från servern och skriva ut dem. Synkront hade det krävt
två trådar. Med coroutines är det två coroutines, och en operator:
auto stdin_to_socket(asio::posix::stream_descriptor& in, tcp::socket& socket) -> awaitable<void> {
auto line = std::string{};
try {
for (;;) {
auto n = co_await asio::async_read_until(in, asio::dynamic_buffer(line), '\n');
co_await asio::async_write(socket, asio::buffer(line, n));
line.erase(0, n);
}
} catch (boost::system::system_error const& e) {
if (e.code() != asio::error::eof) throw;
std::println("(stdin stängd, avslutar)"); // Ctrl-D
}
}
auto socket_to_stdout(tcp::socket& socket) -> awaitable<void> {
auto buf = std::string{};
try {
for (;;) {
auto n = co_await asio::async_read_until(socket, asio::dynamic_buffer(buf), '\n');
std::print("{}", std::string_view{buf}.substr(0, n));
std::fflush(stdout);
buf.erase(0, n);
}
} catch (boost::system::system_error const& e) {
if (e.code() != asio::error::eof) throw;
std::println("(servern stängde)");
}
}
auto chat(std::string host, std::string port) -> awaitable<void> {
auto ex = co_await asio::this_coro::executor;
auto resolver = tcp::resolver{ex};
auto socket = tcp::socket{ex};
auto in = asio::posix::stream_descriptor{ex, ::dup(STDIN_FILENO)};
co_await asio::async_connect(socket, co_await resolver.async_resolve(host, port));
std::println("ansluten till {}:{}, skriv rader, Ctrl-D avslutar", host, port);
co_await (stdin_to_socket(in, socket) || socket_to_stdout(socket));
}
Två nya saker. Den första är posix::stream_descriptor, Asios I/O-objekt för en vanlig filbeskrivare. Det är
första gången i serien som Asio läser något annat än en socket, och det fungerar likadant: async_read_until
på stdin, med samma dynamic_buffer och samma co_await. dup() är för att destruktorn ska stänga en kopia
och inte processens riktiga stdin. Klassen finns på Linux och macOS, inte på Windows.
Den andra är sista raden. Operatorn || tar två awaitables och kör dem parallellt, i samma tråd, och blir
klar när den första av dem är klar. Den andra avbryts. Trycker du Ctrl-D tar stdin slut, stdin_to_socket()
avslutar, och socket_to_stdout(), som står och väntar i async_read_until, får sin operation avbruten och
avslutar också. Dör servern i stället händer samma sak åt andra hållet. I båda fallen returnerar chat(), och
programmet avslutar snyggt. Operatorerna ligger i boost/asio/experimental/awaitable_operators.hpp och
kräver ett using namespace, och det finns en && också, som väntar på båda.
Servern i en terminal, klienten i en andra, en nc i en tredje:
$ ./build/release/chatclient/chatclient
ansluten till localhost:4711, skriv rader, Ctrl-D avslutar
hej från chatclient
[127.0.0.1:60366] hej från nc
[127.0.0.1:60366] hej igen
(stdin stängd, avslutar)
Timeouts
Samma operator löser ett problem som ingen av de tidigare delarna rört: timeouts. En synkron connect() kan
hänga i minuter mot en adress som inte svarar, och en asynkron likaså, om ingen avbryter den. Med || är en
timeout en timer som tävlar mot operationen. Här är daytime-klienten igen, med tre sekunders tidsgräns på
connect och på read:
constexpr auto timeout = 3s;
auto constexpr TIMEOUT = 1;
//...
timer.expires_after(timeout);
auto connected = co_await (asio::async_connect(socket, endpoints, asio::use_awaitable)
|| timer.async_wait(asio::use_awaitable));
if (connected.index() == TIMEOUT)
throw std::runtime_error{std::format("connect: timeout efter {}", timeout)};
std::println("ansluten till {}", to_string(std::get<0>(connected)));
timer.expires_after(timeout);
auto received = co_await (asio::async_read(socket, asio::dynamic_buffer(reply), asio::as_tuple(asio::use_awaitable))
|| timer.async_wait(asio::use_awaitable));
if (received.index() == TIMEOUT)
throw std::runtime_error{std::format("read: timeout efter {}", timeout)};
auto [ec, n] = std::get<0>(received);
Resultatet av || är en std::variant med ett alternativ per sida, och index() säger vem som vann: 0 är
operationen, 1 är timern, därav konstanten TIMEOUT. Vinner timern avbryts anslutningsförsöket, och vi kastar. Vinner anslutningen
avbryts timern, och vi fortsätter med dess resultat i std::get<0>.
Och så sa jag att det inte behövs några tokens i coroutine-kod, och här står use_awaitable på fyra ställen.
Det är undantaget. Operatorerna är definierade för awaitable<T>, inte för deferred-objekt. Ett anrop utan
token går att co_await:a, men inte att sätta på en sida om ||. Mitt första försök utan tokens gav ett
kompilatorfel på ett dussin rader, som kokade ned till att deferred_async_operation inte är en awaitable.
I klienten behövdes inget, för där var operanderna egna coroutines, som är awaitables. Vill man ha operationer
direkt i uttrycket får use_awaitable skrivas ut, och as_tuple får ta den som argument.
Mot nc -l 1313, som accepterar anslutningen men aldrig skickar något, och mot en adress som inte svarar:
$ ./build/release/daytime-timeout/daytime-timeout
ansluten till 127.0.0.1:1313
fel: read: timeout efter 3s
$ ./build/release/daytime-timeout/daytime-timeout 10.255.255.1
fel: connect: timeout efter 3s
För dig som kan Node.js. Nu går det att sätta upp en ordentlig mappning.
Node.js Boost.Asio net.createServer(handler)tcp::acceptor+listener()+co_spawnasync functionawaitable<T>for await (const chunk of socket)co_await async_read_some()setTimeoutsteady_timerPromise.race([a, b])a || bPromise.all([a, b])a && bAbortController/AbortSignalcancellation_signal/cancellation_slotDen stora skillnaden är fortfarande eager mot lazy.
Promise.racetar Promises som redan kör, och förloraren fortsätter köra i bakgrunden om du inte avbryter den själv med enAbortController. Asios||startar båda sidorna, och avbryter förloraren åt dig. Det leder över till nästa avsnitt.
Utblick
Tre saker som den här artikeln bara snuddar vid, och som du kommer att stöta på.
Cancellation. När || avbröt förloraren använde den Asios stöd för per-operation cancellation, som kom i
Boost 1.77. Varje asynkron operation kan kopplas till en cancellation_slot, och när någon signalerar på den
avbryts operationen med operation_aborted. Operatorn gör det åt dig, men du kan göra det själv: skapa en
cancellation_signal, bind dess slot till en operation med bind_cancellation_slot, och anropa emit() när
du vill avbryta. Det är vad som behövs för en "avbryt"-knapp eller en graceful shutdown, och det senare
återkommer i nästa del. I de flesta fall räcker operatorerna.
Stackful coroutines. Asio hade coroutines långt före C++20, i form av asio::spawn med en
yield_context som token. De bygger på Boost.Context, som byter stack i stället för att använda språkets
coroutines, och biblioteket är inte header-only. Du ser dem i äldre kod och i äldre exempel, och de fungerar
fortfarande. För ny kod är awaitable och co_await rätt val.
Boost.Cobalt. Sedan Boost 1.84 finns ett eget coroutine-bibliotek ovanpå Asio, med task, promise,
generator och channel. Det är ett försök att göra coroutines enklare än Asios egna typer, med färre val
och ett tydligare eager/lazy-tänk. Jag har inte använt det på riktigt än, och det kan hända att jag skriver om
det längre fram. Inget löfte dock.
Sammanfattning
Callback och coroutine är samma API. Sista argumentet till varje async_*-funktion är en completion token, och
vi såg fyra av dem på samma async_wait: callback, use_future, deferred och use_awaitable. Sedan Boost
1.86 är deferred default, och eftersom en awaitable kan co_await:a ett deferred-objekt behövs nästan
aldrig någon token alls i coroutine-kod.
Med coroutines blir den asynkrona koden synkron till formen. Echo-serverns kedja av handlers blev en for-loop,
och buffertar och sockets blev lokala variabler igen, eftersom de lever i coroutinens frame. Daytime-klientens
tre nivåer av lambdas blev tre co_await i följd, och fel kastas som exceptions i stället för att smugglas ut
via en variabel. Exceptions som lämnar en coroutine hamnar i co_spawn:s completion handler, och med
detached försvinner de tyst, så fånga dem.
Chattservern fick två coroutines per session, en läsare och en skrivare, med en timer som aldrig går av som
väckarklocka för skrivkön. Den egna klienten läser från stdin och socketen samtidigt med två coroutines och
operatorn ||, som också ger timeouts: en timer som tävlar mot operationen, med en std::variant som resultat.
Det är det enda stället där use_awaitable måste skrivas ut, för operatorerna tar bara awaitables.
Och allt det här, varenda co_await, är samma io_context, samma run() och samma strand:ar som i förra delen.
Nästa del lämnar syntaxen och går på produktionsdetaljerna: TLS med asio::ssl, graceful shutdown med
signal_set och cancellation, och UDP så att klienten hittar servern utan adress.
Länkar
- Källkod till artikeln – alla programmen plus klientsimulatorn
- Förra delen – Asynkront med callbacks
- Boost.Asio – C++20 coroutines support
- Boost.Asio – completion tokens
- Boost.Asio – per-operation cancellation
- Boost.Asio – chat-exemplet med coroutines
- Boost.Cobalt
- Asynkrona operationer med coroutines
- Asynkron filläsning med C++20 coroutines
- Coroutine generator i C++23
- Vad är coroutines i C++?
Senaste Artiklarna
-
Bygg en chattserver med Boost.Asio, del 3 - Asynkront med coroutines
18 november 2026 -
Bygg en chattserver med Boost.Asio, del 2 - Asynkront med callbacks
11 november 2026 -
Bygg en chattserver med Boost.Asio, del 1 - Grunderna och synkron I/O
4 november 2026 -
Väderdata med Boost
15 oktober 2026 -
Kom igång med Boost
2 oktober 2026 -
C++26 ORM via Reflection
29 september 2026 -
C++26 Reflection
18 september 2026 -
C++26 Contracts
11 september 2026