Structured concurrency

Structured concurrency is a programming paradigm aimed at improving the clarity, quality, and development time of a computer program by using a structured approach to concurrent programming. The core concept is the encapsulation of concurrent threads of execution (here encompassing kernel and userland threads and processes) by way of control flow constructs that have clear entry and exit points and that ensure all spawned threads have completed before exit. The concept is analogous to structured programming, which introduced control flow constructs that encapsulated sequential statements and subroutines. Such encapsulation allows errors in concurrent threads to be propagated to the control structure's parent scope and managed by the native error handling mechanisms of each particular computer language. It allows control flow to remain readily evident by the structure of the source code despite the presence of concurrency. To be effective, this model must be applied consistently throughout all levels of the program-- otherwise concurrent threads may leak out, become orphaned, or fail to have runtime errors correctly propagated.

Programming paradigms

The concept was formulated in 2016 by Martin Sústrik (creator of ZeroMQ),[1] and then further refined in 2018 by Nathaniel J. Smith, who implemented it in Trio.[2] Meanwhile, Roman Elizarov independently came upon the same ideas while developing an experimental coroutine library for the Kotlin language.[3][4]

In 2019, the loom project from OpenJDK is adopting structured concurrency to bring it to the Java platform in a future release as part of a larger work on lightweight threads and coroutines.[5]

In 2020, Swift is mentioning adoption of structured concurrency in their concurrency roadmap.[6]

Variations

A major point of variation is how an error in one member of a concurrent thread tree is handled. Simple implementations will merely wait until the children and siblings of the failing thread run to completion before propagating the error to the parent scope. However, that could take an indefinite amount of time. The alternative is to employ a general cancellation mechanism (typically a cooperative scheme allowing program invariants to be honored) to terminate the children and sibling threads in an expedient manner.

See also

References

Citations
  1. Sústrik, Martin (7 February 2016). "Structured Concurrency". Retrieved 1 August 2019.
  2. Smith, Nathaniel J. (25 April 2018). "Notes on structured concurrency, or: Go statement considered harmful". Retrieved 1 August 2019.
  3. Elizarov, Roman (12 September 2018). "Structured concurrency". Retrieved 21 September 2019.
  4. Elizarov, Roman (July 2019). Structured concurrency (Videotape). Hydra Distributed computing conference. 42 minutes in. Retrieved 21 September 2019. We needed a name and we needed to finalize this whole concept [...] and we stumble onto this blog post [...] by Nathaniel J. Smith.
  5. Bateman, Alan. "Structured concurrency". openjdk.java.net. OpenJDK. Retrieved November 23, 2019.
  6. Cohen, Ben. "Swift Concurrency Roadmap". swift.org. Swift. Retrieved October 31, 2020.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.