Tasks

Einfache Futures mit Coroutinen implementieren

Anstelle von return, verwendet eine Coroutine co_return, um ihren Wert zurückzugeben. In diesem Artikel werde ich eine einfache Coroutine implementieren, die co_return verwendet.

Hier geht es direkt zum Artikel auf Heise Developer: .

Gelesen: 31

Synchronisation mit atomaren Variablen

Sender/Empfänger Arbeitsabläufe sind typisch für Threads. In solch einem Arbeitsablauf wartet der Empfänger auf die Benachrichtigung des Senders bevor er seine Arbeit fortsetzt. Es gibt einige Möglichkeiten diesen Arbeitsablauf umzusetzen. Mit C++11 bieten sich Bedingungsvariablen oder Promise/Future-Paare an, mit C++20 atomare Variablen.

Hier geht es direkt zum Artikel auf Heise Developer:

Gelesen: 1825

C++ Core Guidelines: Mehr Regeln zur Concurrency und zur Parallelität

Das Schreiben von Multithreading-Programmen ist sehr anspruchsvoll. Das gilt vor allem, wenn sie korrekt sein sollen. Die Regeln der C++ Core Guidelines geben die notwendige Hilfe an die Hand, um korrekte Programme zu schreiben. Die Regeln in diesem Artikel werden sich mit Themen wie Data Races, dem Teilen von Daten, Tasks und dem berühmt-berüchtigten Schlüsselwort volatile beschäftigen.

Hier geht es direkt zum Artikel auf Heise Developer:

Gelesen: 6594

std::future Erweiterungen

Tasks in der Form von Promisen und Futuren in C++11 genießen einen ambivalenten Ruf. Zum einen sind sie deutlich leichter zu verwenden als Threads oder Bedingungsvariablen, zum anderen besitzen sie eine große Unzulänglichkeit. Sie können nicht komponiert werden. Mit dieser Unzulänglichkeit räumt C++20 auf.

Weiterlesen...
Tags: Tasks, C++20
Gelesen: 15384

Monaden in C++

Monaden in C++? Was für ein seltsamer Titel für einen Artikel. Doch so seltsam ist er gar nicht. Mit std::optional wird C++17 um eine Monade erweiterte. Die Ranges-Bibliothek von Eric Niebler und die erweiterten Futures, auf die wir in C++20 hoffen dürfen, sind Monaden.

Weiterlesen...
Gelesen: 16022

Mein Fazit: Addition in drei verschiedenen Varianten

Nachdem ich in den letzten drei Artikel die Summe eines Vektors in drei verschiedenen Strategien berechnet habe, möchte ich mit diesem Artikel mein Fazit ziehen.

Weiterlesen...
Tags: Tasks
Gelesen: 12293

Multithreaded: Addition mit minimaler Synchronisation

Zwei Strategien bin ich bisher bei meiner Addition aller Elemente eines std::vector gefolgt. Zum einen habe ich die ganze Summation in einem Thread ausgeführt (Single-Threaded: Summe der Elemente eines Vektors), zum anderen alle Threads auf einer gemeinsamen Summations-Variable (Multithreaded: Addition mit einer geteilten Variable) agieren lassen. Gerade die zweite Strategie war sehr naiv. In diesem Artikel werde ich meine Erkenntnisse aus beiden Artikeln anwenden. Mein Ziel wird es daher sein, die Threads möglichst unabhängig ihre Arbeit ausführen zu lassen und die Synchronisation der Threads auf der Summations-Variable zu minimieren.

Weiterlesen...
Gelesen: 8768

Besondere Futures mit std::async

Der erzeugende Thread muss sich um die Lebenszeit seines erzeugten Threads (th) kümmern. Der Erzeuger wartet entweder, bis sein Kind seine Arbeit vollzogen hat (th.join()) oder er trennt sich von ihm (th.detach()). Das ist alles ein alter Hut. Dies gilt aber nicht für std:.async. Der große Charme von std::async besteht auch darin, dass sich der Erzeuger nicht um die Lebenszeit seines Kindes kümmern muss. 

Weiterlesen...
Tags: Tasks
Gelesen: 26677

Bedingungsvariablen versus Tasks zur Synchronisation von Threads

 

Werden Promise und Future für die Synchronization von Threads verwendet, haben sie sehr viel gemein mit Bedingungsvariablen. Meist sind Tasks die bessere Wahl.

Weiterlesen...
Gelesen: 12470

Abonniere den Newsletter (+ pdf Päckchen)

Beiträge-Archiv

Sourcecode

Neuste Kommentare