Tokio (programvara)

Tokyo
Originalförfattare	Carl Lerche
Initial release	23 december 2020 ; 2 år sedan
Stabil frisättning	1.25.0
Förvar	github .com /tokio-rs /tokio ;
Skrivet i	Rost
Operativ system	macOS , Windows , Linux , WebAssembly
Typ	Asynkron körtid
Licens	MIT-licens
Hemsida	tokio .rs

Tokio är ett mjukvarubibliotek för programmeringsspråket Rust . Den tillhandahåller en körtid och funktioner som möjliggör användning av asynkron I/O , vilket möjliggör samtidighet när det gäller slutförande av uppgift.

Tokio släpptes i augusti 2016 för Rust, ett allmänt programmeringsspråk . Tokio utvecklades av Carl Lerche och började som ett ramverk för nätverksapplikationer och stöder funktioner som socket-lyssning och broadcasting , vilket gör att meddelanden kan överföras mellan datorer.

Historia

Tokio startade i augusti 2016 av Carl Lerche som ett nätverksapplikationsramverk för Rust byggt på terminer , vilket möjliggör nätverksbaserad mellanprogram och en icke-blockerande , eller asynkron, implementering av beredskapsintresse för reaktorn . Tokio inspirerades av Finagle, ett Scala -baserat RPC-system (asynchronous remote procedure call ) utvecklat på Twitter för virtuella Java-maskiner (JVM), som tillåter distribuerade system att kommunicera inom en JVM. Tokio använder den lägre nivån Rust crate mio , som själv använder systemanrop som epoll ( Linux ), kqueue ( FreeBSD ) och input/output completion port (IOCP) API ( Windows ). Namnet "Tokio" kommer från Tokyo och mio. Den preliminära versionen av Tokio släpptes i januari 2017, följt av en fullständig release i december 2020. 2017 fick Tokio ett bidrag från Mozilla Open Source Support Fund. I april 2021 finansierade Tokio sin första betalda bidragsgivare, Alice Ryhl, för hennes arbete både med att utveckla projektet och hjälpa dess användare.

Även om Rust har stödt asynkrona funktioner sedan version 1.39, som släpptes i november 2019, tillhandahåller den inga faciliteter för att exekvera dem, vilket kräver en extern körtid för detta ändamål. Tokio tillhandahåller en körtid som använder en flertrådad schemaläggare för arbetsstöld . Rusts framtid utvärderas lätt , vilket kräver funktioner för att anropa .await innan de utför något arbete. När .await anropas kan Tokios körtid pausa den ursprungliga framtiden tills dess I/O slutförs, och återupptar en annan uppgift som är redo för vidare bearbetning.

Noterbara användare av Tokio inkluderar utvecklingsteamen bakom Discord och AWS Lambda . JavaScript- och TypeScript - runtime Deno använder Tokio under huven, i jämförelse med JavaScript-runtime Node.js , som använder libuv - biblioteket.

Funktioner

Asynkron kod

Tokio tillåter användning av asynkrona funktioner i Rust genom att skapa en asynkron körtid. Detta kan åstadkommas genom #[tokio::main] makrot .

Till exempel:


    
       
       
     
    
 #[tokio::main]  async  fn  main  ()  ->  Resultat  <  ()  >  {  let  url  =  "https://en.wikipedia.org/"  ;  låt  text  =  reqwest  ::  get  (  url  ).  vänta  ?  .  text  ().  vänta  ?  ;  println!  (  "{}"  ,  text  );  Ok  (())  }

I det här exemplet används reqwest -lådan för att begära HyperText Markup Language (HTML) för engelska Wikipedia . För att säkerställa att begäran inte hanteras omedelbart, lindar Tokio funktionsanropet till en asynkron körning, i väntan på att begäran ska slutföras innan den anropar println() .

Tokio innehåller också en version av Rust-standardbiblioteket som är designat för att användas asynkront. Till exempel, tokio::fs::read_to_end() , som läser innehållet i en fil, är den asynkrona versionen av std::fs::read_to_end() . Dessutom stöder Tokio io_uring , ett Linux asynkront I/O syscall-gränssnitt, i en separat låda som heter tokio-uring .

Green-threading vid kompilering

Tokio tillåter vidare användare att skapa uppgifter, som är gröna trådar , med hjälp av en tokio::spawn()- funktion. Gröna trådar körs på användarnivå, vilket ger parallellitet när inbyggda trådar inte alltid är tillgängliga. Tidigare versioner av Rust implementerade grön trådning; denna funktion togs bort i Rust 1.0. Till skillnad från futures behöver uppgifter inte använda .await , eftersom uppgiften kommer att köras automatiskt när en tråd är tillgänglig.

Socket lyssnar

Tokio kan lyssna på ett uttag genom ett icke-blockerande tillvägagångssätt. Speciellt binder TcpListener -strukturen en TCP-socket-lyssnare ( Transmission Control Protocol ) till en adress och exekverar asynkront en funktion.

Broadcasting

Tokio tillhandahåller en sändningskanaltyp , vilket gör att meddelanden kan sändas till flera mottagare. När ett meddelande skickas tas det emot av sådana mottagare. Detta möjliggör kommunikation i realtid och distribuerade system, bland andra applikationer.

externa länkar

Officiell hemsida
Tokio på GitHub
Tokio på crates.io