Misplaced Pages

Tokio (software)

Article snapshot taken from Wikipedia with creative commons attribution-sharealike license. Give it a read and then ask your questions in the chat. We can research this topic together.
Library for Rust programming language
Tokio
Original author(s)Carl Lerche
Initial releaseDecember 23, 2020; 3 years ago (2020-12-23)
Stable release1.41.1 Edit this on Wikidata
Repository
Written inRust
Operating systemmacOS, Windows, Linux, FreeBSD, WebAssembly
TypeAsynchronous runtime
LicenseMIT License
Websitetokio.rs

Tokio is a software library for the Rust programming language. It provides a runtime and functions that enable the use of asynchronous I/O, allowing for concurrency in regards to task completion.

Tokio was released in August 2016 for Rust, a general-purpose programming language. Developed by Carl Lerche, Tokio began as a network application framework and supports features such as socket listening and broadcasting, allowing messages to be transferred between computers.

History

Tokio began in August 2016 by Carl Lerche as a network application framework for Rust built on futures, allowing for network-based middleware and a non-blocking, or asynchronous, implementation of readiness interest to the reactor. Tokio was inspired by Finagle, a Scala-based asynchronous remote procedure call (RPC) system developed at Twitter for Java virtual machines (JVM), allowing distributed systems to communicate within a JVM. Tokio utilizes the lower-level Rust crate mio, itself using system calls such as epoll (Linux), kqueue (FreeBSD), and the input/output completion port (IOCP) API (Windows). For Linux it can also use io_uring via tokio-uring. The name "Tokio" is derived from Tokyo and mio. The preliminary version of Tokio was released in January 2017, followed by a full release in December 2020. In 2017, Tokio received a grant from the Mozilla Open Source Support fund. In April 2021, Tokio funded its first paid contributor, Alice Ryhl, for her work both developing the project and assisting its users.

While Rust has supported asynchronous functions since version 1.39, released in November 2019, it provides no facilities to execute them, requiring an external runtime for that purpose. Tokio provides a runtime that uses a multi-threaded work stealing scheduler. Rust's futures are lazily evaluated, requiring functions to call .await before they do any work. When .await is invoked, Tokio's runtime may pause the original future until its I/O completes, and unpauses a different task that is ready for further processing.

Users of Tokio include the development teams behind Discord and AWS Lambda. The JavaScript and TypeScript runtime Deno uses Tokio under the hood, in comparison to the JavaScript runtime Node.js, which uses the libuv library.

Features

Asynchronous code

Tokio allows for the usage of asynchronous functions in Rust through the creation of an asynchronous runtime. This can be accomplished through the # macro.

For example: 

#
async fn main() -> Result<()> {
    let url = "https://en.wikipedia.org/";
    let text = reqwest::get(url).await?.text().await?;
    println!("{}", text);
    Ok(())
}

In this example, the reqwest crate is used to request the HyperText Markup Language (HTML) for English Misplaced Pages. To ensure that the request is not immediately handled, Tokio wraps the function call into an asynchronous runtime, waiting for the request to complete before calling println().

Tokio also includes a version of the Rust standard library that is designed for being used asynchronously. For example, tokio::fs::read_to_end(), which reads the contents of a file, is the asynchronous version of std::fs::read_to_end(). In addition, Tokio supports io_uring, a Linux asynchronous I/O syscall interface, in a separate crate named tokio-uring.

The coroutine model

Tokio further allows users to create tasks, which are stackless coroutines, using a tokio::spawn() function. Tasks run at the user level, providing concurrency even when there is only a single thread.

Socket listening

Tokio is capable of listening on a socket through a non-blocking approach. In particular, the TcpListener structure binds a Transmission Control Protocol (TCP) socket listener to an address and asynchronously executes function.

Broadcasting

Tokio provides a broadcast channel type, allowing for messages to be broadcast to multiple receivers. Upon sending a message, it is received by such receivers. This enables real-time communication and distributed systems, among other applications.

