Yazılım Geliştirme: Koroya dayalı tüketici üreticisinin iş akışı | Haberler Online
Koro, eşzamansız kod yazmak için sezgisel ve yapılandırılmış bir yol sunar. Asenkron prosedürel stil operasyonları yazmanıza izin verirler. Asenkron programlamayı basitleştirmek için C ++ 20'ye tanıtılan bir işlevdir.
Rainer Grimm yıllardır yazılım mimarı, ekip ve eğitim müdürü olarak çalıştı. C ++ programlama dilleri, Python ve Haskell hakkında makaleler yazmayı seviyor, ancak uzman konferanslarla konuşmayı da seviyor. Modern C ++ blogunda, C ++ tutkusuyla yoğun bir şekilde ilgileniyor.
Bu tek prodüktör-ko-evi iş akışının anlaşılması kolay olmasa bile, choroutine deneyleri için iyi bir başlangıç noktasıdır.
Gibi mevcut mekanizmalar std::async, std:
ackaged_task veya olaylar (std::condition_variable & std::mutex) Bir iletişim kanalı oluşturarak etkinliğin sonucunda iki veya daha fazla iş parçacığını senkronize edin. Bu iletişim kanalının iki ucu var:
Koro istiflemeden – bu, vergi nesnesinin kazıkta oluşturulması gerektiği anlamına gelir. Tesadüfen, bibliyotik bir zarftır promise_type (((std::coroutine_handle<promise_type>), ama gerçekte hiçbir şey std:romise ortak noktası var.
. promise_type Bir koroutinin durum mekanizmasındaki önceden tanımlanmış geçiş durumlarını tanımlayan bir arayüzdür (bir adaptasyon noktası).
Koro çok yönlüdür ve eşzamansız bir haber akışını yönetmek için gereken farklı senaryolarda kullanılabilir. Yaygın bir örnek, sokete dayalı iletişimdir.
Bugün koroyu başka bir örnek kullanarak açıklamaya çalışacağım: tek üretici için tüketici iş akışı.
uygulama
Önce koro için sonuç türünü tanımlamalıyız:
class[[nodiscard]] AudioDataResult final
{
public:
class promise_type;
using handle_type = std::coroutine_handle<promise_type>;
class promise_type
{
...
};
};
Bu içeride bir sargı: promise_type Tip. Çevredeki sınıfı öznitelikle dekore ediyoruz [[nodiscard]]Sonuç türü koronun kontrolü nesnesi olduğundan: askıya alma/kurtarmasını yönetmek için istemci koduna geri dönelim.
@Ankunkt Sınıfın yok edicisi, kaynakları (dinamik bellek) RAII yolunda düzenler, böylece choroutine koşullarını yönetmek için gerekli değilse, getiri türü titizlikle göz ardı edilebilir.
~AudioDataResult() { if(handle_) { handle_.destroy(); } }
Sonuç türü, kontrol nesnesinin çoğaltılmasını önlemek için yer değiştirme -solo: kopya işlemleri yasaktır.
// Make the result type move-only,
//due to exclusive ownership over the handle
AudioDataResult(const AudioDataResult& ) = delete;
AudioDataResult& operator= (constAudioDataResult& ) = delete;
AudioDataResult(AudioDataResult&& other) noexcept:
handle_(std::exchange(other.handle_, nullptr))
{}
AudioDataResult& operator = (AudioDataResult&& other) noexcept
{
using namespace std;
AudioDataResult tmp =std::move(other);
swap(*this, tmp);
return *this;
}
Şimdi Promme_Type arayüzünün kendisini tanımlıyoruz:
// Predefined interface that has to be specify
//in order to implement
// coroutine's state-machine transitions
class promise_type
{
public:
using value_type = std::vector<int>;
AudioDataResult get_return_object()
{
return AudioDataResult{ handle_type::from_promise(*this) };
}
std::suspend_never initial_suspend() noexcept { return{}; }
std::suspend_always final_suspend() noexcept { return{}; }
void return_void() {}
void unhandled_exception()
{
std::rethrow_exception(std::current_exception());
}
// Generates the value and suspend the "producer"
template <typename Data>
requires std::convertible_to<std::decay_t<Data>, value_type>
std::suspend_always yield_value(Data&& value)
{
data_ = std::forward<Data>(value);
data_ready_.store(true, std::memory_order::relaxed);
return {};
}
private:
value_type data_;
std::atomic<bool> data_ready_;
};//promise_type interface
. promise_type Koroutinin gerekli altyapısını tanımlar. Ayrıca, promise_type Bir jeneratör olarak hareket etmek isteyen tüm koro için – “üretici” – değerleri vermek yield_value-Modi genişletildi (co_yield ≡ co_await promise_.yield_value). Veriler tüketilirse, karşılık gelen SRAPPE yöntemine sahip olmalıyız resume() Üreticiye devam etmeyi sağlayın.
void resume() { if( not handle_.done()) { handle_.resume();} }
Şimdi koroyu tüketici gereksinimlerini karşılayacak şekilde genişletmeliyiz: verilerin hazır olmasıyla senkronize edilmelidir. Başka bir deyişle, veriler üretici tarafından mevcut olduğu gibi rapor edilene kadar tüketici kesintiye uğrar. Bunu yapmak için arayüzlemeliyiz Awaiter alet:
class promise_type
{
// Awaiter interface: for consumer waiting on data being ready
struct AudioDataAwaiter
{
explicit AudioDataAwaiter(promise_type& promise) noexcept: promise_(promise) {}
bool await_ready() const
{
return promise_.data_ready_.load(std::memory_order::relaxed);
}
void await_suspend(handle_type) const
{
while( not promise_.data_ready_.exchange(false))
{
std::this_thread::yield();
}
}
// move assignment at client invocation side:
// const auto data = co_await audioDataResult;
// This requires that coroutine's result type provides
// the co_await unary operator
value_type&& await_resume() const
{
return std::move(promise_.data_);
}
private:
promise_type& promise_;
};//Awaiter interface
};//promise_type
Eyalet makinesinde await_ready() İlk geçiş durumu: Verilerin iradesi için doğrulanmıştır. Veriler hazır değilse, bir sonraki irade await_suspend() isminde. Burada aslında ilgili bayrağın ayarlanmamasını bekliyoruz. Sonunda olur await_resume() Adı: “Hareket ettiriyoruz” değerini promise_typeKoşulsuz bir referans rvalue tarzında dönüştürmek. Müşteri çağrısının yanında, bu, döndürülen değer için atama operatörünün – data – denir.
const auto data = co_await audioDataResult;
Bunun çalışması için, sonuç türü bir kenarın operatörü olmalıdır. co_await Bizimkini sağlayın Awaiter-arayüz.
class AudioDataResult
{
auto operator co_await() noexcept
{
return promise_type::AudioDataAwaiter{handle_.promise()};
}
};
: https://godbolt.org/z/mvyfbep8r
Aşağıdaki program producerConsumer.cpp Örnek 1'in basitleştirilmiş bir versiyonunu gösterir:
// producerConsumer.cpp
#include <algorithm>
#include <atomic>
#include <chrono>
#include <coroutine>
#include <functional>
#include <iostream>
#include <iterator>
#include <memory>
#include <source_location>
#include <thread>
#include <utility>
#include <vector>
void funcName(const std::source_location location = std::source_location::current()) {
std::cout << location.function_name() << 'n';
}
template <typename Container>
void printContainer(const Container& container)
{
typedef typename Container::value_type value_type;
auto first = std::cbegin(container);
auto last = std::cend(container);
std::cout << " [";
std::copy(first, std:rev(last), std:stream_iterator<value_type>(std::cout, ", "));
std::cout << *std:rev(last) << "]n";
}
class [[nodiscard]] AudioDataResult final
{
public:
class promise_type;
using handle_type = std::coroutine_handle<promise_type>;
// Predefined interface that has to be specify in order to implement
// coroutine's state-machine transitions
class promise_type
{
public:
using value_type = std::vector<int>;
AudioDataResult get_return_object()
{
return AudioDataResult{handle_type::from_promise(*this)};
}
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception()
{
std::rethrow_exception(std::current_exception());
}
// Generates the value and suspend the "producer"
template <typename Data>
requires std::convertible_to<std::decay_t<Data>, value_type>
std::suspend_always yield_value(Data&& value)
{
data_ = std::forward<Data>(value);
data_ready_.store(true);
return {};
}
// Awaiter interface: for consumer waiting on data being ready
struct AudioDataAwaiter
{
explicit AudioDataAwaiter(promise_type& promise) noexcept: promise_(promise) {}
bool await_ready() const { return promise_.data_ready_.load();}
void await_suspend(handle_type) const
{
while(not promise_.data_ready_.exchange(false)) {
std::this_thread::yield();
}
}
// move assignment at client invocation side: const auto data = co_await audioDataResult;
// This requires that coroutine's result type provides the co_await unary operator
value_type&& await_resume() const
{
return std::move(promise_.data_);
}
private:
promise_type& promise_;
};//Awaiter interface
private:
value_type data_;
std::atomic<bool> data_ready_;
}; //promise_type interface
auto operator co_await() noexcept
{
return promise_type::AudioDataAwaiter{handle_.promise()};
}
// Make the result type move-only, due to ownership over the handle
AudioDataResult(const AudioDataResult&) = delete;
AudioDataResult& operator=(const AudioDataResult&) = delete;
AudioDataResult(AudioDataResult&& other) noexcept: handle_(std::exchange(other.handle_, nullptr)){}
AudioDataResult& operator=(AudioDataResult&& other) noexcept
{
using namespace std;
AudioDataResult tmp = std::move(other);
swap(*this, tmp);
return *this;
}
// d-tor: RAII
~AudioDataResult() { if (handle_) {funcName(); handle_.destroy();}}
// For resuming the producer - at the point when the data are consumed
void resume() {if (not handle_.done()) { funcName(); handle_.resume();}}
private:
AudioDataResult(handle_type handle) noexcept : handle_(handle) {}
private:
handle_type handle_;
};
using data_type = std::vector<int>;
AudioDataResult producer(const data_type& data)
{
for (std::size_t i = 0; i < 5; ++i) {
funcName();
co_yield data;
}
co_yield data_type{}; // exit criteria
}
AudioDataResult consumer(AudioDataResult& audioDataResult)
{
while(true)
{
funcName();
const auto data = co_await audioDataResult;
if (data.empty()) {std::cout << "No data - exit!n"; break;}
std::cout << "Data received:";
printContainer(data);
audioDataResult.resume(); // resume producer
}
}
int main()
{
{
const data_type data = {1, 2, 3, 4};
auto audioDataProducer = producer(data);
std::thread t ([&]{auto audioRecorded = consumer(audioDataProducer);});
t.join();
}
std::cout << "bye-bye!n";
}
Son olarak, program programın baskısıdır:
Diğer seçenek de kullanımı promise_type::await_transform()İçindeki değeri bekle promise_type-İnsman üretici tarafından kullanıldığı için arşivlenmiştir.
class promise_type
{
auto await_transform(handle_type other)
{
// Awaiter interface: remained the same
struct AudioDataAwaiter
{
explicit AudioDataAwaiter(promise_type& promise)noexcept: promise_(promise) {}
...
};
return AudioDataAwaiter{other.promise()};
}
};
Bu şekilde artık bir kenarın operatörü olmak zorunda değiliz co_await Sonuç türünü belirtin, ancak bir dönüştürme operatörü (açık),
explicit operator handle_type() const {return handle_;}
Böylece tüketicinin bulunduğu noktaya teslim edebiliriz co_await Aramada dahili olarak arayın await_transform() Tercüme edilmiştir.
const auto data = co_await static_cast<AudioDataResult::handle_type>(audioDataResult);
Bunu şu şekilde açıklayabiliriz: me.handle_.promise().await_transform(other.handle_)
: https://godbolt.org/z/57zsk9ren
çözüm
Bu basit örnekte, üretici cezalandırılmadan durdurulur, çünkü iyileşmeden sonra tam olarak aynı – önceden bilinen – sunar. Muhtemelen gerçek bir senaryoda durum böyle değildir: üreticinin kendisi muhtemelen bir tür arabulucu olacaktır – tüketiciye iade edilecek asenkron verilerin alıcısı. Bu nedenle, veriler tutuklandığında veri kayıplarından kaçınmak ve tüketicinin devam etmesini beklemek, üreticinin varış oranı ile tüketicinin tüketim oranı arasındaki farkları telafi etmek için ürün üzerinde bir kuyruk mantığı uygulanmalıdır.
Sırada ne var?
C ++ 20'de tre-vie tanımlanabilir veya default Rica etmek. Bu, altı karşılaştırma operatörünün de mevcut olduğu anlamına gelir: ==, !=, <, <=, > VE >=. Eşitlik operatörünü de kullanabilirsiniz (==) Tanımlayın veya default Rica etmek.
Kısa Noel Tatmanım
Blogum küçük bir Noel tatili yapıyor. Bir sonraki makaleyi 8 Ocak'ta yayınlayacağım. Tüm okuyuculara iyi vakit geçiriyorum.
(RME)
Yazılım Geliştirme: Tüketici Üreticisinin Koirutin'e Dayalı İş Akışı
Koro, eşzamansız kod yazmak için sezgisel ve yapılandırılmış bir yol sunar. Asenkron prosedürel stil operasyonları yazmanıza izin verirler. Asenkron programlamayı basitleştirmek için C ++ 20'ye tanıtılan bir işlevdir.
Rainer Grimm yıllardır yazılım mimarı, ekip ve eğitim müdürü olarak çalıştı. C ++ programlama dilleri, Python ve Haskell hakkında makaleler yazmayı seviyor, ancak uzman konferanslarla konuşmayı da seviyor. Modern C ++ blogunda, C ++ tutkusuyla yoğun bir şekilde ilgileniyor.
Bu tek prodüktör-ko-evi iş akışının anlaşılması kolay olmasa bile, choroutine deneyleri için iyi bir başlangıç noktasıdır.
Gibi mevcut mekanizmalar std::async, std:
ackaged_task veya olaylar (std::condition_variable & std::mutex) Bir iletişim kanalı oluşturarak etkinliğin sonucunda iki veya daha fazla iş parçacığını senkronize edin. Bu iletişim kanalının iki ucu var:- std:romiseOrtak durumun sonucu veya istisnasını kim yazar
- std::future (((std::shared_future) – Etkinliğin (veya istisnanın) sonucunu bekleyen bir alıcı son.
Koro istiflemeden – bu, vergi nesnesinin kazıkta oluşturulması gerektiği anlamına gelir. Tesadüfen, bibliyotik bir zarftır promise_type (((std::coroutine_handle<promise_type>), ama gerçekte hiçbir şey std:
romise ortak noktası var.. promise_type Bir koroutinin durum mekanizmasındaki önceden tanımlanmış geçiş durumlarını tanımlayan bir arayüzdür (bir adaptasyon noktası).
Koro çok yönlüdür ve eşzamansız bir haber akışını yönetmek için gereken farklı senaryolarda kullanılabilir. Yaygın bir örnek, sokete dayalı iletişimdir.
Bugün koroyu başka bir örnek kullanarak açıklamaya çalışacağım: tek üretici için tüketici iş akışı.
uygulama
Önce koro için sonuç türünü tanımlamalıyız:
class[[nodiscard]] AudioDataResult final
{
public:
class promise_type;
using handle_type = std::coroutine_handle<promise_type>;
class promise_type
{
...
};
};
Bu içeride bir sargı: promise_type Tip. Çevredeki sınıfı öznitelikle dekore ediyoruz [[nodiscard]]Sonuç türü koronun kontrolü nesnesi olduğundan: askıya alma/kurtarmasını yönetmek için istemci koduna geri dönelim.
@Ankunkt Sınıfın yok edicisi, kaynakları (dinamik bellek) RAII yolunda düzenler, böylece choroutine koşullarını yönetmek için gerekli değilse, getiri türü titizlikle göz ardı edilebilir.
~AudioDataResult() { if(handle_) { handle_.destroy(); } }
Sonuç türü, kontrol nesnesinin çoğaltılmasını önlemek için yer değiştirme -solo: kopya işlemleri yasaktır.
// Make the result type move-only,
//due to exclusive ownership over the handle
AudioDataResult(const AudioDataResult& ) = delete;
AudioDataResult& operator= (constAudioDataResult& ) = delete;
AudioDataResult(AudioDataResult&& other) noexcept:
handle_(std::exchange(other.handle_, nullptr))
{}
AudioDataResult& operator = (AudioDataResult&& other) noexcept
{
using namespace std;
AudioDataResult tmp =std::move(other);
swap(*this, tmp);
return *this;
}
Şimdi Promme_Type arayüzünün kendisini tanımlıyoruz:
// Predefined interface that has to be specify
//in order to implement
// coroutine's state-machine transitions
class promise_type
{
public:
using value_type = std::vector<int>;
AudioDataResult get_return_object()
{
return AudioDataResult{ handle_type::from_promise(*this) };
}
std::suspend_never initial_suspend() noexcept { return{}; }
std::suspend_always final_suspend() noexcept { return{}; }
void return_void() {}
void unhandled_exception()
{
std::rethrow_exception(std::current_exception());
}
// Generates the value and suspend the "producer"
template <typename Data>
requires std::convertible_to<std::decay_t<Data>, value_type>
std::suspend_always yield_value(Data&& value)
{
data_ = std::forward<Data>(value);
data_ready_.store(true, std::memory_order::relaxed);
return {};
}
private:
value_type data_;
std::atomic<bool> data_ready_;
};//promise_type interface
. promise_type Koroutinin gerekli altyapısını tanımlar. Ayrıca, promise_type Bir jeneratör olarak hareket etmek isteyen tüm koro için – “üretici” – değerleri vermek yield_value-Modi genişletildi (co_yield ≡ co_await promise_.yield_value). Veriler tüketilirse, karşılık gelen SRAPPE yöntemine sahip olmalıyız resume() Üreticiye devam etmeyi sağlayın.
void resume() { if( not handle_.done()) { handle_.resume();} }
Şimdi koroyu tüketici gereksinimlerini karşılayacak şekilde genişletmeliyiz: verilerin hazır olmasıyla senkronize edilmelidir. Başka bir deyişle, veriler üretici tarafından mevcut olduğu gibi rapor edilene kadar tüketici kesintiye uğrar. Bunu yapmak için arayüzlemeliyiz Awaiter alet:
class promise_type
{
// Awaiter interface: for consumer waiting on data being ready
struct AudioDataAwaiter
{
explicit AudioDataAwaiter(promise_type& promise) noexcept: promise_(promise) {}
bool await_ready() const
{
return promise_.data_ready_.load(std::memory_order::relaxed);
}
void await_suspend(handle_type) const
{
while( not promise_.data_ready_.exchange(false))
{
std::this_thread::yield();
}
}
// move assignment at client invocation side:
// const auto data = co_await audioDataResult;
// This requires that coroutine's result type provides
// the co_await unary operator
value_type&& await_resume() const
{
return std::move(promise_.data_);
}
private:
promise_type& promise_;
};//Awaiter interface
};//promise_type
Eyalet makinesinde await_ready() İlk geçiş durumu: Verilerin iradesi için doğrulanmıştır. Veriler hazır değilse, bir sonraki irade await_suspend() isminde. Burada aslında ilgili bayrağın ayarlanmamasını bekliyoruz. Sonunda olur await_resume() Adı: “Hareket ettiriyoruz” değerini promise_typeKoşulsuz bir referans rvalue tarzında dönüştürmek. Müşteri çağrısının yanında, bu, döndürülen değer için atama operatörünün – data – denir.
const auto data = co_await audioDataResult;
Bunun çalışması için, sonuç türü bir kenarın operatörü olmalıdır. co_await Bizimkini sağlayın Awaiter-arayüz.
class AudioDataResult
{
auto operator co_await() noexcept
{
return promise_type::AudioDataAwaiter{handle_.promise()};
}
};
: https://godbolt.org/z/mvyfbep8r
Aşağıdaki program producerConsumer.cpp Örnek 1'in basitleştirilmiş bir versiyonunu gösterir:
// producerConsumer.cpp
#include <algorithm>
#include <atomic>
#include <chrono>
#include <coroutine>
#include <functional>
#include <iostream>
#include <iterator>
#include <memory>
#include <source_location>
#include <thread>
#include <utility>
#include <vector>
void funcName(const std::source_location location = std::source_location::current()) {
std::cout << location.function_name() << 'n';
}
template <typename Container>
void printContainer(const Container& container)
{
typedef typename Container::value_type value_type;
auto first = std::cbegin(container);
auto last = std::cend(container);
std::cout << " [";
std::copy(first, std:
rev(last), std:stream_iterator<value_type>(std::cout, ", ")); std::cout << *std:
rev(last) << "]n"; }
class [[nodiscard]] AudioDataResult final
{
public:
class promise_type;
using handle_type = std::coroutine_handle<promise_type>;
// Predefined interface that has to be specify in order to implement
// coroutine's state-machine transitions
class promise_type
{
public:
using value_type = std::vector<int>;
AudioDataResult get_return_object()
{
return AudioDataResult{handle_type::from_promise(*this)};
}
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception()
{
std::rethrow_exception(std::current_exception());
}
// Generates the value and suspend the "producer"
template <typename Data>
requires std::convertible_to<std::decay_t<Data>, value_type>
std::suspend_always yield_value(Data&& value)
{
data_ = std::forward<Data>(value);
data_ready_.store(true);
return {};
}
// Awaiter interface: for consumer waiting on data being ready
struct AudioDataAwaiter
{
explicit AudioDataAwaiter(promise_type& promise) noexcept: promise_(promise) {}
bool await_ready() const { return promise_.data_ready_.load();}
void await_suspend(handle_type) const
{
while(not promise_.data_ready_.exchange(false)) {
std::this_thread::yield();
}
}
// move assignment at client invocation side: const auto data = co_await audioDataResult;
// This requires that coroutine's result type provides the co_await unary operator
value_type&& await_resume() const
{
return std::move(promise_.data_);
}
private:
promise_type& promise_;
};//Awaiter interface
private:
value_type data_;
std::atomic<bool> data_ready_;
}; //promise_type interface
auto operator co_await() noexcept
{
return promise_type::AudioDataAwaiter{handle_.promise()};
}
// Make the result type move-only, due to ownership over the handle
AudioDataResult(const AudioDataResult&) = delete;
AudioDataResult& operator=(const AudioDataResult&) = delete;
AudioDataResult(AudioDataResult&& other) noexcept: handle_(std::exchange(other.handle_, nullptr)){}
AudioDataResult& operator=(AudioDataResult&& other) noexcept
{
using namespace std;
AudioDataResult tmp = std::move(other);
swap(*this, tmp);
return *this;
}
// d-tor: RAII
~AudioDataResult() { if (handle_) {funcName(); handle_.destroy();}}
// For resuming the producer - at the point when the data are consumed
void resume() {if (not handle_.done()) { funcName(); handle_.resume();}}
private:
AudioDataResult(handle_type handle) noexcept : handle_(handle) {}
private:
handle_type handle_;
};
using data_type = std::vector<int>;
AudioDataResult producer(const data_type& data)
{
for (std::size_t i = 0; i < 5; ++i) {
funcName();
co_yield data;
}
co_yield data_type{}; // exit criteria
}
AudioDataResult consumer(AudioDataResult& audioDataResult)
{
while(true)
{
funcName();
const auto data = co_await audioDataResult;
if (data.empty()) {std::cout << "No data - exit!n"; break;}
std::cout << "Data received:";
printContainer(data);
audioDataResult.resume(); // resume producer
}
}
int main()
{
{
const data_type data = {1, 2, 3, 4};
auto audioDataProducer = producer(data);
std::thread t ([&]{auto audioRecorded = consumer(audioDataProducer);});
t.join();
}
std::cout << "bye-bye!n";
}
Son olarak, program programın baskısıdır:
Diğer seçenek de kullanımı promise_type::await_transform()İçindeki değeri bekle promise_type-İnsman üretici tarafından kullanıldığı için arşivlenmiştir.
class promise_type
{
auto await_transform(handle_type other)
{
// Awaiter interface: remained the same
struct AudioDataAwaiter
{
explicit AudioDataAwaiter(promise_type& promise)noexcept: promise_(promise) {}
...
};
return AudioDataAwaiter{other.promise()};
}
};
Bu şekilde artık bir kenarın operatörü olmak zorunda değiliz co_await Sonuç türünü belirtin, ancak bir dönüştürme operatörü (açık),
explicit operator handle_type() const {return handle_;}
Böylece tüketicinin bulunduğu noktaya teslim edebiliriz co_await Aramada dahili olarak arayın await_transform() Tercüme edilmiştir.
const auto data = co_await static_cast<AudioDataResult::handle_type>(audioDataResult);
Bunu şu şekilde açıklayabiliriz: me.handle_.promise().await_transform(other.handle_)
: https://godbolt.org/z/57zsk9ren
çözüm
Bu basit örnekte, üretici cezalandırılmadan durdurulur, çünkü iyileşmeden sonra tam olarak aynı – önceden bilinen – sunar. Muhtemelen gerçek bir senaryoda durum böyle değildir: üreticinin kendisi muhtemelen bir tür arabulucu olacaktır – tüketiciye iade edilecek asenkron verilerin alıcısı. Bu nedenle, veriler tutuklandığında veri kayıplarından kaçınmak ve tüketicinin devam etmesini beklemek, üreticinin varış oranı ile tüketicinin tüketim oranı arasındaki farkları telafi etmek için ürün üzerinde bir kuyruk mantığı uygulanmalıdır.
Sırada ne var?
C ++ 20'de tre-vie tanımlanabilir veya default Rica etmek. Bu, altı karşılaştırma operatörünün de mevcut olduğu anlamına gelir: ==, !=, <, <=, > VE >=. Eşitlik operatörünü de kullanabilirsiniz (==) Tanımlayın veya default Rica etmek.
Kısa Noel Tatmanım
Blogum küçük bir Noel tatili yapıyor. Bir sonraki makaleyi 8 Ocak'ta yayınlayacağım. Tüm okuyuculara iyi vakit geçiriyorum.
(RME)