References

  1. "Release 1.41.1". 7 November 2024. Retrieved 1 December 2024.
  2. Chanda, Abhishek (2018). Network Programming with Rust: Build fast and resilient network servers and clients by leveraging Rust's memory-safety and concurrency features. Birmingham: Packt Publishing. ISBN 978-1-78862-171-7. OCLC 1028194311.
  3. Sharma, Rahul (2019). Mastering Rust : learn about memory safety, type system, concurrency, and the new features of Rust 2018 edition. Vesa Kaihlavirta (Second ed.). Birmingham, UK. ISBN 978-1-78934-118-8. OCLC 1090681119.{{cite book}}: CS1 maint: location missing publisher (link)
  4. De Simone, Sergio (2021-01-06). "Rust Asynchronous Runtime Tokio Reaches 1.0". InfoQ. Retrieved 2021-11-21.
  5. ^ Lerche, Carl (August 3, 2016). "Announcing Tokio". Retrieved December 11, 2022.
  6. "Finagle: A Protocol-Agnostic RPC System". August 19, 2011. Retrieved December 11, 2022.
  7. Gomez, Guillaume; Boucher, Antoni (2018). Rust Programming By Example: Enter the World of Rust by Building Engaging, Concurrent, Reactive, and Robust Applications. Birmingham: Packt Publishing. ISBN 9781788470308.
  8. Lerche, Carl (August 3, 2016). "I enjoyed visiting Tokio (Tokyo) the city and I liked the "io" suffix and how it plays w/ Mio as well. I don't know... naming is hard so I didn't spend too much time thinking about it". Reddit. Retrieved December 11, 2022.
  9. Lerche, Carl; Crichton, Alex; Turon, Aaron. "Announcing Tokio 0.1". Retrieved December 11, 2022.
  10. ^ Krill, Paul (2021-01-08). "Tokio Rust runtime reaches 1.0 status". InfoWorld. Retrieved 2021-09-03.
  11. Lerche, Carl. "Announcing Tokio 1.0". Retrieved December 11, 2022.
  12. "Mozilla Awards $365,000 to Open Source Projects as part of MOSS". LWN.net. Retrieved 2021-11-21.
  13. "Welcoming Alice Ryhl as the first paid Tokio contributor". Tokio. Retrieved 2021-11-28.
  14. Allen Wyma (12 November 2021). "Tokio Ecosystem with Alice Ryhl". Rustacean Station (Podcast). Retrieved 2021-11-26.
  15. "Rust Gets Zero-Cost Async/Await Support in Rust 1.39". InfoQ. Retrieved 2021-11-28.
  16. "The Async Ecosystem". Asynchronous Programming in Rust. Retrieved 2021-11-28.
  17. Matsakis, Niko (2019-11-07). "Async-await on stable Rust!". Rust Blog. Retrieved 2021-11-28.
  18. ^ "Hello Tokio". Tokio. Retrieved 2021-11-28.
  19. Rappl Moraza, Florian (2022). Modern Frontend Development with Node.js: A Compendium for Modern JavaScript Web Development Within the Node.js Ecosystem. Birmingham, UK. ISBN 9781804617380.{{cite book}}: CS1 maint: location missing publisher (link)
  20. "I/O". Tokio. Retrieved December 11, 2022.
  21. "Announcing tokio-uring: io-uring support for Tokio". Tokio. Retrieved 2021-11-28.
  22. Sintes, Tony (April 13, 2001). "Four for the ages". InfoWorld. Retrieved January 5, 2023.
  23. Eguia Moraza, Iban (2018). Rust high performance : learn to skyrocket the performance of your Rust applications. Birmingham, UK. ISBN 978-1-78847-823-6. OCLC 1033544275.{{cite book}}: CS1 maint: location missing publisher (link)
  24. Blandy, Jim; Orendoff, Jason; Tindall, Leonara (2019). Programming Rust. Sebastopol. ISBN 9781492052548.{{cite book}}: CS1 maint: location missing publisher (link)

External links

Categories: